代码随想录Day22

最新推荐文章于 2024-09-27 14:28:55 发布
最新推荐文章于 2024-09-27 14:28:55 发布
阅读量278 收藏 3
点赞数 1
文章标签： 算法 leetcode java 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43797723/article/details/142321387
版权

目录

1、98. 所有可达路径

2、99. 岛屿数量

3、100. 岛屿的最大面积

4、101. 孤岛的总面积

5、102. 沉没孤岛

6、103. 水流问题

1、98. 所有可达路径

import java.util.*;
import java.lang.*;
class Main
{
    static List<Integer> path = new LinkedList<>();
    static List<List<Integer>> res = new LinkedList<>();
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[][] graph = new int[n + 1][n + 1];
        while(in.hasNext())
        {
            graph[in.nextInt()][in.nextInt()] = 1;
        }
        path.add(1);
        dfs(graph,n,1);
        if(res.size() == 0)
            System.out.println("-1");
        else
        {
            for(List<Integer> r : res)
            {
                System.out.print(r.get(0));
                for(int i = 1; i < r.size(); ++i)
                {
                    System.out.print(' ');
                    System.out.print(r.get(i));
                }
                System.out.println();
            }
        }
    }
    public static void dfs(int[][] graph, int n, int start)
    {
        if(start == n)
        {
            res.add(new LinkedList<>(path));
            return;
        }
        for(int i = 1; i <= n; ++i)
        {
            if(graph[start][i] == 1 && start != i)
            {
                path.add(i);
                dfs(graph,n,i);
                path.remove(path.size() - 1);
            }
        }
    }
}

2、99. 岛屿数量

深搜

import java.util.*;
import java.lang.*;
class Main
{
    static int res = 0;
    static int[][] dir = {{0,1},{0,-1},{1,0},{-1,0}};
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[][] graph = new int[n][m];
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                graph[i][j] = in.nextInt();
            }
        }
        int[][] visited = new int[n][m];
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                if(visited[i][j] == 0 && graph[i][j] == 1)
                {
                    ++res;
                    visited[i][j] = 1;
                    dfs(graph,visited,i,j);
                }
            }
        }
        System.out.println(res);
        
    }
    public static void dfs(int[][] graph, int[][] visited, int x, int y)
    {
        for(int i = 0; i < 4; ++i)
        {
            int nextx = x + dir[i][0];
            int nexty = y + dir[i][1];
            if(nextx < 0 || nextx > graph.length - 1 || nexty < 0 || nexty > graph[0].length - 1) continue;
            if(visited[nextx][nexty] == 0 && graph[nextx][nexty] == 1)
            {
                visited[nextx][nexty] = 1;
                dfs(graph,visited,nextx,nexty);
            }
        }
    }
}

广搜

import java.util.*;
import java.lang.*;
class Main
{
    static int res = 0;
    static int[][] dir = {{0,1},{0,-1},{1,0},{-1,0}};
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[][] graph = new int[n][m];
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                graph[i][j] = in.nextInt();
            }
        }
        int[][] visited = new int[n][m];
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                if(visited[i][j] == 0 && graph[i][j] == 1)
                {
                    ++res;
                    visited[i][j] = 1;
                    bfs(graph,visited,i,j);
                }
            }
        }
        System.out.println(res);
        
    }
    public static void bfs(int[][] graph, int[][] visited, int x, int y)
    {
        Queue<Point> que = new LinkedList<>();
        for(int i = 0; i < 4; ++i)
        {
            int nextx = x + dir[i][0];
            int nexty = y + dir[i][1];
            if(nextx < 0 || nextx > graph.length - 1 || nexty < 0 || nexty > graph[0].length - 1) continue;
            if(visited[nextx][nexty] == 0 && graph[nextx][nexty] == 1)
            {
                visited[nextx][nexty] = 1;
                que.offer(new Point(nextx,nexty));
            }
        }
        while(!que.isEmpty())
        {
            bfs(graph,visited,que.peek().x,que.poll().y);
        }
        
    }
}
class Point
{
    int x;
    int y;
    Point(int x, int y)
    {
        this.x = x;
        this.y = y;
    }
}

3、100. 岛屿的最大面积

