Weekly Contest 179

1374. Generate a String With Characters That Have Odd Counts

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

    }
};

1375. Bulb Switcher III

class Solution {
public:
    int numTimesAllBlue(vector<int>& light) {
        vector<int> preLight(light.size(), 0);
        int maxLight{-1}, lightNum{0}, result{0};
        for(int i = 0; i < light.size(); i++){
            preLight[light[i] - 1] = 1;
            lightNum++;
            if(maxLight + 1 == light[i] - 1){
                for(int i = maxLight + 1; i < light.size(); i++){
                    if(preLight[i] == 1){
                        maxLight = i;
                    }else{
                        break;
                    }
                }
            }
            if(maxLight + 1 == lightNum)
                result++;
        }
        return result; 
    }
};

1376. Time Needed to Inform All Employees

class Solution {
public:
    int minuToOne(int i, vector<int>& manager, vector<int>& informTime, vector<int>& onesMinu){
        if(manager[i] == -1)
            return 0;
        if(onesMinu[i] != -1)
            return onesMinu[i];
        onesMinu[i] = minuToOne(manager[i], manager, informTime, onesMinu) + informTime[manager[i]];
        return onesMinu[i];
    }
    int numOfMinutes(int n, int headID, vector<int>& manager, vector<int>& informTime) {
        vector<int> onesMinu(manager.size(), -1);
        int maxTimes = 0;
        for(int i = 0;i < manager.size(); i++){
            maxTimes = max(maxTimes, minuToOne(i, manager, informTime, onesMinu));
        }
        return maxTimes;
    }
};

1377. Frog Position After T Seconds

struct node
{
    vector<int> child;
    double probability;
    node(){probability = 0;};
};


class Solution {
public:
    double frogPosition(int n, vector<vector<int>>& edges, int t, int target) {
        vector<node> nodes(n + 1);
        vector<int> visited(n + 1, 0);
        queue<node *> nodesQueue;
        for(int i = 0; i < edges.size(); i++){
            nodes[edges[i][0]].child.push_back(edges[i][1]);
            nodes[edges[i][1]].child.push_back(edges[i][0]);  
        }
        nodes[1].probability = 1.0;
        nodesQueue.push(&nodes[1]);
        visited[1] = 1;
        for(int tt = 0; tt < t; tt++){
            int size = nodesQueue.size();
            for(int i = 0; i < size; i++){
                node *p =  nodesQueue.front();
                int childSize = 0;
                for(int i = 0; i < p->child.size(); i++){
                    if(visited[p->child[i]] == 0)
                        childSize++;
                }
                for(int i = 0; i < p->child.size(); i++){
                    if(visited[p->child[i]] == 0){
                        nodes[p->child[i]].probability = p->probability / childSize;
                        nodesQueue.push(&nodes[p->child[i]]);
                        visited[p->child[i]] = 1;
                    }
                }
                if(childSize)
                    p->probability = 0;
                nodesQueue.pop();
            }
        }
        return nodes[target].probability;
    }
};