HDU 5352 MZL's City（最小费用最大流-mcmf）

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;
}