LeetCode [5352 ~ 5355]

链接：https://leetcode-cn.com/problems/generate-a-string-with-characters-that-have-odd-counts/
来源：LeetCode

5352. 生成每种字符都是奇数个的字符串(签到)

  直接按照题意输出即可，如果是偶数直接输出奇数个 “a” ，一个 “b”；如果是奇数个直接输出奇数个 “a”。

class Solution {
public:
    string generateTheString(int n) {
        string ans = "";
        if (n % 2 == 0) {
            for (int i = 1; i <= n - 1; i ++) {
                ans += "a";
            } ans += "b";
        } else {
            for (int i = 1; i <= n; i ++) {
                ans += "a";
            }
        }
        return ans;
    }
};

5353. 灯泡开关 III(思维)

  我们可以发现如果前面几位数可以构成一个排列数，那么灯就可以全部变成蓝色。所以只要当前数以及之前的数字可以构成 $[1,2,3...]$ 的一个排列答案就增加一。

class Solution {
public:
    int numTimesAllBlue(vector<int>& light) {
        int n = light.size();
        int Max = 1, ans = 0;
        for (int i = 0; i < n; i ++) {
            Max = max(Max, light[i]);
            if (Max == i + 1) ans ++;
        }
        return ans;
    }
};

5354. 通知所有员工所需的时间(bfs)

  通过题意描述我们可以知道，题目实际上就是让我们求树上的最短距离。我们直接进行 $bfs$ 即可。直到没有可以在向下走的点，就可以得到一个值，比较到所有叶子结点的值，选取一个最大值。

class Solution {
public:
    
    int numOfMinutes(int n, int headID, vector<int>& manager, vector<int>& informTime) {
        vector<pair<long long, int>>G[n + 1];
        int faCost = 0;
        for (int i = 0; i < n; i ++) {
            if (manager[i] == -1) faCost = informTime[i];
            else G[manager[i]].push_back({informTime[i], i});
        }
        
        vector<bool>vis(n + 1, false); long long Max = -1;
        priority_queue<pair<long long, int>>pq; pq.push(pair<long long, int>(faCost, headID));
        vis[headID] = true;
        while(!pq.empty()) {
            pair<long long, int> now = pq.top(); pq.pop();
            if (G[now.second].size() == 0) {
                Max = max(Max, now.first);
                continue;
            }
            for (int i = 0; i < G[now.second].size(); i ++) {
                if (!vis[G[now.second][i].second]) {
                    vis[G[now.second][i].second] = true;
                    pq.push(pair<long long, int>(now.first + G[now.second][i].first, G[now.second][i].second));
                }
            }
        }
        return (int)Max;
    }
};

5355. T 秒后青蛙的位置(bfs、dfs)

  直接使用 $vector$ 建一个图出来，然后进行 $dfs$ ，如果到达目标点时间并且时间已经使用完了，此时可以返回一个概率；或者时间还没有使用完，但是已经到达目标点并且目标点是叶子结节，这时候只能在原地停留等待时间结束，此时也可以有一个概率值，其他的情况概率值都是零(无法到达目的地)。此题需要注意初始化问题。

//dfs
class Solution {
public:

    double dfs(int u, int fa, int t, int target, vector<vector<int>>& G) {
        int len = G[u].size();
        if (!t || (fa && len == 1)) {//没有时间，或者走到根结点不能在走了
            return u == target ? 1.0 : 0.0;
        }
        double p = 1.0 / (fa ? len - 1 : len);//根结点没有父亲，其他节点要把父亲删除
        double pp = 0.0;
        for (int i = 0; i < len; i ++) {
            int v = G[u][i];
            if (v == fa) continue;
            pp = max(pp, dfs(v, u, t - 1, target, G));
        }
        return p * pp;
    }
    double frogPosition(int n, vector<vector<int>>& edges, int t, int target) {
        if (n == 1) return 1.0;
        vector<vector<int>> G(n + 10);
        for (int i = 0; i < n - 1; i ++) {
            G[edges[i][0]].push_back(edges[i][1]);
            G[edges[i][1]].push_back(edges[i][0]);
        }
        return dfs(1, 0, t, target, G);
    }
};

//bfs
class Solution {
public:

    struct Node {
        int to, t;
        double p;
        Node(){}
        Node(int to, int t, double p) : to(to), t(t), p(p) {};
    };

    double bfs(int n, int s, int t, int target, vector<vector<int>>& G) {
        //return t;
        vector<bool>vis(n + 10);
        queue<Node>q; q.push(Node(s, 0, 1.0)); vis[s] = true;
        while (!q.empty()) {
            Node now = q.front(); q.pop();
            int len = G[now.to].size();
            //if (now.to == target) return now.t;
            if (now.t == t || (len == 1 && vis[G[now.to][0]] && now.t < t)) { 
            //时间刚好用完，或者时间还没有用完但是到达了目标点
                if (now.to == target) return now.p;
            }
            for (int i = 0; i < len; i ++) {
                int v = G[now.to][i];
                if (!vis[v]) {
                    vis[v] = true;
                    double pp = 1.0 / (now.to == 1 ? len : len - 1);
                    //return pp * now.p;
                    q.push(Node(v, now.t + 1, now.p * pp));
                }
            }
        }
        return 0.0;
    }

    double frogPosition(int n, vector<vector<int>>& edges, int t, int target) {
        if (n == 1) return 1.0;
        vector<vector<int>> G(n + 10);
        for (int i = 0; i < n - 1; i ++) {
            G[edges[i][0]].push_back(edges[i][1]);
            G[edges[i][1]].push_back(edges[i][0]);
        }
        return bfs(n, 1, t, target, G);
    }
};