TZOJ 3927 Circular Sequence(环形最大子段和)

描述

Given a sequence with n elements, if the last element is also adjacent to the first element of the sequence, the sequence is called “circular sequence”.
Now, here comes a simple problem: given a circular sequence, you should find a segment of the sequence, such that it contains at least one element, and the sum of the elements is as large as possible. 

输入

Input may contain several test cases. The first line is a single integer t, the number of test cases below. Each test case is composed of two lines. The first line of each test case is a positive integer n (1<=n<=100000), denoting the number of elements in the circular sequence, and the second line has n integers; the absolute value of each integer is no more than 100000. 

输出

For each test case, output the maximum segment sum in a single line. 

样例输入

2
2
-1 -2
3
1 -2 3

样例输出

-1
4

题意

n个数，求环形最大字段和。

题解

答案分两种情况：

1.答案不穿越两端，相当于是普通的最大子段和，直接写【ans1】。

2.答案穿越两端，相当于是前一段+后一段，那么相当于总和-普通的最小子段和【ans2】。

代码

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

public class Main {

    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskA solver = new TaskA();
        int T = in.nextInt();
        for (int i = 1; i <= T; i++)
            solver.solve(i, in, out);
        out.close();
    }

    static class TaskA {
        private long[] a;
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            a = new long[n + 5];
            long AC = 0, min = 0, max = 0, p = (long)-1e9;
            boolean positive = true;
            for (int i = 1; i <= n; i++) {
                int x = in.nextInt();
                p = Math.max(p, x);
                a[i] = a[i-1] + x;
                if (x >= 0)
                    positive = false;
            }
            // 全是负数
            if (positive) {
                System.out.println(p);
                return;
            }
            for (int i = 1; i <= n; i++) {
                // 不跨越，普通最大子段和
                long ans1 = a[i] - min;
                // 跨越，总和-普通最小子段和
                long ans2 = a[n] - (a[i] - max);
                min = Math.min(min, a[i]);
                max = Math.max(max, a[i]);
                AC = Math.max(AC, Math.max(ans1, ans2));
            }
            System.out.println(AC);
        }
    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
    }
}