leetcode1559.二维网格图中探测环（判断存在环，中等）

判断图中是否存在环有两种方法：
1.并查集，对每条边进行遍历，并将边两边的节点进行合并，如果遍历到一条边，两个端点的findfather相等，则出现了环。
2.DFS。需要注意的是，在下一层搜索的时候，不能往相反的方向搜索！！

方法一：并查集

class Solution {
public:
    vector<int> father;
    int findfather (int u);
    bool containsCycle(vector<vector<char>>& grid) {
        
        int m = grid.size(), n = grid[0].size();
        father.resize(m * n);
        for (int i = 0; i < m * n; ++i) {
            father[i] = i;
        }
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                int u, v;
                if (j > 0 && grid[i][j - 1] == grid[i][j]) { 
                    u = i * n + j - 1;
                    v = i * n + j;
                    int fau = findfather(u);
                    int fav = findfather(v);
                    if (fau != fav) {
                        father[fau] = fav;
                    }else {
                        return true;
                    }
                }
                if (i > 0 && grid[i - 1][j] == grid[i][j]) {
                    u = (i - 1) * n + j;
                    v = i * n + j;
                    int fau = findfather(u);
                    int fav = findfather(v);
                    if (fau != fav) {
                        father[fau] = fav;
                    }else {
                        return true;
                    }
                }
            }
        }
        return false;
    }
};
int Solution :: findfather (int u) {
    if (father[u] == u) return u;
    return father[u] = findfather(father[u]);
}

注意的点：每次跟左边和上边的边，进行判断以及合并节点就可以了。

方法二：DFS

class Solution {
public:
    int m, n;
    int xy[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; //3-dir为相反方向
    bool dfs(vector<vector<char>>& grid, vector<vector<bool>> &flag, int x, int y, int dir) {
        flag[x][y] = true;
        for (int i = 0; i < 4; ++i) {
            int xx = x + xy[i][0];
            int yy = y + xy[i][1];
            if (dir != i && xx >= 0 && xx < m && yy >=0 && yy < n && grid[xx][yy] == grid[x][y]) { //不能向反方向搜索！！
                if (flag[xx][yy]) return true; //如果访问过，则返回true！！！
                //3-i为下一层不能搜索的方向
                if (dfs(grid, flag, xx, yy, 3 - i)) return true;  //如果下一层返回的是true，则返回true！！！
            }
        }
        return false;
    }
    bool containsCycle(vector<vector<char>>& grid) {
        
        m = grid.size();
        n = grid[0].size();
        vector<vector<bool>> flag(m, vector<bool>(n, false));
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (!flag[i][j] && dfs(grid, flag, i, j, -1)) {
                    return true;
                }
            }
        }
        return false;
    }
};

难点
1：避免向反方向搜索怎么解决？
int xy[4][2] = {0, 1, 1, 0, -1, 0, 0, -1};
3-dir即为反方向。
2：如何判断存在环？
如果遇到一个节点，之前已经标记过，即出现了环。。