力扣75双周赛

看电影入了迷，十一点才想起来有双周赛。。只写了两个题

T1

就是比较二进制的表示下每一位的不相同的个数和

class Solution {
public:
    int minBitFlips(int start, int goal) {
        int res = 0;
        for(int i = 0; i < 32; ++ i)
        {
            int x = (start >> i) & 1;
            int y = (goal >> i) & 1;
            if(x ^ y) res ++;
        }
        return res;
    }
};

T2

观察到每次都是将数组的元素整体向前面移一位（带上求和的加法）

用到滚动变量的思想即可

class Solution {
public:
    int triangularSum(vector<int>& nums) {
        int n = nums.size();
        vector<int> t = nums; //滚动变量
        for(int i = n - 2; i >= 0; -- i) //n-1次求和
        {
            for(int j = i; j >= 0; -- j) 
                t[j] = (nums[j] + nums[j + 1]) % 10;
            nums = t;
        }
        return t[0];
    }
};

T3

没写出来。我一开始的想法如下：可以将数组分为一块块的 0、1 区域，和是所有的区域组合结果相加。

没有将这个时间复杂度极高的想法用前缀和思想表示出来是这题没有写出来的关键。

这里模拟一下如果又碰到这个情况要怎样处理。

我已将暴力枚举的想法写出来了，发现时间过高，仔细观察我的式子后发现可以将分块求和优化成固定某一个块，寻找它两边不一样性质块的数量总和。

那为什么我没有想出来前缀和优化呢？还是对前缀和的印象太古板了，我对前缀和的固有认知是快速查询一个连续区段的和，但是连续放到两个性质不同的类别里面是可以通过额外空间实现前缀和的。

typedef long long LL;
const int N = 1e5 + 5;
class Solution {
public:
    int a[N], b[N];
    long long numberOfWays(string s) {
        int n = s.size();
        if(s[0] == '0') a[0] = 1;
        else b[0] = 1;

        for(int i = 1; i < n; ++ i)
        {
            a[i] = a[i - 1] + (s[i] == '0');
            b[i] = b[i - 1] + (s[i] == '1');
        }

        //对每个数字 它左右有多少个 0或1 即可
        LL res = 0;
        for(int i = 1; i < n - 1; ++ i)
        {
            LL t;
            if(s[i] == '0') //两边的1有多少
            {
                t = b[i - 1] * (b[n - 1] - b[i]);
            }
            else //两边的0有多少
            {
                t = a[i - 1] * (a[n - 1] - a[i]);
            }
            res += t;
        }
        return res;
    }
};

T4

看了题解区后我对二分的认识进一步加深了。

为什么这个问题能够二分？二分的适用范围是答案有明显的二段性，即有一个点作为分界点。

回到这个问题，某一个字符串要么符合完全相同、要么不完全相同。辅以字符串哈希用来快速查询某两个字符串是否相等。

typedef long long ll;
typedef unsigned long long ull;
class Solution {
const static int N = 1e5 + 5;
ull p[N], pre[N]; //p记录进制数 pre记录哈希字符的值
const int M = 13331;
public:
    long long sumScores(string s) {
        ll res = 0;
        int n = s.size();
        p[0] = 1;

        for(int i = 1; i <= n; ++ i)
        {
            p[i] = p[i-1] * M; //快速查询进制数
            pre[i] = pre[i-1] * M + s[i - 1]; //哈希函数
        }

        for(int i = 1; i <= n; ++ i) //长度
        {
            //判断父串的长度为i的前缀 和长度为i的后缀 的最长公共前缀
            //0, i - 1, n - i, n - 1
            int L = 0, R = i;
            while(L < R)
            {
                int mid = (L + R + 1) >> 1; //向上取整 防止出现-1的情况
                if(check(0, mid - 1, n - i, n - i - 1 + mid)) L = mid;
                else R = mid - 1;
            }
            res += L;
        }

        return res;
    }

    bool check(int x1, int y1, int x2, int y2)
    {
        ull t1, t2;

        t1 = pre[y1 + 1];
        t2 = pre[y2 + 1] - pre[x2] * p[y2 - x2 + 1];

        return t1 == t2;
    }
};