Algorithm about SubArrays & SubStrings

No.1 Maximum Subarray

Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

e.g. [−2,1,−3,4,−1,2,1,−5,4] -> [4,−1,2,1] = 6.

public void maxSubSimple(int[] array) {
    if (array == null || array.length == 0) {
        System.out.println("empty array");
    }
    int max = array[0], cursum = array[0];
    for (int i = 1; i < array.length; i++) {
        cursum = cursum > 0 ? cursum + array[i] : array[i];
        max = max > cursum ? max : cursum;
    }
    System.out.println("max sub-array sum is: " + max);
}
public void maxSubFull(int[] array) {
    if (array == null || array.length == 0) {
        System.out.println("empty array");
    }
    int max = array[0], cursum = array[0];
    int start = 0, end = 0;
    int final_s = 0, final_t = 0;
    for (int i = 1; i < array.length; i++) {
        if (cursum < 0) {
            cursum = array[i];
            start = i;
            end = i;
        } else {
            cursum = cursum + array[i];
            end = i;
        }
        if (max < cursum) {
            max = cursum;
            final_s = start;
            final_t = end;
        }
    }
    System.out.println("sub Array: ("+final_s+", "+final_t+")");
    System.out.println("max sub-array sum is: " + max);
}

No.2 Maximum Product Subarray

Find the contiguous subarray within an array (containing at least one number) which has the largest product.

e.g. [2,3,-2,4] -> [2,3] = 6.

public int maxProduct(int[] A) {
        int premin = A[0], premax = A[0], max = A[0];
        for (int i = 1; i < A.length; i++) {
            int tmp1 = premin * A[i];
            int tmp2 = premax * A[i];
            premin = Math.min(A[i], Math.min(tmp1, tmp2));
            premax = Math.max(A[i], Math.max(tmp1, tmp2));
            max = Math.max(premax, max);
        }
        return max;
}

No.3 LIS (Longest Increasing Subarray) 

The increasing subarray does't has to be contiuous nor same diff

e.g. [1, 6, 8, 3, 7, 9] -> [1, 3, 7, 9] = 4

DP, O(n^2)

public void findLIS(int[] array) {
    if (array == null || array.length == 0) {
        System.out.println("Empty array");
        return;
    }
    int len = array.length;
    int[] dp = new int[len];
    int lis = 1;
    for (int i = 0; i < len; i++) {
        dp[i] = 1;
        for (int j = 0; j < i; j++) {
            if (array[j] < array[i] & dp[j] + 1 > dp[i]) {
                dp[i] = dp[j] + 1;
            }
        }
        if (dp[i] > lis) {
            lis = dp[i];
        }
    }
    System.out.println("length of Longest Increasing Subarray: "+lis);
}

DP + Binary Search, O(nlogn)

维护一个数组 maxval[i]，记录长度为 i+1 的递增子序列中最大元素的最小值，并对于数组中的每个元素考察其是哪个子序列的最大元素，二分更新maxval数组——《编程之美》

public void BinSearch(int[] maxval, int maxlen, int x) {
    int left = 0, right = maxlen-1;
    while (left <= right) {
        int mid = left + (right - left) / 2;
        if (maxval[mid] <= x) {
            left++;
        } else {
            right--;
        }
    }
    maxval[left] = x;
}
public void LIS(int[] array) {
    if (array == null || array.length == 0) {
        System.out.println("Empty array");
        return;
    }
    int len = array.length;
    int[] maxval = new int[len];
    maxval[0] = array[0];
    int maxlen = 1;
    for (int i = 0; i < len; i++) {
        if (array[i] > maxval[maxlen-1]) {
            maxval[maxlen++] = array[i];
        } else {
            BinSearch(maxval, maxlen, array[i]);
        }
    }
    System.out.println("length of Longest Increasing Subarray: "+maxlen);
}

No.4 LCS (Longest Common Substring)

p.s. 最长公共子串: 在原字符串中是连续

　　最长公共子序列: 并不要求在原字符串中连续

e.g. [b, a, b], [c, a, b, a] -> [a, b] or [b, a]

public void LCS(String str1, String str2) {
    if (str1 == null || str2 == null || str1.length() == 0 || str2.length() == 0) {
        System.out.println("The LCS is empty string");
        return;
    }
    int m = str1.length(), n = str2.length();
    int[] pre = new int[n];
    int[] cur = new int[n];
    int max = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            if (str1.charAt(i) == str2.charAt(j)) {
                if (i == 0 || j == 0) {
                    cur[j] = 1;
                } else {
                    cur[j] = pre[j-1] + 1;
                }
                max = max > cur[j] ? max : cur[j];
            }
        }
        pre = cur;
        cur = new int[n];
    }
    System.out.println(max);
}

No.5 LCS (Longest Common Subsequence)

e.g. [g c c c t a g c g], [g c g c a a t g] -> []

public void LCS(String str1, String str2) {
    if (str1 == null || str2 == null || str1.length() == 0 || str2.length() == 0) {
        System.out.println("The LCS is empty string");
        return;
    }
    int m = str1.length(), n = str2.length();
    int[] cur = new int[n];
    int upleft = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            int tmp = cur[j];
            if (j == 0) {
                cur[j] = str1.charAt(i) == str2.charAt(j) ? 1 : cur[j];
            } else if (i == 0) {
                cur[j] = str1.charAt(i) == str2.charAt(j) ? 1 : cur[j-1];
            } else {
                if (str1.charAt(i) == str2.charAt(j)) {
                    cur[j] = Math.max(upleft+1, Math.max(cur[j-1], cur[j]));
                } else {
                    cur[j] = Math.max(upleft, Math.max(cur[j-1], cur[j]));
                }
            }
            upleft = tmp;
        }
    }
    System.out.println(cur[n-1]);
}