SGU 520 Fire in the Country 博弈SG函数(或者YY一下)

题目大意：

现在给出一个有着n个顶点m条边的图，边为双向边， 现在两个人轮流操作机器人，机器人从点1开始走，两个人轮流控制机器人走向与当前点相连的点，两个人每次操作机器人走的同时，火势将会向外蔓延，每操作一次之后火势就向与当前着火点相连的点蔓延，机器人在谁操作之后被火烧到谁就输，比如样例：

Nikolay先手从1走到3，当天晚上1着火，然后Vladimir只能从3走到1，当天晚上1是着火点所以Vladimir输了，输出Vladimir

大致思路：

这题比赛的时候想的是一个YY的做法：

我定义P点：一个点是P点当且仅当谁控制机器人走到这个点谁就赢

相反的是N点：一个点是N点表示谁控制机器人走到这个点谁就输

由于火势是不停蔓延的，那么控制机器人行动时不能回头，这样即使图中有环，也不可能往回走，可以先BFS遍历一下找到点的层级( 即到达该点的步数 ) 这样我们就只能控制机器人从层级低的点走到层级高的点，这样原图可以变成一个无环有向图，图的边来自于原图中层级低的点指向层级高的点且在原图中连通

我们考虑父亲结点root和子节点son[ i ] ( 这里就是拓扑序的意思，方编写我就当做树的层级吧..虽然可能不是树...) ，当父亲节点没有子节点时，一定是 P 点，因为下一个人已经无路可走了

当父亲节点有子节点时，如果子节点中有P点，那么父亲节点是N点( 博弈中的小策略 )也很容易明白因为代打这个父亲节点后，下一个人一定会选择走到P点这样走到这个父亲节点的人就输了，也就是说只需要判断父亲节点的子节点中有无P点即可判断父亲节点是P点还是N点

这样dfs一下找到节点1的值是P还是N即可，是N则Vladimir赔钱，否则Nikolay赔钱

比赛之后学了一些图上的博弈，发现这题可以用Sprague-Grundy函数来解和之前一样BFS建好新的无环有向图之后，用dfs迭代求SG函数的值

当SG[ 1 ] == 0 时，Nikolay赔钱，SG[ 1 ] != 0时，Vladimir赔钱

这里附上SG函数解法的代码(相比上一种比赛时YY出来的方案感觉还是好一点)

题解写一半发现CSDN维护了..我擦...

Result  :  Accepted     Memory  :  322 KB     Time  :  15 ms

/*
* Author: Gatevin
* Created Time: 2014/9/2 22:10:56
* File Name: C.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#include<iomanip>
using namespace std;
const double eps(1e-8);
typedef long long lint;
#define pb(x) push_back(x)
#define clr(x) memset(x, 0, sizeof(x))
int n,m;
int deep[1010];//到达对应的点需要走的步数
bool vis[1010];//用了两次，都是用来记忆化
vector <int> G[1010];//原图
vector <int> F[1010];//删边之后的博弈求SG函数用图
queue <int> q;
int SG[1010];

void bfs()
{
clr(vis);
vis[1] = 1;
q.push(1);
while(!q.empty())
{
for(unsigned int i = 0; i < G[q.front()].size(); i++)
{
if(!vis[G[q.front()][i]])
{
deep[G[q.front()][i]] = deep[q.front()] + 1;
vis[G[q.front()][i]] = 1;
q.push(G[q.front()][i]);
}
}
q.pop();
}
return;
}

void build()
{
for(int i = 1; i <= n; i++)
{
for(unsigned int j = 0; j < G[i].size(); j++)
{
if(deep[i] < deep[G[i][j]])
{
F[i].pb(G[i][j]);
}
}
}
return;
}

bool check(int val, int root)//求mex()
{
for(unsigned int i = 0; i < F[root].size(); i++)
{
if(val == SG[F[root][i]]) return true;
}
return false;
}

void dfs(int root)//递归求解SG函数
{
if(F[root].empty())
{
SG[root] = 0;
return;
}
if(vis[root]) return;
for(unsigned int i = 0; i < F[root].size(); i++)
{
dfs(F[root][i]);
}
int cnt = 0;
while(check(cnt, root))
{
cnt++;
}
SG[root] = cnt;
vis[root] = 1;
return;
}

int main()
{
scanf("%d %d", &n, &m);
int tx,ty;
for(int i = 1; i <= m; i++)
{
scanf("%d %d", &tx, &ty);
G[tx].pb(ty);
G[ty].pb(tx);
}
bfs();
build();
clr(vis);
dfs(1);
if(SG[1] != 0)
{
printf("Vladimir\n");
}
else
{
printf("Nikolay\n");
}
return 0;
}