[](https://github.com/e-maxx-eng/e-maxx-eng/wiki/Translation-Progress)

Let a game be played by two players on an arbitrary graph $G$.

I.e. the current state of the game is a certain vertex.

The player perform moves by turns, and move from the current vertex to an adjacent vertex using a connecting edge.

Depending on the game, the person that is unable to move will either lose or win the game.

We consider the most general case, the case of an arbitrary directed graph with cycles.

It is our task to determine, given an initial state, who will win the game if both players play with optimal strategies or determine that the result of the game will be a draw.

We will solve this problem very efficiently.

We will find the solution for all possible starting vertices of the graph in linear time with respect to the number of edges: $O(m)$.

We will call a vertex a winning vertex, if the player starting at this state will win the game, if he plays optimal (regardless what turns the other player makes).

And similarly we will call a vertex a losing vertex, if the player starting at this vertex will lose the game, if the opponent plays optimal.

For some of the vertices of the graph we already know in advance that they are winning or losing vertices: namely all vertices that have no outgoing edges.

Also we have the following **rules**:

- if a vertex has an outgoing edge that leads to a losing vertex, then the vertex itself is a winning vertex.

- if all outgoing edges of a certain vertex lead to winning vertices, then the vertex itself is a losing vertex.

- if at some point there are still undefined vertices, and neither will fit the first or the second rule, then each of these vertices, when used as a starting vertex, will lead to a draw if both player play optimal.

Thus we can define an algorithm which runs in $O(n m)$ time immediately.

We go through all vertices and try to apply the first or second rule, and repeat.

However we can accelerate this procedure, and get the complexity down to $O(m)$.

We will go over all the vertices, for which we initially know if they are winning or losing states.

For each of them we start a [depth first search](./graph/depth-first-search.html).

This DFS will move back over the reversed edges.

First of all, it will not enter vertices which already are defined as winning or losing vertices.

And further, if the search goes from a losing vertex to an undefined vertex, then we mark this one as a winning vertex, and continue the DFS using this new vertex.

If we go from a winning vertex to an undefined vertex, then we must check whether all edges from this one leads to winning vertices.

We can perform this test in $O(1)$ by storing the number of edges that lead to a winning vertex for each vertex.

So if we go from a winning vertex to an undefined one, then we increase the counter, and check if this number is equal to the number of outgoing edges.

If this is the case, we can mark this vertex as a losing vertex, and continue the DFS from this vertex.

Otherwise we don't know yet, if this vertex is a winning or losing vertex, and therefore it doesn't make sense to keep continuing the DFS using it.

In total we visit every winning and every losing vertex exactly once (undefined vertices are not visited), and we go over each edge also at most one time.

Hence the complexity is $O(m)$.

Here is the implementation of such a DFS.

We assume that the variable `adj_rev` stores the adjacency list for the graph in **reversed** form, i.e. instead of storing the edge $(i, j)$ of the graph, we store $(j, i)$.

Also for each vertex we assume that the outgoing degree is already computed.

```cpp

vector<vector<int>> adj_rev;

vector<bool> winning;

vector<bool> losing;

vector<bool> visited;

vector<int> degree;

void dfs(int v) {

visited[v] = true;

for (int u : adj_rev[v]) {

if (!visited[v]) {

if (losing[v])

winning[u] = true;

else if (--degree[u] == 0)

losing[u] = true;

else

continue;

dfs(u);

}

}

}

- [Games on arbitrary graphs](./game_theory/games_on_graphs.html)