LWC 53:694. Number of Distinct Islands

LWC 53:694. Number of Distinct Islands

传送门:694. Number of Distinct Islands

Problem:

Given a non-empty 2D array grid of 0’s and 1’s, an island is a group of 1’s (representing land) connected 4-directionally (horizontal or vertical.) You may assume all four edges of the grid are surrounded by water. Count the number of distinct islands. An island is considered to be the same as another if and only if one island can be translated (and not rotated or reflected) to equal the other.

Example 1:

11000 11000 00011 00011 Given the above grid map, return 1.

Example 2:

11011 10000 00001 11011 Given the above grid map, return 3. Notice that: 1 1 1 and 1 1 1 are considered different island shapes, because we do not consider reflection / rotation.

Note:

The length of each dimension in the given grid does not exceed 50.

思路: 首先dfs求出每个区域,并记录每个区域的起点,接着根据这些起点再dfs一次,判断四个方向上的长度是否相同。比如:

0 1 0 0 0 1 0
1 1 1 0 1 1 1
0 1 0 0 0 1 0

可以记录每个位置上四个方向的延伸长度,如果每个位置的上的四个值均相同,则说明两个区域重复。

实际上超时,可以采用HASH的思想,在第一次DFS时,就把四个方向的信息取回来,最终存一个起点的HASH值即可。

代码如下:

    int[][] dir = {{1, 0},{0, 1},{-1, 0},{0, -1}};
    int[][] dp = new int[50 * 50 + 16][5]; // four direction

    boolean[][] vis = new boolean[52][52];
    int n, m;

    Set<Integer> set = new HashSet<>();
    public int numDistinctIslands(int[][] grid) {
        n = grid.length;
        if (n == 0) return 0;
        m = grid[0].length;
        if (m == 0) return 0;
        vis = new boolean[52][52];
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (grid[i][j] == 1) {
                    if (!vis[i][j]) {
                        si = i;
                        sj = j;
                        dfs(grid, i, j);
                        set.add(dp[i * m + j][4]);
                    }
                }
            }
        }

        return set.size();
    }

    boolean check(int i, int j) {
        return i >= 0 && i < n && j >= 0 && j < m;
    }

    int si, sj;
    public int[] dfs(int[][] grid, int x, int y) {
        vis[x][y] = true;

        for (int k = 0; k < 4; ++k) {
            int[] d = dir[k];
            int nx = d[0] + x;
            int ny = d[1] + y;
            if (check(nx, ny) && !vis[nx][ny] && grid[nx][ny] == 1) {
                dp[x * m + y][k] = 1 + dfs(grid, nx, ny)[k];
                dp[x * m + y][4] += (dp[nx * m + ny][4] + 1) * (k + 1);
            }
        }

        for (int k = 0; k < 4; ++k) {
            dp[x * m + y][4] += (((x - si + 1) * m + (y - sj + 1)) * 177) *  (dp[x * m + y][k] + 1) * (k + 1);
        }

        return dp[x * m + y];
    }

上述代码采用数值的做法,当然,你也可以直接遍历一条链,以字符串的形式存储遍历的顺序,理解起来更直观,代码如下:

    int[][] dir = {{1, 0},{0, 1},{-1, 0},{0, -1}};
    char[]  c   = {'D','R','U','L'};
    int n, m;

    boolean[][] vis;

    public int numDistinctIslands(int[][] grid) {
        n = grid.length;
        if (n == 0) return 0;
        m = grid[0].length;
        if (m == 0) return 0;
        vis = new boolean[n][m];
        Set<String> set = new HashSet<>();
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (grid[i][j] == 1 && !vis[i][j]) {
                    si = i;
                    sj = j;
                    set.add(dfs(grid, i, j));
                }
            }
        }
        return set.size();
    }

    int si, sj;
    public String dfs(int[][] grid, int i, int j) {
        String ans = "" + ((i - si) * m + (j - sj));
        vis[i][j] = true;
        for (int k = 0; k < 4; ++k) {
            int[] d = dir[k];
            int ni = d[0] + i;
            int nj = d[1] + j;
            if (check(ni, nj) && !vis[ni][nj] && grid[ni][nj] == 1) {
                ans += c[k] + dfs(grid, ni, nj);
            }
        }
        return ans;
    }

    boolean check(int i, int j) {
        return i >= 0 && i < n && j >= 0 && j < m;
    }

注意:把相对位置的信息带进来,否则个别案例过不了。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏有趣的Python

算法与数据结构(八) 图论:带权图&最小生成树

带权图 Weighted Graph ? 带权图 边上都有自己的权值的带权图。 ? 邻接矩阵 把原来的1/0变成权值。 邻接表的改造 ? 邻接表 邻接...

3816
来自专栏冰霜之地

四叉树上如何求希尔伯特曲线的邻居 ?

关于邻居的定义,相邻即为邻居,那么邻居分为2种,边相邻和点相邻。边相邻的有4个方向,上下左右。点相邻的也有4个方向,即4个顶点相邻的。

721
来自专栏机器学习与自然语言处理

最大子序列和问题之算法优化

算法一:穷举式地尝试所有的可能 int maxSubsequenceSum(const int a[], int n) { int i, j, k; ...

1857
来自专栏Python爬虫与算法进阶

萌新刷题(十一)有效数字

题目 给定一个字符串,验证其是否为数字。 样例 "0" => true " 0.1 " => true "abc" => false "1 a" => ...

3287
来自专栏Python小屋

详解Python科学计算扩展库numpy中的矩阵运算(1)

首先解答上一篇文章中使用with关键字让你的Python代码更加Pythonic最后的习题,该题答案是False,原因在于内置函数sorted()的参数reve...

2644
来自专栏有趣的Python

玩转算法面试:(二)面试中的复杂度分析

面试中的时间复杂度分析 到底什么是大O n表示数据规模 O(f(n)) fn是关于n的一个函数。表示运行算法所需要执行的指令数,和f(n)成正比。 ? 常见...

5735
来自专栏Albert陈凯

技术面试要了解的算法和数据结构知识

目录 在线练习 在线编程面试 数据结构 算法 贪心算法 位运算 复杂度分析 视频教程 面试宝典 计算机科学资讯 文件结构 在线练习 Le...

2785
来自专栏专注数据中心高性能网络技术研发

[LeetCode]Math主题系列{第7,9,13,273题}

1.内容介绍 本篇文章记录在leetcode中Math主题下面的题目和自己的思考以及优化过程,具体内容层次按照{题目,分析,初解,初解结果,优化解,优化解结果,...

3407
来自专栏韦弦的微信小程序

Swift 只出现一次的数字 - LeetCode

给定一个整数数组,除了某个元素外其余元素均出现两次。请找出这个只出现一次的元素。 备注: 你的算法应该是一个线性时间复杂度。 你可以不用额外空间来实现它吗?

701
来自专栏编程

python学习笔记第三天:python之numpy篇!

此图只是为了封面而已,并非python女友 接下来要给大家介绍的系列中包含了Python在量化金融中运用最广泛的几个Library: numpy scipy p...

2165

扫码关注云+社区