代码随想录算法训练营第五十九天| 110. 字符串接龙、105. 有向图的完全可达性、106. 岛屿的周长

于 2024-07-08 14:15:55 发布
阅读量1k 收藏 29
点赞数 30
文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dreamtang/article/details/140265688
版权

[KamaCoder] 110. 字符串接龙

[KamaCoder] 110. 字符串接龙 文章解释

题目描述

字典 strList 中从字符串 beginStr 和 endStr 的转换序列是一个按下述规格形成的序列： 

1. 序列中第一个字符串是 beginStr。

2. 序列中最后一个字符串是 endStr。 

3. 每次转换只能改变一个字符。 

4. 转换过程中的中间字符串必须是字典 strList 中的字符串，且strList里的每个字符串只用使用一次。 

给你两个字符串 beginStr 和 endStr 和一个字典 strList，找到从 beginStr 到 endStr 的最短转换序列中的字符串数目。如果不存在这样的转换序列，返回 0。

输入描述

第一行包含一个整数 N，表示字典 strList 中的字符串数量。 第二行包含两个字符串，用空格隔开，分别代表 beginStr 和 endStr。 后续 N 行，每行一个字符串，代表 strList 中的字符串。

输出描述

输出一个整数，代表从 beginStr 转换到 endStr 需要的最短转换序列中的字符串数量。如果不存在这样的转换序列，则输出 0。

输入示例
6
abc def
efc
dbc
ebc
dec
dfc
yhn
输出示例
4

数据范围：

2 <= N <= 500

[KamaCoder] 110. 字符串接龙

自己看到题目的第一想法

    只要能构建从 beginStr 到 endStr 的邻接矩阵, 就可以知道所有路劲了. 但是构建邻接矩阵成了难题.

看完代码随想录之后的想法

    从 beginStr 开始, 从左往右替换 beginStr 中的每一个字符, 如果替换后的字符串 word 在 strList 中存在对应的字符串, 说明可以从 beginStr 改变一个字符到达对应的字符串. 使用一个 Map<String, Integer> 记录住到达 word 的路劲长度. 这样不停的遍历, 直到第一次遇到 word.equals(endStr) 则找到了对应的路劲.

import java.util.Scanner;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Set;


public class Main {
    private static int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String beginStr = "";
        String endStr = "";
        Set<String> dicStrs = new HashSet<>();
        while (scanner.hasNext()) {
            int dicSize = scanner.nextInt();
            scanner.nextLine();
            String[] dicStrArrays = scanner.nextLine().split(" ");
            beginStr = dicStrArrays[0];
            endStr = dicStrArrays[1];
            for (int i = 0; i < dicSize; i++) {
                dicStrs.add(scanner.nextLine());
            }
        }
        
        Map<String, Integer> wordPath = new HashMap<>();
        Deque<String> words = new LinkedList<>();
        String word;
        words.addLast(beginStr);
        wordPath.put(beginStr, 1);
        while(!words.isEmpty()) {
            String currentWord = words.pop();
            StringBuilder wordBuilder = null;
            for (int i = 0; i < currentWord.length(); i++) {
                wordBuilder = new StringBuilder(currentWord);
                for (int j = 0; j < 26; j++) {
                    wordBuilder.setCharAt(i, (char)(j + 'a'));
                    word = wordBuilder.toString();
                    if (wordPath.containsKey(word)) {
                        continue;
                    }
                    if (word.equals(endStr)) {
                        System.out.println(wordPath.get(currentWord) + 1);
                        return;
                    }
                    if (!dicStrs.contains(word)) {
                        continue;
                    }
                    wordPath.put(word, wordPath.get(currentWord) + 1);
                    words.addLast(word);
                }
            }
        }
        System.out.println(0);
    }
}

自己实现过程中遇到哪些困难

    整体不难, 一周半过后还完全可以靠逻辑快速 AC.

[KamaCoder] 105. 有向图的完全可达性

[KamaCoder] 105. 有向图的完全可达性 文章解释

题目描述

给定一个有向图，包含 N 个节点，节点编号分别为 1，2，...，N。现从 1 号节点开始，如果可以从 1 号节点的边可以到达任何节点，则输出 1，否则输出 -1。

