NOIP2017模拟赛总结（2017.10.26-2017.10.29）_2017[noip模拟赛]-优快云博客

本文链接：https://blog.youkuaiyun.com/maxwei_wzj/article/details/78404597

本文精选了算法竞赛中的经典题目，包括背包问题、最短路径、DP、贪心算法等，详细解析了每道题目的解题思路和代码实现，为算法爱好者提供了宝贵的学习资源。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

嗯，这次是10.26到10.29的题，因为10.27休息了一天，所以还是3天。

2017.10.26 Problem A
题目大意： 有一个容积为 $V$ 的背包和 $n$ 个物品，每个物品有两个参数 $a_i,b_i$ ，表示要装下这个物品需要消耗 $a_i$ 的容积，但装进去后背包的容积会扩大 $b_i$ ，问存不存在一种装物品的顺序使得能装下所有物品。
做法： 本题需要用到贪心。
首先对于 $ai≤bia_i\le b_i$ 的物品，按照 $a_i$ 从小到大的顺序取，如果不能取完那就无解，关键是如何处理 $a_i>b_i$ 的物品。
实际上，像这类取东西的题目，可以有一类贪心证法，这里记录下我的证法。
注意到无论按什么顺序取两个物品，取完后的状态都是一样的，那么我们就试图证明，如果取完物品 $i$ 后还能取物品 $j$ （条件1），一定可以推出取完物品 $j$ 后还能取物品 $i$ （条件2），那么先取物品 $j$ 就是更优的。为什么呢？因为在这种情况下，条件1,2满足的情况只有三种：两个都满足，两个都不满足，条件1不满足而条件2满足。显然情况1,2对结果没有影响，关键是情况3，若是这种情况的话，先取 $i$ 就一定不能取完所有物品，而先取 $j$ 说不定可以，所以先取 $j$ 一定最优。
我们把条件1和条件2用数学式子表达出来：
条件1： $V−ai+bi≥ajV-a_i+b_i\ge a_j$
条件2： $V−aj+bj≥aiV-a_j+b_j\ge a_i$
在两个条件中 $V$ 的解集分别为 $V≥ai+aj−biV\ge a_i+a_j-b_i$ 和 $V≥ai+aj−bjV\ge a_i+a_j-b_j$ ，要使条件1能推出条件2，那么条件2的解集应包含条件1的解集，即 $ai+aj−bj≤ai+aj−bia_i+a_j-b_j\le a_i+a_j-b_i$ ，解得 $bi≤bjb_i\le b_j$ ，由此证得先取 $b_i$ 较大的物品是最优的，那么就这么取即可。时间复杂度 $O(nlog⁡n)O(n\log n)$ 。
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define ll long long
using namespace std;
int n,T;
ll v;
struct point {ll a,b;} f[100010],g[100010];

bool cmp0(point a,point b)
{
	return a.a<b.a;
}

bool cmp(point a,point b)
{
	return a.b>b.b;
}

int main()
{
	scanf("%d",&T);
	while(T--)
	{
		scanf("%d%lld",&n,&v);
		int t1=0,t2=0;
		for(int i=1;i<=n;i++)
		{
			ll a,b;
			scanf("%lld%lld",&a,&b);
			if (b-a>=0) g[++t1].a=a,g[t1].b=b;
			else f[++t2].a=a,f[t2].b=b;
		}
		
		sort(g+1,g+t1+1,cmp0);
		sort(f+1,f+t2+1,cmp);
		bool flag=1;
		for(int i=1;i<=t1;i++)
		{
			if (v<g[i].a) {flag=0;break;}
			v=v-g[i].a+g[i].b;
		}
		if (!flag) {printf("No\n");continue;}
		for(int i=1;i<=t2;i++)
		{
			if (v<f[i].a) {flag=0;break;}
			v=v-f[i].a+f[i].b;
		}
		if (flag) printf("Yes\n");
		else printf("No\n");
	}
	
	return 0;
}

