Lintcode： 不同岛屿的个数II

最新推荐文章于 2024-10-08 21:35:01 发布
最新推荐文章于 2024-10-08 21:35:01 发布
阅读量880 收藏 1
点赞数 1
分类专栏： Lintcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pianzang5201/article/details/93503836
版权

问题：

给定一个0和1的非空的二维数组网格，一个岛是一个1(表示陆地)的组，4个方向(水平或垂直)连接。你可以假设网格的所有四条边都被水包围。
计算不同岛屿的数量。当一个岛被认为与另一个岛相同时，它们有相同的形状，或在旋转后的形状相同(90,180，或270度)或翻转(左/右方向或向上/向下方向)。

样例：

Example 1:

Input: [[1,1,0,0,0],[1,0,0,0,0],[0,0,0,0,1],[0,0,0,1,1]]
Output: 1
Explanation:
The island is look like this:
11000
10000
00001
00011

Notice that:
11
1
and
 1
11
are considered same island shapes. Because if we make a 180 degrees clockwise rotation on the first island, then two islands will have the same shapes.

Example 2:

Input: [[1,1,1,0,0],[1,0,0,0,1],[0,1,0,0,1],[0,1,1,1,0]]
Output: 2
Explanation:
The island is look like this:
11100
10001
01001
01110

Here are the two distinct islands:
111
1
and
1
1

Notice that:
111
1
and
1
111
are considered same island shapes. Because if we flip the first array in the up/down direction, then they have the same shapes.

注意事项

每个维度在给定网格的长度不超过50。

python：

class Solution:
    """
    @param grid: the 2D grid
    @return: the number of distinct islands
    """
    def strReverse1(self, src):
        if src == "":
            return ""
        return src[::-1]
    def changeToFalse(self, grid, m, n, mMin, mMax, nMin, nMax):
        if m < 0 or m >= len(grid) or n < 0 or n >= len(grid[0]):
            return
        if grid[m][n] == 1:
            grid[m][n] = 2
            Mmin = min(m, mMin[0])
            del mMin[0]
            mMin.append(Mmin)
            Mmax = max(m, mMax[0])
            del mMax[0]
            mMax.append(Mmax)
            Nmin = min(n, nMin[0])
            del nMin[0]
            nMin.append(Nmin)
            Nmax = max(n, nMax[0])
            del nMax[0]
            nMax.append(Nmax)
            self.changeToFalse(grid, m-1, n, mMin, mMax, nMin, nMax)
            self.changeToFalse(grid, m+1, n, mMin, mMax, nMin, nMax)
            self.changeToFalse(grid, m, n-1, mMin, mMax, nMin, nMax)
            self.changeToFalse(grid, m, n+1, mMin, mMax, nMin, nMax)
    def numDistinctIslands2(self, grid):
        # write your code here
        if len(grid) == 0 or len(grid[0]) == 0:
            return 0
        resultStr = []
        for i in range(len(grid)):
            for j in range(len(grid[i])):
                if grid[i][j] == 1:
                    mMin = []
                    mMin.append(i)
                    mMax = []
                    mMax.append(i)
                    nMin = []
                    nMin.append(j)
                    nMax = []
                    nMax.append(j)
                    self.changeToFalse(grid, i, j, mMin, mMax, nMin, nMax)
                    temp = ""
                    temp90 = ""
                    temp180 = ""
                    temp270 = ""
                    templ2r = ""
                    tempt2b = ""
                    flag = False
                    for p in range(mMin[0], mMax[0]+1, 1):
                        for q in range(nMin[0], nMax[0]+1, 1):
                            temp = temp + str(grid[p][q])
                        if p != mMax[0]:
                            temp += "_"
                    temp180 = self.strReverse1(temp)
                    for p90 in range(nMin[0], nMax[0]+1, 1):
                        for q90 in range(mMax[0], mMin[0]-1, -1):
                            temp90 = temp90 + str(grid[q90][p90])
                        if p90 != nMax[0]:
                            temp90 += "_"
                    temp270 = self.strReverse1(temp90)
                    for pl2r in range(mMin[0], mMax[0]+1, 1):
                        for ql2r in range(nMax[0], nMin[0]-1, -1):
                            templ2r = templ2r + str(grid[pl2r][ql2r])
                        if pl2r != mMax[0]:
                            templ2r += "_"
                    tempt2b = self.strReverse1(templ2r)
                    if len(resultStr) == 0:
                        resultStr.append(temp)
                        resultStr.append(temp90)
                        resultStr.append(temp180)
                        resultStr.append(temp270)
                        resultStr.append(templ2r)
                        resultStr.append(tempt2b)
                    else:
                        for index in range(len(resultStr)):
                            if resultStr[index] == temp or resultStr[index] == temp90 or resultStr[index] == temp180 or resultStr[index] == temp270 or resultStr[index] == templ2r or resultStr[index] == tempt2b:
                                flag = True
                                break
                        if flag == False:
                            resultStr.append(temp)
                            resultStr.append(temp90)
                            resultStr.append(temp180)
                            resultStr.append(temp270)
                            resultStr.append(templ2r)
                            resultStr.append(tempt2b)
        return len(resultStr)//6

