package class40;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.TreeSet;

// 来自去哪儿网
// 给定一个arr，里面的数字都是0~9
// 你可以随意使用arr中的数字，哪怕打乱顺序也行
// 请拼出一个能被3整除的，最大的数字，用str形式返回
public class Code02_Mod3Max {

	public static String max1(int[] arr) {
		Arrays.sort(arr);
		for (int l = 0, r = arr.length - 1; l < r; l++, r--) {
			int tmp = arr[l];
			arr[l] = arr[r];
			arr[r] = tmp;
		}
		StringBuilder builder = new StringBuilder();
		TreeSet<String> set = new TreeSet<>((a, b) -> Integer.valueOf(b).compareTo(Integer.valueOf(a)));
		process1(arr, 0, builder, set);
		return set.isEmpty() ? "" : set.first();
	}

	public static void process1(int[] arr, int index, StringBuilder builder, TreeSet<String> set) {
		if (index == arr.length) {
			if (builder.length() != 0 && Integer.valueOf(builder.toString()) % 3 == 0) {
				set.add(builder.toString());
			}
		} else {
			process1(arr, index + 1, builder, set);
			builder.append(arr[index]);
			process1(arr, index + 1, builder, set);
			builder.deleteCharAt(builder.length() - 1);
		}
	}

	public static String max2(int[] arr) {
		if (arr == null || arr.length == 0) {
			return "";
		}
		Arrays.sort(arr);
		for (int l = 0, r = arr.length - 1; l < r; l++, r--) {
			int tmp = arr[l];
			arr[l] = arr[r];
			arr[r] = tmp;
		}
		if (arr[0] == 0) {
			return "0";
		}
		String ans = process2(arr, 0, 0);
		String res = ans.replaceAll("^(0+)", "");
		if (!res.equals("")) {
			return res;
		}
		return ans.equals("") ? ans : "0";
	}

	// arr中的数字一定是0~9
	// arr是经过排序的，并且是从大到小排序，比如[9,8,7,7,7,3,1]等
	// 这个递归函数的含义 :
	// 在arr[index...一直到最后]上做选择，arr[0...index-1]就当不存在
	// 每个位置的字符可以要、也可以不要，但是！选出来的数字拼完之后的结果，在%3之后，余数一定要是mod！
	// 返回在上面设定的情况下，最大的数是多少？
	// 如果存在这样的数，返回字符串的形式
	// 如果不存在这样的数，返回特殊字符串，比如"$"，代表不可能
	// 这个递归函数可以很轻易的改出动态规划
	public static String process2(int[] arr, int index, int mod) {
		if (index == arr.length) {
			return mod == 0 ? "" : "$";
		}
		String p1 = "$";
		int nextMod = nextMod(mod, arr[index] % 3);
		String next = process2(arr, index + 1, nextMod);
		if (!next.equals("$")) {
			p1 = String.valueOf(arr[index]) + next;
		}
		String p2 = process2(arr, index + 1, mod);
		if (p1.equals("$") && p2.equals("$")) {
			return "$";
		}
		if (!p1.equals("$") && !p2.equals("$")) {
			return smaller(p1, p2) ? p2 : p1;
		}
		return p1.equals("$") ? p2 : p1;
	}

	public static int nextMod(int require, int current) {
		if (require == 0) {
			if (current == 0) {
				return 0;
			} else if (current == 1) {
				return 2;
			} else {
				return 1;
			}
		} else if (require == 1) {
			if (current == 0) {
				return 1;
			} else if (current == 1) {
				return 0;
			} else {
				return 2;
			}
		} else { // require == 2
			if (current == 0) {
				return 2;
			} else if (current == 1) {
				return 1;
			} else {
				return 0;
			}
		}
	}

	public static boolean smaller(String p1, String p2) {
		if (p1.length() != p2.length()) {
			return p1.length() < p2.length();
		}
		return p1.compareTo(p2) < 0;
	}

