Hdu 5352 MZL's City （最小费用最大流）

解析：源点S与所有的1查询连边，容量为K，所有的查询与相关的节点连边，容量为1，图中节点1~n与T连边，容量为1，解即是最大流量。

通过控制费用，越早的查询费用越大，从而获得最小字典序。

[code]:

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>

//#pragma comment(linker, "/STACK:102400000,102400000")
#define th(x) this->x=x
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 705;
const int maxm = 101500;

struct Node{
    int v,cap,cost,next;
    void init(int v,int cap,int cost,int next){
        th(v);th(cap);th(cost);th(next);
    }
};
struct MinCost{
    Node buf[maxm];int n,len,E[maxn];
    int p[maxn],d[maxn];
    bool vis[maxn];
    queue<int> q;
    void init(int n){
        this->n=n;len=0;
        memset(E,-1,n*sizeof(int));
    }
    void addCap(int a,int b,int cap,int cost){
        buf[len].init(b,cap,cost,E[a]);E[a]=len++;
        buf[len].init(a,0,-cost,E[b]);E[b]=len++;
    }
    bool spfa(int s,int t){
        memset(d,63,n*sizeof(int));
        memset(p,-1,n*sizeof(int));
        memset(vis,0,n*sizeof(bool));
        d[s]=0;vis[s]=true;
        q.push(s);
        int u,v,i;
        while(!q.empty()){
            u = q.front();q.pop();vis[u]=false;
            for(i=E[u];i!=-1;i=buf[i].next){
                v=buf[i].v;
                if(buf[i].cap>0&&d[v]>d[u]+buf[i].cost){
                    d[v]=d[u]+buf[i].cost;
                    p[v]=i;
                    if(!vis[v]){
                        vis[v]=true;
                        q.push(v);
                    }
                }
            }
        }
        return d[t]<inf;
    }
    int mfmc(int s,int t){//最小费用最大流
            int x,neck,mincost=0,maxflow=0;
            while(spfa(s,t)){
                neck = inf;
                for(x=p[t];x!=-1;x=p[buf[x^1].v])
                    neck = min(neck,buf[x].cap);
                maxflow+=neck;
                for(x=p[t];x!=-1;x=p[buf[x^1].v]){
                    buf[x].cap-=neck;
                    buf[x^1].cap+=neck;
                    mincost+=buf[x].cost*neck;
                }
            }
            return maxflow;
    }
}sol;
struct Nod{
    int b,next,tag;
    void init(int b,int next){
        this->b=b;this->next=next;tag = 1;
    }
}buf[1005];
int n,m,k,len,E[205],cnt,ans[505];
int S,T,link[205][205],rebuild[505][205];

void init(){
    len = cnt = 0;
    memset(E,-1,(n+1)*sizeof(int));
    memset(rebuild,0,sizeof(rebuild));
}
void add_edge(int a,int b){
    buf[len].init(b,E[a]);link[a][b]=len;E[a]=len++;
    buf[len].init(a,E[b]);link[b][a]=len;E[b]=len++;
}
void del_edge(int a,int b){
    buf[link[a][b]].tag = 0;
    buf[link[b][a]].tag = 0;
}
void dfs(int u){
    int i,v;
    rebuild[cnt][u] = 1;
    for(i = E[u];i!= -1;i = buf[i].next){
        v = buf[i].b;
        if(buf[i].tag==0||rebuild[cnt][v]) continue;
        dfs(v);
    }
}
void solve(){
    int i,j;
    S = 0,T = n+cnt+1;
    sol.init(T+1);
    for(i = 1;i <= cnt;i++) sol.addCap(S,i,k,cnt+1-i);
    for(i = 1;i <= n;i++) sol.addCap(i+cnt,T,1,0);
    for(i = 1;i <= cnt;i++){
        for(j = 1;j <= n;j++){
            if(rebuild[i][j]) sol.addCap(i,j+cnt,1,0);
        }
    }
    printf("%d\n",sol.mfmc(S,T));
    for(i = sol.E[S],j = cnt;i != -1;i = sol.buf[i].next){
        ans[--j] = k-sol.buf[i].cap;
    }
    for(i = 0;i < cnt;i++){
        if(i ) putchar(' ');
        printf("%d",ans[i]);
    }
    putchar('\n');

}

inline bool read(int &ret){
    char c;int sgn;
    if(c = getchar(),c==EOF) return 0;
    while(c != '-'&&(c<'0'||c>'9')) c=getchar();
    sgn = (c=='-')?-1:1;
    ret = (c=='-')?0:(c-'0');
    while(c=getchar(),c>='0'&&c<='9') ret=ret*10+(c-'0');
    ret*=sgn;
    return 1;
}

int main(){
    int i,j,cas,op,x,u,v;
    scanf("%d",&cas);
    while(cas--){
        scanf("%d%d%d",&n,&m,&k);
        init();

        for(i = 0;i < m;i++){
            read(op);
            if(op==1){
                read(u);
                cnt++;
                dfs(u);
            }else if(op==2){
                read(u);read(v);
                add_edge(u,v);
            }else{
                read(x);
                while(x--){
                    read(u);read(v);
                    del_edge(u,v);
                }
            }
        }
        solve();
    }

    return 0;
}