AGC048 部分题解

A

先判断 $S$ 字典序是否大于atcoder，是就输出 $0$。

否则往后面找到第一个不为a的字母，移到第一位即可。假如这个字母字典序比t还大，那么移到第二位就够了。

代码如下：

#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
#define maxn 100010
int T,n;
char s[maxn];
char s2[9]={' ','a','t','c','o','d','e','r',0};

int main()
{
	cin>>T;while(T--)
	{
		cin>>s+1;n=strlen(s+1);
		int v=0;
		for(int i=1;i<=min(n,7);i++){
			if(s[i]>s2[i]){v=1;break;}
			if(s[i]<s2[i]){v=-1;break;}
		}
		if(v==1||(!v&&n>7)){cout<<"0\n";continue;}
		int st=1;while(st<=n&&s[st]=='a')st++;
		if(st>n)cout<<"-1\n";
		else{
			if(st>1&&s[st]>'t')cout<<st-2<<"\n";
			else cout<<st-1<<"\n";
		}
	}
}

B

先假设全部位置都用圆括号，然后考虑将一些位置变成方括号。

假设一对方括号的位置为 $x,y$，那么 $y-x+1$ 一定是偶数，即 $x,y$ 的奇偶性一定不同。

然后可以发现，假如选出的变成方括号的位置集合为 X = { x 1 , x 2 , . . . , x k } X=\{x_1,x_2,...,x_k\} X={x1​,x2​,...,xk​}，那么 $X$ 内奇数和偶数各占一半。而奇数和偶数各占一半的集合，一定对应一个合法的括号序列。

一种简单的构造方案是：将 $X$ 内的元素排序，每次找到一对相邻的并且奇偶性不同的 $x_i,x_{i+1}$（显然如果 $X$ 不为空那么一定存在这样的一对数），将 $[x_i,x_{i+1}]$ 区间的括号序列变成[()()...()()]，内部已经被操作过的区间不变，然后将这一对数从 $X$ 中删除。重复这个操作直到 $X$ 为空，这样这个序列就造好了。

现在的问题是：选一些位置变成方括号，并且选出来的位置奇数和偶数各占一半。这个贪心即可，将 $B_i-A_i$ 进行排序，奇数位和偶数位的分别排，然后每次选最大的两个，看看是否大于 $0$，是就选上。

代码如下：

#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
#define maxn 100010
 
int n,a[maxn];
vector<int> b[2];
long long ans=0;
 
int main()
{
	scanf("%d",&n);
	for(int i=1;i<=n;i++){
		scanf("%d",&a[i]);
		ans+=a[i];
	}
	for(int i=1,x;i<=n;i++){
		scanf("%d",&x);
		b[i&1].push_back(x-a[i]);
	}
	for(int i=0;i<2;i++)sort(b[i].begin(),b[i].end());
	for(int i=n/2-1;i>=0;i--){
		int val=b[0][i]+b[1][i];
		if(val<=0)break;
		ans+=val;
	}
	printf("%lld",ans);
}

C

考虑相邻两只企鹅之间的空隙长度，记为 $c_i=A_{i+1}-A_i-1$，那么企鹅的一次移动等价于使 $j=i+1/i-1$，让 $c_j+=c_i,c_i:=0$。

记 $d_i=B_{i+1}-B_i-1$，那么对于 $d_i>0$ 的 $i$，这段空隙肯定等于 $c$ 的一个区间 $[l,r]$ 的和，对于 $i>j$ 且 $d_i>0,d_j>0$，那么 $j$ 对应的区间一定在 $i$ 对应的区间前面。即对应的区间是有单调性的，并且这些区间不可能有交集，于是扫一遍就能得到这些区间。

而要将一个区间 $[l,r]$ 的值全部累加到 $i$ 位置，需要的操作次数为 $\max (i-l,0)+\max (r-i,0)$，这个操作次数的总和就是答案，虽然需要考虑不同 $i$ 之间操作的影响，但是由于区间有单调性，所以这个下限总是可以达到的，方案也不难构造。

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define maxn 100010

int n,l,a[maxn],b[maxn],c[maxn],d[maxn];
long long ans=0;

int main()
{
	scanf("%d %d",&n,&l);
	for(int i=1;i<=n;i++)scanf("%d",&a[i]);a[n+1]=l+1;
	for(int i=1;i<=n;i++)scanf("%d",&b[i]);b[n+1]=l+1;
	for(int i=0;i<=n;i++)c[i]=a[i+1]-a[i]-1;
	for(int i=0;i<=n;i++)d[i]=b[i+1]-b[i]-1;
	for(int i=0,j=0;i<=n;i++)if(d[i]){
		while(c[j]==0)j++;
		int l=j,s=0;
		while(j<=n&&s<d[i])s+=c[j++];
		if(s!=d[i])return printf("-1"),0;
		ans+=max(i-l,0)+max(j-1-i,0);
	}
	printf("%lld",ans);
}

D

有一个性质：一个人每次要么拿一个，那么拿一堆，不可能拿 $k\in (1,a_l)$ 个。如果拿了 $k$ 个，那么下一次就只能拿 $[1,a_l-k]$ 个，如果拿 $1$ 个，那么下一次可以拿 $[1,a_l-1]$ 个，显然后者的决策范围包含前者，所以前者一定不优。

然后考虑 $\text{dp}$，设 $l_{i,j}$ 表示 两人只用 $[i,j]$ 范围内的石子进行游戏，左方先手，且可以任意修改 $a_i$ 的初值，则 $a_i$ 至少为多少可以使左方必胜。

类似的，定义出 $r_{i,j}$：右方先手，则 $a_j$ 至少为多少可以使右方必胜。

$r$ 的转移和 $l$ 类似，这里只说 $l$ 的。

转移有两种：取一个或取一堆。如果 $A_j<r_{i+1,j}$，那么左方直接取一堆，右方就变成了必败态，即左方无论 $a_i$ 是多少都必胜，让 $l_{i,j}=1$。

否则，两个人肯定轮流一个一个取，直到某一方发现，自己取完之后对面必败，那么他就肯定会选择取完。

当左方取了 $l_{i,j}-l_{i,j-1}+1$ 个时，右方直接取完，则右方胜利。当右方取了 $a_j-r_{i+1,j}+1$ 个时，左方直接取完，则左方胜利。要使左方必胜，则需要满足：
$$\begin{gathered} l_{i,j}-l_{i,j-1}+1>a_j-r_{i+1,j}+1 \\ {l}_{i,j}>a_j-r_{i+1,j}+l_{i,j-1} \end{gathered}$$

所以 $l_{i,j}$ 的最小值为 $a_j-r_{i+1,j}+l_{i,j-1}+1$。

代码如下：

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define maxn 110
#define ll long long

int T,n;
ll a[maxn];
ll l[maxn][maxn],r[maxn][maxn];

int main()
{
	scanf("%d",&T);while(T--)
	{
		scanf("%d",&n);
		for(int i=1;i<=n;i++){
			scanf("%lld",&a[i]);
			l[i][i]=r[i][i]=1;
		}
		for(int len=2;len<=n;len++){
			for(int i=1;i+len-1<=n;i++){
				int j=i+len-1;
				if(a[j]<r[i+1][j])l[i][j]=1;
				else l[i][j]=a[j]-r[i+1][j]+l[i][j-1]+1;
				if(a[i]<l[i][j-1])r[i][j]=1;
				else r[i][j]=a[i]-l[i][j-1]+r[i+1][j]+1;
			}
		}
		if(a[1]>=l[1][n])printf("First\n");
		else printf("Second\n");
	}
}