# Leet专题刷题Day03-BFS

Leet专题刷题Day03-BFS

102. 二叉树的层序遍历

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        if (root == null) {
            return res;
        }

        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);
            }
            res.add(level);
        }
        
        return res;
    }
}

103. 二叉树的锯齿形层序遍历

思路：102如果是奇数就加载LinkedList尾插法，偶数头插法。

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
         List<List<Integer>> res = new ArrayList<List<Integer>>();
        if (root == null) {
            return res;
        }

        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        boolean flag = true;
        while (!queue.isEmpty()) {
            LinkedList<Integer> level = new LinkedList<Integer>();
            int currentLevelSize = queue.size();
            for (int i = 1; i <= currentLevelSize; ++i) {
                TreeNode node = queue.poll();
                if (flag){
                    level.addLast(node.val);
                }else{
                    level.addFirst(node.val);
                }
                
                if (node.left != null) queue.offer(node.left);
                if (node.right != null)  queue.offer(node.right);
            }
            res.add(level);
            flag = ! flag;
        }
        
        return res;
    }
}

322. 零钱兑换

思路：其实这题是一道动态规划的题目，但是本次主要练习bfs。

思路一：可以层序遍历，记录每一层的深度。但是超时了，因为每次offer 的时候会有重复的candidate。然后想到了HashSet来判断，并且从低向上太慢了，从上往下找。

class Solution {
    public int coinChange(int[] coins, int amount) {
        if (amount == 0) return 0;
        Queue<Integer> queue = new LinkedList<>();
        for (int coin : coins) queue.offer(coin);
        int ans = 1;
        while ( ! queue.isEmpty()){
            int size = queue.size();
            for (int i = 0; i < size; i++){
                int candidate = queue.poll();
                if (candidate == amount) return ans;
                if (candidate < amount) {
                    for (int coin : coins) queue.offer(coin+candidate);
                }
            }
            ans++;
        }
        return -1;
        
    }
}

AC版本

class Solution {
    public int coinChange(int[] coins, int amount) {
        if(amount==0){
            return 0;
        }
        Queue<Integer> queue=new LinkedList<>();
        HashSet<Integer> set=new HashSet<>();
        queue.offer(amount);
        int level=0;
        while(!queue.isEmpty()){
            int size=queue.size();
            for(int i=0;i<size;i++){
                int temp=queue.poll();
                for(int j=0;j<coins.length;j++){
                    int cur=temp-coins[j];
                    if(cur==0){
                        return level+1;
                    }
                    if(cur>0 &&!set.contains(cur)){
                        set.add(cur);
                        queue.offer(cur);
                    }
                }
            }
            level++;
        }
        return -1;
    }
}

279. 完全平方数

还是动态规划题目

思路

class Solution {
    public int numSquares(int n) {
        Queue<Integer> queue = new LinkedList<>();
        TreeSet<Integer> set = new TreeSet<>();
        Set<Integer> overlap = new HashSet<>(); 
        for (int i = 1; i <= Math.floor(Math.sqrt(n)); i++){
            set.add(i*i);
        }
        queue.add(n);
        int level = 0;
        while ( ! queue.isEmpty()){
            int size = queue.size();
            for (int i = 0; i < size; i++){
                int candidate = queue.poll();
                for (int intt : set){
                    int new_candidate  = candidate - intt;
                    if (new_candidate == 0) return level+1;
                    else if (new_candidate > 0 && ! overlap.contains(new_candidate)){
                        overlap.add(new_candidate);
                        queue.offer(new_candidate);
                    }
                }

            }
            level++;
        }
        return -1;
    }
}

690. 员工的重要性

题目比较复杂，但是是简单题 主要是把List中所有的Employee放入Set中。

class Solution {
    public int getImportance(List<Employee> employees, int id) {
        Map<Integer, Employee> map = new HashMap<Integer, Employee>();
        for (Employee employee : employees) {
            map.put(employee.id, employee);
        }
        int total = 0;
        Queue<Integer> queue = new LinkedList<Integer>();
        queue.offer(id);
        while (!queue.isEmpty()) {
            int curId = queue.poll();
            Employee employee = map.get(curId);
            total += employee.importance;
            List<Integer> subordinates = employee.subordinates;
            for (int subId : subordinates) {
                queue.offer(subId);
            }
        }
        return total;
    }
}

993. 二叉树的堂兄弟节点

class Solution {
    public boolean isCousins(TreeNode root, int x, int y) {
        Queue<TreeNode> queue = new LinkedList<>();
        queue.add(root);
        while (! queue.isEmpty()){
            int size = queue.size();
            boolean left = false;
            boolean right = false;
            for (int i = 0; i < size; i++){
                boolean judge = left || right;
                TreeNode candidate = queue.poll();
                if (candidate.left != null){
                    left = candidate.left.val == x ? true : left;
                    right = candidate.left.val == y ? true : right;
                    queue.offer(candidate.left);
                }
                if (candidate.right != null){
                    left = candidate.right.val == x ? true : left;
                    right = candidate.right.val == y ? true : right;
                    queue.offer(candidate.right);
                }
                if (!judge && left && right) return false;
            }
            if (left && right) return true;
        }
        return false;
    }
}