Codeforces Gym 100548H The Problem to Make You Happy （图上博弈DP）

题目链接

题目大意：

    在一张有向图上Bob和Alice在两个点向前走，Bob先走，Alice再走，如果他们相遇那么Alice获胜，如果有人无路可走那么另一个获胜，如果游戏不会结束那么Bob获胜。每个人都选择最优策略。求谁会获胜。

解题思路：

    明显是图上博弈dp，比赛时写的代码用记忆化搜索判断游戏不会结束的方法估计时错误的，就一直WA。

    其实我们不需要判断出每一种情况，这里不好判断游戏结束，那我们就不判断它，只要找到所有Bob必败的情况，剩下的就是Bob必胜的情况了。

    最终比赛结束的情况很好找到，决策也需要后面的结果，我们就从结束逆推回初始状态，建立反向图，表示状态用dp[i][j][k]，i：Bob位置，j：Alice位置，k：该谁走。初始化就是对于所有相遇的情况Alice胜利，所有Bob无路可走的状态Alice胜利。然后用bfs倒推。状态转移是，对于Alice走，如果有可以转移到Bob必败的状态，那么这个状态Bob必败，对于Bob走，只有全部可以到达的状态都是必败那么这个状态必败。

AC代码：

#include <iostream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <algorithm>
#include <queue>
#include <map>
using namespace std;

const int MAXN=100+3;

struct Node
{
    int x,y,z;//Bob位置，Alice位置，该谁走
    Node(int x,int y,int z):x(x),y(y),z(z){};
};

vector<int> G[MAXN];//反向图
int N,M,X,Y;
bool dp[MAXN][MAXN][2];//Bob位置，Alice位置，该谁走(0:Alice,1:Bob)，Bob是否会输
int cnt[MAXN][MAXN];//这个状态往下走输的情况数
int out[MAXN];//出度

int main()
{
    int T;
    scanf("%d",&T);
    for(int cas=1;cas<=T;++cas)
    {
        scanf("%d%d",&N,&M);
        for(int i=1;i<=N;++i)//初始化
        {
            G[i].clear();
            out[i]=0;
            for(int j=1;j<=N;++j)
            {
                dp[i][j][0]=dp[i][j][1]=false;
                cnt[i][j]=0;
            }
        }
        for(int i=0;i<M;++i)
        {
            int a,b;
            scanf("%d%d",&a,&b);
            G[b].push_back(a);
            ++out[a];
        }
        scanf("%d%d",&X,&Y);
        queue<Node> que;
        for(int i=1;i<=N;++i)//相遇
        {
            dp[i][i][0]=dp[i][i][1]=true;
            que.push(Node(i,i,0));
            que.push(Node(i,i,1));
        }
        for(int i=1;i<=N;++i)//无路可走
            if(out[i]==0)
                for(int j=1;j<=N;++j)
                    if(!dp[i][j][0])
                    {
                        dp[i][j][0]=true;
                        que.push(Node(i,j,0));
                    }
        while(!que.empty())
        {
            int x=que.front().x,y=que.front().y,z=que.front().z; que.pop();
            if(z)//该Bob走
            {
                for(int i=0;i<G[x].size();++i)
                    if(++cnt[G[x][i]][y]==out[G[x][i]]&&!dp[G[x][i]][y][0])//全部路径都是必败，这种情况就是必败
                    {
                        dp[G[x][i]][y][0]=true;
                        que.push(Node(G[x][i],y,0));
                    }
            }
            else//该Alice走
            {
                for(int i=0;i<G[y].size();++i)//能够然Bob必败，那么这个情况就是必败
                    if(!dp[x][G[y][i]][1])
                    {
                        dp[x][G[y][i]][1]=true;
                        que.push(Node(x,G[y][i],1));
                    }
            }
        }
        printf("Case #%d: ",cas);
        puts(dp[X][Y][0]?"No":"Yes");
    }
    
    return 0;
}

/*
 3 
 5 3 
 1 2 
 3 4 
 4 5 
 3 1 
 
 4 3 
 1 2 
 2 3 
 3 4 
 1 2 
 
 3 3 
 1 2 
 2 3 
 3 1 
 2 1 
 */