2017.10.26 Problem B
题目大意： 有一个长为 $n$ 的数列，若一个区间 $[L, R]$ 内存在一个数 $a_k$ ，使得对于所有 $L≤i≤RL\le i\le R$ ，都有 $a_k|a_i$ ，那么我们说这个区间是合法的，价值为 $R - L$ ，求价值最大区间的价值以及所有这些区间的左端点。
做法： 本题需要用到枚举。
对于一个点，我们可以暴力求出以它为公因数的最长合法区间的左端点和右端点，这样做的时间复杂度是 $O(n^2)$ 的，虽然常数不大，但如果所有数字都相同的话会被卡掉。注意到，如果当前可以扩展到 $r h t$ 这个右端点，那么从这个点到这个右端点之间的这些点实际上求了也没用，那么我们可以直接跳到 $r h t + 1$ 继续暴力。可以证明最坏情况下时间复杂度为 $O(nlog⁡n)O(n\log n)$ ，随机情况下复杂度为 $O (n)$ 。
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define ll long long
using namespace std;
int n,lft[500010]={0},rht[500010]={0},mx=0,num=0;
ll a[500010];
bool vis[500010]={0};

int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
		scanf("%lld",&a[i]);
	
	for(int i=1;i<=n;i=rht[i]+1)
	{
		int j;
		for(j=i;j>=1;j--)
			if (a[j]%a[i]!=0) break;
		lft[i]=j+1;
		for(j=i;j<=n;j++)
			if (a[j]%a[i]!=0) break;
		rht[i]=j-1;
		mx=max(mx,rht[i]-lft[i]);
	}
	
	for(int i=1;i<=n;i++)
		if (rht[i]-lft[i]==mx) vis[lft[i]]=1;
	for(int i=1;i<=n;i++)
		if (vis[i]) num++;
	printf("%d %d\n",num,mx);
	for(int i=1;i<=n;i++)
		if (vis[i]) printf("%d ",i);
	
	return 0;
}

2017.10.26 Problem C
题目大意： 一个 $n(≤30)×m(≤30)n(\le 30)\times m(\le 30)$ 的棋盘中，要放 $c(≤10)c(\le 10)$ 种颜色的棋子，每种颜色的棋子数量可能不同，但总数不超过 $900$ ，不同颜色的棋子不能放在同一行或同一列，求合法的方案数。
做法： 本题需要用到组合数学递推+二维背包。
观察发现，每种颜色的棋子都独占若干行和若干列，如果我们能知道在正好占用若干行若干列时，放若干个棋子的方案数的话，就可以做二维背包了！令 $f (i, j, k)$ 为 $k$ 个同色棋子正好占用 $i$ 行 $j$ 列的方案数，那么可得状态转移方程：
$f(i,j,k)=Ci×jk−∑p=0i∑q=0jCipCjqf(i−p,j−q,k)f(i,j,k)=C_{i\times j}^k-\sum_{p=0}^i\sum_{q=0}^jC_i^pC_j^qf(i-p,j-q,k)$
上式是怎么推出来的呢？可以看做，用在 $i×ji\times j$ 个格子里放 $k$ 个棋子的方案数，减去正好空 $p$ 行 $q$ 列的方案数。注意到第三维实际上没有必要枚举全部 $1$ ~ $900$ ，只要求出 $k =$ 某种棋子颜色总数的情况就可以了，那么我们删去第三维，上式就是 $O(cn^2m^2)$ 的了，可以接受。
接下来就是二维背包了。令 $g (k, i, j)$ 为放前 $k$ 种颜色，还剩 $i$ 行 $j$ 列没有占用的方案数，那么有状态转移方程：
$g(k,i,j)=∑p=in∑q=jmCpiCqjf(p−i,q−j,num(k))g(k−1,p,q)g(k,i,j)=\sum_{p=i}^n\sum_{q=j}^mC_p^iC_q^jf(p-i,q-j,num(k))g(k-1,p,q)$
其中 $n u m (k)$ 为第 $k$ 种颜色的棋子数量，边界条件为 $g (0, n, m) = 1$ ，显然答案为 $∑i=1n∑j=1mg(c,i,j)\sum_{i=1}^n\sum_{j=1}^m g(c,i,j)$ 。上述的方程应该可以挺容易推出来了，时间复杂度为 $O(cn^2m^2)$ ，那么预处理出组合数就可以通过该题了。
（原题好像叫做CQOI2011放棋子）
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define ll long long
#define mod 1000000009
using namespace std;
int n,m,c,num[11],tot=0;
ll cc[1010][1010],f[35][35]={0},g[2][35][35]={0};

