图与搜索

主要知识点：

克隆图

拓扑排序

DFS BFS

BFS两个使用场景：图的遍历 简单图求最短路径

BFS in Graph 和BFS in Tree的主要区别就是有无环

遇到让找所有方案的题，一定是DFS，90%的DFS要么是排列，要么是组合。

Clone Graph --not bug free

方法一：递归

public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
        // write your code here
        if (node == null) {
            return node;
        }
        HashMap<UndirectedGraphNode, UndirectedGraphNode> hashMap = new HashMap<>();
        return help(node, hashMap);
    }
    
    public UndirectedGraphNode help(UndirectedGraphNode node, HashMap<UndirectedGraphNode, UndirectedGraphNode> hashMap) {
        UndirectedGraphNode root = new UndirectedGraphNode(node.label);
        hashMap.put(node, root);
        for (UndirectedGraphNode neighbor : node.neighbors) {
            if (hashMap.containsKey(neighbor)) {
                root.neighbors.add(hashMap.get(neighbor));
            } else {
                root.neighbors.add(help(neighbor, hashMap));
            }
        }
        return root;
    }

方法二：非递归，分两步：找节点和mapping  neighbors

public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
        // write your code here
        if (node == null) {
            return node;
        }
        //getNodeAndMapping
        List<UndirectedGraphNode> nodes = new ArrayList<UndirectedGraphNode>();
        HashMap<UndirectedGraphNode, UndirectedGraphNode> mapping = new HashMap<>();
        Queue<UndirectedGraphNode> queue = new LinkedList<UndirectedGraphNode>();
        queue.offer(node);
        nodes.add(node);
        mapping.put(node, new UndirectedGraphNode(node.label));
        while (!queue.isEmpty()) {
            UndirectedGraphNode cur = queue.poll();
            for (UndirectedGraphNode neighbor : cur.neighbors) {
                if (mapping.containsKey(neighbor)) {
                    continue;
                }
                nodes.add(neighbor);
                mapping.put(neighbor, new UndirectedGraphNode(neighbor.label));
                queue.offer(neighbor);
            }
        }
        
        //clone neighbor
        for (UndirectedGraphNode old : nodes) {
            UndirectedGraphNode newNode = mapping.get(old);
            for (UndirectedGraphNode neighbor : old.neighbors) {
                newNode.neighbors.add(mapping.get(neighbor));
            }
        }
        return mapping.get(node);
    }

Topological Sorting

public ArrayList<DirectedGraphNode> topSort(ArrayList<DirectedGraphNode> graph) {
        // write your code here
        Map<DirectedGraphNode, Integer> indegreeMap = new HashMap<DirectedGraphNode, Integer>();
        getInDegree(graph, indegreeMap);
        Queue<DirectedGraphNode> queue = new LinkedList<DirectedGraphNode>();
        for (DirectedGraphNode node : graph) {
            if (!indegreeMap.containsKey(node)) {
                queue.offer(node);
            }
        }
        ArrayList<DirectedGraphNode> result = new ArrayList<>();
        while (!queue.isEmpty()) {
            DirectedGraphNode cur = queue.poll();
            result.add(cur);
            for (DirectedGraphNode neighbor : cur.neighbors) {
                int indegree = indegreeMap.get(neighbor);
                indegreeMap.put(neighbor, indegree - 1);
                if (indegree == 1) {
                    queue.offer(neighbor);
                }
            }
        }
        return result;
    }
    
    public void getInDegree(ArrayList<DirectedGraphNode> graph,  
        Map<DirectedGraphNode, Integer> indegreeMap) {
            for (DirectedGraphNode node : graph) {
                for (DirectedGraphNode neighbor : node.neighbors) {
                    if (!indegreeMap.containsKey(neighbor)) {
                        indegreeMap.put(neighbor, 1);
                    } else {
                        indegreeMap.put(neighbor, indegreeMap.get(neighbor) + 1);
                    }
                }
            }   
    }

Permutations

Given a list of numbers, return all possible permutations.You can assume that there is no duplicate numbers in the list.

