并不对劲的CF1236D&E：Alice&Doll&UnfairGame

CF1236D Alice&Doll

题目描述

有一个机器人在一个\(n\times m\)的有\(k\)个障碍网格上移动，上北下南左西右东。

它一开始在第一行第一列，面朝东边。它在每个格子上可以右转一次或不右转，然后会向面向的方向走一步。

问能不能将所有不是障碍的格子都走恰好一遍。\(n,m,k\leq10^5\)

题解

会发现每个格只能右转一次，所以最后走出的路径大概这样：

-------------------
 *                |
 *                |
 |----------*     |
 |   *-----|      |
*------------------

手动模拟这个过程就行。

注意考虑在一开始就拐弯的情况，不然会FST。

代码

#include<algorithm>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<ctime>
#include<iomanip>
#include<iostream>
#include<map>
#include<queue>
#include<stack>
#include<vector>
#define LL long long
#define rep(i,x,y) for(int i=(x);i<=(y);++i)
#define dwn(i,x,y) for(int i=(x);i>=(y);--i)
#define view(u,k) for(int k=fir[u];~k;k=nxt[k])
#define maxn 100007
using namespace std;
int read()
{
	int x=0,f=1;char ch=getchar();
	while(!isdigit(ch)&&ch!='-')ch=getchar();
	if(ch=='-')f=-1,ch=getchar();
	while(isdigit(ch))x=(x<<1)+(x<<3)+ch-'0',ch=getchar();
	return x*f;
}
void write(int x)
{
	char ch[20];int f=0;
	if(!x){putchar('0'),putchar('\n');return;}
	if(x<0)putchar('-'),x=-x;
	while(x)ch[++f]=x%10+'0',x/=10;
	while(f)putchar(ch[f--]);
	putchar('\n');
}
vector<int>nd[2][maxn];
int p[2][maxn],n,m,k,mx[4],now,f;
bool cmpy(int x,int y){return p[1][x]<p[1][y];}
bool cmpx(int x,int y){return p[0][x]<p[0][y];}
int getp(int rc,int k,int x,int f)
{
	if(nd[rc][k].size()==0)return -1;
	int l=0,r=nd[rc][k].size()-1,ans=-1;
	if(f==0&&p[rc^1][nd[rc][k][l]]>x)return -1;
	if(f==1&&p[rc^1][nd[rc][k][r]]<x)return -1;
	while(l<=r)
	{
		int mid=l+r>>1;
		if((!f&&p[rc^1][nd[rc][k][mid]]<=x)||(f&&p[rc^1][nd[rc][k][mid]]>=x))
		{
			if(!f)ans=max(ans,mid),l=mid+1;
			else ans=ans==-1?mid:min(ans,mid),r=mid-1;
		}
		else
		{
			if(!f)r=mid-1;
			else l=mid+1;
		}
	}
	if(ans!=-1)ans=nd[rc][k][ans];
	return ans;
}
int main()
{
	n=read(),m=read(),k=read();mx[0]=m,mx[1]=n,mx[2]=mx[3]=1;
	rep(i,1,k){p[0][i]=read(),p[1][i]=read(),nd[0][p[0][i]].push_back(i),nd[1][p[1][i]].push_back(i);if(p[0][i]==1&&p[1][i]==2)f=1;}
	rep(i,1,n)sort(nd[0][i].begin(),nd[0][i].end(),cmpy);
	rep(i,1,m)sort(nd[1][i].begin(),nd[1][i].end(),cmpx);
	int px=1,py=1;LL sum=(LL)n*m-1;
	if(m==1)f=1;
	if(f)now=1,mx[0]=1;
	while(1)
	{
		int pre=now-1;if(pre==-1)pre=3;
		if(now==0)
		{
			int x=getp(0,px,py,1);
			if(x!=-1)x=min(mx[now],p[1][x]-1);
			else x=mx[now];
			if(x==py)break;
			sum-=(LL)(x-py);
			mx[pre]=px+1,py=x;
		}
		else if(now==1)
		{
			int x=getp(1,py,px,1);
			if(x!=-1)x=min(mx[now],p[0][x]-1);
			else x=mx[now];
			if(x==px)break;
			sum-=(LL)(x-px);
			mx[pre]=py-1,px=x;
		}
		else if(now==2)
		{
			int x=getp(0,px,py,0);
			if(x!=-1)x=max(mx[now],p[1][x]+1);
			else x=mx[now];
			if(x==py)break;
			sum-=(LL)(py-x);
			mx[pre]=px-1,py=x;
		}
		else
		{
			int x=getp(1,py,px,0);
			if(x!=-1)x=max(mx[now],p[0][x]+1);
			else x=mx[now];
			if(x==px)break;
			sum-=(LL)(px-x);
			mx[pre]=py+1,px=x;
		}
		now=(now+1)%4;
	}
	if(sum==(LL)k)puts("Yes");
	else puts("No");
	return (0-0);
}

