算法练习（图论）

1.

/*首先为了方便表示，我们先给每一个单词标号，即给每个单词分配一个 id。创建一个由单词 word 到 id 对应的映射 wordId，并将 beginWord 与 wordList 中所有的单词都加入这个映射中。之后我们检查 endWord 是否在该映射内，若不存在，则输入无解。我们可以使用哈希表实现上面的映射关系。
然后我们需要建图，依据朴素的思路，我们可以枚举每一对单词的组合，判断它们是否恰好相差一个字符，以判断这两个单词对应的节点是否能够相连。但是这样效率太低，我们可以优化建图。
具体地，我们可以创建虚拟节点。对于单词 hit，我们创建三个虚拟节点 *it、h*t、hi*，并让 hit 向这三个虚拟节点分别连一条边即可。如果一个单词能够转化为 hit，那么该单词必然会连接到这三个虚拟节点之一。对于每一个单词，我们枚举它连接到的虚拟节点，把该单词对应的 id 与这些虚拟节点对应的 id 相连即可。
最后我们将起点加入队列开始广度优先搜索，当搜索到终点时，我们就找到了最短路径的长度。注意因为添加了虚拟节点，所以我们得到的距离为实际最短路径长度的两倍。同时我们并未计算起点对答案的贡献，所以我们应当返回距离的一半再加一的结果。
*/
    Map<String, Integer> wordId = new HashMap<>();
    List<List<Integer>> edge = new ArrayList<>();
    int nodeNum = 0;

    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        if (!wordList.contains(endWord)) {
            return 0;
        }

        for (String s : wordList) {
            addEdge(s);
        }
        addEdge(beginWord);
        int[] dis = new int[nodeNum];
        Arrays.fill(dis, Integer.MAX_VALUE);
        int beginId = wordId.get(beginWord), endId = wordId.get(endWord);
        dis[beginId] = 0;

        Queue<Integer> queue = new LinkedList<>();
        queue.offer(beginId);
        while (!queue.isEmpty()) {
            int id = queue.poll();
            if (id == endId) {
                return dis[endId] / 2 + 1;
            }
            for (int nextId : edge.get(id)) {
                if (dis[nextId] == Integer.MAX_VALUE) {
                    dis[nextId] = dis[id] + 1;
                    queue.offer(nextId);
                }
            }
        }
        return 0;
    }
    
   public void addEdge(String s) {
        addWord(s);
        int id1 = wordId.get(s);
        char[] array = s.toCharArray();
        for (int i = 0; i < array.length; i++) {
            char temp = array[i];
            array[i] = '*';
            String newWord = new String(array);
            addWord(newWord);
            int id2 = wordId.get(newWord);
            edge.get(id1).add(id2);
            edge.get(id2).add(id1);
            array[i] = temp;
        }
    }

    public void addWord(String s) {
        if (!wordId.containsKey(s)) {
            wordId.put(s, nodeNum++);
            edge.add(new ArrayList<Integer>());
        }
    }

2.

//如果节点为1开始dfs直到无法继续，将经过的点设为0，岛屿数等于进行的dfs次数
public int numIslands(char[][] grid) {
        if (grid == null || grid.length == 0) {
            return 0;
        }

        int rl = grid.length;
        int cl = grid[0].length;
        int numOfIsland = 0;
        for (int i = 0; i < rl; i++) {
            for (int j = 0; j < cl; j++) {
                if (grid[i][j] == '1') {
                    numOfIsland += 1;
                    islandDfs(grid, i, j);
                }
            }
        }
        return numOfIsland;
    }

    public void islandDfs(char[][] grid, int row, int col) {
        int rl = grid.length;
        int cl = grid[0].length;

        if (row < 0 || row >= rl || col < 0 || col >= cl || grid[row][col] == '0') {
            return;
        }

        grid[row][col] = '0';
        islandDfs(grid, row - 1, col);
        islandDfs(grid, row, col - 1);
        islandDfs(grid, row + 1, col);
        islandDfs(grid, row, col + 1);
    }

3.

//思路：该问题等价于寻找有无环的存在

//括扑排序法
    List<List<Integer>> edges;
    int[] inCount;
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        edges = new ArrayList<>();
        inCount = new int[numCourses];
        for (int i = 0; i < numCourses; i++) {
            edges.add(new ArrayList<Integer>());
        }
        for (int[] prerequisite : prerequisites) {
            edges.get(prerequisite[1]).add(prerequisite[0]);
            inCount[prerequisite[0]]++;
        }

        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (inCount[i] == 0){
                queue.offer(i);
            }
        }

        int visited = 0;
        while (!queue.isEmpty()){
            visited++;
            int u = queue.poll();
            for (int v : edges.get(u)) {
                inCount[v] -= 1;
                if (inCount[v] == 0){
                    queue.offer(v);
                }
            }
        }

        return numCourses == visited;
    }

//dfs法
    List<List<Integer>> edges;  
    int[] visited; 
    boolean valid = true; 
    public boolean canFinish(int numCourses, int[][] prerequisites) {
            edges = new ArrayList<>();
            visited = new int[numCourses];
            for (int i = 0; i < numCourses; i++) {
                edges.add(new ArrayList<Integer>());
            }
            for (int[] prerequisite : prerequisites) {
                edges.get(prerequisite[1]).add(prerequisite[0]);
            }
            for (int i = 0; i < numCourses && valid; i++) {
                if (visited[i] == 0) {
                    dfs(i);
                }
            }
            return valid;
    
        }
        public void dfs(int u) {
            visited[u] = 1;
            for (int v : edges.get(u)) {
                if (visited[v] == 0) {
                    dfs(v);
                    if (!valid) {
                        return;
                    }
                } else if (visited[v] == 1) {
                    valid = false;
                    return;
                }
            }
            visited[u] = 2;
        }

4.

//该题与第三题本质一样，只需要在第三题的基础上把寻找环的每步记录下来即可
public int[] findOrder(int numCourses, int[][] prerequisites) {
        edges = new ArrayList<>();
        inCount = new int[numCourses];
        for (int i = 0; i < numCourses; i++) {
            edges.add(new ArrayList<Integer>());
        }
        for (int[] prerequisite : prerequisites) {
            edges.get(prerequisite[1]).add(prerequisite[0]);
            inCount[prerequisite[0]]++;
        }

        Queue<Integer> queue = new LinkedList<>();
        for (int i = 0; i < numCourses; i++) {
            if (inCount[i] == 0){
                queue.offer(i);
            }
        }

        int visited = 0;
        int[] order = new int[numCourses];
        while (!queue.isEmpty()){
            int u = queue.poll();
            order[visited] = u;
            visited++;
            for (int v : edges.get(u)) {
                inCount[v] -= 1;
                if (inCount[v] == 0){
                    queue.offer(v);
                }
            }
        }
        if (numCourses == visited){
            return order;
        }else {
            return new int[0];
        }
    }