C++：

class Solution {
public:
    /**
     * @param grid: the 2D grid
     * @return: the number of distinct islands
     */
    void changeToFalse(vector<vector<int>> &grid, int m, int n, int &mMin, int &mMax, int &nMin, int &nMax)
    {
    	if (m < 0 || m >= grid.size() || n < 0 || n >= grid[0].size())
    	{
    		return;
    	}
    	if (grid[m][n] == 1)
    	{
    		grid[m][n] = 2;
    		mMin = min(m, mMin);
    		mMax = max(m, mMax);
    		nMin = min(n, nMin);
    		nMax = max(n, nMax);
    		changeToFalse(grid, m - 1, n, mMin, mMax, nMin, nMax);
    		changeToFalse(grid, m + 1, n, mMin, mMax, nMin, nMax);
    		changeToFalse(grid, m, n - 1, mMin, mMax, nMin, nMax);
    		changeToFalse(grid, m, n + 1, mMin, mMax, nMin, nMax);
    	}
    }
    string stringRev(string src)
    {
        string temp = src;
        reverse(temp.begin(),temp.end()); 
        return temp;
    }
    int numDistinctIslands2(vector<vector<int>> &grid) 
    {
        // write your code here
        if (grid.size() == 0 || grid[0].size() == 0)
    	{
    		return 0;
    	}
    	
    	vector<string> resultStr;
    	for (int i = 0; i < grid.size(); i++)
    	{
    		for (int j = 0; j < grid[i].size(); j++)
    		{
    			if (grid[i][j] == 1)
    			{
    				int mMin = i;
    				int mMax = i;
    				int nMin = j;
    				int nMax = j;
    				changeToFalse(grid, i, j, mMin, mMax, nMin, nMax);
    				string temp = "";
    				string temp90 = "";
    				string temp180 = "";
    				string temp270 = "";
    				string templ2r = "";
    				string tempt2b = "";
    				bool flag = false;
    				for (int p = mMin; p <= mMax; p++)
    				{
    					for (int q = nMin; q <= nMax; q++)
    					{
    						temp = temp + to_string(grid[p][q]);
    					}
    					if(p != mMax)
    					{
    					    temp += "_";
    					}
    				}
    				temp180 = stringRev(temp);
    				for (int p90 = nMin; p90 <= nMax; p90++)
    				{
    					for (int q90 = mMax; q90 >= mMin; q90--)
    					{
    						temp90 = temp90 + to_string(grid[q90][p90]);
    					}
    					if(p90 != nMax)
    					{
    					    temp90 += "_";
    					}
    				}
    				temp270 = stringRev(temp90);
    				for (int pl2r = mMin; pl2r <= mMax; pl2r++)
    				{
    					for (int ql2r = nMax; ql2r >= nMin; ql2r--)
    					{
    						templ2r = templ2r + to_string(grid[pl2r][ql2r]);
    					}
    					if(pl2r != mMax)
    					{
    					    templ2r += "_";
    					}
    				}
    				tempt2b = stringRev(templ2r);
    				if (resultStr.empty())
    				{
    					resultStr.push_back(temp);
						resultStr.push_back(temp90);
						resultStr.push_back(temp180);
						resultStr.push_back(temp270);
						resultStr.push_back(templ2r);
						resultStr.push_back(tempt2b);
    				}
    				else {
    					for (int index = 0; index < resultStr.size(); index++)
    					{
    						if (resultStr[index] == temp || resultStr[index] == temp90 || resultStr[index] == temp180 || resultStr[index] == temp270 || resultStr[index] == templ2r || resultStr[index] == tempt2b)
    						{
    							flag = true;
    							break;
    						}
    					}
    					if (flag == false)
    					{
    						resultStr.push_back(temp);
    						resultStr.push_back(temp90);
    						resultStr.push_back(temp180);
    						resultStr.push_back(temp270);
    						resultStr.push_back(templ2r);
    						resultStr.push_back(tempt2b);
    					}
    				}
    
    			}
    		}
    	}
    	return int(resultStr.size()/6);
    }
};

 

