【Leetcode】回溯法总结

回溯法的解体框架

解决一个回溯问题，实际上就是一个决策树的遍历过程。一般来说，我们需要解决三个问题：

路径：也就是已经做出的选择。
选择列表：也就是你当前可以做的选择。
结束条件：也就是到达决策树底层，无法再做选择的条件。

可以套用模板：

LinkedList result = new LinkedList();
public void backtrack(路径，选择列表){
    if(满足结束条件){
        result.add(结果);
    }
    for(选择：选择列表){
        做出选择;
        backtrack(路径，选择列表);
        撤销选择;
    }
}

面试题38. 字符串的排列

class Solution {
    private Set<String> ans = new HashSet<>();
    public String[] permutation(String s) {
        if(s == null || s.length() == 0){
            return new String[]{""};
        }
        char[] chs = s.toCharArray();
        boolean[] visited = new boolean[chs.length];
        backtracing(s,chs,new StringBuilder(),visited);
        String[] ansArr = new String[ans.size()];
        int i = 0;
        for(String str: ans){
            ansArr[i++] = str;
        }
        return ansArr;
    }
    public void backtracing(String s,char[] chs, StringBuilder sb, boolean[] visited){
        if(sb.length() == s.length()){
            ans.add(sb.toString());
        }
        for(int i = 0; i < chs.length; i++){
            if(visited[i]){
                continue;
            }
            visited[i] = true;
            char c = chs[i];
            sb.append(c+"");
            backtracing(s,chs,sb,visited);
            sb.deleteCharAt(sb.length()-1);
            visited[i] = false;
        }
    }
}

 

面试题34. 二叉树中和为某一值的路径

class Solution {
    private List<List<Integer>> ans = new ArrayList<>();
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        backtracing(root,sum,new ArrayList<>());
        return ans;
    }
    private void backtracing(TreeNode root, int sum, ArrayList<Integer> path){
        if(root == null) return;
        sum -= root.val;
        path.add(root.val);
        if(sum == 0 && root.left == null && root.right == null){
            ans.add(new ArrayList<>(path));
        }else{
            backtracing(root.left,sum,path);
            backtracing(root.right,sum,path);
        }
        path.remove(path.size()-1);
    }
}

 

大数打印1~最大的n位数

在本题中，结束条件就是路径长于n，选择列表是0~9，当位于第一位的时候需要剪枝。

public class Solution {
    private static List<String> list = new ArrayList<>();
    public static List<String> printNumbers(int n) {
        trace(new StringBuilder(),n);
        list.remove(0);
        return list;
    }
    public static void trace(StringBuilder num, int n){
        if(num.length() > n){
            return;
        }
        list.add(num.toString());
        for(int i = 0; i < 10; i++){
            if(i == 0 && num.length() == 0){
                continue;
            }
            num.append(i);
            trace(num,n);
            num.deleteCharAt(num.length()-1);
        }
    }

    public static void main(String[] args) {
        List<String> list = printNumbers(3);
        System.out.println(list.toString());
    }
}

【补充】大数相加问题

class Solution {
    public String addStrings(String num1, String num2) {
        int i = num1.length()-1, j = num2.length()-1;
        int carry = 0;
        StringBuilder sb = new StringBuilder();
        while(i >= 0 || j >= 0 || carry > 0){
            if(i >= 0){
                carry += num1.charAt(i--)-'0';
            }
            if(j >= 0){
                carry += num2.charAt(j--)-'0';
            }
            sb.append(carry%10);
            carry /= 10;
        }
        return sb.reverse().toString();
    }
}