101. 孤岛的总面积
时间限制：1.000S 空间限制：256MB
题目描述
给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。
现在你需要计算所有孤岛的总面积，岛屿面积的计算方式为组成岛屿的陆地的总数。
输入描述
第一行包含两个整数 N, M，表示矩阵的行数和列数。之后 N 行，每行包含 M 个数字，数字为 1 或者 0。
输出描述
输出一个整数，表示所有孤岛的总面积，如果不存在孤岛，则输出 0。
输入示例
4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1输出示例
1提示信息
在矩阵中心部分的岛屿，因为没有任何一个单元格接触到矩阵边缘，所以该岛屿属于孤岛，总面积为 1。
数据范围：
1 <= M, N <= 50。
思路:
本题要求找到不靠边的陆地面积，那么我们只要从周边找到陆地然后 通过 dfs或者bfs 将周边靠陆地且相邻的陆地都变成海洋，然后再去重新遍历地图 统计此时还剩下的陆地就可以了。
代码参考:
dfs:
import java.util.*;
class Main{
public static void main(String[] args){
int n,m;
Scanner in=new Scanner(System.in);
n=in.nextInt();
m=in.nextInt();
int[][] map=new int[n][m];
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
map[i][j]=in.nextInt();
}
}
//将靠边的岛屿变成海洋
for(int i=0;i<m;i++){
if(map[0][i]==1){
dfs(map,0,i);
}
if(map[n-1][i]==1){
dfs(map,n-1,i);
}
}
for(int i=0;i<n;i++){
if(map[i][0]==1){
dfs(map,i,0);
}
if(map[i][m-1]==1){
dfs(map,i,m-1);
}
}
//找孤岛
int result=0;
for(int i=1;i<n;i++){
for(int j=1;j<m;j++){
if(map[i][j]==1){
result+= dfs(map,i,j);
}
}
}
System.out.println(result);
}
public static int dfs(int[][]map,int x,int y){
int[][] dir={{-1,0},{0,-1},{1,0},{0,1}};
map[x][y]=0;
int result=0;
result++;
//像四个方向递归查找
for(int i=0;i<4;i++){
int newx=x+dir[i][0];
int newy=y+dir[i][1];
//
if(newx>=0&&newx<map.length&&newy>=0&&newy<map[0].length&&map[newx][newy]==1){
result+=dfs(map,newx,newy);
}
}
return result;
}
}102. 沉没孤岛
时间限制：1.000S 空间限制：256MB
题目描述
给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿指的是由水平或垂直方向上相邻的陆地单元格组成的区域，且完全被水域单元格包围。孤岛是那些位于矩阵内部、所有单元格都不接触边缘的岛屿。
现在你需要将所有孤岛“沉没”，即将孤岛中的所有陆地单元格（1）转变为水域单元格（0）。
输入描述
第一行包含两个整数 N, M，表示矩阵的行数和列数。
之后 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。
输出描述
输出将孤岛“沉没”之后的岛屿矩阵。 注意：每个元素后面都有一个空格
输入示例
4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1输出示例
1 1 0 0 0
1 1 0 0 0
0 0 0 0 0
0 0 0 1 1提示信息
将孤岛沉没。
数据范围：
1 <= M, N <= 50。
思路:
与上题在思路上也是差不多的。
思路依然是从地图周边出发，将周边空格相邻的陆地都做上标记，然后在遍历一遍地图，遇到 陆地 且没做过标记的，那么都是地图中间的 陆地 ，全部改成水域就行。
不用额外定义空间了，标记周边的陆地，可以直接改陆地为其他特殊值作为标记。
步骤一：深搜或者广搜将地图周边的 1 （陆地）全部改成 2 （特殊标记）
步骤二：将水域中间 1 （陆地）全部改成 水域（0）
步骤三：将之前标记的 2 改为 1 （陆地）
如图：
代码参考:
import java.util.*;
class Main{
public static void main(String[] args){
int n,m;
Scanner in=new Scanner(System.in);
n=in.nextInt();
m=in.nextInt();
int[][] map=new int[n][m];
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
map[i][j]=in.nextInt();
}
}
//将靠边的岛屿变成2
for(int i=0;i<m;i++){
if(map[0][i]==1){
dfs(map,0,i,2);
}
if(map[n-1][i]==1){
dfs(map,n-1,i,2);
}
}
for(int i=0;i<n;i++){
if(map[i][0]==1){
dfs(map,i,0,2);
}
if(map[i][m-1]==1){
dfs(map,i,m-1,2);
}
}
//沉没孤岛
for(int i=1;i<n;i++){
for(int j=1;j<m;j++){
if(map[i][j]==1){
map[i][j]=0;
}
}
}
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(map[i][j]==2) map[i][j]=1;
System.out.print(map[i][j]+" ");
}
System.out.println();
}
}
public static void dfs(int[][]map,int x,int y,int target){
int[][] dir={{-1,0},{0,-1},{1,0},{0,1}};
map[x][y]=target;
//像四个方向递归查找
for(int i=0;i<4;i++){
int newx=x+dir[i][0];
int newy=y+dir[i][1];
//
if(newx>=0&&newx<map.length&&newy>=0&&newy<map[0].length&&map[newx][newy]==1){
dfs(map,newx,newy,2);
}
}
}
}103. 水流问题
时间限制：1.000S 空间限制：256MB
题目描述
现有一个 N × M 的矩阵，每个单元格包含一个数值，这个数值代表该位置的相对高度。矩阵的左边界和上边界被认为是第一组边界，而矩阵的右边界和下边界被视为第二组边界。
矩阵模拟了一个地形，当雨水落在上面时，水会根据地形的倾斜向低处流动，但只能从较高或等高的地点流向较低或等高并且相邻（上下左右方向）的地点。我们的目标是确定那些单元格，从这些单元格出发的水可以达到第一组边界和第二组边界。
输入描述
第一行包含两个整数 N 和 M，分别表示矩阵的行数和列数。
后续 N 行，每行包含 M 个整数，表示矩阵中的每个单元格的高度。
输出描述
输出共有多行，每行输出两个整数，用一个空格隔开，表示可达第一组边界和第二组边界的单元格的坐标，输出顺序任意。
输入示例
5 5
1 3 1 2 4
1 2 1 3 2
2 4 7 2 1
4 5 6 1 1
1 4 1 2 1输出示例
0 4
1 3
2 2
3 0
3 1
3 2
4 0
4 1提示信息
图中的蓝色方块上的雨水既能流向第一组边界，也能流向第二组边界。所以最终答案为所有蓝色方块的坐标。
数据范围：
1 <= M, N <= 100。
思路:
我们可以 反过来想，从第一组边界上的节点 逆流而上，将遍历过的节点都标记上。
同样从第二组边界的边上节点 逆流而上，将遍历过的节点也标记上。
然后两方都标记过的节点就是既可以流太平洋也可以流大西洋的节点。
从第一组边界边上节点出发，如图：
代码参考:
import java.util.*;
class Main{
public static void main(String[] args){
int n,m;
Scanner in=new Scanner(System.in);
n=in.nextInt();
m=in.nextInt();
int[][] map=new int[n][m];
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
map[i][j]=in.nextInt();
}
}
boolean[][] first=new boolean[n][m];
boolean[][] second=new boolean[n][m];
//上下边界
for(int i=0;i<m;i++){
dfs(map,0,i,first);
dfs(map,n-1,i,second);
}
//左右边界
for(int i=0;i<n;i++){
dfs(map,i,0,first);
dfs(map,i,m-1,second);
}
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
if(first[i][j]&&second[i][j]){
System.out.println(i+" "+j);
}
}
}
}
public static void dfs(int[][]map,int x,int y,boolean[][] visited){
int[][] dir={{-1,0},{0,-1},{1,0},{0,1}};//当前结点向四周流动
visited[x][y]=true;
for(int i=0;i<4;i++){
int newx=x+dir[i][0];
int newy=y+dir[i][1];
if(newx>=0&&newy>=0&&newx<map.length&&newy<map[0].length&&visited[newx][newy]==false&&map[x][y]<=map[newx][newy]){
dfs(map,newx,newy,visited);
}
}
}
}104. 建造最大岛屿
时间限制：1.000S 空间限制：256MB
题目描述
给定一个由 1（陆地）和 0（水）组成的矩阵，你最多可以将矩阵中的一格水变为一块陆地，在执行了此操作之后，矩阵中最大的岛屿面积是多少。
岛屿面积的计算方式为组成岛屿的陆地的总数。岛屿是被水包围，并且通过水平方向或垂直方向上相邻的陆地连接而成的。你可以假设矩阵外均被水包围。
输入描述
第一行包含两个整数 N, M，表示矩阵的行数和列数。之后 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。
输出描述
输出一个整数，表示最大的岛屿面积。如果矩阵中不存在岛屿，则输出 0。
输入示例
4 5
1 1 0 0 0
1 1 0 0 0
0 0 1 0 0
0 0 0 1 1输出示例
6提示信息
对于上面的案例，有两个位置可将 0 变成 1，使得岛屿的面积最大，即 6。
数据范围：
1 <= M, N <= 50。
暴力:
遍历地图尝试 将每一个 0 改成1，然后去搜索地图中的最大的岛屿面积。
计算地图的最大面积：遍历地图 + 深搜岛屿，时间复杂度为 n * n。
（其实使用深搜还是广搜都是可以的，其目的就是遍历岛屿做一个标记，相当于染色，那么使用哪个遍历方式都行，以下我用深搜来讲解）
每改变一个0的方格，都需要重新计算一个地图的最大面积，所以 整体时间复杂度为：n^4。
优化:
只要用一次深搜把每个岛屿的面积记录下来就好。
第一步：一次遍历地图，得出各个岛屿的面积，并做编号记录。可以使用map记录，key为岛屿编号，value为岛屿面积
第二步：再遍历地图，遍历0的方格（因为要将0变成1），并统计该1（由0变成的1）周边岛屿(上下左右的岛)面积，将其相邻面积(岛屿去重)相加在一起，遍历所有 0 之后，就可以得出 选一个0变成1 之后的最大面积。
import java.util.*;
class Main {
static Map<Integer, Integer> mymap = new HashMap<>();
public static void main(String[] args) {
int n, m;
Scanner in = new Scanner(System.in);
n = in.nextInt();
m = in.nextInt();
int[][] map = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
map[i][j] = in.nextInt();
}
}
mymap.put(0, 0);
//得到每个岛的面积
int marked = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (map[i][j] == 1) {
int s = dfs(map, i, j, ++marked);
mymap.put(marked, s);//记录岛屿的编号和面积
}
}
}
//将0改为1
boolean flag = true;//是否全为陆地
int result = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (map[i][j] == 0) {
flag = false;
result = Math.max(result, getS(map, i, j));
}
}
}
if (flag) {
System.out.println(mymap.get(2));
} else {
System.out.println(result);
}
}
public static int dfs(int[][] map, int x, int y, int marked) {
int[][] dir = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
map[x][y] = marked;
int result = 1;
for (int i = 0; i < 4; i++) {
int newx = x + dir[i][0];
int newy = y + dir[i][1];
if (newx >= 0 && newy >= 0 && newx < map.length && newy < map[0].length && map[newx][newy] == 1) {
result += dfs(map, newx, newy, marked);
}
}
return result;
}
//计算将其变为陆地后与周围岛屿的最大面积
public static int getS(int[][] map, int x, int y) {
int[][] dir = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
List<Integer> visited = new LinkedList<>();//记录周围岛屿防止重复
int s = 1;
for (int i = 0; i < 4; i++) {
int newx = x + dir[i][0];
int newy = y + dir[i][1];
if (newx >= 0 && newy >= 0 && newx < map.length && newy < map[0].length) {
int n = map[newx][newy];
if (!visited.contains(n)) {
visited.add(n);
Integer nums = mymap.get(n);
s+=nums;
}
}
}
return s;
}
}注意细节:
1.遍历为0的位置将其变为1更新最大岛屿面积时,要判断整个区域是不是没有海而全是陆地
2.遍历为0的位置将其变为1更新最大岛屿面积时,要对周围的陆地进行去重后才相加面积!
328
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
