暑假N天乐【比赛篇】 —— 2019牛客暑期多校训练营（第三场）

这场相对来说友好一点，本来前几天就补差不多了，然后忘记发了...

以下题解包括：\(A \ \ \ B \ \ \ F \ \ \ G \ \ \ H \ \ \ J\)

\(D\) 题队友补了，我也懒得想数学公式题，所以就请移步别的题解了。

比赛地址： https://ac.nowcoder.com/acm/contest/883#question

【A】 Graph Games 分块+随机化

给定 \(n\) 个点和 \(m\) 条边，定义 \(S(x)\) 是和 \(x\) 点邻接的所有点的集合。进行 \(q\) 次操作，分为两种：

• 翻转 \([l,r]\) 区间里边的状态，存在-->删边、不存在-->加边
• 询问 \(S(u)\) 是否等于 \(S(v)\)

其中 \(n \leq 1e^5 \ \ m \leq 2e^5 \ \ q \leq 2e^5\)。

由于需要满足整个邻接的集合都相同，如果每个点进行核对，这个复杂度就已经炸了。于是考虑给每一个点赋上一个随机数，利用随机数的异或进行判断是否集合相同，可以证明（大概）不会出现冲突的情况。

又因为区间巨大，需要利用分块的操作来降低复杂度，对于块内更新就直接更新即可；对于块间更新，那么就需要用到 \(lazy\) 标记，用 \(lazy == 1\) 表示当前块内需要被考虑。\(sum\) 数组存储每块里每个点待更新的权值，\(s\) 数组存储每个点单点更新的值即可。

建议配合代码理解。

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <bitset>
#include <cctype>
#include <cstdio>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <numeric>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;

const int maxn = 2e5+5;
const int sqrtn = 5e2+5;

int n, m;
int num;
int block;
int u[maxn];
int v[maxn];
int val[maxn];      // 随机权值（大概可以保证异或值不发生冲突【重复】）
int belong[maxn];
int l[sqrtn];
int r[sqrtn];
int lazy[sqrtn];    // 整块翻转标记
ll s[maxn];         // 每个点的异或值
ll sum[sqrtn][maxn];// 每块里每个点待更新的权值

void build() {      // 分块建立
    block = sqrt(m);
    num = m / block;
    if(m % block != 0) {
        num ++;
    }
    for(int i = 1; i <= num; i++) {
        l[i] = (i-1)*block + 1;
        r[i] = i*block;
        lazy[i] = 1;    // 初始赋值 1 代表当前块可以使用
        for(int j = 1; j <= n; j++) {
            sum[i][j] = 0;
        }
    }
    r[num] = m;
    for(int i = 1; i <= m; i++) {
        belong[i] = (i-1)/block+1;
    }
    for(int i = 1; i <= n; i++) {
        s[i] = 0;
    }
}

void update(int l, int r) {     // 分块更新
    if(belong[l] == belong[r]) {
        for(int i = l; i <= r; i++) {
            s[u[i]] ^= val[v[i]];
            s[v[i]] ^= val[u[i]];
        }
        return ;
    }
    for(int i = l; belong[i] == belong[l]; i++) {
        s[u[i]] ^= val[v[i]];
        s[v[i]] ^= val[u[i]];
    }
    for(int i = r; belong[i] == belong[r]; i--) {
        s[u[i]] ^= val[v[i]];
        s[v[i]] ^= val[u[i]];
    }
    for(int i = belong[l]+1; i < belong[r]; i++) {
        lazy[i] ^= 1;   // 翻转
    }
}

int main() {
    srand(time(NULL));
    for(int i = 0; i < maxn; i++) {
        // 每个点赋予随机权值，加点删点都是异或操作
        val[i] = rand() + 1;
    }
    int t;
    scanf("%d", &t);
    while(t--) {
        scanf("%d%d", &n, &m);
        build();    // 按 m 分块
        for(int i = 1; i <= m; i++) {
            scanf("%d%d", &u[i], &v[i]);
            sum[belong[i]][u[i]] ^= val[v[i]];
            sum[belong[i]][v[i]] ^= val[u[i]];
        }
        int q;
        scanf("%d", &q);
        for(int i = 1; i <= q; i++) {
            int f, x, y;
            scanf("%d%d%d", &f, &x, &y);
            if(f == 1) {
                update(x, y);
            }
            else {
                ll ans1 = s[x];     // 单点的情况
                ll ans2 = s[y];
                for(int i = 1; i <= num; i++) { // 整块的情况
                    if(lazy[i]) {
                        ans1 ^= sum[i][x];
                        ans2 ^= sum[i][y];
                    }
                }
                if(ans1 == ans2) {
                    printf("1");
                }
                else {
                    printf("0");
                }
            }
        }
        printf("\n");
    }
    return 0;
}

