Hdu4687 Boke and Tsukkomi

Boke and Tsukkomi

                                                                              Time Limit: 3000/3000 MS (Java/Others)    Memory Limit: 102400/102400 K (Java/Others)
                                                                                                           Total Submission(s): 1215    Accepted Submission(s): 386

Problem Description

A new season of Touhou M-1 Grand Prix is approaching. Girls in Gensokyo cannot wait for participating it. Before the registration, they have to decide which combination they are going to compete as. Every girl in Gensokyo is both a boke (funny girl) and a tsukkomi
(straight girl). Every candidate combination is made up of two girls, a boke and a tsukkomi. A girl may belong to zero or more candidate combinations, but one can only register as a member of one formal combination. The host of Touhou M-1 Grand Prix hopes
that as many formal combinations as possible can participate in this year. Under these constraints, some candidate combinations are actually redundant as it\'s impossible to register it as a formal one as long as the number of formal combinations has to be
maximized. So they want to figure out these redundant combinations and stop considering about them.

 

Input

There are multiple test cases. Process to the End of File.
The first line of each test case contains two integers: 1 ≤ N ≤ 40 and 1 ≤ M ≤ 123, where N is the number of girls in Gensokyo, and M is the number of candidate combinations. The following M lines are M candidate combinations, one by each line.
Each combination is represented by two integers, the index of the boke girl 1 ≤ B_i ≤ N and the index of the tsukkomi girl 1 ≤ T_i ≤ N, where B_i != T_i.

 

Output

For each test case, output the number of redundant combinations in the first line. Then output the space-separated indexes of the redundant combinations in ascending order in the second line.

 

Sample Input

4 4
1 3
2 3
2 4
3 1
6 6
1 2
3 2
3 4
5 2
5 4
5 6

 

Sample Output

1
2
3
2 4 5

 

Author

Zejun Wu (watashi)

 

Source

2013 Multi-University Training Contest 9

 

———————————————————————————————

题意：有n个女孩，她们之间有k对可能的组合，但参赛时每个人只能参加一个组合，在组合数量最大化时有些组合是多余的，但使组合数量最大化可能有多种方式，找出这些多余的组合

解题思路：一般图匹配带花树，这题不能这样判断，当一个组合不选择时，组合数量仍能达到最大化，它就是多余组合，因为可能选了这个组合也能使组合数量达到最大化。应该固定一个组合，若其他组合形成的组合数量等于之前组合数量减一，那么它就不是多余的，否则它就是多余的。也就是说要让剩余的组合无论怎么选都能达到组合数量最大化

#include <iostream>
#include <cstdio>
#include <string>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#include <vector>
#include <set>
#include <stack>
#include <map>
#include <climits>
using namespace std;

#define LL long long
const int INF = 0x3f3f3f3f;

const int MAXN = 250;
int N; //点的个数，点的编号从1到N
bool Graph[MAXN][MAXN];
int Match[MAXN];
bool InQueue[MAXN],InPath[MAXN],InBlossom[MAXN];
int Head,Tail;
int Queue[MAXN];
int Start,Finish;
int NewBase;
int Father[MAXN],Base[MAXN];
int a[MAXN],b[MAXN],ans[MAXN];

void Push(int u)
{
    Queue[Tail] = u;
    Tail++;
    InQueue[u] = true;
}
int Pop()
{
    int res = Queue[Head];
    Head++;
    return res;
}
int FindCommonAncestor(int u,int v)
{
    memset(InPath,false,sizeof(InPath));
    while(true)
    {
        u = Base[u];
        InPath[u] = true;
        if(u == Start) break;
        u = Father[Match[u]];
    }
    while(true)
    {
        v = Base[v];
        if(InPath[v])break;
        v = Father[Match[v]];
    }
    return v;
}
void ResetTrace(int u)
{
    int v;
    while(Base[u] != NewBase)
    {
        v = Match[u];
        InBlossom[Base[u]] = InBlossom[Base[v]] = true;
        u = Father[v];
        if(Base[u] != NewBase) Father[u] = v;
    }
}
void BloosomContract(int u,int v)
{
    NewBase = FindCommonAncestor(u,v);
    memset(InBlossom,false,sizeof(InBlossom));
    ResetTrace(u);
    ResetTrace(v);
    if(Base[u] != NewBase) Father[u] = v;
    if(Base[v] != NewBase) Father[v] = u;
    for(int tu = 1; tu <= N; tu++)
        if(InBlossom[Base[tu]])
        {
            Base[tu] = NewBase;
            if(!InQueue[tu]) Push(tu);
        }
}
void FindAugmentingPath()
{
    memset(InQueue,false,sizeof(InQueue));
    memset(Father,0,sizeof(Father));
    for(int i = 1; i <= N; i++)
        Base[i] = i;
    Head = Tail = 1;
    Push(Start);
    Finish = 0;
    while(Head < Tail)
    {
        int u = Pop();
        for(int v = 1; v <= N; v++)
            if(Graph[u][v] && (Base[u] != Base[v]) && (Match[u] != v))
            {
                if((v == Start) || ((Match[v] > 0) && Father[Match[v]] > 0))
                    BloosomContract(u,v);
                else if(Father[v] == 0)
                {
                    Father[v] = u;
                    if(Match[v] > 0)
                        Push(Match[v]);
                    else
                    {
                        Finish = v;
                        return;
                    }
                }
            }
    }
}
void AugmentPath()
{
    int u,v,w;
    u = Finish;
    while(u > 0)
    {
        v = Father[u];
        w = Match[v];
        Match[v] = u;
        Match[u] = v;
        u = w;
    }
}
void Edmonds()
{
    memset(Match,0,sizeof(Match));
    for(int u = 1; u <= N; u++)
        if(Match[u] == 0)
        {
            Start = u;
            FindAugmentingPath();
            if(Finish > 0)AugmentPath();
        }
}

int main()
{

    int u,v,m;
    while(~scanf("%d%d",&N,&m))
    {
        memset(Graph,false,sizeof(Graph));

        for(int i=1; i<=m; i++)
        {
            scanf("%d%d",&a[i],&b[i]);
            Graph[a[i]][b[i]] = Graph[b[i]][a[i]] = true;
        }
        Edmonds();
        int tot=0;
        for(int i=1; i<=N; i++)
            if(Match[i]>0)
                tot++;
        int cnt=0;
        for(int i=1; i<=m; i++)
        {
            int aa=a[i],bb=b[i];
             memset(Graph,false,sizeof(Graph));

        for(int i=1; i<=m; i++)
        {
           if(a[i]==aa||b[i]==aa||a[i]==bb||b[i]==bb)
            continue;
            Graph[a[i]][b[i]] = Graph[b[i]][a[i]] = true;
        }

            Edmonds();//进行匹配

            int tt=0;
            for(int i=1; i<=N; i++)
                if(Match[i]>0)
                    tt++;
            if(tt!=tot-2)
                ans[cnt++]=i;

        }

        printf("%d\n",cnt);
        int q=0;
        for(int i=0; i<cnt; i++)
        {
            if(q++)
                printf(" ");
            printf("%d",ans[i]);
        }
        printf("\n");
    }

    return 0;
}