ll power(ll a,ll b)
{
	ll s=1,ss=a;
	while(b)
	{
		if (b&1) s=(s*ss)%mod;
		b>>=1;ss=(ss*ss)%mod;
	}
	return s;
}

ll C(int n,int m)
{
	if (m>n) return 0;
	return cc[n][m];
}

int main()
{
	scanf("%d%d%d",&n,&m,&c);
	for(int i=1;i<=c;i++) scanf("%d",&num[i]),tot+=num[i];
	
	cc[0][0]=1;
	for(int i=1;i<=1000;i++)
	{
		cc[i][0]=1;
		for(int j=1;j<=i;j++)
			cc[i][j]=(cc[i-1][j-1]+cc[i-1][j])%mod;
	}
	
	int now=1,past=0;
	g[past][n][m]=1;
	for(int k=1;k<=c;k++)
	{
		memset(f,0,sizeof(f));
		for(int i=1;i<=n;i++)
			for(int j=1;j<=m;j++)
			{
				f[i][j]=C(i*j,num[k]);
				for(int p=0;p<=i;p++)
					for(int q=0;q<=j;q++)
						if (p||q) f[i][j]=(((f[i][j]-((C(i,p)*C(j,q))%mod)*f[i-p][j-q])%mod)+mod)%mod;
			}
		for(int i=0;i<=n;i++)
			for(int j=0;j<=m;j++)
			{
				g[now][i][j]=0;
				for(int p=i;p<=n;p++)
					for(int q=j;q<=m;q++)
						g[now][i][j]=(g[now][i][j]+((((C(p,i)*C(q,j))%mod)*f[p-i][q-j])%mod)*g[past][p][q])%mod;
			}
		swap(now,past);
	}
	
	ll ans=0;
	for(int i=0;i<=n;i++)
		for(int j=0;j<=m;j++)
			ans=(ans+g[past][i][j])%mod;
	printf("%lld\n",ans);
	
	return 0;
}

2017.10.28 Problem A
题目大意： $n(≤500000)×nn(\le 500000)\times n$ 个士兵占成 $n×nn\times n$ 的方阵，第 $i$ 行第 $j$ 列的士兵站在 $(i, j)$ ，所有士兵身高相同，问从 $(0, 0)$ 能看到的士兵的数量。
做法： 本题需要用到欧拉函数。
题目显然是在求 $∑i=1n∑j=1n[gcd⁡(i,j)=1]\sum_{i=1}^n\sum_{j=1}^n[\gcd(i,j)=1]$ ，推一下就可以发现答案为 $1+2∑i=2nφ(i)1+2\sum_{i=2}^n\varphi(i)$ ，线性筛求出欧拉函数然后求出这个式子就行了。
（然而我求稳写了 $O(nlog⁡log⁡n)O(n\log \log n)$ 的筛法…）
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define ll long long
using namespace std;
ll n,phi[500010],ans=0;
bool vis[500010]={0};

