King's Quest POJ - 1904 匈牙利算法的思想+tarjan缩点＋染色

题目链接：https://cn.vjudge.net/problem/POJ-1904

自己一开始的想法，打算用匈牙利算法实现，找二分图的最大匹配。但是打了打发现，不太好实现。原因如下：匈牙利算法是不停的找增广路。如果这个题用匈牙利算法实现的时候，就是这个地方：

 bool Find(int t)
 {
     for(int i=; i<=m; i++)
     {
         if(line[t][i]&&Exit[i]==)
         {
             Exit[i]=;
             if(net[i]==||Find(net[i]))
             {
                 net[i]=t;
                 return true;
             }
         }
     }
 }

，这个是找到合法的就返回，无法把所有的情况都找到，所以这个方法不行。

然后再去想tarjan算法，找缩点，也就是图上的两点都能都到达，如果是王子向喜欢的公主连线的话，连一条单向边，如果是公主喜欢的王子的话，然后再从公主连向王子一条单向边，这样，就能够在最大匹配的图上实现一个连通图的建立.

但是注意这个题有个坑点，在构成连通图的时候，有的王子不喜欢某个公主，但是在图上也有可能通过别的点联通起来，这个时候就需要特判一下了。

ＡＣ代码：

 #include<iostream>
 #include<stack>
 #include<iomanip>
 #include<algorithm>
 #include<cmath>
 #include<string>
 #include<cstring>
 #include<queue>
 #include<vector>
 #include<stdio.h>
 #include<map>
 using namespace std;
 # define inf 0x3f3f3f3f
 # define ll long long
 const int N = + ;
 const int M = + ;
 struct node
 {
     int to;
     int nex;
 } edge[M];
 int head[M],low[N],dfn[N],istack[N];
 int num,ind,col,n,m;
 stack<int>q;
 vector<int>wakaka[N];
 vector<int>w1;
 vector<int>ans[N];
 int Map[][];
 void init()
 {
     while(!q.empty())q.pop();
     memset(head,-,sizeof(head));
     num=,ind=,col=;
     memset(low,,sizeof(low));
     memset(dfn,,sizeof(dfn));
     memset(istack,,sizeof(istack));
 }
 void addedge(int fr,int to)
 {
     edge[num].to=to;
     edge[num].nex=head[fr];
     head[fr]=num++;
 }
 void tarjan(int u,int root)
 {
     q.push(u);
     low[u]=dfn[u]=++ind;
     for(int i=head[u]; i!=-; i=edge[i].nex)
     {
         int v=edge[i].to;
         if(dfn[v]==)
         {
             tarjan(v,u);
             low[u]=min(low[u],low[v]);
         }
         else if(istack[v]==)
         {
             low[u]=min(low[u],dfn[v]);
         }
     }
     if(low[u]==dfn[u])
     {
         int t;
         col++;
         do
         {
             t=q.top();
             q.pop();
             istack[t]=col;
             wakaka[col].push_back(t);
         }
         while(t!=u);
     }
 }
 int main()
 {
     init();
     scanf("%d",&n);
     int t;
     for(int i=; i<=n; i++)
     {
         scanf("%d",&m);
         for(int j=; j<=m; j++)
         {
             scanf("%d",&t);
             addedge(i,t+n);
             Map[i][t]=;
         }
     }
     for(int i=; i<=n; i++)
     {
         scanf("%d",&t);
         addedge(t+n,i);
        // Map[t][i]=1;
     }
     for(int i=; i<=n; i++)
     {
         if(dfn[i]==)
         {
             tarjan(i,);
         }
     }
     for(int i=; i<=col; i++)
     {
         sort(wakaka[i].begin(),wakaka[i].end());
         int len=wakaka[i].size();
         for(int j=; j<len; j++)
         {
             int u=wakaka[i][j];
             if(u<=n)w1.push_back(u);
             else
             {
                 int len2=w1.size();
                 for(int k=; k<len2; k++)
                 {
                 if(Map[w1[k]][u-n])//判断是不是有相互喜欢的关系
                     ans[w1[k]].push_back(u-n);
                 }
             }
         }
         w1.clear();
     }
     for(int i=; i<=n; i++)
     {
     sort(ans[i].begin(),ans[i].end());
         int len=ans[i].size();
         printf("%d",len);
         for(int j=; j<len; j++)
         {
             printf(" %d",ans[i][j]);
         }
         printf("\n");
     }
     return ;
 }