public List<List<Integer>> permute(int[] nums) {
        // write your code here
        List<List<Integer>> results = new ArrayList<>();
        if (nums == null || nums.length == 0) {
            results.add(new ArrayList<Integer>());
            return results;
        }
        boolean[] used = new boolean[nums.length];
        DFS(nums, results, new ArrayList<Integer>(), used);
        return results;
    }
    
    public void DFS(int[] nums, List<List<Integer>> results, List<Integer> cur, boolean[] used) {
        if (cur.size() == nums.length) {
            results.add(new ArrayList<>(cur));
            return ;
        }
        for (int i = 0; i < nums.length; i++) {
            if (used[i]) {
                continue;
            }
            used[i] = true;
            cur.add(nums[i]);
            DFS(nums, results, cur, used);
            cur.remove(cur.size() - 1);
            used[i] = false;
        }
    }

Permutations II

注意不要忘了排序。

Given a list of numbers with duplicate number in it. Find all unique permutations.

public List<List<Integer>> permuteUnique(int[] nums) {
        // write your code here
        List<List<Integer>> results = new ArrayList<>();
        if (nums == null || nums.length == 0) {
            results.add(new ArrayList<Integer>());
            return results;
        }
        Arrays.sort(nums);
        boolean[] used = new boolean[nums.length];
        DFS(nums, results, new ArrayList<Integer>(), used);
        return results;
    }
    
    public void DFS(int[] nums, List<List<Integer>> results, List<Integer> cur, boolean[] used) {
        if (cur.size() == nums.length) {
            results.add(new ArrayList<>(cur));
            return ;
        }
        for (int i = 0; i < nums.length; i++) {
            if (used[i]) {
                continue;
            }
            if (i > 0 && !used[i - 1] && nums[i] == nums[i - 1]) {
                continue;
            }
            used[i] = true;
            cur.add(nums[i]);
            DFS(nums, results, cur, used);
            cur.remove(cur.size() - 1);
            used[i] = false;
        }
    }

String Permutation II

Given a list of numbers with duplicate number in it. Find all uniquepermutations.

public List<String> stringPermutation2(String str) {
        // Write your code here
        List<String> result = new ArrayList<String>();
        if (str == null || str.length() == 0) {
            result.add("");
            return result;
        }
        char[] chars = str.toCharArray();
        Arrays.sort(chars);
        boolean[] used = new boolean[chars.length];
        StringBuilder sb = new StringBuilder();
        DFS(chars, result, sb, used);
        return result;
    }
    
    private void DFS(char[] chars, List<String> result, StringBuilder sb, boolean[] used) {
        if (sb.length() == chars.length) {
            result.add(sb.toString());
        }
        for (int i = 0; i < chars.length; i++) {
            if (used[i]) {
                continue;
            }
            if (i != 0 && !used[i - 1] && chars[i] == chars[i - 1]) {
                continue;
            }
            used[i] = true;
            sb.append(chars[i]);
            DFS(chars, result, sb, used);
            used[i] = false;
            sb.deleteCharAt(sb.length() - 1);
        }
    }

Subsets

Given a set of distinct integers, return all possible subsets

public ArrayList<ArrayList<Integer>> subsets(int[] nums) {
        // write your code here
        ArrayList<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
        if (nums == null || nums.length == 0) {
            return results;
        }
        Arrays.sort(nums);
        DFS(nums, results, new ArrayList<Integer>(), 0);
        return results;
    }
    
    private void DFS(int[] nums, ArrayList<ArrayList<Integer>> results, ArrayList<Integer> cur, int start) {
        results.add(new ArrayList<Integer>(cur));
        for (int i = start; i < nums.length; i++) {
            cur.add(nums[i]);
            DFS(nums, results, cur, i + 1);
            cur.remove(cur.size() - 1);
        }
    }

Subsets II

Given a list of numbers that may has duplicate numbers, return all possible subsets

