AtCoder Grand Contest 037(without F)

AGC037 A - Dividing a String

洛谷传送门

AGC037A

---

分析

考虑每一段长度只可能是一或二，设 \(dp[i]\) 表示以 \(i\) 为结尾的前缀最多可以分成多少段。

如果 \(s[i]\) 和 \(s[i-1]\) 不同，那么 \(dp[i]=dp[i-1]+1\)，

否则可以将 \(s[i-2,i-1]\) 分成一段，把 \(s[i]\) 分成一段，那么 \(dp[i]=dp[i-3]+2\)

最后的答案就是 \(dp[n]\)

---

代码

#include <cstdio>
#include <cstring>
using namespace std;
const int N=200011;
int n,dp[N]; char s[N];
int main(){
	scanf("%s",s+1),n=strlen(s+1);
	for (int i=1;i<=n;++i)
	if (s[i]==s[i-1]){
		if (i>2) dp[i]=dp[i-3]+2;
	        else dp[i]=1;
	}else dp[i]=dp[i-1]+1;
	return !printf("%d",dp[n]);
}

---

AGC037 B - RGB Balls

洛谷传送门

AGC037B

---

分析

可以发现只要让第 \(i\) 个人选择每种字母的第 \(i\) 个就能让答案最小。

或者说，只要第三个字母及时匹配就可以让答案最小。

那么维护 \(RG,RB,GB\) 的配对情况，找到一个 \(B,G,R\) 就直接匹配掉。

也就是 \(n!\) 乘上实时可匹配的 \(RG,RB,GB\) 的个数。

---

代码

#include <cstdio>
using namespace std;
const int N=300011,mod=998244353;
int n,a[N],ans=1,c[11]; char s[N];
int main(){
	scanf("%d%s",&n,s+1);
	for (int i=1;i<=3*n;++i){
		if (s[i]=='R') a[i]=1;
		else if (s[i]=='G') a[i]=2;
		    else a[i]=4;
		if (c[7-a[i]]) ans=1ll*ans*(c[7-a[i]]--)%mod;
		else if (a[i]!=4&&c[3-a[i]]) ans=1ll*ans*(c[3-a[i]]--)%mod,++c[3];
		else if (a[i]!=2&&c[5-a[i]]) ans=1ll*ans*(c[5-a[i]]--)%mod,++c[5];
		else if (a[i]!=1&&c[6-a[i]]) ans=1ll*ans*(c[6-a[i]]--)%mod,++c[6];
		    else ++c[a[i]];
	}
	for (int i=1;i<=n;++i) ans=1ll*ans*i%mod;
	return !printf("%d",ans);
}

---

AGC037 C - Numbers on a Circle

洛谷传送门

AGC037C

---

分析

正过来考虑 \(a\) 挺难的，考虑用 \(b\) 倒过来考虑。

当 \(a_i>b_i\) 的时候就是无解，每次找到 \(b\) 未变成 \(a\) 的最大值，

减去 \(b_{i-1}+b_{i+1}\) 就相当于一个操作，这样不断用最大值减就能让答案尽量小。

那么如果 \(\large \frac{b_i-a_i}{b_{i-1}+b_{i+1}}\) 不小于一就可以进行操作，否则一定无解，因为两边的数字也减不了。

可以发现 \(b_i\) 减到不能再减（减去商乘除数）时至少会减半，所以时间复杂度为 \(O(n\log n\log {b_i})\)

---

代码

#include <cstdio>
#include <cctype>
#include <queue>
using namespace std;
const int N=200011;
int a[N],b[N],n;
long long ans;
int iut(){
	int ans=0; char c=getchar();
	while (!isdigit(c)) c=getchar();
	while (isdigit(c)) ans=ans*10+c-48,c=getchar();
	return ans;
}
struct One{
	int rk;
	bool operator <(const One &t)const{
	    return b[rk]<b[t.rk];
	}
};
priority_queue<One>q;
int main(){
	n=iut();
	for (int i=1;i<=n;++i) a[i]=iut();
	for (int i=1;i<=n;++i){
		b[i]=iut();
		if (a[i]>b[i]) return !printf("-1");
		if (a[i]<b[i]) q.push((One){i});
	}
	while (!q.empty()){
		One t=q.top(); q.pop();
		int delta=b[t.rk>1?(t.rk-1):n]+b[t.rk<n?(t.rk+1):1];
		if (b[t.rk]-a[t.rk]<delta) return !printf("-1");
		int now=(b[t.rk]-a[t.rk])/delta;
		ans+=now,b[t.rk]-=now*delta;
		if (b[t.rk]>a[t.rk]) q.push(t);
	}
	return !printf("%lld",ans);
}

---

AGC037 D - Numbers on a Circle

洛谷传送门

AGC037D

---

分析

可以发现 \(C\) 只需要满足 \(D\) 的每一行元素与 \(C\) 的每一行元素相同即可。

那么 \(B\) 只需要满足每一列的元素在 \(D\) 中对应的行都互不相同。

把每个元素按照所属的行染色，那么对于每一列跑一次二分图匹配，使得每一行恰好跟一种颜色匹配，

再通过流量判断是哪一行跟哪种颜色匹配，注意这条边不能退流，所以标记之后就不能走了。

时间复杂度 \(O(mn\sqrt{nm})\)

---

代码

