leetcode：694. 不同岛屿的数量

题目来源

• leetcode：694. 不同岛屿的数量

题目描述

给定一个非空01二维数组表示的网格，一个岛屿由四连通（上、下、左、右四个方向）的 1 组成，你可以认为网格的四周被海水包围。

请你计算这个网格中共有多少个形状不同的岛屿。
两个岛屿被认为是相同的，当且仅当一个岛屿可以通过平移变换（不可以旋转、翻转）和另一个岛屿重合。

题目解析

关键点：两个岛屿是不是相同的

两个相同的岛屿通过平移可以完全重合，但是不能旋转。

如何判断

• 可以通过相对位置来判断
• 比如使用岛屿的最左上角的1当做基点，那么节点左边的点是(0,1), 上边的点就是 (-1,0)，下面的点就是 (1,0)。

class Solution {
    vector<vector<int>> dirs{{0,-1},{-1,0},{0,1},{1,0}};
    void helper(vector<vector<int>>& grid, int x0, int y0, int i, int j, vector<vector<bool>>& visited, set<string>& s) {
        int m = grid.size(), n = grid[0].size();
        visited[i][j] = true;
        for (auto dir : dirs) {
            int x = i + dir[0], y = j + dir[1];
            if (x < 0 || x >= m || y < 0 || y >= n || grid[x][y] == 0 || visited[x][y])
                continue;
            string str = to_string(x - x0) + "_" + to_string(y - y0);
            s.insert(str);
            helper(grid, x0, y0, x, y, visited, s);
        }
    }
public:

    int numDistinctIslands(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size();
        unordered_set<string> res;
        vector<vector<bool>> visited(m, vector<bool>(n, false));
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == 1 && !visited[i][j]) {
                    set<string> s;
                    helper(grid, i, j, i, j, visited, s);
                    string t = "";
                    for (auto str : s) t += str + "_";
                    res.insert(t);
                }
            }
        }
        return res.size();
    }

};

如何判断

• 对于形状相同的岛屿，如果从同一起点出发，深度优先遍历的顺序肯定是一样的。因为遍历顺序是写死在递归函数里面的，不会动态改变；
• 所以，遍历顺序从某种意义上说就可以用来描述岛屿的形状，比如下图这两个岛屿：

• 假设它们的遍历顺序是：下，右，上，撤销上，撤销右，撤销下
• 如果我用分别用1, 2, 3, 4代表上下左右，用-1, -2, -3, -4代表上下左右的撤销，那么可以这样表示它们的遍历顺序：2, 4, 1, -1, -4, -2
• 你看，这就相当于是岛屿序列化的结果，只要每次使用dfs遍历岛屿的时候生成这串数字进行比较，就可以计算到底有多少个不同的岛屿了。

class Solution {
    vector<vector<int>> dirs{{0,-1},{-1,0},{0,1},{1,0}};
    void helper(vector<vector<int>>& grid,  int i, int j, int dir, string& path) {
        int m = grid.size(), n = grid[0].size();
        if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] != 1)
            return;

        grid[i][j] = 2;
        path += to_string(dir) + ",";
        helper(grid,  i - 1, j, 1,  path);
        helper(grid,  i  + 1, j, 2,  path);
        helper(grid,  i , j - 1, 3,  path);
        helper(grid,  i , j + 1, 4,  path);
        path += to_string(-dir) + ",";
    }

public:

    int numDistinctIslands(vector<vector<int>>& grid) {
        int m = grid.size(), n = grid[0].size();
        unordered_set<string> res;
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                if (grid[i][j] == 1) {
                    string path;
                    helper(grid, i, j, 0, path); // 初始的方向可以随便写，不影响正确性
                    res.insert(path);
                }
            }
        }
        return res.size();
    }
};

测试

int main() {
    Solution a;

    vector<vector<int> > p {{1, 1, 0, 1, 1}, {1, 0, 0, 0, 0},  {0, 0, 0, 0, 1}, {1, 1, 0, 1, 1}};
    auto n = a.numDistinctIslands(p);
    std::cout << n << "\n";

    return 0;
}