力扣周赛：第414场周赛

👨‍🎓作者简介：爱好技术和算法的研究生
🌌上期文章：[首期文章]
📚订阅专栏：力扣周赛
希望文章对你们有所帮助

本科打ACM所以用的都是C++，未来走的是Java，所以现在敲算法还是主要Java为主，C++偶尔敲一下保持一下记忆。

将日期转换为二进制表示

题目描述
给你一个字符串 date，它的格式为 yyyy-mm-dd，表示一个公历日期。

date 可以重写为二进制表示，只需要将年、月、日分别转换为对应的二进制表示（不带前导零）并遵循 year-month-day 的格式。

返回 date 的 二进制 表示。
示例1
输入： date = “2080-02-29”

输出： “100000100000-10-11101”

解释：

100000100000, 10 和 11101 分别是 2080, 02 和 29 的二进制表示。
示例2
输入： date = “1900-01-01”

输出： “11101101100-1-1”

解释：

11101101100, 1 和 1 分别是 1900, 1 和 1 的二进制表示。

签到题，不必多说

class Solution {
    public String convertDateToBinary(String date) {
        String[] dates = date.split("-");
        String ans = "";
        for(int i = 0;i < 3; ++i){
            if(i != 0){
                ans += "-";
            }
            int num = 0, n = dates[i].length();
            String res = "";
            for(int j = 0; j < n; ++j){
                num = num * 10 + dates[i].charAt(j) - '0';
            }
            while(num != 0){
                if((num & 1) == 1){
                    res += "1";
                }
                else res += "0";
                num >>= 1;
            }
            StringBuffer sb = new StringBuffer(res);
            res = sb.reverse().toString();
            ans += res;
        }
        return ans;
    }
}

范围内整数的最大得分

题目描述
给你一个整数数组 start 和一个整数 d，代表 n 个区间 [start[i], start[i] + d]。

你需要选择 n 个整数，其中第 i 个整数必须属于第 i 个区间。所选整数的 得分 定义为所选整数两两之间的 最小 绝对差。

返回所选整数的 最大可能得分 。
示例1
输入： start = [6,0,3], d = 2

输出： 4

解释：

可以选择整数 8, 0 和 4 获得最大可能得分，得分为 min(|8 - 0|, |8 - 4|, |0 - 4|)，等于 4。
示例2
输入： start = [2,6,13,13], d = 5

输出： 5

解释：

可以选择整数 2, 7, 13 和 18 获得最大可能得分，得分为 min(|2 - 7|, |2 - 13|, |2 - 18|, |7 - 13|, |7 - 18|, |13 - 18|)，等于 5。

数据范围
2 <= start.length <= 10⁵
0 <= start[i] <= 10⁹
0 <= d <= 10⁹

d的范围如此大，只要一次循环就必定会超时，但是对于每个数字，我们必定需要对[0, d]之间的范围进行相加，因此很显然这题需要使用二分，因此我们只需要对答案进行二分，重点是二分的条件判断。观察样例可以很容易发现，最小的数一定不会继续增大，而最大的数会增大到最大即+d，这样有助于得到最大得分，另外可以发现位置并不影响最终的结果，因此可以直接将数组进行排序。

对于特定得分score，判断是否可以使所选整数的得分不小于 score 的方法如下：遍历按升序排序的数组 start，遍历过程中维护上一个选择的整数 prev，初始时 prev=−∞，对于遍历到的每个整数 num，执行如下操作：

• 如果num+d−prev<score，则即使当前选择的整数取最大值也不满足与上一个选择的整数之差大于等于 score，因此无法使所选整数的得分不小于 score。
• 如果num+d−prev≥score，则当前选择的整数可以取的最小值为 max(num,prev+score)，将 prev 的值更新，然后继续遍历其余元素

上述做法中，对于遍历到的每个整数都计算选择的整数可以取的最小值，该做法基于贪心策略，理由如下：后一个整数的取值范围根据数组 start 中的元素值与整数 d 确定，当后一个选择的整数的取值范围确定时，前一个整数的取值越小，后一个整数可以选择的范围越大，如果前一个整数的取值大于可以取的最小值，则后一个整数可以选择的范围更小，该选择整数的方案一定不会优于取最小值的方案。

代码如下：

class Solution {
    public int maxPossibleScore(int[] start, int d) {
        Arrays.sort(start);
        long l = 0, r = start[start.length - 1] + d - start[0];
        int res = 0;
        while(l <= r){
            long mid = (l + r) >> 1;
            int flag = 0; long prev = Integer.MIN_VALUE;
            for(int i = 0; i < start.length; ++i){
                if(start[i] + d - prev < mid){
                    flag = 1;
                    break;
                }
                prev = Math.max(start[i], prev + mid);
            }
            if(flag == 1)r = mid - 1;
            else{
                l = mid + 1;
                res = (int)mid;
            }
        }
        return res;
    }
}

到达数组末尾的最大得分

题目描述
给你一个长度为 n 的整数数组 nums 。

你的目标是从下标 0 出发，到达下标 n - 1 处。每次你只能移动到 更大 的下标处。

从下标 i 跳到下标 j 的得分为 (j - i) * nums[i]。

请你返回你到达最后一个下标处能得到的 最大总得分 。
示例1
输入：nums = [1,3,1,5]

输出：7

解释：

一开始跳到下标 1 处，然后跳到最后一个下标处。总得分为 1 * 1 + 2 * 3 = 7 。
示例2
输入：nums = [4,3,1,3,2]

输出：16

解释：

