【图论】hdu6370Werewolf

有理有据的结论题

Problem Description

"The Werewolves" is a popular card game among young people.In the basic game, there are 2 different groups: the werewolves and the villagers.
Each player will debate a player they think is a werewolf or not. 
Their words are like "Player x is a werewolf." or "Player x is a villager.".
What we know is :
1. Villager won't lie.
2. Werewolf may lie. 
Of cause we only consider those situations which obey the two rules above. 
It is guaranteed that input data exist at least one situation which obey the two rules above.
Now we can judge every player into 3 types :
1. A player which can only be villager among all situations, 
2. A player which can only be werewolf among all situations.
3. A player which can be villager among some situations, while can be werewolf in others situations.
You just need to print out the number of type-1 players and the number of type-2 players.
No player will talk about himself.

Input

The first line of the input gives the number of test cases T.Then T test cases follow.
The first line of each test case contains an integer N,indicating the number of players.
Then follows N lines,i-th line contains an integer x and a string S,indicating the i-th players tell you,"Player x is a S."

limits:
1≤T≤10
1≤N≤100,000
1≤x≤N
S∈ {"villager"."werewolf"}

Output

For each test case,print the number of type-1 players and the number of type-2 players in one line, separated by white space.

Sample Input

1

2

2 werewolf

1 werewolf

Sample Output

0 0

---

题目大意

现在有N个人，每个人要么是第一类：说的全是真话；要么是第二类：说的可能是假话。

每一个人x都指认另一个人y是第一类或第二类人。

请问在所有合法的情况下，有多少人必定是第一类人、有多少人必定是第二类人？

题目分析

为什么好多人第一眼看去2-sat？为什么有些人（MikuKnight）以为这真的是把狼人杀？？？

以上吐槽结束。题意已经大概写了一下了。

暴力想法

暴力做法的第一反应肯定是爆搜。

时间复杂度O(2^n)

推点性质

再一眼看去：诶这题意有点意思啊，为什么问的是“所有合法”情况下？

转念一想，那么如果每个人都说假话不也合法吗？

于是得到了这题的第一个性质：每一个人都可能是第二类人。

既然如此，只需要判断一个人能不能够成为第一类人就行了。

方法很简单，对于每一个人，假定他说真话合法，于是dfs下去检查是否矛盾。细节在于铁定说假话的人的话是没有后继效用的，意即他指认的第一类人并不一定合法。

时间复杂度O(n^2)

再推点性质

打多校时候同队的ZXB机智地猜了一条结论（以下简称“一定是第二类人的人”为“铁狼”）：

结论的充分性是显然的，考虑其必要性。

首先一个人是铁狼的充要条件是其不可能成为第一类人。由上面的性质可以得到，问题的补集就变成是：哪些人不能成为第二类人。

由于每一个人会且只会指认一个人，最基础的判定方法自然是上一条中的dfs。

考虑指认关系形成的图中环的部分。若环中有超过一条“werewolf”边，在合法情况下，被指认人的判定可以是被信任的也可以是不被信任的；再者，由于问题询问的是“所有合法情况”，被指认人的后继因此也可以被信任或不被信任。换句话说，一旦被指认，他之后的所有后继都形同虚设、模棱两可。

再考虑图中非环部分。由于每个人都可能是第二类人，于是只需考虑第一类边。自然，非法情况当且仅当（直接或间接）指认铁狼为村民。

这样，就证明了性质的充要性。

可能会犯的错误1

把边(u,v,werewolf)的v的后继全部删去。

这个情况在环上成立然而链上不成立。

可能会犯的错误2

某些方法会出现的找环时候的错误。

挂张图，这个就不细说了我错在这里没发现好久，属于做题的经验，还是多积累吧。

后记

话说在这题上和法老拉平还是有点小激动啊

 #include<cstdio>
 #include<cctype>
 #include<cstring>
 const int maxn = ;

 struct Edge
 {
     int y,opt;
 }edges[maxn];
 int T,n,ans;
 char ch[];
 int vis[maxn],deg[maxn],sv[maxn],cnt,tag;
 int head[maxn],nxt[maxn];
 int qead[maxn],qxt[maxn],qdges[maxn],edgeTot;
 bool done[maxn];

 int read()
 {
     char ch = getchar();
     int num = ;
     bool fl = ;
     for (; !isdigit(ch); ch = getchar())
         if (ch=='-') fl = ;
     for (; isdigit(ch); ch = getchar())
         num = (num<<)+(num<<)+ch-;
     if (fl) num = -num;
     return num;
 }
 void addedge(int u, int v)
 {
     qdges[++edgeTot] = v, qxt[edgeTot] = qead[u], qead[u] = edgeTot;
 }
 void dfs(int x)
 {
     vis[x] = ;
     for (int i=head[x]; i!=-; i=nxt[i])
     {
         int v = edges[i].y;
         if (vis[v]){
             if (vis[v]==) vis[v] = , sv[++sv[]] = v;
             vis[x] = ;
             return;
         }
         dfs(v);
         if (vis[v]==) vis[x] = ;
     }
 }
 void search(int x, int top, int tot)
 {
     for (int i=head[x]; i!=-; i=nxt[i])
     {
         int v = edges[i].y, cnt = tot;
         if (!edges[i].opt){
             if (cnt){
                 tag = -;
                 return;
             }
             cnt = , tag = v;
         }
         if (v==top) return;
         search(v, top, cnt);
     }
 }
 void wit(int x)
 {
     if (done[x]) return;
     done[x] = ;
     for (int i=qead[x]; i!=-; i=qxt[i])
         wit(qdges[i];);
 }
 int main()
 {
 //    freopen("1009.in","r",stdin);
 //    freopen("1009.out","w",stdout);
     T = read();
     while (T--)
     {
         memset(head, -, sizeof head);
         memset(qead, -, sizeof qead);
         memset(done, , sizeof done);
         memset(vis, , sizeof vis);
         memset(deg, , sizeof deg);
         memset(vv, , sizeof vv);
         n = read(), edgeTot = sv[] = ans = ;
         for (int i=; i<=n; i++)
         {
             edges[i].y = read(), scanf("%s",ch);
             edges[i].opt = ch[]=='v';
             nxt[i] = head[i], head[i] = i;
             deg[edges[i].y]++;
             if (edges[i].opt) addedge(edges[i].y, i);
         }
         for (int i=; i<=n; i++)
             if (!vis[i]&&!deg[i]) dfs(i);
         for (int i=; i<=n; i++)
             if (!vis[i]) dfs(i);
         for (int i=; i<=sv[]; i++)
         {
             cnt = , tag = -;
             search(sv[i], sv[i], );
             if (tag==-) continue;
             wit(tag);
         }
         for (int i=; i<=n; i++)
             if (done[i]) ans++;
         printf("0 %d\n",ans);
     }
     return ;
 }

END