AtCoder Grand Contest 037

Preface

这篇咕了可能快一个月了吧，正好今天晚上不想做题就来补博客

现在还不去复习初赛我感觉我还是挺刚的（微笑）

---

A - Dividing a String

考虑最好情况把每个字符串当作一个来看，考虑不合法的情况怎么处理

可以很容易地发现再怎么差我长度分成\(1,2,1,2,\cdots\)的样子就好了，因此字符串最长为\(2\)

贪心地把后面的数和前面合并即可

#include<cstdio>
#include<cstring>
#define RI register int
#define CI const int&
using namespace std;
const int N=200005;
char s[N]; int n,ans,pos;
int main()
{
	scanf("%s",s+1); n=strlen(s+1); ans=n; pos=1;
	for (RI i=2;i<=n;++i)
	if (s[i]==s[pos]) --ans,pos=i+2,i+=2; else pos=i;
	return printf("%d",ans),0;
}

---

B - RGB Balls

这道题我想了比C题长了一个小时你敢相信

首先不考虑顺序，最后乘上\(n!\)，那么我们考虑答案\(\sum (c_i-a_i)=\sum c_i-\sum a_i\)，要么就是在\(\sum c_i\)确定的情况下让\(\sum a_i\)最大，或者是在\(\sum a_i\)确定的情况下让\(\sum c_i\)最小

那么我们考虑从后忘前做，考虑当前匹配的是\(R\)，那么一旦之前出现过\(BG\)，就一定要让这个\(R\)和它们匹配，否则就会使\(\sum a_i\)确定的情况下让\(\sum c_i\)变大

换而言之，如果出现过\(BG\)种的一种，那么我们必须匹配成\(RB\)或\(RG\)，否则就会使\(\sum c_i\)确定的情况下让\(\sum a_i\)变小

否则单独拿出来，顺便统计答案即可

#include<cstdio>
#define RI register int
#define CI const int&
using namespace std;
const int N=300005,mod=998244353;
char s[N]; int n,ans,r,b,g,rb,rg,bg;
int main()
{
	RI i; for (scanf("%d%s",&n,s+1),ans=i=1;i<=n;++i)
	ans=1LL*ans*i%mod; for (i=3*n;i;--i)
	switch (s[i])
	{
		case 'R':
			if (bg) ans=1LL*ans*(bg--)%mod; else
			if (b) ans=1LL*ans*(b--)%mod,++rb; else
			if (g) ans=1LL*ans*(g--)%mod,++rg; else ++r;
			break;
		case 'G':
			if (rb) ans=1LL*ans*(rb--)%mod; else
			if (r) ans=1LL*ans*(r--)%mod,++rg; else
			if (b) ans=1LL*ans*(b--)%mod,++bg; else ++g;
			break;
		case 'B':
			if (rg) ans=1LL*ans*(rg--)%mod; else
			if (r) ans=1LL*ans*(r--)%mod,++rb; else
			if (g) ans=1LL*ans*(g--)%mod,++bg; else ++b;
			break;
	}
	return printf("%d",ans),0;
}

---

C - Numbers on a Circle

首先这种操作这么神仙有可逆性的题目我们肯定要倒过来考虑，把加变成减

然后我们发现一个十分有趣的性质，当\(i\)能操作使\(i-1\)与\(i+1\)使不能操作的（因为一操作就变负了）

那么换句话说此时\(i\)操作减去的数不会再改变，因此操作多少次可以直接除一下

发现操作的顺序就是按照数的大小顺序操作的，因此我们把所有能操作的数扔进一个队列里，然后做完一个数考虑它两边的数能不能被操作即可

#include<cstdio>
#include<queue>
#define RI register int
#define CI const int&
using namespace std;
const int N=200005;
int n,a[N],b[N],pre[N],nxt[N]; long long ans; queue <int> q; bool vis[N];
inline bool check(CI id)
{
	return b[id]-a[id]>=b[pre[id]]+b[nxt[id]];
}
int main()
{
	RI i; for (scanf("%d",&n),i=1;i<=n;++i) scanf("%d",&a[i]);
	for (i=1;i<=n;++i) scanf("%d",&b[i]),pre[i]=i-1,nxt[i]=i+1;
	for (nxt[pre[1]=n]=i=1;i<=n;++i) if (check(i)) q.push(i),vis[i]=1;
	while (!q.empty())
	{
		int nw=q.front(); vis[nw]=0; q.pop();
		int cur=(b[nw]-a[nw])/(b[pre[nw]]+b[nxt[nw]]);
		ans+=cur; b[nw]-=cur*(b[pre[nw]]+b[nxt[nw]]);
		if (!vis[pre[nw]]&&check(pre[nw])) q.push(pre[nw]),vis[pre[nw]]=1;
		if (!vis[nxt[nw]]&&check(nxt[nw])) q.push(nxt[nw]),vis[nxt[nw]]=1;
	}
	for (i=1;i<=n;++i) if (a[i]!=b[i]) return puts("-1"),0;
	return printf("%lld",ans),0;
}

---

D - Sorting a Grid

我们考虑将输入看作一个\(n\times m\)的二元组\((x_i,y_i)\)，来表示\(i\)这个数必须从第\(x_i\)行走的第\(y_i\)行，且它们需要被放置同一列

那么我们如果建出这样的二分图，把\(x_i\)向\(y_i\)连边，跑一个最大匹配，那此时的方案可以作为第一列的方案

然后考虑霍尔定理，我们发现此时每个点的度数都是\(M\)，因此存在完美匹配

