寒假集训day1

今天的代码怎么都这么难调啊！！！

T1：游戏
$本题算是个半裸的STL模板题$
$题意：有w列h行，对于a\equiv b(\mathrm{m}\mathrm{o}\mathrm{d}2)的点，放一块木板，使(a,b)与（a，b+1）相连，再每一列上方放一个球垂直下落，遇到木板沿着木板往相邻位置走，给出n个减少的木板，求每个点的最终位置$
$先考虑没有减少木板的情况，观察第一列发现，由于相邻两球遇到同一块木板时位置交换，所以可以对每一列分别考虑$
$对于每一列，我们发现:$
$1.若为奇数列，直接将奇偶相邻交换$ $2.若为偶数列，收尾不变，中间的相邻交换$
$考虑拆掉一些木板,则表示这一行的这一列不会被交换$
$所以我们可以用两个双端队列维护每个球最终位置，最后在记录答案即可$
$注意点：$

1. deque和stack的运用，即下标不一定从1开始，应用迭代器iterator
2. 木板为奇数列或者偶数列的时候，操作是不同的，因为如果是偶数列的话，与右边奇数列交换，此时奇数的序数（即在原序列中为第几个奇数）比偶数的序数大1，而如果是偶数的话，两个的序数是相等的
3. 迭代器下标从0开始，end()应该是开区间
4. 题目问的不是每个落点的最终球，而是每个球的最终落点，所以最后还需要计算一次
5. 因为交换时为了方便，要再记录一个ans1，ans2（当然，大佬如果可以不用就忽略），ans1表示fir为奇数队列还是偶数队列，ans2表示sec为奇数队列还是偶数队列，然后在后面操作的时候要分两种情况讨论

#include<bits/stdc++.h>
using namespace std;

const int N=2e5+5;
int h,w,n;
vector <int> ball[N];
deque <int> fir,sec;
int ans1=1,ans2=2,ans[N];
int main(){
	scanf("%d%d%d",&h,&w,&n);
	for(int i=1;i<=n;i++){
		int x,y;
		scanf("%d%d",&x,&y);
		ball[x].push_back(y);
	}
	for(int i=1;i<=w;i++){
		if(i&1){
			fir.push_back(i);
		}
		else{
			sec.push_back(i);
		}
	}
	for(int i=1;i<=h;i++){
		if(i&1){//对奇偶行分别判断
			swap(ans1,ans2);
			vector <int>::iterator it;
			for(it=ball[i].begin();it<ball[i].end();it++){//
				int v=*it;
				if(v%2==0){//对删掉的木板是奇数列还是偶数列讨论
				int tmp=v/2; 
			    if(ans1==1)//对奇偶队列产生的影响讨论
				{
				int tmpf=fir[tmp],tmps=sec[tmp-1];
			    fir[tmp]=tmps,sec[tmp-1]=tmpf;//
			    }
			    if(ans2==1)//对奇偶队列产生的影响讨论
				{
				int tmpf=fir[tmp-1],tmps=sec[tmp];
			    fir[tmp-1]=tmps,sec[tmp]=tmpf;//
			    }
				}
				if(v%2==1){//对删掉的木板是奇数列还是偶数列讨论
				int tmp=v/2+1; 
			    if(ans1==1)//对奇偶队列产生的影响讨论
				{
				int tmpf=fir[tmp-1],tmps=sec[tmp-1];
			    fir[tmp-1]=tmps,sec[tmp-1]=tmpf;//
			    }
			    if(ans2==1)//对奇偶队列产生的影响讨论
				{
				int tmpf=fir[tmp-1],tmps=sec[tmp-1];
			    fir[tmp-1]=tmps,sec[tmp-1]=tmpf;//
			    }
				}
		     }
		}
		if((!(i&1))){//对奇偶行分别判断
		    if(ans1==1){//对奇偶队列产生的影响讨论
			int tmp1=fir.front(),tmp2=sec.back();//
			fir.pop_front(),fir.push_back(tmp2);
		    sec.pop_back(),sec.push_front(tmp1);
		    }
		    if(ans2==1){//对奇偶队列产生的影响讨论
		    int tmp1=sec.front(),tmp2=fir.back();//
		    sec.pop_front(),sec.push_back(tmp2);
		    fir.pop_back(),fir.push_front(tmp1);
		    }
		    swap(ans1,ans2);
		    vector <int>::iterator it;
		    for(it=ball[i].begin();it<ball[i].end();it++){
		    	int v=*it;
		    	if(v%2==0){//对删掉的木板是奇数列还是偶数列讨论
				int tmp=v/2; 
			    if(ans1==1)
				{
				int tmpf=fir[tmp],tmps=sec[tmp-1];
			    fir[tmp]=tmps,sec[tmp-1]=tmpf;//
			    }
			    if(ans2==1)//对奇偶队列产生的影响讨论
				{
				int tmpf=fir[tmp-1],tmps=sec[tmp];
			    fir[tmp-1]=tmps,sec[tmp]=tmpf;//
			    }
				}
				if(v%2==1){//对删掉的木板是奇数列还是偶数列讨论
				int tmp=v/2+1; 
			    if(ans1==1)
				{
				int tmpf=fir[tmp-1],tmps=sec[tmp-1];
			    fir[tmp-1]=tmps,sec[tmp-1]=tmpf;//
			    }
			    if(ans2==1)//对奇偶队列产生的影响讨论
				{
				int tmpf=fir[tmp-1],tmps=sec[tmp-1];
			    fir[tmp-1]=tmps,sec[tmp-1]=tmpf;//
			    }
				}
		    }
		}
	}
	int tnt=0;
	if(ans1==1){
		while(!sec.empty()){//
			int font=fir.front(),sont=sec.front();
			fir.pop_front(),sec.pop_front();
			ans[font]=++tnt;ans[sont]=++tnt;
	    }
	}
	if(ans1==2){
		while(!fir.empty()){//
			int font=fir.front(),sont=sec.front();
			fir.pop_front(),sec.pop_front();
			ans[sont]=++tnt,ans[font]=++tnt;
 	    }
	}
	for(int i=1;i<=w;i++){//
		printf("%d\n",ans[i]);
	}
}

