【HDOJ3861】【Tarjan缩点+最小路径覆盖】

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

The King’s Problem

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 3544    Accepted Submission(s): 1256

Problem Description

In the Kingdom of Silence, the king has a new problem. There are N cities in the kingdom and there are M directional roads between the cities. That means that if there is a road from u to v, you can only go from city u to city v, but can’t go from city v to city u. In order to rule his kingdom more effectively, the king want to divide his kingdom into several states, and each city must belong to exactly one state. What’s more, for each pair of city (u, v), if there is one way to go from u to v and go from v to u, (u, v) have to belong to a same state. And the king must insure that in each state we can ether go from u to v or go from v to u between every pair of cities (u, v) without passing any city which belongs to other state.
  Now the king asks for your help, he wants to know the least number of states he have to divide the kingdom into.

 

Input

The first line contains a single integer T, the number of test cases. And then followed T cases.

The first line for each case contains two integers n, m(0 < n <= 5000,0 <= m <= 100000), the number of cities and roads in the kingdom. The next m lines each contains two integers u and v (1 <= u, v <= n), indicating that there is a road going from city u to city v.

 

Output

The output should contain T lines. For each test case you should just output an integer which is the least number of states the king have to divide into.

 

Sample Input

1
3 2
1 2
1 3

 

Sample Output

2

题目大意：给一个无向图，1）如果u v两点互相可达，则必须被划分为同一个区域，

　　　　　　　　　　　　2）如果u 和 v 至少有一方可达另一方【并且不能经过别的区域，即所走路径必须和自己属于同一区域】则可以被划分为同一个区域

　　　　　　　　　　　　3）一个点必须属于且只属于一个区域

求所需划分的最少区域

题目分析：由要求一可知要先求强连通分量进行缩点，而要求二和三可知即求最小路径覆盖【最少用几条路径【路径即起点与终点都不相同，无相交的路】可以走过所有的点】

定义:

最小路径覆盖：在图中找一些路径（路径数最少），使之覆盖了图中所有的顶点，且每个顶点有且仅和一条路径有关联。

最小顶点覆盖：在图中找一些点（顶点数最少），使之覆盖了图中所有的边，每条边至少和一个顶点有关联。

二分图：最小顶点覆盖=最大匹配数。

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

 //Wannafly挑战赛14 C https://www.nowcoder.com/acm/contest/81/C
 #include<iostream>
 #include<cstring>
 #include<algorithm>
 #include<queue>
 #include<stack>
 #include<vector>
 using namespace std;
 const int maxn=;
 struct edge{
     int from;
     int to;
     int next;
 }EDGE[maxn];
 vector<int>vc[maxn];
 int head[maxn],dfn[maxn],vis[maxn],vvis[maxn],used[maxn],low[maxn],col[maxn],in[maxn],out[maxn],en[maxn],stk[maxn];//各个变量的意义可参照上篇博客
 int edge_cnt=,tot1=,tot2=,scc_cnt=,tot0=;
 void add(int x,int y)
 {
     EDGE[edge_cnt].from=x;
     EDGE[edge_cnt].to=y;
     EDGE[edge_cnt].next=head[x];
     head[x]=edge_cnt++;
 }
 bool find(int x)
 {
     for(int i = head[x] ; i != - ; i=EDGE[i].next)
     {
         if(!used[EDGE[i].to])
         {
             used[EDGE[i].to]=;
             if(!vvis[EDGE[i].to]||find(vvis[EDGE[i].to]))
             {
                 vvis[EDGE[i].to]=x;
                 return ;
             }
         }
     }
     return ;
 }
 void Tarjan(int u)
 {
     low[u]=dfn[u]=++tot1;//注意tot1的初值必须是1【因为dfn必须为正数】，所以这里使用++tot1而不用tot1++;
     vis[u]=;
     stk[++tot2]=u;
     for(int i = head[u]; i != -  ; i = EDGE[i].next)
     {
         if(!dfn[EDGE[i].to]){
             Tarjan(EDGE[i].to);
             low[u]=min(low[u],low[EDGE[i].to]);
         }
         else if(vis[EDGE[i].to]){
             low[u]=min(low[u],low[EDGE[i].to]);
         }
     }
             if(low[u]==dfn[u]){
             int xx;
             scc_cnt++;
             do{
                 xx=stk[tot2--];
                 vc[scc_cnt].push_back(xx);
                 col[xx]=scc_cnt;
                 vis[xx]=;
             }while(xx!=u);
         }
 }
 int main()
 {
     int t;
     scanf("%d",&t);
     while(t--)
     {
     edge_cnt=,tot1=,tot2=,scc_cnt=,tot0=;
      scc_cnt=;
     int n,m;
     scanf("%d%d",&n,&m);
     memset(head,-,sizeof(head));
     memset(stk,,sizeof(stk));
     memset(in,,sizeof(in));
     memset(out,,sizeof(out));
     memset(dfn,,sizeof(dfn));
     memset(low,,sizeof(low));
     memset(col,,sizeof(col));
    memset(vis,,sizeof(vis));
     memset(vvis,,sizeof(vvis));
     while(m--)
     {
         int a,b;
         scanf("%d%d",&a,&b);
          add(a,b);
     }
     for(int i =  ; i <= n; i++)
     {
         if(!dfn[i])Tarjan(i);
     }
     memset(head,-,sizeof(head));
     int orz0=edge_cnt;
  //   cout << "$$$\n";
  edge_cnt=;
     for(int i =  ; i < orz0 ; i++)
     {
         if(col[EDGE[i].from]!=col[EDGE[i].to])
         {
             add(col[EDGE[i].from],col[EDGE[i].to]);
 //            cout << col[EDGE[i].from] << endl;
         }
     }
   //  cout << "###\n";
     int sum=;
     //int sum1=0,sum2=0;
         for(int i =  ; i <= scc_cnt ; i++)
         {
             memset(used,,sizeof(used));
             if(find(i))sum++;
         }
     cout << scc_cnt-sum <<endl;
     for(int i =  ; i <= scc_cnt ; i++)
     vc[i].clear();
 }
     return ;
 }
 /*4 5
 1 3
 2 4
 4 2
 1 4
 2 1*/