CF1236E Alice&UnfairGame

题目描述

A和B两个人在玩游戏。有编号为1到\(n\)的\(n\)个箱子按编号顺序排成一排，有一个箱子里有东西。

游戏要进行\(m\)轮，每轮的流程是：A先把东西移动到和它相邻的箱子里，然后B猜哪个箱子里有东西。一旦B猜中了，游戏就会结束，并且B获胜。

若游戏进行完了第\(m\)轮，则A还可以把东西移动到和它相邻的箱子里一次，之后A胜利。

已知\(n,m\)，和B在每一轮会猜测的箱子编号\(a_1,...,a_m\)，问有多少对\((x,y)\)满足游戏开始前东西在\(x\)号箱子，游戏结束时东西在\(y\)号箱子，且A胜利。

一行题解

对于同一个起点，合法终点连续=>在有障碍物的平面上行走=>在某时刻走到某点的“人”的起点连续=>线段树维护区间加减

题解

这个人讲得很清楚。

发现在A知道B的猜测序列时，除非\(n=1\)，A总有办法赢。

具体的方式是：从随便一个位置出发，如果这一轮B猜的是左边相邻的箱子就往右走或不走，右边同理，如果B猜的是当前箱子就往右或左走，如果都不是就往右或往左或不走。

按这种移动方式，会发现从每个位置出发，能使A赢的结束位置一定是连续的。

所以可以通过求从每个点出发能走到的使A赢的最左、最右位置。

先考虑最右位置。

假设从\(x\)出发，当前位置为\(p\)，时刻为\(t\)，那么为了尽可能往右走，应该当且仅当\(a_t=p+1\)时不会走，其他时候都会向右走。

可以把这个过程看成在平面上行走：以时刻为横坐标，以位置为纵坐标，一个人一开始在\((0,x)\)出发，对于每个时刻，如果他右上方没有障碍物就往右上走，反之往右走。

这样是\(O(n^2)\)的。

考虑把所有“人”放在一块考虑：有\(n\)个人在平面上行走，\(i\)号人从\((0,i)\)出发，每个人的走法和上面一样。

发现人们走出的路径可能会合并，但不会交叉。也就是说，某时刻在某位置的人们的坐标是连续的，某时刻人们的坐标按编号是单调不降的。

对于坐标为\((i,a_i)\)的障碍物，会挡住走到\((i-1,a_i-1)\)的“人”们。可以二分出这一段“人”的编号区间。在下一个时刻，除了这个编号区间的人以外，所有人纵坐标+1。

可以用线段树维护当前人们走到的位置的纵坐标。

注意人们不能走出去，因此可以设置\((1,n+1),(2,n+1),...,(m,n+1)\)这些额外的障碍物。

对于最左位置，可以看成把序列翻转后的最右位置。

时间复杂度\(O((n+m)log\space n)\)。

代码