输入描述

第一行包含两个正整数，表示节点数量 N 和边的数量 K。 后续 K 行，每行两个正整数 s 和 t，表示从 s 节点有一条边单向连接到 t 节点。

输出描述

如果可以从 1 号节点的边可以到达任何节点，则输出 1，否则输出 -1。

输入示例
4 4
1 2
2 1
1 3
2 4
输出示例
1

数据范围：

1 <= N <= 100；
1 <= K <= 2000。

[KamaCoder] 105. 有向图的完全可达性

自己看到题目的第一想法

    无.

看完代码随想录之后的想法

    利用 dfs 不停的往前遍历, 同时因为是双向图, 对于遍历过的节点需要记录一下, 避免死循环.

import java.util.ArrayList;
import java.util.Scanner;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Set;

// 邻接表 dfs
public class Main {
    private static int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int nodeCount = 0;
        Map<Integer, List<Integer>> nodes = new HashMap<>();
        while (scanner.hasNext()) {
            nodeCount = scanner.nextInt();
            int sideCount = scanner.nextInt();
            for (int i = 0; i < sideCount; i++) {
                int node = scanner.nextInt();
                List<Integer> toNodes = nodes.get(node);
                if (toNodes == null) {
                    toNodes = new ArrayList<>();
                    nodes.put(node, toNodes);
                }
                toNodes.add(scanner.nextInt());
            }
        }
        
        boolean[] visited = new boolean[nodeCount + 1];
        visited[0] = true;
        dfs(nodes, 1, visited);
        for (int i = 1; i < visited.length; i++) {
            if (!visited[i]) {
                System.out.println(-1);
                return;
            }
        }
        System.out.println(1);
    }
    private static void dfs(Map<Integer, List<Integer>> nodes, int node, boolean[] visited) {
        if (visited[node]) {
            return;
        }
        visited[node] = true;
        List<Integer> toNodes = nodes.get(node);
        if (toNodes == null) {
            return;
        }
        for (Integer newNode : toNodes) {
            dfs(nodes, newNode, visited);
        }
    }
}
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Set;


// 邻接矩阵 dfs
public class Main {
    private static int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[][] nodes = null;
        while (scanner.hasNext()) {
            int nodeCount = scanner.nextInt();
            int sideCount = scanner.nextInt();
            nodes = new int[nodeCount + 1][nodeCount + 1];
            for (int i = 0; i < sideCount; i++) {
                nodes[scanner.nextInt()][scanner.nextInt()] = 1;
            }
        }
        boolean[] visited = new boolean[nodes.length];
        visited[0] = true;
        dfs(nodes, 1, visited);
        for (int i = 1; i < visited.length; i++) {
            if (!visited[i]) {
                System.out.println(-1);
                return;
            }
        }
        System.out.println(1);
    }
    private static void dfs(int[][] nodes, int node, boolean[] visited) {
        if (visited[node]) {
            return;
        }
        visited[node] = true;
        for (int i = 1; i < nodes[node].length; i++) {
            if (nodes[node][i] == 1) {
                dfs(nodes, i, visited);   
            }
        }
    }
}
import java.util.ArrayList;
import java.util.Scanner;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Set;

// 邻接表 bfs
public class Main {
    private static int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int nodeCount = 0;
        Map<Integer, List<Integer>> nodes = new HashMap<>();
        while (scanner.hasNext()) {
            nodeCount = scanner.nextInt();
            int sideCount = scanner.nextInt();
            for (int i = 0; i < sideCount; i++) {
                int node = scanner.nextInt();
                List<Integer> toNodes = nodes.get(node);
                if (toNodes == null) {
                    toNodes = new ArrayList<>();
                    nodes.put(node, toNodes);
                }
                toNodes.add(scanner.nextInt());
            }
        }
        
