hdu5639 Deletion 【二分+网络流】

链接：http://acm.hdu.edu.cn/showproblem.php?pid=5639

题意：

给你一个n个点m条边的无向图，现在要将图中的边全部删掉，每次可以删除多条边，但是每次删掉的边组成的子图的每个连通块中最多只有一个环，最少多少次把边全删掉。

分析：

每次删掉的边组成的子图的每个连通块中最多只有一个环，那么这些边组成的结构就是树套环。

如果一个图的每个点的出边只有一条, 那么一定会构成环套树这种结构. 于是问题可以转化成, 给无向图的每条边定向, 使得出度最大点的出度最小 (每个点的出度大小对应了删的次数).
显然, 这个东西使可以二分的, 不妨设二分值为x. 考虑混合图的欧拉回路的做法, 利用网络流判合法. 先给每条无向边随便定向, 对于出度大于x的, 从源点连一条流量为deg-x的边, 对于出度小于xx的, 从这个点连一条流量为x-deg的边到汇点. 对于原来图中的边, 流量为1加到网络流图中. 只要满流就是合法.

代码：

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<string>
#include<vector>
#include<queue>
#include<cmath>
#include<stack>
#include<set>
#include<map>
#define INF 0x3f3f3f3f
#define Mn 2010
#define Mm 20005
#define mod 1000000007
#define CLR(a,b) memset((a),(b),sizeof((a)))
#define CPY(a,b) memcpy ((a), (b), sizeof((a)))
#pragma comment(linker, "/STACK:102400000,102400000")
#define ul u<<1
#define ur (u<<1)|1
using namespace std;
typedef long long ll;
int read() {
    char c=getchar();
    int re=0,f=1;
    while(c<'0'||c>'9') {if(c=='-') f=-1;c=getchar();}
    while(c>='0'&&c<='9') {re=re*10+c-'0';c=getchar();}
    return re*f;
}
struct edge {
    int v,w,next;
} e[Mm];
int s,t,N;
int head[Mn],cur[Mn],tot;
int deep[Mn];
void addedge(int u,int v,int w) {
    e[tot].v=v;
    e[tot].w=w;
    e[tot].next=head[u];
    head[u]=tot++;
}
queue<int> q;
bool bfs(int st,int en) {
    while(!q.empty()) q.pop();
    CLR(deep,-1);
    q.push(st);
    deep[st]=0;
    while(!q.empty()) {
        int u=q.front();
        q.pop();
        if(u==en) return true;
        for(int i=head[u]; i!=-1; i=e[i].next) {
            int v=e[i].v;
            int w=e[i].w;
            if(w>0&&deep[v]==-1) {
                deep[v]=deep[u]+1;
                q.push(v);
            }
        }
    }
    return false;
}
int dfs(int u,int sum,int en) {
    if(u==en) return sum;
    int a=0,us=0;
    for(int &i=cur[u]; i!=-1; i=e[i].next) {
        if(deep[e[i].v]==deep[u]+1) {
            a=sum-us;
            a=dfs(e[i].v,min(a,e[i].w),en);
            e[i].w-=a;
            e[i^1].w+=a;
            if(e[i].w) cur[u]=i;
            us+=a;
            if(us==sum) return sum;
        }
    }
    if(!us) deep[u]=-1;
    return us;
}
int dinic(int st,int en) {
    int ans=0;
    while(bfs(st,en)) {
        CPY(cur,head);
        ans+=dfs(st,INF,en);
    }
    return ans;
}
int degree[Mn];
int n,m;
int U[Mn],V[Mn];
int solve(int x) {
    int sum=0;
    CLR(head,-1);
    tot=0;
    for(int i=1;i<=m;i++) {
        addedge(U[i],V[i],1);
        addedge(V[i],U[i],0);
    }
    for(int i=1;i<=n;i++) {
        if(degree[i]>x) {
            addedge(s,i,degree[i]-x);
            addedge(i,s,0);
            sum+=degree[i]-x;
        } else if(degree[i]<x){
            addedge(i,t,x-degree[i]);
            addedge(t,i,0);
        }
    }
    if(sum==dinic(s,t)) return 1;
    else return 0;
}
void init() {
    CLR(head,-1);
    CLR(degree,0);
    tot=0;
}
int main() {
    int T=read();
    while(T--) {
        init();
        n=read(),m=read();
        for(int i=1;i<=m;i++) {
            U[i]=read(),V[i]=read();
            degree[U[i]]++;
        }
        s=0,t=n+1;N=t;
        int l=0,r=m,ans=0;
        while(l<=r) {
            int mid=(l+r)>>1;
            if(solve(mid)) {
                r=mid-1;
                ans=mid;
            } else l=mid+1;
        }
        cout<<ans<<endl;
    }
    return 0;
}