IOI2020集训队作业 -17 (CF536D, AGC027F, AGC024E)

A - CF536D Tavas in Kansas

Sol

将每个点抽象成二维平面上的点，横坐标为这个点到$s$的最短路长度，纵坐标为这个点到$t$的最短路的长度。则任意时刻还没有选过的点总是在右上角的一个矩形内。以矩形的左下角位置作为状态进行$dp$，转移可以前缀和优化。时间复杂度$O(n^2)$。

Code

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
#define ll long long
using namespace std;
template <class T>
inline void rd(T &x) {
	x=0; char c=getchar(); int f=1;
	while(!isdigit(c)) { if(c=='-') f=-1; c=getchar(); }
	while(isdigit(c)) x=x*10-'0'+c,c=getchar(); x*=f;
}
const int N=2010;
const ll inf=1e18;
int head[N],ecnt;
struct ed { int to,next,w; }e[200010];
void ad(int x,int y,int w) {
	e[++ecnt]=(ed){y,head[x],w}; head[x]=ecnt;
	e[++ecnt]=(ed){x,head[y],w}; head[y]=ecnt;
}
struct node {
	int u; ll d;
	node(int u=0,ll d=0): u(u),d(d) {}
	friend bool operator <(node A,node B) { return A.d>B.d; }
};
int n,m;
void dijkstra(int s,ll *dis) {
	static int vis[N];
	priority_queue<node> que;
	for(int i=1;i<=n;++i) dis[i]=inf,vis[i]=0;
	dis[s]=0,que.push(node(s,dis[s]));
	while(!que.empty()) {
		int u=que.top().u; que.pop();
		if(vis[u]) continue; vis[u]=1;
		for(int k=head[u];k;k=e[k].next) {
			int v=e[k].to;
			if(dis[v]>dis[u]+e[k].w) {
				dis[v]=dis[u]+e[k].w;
				que.push(node(v,dis[v]));
			}
		}
	}
}
void uni(ll *A,int &m) {
	static ll x[N]; int cnt=0;
	for(int i=1;i<=n;++i) x[++cnt]=A[i];
	sort(x+1,x+cnt+1);
	m=unique(x+1,x+cnt+1)-x-1;
	for(int i=1;i<=n;++i) A[i]=lower_bound(x+1,x+m+1,A[i])-x;
}
ll dis[2][N],val[N];
ll sum[N][N],f[2][N][N],g[2][N][N];
int siz[N][N],pos[2][N];
int X,Y;
ll Q(int x1,int y1,int x2,int y2) {
	if(siz[x1][y1]-siz[x2][y2]==0) return -inf;
	return sum[x1][y1]-sum[x2][y2];
}
int main() {
	rd(n),rd(m);
	int s,t; rd(s),rd(t);
	for(int i=1;i<=n;++i) rd(val[i]);
	for(int i=1,x,y,w;i<=m;++i) rd(x),rd(y),rd(w),ad(x,y,w);
	dijkstra(s,dis[0]),dijkstra(t,dis[1]);
	uni(dis[0],X),uni(dis[1],Y);
	for(int i=1;i<=n;++i)
		sum[dis[0][i]][dis[1][i]]+=val[i],
		siz[dis[0][i]][dis[1][i]]++;
	for(int i=X;i>=1;--i)
		for(int j=Y;j>=1;--j)
			sum[i][j]+=sum[i+1][j]+sum[i][j+1]-sum[i+1][j+1],
			siz[i][j]+=siz[i+1][j]+siz[i][j+1]-siz[i+1][j+1];
	memset(f,-0x3f,sizeof(f));
	
	for(int i=1;i<=X;++i) pos[1][i]=Y+1;
	for(int j=1;j<=Y;++j) pos[0][j]=X+1;
	
	for(int i=X+1;i>=1;--i)
		for(int j=Y+1;j>=1;--j)
			for(int d=0;d<2;++d) {
				if(!siz[i][j]) {
					f[d][i][j]=0;
					continue;
				}
				if(d==0) {
//					for(int k=i+1;k<=X+1;++k)
//						f[d][i][j]=max(f[d][i][j],Q(i,j,k,j)-f[d^1][k][j]);
					while(Q(i,j,pos[0][j]-1,j)>-inf) pos[0][j]--;
					f[0][i][j]=sum[i][j]-g[1][pos[0][j]][j];
					g[0][i][j]=min(g[0][i][j+1],f[0][i][j]+sum[i][j]);
				}
				else {
//					for(int k=j+1;k<=Y+1;++k)
//						f[d][i][j]=max(f[d][i][j],Q(i,j,i,k)-f[d^1][i][k]);
					while(Q(i,j,i,pos[1][i]-1)>-inf) pos[1][i]--;
					f[1][i][j]=sum[i][j]-g[0][i][pos[1][i]];
					g[1][i][j]=min(g[1][i+1][j],f[1][i][j]+sum[i][j]);
				}
			}
	if(f[0][1][1]>0) printf("Break a heart");
	else if(f[0][1][1]==0) printf("Flowers");
	else printf("Cry");
	return 0;
}