void calc_phi()
{
	for(int i=1;i<=n;i++) phi[i]=i;
	for(ll i=2;i<=n;i++)
		if (!vis[i])
		{
			for(ll j=1;i*j<=n;j++)
			{
				vis[i*j]=1;
				phi[i*j]=phi[i*j]*(i-1)/i;
			}
		}
}

int main()
{
	scanf("%lld",&n);
	calc_phi();
	for(int i=2;i<=n;i++) ans+=phi[i];
	ans=(ll)2*ans+1;
	printf("%lld",ans);
	
	return 0;
}

2017.10.28 Problem B
题目大意： 有 $n$ 个炸弹，有些炸弹会连一条单向引线到另一个炸弹，引爆一个炸弹时，其引线连接的炸弹也会同时爆炸，引爆每个炸弹有一个非负分数，问引爆 $k$ 个炸弹最多能获得的分数是多少。
做法： 本题需要用到缩环+贪心+堆。
注意到一点，如果我们把没引出引线的点看做向点 $0$ 引了一条引线，那么整个图可以看做一棵树+若干棵环套树，注意到我们可以把环缩起来，并从缩起来的点向点 $0$ 连边，那么可以构成一个等价的图，而这个图显然是一棵树。那么问题变成，选取 $k$ 条到根的路径，使得这些路径所经过的点权之和最大。
然后我们就可以贪心了（我也不知道为什么能贪，写了个树形DP拍了几组数据发现结果都一样），先预处理出一个点子树中的点到该点能获得的最大点权和（也就是重链），还要记录提供最优答案的那个儿子（以下称为重儿子）。然后每次在堆里取最大的一个，然后顺着所取的路径，把路径上所有点的非重儿子的重链加入堆，取个 $k$ 次之后就能得出答案了，时间复杂度为 $O(nlog⁡n)O(n\log n)$ 。
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#define ll long long
using namespace std;
int n,k,tot=0,first[400010]={0},vis[400010]={0},belong[200010],next[400010]={0};
ll a[200010],b[400010],f[400010],ans=0,mx,mxi;
struct edge {int v,next;} e[200010];
bool son[400010]={0};
struct point
{
	int id;
	ll val;
	bool operator < (point a) const
	{
		return val<a.val;
	}
};
priority_queue <point> Q;

ll read()
{
	ll s=0;
	char c;
	c=getchar();
	while(c<'0'||c>'9') c=getchar();
	while(c>='0'&&c<='9')
	{
		s=s*10+c-'0';
		c=getchar();
	}
	return s;
}

void find_loop(int v)
{
	if (v==0) return;
	if (!vis[a[v]]) vis[a[v]]=vis[v],find_loop(a[v]);
	else if (vis[a[v]]==vis[v])
	{
		ll i=a[v];
		++tot;b[tot]=0;
		while(i!=v)
		{
			belong[i]=tot;
			i=a[i];
		}
		belong[v]=tot;
	}
}

void insert(int a,int b)
{
	e[++tot].v=b;
	e[tot].next=first[a];
	first[a]=tot;
}

void dfs(int v)
{
	f[v]=0;
	for(int i=first[v];i;i=e[i].next)
	{
		dfs(e[i].v);
		if (f[e[i].v]>f[v])
		{
			f[v]=f[e[i].v];
			next[v]=e[i].v;
		}
	}
	f[v]+=b[v];
}

int main()
{
	scanf("%d%d",&n,&k);
	belong[0]=0;
	for(int i=1;i<=n;i++)
	{
		a[i]=read(),b[i]=read();
		belong[i]=i;
	}
	
	tot=n;
	for(int i=1;i<=n;i++)
		if (!vis[i]) vis[i]=i,find_loop(i);
	tot=0;
	memset(vis,0,sizeof(vis));
	for(int i=1;i<=n;i++)
	{
		if (belong[i]>n) b[belong[i]]+=b[i];
		if (belong[i]==belong[a[i]]&&!vis[belong[i]]) vis[belong[i]]=1,insert(0,belong[i]);
		else if (belong[i]!=belong[a[i]]) insert(belong[a[i]],belong[i]);
	}
	
	dfs(0);
	point now,nex;
	now.id=0,now.val=f[0];
	Q.push(now);
	for(int i=1;i<=k;i++)
	{
		if (Q.empty()) break;
		now=Q.top(),Q.pop();
		ans+=now.val;
		int x=now.id;
		while(next[x])
		{
			for(int j=first[x];j;j=e[j].next)
				if (e[j].v!=next[x])
				{
					nex.id=e[j].v;
					nex.val=f[e[j].v];
					Q.push(nex);
				}
			x=next[x];
		}
	}
	printf("%lld",ans);
	
	return 0;
}

