modify code

Author: algorithmzuo

src/class089/Code01_LargestNumber.java

@@ -0,0 +1,28 @@
+package class089;
+
+import java.util.Arrays;
+
+// 最大数
+// 给定一组非负整数nums
+// 重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数
+// 测试链接 : https://leetcode.cn/problems/largest-number/
+public class Code01_LargestNumber {
+
+	public static String largestNumber(int[] nums) {
+		int n = nums.length;
+		String[] arr = new String[n];
+		for (int i = 0; i < n; i++) {
+			arr[i] = String.valueOf(nums[i]);
+		}
+		Arrays.sort(arr, (a, b) -> (b + a).compareTo(a + b));
+		if (arr[0].equals("0")) {
+			return "0";
+		}
+		StringBuilder path = new StringBuilder();
+		for (String s : arr) {
+			path.append(s);
+		}
+		return path.toString();
+	}
+
+}

src/class089/Code02_TwoCityScheduling.java

@@ -0,0 +1,30 @@
+package class089;
+
+import java.util.Arrays;
+
+// 两地调度
+// 公司计划面试2n个人，给定一个数组 costs
+// 其中costs[i]=[aCosti, bCosti]
+// 表示第i人飞往a市的费用为aCosti，飞往b市的费用为bCosti
+// 返回将每个人都飞到a、b中某座城市的最低费用
+// 要求每个城市都有n人抵达
+// 测试链接 : https://leetcode.cn/problems/two-city-scheduling/
+public class Code02_TwoCityScheduling {
+
+	public static int twoCitySchedCost(int[][] costs) {
+		int n = costs.length;
+		int[] arr = new int[n];
+		int sum = 0;
+		for (int i = 0; i < n; i++) {
+			arr[i] = costs[i][1] - costs[i][0];
+			sum += costs[i][0];
+		}
+		Arrays.sort(arr);
+		int m = n / 2;
+		for (int i = 0; i < m; i++) {
+			sum += arr[i];
+		}
+		return sum;
+	}
+
+}

src/class089/Code03_MinimumNumberEatOranges.java

@@ -0,0 +1,41 @@
+package class089;
+
+import java.util.HashMap;
+
+// 吃掉N个橘子的最少天数
+// 厨房里总共有 n 个橘子，你决定每一天选择如下方式之一吃这些橘子
+// 1）吃掉一个橘子
+// 2) 如果剩余橘子数 n 能被 2 整除，那么你可以吃掉 n/2 个橘子
+// 3) 如果剩余橘子数 n 能被 3 整除，那么你可以吃掉 2*(n/3) 个橘子
+// 每天你只能从以上 3 种方案中选择一种方案
+// 请你返回吃掉所有 n 个橘子的最少天数
+// 测试链接 : https://leetcode.cn/problems/minimum-number-of-days-to-eat-n-oranges/
+public class Code03_MinimumNumberEatOranges {
+
+	// 所有的答案都填在这个表里
+	// 这个表对所有的过程共用
+	public static HashMap<Integer, Integer> dp = new HashMap<>();
+
+	public static int minDays(int n) {
+		if (n <= 1) {
+			return n;
+		}
+		if (dp.containsKey(n)) {
+			return dp.get(n);
+		}
+		// 1) 吃掉一个橘子
+		// 2) 如果n能被2整除，吃掉一半的橘子，剩下一半
+		// 3) 如果n能被3正数，吃掉三分之二的橘子，剩下三分之一
+		// 因为方法2）和3），是按比例吃橘子，所以必然会非常快
+		// 所以，决策如下：
+		// 可能性1：为了使用2）方法，先把橘子吃成2的整数倍，然后直接干掉一半，剩下的n/2调用递归
+		// 即，n % 2 + 1 + minDays(n/2)
+		// 可能性2：为了使用3）方法，先把橘子吃成3的整数倍，然后直接干掉三分之二，剩下的n/3调用递归
+		// 即，n % 3 + 1 + minDays(n/3)
+		// 至于方法1)，完全是为了这两种可能性服务的，因为能按比例吃，肯定比一个一个吃快(显而易见的贪心)
+		int ans = Math.min(n % 2 + 1 + minDays(n / 2), n % 3 + 1 + minDays(n / 3));
+		dp.put(n, ans);
+		return ans;
+	}
+
+}

src/class089/Code04_MinimumCostToConnectSticks.java

