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;

}