#include<algorithm>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<ctime>
#include<iomanip>
#include<iostream>
#include<map>
#include<queue>
#include<set>
#include<stack>
#include<vector>
#define rep(i,x,y) for(register int i=(x);i<=(y);++i)
#define dwn(i,x,y) for(register int i=(x);i>=(y);--i)
#define view(u,k) for(int k=fir[u];~k;k=nxt[k])
#define LL long long
#define maxn 100007
#define ls (u<<1)
#define rs (u<<1|1)
#define mi ((l+r)>>1)
using namespace std;
int read()
{
    int x=0,f=1;char ch=getchar();
    while(!isdigit(ch)&&ch!='-')ch=getchar();
    if(ch=='-')f=-1,ch=getchar();
    while(isdigit(ch))x=(x<<1)+(x<<3)+ch-'0',ch=getchar();
    return x*f;
}
void write(LL x)
{
    if(x==0){putchar('0'),putchar('\n');return;}
    int f=0;char ch[20];
    if(x<0)putchar('-'),x=-x;
    while(x)ch[++f]=x%10+'0',x/=10;
    while(f)putchar(ch[f--]);
    putchar('\n');
    return;
}
int n,a[maxn],m,ans[2][maxn];
LL Ans;
int mn[maxn<<2],mx[maxn<<2],mk[maxn<<2];
void pu(int u){mn[u]=min(mn[ls],mn[rs]),mx[u]=max(mx[ls],mx[rs]);}
void build(int u,int l,int r)
{
	mk[u]=0;
	if(l==r){mx[u]=mn[u]=l;return;}
	build(ls,l,mi),build(rs,mi+1,r),pu(u);return;
}
void mark(int u,int k){mn[u]+=k,mx[u]+=k,mk[u]+=k;}
void pd(int u){if(mk[u])mark(ls,mk[u]),mark(rs,mk[u]),mk[u]=0;}
void add(int u,int l,int r,int x,int y,int k)
{
	if(x<=l&&r<=y){mark(u,k);return;}
	pd(u);
	if(x<=mi)add(ls,l,mi,x,y,k);
	if(y>mi)add(rs,mi+1,r,x,y,k);
	pu(u);return;
}
int askl(int u,int l,int r,int x)//max,<x
{
	if(l==r)return mx[u]<x?l:l-1;
	pd(u);
	if(mn[rs]<x)return askl(rs,mi+1,r,x);
	return askl(ls,l,mi,x);
}
int askr(int u,int l,int r,int x)//min,>x
{
	if(l==r)return mx[u]>x?l:l+1;
	pd(u);
	if(mx[ls]>x)return askr(ls,l,mi,x);
	return askr(rs,mi+1,r,x);
}
int ask(int u,int l,int r,int x)
{
	if(x<=l&&r<=x){return mx[u];}
	pd(u);
	if(x<=mi)return ask(ls,l,mi,x);
	return ask(rs,mi+1,r,x);
}
void work(int f)
{
	build(1,1,n);
	rep(i,1,m+1)
	{
		int l2=askl(1,1,n,n),r2=n;
		if(i<=m)
		{
			int l=askl(1,1,n,a[i]-1),r=askr(1,1,n,a[i]-1);
			if(l+1<=r-1)add(1,1,n,l+1,r-1,-1);
		}
		mk[1]++;
		if(l2+1<=r2)add(1,1,n,l2+1,r2,-1);
	}
	rep(i,1,n)ans[f][i]=ask(1,1,n,i);
}
int main()
{
	n=read(),m=read();
	rep(i,1,m)a[i]=read();
	work(0);
	rep(i,1,m)a[i]=n-a[i]+1;
	work(1);
	reverse(ans[1]+1,ans[1]+n+1);
	rep(i,1,n)ans[1][i]=n-ans[1][i]+1;
	rep(i,1,n)Ans+=max(0ll,(LL)(ans[0][i]-ans[1][i]+1));
	write(Ans);
	return 0;
}