强连通 HDU 3861

t个样例

n个点m条边

分成一些区

2个点互相能到达必须分在一个区

一个区中任何2个点可以u->v 或者v->u

任何点都要有自己的区

求最小的区的数目

强联通缩点

成新图

二分匹配 求最大匹配

最小路径覆盖=点数-最大匹配数

  1 #include<stdio.h>
  2 #include<algorithm>
  3 #include<string.h>
  4 #include<stack>
  5
  6 using namespace std;
  7
  8 #define MAXN 5010
  9 #define MAXN1 100010
 10 int head[MAXN],dfn[MAXN],low[MAXN],cou[MAXN],fa[MAXN];
 11 int cnt,k,num;
 12 bool vis[MAXN],mark[MAXN];
 13
 14 struct edg
 15 {
 16     int next,to,fr;
 17 }x[MAXN1];
 18 void add(int u,int v)
 19 {
 20     x[cnt].next=head[u];
 21     x[cnt].fr=u;
 22     x[cnt].to=v;
 23     head[u]=cnt++;
 24 }
 25 stack<int>s;
 26
 27 void dfs(int u)
 28 {
 29     low[u]=dfn[u]=k++;
 30     vis[u]=1;
 31     s.push(u);
 32     int i;
 33     for(i=head[u];i!=-1;i=x[i].next)
 34     {
 35         int v=x[i].to;
 36         if(!dfn[v])
 37         {
 38             dfs(v);
 39             low[u]=min(low[u],low[v]);
 40         }
 41         else if(vis[v])
 42             low[u]=min(low[u],dfn[v]);
 43     }
 44     if(dfn[u]==low[u])
 45     {
 46         num++;
 47         while(!s.empty())
 48         {
 49             int now=s.top();
 50             s.pop();
 51             vis[now]=0;
 52             fa[now]=num;
 53             if(now==u)break;
 54         }
 55     }
 56 }
 57 int pa[MAXN];
 58
 59 bool dfs1(int u)
 60 {
 61     int i;
 62     for(i=head[u];i!=-1;i=x[i].next)
 63     {
 64         if(mark[x[i].to])
 65             continue;
 66         mark[x[i].to]=1;
 67         if(pa[x[i].to]==-1||dfs1(pa[x[i].to]))
 68         {
 69             pa[x[i].to]=u;
 70             return 1;
 71         }
 72     }
 73     return 0; //很重要
 74 }
 75 int main()
 76 {
 77     int t;
 78     scanf("%d",&t);
 79
 80     while(t--)
 81     {
 82         int n,m,i;
 83         scanf("%d%d",&n,&m);
 84         cnt=0;
 85         memset(head,-1,sizeof(head));
 86         memset(dfn,0,sizeof(dfn));
 87         memset(low,0,sizeof(low));
 88
 89         for(i=1;i<=m;i++)
 90         {
 91             int a,b;
 92             scanf("%d%d",&a,&b);
 93             add(a,b);
 94         }
 95         k=1;
 96         num=0;
 97         for(i=1;i<=n;i++) //强联通
 98             if(!dfn[i])
 99                 dfs(i);
100         memset(head,-1,sizeof(head));
101         memset(pa,-1,sizeof(pa));
102         int en=cnt;
103         cnt=0;
104         for(i=0;i<en;i++)
105         {
106             int u,v;
107             u=fa[x[i].fr];
108             v=fa[x[i].to];
109             if(u!=v)
110             {
111                 add(u,v);
112             }
113         }
114         int ans=0;
115
116         for(i=1;i<=num;i++) //二分匹配
117         {
118             memset(mark,0,sizeof(mark));
119             if(dfs1(i))
120                 ans++;
121         }
122         printf("%d\n",num-ans);
123     }
124
125     return 0;
126 }
时间: 2024-10-06 16:47:53

强连通 HDU 3861的相关文章

hdu 3861 The King’s Problem (强连通+最小路径覆盖)

The King's Problem Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 1637    Accepted Submission(s): 600 Problem Description In the Kingdom of Silence, the king has a new problem. There are N cit

