LeetCode: 第 159 场周赛

LeetCode: 第 159 场周赛题解

5230. 缀点成线

题目

在一个 XY 坐标系中有一些点，我们用数组 coordinates 来分别记录它们的坐标，其中 coordinates[i] = [x, y] 表示横坐标为 x、纵坐标为 y 的点。
请你来判断，这些点是否在该坐标系中属于同一条直线上，是则返回 true，否则请返回 false。

实例

输入：coordinates = [[1,2],[2,3],[3,4],[4,5],[5,6],[6,7]]
输出：true

题解

方程求解，注意: （点都在同一竖线）的特殊情况

class Solution {
    public boolean checkStraightLine(int[][] coordinates) {
        int i , n = coordinates.length;
        int dx = coordinates[1][0] - coordinates[0][0];
        int dy = coordinates[1][1] - coordinates[0][1];
        boolean ans  = true;
        for(i = 2 ; i < n ; i ++)
            if(dx == 0 && coordinates[0][0] != coordinates[i][0]){
                ans  = false;
                break;
            }
            else if(dy == 0 && coordinates[0][1] != coordinates[i][1]){
                 ans  = false;
                break;
            }else if(dx != 0 && dy != 0){
                if(1.0*(coordinates[i][0] - coordinates[0][0])/dx != 1.0*(coordinates[i][1] - coordinates[0][1])/dy){
                    ans = false;
                    break;
                }
            }
           
        return ans;
    }
}

5231. 删除子文件夹

题目

你是一位系统管理员，手里有一份文件夹列表 folder，你的任务是要删除该列表中的所有 子文件夹，并以 任意顺序 返回剩下的文件夹。
我们这样定义「子文件夹」：
如果文件夹 folder[i] 位于另一个文件夹 folder[j] 下，那么 folder[i] 就是 folder[j] 的子文件夹。
文件夹的「路径」是由一个或多个按以下格式串联形成的字符串：
/ 后跟一个或者多个小写英文字母。
例如，/leetcode 和 /leetcode/problems 都是有效的路径，而空字符串和 / 不是。

实例

示例 1：

输入：folder = ["/a","/a/b","/c/d","/c/d/e","/c/f"]
输出：["/a","/c/d","/c/f"]
解释："/a/b/" 是 “/a” 的子文件夹，而 “/c/d/e” 是 “/c/d” 的子文件夹。

示例 2：

输入：folder = ["/a","/a/b/c","/a/b/d"]
输出：["/a"]
解释：文件夹 “/a/b/c” 和 “/a/b/d/” 都会被删除，因为它们都是 “/a” 的子文件夹。

示例 3：

输入：folder = ["/a/b/c","/a/b/d","/a/b/ca"]
输出：["/a/b/c","/a/b/ca","/a/b/d"]

题解

用暴力求解

class Solution {
    public List<String> removeSubfolders(String[] folder) {
        int i = 0 ,  n = folder.length;
        Arrays.sort(folder, (a, b) -> {return a.length() - b.length();});
        List<String> ans = new ArrayList<String>();
        int [] f = new int[n];
        for(i = 0 ; i < n ; i ++){
            if(f[i] == 1) continue;
            for(int j = i + 1 ; j < n; j ++)
                if(f[j] == 1) continue;
                else if(folder[j].startsWith(folder[i]) &&  folder[j].charAt(folder[i].length()) == '/'){
                    f[j] = 1;
                }
        }
        for(i = 0 ; i < n ; i ++) if(f[i] == 0) ans.add(folder[i]);
        return ans;
    }
}

5232. 替换子串得到平衡字符串

题目

有一个只含有 ‘Q’, ‘W’, ‘E’, ‘R’ 四种字符，且长度为 n 的字符串。
假如在该字符串中，这四个字符都恰好出现 n/4 次，那么它就是一个「平衡字符串」。
给你一个这样的字符串 s，请通过「替换子串」的方式，使原字符串 s 变成一个「平衡字符串」。
你可以用和「待替换子串」长度相同的 任何 其他字符串来完成替换。
请返回待替换子串的最小可能长度。
如果原字符串自身就是一个平衡字符串，则返回 0。

示例

示例 1：

输入：s = “QWER”
输出：0
解释：s 已经是平衡的了。

示例 2：

输入：s = “QQWE”
输出：1
解释：我们需要把一个 ‘Q’ 替换成 ‘R’，这样得到的 “RQWE” (或 “QRWE”) 是平衡的。

示例 3：

输入：s = “QQQW”
输出：2
解释：我们可以把前面的 “QQ” 替换成 “ER”。

