【代码随想录Day52】图论Part04

字符串接龙

题目链接/文章讲解：代码随想录

import java.util.*;

public class Main {
    // 使用广度优先搜索（BFS）方法计算从beginWord到endWord的最短转换序列长度
    public static int findLadderLength(String beginWord, String endWord, List<String> wordList) {
        // 将单词列表转换为集合以提高查询效率
        HashSet<String> wordSet = new HashSet<>(wordList);

        // 创建队列以存储当前待处理的单词
        Queue<String> wordQueue = new LinkedList<>();

        // 创建映射以记录每个单词的路径长度
        HashMap<String, Integer> visitedWords = new HashMap<>();
        wordQueue.offer(beginWord);
        visitedWords.put(beginWord, 1);

        // 开始BFS遍历
        while (!wordQueue.isEmpty()) {
            String currentWord = wordQueue.poll();
            int currentPathLength = visitedWords.get(currentWord);

            // 遍历当前单词的每一个字符
            for (int i = 0; i < currentWord.length(); i++) {
                char[] charArray = currentWord.toCharArray();

                // 尝试用每个字母替换当前字符
                for (char letter = 'a'; letter <= 'z'; letter++) {
                    charArray[i] = letter;
                    String newWord = new String(charArray);

                    // 如果新单词是目标单词，返回路径长度
                    if (newWord.equals(endWord)) {
                        return currentPathLength + 1; // 返回当前路径长度加一
                    }

                    // 如果新单词存在于集合中且未被访问过
                    if (wordSet.contains(newWord) && !visitedWords.containsKey(newWord)) {
                        visitedWords.put(newWord, currentPathLength + 1);
                        wordQueue.offer(newWord); // 将新单词加入队列
                    }
                }
            }
        }

        // 如果没有找到转换路径，返回0
        return 0;
    }

    public static void main(String[] args) {
        // 接收输入
        Scanner scanner = new Scanner(System.in);
        int numberOfWords = scanner.nextInt();
        scanner.nextLine(); // 读取行结束符
        String[] inputWords = scanner.nextLine().split(" ");

        List<String> wordList = new ArrayList<>();
        for (int i = 0; i < numberOfWords; i++) {
            wordList.add(scanner.nextLine()); // 添加单词到列表中
        }

        // 计算从beginWord到endWord的最短转换序列长度
        int result = findLadderLength(inputWords[0], inputWords[1], wordList);
        System.out.println(result); // 打印结果
    }
}

有向图的完全可达性

题目链接/文章讲解：代码随想录

import java.util.*;

public class Main {
    // 邻接表，用于存储图的结构
    public static List<List<Integer>> adjacencyList = new ArrayList<>();

    // 深度优先搜索 (DFS) 方法
    public static void depthFirstSearch(boolean[] visited, int currentVertex) {
        // 如果当前顶点已经被访问过，直接返回
        if (visited[currentVertex]) {
            return;
        }
        // 标记当前顶点为已访问
        visited[currentVertex] = true;
        // 获取当前顶点的邻接顶点
        List<Integer> adjacentVertices = adjacencyList.get(currentVertex);
        // 对所有邻接顶点进行深度优先搜索
        for (int nextVertex : adjacentVertices) {
            depthFirstSearch(visited, nextVertex);
        }
    }

    // 广度优先搜索 (BFS) 方法
    public static void breadthFirstSearch(boolean[] visited, int startingVertex) {
        // 使用队列来实现广度优先搜索
        Queue<Integer> queue = new LinkedList<>();
        // 将起始顶点加入队列并标记为已访问
        queue.add(startingVertex);
        visited[startingVertex] = true;

        // 当队列不为空时，继续处理
        while (!queue.isEmpty()) {
            int currentVertex = queue.poll(); // 取出队列中的当前顶点
            List<Integer> adjacentVertices = adjacencyList.get(currentVertex);
            // 对所有邻接顶点进行处理
            for (int nextVertex : adjacentVertices) {
                // 如果邻接顶点未被访问过，则添加到队列，并标记为已访问
                if (!visited[nextVertex]) {
                    queue.add(nextVertex);
                    visited[nextVertex] = true;
                }
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int numberOfVertices = scanner.nextInt(); // 顶点数量
        int numberOfEdges = scanner.nextInt(); // 边的数量

        // 初始化邻接表
        for (int i = 0; i < numberOfVertices; i++) {
            adjacencyList.add(new LinkedList<>());
        }

        // 构建邻接表
        for (int i = 0; i < numberOfEdges; i++) {
            int sourceVertex = scanner.nextInt() - 1; // 输入的源顶点
            int targetVertex = scanner.nextInt() - 1; // 输入的目标顶点
            adjacencyList.get(sourceVertex).add(targetVertex);
        }

        boolean[] visited = new boolean[numberOfVertices]; // 访问记录数组
        depthFirstSearch(visited, 0); // 从顶点0开始进行深度优先搜索
//        breadthFirstSearch(visited, 0); // 如果需要使用广度优先搜索，可以取消注释

        // 检查图是否是连通的
        for (int i = 0; i < numberOfVertices; i++) {
            if (!visited[i]) {
                System.out.println(-1); // 如果有未访问的顶点，输出-1
                return;
            }
        }
        System.out.println(1); // 如果所有顶点都被访问，输出1
    }
}

岛屿的周长

题目链接/文章讲解：代码随想录

import java.util.*;

public class Main {
    // 定义四个方向的移动
    static int[][] directions = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    // 用于记录当前1的周长
    static int perimeterCount;

    // 计算当前位置周围的周长
    public static void calculatePerimeter(int[][] grid, int x, int y) {
        for (int[] direction : directions) {
            int newX = x + direction[0];
            int newY = y + direction[1];

            // 如果遇到边界或水（0），周长增加1
            if (newX < 0 || newX >= grid.length || newY < 0 || newY >= grid[0].length
                || grid[newX][newY] == 0) {
                perimeterCount++;
            }
        }
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 接受网格的尺寸输入
        int rows = scanner.nextInt();
        int columns = scanner.nextInt();

        int[][] grid = new int[rows][columns];
        // 读取网格数据
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                grid[i][j] = scanner.nextInt();
            }
        }

        int totalPerimeter = 0; // 初始化总周长
        // 遍历整个网格
        for (int i = 0; i < rows; i++) {
            for (int j = 0; j < columns; j++) {
                // 如果当前单元格为1，则计算其周长
                if (grid[i][j] == 1) {
                    perimeterCount = 0; // 重置周长计数
                    calculatePerimeter(grid, i, j); // 计算周长
                    totalPerimeter += perimeterCount; // 累加到总周长
                }
            }
        }

        // 输出结果
        System.out.println(totalPerimeter);
    }
}