初步接触极大极小值算法

题目 猫和老鼠：https://leetcode-cn.com/problems/cat-and-mouse/submissions/

极大极小值，有深度搜索的感觉在。

每次新赋值都是要考虑当前状态是极大值还是极小值，然后根据这个状态再向上更新值。

 

这道题，维护两个数组，一个是当前节点可走节点数，一个是当前节点的胜负状态。

一开始先初始化这两个数组，将可走节点数取该节点线条数，如果是猫就减去一条0的线路。

胜负状态就初始化老鼠0，猫任意，老鼠赢 和 老鼠和猫同一点，猫赢 这两种状态点，其他节点通过后期遍历赋值。

 

遍历取到的状态点

同时每个状态点都要将能达到它的父节点给取出

遍历这些父节点，将没有状态的点进行判断赋值。

 

最后跑完的整个胜负数组的状态就是 老鼠起点， 猫起点， 胜负状态 的一个数组。

 

class Solution {
    public int catMouseGame(int[][] graph) {
        int N = graph.length;
        final int DRAW = 0, MOUSE = 1, CAT = 2;

        int[][][] degree = new int[50][50][3];
        int[][][] color = new int[50][50][3];

        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                degree[i][j][1] = graph[i].length;
                degree[i][j][2] = graph[j].length;

                for (int m: graph[j]) {
                    if (m == 0) {
                        degree[i][j][2]--;
                        break;
                    }
                }
            }
        }

        Queue<int[]> queue = new LinkedList<>();
        for (int i = 0; i < N; i++) {
            for (int j = 1; j <=2; j++) {
                color[0][i][j] = MOUSE;
                queue.add(new int[]{0, i, j, MOUSE});
                if (i > 0) {
                    color[i][i][j] = CAT;
                    queue.add(new int[]{i, i, j, CAT});
                }
            }
        }

        while(!queue.isEmpty()) {
            int[] node = queue.remove();
            int i = node[0], j = node[1], t = node[2], c = node[3];
            
            for (int[] parent: getParent(graph, i, j, t)) {
                int i2 = parent[0], j2 = parent[1], t2 = parent[2];

                if (color[i2][j2][t2] == DRAW) {
                    if (t2 == c) {
                        color[i2][j2][t2] = c;
                        queue.add(new int[]{i2, j2, t2, c});
                    } else {
                        degree[i2][j2][t2]--;
                        if (degree[i2][j2][t2] == 0) {
                            color[i2][j2][t2] = 3 - t2;
                            queue.add(new int[]{i2, j2, t2, 3 - t2});
                        }
                    }
                }
            }
        }

        return color[1][2][1];
    }

    private List<int[]> getParent(int[][] graph, int i, int j, int t) {
        List<int[]> list = new LinkedList();
        if (t == 2) {
            for (int m : graph[i]) {
                list.add(new int[]{m, j, 3-t});
            }
        } else {
            for (int c : graph[j]) {
                if (c > 0) {
                    list.add(new int[]{i, c, 3-t});
                }
            }
        }
        return list;
    }
}