Codeforces Round #841 (Div. 2) and Divide by Zero 2022

《C. Even Subarrays》

异或和，前缀和

 

 这道题如果用朴素的暴露解法为O(n^2)，算出每一个子段的异或和，然后看一下这些异或和中哪个的除数是奇数个，但会超时

 

超时原因明显是因为我们要算出每一个子段的异或和；

 

在1~n的范围内的数进行异或和，其最大值不会超过2*n(因为2*n等价与n<<1)

 

 想一想在1~2*n的范围内，哪些数是除数为奇数？（即因子数为奇数）

　　我们知道如果一个数num，其有除数i,那么其必然有另一个除数num/i;

　　则除数必然是成对出现的，但是有例外：如果num/i==i，那么就对除数个数的贡献为1，而不是2了，这个时候这个数num，必然是除数是奇数个

 

然后在范围1~2*n，除数是奇数个的数，即开根号能够开出整数的数，最多有sqrt(2*n)个

 

然后该如何作，即要如何作才能避免O(n^2)地算出每一个子段的异或和？

　　正难则反，我们想一下如何找出不合法的子段个数，即子段异或和为奇数的个数，然后用总子段个数n*(n+1)/2,减去不合法的子段个数

　　　就是我们要求的除数是偶数的子段个数

 

但是不合法的子段个数如何找？

　　我们可以现算出异或和的前缀和

　　然后我们枚举有奇数个除数（因子）的数，假设这个数为t

　　在下标1~i中的是否有连续的子段的异或和为这个t;

　　办法就是利用num1^t=num2

　　num2是现在1~i异或和，t是1~i某段子段j~i的异或区间和，那么num1就是1~j-1的异或和

       看一下num1是否真的存在过,如果存在，说明t也存在过；

 

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef long long ll;
const int N = 2 * 1e5;
int maxn = 0, a[N], cnt[4 * N];
int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        int n;
        cin >> n;
        for (int i = 1; i <= n; i++)
        {
            int num;
            scanf("%d", &a[i]);
            a[i] ^= a[i - 1];
        }
        // 初始总共有ans个子段
        ll ans = (ll)n * (n + 1) / 2;
        // 其实a[0]就是0
        cnt[a[0]]++;
        for (int i = 1; i <= n; i++)
        {
            for (int j = 0; j * j <= 2 * n; j++)
            {
                // 这个t就是完全平方数,即有奇数个除数（因子）的数,注意0在题目中算有奇数个除数（因子）的数
                // 然后我现在就是像看一下:在下标1~i中的是否有连续的子段的异或和为这个t;
                // 办法就是利用num1^t=num2
                // num2是现在1~i异或和，t是1~i某段子段j~i的异或区间和
                // 那么num1就是1~j-1的异或和
                // 看一下num1是否真的存在过,如果存在，说明t也存在过；
                int t = j * j;
                ans -= cnt[(a[i] ^ t)];
            }
            cnt[a[i]]++;
        }
        cout << ans << endl;
        memset(cnt, 0, sizeof(cnt));
    }
    return 0;
}

这个还有要注意的地方：t范围是1~2*n,a[i]的范围是1~n，这两个相异或，值<=4*n ，所以cnt[]数组的下标范围开到4*n

否则会爆数组下标

 

《D. Valiant's New Map》

思维，二维前缀和

 这道题没啥难度，但是有个转化十分巧妙，否则作不出（除非会二维区间的最值维护（二维ST表或二维线段树））：

　　我们二分l的长度，O(log(min(n,m)))

　　然后如何判断出我们所框定的区间内的数每一个都大于l呢？

　　我们可以新开一个二维数组b,O（n*m）

　　b[i][j]=1,当原数组a[i][j]>=l ,否则b[i][j]=0

　　然后我们二维前缀和b,然后可以查看任意框内数的总和

　　我们看一下我们所框定的区间内数的总和sum，如何sum==l*l，说明这个框内原数组中每一个数都>=l

总时间O(1e6*log(min(n,m)))

#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
using namespace std;
const int N = 1e6 + 2;
int n, m;
　　//注意这里写法：
void init(vector<vector<int>> &b, vector<vector<int>> &pre, int x, vector<vector<int>> a)
{
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
        {
            if (a[i][j] >= x)
                b[i][j] = 1;
            else
                b[i][j] = 0;
        }
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= m; j++)
            pre[i][j] = pre[i - 1][j] + pre[i][j - 1] - pre[i - 1][j - 1] + b[i][j];
}
bool check(int x, vector<vector<int>> a)
{
    vector<vector<int>> b(n + 1, vector<int>(m + 1)), pre(n + 1, vector<int>(m + 1));
    init(b, pre, x, a);
    for (int i = 1; i + x - 1 <= n; i++)
    {
        for (int j = 1; j + x - 1 <= m; j++)
        {
            int sy = i, sx = j;
            int xy = i + x - 1, xx = j + x - 1;
            int sum = pre[xy][xx] - pre[xy][sx - 1] - pre[sy - 1][xx] + pre[sy - 1][sx - 1];
            if (sum >= x * x)
                return true;
        }
    }
    return false;
}
int main()
{
    int t;
    cin >> t;
    while (t--)
    {
        cin >> n >> m;
　　　　　　//注意这里初始化vector,默认每个数都是0，然后可以当做普通数组用，同时不要担心爆数组，十分好用
        vector<vector<int>> a(n + 1, vector<int>(m + 1));
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
            {
                int num;
                scanf("%d", &num);
                a[i][j] = num;
            }
        int l = 1, r = min(n, m), ans;
        while (l <= r)
        {
            int mid = (l + r) >> 1;
            if (check(mid, a))
            {
                l = mid + 1;
                ans = mid;
            }
            else
                r = mid - 1;
        }
        cout << ans << endl;
    }
    return 0;
}