2018-2019 ICPC, NEERC, Southern Subregional Contest 部分题解

A. Find a Number

思路：从0开始bfs搜索就好了，直到模数等于0且数字和等于s就好了。

 

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<queue>
using namespace std;
struct node
{
	char s[605];
	int mod,sum,len;
	node()
	{
		mod=sum=0;
		len=-1;
		memset(s,0,sizeof(s));
	}
};
int d[550][5050];
int main()
{
	int s,sum;
	cin>>s>>sum;
	queue<node>q;
	for(int i=0;i<=500;i++)
	memset(d[i],0,sizeof(d[i]));
	node tmp;
	q.push(tmp);
	while(!q.empty())
	{
		node e=q.front();q.pop();
		for(int i=0;i<10;i++)
		{
			node ne=e;
			ne.len++;
			ne.s[ne.len]='0'+i;
			ne.mod=(ne.mod*10+i)%s;
			ne.sum+=i;
			if(d[ne.mod][ne.sum]||ne.sum>sum)continue;
			d[ne.mod][ne.sum]=1;
			if(ne.mod==0&&ne.sum==sum)
			{
				puts(ne.s);
				return 0;
			}
			q.push(ne);
		}
	}
	cout<<-1;
}

C. Cloud Computing

题意：一个公司每天需要k个cpu，要持续n天，有m个租售cpu方案，每次方案给定一个租售日期区间和单价p以及租售的cpu数量c。你要选择若干种方案，使得满足公司需求且花费最小，求最小花费。

思路：线段树区间覆盖，每个点初始值为0，表示这一天已租的cpu数量为0，将方案数按照单价从小到大排序，然后线段树区间覆盖，直到线段树区间的所有值都为k即可。

#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const int maxn=1e6+10;
int Min[maxn*8],Max[maxn*8],add[maxn*8],n,k,m,p;
ll ans=0;
struct node
{
	int l,r,c,p;
	bool operator<(const node& t)
	{
		return p<t.p;
	}
}a[maxn];
void pushdown(int o,int ls,int rs)
{
	add[ls]+=add[o],add[rs]+=add[o];
	Min[ls]+=add[o],Min[rs]+=add[o];
	Max[ls]+=add[o],Max[rs]+=add[o];
	add[o]=0;
}
void pushup(int o,int ls,int rs)
{
	Min[o]=min(Min[ls],Min[rs])+add[o];
	Max[o]=max(Max[ls],Max[rs])+add[o];
}
void up(int l,int r,int o,int ql,int qr)
{
	int mid=(l+r)/2,ls=o*2,rs=o*2+1;
	if(Min[o]==m)return;
	if(l>=ql&&r<=qr)
	{
		if(Max[o]==Min[o])
		{
			if(a[p].c+Min[o]<=m)
			{
				add[o]+=a[p].c;
				ll tmp=1ll*(r-l+1)*a[p].c*a[p].p;
				ans+=tmp;
				pushup(o,ls,rs);
			}
			else
			{
				int t=m-Min[o];
				add[o]+=t;
				ll tmp=1ll*(r-l+1)*a[p].p*t;
				ans+=tmp;
				pushup(o,ls,rs);
			}
			return;
		}
		else if(Max[o]+a[p].c<=m)
		{
			add[o]+=a[p].c;
			ans+=1ll*(r-l+1)*a[p].c*a[p].p;
			pushup(o,ls,rs);
			return;
		}
		else{
			if(add[o])pushdown(o,ls,rs);
			up(l,mid,ls,ql,qr);
			up(mid+1,r,rs,ql,qr);
			pushup(o,ls,rs);
			return;
		}
	}
	if(add[o])pushdown(o,ls,rs);
	if(ql<=mid)up(l,mid,ls,ql,qr);
	if(qr>mid)up(mid+1,r,rs,ql,qr);
	pushup(o,ls,rs);
}
int main()
{
	scanf("%d%d%d",&n,&m,&k);
	for(int i=1;i<=k;i++)
	scanf("%d%d%d%d",&a[i].l,&a[i].r,&a[i].c,&a[i].p);
	sort(a+1,a+1+k);
	for(int i=1;i<=k;i++)
	{
		p=i;
		up(1,n,1,a[i].l,a[i].r);
		if(Min[1]==m)break;
	}
	printf("%I64d",ans);
}

