PIPI：1008: 最大连续子序列暴力求解和动态规划求解（Java）

题目描述: 1008: 最大连续子序列

题目描述：给定 K 个整数的序列{ N1, N2, ..., NK } ，其任意连续子序列可表示为{ Ni, Ni+1,...,Nj} ，其中1 <= i<= j <= K。最大连续子序列是所有连续子序列中元素和最大的一个，例如给定序列{ -2, 11, -4, 13, -5, -2 } ，其最大连续子序列为{ 11, -4, 13 } ，最大和为20。编写程序得到其中最大子序列的和并输出该子序列的第一个和最后一个元素的下标。

输入：测试输入包含若干测试用例，每个测试用例占2 行，第 1 行给出正整数 K( <100000) ，第 2 行给出 K 个整数，每个整数的范围-10000至10000 ，中间用空格分隔。

输出：对每个测试用例， 在 1 行里输出最大和、 最大连续子序列的第一个和最后一个元素的下标，中间用空格分隔。 如果最大连续子序列不唯一， 则输出序号 i 和 j 最小的那个（如输入样例的第 2、3组）。若所有 K 个元素都是负数，则定义其最大和为0，输出"0 0 0"

image.png

解题思路：

• 方法1：暴力解题：对于每一个位置 i, 分别计算以 i 为子序列的末尾，前1项，前2项··· 前 i 项的和，其中的最大值即为最大子序列，即为所求
• 方法2：动态规划解题：对于第一个位置，其最大子序列就是本身，后面每一个位置的最大子序列，都是比较前一项的与本位置之和的大小关系，若相加小于本位置的值，则最大子序列从当前位置开始，否则为与前一项之和

实现： 定义每一个位置类，包含大小序列的开始位置，结束位置，以及最大序列和，同时实现 comparable 接口，依次按照 value，开始位置，结束位置 可方便进行排序

static class Node implements Comparable {
        int from;
        int to;
        int value;

        @Override
        public String toString() {
            return "from = " + from + "\t to = " + to + "\t value = " + value;
        }

        // 实现Comparable接口，方便排序，先按 value 排序，若相同，按 from 逆序排序，最后按 to 逆序排序
        @Override
        public int compareTo(Node o) {
            if (this.value != o.value) return  this.value - o.value;
            else if (this.from != o.from) return o.from - this.from;
            else return o.to - this.to;
        }

    }

方法一：暴力解决的代码实现：注意此方法会超出时间限制 **

import java.util.Arrays;
import java.util.Scanner;

public class MaxSubSequence {

    public static void main(String[] args) {
        Scanner inScanner = new Scanner(System.in);
        while (inScanner.hasNext()) {
            int cnt = inScanner.nextInt();
            int[] nums = new int[cnt];
            for (int i = 0; i < cnt; i++) {
                nums[i] = inScanner.nextInt();
            }
            getMaxSubSequence(nums);
        }
    }

    /**
     * 暴力解决：
     *   对于每一个位置 i，分别计算前 1项，2项， 。。。  前 i项之和，找出最大的和，记录是前几项
     *  实现Comparable接口，方便排序，先按 value 排序，若相同，按 from 逆序排序，最后按 to 逆序排序
     * @param nums
     */
    public static void getMaxSubSequence(int[] nums) {
        Node[] nodes = new Node[nums.length];
        Node node;
        for (int i = 0; i < nums.length; i++) { // 计算每一个位置的最大值
            int sum = Integer.MIN_VALUE;
            int j = 0, max_pos = 0;
            for (; j <= i; j++) { // 依次计算 j -> i上每一个位置到 i的最大值
                int temp = 0, k = j;
                for (; k <= i; k++) { // j -> i 的最大值
                    temp += nums[k];
                }
                if (temp > sum) {
                    max_pos = j;
                    sum = temp;
                }
            }
            node = new Node();
            node.from = max_pos;
            node.to = i;
            node.value = sum;
            nodes[i] = node;
        }
        Arrays.sort(nodes);
//        for (Node n :nodes) {
//            System.out.println(n.toString());
//        }
        node = nodes[nodes.length-1];
        if (node.value < 0) System.out.println("0 0 0");  // 若小于0，直接输出 0 0 0
        else System.out.println(node.value + " " + node.from + " " + node.to);
    }

    static class Node implements Comparable {
        int from;
        int to;
        int value;

        @Override
        public String toString() {
            return "from = " + from + "\t to = " + to + "\t value = " + value;
        }

        // 实现Comparable接口，方便排序，先按 value 排序，若相同，按 from 逆序排序，最后按 to 逆序排序
        @Override
        public int compareTo(Node o) {
            if (this.value != o.value) return  this.value - o.value;
            else if (this.from != o.from) return o.from - this.from;
            else return o.to - this.to;
        }

    }

}

方法二：动态规划解题代码实现：

import java.util.Arrays;
import java.util.Scanner;


public class MaxSubSequence {

    public static void main(String[] args) {
        Scanner inScanner = new Scanner(System.in);
        while (inScanner.hasNext()) {
            int cnt = inScanner.nextInt();
            int[] nums = new int[cnt];
            for (int i = 0; i < cnt; i++) {
                nums[i] = inScanner.nextInt();
            }
            getMaxSubSequence2(nums);
        }
    }

    /**
     * 动态规划解决
     * @param nums
     */
    public static void getMaxSubSequence2(int[] nums){
        Node[] nodes = new Node[nums.length]; // 新建记录到i的最大值数组
        // 添加第一个位置
        Node first = new Node();
        first.from = 0;
        first.to = 0;
        first.value = nums[0];
        nodes[0] = first;
        Node last = first; // 上一个最大位置
        Node current; // 当前位置
        for (int i = 1; i < nums.length; i++) { // 从第二个位置开始
            current = new Node();
            if (nums[i] + last.value > nums[i] ){ // 前一个最大序列与当前位置之和大于当前位置，则将当前位置纳入最大子序列计算
                current.from = last.from;
                current.to = i;
                current.value = nums[i] + last.value;
            } else { // 否则从当前位置从新计算
                current.from = i;
                current.to = i;
                current.value = nums[i];
            }
            last = current; // 更新上一个的最大子序列
            nodes[i] = current;
        }
        Arrays.sort(nodes);
//        for (Node n :nodes) {
//            System.out.println(n.toString());
//        }
        Node node = nodes[nodes.length-1];
        if (node.value < 0) System.out.println("0 0 0");
        else System.out.println(node.value + " " + node.from + " " + node.to);
    }

    static class Node implements Comparable {
        int from;
        int to;
        int value;

        @Override
        public String toString() {
            return "from = " + from + "\t to = " + to + "\t value = " + value;
        }

        // 实现Comparable接口，方便排序，先按 value 排序，若相同，按 from 逆序排序，最后按 to 逆序排序
        @Override
        public int compareTo(Node o) {
            if (this.value != o.value) return  this.value - o.value;
            else if (this.from != o.from) return o.from - this.from;
            else return o.to - this.to;
        }

    }

}