T2：画画
$首先观察题目，发现走过去再走回来的操作像极了NOIP某年的dp题$
$所以运用套路走两次$
$我开始的想法是因为只会往右走或往下走，所以能走就一定走完，后来发现走两次，就以为不行，结果发现没法判断只有1条路径的情况$
$正解：$
$对于第一条路径：能往下走就走，不能走就往右走$
$对于第二条路径，能往右走就往右走，不能走就往下$
$对于重合的点乘2，因为来到重合点的路径对于第一条和第二条可以互换$
$注意点：$

1. 如果遇到连续的重合点只用乘1次2，因为对于连续的重合点，重合点之间的路径是唯一的，互换不会产生新的方案
2. 收尾两个点的路径互换只能算一次，如果交换两次的话，和原来的方案是相同的（我代码中算的是尾点）
3. 起点开始的连续路径不能计入答案（如果和我一样计算尾点的话）

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
const int N=1e5+5;//
int a[N],b[N],suma[N],sumb[N];
int n;
ll ans=1,mod=1e9+7;//
bool flag=false,flag2=false;//
void dfs(int x,int y,int xx,int yy,bool ff){//ff用来判断连续的重合点
	if(suma[x]>a[x]||sumb[y]>b[y]||suma[xx]>a[xx]||sumb[yy]>b[yy]) {if(x==xx&&y==yy) ans/=2;return;};
	if(x!=xx||y!=yy){
		flag=true;
	}
	if(x==n&&y==n&&xx==n&&yy==n){
		flag2=true;
		return;
	}
	if(suma[x]+1<=a[x]&&sumb[yy]+1<=b[yy]&&y+1<=n&&xx+1<=n){
		suma[x]++,sumb[yy]++;
		bool f=false;
		if(x!=xx+1||y!=yy+1)sumb[y+1]++,suma[xx+1]++;
		if(x==xx+1&&y+1==yy) {if(!ff) ans=ans*2%mod;f=true;};
		dfs(x,y+1,xx+1,yy,f);
		suma[x]--,sumb[yy]--;
		if(x!=xx+1||y!=yy+1)sumb[y+1]--,suma[xx+1]--;
	}
	if(suma[x]==a[x]&&x+1<=n&&xx+1<=n&&sumb[yy]+1<=b[yy]){
		suma[x+1]++,sumb[yy]++;
		bool f=false;
		if(x+1!=xx+1||y!=yy)suma[xx+1]++,sumb[y]++;
		if(x+1==xx+1&&y==yy){if(!ff) ans=ans*2%mod;f=true;}
		dfs(x+1,y,xx+1,yy,f);
		suma[x+1]--,sumb[yy]--;
		if(x+1!=xx+1||y!=yy)suma[xx+1]--,sumb[y]--;
	}
	if(sumb[yy]==b[yy]&&yy+1<=n&&y+1<=n&&suma[x]+1<=a[x]){
		suma[x]++,sumb[yy+1]++;
		bool f=false;
		if(x!=xx||y+1!=yy+1)suma[xx]++,sumb[y+1]++;
		if(x==xx&&y+1==yy+1){if(!ff) ans=ans*2%mod;f=true;}
		dfs(x,y+1,xx,yy+1,f);
		suma[x]--,sumb[yy+1]--;
		if(x!=xx||y+1!=yy+1)suma[xx]--,sumb[y+1]--;
	}
	if(sumb[yy]==b[yy]&&suma[x]==a[x]&&x+1<=n&&yy+1<=n){
		sumb[y]++;suma[xx]++;
		bool f=false;
		if(x+1!=xx||y!=yy+1)suma[x+1]++,sumb[yy+1]++;
		if(x+1==xx&&y==yy+1){if(!ff) ans=ans*2%mod;f=true;}
		dfs(x+1,y,xx,yy+1,f);
		sumb[y]--;suma[xx]--;
		if(x+1!=xx||y!=yy+1)suma[x+1]--,sumb[yy+1]--;
	}
}
int main(){
	int T;
	scanf("%d",&T);
	while(T--){
	flag2=false;flag=false;
    memset(suma,0,sizeof(suma));
    memset(sumb,0,sizeof(sumb));
	scanf("%d",&n);	ans=1;
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i]);
	}
	for(int i=1;i<=n;i++){
		scanf("%d",&b[i]);
	}
	suma[1]++,sumb[1]++;
	dfs(1,1,1,1,1);
	if(!flag2){
		puts("0");
		continue;
	}
	if(!flag){
		puts("1");
		continue;
	}	
	printf("%lld\n",ans);
    }
}