public ArrayList<ArrayList<Integer>> subsetsWithDup(int[] nums) {
        // write your code here
        ArrayList<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
        if (nums == null || nums.length == 0) {
            return results;
        }
        Arrays.sort(nums);
        DFS(nums, results, new ArrayList<Integer>(), 0);
        return results;
    }
    
    private void DFS(int[] nums, ArrayList<ArrayList<Integer>> results, ArrayList<Integer> cur, int start) {
        results.add(new ArrayList<Integer>(cur));
        for (int i = start; i < nums.length; i++) {
            if (i != start && nums[i] == nums[i - 1]) {
                continue;
            }
            cur.add(nums[i]);
            DFS(nums, results, cur, i + 1);
            cur.remove(cur.size() - 1);
        }
    }

k Sum II

Given n unique integers, number k (1<=k<=n) and target.

Find all possible k integers where their sum is target.

public ArrayList<ArrayList<Integer>> kSumII(int[] A, int k, int target) {
        // write your code here
        ArrayList<ArrayList<Integer>> results = new ArrayList<ArrayList<Integer>>();
        if (A == null || A.length == 0) {
            results.add(new ArrayList<Integer>());
            return results;
        }
        Arrays.sort(A);
        DFS(A, k, target, 0, results, new ArrayList<Integer>());
        return results;
    }
    
    private void DFS(int[] A, int k, int target, int start, 
        ArrayList<ArrayList<Integer>> results, ArrayList<Integer> cur) {
        if (cur.size() > k) {
            return ;
        }
        if (cur.size() == k && target == 0) {
            results.add(new ArrayList<Integer>(cur));
            return ;
        }
        for (int i = start; i < A.length; i++) {
            cur.add(A[i]);
            DFS(A, k, target - A[i], i + 1, results, cur);
            cur.remove(cur.size() - 1);
        }
    }

N-Queens --not bug free

ArrayList<ArrayList<String>> solveNQueens(int n) {
        // write your code here
        ArrayList<ArrayList<String>> results = new ArrayList<ArrayList<String>>();
        if (n <= 0) {
            results.add(new ArrayList<String>());
            return results;
        }
        char[] helpChar = new char[n];
        Arrays.fill(helpChar,'.');
        boolean[] col_used = new boolean[n];
        boolean[] diag_pos_used = new boolean[2 * n - 1];
        boolean[] diag_neg_used = new boolean[2 * n - 1];
        help(n, results, new ArrayList<String>(), helpChar,
            0, col_used, diag_pos_used, diag_neg_used);
        return results;
    }
    
    public void help(int n, ArrayList<ArrayList<String>> results, ArrayList<String> cur,
        char[] helpChar, int row_cur, boolean[] col_used, 
        boolean[] diag_pos_used, boolean[] diag_neg_used) {
        if (row_cur == n) {
            results.add(new ArrayList<String>(cur));
            return;
        }
        for (int j = 0; j < n; j++) {
            int d1 = row_cur + j;
            int d2 = j - row_cur + n - 1;
            if (col_used[j] || diag_pos_used[d2] || diag_neg_used[d1]) {
                    continue;
            } else {
                col_used[j] = true;
                diag_pos_used[d2] = true;
                diag_neg_used[d1] = true;
                helpChar[j] = 'Q';
                cur.add(new String(helpChar));
                helpChar[j] = '.';//Attention
                    
                help(n, results, cur, helpChar,
                    row_cur + 1, col_used, diag_pos_used, diag_neg_used);
                    
                col_used[j] = false;
                diag_pos_used[d2] = false;
                diag_neg_used[d1] = false;
                cur.remove(cur.size() - 1);
            }
        }
    }

N-Queens II

Follow up for N-Queens problem.

Now, instead outputting board configurations, return the total number of distinct solutions.