HDU 3861 The King&#39;s Problem(强连通分量缩点+最小路径覆盖)

http://acm.hdu.edu.cn/showproblem.php?pid=3861 题意: 国王要对n个城市进行规划,将这些城市分成若干个城市,强连通的城市必须处于一个州,另外一个州内的任意两个城市u,v,有从u到v的路径或从v到u的路径.求最少可以分成几个州. 思路: 这道题目挺好. 首先,强连通分量进行缩点,重新建图. 新建的图就是一个DAG图,接下来就转换成了最小路径覆盖问题. 最小路径覆盖就是用尽量少的不相交的简单路径覆盖DAG的所有顶点.每个顶点只属于一条路径,单个顶点也可以

HDU 3861 The King’s Problem (强连通+二分匹配)

题目地址:HDU 3861 这题虽然是两个算法结合起来的.但是感觉挺没意思的..结合的一点也不自然,,硬生生的揉在了一块...(出题者不要喷我QAQ.) 不过这题让我发现了我的二分匹配已经好长时间没用过了..都快忘了..正好在省赛之前又复习了一下. 代码如下: #include <iostream> #include <string.h> #include <math.h> #include <queue> #include <algorithm>

HDU 3861 The King’s Problem(强连通+二分图最小路径覆盖)

HDU 3861 The King's Problem 题目链接 题意:给定一个有向图,求最少划分成几个部分满足下面条件 互相可达的点必须分到一个集合 一个对点(u, v)必须至少有u可达v或者v可达u 一个点只能分到一个集合 思路:先强连通缩点,然后二分图匹配求最小路径覆盖 代码: #include <cstdio> #include <cstring> #include <vector> #include <algorithm> #include <

(tarjan+匈牙利算法) hdu 3861

F - The King’s Problem Time Limit:1000MS     Memory Limit:32768KB     64bit IO Format:%I64d & %I64u Submit Status Practice HDU 3861 Description In the Kingdom of Silence, the king has a new problem. There are N cities in the kingdom and there are M d

HDU 3861 The King’s Problem 最小路径覆盖(强连通分量缩点+二分图最大匹配)

题目链接:http://acm.hdu.edu.cn/showproblem.php?pid=3861 最小路径覆盖的一篇博客:https://blog.csdn.net/qq_39627843/article/details/82012572 题意: 把城市至少分成几个块,规则有三 1. A能B,B能到A,那么A,B一定要在一起. 2. 一个城市只能属于一个块. (说明了是最小不相交覆盖)3. 在一个块里的城市,任意2点之间必须有路径. 对于规则1,就是说强连通的必须在一起,所以用Tarjan

HDU - 3861 The King’s Problem (强连通分量+最小路径覆盖)

思路:tarjarn缩点,然后剩下的就是纯粹的最小路径覆盖,最小路径覆盖=顶点数-匹配数.匹配数跑一遍匈牙利即可. 1 #include <iostream> 2 #include <queue> 3 #include <stack> 4 #include <cstdio> 5 #include <vector> 6 #include <map> 7 #include <set> 8 #include <bitset

HDU - 3861 The King’s Problem(强连通分量+最小路径覆盖)

题目大意:给出一张有向图,要求你将这些点进行划分,划分依据如下 1.如果两个点互相可达,那么这两个点必须在一个集合中 2.同一个集合中任意两个点u,v要满足,要么u能到达v,要么v能到达u 3.一个点只能被划分到一个集合 问最少能划分成几个点集 解题思路:首先先求出所有的强连通分量,满足条件1 满足条件2,3的话,就要求出最小路径覆盖 所以可以将所有的强连通分量进行缩点,桥作为连接,然后匈牙利一下,求出最大匹配数,再用强连通分量的数量-最大匹配数,就是答案了 #include <cstdio>

The King’s Problem (hdu 3861 强连通缩点+最小路径覆盖)

The King's Problem Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 2085    Accepted Submission(s): 741 Problem Description In the Kingdom of Silence, the king has a new problem. There are N cit