---

B - AGC027F Grafting

Sol

若已知某一个点$rt$在整个过程中不会被染黑，则可以用以下算法解决问题：

• 以$rt$为根对两棵树$dfs$找出每个点的父亲。操作转化成修改叶子结点的父亲，并且每个点只能被改一次。
• 不需要修改的点必须形成一个包含$rt$的连通块；对于需要修改的点我们只需要确定它们被修改的顺序：原图中的儿子必须先于父亲，目标图中的父亲必须先于儿子。这个可以toposort解决。

对于原问题，枚举第一步的操作就可以转化成上述问题。

Code

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
#include <queue>
#define PB push_back
#define ll long long
using namespace std;
template <class T>
inline void rd(T &x) {
	x=0; char c=getchar(); int f=1;
	while(!isdigit(c)) { if(c=='-') f=-1; c=getchar(); }
	while(isdigit(c)) x=x*10-'0'+c,c=getchar(); x*=f;
}
const int N=55;
int n;
namespace Gr {
	vector<int> G[N];
	queue<int> que;
	int du[N];
	void init() { for(int i=1;i<=n;++i) G[i].clear(),du[i]=0; }
	void ad(int x,int y) {
//		cout<<x<<' '<<y<<endl;
		G[x].PB(y);
		du[y]++;
	}
	bool sol() {
		int cnt=0;
		for(int i=1;i<=n;++i) if(!du[i]) que.push(i);
		while(!que.empty()) {
			cnt++; int u=que.front(); que.pop();
			for(int i=0;i<G[u].size();++i) {
				int v=G[u][i];
				if(!(--du[v])) que.push(v);
			}
		}
		return cnt==n;
	}
}
vector<int> G[2][N];
int fa[2][N];
int mp[2][N][N];
int flg;
int dfs2(int u) {
	int tot=1;
	for(int v=1;v<=n;++v)
		if(fa[0][v]==u&&fa[1][v]==u)
			tot+=dfs2(v);
	return tot;
}
void dfs(int p,int u,int last) {
	fa[p][u]=last;
	for(int i=0;i<G[p][u].size();++i)
		if(G[p][u][i]!=last) dfs(p,G[p][u][i],u);
}
int vis[N],tot_siz;
void check(int u) {
	if(vis[u]) return; tot_siz++,vis[u]=1;
	for(int i=0;i<G[0][u].size();++i) check(G[0][u][i]);
}
int sol(int rt) {
//	cout<<"SOL:"<<rt<<endl;
	for(int d=0;d<2;++d)
		for(int u=1;u<=n;++u) {
			G[d][u].clear();
			for(int v=1;v<=n;++v) if(mp[d][u][v])
				G[d][u].PB(v);
		}
	{
		tot_siz=0;
		for(int i=1;i<=n;++i) vis[i]=0;
		check(1);
		if(tot_siz<n) return 0;
	}		
		
	dfs(0,rt,0);
	dfs(1,rt,0);
	Gr::init();
	int cnt=0;
	for(int i=1;i<=n;++i)
		if(fa[0][i]!=fa[1][i]) {
			if(fa[1][fa[1][i]]!=fa[0][fa[1][i]]) Gr::ad(fa[1][i],i);
			if(fa[1][fa[0][i]]!=fa[0][fa[0][i]]) Gr::ad(i,fa[0][i]);
		}
		else cnt++;
	if(dfs2(rt)!=cnt) return 0;
	
	if(Gr::sol()) {
//		cout<<"OK"<<endl;
		flg=1; int cnt=0;
		for(int i=1;i<=n;++i) cnt+=fa[1][i]==fa[0][i];
		return cnt;
	}
  	return 0;
}