#include <cstdio>
#include <cctype>
#include <algorithm>
#include <queue>
using namespace std;
const int N=211; struct node{int y,w,next;}e[N*N];
int dis[N],v[N*N],n,m,S,T,et=1,as[N],a[N][N],b[N][N];
int iut(){
	int ans=0; char c=getchar();
	while (!isdigit(c)) c=getchar();
	while (isdigit(c)) ans=ans*10+c-48,c=getchar();
	return ans;
}
void add(int x,int y,int w){
	e[++et]=(node){y,w,as[x]},as[x]=et;
	e[++et]=(node){x,0,as[y]},as[y]=et;
}
bool bfs(int S){
	for (int i=1;i<=T;++i) dis[i]=0;
	queue<int>q; q.push(S),dis[S]=1;
	while (!q.empty()){
		int x=q.front(); q.pop();
		for (int i=as[x];i;i=e[i].next)
		if (!v[i]&&e[i].w>0&&!dis[e[i].y]){
			dis[e[i].y]=dis[x]+1;
			if (e[i].y==T) return 1;
			q.push(e[i].y);
		}
	}
	return 0;
}
int min(int a,int b){return a<b?a:b;}
int dfs(int x,int now){
	if (x==T||!now) return now;
	int rest=0,f;
	for (int i=as[x];i;i=e[i].next)
	if (!v[i]&&e[i].w>0&&dis[e[i].y]==dis[x]+1){
		f=dfs(e[i].y,min(now-rest,e[i].w)),
		rest+=f,e[i].w-=f,e[i^1].w+=f;
		if (now==rest) return now;
	}
	if (!rest) dis[x]=0;
	return rest;
}
int main(){
	n=iut(),m=iut(),S=n<<1|1,T=S+1;
	for (int i=1;i<=n;++i) add(S,i,1),add(i+n,T,1);
	for (int i=1;i<=n;++i)
	for (int j=1;j<=m;++j){
		a[j][i]=iut();
	    add(i,(a[j][i]-1)/m+1+n,1);
    }
	for (int j=1;j<=m;++j){
		for (int i=2;i<=n*4;i+=2) e[i].w=1,e[i^1].w=0;
		while (bfs(S)) dfs(S,1e9);
		for (int i=1,t=n*4+2;i<=n;++i)
		for (int k=1;k<=m;++k,t+=2)
		    if (!e[t].w&&!v[t]) v[t]=v[t^1]=1,b[j][i]=a[k][i];
	}
	for (int i=1;i<=n;++i)
	for (int j=1;j<=m;++j) printf("%d%c",b[j][i],j==m?10:32);
	for (int j=1;j<=m;++j) sort(b[j]+1,b[j]+1+n);
	for (int i=1;i<=n;++i)
	for (int j=1;j<=m;++j) printf("%d%c",b[j][i],j==m?10:32);
	return 0;
}

---

AT5162 [AGC037E] Reversing and Concatenating

洛谷传送门

AGC037E

---

分析

找到 \(t\) 所能截取的字典序最小的 \(s\)，实际上只需要最后一次截取字典序最小的字符串即可。

或者说就是让最小的字符在开头出现的次数尽量多，并且每进行一次操作，最小的字符在开头出现次数会翻倍（第一次除外）。

那么 \(cnt*2^{k-1}\geq n\) 时实际上答案就是全部都是最小的字符，

否则就是前 \(cnt*2^{k-1}\) 个是最小的，之后的再用字典序最小的字符串补充即可。

可以用二分加哈希判断字典序最小字符串做到 \(O(n\log n)\)

---

代码

#include <cstdio>
#include <cctype>
using namespace std;
const int N=10011; typedef unsigned long long ull;
char s[N]; ull h[N],p[N]; int n,k,ans,len,mx;
int iut(){
	int ans=0; char c=getchar();
	while (!isdigit(c)) c=getchar();
	while (isdigit(c)) ans=ans*10+c-48,c=getchar();
	return ans;
}
ull query(int l,int r){return h[r]-h[l-1]*p[r-l+1];}
bool geq(int X,int Y){
	if (query(X,X+n-1)==query(Y,Y+n-1)) return 0;
	int l=0,r=n;
	while (l<r){
		int mid=(l+r+1)>>1;
		if (query(X,X+mid-1)!=query(Y,Y+mid-1)) r=mid-1;
		    else l=mid;
	}
	return s[X+l]>s[Y+l];
}
int main(){
	n=iut(),k=iut(),p[0]=1;
	for (int i=1;i<=n;++i){
	    char ch=getchar();
		while (!isalpha(ch)) ch=getchar();
		s[i]=s[n*2-i+1]=ch;
	}
	for (int i=1;i<=n*2;++i) h[i]=h[i-1]*13131+s[i];
	for (int i=1;i<=n*2;++i) p[i]=p[i-1]*13131;
	ans=n+1;
	for (int i=1;i<=n;++i) if (geq(ans,i)) ans=i;
	for (int i=0;i<n;++i)
	if (s[ans+i]==s[ans]) len=i+1;
		else break;
	if (k>14||(len<<(k-1))>=n) mx=n;
	    else mx=len<<(k-1);
	for (int i=1;i<=mx;++i) putchar(s[ans]);
	for (int i=0;i<n-mx;++i) putchar(s[ans+len+i]);
	return 0;
}