public static int sum;
    public int totalNQueens(int n) {
        //write your code here
        if (n <= 0) {
            return 0;
        }
        boolean[] col_used = new boolean[n];
        boolean[] diag_pos_used = new boolean[2 * n];
        boolean[] diag_neg_used = new boolean[2 * n];
        sum = 0;
        DFS(n, 0, col_used, diag_pos_used, diag_neg_used);
        return sum;
    }
    
    public void DFS(int n, int row, boolean[] col_used, boolean[] diag_pos_used, boolean[] diag_neg_used) {
        if (row == n) {
            sum++;
            return;
        }
        for (int j = 0; j < n; j++) {
            int d1 = j - row + n - 1;
            int d2 = j + row;
            if (col_used[j] || diag_pos_used[d1] || diag_neg_used[d2]) {
                continue;
            }
            col_used[j] = true;
            diag_pos_used[d1] = true;
            diag_neg_used[d2] = true;
            DFS(n, row + 1, col_used, diag_pos_used, diag_neg_used);
            col_used[j] = false;
            diag_pos_used[d1] = false;
            diag_neg_used[d2] = false;
        }
    }

Palindrome Partitioning

复杂度2^n，切或者不切。

Given a string s, partition s such that every substring of the partition is a palindrome.Return all possible palindrome partitioning of s.

List<List<String>> results = new ArrayList<List<String>>();
        if (s == null || s.length() == 0) {
            results.add(new ArrayList<String>());
            return results;
        }
        int n = s.length();
        char[] chars = s.toCharArray();
        boolean[][] isPalindrome = new boolean[n][n];
        for (int i = 0; i < n; i++) {
            isPalindrome[i][i] = true;
        }
        for (int k = 1; k < n; k++) {
            for (int i = 0; i < n - k; i++) {
                int j = i + k;
                if (chars[i] == chars[j] && (k == 1 || isPalindrome[i + 1][j - 1])) {
                    isPalindrome[i][j] = true;
                }
            }
        }
        dfs(s, results, new ArrayList<String>(), isPalindrome, 0);
        return results;
    }
    
    private void dfs(String s, List<List<String>> results, List<String> cur, boolean[][] isPalindrome, int start ) {
        if (start == s.length()) {
            results.add(new ArrayList<String>(cur));
            return;
        }
        for (int i = start; i < s.length(); i++) {
            if (isPalindrome[start][i]) {
                cur.add(s.substring(start, i + 1));
                dfs(s, results, cur, isPalindrome, i + 1);
                cur.remove(cur.size() - 1);
            }
        }
    }

 Combination Sum

Given a set of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

The same repeated number may be chosen from C unlimited number of times.

public List<List<Integer>> combinationSum(int[] candidates, int target) {
        // write your code here
        List<List<Integer>> results = new ArrayList<List<Integer>>();
        if (candidates == null || candidates.length == 0 || target <= 0) {
            return results;
        }
        Arrays.sort(candidates);
        dfs(candidates, target, results, new ArrayList<Integer>(), 0);
        return results;
    }
    
    private void dfs(int[] candidate, int target, List<List<Integer>> results, List<Integer> cur, int start) {
        if (target == 0) {
            results.add(new ArrayList<Integer>(cur));
            return;
        }
        for (int i = start; i < candidate.length; i++) {
            if (i != start && candidate[i] == candidate[i - 1]) {
                continue;
            }
            if (candidate[i] > target) {
                break;
            } else {
                cur.add(candidate[i]);
                dfs(candidate, target - candidate[i], results, cur, i);
                cur.remove(cur.size() - 1);
            }
        }
    }

Combination Sum II

Given a collection of candidate numbers (C) and a target number (T), find all unique combinations in C where the candidate numbers sums to T.

Each number in C may only be used once in the combination.

public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        // write your code here
        List<List<Integer>> results = new ArrayList<List<Integer>>();
        if (candidates == null || candidates.length == 0 || target <= 0) {
            return results;
        }
        Arrays.sort(candidates);
        dfs(candidates, target, results, new ArrayList<Integer>(), 0);
        return results;
    }
    
    private void dfs(int[] candidate, int target, List<List<Integer>> results, List<Integer> cur, int start) {
        if (target == 0) {
            results.add(new ArrayList<Integer>(cur));
            return;
        }
        for (int i = start; i < candidate.length; i++) {
            if (i != start && candidate[i] == candidate[i - 1]) {
                continue;
            }
            if (candidate[i] > target) {
                break;
            } else {
                cur.add(candidate[i]);
                dfs(candidate, target - candidate[i], results, cur, i + 1);
                cur.remove(cur.size() - 1);
            }
        }
    }

