LeetCode 第 121 场双周赛

LeetCode 第 121 场双周赛

大于等于顺序前缀和的最小缺失整数

代码:

class Solution {
public:
    int missingInteger(vector<int>& nums) {
        int n = nums.size();
        set<int> s;
        for(auto x : nums)
        {
            s.insert(x);
        }
        int cur = nums[0];
        for(int i = 1;i < n;i ++)
        {
            if(nums[i] == nums[i - 1] + 1)
            {
                cur += nums[i];
            }
            else
            {
                while(s.count(cur))
                {
                    cur ++;
                }
                return cur;
                break;
            }
        }
        while(s.count(cur))
        {
            cur ++;
        }
        return cur;
    }
};

使数组异或和等于 K 的最少操作次数

解题思路:

对于每个\(x\)有四种操作，对应四条边，\(bfs\)找到\(y\)的最小步数。

代码:

class Solution {
public:
    int minimumOperationsToMakeEqual(int x, int y) {
        int ans = 1e9;
        if(x <= y)
        {
            return y - x;
        }
        else
        {
            vector<int> d(2 * x + 1,1e9);
            vector<bool> st(2 * x + 1,false);
            queue<int> q;
            q.push(x);
            d[x] = 0;
            while(q.size())
            {
                auto u = q.front();
                q.pop();
                st[u] = true;
                int v = u - 1;
                d[v] = min(d[v],d[u] + 1);
                if(v == y)
                {
                    ans = d[v];
                    break;
                }
                if(v && !st[v])
                {
                    q.push(v);
                }
                v = u + 1;
                d[v] = min(d[v],d[u] + 1);
                if(v == y)
                {
                    ans = d[v];
                    break;
                }
                if(v && !st[v])
                {
                    q.push(v);
                }
                if(u % 11 == 0)
                {
                    v = u / 11;
                    d[v] = min(d[v],d[u] + 1);
                    if(v == y)
                    {
                        ans = d[v];
                        break;
                    }
                    if(v && !st[v])
                    {
                        q.push(v);
                    }
                }
                if(u % 5 == 0)
                {
                    v = u / 5;
                    d[v] = min(d[v],d[u] + 1);
                    if(v == y)
                    {
                        ans = d[v];
                        break;
                    }
                    if(v && !st[v])
                    {
                        q.push(v);
                    }
                }
            }
        }
        return ans;
    }   
};

使数组异或和等于 K 的最少操作次数

解题思路:

对于每个二进制位，如果当前数组异或和与\(k\)不同，则操作次数加一。

代码:

class Solution {
public:
    int minOperations(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> cnt(40),cur(40);
        for(int i = 0;i<30;i++)
        {
            cnt[i] = k >> i & 1;
        }
        for(int i = 0;i<n;i++)
        {
            for(int j = 0;j<30;j++)
            {
                cur[j] ^= nums[i] >> j & 1;
            }
        }
        int ans = 0;
        for(int i = 0;i < 30;i++)
        {
            if(cur[i] ^ cnt[i])
            {
                ans ++;
            }
        }
        return ans;
    }
};

统计强大整数的数目

解题思路:

数位\(dp\)。

当进入最后个固定数位后，我们只有一种选法。

对于数位上限的限制，在循环条件上判断，而不在递归条件中判断。

若将限制数位作为高位上限判断则会导致答案减少。

举例:

上界为9953,限制数位最大为\(7\)。

我们在枚举百位时枚举到了7，如果我们判断到达高位上限，那么接下来的十位我们最多枚举到5，即9753.

但9763很明显是存在的。

代码:

class Solution {
public:
    using ll = long long;
    vector<int> h = vector<int>(20,0);
    vector<int> l = vector<int>(20,0);
    vector<ll> f =vector<ll>(20,-1);


    long long numberOfPowerfulInt(long long start, long long finish, int limit, string s) {
        int len = 0;
        while(start)
        {
            l[++len] = start % 10;
            start /= 10;
        } 
        len = 0;  
        while(finish)
        {
            h[++len] = finish % 10;
            finish /= 10;
        }
        reverse(s.begin(),s.end());
        s = '0' + s;
        auto dfs =[&](auto self,int u,bool ll,bool hl) -> long long
        {
            if(u == 0)
            {
                return 1;
            }
            if(!ll && !hl && f[u] != -1)
            {
                return f[u];
            }
            int st = ll ? l[u] : 0;
            int ed = hl ? h[u] : 9;
            long long res = 0;
            if(u > s.size() - 1)
            {
                for(int i = st;i <= min(limit,ed);i ++)
                {
                    res += self(self,u - 1,ll && i == st,hl && i == ed);
                }
            }
            else
            {
                // return s.size();
                auto x = s[u] - '0';
                if(st <= x && min(limit,ed) >= x)
                {
                    res += self(self,u - 1,ll && x == st,hl && x == ed);
                }
                
            }
            if(!ll && !hl)
            {
                f[u] = res;
            }
            return res;
        };
        return dfs(dfs,len,true,true);
    }
};