Added MaxSubseqDiffNoOverlap

Author: FreeTymeKiyan

MaxSubseqDifference.java renamed to Other/MaxSubseqDifference.java

@@ -0,0 +1,106 @@
+/**
+ * Find two disjoint (non-overlapping) subsequences in an array with maximum 
+ * difference.
+ * 
+ * Tags: Array
+ */
+class MaxSubseqDifferenceNoOverlap {
+    public static void main(String[] args) {
+        
+    }
+    
+    /**
+     * 
+     */
+    public int MaxSubseqDifferenceNoOverlap(int[] A) {
+        int[] finalMax = null;
+        int[] finalMin = null;
+        Integer maxDiff = null; // use Integer to determine whether it's set
+        for (int i = 0; i < A.length; i++) {
+            int[] preMax = maxKadane(A, 0, i); // left max
+            int[] postMin = minKadane(A, i, A.length); // right min
+            int[] preMin = minKadane(A, 0 ,i); // left min
+            int[] postMax = maxKadane(A, i, A.length); // right max
+            
+            int diff1 = sum(A, preMax) - sum(A, postMin);
+            int diff2 = sum(A, postMax) - sum(A, preMin);
+            if (diff1 > diff2) {
+                // if maxDiff not set or diff1 is bigger
+                if (maxDiff == null || diff1 > maxDiff) { // update maxDiff
+                    maxDiff = diff1;
+                    finalMax = preMax;
+                    finalMin = postMin;
+                }
+            } else {
+                if (maxDiff == null || diff2 > maxDiff) {
+                    maxDiff = diff2;
+                    finalMax = postMax;
+                    finalMin = preMin;
+                }
+            }
+        }
+        return maxDiff;
+    }
+    
+    /**
+     * 
+     */
+    private int[] maxKadane(int[] A, int s, int e) {
+        int beginTemp = s;
+        int begin = s;
+        int end = s;
+        int maxSoFar = A[s];
+        int maxEndingHere = A[s];
+        
+        for (int i = 1; i < e; i++) {
+            if (maxEndingHere < 0) {
+                maxEndingHere = A[i];
+                beginTemp = i;
+            } 
+            else maxEndingHere += A[i];
+
+            if (maxEndingHere >= maxSoFar) {
+                maxSoFar = maxEndingHere;
+                begin = beginTemp;
+                end = i;
+            }
+        }
+        
+        return new int[]{begin, end};
+    }
+    
+    /**
+     * Modification of 
+     */
+    private int[] minKadane(int[] A, int s, int e) {
+        int beginTemp = s;
+        int begin = s;
+        int end = s;
+        int minSoFar = A[s];
+        int minEndingHere = A[s];
+        
+        for (int i = 1; i < e; i++) {
+            if (minEndingHere > 0) {
+                minEndingHere = A[i];
+                beginTemp = i;
+            }
+            else minEndingHere += A[i];
+            
+            if (minEndingHere <= minSoFar) {
+                minSoFar = minEndingHere;
+                begin = beginTemp;
+                end = i;
+            }
+        }
+        
+        return new int[]{begin, end};
+    }
+    
+    private int sum(int[] A, int[] range) {
+        int sum = 0;
+        for (int i = range[0]; i <= range[1]; i++) {
+            sum += A[i];
+        }
+        return sum;
+    }
+}