leetCode第199场周赛学习

199场周赛

1528. 重新排列字符串

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

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

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

输入：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) {
        char help[101];
        string res;
        for(int i=0;i<indices.size();i++){
            help[indices[i]]=s[i];
        }
         for(int i=0;i<indices.size();i++){
            res+=help[i];
        }
        return res;
    }
};

优化一点

class Solution {
public:
    string restoreString(string s, vector<int>& indices) {
        string res(indices.size(),0);
        for(int i=0;i<indices.size();i++){
            res[indices[i]]=s[i];
        }
        return res;
    }
};

1529. 灯泡开关 IV

房间中有 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’

分析

害 说来惭愧分析能力一直不足

这题的思路是这样的 首先要求从初始状态变到target状态(等同于从target状态变化到初始状态)

例如 从10111变到00000 首先 第一个得变一次 变为01000那么第二个不符合要求在变 00111 然后在变 00000

那么分析完这一个之后 我们就模拟一下这个行为 就是初始 标准为 0 ，我们遍历数组，碰到第一个非0 变化一次 然后我们的标准也同时变化 重复上述步骤 直到遍历结束

模拟

class Solution {
public:
    int minFlips(string target) {
        int res=0;
        char pre='0';
        for(int i=0;i<target.size();i++){
           if(pre!=target[i]){
               res++;
               pre=target[i];
           }
        }
        return res;
        
    }
};

1530. 好叶子节点对的数量

给你二叉树的根节点 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] 。

提示：

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

分析

求好叶子节点对的个数就是求两个叶子节点之间距离小于D的对子数，就是从某个节点出发到两个叶子节点的距离和小于D的，那么我们就得记下到某个节点距离为n的叶子节点的个数。

cnt i j 表示 以i为根节点的子树中，距离i为j的叶子节点的个数

害 好难啊

dfs

const int MAXN=1030;
int cnt[MAXN][15]; //cnt[i][j]表示 以i为根节点的子树中，距离i为j的叶子节点的个数
int res,tot;
class Solution {
public:
    int dfs(TreeNode* root, int distance){
        int x=++tot;
        int l=0,r=0;
        if(root->left) l=dfs(root->left,distance);
        if(root->right) r=dfs(root->right,distance);
        if(l>0 && r>0){
            for(int i=0;i<=distance;i++){
                for(int j=0;j<=distance;j++){
                    if(i+j+2<=distance) res+=cnt[l][i]*cnt[r][j];
                }
            }
        }
        for(int i=0;i<distance;i++){
            cnt[x][i+1]=cnt[l][i]+cnt[r][i];
        }
        if(l==0 && r==0) cnt[x][0]=1;
        return x;
    }
    int countPairs(TreeNode* root, int distance) {
        res=tot=0;
        memset(cnt,0,sizeof(cnt));
        dfs(root,distance);
        return res;
    }
};

1