@@ -0,0 +1,30 @@
+package class089;
+
+import java.util.PriorityQueue;
+
+// 连接棒材的最低费用
+// 你有一些长度为正整数的棍子
+// 这些长度以数组sticks的形式给出
+// sticks[i]是第i个木棍的长度
+// 你可以通过支付x+y的成本将任意两个长度为x和y的棍子连接成一个棍子
+// 你必须连接所有的棍子，直到剩下一个棍子
+// 返回以这种方式将所有给定的棍子连接成一个棍子的最小成本
+// 测试链接 : https://leetcode.cn/problems/minimum-cost-to-connect-sticks/
+public class Code04_MinimumCostToConnectSticks {
+
+	public static int connectSticks(int[] arr) {
+		PriorityQueue<Integer> pQ = new PriorityQueue<>();
+		for (int i = 0; i < arr.length; i++) {
+			pQ.add(arr[i]);
+		}
+		int sum = 0;
+		int cur = 0;
+		while (pQ.size() > 1) {
+			cur = pQ.poll() + pQ.poll();
+			sum += cur;
+			pQ.add(cur);
+		}
+		return sum;
+	}
+
+}

src/class089/Code05_CrossRiver.java

@@ -0,0 +1,67 @@
+package class089;
+
+// 过河问题
+// 有一个大晴天，Oliver与同学们一共N人出游
+// 他们走到一条河的东岸边，想要过河到西岸
+// 而东岸边有一条小船，船太小了，一次只能乘坐两人
+// 每个人都有一个渡河时间T，船划到对岸的时间等于船上渡河时间较长的人所用时间
+// 现在已知N个人的渡河时间T，Oliver 想要你告诉他，他们最少要花费多少时间，才能使所有人都过河
+// 注意，只有船在东岸（西岸）的人才能坐上船划到对岸
+// 测试链接 : https://www.luogu.com.cn/problem/P1809
+// 请同学们务必参考如下代码中关于输入、输出的处理
+// 这是输入输出处理效率很高的写法
+// 提交以下的code，提交时请把类名改成"Main"，可以直接通过
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code05_CrossRiver {
+
+	public static int MAXN = 100001;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] dp = new int[MAXN];
+
+	public static int n;
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		while (in.nextToken() != StreamTokenizer.TT_EOF) {
+			n = (int) in.nval;
+			for (int i = 0; i < n; i++) {
+				in.nextToken();
+				arr[i] = (int) in.nval;
+			}
+			int ans = minCost();
+			out.println(ans);
+			out.flush();
+		}
+
+	}
+
+	public static int minCost() {
+		Arrays.sort(arr, 0, n);
+		if (n >= 1) {
+			dp[0] = arr[0];
+		}
+		if (n >= 2) {
+			dp[1] = arr[1];
+		}
+		if (n >= 3) {
+			dp[2] = arr[0] + arr[1] + arr[2];
+		}
+		for (int i = 3; i < n; i++) {
+			dp[i] = Math.min(dp[i - 2] + arr[1] + arr[0] + arr[i] + arr[1], dp[i - 1] + arr[i] + arr[0]);
+		}
+		return dp[n - 1];
+	}
+
+}

src/class089/Code06_JumpGameII.java

@@ -0,0 +1,31 @@
+package class089;
+
+// 跳跃游戏II
+// 给定一个长度为n的0索引整数数组nums，初始位置为nums[0]
+// 每个元素nums[i]表示从索引i向前跳转的最大长度
+// 换句话说，如果你在nums[i]处，你可以跳转到任意nums[i+j]处
+// 0 <= j <= nums[i] 
+// i + j < n
+// 返回到达nums[n - 1]的最小跳跃次数
+// 生成的测试用例可以到达nums[n-1]
+// 测试链接 : https://leetcode.cn/problems/jump-game-ii/
+public class Code06_JumpGameII {
+
+	public static int jump(int[] arr) {
+		if (arr == null || arr.length == 0) {
+			return 0;
+		}
+		int step = 0;
+		int cur = 0;
+		int next = 0;
+		for (int i = 0; i < arr.length; i++) {
+			if (cur < i) {
+				step++;
+				cur = next;
+			}
+			next = Math.max(next, i + arr[i]);
+		}
+		return step;
+	}
+
+}

src/class090/Code01_CuttingBamboo.java

