Leet Code Weekly Contest 263

class Solution
{
public:
    bool isNum(string &s)
    {
        for (int i = 0; i < s.length(); i++)
        {
            if (s[i] < '0' || s[i] > '9')
            {
                return false;
            }
        }
        
        return true;
    }
    
    bool areNumbersAscending(string s)
    {
        int prev_num = 0;
        string current = "";
        
        for (int i = 0; i < s.length(); i++)
        {
            if (s[i] == ' ')
            {
                if (isNum(current))
                {
                    int num = stoi(current);
                    
                    if (prev_num != 0 && prev_num >= num)
                    {
                        return false;
                    }
                    
                    prev_num = num;
                }
                
                current = "";
            }
            else
            {
                current += s[i];
            }
        }
        
        if (isNum(current))
        {
            int num = stoi(current);

            if (prev_num != 0 && prev_num >= num)
            {
                return false;
            }
        }
        
        return true;
    }
};

class Bank
{
public:
    vector<long long> balances;
    
    Bank(vector<long long>& balance)
    {
        balances = vector<long long>(balance);
    }
    
    bool validAccount(int account)
    {
        return account >=1 && account <= balances.size();
    }
    
    bool transfer(int account1, int account2, long long money)
    {
        if (!validAccount(account1) || !validAccount(account2))
        {
            return false;
        }
        
        if (balances[account1 - 1] >= money)
        {
            balances[account1 - 1] -= money;
            balances[account2 - 1] += money;
            return true;
        }
        
        return false;
    }
    
    bool deposit(int account, long long money)
    {
        if (!validAccount(account))
        {
            return false;
        }
        
        balances[account - 1] += money;
        return true;
    }
    
    bool withdraw(int account, long long money)
    {
        if (!validAccount(account))
        {
            return false;
        }
        
        if (balances[account - 1] >= money)
        {
            balances[account - 1] -= money;
            return true;
        }
        
        return false;
    }
};

class Solution
{
public:
    int countMaxOrSubsets(vector<int>& nums)
    {
        map<int, int> cnt;
        
        int n = nums.size(), max_result = 0;
        
        for (int mask = 0; mask < (1 << n); mask++)
        {
            if (mask != 0)
            {
                int or_result = 0;
                
                for (int i = 0; i < n; i++)
                {
                    if (mask & (1 << i))
                    {
                        or_result |= nums[i];
                    }
                }
                
                if (cnt.find(or_result) == cnt.end())
                {
                    cnt[or_result] = 1;
                }
                else
                {
                    cnt[or_result]++;
                }
                
                max_result = max(or_result, max_result);
            }
        }
        
        return cnt[max_result];
    }
};

class Solution
{
public:
    vector<int> targets[10000];
    
    vector<int> dists[10000];
    bool visit[10000];
    
    queue<int> q;
    
    int leave_time(int t, int change)
    {
        int period = 2 * change;
        
        if (t % period < change)
        {
            return t;
        }
        
        return t - (t % period) + period;
    }
    
    bool is_diff(vector<int> &x, vector<int> &y)
    {
        if (x.size() != y.size())
        {
            return true;
        }
        
        for (int i = 0; i < x.size(); i++)
        {
            if (x[i] != y[i])
            {
                return true;
            }
        }
        
        return false;
    }
    
    void spfa(int n, int s, int t, int time, int change)
    {
        for (int i = 0; i < n; i++)
        {
            visit[i] = false;
        }
        
        dists[s].push_back(0);
        visit[s] = true;
        
        q.push(s);
        
        while (!q.empty())
        {
            int x = q.front(); q.pop();
            visit[x] = false;
            
            for (auto &y : targets[x])
            {
                for (auto &dist_x : dists[x])
                {
                    int arrive_time = leave_time(dist_x, change) + time;
                    
                    // Has this in y already.
                    if (find(dists[y].begin(), dists[y].end(), arrive_time) != dists[y].end())
                    {
                        continue;
                    }
                    
                    vector<int> prev_y_dists = vector<int>(dists[y]);
                    
                    dists[y].push_back(arrive_time);
                    
                    if (dists[y].size() > 2)
                    {
                        sort(dists[y].begin(), dists[y].end());
                        dists[y].pop_back();
                    }
                    
                    if (is_diff(dists[y], prev_y_dists))
                    {      
                        if (!visit[y])
                        {
                            q.push(y);
                            visit[y] = true;
                        }
                    }
                }
            }
        }
    }
    
    int secondMinimum(int n, vector<vector<int>>& edges, int time, int change)
    {
        for (auto &edge : edges)
        {
            int x = edge[0] - 1, y = edge[1] - 1;
            targets[x].push_back(y);
            targets[y].push_back(x);
        }
        
        spfa(n, 0, n - 1, time, change);
        
        return dists[n - 1][1];
    }
};