Maximum Subsequence Sum（java）

7-1 Maximum Subsequence Sum（25 分）

Given a sequence of K integers { N​1​​, N​2​​, ..., N​K​​ }. A continuous subsequence is defined to be { N​i​​, N​i+1​​, ..., N​j​​ } where 1≤i≤j≤K. The Maximum Subsequence is the continuous subsequence which has the largest sum of its elements. For example, given sequence { -2, 11, -4, 13, -5, -2 }, its maximum subsequence is { 11, -4, 13 } with the largest sum being 20.

Now you are supposed to find the largest sum, together with the first and the last numbers of the maximum subsequence.

Input Specification:
Each input file contains one test case. Each case occupies two lines.The first line contains a positive integer K (≤10000). The second line contains K numbers, separated by a space.

Output Specification:
For each test case, output in one line the largest sum, together with the first and the last numbers of the maximum subsequence. The numbers must be separated by one space, but there must be no extra space at the end of a line. In case that the maximum subsequence is not unique, output the one with the smallest indices i and j (as shown by the sample case). If all the K numbers are negative, then its maximum sum is defined to be 0, and you are supposed to output the first and the last numbers of the whole sequence.

Sample Input:

10
-10 1 2 3 4 -5 -23 3 7 -21

Sample Output:

10 1 4

思路：最大子列和问题，输出和的同时，输出子列的起始项和结尾项。

通过在线处理法可知，获取最大子列和时，当前的arr[i]即为最大子列和的结尾项，那么我们只要记住最大子列的循环次数num（num即为最大子列的个数），

就可以通过数组的特性,即可获取最大子列的起始项 arr[i-num+1]。（最后+1的原因是，num为子列的个数，i-num后，索引在子列起始项的前一项，所以+1后为最大子列起始项位置所在）

代码如下：

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;


public class Main {

    public static void main(String[] args) throws Exception {
        //StreamTokenizer类获取屏幕输入，处理输入比Scanner类效率高
        StreamTokenizer in = new StreamTokenizer(new BufferedReader(
                new InputStreamReader(System.in)));

        in.nextToken();
        int n = (int) in.nval;
        int[] num = new int[n];
        for (int i = 0; i < n; i++) {
            in.nextToken();
            num[i] = (int) in.nval;
        }

        //解决全是负数的情况
        int count = 0;
        for (int i = 0; i < n; i++) {
            if (num[i] < 0) {
                count++;
            }
        }
        if (count == n) {
            System.out.println(0 + " " + num[0] + " " + num[n - 1]);
        } else {

            int[] b = maxSubseqSum(num);
            System.out.print(b[0] + " " + b[1] + " " + b[2]);
        }
    }

    public static int[] maxSubseqSum(int[] arr) {
        int thisSum = 0, maxSum = 0;
        int start = 0, end = 0;
        //记录循环次数，这样可以通过子列结尾值获取子列开头的值
        int num = 0;
        for (int i = 0; i < arr.length; i++) {
            num++;
            thisSum += arr[i];
            if (thisSum > maxSum) {
                maxSum = thisSum;
                //当前和为最大值时，此时arr[i]为子列结尾值
                end = arr[i];
                //+1的原因：num为子列的个数，i-num后索引所在位置为子列起始位置的前一项。
                start = arr[i - num + 1];
            } else if (thisSum < 0) {
                thisSum = 0;
                num = 0;
            }
        }
        return new int[]{maxSum, start, end};
    }
}