考虑每次找出一个匹配用来填某一列，然后删掉对应的边重复填即可

套路的不能再套路的题目

#include<cstdio>
#include<vector>
#include<cstring>
#include<iostream>
#include<assert.h>
#define RI register int
#define CI const int&
using namespace std;
const int N=205,M=100005,INF=1e9;
int n,m,a[N][N],fr[N*N],to[N*N],b[N][N],c[N][N],p[N]; vector <int> eg[N][N];
class Network_Flow
{
	private:
		struct edge
		{
			int to,nxt,v;
		}e[M]; int head[N],cur[N],s,t,cnt,dep[N],q[N];
		inline void addedge(CI x,CI y)
		{
			e[++cnt]=(edge){y,head[x],1}; head[x]=cnt;
			e[++cnt]=(edge){x,head[y],0}; head[y]=cnt;
		}
		#define to e[i].to
		inline bool BFS(CI s,CI t)
		{
			RI H=0,T=1; memset(dep,-1,t+1<<2); dep[q[1]=s]=0;
			while (H<T)
			{
				int now=q[++H]; for (RI i=head[now];i;i=e[i].nxt)
				if (e[i].v&&!~dep[to]) dep[to]=dep[now]+1,q[++T]=to;
			}
			return ~dep[t];
		}
		inline int DFS(CI now,CI t,int dis)
		{
			if (now==t) return dis; int ret=0;
			for (RI& i=cur[now];i&&dis;i=e[i].nxt)
			if (e[i].v&&dep[to]==dep[now]+1)
			{
				int dist=DFS(to,t,min(e[i].v,dis));
				dis-=dist; ret+=dist; e[i].v-=dist; e[i^1].v+=dist;
			}
			if (!ret) dep[now]=0; return ret;
		}
		#undef to
	public:
		inline void init(void)
		{
			RI i,j; memset(head,0,(t=(n<<1|1))+1<<2); cnt=1;
			for (i=1;i<=n;++i) addedge(s,i),addedge(n+i,t);
			for (i=1;i<=n;++i) for (j=1;j<=n;++j)
			if (!eg[i][j].empty()) addedge(i,n+j);
		}
		inline void Dinic(void)
		{
			int ret=0; while (BFS(s,t))	memcpy(cur,head,t+1<<2),ret+=DFS(s,t,INF);
			assert(ret==n); for (RI i=1,j;i<=n;++i)
			for (j=head[i];j;j=e[j].nxt) if (e[j].to!=s&&!e[j].v) p[i]=e[j].to-n;
		}
}NF;
int main()
{
	RI i,j,k; for (scanf("%d%d",&n,&m),i=1;i<=n;++i)
	for (j=1;j<=m;++j) scanf("%d",&a[i][j]),fr[a[i][j]]=i;
	for (i=1;i<=n;++i) for (j=1;j<=m;++j) to[(i-1)*m+j]=i;
	for (i=1;i<=n*m;++i) eg[fr[i]][to[i]].push_back(i);
	for (k=1;k<=m;++k) for (NF.init(),NF.Dinic(),i=1;i<=n;++i)
	b[i][k]=c[p[i]][k]=eg[i][p[i]].back(),eg[i][p[i]].pop_back();
	for (i=1;i<=n;++i) for (j=1;j<=m;++j) printf("%d%c",b[i][j]," \n"[j==m]);
	for (i=1;i<=n;++i) for (j=1;j<=m;++j) printf("%d%c",c[i][j]," \n"[j==m]);
	return 0;
}

---

E - Reversing and Concatenating

考虑分类讨论，其实这题的情况还是挺好分析的

首先为了让字典序最小，我们肯定考虑尽量复制原来字符串种字典序最小的字符

• 若字符串的最后一个字符为最小的，连续长度为\(L\)，那么此时的开头字符为最小值的长度就是\(L\times 2^K\)
• 若字符串中间的一段最长的字符连续长度为\(L\)，那么此时的开头字符为最小值的长度就是\(L\times 2^{K-1}\)

发现数据范围很小，我们直接暴枚从那个地方为结尾开始取即可，复杂度\(O(n^2)\)

#include<cstdio>
#include<iostream>
#define RI register int
#define CI const int&
using namespace std;
const int N=10005;
char s[N],mi='z',ans[N],tp[N]; int n,k;
inline bool cmp_min(char *a,char *b)
{
	for (RI i=1;i<=n;++i)
	if (a[i]!=b[i]) return a[i]<b[i]; return 0;
}
inline void solve(char *s,int k)
{
	int nw=n,len=0; while (nw&&s[nw]==mi) --nw,++len;
	while (k&&len<n) --k,len<<=1; len=min(n,len);
	RI i; for (i=1;i<=len;++i) tp[i]=mi;
	for (i=len+1;i<=n;++i) tp[i]=s[nw--];
	if (cmp_min(tp,ans)) for (i=1;i<=n;++i) ans[i]=tp[i];
}
int main()
{
	RI i; for (scanf("%d%d%s",&n,&k,s+1),i=1;i<=n;++i)
	mi=min(s[i],mi),s[(n<<1)-i+1]=s[i],ans[i]='z';
	if (s[n]==mi) solve(s,k);
	for (i=n+1;i<=(n<<1);++i) if (s[i]==mi) solve(s+i-n,k-1);
	return puts(ans+1),0;
}

---

F - Counting of Subarrays

我菜死了根本不会做，留着以后填坑，题解可以看曲明姐姐的

---

Postscript

哎呀比赛的坑可好歹是填完了，又要开新的坑了\kel