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);
    }
};