1. BFS(Breadth First Search)
原理:从一个节点开始向其邻节点扩散,遇到目标节点停止,代码使用队列实现
应用
- 树的层序遍历(leetcode 102)
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> ret = new ArrayList<List<Integer>>();
if (root == null) return ret;
Queue<TreeNode> queue = new LinkedList<TreeNode>();
queue.offer(root);
while (!queue.isEmpty()) {
List<Integer> level = new ArrayList<Integer>();
int currentLevelSize = queue.size();
for (int i = 1; i <= currentLevelSize; i++) {
TreeNode node = queue.poll();
level.add(node.val);
if (node.left != null) {
queue.offer(node.left);
}
if (node.right != null) {
queue.offer(node.right);
}
}
ret.add(level);
}
return ret;
}
- 单源最短路径
public int shortestPath(Node start, Node target) {
Queue<Node> q = new LinkedList<>();
Set<Node> visitied = new HashSet<>();
q.offer(start);
visited.add(start);
int step = 0;
while (!q.isEmpty()) {
int s = q.size();
for (int i = 0; i < s; i++) {
Node cur = q.poll();
if (cur == target)
return step;
for (Node x : cur.adj()) {
if (!visited.contains(x)) {
q.offer(x);
visited.add(x);
}
}
}
step++;
}
}
2. DFS(Depth First Search)
原理:尽可能深的搜索分支节点,遇到已访问的则回溯,遇到目标节点停止,代码使用递归实现
深度优先遍历,直接使用了系统栈,系统栈帮助我们保存了每一个结点的状态信息
回溯算法:采用试错的思想,当前的分步不能得到解,将取消上一步或几步的计算,再通过其它的分步再次尝试,是一种有方向的暴力搜索解法
回溯应用剪枝技巧:回溯算法的时间复杂度很高,如果能够提前知道这一条分支不能搜索到结果,就可以提前结束,这一步操作称为剪枝,不同问题采用不同的剪枝策略
应用
- 全排列(leetcode 46)
class Solution {
List<List<Integer>> res = new LinkedList<>();
public List<List<Integer>> permute(int[] nums) {
LinkedList<Integer> trace = new LinkedList<>();
backtrack(nums, trace); //参数1:选择列表;参数2:记录轨迹
return res;
}
private void backtrack(int[] nums, LinkedList<Integer> trace) {
if (trace.size() == nums.length) { //结束条件
res.add(new LinkedList(trace)); //添加当前trace的拷贝
return;
}
for (int i = 0; i < nums.length; i++) {
if (trace.contains(nums[i]))
continue;
trace.add(nums[i]); //选择后添加
backtrack(nums, trace);
trace.removeLast(); //回溯,撤销选择
}
}
}
- N皇后(leetcode 51)
给一个 N×N 的棋盘,放置 N 个皇后,使得它们不能互相攻击,
皇后可以攻击同一行、同一列、左上左下右上右下四个方向的任意单位
class Solution {
List<List<String>> res = new LinkedList<>();
public List<List<String>> solveNQueens(int n) {
//初始化棋牌为.......
List<char[]> board = new LinkedList<>();
for (int i = 0; i < n; i++) {
char[] arr = new char[n];
Arrays.fill(arr, '.');
board.add(arr);
}
//回溯算法
backtrack(board, 0);
return res;
}
//路径:borad中小于row的行已成功放置皇后
//选择列表:第row行的所有列
//结束条件:row超过board的行数
private void backtrack(List<char[]> board, int row) {
//结束条件
if (row == board.size()) res.add(transform(board)); //添加成功放置皇后的新borad
for (int col = 0; col < board.size(); col++) {
if (!isValid(board, row, col)) continue; //排除不合法选择
board.get(row)[col] = 'Q'; //做选择
backtrack(board, row + 1); //进入下一行决策
board.get(row)[col] = '.'; //撤销选择
}
}
private List<String> transform(List<char[]> board) {
List<String> newBoard = new LinkedList<>();
for (char[] row : board) {
newBoard.add(new String(row));
}
return newBoard;
}
private boolean isValid(List<char[]> board, int row, int col) {
int n = board.size();
// 检查列是否有皇后互相冲突
for(int i = 0; i < n; i++) {
if(board.get(i)[col] == 'Q') return false;
}
// 检查右上方是否有皇后互相冲突
for(int i = row - 1, j = col + 1; i >= 0 && j < n; i--,j++){
if(board.get(i)[j] == 'Q') return false;
}
// 检查左上方是否有皇后互相冲突
for(int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--){
if(board.get(i)[j] == 'Q') return false;
}
return true;
}
}