【LeetCode】周赛纪录(八)第199场周赛20200726 重新排列字符串 灯泡开关 IV 好叶子节点对的数量 压缩字符串 II

周赛第199场20200726

5472. 重新排列字符串

题目描述1

给你一个字符串 s 和一个 长度相同 的整数数组 indices 。

请你重新排列字符串 s ,其中第 i 个字符需要移动到 indices[i] 指示的位置。

返回重新排列后的字符串。

示例 1:

输入:s = "codeleet", indices = [4,5,6,7,0,2,1,3]
输出:"leetcode"
解释:如图所示,"codeleet" 重新排列后变为 "leetcode" 。

Solution1

class Solution {
    public String restoreString(String s, int[] indices) {
        char[] a = s.toCharArray();
        char[] b = new char[s.length()];
        int n = s.length();
        for(int i = 0; i < n; i++){
            b[indices[i]] = a[i]; 
        }
        return String.valueOf(b);
    }
}

5473. 灯泡开关 IV

题目描述2

房间中有 n 个灯泡,编号从 0 到 n-1 ,自左向右排成一行。最开始的时候,所有的灯泡都是 关 着的。

请你设法使得灯泡的开关状态和 target 描述的状态一致,其中 target[i] 等于 1 第 i 个灯泡是开着的,等于 0 意味着第 i 个灯是关着的。

有一个开关可以用于翻转灯泡的状态,翻转操作定义如下:

选择当前配置下的任意一个灯泡(下标为 i )
翻转下标从 i 到 n-1 的每个灯泡
翻转时,如果灯泡的状态为 0 就变为 1,为 1 就变为 0 。

返回达成 target 描述的状态所需的 最少 翻转次数。

示例 :

输入:target = "10111"
输出:3
解释:初始配置 "00000".
从第 3 个灯泡(下标为 2)开始翻转 "00000" -> "00111"
从第 1 个灯泡(下标为 0)开始翻转 "00111" -> "11000"
从第 2 个灯泡(下标为 1)开始翻转 "11000" -> "10111"
至少需要翻转 3 次才能达成 target 描述的状态

输入:target = "101"
输出:3
解释:"000" -> "111" -> "100" -> "101".

输入:target = "00000"
输出:0

输入:target = "001011101"
输出:5

Solution2

  1. 每次看当前位和前面位不一样,就增加一次
class Solution {
    public int minFlips(String target) {
        int n = target.length();
        int res = 0;
        for(int i = 1; i < n; i++){
            if(target.charAt(i) != target.charAt(i-1)){
                res++;
            }
        }
        if(target.charAt(0) == '1'){
            res++;
        }
        return res;
    }
}
  1. 用status记录当前状态,和target不一样就增加次数
class Solution {
    public int minFlips(String target) {
        char[] a = target.toCharArray();
        int res = 0;
        int status = 0;
        for(char ch : a){
            if(status != ch - '0'){
                res++;
                status ^= 1;//与1异或:0变1,1变0
            }
        }
        return res;
    }
}

5474. 好叶子节点对的数量

题目描述3

给你二叉树的根节点 root 和一个整数 distance 。

如果二叉树中两个 叶 节点之间的 最短路径长度 小于或者等于 distance ,那它们就可以构成一组 好叶子节点对 。

返回树中 好叶子节点对的数量 。

示例:

输入:root = [1,2,3,null,4], distance = 3
输出:1
解释:树的叶节点是 3 和 4 ,它们之间的最短路径的长度是 3 。这是唯一的好叶子节点对。

输入:root = [1,2,3,4,5,6,7], distance = 3
输出:2
解释:好叶子节点对为 [4,5] 和 [6,7] ,最短路径长度都是 2 。但是叶子节点对 [4,6] 不满足要求,因为它们之间的最短路径长度为 4 。

输入:root = [7,1,4,6,null,5,3,null,null,null,null,null,2], distance = 3
输出:1
解释:唯一的好叶子节点对是 [2,5] 。

输入:root = [100], distance = 1
输出:0

输入:root = [1,1,1], distance = 2
输出:1

提示:

  • tree 的节点数在 [1, 2^10] 范围内。
  • 每个节点的值都在 [1, 100] 之间。
  • 1 <= distance <= 10

Solution3