        boolean[] visited = new boolean[nodeCount + 1];
        visited[0] = true;
        bfs(nodes, 1, visited);
        for (int i = 1; i < visited.length; i++) {
            if (!visited[i]) {
                System.out.println(-1);
                return;
            }
        }
        System.out.println(1);
    }
    private static void bfs(Map<Integer, List<Integer>> nodes, int node, boolean[] visited) {
        Deque<Integer> fromNodes = new LinkedList<>();
        fromNodes.add(node);
        visited[node] = true;
        while (!fromNodes.isEmpty()) {
            int fromNode = fromNodes.pop();
            List<Integer> toNodes = nodes.get(fromNode);
            if (toNodes == null) {
                continue;
            }
            for (Integer newNode : toNodes) {
                if (visited[newNode]) {
                    continue;
                }
                fromNodes.add(newNode);
                visited[newNode] = true;
            }
        }
    }
}

自己实现过程中遇到哪些困难 

    无

[KamaCoder] 106. 岛屿的周长

[KamaCoder] 106. 岛屿的周长 文章解释

题目描述

给定一个由 1（陆地）和 0（水）组成的矩阵，岛屿是被水包围，并且通过水平方向或垂直方向上相邻的陆地连接而成的。

你可以假设矩阵外均被水包围。在矩阵中恰好拥有一个岛屿，假设组成岛屿的陆地边长都为 1，请计算岛屿的周长。岛屿内部没有水域。

输入描述

第一行包含两个整数 N, M，表示矩阵的行数和列数。之后 N 行，每行包含 M 个数字，数字为 1 或者 0，表示岛屿的单元格。

输出描述

输出一个整数，表示岛屿的周长。

输入示例
5 5
0 0 0 0 0 
0 1 0 1 0
0 1 1 1 0
0 1 1 1 0
0 0 0 0 0
输出示例
14

数据范围：

1 <= M, N <= 50。

[KamaCoder] 106. 岛屿的周长

 

自己看到题目的第一想法

    当前陆地的上下左右方向, 每个方向有一个海水, 则周长+1;

看完代码随想录之后的想法

    方法1是一样的想法. 方法2通过计算陆地个数, 用陆地个数*4-相邻陆地个数*2计算.

import java.util.Scanner;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Set;


public class Main {
    private static int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[][] nodes = null;
        boolean[][] visited = null;
        while (scanner.hasNext()) {
            nodes = new int[scanner.nextInt()][scanner.nextInt()];
            visited = new boolean[nodes.length][nodes[0].length];
            for (int i = 0; i < nodes.length; i++) {
                for (int j = 0; j < nodes[i].length; j++) {
                    nodes[i][j] = scanner.nextInt();
                }
            }
        }
        for (int i = 0; i < nodes.length; i++) {
            for (int j = 0; j < nodes[i].length; j++) {
                if (nodes[i][j] != 1) {
                    continue;
                }
                System.out.println(dfs(nodes, visited, i, j));
                return;
            }
        }
        System.out.println(0);
    }
    
    private static int dfs(int[][] nodes, boolean[][] visited, int x, int y) {
        if (visited[x][y]) {
            return 0;
        }
        visited[x][y] = true;
        int newX;
        int newY;
        int perimeter = 0;
        for (int i = 0; i < dir.length; i++) {
            newX = x + dir[i][0];
            newY = y + dir[i][1];
            if (newX < 0 || newX >= nodes.length || newY < 0 || newY >= nodes[newX].length) {
                perimeter++;
                continue;
            }
            if (nodes[newX][newY] == 0) {
                perimeter++;
            } else {
                perimeter += dfs(nodes, visited, newX, newY);
            }
        }
        return perimeter;
    }
}
import java.util.Scanner;
import java.util.Deque;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.Map;
import java.util.Queue;
import java.util.Set;

// 巧妙记边法
public class Main {
    private static int[][] dir = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int[][] nodes = null;
        boolean[][] visited = null;
        while (scanner.hasNext()) {
            nodes = new int[scanner.nextInt()][scanner.nextInt()];
            visited = new boolean[nodes.length][nodes[0].length];
            for (int i = 0; i < nodes.length; i++) {
                for (int j = 0; j < nodes[i].length; j++) {
                    nodes[i][j] = scanner.nextInt();
                }
            }
        }
        int count = 0;
        int duplicate = 0;
        for (int i = 0; i < nodes.length; i++) {
            for (int j = 0; j < nodes[i].length; j++) {
                if (nodes[i][j] != 1) {
                    continue;
                }
                count++;
                int newX;
                int newY;
                for (int k = 0; k < 2; k++) {
                    newX = i + dir[k][0];
                    newY = j + dir[k][1];
                    if (newX >= nodes.length || newY >= nodes[newX].length) {
                        continue;
                    }
                    if (nodes[newX][newY] == 1) {
                        duplicate++;
                    }
                }
            }
        }
        System.out.println(count * 4 - duplicate * 2);
    }
}

