本文我们就Leetcode中的一个类型的题目backtracking进行一系列的总结和归纳。
backtracking这个方法本质是建立在递归的基础上，不断尝试新的路径，这里关键是每次尝试完以后需要退回来也就是回溯。
backtracking这个方法本质是建立在递归的基础上，不断尝试新的路径，这里关键是每次尝试完以后需要退回来也就是回溯。
如果你已经找到了解决方案，那么返回成功
for(现在位置可以的所有可能选择）｛
选择其中一个方案然后沿着路径前进一步
使用递归的方法从新的位置解决问题
如果新的位置可以成功解决，向上一级返回成功
从现在位置恢复到循环之前的位置 ｝
如果到这里表示仍然没有成功，返回失败
下面我们来看一下的例题：
package DFS; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.LinkedList; import java.util.List; import java.util.Set; import java.util.Stack; public class DFSProblem { public static void main(String[] args) { List<List<Integer>> res=new ArrayList<List<Integer>>(); res=getFactors(12); System.out.println(res.size()); } /* * 113. Path Sum II * 11.18 By Mingyang * 典型的backtracking，不过注意，这里的值可能是负数，所以不能用sum小于0来做任何判断 * 1.长度标准：无 * 2.可选的范围：每一个node的左边和右边子节点（不为空的情况）。 * 3.往前走一步：temp加一个，sum减一个 * 4.后退一步：把temp remove掉 * 5.特殊的case：root==null也就是走到了根节点的下一个空了 */ public List<List<Integer>> pathSum(TreeNode root, int sum) { List<List<Integer>> res = new ArrayList<List<Integer>>(); List<Integer> temp = new ArrayList<Integer>(); dfs(root, sum, res, temp); return res; } public void dfs(TreeNode root, int sum, List<List<Integer>> res, List<Integer> temp){ if(root==null) return; temp.add(root.val); if(root.left==null && root.right==null ){ if(root.val==sum) res.add(new ArrayList<Integer>(temp)); return; } if(root.left!=null) { dfs(root.left,sum-root.val,res,temp); temp.remove(temp.size()-1); } if(root.right!=null) { dfs(root.right,sum-root.val,res,temp); temp.remove(temp.size()-1); } } /* * 320 Generalized Abbreviation * 2016-3-14 by Mingyang * Given "word" Return the following list (order does not matter): * ["word", "1ord", "w1rd", "wo1d", "wor1", "2rd", "w2d", "wo2", "1o1d", "1or1", "w1r1", "1o2", "2r1", "3d", "w3", "4"] * 这道题目的题意是比较难懂的，网上找了很多，都是copy过来copy过去的，都是一个答案，所以后面自己想出来了一个最好的题意的解释。就是把四个数xxxx，用分别用一个1，两个1，三个1来代替其中的字母 * 如果出现111x就自动转化为3x，所以我的思路就是先找出所有包含1的排列组合，然后转换为标准格式。典型的backtracking。 * 1.长度标准：有1，2，3（0和4）单独来看的 * 2.可选的范围：从start开始的每一个字符（有一定的顺序，所以用start） * 3.往前走一步：count-1，start+1，改变string * 4.后退一步：把string改回来 * 5.特殊的case：count等于0，也就是输入了相应的个数的1 */ public static List<String> generateAbbreviations(String word) { List<String> res = new ArrayList<String>(); for(int i=1;i<word.length();i++){ dfs(word,res,i,0,""); } res.add(word); res.add(Integer.toString(word.length())); return res; } public static void dfs(String word,List<String> res,int count,int start,String copy){ if(count==0){ copy=format(copy); res.add(copy); return; } StringBuffer sb=new StringBuffer(); if(copy.length()==0){ sb.append(word); }else{ sb.append(copy); } for(int i=start;i<word.length();i++){ sb.setCharAt(i,'1');//学习一下stringbuffer的技巧 dfs(word,res,count-1,i+1,sb.toString()); sb.setCharAt(i, word.charAt(i)); } } public static String format(String s){ StringBuffer sb=new StringBuffer(); int num=0; for(int i=0;i<s.length()-1;i++){ if(Character.isDigit(s.charAt(i))&&Character.isDigit(s.charAt(i+1))){ if(num!=0) num=num+s.charAt(i+1)-'0'; else num=s.charAt(i)-'0'+s.charAt(i+1)-'0'; }else{ if(Character.isDigit(s.charAt(i))&&num!=0){ sb.append(num); num=0; }else{ sb.append(s.charAt(i)); } } } if(num!=0){ sb.append(num); }else{ sb.append(s.charAt(s.length()-1));} return sb.toString(); } /* * 294 Flip Game II * 2016-3-13 by Buttercola * You and your friend take turns to flip twoconsecutive "++" into "--". * The game ends when a person can no longer make a move and therefore the other person will be the winner. * 总而言之就是一句话，我走了一步以后，你就没法走了。这道题目也算backtracking，不过跟典型的不一样，只用return boolean，并且传参只有数组（不用string，是因为string改参数比较麻烦，也是一种技巧） * 1.长度标准：无 * 2.可选的范围：从0开始的每一个字符 * 3.往前走一步：改变整个char array * 4.后退一步：把char array改回来 */ public boolean canWin(String s) { if (s == null || s.length() == 0) { return false; } char[] arr = s.toCharArray(); return canWinHelper(arr); } private boolean canWinHelper(char[] arr) { int i = 0; for (i = 0; i < arr.length - 1; i++) { if (arr[i] == '+' && arr[i + 1] == '+') { arr[i] = '-'; arr[i + 1] = '-'; boolean win = !canWinHelper(arr); arr[i] = '+'; arr[i + 1] = '+'; if (win) { return true; } } } return false; } /* * 291 Word Pattern II * 2016-3-13 by Mingyang * Given a pattern and a string str, find if str follows the same pattern. * pattern = "abab", str = "redblueredblue" should return true. * pattern = "aaaa", str = "asdasdasdasd" should return true. * pattern = "aabb", str = "xyzabcxzyabc" should return false. * 这道题目有一定的难度，又是一个backtracking boolean的题目，不过这里多了一个参数Hashmap * 1.长度标准：无 * 2.可选的范围：从j开始，也就是从str未match的第一个字符开始的一系列的substring * 3.往前走一步：改变map，将两个对应的东西分别放入map * 4.后退一步：把map刚刚加入的值去掉 * 5.特别的case：刚好搜完和一个搜完了另一个没搜完，一个return true。另一个return false * 我们要backtracking所有的可能的string的组合, 对于每个组合, 我们都需要添加到hashmap中, * 这里, 我们在遍历pattern和string时, 要同时记录pattern中每个char对应在pattern的位置和当前string中substring对应的pattern的位置. * 通过string和pattern在pattern中的位置i来判断是否相同. 为了区分pattern和string, 我们可以同两个hashmap。 */ public boolean wordPatternMatch(String pattern, String str) { HashMap map = new HashMap(); return dfs(pattern, 0, str, 0, map); } private boolean dfs(String pattern, int i, String str, int j, HashMap map){ if(i == pattern.length() && j == str.length()){// 如果刚好搜完. 返回true return true; } if(i == pattern.length() || j == str.length()){// 如果一个完了, 另一个没完, 返回false return false; } char c = pattern.charAt(i); //initialize new value for(int k = j; k < str.length(); k++){ if(map.get(c) == map.get(str.substring(j, k+1))){//如果map中的i对应的值(可以是null) 和 sbustring对应的值相同(也可以是null) Integer val = (Integer)map.get(c); if(val == null){//如果是null map.put(pattern.charAt(i), i);//把pattern的<char,integer>放map中 map.put(str.substring(j, k+1), i);//把string的<string,integer>放map中 } if(dfs(pattern, i+1, str, k+1, map)){//dfs return true; } if(val == null){// backtracking map.remove(pattern.charAt(i)); map.remove(str.substring(j, k+1)); } } } return false;//注意不要忘了，不能继续走下去拿到合适的match一定要return false } /* * 267. Palindrome Permutation II * 2016-3-13 by Mingyang * Given a string s, return all the palindromic permutations (without duplicates) of it. Return an empty list if no palindromic permutation could be form. * Given s = "aabb", return ["abba", "baab"]. * Given s = "abc", return []. * 这道题目就相对来说简单多了，就跟permutation II类似，如果不写那个比较重要的判断句，那么久会出现很多的重复的。整题原理就是找到所有的组合可能性，再选择其中合适的 * 1.长度标准：无（固定） * 2.可选的范围：对于一个array的所有permutation，这个array有重复（所以多了一句判断句），而且前后可以颠倒（所以用visited）。具体参考permutation II * 3.往前走一步：sb加入这个数，visited改为true * 4.后退一步：sb减去，visited改为false * 5.特别的case：到了长度检查。 * 6.关于重复：因为可以有重复aabb可能会有abba和abba，第一个a在第一个，第二个a在第二个 */ public static List<String> generatePalindromes(String s) { List<String> res=new ArrayList<String>(); boolean[] visited=new boolean[s.length()]; char[] model=s.toCharArray(); StringBuffer sb=new StringBuffer(); dfs(res,model,visited,sb); return res; } public static void dfs(List<String> res,char[] model,boolean[] visited,StringBuffer sb){ if(sb.toString().length()==model.length){ if(isPalindrome(sb.toString())){ res.add(sb.toString()); } return; } for(int i=0;i<model.length;i++){ if (i > 0 && !visited[i - 1] && model[i] == model[i - 1]) // 这个非常的重要！！！！！！！！！！ continue; if(!visited[i]){ sb.append(model[i]); visited[i]=true; dfs(res,model,visited,sb); visited[i]=false; sb.deleteCharAt(sb.length()-1); } } } /* * 254 Factor Combinations * 2016-3-13 by Mingyang * Numbers can be regarded as product of its factors. For example, * 8 = 2 x 2 x 2; 8= 2 x 4. * Write a function that takes an integer n and return all possible combinations of its factors * 1.长度标准：无（固定） * 2.可选的范围：最开始是从2到n-1的所有整数，每一次递进以后。就是从上次取得那个数起到n-1的所有整数。 * 3.往前走一步：temp加入这个数，num乘以这个数--网上的版是这个数除以i。少了一个参数，一样的原理 * 4.后退一步：temp remove * 5.特别的case：到了长度检查。 */ public static List<List<Integer>> getFactors(int n) { List<List<Integer>> res=new ArrayList<List<Integer>>(); List<Integer> temp=new ArrayList<Integer>(); dfs1(res,temp,1,n,2); return res; } public static void dfs1(List<List<Integer>> res, List<Integer>temp, int num,int n,int start){ if(num==n){ res.add(new ArrayList<Integer>(temp)); return; } if(num>n) return; for(int i=start;i<n;i++){ if(n%(num*i)==0){//这里很巧妙地判断整除性，这样可以省去很多不必要的数 //num=num*i;原来这么分开写，但是这么分开写后面就要重新赋初值，把num改回去。所以直接在dfs1的参数里面乘 temp.add(i); dfs1(res,temp,num*i,n,i); temp.remove(temp.size()-1); //num=num/i; } } } /* * 39. Combination Sum * 2015-12-13 by Mingyang * The same repeated number may be chosen from C unlimited number of times. * 注意在实现中for循环中第一步有一个判断，那个是为了去除重复元素产生重复结果的影响 * 因为在这里每个数可以重复使用，所以重复的元素也就没有作用了，所以应该跳过那层递归。 * 1.长度标准：无（固定） * 2.可选的范围：从start开始到最后一个数 * 3.往前走一步：temp加入这个数，remain再减去 * 4.后退一步：temp减去这个数 * 5.特别的case：剩下的小于0直接return * 6.关于重复：因为每个数可以用很多次。所以223时会出现重复，所以可以跳过第二个2. */ public List<List<Integer>> combinationSum(int[] candidates, int target) { List<List<Integer>> res = new ArrayList<List<Integer>>(); List<Integer> temp = new ArrayList<Integer>(); if (candidates == null || candidates.length == 0) return res; Arrays.sort(candidates); dfs(candidates, target, 0, temp, res); return res; } public void dfs(int[] candidates, int remain, int start,List<Integer> temp, List<List<Integer>> res) { if (remain == 0) { res.add(new ArrayList<Integer>(temp)); return; } if (remain < 0) return; for (int i = start; i < candidates.length; i++) { if (i > 0 && candidates[i] == candidates[i - 1]) // 这里就是跳过那个重复的元素，因为每次已经可以重复使用自己了，这一步很重要！！ continue; temp.add(candidates[i]); dfs(candidates, remain - candidates[i], i, temp, res); temp.remove(temp.size() - 1); } } /* * 40. Combination Sum II * 2015-12-13 by Mingyang * Each number in C may only be used * once in the combination. * 在这里我们还是需要在每一次for循环前做一次判断，因为虽然一个元素不可以重复使用，但是如果这个元素重复出现是允许的， * 但是为了避免出现重复的结果集，我们只对于第一次得到这个数进行递归，接下来就跳过这个元素了， * 因为接下来的情况会在上一层的递归函数被考虑到，这样就可以避免重复元素的出现。 Each number in C may only be used * once in the combination. I 是The same repeated number may be chosen from C unlimited number of times. * 1.长度标准：无（固定） * 2.可选的范围：从start开始到最后一个数 * 3.往前走一步：temp加入这个数，remain再减去 * 4.后退一步：temp减去这个数 * 5.特别的case：剩下的小于0直接return * 6.关于重复：11 和1 在第一个1用了以后，第二个1就不用了 */ public List<List<Integer>> combinationSum2(int[] candidates, int target) { List<List<Integer>> res = new ArrayList<List<Integer>>(); List<Integer> temp = new ArrayList<Integer>(); if (candidates == null || candidates.length == 0) return res; Arrays.sort(candidates); dfs2(candidates, target, 0, temp, res); return res; } public void dfs2(int[] candidates, int remain, int begin,List<Integer> temp, List<List<Integer>> res) { if (remain == 0) { res.add(new ArrayList<Integer>(temp)); return; } if (remain < 0) return; for (int i = begin; i < candidates.length; i++) { if (i > begin && candidates[i] == candidates[i - 1])//去重复 continue; temp.add(candidates[i]); dfs2(candidates, remain - candidates[i], i + 1, temp, res);//所以在1中，这里的下一个还是i temp.remove(temp.size() - 1); } } /* * 216. Combination Sum III * 2015-12-18 by Mingyang * i一定要取到9，虽然大小聪明，想只取到7，但是后面的遍历可能也会遍历到9啊。 * 1.长度标准：无（固定等于k） * 2.可选的范围：从start开始到9 * 3.往前走一步：temp加入这个数，k-1表示又来了一位，n-i，然后start加1表示从下一位加起 * 4.后退一步：temp减去这个数 * 5.特别的case：剩下的小于0直接return * 6.关于重复：11 和1 在第一个1用了以后，第二个1就不用了 */ public List<List<Integer>> combinationSum3(int k, int n) { List<List<Integer>> res = new ArrayList<List<Integer>>(); List<Integer> temp = new ArrayList<Integer>(); dfs(res, temp, k, n, 1); return res; } public void dfs(List<List<Integer>> res, List<Integer> temp, int k, int n,int start) { if (k == 0) { if (n == 0) { res.add(new ArrayList<Integer>(temp)); } return; } for (int i = start; i <= 9; i++) { temp.add(i); dfs(res, temp, k - 1, n - i, start+1); temp.remove(temp.size() - 1); } } /* * 131. Palindrome Partitioning * 2015-12-17 by Mingyang * Return all possible palindrome partitioning of s. * 1.长度标准：无（固定） * 2.可选的范围：从start开始到最后一个 * 3.往前走一步：temp加入这个数，然后start加1表示从下一位加起 * 4.后退一步：temp减去这个数 * 5.特别的case：start到最后一位 * 6.关于重复：无 */ public List<List<String>> partition(String s) { List<String> item = new ArrayList<String>(); List<List<String>> res = new ArrayList<List<String>>(); if (s == null || s.length() == 0) return res; dfs(s, 0, item, res); return res; } public void dfs(String s, int start, List<String> item,List<List<String>> res) { if (start == s.length()) { res.add(new ArrayList<String>(item)); return; } for (int i = start; i < s.length(); i++) { String str = s.substring(start, i + 1);// 每一轮dfs进来都是先取第一个数，start index，可以不用stringbuffer来存 if (isPalindrome(str)) { item.add(str); dfs(s, i + 1, item, res);// 上面取到i，所以下一个start index就是i+1 item.remove(item.size() - 1); } } } public static boolean isPalindrome(String s) { int low = 0; int high = s.length() - 1; while (low < high) { if (s.charAt(low) != s.charAt(high)) return false; low++; high--; } return true; } /* * 93. Restore IP Addresses * 2015.12.16 by Mingyang * 这里不用StringBuffer因为我们最后要检查每一小块string到底是否符合要求 * 1.长度标准：无（固定） * 2.可选的范围：从start开始到最后一个 * 3.往前走一步：stringbuffer 变成string跟前面的相加成为一个新的string，然后start加1表示从下一位加起，然后count也减一个 * 4.后退一步：不用，因为传进去是string，不会对当前状态进行影响 * 5.特别的case：count小于等于0 * 6.关于重复：无 */ public static List<String> restoreIpAddresses1(String s) { List<String> res = new ArrayList<String>(); dfs(res, s, 0, "", 4); return res; } public static void dfs(List<String> res, String s, int start, String item,int count) { if (start == s.length() && count == 0) { res.add(item); return; } if (count <= 0) { return; } StringBuffer sb = new StringBuffer(); for (int i = start; i < s.length(); i++) { sb.append(s.charAt(i)); if (isValid(sb.toString())) { dfs(res, s, i + 1, item.isEmpty() ? (sb.toString()): (item + '.' + sb.toString()), count-1); } else { return;// 为什么需要写这个呢，因为这个可以防止多余的计算，比如数字太大2552551113，会让下面的isValid失效，就是省去多余的 } } } public static boolean isValid(String s) { if (s.charAt(0) == '0') return s.equals("0"); // 如果以0开头的，必须要检查是否等于001，011等不合格的，若开头为0，整个数必须为0 System.out.println(s); int num = Integer.parseInt(s); if (num <= 255 && num > 0) return true; else return false; } /* * 78. Subsets * 2015.12.16 by Mingyang * 注意这里虽然感觉很像combine，但是这个array可以随意的，可以为任意数的array，所以还是得用array来 * 并且那个array要sort一下，记住，千万不要忘了加空集 * 1.长度标准：从空集，到本身长度的集合 * 2.可选的范围：从start开始到最后一个 * 3.往前走一步：item加一个，然后start加1表示从下一位加起，然后count也减一个 * 4.后退一步：不用，因为传进去是string，不会对当前状态进行影响 * 5.特别的case：count小于等于0 * 6.关于重复：无 */ public static List<List<Integer>> subsets(int[] nums) { List<List<Integer>> res = new ArrayList<List<Integer>>(); ArrayList<Integer> item = new ArrayList<Integer>(); if (nums.length == 0 || nums == null) return res; Arrays.sort(nums); for (int len = 1; len <= nums.length; len++) dfs3(nums, 0, len, item, res); res.add(new ArrayList<Integer>()); return res; } public static void dfs3(int[] S, int start, int len, List<Integer> item,List<List<Integer>> res) { if (item.size() == len) { res.add(new ArrayList<Integer>(item)); return; } for (int i = start; i < S.length; i++) { item.add(S[i]); dfs3(S, i + 1, len, item, res); item.remove(item.size() - 1); } } /* * 90. Subsets II 12.16 by Mingyang * 这里我们将后面重复的部分算进来，就是当有重复出现的时候，结果不能重复，我就加了一个boolean array * 1.长度标准：从空集，到本身长度的集合 * 2.可选的范围：从start开始到最后一个 * 3.往前走一步：item加一个，然后start加1表示从下一位加起，然后count也减一个 * 4.后退一步：不用，因为传进去是string，不会对当前状态进行影响 * 5.特别的case：count小于等于0 * 6.关于重复：这里有重复出现，所以多了boolean array */ public static List<List<Integer>> subsetsWithDup(int[] nums) { List<List<Integer>> res = new ArrayList<List<Integer>>(); ArrayList<Integer> item = new ArrayList<Integer>(); if (nums.length == 0 || nums == null) return res; Arrays.sort(nums); boolean[] array = new boolean[nums.length]; for (int len = 1; len <= nums.length; len++) dfs3(nums, 0, len, item, res, array); res.add(new ArrayList<Integer>()); return res; } public static void dfs3(int[] S, int start, int len, List<Integer> item,List<List<Integer>> res, boolean[] array) { if (item.size() == len) { res.add(new ArrayList<Integer>(item)); return; } for (int i = start; i < S.length; i++) { if (i != 0 && S[i] == S[i - 1] && array[i - 1] == false)//这句非常关键，表示出了第一个以外，所有的跟前面一样的，并且前面还没用过（多半用了被重新还原的） continue; item.add(S[i]); array[i] = true; dfs3(S, i + 1, len, item, res, array); item.remove(item.size() - 1); array[i] = false; } } /* * 79. Word Search * 2015.12.16 by Mingyang * 这里的起点就是遍历所有的点，找出这个起点 * 我自己做的时候，用了一个StringBuffer来进行加减，判断条件就是sb和word相等，但是！每次加减sb造成了时间上的浪费 * 这里我们用一个index来就好了，每次完了以后，index+1.这样的话我们就可以通过index和word的长度来判断 * 另外有一个技巧就是index不用自己加加，只用加1，这样不会改变index的本质，不用退回来再减一个了。 * 1.长度标准：所有表格进行遍历，对每一个进行dfs，只要有一个可以就成功了 * 2.可选的范围：没有可选范围，已经规定死了xy轴 * 3.往前走一步：可以往上下左右四个方向分别加1 * 4.后退一步：mark unvisited * 5.特别的case：出界了，访问过了，或者达标了 * 6.关于重复：无 */ public boolean exist(char[][] board, String word) { int m = board.length; int n = board[0].length; boolean[][] visited = new boolean[m][n]; for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { if (dfs4(board, word, 0, i, j, visited)) return true; } } return false; } public boolean dfs4(char[][] board, String word, int index, int rowindex,int colindex, boolean[][] visited) { if (index == word.length()) return true; if (rowindex < 0 || colindex < 0 || rowindex >= board.length|| colindex >= board[0].length) return false; if (visited[rowindex][colindex]) return false; if (board[rowindex][colindex] != word.charAt(index)) return false; visited[rowindex][colindex] = true; boolean res = dfs4(board, word, index + 1, rowindex - 1, colindex,visited) || dfs4(board, word, index + 1, rowindex + 1, colindex, visited) || dfs4(board, word, index + 1, rowindex, colindex + 1, visited) || dfs4(board, word, index + 1, rowindex, colindex - 1, visited); visited[rowindex][colindex] = false; return res; } /* * 77. Combinations * 2015.12.16 by Mingyang * 这里有个一个start的多的参数以后就可以保证所有序列按顺序输出的，并且不会重复 12-13-14-23-24-34 * 1.长度标准：无 * 2.可选的范围：从start到最后一个 * 3.往前走一步：可以往上下左右四个方向分别加1 * 4.后退一步：mark unvisited * 5.特别的case：出界了，访问过了，或者达标了 * 6.关于重复：无 */ public static List<List<Integer>> combine(int n, int k) { List<List<Integer>> res = new ArrayList<List<Integer>>(); if (n <= 0 || n < k) return res; List<Integer> item = new ArrayList<Integer>(); dfs2(n, k, 1, item, res);// because it need to begin from 1-------从1开始的哦 return res; } private static void dfs2(int n, int k, int start, List<Integer> item,List<List<Integer>> res) { if (item.size() == k) { res.add(new ArrayList<Integer>(item));// because item is ArrayList<T> so it will not disappear from stack to stack return; } for (int i = start; i <= n; i++) { // 这里多加了一个start，这样就不用再判断重复了 item.add(i); dfs2(n, k, i + 1, item, res); item.remove(item.size() - 1); } } /* * 51. N-Queens * 2016.3.12 by Mingyang * 在这道题目里面，到了最后一步，才把整个棋盘转换成List of String * 其余的大部分时间都是只是把棋盘相应的位置填满 另外这道题目走的方式，不是像word * search那么上下左右到处走，而是在列数确定的情况下，行数从第一个到最后一个loop * 1.长度标准：无 * 2.可选的范围：在col固定的情况下，遍历所有的row * 3.往前走一步：如果某一个row可以就检查是否validate，并且把棋盘上的值改了 * 4.后退一步：棋盘上的值改回来 * 5.特别的case：column走到了最后一个 * 6.关于重复：无 */ public List<List<String>> solveNQueens(int n) { char[][] board = new char[n][n]; for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) board[i][j] = '.'; List<List<String>> res = new ArrayList<List<String>>(); dfs(board, 0, res); return res; } private void dfs(char[][] board, int colIndex, List<List<String>> res) { if (colIndex == board.length) { res.add(construct(board)); return; } for (int i = 0; i < board.length; i++) { if (validate(board, i, colIndex)) { board[i][colIndex] = 'Q'; dfs(board, colIndex + 1, res); board[i][colIndex] = '.'; } } } private boolean validate(char[][] board, int x, int y) { for (int i = 0; i < board.length; i++) { for (int j = 0; j < y; j++) { if (board[i][j] == 'Q'&& (x + j == y + i || x + y == i + j || x == i)) return false; } } return true; } private List<String> construct(char[][] board) { List<String> res = new LinkedList<String>(); for (int i = 0; i < board.length; i++) { String s = new String(board[i]); res.add(s); } return res; } /* * 52. N-Queens II * 2015.12.16 by Mingyang * 1.长度标准：无 * 2.可选的范围：在row固定的情况下，遍历所有的列 * 3.往前走一步：如果某一个col可以就检查是否validate，并且存上column的信息 * 4.后退一步：棋盘上的值改回来 * 5.特别的case：row走完了 * 6.关于重复：无 */ public int totalNQueens(int n) { int[] res = { 0 }; if (n <= 0) return res[0]; int[] columnVal = new int[n]; DFS_helper(n, res, 0, columnVal); return res[0]; } public void DFS_helper(int nQueens, int[] res, int row, int[] columnVal) { if (row == nQueens) { res[0] += 1; } else { for (int i = 0; i < nQueens; i++) { columnVal[row] = i;// (row,columnVal[row)==>(row,i) if (isValid(row, columnVal)) DFS_helper(nQueens, res, row + 1, columnVal); } } } public boolean isValid(int row, int[] columnVal) { for (int i = 0; i < row; i++) { if (columnVal[row] == columnVal[i]|| Math.abs(columnVal[row] - columnVal[i]) == row - i) return false; } return true; } /* * 46. Permutations * 2015.12.13 by Mingyang 方法还是原来那个套路，还是用一个循环递归处理子问题。 * 区别是这里并不是一直往后推进的，前面的数有可能放到后面，所以我们需要维护一个visited数组来表示该元素是否已经在当前结果中， * 因为每次我们取一个元素放入结果，然后递归剩下的元素，所以不会出现重复 * 这道题还有一个扩展就是如果元素集合中会出现重复，那么意味着我们需要跳过一些重复元素 * 1.长度标准：无 * 2.可选的范围：任何一个都可以选！没有顺序 * 3.往前走一步：在未访问某一个的前提下，直接带入 * 4.后退一步：remove * 5.特别的case：size到了 * 6.关于重复：无 */ public List<List<Integer>> permute(int[] nums) { List<List<Integer>> res = new ArrayList<List<Integer>>(); if (nums == null || nums.length == 0) return res; boolean[] visited = new boolean[nums.length]; List<Integer> temp = new ArrayList<Integer>(); dfs3(nums, visited, temp, res); return res; } private void dfs3(int[] nums, boolean[] visited, List<Integer> temp,List<List<Integer>> res) { if (temp.size() == nums.length) { res.add(new ArrayList<Integer>(temp)); return; } for (int i = 0; i < nums.length; i++) { if (!visited[i]) { visited[i] = true; temp.add(nums[i]); dfs3(nums, visited, temp, res); temp.remove(temp.size() - 1); visited[i] = false; } } } /* * 47. Permutations II * 2015.12.13 by Mingyang 唯一的区别就是在这个题目中元素集合可以出现重复。 * 这给我们带来一个问题就是如果不对重复元素加以区别， 那么类似于{1,1,2}这样的例子我们会有重复结果出现。那么如何避免这种重复呢？ * 方法就是对于重复的元素循环时跳过递归函数的调用，只对第一个未被使用的进行递归， * 我们那么这一次结果会出现在第一个的递归函数结果中，而后面重复的会被略过。 如果第一个重复元素前面的元素还没在当前结果中，那么我们不需要进行递归。 * 首先我们要对元素集合排序，从而让重复元素相邻，接下来就是一行代码对于重复元素和前面元素使用情况的判断即可。 * 这样的解法是带有一般性的，把这个代码放到Permutations中也是正确的，所以如果熟悉的话， * 面试时如果碰到这个题目建议直接实现这个代码，不要假设元素没有重复，当然可以跟面试官讨论，不过一般来说都是要考虑这个情况的哈。 * 1.长度标准：无 * 2.可选的范围：任何一个都可以选！没有顺序 * 3.往前走一步：在未访问某一个的前提下，直接带入 * 4.后退一步：remove * 5.特别的case：size到了 * 6.关于重复：这里对于重复有要求，因为这个可以允许重复的字符，所以如果我等于前面的一个，并且前面的一个未访问（其实已经访问并且清除了）直接return */ public List<List<Integer>> permuteUnique(int[] nums) { List<List<Integer>> res = new ArrayList<List<Integer>>(); if (nums == null || nums.length == 0) return res; Arrays.sort(nums); boolean[] visited = new boolean[nums.length]; List<Integer> temp = new ArrayList<Integer>(); dfs4(nums, visited, temp, res); return res; } private void dfs4(int[] nums, boolean[] visited, List<Integer> temp,List<List<Integer>> res) { if (temp.size() == nums.length) { res.add(new ArrayList<Integer>(temp)); return; } for (int i = 0; i < nums.length; i++) { if (i > 0 && !visited[i - 1] && nums[i] == nums[i - 1]) // 这个非常的重要！！！！！！！！！！ continue; if (!visited[i]) { visited[i] = true; temp.add(nums[i]); dfs4(nums, visited, temp, res); temp.remove(temp.size() - 1); visited[i] = false; } } } /* * 37. Sudoku Solver * 2015.12.13 by Mingyang * 1.长度标准：无 * 2.可选的范围：所有木有值得点，选取从1到9的数字 * 3.往前走一步：如果放进去是validate的，那就放 * 4.后退一步：若果放进去，后面是false的，就把这个点改回来 * 5.特别的case：无了 * 6.关于重复：无 * 本题目的isValid是难点 */ public void solveSudoku(char[][] board) { if (board == null || board.length == 0) return; helper(board); } private boolean helper(char[][] board) { for (int i = 0; i < board.length; i++) { for (int j = 0; j < board[0].length; j++) { if (board[i][j] == '.') { for (char num = '1'; num <= '9'; num++) {// 尝试 if (isValid(board, i, j, num)) { board[i][j] = num; if (helper(board)) return true; else board[i][j] = '.';// 回退 } } return false; } } } return true; } private boolean isValid(char[][] board, int i, int j, char c) { // check column for (int row = 0; row < 9; row++) if (board[row][j] == c) return false; // check row for (int col = 0; col < 9; col++) if (board[i][col] == c) return false; // check block for (int row = i / 3 * 3; row < i / 3 * 3 + 3; row++) for (int col = j / 3 * 3; col < j / 3 * 3 + 3; col++) if (board[row][col] == c) return false; return true; } /* * 22. Generate Parentheses * 2015.12.13 by Mingyang * 1.长度标准：无 * 2.可选的范围：只有左括号和右括号，先一直加左边，完了再加右边 * 3.往前走一步：sb加了，left或right减一 * 4.后退一步：sb remove * 5.特别的case：left和right都为0 * 6.关于重复：无 */ public static List<String> generateParenthesis(int n) { List<String> res = new ArrayList<String>(); if (n <= 0) return res; StringBuffer sb = new StringBuffer(); dfs100(n, n, res, sb); return res; } public static void dfs100(int left, int right, List<String> res,StringBuffer sb) { if (left == 0 && right == 0) { res.add(sb.toString()); System.out.println(sb.toString()); return; } if (left > right) return; if (left < 0 || right < 0) return; sb.append('('); dfs100(left - 1, right, res, sb); sb.deleteCharAt(sb.length() - 1); sb.append(')'); dfs100(left, right - 1, res, sb); sb.deleteCharAt(sb.length() - 1); } /* * 17. Letter Combinations of a Phone Number * 2015.11.30 by Mingyang 是对keyboard的循环 * 1.长度标准：无 * 2.可选的范围：数字对应的keyboard的string遍历每一个char * 3.往前走一步：加上这个char以后，index又加1 * 4.后退一步：stringbuffer remove * 5.特别的case：长度相等 * 6.关于重复：无 */ public List<String> letterCombinations(String digits) { List<String> result = new ArrayList<String>(); if (digits == null || digits.length() == 0) return result; String[] keyboard = { "", "", "abc", "def", "ghi", "jkl", "mno","pqrs", "tuv", "wxyz" }; StringBuilder current = new StringBuilder(); int index = 0; dfs(digits, index, current, keyboard, result); return result; } private void dfs(String digits, int index, StringBuilder current,String[] keyboard, List<String> result) { if (index == digits.length()) { result.add(current.toString()); return; } int num = digits.charAt(index) - '0';// get integer number for (int i = 0; i < keyboard[num].length(); i++) { current.append(keyboard[num].charAt(i)); dfs(digits, index + 1, current, keyboard, result); current.deleteCharAt(current.length() - 1); } } /* * Number of Islands 12.19 by Mingyang * 直接设一个叫count的值，没遇到一个1，就把所有相连的1全部变为0，这样，到底遇到几次1，就是最终有几个小岛啦 */ public int numIslands(char[][] grid) { if (grid == null || grid.length == 0 || grid[0].length == 0) return 0; int count = 0; for (int i = 0; i < grid.length; i++) { for (int j = 0; j < grid[0].length; j++) { if (grid[i][j] == '1') { count++; dfs(grid, i, j); } } } return count; } public void dfs(char[][] grid, int i, int j) { // validity checking if (i < 0 || j < 0 || i > grid.length - 1 || j > grid[0].length - 1) return; // if current cell is water or visited if (grid[i][j] != '1') return; // set visited cell to '0' grid[i][j] = '0'; // merge all adjacent land dfs(grid, i - 1, j); dfs(grid, i + 1, j); dfs(grid, i, j - 1); dfs(grid, i, j + 1); } /* * 212. Word Search II 12.17 by Mingyang 这么做可以在word * search的基础之上做，但是效率不高，所以后面可以用tire tree */ public List<String> findWords(char[][] board, String[] words) { ArrayList<String> result = new ArrayList<String>(); int m = board.length; int n = board[0].length; for (String word : words) { boolean flag = false; boolean[][] visited = new boolean[m][n]; for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { char[][] newBoard = new char[m][n]; for (int x = 0; x < m; x++) for (int y = 0; y < n; y++) newBoard[x][y] = board[x][y]; if (dfs4(newBoard, word, i, j, 0, visited)) { flag = true; } } } if (flag) { result.add(word); } } return result; } /* * Simplify Path 12.3 by Mingyang 当遇到“/../"则需要返回上级目录，需检查上级目录是否为空。 * * 当遇到"/./"则表示是本级目录，无需做任何特殊操作。 * * 当遇到"//"则表示是本级目录，无需做任何操作。 * * 当遇到其他字符则表示是文件夹名，无需简化。 * * 当字符串是空或者遇到”/../”，则需要返回一个"/"。 * * 当遇见"/a//b"，则需要简化为"/a/b"。 所以我们这里遇到简化的时候，先split为//之间的值。然后用两个堆栈来解决，因为方向是反的 * 当字符串为空或者为"."，不做任何操作。 * * 当字符串不为".."，则将字符串入栈。 * * 当字符串为"..", 则弹栈（返回上级目录）。 */ public String simplifyPath(String path) { if (path == null || path.length() == 0) return path; Stack<String> stack = new Stack<String>(); String[] list = path.split("/"); for (int i = 0; i < list.length; i++) { if (list[i].equals(".") || list[i].length() == 0) continue; else if (!list[i].equals("..")) stack.push(list[i]); else { if (!stack.isEmpty()) stack.pop(); } } StringBuilder res = new StringBuilder(); Stack<String> temp = new Stack<String>(); while (!stack.isEmpty()) temp.push(stack.pop()); while (!temp.isEmpty()) res.append("/" + temp.pop()); if (res.length() == 0) res.append("/"); return res.toString(); } /* * Additive Number 1.2 by Mingyang */ public boolean isAdditiveNumber(String s) { int n = s.length(); for (int i = 1; i < n; i++) { for (int j = i + 1; j < n; j++) { long a = parse(s.substring(0, i)); long b = parse(s.substring(i, j)); if (a == -1 || b == -1) continue; if (dfs(s.substring(j), a, b)) return true; } } return false; } boolean dfs(String s, long a, long b) { if (s.length() == 0) return true; for (int i = 1; i <= s.length(); i++) { long c = parse(s.substring(0, i)); if (c == -1) continue; if (c - a == b && dfs(s.substring(i), b, c)) { return true; } } return false; } long parse(String s) { if (!s.equals("0") && s.startsWith("0")) return -1; long result = 0; try { result = Long.parseLong(s); } catch (NumberFormatException e) { return -1; } return result; } }