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