双向排序 (蓝桥杯) 暴力破解 JAVA

题目描述：

给定序列(a[1], a[2], … , a[n]) = (1, 2, … , n)，即a[i] = i。
小蓝将对这个序列进行m次操作，每次可能是将a[1], a[2], … a[qi] 降序排列，或者将a[qi], a[qi+1], …a[n] 升序排列。 请求出操作完成后的序列。

输入格式：

输入的第一行包含两个整数n, m，分别表示序列的长度和操作次数。 接下来m行描述对序列的操作，其中第i行包含两个整数pi, qi
表示操作类型和参数。
当pi = 0 时，表示将a[1], a[2], … a[qi] 降序排列；
当pi = 1
时，表示将a[qi], a[qi+1], … , a[n] 升序排列。

对于30%的评测用例，n,m ≤ 1000；
对于60% 的评测用例，n,m ≤ 5000；
对于所有评测用例，1 ≤ n,m ≤ 100000,

输入格式：

输出一行，包含n个整数，相邻的整数之间使用一个空格分隔，表示操作完成后的序列。

输入样例：

3 3
0 3
1 2
0 2

输出样例：

3 1 2

---

代码：
本代码不是正解，只是用来混分的。
思路就是利用sort 函数，和sort函数的重构，按照输入对，数组进行变化。
注意：重构sort数组的排序规则，得用Integer定义数组
sort(a, 1, n)就是对a数组进行排序，排序的范围是下标[1, n)，左闭右开

重构sort函数的方法，有两种。

方法一：

import java.util.*;
public class Main {
	 
	public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        Integer a[] = new Integer[m + 1];
        for(int i = 1; i <= m; i ++) a[i] = i;
       // for(int i = 1; i <= m; i ++) System.out.print(a[i] + " ");
        for(int i = 0; i < n; i ++) {
        	int pi = sc.nextInt();
        	int qi = sc.nextInt();
        	if(pi == 0) {
        		Arrays.sort(a, 1, qi + 1, new Comparator<Integer>() {
        		public int compare(Integer a, Integer b) {
        			return b - a;
        		}
        		});
        	}
        	else if(pi == 1) {
        		Arrays.sort(a, qi, m + 1);
        	}
        }
        for(int i = 1; i <= m; i ++)
        	System.out.print(a[i] + " ");
	} 
}

方法二：

import java.util.*;
public class Main {
	 
	public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        Integer a[] = new Integer[m + 1];
        for(int i = 1; i <= m; i ++) a[i] = i;
       // for(int i = 1; i <= m; i ++) System.out.print(a[i] + " ");
        for(int i = 0; i < n; i ++) {
        	int pi = sc.nextInt();
        	int qi = sc.nextInt();
        	if(pi == 0) {
        		Arrays.sort(a, 1, qi + 1 ,(b, c)->Integer.compare(c , b));
        	}
        	else if(pi == 1) {
        		Arrays.sort(a, qi, m + 1);
        	}
        }
        for(int i = 1; i <= m; i ++)
        	System.out.print(a[i] + " ");
	} 
}

官方平台提交能得到 5 ~ 6 成分数。

---

其中重构sort方法的排序方式：

Arrays.sort(a, 1, qi + 1, new Comparator<Integer>() {
        		public int compare(Integer a, Integer b) {
        			return b - a;
        		}
        		});

由于sort函数是以快速排序为底层逻辑。
可以这样理解 return b - a 这一部分：
原来顺序是a, b
b - a > 0 则 b 和 a 交换位置，所以最后会构成降序。
反之return a - b，即 a - b > 0 则a，b交换位置，最后会形成升序。
方法二，是简化版，理解起来也一样。