算法基础复习-BFS、DFS

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;
    } 
}