示例 4：

输入：s = “QQQQ”
输出：3
解释：我们可以替换后 3 个 ‘Q’，使 s = “QWER”。

题解

比赛的时候脑子抽了没做出来，这种子串问题一般用动态规划或者滑动窗口可以解决。这道题用的是滑动窗口方法。不了解什么是滑动窗口的自行百度。

• 首先我们计算Q、R、E、W出现的总次数。
• 再算出Q、R、E、W多出的次数。
• 平衡子串就是子串里Q、R、E、W的次数 >= Q、R、E、W多出的次数。

class Solution {
    public int balancedString(String s) {
        char []sc = s.toCharArray();
        int i , n = sc.length;
        int []a = new int[4];
        int []b = new int[4];
        //算出总次数
        for(i = 0 ; i < n ; i ++){
            if(sc[i] == 'Q') a[0] ++;
            else if(sc[i] == 'W') a[1] ++;
            else if(sc[i] == 'E') a[2] ++;
            else a[3] ++;
        }
        int d = 0;
        //多出来的次数
        for(i = 0 ; i < 4 ; i ++) {
            a[i] -= n/4;
            d += Math.abs(a[i]);
        }
        if(d == 0) return d;
        int ans = n + 1,l = 0,r = -1;
        while(true){
            while(true){
                r++;
                if(sc[r] == 'Q') b[0] ++;
                else if(sc[r] == 'W') b[1] ++;
                else if(sc[r] == 'E') b[2] ++;
                else b[3] ++;
                for(i = 0 ; i < 4 ; i ++){
                    if(a[i] <= 0) continue;
                    if(b[i] < a[i]) break;
                }
                if(i == 4) {
                    ans = Math.min(ans, r - l + 1);
                    break;
                }
                if(r == n - 1) break;
            }
            
            while(l <= r){
                if(sc[l] == 'Q') b[0] --;
                else if(sc[l] == 'W') b[1] --;
                else if(sc[l] == 'E') b[2] --;
                else b[3] --;
                l ++;
                for(i = 0 ; i < 4 ; i ++){
                    if(a[i] <= 0) continue;
                    if(b[i] < a[i]) break;
                }
                if(i == 4) ans = Math.min(ans, r - l + 1);
                else break;
            }
            if(r == n - 1) break;
        }
        return ans;
    }
}

5233. 规划兼职工作

题目

你打算利用空闲时间来做兼职工作赚些零花钱。
这里有 n 份兼职工作，每份工作预计从 startTime[i] 开始到 endTime[i] 结束，报酬为 profit[i]。
给你一份兼职工作表，包含开始时间 startTime，结束时间 endTime 和预计报酬 profit 三个数组，请你计算并返回可以获得的最大报酬。
注意，时间上出现重叠的 2 份工作不能同时进行。
如果你选择的工作在时间 X 结束，那么你可以立刻进行在时间 X 开始的下一份工作。

实例

输入：startTime = [1,2,3,3], endTime = [3,4,5,6], profit = [50,10,40,70]
输出：120
解释：
我们选出第 1 份和第 4 份工作，
时间范围是 [1-3]+[3-6]，共获得报酬 120 = 50 + 70。

题解

动态规划：

• dp[i]: 前i个工作获得的最大报酬。
• w[i].p: 第i个工作的报酬
• j: 在前i个工作里与第i个工作时间不重叠 距离最近的工作j
• 状态转移公式: dp[i] = Math.max(dp[i - 1], dp[j] + w[i].p)

class Solution {
    public int jobScheduling(int[] startTime, int[] endTime, int[] profit) {
        int i, j, n = profit.length;
        W []w = new W[n + 1];
        w[0] = new W();
        for(i = 1; i <= n ; i ++)
            w[i] = new W(startTime[i - 1],endTime[i - 1],profit[i - 1]);
        
        int []dp = new int[n + 1];
        Arrays.sort(w, (a,b) -> {
            if(a.e != b.e) return a.e - b.e;
            return a.s - b.s;
        });
    
        dp[1] = w[1].p;
        for(i = 2 ; i <= n ; i ++){
            for(j = i - 1 ; j >= 0 ; j --)
                if(w[i].s >= w[j].e) break;
            dp[i] = Math.max(dp[i - 1], dp[j] + w[i].p);
        }
        return dp[n];
    }
   
}
class W{
    int s,e,p, pre;
    W(){}
    W(int s1,int e1,int p1){
        s = s1;
        e = e1;
        p = p1;
    }
}