int main() {
	int T; rd(T);
	while(T--) {
		flg=0;
		rd(n);
		for(int i=1,x,y;i<n;++i) rd(x),rd(y),mp[0][x][y]=mp[0][y][x]=1;
		for(int i=1,x,y;i<n;++i) rd(x),rd(y),mp[1][x][y]=mp[1][y][x]=1;
		int ans=sol(1);
		for(int u=1;u<=n;++u) {
			int t=0; for(int v=1;v<=n;++v) t+=mp[0][u][v];
			if(t>1) continue;
			for(int v=1;v<=n;++v) if(mp[0][u][v])
				for(int w=1;w<=n;++w) if(!mp[0][u][w]) {
					mp[0][u][v]=mp[0][v][u]=0;
					mp[0][u][w]=mp[0][w][u]=1;
					ans=max(ans,sol(u)-1);
					mp[0][u][v]=mp[0][v][u]=1;
					mp[0][u][w]=mp[0][w][u]=0;
				}
		}
		if(!flg) printf("-1\n");
		else printf("%d\n",n-ans);
		for(int d=0;d<2;++d)
			for(int i=1;i<=n;++i)
				for(int j=1;j<=n;++j)
					mp[d][i][j]=0;
	}
	return 0;
}

---

C - AGC024E Sequence Growing Hard

Sol

如果直接数“往$A_i$添加一个元素得到$A_{i+1}$使得$A_i< A_{i+1}$”的方案数，有一种情况会被数多次，即往一段相同的数中再插入一个这个数：xxxxxxx，xxxxxxx，xxxxxxx，xxxxxxx……所以我们规定，这种情况下我们只数xxxxxxx（也就是新加的数在末尾）。

观察发现合法的条件是，加入的这个数严格大于上个序列中与它位置相同的数。

建一棵树，树上有$n+1$个节点，每个点的编号代表它是第几个序列中插入的元素，节点的权值就是元素的权值。根节点是空节点，可以认为编号为$0$，权值为$0$；对于其它节点，它的父亲表示它插入时上个序列中与它位置相同的数。显然有每个点的编号要大于父亲的编号，且每个点的权值严格大于父亲的权值；并且一个确定的这样的一棵树，我们可以唯一地还原出序列。所以对这样的树形结构计数就可以了。

Code

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#define ll long long
using namespace std;
template <class T>
inline void rd(T &x) {
	x=0; char c=getchar(); int f=1;
	while(!isdigit(c)) { if(c=='-') f=-1; c=getchar(); }
	while(isdigit(c)) x=x*10-'0'+c,c=getchar(); x*=f;
}
const int N=310;
int mod;
int n,m;
int f[N][N],s[N][N];
int C[N][N];
int main() {
	rd(n),rd(m),rd(mod);
	for(int i=0;i<=n;++i) for(int j=0;j<=i;++j) C[i][j]=j?(C[i-1][j-1]+C[i-1][j])%mod:1;
	for(int i=m;i>=0;--i) f[1][i]=1,s[1][i]=(s[1][i+1]+f[1][i])%mod;
	for(int i=2;i<=n+1;++i) {
		for(int j=0;j<=m;++j)
			for(int z=1;z<i;++z) {
				f[i][j]=(f[i][j]+f[i-z][j]*(ll)s[z][j+1]%mod*C[i-2][z-1]%mod)%mod;
			}

		for(int j=m;j>=0;--j) s[i][j]=(s[i][j+1]+f[i][j])%mod;
	}
	printf("%d",f[n+1][0]);
	return 0;
}

来源：CSDN

作者：zhongyuwei20031224

链接：https://blog.csdn.net/weixin_45313881/article/details/103710882