HDU 3551 Hard Problem (带花树算法)

http://acm.hdu.edu.cn/showproblem.php?pid=3551

终于把带花树专题刷完了

题意：

给定一个无向图，问能否删除一些边使得所有顶点的读数为给定的度数

方法：

这道题看网上有用网络流解的，这里用带花树做匹配来解。

先预处理所有的顶点的度数deg，然后与给定的度数D比较。

设边e(u,v)，则将(u,e) (v,e') (e,e')连起来，注意u有deg[u]-D[u]-1个顶点，v同样，e,e'表示将边e拆成e和e'两个顶点，然后用带花树算法做匹配，如果有完美匹配则输出YES，否则输出NO。（想一下，如果有完美匹配就表明这些多余的边能够直接移走使每个顶点的度数变为D）

注意：

重边时拆分顶点的编号唯一（这里WA了好多次。。。）；特判D[i]>deg[i]的情况

//#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<set>
#include<list>
#include<map>
#include<iterator>
#include<cstdlib>
#include<vector>
#include<queue>
#include<stack>
#include<algorithm>
#include<functional>
using namespace std;
typedef long long LL;
#define ROUND(x) round(x)
#define FLOOR(x) floor(x)
#define CEIL(x) ceil(x)
const int maxn=1010;
const int inf=0x3f3f3f3f;
const LL inf64=0x3f3f3f3f3f3f3f3fLL;
const double INF=1e30;
const double eps=1e-6;
/**
*一般图的最大基数匹配：带花树算法
*输入：g[][],n(输入从0到n-1,用addEdge()加边)
*输出：gao()(最大匹配数),match[](匹配)
*/
//const int maxn=0;
struct Matching
{
    deque<int> Q;
    int n;
    //g[i][j]存放关系图：i,j是否有边,match[i]存放i所匹配的点
    bool g[maxn][maxn],inque[maxn],inblossom[maxn],inpath[maxn];
    int match[maxn],pre[maxn],base[maxn];

    //找公共祖先
    int findancestor(int u,int v)
    {
        memset(inpath,0,sizeof(inpath));
        while(1)
        {
            u=base[u];
            inpath[u]=true;
            if(match[u]==-1)break;
            u=pre[match[u]];
        }
        while(1)
        {
            v=base[v];
            if(inpath[v])return v;
            v=pre[match[v]];
        }
    }

    //压缩花
    void reset(int u,int anc)
    {
        while(u!=anc)
        {
            int v=match[u];
            inblossom[base[u]]=1;
            inblossom[base[v]]=1;
            v=pre[v];
            if(base[v]!=anc)pre[v]=match[u];
            u=v;
        }
    }

    void contract(int u,int v,int n)
    {
        int anc=findancestor(u,v);
        //SET(inblossom,0);
        memset(inblossom,0,sizeof(inblossom));
        reset(u,anc);
        reset(v,anc);
        if(base[u]!=anc)pre[u]=v;
        if(base[v]!=anc)pre[v]=u;
        for(int i=1; i<=n; i++)
            if(inblossom[base[i]])
            {
                base[i]=anc;
                if(!inque[i])
                {
                    Q.push_back(i);
                    inque[i]=1;
                }
            }
    }

    bool dfs(int S,int n)
    {
        for(int i=0; i<=n; i++)pre[i]=-1,inque[i]=0,base[i]=i;
        Q.clear();
        Q.push_back(S);
        inque[S]=1;
        while(!Q.empty())
        {
            int u=Q.front();
            Q.pop_front();
            for(int v=1; v<=n; v++)
            {
                if(g[u][v]&&base[v]!=base[u]&&match[u]!=v)
                {
                    if(v==S||(match[v]!=-1&&pre[match[v]]!=-1))contract(u,v,n);
                    else if(pre[v]==-1)
                    {
                        pre[v]=u;
                        if(match[v]!=-1)Q.push_back(match[v]),inque[match[v]]=1;
                        else
                        {
                            u=v;
                            while(u!=-1)
                            {
                                v=pre[u];
                                int w=match[v];
                                match[u]=v;
                                match[v]=u;
                                u=w;
                            }
                            return true;
                        }
                    }
                }
            }
        }
        return false;
    }

    void init(int n)
    {
        this->n = n;
        memset(match,-1,sizeof(match));
        memset(g,0,sizeof(g));
    }

    void addEdge(int a, int b)
    {
        ++a;
        ++b;
        g[a][b] = g[b][a] = 1;
    }

    int gao()
    {
        int ans = 0;
        for (int i = 1; i <= n; ++i)
            if (match[i] == -1 && dfs(i, n))
                ++ans;
        return ans;
    }
} match;

struct Edge
{
    int u,v;
} edge[maxn];
int deg[maxn];
int D[maxn];
int n,m;
vector<int> p[maxn];
void init()
{
    for(int i=0; i<maxn; i++) p[i].clear();
    memset(deg,0,sizeof(deg));
    memset(D,0,sizeof(D));
}
void input()
{
    scanf("%d%d",&n,&m);
    for(int i=0; i<m; i++)
    {
        scanf("%d%d",&edge[i].u,&edge[i].v);
        deg[--edge[i].u]++;
        deg[--edge[i].v]++;
    }
    for(int i=0; i<n; i++) scanf("%d",&D[i]);
}
int solve()
{
    for(int i=0; i<n; i++) if(deg[i]<D[i]) return 0;
    int flag=1;
    for(int i=0; i<n; i++) if(deg[i]!=D[i]) flag=0;
    if(flag) return 1;

    int cnt=0;
    for(int k=0; k<m; k++)
    {
        int u=edge[k].u;
        int v=edge[k].v;
        if(p[u].empty())
        {
            int tmp=deg[u];
            while(tmp>D[u]) p[u].push_back(cnt++),tmp--;
        }
        if(p[v].empty())
        {
            int tmp=deg[v];
            while(tmp>D[v]) p[v].push_back(cnt++),tmp--;
        }
    }
    match.init(cnt+2*m);
    for(int k=0; k<m; k++)
    {
        int u=edge[k].u;
        int v=edge[k].v;
        match.addEdge(cnt+2*k,cnt+2*k+1);
        for(int i=0; i<p[u].size(); i++)
            match.addEdge(p[u][i],cnt+2*k);
        for(int i=0; i<p[v].size(); i++)
            match.addEdge(p[v][i],cnt+2*k+1);
    }
    match.gao();
    for(int i=1; i<=match.n; i++) if(match.match[i]==-1) return 0;
    return 1;
}
int main()
{
//    std::ios_base::sync_with_stdio(false);
//    freopen("in.cpp","r",stdin);
    int T;
    scanf("%d",&T);
    for(int kase=1; kase<=T; kase++)
    {
        init();
        input();
        if(solve()) printf("Case %d: YES
",kase);
        else printf("Case %d: NO
",kase);
    }
    return 0;
}