Word Ladder --not bug free

几点容易错的地方：

求adjMap的时候list list更新只要一个update即可

prevMap首先应该放入(start, null)

最后结果是有几个几点就返回几。

方法一：获得previousMap之后DFS

public int ladderLength(String start, String end, Set<String> dict) {
        // write your code here
        if (dict == null || dict.size() == 0 || start == null || end == null) {
            return 0;
        }
        dict.add(start);
        dict.add(end);
        Map<String, List<String>> adjMap = getAdjacentMap(dict, start.length());
        Map<String, String> previousMap = new HashMap<String, String>();
        // for (String str1 : adjMap.keySet()) {
        //     System.out.print(str1 + " ");
        //     System.out.println(adjMap.get(str1));
        // }
        previousMap.put(start, null);//Attention
        Queue<String> queue = new LinkedList<String>();
        queue.offer(start);
        
        while (!queue.isEmpty()) {
            String cur = queue.poll();
            List<String> adj = adjMap.get(cur);
            if (adj != null) {//Attention
                 for (String str : adj) {
                    if (!previousMap.containsKey(str)) {
                        previousMap.put(str, cur);
                        queue.offer(str);
                    }
                    if (str.equals(end)) {
                        return getNodeNum(previousMap, end);
                    }
                }
            }
        }
        return 0;
    }
    
    private int getNodeNum(Map<String, String> previousMap, String end) {
        int n = 0;
        while (end != null) {
            end = previousMap.get(end);
            n++;
        }
        return n;
    }

    private Map<String, List<String>> getAdjacentMap(Set<String> dict, int n) {
        Map<String, List<String>> adjMap = new HashMap<String, List<String>>();
        for (int i = 0; i < n; i++) {
            Map<String, List<String>> repToWord = new HashMap<String, List<String>>();
            for (String str : dict) {
                String rep = str.substring(0, i) + str.substring(i + 1, n);
                update(repToWord, rep, str);
            }
            
            for (List<String> list : repToWord.values()) {
                if (list.size() < 2) {
                    continue;
                }
                for (String str1 : list) {
                    for (String str2 : list) {
                        if (str1 != str2) {
                            update(adjMap, str1, str2);
                        }
                    }
                }
            }
        }
        return adjMap;
    }
    
    private void update(Map<String, List<String>> map, String key, String value) {
        if (!map.containsKey(key)) {
            map.put(key, new ArrayList<String>());
        }
        map.get(key).add(value);
    }

 方法二：获得previousMap之后BFS

 public int ladderLength(String start, String end, Set<String> dict) {
        // write your code here
        if (dict == null || dict.size() == 0 || start == null || end == null) {
            return 0;
        }
        if (start.equals(end)) {
            return 1;
        }
        dict.add(start);
        dict.add(end);
        Map<String, List<String>> adjMap = getAdjacentMap(dict, start.length());
        HashSet<String> hashSet = new HashSet<String>();
        hashSet.add(start);
        Queue<String> queue = new LinkedList<String>();
        queue.offer(start);
        int length = 0;
        while (!queue.isEmpty()) {
            length++;
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                String cur = queue.poll();
                List<String> adj = adjMap.get(cur);
                if (adj != null) {
                    for (String str : adj) {
                        if (!hashSet.contains(str)) {
                            hashSet.add(str);
                            queue.offer(str);
                        }
                        if (str.equals(end)) {
                            return length + 1;
                        }
                    }
                }   
            }
        }
        return 0;
    }
    

    //"hit", "cog", ["hot","dot","dog","lot","log"]
    private Map<String, List<String>> getAdjacentMap(Set<String> dict, int n) {
        Map<String, List<String>> adjMap = new HashMap<String, List<String>>();
        for (int i = 0; i < n; i++) {
            Map<String, List<String>> repToWord = new HashMap<String, List<String>>();
            for (String str : dict) {
                String rep = str.substring(0, i) + str.substring(i + 1, n);
                update(repToWord, rep, str);
            }
            
            for (List<String> list : repToWord.values()) {
                if (list.size() < 2) {
                    continue;
                }
                for (String str1 : list) {
                    for (String str2 : list) {
                        if (str1 != str2) {
                            update(adjMap, str1, str2);
                        }
                    }
                }
            }
        }
        return adjMap;
    }
    
    private void update(Map<String, List<String>> map, String key, String value) {
        if (!map.containsKey(key)) {
            map.put(key, new ArrayList<String>());
        }
        map.get(key).add(value);
    }

