BZOJ 3164: [Heoi2013]Eden的博弈问题

3164: [Heoi2013]Eden的博弈问题

Time Limit: 10 Sec  Memory Limit: 256 MB
Submit: 134  Solved: 98
[Submit][Status][Discuss]

Description

对于有两个玩家的，状态透明且状态转移确定的博弈游戏，博弈树是常用的分析工具。博弈树是一棵有根树，其中的节点为游戏的状态。若节点B的父亲是A，则说明状态A能通过一次决策转移到状态B。每个状态都有一个唯一的决策方，即这个状态下应该由哪一方做出决策。我们规定双方在任何时候都是轮流做出决策的，即树上相邻节点的决策方总是不相同的。在这个问题中，我们只关心两个玩家的胜负情况，且规定游戏不会出现平局。 我们称两个玩家分别为黑方和白方，其中根节点的决策方为黑方。显然每个节点 只有两个状态：黑方胜和白方胜。若某内节点（即存在后继节点的节点）的决策 方为黑方，则该节点为黑方胜的充要条件为它的儿子中存在黑方胜的节点，反之亦然。求解博弈树即为判明博弈树根节点的状态。如果我们得知了所有叶节点（即无后继节点的节点）的状态，那么博弈树就 很容易求解了。但是现在的情况是所有叶节点的状态均为未知的，需要进一步的计算。对于一个由叶节点构成的集合S，如果S中的节点均被判明为黑方胜，就可以断言根节点为黑方胜的话，则称 S为一个黑方胜集合。对于黑方胜集合 S，
如果对于任意的黑方胜集合 S’均满足|S| ≤ |S’ |（|S|表示集合S中的元素数目），
 则称S为一个最小黑方胜集合。同样地，也可以定义白方胜集合和最小白方胜集合。 
 Eden最近在研究博弈树问题。他发现，如果一个叶节点既属于某一个最小黑方胜集合，又属于一个最小白方胜集合，那么求解这个节点的状态显然最有益 于求解根节点的状态。像这样的叶节点就称之为关键叶节点。对于一棵给定的博弈树，Eden想要知道哪些叶节点是关键叶节点。

Input

每个测试点包含一组测试数据。 
测试数据的第一行包含一个正整数n，表示博弈树的节点数目。节点从1到n 编号，且 1 号节点为根节点。 
之后n–1 行，每行包含一个正整数。第i行的正整数表示节点i的父节点的编号。

Output

在一行内输出三个空格分隔的正整数，分别是编号最小的关键叶节点的编号，
关键叶节点的数目和所有关键叶节点的编号的异或和。

Sample Input

7
1
1
2
2
3
3

Sample Output

4 4 0

HINT

对于100% 的数据，1 ≤  n ≤ 200,000 ，且对于节点 i（i ≠ 1 ），其父节点的编号小于i。

Source

 

[Submit][Status][Discuss]

这贪心好水啊~~~

 #include <cstdio>

 template <class T>
 inline T min(const T &a, const T &b)
 {
     return a < b ? a : b;
 }

 const int mxn = ;
 const int inf = ;

 int n, fat[mxn];

 int hd[mxn];
 int to[mxn];
 int nt[mxn];

 inline void addEdge(int u, int v)
 {
     static int tot = ;
     nt[++tot] = hd[u];
     to[tot] = v;
     hd[u] = tot;
 }

 int dep[mxn];

 void preDFS(int u, int d)
 {
     dep[u] = d;

     for (int i = hd[u]; i; i = nt[i])
         preDFS(to[i], d ^ );
 }

 namespace tree1
 {
     int f[mxn];
     int v[mxn];

     void DFS1(int u)
     {
         if (!hd[u])
             f[u] = ;
         else
         {
             if (dep[u])
             {
                 f[u] = ;

                 for (int i = hd[u]; i; i = nt[i])
                     DFS1(to[i]), f[u] = f[u] + f[to[i]];
             }
             else
             {
                 f[u] = inf;

                 for (int i = hd[u]; i; i = nt[i])
                     DFS1(to[i]), f[u] = min(f[u], f[to[i]]);
             }
         }
     }

     void DFS2(int u)
     {
         if (!hd[u])
             v[u] = ;
         else
         {
             if (dep[u])
             {
                 for (int i = hd[u]; i; i = nt[i])
                     DFS2(to[i]);
             }
             else
             {
                 for (int i = hd[u]; i; i = nt[i])
                     if (f[to[i]] == f[u])DFS2(to[i]);
             }
         }
     }

     inline void solve(void)
     {
         DFS1();
         DFS2();
     }
 }

 namespace tree2
 {
     int f[mxn];
     int v[mxn];

     void DFS1(int u)
     {
         if (!hd[u])
             f[u] = ;
         else
         {
             if (!dep[u])
             {
                 f[u] = ;

                 for (int i = hd[u]; i; i = nt[i])
                     DFS1(to[i]), f[u] = f[u] + f[to[i]];
             }
             else
             {
                 f[u] = inf;

                 for (int i = hd[u]; i; i = nt[i])
                     DFS1(to[i]), f[u] = min(f[u], f[to[i]]);
             }
         }
     }

     void DFS2(int u)
     {
         if (!hd[u])
             v[u] = ;
         else
         {
             if (!dep[u])
             {
                 for (int i = hd[u]; i; i = nt[i])
                     DFS2(to[i]);
             }
             else
             {
                 for (int i = hd[u]; i; i = nt[i])
                     if (f[to[i]] == f[u])DFS2(to[i]);
             }
         }
     }

     inline void solve(void)
     {
         DFS1();
         DFS2();
     }
 }

 signed main(void)
 {
     scanf("%d", &n);

     for (int i = ; i <= n; ++i)
         scanf("%d", fat + i);

     for (int i = ; i <= n; ++i)
         addEdge(fat[i], i);

     preDFS(, );

     tree1::solve();
     tree2::solve();

     int ans1 = inf, ans2 = , ans3 = ;

     for (int i = ; i <= n; ++i)
         if (tree1::v[i] && tree2::v[i])
         {
             ans1 = min(ans1, i);
             ans2 = ans2 + ;
             ans3 = ans3 ^ i;
         }

     printf("%d %d %d\n", ans1, ans2, ans3);
 }

@Author: YouSiki