Java回溯算法知识点(含面试大厂题和源码)

回溯算法是一种通过试错来解决问题的算法,它尝试分步解决一个问题。如果发现当前的步骤不能得到有效的解决方案,它将取消上一步或几步的计算,再尝试其他的解决方案。回溯算法通常用递归方法实现,适用于解决组合问题、划分问题、排列问题、子集问题等。

回溯算法的关键知识点:

  1. 递归思想

    回溯算法通常使用递归函数来实现。递归函数在每次调用时,都会尝试一种可能的解决方案,如果这种解决方案不可行,就会回退到上一步,尝试其他的解决方案。

  2. 三种基本框架

    回溯算法的实现通常有三种基本框架:

    • 深度优先搜索(DFS):从起点开始,尽可能深地搜索树的分支。
    • 广度优先搜索(BFS):从起点开始,先搜索树的所有第一层的节点,再逐层深入。
    • 迭代回溯:使用栈来模拟递归过程,避免递归带来的额外开销。
  3. 剪枝操作

    在回溯过程中,剪枝是非常重要的优化操作。它指的是在搜索过程中,提前排除那些明显不会得到解的情况,从而减少不必要的计算。

  4. 约束条件和目标函数

    回溯算法在解决问题时,需要定义约束条件和目标函数。约束条件用于判断当前的解决方案是否可行,目标函数用于评估当前解决方案的优劣。

  5. 记忆化搜索

    记忆化搜索是一种优化技术,它将已经解决的子问题的答案存储起来,当需要再次解决同一个子问题时,可以直接查找答案,避免重复计算。

  6. 回溯算法的应用

    回溯算法广泛应用于解决组合问题、划分问题、排列问题、子集问题等。例如八皇后问题、图的着色问题、旅行商问题、0-1背包问题等。

实现回溯算法的步骤:

  1. 确定解空间:首先需要确定问题的解空间,即所有可能的解决方案。

  2. 探索解空间:使用递归或迭代的方式,逐步探索解空间中的每一个可能的解。

  3. 约束条件检查:在探索过程中,使用约束条件来过滤掉不符合条件的解。

  4. 回溯:当探索到当前路径无法得到有效解时,回退到上一步,尝试其他的解决方案。

  5. 记录和输出解:当找到一个可行解时,记录下来。如果需要找到所有解,则继续探索;如果只需要找到一个解,则输出当前解并结束。

回溯算法是一种强大而又灵活的算法,通过不断的尝试和错误,最终找到问题的解。掌握回溯算法,可以帮助你在面试中解决各种复杂的问题。

题目 1:N 皇后问题

问题描述:在 N×N 的棋盘上摆放 N 个皇后,使得它们不能互相攻击,即任意两个皇后都不能处于同一行、同一列或同一斜线上。求解所有可能的摆放方案。

Java 源码

java 复制代码
public class NQueens {
    static int count = 0; // 用于记录解的个数

    public static void placeQueen(int n, int[][] board) {
        if (placeQueenHelper(n, board, 0)) {
            printSolution(board);
            count++;
        }
    }

    private static boolean placeQueenHelper(int n, int[][] board, int row) {
        if (row == n) {
            return true;
        }
        for (int col = 0; col < n; col++) {
            if (isValid(board, row, col)) {
                board[row][col] = 1; // 放置皇后
                if (placeQueenHelper(n, board, row + 1)) {
                    return true;
                }
                board[row][col] = 0; // 移除皇后,回溯
            }
        }
        return false;
    }

    private static boolean isValid(int[][] board, int row, int col) {
        for (int i = 0; i < row; i++) {
            if (board[i][col] == 1) return false; // 检查同一列
            if (board[row - col + i][col - i] == 1) return false; // 检查主对角线
            if (board[row - col + i][col + i] == 1) return false; // 检查副对角线
        }
        return true;
    }