import java.util.*;
import java.lang.*;
class Main
{
    static int cnt;
    static int[][] dir = {{0,1},{0,-1},{1,0},{-1,0}};
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[][] graph = new int[n][m];
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                graph[i][j] = in.nextInt();
            }
        }
        int[][] visited = new int[n][m];
        int res = 0;
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                if(visited[i][j] == 0 && graph[i][j] == 1)
                {
                    cnt = 1;
                    visited[i][j] = 1;
                    dfs(graph,visited,i,j);
                    res = Math.max(res,cnt);
                }
            }
        }
        System.out.println(res);
        
    }
    public static void dfs(int[][] graph, int[][] visited, int x, int y)
    {
        for(int i = 0; i < 4; ++i)
        {
            int nextx = x + dir[i][0];
            int nexty = y + dir[i][1];
            if(nextx < 0 || nextx > graph.length - 1 || nexty < 0 || nexty > graph[0].length - 1) continue;
            if(visited[nextx][nexty] == 0 && graph[nextx][nexty] == 1)
            {
                visited[nextx][nexty] = 1;
                ++cnt;
                dfs(graph,visited,nextx,nexty);
            }
        }
    }
}

4、101. 孤岛的总面积

import java.util.*;
import java.lang.*;
class Main
{
    static int cnt;
    static int[][] dir = {{0,1},{0,-1},{1,0},{-1,0}};
    static boolean isIsolated = true;
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[][] graph = new int[n][m];
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                graph[i][j] = in.nextInt();
            }
        }
        int[][] visited = new int[n][m];
        int res = 0;
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                if(visited[i][j] == 0 && graph[i][j] == 1)
                {
                    cnt = 1;
                    visited[i][j] = 1;
                    if(i == 0 || i == graph.length - 1 || j == 0 || j == graph[0].length - 1) isIsolated = false;
                    dfs(graph,visited,i,j);
                    if(isIsolated) res += cnt;
                }
                isIsolated = true;
            }
        }
        System.out.println(res);
        
    }
    public static void dfs(int[][] graph, int[][] visited, int x, int y)
    {
        for(int i = 0; i < 4; ++i)
        {
            int nextx = x + dir[i][0];
            int nexty = y + dir[i][1];
            if(nextx < 0 || nextx > graph.length - 1 || nexty < 0 || nexty > graph[0].length - 1) continue;
            if(visited[nextx][nexty] == 0 && graph[nextx][nexty] == 1)
            {
                visited[nextx][nexty] = 1;
                ++cnt;
                if(nextx == 0 || nextx == graph.length - 1 || nexty == 0 || nexty == graph[0].length - 1) isIsolated = false;
                dfs(graph,visited,nextx,nexty);
            }
        }
    }
}

5、102. 沉没孤岛

import java.util.*;
import java.lang.*;
class Main
{
    static int[][] dir = {{0,1},{0,-1},{1,0},{-1,0}};
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[][] graph = new int[n][m];
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                graph[i][j] = in.nextInt();
            }
        }
        for(int i = 0; i < n; ++i)
        {
            if(graph[i][0] == 1) dfs(graph,i,0);
            if(graph[i][m - 1] == 1) dfs(graph,i,m - 1);
        }
        for(int i = 1; i < m - 1; ++i)
        {
            if(graph[0][i] == 1) dfs(graph,0,i);
            if(graph[n - 1][i] == 1) dfs(graph,n - 1,i);
        }
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                if(graph[i][j] == 1) graph[i][j] = 0;
                if(graph[i][j] == 2) graph[i][j] = 1;
                System.out.print(graph[i][j] + " ");
            }
            System.out.println();
        }
    }
    public static void dfs(int[][] graph, int x, int y)
    {
        graph[x][y] = 2;
        for(int i = 0; i < 4; ++i)
        {
            int nextx = x + dir[i][0];
            int nexty = y + dir[i][1];
            if(nextx < 0 || nextx > graph.length - 1 || nexty < 0 || nexty > graph[0].length - 1) continue;
            if(graph[nextx][nexty] == 1)
            {
                dfs(graph,nextx,nexty);
            }
        }
    }
}

6、103. 水流问题