2017.10.28 Problem C
题目大意： 一个带边权的有向图，要从 $u$ 点走到 $v$ 点，，经过每个点要缴纳一个费用，每个点费用可能不同，一条路径的费用为路径上所有经过点的费用最大值，问在路径长度不超过 $s$ 的情况下，路径费用的最小值。
做法： 本题需要用到二分答案+最短路。
很显然需要二分费用，然后我们需要判定费用不超过一定值的时候存不存在长度不超过 $s$ 的路径，那么我们做一个最短路，不走费用超过该值的点即可。本题好像卡SPFA，所以我用Dijkstra算法写了，时间复杂度为 $O(nlog⁡n)O(n\log n)$ 。
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
#define ll long long
using namespace std;
int n,m,u,v,tot=0,first[10010]={0};
ll inf,s,f[10010],mxf=0,dis[10010];
struct edge {int v,next;ll d;} e[100010];
struct point
{
	int id;
	ll val;
	bool operator < (point a) const
	{
		return val>a.val;
	}
};
bool vis[10010];
priority_queue <point> Q;

void insert(int a,int b,ll d)
{
	e[++tot].v=b;
	e[tot].next=first[a];
	e[tot].d=d;
	first[a]=tot;
}

void dijkstra(ll limit)
{
	point now,next;
	while(!Q.empty()) Q.pop(); 
	for(int i=1;i<=n;i++)
	{
		if (i!=u) dis[i]=inf;
		else dis[i]=0;
	}
	if (f[u]>limit||f[v]>limit) return;
	
	for(int i=first[u];i;i=e[i].next)
		if (f[e[i].v]<=limit) dis[e[i].v]=min(dis[e[i].v],e[i].d);
	memset(vis,0,sizeof(vis));
	vis[u]=1;
	for(int i=1;i<=n;i++)
		if (i!=u&&f[i]<=limit)
		{
			now.id=i,now.val=dis[i];
			Q.push(now);
		}
	
	for(int i=2;i<=n;i++)
	{
		if (Q.empty()) return;
		now=Q.top(),Q.pop();
		while(vis[now.id])
		{
			if (Q.empty()) return;
			now=Q.top(),Q.pop();
		}
		vis[now.id]=1;
		for(int j=first[now.id];j;j=e[j].next)
			if (!vis[e[j].v]&&f[e[j].v]<=limit&&dis[e[j].v]>dis[now.id]+e[j].d)
			{
				next.id=e[j].v;
				next.val=dis[e[j].v]=dis[now.id]+e[j].d;
				Q.push(next);
			}
	}
}

int main()
{
	inf=1000000000;
	inf*=inf;
	
	scanf("%d%d%d%d%lld",&n,&m,&u,&v,&s);
	for(int i=1;i<=n;i++) scanf("%lld",&f[i]),mxf=max(mxf,f[i]);
	for(int i=1;i<=m;i++)
	{
		int a,b;ll d;
		scanf("%d%d%lld",&a,&b,&d);
		insert(a,b,d),insert(b,a,d);
	}
	
	dijkstra(inf);
	if (dis[v]>s) {printf("-1");return 0;}
	ll l=0,r=mxf;
	while(l<r)
	{
		ll mid=(l+r)/2;
		dijkstra(mid);
		if (dis[v]>s) l=mid+1;
		else r=mid;
	}
	printf("%lld",l);
	
	return 0;
}