【B】 Crazy Binary String 贪心

给定一个 \(01\) 串，分别选择一个最长的子串和子序列，使其中 \(0\) 和 \(1\) 的个数相同。

对于子序列来说显然就是区间内 \(min(sum_1, sum_0)\)；

对于子串来说需要维护前缀和，然后寻找第一次出现的相同值的位置。

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <bitset>
#include <cctype>
#include <cstdio>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <numeric>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;

const int maxn = 1e5+5;

char s[maxn];

map<int, int> mp;

int main() {
    int n;
    while(~scanf("%d", &n)) {
        scanf("%s", s+1);
        int a = 0, b;
        mp.clear();

        int x = 0, y = 0;

        int cnt = 0;
        for(int i = 1; i <= n; i++) {
            if(s[i] == '0') {
                x ++;
                cnt --;
                if(cnt == 0) {
                    a = max(a, i);
                    continue;
                }
                if(mp[cnt] == 0) {
                    mp[cnt] = i;
                    continue;
                }
                a = max(a, i-mp[cnt]);
                
            }
            else {
                y ++;
                cnt ++;
                if(cnt == 0) {
                    a = max(a, i);
                    continue;
                }
                if(mp[cnt] == 0) {
                    mp[cnt] = i;
                    continue;
                }
                a = max(a, i-mp[cnt]);               
                
            }
        }
        b = min(x, y) * 2;
        printf("%d %d\n", a, b);
    }
    return 0;
}

【F】 Planting Trees 单调队列

给定一个 \(n*n\) 的矩阵和每个点的权值 \(a_{ij}\)，要找到一个最大的矩形，使得矩形内部权值的最大值和最小值之差不超过 \(m\)。

需要定义两个单调队列，一个维护当前最大值，另一个维护最小值，然后...说起来太复杂了，代码看看就好。另外 \(deque\) 直接用的话我是 TLE 了，所以是手写。

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <bitset>
#include <cctype>
#include <cstdio>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <numeric>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
 
const int maxn = 5e2+5;
 
int cmax[maxn], cmin[maxn];     // 列最大最小值
int qmax[maxn*2], qmin[maxn*2]; // 单调队列（双端）
int a[maxn][maxn];
int l1, r1, l2, r2;
int ans, n, m;
 
int solve() {
    l1 = l2 = 0;
    r1 = r2 = 0;
    int x = 1;
    int temp = 0;
    memset(qmin, 0, sizeof(qmin));
    memset(qmax, 0, sizeof(qmax));
    for(int i = 1; i <= n; i++) {
        while(l1 < r1 && cmax[qmax[r1-1]] < cmax[i]) {
            r1--;
        }
        qmax[r1++] = i;
        while(l2 < r2 && cmin[qmin[r2-1]] > cmin[i]) {
            r2--;
        }
        qmin[r2++] = i;
        while(l1 < r1 && l2 < r2 && cmax[qmax[l1]] - cmin[qmin[l2]] > m && x <= i) {
            x = min(qmax[l1], qmin[l2])+1;
            if(qmax[l1] < qmin[l2]) {
                l1++;
            }
            else if(qmax[l1] > qmin[l2]) {
                l2++;
            }
            else {
                l1++;
                l2++;
            }
        }
        temp = max(temp, i-x+1);
    }
    return temp;
}
 
