HDOJ 4687 Boke and Tsukkomi 一般图最大匹配带花树+暴力

一般图最大匹配带花树+暴力:

先算最大匹配 C1

在枚举每一条边,去掉和这条边两个端点有关的边.....再跑Edmonds得到匹配C2

如果C2+2==C1则这条边再某个最大匹配中

Boke and Tsukkomi

Time Limit: 3000/3000 MS (Java/Others)    Memory Limit: 102400/102400 K (Java/Others)

Total Submission(s): 649    Accepted Submission(s): 202

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 ≤ Bi ≤ N and the index of the tsukkomi girl 1 ≤ Ti ≤ N, where Bi != Ti.

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

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

using namespace std;

const int maxn=50;

vector<int> ans;

bool G[maxn][maxn],TG[maxn][maxn];

int n,m;
int Match[maxn];
int Start,Finish,NewBase;
int Father[maxn],Base[maxn];
bool InQueue[maxn],InPath[maxn],InBlossom[maxn];
int Count;
queue<int> q;

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 BlossomContract(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])
            {
              q.push(tu);
              InQueue[tu]=true;
            }
        }
    }
}

void FindAugmentingPath()
{
  memset(InQueue,false,sizeof(InQueue));
  memset(Father,0,sizeof(Father));
  for(int i=1;i<=n;i++)
    Base[i]=i;
  while(!q.empty()) q.pop();
  q.push(Start); InQueue[Start]=true;
  Finish=0;

  while(!q.empty())
    {
      int u=q.front(); q.pop();
      InQueue[u]=false;
      for(int i=1;i<=n;i++)
        {
          if(i==u||G[u][i]==false) continue;
          int v=i;
          if(Base[u]!=Base[v]&&Match[u]!=v)
            {
              if(v==Start||(Match[v]>0&&Father[Match[v]]>0))
                BlossomContract(u,v);
              else if(Father[v]==0)
                {
                  Father[v]=u;
                  if(Match[v]>0)
                    {
                      q.push(Match[v]);
                      InQueue[Match[v]]=true;
                    }
                  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 bian[200][2];

int main()
{
  while(scanf("%d%d",&n,&m)!=EOF)
    {
      memset(G,0,sizeof(G));
      memset(TG,0,sizeof(TG));
      ans.clear();

      for(int i=0;i<m;i++)
        {
          int u,v;
          scanf("%d%d",&u,&v);
          bian[i][0]=u;bian[i][1]=v;
          G[u][v]=G[v][u]=1;
          TG[u][v]=TG[v][u]=1;
        }

      Edmonds();

      Count=0;
      for(int i=1;i<=n;i++)
        if(Match[i]) Count++;

      for(int i=0;i<m;i++)
        {
          int u=bian[i][0],v=bian[i][1];
          ///clear about u,v
          for(int j=1;j<=n;j++)
            {
              G[u][j]=G[j][u]=G[j][v]=G[v][j]=0;
            }

          Edmonds();

          int C2=0;
          for(int j=1;j<=n;j++)
              if(Match[j]) C2++;

          if(C2<Count-2)
            ans.push_back(i+1);

          ///Recover
          for(int j=1;j<=n;j++)
            {
              G[u][j]=TG[u][j]; G[j][u]=TG[j][u];
              G[v][j]=TG[v][j]; G[j][v]=TG[j][v];
            }
        }
        int sz = ans.size();
        printf("%d\n",sz);
        for(int i=0;i<sz;i++)
        {
            printf("%d",ans[i]);
            if(i<sz-1)printf(" ");
        }
        printf("\n");
    }
  return 0;
}
时间: 2024-10-08 02:30:20

HDOJ 4687 Boke and Tsukkomi 一般图最大匹配带花树+暴力的相关文章

HDU 4687 Boke and Tsukkomi 一般图匹配,带花树,思路,输出注意空行 难度:4

http://acm.hdu.edu.cn/showproblem.php?pid=4687 此题求哪些边在任何一般图极大匹配中都无用,对于任意一条边i,设i的两个端点分别为si,ti, 则任意一个极大匹配中都必然有si或ti至少一个点被匹配,当在图中去掉si,ti两个点时,匹配数会损失一个或两个. 如果损失两个,就说明在极大匹配中这两个点分别连接不同的边,于是边i是无用的 所以总体思路:一般图匹配求出最大匹配数cnt0,分别试着去掉每条边的端点,再次匹配,匹配数如果小于cnt0-1,则这条边无

poj 3020 一般图最大匹配 带花树开花算法

题意: 给出一个h*w的图,每个点都是'o'或'*',最少要用多少个1*2的矩形才能把图中所有的'*'都覆盖掉. 限制: 1 <= h <= 40; 1 <= w <= 10 思路: 最小边覆盖=|V|-最大匹配 一般图最大匹配,带花树开花算法 /*poj 3020 一般图最大匹配 带花树开花算法 题意: 给出一个h*w的图,每个点都是'o'或'*',最少要用多少个1*2的矩形才能把图中所有的'*'都覆盖掉. 限制: 1 <= h <= 40; 1 <= w &l

ZOJ 3316 Game 一般图最大匹配带花树

一般图最大匹配带花树: 建图后,计算最大匹配数. 如果有一个联通块不是完美匹配,先手就可以走那个没被匹配到的点,后手不论怎么走,都必然走到一个被匹配的点上,先手就可以顺着这个交错路走下去,最后一定是后手没有路可走,因为如果还有路可走,这一条交错路,就是一个增广路,必然有更大的匹配. Game Time Limit: 1 Second      Memory Limit: 32768 KB Fire and Lam are addicted to the game of Go recently.

一般图最大匹配带花树

参考博客:http://blog.sina.com.cn/s/blog_95ec9e7401018bga.html https://www.cnblogs.com/owenyu/p/6858508.html 用Dinic实现的二分图匹配的时间复杂度其实是O(M*N^0.5),这也许能够解释为什么一般网络流算法比Hungry要快了. 另外,带花树算法的正确性的证明比较困难:而其时间复杂度是可以做到O(M*N^0.5)的 简述一下“带花树”算法吧: 它的核心思想还是找增广路.假设已经匹配好了一堆点,

Work Scheduling URAL - 1099 一般图最大匹配带花树

#include <stdio.h> #include <string.h> #include <iostream> #include <algorithm> #include <string> using namespace std; const int MAXN = 250; int N; //点的个数,点的编号从1到N bool Graph[MAXN][MAXN]; int Match[MAXN]; bool InQueue[MAXN],I

【UOJ 79】 一般图最大匹配 (?带花树开花)

从前一个和谐的班级,所有人都是搞OI的.有 n 个是男生,有 0 个是女生.男生编号分别为 1,-,n. 现在老师想把他们分成若干个两人小组写动态仙人掌,一个人负责搬砖另一个人负责吐槽.每个人至多属于一个小组. 有若干个这样的条件:第 v 个男生和第 u 个男生愿意组成小组. 请问这个班级里最多产生多少个小组? 输入格式 第一行两个正整数,n,m.保证 n≥2. 接下来 m 行,每行两个整数 v,u 表示第 v 个男生和第 u 个男生愿意组成小组.保证 1≤v,u≤n,保证 v≠u,保证同一个条

zoj3316【一般图最大匹配 带花树开花】

链接:http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=3726 算法见:http://fanhq666.blog.163.com/blog/static/8194342620120304463580/ 题意:棋盘上有n个点,现在两个人轮流在移除一个子,每次移除的子距离上次移除的子曼哈顿距离小于L.最后不能移除的人输. 分析:将距离小于L的点连边.如果一个连通块不是是完备匹配,先手一定可以让自己走到一个没有匹配的点上,然后后手就

kuangbin带你飞 匹配问题 二分匹配 + 二分图多重匹配 + 二分图最大权匹配 + 一般图匹配带花树

二分匹配:二分图的一些性质 二分图又称作二部图,是图论中的一种特殊模型. 设G=(V,E)是一个无向图,如果顶点V可分割为两个互不相交的子集(A,B),并且图中的每条边(i,j)所关联的两个顶点i和j分别属于这两个不同的顶点集(i in A,j in B),则称图G为一个二分图. 1.一个二分图中的最大匹配数等于这个图中的最小点覆盖数 König定理是一个二分图中很重要的定理,它的意思是,一个二分图中的最大匹配数等于这个图中的最小点覆盖数.如果你还不知道什么是最小点覆盖,我也在这里说一下:假如选

一般图匹配带花树

R - Work Scheduling Time Limit:500MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u Submit Status Practice URAL 1099 Appoint description: Description There is certain amount of night guards that are available to protect the local junkyard