蓝桥杯 2018-6 递增三元组

题目描述
给定三个整数数组
A = [A1, A2, … AN],
B = [B1, B2, … BN],
C = [C1, C2, … CN]，
请你统计有多少个三元组(i, j, k) 满足：

1 <= i, j, k <= N
Ai < Bj < Ck
【输入格式】
第一行包含一个整数N。
第二行包含N个整数A1, A2, … AN。
第三行包含N个整数B1, B2, … BN。
第四行包含N个整数C1, C2, … CN。

对于30%的数据，1 <= N <= 100
对于60%的数据，1 <= N <= 1000
对于100%的数据，1 <= N <= 100000 0 <= Ai, Bi, Ci <= 100000
【输出格式】
一个整数表示答案
【输入样例】
3
1 1 1
2 2 2
3 3 3
【输出样例】
27

悄悄说一句，这道题不难，很简单，别想复杂了，不然容易出错。
简单做法：
别想太多，就是先遍历B元组，然后分别遍历A、C元组，找A中比当前B[i]小的数的个数，找C中比当前B[i]大的数的个数，然后相乘，再与总计数相加，然后又进入for循环。
深一点的做法：
我看到这个题的第一眼，就想到了这个方法，无奈无奈，老是调不出来，唉。
先对三个元组进行排序。
对A降序，对B、C升序，排序。为什么这样排？
因为我从0开始遍历A，遍历到第一个小于B的，那么后面的必然都小于B（降序排序，后面的都小），所以小于B的个数等于n-i+1，同理对于C，遍历到第一个大于B的，那么后面的必然都大于B（升序排序，后面的都大），所以大于B的个数等于n-i+1。同时，下一个B元素必然比当前这个大，那么A，想到这里A，需要改一改，我们从A的最后一个遍历A，这样，下一个循环，A只需要从上次遍历到的地方开始就行，因为小于上一个B的A，必然也小于这一个。同理对于C，对于C就没有这个规律了，乖乖从头开始遍历吧，我把上面那样考虑化了删除线，因为虽然思路对，确实有点麻烦，易出错，对于A，我们依然可以从0开始遍历，每次重新遍历即可。

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

public class okt6递增三元组 {
	public static void main(String[] args) {
		// f();
		// f1();
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		Integer[] a = new Integer[n];
		Integer[] b = new Integer[n];
		Integer[] c = new Integer[n];
		for (int i = 0; i < c.length; i++) {
			a[i] = scanner.nextInt();
		}
		for (int i = 0; i < c.length; i++) {
			b[i] = scanner.nextInt();
		}
		for (int i = 0; i < c.length; i++) {
			c[i] = scanner.nextInt();
		}
		long ans = 0;
		Comparator cmp = new CMP();
		Arrays.sort(a, cmp);
		Arrays.sort(b);
		Arrays.sort(c);
		for (int i = 0; i < b.length; i++) {
			int j = 0;
			while (j < b.length && a[j] >= b[i])
				j++;
			int k = 0;
			while (k < b.length && c[k] <= b[i])
				k++;
			// System.out.println(j + " " + k);
			if (j < b.length && k < b.length)
				ans += (b.length - j) * (b.length - k);
			// System.out.println((b.length - j) * (b.length - i));
		}
		System.out.println(ans);
		// f2();
	}

	private static void f2() {
		// TODO Auto-generated method stub
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		Integer[] a = new Integer[n];
		Integer[] b = new Integer[n];
		Integer[] c = new Integer[n];
		for (int i = 0; i < c.length; i++) {
			a[i] = scanner.nextInt();
		}
		for (int i = 0; i < c.length; i++) {
			b[i] = scanner.nextInt();
		}
		for (int i = 0; i < c.length; i++) {
			c[i] = scanner.nextInt();
		}
		long ans = 0;
		Comparator cmp = new CMP();
		Arrays.sort(a, cmp);
		Arrays.sort(b);
		Arrays.sort(c);
		int j = b.length - 1;
		
		for (int i = 0; i < b.length; i++) {
           int k = 0;
			while (j >= 0 && a[j] < b[i])
				j--;
			j++;
			while (k < b.length && c[k] <= b[i])
				k++;
			// System.out.println(j + " " + k);
			if (j >= 0 && k < b.length)
				ans += (b.length - j) * (b.length - k);
			// System.out.println((b.length - j) * (b.length - i));
		}
		System.out.println(ans);
	}

	private static void f1() {
		// TODO Auto-generated method stub
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		Integer[] a = new Integer[n];
		Integer[] b = new Integer[n];
		Integer[] c = new Integer[n];
		for (int i = 0; i < c.length; i++) {
			a[i] = scanner.nextInt();
		}
		for (int i = 0; i < c.length; i++) {
			b[i] = scanner.nextInt();
		}
		for (int i = 0; i < c.length; i++) {
			c[i] = scanner.nextInt();
		}
		long ans = 0;
		for (int i = 0; i < b.length; i++) {
			int min = 0;
			int max = 0;
			for (int j = 0; j < a.length; j++) {
				if (a[j] < b[i]) {
					min++;
				}
			}
			for (int j = 0; j < c.length; j++) {
				if (c[j] > b[i]) {
					max++;
				}
			}
			ans += min * max;
		}
		System.out.println(ans);
	}

class CMP implements Comparator<Integer> {
	@Override // 可以去掉。作用是检查下面的方法名是不是父类中所有的
	public int compare(Integer a, Integer b) {
//        两种都可以，升序排序的话反过来就行
//        return a-b<0?1:-1;
		return b - a;
	}
}

这里还有一个小难点，因为要降序，需要自己写降序比较器，我老是忘记怎么写。！！！！！！！！！