int main() {
    int t;
    scanf("%d", &t);
    while(t--) {
        ans = 0;
        scanf("%d%d", &n, &m);
        for(int i = 1; i <= n; i ++) {
            for(int j = 1; j <= n; j++) {
                scanf("%d", &a[i][j]);
            }
        }
        for(int i = 1; i <= n; i++) {
            for(int k = 1; k <= n; k++) {
                cmax[k] = 0;
                cmin[k] = inf;
            }
            for(int j = i; j <= n; j++) {
                for(int k = 1; k <= n; k++) {
                    cmax[k] = max(cmax[k], a[j][k]);
                    cmin[k] = min(cmin[k], a[j][k]);
                }
                ans = max(ans, solve()*(j-i+1));
            }
        }
        printf("%d\n", ans);
    }
    return 0;
}

【G】 Removing Stones RMQ+二分

给定 \(n\) 堆石头，每次可以选择两堆非空的各取走一个石头，如果最后能取光它就能获胜。 问存在多少个区间 \([l,r]\)，满足必胜空间的定义。另外，如果区间内石头总数是奇数，那么就先去掉个数最小的一堆的一个石头。

游戏必胜的条件：区间的石头总数和 \(sum\) >= 两倍的区间最大值 \(max\)。
那么先利用 \(RMQ\) 就可以求出区间最值，然后把区间的贡献都算在区间中拥有最大数量石头的那堆上，先处理出一个石头的管辖边界 \([l,r]\)，然后枚举一边，二分找另一边。

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <bitset>
#include <cctype>
#include <cstdio>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <numeric>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;

const int maxn = 300000+5;

int dp_max[maxn][25];   // 维护区间最大值
int pos[maxn][25];      // 维护区间最大值的位置
int a[maxn];
int n;
ll sum_f[maxn];         // 前缀和
ll sum_b[maxn];         // 后缀和

void RMQ() {
    for(int i = 1; i <= n; i++) {
        dp_max[i][0] = a[i];
        pos[i][0] = i;
    }
    for(int j = 1; (1<<j) <= n; j++) {
        for(int i = 1; i+(1<<j)-1 <= n; i++) {
            if(dp_max[i][j-1] >= dp_max[i+(1<<(j-1))][j-1]) {
                dp_max[i][j] = dp_max[i][j-1];
                pos[i][j] = pos[i][j-1];
            }
            else {
                dp_max[i][j] = dp_max[i+(1<<(j-1))][j-1];
                pos[i][j] = pos[i+(1<<(j-1))][j-1];
            }

        }
    }
}

int query_pos(int l, int r) {   // 查询区间最值所在位置
    int k = log2(r-l+1);
    if(dp_max[l][k] >= dp_max[r-(1<<k)+1][k]) {
        return pos[l][k];
    }
    return pos[r-(1<<k)+1][k];
}

ll solve(int l, int r) {
    if(l >= r) {
        return 0;
    }
    int p = query_pos(l, r);    // 区间最值位置
    // printf("l == %d  r == %d  p == %d\n", l, r, p);
    ll ans = 0;
    if(p-l < r-p) {     // 更靠近左端点
        for(int i = l; i <= p; i++) {
            ans += (r - (lower_bound(sum_f+p, sum_f+r+1, sum_f[i-1]+2*a[p])-(sum_f+1)));
            // 区间和必须 >= 二倍区间最大值【条件x】
            // 对答案的贡献 == (右端点位置 - 满足条件的最左端【满足条件x】)
        }
    }
    else {
        for(int i = p; i <= r; i++) {
            ans += ((n-l+1) - (lower_bound(sum_b+(n-p+1), sum_b+(n-l+1)+1, sum_b[n-i]+2*a[p])-(sum_b+1)));
            // 后缀是反着存的，所以处理时也是反着
        }
    }
    return ans + solve(l, p-1) + solve(p+1, r);
}

int main() {
    int t;
    scanf("%d", &t);
    while(t--) {
        scanf("%d", &n);
        sum_f[0] = sum_b[0] = 0;
        for(int i = 1; i <= n; i++) {
            scanf("%d", &a[i]);
            sum_f[i] = sum_f[i-1] + a[i];
        }
        for(int i = 1; i <= n; i++) {
            sum_b[i] = sum_b[i-1] + a[n-i+1];
        }
        RMQ();
        printf("%lld\n", solve(1, n));
    }
    return 0;
}

【H】 Magic Line 数学

给定二维平面上的 \(n\) （偶数）个点，需要画一条直线将这 n 个点平均分成两块，输出该直线上的任意两点坐标（整数）。

