【算法总结】graph 图的问题

1. 描述及例题：
   在一个点线组成的矩阵关系上即为一个图的问题。图的问题主要分为三种类型：
   
   • Deep copy: 在图上建立一个新的图，把原图的关系都copy到新图上。
     • Clone Graph
       
     • Copy List with Random Pointer
   • Union find: 在图上找到有几个union块。
     • Surrounded Regions
       
     • Number of Islands
       
     • Number of Islands II 
   • Topological sort: 根据pair的关系，或者点线的关系，构建出一个图，找出从start到end的path。
     • Alien Dictionary 
       
     • Course Schedule
       
     • Course Schedule II
       
     • Word Ladder
     • Topological sort
2. 解决思路及时间复杂度：
   图的问题基本都采用 DFS或者BFS的思路进行解决。
   • Deep copy:
     • 先遍历一遍原图，一边遍历一边建立新的图的点。用hashmap记录原node和新node之间的关系。
     • 再复制边的关系。把原图的边的关系，在新的node之间边的关系同样复制
       
   • 以Clone Graph为例，代码如下：
     

     public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {        if(node == null){            return null;        }        // write your code here        ArrayList<UndirectedGraphNode> list = new ArrayList<UndirectedGraphNode>();        HashMap<UndirectedGraphNode, UndirectedGraphNode> map = new HashMap<UndirectedGraphNode, UndirectedGraphNode>();        int size = 0;        list.add(node);        UndirectedGraphNode newHead = new UndirectedGraphNode(node.label);        map.put(node, newHead);        while(size<list.size()){            for(UndirectedGraphNode n : list.get(size).neighbors){                if(!map.containsKey(n)){                    UndirectedGraphNode newNode = new UndirectedGraphNode(n.label);                    map.put(n, newNode);                    list.add(n);                }            }           size++;         }        //copy edge        for(int i=0; i<list.size(); i++){             UndirectedGraphNode newN = map.get(list.get(i));             ArrayList<UndirectedGraphNode> newNeighbor = new ArrayList<UndirectedGraphNode>();            for(UndirectedGraphNode neiNode : list.get(i).neighbors){               newNeighbor.add(map.get(neiNode));            }            newN.neighbors = newNeighbor;        }        return newHead;            }

     
     
     
   • Union find:
     • 遍历整个图，一但找到符合条件的点进行dfs，把整个union进行标记，并记录union个数。
   • 以Number of Islands为例：
     

     public class Solution {    public int numIslands(boolean[][] grid) {        if(grid == null || grid.length == 0 || grid[0].length == 0){            return 0;        }        int res = 0;        boolean[][] visited = new boolean[grid.length][grid[0].length];        for(int i=0; i<grid.length; i++){            for(int j=0; j<grid[0].length; j++){                if(grid[i][j] && !visited[i][j]){                    dfs(i, j, grid, visited);                    res++;                }            }        }        return res;    }    private void dfs(int i, int j, boolean[][] grid, boolean[][] visited){        //end condition        if(i>=grid.length || i<0 || j>=grid[0].length || j<0 || visited[i][j] || !grid[i][j]){            return;        }        visited[i][j] = true;        dfs(i+1, j, grid, visited);        dfs(i-1, j, grid, visited);        dfs(i, j+1, grid, visited);        dfs(i, j-1, grid, visited);    }}

     
     
     
   • Topological sort:
     • 先用hashMap记录到所有Node的入度,选择入度为0的点为起点。
     • 从起点开始进行bfs，每遍历一个点就入度减一，直到入度为0时，把这个点加入结果顺序中。
     • 注意点：环的问题，如果图是有环的，则计数器会产生断层，即某个节点的计数器永远无法清零（有环意味着有的节点被多加了1，然而遍历的时候一次只减一个1，所以导致无法归零），这样该节点也无法加入到结果中。所以我们只要判断这个结果的节点数和实际图中节点数相等，就代表无环，不相等，则代表有环。
   • 以Topological sort代码示例：
     

     public class Solution {    public ArrayList<DirectedGraphNode> topSort(ArrayList<DirectedGraphNode> graph) {        ArrayList<DirectedGraphNode> res = new ArrayList<DirectedGraphNode>();        if(graph==null || graph.size()==0){            return res;        }        //record indegree        HashMap<DirectedGraphNode, Integer> map = new HashMap<DirectedGraphNode, Integer>();         for(int i=0; i<graph.size(); i++){            DirectedGraphNode node = graph.get(i);            for(DirectedGraphNode n : node.neighbors){                if(map.containsKey(n)){                    map.put(n, map.get(n)+1);                }else{                    map.put(n, 1);                }            }        }        //find start point        LinkedList<DirectedGraphNode> queue = new LinkedList<DirectedGraphNode>();        for(int i=0; i<graph.size(); i++){            if(!map.containsKey(graph.get(i))){                res.add(graph.get(i));                queue.offer(graph.get(i));            }        }        //travelsal        while(!queue.isEmpty()){            DirectedGraphNode node = queue.poll();            for(DirectedGraphNode n : node.neighbors){                if(map.containsKey(n)){                    map.put(n, map.get(n)-1);                    if(map.get(n)==0){                        res.add(n);                        queue.offer(n);                    }                }            }        }        return res;    }}

     
     
     
3. 代码模板示例：
   主要是用dfs或bfs去解决。所以模板以dfs和bfs的递归和迭代两种实现方式为主。
   • DFS递归：见island那题。注意visited维护。
   • DFS迭代：用stack实现。
   • BFS递归：一般不用递归实现。
   • BFS迭代：用queue实现。