当前位置:   article > 正文

回溯算法总结(java)_回溯算法java

回溯算法java

回溯算法

  • 回溯法按深度优先策略搜索问题的解空间树。首先从根节点出发搜索解空间树,当算法搜索至解空间树的某一节点时,先利用剪枝函数判断该节点是否可行(即能得到问题的解)。如果不可行,则跳过对该节点为根的子树的搜索,逐层向其祖先节点回溯;否则,进入该子树,继续按深度优先策略搜索。
  • 回溯法的基本行为是搜索,搜索过程使用剪枝函数来为了避免无效的搜索。剪枝函数包括两类:1. 使用约束函数,剪去不满足约束条件的路径;2.使用限界函数,剪去不能得到最优解的路径。
  • 回溯算法说白了就是穷举法。不过回溯算法使用剪枝函数,剪去一些不可能到达 最终状态(即答案状态)的节点,从而减少状态空间树节点的生成,提高了效率。
  • 回溯算法一般都采用递归实现。回溯利用递归的性质,从问题的起始点出发,不断地进行尝试,回头一步甚至多步再做选择,直到最终抵达终点。

回溯解题模板

function backtrack(n, used) {
    // 判断输入或者状态是否非法
    if (input/state is invalid) {
        return;
  	}
    // 判读递归是否应当结束,满足结束条件就返回结果
    if (match condition) {
        return some value;
  	}
    // 遍历当前所有可能出现的情况,并尝试每一种情况
    for (all possible cases) {
        // 如果上一步尝试会影响下一步尝试,需要写入状态
        used.push(case)
        // 递归进行下一步尝试,搜索该子树
        result = backtrack(n + 1, used)
        // 在这种情况下已经尝试完毕,重置状态,以便于下面的回溯尝试
        used.pop(case)
    } 
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

经典问题

leetcode17. 电话号码的字母组合
class Solution {
    private List<String> res = new ArrayList<>();
    private final String[] letterMap = new String[]{"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};

    public List<String> letterCombinations(String digits) {
        if (digits.length() == 0) {
            return res;
        }
        findCombination(digits, 0, "");
        return res;
    }

    private void findCombination(String digits, int index, String s){

        if(index == digits.length()){
            res.add(s);
            return;
        }

        Character c = digits.charAt(index);
        String letters = letterMap[c - '0'];
        for(int i = 0 ; i < letters.length() ; i ++){
            findCombination(digits, index+1, s + letters.charAt(i));
        }
        return;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
leetcode46. 全排列
public class Solution {

    private List<List<Integer>> res = new ArrayList<>();

    public List<List<Integer>> permute(int[] nums) {
        if (nums.length == 0) {
            return res;
        }
        boolean[] used = new boolean[nums.length];
        List<Integer> list = new ArrayList<>();
        backtrack(nums, 0, list, used);
        return res;
    }

    public void backtrack(int[] nums, int index, List<Integer> list, boolean[] used) {
        if (index == nums.length) {
            res.add(new ArrayList<>(list));
            return;
        }

        for (int i = 0; i < nums.length; i++) {
            if (!used[i]) {
                list.add(nums[i]);
                used[i] = true;
                backtrack(nums, index + 1, list, used);
                list.remove(list.size() - 1);
                used[i] = false;
            }
        }
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
leetcode51. N皇后
class Solution {
    public List<List<String>> res = new ArrayList<>();

    public List<List<String>> solveNQueens(int n) {
        int[] cols = new int[n];
        for (int i=0; i<n; i++) {
            cols[i] = -1;
        }
        backtrack(0, n, cols);
        return res;
    }

    public void  backtrack(int index, int n, int[] cols) {
        if (index == n) {
            res.add(locToList(cols));
            return;
        }

        for (int i=0; i<n; i++) {
            cols[index] = i;
            if (isSafe(cols, index)) {
                backtrack(index+1, n, cols);
            }
            cols[index] = -1;
        }
    }

    public boolean isSafe(int[] cols, int index) {
        for (int i=0; i<index; i++) {
            if (cols[i] == cols[index] || i+cols[i] == index+cols[index] || i-cols[i] == index-cols[index]) {
                return false;
            }
        }
        return true;
    }

    public List<String> locToList(int[] cols) {
        ArrayList<String> list = new ArrayList<>();
        for (int i=0; i<cols.length; i++) {
            StringBuilder sb = new StringBuilder();
            for (int j=0; j<cols[i]; j++){
                sb.append(".");
            }
            sb.append("Q");
            for (int j=cols[i]+1; j<cols.length; j++){
                sb.append(".");
            }
            list.add(sb.toString());
        }
        return list;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52

其他

递归与迭代
  • 计算机解决问题其实没有任何奇技淫巧,它唯一的解决办法就是穷举,穷举所有可能性。算法设计无非就是先思考“如何穷举”,然后再追求“如何聪明地穷举”。其中穷举的代码形式上有两种:递归和迭代
  • 重复调用函数自身实现循环称为递归。递归是用栈机制实现的,每深入一层,都要占去一块栈数据区域,所以有可能导致堆栈溢出的错误。思想简单,代码简洁,将问题交给计算机
  • 利用变量的原值推出新值称为迭代,或着说迭代是函数内某段代码实现循环。由于递归容易导致堆栈溢出,并且递归比迭代效率要低,所以尽量使用迭代
  • 递归是一个树结构,迭代是一个环结构
递归与递推
  • 递归是自顶向下(对应函数入栈),又自底向上(对应函数出栈)。可以在自顶向下的时候进行操作,也可以在自底向上的时候进行操作。
  • 递推是自底向上
两种实现形式
  • 状态记录回溯
  • 交换回溯
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/不正经/article/detail/423788
推荐阅读
相关标签
  

闽ICP备14008679号