自己实现过程中遇到哪些困难

    每个相邻的岛屿, 边是重复计算了2次, 一开始算成一次了.

dreamtang
关注
有向图的强连通分量课程设计报告.docx
07-05
有向图的强连通分量是图论中的一个重要概念，尤其在算法设计和数据结构的学习中占有举足轻重的地位。本课程设计报告主要针对有向图的强连通分量进行深入研究，通过算法分析和系统设计，实现求解有向图强连通分量的...
随想录 Day 66 110. 字符串接龙 105. 有向图的完全可达性 106. 岛屿的周长
weixin_44645059的博客
06-23 616
时间限制：1.000S 空间限制：256MB题目描述字典 strList 中从字符串 beginStr 和 endStr 的转换序列是一个按下述规格形成的序列：序列中第一个字符串是 beginStr。序列中最后一个字符串是 endStr。每次转换只能改变一个字符。转换过程中的中间字符串必须是字典 strList 中的字符串，且strList里的每个字符串只用使用一次。
字符串的应用-成语接龙
luoli_1的博客
05-17 103
【代码】字符串的应用-成语接龙。
力扣_字符串9—单词接龙I、II
qweasdwxc的博客
02-16 761
按字典wordList完成从单词beginWord到单词endWord转化，一个表示此过程的 转换序列 是形式上像beginWord−s1−s2−...−sksi1<=i<=kwordListbeginWordwordListsk==endWordbeginWordendWordwordListbeginWordendW。
110.字符串接龙
最新发布
SHUOSHUREN233的博客
07-05 330
题目描述：字典 strList 中从字符串 beginStr 和 endStr 的转换序列是一个按下述规格形成的序列： （1）序列中第一个字符串是 beginStr。（4）转换过程中的中间字符串必须是字典 strList 中的字符串，且strList里的每个字符串只使用一次。给你两个字符串 beginStr 和 endStr 和一个字典 strList，找到从 beginStr 到 endStr 的最短转换序列中的字符串数目。后续 N 行，每行一个字符串，代表 strList 中的字符串。
java实现字符串单词接龙
qq_36560270的博客
03-29 334
当存在多个首字母相同的单词时，取长度最长的单词，如果长也相等，则取字典序最小的单词;现给定一组全部由小写字母组成单词数组，并指定其中的一个单词作为起始单词，进行单词接龙；输入的第一行为一个非负整数，表示起始单词在数组中的索引K，0<=K<N;请输出最长的单词串，单词串是单词拼接而成，中间没有空。输入的第二行为一个非负整数，表示单词的个数N。接下来的N行，分别表示单词数组中的单词。单个单词的长度的取值范围为[1,30]。输出一个字符串，表示最终拼接的单词串。单词个数N的取值范围为[1，20]；
论文研究-基于粗糙图的分层符号有向图故障诊断方法研究 .pdf
08-14
在讨论基于粗糙图的分层符号有向图故障诊断方法之前，我们首先要明白符号有向图（SDG）和粗糙集在故障诊断中的应用及其限制。 符号有向图（SDG）是一种用于故障诊断的模型，它通过表示系统的组件及它们之间的因果...
aodv-uu-0.9.6.zip_AODV协议代码_aodv_aodv-uu-0.9.6_www.9uu.com大二
09-23
这个版本的代码提供了对AODV协议的详细实现，对于理解AODV的工作原理、进行网络模拟以及研究路由协议优化非常有帮助。 AODV协议的核心机制包括： 1. **路由发现（Route Discovery）**：当一个节点需要发送数据到未...
【Leetcode之树】0127 单词接龙
Withered Wood
04-21 161
来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/word-ladder实现语言：Java文章记录的是第一次做力扣题时的代码，之后做题的代码放在GitHub上了，由于博客中的文章有点多，挨个修改费时费力，博客中写的有关力扣的文章和GitHub中的代码并不完全对应。力扣题GitHub地址字典 中从单词 和 的 转换序列 是一个按下述规格形成的序列：序列中第一个单词是 。序列中最后一个单词是 。每次转换只能改变一个字母。转换过程中的中间单词必须是字典
爬山问题（百度笔试2018）
legend_hua的博客
04-18 1191
问题描述冬木市西边的园藏山是著名的旅游圣地。从空中俯瞰，园藏山可以看成一个 n * m 的矩阵，我们把行从上往下按 1 到 n 编号，把列从左往右按 1 到 m 编号，那么(i, j)就表示矩阵第 i 行第 j 列的位置。我们用ℎi,j , 表示位置(i, j)的海拔高度。初始时，Saber 在(sx, sy)这个位置，她想前往更高的地方。每一次她可以选择向上、下、左、右其中一个方向走，但不能走出...
代码随想录算法训练营第67天：图论5[1]
2302_79934729的博客
07-04 1294
‍。
单词接龙（字符串处理+dfs）
amazingee的博客
01-28 772
【题目描述】 单词接龙是一个与我们经常玩的成语接龙相类似的游戏，现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”（每个单词都最多在“龙”中出现两次），在两个单词相连时，其重合部分合为一部分，例如beast和astonish，如果接成一条龙则变为beastonish，另外相邻的两部分不能存在包含关系，例如at和atide间不能相连。 【输入】 输入的第一行为一个单独的整...
luogu1019_单词接龙（NOIP2000普及组第4题/提高组第3题）
HCSDN
08-01 436
luogu1019_单词接龙（NOIP2000普及组第4题/提高组第3题） 时空限制    1000ms/128MB 题目描述 单词接龙是一个与我们经常玩的成语接龙相类似的游戏，现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”（每个单词都最多在“龙”中出现两次），在两个单词相连时，其重合部分合为一部分，例如 beast和 astonish，如果接成一条龙则变为 ...
P1019 单词接龙【DFS+字符串】
王小二的博客
09-29 608
题目链接！ 题目描述 单词接龙是一个与我们经常玩的成语接龙相类似的游戏，现在我们已知一组单词，且给定一个开头的字母，要求出以这个字母开头的最长的“龙”（每个单词都最多在“龙”中出现两次），在两个单词相连时，其重合部分合为一部分，例如 beast和astonish，如果接成一条龙则变为beastonish，另外相邻的两部分不能存在包含关系，例如at 和 atide 间不能相连。 输入输出格式
算法训练 单词接龙
小木屋
05-11 2307
思路： 1.算出两两字符串之间的 【 尾首相连】  最小重合部分长度（长度为0不算）; 2.用一个大小为n的集合数组arr ，arr[i] 代表【第i个字符串】的【邻接集合】，集合里面存放可以邻接的字符串【所在位置】； 3.从每个开头为 【字符c】  的字符串开始深搜，取得最长的龙； 4.这个题的细节之处非常多： 1.字符串可以出现两次 2.【尾首相连】长度尽可能短（但是不能为零）
成语接龙（字符串，思路，按长度排序）
Dch19990825的博客
11-03 1197
成语接龙 Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 0    Accepted Submission(s): 0   Problem Description 小Z和大Z最近沉迷于成语接龙游戏，他们准备把成语接龙的规则修改一下。...
c语言字符串接龙,接龙分析.c
weixin_29304713的博客
05-17 641
//接龙字符串支持的长度//支持的名字长度//支持的名字个数#include //standard input and output#include #define JIELONG_STRLEN 2000//已经参与接龙的字符串，整体复制char jielong[JIELONG_STRLEN];//应该参与接龙的姓名列表char nameStr[100][20];//还未参与接龙的人char ...
递归分解算法：高效处理大规模图可达性查询
传统的图可达性查询算法如区间标记、链分解、2-hop标签和路径树等在处理大型有向图时可能面临存储需求大和查询效率低的问题。 本文提出的"基于递归分解的图可达性查询算法"提供了一种创新的解决方案。该算法的核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值