最大子序列和问题的求解

最大子序列和问题

$给定（可能有负的）整数A_1,A_2,...,A_N求\sum_{k=j}^jA_k的最大值。（为方便起见，如果所有整数均为负数，则最大子序列和为0）$

算法1

public static int maxSubSum1(int[] a) {
    int maxSum = 0;

    for (int i = 0; i < a.length; i++) {
        for (int j = 0; j < a.length; j++) {
            int thisSum = 0;
            for (int k = i; k <= j; k++) {
                thisSum += a[k];
            }
            if (thisSum > maxSum) {
                maxSum = thisSum;
            }
        }
    }

    return maxSum;
}

$效率：O(N^3)$

算法2

public static int maxSubSum2(int[] a) {
    int maxSum = 0;

    for (int i = 0; i < a.length; i++) {
        int thisSum = 0;
        for (int j = i; j < a.length; j++) {
            thisSum += a[j];
            if (thisSum > maxSum) {
                maxSum = thisSum;
            }
        }
    }

    return maxSum;
}

$效率：O(N^2)$

算法3

private static int maxSumRec(int[] a, int left, int right) {
    if (left == right)
        if (a[left] > 0)
            return a[left];
        else
            return 0;

    int center = (left + right) / 2;
    int maxLeftSum = maxSumRec(a, left, center);
    int maxRightSum = maxSumRec(a, center + 1, right);

    int maxLeftBorderSum = 0, leftBorderSum = 0;
    for (int i = center; i >= left; i--) {
        leftBorderSum += a[i];
        if (leftBorderSum > maxLeftBorderSum) {
            maxLeftBorderSum = leftBorderSum;
        }
    }

    int maxRightBorderSum = 0, rightBorderSum = 0;
    for (int i = center + 1; i <= right; i++) {
        rightBorderSum += a[i];
        if (rightBorderSum > maxRightBorderSum) {
            maxRightBorderSum = rightBorderSum;
        }
    }

    return max(maxLeftSum, maxRightSum, maxLeftBorderSum + maxRightBorderSum);
}

private static int max(int... nums) {
    int max = nums[0];
    for (int i : nums) {
        if (i > max)
            max = i;
    }
    return max;
}

public static int maxSubSum3(int[] a) {
    return maxSumRec(a, 0, a.length-1);
}

$效率：O(NlogN)$

算法4

public static int maxSubSum4(int... a) {
    int maxSum = 0, thisSum = 0;
    List<Integer> list = new ArrayList<Integer>();
    for (int i = 0; i < a.length; i++) {
        thisSum += a[i];
        if (thisSum > maxSum) {
            list.add(i);
            maxSum = thisSum;
        } else if (thisSum < 0) {
            thisSum = 0;
            list.clear();
        }
    }
    System.out.println("index:"+list.get(0)+"-->"+list.get(list.size()-1));
    return maxSum;
}

$效率：O(N)$

算法4一个附带的优点是，它只对数据进行一次扫描，一旦$a[i]$被读入并被处理，它就不再需要被记忆。因此，如果数组在磁盘上或通过互联网传送，那么它就可以被按顺序读入，在主存中不必存储数组的任何部分。不仅如此，在任意时刻，算法都能对它已经读入的数据给出子序列问题的正确答案（其他算法不具有这个特性）。具有这种特性的算法叫做联机算法