Description
给你n个点,m次操作,和整数k
1操作,每次最多可以修复k个属于x所在连通块内的点
2操作,修复x与y之间的路,双向边
3操作,告诉你损坏了一些道路
问根据以上信息,最多修复了多少个点,输出每次修复的点的个数,并使输出的这个序列字典序最小
Input
第一行为一个整数T表示用例组数,每组用例第一行为三个整数n,m,k分别表示点数,操作数和操作一最多可以修复的点数,之后m行每行一个操作,首先输入操作op,op=1时输入一个整数x表示最多可以修复x所属连通块中的k个点,op=2时输入两个整数x和y表示修复x和y间的双向边,op=3时输入一个整数num,然后输入num对整数,每对整数x和y表示x到y的双向路损坏了
Output
输出最多修复的点数,并使得输出的这个序列字典序最小
Sample Input
1
5 6 2
2 1 2
2 1 3
1 1
1 2
3 1 1 2
1 2
Sample Output
3
0 2 1
Solution
首先用dfs判每次1操作可以与x所属连通块有哪些点,建图时两排点,cnt个连通块各作为一个点,n个点各作为一个点,源点向每个连通块连一条流量为k,费用随m的标号递减的边(这样可以保证输出序列字典序最小),每个连通块向属于这个块的所有点连边,流量为1,费用为0,每个点向汇点连一条流量为1,费用为0的边,跑费用流,最后输出源点向操作点的反向弧流量
Code
#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
#define maxn 1111
#define maxm 111111
#define INF 0x3f3f3f3f
int head[maxn],d[maxn],s,e,no,dis[maxn][maxn],vis[maxn],pre[maxn];
struct point
{
int u,v,flow,next,cost;
point(){};
point(int x,int y,int z,int w,int c):u(x),v(y),next(z),flow(w),cost(c){};
}p[maxm];
void add(int x,int y,int z,int c)
{
p[no]=point(x,y,head[x],z,c);
head[x]=no++;
p[no]=point(y,x,head[y],0,-c);
head[y]=no++;
}
void init()
{
memset(head,-1,sizeof(head));
no=0;
}
bool spfa()
{
int i,x,y;
queue<int>q;
memset(d,0x3f,sizeof(d));
memset(vis,false,sizeof(vis));
memset(pre,-1,sizeof(pre));
d[s]=0;
vis[s]=true;
q.push(s);
while(!q.empty())
{
x=q.front();
q.pop();
vis[x]=false;
for(i=head[x];i!=-1;i=p[i].next)
{
if(p[i].flow&&d[y=p[i].v]>d[x]+p[i].cost)
{
d[y]=d[x]+p[i].cost;
pre[y]=i;
if(vis[y])
continue;
vis[y]=true;
q.push(y);
}
}
}
return d[e]!=d[e+1];
}
int mcmf()
{
int mincost=0,maxflow=0,minflow,i;
while(spfa())
{
minflow=INF;
for(i =pre[e];i!=-1;i=pre[p[i].u])
minflow=min(minflow,p[i].flow);
for(i=pre[e];i!=-1;i=pre[p[i].u])
{
p[i].flow-=minflow;
p[i^1].flow+=minflow;
}
mincost+=d[e]*minflow;
maxflow+=minflow;
}
return maxflow;
}
int M[maxn][maxn],flag[maxn][maxn];
int n,m,k,cnt;
vector<int>g[maxn];
void init1()//初始化
{
cnt=0;//连通块数
memset(M,0,sizeof(M));
memset(flag,0,sizeof(flag));
for(int i=0;i<maxn;i++)
g[i].clear();
}
void dfs(int fa,int u)//找到u所属连通块中的点
{
flag[fa][u]=1;
g[fa].push_back(u);
for(int i=1;i<=n;i++)
{
if(!M[u][i]||flag[fa][i])
continue;
dfs(fa,i);
}
}
int main()
{
int T;
scanf("%d",&T);
while(T--)
{
scanf("%d%d%d",&n,&m,&k);
init1();//初始化
for(int i=0;i<m;i++)
{
int op;
scanf("%d",&op);
if(op==1)//操作一
{
int x;
scanf("%d",&x);
cnt++;
dfs(cnt,x);
}
if(op==2)//操作二
{
int x,y;
scanf("%d%d",&x,&y);
M[x][y]=M[y][x]=1;
}
if(op==3)//操作三
{
int num,x,y;
scanf("%d",&num);
while(num--)
{
scanf("%d%d",&x,&y);
M[x][y]=M[y][x]=0;
}
}
}
init();//初始化
s=0;//源点为0
e=n+cnt+1;//汇点为n+cnt+1
for(int i=1;i<=cnt;i++)//源点向每个连通块建容量为k,花费随i递减(此处用m-i)的边
add(s,i,k,m-i);
for(int i=1;i<=n;i++)//每个点向汇点建容量为1,花费为0的边
add(i+cnt,e,1,0);
for(int i=1;i<=cnt;i++)//每个连通块向属于这个连通块的所有点建容量为1,花费为01边
for(int j=0;j<g[i].size();j++)
add(i,g[i][j]+cnt,1,0);
int ans=mcmf();
printf("%d\n",ans);
for(int i=0;i<2*cnt;i++)
if(i%2==1)//源点到各个连通块的反向弧流量
printf("%d%c",p[i].flow,i==2*cnt-1?'\n':' ');
}
return 0;
}