参考 https://www.bilibili.com/video/BV1Up4y1i711?p=4

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    int ans = 0;
    public int countPairs(TreeNode root, int distance) {
        if(root == null) return 0;
        dfs(root, distance);
        return ans;
    }

    public int[] dfs(TreeNode root, int distance){
        //dis[i]代表,到当前节点距离为i的叶子节点的数量
        int[] dis = new int[distance];
        if(root == null) return dis;
        if(root.left == null && root.right == null){
            //是叶子节点
            dis[0] = 1;
            return dis;
        }
        int[] left = dfs(root.left, distance);
        int[] right = dfs(root.right, distance);
        
        for(int i = 0; i <= distance - 2; i++){
            for(int j = 0; i + j + 2 <= distance; j++){
                //所有满足的方案数
                //x---left-+1-node-+1-right---y
                // i+1+1+j<=distance说明是一条合法的路径。左边选一条,右边选一条,所以二者相乘。
                ans += left[i] * right[j];
            }
        }
        //更新,向上传
        for(int i = 1; i < distance; i++){
            //当前节点距离为i的叶子节点的数量 = 距离left距离为i-1的数量 + 距离right距离为i-1的数量
            dis[i] = left[i-1] + right[i-1];
        }
        return dis;
    }
}

5462. 压缩字符串 II

题目描述4

行程长度编码 是一种常用的字符串压缩方法,它将连续的相同字符(重复 2 次或更多次)替换为字符和表示字符计数的数字(行程长度)。例如,用此方法压缩字符串 “aabccc” ,将 “aa” 替换为 “a2” ,“ccc” 替换为` “c3” 。因此压缩后的字符串变为 “a2bc3” 。

注意,本问题中,压缩时没有在单个字符后附加计数 ‘1’ 。

给你一个字符串 s 和一个整数 k 。你需要从字符串 s 中删除最多 k 个字符,以使 s 的行程长度编码长度最小。

请你返回删除最多 k 个字符后,s 行程长度编码的最小长度 。

示例 1:

输入:s = "aaabcccd", k = 2
输出:4
解释:在不删除任何内容的情况下,压缩后的字符串是 "a3bc3d" ,长度为 6 。最优的方案是删除 'b' 和 'd',这样一来,压缩后的字符串为 "a3c3" ,长度是 4 。

示例 2:

输入:s = "aabbaa", k = 2
输出:2
解释:如果删去两个 'b' 字符,那么压缩后的字符串是长度为 2 的 "a4" 。

示例 3:

输入:s = "aaaaaaaaaaa", k = 0
输出:3
解释:由于 k 等于 0 ,不能删去任何字符。压缩后的字符串是 "a11" ,长度为 3 。

提示:

  • 1 <= s.length <= 100
  • 0 <= k <= s.length
  • s 仅包含小写英文字母

Solution

参考:https://www.bilibili.com/video/BV1Up4y1i711?p=5

class Solution {
    public int getLengthOfOptimalCompression(String s, int k) {
        int n = s.length();
        //dp[i][j]:前i个字符(从1开始编号)删除了j个字符之后对应的压缩字符串的最小长度
        int[][] dp = new int[n+1][k+1];
        //初始化
        for(int i = 0; i <= n; i++){
            for(int j = 0; j <= k; j++){
                dp[i][j] = Integer.MAX_VALUE / 2;
            }
        }
        dp[0][0] = 0;
        for(int i = 1; i <= n; i++){
            for(int j = 0; j <= k && j <= i; j++){
                if(j > 0){
                    //删除第i个字符,不考虑第i个字符的[一整段]
                    dp[i][j] = dp[i-1][j-1];
                }
                int same = 0;//和第i个字符相同字符的个数
                int diff = 0;//和第i个字符不同的字符的个数
                //枚举i0:一整段开头的前一个位置,[i0+1,i]是[一整段]
                for(int i0 = i; i0 >= 1; i0--){
                    if(s.charAt(i0-1) == s.charAt(i-1)){
                        same++;
                    }else{
                        diff++;
                    }
                    if(diff <= j){
                        //min(dp[i0][j-X]+Y)
                        //X:和s[i]不同的字符个数
                        //Y:和s[i]相同的字符压缩后的长度
                        dp[i][j] = Math.min(dp[i][j], dp[i0-1][j-diff] + calc(same));
                    }else{
                        break;
                    }
                }
            }
        }
        int res = Integer.MAX_VALUE;
        for(int j = 0; j <= k; j++){
            res = Math.min(res, dp[n][j]);
        }
        return res;
    }
    public int calc(int x){
        if(x == 1){
            return 1;
        }
        if(x < 10){
            return 2;
        }
        if(x < 100){
            return 3;
        }
        return 4;
    }
}

欢迎关注公众号:GitKid,暂时每日分享LeetCode题解,在不断地学习中,公众号内容也在不断充实,欢迎扫码关注

你可能感兴趣的:(数据结构与算法,LeetCode,leetcode,java,算法,周赛,动态规划)