import java.util.*;
import java.lang.*;
class Main
{
    static int[][] dir = {{0,1},{0,-1},{1,0},{-1,0}};
    public static void main(String[] args)
    {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int m = in.nextInt();
        int[][] graph = new int[n][m];
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                graph[i][j] = in.nextInt();
            }
        }
        boolean[][] isFirst = new boolean[n][m];
        boolean[][] isSecond = new boolean[n][m];
        for(int i = 0; i < n; ++i)
        {
            dfs(graph,isFirst,i,0);
            dfs(graph,isSecond,i,m - 1);
        }
        for(int i = 0; i < m; ++i)
        {
            dfs(graph,isFirst,0,i);
            dfs(graph,isSecond,n - 1,i);
        }
        for(int i = 0; i < n; ++i)
        {
            for(int j = 0; j < m; ++j)
            {
                if(isFirst[i][j] && isSecond[i][j]) System.out.println(i + " " + j);
            }
        }
    }
    public static void dfs(int[][] graph, boolean[][] record, int x, int y)
    {
        record[x][y] = true;
        for(int i = 0; i < 4; ++i)
        {
            int nextx = x + dir[i][0];
            int nexty = y + dir[i][1];
            if(nextx < 0 || nextx > graph.length - 1 || nexty < 0 || nexty > graph[0].length - 1) continue;
            if(!record[nextx][nexty] && graph[nextx][nexty] >= graph[x][y])
            {
                dfs(graph,record,nextx,nexty);
            }
        }
    }
}
维克吐蛙
关注
代码随想录 Day14 二叉树
02-07
### 二叉树原理及Java实现详解 #### 一、二叉树简介 二叉树是一种树形数据结构，其中每个节点最多有两个子节点，分别称为左子节点和右子节点。二叉树广泛应用于各种计算机科学领域，如数据管理、算法设计、编译器...
代码随想录刷题打卡day02
04-18
3. 代码重构：代码中声明的数组 `int[] nums = {1};` 在 `while` 循环中使用时，包含等号的条件可以避免在临界情况下（如数组只有一个元素）发生数组越界的问题。 4. 数组操作与指针移动：在双指针法中，通常需要对...
代码随想录 day22
ysk_0904的博客
11-09 113
【代码】代码随想录 day22。
代码随想录day22
qq_40829893的博客
11-01 112
while循环至根节点有点难琢磨。
代码随想录 Day22 二叉树
2302_77073236的博客
02-20 280
因为二叉搜索树的元素有序性，所以都比较简单，damn是450删除二叉搜索树的节点比较复杂，考虑的情况很多。
【代码随想录day22】爬楼梯
little_spice的博客
08-16 441
假设你正在爬楼梯。需要n阶你才能到达楼顶。每次你可以爬1或2个台阶。你有多少种不同的方法可以爬到楼顶呢？n = 22有两种方法可以爬到楼顶。1. 1 阶 + 1 阶2. 2 阶n = 33有三种方法可以爬到楼顶。1. 1 阶 + 1 阶 + 1 阶2. 1 阶 + 2 阶3. 2 阶 + 1 阶。
【代码随想录Day22】回溯算法Part01
Shayne 的博客
09-20 802
【代码】【代码随想录Day22】回溯算法Part01。
代码随想录day04
qq_42467430的博客
12-12 1032
链表类
代码随想录-Day22
ToBewhatyouwannabe的博客
05-29 1139
这段代码定义了一个名为Solution的类，用于求解二叉搜索树（Binary Search Tree, BST）中两个指定节点的最近公共祖先（Lowest Common Ancestor, LCA）。rootpqgetPathpqpqnullancestornullroottargetpath注意，这段代码的高效运行依赖于输入是二叉搜索树的特性，即树中任意节点的左子树所有节点的值都小于该节点的值，右子树所有节点的值都大于该节点的值。
代码随想录Day57
qq_45655634的博客
04-17 380
难难难，面试也有答案就好了动态规划完结，不知道啥时候刷第二遍股票也难难难，不知道是对还是错。
代码随想录Day40
qq_45655634的博客
04-01 367
目前所做的动态规划本质上还是在找规律，如何从dp数组的前一种状态推出dp数组的下一种状态，目前的都还比较简单，背包问题就比较难了；今天大涨，我不出意外的话，今天又会是4月涨的最好的一天。
我在代码随想录-写代码Day16之二叉树
01-24
二叉树遍历
二叉树最小深度
2301_80161204的博客
09-27 448
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1258
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
904. 水果成篮
最新发布
YQ20210216的博客
09-27 354
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
【优选算法】（第一篇）
weixin_73861555的博客
09-25 1083
这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。
代码随想录算法训练营|226.翻转二叉树 、 101. 对称二叉树、 104.二叉树的最大深度、 111.二叉树的最小深度
cccoffer的博客
09-27 383
这里只是取最小值是不正确的，因为一旦有一个节点的左或右节点出现了空，此时这个位置成为了最小值，但是不符合题意的，题意是到叶子节点的最小深度。首先交换当前节点的左右子节点，然后递归当前节点的左右子节点（相当于到了子节点还是做同样的操作），知道所有节点遍历完了，就完成了翻转，返回root即可。思路：这题的就是区分高度和深度的题目，不过也可以用求高度的方法求得（即求根节点的高度即可，这个就是用到了后序遍历），求深度就是从根节点开始遍历，直到找到最深的叶子节点即可（相当于前序遍历），这里用前序遍历的方式解题。
560. 和为 K 的子数组
mrjieke6的博客
09-24 298
子数组是数组中元素的连续非空序列。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值