@@ -0,0 +1,37 @@
+package class090;
+
+// 砍竹子II
+// 现需要将一根长为正整数bamboo_len的竹子砍为若干段
+// 每段长度均为正整数
+// 请返回每段竹子长度的最大乘积是多少
+// 答案需要对1000000007取模
+// 测试链接 : https://leetcode.cn/problems/jian-sheng-zi-ii-lcof/
+public class Code01_CuttingBamboo {
+
+	public static int mod = 1000000007;
+
+	public static long power(long x, int n) {
+		long ans = 1;
+		while (n > 0) {
+			if ((n & 1) == 1) {
+				ans = (ans * x) % mod;
+			}
+			x = (x * x) % mod;
+			n >>= 1;
+		}
+		return ans;
+	}
+
+	public static int cuttingBamboo(int n) {
+		if (n == 2) {
+			return 1;
+		}
+		if (n == 3) {
+			return 2;
+		}
+		int rest = n % 3 == 0 ? n : (n % 3 == 1 ? (n - 4) : (n - 2));
+		int last = n % 3 == 0 ? 1 : (n % 3 == 1 ? 4 : 2);
+		return (int) ((power(3, rest / 3) * last) % mod);
+	}
+
+}

src/class091/Code01_MeetingMonopoly.java

@@ -0,0 +1,104 @@
+package class091;
+
+import java.util.Arrays;
+
+// 会议必须独占时间段的最大会议数量
+// 给定若干会议的开始、结束时间
+// 你参加某个会议的期间，不能参加其他会议
+// 返回你能参加的最大会议数量
+// 没有在线测试，对数器验证
+public class Code01_MeetingMonopoly {
+
+	// 暴力方法
+	// 为了验证
+	// 时间复杂度O(n!)
+	public static int maxMeeting1(int[][] meeting) {
+		return f(meeting, meeting.length, 0);
+	}
+
+	// 把所有会议全排列
+	// 其中一定有安排会议次数最多的排列
+	public static int f(int[][] meeting, int n, int i) {
+		int ans = 0;
+		if (i == n) {
+			for (int j = 0, time = -1; j < n; j++) {
+				if (time <= meeting[j][0]) {
+					ans++;
+					time = meeting[j][1];
+				}
+			}
+		} else {
+			for (int j = i; j < n; j++) {
+				swap(meeting, i, j);
+				ans = Math.max(ans, f(meeting, n, i + 1));
+				swap(meeting, i, j);
+			}
+		}
+		return ans;
+	}
+
+	public static void swap(int[][] meeting, int i, int j) {
+		int[] tmp = meeting[i];
+		meeting[i] = meeting[j];
+		meeting[j] = tmp;
+	}
+
+	// 正式方法
+	// 时间复杂度O(n*logn)
+	public static int maxMeeting2(int[][] meeting) {
+		Arrays.sort(meeting, (a, b) -> a[1] - b[1]);
+		int n = meeting.length;
+		int ans = 0;
+		for (int i = 0, cur = -1; i < n; i++) {
+			if (cur <= meeting[i][0]) {
+				ans++;
+				cur = meeting[i][1];
+			}
+		}
+		return ans;
+	}
+
+	// 为了验证
+	// 生成随机会议
+	public static int[][] randomMeeting(int n, int m) {
+		int[][] ans = new int[n][2];
+		for (int i = 0, a, b; i < n; i++) {
+			a = (int) (Math.random() * m);
+			b = (int) (Math.random() * m);
+			if (a == b) {
+				ans[i][0] = a;
+				ans[i][1] = a + 1;
+			} else {
+				ans[i][0] = Math.min(a, b);
+				ans[i][1] = Math.max(a, b);
+			}
+		}
+		return ans;
+	}
+
+	// 对数器
+	// 为了验证
+	public static void main(String[] args) {
+		int N = 10;
+		int M = 12;
+		int testTimes = 2000;
+		System.out.println("测试开始");
+		for (int i = 1; i <= testTimes; i++) {
+			int n = (int) (Math.random() * N) + 1;
+			int[][] meeting = randomMeeting(n, M);
+			int ans1 = maxMeeting1(meeting);
+			int ans2 = maxMeeting2(meeting);
+			if (ans1 != ans2) {
+				// 如果出错了
+				// 可以增加打印行为找到一组出错的例子
+				// 然后去debug
+				System.out.println("出错了！");
+			}
+			if (i % 100 == 0) {
+				System.out.println("测试到第" + i + "组");
+			}
+		}
+		System.out.println("测试结束");
+	}
+
+}