2017.10.29 Problem A
题目大意： $n$ 支球队相互比赛，每两支球队会打一场主场和一场客场，赢了计 $3$ 分，输了不计分，平局各计 $1$ 分，给出比赛的情况，求出最后分数最高的球队编号（可能有多个）。
做法： 模拟，裸的不行，不讲了。
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
int n,mx=-1,score[110]={0},mxi[110],t=0;
char s[110];

int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++)
	{
		scanf("%s",s);
		for(int j=1;j<=n;j++)
		{
			if (s[j-1]=='W') score[i]+=3;
			if (s[j-1]=='D') score[i]+=1,score[j]+=1;
			if (s[j-1]=='L') score[j]+=3;
		}
	}
	
	for(int i=1;i<=n;i++)
	{
		if (score[i]==mx) mxi[++t]=i;
		if (score[i]>mx) mx=score[i],t=1,mxi[t]=i;
	}
	
	for(int i=1;i<=t;i++)
		printf("%d ",mxi[i]);
	
	return 0;
}

2017.10.29 Problem B
题目大意： 平面上有 $n(≤1000)n(\le 1000)$ 个点，记横坐标最小和最大的点为 $A$ 和 $B$ ，现在要从 $A$ 走到 $B$ 再走回 $A$ ，并经过每个点一次且仅一次（ $A$ 两次），并且从 $A$ 到 $B$ 走时只能向横坐标更大的点走，从 $B$ 到 $A$ 走时只能向横坐标更小的点走，并且要求从 $A$ 到 $B$ 走时一定经过点 $b_1$ ，从 $B$ 到 $A$ 走时一定经过点 $b_2$ ，问满足要求的最短路径长度。
做法： 本题需要用到DP。
转化为双线程DP，令 $f (i, j)$ 为从 $A$ 走到 $i$ ，从 $j$ 走到 $A$ ，且从 $A$ 到 $m a x (i, j)$ 都已经走过的最短路径长度，我们发现 $f (i, j)$ 对 $f(max⁡(i,j)+1,j)f(\max(i,j)+1,j)$ 和 $f(i,max⁡(i,j)+1)f(i,\max(i,j)+1)$ 都可能有贡献，更新的式子为：
$f(max⁡(i,j)+1,j)=min⁡(f(max⁡(i,j)+1,j),f(i,j)+dis(i,max(i,j+1)))f(\max(i,j)+1,j)=\min(f(\max(i,j)+1,j),f(i,j)+dis(i,max(i,j+1)))$
以上式子当 $max⁡(i,j)+1≠b1\max(i,j)+1\ne b_1$ 时可以进行更新。
$f(i,max⁡(i,j)+1)=min⁡(f(i,max⁡(i,j)+1),f(i,j)+dis(j,max(i,j+1)))f(i,\max(i,j)+1)=\min(f(i,\max(i,j)+1),f(i,j)+dis(j,max(i,j+1)))$
以上式子当 $max⁡(i,j)+1≠b2\max(i,j)+1\ne b_2$ 时可以进行更新。
最后的答案为 $f (n, n)$ ，时间复杂度为 $O(n^2)$ 。
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <cmath>
#define inf 1000000000
using namespace std;
int n,b1,b2;
double x[1010],y[1010],dp[1010][1010];

double dis(int i,int j)
{
	return sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j]));
}