    private static void printSolution(int[][] board) {
        for (int[] row : board) {
            for (int val : row) {
                System.out.print(val + " ");
            }
            System.out.println();
        }
        System.out.println();
    }

    public static void main(String[] args) {
        int n = 4; // 棋盘大小
        int[][] board = new int[n][n];
        placeQueen(n, board);
        System.out.println("Total solutions: " + count);
    }
}

题目 2:全排列问题

问题描述:给定一个不含重复数字的序列,返回其所有可能的全排列。

Java 源码

java 复制代码
import java.util.ArrayList;
import java.util.List;

public class Permutations {
    public static List<List<Integer>> permute(int[] nums) {
        List<Integer> list = new ArrayList<>();
        for (int num : nums) {
            list.add(num);
        }
        return backtrack(list, new ArrayList<>());
    }

    private static List<List<Integer>> backtrack(List<Integer> list, List<Integer> result) {
        if (list.size() == 0) {
            result.add(new ArrayList<>(list));
            return result;
        }
        for (int i = 0; i < list.size(); i++) {
            List<Integer> newResult = new ArrayList<>(result);
            newResult.add(list.get(i));
            list.remove(i);
            backtrack(list, newResult);
            list.add(i, list.get(i)); // 回溯
        }
        return result;
    }

    public static void main(String[] args) {
        int[] nums = {1, 2, 3};
        List<List<Integer>> result = permute(nums);
        for (List<Integer> perm : result) {
            System.out.println(perm);
        }
    }
}

题目 3:组合总和问题

问题描述 :给定一个候选数字的集合(候选数字中的每个数字可以多次选择),保证和的总和不小于目标和,找出所有可能的组合,且每种组合的数字不会重复。
Java 源码

java 复制代码
import java.util.ArrayList;
import java.util.List;

public class CombinationSum {
    public static List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> result = new ArrayList<>();
        List<Integer> combination = new ArrayList<>();
        backtrack(candidates, target, combination, result, 0);
        return result;
    }

    private static void backtrack(int[] candidates, int target, List<Integer> combination, List<List<Integer>> result, int start) {
        if (target < 0) {
            return;
        }
        if (target == 0) {
            result.add(new ArrayList<>(combination));
            return;
        }
        for (int i = start; i < candidates.length; i++) {
            combination.add(candidates[i]);
            backtrack(candidates, target - candidates[i], combination, result, i); // 允许重复使用同一个数字
            combination.remove(combination.size() - 1); // 回溯
        }
    }

    public static void main(String[] args) {
        int[] candidates = {10, 1, 2, 7, 6, 1, 5};
        int target = 8;
        List<List<Integer>> result = combinationSum(candidates, target);
        for (List<Integer> comb : result) {
            System.out.println(comb);
        }
    }
}

以上题目和代码示例都是经典的回溯算法问题,它们可以帮助你在面试中展示你的算法能力和编程技巧。在实际面试中,除了正确解决问题,清晰地解释你的思路和代码也非常重要。

相关推荐
憨子周33 分钟前
2M的带宽怎么怎么设置tcp滑动窗口以及连接池
java·网络·网络协议·tcp/ip
passer__jw7671 小时前
【LeetCode】【算法】3. 无重复字符的最长子串
算法·leetcode
passer__jw7671 小时前
【LeetCode】【算法】21. 合并两个有序链表
算法·leetcode·链表
sweetheart7-71 小时前
LeetCode22. 括号生成(2024冬季每日一题 2)
算法·深度优先·力扣·dfs·左右括号匹配
霖雨2 小时前
使用Visual Studio Code 快速新建Net项目
java·ide·windows·vscode·编辑器
SRY122404192 小时前
javaSE面试题
java·开发语言·面试
Fiercezm3 小时前
JUC学习
java
无尽的大道3 小时前
Java 泛型详解:参数化类型的强大之处
java·开发语言
ZIM学编程3 小时前
Java基础Day-Sixteen
java·开发语言·windows
我不是星海3 小时前
1.集合体系补充(1)
java·数据结构