G. Monsters and Potions

题意：在一个长度最多为100的区间内，你有m个英雄，每个点都有一个hp，如果hp是正的，英雄路过这个点其血量就加hp，如果为负的英雄路过那英雄的血量就减去hp（英雄的hp为负数就阵亡），每个点的hp如果被用了一次，那么就一直为0，求一个点，所有英雄都能走到这个点。

思路：长度最大为100，当然暴力枚举每个点，然后再bfs暴力搜素即可，n^4复杂度过之。

#include<cstdio>
#include<cstring>
#include<queue>
#include<iostream>
#include<algorithm>
using namespace std;
struct node
{
	int x,h,id;
	node(int a,int b,int c)
	{
		x=a,h=b,id=c;
	}
};
int a[105],b[105],x[105],h[105],ans[105],vis[105][105];
queue<node>q;
int main()
{
	int n,m;
	cin>>n>>m;
	for(int i=1;i<=m;i++)
	cin>>x[i]>>h[i];
	for(int i=1;i<=n;i++)
	cin>>a[i],b[i]=a[i];
	for(int pos=1;pos<=n;pos++)
	{
		int cnt=0;
		for(int i=1;i<=m;i++)
		{
			q.push(node(x[i],h[i],i));
			memset(vis[i],0,sizeof(vis[i]));	
		}
		for(int i=1;i<=n;i++)a[i]=b[i];
		while(!q.empty())
		{
			node e=q.front();q.pop();
			//if(pos==3)
			//printf("id=%d x=%d h=%d\n",e.id,e.x,e.h);
			if(vis[e.id][e.x]==n)continue;
			vis[e.id][e.x]++;
			if(e.x==pos)
			{
				ans[++cnt]=e.id;
				continue;
			}
			int xx=e.x,hh=e.h;
			while(pos>e.x&&e.h+a[e.x+1]>=0)++e.x,e.h+=a[e.x];
			while(pos<e.x&&e.h+a[e.x-1]>=0)--e.x,e.h+=a[e.x];
			int t1=min(xx,pos),t2=max(xx,pos); 
			if(e.x==pos)
				for(int k=t1;k<=t2;k++)
				a[k]=0;
			else
			e.x=xx,e.h=hh;
			q.push(e);
		}
		if(cnt==m)
		{
			printf("%d\n",pos);
			for(int i=1;i<=cnt;i++)cout<<ans[i]<<" ";
			return 0;
		}
		//printf("pos=%d cnt=%d\n",pos,cnt);
		//for(int i=1;i<=cnt;i++)cout<<ans[i]<<" ";
		//puts("");
	}
	puts("-1");
}

I. Privatization of Roads in Berland

题意：给你一张图，要求给边涂色，要求同一个颜色最多用两次，且每个点连接的边的不同的颜色至多为k，求染色方案。

