Binary Tree Level Order Traversal

Given a binary tree, return the level order traversal of its nodes’ values. (ie, from left to right, level by level).

For example:
Given binary tree {3,9,20,#,#,15,7},

return its level order traversal as:

[
  [3],
  [9,20],
  [15,7]
]

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

1. 通過統計每一行的結點數

定義兩個變量，toBePrinted和nextLevel。

toBePrinted：當前待打印結點的數量
nextLevel：下一層的結點數量

通過Deque來進行統計。

2. 插入特殊結點

參考自：Binary Tree Level Order Traversal

通過插入特殊結點，來判斷一層是否結束。這樣做的好處是不用統計每一層結點數目。僞代碼如下：

a queue stores [step0, step1, step2, ...]

queue.add(first step)

while queue is not empty

  current_step = queue.poll()

  // do something here with current_step
  // like counting

  foreah step in current_step can jump to
    queue.add(step)

代碼1：通過統計每一行的結點數：

    public List<List<Integer>> levelOrder(TreeNode root) {

        List<List<Integer>> rt = new ArrayList<List<Integer>>();

        if (root == null) {
            return rt;
        }

        Deque<TreeNode> deque = new LinkedList<TreeNode>();
        deque.add(root);

        int toBePrinted = 1;
        int nextLevel = 0;

        List<Integer> level = new LinkedList<Integer>();

        while (!deque.isEmpty()) {

            TreeNode p = deque.poll();
            level.add(p.val);
            toBePrinted--;

            if (p.left != null) {
                deque.addLast(p.left);
                nextLevel++;
            }

            if (p.right != null) {
                deque.addLast(p.right);
                nextLevel++;
            }

            if (toBePrinted == 0) {
                toBePrinted = nextLevel;
                nextLevel = 0;
                rt.add(new ArrayList<Integer>(level));
                level.clear();
            }

        }

        return rt;
    }

代碼2：插入特殊結點：

    public List<List<Integer>> levelOrder2(TreeNode root) {

        List<List<Integer>> rt = new ArrayList<List<Integer>>();

        if (root == null) {
            return rt;
        }

        final TreeNode END = new TreeNode(0);

        Deque<TreeNode> deque = new LinkedList<TreeNode>();
        List<Integer> level = new LinkedList<Integer>();

        deque.add(root);
        deque.add(END);

        while (!deque.isEmpty()) {

            TreeNode p = deque.pop();

            if (p == END) {
                rt.add(new ArrayList<Integer>(level));
                level.clear();

                if (!deque.isEmpty()) {
                    deque.add(END);
                }
            } else {
                level.add(p.val);

                if (p.left != null) {
                    deque.add(p.left);
                }

                if (p.right != null) {
                    deque.add(p.right);
                }
            }
        }

        return rt;
    }

Binary Tree Level Order Traversal II

Given a binary tree, return the bottom-up level order traversal of its nodes’ values. (ie, from left to right, level by level from leaf to root).

For example:
Given binary tree {3,9,20,#,#,15,7},

return its bottom-up level order traversal as:

[
  [15,7],
  [9,20],
  [3]
]

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

參考：LeetCode 102 Binary Tree Level Order Traversal

只是在返回result前，加入一句話

Collections.reverse(result);

    public List<List<Integer>> levelOrderBottom(TreeNode root) {

        List<List<Integer>> rt = new ArrayList<List<Integer>>();

        if (root == null) {
            return rt;
        }

        final TreeNode END = new TreeNode(0);

        Deque<TreeNode> deque = new LinkedList<TreeNode>();
        List<Integer> level = new LinkedList<Integer>();

        deque.add(root);
        deque.add(END);

        while (!deque.isEmpty()) {

            TreeNode p = deque.pop();

            if (p == END) {
                rt.add(new ArrayList<Integer>(level));
                level.clear();

                if (!deque.isEmpty()) {
                    deque.add(END);
                }
            } else {
                level.add(p.val);

                if (p.left != null) {
                    deque.add(p.left);
                }

                if (p.right != null) {
                    deque.add(p.right);
                }
            }
        }

        Collections.reverse(rt);
        return rt;
    }

Binary Tree Zigzag Level Order Traversal

Given a binary tree, return the zigzag level order traversal of its nodes’ values. (ie, from left to right, then right to left for the next level and alternate between).

For example:
Given binary tree {3,9,20,#,#,15,7},

return its zigzag level order traversal as:

[
  [3],
  [20,9],
  [15,7]
]

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

參考LeetCode 102 Binary Tree Level Order Traversal

只需要加入一個變量，判斷行數，翻轉list即可。

    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {

        List<List<Integer>> rt = new ArrayList<List<Integer>>();

        if (root == null) {
            return rt;
        }

        final TreeNode END = new TreeNode(0);

        Deque<TreeNode> deque = new LinkedList<TreeNode>();
        List<Integer> level = new LinkedList<Integer>();
        int count = 0;

        deque.add(root);
        deque.add(END);

        while (!deque.isEmpty()) {

            TreeNode p = deque.pop();

            if (p == END) {

                if (count % 2 == 1) {
                    Collections.reverse(level);
                }

                count++;

                rt.add(new ArrayList<Integer>(level));
                level.clear();

                if (!deque.isEmpty()) {
                    deque.add(END);
                }
            } else {
                level.add(p.val);

                if (p.left != null) {
                    deque.add(p.left);
                }

                if (p.right != null) {
                    deque.add(p.right);
                }
            }
        }

        return rt;
    }

Course Schedule

There are a total of n courses you have to take, labeled from 0 to n - 1.

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]

Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?

For example:

2, [[1,0]]

There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.

2, [[1,0],[0,1]]

There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.

Note:
The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.

題目等價爲：檢測圖中是否有環

參考網址：LeetCode – Course Schedule (Java)

BFS:

    // BFS
    public static boolean canFinish(int numCourses, int[][] prerequisites) {

        // 參數檢查
        if (prerequisites == null) {
            return false;
        }

        int len = prerequisites.length;
        if (numCourses <= 0 || len == 0) {
            return true;
        }

        // 記錄每個course的prerequisites的數量
        int[] pCounter = new int[numCourses];
        for (int i = 0; i < len; i++) {
            pCounter[prerequisites[i][0]]++;
        }

        // 用隊列記錄可以直接訪問的course
        LinkedList<Integer> queue = new LinkedList<Integer>();
        for (int i = 0; i < numCourses; i++) {
            if (pCounter[i] == 0) {
                queue.add(i);
            }
        }

        // 取出隊列的course，判斷
        int numNoPre = queue.size();
        while (!queue.isEmpty()) {
            int top = queue.remove();
            for (int i = 0; i < len; i++) {
                // 該course是某個course的prerequisites
                if (prerequisites[i][1] == top) {
                    pCounter[prerequisites[i][0]]--;
                    if (pCounter[prerequisites[i][0]] == 0) {
                        numNoPre++;
                        queue.add(prerequisites[i][0]);
                    }
                }
            }
        }

        return numNoPre == numCourses;
    }

DFS:

    // DFS
    public static boolean canFinish2(int numCourses, int[][] prerequisites) {

        // 參數檢查
        if (prerequisites == null) {
            return false;
        }

        int len = prerequisites.length;
        if (numCourses <= 0 || len == 0) {
            return true;
        }

        int[] visit = new int[numCourses];

        // key：course；value：以該course爲prerequisites的course
        HashMap<Integer, ArrayList<Integer>> map = new HashMap<Integer, ArrayList<Integer>>();

        // 初始化map
        for (int[] p : prerequisites) {
            if (map.containsKey(p[1])) {
                map.get(p[1]).add(p[0]);
            } else {
                ArrayList<Integer> l = new ArrayList<Integer>();
                l.add(p[0]);
                map.put(p[1], l);
            }
        }

        // dfs
        for (int i = 0; i < numCourses; i++) {
            if (!canFinishDFS(map, visit, i)) {
                return false;
            }
        }

        return true;
    }

    private static boolean canFinishDFS(
            HashMap<Integer, ArrayList<Integer>> map, int[] visit, int i) {

        if (visit[i] == -1) {
            return false;
        }

        if (visit[i] == 1) {
            return true;
        }

        visit[i] = -1;

        // course i是某些course的prerequisites
        if (map.containsKey(i)) {
            for (int j : map.get(i)) {
                if (!canFinishDFS(map, visit, j)) {
                    return false;
                }
            }
        }

        visit[i] = 1;

        return true;
    }

Course Schedule II

There are a total of n courses you have to take, labeled from 0 to n - 1.

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]

Given the total number of courses and a list of prerequisite pairs, return the ordering of courses you should take to finish all courses.

There may be multiple correct orders, you just need to return one of them. If it is impossible to finish all courses, return an empty array.

For example:

2, [[1,0]]

There are a total of 2 courses to take. To take course 1 you should have finished course 0. So the correct course order is [0,1]

4, [[1,0],[2,0],[3,1],[3,2]]

There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0. So one correct course order is [0,1,2,3]. Another correct ordering is[0,2,1,3].

Note:
The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.

click to show more hints.

Hints:

This problem is equivalent to finding the topological order in a directed graph. If a cycle exists, no topological ordering exists and therefore it will be impossible to take all courses.
Topological Sort via DFS - A great video tutorial (21 minutes) on Coursera explaining the basic concepts of Topological Sort.
Topological sort could also be done via BFS.

參考：LeetCode 207 Course Schedule

只是加了一句話而已，用於保存結果。注意prerequisites爲空的時候，任意輸出一組結果即可。

    public int[] findOrder(int numCourses, int[][] prerequisites) {

        // 參數檢查
        if (prerequisites == null) {
            throw new IllegalArgumentException();
        }

        int len = prerequisites.length;
        if (len == 0) {
            int[] seq = new int[numCourses];
            for (int i = 0; i < seq.length; i++) {
                seq[i] = i;
            }
            return seq;
        }

        int[] seq = new int[numCourses];
        int c = 0;

        // 記錄每個course的prerequisites的數量
        int[] pCounter = new int[numCourses];
        for (int i = 0; i < len; i++) {
            pCounter[prerequisites[i][0]]++;
        }

        // 用隊列記錄可以直接訪問的course
        LinkedList<Integer> queue = new LinkedList<Integer>();
        for (int i = 0; i < numCourses; i++) {
            if (pCounter[i] == 0) {
                queue.add(i);
            }
        }

        // 取出隊列的course，判斷
        int numNoPre = queue.size();
        while (!queue.isEmpty()) {
            int top = queue.remove();
            // 保存結果 +_+
            seq[c++] = top;
            for (int i = 0; i < len; i++) {
                // 該course是某個course的prerequisites
                if (prerequisites[i][1] == top) {
                    pCounter[prerequisites[i][0]]--;
                    if (pCounter[prerequisites[i][0]] == 0) {
                        numNoPre++;
                        queue.add(prerequisites[i][0]);
                    }
                }
            }
        }

        if (numNoPre != numCourses) {
            return new int[] {};
        }

        return seq;
    }

Surrounded Regions

Given a 2D board containing 'X' and 'O', capture all regions surrounded by 'X'.

A region is captured by flipping all 'O's into 'X's in that surrounded region.

For example,

X X X X
X O O X
X X O X
X O X X

After running your function, the board should be:

X X X X
X X X X
X X X X
X O X X

和word search很像，但是應該首先找到沒有被包圍的O。

    static class Point {
        int x;
        int y;

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    HashSet<String> boarderConnected;

    String pointId(int x, int y) {
        return x + "," + y;
    }

    boolean connectIfNotConnected(char[][] board, int x, int y) {

        if (x < 0 || y < 0)
            return false;
        if (x >= board.length || y >= board[0].length)
            return false;

        if (board[x][y] == 'X')
            return false;

        String id = pointId(x, y);
        if (boarderConnected.contains(id))
            return false;

        boarderConnected.add(id);

        return true;
    }

    void connectBoarder(char[][] board, int x, int y) {

        LinkedList<Point> queue = new LinkedList<Point>();

        queue.add(new Point(x, y));

        while (!queue.isEmpty()) {
            Point p = queue.poll();

            if (connectIfNotConnected(board, p.x, p.y)) {

                queue.add(new Point(p.x + 1, p.y));
                queue.add(new Point(p.x - 1, p.y));

                queue.add(new Point(p.x, p.y + 1));
                queue.add(new Point(p.x, p.y - 1));
            }

        }

    }

    public void solve(char[][] board) {

        int mx = board.length;
        if (mx < 3)
            return;

        int my = board[0].length;
        if (my < 3)
            return;

        boarderConnected = new HashSet<String>();

        int x;
        int y;

        for (x = 0; x < mx; x++) {
            connectBoarder(board, x, 0);
            connectBoarder(board, x, my - 1);
        }

        for (y = 0; y < my; y++) {
            connectBoarder(board, 0, y);
            connectBoarder(board, mx - 1, y);
        }

        for (x = 0; x < mx; x++) {
            for (y = 0; y < my; y++) {
                if (board[x][y] == 'O') {
                    if (!boarderConnected.contains(pointId(x, y))) {
                        board[x][y] = 'X';
                    }
                }
            }
        }

    }

LeetCode之Breadth-first Search題目彙總

Binary Tree Level Order Traversal

Binary Tree Level Order Traversal II

Binary Tree Zigzag Level Order Traversal

Course Schedule

Course Schedule II

Surrounded Regions

LeetCode之Depth-first Search題目彙總

LeetCode 300 Longest Increasing Subsequence

LeetCode之Trie題目彙總

LeetCode之Math題目彙總

LeetCode之Array題目彙總

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結