int main()
{
	scanf("%d%d%d",&n,&b1,&b2);
	for(int i=0;i<n;i++)
		scanf("%lf%lf",&x[i],&y[i]);
	
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
			dp[i][j]=inf;
	dp[0][0]=0;
			
	for(int i=0;i<n;i++)
		for(int j=0;j<n;j++)
			if (i!=j||i==0)
			{
				int k=max(i,j)+1;
				if (i!=b1) dp[k][j]=min(dp[k][j],dp[i][j]+dis(i,k));
				if (j!=b2) dp[i][k]=min(dp[i][k],dp[i][j]+dis(j,k));
			}
	if (n-2!=b1) dp[n-1][n-1]=min(dp[n-1][n-1],dp[n-2][n-1]+dis(n-2,n-1));
	if (n-2!=b2) dp[n-1][n-1]=min(dp[n-1][n-1],dp[n-1][n-2]+dis(n-2,n-1));
	printf("%.2lf",dp[n-1][n-1]);
	
	return 0;
}

2017.10.29 Problem C
题目大意： 停车场有 $n$ 个车位，有 $m$ 个操作，每个操作是一辆车开入或者开出停车场，车开入之后会选择一个离最近的车最远的车位停入，如果有多个位置选择编号最小的，对于每个开入操作，输出它停放的车位编号。
做法： 本题需要用到链表+堆。
分析后发现，两个车位 $i, j$ 之间停放车辆时，最远的距离应是 $⌊j−i2⌋−1\lfloor \frac{j-i}{2}\rfloor-1$ （这里距离指两辆车之间相隔的车位数），这是一个定值，因此我们用一个链表维护车位被占用的情况，然后再用堆维护距离的最大值即可。时间复杂度 $O(mlog⁡m)O(m\log m)$ 。
以下是本人代码：

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
int n,m,pos[1000010],pre[500010],next[500010],val[500010],tot=2,nowtime=0;
int tim[500010]={0};
struct point
{
	int id,lft,val,t;
	bool operator < (point a) const
	{
		if (val!=a.val) return val<a.val;
		else return lft>a.lft;
	};
};
priority_queue <point> Q;

void insert(int x,int y)
{
	point now;
	val[++tot]=y;
	pre[next[x]]=tot;
	pre[tot]=x;
	next[tot]=next[x];
	next[x]=tot;
	now.id=x,now.lft=val[x],now.t=++nowtime;
	if (now.id==1||next[now.id]==2) now.val=val[next[now.id]]-val[now.id]-2;
	else now.val=(val[next[now.id]]-val[now.id])/2-1;
	Q.push(now);tim[now.id]=nowtime;
	now.id=tot,now.lft=y,now.t=++nowtime;
	if (now.id==1||next[now.id]==2) now.val=val[next[now.id]]-val[now.id]-2;
	else now.val=(val[next[now.id]]-val[now.id])/2-1;
	Q.push(now);tim[now.id]=nowtime;
}

void del(int x)
{
	point now;
	next[pre[x]]=next[x];
	pre[next[x]]=pre[x];
	now.id=pre[x],now.lft=val[pre[x]],now.t=++nowtime;
	if (now.id==1||next[now.id]==2) now.val=val[next[now.id]]-val[now.id]-2;
	else now.val=(val[next[now.id]]-val[now.id])/2-1;
	Q.push(now);tim[now.id]=nowtime;
	tim[x]=nowtime;
}

int main()
{
	scanf("%d%d",&n,&m);
	pre[2]=1,next[1]=2;
	val[1]=0,val[2]=n+1;
	point now;
	now.id=1,now.lft=0,now.val=n+1,now.t=0;
	Q.push(now);
	for(int i=1;i<=m;i++)
	{
		int op,x,ans;
		scanf("%d%d",&op,&x);
		if (op==1)
		{
			now=Q.top(),Q.pop();
			while(now.t<tim[now.id]||val[now.id]+1==val[next[now.id]]) now=Q.top(),Q.pop();
			if (now.id==1) ans=1;
			else if (next[now.id]==2) ans=n;
					else ans=now.lft+now.val+1;
			insert(now.id,ans);
			pos[x]=tot;
			printf("%d\n",ans);
		}
		if (op==2) del(pos[x]);
	}
	
	return 0;
}