LeetCode 第 199 场周赛(757/5231,前14.5%)

文章目录

    • 1. 比赛结果
    • 2. 题目
      • 1. LeetCode 5472. 重新排列字符串 easy
      • 2. LeetCode 5473. 灯泡开关 IV medium
      • 3. LeetCode 5474. 好叶子节点对的数量 medium
      • 4. LeetCode 5462. 压缩字符串 II hard

1. 比赛结果

第一题失误,点完提交就跑了,没想到。。第四题DP有些难,继续加油!

全国排名: 757 / 5231,14.5%;全球排名: 0 / 1,00.0%
LeetCode 第 199 场周赛(757/5231,前14.5%)_第1张图片

2. 题目

1. LeetCode 5472. 重新排列字符串 easy

题目链接

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

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

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

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

示例 2:
输入:s = "abc", indices = [0,1,2]
输出:"abc"
解释:重新排列后,每个字符都还留在原来的位置上。

示例 3:
输入:s = "aiohn", indices = [3,1,4,2,0]
输出:"nihao"

示例 4:
输入:s = "aaiougrt", indices = [4,0,2,6,7,3,1,5]
输出:"arigatou"

示例 5:
输入:s = "art", indices = [1,0,2]
输出:"rat"
 
提示:
s.length == indices.length == n
1 <= n <= 100
s 仅包含小写英文字母。
0 <= indices[i] < n
indices 的所有的值都是唯一的
(也就是说,indices 是整数 0 到 n - 1 形成的一组排列)。

解题:

class Solution {
public:
    string restoreString(string s, vector<int>& indices) {
    	string ans = s;
    	for(int i = 0; i < indices.size(); ++i)
    		ans[indices[i]] = s[i];
    	return ans;
    }
};
class Solution:
    def restoreString(self, s: str, indices: List[int]) -> str:
        ans = list(s)
        for i in range(len(s)):
            ans[indices[i]] = s[i]
        return "".join(ans)

2. LeetCode 5473. 灯泡开关 IV medium

题目链接

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

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

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

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

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

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

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

示例 3:
输入:target = "00000"
输出:0

示例 4:
输入:target = "001011101"
输出:5
 
提示:
1 <= target.length <= 10^5
target[i] == '0' 或者 target[i] == '1'

解题:

  • 从左往右找到1,开始数有多少类(连续的1或者0)
class Solution {
public:
    int minFlips(string target) {
    	int s = 0, i = 0, n = target.size();
    	char prev = '0';
    	for(i = 0; i < n; ++i)
    	{
    		if(prev != target[i])
    			s++;
    		prev = target[i];
    	}
    	return s;
    }
};

3. LeetCode 5474. 好叶子节点对的数量 medium

题目链接

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

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

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

示例 1:
LeetCode 第 199 场周赛(757/5231,前14.5%)_第2张图片

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

示例 2:
LeetCode 第 199 场周赛(757/5231,前14.5%)_第3张图片

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

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

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

示例 5:
输入:root = [1,1,1], distance = 2
输出:1
 
提示:
tree 的节点数在 [1, 2^10] 范围内。
每个节点的值都在 [1, 100] 之间。
1 <= distance <= 10

解题:

  • 返回值dis(distance+1,0)数组,dis[i]表示 距离为 i 的节点有多少个
class Solution {
    int ans = 0;
public:
    int countPairs(TreeNode* root, int distance) {
        dfs(root, distance);
        return ans;
    }

    vector<int> dfs(TreeNode* root, int distance)
    {
        if(!root) return {};
        auto l = dfs(root->left,distance);
        auto r = dfs(root->right,distance);
        if(!root->left && !root->right)
        {
            vector<int> dis(distance+1,0);
            dis[1] = 1;
            return dis;
        }
        for(int i = 1; i < min(int(l.size()),distance+1); ++i)
            for(int j = 1; j < min(int(r.size()),distance+1); ++j)
                if(i+j <= distance)
                    ans += l[i]*r[j];
        vector<int> dis(distance+1, 0);
        for(int i = 1; i+1 <= distance; ++i)
            dis[i+1] += (i < l.size() ? l[i] : 0) + (i < r.size() ? r[i] : 0);
        return dis;
    }
};

4. LeetCode 5462. 压缩字符串 II hard

题目链接

行程长度编码 是一种常用的字符串压缩方法,它将连续的相同字符(重复 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 仅包含小写英文字母

解题:

动态规划,难。


我的CSDN博客地址 https://michael.blog.csdn.net/

长按或扫码关注我的公众号(Michael阿明),一起加油、一起学习进步!
Michael阿明

你可能感兴趣的:(LeetCode)