题解上是直接双关键字排序就能 AC，比赛时候想的还是有点太多了，我的解法是先找一个在第三象限的点【离得相当远】，然后以这个点为“ \(p\) 点”进行极角排序，然后取排序为“中点”的点和 \(p\) 点连线取另一端，然后再横坐标 -1 即可（保证不和“中点”相交）。

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <bitset>
#include <cctype>
#include <cstdio>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <numeric>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
 
const int maxn = 1e5+5;
 
struct node {
    ll x, y;   
}p[maxn];
 
ll jud(node p1, node p2, node p0) {
    ll ans = (p1.x-p0.x)*(p2.y-p0.y) - (p2.x-p0.x)*(p1.y-p0.y);
    return ans;
}
 
bool cmp(node a, node b) {
    ll c = jud(node{-100000000, -10000}, b, a);
    return c < 0;
}
 
int main() {
    int t;
    scanf("%d", &t);
    while(t--) {
        int n;
        scanf("%d", &n);
        for(int i = 1; i <= n; i++) {
            scanf("%lld%lld", &p[i].x, &p[i].y);
        }
        sort(p+1, p+1+n, cmp);
        ll x = p[n/2].x;
        ll y = p[n/2].y;
        ll xx = 2*x + 100000000;
        ll yy = 2*y + 10000;
        printf("-100000000 -10000 %lld %lld\n", xx-1, yy);
    }
    return 0;
}

【J】 LRU management 模拟

模拟 LRU 算法：

• 添加一个 \(block\) 到缓存中，如果已经存在，将它移到末尾
• 询问一个 \(block\) 是否在缓存中，如果存在，则输出它的前驱（-1）或者它本身（0）或者它的后继（1）的数据

需要和队友一起写的大模拟，就很烦。【直接用 字符串 会tle（怎么搞都过不了那种），所以需要转化成数字】。

牛客评测姬祖传 TLE，只要你试得够多次，必定能AC。

#include <map>
#include <set>
#include <list>
#include <cmath>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <bitset>
#include <cctype>
#include <cstdio>
#include <vector>
#include <string>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <numeric>
#include <iostream>
#include <algorithm>
#include <unordered_map>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double PI = acos(-1.0);
const double eps = 1e-6;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;

struct node {
    int pos;
    ll name;
    int val;
    bool operator < (const node &x) const {
        return pos < x.pos;
    }
};

set<node> SS;
unordered_map<ll, int> vis;

int main() {
    int t;
    scanf("%d", &t);
    while(t--) {
        SS.clear();
        vis.clear();
        int q, m;
        scanf("%d%d", &q, &m);
        int tot = 0;
        while(q--) {
            int op, v;
            char x[15];
            scanf("%d%s%d", &op, x, &v);
            int l = strlen(x);
            ll s = 0;
            for(int i = 0; i < l; i++) {
                s =  s*11+x[i]-'0';
            }
            if(op == 0) {
                if(vis[s] == 0) {
                    if(SS.size() == m) {
                        vis[SS.begin()->name] = 0;
                        SS.erase(SS.begin());
                    }
                    SS.insert(node{++tot, s, v});
                    vis[s] = tot;
                    printf("%d\n", v);
                }
                else {
                    auto it = SS.lower_bound(node{vis[s], 0, 0});
                    node temp = *it;
                    SS.erase(it);
                    temp.pos = ++tot;
                    SS.insert(temp);
                    vis[s] = tot;
                    printf("%d\n", temp.val);
                }
            }
            else if(op == 1){
                if(vis[s] == 0) {
                    printf("Invalid\n");
                }
                else {
                    auto it = SS.lower_bound(node{vis[s], 0, 0});
                    if(v == 0) {
                        printf("%d\n", (*it).val);
                    }
                    else if(v == 1) {
                        it++;
                        if(it == SS.end()) {
                            printf("Invalid\n");
                        }
                        else {
                            printf("%d\n", (*it).val);
                        }
                    }
                    else if(v == -1){
                        if(it == SS.begin()) {
                            printf("Invalid\n");
                        }
                        else {
                            it--;
                            printf("%d\n", (*it).val);
                        }
                    }
                }
            }   
        }
    }
    return 0;
}