积土成山，风雨兴焉；积水成渊，蛟龙生焉；积善成德，而神明自得，圣心备焉。故不积跬步，无以至千里，不积小流无以成江海。齐骥一跃，不能十步，驽马十驾，功不在舍。面对悬崖峭壁，一百年也看不出一条裂缝来，但用斧凿，能进一寸进一寸，能进一尺进一尺，不断积累，飞跃必来，突破随之。

题目

给你一个长度为n的序列，你每次可以将一个序列分割成两个连续的的子序列，
分割的代价为原序列的总和。
现在允许你在初始时将序列重新排列一次。
问分割成n个长度为1的序列的最大总代价是多少？

题目链接

在做这道题中，每次我用Arrays.sort();进行排序后，输出的数总全是0。然后不得已用了Collections.sort();进行排序。

本文不讲思路和其他的，也不贴代码了。只讲坑。

总结

首先看问题代码：

import java.io.*;
import java.util.*;

/**
 * @Author DragonOne
 * @Date 2021/9/4 19:40
 */
public class Main {
    public static void main(String[] args) throws Exception {
        Scanner Scin = new Scanner(System.in);
        StreamTokenizer STcin = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        BufferedReader BRcin = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        final int maxn = (int) 20 + 5;

        int n;
        STcin.nextToken();
        n = (int) STcin.nval; //输入n个数
        int[] a = new int[maxn];
        for (int i = 0; i < n; i++) {
            STcin.nextToken();
            a[i]=(int) STcin.nval;
        }
        for (int i=0;i<n;++i) { //区别之处
            System.out.println(a[i]);
        }
        System.out.println("====================================");
        Arrays.sort(a);
        for (int i=0;i<n;++i) { //区别之处
            System.out.println(a[i]);
        }
    }
}

现在输入数据：

5
4 9 8 1 6

输出：

4
9
8
1
6
====================================
0
0
0
0
0

这就是问题所在。排序后的输出结果全是0。刚开始我也很懵，也不知道怎么滴，就试着改了数组的大小，然后就发现了问题所在。

先看一下代码，注意与上面的代码区别开：

import java.io.*;
import java.util.*;

/**
 * @Author DragonOne
 * @Date 2021/9/4 19:40
 */
public class Main {
    public static void main(String[] args) throws Exception {
        Scanner Scin = new Scanner(System.in);
        StreamTokenizer STcin = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        BufferedReader BRcin = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        final int maxn = (int) 20 + 5;

        int n;
        STcin.nextToken();
        n = (int) STcin.nval; //输入n个数
        int[] a = new int[maxn];

        for (int i = 0; i < n; i++) {
            STcin.nextToken();
            a[i]=(int) STcin.nval;
        }
        for (int it : a) { //区别之处
            System.out.println(it);
        }
        System.out.println("====================================");
        Arrays.sort(a);
        for (int it : a) { //区别之处
            System.out.println(it);
        }

    }
}

输入同上，看输出：

4
9
8
1
6
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
====================================
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
1
4
6
8
9

也许应该已经发现了问题所在。那就是默认情况下，Arrays.sort()是给整个数组进行排序，而并不是一部分。你开了多大的数组，它就会排多大范围内的数。这就是为什么排序输出的前n个全是0了，而最终的数全部在后面。所以，以后开数组得讲究一下了，不能再任意开了。(灬ꈍ ꈍ灬)

当然了，还是有解决办法的，那就是用Arrays.sort()的另一种方式，控制排序的范围。

示例：

import java.io.*;
import java.util.*;

/**
 * @Author DragonOne
 * @Date 2021/9/4 19:40
 */
public class Main {
    public static void main(String[] args) throws Exception {
        Scanner Scin = new Scanner(System.in);
        StreamTokenizer STcin = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        BufferedReader BRcin = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

        final int maxn = (int) 20 + 5;

        int n;
        STcin.nextToken();
        n = (int) STcin.nval; //输入n个数
        int[] a = new int[maxn];

        for (int i = 0; i < n; i++) {
            STcin.nextToken();
            a[i]=(int) STcin.nval;
        }
        for (int it : a) {
            System.out.println(it);
        }
        System.out.println("====================================");
//        Arrays.sort(a);
        Arrays.sort(a,0,n); //区别之处【0,n)
        for (int it : a) {
            System.out.println(it);
        }

    }
}

输入输出：

5
4 1 6 2 8
//输出
4
1
6
2
8
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
====================================
1
2
4
6
8
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0

虽然这样还是有0，但是在排序后是可以正常输出前n个数了。就不会像之前一样，排序后的数在后面而不方便操作。