Word Ladder II--not bug free

 public List<List<String>> findLadders(String start, String end, Set<String> dict) {
        // write your code here  
        List<List<String>> results = new ArrayList<List<String>>();
        if (dict == null) {
            results.add(new ArrayList<String>());
            return results;
        }
        dict.add(start);
        dict.add(end);
        Map<String, List<String>> adjMap = getAdjacentMap(dict, start.length());
        Map<String, List<String>> previousMap = getLatestPreviousMap(start, end, adjMap);
        LinkedList<String> cur = new LinkedList<String>();
        cur.add(end);
        DFS(start, previousMap, results, cur, end);
        return results;
    }
    
    private void DFS(String start, Map<String, List<String>> previousMap, List<List<String>> results,
        LinkedList<String> cur, String tail) {
            if (tail.equals(start)) {
                results.add(new LinkedList<String>(cur));
                return ;
            }
            if (previousMap.get(tail) != null) {//Attention
                for (String str : previousMap.get(tail)) {
                    cur.addFirst(str);
                    DFS(start, previousMap, results, cur, str);
                    cur.removeFirst();
                } 
            }
        }
    
    
    private Map<String, List<String>> getLatestPreviousMap(String start, String end, 
        Map<String, List<String>> adjMap) {
        Map<String, List<String>> previousMap = new HashMap<String, List<String>>();
        Map<String, Integer> distMap = new HashMap<String, Integer>();
        Queue<String> queue = new LinkedList<String>();
        
        previousMap.put(start, null);
        distMap.put(start, 0);
        queue.offer(start);
        
        while (!queue.isEmpty()) {
            String cur = queue.poll();
            List<String> adj = adjMap.get(cur);
            if (adj != null) {
                for (String str : adj) {
                    if (!previousMap.containsKey(str)) {
                        List<String> previousList = new ArrayList<String>();
                        previousList.add(cur);
                        previousMap.put(str, previousList);
                        distMap.put(str, distMap.get(cur) + 1);
                        queue.offer(str);//Attention
                    } else if (distMap.get(cur) < distMap.get(str)) {
                        previousMap.get(str).add(cur);
                    }
                }
            }
        }
        return previousMap;
    }
    
     private Map<String, List<String>> getAdjacentMap(Set<String> dict, int n) {
        Map<String, List<String>> adjMap = new HashMap<String, List<String>>();
        for (int i = 0; i < n; i++) {
            Map<String, List<String>> repToWord = new HashMap<String, List<String>>();
            for (String str : dict) {
                String rep = str.substring(0, i) + str.substring(i + 1, n);
                update(repToWord, rep, str);
            }
            
            for (List<String> list : repToWord.values()) {
                if (list.size() < 2) {
                    continue;
                }
                for (String str1 : list) {
                    for (String str2 : list) {
                        if (str1 != str2) {
                            update(adjMap, str1, str2);
                        }
                    }
                }
            }
        }
        return adjMap;
    }
    
    private void update(Map<String, List<String>> map, String key, String value) {
        if (!map.containsKey(key)) {
            map.put(key, new ArrayList<String>());
        }
        map.get(key).add(value);
    }

Six Degrees

Six degrees of separation is the theory that everyone and everything is six or fewer steps away, by way of introduction, from any other person in the world, so that a chain of "a friend of a friend" statements can be made to connect any two people in a maximum of six steps.

Given a friendship relations, find the degrees of two people, return -1 if they can not been connected by friends of friends.

