HDU 6105 Gameia 树上博弈（思路题）（内附官方题解）

题目  ：Gameia：链接

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)

Total Submission(s): 160    Accepted Submission(s): 53

Problem Description

Alice and Bob are playing a game called 'Gameia ? Gameia !'. The game goes like this :
0. There is a tree with all node unpainted initial.
1. Because Bob is the VIP player, so Bob has K chances to make a small change on the tree any time during the game if he wants, whether before or after Alice's action. These chances can be used together or separate, changes will happen in a flash. each change is defined as cut an edge on the tree.
2. Then the game starts, Alice and Bob take turns to paint an unpainted node, Alice go first, and then Bob.
3. In Alice's move, she can paint an unpainted node into white color.
4. In Bob's move, he can paint an unpainted node into black color, and what's more, all the other nodes which connects with the node directly will be painted or repainted into black color too, even if they are white color before.
5. When anybody can't make a move, the game stop, with all nodes painted of course. If they can find a node with white color, Alice win the game, otherwise Bob.
Given the tree initial, who will win the game if both players play optimally?

 

Input

The first line of the input gives the number of test cases T; T test cases follow.
Each case begins with one line with two integers N and K : the size of the tree and the max small changes that Bob can make.
The next line gives the information of the tree, nodes are marked from 1 to N, node 1 is the root, so the line contains N-1 numbers, the i-th of them give the farther node of the node i+1.

Limits
T≤100
1≤N≤500
0≤K≤500
1≤Pi≤i

 

Output

For each test case output one line denotes the answer.
If Alice can win, output "Alice" , otherwise "Bob".

 

Sample Input

  
  

   
   2
2 1
1
3 1
1 2
  
  

 

Sample Output

  
  

   
   Bob
Alice
  
  

题解：- 如果Bob能把这棵树分成若干两个一组的点对，那么Bob取得胜利，否则Alice获胜。

 - 如果原树不存在两两匹配的方案，Alice从树叶开始，每次都染树叶父节点，Bob被迫只能不断的染叶子，Bob退化成一般玩家，因为Bob做不做小动作都不会逆转局势，总会出现一个时间点Bob没办法跟上Alice的节奏而让Alice染到一个周围都已被染色的孤立点（因为原树不存在两两匹配的方案） 

- 如果原树存在两两匹配的方案，而且Bob的小动作次数也足以把原树分成两两的点对，那么Bob显然获胜。 - 如果原树存在两两匹配的方案，而Bob的小动作不足以把树分成两两的点对，Alice一定获胜，因为每次染某个叶子节点（该节点为其父节点的唯一子节点），Alice总能迫使Bob不断的做小动作以保证剩下的树不会出现奇数节点的树，且每次小动作割出一个点对（包含Alice刚染的点），最后有两种情况。

 - 出现某个结点有>=2个子节点为叶子节点。Alice染这个点，Bob跟不上Alice的节奏，出现孤点，Ailice取胜

 - 否则整个过程一定会持续到树被染光或者Bob被Alice掏空导致做不了小动作进而被迫割出一块size为奇数的子树（这棵树显然没办法两两匹配）而败北。

 - Bob被允许“任意时刻”做小动作看似很厉害其实很鸡肋，把问题改成“Bob只能在游戏开始之前做小动作”会得到同样的结论。 - “氪不改命，玄不救非” 时间复杂度 $O(n)$

我的理解：经过长时间的思考确实，Bob的k次断线必须维持所剩节点为偶，若为偶，那么白棋下在叶节点，使得再下的黑棋多染一个节点，使所剩棋子为奇数，为了不多染一个棋子，那么Bob要断线避免所剩棋子数为奇数个。

Bob赢得方法只有一个，在开始之前先用他的k次断线，将树分成两两匹配，才能赢，否则Bob输。

两两匹配方法，应该是从叶节点上往上匹配，所以父节点必须在孩子节点匹配以后再匹配（拓扑排序），没有匹配的节点都应该和他的父亲匹配，那么只需要判断他（他自己没有染色，并且他的儿子都已经匹配过）的父亲是否被染色了即可，若未染色，则将他和他的父亲都染上色，否则他没法完成配对，则一定是白棋赢。

若两两可以匹配则判断k次断线是否够，不够则白赢；

我的AC代码：

#include<stdio.h>
#include <iostream>
#include<string.h>
#include<algorithm>
#include<cmath>
#include<map>
#define LL long long
using namespace std;
int a[600];//a[i]=x表示节点i的父节点是x
int b[600];//染色标记
int topo[600];//排序后的节点顺序
int c[600][600];//c[i][j]=x代表节点i的第j个儿子是节点x;
int s[600];//s[i]=x代表节点i有x个儿子
int cnt;
void toposort(int d)
{
    for(int i=0;i<s[d];i++)  toposort(c[d][i]);//先将d节点的儿子排序
    topo[cnt++]=d;//然后再放节点d
   return ;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(b,0,sizeof(b));
        memset(s,0,sizeof(s));
        cnt=0;
        b[0]=1;
        a[1]=0;//因为1节点没有父节点，为了避免特判，所以给1添个已经染色的父节点0；不影响结果。
        int n,k;
        scanf("%d%d",&n,&k);
        for(int i=2; i<=n; i++)
        {
            scanf("%d",&a[i]);
            c[a[i]][s[a[i]]++]=i;
        }
        int flag=0;
        if(n%2)  flag=1;//节点数为奇数一定是白赢
        if(!flag) toposort(1);
        if(!flag)
            for(int i=0; i<n; i++)
                if(!b[topo[i]])
                {
                    if(b[a[topo[i]]])
                    {
                        flag=1;
                        break;
                    }
                    else
                    {
                        b[a[topo[i]]]=1;
                        b[topo[i]]=1;
                    }
                }
        if(!flag) if(n/2-1>k) flag=1;//判断k次够不够
        if(flag) printf("Alice\n");
        else  printf("Bob\n");
    }
}