【LeetCode 深度优先搜索专项】不同岛屿的数量 II（711）
weixin_37780776的博客
10-29 624
【LeetCode 深度优先搜索专项】不同岛屿的数量 II（711）
Google面试题：岛屿的个数II
LintCode的博客
09-10 241
给定 n, m, 分别代表一个二维矩阵的行数和列数, 并给定一个大小为 k 的二元数组A. 初始二维矩阵全0. 二元数组A内的k个元素代表k次操作, 设第i个元素为 (A[i].x, A[i].y), 表示把二维矩阵中下标为A[i].x行A[i].y列的元素由海洋变为岛屿. 问在每次操作之后, 二维矩阵中岛屿的数量. 你需要返回一个大小为k的数组. 设定0表示海洋, 1代表岛屿, 并且上下左右相邻的1为同一个岛屿. 在线做题地址 样例 1: 输入: n = 4, m = 5, A = [[1,1],[0
leetcode：711.不同岛屿的数量 II
OceanStar的博客
08-23 910
如果两个岛屿之间形状相同，或者旋转（旋转角度仅可以为 90 、 180或 270 度）之后形状相同，或者镜像（可以沿上下或左右镜像）之后形状相同，就称这两个岛屿是相同的。给定一个 m × n的二维矩阵 grid ，使用或上、或下、或左、或右方向上相接的一组 1 代表一个岛屿。可以假定矩阵以外的区域都是海水。要求返回给定 grid 中包含的不同岛屿数量。
LeetCode-算法学习（入门篇）
最新发布
Forbiven的博客
10-08 1042
左神将算法分为了硬计算类算法、软计算类算法。硬计算类算法：精确求解。但是某些问题使用硬计算类的算法，可能会让计算的复杂度较高。大厂算法和数据结构笔试、面试题、acm比赛或者和acm形式类似的比赛，考察的都是硬计算类算法。软计算类算法：更注重逼近解决问题，而不是精确求解。计算时间可控比如：模糊逻辑、神经网络、进化计算、概率理论、混沌理论、支持向量机、群体智能硬计算类算法是所有程序员岗位都会考、任何写代码的工作都会用到的。前端、后端、架构、算法所有岗位都要用到。
LeetCode题解(0711)：不同岛屿的数量II(Python)
长行
11-26 416
题目：原题链接（困难） 标签：哈希表、图、广度优先搜索、深度优先搜索 解法 时间复杂度 空间复杂度 执行用时 Ans 1 (Python) O(N×M+I)O(N×M+I)O(N×M+I) : 其中I为岛屿数量 O(I)O(I)O(I) 320ms (60.87%) Ans 2 (Python) Ans 3 (Python) 解法一： class Solution: def numDistinctIslands(self, grid: List[List[in
【LeetCode - 694】不同岛屿的数量
学哥斌的博客
09-11 1545
【中等】BFS、哈希表
[LeetCode] Number of Islands II 岛屿的数量之二
weixin_33913332的博客
02-15 150
  A 2d grid map of m rows and n columns is initially filled with water. We may perform an addLand operation which turns the water at position (row, col) into a land. Given a list of positions to oper...
LintCode——岛屿的个数
ITYBED
04-24 649
描述： 给一个01矩阵，求不同的岛屿的个数。 0代表海，1代表岛，如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。 样例： 在矩阵： [ [1, 1, 0, 0, 0], [0, 1, 0, 0, 1], [0, 0, 0, 1, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0, 1
[LintCode 433] 岛屿的个数(Python)
yurenguowang的博客
08-22 2964
题目描述 给一个01矩阵，求不同的岛屿的个数。 0代表海，1代表岛，如果两个1相邻，那么这两个1属于同一个岛。我们只考虑上下左右为相邻。 样例 在矩阵： [ [1, 1, 0, 0, 0], [0, 1, 0, 0, 1], [0, 0, 0, 1, 1], [0, 0, 0, 0, 0], [0, 0, 0, 0,
leetcode lintcode python
m0_67105022的博客
03-09 407
动态规划的题目分为两大类，一种是求最优解类，典型问题是背包问题，另一种就是计数类，比如这里的统计方案数的问题，它们都存在一定的递推性质。前者的递推性质还有一个名字，叫做 「最优子结构」 ——即当前问题的最优解取决于子问题的最优解，后者类似，当前问题的方案数取决于子问题的方案数。所以在遇到求方案数的问题时，我们可以往动态规划的方向考虑。
lintcode微软
MuseCP@YenTown
02-27 312
156.合并区间 /** * Definition of Interval: * classs Interval { * int start, end; * Interval(int start, int end) { * this->start = start; * this->end = end; * } ...
Lintcode： 不同岛屿的个数
观月执白
06-19 575
问题： 给定一个由0和1组成的非空的二维网格，一个岛屿是指四个方向（包括横向和纵向）都相连的一组1（1表示陆地）。你可以假设网格的四个边缘都被水包围。 找出所有不同的岛屿的个数。如果一个岛屿与另一个岛屿形状相同（不考虑旋转和翻折），我们认为这两个岛屿是相同的。 注意： 11 1 和 1 11 是不同的岛屿，因为我们不考虑旋转和翻折。 样例 样例 1: 输入: ...
leetcode：694. 不同岛屿的数量
OceanStar的博客
08-23 728
给定一个非空01二维数组表示的网格，一个岛屿由四连通（上、下、左、右四个方向）的 1 组成，你可以认为网格的四周被海水包围。两个岛屿被认为是相同的，当且仅当一个岛屿可以通过平移变换（不可以旋转、翻转）和另一个岛屿重合。两个相同的岛屿通过平移可以完全重合，但是不能旋转。请你计算这个网格中共有多少个形状不同的岛屿。关键点：两个岛屿是不是相同的。
LeetCode 694. 不同岛屿的数量
m0_66776925的博客
01-10 218
基本思路： 130题的升级版，但是难在如何保存形状； ...
LeetCode题解(0305)：岛屿数量II(Python)
长行
12-03 288
题目：原题链接（困难） 标签：并查集 解法 时间复杂度 空间复杂度 执行用时 Ans 1 (Python) O(P2+M×N)O(P^2+M×N)O(P2+M×N) O(M×N)O(M×N)O(M×N) 276ms (62.22%) Ans 2 (Python) Ans 3 (Python) 解法一： class DSU: def __init__(self, n): self.array = [i for i in range(n)]
LintCode-岛屿的个数II
linside的博客
02-28 672
434. 岛屿的个数II 给定 n，m，分别代表一个2D矩阵的行数和列数，同时，给定一个大小为 k 的二元数组A。起初，2D矩阵的行数和列数均为 0，即该矩阵中只有海洋。二元数组有 k 个运算符，每个运算符有 2 个整数 A[i].x, A[i].y，你可通过改变矩阵网格中的A[i].x]，[A[i].y] 来将其由海洋改为岛屿。请在每次运算后，返回矩阵中岛屿的数量。 注意事项 ...
LeetCode 694. 不同岛屿的数量（BFS/DFS+set）
Michael是个半路程序员
07-17 2832
文章目录1. 题目2. 解题2.1 BFS 1. 题目 给定一个非空01二维数组表示的网格，一个岛屿由四连通（上、下、左、右四个方向）的 1 组成，你可以认为网格的四周被海水包围。 请你计算这个网格中共有多少个形状不同的岛屿。 两个岛屿被认为是相同的，当且仅当一个岛屿可以通过平移变换（不可以旋转、翻转）和另一个岛屿重合。 样例 1: 11000 11000 00011 00011 给定上图，返回结果 1。 样例 2: 11011 10000 00001 11011 给定上图，返回结果 3。 注意: 11
694 不同岛屿的数量
weixin_44171872的博客
10-11 631
题目描述： 给定一个非空 01 二维数组表示的网格，一个岛屿由四连通（上、下、左、右四个方向）的 1 组成，你可以认为网格的四周被海水包围。 请你计算这个网格中共有多少个形状不同的岛屿。两个岛屿被认为是相同的，当且仅当一个岛屿可以通过平移变换（不可以旋转、翻转）和另一个岛屿重合。 示例 1： 11000 11000 00011 00011 给定上图，返回结果 1 。 示例 2： 11011 10000 00001 11011 给定上图，返回结果 3 。 注意： 11 1 和 1 11 是不同的岛屿，因为我们
694. Number of Distinct Islands 形状不同的岛屿数量
weixin_30469895的博客
08-08 265
［抄题］： Given a non-empty 2D arraygridof 0's and 1's, anislandis a group of1's (representing land) connected 4-directionally (horizontal or vertical.) You may assume all four edges of the grid are...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值