BZOJ2140 稳定婚姻[强连通分量]

发现如果$B_i$和$G_j$配对，那么$B_j$又要找一个$G_k$配对，$B_k$又要找一个$G_l$配对，一直到某一个$B_x$和$G_i$配对上为止，才是不稳定的。

暴力是二分图匹配、匈牙利算法（据说可过）。仔细观察，将配对关系和潜在关系全连边，不稳定的结果则是一个环。

但是不能直接就这样找。因为无向的话，并不能保证$B_i$和$G_j$配对后就一定从$G_j$走向$B_j$。所以为了保证走向正确，需要定一下向。

将所有$G$点（糟糕的名称）连边指向他对应的配偶$B$点，然后所有$B$点将自己有的潜在关系连边指向$G$点。这样，每个$B$只有一个入度（从原来配对的$G$过来），然后再重新走向一个新的$G$点......

是不是超有道理的。。。所以每对点在不在一个简单环上，换言之，因为两点间连了一条边，只要看这条边在不在一个SCC上（边在SCC上和在简单环上是等价的，不过但两点在SCC上和在简单环上不一定等价）即可。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #include<queue>
 #include<map>
 #define mst(x) memset(x,0,sizeof x)
 #define dbg(x) cerr << #x << " = " << x <<endl
 #define dbg2(x,y) cerr<< #x <<" = "<< x <<"  "<< #y <<" = "<< y <<endl
 using namespace std;
 typedef unsigned long long ull;
 typedef long long ll;
 typedef double db;
 typedef pair<int,int> pii;
 template<typename T>inline T _min(T A,T B){return A<B?A:B;}
 template<typename T>inline T _max(T A,T B){return A>B?A:B;}
 template<typename T>inline char MIN(T&A,T B){return A>B?(A=B,):;}
 template<typename T>inline char MAX(T&A,T B){return A<B?(A=B,):;}
 template<typename T>inline void _swap(T&A,T&B){A^=B^=A^=B;}
 template<typename T>inline T read(T&x){
     x=;int f=;char c;while(!isdigit(c=getchar()))if(c=='-')f=;
     while(isdigit(c))x=x*+(c&),c=getchar();return f?x=-x:x;
 }
 const int N=1e5+,base=;
 struct thxorz{int to,nxt;}G[N];
 char s[];
 int Head[N],frm[N],tot;
 int n,m,k;
 inline void Addedge(int x,int y){G[++tot].to=y,G[tot].nxt=Head[x],Head[x]=tot;frm[tot]=x;}
 map<ull,int> mp;
 inline int Read(){
     scanf("%s",s+);int len=strlen(s+);ull ha=;
     for(register int i=;i<=len;++i)ha=ha*base+s[i]-'A'+;
     if(mp.find(ha)==mp.end())mp[ha]=++n;
     return mp[ha];
 }
 #define y G[j].to
 int dfn[N],low[N],stk[N],instk[N],Top,cnt,bel[N];
 void tarjan(int x){
     dfn[x]=low[x]=++cnt,stk[++Top]=x,instk[x]=;
     for(register int j=Head[x];j;j=G[j].nxt){
         if(!dfn[y])tarjan(y),MIN(low[x],low[y]);
         else if(instk[y])MIN(low[x],dfn[y]);
     }
     if(dfn[x]==low[x]){
         int tmp;
         do instk[tmp=stk[Top--]]=,bel[tmp]=x;while(tmp^x);
     }
 }
 #undef y
 int main(){//freopen("test.in","r",stdin);//freopen("test.ans","w",stdout);
     read(k);
     for(register int i=,x,y;i<=k;++i)x=Read(),y=Read(),Addedge(x,y);
     read(m);
     for(register int i=,x,y;i<=m;++i)x=Read(),y=Read(),Addedge(y,x);
     for(register int i=;i<=n;++i)if(!dfn[i])tarjan(i);
     for(register int i=,x,y;i<=k;++i){
         x=frm[i],y=G[i].to;//dbg2(x,y);
         puts(bel[x]^bel[y]?"Safe":"Unsafe");
     }
     return ;
 }

总结：一些匹配关系，可以转化为有向图，或者对图定向来完成转化，然后使用tarjan找SCC处理环问题。