HDU 4687 Boke and Tsukkomi (2013.8.20 多校9 1002)(暴力+带花树算法)

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

题意：找到所有的最大匹配，然后输出不在任何最大匹配中的边的序号

解法：贴板题，一般图的最大匹配，带花树算法，然后求暴力枚举去掉一条边的最大匹配数与原最大匹配数比较

赛后才知道带花树算法

直接用的标程的带花树算法的模板。。。

/**
*版题。。。之前不知道这个算法。。。
*一般图的最大匹配：带花树算法
*暴力枚举去掉一条边的最大匹配数与原最大匹配数比较
*
*@Author: xiaohai
*/
//#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=45;
const int maxm=300;
const int inf=0x3f3f3f3f;
const LL inf64=0x3f3f3f3f3f3f3f3fLL;
const double INF=1e30;
const double eps=1e-6;
int n,m,cnt;
int mtx[maxn][maxn];
struct Edge
{
    int u,v;
    Edge(int _u,int _v):u(_u),v(_v) {}
};
vector<Edge> edge;
/**
*一般图的最大基数匹配：带花树算法
*输入：g[][],n(输入从0到n-1,用addEdge()加边)
*输出：gao()(最大匹配数),match[](匹配)
*/
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;
    }
};
Matching match;
void init()
{
    edge.clear();
    memset(mtx,0,sizeof(mtx));
}
void input()
{
//    scanf("%d%d",&n,&m);
    match.init(n);
    while(m--)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        --u,--v;
        mtx[u][v]=mtx[v][u]=1;
        match.addEdge(u,v);
        edge.push_back(Edge(u,v));
    }
}
void solve()
{
    cnt=match.gao();
    vector<int> ans;
    for(int k=0; k<edge.size(); k++)
    {
        int u=edge[k].u,v=edge[k].v;
        match.init(n);
        for(int i=0; i<n; i++)
        {
            for(int j=0; j<n; j++)
            {
                if(i!=u&&i!=v&&j!=u&&j!=v)
                {
                    match.g[i+1][j+1]=mtx[i][j];
                }
            }
        }
        if(match.gao()<cnt-1) ans.push_back(k+1);
    }
    printf("%d
",ans.size());
    for(int i=0; i<ans.size(); i++)
    {
        printf("%d",ans[i]);
        if(i<ans.size()-1) printf(" ");
    }
    puts("");
}
int main()
{
    std::ios_base::sync_with_stdio(false);
//    freopen("in.cpp","r",stdin);
    while(~scanf("%d%d",&n,&m))
    {
        init();
        input();
        solve();
    }
    return 0;
}