思路：设du[ i ]为该点连接的边数，如果du[ i ]<=k，随便染色不影响，如果du[ i ]>k，那么必定有2*(du[ i ]-k)条边，其颜色是用两次的，那么我可以从源点连接点 i ，流量为2*(du[ i ]-k)，代表有这么多的边是要用重复颜色的，每条边看做一个点，并且连接到汇点，流量为1，代表这边只能用一次，然后题目给的所有边流量都为1，然后求最大流即可。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<queue>
#include<map>
using namespace std;
const int maxn=1300;
const int inf=1e8;
struct Edge
{
	int from,to,cap,flow,id;
};
int k,cnt,du[maxn];
map<int,int>mp;
map<int,int>::iterator it;
struct Dinic
{
	int n,m,s,t;
	vector<Edge>edges;
	vector<int>G[maxn];
	bool vis[maxn];
	int d[maxn];
	int cur[maxn];
	void init(int n)
	{
		this->n=n;
		for(int i=0;i<n;i++)G[i].clear();
		edges.clear(); 
	}
	void AddEdge(int from,int to,int cap,int id)
	{
		edges.push_back((Edge){from,to,cap,0,id});
		edges.push_back((Edge){to,from,0,0,0});
		m=edges.size();
		G[from].push_back(m-2);
		G[to].push_back(m-1);
	}
	void DelEdge(int from)
	{
		G[from].clear();
	}
	void clear(int t,int k)
	{
		for(int i=0;i<edges.size();i++)
		{
			edges[i].flow=0;
			if(edges[i].to==t)
			edges[i].cap=k;
		}	
	}
	bool bfs()
	{
		memset(vis,0,sizeof(vis));
		queue<int>Q;
		Q.push(s);
		d[s]=0;
		vis[s]=1;
		while(!Q.empty()) 
		{
			int x=Q.front();Q.pop();
			for(int i=0;i<G[x].size();i++)
			{
				Edge& e=edges[G[x][i]];
				if(!vis[e.to]&&e.cap>e.flow)
				{
					vis[e.to]=1;
					d[e.to]=d[x]+1;
					Q.push(e.to);
				}
			}
		}
		return vis[t];
	}
	int dfs(int x,int a)
	{
		if(x==t||a==0)return a;
		int flow=0,f;
		for(int& i=cur[x];i<G[x].size();i++)
		{
			Edge& e=edges[G[x][i]];
			if(d[x]+1==d[e.to]&&(f=dfs(e.to,min(a,e.cap-e.flow)))>0)
			{
				e.flow+=f;
				edges[G[x][i]^1].flow-=f;
				flow+=f;
				a-=f;
				if(a==0)break;
			}
		}
		return flow;
	}
	int Maxflow(int s,int t)
	{
		this->s=s;this->t=t;
		int flow=0;
		while(bfs()) 
		{
			memset(cur,0,sizeof(cur));
			flow+=dfs(s,inf);
		}
		return flow;
	}
	void print(int m)
	{
		int ans[m+1]={0},tot=0;
		for(int i=1;i<=cnt;i++)
		{
			if(du[i]<=k)continue;
			int sum=0;
			for(int j=0;j<G[i].size();j++)
			{
				Edge e=edges[G[i][j]];
				if(e.id==0||e.flow==0||ans[e.id])continue;
				sum++;
				if(sum%2)ans[e.id]=++tot;
				else ans[e.id]=tot;
			}
		}
		for(int i=1;i<=cnt;i++)
		{
			for(int j=0;j<G[i].size();j++)
			{
				Edge e=edges[G[i][j]];
				if(e.id==0||e.flow!=0||ans[e.id])continue;
				ans[e.id]=++tot;
			}
		}
		for(int i=1;i<=m;i++)printf("%d%c",ans[i],i==m?'\n':' ');
	}
}solve;

int main()
{
	int T;
	scanf("%d",&T);
	while(T--)
	{
		mp.clear();cnt=0;
		memset(du,0,sizeof(du));
		int n,m,u,v,s,t,sum=0;
		scanf("%d%d%d",&n,&m,&k);
		s=n+m+1,t=s+1;
		solve.init(t+1);
		for(int i=1;i<=m;i++)
		{
			scanf("%d%d",&u,&v);
			if(!mp[u])mp[u]=++cnt;
			if(!mp[v])mp[v]=++cnt;
			du[mp[u]]++,du[mp[v]]++;
			++cnt;
			solve.AddEdge(mp[u],cnt,1,i);
			solve.AddEdge(mp[v],cnt,1,i);
			solve.AddEdge(cnt,t,1,0);
		}
		for(it=mp.begin();it!=mp.end();it++)
		{
			u=it->second;
			if(du[u]>k)
			solve.AddEdge(s,u,2*(du[u]-k),0),sum+=2*(du[u]-k);
		}
		if(solve.Maxflow(s,t)!=sum)
		for(int i=1;i<=m;i++)printf("0%c",i==m?'\n':' ');
		else solve.print(m);
	}
}