UVALive - 7042 The Problem to Make You Happy 博弈

题目大意：给你一个有向图， Bob 和 Alice 在做游戏，每轮他们走一步，当Bob 和 Alice在同一个点或者 Bob无路可走，Bob输，否则Alice输。

思路：因为在Bob赢的时候存在有环的情况， 但是在Bob输的时候的状态是明确的，我们利用Bob输的状态进行必胜比败态推演，

f[ i ][ j ][ k ] 表示Alice在i ，Bob在j 且轮到k走  Bob是必输还是必胜。

#include<bits/stdc++.h>
#define LL long long
#define fi first
#define se second
#define mk make_pair
#define pii pair<int, int>
#define y1 skldjfskldjg
#define y2 skldfjsklejg

using namespace std;

const int N =  + ;
const int M = 1e5 + ;
const int inf = 0x3f3f3f3f;
const LL INF = 0x3f3f3f3f3f3f3f3f;
const int mod = 1e9 +;

int n, m, B, A, deg[N], num[N][N][];
vector<int> edge[N], redge[N];
int f[N][N][], vis[N][N][];

struct node {
    node(int x, int y, int d) {
        this->x = x;
        this->y = y;
        this->d = d;
    }
    int x, y, d;
};

void init() {
    for(int i = ; i < N; i++) {
        edge[i].clear(); redge[i].clear();
    }

    memset(deg, , sizeof(deg));
    memset(vis, , sizeof(vis));
    memset(num, , sizeof(num));

    for(int i = ; i < N; i++)
        for(int j = ; j < N; j++)
            f[i][j][] = f[i][j][] = ;

}

void bfs() {
    queue<node> que;
    for(int i = ; i <= n; i++) {
        for(int j = ; j <= n; j++) {
            for(int k = ; k < ; k++) {
                if(i == j) {
                    f[i][j][k] = ;
                    que.push(node(i, j, k));
                    vis[i][j][k] = ;
                } else if(k == ) {
                    if(!edge[j].size()) {
                        f[i][j][k] = ;
                        que.push(node(i, j, k));
                        vis[i][j][k] = ;
                    }
                }
            }
        }
    }

    while(!que.empty()) {
        node cur = que.front(); que.pop();
        if(!cur.d) {
            for(int i = ; i < redge[cur.y].size(); i++) {
                int nxy = redge[cur.y][i];
                if(vis[cur.x][nxy][]) continue;
                num[cur.x][nxy][]++;

                if(num[cur.x][nxy][] == deg[nxy]) {
                    f[cur.x][nxy][] = ;
                    vis[cur.x][nxy][] = ;
                    que.push(node(cur.x, nxy, ));
                }

            }
        } else {
            for(int i = ; i < redge[cur.x].size(); i++) {
                int nxx = redge[cur.x][i];
                if(vis[nxx][cur.y][]) continue;

                f[nxx][cur.y][] = ;
                vis[nxx][cur.y][] = ;
                que.push(node(nxx, cur.y, ));
            }
        }
    }
}

int main() {
    int T; scanf("%d", &T);
    for(int cas = ; cas <= T; cas++) {
        init();

        scanf("%d%d", &n, &m);
        for(int i = ; i <= m; i++) {
            int u, v; scanf("%d%d", &u, &v);
            edge[u].push_back(v);
            redge[v].push_back(u);
            deg[u]++;
        }

        scanf("%d%d", &B, &A);

        bfs();

        printf("Case #%d: ", cas);
        printf("%s\n", f[A][B][] ? "Yes" : "No");
    }
    return ;
}

/*
*/