CSP考前总结

10.2

考试：

1.数位DP 或者找规律

2.SB题，扫一遍找最大最小即可

3.莫比乌斯反演

出题人相出个数论和数据结构的综合题，但是找不到NOIP级别的，没办法只能忍痛割爱出个莫比乌斯，话说回来，莫比乌斯要是会了，其他的应该也就会了……(吧

看这个操作 1 n d v

相当于 \(a[x] += v[\gcd(x,n)=d]\)

\(v[\gcd(x,n) = d] = v [\gcd(\frac{x}{d},\frac{n}{d})=1] = v\sum\limits_{k|\gcd(\frac{x}{d},\frac{n}{d})} \mu(k) = v\sum\limits_{k|\frac{x}{d},k|\frac{n}{d}} \mu(k)\)

\(=\sum\limits_{k|\frac{n}{d},kd|x} v\mu(k)\)

如果按照操作来说我们现在其实就是枚举了所有的 \(\frac{n}{d}\) 的约数 \(k\), 然后枚举所有 \(kd\) 的倍数，对应位置加上 \(v\mu(k)\) 就行了。 查询 \(O(1)\) 查询

但是这样修改的复杂度太大，查询的复杂度太低，不妨让修改的时候枚举约数，查询的时候也枚举约数。也即我们修改的时候,新开一个数组 \(f\)，枚举约数之后只让 \(kd\) 加上 \(v\mu(k)\) 查询的时候查询\(\sum\limits_{i=1}^n\sum\limits_{d|i} f(d)=\sum\limits_{d=1}^n f(d)\lfloor \frac{n}{d}\rfloor\)

后面的东西跟根号分块就行了，前面的东西始终是个区间和，单点修改区间求和，使用树状数组就可以了

时间复杂度$O（q\sqrt{l}\log l+ l \log l） $

4.代码：

int mu[N],prime[N],vis[N],cnt,tot,p[N],l,m,val[N];
void add(int x,int v){
    while(x<=l){
        val[x]+=v; x+=x&(-x);
    }
}
int ask(int pos){
    int sum=0;
    while(pos){
        sum+=val[pos];
        pos-=pos&(-pos);
    }
    return sum;
}
void yilin()
{
    mu[1]=1;
    for(int i=2;i<=200000;i++){
        if(!vis[i]){
            prime[++cnt]=i;
            mu[i]=-1;
        }
        for(int j=1;j<=cnt;j++){
            vis[i*prime[j]]=1;
            if(i%prime[j]==0){
                mu[i*prime[j]]=0;
                break;
            }
            mu[i*prime[j]]=-mu[i];
        }
    }
}
int main(){
    yilin();
    while(1){
        memset(val,0,sizeof(val));
        printf("Case #%lld:\n",++tot);
        l=read(); m=read();
        if(l==0 && m==0)break;
        for(int i=1;i<=m;i++){
            int opt,n,d,v; opt=read();
            if(opt==1){
                n=read(); d=read(); v=read();
                if(n%d!=0)continue;
                for(int k=1; k*k<=(n/d); k++)
                {
                    if((n/d)%k==0)add(k*d,v*mu[k]);
                    if(k*k!=n/d)add( d*( (n/d)/k ),v*mu[(n/d)/k]);
                }
            }
            else{
                x=read();
                int ans=0;
                for(int l=1,r;l<=x;l=r+1){
                    r=min(x,x / (x / l));
                    ans+=(x/l) * ((ask(r)-ask(l-1));
                }
                printf("5d\n",ans);
            }
        }
    }
}

5.裴蜀定理

\(ax+by=m\)有整数解时当且仅当m是\(gcd(a,b)\)的倍数。裴蜀等式有解时必然有无穷多个整数解，每组解x、y都称为裴蜀数，可用扩展欧几里得算法求得。

例如，12和42的最大公约数是6，则方程\(12x+42y=6​\)有解。事实上有(-3)×12 + 1×42 = 6及4×12 + (-1)×42 =6。特别来说，方程 ax+by=1 有整数解当且仅当整数a和b互素。

6.数论分块

整除分块快速处理：\(\huge\sum_{i=1}^{n}{\lfloor \frac{n}{i} \rfloor}\)

通过打表找规律，可以发现 特定块的\(\lfloor \frac{n}{i} \rfloor\)的值是相同的，假设起始位置为l,那么结束位置\(\lfloor \frac{n}{\lfloor \frac{n}{l}\rfloor} \rfloor\)

for(int l=1,r;l<=x;l=r+1){
            r=min(x,x / (x / l));
            ans+=(x/l) * ((ask(r)-ask(l-1));}

10.3

BZOJ 4879

对于每个点分三种情况

• 没走过这个点，有颜色，无解
• 走过这个点，有颜色，那么最早时刻在最后一次经过这个点之后
• 走过这个点，没颜色，那么最晚时刻在最后一次经过这个点之后

原问题变为了求最后一次经过某个点的时间

倒过来做变成第一次经过某个点的时间

一次操作无非就是横着擦一下或者竖着擦一下，先只考虑横着擦一下，我们把原图从上到下，从左到右编号，那么每次操作相当于把原序列中没有数字的部分都抹成某个数字，这个题就变成了BZOJ 疯狂的馒头，直接并查集找最右面的点就 OK 了

还有竖着的怎么半？分两次做，一次只做横着的，从上到下从左到右编号，一次只做竖着的从左到右从上到下编号，两次答案取交集就可以了

时间复杂度 \(O(\text{union-find-set})\)

即使你写的是 \(n\log n\) 也能通过测试数据，但是 \(set\) 模拟的做法大概率会 T

​ 可以用最小生成树，建边从0~n.

10.4

1.能量项链 考虑中间的十分，每种颜色值出现了两次我们可以在一种颜色出现第一次的时候 +1， 出现第二次的时候 -1，那么前缀和相等的一对点一定可以成为一对分割点 ，如果颜色出现了不止一次的话，+1，-1显然不行

所以我们可以每次加减一个不同的很大整数来避免重复。

2.动态规划，每次倒着扫就行

3.树剖加DP

​ 考虑这样一个问题，要怎么样的点才能满足三个点两两距离相等呢？

1、存在三个点有共同的 \(lca\)。

2、存在一个点，使得它到它两颗不同的子树种两点的距离为 \(d\) 且它存在 \(d\) 级祖先。

\(f(x,i)\) 表示以 \(x\) 为根的子树中，距离 \(x\) 为 \(i\) 的点数

\(g(x,i)\) 表示以 \(x\) 为根的子树中, 形如下图的的 \((a,b)\) 数量

其中 \(d\) 可以是任意值（说白了就是都考虑进去），或者说只要在上面街上一个长度为 \(i\) 的边就可以构成一个合法的三元组。

考虑转移，枚举 \(x\) 的下一个儿子 \(u\)

\(g(x,i) += f(x,i)\times f(u,i-1) + g(u,i+1)\)

\(f(x,i) += f(u,i-1)\)

4.线段树 [POI2015]KIN 看电影

10.5

1.旅行者和火把问题，首先贪心有两种方式，一种是每次最快的运一个人再回来，第二种是前两个人先过去，最快的送火把回来，然后两个最慢的过去，次快的再回来，这样是运两个人，动态规划维护这个贪心，设\(f[x]\)是从最后运到x位置的最小代价

第一种方案：\(a[1]+a[i]+f[i+1]\)
第二种方案：\(f[i+2]+a[1]+2*a[2]+a[i+1]\)

所以方程：\(f[i]=min(a[1]+a[i]+f[i+1],f[i+2]+a[1]+2*a[2]+a[i+1]);\)

注意特判，因为给出的按升序排列，所以当\(n<=2\)时直接输出\(a[n]\).

2.动态规划，

设\(g[l][r][i][j]\)为将l~r删至剩下的数的最小值为i,最大值为j,的最小代价。

\(f[l][r]\)为将l~r的序列全部删掉的最小总代价。

可以离散化一下

\(g[l][r][min(i,w[r])][max(j,w[r])]=g[l][r-1][i][j]\) 和前面的l~r-1放到一起删。

\(g[l][r][i][j]=min(g[l][r][i][j],g[l][k][i][j]+f[k+1][r])\) 和后面的k+1~r作为被包含子区间删去。

\(f[l][r]=g[l][r][i][j]+a+b*(j-i)^2\)

3.动态DP，

这个DP在树上进行，考虑轻重链剖分，设\(f[i]\)为以i 为跟的字数满足条件的最小总代价

\(f[i]=\text{min}(v[i],\sum\limits_{i\to j}f[j])\)

由于需要DDP，所以转化为

设y 为x的重儿子，x的所有轻儿子的f之和为g[x],则有\(f[x]=\text{min}(v[x],f[y]+g[x])\)

接下来可以用矩阵转移这个东西，每个叶子结点的代价已知

0 f[u] * 0 a[x] = 0 f[x]

​ \(\infty\) g[x]

第二行的转移结果不考虑

10.6

10.7

1.每次选三个，直接枚举所有情况，看哪个更优

2.概率DP

3.开一个bitset即可

代码：

#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<bitset>
#define N 10005
#define M 100005
using namespace std;
bitset<N> to[N];
bitset<N> vis,quan;
int f[N][N],a[N],n,m,ans=2147483647;
int main()
{
    n=read(); m=read();
    for(int i=1;i<=n;i++)quan[i]=1;
    for(int i=1;i<=n;i++)
    for(int j=1;j<=n;j++)f[i][j]=2147483647;
    int x,y,c;
    for(int i=1;i<=m;i++)
    {
        x=read();y=read();c=read();
        if(f[x][y]==2147483647)a[x]++;
        to[x][y]=1;
        f[x][y]=min(f[x][y],c);
    }
    int mx;
    for(int i=1;i<n;i++)
    for(int j=i;j<=n;j++)
    {
        mx=0;
        if(a[i]+a[j] < n)continue;
        vis=to[i]|to[j];
        if(vis != quan)continue;
        for(int k=1;k<=n;k++) mx=max(mx,min(f[i][k],f[j][k]));
        if(mx)ans=min(ans,mx);
    }
    if(ans==2147483647)puts("No solution");
    else printf("%d\n",ans);
}
/*
4 13
1 1 1
1 2 3
1 3 3
1 4 5
2 1 2
2 2 1
2 3 2
3 1 4
3 3 4
3 4 1
4 1 2
4 2 3
4 4 3
*/

对拍

while( ((double)clock()-yilr) / CLOCKS_PER_SEC < 0.75) dfs(1,0,++dep);

CLOCKS_PER_SEC 这个常数在Windows下等于1000

迭代加深搜会用

对拍程序：

#include<cstdio>
#include<ctime>
#include<iostream>
#include<cstdlib>
using namespace std;
int main()
{
    int T=0;
    while(1)
    {
        double t1=clock();
        system("F:\\random.exe");
        double t2=clock();
        system("F:\\baoli.exe");
        double t3=clock();
        system("F:\\sol.exe");
        if(system("fc F:\\baoli.out F:\\sol.out"))
        {
            puts("yelir doesn't love you");
            break;
        }
        else 
        printf("yelir love you,测试点 %d 总时间 %.0f",++T,（clock()-t1）/1000.0 );
    }
    return 0;
}

#include<cstdlib>
#include<cstdio>
#include<ctime>
using namespace std;
int main() 
{
    int T = 0;
    while(1) 
    {
        double ti = clock();
        system("F:\\random.exe");
        double st = clock();
        system("F:\\baoli.exe");
        double ed = clock();
        system("F:\\sol.exe");
        if (system("fc F:\\baoli.out F:\\sol.out")) {
            puts("Wrong Answer");
            return 0;
        }
        else 
        {
            printf("Accepted, 测试点 #%d, 用时 %.0lfms 总用时 %.0lfs\n", ++ T, ed - st, (clock() - ti) / 1000);
        }
    }
}

各种排序

稳定的排序：

插入排序（直接插，二分插），冒泡排序，归并排序，基数排序，

不稳定的排序：

希尔排序，堆排序，快速排序，选择排序

yelir

1.注意撞关键字，比如next, end,y1,y2,x1,x2,j1,j2

2.注意超空间，时间问题，卡评测要专业

qsing2

1.是一道物理题，分三种情况，从高到低，从低到高，平跳，推式子即可

2.回声也就说明重复，可证最多重复一千次，然后建一棵Tire树，每次加入前查询，不必配直接返回即可。

3.线段树，当前点若没有人则赋为inf，单点修改，最后一问，可维护一下区间有多少学生，线段树区间求和即可，注意最后要从tail向前扫，因为他到队尾后还可能向队尾走，而且不一定总的队长为n+m，可能更长，而且注意build传参的范围，不是n，而是n+m.

#define N 20050
using namespace std;
int tr[20005005][2];
char s[2000];
int ans,tot,n;
inline void Insert(){
    int k = 0;
    for(int i = 0;i <= 1000;i ++){
        int o = s[i] - '0';
        if(!tr[k][o]) tr[k][o] = ++ tot;
        k = tr[k][o];
    }
}
inline int Ask() {
    int k = 0,res = 0;
    for(int i = 0;i <= 1000;i ++) {
        int o = s[i] - '0';
        if(!tr[k][o]) {
            return res;
        }
        else k = tr[k][o],res ++;
    }
    return res;
}
int main() {
    scanf("%d",&n);
    for(int i = 1;i <= n;i ++) {
        scanf("%s",s);
        int len = strlen(s),cnt = 0;
        for(int j = len;j <= 1000;j ++)
            s[j] = s[cnt],cnt = (cnt + 1) % len;
        ans = max(ans,Ask()); Insert();
    }
    printf("%d\n",ans);
    fclose(stdin); fclose(stdout);
    return 0;
}