T3: 猫
洛古地址
$（洛古上的数据比较小，需要调整）$
$实在是看不懂写滚动数组的是怎么过的，当多了一位j时，不知道为什么j-1的决策点可以直接给j$
$本题解比较好理解，但空间较大$
$dp[i][j]表示取[1,i]只猫，用j个管理员的最小等待时间$
$dp[i][j]=dp[k][j-1]+(j-k)\ast T[j]-(sum[j]-sum[k])$
$移一下项，发现dp[k][j-1]+sum[k]=T[j]\ast k+dp[i][j]-j\ast T[j]+sum[j]$
$因为T[j]单调递增，所以我们可以维护一个凸包，但由于是二维，所以要维护多个凸包，每次判断队首的斜率是否小于T[j]，是就弹出队列，直到大于T[j]（因为T[j]单调递增，所以后面也不会再用到弹出的元素）$
$接下来取出队首转移即可$
（实在不明白为什么多一维之后决策点还是能直接用！！！）

#include<bits/stdc++.h>
using namespace std;

const int N=1e5+5;
int n,m,p;
int dis[N],T[N];
typedef long long ll;
ll dp[50005][1003],q[50005][1003],hd[50005],tl[50005],sum[N];
inline double slope(int tt,int a,int b){
	return double(dp[a][tt]+sum[a]-dp[b][tt]-sum[b])/(a-b);
}
int main(){
	scanf("%d%d%d",&n,&m,&p);
	dis[1]=0;
	for(int i=2;i<=n;i++){
		int d;
		scanf("%d",&d);
		dis[i]=dis[i-1]+d;
	}
	for(int i=1;i<=m;i++){
		int h,t;
		scanf("%d%d",&h,&t);
		T[i]=t-dis[h];
	}
	sort(T+1,T+m+1);
	for(int i=1;i<=m;i++){
		sum[i]=sum[i-1]+T[i];
	}
	for(int j=0;j<=m;j++){
		hd[j]=1,tl[j]=0;
	}
	for(int i=1;i<=m;i++)
	{
		for(int j=1;j<=p;j++){
			while(hd[j-1]<tl[j-1]&&slope(j-1,q[j-1][hd[j-1]],q[j-1][hd[j-1]+1])<=T[i]) hd[j-1]++;//
			int nxt=q[j-1][hd[j-1]];
			dp[i][j]=dp[nxt][j-1]+(i-nxt)*T[i]-(sum[i]-sum[nxt]);
			while(hd[j]<tl[j]&&slope(j,q[j][tl[j]],q[j][tl[j]-1])>slope(j,q[j][tl[j]],i)) tl[j]--;
			q[j][++tl[j]]=i;
		}
	}
	printf("%lld",dp[m][p]);
}