The two players play the role of cat and mouse respectively, and play the game on an undirected graph. They take turns.

The form of graph is: graph[a] is a list, which is composed of all nodes b satisfying that ab is an edge in the graph.

The mouse starts from node 1 and starts first; The cat starts from node 2 and starts the second. There is a hole at node 0.

In each player's action, they must move along an edge connected to their current position in the graph. For example, if a mouse is at node 1, it must move to any node in the graph[1].

In addition, the cat cannot move into the hole (node 0).

Then, the game ends in one of the following three situations:

- If the cat and mouse appear at the same node, the cat wins.
- If the mouse reaches the hole, the mouse wins.
- If a position repeats (that is, the player's position and moving order are the same as the last action), the game is tied.

Give you a graph and assume that both players are participating in the game at their best:

- If the mouse wins, it returns {1;
- If the cat wins, return 2;
- Returns 0 if there is a draw.

Example 1:

Input: graph = [[2,5],[3],[0,4,5],[1,4,5],[2,3],[0,2,3]]

Output: 0

Example 2:

Input: graph = [[1,3],[0],[3],[0,2]]

Output: 1

Tips:

- 3 <= graph.length <= 50
- 1 <= graph[i].length < graph.length
- 0 <= graph[i][j] < graph.length
- graph[i][j] != i
- Graphs [i] are different from each other
- Cats and mice always move in the game

# analysis:

Methods: dynamic programming + dfs

Considering the state and steps of the cat and mouse, and the length of the undirected graph is limited to 50, it is advisable to use three dimensions to represent the state, so that the current state is F(i, j, k), i represents the number of steps taken, j represents the node taken by the mouse, and k represents the node taken by the cat. The current state meets the following conditions:

- When I > = twice the length of the undirected graph, it means that the cat and mouse come to a route and go back and forth, draw, F(i, j, k) = 0
- When j = 0, the mouse enters the hole, the mouse wins, F(i, j, k) = 1
- When j = k ， the cat and the mouse meet. The cat wins. F(i, j, k) = 2

The priority of the mouse is: hole > Draw > cat. The priority of the cat is: don't let the mouse enter the hole > catch the mouse > draw. We can use depth first traversal and judge according to the priority. Because the mouse goes first, and we start from 0, so we take the remainder of the steps. The even number is the old mouse step and the odd number is the cat step.

Time complexity: O(n^4)

Space complexity: O(n^3)

class Solution { //Undirected graph int[][] graph; //Define 3D array int[][][] arr; //The maximum number of nodes is 50 int num = 50; public int catMouseGame(int[][] graph) { this.graph = graph; //Define 3D array arr = new int[num * 2][num][num]; //Traversal. The array defaults to 0. Returning - 1 means a draw int res = dfs(0, 1, 2); return res == -1? 0: res; } public int dfs(int i, int j, int k){ //Repeated traversal once, draw if(i == num * 2){ return -1; } //The mouse goes into the hole if(j == 0){ arr[i][j][k] = 1; return 1; } //The cat caught the mouse if(j == k){ arr[i][j][k] = 2; return 2; } //walk if(arr[i][j][k] != 0){ return arr[i][j][k]; } //Mouse step if(i % 2 == 0){ //Logo cat wins int cat = 2; //Traversal route for(int g: graph[j]){ //Off road condition int state = dfs(i+1, g, k); //There's a hole. Go in if(state == 1){ arr[i][j][k] = 1; return 1; } //The cat can't win a draw if(state == -1){ cat = -1; } } arr[i][j][k] = cat; return cat; } //Catwalk //Logo mouse wins int mouse = 1; //Traversal route for(int g: graph[k]){ //Rat hole, no entry if(g == 0){ continue; } //Off road condition int state = dfs(i+1, j, g); //Catch a mouse if(state == 2){ arr[i][j][k] = 2; return 2; } //Draw, mouse can't win if(state == -1){ mouse = -1; } } arr[i][j][k] = mouse; return mouse; } }

Title Source: LeetCode

Link: https://leetcode-cn.com/problems/cat-and-mouse