第263周赛

5902. 检查句子中的数字是否递增

思路：模拟

class Solution {
public:
    bool areNumbersAscending(string s) {
        int pre=-1;
        int cur=0;
        int n=s.size();
        for(int i=0;i<n;++i)
        {
            if(isdigit(s[i]))
            {
                cur=cur*10+s[i]-'0';
                if(i==n-1||!isdigit(s[i+1]))
                {
                    if(cur>pre)pre=cur;
                    else return false;
                    cur=0;
                }
            }
        }
        return true;
    }
};

时间复杂度 O(n)

空间复杂度 O(1)

5903. 简易银行系统

思路：模拟

class Bank {
public:
    Bank(vector<long long>& balance): accounts(balance) {

    }
    
    bool transfer(int account1, int account2, long long money) {
        if(account1-1<accounts.size()&&account2-1<accounts.size()&&accounts[account1-1]>=money){
            accounts[account1-1]-=money;
            accounts[account2-1]+=money;
            return true;
        }
        else{
            return false;
        }
    }
    
    bool deposit(int account, long long money) {
        if(account-1<accounts.size()){
            accounts[account-1]+=money;
            return true;
        }
        else
            return false;
    }
    
    bool withdraw(int account, long long money) {
        if(account-1<accounts.size()&&accounts[account-1]>=money){
            accounts[account-1]-=money;
            return true;
        }
        else
            return false;
    }
    
    vector<long long> accounts;
};

/**
 * Your Bank object will be instantiated and called as such:
 * Bank* obj = new Bank(balance);
 * bool param_1 = obj->transfer(account1,account2,money);
 * bool param_2 = obj->deposit(account,money);
 * bool param_3 = obj->withdraw(account,money);
 */

5904. 统计按位或能得到最大值的子集数目

思路：枚举

rc里面存的是按位或的结果result和不同非空子集的数目count，使用res记录最大按位或的结果

class Solution {
public:
    int countMaxOrSubsets(vector<int>& nums) {
        unordered_map<int,int> rc = {{0,1}};
        int res=0;
        for(auto n:nums){
            auto nrc = rc;
            for(auto [r,c]:rc){
                nrc[r|n]+=c;
                res=max(res,r|n);
            }
            rc=move(nrc);
        }
        return rc[res];
    }
};

时间复杂度 O(2ⁿ)

空间复杂度 O(1)

5905. 到达目的地的第二短时间

思路：bfs

最短路径考虑bfs解决，bfs队列存储2个信息：节点id, 到当前节点时间。

fast记录第一次遍历经过的点，second记录第二次遍历经过的点，首先创建邻接表，然后bfs遍历，如果遍历到n，判断如果是第一次遍历，设置first，如果不是，判断时间大于first，返回第二次遍历的时间。

如果next第一次没有遍历过，加入fast。

如果next第二次没有遍历过并且大于第一次遍历的时间，加入second

考虑红绿灯，如果(targetTime/change)%2==1,此时为红灯，需要等红灯，targetTime需要向上取整。

class Solution {
public:
        unordered_map<int,int> fast;
        unordered_map<int,int> second;
    int secondMinimum(int n, vector<vector<int>>& edges, int time, int change) {
        queue<pair<int,int>> Q;
        Q.push(make_pair(1,0));
        unordered_map<int,vector<int>> G;
        int first=-1;

        for(auto edge:edges){
            if(G.find(edge[0])==G.end()) G[edge[0]] = vector<int>(0);
            if(G.find(edge[1])==G.end()) G[edge[1]] = vector<int>(0);
            G[edge[0]].push_back(edge[1]);
            G[edge[1]].push_back(edge[0]);
        }

        while(!Q.empty()){
            pair<int,int> p=Q.front();
            Q.pop();
            int node = p.first;
            int curTime = p.second;
            for(auto next:G[node]){
                if(next==n){
                    if(first==-1)
                        first=curTime+time;
                    else{
                        if(curTime+time>first) return curTime+time;
                    }
                }
                int targetTime = curTime + time;
                if((targetTime / change)%2==1){
                    targetTime= (targetTime/change+1)*change;
                }
                if(fast.find(next)==fast.end()){
                    fast[next]=targetTime;
                    Q.push(make_pair(next,targetTime));
                    continue;
                }
                if(second.find(next)==second.end()&&fast[next]<targetTime){
                    second[next]=targetTime;
                    Q.push(make_pair(next,targetTime));
                    continue;
                }
            }
        }
        return -1;
    }
};

时间复杂度 O(m+n) m是经过的边数量，n是点数量

空间复杂度 O(m)