直接跳到最后一个下标处。总得分为 4 * 4 = 16 。
数据范围
1 <= nums.length <= 10⁵
1 <= nums[i] <= 10⁵

很显然是贪心，直接遍历数组，只要发现更大的nums[i]就停止，并计算在此之前的总得分，最后重新更新这个最大的数，直到遍历完这个数组，力扣上有一个题解是将其比喻为长方形面积，还是很形象的，这里借鉴一下

代码如下：

class Solution {
    public long findMaximumScore(List<Integer> nums) {
        long ans = 0, maxn = nums.get(0), pos = 0;
        for(int i = 1; i < nums.size(); ++i){
            if(nums.get(i) > maxn){
                ans += (i - pos) * maxn;
                maxn = nums.get(i);
                pos = i;
            }
        }
        ans += (nums.size() - pos - 1) * maxn;
        return ans;
    }
}

吃掉所有兵需要的最多移动次数

题目描述
给你一个 50 x 50 的国际象棋棋盘，棋盘上有 一个 马和一些兵。给你两个整数 kx 和 ky ，其中 (kx, ky) 表示马所在的位置，同时还有一个二维数组 positions ，其中 positions[i] = [xi, yi] 表示第 i 个兵在棋盘上的位置。

Alice 和 Bob 玩一个回合制游戏，Alice 先手。玩家的一次操作中，可以执行以下操作：

玩家选择一个仍然在棋盘上的兵，然后移动马，通过 最少 的 步数 吃掉这个兵。注意 ，玩家可以选择 任意 一个兵，不一定 要选择从马的位置出发 最少 移动步数的兵。
在马吃兵的过程中，马 可能 会经过一些其他兵的位置，但这些兵 不会 被吃掉。只有 选中的兵在这个回合中被吃掉。
Alice 的目标是 最大化 两名玩家的 总 移动次数，直到棋盘上不再存在兵，而 Bob 的目标是 最小化 总移动次数。

假设两名玩家都采用 最优 策略，请你返回 Alice 可以达到的 最大 总移动次数。

在一次 移动 中，如下图所示，马有 8 个可以移动到的位置，每个移动位置都是沿着坐标轴的一个方向前进 2 格，然后沿着垂直的方向前进 1 格。

示例1
输入：kx = 1, ky = 1, positions = [[0,0]]

输出：4

解释：马需要移动 4 步吃掉 (0, 0) 处的兵。
示例2
输入：kx = 0, ky = 2, positions = [[1,1],[2,2],[3,3]]

输出：8

解释：

• Alice 选择 (2, 2) 处的兵，移动马吃掉它需要 2 步：(0, 2) -> (1, 4) -> (2, 2) 。
• Bob 选择 (3, 3) 处的兵，移动马吃掉它需要 2 步：(2, 2) -> (4, 1) -> (3, 3) 。
• Alice 选择 (1, 1) 处的兵，移动马吃掉它需要 4 步：(3, 3) -> (4, 1) -> (2, 2) -> (0, 3) -> (1, 1) 。

这道题没做出来，贴一个我觉得比较不错的题解：题解
总的来说就是DP+递推/记忆化搜索

代码如下（借鉴AC代码）：

class Solution {
    private static final int[][] dirs = {
        {2, 1}, {1, 2}, {-1, 2}, {-2, 1},
        {-2, -1}, {-1, -2}, {1, -2}, {2, -1}
    };
    public int maxMoves(int kx, int ky, int[][] positions) {
        int n = positions.length;
        int[][][] f = new int[n][50][50];
        for(int i = 0; i < n; ++i){
            int[][] d = f[i];
            for(int j = 0; j < 50; ++j){
                Arrays.fill(d[j], -1);
            }
            int px = positions[i][0], py = positions[i][1];
            d[px][py] = 0;
            List<int[]> q = List.of(new int[]{px, py});
            int step = 1;
            while(!q.isEmpty()){
                List<int[]> tmp = q;
                q = new ArrayList<>();
                for(int[] p : tmp){
                    for(int[] dir : dirs){
                        int x = p[0] + dir[0], y = p[1] + dir[1];
                        if(x >= 0 && x < 50 && y >= 0 && y < 50 && d[x][y] < 0){
                            d[x][y] = step;
                            q.add(new int[]{x, y});
                        }
                    }
                }
                ++step;
            }
        }
        int[][] memo = new int[n + 1][1 << n];
        for(int[] row : memo){
            Arrays.fill(row, -1);
        }
        return dfs(n, (1 << n) - 1, kx, ky, positions, f, memo);
    }
    private int dfs(int i, int mask, int kx, int ky, int[][] positions, int[][][] dis, int[][] memo) {
        if(mask == 0) return 0;
        if(memo[i][mask] != -1)return memo[i][mask];
        int n = positions.length;
        int x = i < n ? positions[i][0] : kx, y = i < n ? positions[i][1] : ky;
        int res = 0, u = (1 << n) - 1;
        if (Integer.bitCount(u ^ mask) % 2 == 0) {
            for (int j = 0; j < n; j++) {
                if ((mask >> j & 1) > 0) {
                    res = Math.max(res, dfs(j, mask ^ (1 << j), kx, ky, positions, dis, memo) + dis[j][x][y]);
                }
            }
        } else {
            res = Integer.MAX_VALUE;
            for (int j = 0; j < n; j++) {
                if ((mask >> j & 1) > 0) {
                    res = Math.min(res, dfs(j, mask ^ (1 << j), kx, ky, positions, dis, memo) + dis[j][x][y]);
                }
            }
        }
        return memo[i][mask] = res;
    }
}