2022 NOI Online 游记 + 赛后复盘

人生中 第一场OI全国大赛

感觉还不错 虽然结果一般（还没出成绩 估分很低）

但也毕竟是个“练兵”

是为了日后在比赛中取得更好的成绩

打好基础 埋下伏笔

8:30开始

8:27左右就能进了

 

 

T1

丹钓战

谐音梗是要扣钱的（bushi

正巧了 25号老师刚带我们练了一套题 第一题就是用单调栈去写的矩阵题 一眼就看出来了谐音

（然鹅某条金鱼并没有get到谐音的点并以丹钓战为题脑嗨了一万三千字的唯美故事）

看了一会 N能达到5e5 感觉要写线段树

线段树打了1个多小时 打不出来 没办法 直接转暴力 15pts

 

复盘：

受到启发：区间 ——> 莫队

写了个莫队  

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cmath>
using namespace std;
#define int long long
const int N = 5e5 + 5;
inline int read(){
    int s = 0,w = 1;
    char ch = getchar();
    while(ch<'0'||ch>'9'){
        if(ch=='-')w = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') s = s * 10 + ch - '0',ch = getchar();
    return s * w;
}
inline void write(int x){
    static char buf[16];
    static int len = -1;
    if(x < 0) putchar('-'),x = -x;
    do buf[++ len] = x % 10,x /= 10;
    while(x);
    while(len >= 0) putchar(buf[len --] + '0');
    putchar('\n');
}
struct A{
    int l;
    int r;
    int num;
}q[N];
int n,Q;
int a[N];
int b[N];
int rcd[N] = {0,0};
int ans[N];
int pos[N];
int nw = 1;
class CHK{
public:
    inline void Add_L(){
        l--;
        vis[rcd[l]]++;
        sum++;
        sum -= vis[l];
    }
    inline void Sub_L(){
        vis[rcd[l]]--;
        sum--;
        sum += vis[l];
        l++;
    }
    inline void Add_R(){
        r++;
        vis[rcd[r]]++;
        sum += (rcd[r] < l);
    }
    inline void Sub_R(){
        vis[rcd[r]]--;
        sum -= (rcd[r] < l);
        r--;
    }
    inline int L(){
        return l;
    }
    inline int R(){
        return r;
    }
    inline int Sum_(){
        return sum;
    }
private:
    int vis[N];
    int l = 1,r = 0;
    int sum = 0;
};
CHK Stack_;//最近迷上了class
signed main(){
    n = read();
    Q = read();
    int siz = sqrt(n);
    for(register int i = 1;i <= n;i++) a[i] = read();
    for(register int i = 1;i <= n;i++) b[i] = read();
    for (register int i = 2;i <= n;i ++,nw = i - 1){
        while(nw){
            if (a[i] == a[nw] || b[i] >= b[nw]) nw = rcd[nw];
            else break;
        }
        rcd[i] = nw;
    }
    for(register int i = 1;i<=Q;i ++){
        q[i].l = read();
        q[i].r = read();
        q[i].num = i;
        pos[i] = (q[i].l - 1)/(siz + 1);//收到大佬启发；i/siz只能过60pts
    }
    sort(q + 1,q + 1 + Q,[](A a,A b){return pos[a.num] != pos[b.num]?a.l < b.l : ((pos[a.num] & 1) ? a.r < b.r : a.r > b.r);});//在B站学到的高级cmp写法
    for(register int i = 1;i<=Q;i ++){
        while(q[i].l < Stack_.L()) Stack_.Add_L();
        while(q[i].r > Stack_.R()) Stack_.Add_R();
        while(q[i].l > Stack_.L()) Stack_.Sub_L();
        while(q[i].r < Stack_.R()) Stack_.Sub_R();
        ans[q[i].num] = Stack_.Sum_();
    }
    for(register int i = 1;i<=Q;i ++) write(ans[i]);
    return 0;
}

 

T2

讨论

乍一看以为是图论

若该点入度大于2 则被两个以上的人会 即被两个以上的点所指向 那就查这些点的出度 出度>2则可能有不会的题 为了控复杂度 用string去存每个人会的题 s.find（）找包含（事实证明这是一种很扯淡的做法）

这样存图 每个人的编号既是一个人 也是一道题 一举两得

但是肯定是什么地方写的不对 访问溢出 全 RE 

 

复盘：

从头开始推

如果一个人参与了讨论，则它必然会与另一个人有同样会的题目；

按会的题量降序排序，若上下两人有共同的题目，上面的人会的题数>下面的人，所以一定会有下面不会的题；

则只需判断下面的人是否有上面的人不会的题即可；

与记入度同理 记录每道题“被会”的数量 若数量 == 1，则它是只被当前的人会，属于新题；

若数量 >= 2,则对于当前的人来说，他与下面的那个人就不会这道题，则他俩是可以开始讨论的 

 

#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <limits.h>
using namespace std;
const int N = 5e5 +5;
inline int read(){
    int dp = 0,w = 1;
    char ch = getchar();
    while(ch<'0'||ch>'9'){
        if(ch=='-')w = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') dp = dp * 10 + ch - '0',ch = getchar();
    return dp * w;
}
inline void write(int x){
    static char buf[16];
    static int len = -1;
    if(x < 0) putchar('-'),x = -x;
    do buf[++ len] = x % 10,x /= 10;
    while(x);
    while(len >= 0) putchar(buf[len --] + '0');
    putchar('\n');
}
int T;
int n,p;
int x = -1,y = -1;
int t,v;
struct A{
    int pos;
    int num;
}ans[N];
int a[N];
int f[N];
int dp[N] = {0};
bool chk = 0;
int main() {
    T = read();
    while (T--) {
        chk = 0;
        memset(f,0,sizeof(f));
        n = read();
        for (register int i = 1; i <= n; i++) {
            ans[i].pos = i;
            ans[i].num = read();
            dp[i] = dp[i - 1] + ans[i].num;
            for (register int j = 1;j<=ans[i];j++) a[dp[i-1]+j] = read();
        }
        sort(ans + 1,ans + n + 1,[](A a,A b){return a.num > b.num;});
        for(register int i = 1;i<=n;i++,x = -1,y = -1){
            p = ans[i].pos;
            for(register int j = 1;j<=ans[p].num;j++){
                v = f[a[dp[p-1]+j]];
                if(!v) v = p;
                if(!x) x = v;
                else if(x != v) y = v;
                if(x != -1 && y != -1){
                    chk = 1;
                    ans[p].num = -INT_MAX;
                }
                f[a[dp[p-1]+j]] = p;
            }
        }
        if(chk) puts("NO"),cout<<endl;
        else{
            if(ans[x].num > ans[y].num) x = p;
            else y = p;
            puts("YES");
            cout<<endl;
            printf("%d %d\n",x,y);
        }
    }
    return 0;
}

 

 

T3

如何正确的去排序

考试的时候没有时间看了 暴力都没时间写 直接打表上样例 估计是保龄

 

复盘：

第一反应还是线段树

但是感觉线段树好麻烦

于是决定用树状数组

上了趟博客园 看了hbc大佬的博客 提醒我了

CDQ分治

老师之前在群里发过一个讲陈丹琦的文章 里面就提到了她的cdq分治

于是就去学了cdq分治

并引申到二维偏序三维偏序

才发现 原来丹钓战也是二维偏序

后来一直在推公式 直到发现m = 4时max（S4）可以被压掉 压回三维

去查了知道 这个东西叫反演

所以整个就是二维偏序+三维偏序（著名的陌上开花）+树状数组+cdq分治+反演（这个实在想不到）

（看到好多人还有写 离散化 容斥）

然后就 疯狂的  TLE  +  WA 

好在看到了一位大佬的博客

才知道位运算这么好用

还有处理双倍贡献

于是

终于

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <limits.h>
#include <cstring>
#include <cmath>
//整个代码是在第一次系的树状数组 + cqd + 三维偏序的基础上
//从大佬的代码中学习了好多降复杂度的写法 包括区域定义、快速位运算等等
//整个复杂度在O(nlog2n)左右
#define MOR 996655884
#define lowbit(x) x & -x
#define int long long
using namespace std;
const int N = 5e5 + 5;
int n,m;
int a[5][N];
inline int read(){
    int s = 0,w = 1;
    char ch = getchar();
    while(ch<'0'||ch>'9'){
        if(ch=='-')w = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9') s = s * 10 + ch - '0',ch = getchar();
    return s * w;
}
inline void write(int x) {
    static char buf[16];
    static int len = -1;
    if(x < 0) putchar('-'),x = -x;
    do buf[++len] = x % 10,x /= 10;
    while(x);
    while(len >= 0) putchar(buf[len--] + '0');
    putchar('\n');
}
const int INF_ = 2e5;
struct A{
    int rcd[4];
    int p;
    int res;
    friend bool operator < (const A &a,const A &b);
};
inline bool operator < (const A a, const A b){
    for(register int i = 0;i < 3;i++) if(a.rcd[i] ^ b.rcd[i]) return a.rcd[i] < b.rcd[i];
    return a.p < b.p;
}//看了大佬的处理方式 重载运算符
//原先只从一维重定义rcd，m == 4的时候就全失效了
class C{
private:
    int s[N*2];
    A t[N*2];
    int res = 0;
public:
    inline void modify(int x,int y){
        for(x += INF_; x < INF_ << 1; x += lowbit(x)) s[x] += y;
    }
    inline int query(int x){
        res = 0;
        for(x += INF_; x; x -= lowbit(x)) res += s[x];
        return res;
    }
    void cdq(int l,int r,A *f){
        if(l == r) return;
        /*if(l < r) return;*/
        int mid = l + r >> 1;
        cdq(l,mid,f);
        cdq(mid + 1,r,f);//二分
        static A t[N*2];//这步真的好重要
        int h = 0;
        for(register int i = l,j = mid + 1;(i <= mid) || (j <= r);)
            if(i <= mid && (j > r || f[i].rcd[1] <= f[j].rcd[1])){
                f[i].p == -1 && (modify(f[i].rcd[2],1),0);//位运算压时间真的超好用
                t[h] = f[i];
                h++,i++;
            }
            else{
                if (j <= r && (i > mid || f[i].rcd[1] > f[j].rcd[1])) {
                    ~f[j].p && (f[j].res += query(f[j].rcd[2]));
                    t[h] = f[j];
                    h++,j++;
                }
            }
        for(register int i = l;i <= mid;i++) f[i].p == -1 && (modify(f[i].rcd[2],-1),0);
        int k = 0;
        for(register int i = l;i <= r;i++){
            f[i] = t[k];
            k++;
        }
    }
    inline int work(int n,int k,A *f){
        sort(f + 0,f + n,[](A a,A b){for(register int i = 0;i < 3;i++)if(a.rcd[i] ^ b.rcd[i])return a.rcd[i] < b.rcd[i];return a.p < b.p;});
        cdq(0,n - 1,f);//从头开始 从第一位开始 向下分治
        res = 0;
        for(register int i = 0;i < n;i++){
            ~f[i].p && (res += a[k][f[i].p] * f[i].res);//'～'第一次用 反演
            f[i].res = 0;
        }
        return res;
    }
};
C cdq;
inline int solve(){
    int res = 0,h = 0;
    static A f[N];//这步真的好重要
    for(register int i = 0;i < m;i++,h = 0){
        for(register int k = 0; k < n; k++){
            f[h].p = -1;
            h++;
            for(register int j = 0,p = 0;j < m;j++){
                if(j == i) continue;
                f[h].rcd[p] = a[i][k] - a[j][k];
                f[h ^ 1].rcd[p] = a[j][k] - a[i][k] + (j < i);//这步第一次写的的时候用了两个if - else 有好多重复贡献 会耽误掉很多时间
                p++;
            }
            f[h].p = k;
            h++;
        }
        res += cdq.work(h,i,f);
    }
    return res;
}
signed main(){
    m = read();
    n = read();
    for(register int i = 0;i < m;i++) for(register int j = 0;j < n;j++) a[i][j] = read();
    int res = solve();
    for(register int i = 0;i < m;i++) for(register int j = 0;j < n;j++) a[i][j] *= -1;
    int ans = res - solve() << 1;
    write(ans);
    return 0;
}

 

Generally：

我就是那个考试连暴力都没时间写的蒟蒻

加油吧 小伙子

24OI Fighting！