回溯法 开头 基础+排列

Author: h2pl

src/BackTracking/IP地址划分.java

@@ -0,0 +1,64 @@
+package BackTracking;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by 周杰伦 on 2018/4/1.
+ */
+//1111
+//222 222 222 222
+// 55 55 55 55
+public class IP地址划分 {
+    public static void main(String[] args) {
+
+    }
+    public List<String> restoreIpAddresses(String s) {
+        int i,j,k,m;
+        ArrayList <String> list = new ArrayList<>();
+        int len = s.length();
+        for (i = 1;i< 4 && i < len - 2;i ++) {
+            for (j = i + 1;j < i + 4 && j < len - 1;j ++) {
+                for (m = j + 1;m < j + 4 && m < len;m ++) {
+                    //substring后面的下标是不算在内的。
+                    String s1 = s.substring(0,i);
+                    String s2 = s.substring(i,j);
+                    String s3 = s.substring(j,m);
+                    String s4 = s.substring(m,len);
+                    if(isValid(s1) && isValid(s2) && isValid(s3) && isValid(s4))
+                    {
+                        list.add(s1 + '.' + s2 + '.' + s3 + '.' + s4);
+                    }
+                }
+            }
+        }
+        return list;
+    }
+
+    public boolean isValid(String s) {
+        if (s.length() == 0 || s.length() > 3 || s.charAt(0) == '0' && s.length() > 1
+                || Integer.parseInt(s) > 255) {
+            return false;
+        }else return true;
+    }
+
+//    public List<String> restoreIpAddresses(String s) {
+//        List<String> result = new ArrayList<>();
+//        doRestore(result, "", s, 0);
+//        return result;
+//    }
+
+//    private void doRestore(List<String> result, String path, String s, int k) {
+//        if (s.isEmpty() || k == 4) {
+//            if (s.isEmpty() && k == 4)
+//                result.add(path.substring(1));
+//            return;
+//        }
+//        for (int i = 1; i <= (s.charAt(0) == '0' ? 1 : 3) && i <= s.length(); i++) { // Avoid leading 0
+//            String part = s.substring(0, i);
+//            if (Integer.valueOf(part) <= 255)
+//                doRestore(result, path + "." + part, s.substring(i), k + 1);
+//        }
+//    }
+
+}

src/BackTracking/找出所有数字组合.java

@@ -0,0 +1,41 @@
+package BackTracking;
+
+import java.lang.reflect.Array;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Created by 周杰伦 on 2018/4/1.
+ */
+public class 找出所有数字组合 {
+    public static void main(String[] args) {
+        int []a = {1,2,3};
+        System.out.println(Arrays.toString(permute(a).toArray()));
+    }
+    public static List<List<Integer>> permute(int[] nums) {
+        int m = nums.length;
+        int []visit = new int[m];
+        List<List<Integer>> list = new ArrayList<>();
+        ArrayList<Integer> arr = new ArrayList<>();
+        dfs(arr, nums, visit, list);
+        return list;
+    }
+    public static void dfs(ArrayList<Integer> arr, int []nums, int[]visit, List<List<Integer>> list) {
+        if (arr.size() == nums.length) {
+            list.add(new ArrayList<>(arr));
+            return;
+        }
+        for (int i = 0;i < nums.length;i ++) {
+            if (visit[i] == 1) continue;
+            visit[i] = 1;
+            arr.add(nums[i]);
+            dfs(arr, nums, visit,list);
+            arr.remove(arr.size()-1);
+            visit[i] = 0;
+        }
+
+        return;
+    }
+
+}

src/BackTracking/数字键打出字母组合.java

@@ -0,0 +1,29 @@
+package BackTracking;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by 周杰伦 on 2018/4/1.
+ */
+public class 数字键打出字母组合 {
+    public List<String> letterCombinations(String digits) {
+        if (digits == null || digits.equals(""))return new ArrayList<>();
+        List<String> list = new ArrayList<>();
+        combineStr("",0,digits,list);
+        return list;
+    }
+    public void combineStr(String prefix, int offset, String digits, List<String>ret) {
+        if (offset == digits.length()) {
+            ret.add(prefix);
+            return;
+        }
+        String letters = KEYS[digits.charAt(offset) - '0'];
+        char[] arr = letters.toCharArray();
+        for (char c : arr) {
+            combineStr(prefix + c,offset + 1,digits, ret);
+        }
+    }
+    private static final String[] KEYS = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+
+}

src/BackTracking/矩阵查找单词.java

@@ -0,0 +1,52 @@
+package BackTracking;
+
+/**
+ * Created by 周杰伦 on 2018/4/1.
+ */
+public class 矩阵查找单词 {
+    public static void main(String[] args) {
+        char [][]a = {{'a','b'}};
+        String b = "ba";
+        System.out.println(b.charAt(0));
+        System.out.println(b.charAt(0) == a[0][1]);
+        System.out.println(exist(a,b));
+    }
+    public static boolean exist(char[][] board, String word) {
+        boolean flag = false;
+        int m = board.length;
+        int n = board[0].length;
+        int [][]visit = new int[m][n];
+        for (int i = 0;i < m;i ++) {
+            for (int j = 0; j < n; j++) {
+                if (board[i][j] == word.charAt(0)) {
+                    if (find(board, word, i, j, visit, 0)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return flag;
+
+    }
+    public static boolean find(char[][]board, String word, int i,int j,int[][]visit, int offset)
+    {
+        if (offset == word.length()) {
+            return true;
+        }
+        if (i < 0 || j < 0 || i >= board.length || j >=  board[0].length ||
+                word.charAt(offset) != board[i][j] || visit[i][j] == 1) {
+            return false;
+        }
+
+        visit[i][j] = 1;
+        boolean flag = find(board, word, i + 1, j, visit, offset + 1)
+        ||find(board, word, i, j + 1, visit, offset + 1)
+        ||find(board, word, i - 1, j, visit, offset + 1)
+        ||find(board, word, i, j - 1, visit, offset + 1);
+        visit[i][j] = 0;
+        return flag;
+
+    }
+
+
+}