public int sixDegrees(List<UndirectedGraphNode> graph,
                          UndirectedGraphNode s,
                          UndirectedGraphNode t) {
        // Write your code here
        Queue<UndirectedGraphNode> queue = new LinkedList<UndirectedGraphNode>();
        HashMap<UndirectedGraphNode, UndirectedGraphNode> preMap 
            = new HashMap<UndirectedGraphNode, UndirectedGraphNode>();
        queue.offer(s);
        preMap.put(s, null);
        while (!queue.isEmpty()) {
            UndirectedGraphNode cur = queue.poll();
            for (UndirectedGraphNode node : cur.neighbors) {
                if (!preMap.containsKey(node)) {
                    queue.offer(node);
                    preMap.put(node, cur);
                }
                if (node == t) {
                    break;
                }
            }
        }
        int dist = 0;
        UndirectedGraphNode tail = t;
        while (tail != s) {
            dist++;
            tail = preMap.get(tail);
            if (tail == null) {
                return -1;
            }
        }
        return dist;
    }

 Find the Connected Component in the Undirected Graph

Find the number connected component in the undirected graph. Each node in the graph contains a label and a list of its neighbors. (a connected component (or just component) of an undirected graph is a subgraph in which any two vertices are connected to each other by paths, and which is connected to no additional vertices in the supergraph.)

Each connected component should sort by label.

public List<List<Integer>> connectedSet(ArrayList<UndirectedGraphNode> nodes) {
        // Write your code here
        HashSet<UndirectedGraphNode> hashSet = new HashSet<UndirectedGraphNode>();
        List<List<Integer>> results = new ArrayList<List<Integer>>();
        for (UndirectedGraphNode node : nodes) {
            if (!hashSet.contains(node)) {
                hashSet.add(node);
                List<Integer> tempList = new ArrayList<Integer>();
                Queue<UndirectedGraphNode> queue = new LinkedList<UndirectedGraphNode>();
                tempList.add(node.label);
                queue.offer(node);
                while (!queue.isEmpty()) {
                    UndirectedGraphNode cur = queue.poll();
                    for (UndirectedGraphNode tempNode : cur.neighbors){
                         if (!hashSet.contains(tempNode)) {
                             hashSet.add(tempNode);
                             queue.offer(tempNode);
                             tempList.add(tempNode.label);
                         }
                    }
                }
                Collections.sort(tempList);
                results.add(tempList);
            }
        }
        return results;
    }

Find the Missing Number II --not bug free

Giving a string with number from 1-n in random order, but miss 1 number.Find that number.

 Notice

n <= 30

public int findMissing2(int n, String str) {
        // Write your code here
        if (n <= 0 || str == null) {
            return 0;
        }
        char[] chars = str.toCharArray();
        boolean[] appeared = new boolean[n + 1];
        int[] curIndex = {0};
        help(n, chars, appeared, curIndex);
        for (int i = 1; i <= n; i++) {
            if (!appeared[i]) {
                return i;
            }
        }
        return 0;
    }
    
    public void help(int n, char[] chars, boolean[] appeared, int[] curIndex) {
        if (curIndex[0] >= chars.length) {
            return ;
        }
        if (chars[curIndex[0]] == '0') {
            return ;
        }
        if (!appeared[chars[curIndex[0]] - '0']) {
            appeared[chars[curIndex[0]] - '0'] = true;
            curIndex[0]++;
            help(n, chars, appeared, curIndex);
            if (curIndex[0] >= chars.length) {
                return ;
            }
            curIndex[0]--;
            appeared[chars[curIndex[0]] - '0'] = false;
        }
        if (curIndex[0] < chars.length - 1) {
            int a1 = chars[curIndex[0]] - '0';
            int a2 = chars[curIndex[0] + 1] - '0';
            int num = a1 * 10 + a2;
            if (num > n || appeared[num]) {
                return ;
            }
            appeared[num] = true;
            curIndex[0] += 2;
            help(n, chars, appeared, curIndex);
            if (curIndex[0] >= chars.length) {
                return ;
            }
            curIndex[0] -= 2;
            appeared[num] = false;
        }
    }