Leetcode每日随机2021/5/7

题

还行吧，困难那题确实做不出来

思

第一题
按照第二个数从小到大排个序就行了。
第二题
贪心，优先拿两人都觉得值钱的（alice[i]+bob[i]最大的）。以前做过，我这次的代码还是比以前的好一点，空间好一点。
第三题
看了答案感觉不是很难，没想出来有点可惜。
先按任务结束时间排个序。
然后找到每一个任务之前的那个任务（可被执行的最近的任务）用数组pre存储。
dp[i] = Math.max(dp[i-1],dp[pre[i]]+profit[i])
可惜

代码

第一题

class Solution {
    public int findLongestChain(int[][] pairs) {
		Arrays.sort(pairs, (a, b) -> {
			if (a[1] != b[1]) {
				return a[1] - b[1];
			} else {
				return b[0] - a[0];
			}
		});
		int count = 0;
		int[] temp = { Integer.MIN_VALUE, Integer.MIN_VALUE };
		for (int i = 0; i < pairs.length; i++) {
			if (pairs[i][0] > temp[1]) {
				temp[0] = pairs[i][0];
				temp[1] = pairs[i][1];
				count++;
			}
		}
		return count;
	}
}

第二题

class Solution {
    public int stoneGameVI(int[] aliceValues, int[] bobValues) {
		int aScore = 0, bScore = 0;
		Queue<int[]> queue = new PriorityQueue<int[]>((a, b) -> b[0] + b[1] - a[0] - a[1]);
		for (int i = 0; i < bobValues.length; i++) {
			int[] temp = { aliceValues[i], bobValues[i] };
			queue.offer(temp);
		}
		boolean flag = true;
		while (!queue.isEmpty()) {
			int[] temp = queue.poll();
			if (flag) {
				aScore += temp[0];
			} else {
				bScore += temp[1];
			}
			flag = !flag;
		}
		return aScore > bScore ? 1 : (aScore < bScore ? -1 : 0);
	}
}

思路来自这位老哥的题解
第三题

class Solution {
    public int jobScheduling(int[] startTime, int[] endTime, int[] profit) {
		int len = startTime.length;
		int[][] data = new int[len + 1][3];
		for (int i = 0; i < len; i++) {
			data[i + 1][0] = startTime[i];
			data[i + 1][1] = endTime[i];
			data[i + 1][2] = profit[i];
		}
		Arrays.sort(data, (a, b) -> a[1] - b[1]);
		int[] pre = new int[len + 1];
		int[] dp = new int[len + 1];
		// 找出每个任务的前一个可被执行的任务
		for (int i = 1; i < data.length; i++) {
			for (int j = i - 1; j >= 0; j--) {
				if (data[i][0] >= data[j][1]) {
					pre[i] = j;
					break;
				}
			}
		}
		
		for (int i = 1; i <= len; i++) {
			dp[i] = Math.max(dp[i - 1], dp[pre[i]] + data[i][2]);
		}
		return dp[len];
	}
}