	// 贪心的思路解法 :
	// 先得到数组的累加和，记为sum
	// 1) 如果sum%3==0，说明所有数从大到小拼起来就可以了
	// 2) 如果sum%3==1，说明多了一个余数1，
	// 只需要删掉一个最小的数(该数是%3==1的数);
	// 如果没有，只需要删掉两个最小的数(这两个数都是%3==2的数);
	// 3) 如果sum%3==2，说明多了一个余数2，
	// 只需要删掉一个最小的数(该数是%3==2的数);
	// 如果没有，只需要删掉两个最小的数(这两个数都是%3==1的数);
	// 如果上面都做不到，说明拼不成
	public static String max3(int[] A) {
		if (A == null || A.length == 0) {
			return "";
		}
		int mod = 0;
		ArrayList<Integer> arr = new ArrayList<>();
		for (int num : A) {
			arr.add(num);
			mod += num;
			mod %= 3;
		}
		if ((mod == 1 || mod == 2) && !remove(arr, mod, 3 - mod)) {
			return "";
		}
		if (arr.isEmpty()) {
			return "";
		}
		arr.sort((a, b) -> b - a);
		if (arr.get(0) == 0) {
			return "0";
		}
		StringBuilder builder = new StringBuilder();
		for (int num : arr) {
			builder.append(num);
		}
		return builder.toString();
	}

	// 在arr中，要么删掉最小的一个、且%3之后余数是first的数
	// 如果做不到，删掉最小的两个、且%3之后余数是second的数
	// 如果能做到返回true，不能做到返回false
	public static boolean remove(ArrayList<Integer> arr, int first, int second) {
		if (arr.size() == 0) {
			return false;
		}
		arr.sort((a, b) -> compare(a, b, first, second));
		int size = arr.size();
		if (arr.get(size - 1) % 3 == first) {
			arr.remove(size - 1);
			return true;
		} else if (size > 1 && arr.get(size - 1) % 3 == second && arr.get(size - 2) % 3 == second) {
			arr.remove(size - 1);
			arr.remove(size - 2);
			return true;
		} else {
			return false;
		}
	}

	// a和b比较:
	// 如果余数一样，谁大谁放前面
	// 如果余数不一样，余数是0的放最前面、余数是s的放中间、余数是f的放最后
	public static int compare(int a, int b, int f, int s) {
		int ma = a % 3;
		int mb = b % 3;
		if (ma == mb) {
			return b - a;
		} else {
			if (ma == 0 || mb == 0) {
				return ma == 0 ? -1 : 1;
			} else {
				return ma == s ? -1 : 1;
			}
		}
	}

	// 为了测试
	public static int[] randomArray(int len) {
		int[] arr = new int[len];
		for (int i = 0; i < len; i++) {
			arr[i] = (int) (Math.random() * 10);
		}
		return arr;
	}

	// 为了测试
	public static int[] copyArray(int[] arr) {
		int[] ans = new int[arr.length];
		for (int i = 0; i < arr.length; i++) {
			ans[i] = arr[i];
		}
		return ans;
	}

	// 为了测试
	public static void main(String[] args) {
		int N = 10;
		int testTimes = 10000;
		System.out.println("测试开始");
		for (int i = 0; i < testTimes; i++) {
			int len = (int) (Math.random() * N);
			int[] arr1 = randomArray(len);
			int[] arr2 = copyArray(arr1);
			int[] arr3 = copyArray(arr1);
			String ans1 = max1(arr1);
			String ans2 = max2(arr2);
			String ans3 = max3(arr3);
			if (!ans1.equals(ans2) || !ans1.equals(ans3)) {
				System.out.println("出错了！");
				for (int num : arr3) {
					System.out.print(num + " ");
				}
				System.out.println();
				System.out.println(ans1);
				System.out.println(ans2);
				System.out.println(ans3);
				break;
			}
		}
		System.out.println("测试结束");

	}

}