九章算法强化班

Advanced Data Structure -- Union Find

Number of Islands

Given a boolean 2D matrix, 0 is represented as the sea, 1 is represented as the island. If two 1 is adjacent, we consider them in the same island. We only consider up/down/left/right adjacent.

Find the number of islands.

Have you met this question in a real interview? Yes
Example
Given graph:

[
  [1, 1, 0, 0, 0],
  [0, 1, 0, 0, 1],
  [0, 0, 0, 1, 1],
  [0, 0, 0, 0, 0],
  [0, 0, 0, 0, 1]
]
return 3.

 思路I：BFS 避免相同位置的元素重复入列，访问过的元素都要标记为已访问。BFS为了得到下一个点的坐标，所以需要建立一个表示位置的坐标类。

class Coordinate {
    public int x;
    public int y;
    public Coordinate(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    /**
     * @param grid a boolean 2D matrix
     * @return an integer
     */
    public int numIslands(boolean[][] grid) {
        // Write your code here
        if (grid == null || grid.length == 0) {
            return 0;
        }
        int n = grid.length;
        int m = grid[0].length;
        int islands = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j]) {
                    islands++;
                    mark(grid, i, j);
                }
            }
        }
        return islands;
    }
    private void mark(boolean[][] grid, int x, int y) {
        int[] directionX = {1, 0, -1, 0};
        int[] directionY = {0, -1, 0, 1};
        Queue<Coordinate> queue = new LinkedList<>();
        queue.offer(new Coordinate(x, y));
        grid[x][y] = false;
        while (!queue.isEmpty()) {
            Coordinate coordinate = queue.poll();
            for (int i = 0; i < 4; i++) {
                Coordinate adj = new Coordinate(
                                                coordinate.x + directionX[i],
                                                coordinate.y + directionY[i]);
                if (!inBound(adj, grid)) {
                    continue;
                }
                if (grid[adj.x][adj.y]) {
                    grid[adj.x][adj.y] = false;
                    queue.offer(adj);
                }
            }
        }
    }
    private boolean inBound(Coordinate coordinate, boolean[][] grid) {
        int n = grid.length;
        int m = grid[0].length;
        return coordinate.x >= 0 && coordinate.x < n && coordinate.y >= 0 && coordinate.y < m;
    }
}

思路II：并查集 等价于求集合中连通块的个数。

class UnionFind {
    private int[] father = null;
    private int count;
    public UnionFind(int n, int num) {
        father = new int[n];
        count = num;
    }
    public int find(int x) {
        if (father[x] == 0) {
            return x;
        }
        return find(father[x]);
    }
    public void connect(int a, int b) {
        int root_a = find(a);
        int root_b = find(b);
        if (root_a != root_b) {
            father[root_a] = root_b;
            count--;
        }
    }
    public int query() {
        return count;
    }
}
public class Solution {
    /**
     * @param grid a boolean 2D matrix
     * @return an integer
     */
    public int numIslands(boolean[][] grid) {
        // Write your code here
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return 0;
        }
        int n = grid.length;
        int m = grid[0].length;
        int count = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j]) {
                    count++;
                }
            }
        }
        UnionFind union_find = new UnionFind(n * m, count);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (grid[i][j]) {
                    if (i > 0 && grid[i - 1][j]) {
                        union_find.connect(i * m + j, (i - 1) * m + j);
                    }
                    if (i < n - 1 && grid[i + 1][j]) {
                        union_find.connect(i * m + j, (i + 1) * m + j);
                    }
                    if (j > 0 && grid[i][j - 1]) {
                        union_find.connect(i * m + j, i * m + j - 1);
                    }
                    if (j < m - 1 && grid[i][j + 1]) {
                        union_find.connect(i * m + j, i * m + j + 1);
                    }
                }
            }
        }
        return union_find.query();
    }
}

 

Number of Islands II

Given a n,m which means the row and column of the 2D matrix and an array of pair A( size k). Originally, the 2D matrix is all 0 which means there is only sea in the matrix. The list pair has k operator and each operator has two integer A[i].x, A[i].y means that you can change the grid matrix[A[i].x][A[i].y] from sea to island. Return how many island are there in the matrix after each operator.

 Notice

0 is represented as the sea, 1 is represented as the island. If two 1 is adjacent, we consider them in the same island. We only consider up/down/left/right adjacent.

Have you met this question in a real interview? Yes
Example
Given n = 3, m = 3, array of pair A = [(0,0),(0,1),(2,2),(2,1)].

return [1,1,2,2].

思路：并查集，把二维数组转化为一维father数组。

/**
 * Definition for a point.
 * class Point {
 *     int x;
 *     int y;
 *     Point() { x = 0; y = 0; }
 *     Point(int a, int b) { x = a; y = b; }
 * }
 */
class UnionFind {
    private int[] father = null;
    private int count;
    public UnionFind(int n, int num) {
        father = new int[n];
        for (int i = 0; i < n; i++) {
            father[i] = i;
        }
        count = num;
    }
    public int find(int x) {
        if (father[x] == x) {
            return x;
        }
        return father[x] = find(father[x]);
    }
    public void connect(int a, int b) {
        int root_a = find(a);
        int root_b = find(b);
        if (root_a != root_b) {
            father[root_a] = root_b;
            count--;
        }
    }
    public int query() {
        return count;
    }
    public void setCount() {
        count++;
    }
}
public class Solution {
    /**
     * @param n an integer
     * @param m an integer
     * @param operators an array of point
     * @return an integer array
     */
    public List<Integer> numIslands2(int n, int m, Point[] operators) {
        // Write your code here
        List<Integer> result = new ArrayList<>();
        if (n < 1 || m < 1 || operators == null || operators.length == 0) {
            return result;
        }
        int[][] island = new int[n][m];
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        UnionFind union_find = new UnionFind(n * m, 0);
        for (int i = 0; i < operators.length; i++) {
            Point point = operators[i];
            if (island[point.x][point.y] == 1) {
                result.add(union_find.query());
                continue;
            }
            union_find.setCount();
            island[point.x][point.y] = 1;
            for (int j = 0; j < 4; j++) {
                Point nextPoint = new Point(point.x + dx[j], point.y + dy[j]);
                if (inBound(nextPoint, n, m)
                    && island[nextPoint.x][nextPoint.y] == 1) {
                    union_find.connect(point.x * m + point.y, nextPoint.x * m + nextPoint.y);       
                }
            }
            result.add(union_find.query());
        }
        return result;
    }
    public boolean inBound(Point point, int n, int m) {
        if (point.x < 0 || point.x >= n) {
            return false;
        }
        if (point.y < 0 || point.y >= m) {
            return false;
        }
        return true;
    }
}

 

LeetCode 547. Friend Circles

There are N students in a class. Some of them are friends, while some are not. Their friendship is transitive in nature. For example, if A is a direct friend of B, and B is a direct friend of C, then A is an indirect friend of C. And we defined a friend circle is a group of students who are direct or indirect friends.

Given a N*N matrix M representing the friend relationship between students in the class. If M[i][j] = 1, then the ith and jth students are direct friends with each other, otherwise not. And you have to output the total number of friend circles among all the students.

Example 1:
Input: 
[[1,1,0],
 [1,1,0],
 [0,0,1]]
Output: 2
Explanation:The 0th and 1st students are direct friends, so they are in a friend circle. 
The 2nd student himself is in a friend circle. So return 2.
Example 2:
Input: 
[[1,1,0],
 [1,1,1],
 [0,1,1]]
Output: 1
Explanation:The 0th and 1st students are direct friends, the 1st and 2nd students are direct friends, 
so the 0th and 2nd students are indirect friends. All of them are in the same friend circle, so return 1.
Note:
N is in range [1,200].
M[i][i] = 1 for all students.
If M[i][j] = 1, then M[j][i] = 1.

思路：并查集的典型应用。题目是求朋友圈的个数，求将这n个人看成n个节点，等价于求连通块的个数。

class UnionFind {
    private int[] father;
    private int count;
    public UnionFind(int n) {
        father = new int[n];
        for (int i = 0; i < father.length; i++) {
            father[i] = i;
        }
        count = n;
    }
    public int find(int x) {
        if (father[x] == x) {
            return x;
        }
        return father[x] = find(father[x]);
    }
    public void union(int a, int b) {
        int root_a = find(a);
        int root_b = find(b);
        if (root_a != root_b) {
            father[root_a] = root_b;
            count--;
        }
    }
    public int getCount() {
        return count;
    }
}
public class Solution {
    public int findCircleNum(int[][] M) {
        if (M == null || M.length == 0 || M[0].length == 0) {
            return 0;
        }
        int n = M.length;
        UnionFind union_find = new UnionFind(n);
        for (int i = 0; i < n - 1; i++) {
            for (int j = i + 1; j < n; j++) {
                if (M[i][j] == 1) {
                    union_find.union(i, j);
                }
            }
        }
        return union_find.getCount();
    }
}

 

Graph Valid Tree

Given n nodes labeled from 0 to n - 1 and a list of undirected edges (each edge is a pair of nodes), write a function to check whether these edges make up a valid tree.

 Notice

You can assume that no duplicate edges will appear in edges. Since all edges are undirected, [0, 1] is the same as [1, 0] and thus will not appear together in edges.

Have you met this question in a real interview? Yes
Example
Given n = 5 and edges = [[0, 1], [0, 2], [0, 3], [1, 4]], return true.

Given n = 5 and edges = [[0, 1], [1, 2], [2, 3], [1, 3], [1, 4]], return false.

思路I：BFS  最后判断连通的节点个数是否为n。

public class Solution {
    /**
     * @param n an integer
     * @param edges a list of undirected edges
     * @return true if it's a valid tree, or false
     */
    public boolean validTree(int n, int[][] edges) {
        // Write your code here
        if (n == 0) {
            return false;
        }
        if (edges.length != n - 1) {
            return false;
        }
        Map<Integer, Set<Integer>> graph =
            initializeGraph(n, edges);
        Queue<Integer> queue = new LinkedList<>();
        Set<Integer> hash = new HashSet<>();
        queue.offer(0);
        hash.add(0);
        int visited = 0;
        while (!queue.isEmpty()) {
            int node = queue.poll();
            visited++;
            for (Integer neighbor : graph.get(node)) {
                if (hash.contains(neighbor)) {
                    continue;
                }
                queue.offer(neighbor);
                hash.add(neighbor);
            }
        }
        return visited == n;
    }
    public Map<Integer, Set<Integer>> initializeGraph(int n, int[][] edges) {
        Map<Integer, Set<Integer>> graph = new HashMap<>();
        for (int i = 0; i < n; i++) {
            graph.put(i, new HashSet<Integer>());
        }
        for (int i = 0; i < edges.length; i++) {
            int u = edges[i][0];
            int v = edges[i][1];
            graph.get(u).add(v);
            graph.get(v).add(u);
        }
        return graph;
    }
}

思路II：并查集  判断n - 1条边是否构成环，即判断是否有两个点的father一样。

class UnionFind {
    private int[] father = null;
    public UnionFind(int n) {
        father = new int[n];
        for (int i = 0; i < n; i++) {
            father[i] = i;
        }
    }
    public int find(int x) {
        if (father[x] == x) {
            return x;
        }
        return father[x] = find(father[x]);
    }
    public void union(int a, int b) {
        int root_a = find(a);
        int root_b = find(b);
        if (root_a != root_b) {
            father[root_a] = root_b;
        }
    }
}
public class Solution {
    /**
     * @param n an integer
     * @param edges a list of undirected edges
     * @return true if it's a valid tree, or false
     */
    public boolean validTree(int n, int[][] edges) {
        // Write your code here
        if (n < 1) {
            return false;
        }
        if ((edges == null || edges.length == 0 || edges[0].length == 0) && n != 1) {
            return false;
        }
        if (n - 1 != edges.length) {
            return false;
        }
        UnionFind union_find = new UnionFind(n);
        for (int i = 0; i < edges.length; i++) {
            if (union_find.find(edges[i][0]) == union_find.find(edges[i][1])) {
                return false;
            }
            union_find.union(edges[i][0], edges[i][1]);
        }
        return true;
    }
}

 

Surrounded Reigions

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.

Have you met this question in a real interview? Yes
Example
X X X X
X O O X
X X O X
X O X X
After capture all regions surrounded by 'X', the board should be:

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

思路I：BFS  BFS二位矩阵的四周，讲从外向内的字符O都标记为字符V代表已访问过的字符O，然后依次便利整个二位矩阵，字符为O的都是除了四周的里面的O，将它置为字符X，为V的字符还原成原来的字符O。

class Node {
    int x;
    int y;
    public Node(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    private static final char visited = 'V';
    /**
     * @param board a 2D board containing 'X' and 'O'
     * @return void
     */
    public void surroundedRegions(char[][] board) {
        // Write your code here
        if (board == null || board.length == 0 || board[0].length == 0) {
            return;
        }
        int n = board.length;
        int m = board[0].length;
        for (int i = 0; i < n; i++) {
            bfs(board, i, 0);
            bfs(board, i, m - 1);
        }
        for (int i = 0; i < m; i++) {
            bfs(board, 0, i);
            bfs(board, n - 1, i);
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (board[i][j] == visited) {
                    board[i][j] = 'O';
                } else if (board[i][j] == 'O') {
                    board[i][j] = 'X';
                }
            }
        }
        return;
    }
    public void bfs(char[][] board, int i, int j) {
        if (board[i][j] != 'O') {
            return;
        }
        Queue<Node> queue = new LinkedList<>();
        queue.offer(new Node(i, j));
        board[i][j] = visited;
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            for (int k = 0; k < 4; k++) {
                Node nextNode = new Node(node.x + dx[k], node.y + dy[k]);
                if (inBound(nextNode, board) && board[nextNode.x][nextNode.y] == 'O') {
                    queue.offer(nextNode);
                    board[nextNode.x][nextNode.y] = visited;
                }
            }
        }
    }
    public boolean inBound(Node node, char[][] board) {
        int n = board.length;
        int m = board[0].length;
        if (node.x < 0 || node.x >= n) {
            return false;
        }
        if (node.y < 0 || node.y >= m) {
            return false;
        }
        return true;
    }
}

 思路II：并查集 建立一个n * m的dummy node，遍历二维数组，边上的为字符O的直接合并到dummy node, 在里面的字符为O的根据情况合并，如果该字符与相邻字符O的parent一样就不合并，如果不一样分两种情况，如果该字符的parent为dummy node就将相邻字符O合并到该字符的parent，否则将该字符的parent合并到相邻字符O的parent。最后再遍历一次二维数组，字符为O并且该字符的parent不是dummy node就将该字符置为字符X。也就是说，不能被包围的字符O的parent都是dummy node，能被包围的字符O的parent都不是dummy node。

class UnionFind {
    int[] parent;
    public UnionFind(int n) {
        parent = new int[n];
        for (int i = 0; i < n; i++) {
            parent[i] = i;
        }
    }
    public int find(int x) {
        if (parent[x] == x) {
            return x;
        }
        parent[x] = find(parent[x]);
        return parent[x];
    }
    public void union(int a, int b) {
        int root_a = find(a);
        int root_b = find(b);
        if (root_a != root_b) {
            if (root_a == parent.length - 1) {
                parent[root_b] = root_a;
            } else {
                parent[root_a] = root_b;
            }
        }
    }
}
public class Solution {
    public void solve(char[][] board) {
        if (board == null || board.length == 0 || board[0].length == 0) {
            return;
        }
        int n = board.length;
        int m = board[0].length;
        UnionFind uf = new UnionFind(n * m + 1);
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (board[i][j] == 'X') {
                    continue;
                }
                if (i == 0 || i == n - 1 || j == 0 || j == m - 1) {
                    uf.union(i * m + j, n * m);
                } else {
                    if (board[i - 1][j] == 'O') {
                        uf.union(i * m + j, (i - 1) * m + j);
                    }
                    if (board[i + 1][j] == 'O') {
                        uf.union(i * m + j, (i + 1) * m + j);
                    }
                    if (board[i][j - 1] == 'O') {
                        uf.union(i * m + j, i * m + j - 1);
                    }
                    if (board[i][j + 1] == 'O') {
                        uf.union(i * m + j, i * m + j + 1);
                    }
                }
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (board[i][j] == 'X' || uf.find(i * m + j) == n * m) {
                    continue;
                }
                board[i][j] = 'X';
            }
        }
    }
}

 

Advanced Data Structure -- Trie 

Implement Trie

Implement a trie with insert, search, and startsWith methods.

 Notice

You may assume that all inputs are consist of lowercase letters a-z.

Have you met this question in a real interview? Yes
Example
insert("lintcode")
search("code")
>>> false
startsWith("lint")
>>> true
startsWith("linterror")
>>> false
insert("linterror")
search("lintcode)
>>> true
startsWith("linterror")
>>> true

思路：trie树的插入，查找，前最匹配。需要注意一点的就是存储子节点的HashMap不能再构造方法里初始化，而是要在定义的时候直接初始化，这是为了覆盖dummy root的HashMap子节点情况。

/**
 * Your Trie object will be instantiated and called as such:
 * Trie trie = new Trie();
 * trie.insert("lintcode");
 * trie.search("lint"); will return false
 * trie.startsWith("lint"); will return true
 */
class TrieNode {
    char c;
    Map<Character, TrieNode> children = new HashMap<>();
    boolean hasWord;
    // Initialize your data structure here.
    public TrieNode() {
    }
    public TrieNode(char c) {
        this.c = c;
    }
}

public class Trie {
    private TrieNode root;

    public Trie() {
        root = new TrieNode();
    }

    // Inserts a word into the trie.
    public void insert(String word) {
        TrieNode cur = root;
        char[] wordArray = word.toCharArray();
        for (int i = 0; i < wordArray.length; i++) {
            char temp = wordArray[i];
            if (cur.children.containsKey(temp)) {
                cur = cur.children.get(temp);
            } else {
                TrieNode newNode = new TrieNode(temp);
                cur.children.put(temp, newNode);
                cur = newNode;
            }
            if (i == wordArray.length - 1) {
                cur.hasWord = true;
            }
        }
    }

    // Returns if the word is in the trie.
    public boolean search(String word) {
        TrieNode node = searchWordNodePos(word);
        if (node == null) {
            return false;
        }
        if (node.hasWord) {
            return true;
        }
        return false;
    }

    // Returns if there is any word in the trie
    // that starts with the given prefix.
    public boolean startsWith(String prefix) {
        if (searchWordNodePos(prefix) == null) {
            return false;
        }
        return true;
    }
    public TrieNode searchWordNodePos(String s) {
        TrieNode cur = root;
        char[] sArray = s.toCharArray();
        for (int i = 0; i < sArray.length; i++) {
            char temp = sArray[i];
            if (!cur.children.containsKey(temp)) {
                return null;
            }
            cur = cur.children.get(temp);
        }
        return cur;
    }
}

 

Add and Search Word

Design a data structure that supports the following two operations: addWord(word) and search(word)

search(word) can search a literal word or a regular expression string containing only letters a-z or ..

A . means it can represent any one letter.

 Notice

You may assume that all words are consist of lowercase letters a-z.

Have you met this question in a real interview? Yes
Example
addWord("bad")
addWord("dad")
addWord("mad")
search("pad")  // return false
search("bad")  // return true
search(".ad")  // return true
search("b..")  // return true

思路：类似上题，trie树的添加可以更加简化。查找单词要递归。

class TrieNode {
    Map<Character, TrieNode> children;
    boolean hasWord;
    public TrieNode() {
        children = new HashMap<>();
        hasWord = false;
    }
}
public class WordDictionary {
    TrieNode root;
    public WordDictionary() {
        root = new TrieNode();
    }
    // Adds a word into the data structure.
    public void addWord(String word) {
        // Write your code here
        TrieNode cur = root;
        char[] wordArray = word.toCharArray();
        for (int i = 0; i < wordArray.length; i++) {
            char temp = wordArray[i];
            if (!cur.children.containsKey(temp)) {
                cur.children.put(temp, new TrieNode());
            }
            cur = cur.children.get(temp);
        }
        cur.hasWord = true;
    }

    // Returns if the word is in the data structure. A word could
    // contain the dot character '.' to represent any one letter.
    public boolean search(String word) {
        // Write your code here
        return find(word, 0, root);
    }
    public boolean find(String word, int index, TrieNode cur) {
        if (index == word.length()) {
            return cur.hasWord;
        }
        char c = word.charAt(index);
        if (cur.children.containsKey(c)) {
            return find(word, index + 1, cur.children.get(c));
        } else if (c == '.') {
            for (char temp : cur.children.keySet()) {
                if (find(word, index + 1, cur.children.get(temp))) {
                    return true;
                }
            }
            return false;
        } else {
            return false;
        }
    }
}

// Your WordDictionary object will be instantiated and called as such:
// WordDictionary wordDictionary = new WordDictionary();
// wordDictionary.addWord("word");
// wordDictionary.search("pattern");

 

Word Search

Given a 2D board and a word, find if the word exists in the grid.

The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or vertically neighboring. The same letter cell may not be used more than once.

Have you met this question in a real interview? Yes
Example
Given board =

[
  "ABCE",
  "SFCS",
  "ADEE"
]
word = "ABCCED", -> returns true,
word = "SEE", -> returns true,
word = "ABCB", -> returns false.

思路：DFS 记得dfs的过程中把访问过的字符标记称某一特殊字符来表示访问过这一字符，避免重复访问。

time：O(n*m*4^len)　　space：O(len) + O(n*m)

public class Solution {
    /**
     * @param board: A list of lists of character
     * @param word: A string
     * @return: A boolean
     */
    public boolean exist(char[][] board, String word) {
        // write your code here
        if (board == null || board.length == 0 || board[0].length == 0) {
            return false;
        }
        if (word == null || word.length() == 0) {
            return true;
        }
        int n = board.length;
        int m = board[0].length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (board[i][j] == word.charAt(0)) {
                    boolean flag = dfsHelper(board, i, j, word, 0);
                    if (flag) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
    public boolean dfsHelper(char[][] board, int i, int j, String word, int start) {
        if (start == word.length()) {
            return true;
        }
        int n = board.length;
        int m = board[0].length;
        if (i < 0 || i >= n || j < 0 || j >= m) {
            return false;
        }
        if (board[i][j] != word.charAt(start)) {
            return false;
        }
        board[i][j] = '#';
        boolean flag = dfsHelper(board, i + 1, j, word, start + 1)
            || dfsHelper(board, i - 1, j, word, start + 1)
            || dfsHelper(board, i, j + 1, word, start + 1)
            || dfsHelper(board, i, j - 1, word, start + 1);
        board[i][j] = word.charAt(start);
        return flag;
    }
}

 

Word Search II

Given a matrix of lower alphabets and a dictionary. Find all words in the dictionary that can be found in the matrix. A word can start from any position in the matrix and go left/right/up/down to the adjacent position. 


Have you met this question in a real interview? Yes
Example
Given matrix:
doaf
agai
dcan
and dictionary:
{"dog", "dad", "dgdg", "can", "again"}

return {"dog", "dad", "can", "again"}

思路：1. 把字典建成Trie树。2. 用dfs的方法遍历矩阵，同时在Trie上搜索前缀是否存在。 3. 查询所有Trie里面有可能出现的字符。 注意找到string之后还要继续往下低轨而不是return，因为下面也可能有要找的string。同时TrieNode中多了一个字符串s来代表从根走到当前位置的字符串，也就是插入的字符串。

class TrieNode {
    Map<Character, TrieNode> children;
    boolean hasWord;
    String s;
    public TrieNode() {
        children = new HashMap<>();
        hasWord = false;
        s = "";
    }
}
class TrieTree {
    TrieNode root;
    public TrieTree() {
        root = new TrieNode();
    }
    public void insert(String word) {
        TrieNode cur = root;
        char[] wordArray = word.toCharArray();
        for (int i = 0; i < wordArray.length; i++) {
            char temp = wordArray[i];
            if (!cur.children.containsKey(temp)) {
                TrieNode newNode = new TrieNode();
                cur.children.put(temp, new TrieNode());
            }
            cur = cur.children.get(temp);
        }
        cur.s = word;
        cur.hasWord = true;
    }
}
public class Solution {
    /**
     * @param board: A list of lists of character
     * @param words: A list of string
     * @return: A list of string
     */
    public ArrayList<String> wordSearchII(char[][] board, ArrayList<String> words) {
        // write your code here
        ArrayList<String> result = new ArrayList<>();
        if (board == null || board.length == 0 || board[0].length == 0) {
            return result;
        }
        if (words == null || words.size() == 0) {
            return result;
        }
        TrieTree tree = new TrieTree();
        for (String word : words) {
            tree.insert(word);
        }
        int n = board.length;
        int m = board[0].length;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                search(board, i, j, tree.root, result);
            }
        }
        return result;
    }
    public void search(char[][] board, int i, int j, TrieNode root,
        ArrayList<String> result) {
        if (root.hasWord) {
            if (!result.contains(root.s)) {
                result.add(root.s);
            }
            //注意此处不能return！！！比如字典里有"se"和"see"
        }
        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length) {
            return;
        }
        if (!root.children.containsKey(board[i][j])) {
            return;
        }
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0, -1};
        for (int k = 0; k < 4; k++) {
            char temp = board[i][j];
            board[i][j] = '#';
            search(board, i + dx[k], j + dy[k], root.children.get(temp), result);
            board[i][j] = temp;
        }
    }
}

 

Word Squares

Given a set of words without duplicates, find all word squares you can build from them.

A sequence of words forms a valid word square if the kth row and column read the exact same string, where 0 ≤ k < max(numRows, numColumns).

For example, the word sequence ["ball","area","lead","lady"] forms a word square because each word reads the same both horizontally and vertically.

b a l l
a r e a
l e a d
l a d y
 Notice

There are at least 1 and at most 1000 words.
All words will have the exact same length.
Word length is at least 1 and at most 5.
Each word contains only lowercase English alphabet a-z.
Have you met this question in a real interview? Yes
Example
Given a set ["area","lead","wall","lady","ball"]
return [["wall","area","lead","lady"],["ball","area","lead","lady"]]
Explanation:
The output consists of two word squares. The order of output does not matter (just the order of words in each word square matters).

Given a set ["abat","baba","atan","atal"]
return [["baba","abat","baba","atan"],["baba","abat","baba","atal"]]
Explanation:
The output consists of two word squares. The order of output does not matter (just the order of words in each word square matters).

 思路：Trie + DFS。先构建trie，新增一个List<String> startWith属性表示包含以当前字符结尾的前缀的所有单词的集合。然后DFS遍历，注意下一个可能构成word squares的单词的前缀是由前面的单词严格限制的，也就是说下一个单子的前缀是固定的，在trie中找到包含这个前缀的所有可能的单词（startWith），对这些单词进行下一轮DFS。

class TrieNode {
    Map<Character, TrieNode> children;
    List<String> startWith;
    public TrieNode() {
        children = new HashMap<>();
        startWith = new ArrayList<>();
    }
}
class Trie {
    TrieNode root;
    public Trie() {
        root = new TrieNode();
    }
    public void insert(String word) {
        TrieNode cur = root;
        char[] wordArray = word.toCharArray();
        for (char c : wordArray) {
            if (!cur.children.containsKey(c)) {
                cur.children.put(c, new TrieNode());
            }
            cur.children.get(c).startWith.add(word);
            cur = cur.children.get(c);
        }
    }
    public List<String> findByPrefix(String prefix) {
        TrieNode cur = root;
        char[] prefixArray = prefix.toCharArray();
        for (char c : prefixArray) {
            if (!cur.children.containsKey(c)) {
                return new ArrayList<String>();
            }
            cur = cur.children.get(c);
        }
        return cur.startWith;
    }
}
public class Solution {
    /**
     * @param words a set of words without duplicates
     * @return all word squares
     */
    public List<List<String>> wordSquares(String[] words) {
        // Write your code here
        List<List<String>> results = new ArrayList<>();
        if (words == null || words.length == 0) {
            return results;
        }
        int n = words[0].length();
        Trie trie = new Trie();
        for (String word : words) {
            trie.insert(word);
        }
        List<String> tempList = new ArrayList<>();
        for (String word : words) {
            tempList.add(word);
            search(trie, tempList, n, results);
            tempList.remove(tempList.size() - 1);
        }
        return results;
    }
    public void search(Trie trie, List<String> tempList, int n,
                       List<List<String>> results) {
        if (tempList.size() == n) {
            results.add(new ArrayList<>(tempList));
            return;
        }
        StringBuilder sb = new StringBuilder();
        int index = tempList.size();
        for (String word : tempList) {
            sb.append(word.charAt(index));
        }
        List<String> startWith = trie.findByPrefix(sb.toString());
        for (String sw : startWith) {
            tempList.add(sw);
            search(trie, tempList, n, results);
            tempList.remove(tempList.size() - 1);
        }
    }
}

  

Boggle Game

Given a board which is a 2D matrix includes a-z and dictionary dict, find the largest collection of words on the board, the words can not overlap in the same position. return the size of largest collection.

Have you met this question in a real interview? Yes
Example
Give a board below

[['a', 'b', 'c'],
 ['d', 'e', 'f'],
 ['g', 'h', 'i']]
dict = ["abc", "cfi", "beh", "defi", "gh"]
Return 3 // we can get the largest collection["abc", "defi", "gh"]

思路：trie + DFS 不得不说这道题真的难，搞了半天。

class TrieNode {
    Map<Character, TrieNode> children;
    boolean isWord;
    public TrieNode() {
        children = new HashMap<>();
        isWord = false;
    }
}
class Trie {
    TrieNode root;
    public Trie() {
        root = new TrieNode();
    }
    public void insert(String word) {
        TrieNode cur = root;
        char[] wordArray = word.toCharArray();
        for (char c : wordArray) {
            if (!cur.children.containsKey(c)) {
                cur.children.put(c, new TrieNode());
            }
            cur = cur.children.get(c);
        }
        cur.isWord = true;
    }
}
class Point {
    int x;
    int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}
public class Solution {
    /**
     * @param board a list of lists of character
     * @param words a list of string
     * @return an integer
     */
    int max = 0;
    int n = 0;
    int m = 0;
    TrieNode globalRoot;
    int[] dx = {1, 0, -1, 0};
    int[] dy = {0, 1, 0, -1};
    public int boggleGame(char[][] board, String[] words) {
        // Write your code here
        if (board == null || board.length == 0 || board[0].length == 0
            || words == null || words.length == 0) {
            return 0;
        }
        n = board.length;
        m = board[0].length;
        Trie trie = new Trie();
        globalRoot = trie.root;
        for (String word : words) {
            trie.insert(word);
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (trie.root.children.containsKey(board[i][j])) {
                    boolean[][] visited = new boolean[n][m];
                    visited[i][j] = true;
                    dfsHelper(board, i, j, trie.root.children.get(board[i][j]), visited, 0);
                    if (max == n * m) {
                        break;
                    }
                }
            }
        }
        return max;
    }
    public void dfsHelper(char[][] board, int x, int y, TrieNode cur, boolean[][] visited, int count) {
        if (cur.isWord) {
            count++;
            max = Math.max(max, count);
            List<Point> visitedPoint = new ArrayList<>();
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    if (!visited[i][j]
                        && globalRoot.children.containsKey(board[i][j])) {
                        visited[i][j] = true;
                        visitedPoint.add(new Point(i, j));
                        dfsHelper(board, i, j,
                        globalRoot.children.get(board[i][j]), visited, count);
                    }
                }
            }
            for (Point point : visitedPoint) {
                visited[point.x][point.y] = false;
            }
        } else {
            for (int k = 0; k < 4; k++) {
                int next_x = x + dx[k];
                int next_y = y + dy[k];
                if (validPoint(next_x, next_y) && !visited[next_x][next_y]
                    && cur.children.containsKey(board[next_x][next_y])) {
                    visited[next_x][next_y] = true;
                    dfsHelper(board, next_x, next_y,
                    cur.children.get(board[next_x][next_y]), visited, count);
                    visited[next_x][next_y] = false;
                }
            }
        }
    }
    public boolean validPoint(int x, int y) {
        return x >= 0 && x < n && y >= 0 && y < m;
    }
}

 

 

139. Word Break

Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, determine if s can be segmented into a space-separated sequence of one or more dictionary words. You may assume the dictionary does not contain duplicate words.

For example, given
s = "leetcode",
dict = ["leet", "code"].

Return true because "leetcode" can be segmented as "leet code".

UPDATE (2017/1/4):
The wordDict parameter had been changed to a list of strings (instead of a set of strings). Please reload the code definition to get the latest changes.

思路：DP 两种DP方法，第一种是j从0遍历到i- 1，时间复杂度O（len^2）,len为字符串s的长度。适用于字典大，s短的情况。

public class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        if (s == null || s.length() == 0) {
            return false;
        }
        if (wordDict == null || wordDict.size() == 0) {
            return false;
        }
        // 1.状态定义
        boolean[] canSegment = new boolean[s.length() + 1];
        // 2.初始化
        canSegment[0] = true;
        // 3.循环递归求解
        for (int i = 0; i < s.length() + 1; i++) {
            for (int j = 0; j < i; j++) {
                if (!canSegment[j]) {
                    continue;
                }
                if (wordDict.contains(s.substring(j, i))) {
                    canSegment[i] = true;
                    break;
                }
            }
        }
        // 4. 求结果
        return canSegment[s.length()];
    }
}

 　　  第二种是遍历字典中的每个单词的长度，如果canSegment[i - word.length()] == true && s.substring(i - word.length(), i).equals(当前遍历的单词)，那么canSegment[i]为true。时间复杂度O(len * size),len为字符串s的长度，size为字典的大小。适用于字典小，s大的情况。而且本题中字典为list而不是set，判断list是否含有某个元素的contains方法时间复杂度是O(size)的不是O(1)，所以建议使用第二种方法。

public class Solution {
    public boolean wordBreak(String s, List<String> wordDict) {
        if (s == null || s.length() == 0) {
            return false;
        }
        if (wordDict == null || wordDict.size() == 0) {
            return false;
        }
        // 1.状态定义
        boolean[] canSegment = new boolean[s.length() + 1];
        // 2.初始化
        canSegment[0] = true;
        // 3.循环递归求解
        for (int i = 0; i < s.length() + 1; i++) {
            for (String word : wordDict) {
                if (i - word.length() < 0 || !canSegment[i - word.length()]) {
                    continue;
                }
                if (s.substring(i - word.length(), i).equals(word)) {
                    canSegment[i] = true;
                    break;
                }
            }
        }
        // 4. 求结果
        return canSegment[s.length()];
    }
}

 

140. Word Break II

Given a non-empty string s and a dictionary wordDict containing a list of non-empty words, add spaces in s to construct a sentence where each word is a valid dictionary word. You may assume the dictionary does not contain duplicate words.

Return all such possible sentences.

For example, given
s = "catsanddog",
dict = ["cat", "cats", "and", "sand", "dog"].

A solution is ["cats and dog", "cat sand dog"].

UPDATE (2017/1/4):
The wordDict parameter had been changed to a list of strings (instead of a set of strings). Please reload the code definition to get the latest changes.

思路：和上一题不同的是，这道题要返回所有可能的组合。所以现在dp[i]里面应该存可以使长度为i所有可能的String里的最后一个word。dp有两种写法，一个就是直接写成数组：List[]的形式，不能形成的dp[i] = null。还有一个是用个hashmap：Map<Integer, List>，用hashmap的好处是如果s很长而且用dict能组合成的长度不是很多的话，map用的空间相对少。dp结束之后，第二步就是通过dp里面保存的word，一步一步回溯找到所有结果。

public class Solution {
    public List<String> wordBreak(String s, List<String> wordDict) {
        List<String> result = new ArrayList<>();
        if (s == null || s.length() == 0 || wordDict == null || wordDict.size() == 0) {
            return result;
        }
        Map<Integer, List<String>> dp = new HashMap<>();
        dp.put(0, new ArrayList<>());
        for (int i = 0; i <= s.length(); i++) {
            for (String word : wordDict) {
                int j = i - word.length();
                if (j < 0 || !dp.containsKey(j)) {
                    continue;
                }
                if (s.substring(j, i).equals(word)) {
                    if (!dp.containsKey(i)) {
                        dp.put(i, new ArrayList<>());
                    }
                    dp.get(i).add(word);
                }
            }
        }
        if (!dp.containsKey(s.length())) {
            return result;
        }
        dfsHelper(dp, s.length(), "", result);
        return result;
    }
    public void dfsHelper(Map<Integer, List<String>> dp, int startIndex, String path, List<String> result) {
        if (startIndex == 0) {
            result.add(path);
            return;
        }
        for (String word : dp.get(startIndex)) {
            dfsHelper(dp, startIndex - word.length(), word + (path.equals("") ? "" : " " + path), result);
        }
    }
}

 

472. Concatenated Words

Given a list of words (without duplicates), please write a program that returns all concatenated words in the given list of words.

A concatenated word is defined as a string that is comprised entirely of at least two shorter words in the given array.

Example:
Input: ["cat","cats","catsdogcats","dog","dogcatsdog","hippopotamuses","rat","ratcatdogcat"]

Output: ["catsdogcats","dogcatsdog","ratcatdogcat"]

Explanation: "catsdogcats" can be concatenated by "cats", "dog" and "cats"; 
 "dogcatsdog" can be concatenated by "dog", "cats" and "dog"; 
"ratcatdogcat" can be concatenated by "rat", "cat", "dog" and "cat".
Note:
The number of elements of the given array will not exceed 10,000
The length sum of elements in the given array will not exceed 600,000.
All the input string will only include lower case letters.
The returned elements order does not matter.

思路I：DP 常规思路是遍历数组中的每一个单词，然后对该单词，查看该单词是否能右数组中剩余的元素组成，这样做时间复杂度过高。需要进行优化，一个单词要想被其他词组成，其他词的长度必然小于这个词的长度，于是先对数组按各单词长度进行从小到大排序，然后每次遍历过程中，用一个set来存储比当前单词长度小的单词，也就是说set存储的是能组成当前单词的候选单词，在遍历过程中如果当前单词能由set里的单词组成（这个过程借用Word Break这道题的DP思路），就把当前单词加入到结果中。最后循环结束就可以返回结果了。

public class Solution {
    public List<String> findAllConcatenatedWordsInADict(String[] words) {
        List<String> result = new ArrayList<>();
        if (words == null || words.length < 3) {
            return result;
        }
        Arrays.sort(words, new Comparator<String>() {
            public int compare(String a, String b) {
                return a.length() - b.length();
            }
        });
        Set<String> set = new HashSet<>();
        for (int i = 0; i < words.length; i++) {
            if (wordBreak(words[i], set)) {
                result.add(words[i]);
            }
            set.add(words[i]);
        }
        return result;
    }
    public boolean wordBreak(String word, Set<String> set) {
        if (set.isEmpty() || set.size() == 0) {
            return false;
        }
        // 递归四要素
        // 1.状态定义
        boolean[] canSegment = new boolean[word.length() + 1];
        // 2.初始化
        canSegment[0] = true;
        // 3.循环递归求解
        for (int i = 1; i < canSegment.length; i++) {
            for (int j = 0; j < i; j++) {
                if (!canSegment[j]) {
                    continue;
                }
                if (set.contains(word.substring(j, i))) {
                    canSegment[i] = true;
                    break;
                }
            }
        }
        // 4.求结果
        return canSegment[word.length()];
    }
}

 思路II：trie Trie 先将各个单词插入到Trie树，然后对每个单词，判断它是否能由其他单词组成。

class TrieNode {
    Map<Character, TrieNode> children;
    boolean hasWord;
    public TrieNode() {
        children = new HashMap<>();
        hasWord = false;
    }
}
class Trie {
    TrieNode root;
    public Trie() {
        root = new TrieNode();
    }
    public void insert(String word) {
        char[] wordArray = word.toCharArray();
        TrieNode cur = root;
        for (int i = 0; i < wordArray.length; i++) {
            char temp = wordArray[i];
            if (!cur.children.containsKey(temp)) {
                cur.children.put(temp, new TrieNode());
            }
            cur = cur.children.get(temp);
        }
        cur.hasWord = true;
    }
}
public class Solution {
    public List<String> findAllConcatenatedWordsInADict(String[] words) {
        List<String> result = new ArrayList<>();
        if (words == null || words.length <= 1) {
            return result;
        }
        Trie trie = new Trie();
        for (String word : words) {
            trie.insert(word);
        }
        for (String word : words) {
            if (dfsHelper(word.toCharArray(), 0, trie.root, 0)) {
                result.add(word);
            }
        }
        return result;
    }
    public boolean dfsHelper(char[] chars, int startIndex, TrieNode root, int count) {
        TrieNode cur = root;
        for (int i = startIndex; i < chars.length; i++) {
            if (!cur.children.containsKey(chars[i])) {
                return false;
            }
            cur = cur.children.get(chars[i]);
            if (cur.hasWord) {
                if (i == chars.length - 1) {
                    return count >= 1;
                }
                if (dfsHelper(chars, i + 1, root, count + 1)) {
                    return true;
                }
            }
        }
        return false;
    }
}

 

Find the Weak Connected Component in the Directed Graph

Find the number Weak Connected Component in the directed graph. Each node in the graph contains a label and a list of its neighbors. (a connected set of a directed graph is a subgraph in which any two vertices are connected by direct edge path.)

 Notice

Sort the element in the set in increasing order

Have you met this question in a real interview? Yes
Example
Given graph:

A----->B  C
 \     |  | 
  \    |  |
   \   |  |
    \  v  v
     ->D  E <- F
Return {A,B,D}, {C,E,F}. Since there are two connected component which are {A,B,D} and {C,E,F}

思路：并查集 由于节点的值不确定，所以用HashMap来存储一个节点和它的父节点的映射关系而不是用数组存储，注意用HashMap来存储的时候并查集中的find函数的写法！

/**
 * Definition for Directed graph.
 * class DirectedGraphNode {
 *     int label;
 *     ArrayList<DirectedGraphNode> neighbors;
 *     DirectedGraphNode(int x) { label = x; neighbors = new ArrayList<DirectedGraphNode>(); }
 * };
 */
class UnionFind {
    Map<Integer, Integer> map;
    public UnionFind(HashSet<Integer> hash) {
        map = new HashMap<>();
        for (Integer temp : hash) {
            map.put(temp, temp);
        }
    }
    public int find(int x) {
        if (map.get(x) == x) {
            return x;
        }
        map.put(x, find(map.get(x)));
        return map.get(x);
    }
    public void union(int a, int b) {
        int root_a = find(a);
        int root_b = find(b);
        if (root_a != root_b) {
            map.put(root_a, root_b);
        }
    }
}
public class Solution {
    /**
     * @param nodes a array of Directed graph node
     * @return a connected set of a directed graph
     */
    public List<List<Integer>> connectedSet2(ArrayList<DirectedGraphNode> nodes) {
        // Write your code here
        List<List<Integer>> results = new ArrayList<>();
        if (nodes == null || nodes.size() == 0) {
            return results;
        }
        HashSet<Integer> set = new HashSet<>();
        for (DirectedGraphNode node : nodes) {
            set.add(node.label);
        }
        UnionFind uf = new UnionFind(set);
        for (DirectedGraphNode node : nodes) {
            for (DirectedGraphNode neighbor : node.neighbors) {
                uf.union(node.label, neighbor.label);
            }
        }
        HashMap<Integer, ArrayList<Integer>> children = new HashMap<Integer, ArrayList<Integer>>();
        for (int num : set) {
            int root_num = uf.find(num);
            if (!children.containsKey(root_num)) {
                children.put(root_num, new ArrayList<Integer>());
            }
            children.get(root_num).add(num);
        }
        for (Integer father : children.keySet()) {
            Collections.sort(children.get(father));
            results.add(children.get(father));
        }
        return results;
    }
}

 

Sweep Line

Building Outline

Question

Given N buildings in a x-axis，each building is a rectangle and can be represented by a triple (start, end, height)，where start is the start position on x-axis, end is the end position on x-axis and height is the height of the building. Buildings may overlap if you see them from far away，find the outline of them。
An outline can be represented by a triple, (start, end, height), where start is the start position on x-axis of the outline, end is the end position on x-axis and height is the height of the outline.


Notice
Please merge the adjacent outlines if they have the same height and make sure different outlines cant overlap on x-axis.
Example
Given 3 buildings：
[ [1, 3, 3],
[2, 4, 4],
[5, 6, 1] ]
The outlines are：
[ [1, 2, 3],
[2, 4, 4],
[5, 6, 1] ]

思路I：使用PriorityQueue

我的解法：用一个带最大堆的扫描线遍历数组，每出现一个拐点则记录一次区间。新加入一个元素后若堆顶元素和之前不同，则表明出现拐点。

1. 首先处理数组中元素。将每一个点用一个point来保存，保存time（开始写错了，应该是位置，但是要改的太多了），flag（起点为1，终点为0），height。用一个HashMap来记录每一对终点和起点（终点为key，起点为value）。

2. 将所有point保存在一个list中并排序，首先根据时间从小到大排序，若时间相等则根据flag排序（先起点后终点），若flag也相等则根据height排序（若同为起点则从大到小排序，若同为终点则从小到大排序）。这样可以避免重复解。

3. 再构建一个最大堆，用于记录加入的元素的最大值。

4. 开始遍历list中每个point，起点元素加入堆，终点元素删去堆中对应的起点元素。

5. 当遇到一个起点元素时，先记录加入前堆顶元素，然后将该起点元素加入，再看加入后堆顶元素，1）若没有变化，则继续下一个point；2）若有变化，则说明出现拐点，将之前堆顶元素时间作为起点，当前堆顶元素时间作为终点，之前堆顶元素高度作为高度。注意：就算堆顶元素变化，但是如果之前堆顶元素和当前堆顶元素时间相同，说明是在这个时间连续有几个起点被加入，宽度为0，不能算一个区间。

6. 当遇到一个终点元素时，将其对应的起点元素从堆中删除。若此时堆为空，则和5中一样记录一个区间，并继续下一个point。若堆不为空，则需要看此时堆顶元素是否改变。若不变则继续，否则说明出现“拐点”。此处“拐点”要分两种情况讨论： 1）若新的堆顶元素高度和之前堆顶元素高度相同，则说明相同高度的两段区间有重叠，题目要求若发生这种情况要合并这两段区间，所以我们要保留之前的堆顶元素（两段同高度相同重叠区间的最左边），删去新的堆顶元素（即代替原堆顶元素被删除，因为每遇到一个终点必须删去一个起点），具体做法可以是先删去新堆顶元素，再加入原堆顶元素，或者直接将新堆顶元素时间改为原堆顶元素时间。 2）若新堆顶和原堆顶元素高度不同，则像5中那样记录一个区间，但是要将现在的堆顶元素时间改为遇到的终点元素的时间。

7. 遍历完整个list结束

class Point {
    int index;
    int height;
    int flag;
    public Point(int index, int height, int flag) {
        this.index = index;
        this.height = height;
        this.flag = flag;
    }
}
public class Solution {
    /**
     * @param buildings: A list of lists of integers
     * @return: Find the outline of those buildings
     */
    public ArrayList<ArrayList<Integer>> buildingOutline(int[][] buildings) {
        // write your code here
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
        if (buildings == null || buildings.length == 0
            || buildings[0].length == 0) {
            return result;
        }
        List<Point> points = new ArrayList<>();
        Map<Point, Point> map = new HashMap<>();
        for (int[] building : buildings) {
            Point start = new Point(building[0], building[2], 1);
            Point end = new Point(building[1], building[2], 0);
            points.add(start);
            points.add(end);
            map.put(end, start);
        }
        Collections.sort(points, new Comparator<Point>() {
            public int compare(Point a, Point b) {
                if (a.index != b.index) {
                    return a.index - b.index;
                } else if (a.flag != b.flag) {
                    return b.flag - a.flag;
                } else {
                    if (a.flag == 1) {
                        return b.height - a.height;
                    }
                    return a.height - b.height;
                }
            }
        });
        Queue<Point> maxHeap = new PriorityQueue<>(buildings.length, new Comparator<Point>() {
            public int compare(Point a, Point b) {
                if (a.height != b.height) {
                    return b.height - a.height;
                }
                return a.index - b.index;
            }
        });
        for (int i = 0; i < points.size(); i++) {
            if (maxHeap.isEmpty()) {
                maxHeap.offer(points.get(i));
                continue;
            }
            Point pre = maxHeap.peek();
            Point next = points.get(i);
            ArrayList<Integer> tempList = new ArrayList<>();
            if (next.flag == 1) {
                maxHeap.offer(next);
                Point cur = maxHeap.peek();
                //由于points排序规则的作用，不会出现当堆顶节点变化时老堆顶节点的索引等于新堆顶节点的索引
                if (cur != pre && cur.index != pre.index) {
                    tempList.add(pre.index);
                    tempList.add(cur.index);
                    tempList.add(pre.height);
                    result.add(tempList);
                }
            } else {
                maxHeap.remove(map.get(next));
                if (maxHeap.isEmpty()) {
                    tempList.add(pre.index);
                    tempList.add(next.index);
                    tempList.add(pre.height);
                    result.add(tempList);
                    continue;
                }
                Point cur = maxHeap.peek();
                if (cur != pre) {
                    if (cur.height == pre.height) {
                        cur.index = pre.index;
                    } else {
                        tempList.add(pre.index);
                        tempList.add(next.index);
                        tempList.add(pre.height);
                        result.add(tempList);
                        cur.index = next.index;
                    }
                }
            }
        }
        return result;
    }
}

思路II：自定义HashHeap堆可以将PriorityQueue中O(n)的remove操作优化到O(lgn)的remove操作。注意点已经在代码中标出。

class Node {
    int time;
    int height;
    int flag;
    public Node(int time, int height, int flag) {
        this.time = time;
        this.height = height;
        this.flag = flag;
    }
}
class HashHeap {
    List<Node> list;
    Map<Node, Integer> map;
    public HashHeap() {
        list = new ArrayList<>();
        map = new HashMap<>();
    }
    public int getParent(int index) {
        if (index == 0) {
            return -1;
        }
        return (index - 1) / 2;
    }
    public int getLeftChild(int index) {
        return 2 * index + 1;
    }
    public int getRightChild(int index) {
        return 2 * index + 2;
    }
    public int size() {
        return list.size();
    }
    public Node peek() {
        return list.get(0);
    }
    public void offer(Node node) {
        list.add(node);
        map.put(list.get(list.size() - 1), list.size() - 1);
        siftup(list.size() - 1);
    }
    public Node poll() {
        if (list.size() == 0) {
            return null;
        }
        Node temp = list.get(0);
        list.set(0, list.get(list.size() - 1));
        list.set(list.size() - 1, temp);
        map.put(list.get(0), 0);
        map.put(list.get(list.size() - 1), list.size() - 1);
        map.remove(list.get(list.size() - 1));
        list.remove(list.size() - 1);
        siftdown(0);
        return temp;
    }
    public void remove(Node node) {
        int index = map.get(node);
        // 注意：当删除的节点是最后一个节点时，此时需要调整的起始节点已经从堆里里面删除,
        // 就不存在siftup和siftdown操作了！否则下标会越界！
        if (index == list.size() - 1) {
            map.remove(list.get(index));
            list.remove(index);
            return;
        }
        Node temp = list.get(index);
        list.set(index, list.get(list.size() - 1));
        list.set(list.size() - 1, temp);
        map.put(list.get(index), index);
        map.put(list.get(list.size() - 1), list.size() - 1);
        map.remove(list.get(list.size() - 1));
        list.remove(list.size() - 1);
        siftup(index);
        siftdown(index);
    }
    public void siftup(int index) {
        while (index >= 0) {
            int smallestIndex = index;
            int parentIndex = getParent(index);
            if (parentIndex >= 0
                && compare(list.get(index), list.get(parentIndex))) {
                smallestIndex = parentIndex;
            }
            if (smallestIndex == index) {
                break;
            }
            swap(index, parentIndex);
            index = smallestIndex;
        }
    }
    public void siftdown(int index) {
        while (index < list.size()) {
            int maximumIndex = index;
            int leftIndex = getLeftChild(index);
            if (leftIndex < list.size()
                && compare(list.get(leftIndex), list.get(maximumIndex))) {
                maximumIndex = leftIndex;
            }
            int rightIndex = getRightChild(index);
            if (rightIndex < list.size()
                && compare(list.get(rightIndex), list.get(maximumIndex))) {
                maximumIndex = rightIndex;
            }
            if (maximumIndex == index) {
                break;
            }
            swap(index, maximumIndex);
            index = maximumIndex;
        }
    }
    public boolean compare(Node a, Node b) {
        if (a.height != b.height) {
            return a.height > b.height;
        }
        return a.time < b.time;
    }
    public void swap(int index1, int index2) {
        Node temp = list.get(index1);
        list.set(index1, list.get(index2));
        list.set(index2, temp);
        map.put(list.get(index1), index1);
        map.put(list.get(index2), index2);
    }
}
public class Solution {
    /**
     * @param buildings: A list of lists of integers
     * @return: Find the outline of those buildings
     */
    public ArrayList<ArrayList<Integer>> buildingOutline(int[][] buildings) {
        // write your code here
        ArrayList<ArrayList<Integer>> result = new ArrayList<>();
        if (buildings == null || buildings.length == 0
            || buildings[0].length == 0) {
            return result;     
        }
        List<Node> nodes = new ArrayList<>();
        Map<Node, Node> map = new HashMap<>();
        for (int[] building : buildings) {
            Node start = new Node(building[0], building[2], 1);
            Node end = new Node(building[1], building[2], 0);
            nodes.add(start);
            nodes.add(end);
            map.put(end, start);
        }
        Collections.sort(nodes, new Comparator<Node>() {
           public int compare(Node a, Node b) {
               if (a.time != b.time) {
                   return a.time - b.time;
               }
               if (a.flag != b.flag) {
                   return b.flag - a.flag;
               }
               if (a.flag == 1) {
                   return b.height - a.height;
               }
               return a.height - b.height;
           }
        });
        HashHeap maxHeap = new HashHeap();
        for (int i = 0; i < nodes.size(); i++) {
            
            if (maxHeap.size() == 0) {
                maxHeap.offer(nodes.get(i));
                continue;
            }
            Node pre = maxHeap.peek();
            Node next = nodes.get(i);
            ArrayList<Integer> tempList = new ArrayList<>();
            if (next.flag == 1) {
                maxHeap.offer(next);
                Node cur = maxHeap.peek();
                if (cur != pre && cur.time != pre.time) {
                    tempList.add(pre.time);
                    tempList.add(cur.time);
                    tempList.add(pre.height);
                    result.add(tempList);
                }
            } else {
                maxHeap.remove(map.get(next));
                if (maxHeap.size() == 0) {
                    tempList.add(pre.time);
                    tempList.add(next.time);
                    tempList.add(pre.height);
                    result.add(tempList);
                    continue;
                }
                Node cur = maxHeap.peek();
                if (pre != cur) {
                    if (cur.height == pre.height) {
                        cur.time = pre.time;
                    } else {
                        tempList.add(pre.time);
                        tempList.add(next.time);
                        tempList.add(pre.height);
                        result.add(tempList);
                        cur.time = next.time;
                    }
                }
            }
        }
        return result;
    }
}

 

Advanced Data Structure -- Segment Tree

Segment Tree Build

The structure of Segment Tree is a binary tree which each node has two attributes start and end denote an segment / interval.

start and end are both integers, they should be assigned in following rules:

The root's start and end is given by build method.
The left child of node A has start=A.left, end=(A.left + A.right) / 2.
The right child of node A has start=(A.left + A.right) / 2 + 1, end=A.right.
if start equals to end, there will be no children for this node.
Implement a build method with two parameters start and end, so that we can create a corresponding segment tree with every node has the correct start and end value, return the root of this segment tree.

Have you met this question in a real interview? Yes
Clarification
Segment Tree (a.k.a Interval Tree) is an advanced data structure which can support queries like:

which of these intervals contain a given point
which of these points are in a given interval
See wiki:
Segment Tree
Interval Tree

Example
Given start=0, end=3. The segment tree will be:

               [0,  3]
             /        \
      [0,  1]           [2, 3]
      /     \           /     \
   [0, 0]  [1, 1]     [2, 2]  [3, 3]
Given start=1, end=6. The segment tree will be:

               [1,  6]
             /        \
      [1,  3]           [4,  6]
      /     \           /     \
   [1, 2]  [3,3]     [4, 5]   [6,6]
   /    \           /     \
[1,1]   [2,2]     [4,4]   [5,5]

思路：很简单，类似写建立二叉树的程序。

/**
 * Definition of SegmentTreeNode:
 * public class SegmentTreeNode {
 *     public int start, end;
 *     public SegmentTreeNode left, right;
 *     public SegmentTreeNode(int start, int end) {
 *         this.start = start, this.end = end;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     *@param start, end: Denote an segment / interval
     *@return: The root of Segment Tree
     */
    public SegmentTreeNode build(int start, int end) {
        // write your code here
        if (start > end) {
            return null;
        }
        if (start == end) {
            return new SegmentTreeNode(start, start);
        }
        SegmentTreeNode root = new SegmentTreeNode(start, end);
        int mid = start + (end - start) / 2;
        root.left = build(start, mid);
        root.right = build(mid + 1, end);
        return root;
    }
}

 

Segment Tree Build II

The structure of Segment Tree is a binary tree which each node has two attributes start and end denote an segment / interval.

start and end are both integers, they should be assigned in following rules:

The root's start and end is given by build method.
The left child of node A has start=A.left, end=(A.left + A.right) / 2.
The right child of node A has start=(A.left + A.right) / 2 + 1, end=A.right.
if start equals to end, there will be no children for this node.
Implement a build method with a given array, so that we can create a corresponding segment tree with every node value represent the corresponding interval max value in the array, return the root of this segment tree.

Have you met this question in a real interview? Yes
Clarification
Segment Tree (a.k.a Interval Tree) is an advanced data structure which can support queries like:

which of these intervals contain a given point
which of these points are in a given interval
See wiki:
Segment Tree
Interval Tree

Example
Given [3,2,1,4]. The segment tree will be:

                 [0,  3] (max = 4)
                  /            \
        [0,  1] (max = 3)     [2, 3]  (max = 4)
        /        \               /             \
[0, 0](max = 3)  [1, 1](max = 2)[2, 2](max = 1) [3, 3] (max = 4)

思路：多了求每个区间的最大值，navie做法是每次建立某一区间节点，就调用findMax()函数在数组中的该区间内找最大值，这个没必要，我们可以从左右区间子树的max属性来更新当前区间节点的max。

/**
 * Definition of SegmentTreeNode:
 * public class SegmentTreeNode {
 *     public int start, end, max;
 *     public SegmentTreeNode left, right;
 *     public SegmentTreeNode(int start, int end, int max) {
 *         this.start = start;
 *         this.end = end;
 *         this.max = max
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     *@param A: a list of integer
     *@return: The root of Segment Tree
     */
    public SegmentTreeNode build(int[] A) {
        // write your code here
        if (A == null || A.length == 0) {
            return null;
        }
        return buildHelper(A, 0, A.length - 1);
    }
    public SegmentTreeNode buildHelper(int[] A, int start, int end) {
        if (start > end) {
            return null;
        }
        if (start == end) {
            return new SegmentTreeNode(start, start, A[start]);
        }
        int mid = start + (end - start) / 2;
        SegmentTreeNode root = new SegmentTreeNode(start, end, A[start]);
        root.left = buildHelper(A, start, mid);
        root.right = buildHelper(A, mid + 1, end);
        if (root.left != null && root.left.max > root.max) {
            root.max = root.left.max;
        }
        if (root.right != null && root.right.max > root.max) {
            root.max = root.right.max;
        }
        return root;
    }
}

 

Segment Tree Query

For an integer array (index from 0 to n-1, where n is the size of this array), in the corresponding SegmentTree, each node stores an extra attribute max to denote the maximum number in the interval of the array (index from start to end).

Design a query method with three parameters root, start and end, find the maximum number in the interval [start, end] by the given root of segment tree.

 Notice

It is much easier to understand this problem if you finished Segment Tree Build first.

Have you met this question in a real interview? Yes
Example
For array [1, 4, 2, 3], the corresponding Segment Tree is:

                  [0, 3, max=4]
                 /             \
          [0,1,max=4]        [2,3,max=3]
          /         \        /         \
   [0,0,max=1] [1,1,max=4] [2,2,max=2], [3,3,max=3]
query(root, 1, 1), return 4

query(root, 1, 2), return 4

query(root, 2, 3), return 3

query(root, 0, 2), return 4

思路：查询给定区间中的最大值，根据给定区间与当前区间节点的三种位置关系来执行相应的操作，注意要包含给定区间超过原有区间范围的情况。

/**
 * Definition of SegmentTreeNode:
 * public class SegmentTreeNode {
 *     public int start, end, max;
 *     public SegmentTreeNode left, right;
 *     public SegmentTreeNode(int start, int end, int max) {
 *         this.start = start;
 *         this.end = end;
 *         this.max = max
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     *@param root, start, end: The root of segment tree and
     *                         an segment / interval
     *@return: The maximum number in the interval [start, end]
     */
    public int query(SegmentTreeNode root, int start, int end) {
        // write your code here
        if (root == null || start > end)  {
            return 0;
        }
        if (root.start >= start && root.end <= end) {
            return root.max;
        }
        int mid = root.start + (root.end - root.start) / 2;
        if (start <= mid && end <= mid) {
            return query(root.left, start, end);
        }
        if (start <= mid && end > mid) {
            return Math.max(query(root.left, start, mid),
                            query(root.right, mid + 1, end));
        }
        return query(root.right, start, end);
    }
}

 

Segment Tree Query II

For an array, we can build a SegmentTree for it, each node stores an extra attribute count to denote the number of elements in the the array which value is between interval start and end. (The array may not fully filled by elements)

Design a query method with three parameters root, start and end, find the number of elements in the in array's interval [start, end] by the given root of value SegmentTree.

 Notice

It is much easier to understand this problem if you finished Segment Tree Buildand Segment Tree Query first.

Have you met this question in a real interview? Yes
Example
For array [0, 2, 3], the corresponding value Segment Tree is:

                     [0, 3, count=3]
                     /             \
          [0,1,count=1]             [2,3,count=2]
          /         \               /            \
   [0,0,count=1] [1,1,count=0] [2,2,count=1], [3,3,count=1]
query(1, 1), return 0

query(1, 2), return 1

query(2, 3), return 2

query(0, 2), return 2

思路：查询给定区间中的元素个数，根据给定区间与当前区间节点的三种位置关系来执行相应的操作，注意要包含给定区间超过原有区间范围的情况。

/**
 * Definition of SegmentTreeNode:
 * public class SegmentTreeNode {
 *     public int start, end, count;
 *     public SegmentTreeNode left, right;
 *     public SegmentTreeNode(int start, int end, int count) {
 *         this.start = start;
 *         this.end = end;
 *         this.count = count;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     *@param root, start, end: The root of segment tree and
     *                         an segment / interval
     *@return: The count number in the interval [start, end]
     */
    public int query(SegmentTreeNode root, int start, int end) {
        // write your code here
        if (root == null || start > end) {
            return 0;
        }
        if (root.start >= start && root.end <= end) {
            return root.count;
        }
        int mid = root.start + (root.end - root.start) / 2;
        if (start <= mid && end <= mid) {
            return query(root.left, start, end);
        }
        if (start <= mid && end > mid) {
            return query(root.left, start, mid)
                + query(root.right, mid + 1, end);
        }
        return query(root.right, start, end);
    }
}

 

Segment Tree Modify

For a Maximum Segment Tree, which each node has an extra value max to store the maximum value in this node's interval.

Implement a modify function with three parameter root, index and value to change the node's value with [start, end] = [index, index] to the new given value. Make sure after this change, every node in segment tree still has the max attribute with the correct value.

 Notice

We suggest you finish problem Segment Tree Build and Segment Tree Query first.

Have you met this question in a real interview? Yes
Example
For segment tree:

                      [1, 4, max=3]
                    /                \
        [1, 2, max=2]                [3, 4, max=3]
       /              \             /             \
[1, 1, max=2], [2, 2, max=1], [3, 3, max=0], [4, 4, max=3]
if call modify(root, 2, 4), we can get:

                      [1, 4, max=4]
                    /                \
        [1, 2, max=4]                [3, 4, max=3]
       /              \             /             \
[1, 1, max=2], [2, 2, max=4], [3, 3, max=0], [4, 4, max=3]
or call modify(root, 4, 0), we can get:

                      [1, 4, max=2]
                    /                \
        [1, 2, max=2]                [3, 4, max=0]
       /              \             /             \
[1, 1, max=2], [2, 2, max=1], [3, 3, max=0], [4, 4, max=0]

思路：改变某一元素的值从而更新线段树。根据要改变值的索引index与当前区间的中点mid的大小关系来选择相应的操作，记得从小到大更新遍历过的区间的max属性。

/**
 * Definition of SegmentTreeNode:
 * public class SegmentTreeNode {
 *     public int start, end, max;
 *     public SegmentTreeNode left, right;
 *     public SegmentTreeNode(int start, int end, int max) {
 *         this.start = start;
 *         this.end = end;
 *         this.max = max
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     *@param root, index, value: The root of segment tree and
     *@ change the node's value with [index, index] to the new given value
     *@return: void
     */
    public void modify(SegmentTreeNode root, int index, int value) {
        // write your code here
        if (root == null || index < root.start || index > root.end) {
            return;
        }
        if (root.start == root.end) {
            root.max = value;
            return;
        }
        int mid = root.start + (root.end - root.start) / 2;
        if (index <= mid) {
            modify(root.left, index, value);
        }
        if (index > mid) {
            modify(root.right, index, value);
        }
        root.max = Math.max(root.left.max, root.right.max);
    }
}

 

Interval Sum

Given an integer array (index from 0 to n-1, where n is the size of this array), and an query list. Each query has two integers [start, end]. For each query, calculate the sum number between index start and end in the given array, return the result list.

 Notice

We suggest you finish problem Segment Tree Build, Segment Tree Query and Segment Tree Modify first.

Have you met this question in a real interview? Yes
Example
For array [1,2,7,8,5], and queries [(0,4),(1,2),(2,4)], return [23,9,20]

思路：线段树build + query的结合，注意query函数中是start ～ end与当前线段树节点的root.start ～ root.end相比，所以query中mid = root.start + (root.end - root.start) / 2，是当前线段树节点的区间中点，不要误写成start + (end - start) / 2，错弄成待查询的区间中点，这个错误非常容易犯。

/**
 * Definition of Interval:
 * public classs Interval {
 *     int start, end;
 *     Interval(int start, int end) {
 *         this.start = start;
 *         this.end = end;
 *     }
 */
class SegmentTreeNode {
    int start;
    int end;
    long sum;
    SegmentTreeNode left;
    SegmentTreeNode right;
    public SegmentTreeNode(int start, int end, long sum) {
        this.start = start;
        this.end = end;
        this.sum = sum;
        left = null;
        right = null;
    }
}
public class Solution {
    /**
     *@param A, queries: Given an integer array and an query list
     *@return: The result list
     */
    public ArrayList<Long> intervalSum(int[] A,
                                       ArrayList<Interval> queries) {
        // write your code here
        ArrayList<Long> result = new ArrayList<>();
        if (A == null || A.length == 0
            || queries == null || queries.size() == 0) {
            return result;
        }
        SegmentTreeNode root = build(A, 0, A.length - 1);
        for (Interval interval : queries) {
            result.add(query(root, interval.start, interval.end));
        }
        return result;
    }
    public SegmentTreeNode build(int[] A, int start, int end) {
        if (start == end) {
            return new SegmentTreeNode(start, end, A[start]);
        }
        SegmentTreeNode root = new SegmentTreeNode(start, end, 0);
        int mid = start + (end - start) / 2;
        root.left = build(A, start, mid);
        root.right = build(A, mid + 1, end);
        root.sum = root.left.sum + root.right.sum;
        return root;
    }
    public long query(SegmentTreeNode root, int start, int end) {
        if (root == null || start > end) {
            return 0;
        }
        if (start <= root.start && end >= root.end) {
            return root.sum;
        }
        int mid = root.start + (root.end - root.start) / 2;
        if (start <= mid && end <= mid) {
            return query(root.left, start, end);
        }
        if (start <= mid && end > mid) {
            return query(root.left, start, mid)
                + query(root.right, mid + 1, end);
        }
        return query(root.right, start, end);
    }
}

 

Interval Sum II

Given an integer array in the construct method, implement two methods query(start, end) and modify(index, value):

For query(start, end), return the sum from index start to index end in the given array.
For modify(index, value), modify the number in the given index to value
 Notice

We suggest you finish problem Segment Tree Build, Segment Tree Query and Segment Tree Modify first.

Have you met this question in a real interview? Yes
Example
Given array A = [1,2,7,8,5].

query(0, 2), return 10.
modify(0, 4), change A[0] from 1 to 4.
query(0, 1), return 6.
modify(2, 1), change A[2] from 7 to 1.
query(2, 4), return 14.

思路：线段树build + modify + query的结合。

class SegmentTreeNode {
    int start;
    int end;
    long sum;
    SegmentTreeNode left;
    SegmentTreeNode right;
    public SegmentTreeNode(int start, int end, long sum) {
        this.start = start;
        this.end = end;
        this.sum = sum;
        left = null;
        right = null;
    }
}
public class Solution {
    /* you may need to use some attributes here */
    SegmentTreeNode root;
    /**
     * @param A: An integer array
     */
    public Solution(int[] A) {
        // write your code here
        root = build(A, 0, A.length - 1);
    }
    
    public SegmentTreeNode build(int[] num, int start, int end) {
        if (num == null || num.length == 0 || start > end) {
            return null;
        }
        if (start == end) {
            return new SegmentTreeNode(start, start, num[start]);
        }
        SegmentTreeNode root = new SegmentTreeNode(start, end, 0);
        int mid = start + (end - start) / 2;
        root.left = build(num, start, mid);
        root.right = build(num, mid + 1, end);
        root.sum = root.left.sum + root.right.sum;
        return root;
    }
    
    /**
     * @param start, end: Indices
     * @return: The sum from start to end
     */
    public long query(int start, int end) {
        // write your code here
        return query(root, start, end);
    }
    
    public long query(SegmentTreeNode root, int start, int end) {
        if (root == null || start > end) {
            return 0;
        }
        if (start <= root.start && end >= root.end) {
            return root.sum;
        }
        int mid = root.start + (root.end - root.start) / 2;
        if (start <= mid && end <= mid) {
            return query(root.left, start, end);
        }
        if (start <= mid && end > mid) {
            return query(root.left, start, mid)
                + query(root.right, mid + 1, end);
        }
        return query(root.right, start, end);
    }
    
    /**
     * @param index, value: modify A[index] to value.
     */
    public void modify(int index, int value) {
        // write your code here
        modify(root, index, value);
    }
    
    public void modify(SegmentTreeNode root, int index, int value) {
        if (root.start == root.end) {
            root.sum = value;
            return;
        }
        int mid = root.start + (root.end - root.start) / 2;
        if (index <= mid) {
            modify(root.left, index, value);
        } else {
            modify(root.right, index, value);
        }
        root.sum = root.left.sum + root.right.sum;
    }
}

 

Interval Minimum Number

Given an integer array (index from 0 to n-1, where n is the size of this array), and an query list. Each query has two integers [start, end]. For each query, calculate the minimum number between index start and end in the given array, return the result list.

 Notice

We suggest you finish problem Segment Tree Build, Segment Tree Query and Segment Tree Modify first.

Have you met this question in a real interview? Yes
Example
For array [1,2,7,8,5], and queries [(1,2),(0,4),(2,4)], return [2,1,5]

思路：线段树build + query结合，只要熟悉线段树的模版，写起来很容易。

/**
 * Definition of Interval:
 * public classs Interval {
 *     int start, end;
 *     Interval(int start, int end) {
 *         this.start = start;
 *         this.end = end;
 *     }
 */
class SegmentTreeNode {
    int start;
    int end;
    int min;
    SegmentTreeNode left;
    SegmentTreeNode right;
    public SegmentTreeNode(int start, int end, int min) {
        this.start = start;
        this.end = end;
        this.min = min;
        left = null;
        right = null;
    }
}
public class Solution {
    /**
     *@param A, queries: Given an integer array and an query list
     *@return: The result list
     */
    public ArrayList<Integer> intervalMinNumber(int[] A,
                                                ArrayList<Interval> queries) {
        // write your code here
        ArrayList<Integer> result = new ArrayList<>();
        if (A == null || A.length == 0
            || queries == null || queries.size() == 0) {
            return result;
        }
        SegmentTreeNode root = build(A, 0, A.length - 1);
        for (Interval interval : queries) {
            result.add(query(root, interval.start, interval.end));
        }
        return result;
    }
    public SegmentTreeNode build(int[] A, int start, int end) {
        if (A == null || A.length == 0 || start > end) {
            return null;
        }
        if (start == end) {
            return new SegmentTreeNode(start, start, A[start]);
        }
        SegmentTreeNode root = new SegmentTreeNode(start, end, 0);
        int mid = start + (end - start) / 2;
        root.left = build(A, start, mid);
        root.right = build(A, mid + 1, end);
        root.min = Math.min(root.left.min, root.right.min);
        return root;
    }
    public int query(SegmentTreeNode root, int start, int end) {
        if (root == null || start > end) {
            return 0;
        }
        if (start <= root.start && end >= root.end) {
            return root.min;
        }
        int mid = root.start + (root.end - root.start) / 2;
        if (start <= mid && end <= mid) {
            return query(root.left, start, end);
        }
        if (start <= mid && end > mid) {
            return Math.min(query(root.left, start, mid),
                query(root.right, mid + 1, end));
        }
        return query(root.right, start, end);
    }
}

 

Count of Smaller Number

Give you an integer array (index from 0 to n-1, where n is the size of this array, value from 0 to 10000) and an query list. For each query, give you an integer, return the number of element in the array that are smaller than the given integer.

 Notice

We suggest you finish problem Segment Tree Build and Segment Tree Query II first.

Have you met this question in a real interview? Yes
Example
For array [1,2,7,8,5], and queries [1,8,5], return [0,4,2]

思路I：数组中最小值min，最大值max，map存储每个元素出现的次数，以这三个来构建线段树。注意这一题的边界情况，queries数组len >= 1时，对每一个询问必须有返回值（0或者非0），当A数组为空或者len == 0时不能直接返回空的list，而是返回长度为queries.length，元素都为0的list。

class SegmentTreeNode {
    int start;
    int end;
    int count;
    SegmentTreeNode left;
    SegmentTreeNode right;
    public SegmentTreeNode(int start, int end, int count) {
        this.start = start;
        this.end = end;
        this.count = count;
        left = null;
        right = null;
    }
}
public class Solution {
   /**
     * @param A: An integer array
     * @return: The number of element in the array that
     *          are smaller that the given integer
     */
    public ArrayList<Integer> countOfSmallerNumber(int[] A, int[] queries) {
        // write your code here
        ArrayList<Integer> result = new ArrayList<>();
        if (queries == null || queries.length == 0) {
            return result;
        }
        if (A == null || A.length == 0) {
            for (int i = 0; i < queries.length; i++) {
                result.add(0);
            }
            return result;
        }
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < A.length; i++) {
            min = Math.min(min, A[i]);
            max = Math.max(max, A[i]);
            if (!map.containsKey(A[i])) {
                map.put(A[i], 0);
            }
            map.put(A[i], map.get(A[i]) + 1);
        }
        SegmentTreeNode root = build(min, max, map);
        for (int value : queries) {
            result.add(query(root, value - 1));
        }
        return result;
    }
    public SegmentTreeNode build(int start, int end,
                                 Map<Integer, Integer> map) {
        if (start > end || map == null || map.size() == 0) {
            return null;
        }
        //System.out.println("empty");
        if (start == end) {
            if (!map.containsKey(start)) {
                return new SegmentTreeNode(start, start, 0);
            }
            return new SegmentTreeNode(start, start, map.get(start));
        }
        SegmentTreeNode root = new SegmentTreeNode(start, end, 0);
        int mid = start + (end - start) / 2;
        root.left = build(start, mid, map);
        root.right = build(mid + 1, end, map);
        root.count = root.left.count + root.right.count;
        return root;
    }
    public int query(SegmentTreeNode root, int value) {
        if (root == null) {
            return 0;
        }
        if (value >= root.end) {
            return root.count;
        }
        if (value < root.start) {
            return 0;
        }
        int mid = root.start + (root.end - root.start) / 2;
        if (value <= mid) {
            return query(root.left, value);
        }
        return root.left.count + query(root.right, value);
    }
}

 思路II：考虑可扩展性，同Count of Smaller Number before itself。

class SegmentTreeNode {
    int start;
    int end;
    int count;
    SegmentTreeNode left;
    SegmentTreeNode right;
    public SegmentTreeNode(int start, int end, int count) {
        this.start = start;
        this.end = end;
        this.count = count;
        left = null;
        right = null;
    }
}
public class Solution {
   /**
     * @param A: An integer array
     * @return: The number of element in the array that
     *          are smaller that the given integer
     */
    public ArrayList<Integer> countOfSmallerNumber(int[] A, int[] queries) {
        // write your code here
        ArrayList<Integer> result = new ArrayList<>();
        if (queries == null || queries.length == 0) {
            return result;
        }
        if (A == null || A.length == 0) {
            for (int i = 0; i < queries.length; i++) {
                result.add(0);
            }
            return result;
        }
        SegmentTreeNode root = build(0, 10000);
        for (int num : A) {
            modify(root, num, 1);
        }
        for (int num : queries) {
            result.add(query(root, 0, num - 1));
        }
        return result;
    }
    public SegmentTreeNode build(int start, int end) {
        if (start > end) {
            return null;
        }
        if (start == end) {
            return new SegmentTreeNode(start, start, 0);
        }
        SegmentTreeNode root = new SegmentTreeNode(start, end, 0);
        int mid = start + (end - start) / 2;
        root.left = build(start, mid);
        root.right = build(mid + 1, end);
        return root;
    }
    public int query(SegmentTreeNode root, int start, int end) {
        if (root == null || start > end) {
            return 0;
        }
        if (start <= root.start && end >= root.end) {
            return root.count;
        }
        int mid = root.start + (root.end - root.start) / 2;
        if (start <= mid && end <= mid) {
            return query(root.left, start, end);
        }
        if (start <= mid && end > mid) {
            return query(root.left, start, mid)
                + query(root.right, mid + 1, end);
        }
        return query(root.right, start, end);
    }
    public void modify(SegmentTreeNode root, int index, int value) {
        if (root == null) {
            return;
        }
        if (root.start == root.end) {
            root.count += value;
            return;
        }
        int mid = root.start + (root.end - root.start) / 2;
        if (index <= mid) {
            modify(root.left, index, value);
        } else {
            modify(root.right, index, value);
        }
        root.count = root.left.count + root.right.count;
    }
}

 

Count of Smaller Number before Itself

Give you an integer array (index from 0 to n-1, where n is the size of this array, data value from 0 to 10000) . For each element Ai in the array, count the number of element before this element Ai is smaller than it and return count number array.

 Notice

We suggest you finish problem Segment Tree Build, Segment Tree Query II and Count of Smaller Number first.

Have you met this question in a real interview? Yes
Example
For array [1,2,7,8,5], return [0,1,2,3,2]

思路：将数组A中的元素作为索引，对应的值为该元素个数，建立线段树。每次遍历A中的元素时，先在线段树中query，再modify，更新线段树中节点的count值。

class SegmentTreeNode {
    int start;
    int end;
    int count;
    SegmentTreeNode left;
    SegmentTreeNode right;
    public SegmentTreeNode(int start, int end, int count) {
        this.start = start;
        this.end = end;
        this.count = count;
        left = null;
        right = null;
    }
}
public class Solution {
   /**
     * @param A: An integer array
     * @return: Count the number of element before this element 'ai' is
     *          smaller than it and return count number array
     */
    public ArrayList<Integer> countOfSmallerNumberII(int[] A) {
        // write your code here
        ArrayList<Integer> result = new ArrayList<>();
        if (A == null || A.length == 0) {
            return result;
        }
        SegmentTreeNode root = build(0, 10000);
        for (int num : A) {
            result.add(query(root, 0, num - 1));
            modify(root, num, 1);
        }
        return result;
    }
    public SegmentTreeNode build(int start, int end) {
        if (start > end) {
            return null;
        }
        if (start == end) {
            return new SegmentTreeNode(start, start, 0);
        }
        SegmentTreeNode root = new SegmentTreeNode(start, end, 0);
        int mid = start + (end - start) / 2;
        root.left = build(start, mid);
        root.right = build(mid + 1, end);
        return root;
    }
    public int query(SegmentTreeNode root, int start, int end) {
        if (root == null || start > end) {
            return 0;
        }
        if (start <= root.start && end >= root.end) {
            return root.count;
        }
        int mid = root.start + (root.end - root.start) / 2;
        if (start <= mid && end <= mid) {
            return query(root.left, start, end);
        }
        if (start <= mid && end > mid) {
            return query(root.left, start, mid)
                + query(root.right, mid + 1, end);
        }
        return query(root.right, start, end);
    }
    public void modify(SegmentTreeNode root, int index, int value) {
        if (root == null) {
            return;
        }
        if (root.start == root.end) {
            root.count += value;
            return;
        }
        int mid = root.start + (root.end - root.start) / 2;
        if (index <= mid) {
            modify(root.left, index, value);
        } else {
            modify(root.right, index, value);
        }
        root.count = root.left.count + root.right.count;
    }
}

 

Min Stack

Implement a stack with min() function, which will return the smallest number in the stack.

It should support push, pop and min operation all in O(1) cost.

 Notice

min operation will never be called if there is no number in the stack.

Have you met this question in a real interview? Yes
Example
push(1)
pop()   // return 1
push(2)
push(3)
min()   // return 2
push(1)
min()   // return 1

思路I:两个栈，一个栈stack保存元素，另一个栈minStack保存当前stack中的最小值，minStack元素个数等于stack中的元素个数。

public class MinStack {
    Stack<Integer> stack;
    Stack<Integer> minStack;
    public MinStack() {
        // do initialize if necessary
        stack = new Stack<Integer>();
        minStack = new Stack<Integer>();
    }

    public void push(int number) {
        // write your code here
        stack.push(number);
        if (minStack.isEmpty()) {
            minStack.push(number);
        } else {
            minStack.push(Math.min(number, minStack.peek()));
        }
    }

    public int pop() {
        // write your code here
        minStack.pop();
        return stack.pop();
    }

    public int min() {
        // write your code here
        return minStack.peek();
    }
}

优化：minStack只存储小于等于当前minStack栈顶元素的值。但是空间复杂度不会改变。

public class MinStack {
    Stack<Integer> stack;
    Stack<Integer> minStack;
    public MinStack() {
        // do initialize if necessary
        stack = new Stack<Integer>();
        minStack = new Stack<Integer>();
    }

    public void push(int number) {
        // write your code here
        stack.push(number);
        if (minStack.isEmpty()) {
            minStack.push(number);
        } else {
            if (number <= minStack.peek()) {
                minStack.push(number);
            }
        }
    }

    public int pop() {
        // write your code here
        //注意这里判断两个Integer对象相等时一律用equals方法，直邮Integer的值在-128 - 127才不会new Integer，直接==比较不会出错。超出这个范围比较的就是内存地址。
        if (stack.peek().equals(minStack.peek())) {
            minStack.pop();
        }
        return stack.pop();
    }

    public int min() {
        // write your code here
        return minStack.peek();
    }
}

 

Largest Rectangle in Histogram

Given n non-negative integers representing the histogram's bar height where the width of each bar is 1, find the area of largest rectangle in the histogram.

histogram

Above is a histogram where width of each bar is 1, given height = [2,1,5,6,2,3].

histogram

The largest rectangle is shown in the shaded area, which has area = 10 unit.

Have you met this question in a real interview? Yes
Example
Given height = [2,1,5,6,2,3],
return 10.

思路：单调栈  注意循环次数为length + 1次！！！栈中存储的是索引。

public class Solution {
    /**
     * @param height: A list of integer
     * @return: The area of largest rectangle in the histogram
     */
    public int largestRectangleArea(int[] height) {
        // write your code here
        if (height == null || height.length == 0) {
            return 0;
        }
        Stack<Integer> stack = new Stack<>();
        int max = 0;
        // 注意这里的i要循环到height.length
        for (int i = 0; i <= height.length; i++) {
            int cur = i == height.length ? 0 : height[i];
            while (!stack.isEmpty() && cur <= height[stack.peek()]) {
                int h = height[stack.pop()];
                int w = stack.isEmpty() ? i : i - stack.peek() - 1;
                max = Math.max(max, h * w);
            }
            stack.push(i);
        }
        return max;
    }
}

 

Maximal Rectangle

Given a 2D boolean matrix filled with False and True, find the largest rectangle containing all True and return its area.

Have you met this question in a real interview? Yes
Example
Given a matrix:

[
  [1, 1, 0, 0, 1],
  [0, 1, 0, 0, 1],
  [0, 0, 1, 1, 1],
  [0, 0, 1, 1, 1],
  [0, 0, 0, 0, 1]
]
return 6.

思路：单调栈  二维数组从上到下累计直方图的高度，每一行看作是直方图的宽度。然后转化为求每一行的直方图能构成的最大面积即转化成Largest Rectangle in Histogram问题。

public class Solution {
    /**
     * @param matrix a boolean 2D matrix
     * @return an integer
     */
    public int maximalRectangle(boolean[][] matrix) {
        // Write your code here
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }
        int n = matrix.length;
        int m = matrix[0].length;
        int[][] height = new int[n][m];
        for (int i = 0; i < m; i++) {
            height[0][i] = matrix[0][i] ? 1 : 0;
        }
        for (int i = 1; i < n; i++) {
            for (int j = 0; j < m; j++) {
                height[i][j] = matrix[i][j] ? height[i - 1][j] + 1 : 0;  
            }
        }
        int result = 0;
        for (int i = 0; i < n; i++) {
            Stack<Integer> stack = new Stack<>();
            for (int j = 0; j <= m; j++) {
                int cur = j == m ? 0 : height[i][j];
                while (!stack.isEmpty() && cur <= height[i][stack.peek()]) {
                    int h = height[i][stack.pop()];
                    int w = stack.isEmpty() ? j : j - stack.peek() - 1;
                    result = Math.max(result, h * w);
                }
                stack.push(j);
            }
        }
        return result;
    }
}

 

Max Tree

Given an integer array with no duplicates. A max tree building on this array is defined as follow:

The root is the maximum number in the array
The left subtree and right subtree are the max trees of the subarray divided by the root number.
Construct the max tree by the given array.

Have you met this question in a real interview? Yes
Example
Given [2, 5, 6, 0, 3, 1], the max tree constructed by this array is:

    6
   / \
  5   3
 /   / \
2   0   1

思路I：分治法  但是时间复杂度最坏可达到O(n^2)，栈深过大会溢出，如升序序列。

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
class Point {
    int index;
    int val;
    public Point(int index, int val) {
        this.index = index;
        this.val = val;
    }
}
public class Solution {
    /**
     * @param A: Given an integer array with no duplicates.
     * @return: The root of max tree.
     */
    public TreeNode maxTree(int[] A) {
        // write your code here
        if (A == null || A.length == 0) {
            return null;
        }
        return dfsHelper(A, 0, A.length - 1);
    }
    public TreeNode dfsHelper(int[] A, int start, int end) {
        if (start > end) {
            return null;
        }
        if (start == end) {
            return new TreeNode(A[start]);
        }
        Point point = findMaximum(A, start, end);
        //System.out.println(point.index + "  " + point.val);
        TreeNode root = new TreeNode(point.val);
        root.left = dfsHelper(A, start, point.index - 1);
        root.right = dfsHelper(A, point.index + 1, end);
        return root;
    }
    public Point findMaximum(int[] A, int start, int end) {
        int index = -1;
        int max = Integer.MIN_VALUE;
        for (int i = start; i <= end; i++) {
            if (A[i] >= max) {
                max = A[i];
                index = i;
            }
        }
        return new Point(index, max);
    }
}

思路II：单调递减栈，找出每个数往左数第一个比他大的数和往右数第一个比他大的数，两者中较小的数即为该数的父亲节点。每个数往左数第一个比他大的数用单调递减栈来维护，当遇到往右数第一个比他大的数就把栈顶元素pop出来，补充该节点与父亲节点的关系。循环次数为length（数组长度） + 1。为了完善所有节点的关系，虚拟出一个节点，值为Integer.MAX_VALUE,确保所有节点的关系。

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param A: Given an integer array with no duplicates.
     * @return: The root of max tree.
     */
    public TreeNode maxTree(int[] A) {
        // write your code here
        if (A == null || A.length == 0) {
            return null;
        }
        Stack<TreeNode> stack = new Stack<>();
        for (int i = 0; i <= A.length; i++) {
            TreeNode right = i == A.length ? new TreeNode(Integer.MAX_VALUE) : new TreeNode(A[i]);
            while (!stack.isEmpty() && right.val >= stack.peek().val) {
                TreeNode cur = stack.pop();
                if (stack.isEmpty()) {
                    right.left = cur;
                } else {
                    TreeNode left = stack.peek();
                    if (left.val > right.val) {
                        right.left = cur;
                    } else {
                        left.right = cur;
                    }
                }
            }
            stack.push(right);
        }
        return stack.peek().left;
    }
}

 

Expression Tree Build

The structure of Expression Tree is a binary tree to evaluate certain expressions.
All leaves of the Expression Tree have an number string value. All non-leaves of the Expression Tree have an operator string value.

Now, given an expression array, build the expression tree of this expression, return the root of this expression tree.

Have you met this question in a real interview? Yes
Clarification
See wiki:
Expression Tree

Example
For the expression (2*6-(23+7)/(1+2)) (which can be represented by ["2" "*" "6" "-" "(" "23" "+" "7" ")" "/" "(" "1" "+" "2" ")"]). 
The expression tree will be like

                 [ - ]
             /          \
        [ * ]              [ / ]
      /     \           /         \
    [ 2 ]  [ 6 ]      [ + ]        [ + ]
                     /    \       /      \
                   [ 23 ][ 7 ] [ 1 ]   [ 2 ] .
After building the tree, you just need to return root node [-].

 思路：首先定义一个Node，对于每一个符号或者数字，附上一个val，以便于之后evaluate它，来建立树

　　　 如果expression[i]等于"("或者")"调整base然后continue跳过后面的步骤

　　　 维护一个单调递增stack，建立最小树，类似题[Max Tree]

/**
 * Definition of ExpressionTreeNode:
 * public class ExpressionTreeNode {
 *     public String symbol;
 *     public ExpressionTreeNode left, right;
 *     public ExpressionTreeNode(String symbol) {
 *         this.symbol = symbol;
 *         this.left = this.right = null;
 *     }
 * }
 */
class Node {
    int val;
    ExpressionTreeNode treeNode;
    public Node(int val, String s) {
        this.val = val;
        treeNode = new ExpressionTreeNode(s);
    }
}
public class Solution {
    /**
     * @param expression: A string array
     * @return: The root of expression tree
     */
    public ExpressionTreeNode build(String[] expression) {
        // write your code here
        if (expression == null || expression.length == 0) {
            return null;
        }
        Stack<Node> stack = new Stack<>();
        int base = 0;
        int val = 0;
        for (int i = 0; i <= expression.length; i++) {
            if (i < expression.length) {
                if (expression[i].equals("(")) {
                    base += 10;
                    continue;
                }
                if (expression[i].equals(")")) {
                    base -= 10;
                    continue;
                }
                val = getWeight(base, expression[i]);
            }
            Node right = i == expression.length ?
                new Node(Integer.MIN_VALUE, "") : new Node(val, expression[i]);
            while (!stack.isEmpty() && right.val <= stack.peek().val) {
               Node cur = stack.pop();
               if (stack.isEmpty()) {
                   right.treeNode.left = cur.treeNode;
               } else {
                   if (stack.peek().val < right.val) {
                       right.treeNode.left = cur.treeNode;
                   } else {
                       stack.peek().treeNode.right = cur.treeNode;
                   }
               }
            }
            stack.push(right);
        }
        return stack.pop().treeNode.left;
    }
    public int getWeight(int base, String s) {
        if (s.equals("+") || s.equals("-")) {
            return base + 1;
        }
        if (s.equals("*") || s.equals("/")) {
            return base + 2;
        }
        return Integer.MAX_VALUE;
    }
}

 

Expression Evaluation

Given an expression string array, return the final result of this expression

 Notice

The expression contains only integer, +, -, *, /, (, ).

Have you met this question in a real interview? Yes
Example
For the expression 2*6-(23+7)/(1+2),
input is

[
  "2", "*", "6", "-", "(",
  "23", "+", "7", ")", "/",
  (", "1", "+", "2", ")"
],
return 2

思路：两个栈，一个栈存数字，一个栈存操作符。

入栈操作：

　　　1. 遇到"("，放入操作符栈

　　　2. 遇到")"，取出数字栈中两个数与操作符栈中一个操作符运算，将结果存入数字栈，循环该过程直到遇到"("，然后从操作符栈中pop出"("。

　　　3. 遇到操作符，如果当前操作符栈中的优先级等于或者高于（等于也要运算，防止类似"999/3/3/3"表达式执行错误的运算顺序）该操作符，取出数字栈中两  　　　　 个数与操作符栈中一个操作符运算，将结果存入数字栈，循环该过程，直到当前操作符栈中的优先级小于该操作符或者遇到"("。

　　　4. 遇到数字，直接存入数字栈。

出栈操作：　　

　　　然后对数字栈和操作符栈中剩余的元素进行：取出数字栈中两个数与操作符栈中一个操作符运算，将结果存入数字栈，循环该过程。最后操作符栈应该为空， 　　　数字栈只剩下一个数，返回这个数。注意这里需要判断数字栈是否为空，比如表达式"((()))"执行程序后数字栈为空，返回0；不为空才返回这个数。

public class Solution {
    /**
     * @param expression: an array of strings;
     * @return: an integer
     */
    public int evaluateExpression(String[] expression) {
        // write your code here
        if (expression == null || expression.length == 0) {
            return 0;
        }
        Stack<Integer> values = new Stack<>();
        Stack<String> ops = new Stack<>();
        for (int i = 0; i < expression.length; i++) {
            if (expression[i].equals("(")) {
                ops.push("(");
            } else if (expression[i].equals(")")) {
                while (!ops.peek().equals("(")) {
                    int result = calculate(values, ops);
                    values.push(result);
                }
                ops.pop();
            } else if (isOperation(expression[i])) {
                while (!ops.isEmpty()
                    && hasPrecedence(ops.peek(), expression[i])) {
                    int result = calculate(values, ops);
                    values.push(result);
                }
                ops.push(expression[i]);
            } else {
                values.push(Integer.parseInt(expression[i]));
            }
        }
        while (!ops.isEmpty()) {
            int result = calculate(values, ops);
            values.push(result);
        }
        if (values.isEmpty()) {
            return 0;
        }
        return values.pop();
    }
    public boolean isOperation(String s) {
        return s.equals("+") || s.equals("-") || s.equals("*") || s.equals("/");
    }
    public int calculate(Stack<Integer> values, Stack<String> ops) {
        String operation = ops.pop();
        int a = values.pop();
        int b = values.pop();
        if (operation.equals("+")) {
            return b + a;
        } else if (operation.equals("-")) {
            return b - a;
        } else if (operation.equals("*")) {
            return b * a;
        } else {
            return b / a;
        }
    }
    public boolean hasPrecedence(String s1, String s2) {
        if (s1.equals("(")) {
            return false;
        }
        if ((s1.equals("+") || s1.equals("-"))
            && (s2.equals("*") || s2.equals("/"))) {
            return false;
        }
        return true;
    }
}

 

Convert Expression to Reverse Polish Notation

Given an expression string array, return the Reverse Polish notation of this expression. (remove the parentheses)

Have you met this question in a real interview? Yes
Example
For the expression [3 - 4 + 5] (which denote by ["3", "-", "4", "+", "5"]), return [3 4 - 5 +] (which denote by ["3", "4", "-", "5", "+"])

思路：先Expression Tree Build，然后后序遍历该树就能求出逆波兰表示法。逆波兰表示法实际上就是二叉树的后序遍历。

class TreeNode {
    int val;
    String s;
    TreeNode left;
    TreeNode right;
    public TreeNode(int val, String s) {
        this.val = val;
        this.s = s;
        left = null;
        right = null;
    }
}
public class Solution {
    /**
     * @param expression: A string array
     * @return: The Reverse Polish notation of this expression
     */
    public ArrayList<String> convertToRPN(String[] expression) {
        // write your code here
        ArrayList<String> result = new ArrayList<>();
        if (expression == null || expression.length == 0) {
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        int val = 0;
        int base = 0;
        for (int i = 0; i <= expression.length; i++) {
            if (i < expression.length) {
                if (expression[i].equals("(")) {
                    base += 10;
                    continue;
                }
                if (expression[i].equals(")")) {
                    base -= 10;
                    continue;
                }
                val = getWeight(base, expression[i]);
            }
            TreeNode right = i == expression.length ? new TreeNode(Integer.MIN_VALUE, "") : new TreeNode(val, expression[i]);
            while (!stack.isEmpty() && right.val <= stack.peek().val) {
                TreeNode cur = stack.pop();
                if (stack.isEmpty()) {
                    right.left = cur;
                } else {
                    if (stack.peek().val < right.val) {
                        right.left = cur;
                    } else {
                        stack.peek().right = cur;
                    }
                }
            }
            stack.push(right);
        }
        dfsHelper(stack.pop().left, result);
        return result;
    }
    public int getWeight(int base, String s) {
        if (s.equals("+") || s.equals("-")) {
            return base + 1;
        }
        if (s.equals("*") || s.equals("/")) {
            return base + 2;
        }
        return Integer.MAX_VALUE;
    }
    public void dfsHelper(TreeNode root, ArrayList<String> result) {
        if (root == null) {
            return;
        }
        if (root.left != null) {
            dfsHelper(root.left, result);
        }
        if (root.right != null) {
            dfsHelper(root.right, result);
        }
        result.add(root.s);
    }
}

 

Convert Expression to Polish Notation

Given an expression string array, return the Polish notation of this expression. (remove the parentheses)

Have you met this question in a real interview? Yes
Clarification
Definition of Polish Notation:

http://en.wikipedia.org/wiki/Polish_notation
http://baike.baidu.com/view/7857952.htm
Example
For the expression [(5 − 6) * 7] (which represented by ["(", "5", "−", "6", ")", "*", "7"]), the corresponding polish notation is [* - 5 6 7] (which the return value should be ["*", "−", "5", "6", "7"]).

思路：先Expression Tree Build，然后前序遍历该树就能求出波兰表示法。波兰表示法实际上就是二叉树的前序遍历。

class TreeNode {
    int val;
    String s;
    TreeNode left;
    TreeNode right;
    public TreeNode(int val, String s) {
        this.val = val;
        this.s = s;
        left = null;
        right = null;
    }
}
public class Solution {
    /**
     * @param expression: A string array
     * @return: The Polish notation of this expression
     */
    public ArrayList<String> convertToPN(String[] expression) {
        // write your code here
        ArrayList<String> result = new ArrayList<>();
        if (expression == null || expression.length == 0) {
            return result;
        }
        Stack<TreeNode> stack = new Stack<>();
        int val = 0;
        int base = 0;
        for (int i = 0; i <= expression.length; i++) {
            if (i < expression.length) {
                if (expression[i].equals("(")) {
                    base += 10;
                    continue;
                }
                if (expression[i].equals(")")) {
                    base -= 10;
                    continue;
                }
                val = getWeight(base, expression[i]);
            }
            TreeNode right = i == expression.length ? new TreeNode(Integer.MIN_VALUE, "") : new TreeNode(val, expression[i]);
            while (!stack.isEmpty() && right.val <= stack.peek().val) {
                TreeNode cur = stack.pop();
                if (stack.isEmpty()) {
                    right.left = cur;
                } else {
                    if (stack.peek().val < right.val) {
                        right.left = cur;
                    } else {
                        stack.peek().right = cur;
                    }
                }
            }
            stack.push(right);
        }
        dfsHelper(stack.pop().left, result);
        return result;
    }
    public int getWeight(int base, String s) {
        if (s.equals("+") || s.equals("-")) {
            return base + 1;
        }
        if (s.equals("*") || s.equals("/")) {
            return base + 2;
        }
        return Integer.MAX_VALUE;
    }
    public void dfsHelper(TreeNode root, ArrayList<String> result) {
        if (root == null) {
            return;
        }
        result.add(root.s);
        if (root.left != null) {
            dfsHelper(root.left, result);    
        }
        if (root.right != null) {
            dfsHelper(root.right, result);
        }
    }
}

 

Find Peak Element

There is an integer array which has the following features:

The numbers in adjacent positions are different.
A[0] < A[1] && A[A.length - 2] > A[A.length - 1].
We define a position P is a peek if:

A[P] > A[P-1] && A[P] > A[P+1]
Find a peak element in this array. Return the index of the peak.

 Notice

The array may contains multiple peeks, find any of them.

Have you met this question in a real interview? Yes
Example
Given [1, 2, 1, 3, 4, 5, 7, 6]

Return index 1 (which is number 2) or 6 (which is number 7)

思路：根据A[mid]与A[mid - 1](单调性)来二分

class Solution {
    /**
     * @param A: An integers array.
     * @return: return any of peek positions.
     */
    public int findPeak(int[] A) {
        // write your code here
        if (A == null || A.length < 3) {
            return 0;
        }
        int start = 0;
        int end = A.length - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (A[mid] < A[mid - 1]) {
                end = mid;
            } else {
                start = mid;
            }
        }
        if (A[start] < A[end]) {
            return end;
        }
        return start;
    }
}

 

Find Peak Element II

There is an integer matrix which has the following features:

The numbers in adjacent positions are different.
The matrix has n rows and m columns.
For all i < m, A[0][i] < A[1][i] && A[n - 2][i] > A[n - 1][i].
For all j < n, A[j][0] < A[j][1] && A[j][m - 2] > A[j][m - 1].
We define a position P is a peek if:

A[j][i] > A[j+1][i] && A[j][i] > A[j-1][i] && A[j][i] > A[j][i+1] && A[j][i] > A[j][i-1]
Find a peak element in this matrix. Return the index of the peak.

 Notice

The matrix may contains multiple peeks, find any of them.

Have you met this question in a real interview? Yes
Example
Given a matrix:

[
  [1 ,2 ,3 ,6 ,5],
  [16,41,23,22,6],
  [15,17,24,21,7],
  [14,18,19,20,10],
  [13,14,11,10,9]
]
return index of 41 (which is [1,1]) or index of 24 (which is [2,2])

思路I：根据列取最大值，根据上一行对应位置或者下一行对应位置是否比该位置的值大来进行二分。时间复杂度O(nlgn)

class Solution {
    /**
     * @param A: An integer matrix
     * @return: The index of the peak
     */
    public List<Integer> findPeakII(int[][] A) {
        // write your code here
        List<Integer> result = new ArrayList<>();
        if (A == null || A.length == 0 || A[0].length == 0) {
            return result;
        }
        int n = A.length;
        int m = A[0].length;
        if (n < 3 || m < 3) {
            return result;
        }
        int start = 0;
        int end = n - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            int column = findRowPeak(A, mid);
            if (A[mid][column] < A[mid - 1][column]) {
                end = mid;
            } else {
                start = mid;
            }
        }
        int column = findRowPeak(A, start);
        if (A[start][column] > A[end][column]) {
            result.add(start);
            result.add(column);
            return result;
        }
        column = findRowPeak(A, end);
        result.add(end);
        result.add(column);
        return result;
    }
    public int findRowPeak(int[][] A, int index) {
        int max = A[index][0];
        int column = 0;
        for (int i = 0; i < A[index].length; i++) {
            if (A[index][i] > max) {
                max = A[index][i];
                column = i;
            }
        }
        return column;
    }
}

思路II：采用思路I，但是交替按照行和列进行二分。时间复杂度O(n)

class Solution {
    /**
     * @param A: An integer matrix
     * @return: The index of the peak
     */
    public List<Integer> findPeakII(int[][] A) {
        // write your code here
        List<Integer> result = new ArrayList<>();
        if (A == null || A.length < 3 || A[0].length < 3) {
            return result;
        }
        int n = A.length;
        int m = A[0].length;
        return find(A, 0, n - 1, 0, m - 1, true);
    }
    public List<Integer> find(int[][] A, int x1, int x2, int y1, int y2, boolean flag) {
        if (flag) {
            int mid = x1 + (x2 - x1) / 2;
            int index = 0;
            for (int i = y1; i <= y2; i++) {
                if (A[mid][i] > A[mid][index]) {
                    index = i;
                }
            }
            if (A[mid - 1][index] > A[mid][index]) {
                return find(A, x1, mid - 1, y1, y2, !flag);
            } else if (A[mid + 1][index] > A[mid][index]) {
                return find(A, mid + 1, x2, y1, y2, !flag);
            } else {
                return Arrays.asList(mid, index);
            }
        } else {
            int mid = y1 + (y2 - y1) / 2;
            int index = 0;
            for (int i = x1; i <= x2; i++) {
                if (A[i][mid] > A[index][mid]) {
                    index = i;
                }
            }
            if (A[index][mid - 1] > A[index][mid]) {
                return find(A, x1, x2, y1, mid - 1, !flag);
            } else if (A[index][mid + 1] > A[index][mid]) {
                return find(A, x1, x2, mid + 1, y2, !flag);
            } else {
                return Arrays.asList(index, mid);
            }
        }
    }
}

 

Sqrt(x)

Implement int sqrt(int x).

Compute and return the square root of x.

Have you met this question in a real interview? Yes
Example
sqrt(3) = 1

sqrt(4) = 2

sqrt(5) = 2

sqrt(10) = 3

思路：从0 ～ x二分答案。易错点：mid * mid很容易超过整数表示范围，所以check的时候记得转为long比较。

class Solution {
    /**
     * @param x: An integer
     * @return: The sqrt of x
     */
    public int sqrt(int x) {
        // write your code here
        if (x < 0) {
            return -1;
        }
        int start = 0;
        int end = x;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if ((long) mid * mid <= (long) x) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if ((long) end * end <= (long) x) {
            return end;
        }
        return start;
    }
}

 

Sqrt(x) II

Implement double sqrt(double x) and x >= 0.

Compute and return the square root of x.

 注意事项

You do not care about the accuracy of the result, we will help you to output results.

您在真实的面试中是否遇到过这个题？ Yes
样例
Given n = 2 return 1.41421356

思路：从0 ～ x二分答案。易错点：由于二分的是double数，当这个二分数<1时你永远也不可能二分到想要的答案，最后的二分结果就是这个数本身，所以这种情况下end的取值应该置为1才行。还有注意浮点数二分的二分模版上与整数二分的不同，while是end - start是大于某个精度（比题目给定的精度还要小以保证结果的正确性）循环。

public class Solution {
    /**
     * @param x a double
     * @return the square root of x
     */
    public double sqrt(double x) {
        // Write your code here
        if (x < 0) {
            return -1;
        }
        double start = 0;
        double end = x;
        if (end < 1) {
            end = 1;
        }
        while (end - start > 1e-12) {
            double mid = start + (end - start) / 2;
            if (mid * mid <= x) {
                start = mid;
            } else {
                end = mid;
            }
        }
        return start;
    }
}

 

Find the Duplicate Number

Given an array nums containing n + 1 integers where each integer is between 1 and n (inclusive), prove that at least one duplicate number must exist. Assume that there is only one duplicate number, find the duplicate one.

 Notice

You must not modify the array (assume the array is read only).
You must use only constant, O(1) extra space.
Your runtime complexity should be less than O(n^2).
There is only one duplicate number in the array, but it could be repeated more than once.
Have you met this question in a real interview? Yes
Example
Given nums = [5,5,4,3,2,1] return 5
Given nums = [5,4,4,3,2,1] return 4

思路：从可能的答案范围1 ～ n进行二分，当在数组中小于等于mid的元素个数等于mid说明小于等于mid的元素都不是重复元素，反之小于等于mid的元素中含有重复元素。

public class Solution {
    /**
     * @param nums an array containing n + 1 integers which is between 1 and n
     * @return the duplicate one
     */
    public int findDuplicate(int[] nums) {
        // Write your code here
        if (nums == null || nums.length < 2) {
            return 0;
        }
        int start = 1;
        int end = nums.length - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (check(mid, nums) <= mid) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (check(start, nums) <= start) {
            return end;
        }
        return start;
    }
    public int check(int num, int[] nums) {
        int result =  0;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] <= num) {
                result++;
            }
        }
        return result;
    }
}

 

Wood Cut

Given n pieces of wood with length L[i] (integer array). Cut them into small pieces to guarantee you could have equal or more than k pieces with the same length. What is the longest length you can get from the n pieces of wood? Given L & k, return the maximum length of the small pieces.

 Notice

You couldn't cut wood into float length.

If you couldn't get >= k pieces, return 0.

Have you met this question in a real interview? Yes
Example
For L=[232, 124, 456], k=7, return 114.

思路：二分这些木头所能切割成的相等木头的长度，注意二分的区间，既然是长度，范围是1 ～ max（这些木头的长度），不能从0开始，因为所得到的长度不可能是0，0代表不存在这样的长度。Last/Biggest length that can get >= k pieces。

public class Solution {
    /**
     *@param L: Given n pieces of wood with length L[i]
     *@param k: An integer
     *return: The maximum length of the small pieces.
     */
    public int woodCut(int[] L, int k) {
        // write your code here
        if (L == null || L.length == 0 || k < 1) {
            return 0;
        }
        int start = 1;
        int max = 0;
        for (int i = 0; i < L.length; i++) {
            max = Math.max(max, L[i]);
        }
        int end = max;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (count(mid, L) < k) {
                end = mid;
            } else {
                start = mid;
            }
        }
        if (count(end, L) >= k) {
            return end;
        }
        if (count(start, L) >= k) {
            return start;
        }
        return 0;
    }
    public int count(int num, int[] L) {
        int result = 0;
        for (int i = 0; i < L.length; i++) {
            result += L[i] / num;
        }
        return result;
    }
}

 

Copy Books

Given n books and the ith book has A[i] pages. You are given k people to copy the n books.

n books list in a row and each person can claim a continous range of the n books. For example one copier can copy the books from ith to jth continously, but he can not copy the 1st book, 2nd book and 4th book (without 3rd book).

They start copying books at the same time and they all cost 1 minute to copy 1 page of a book. What's the best strategy to assign books so that the slowest copier can finish at earliest time?

Have you met this question in a real interview? Yes
Example
Given array A = [3,2,4], k = 2.

Return 5( First person spends 5 minutes to copy book 1 and book 2 and second person spends 4 minutes to copy book 3. )

思路：Smallest time that k people can copy all books。二分抄书所需要的时间，范围是max(抄每本书的时间）～sum(抄每本书的时间)，而且答案一定在这个范围内！对每一个二分的抄书时间，判断在这个时间下k个人能不能抄完所有书，这个判断可以转化为在这个时间下所需要的最小抄书人数是不是小于等于k。

public class Solution {
    /**
     * @param pages: an array of integers
     * @param k: an integer
     * @return: an integer
     */
    public int copyBooks(int[] pages, int k) {
        // write your code here
        if (pages == null || pages.length == 0 || k < 1) {
            return 0;
        }
        int max = 0;
        int sum = 0;
        for (int i = 0; i < pages.length; i++) {
            max = Math.max(max, pages[i]);
            sum += pages[i];
        }
        int start = max;
        int end = sum;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (countCopiers(mid, pages) <= k) {
                end = mid;
            } else {
                start = mid;
            }
        }
        if (countCopiers(start, pages) <= k) {
            return start;
        }
        return end;
    }
    public int countCopiers(int time, int[] pages) {
        int copiers = 1;
        int sum = 0;
        for (int i = 0; i < pages.length; i++) {
            if (sum + pages[i] > time) {
                copiers++;
                sum = 0;
            }
            sum += pages[i];
        }
        return copiers;
    }
}

 

Maximum Average Subarray

Given an array with positive and negative numbers, find the maximum average subarray which length should be greater or equal to given length k.

 Notice

It's guaranteed that the size of the array is greater or equal to k.

Have you met this question in a real interview? Yes
Example
Given nums = [1, 12, -5, -6, 50, 3], k = 3

Return 15.667 // (-6 + 50 + 3) / 3 = 15.667

 思路：涉及子数组问题用到prefix_sum,sum[i] = sum[i - 1] + num[i - 1]。最大平均和转化为原数组中每一个元素减去二分的mid所得到的数组中是否有一段长度大于等于k的subArray的和大于等于0.

public class Solution {
    /**
     * @param nums an array with positive and negative numbers
     * @param k an integer
     * @return the maximum average
     */
    public double maxAverage(int[] nums, int k) {
        // Write your code here
        if (nums == null || nums.length == 0 || k < 1) {
            return 0;
        }
        double min = Integer.MAX_VALUE;
        double max = Integer.MIN_VALUE;
        for (int i = 0; i < nums.length; i++) {
            min = Math.min(min, nums[i]);
            max = Math.max(max, nums[i]);
        }
        double start = min;
        double end = max;
        while (end - start > 1e-6) {
            double mid = start + (end - start) / 2;
            if (check(nums, mid, k)) {
                start = mid;
            } else {
                end = mid;
            }
        }
        return start;
    }
    public boolean check(int[] nums, double mid, int k) {
        double[] sum = new double[nums.length + 1];
        sum[0] = 0;
        double min_pre = 0;
        for (int i = 1; i < sum.length; i++) {
            sum[i] = sum[i - 1] + nums[i - 1] - mid;
            if (i >= k && sum[i] - min_pre >= 0) {
                return true;
            }
            if (i >= k) {
                min_pre = Math.min(min_pre, sum[i - k + 1]);
            }
        }
        return false;
    }
}

 

第5周 & 第6周　----　 Dynamic Programming

Maximal Square

Given a 2D binary matrix filled with 0's and 1's, find the largest square containing all 1's and return its area.

Have you met this question in a real interview? Yes
Example
For example, given the following matrix:

1 0 1 0 0
1 0 1 1 1
1 1 1 1 1
1 0 0 1 0
Return 4.

思路：1.状态　　dp[i][j] 表示以i和j作为正方形右下角可以拓展的最大边长 

　　　2.方程　　if matrix[i][j] == 1　　dp[i][j] = min(left[i][j-1], up[i-1][j], dp[i-1][j-1]) + 1  

　　　　　　　　(upper[i][j] 表示以i, j 作为全为1的向上长条有多长，left[i][j] 表示以i, j 作为全为1的向左长条有多长,)

　　　　　　　　if matrix[i][j] == 0　　dp[i][j] = 0 

　　　　　　　　然而我们可以将上面这个状态转移方程简化如下面这个：

　　　　　　　　if matrix[i][j] == 1　　dp[i][j] = min(dp[i - 1][j], dp[i][j-1], dp[i-1][j-1]) + 1;

　　　　　　　　if matrix[i][j] == 0　　dp[i][j] = 0 

　　　3.初始化　f[i][0] = matrix[i][0];

　　　　　　　　f[0][j] = matrix[0][j] 

　　　4.答案　　max{dp[i][j]} * max{dp[i][j]} 

public class Solution {
    /**
     * @param matrix: a matrix of 0 and 1
     * @return: an integer
     */
    public int maxSquare(int[][] matrix) {
        // write your code here
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }
        int n = matrix.length;
        int m = matrix[0].length;
        int[][] dp = new int[2][m];
        int result = 0;
        for (int i = 0; i < n; i++) {
            dp[i % 2][0] = matrix[i % 2][0];
            if (dp[i % 2][0] > result) {
                result = dp[i % 2][0];
            }
        }
        for (int j = 0; j < m; j++) {
            dp[0][j] = matrix[0][j];
            if (dp[0][j] > result) {
                result = dp[0][j];
            }
        }
        for (int i = 1; i < n; i++) {
            for (int j = 1; j < m; j++) {
                if (matrix[i % 2][j] == 1) {
                    dp[i % 2][j] = Math.min(Math.min(dp[(i - 1) % 2][j], dp[i % 2][j - 1]), dp[(i - 1) % 2][j - 1]) + 1;
                    if (dp[i % 2][j] > result) {
                        result = dp[i % 2][j];
                    }
                } else {
                    dp[i % 2][j] = 0;
                }
            }
        }
        return result * result;
    }
}

 

Maximal Square II

Given a 2D binary matrix filled with 0's and 1's, find the largest square which diagonal is all 1 and others is 0.

Have you met this question in a real interview? Yes
Example
For example, given the following matrix:

1 0 1 0 0
1 0 0 1 0
1 1 0 0 1
1 0 0 1 0
Return 9

思路：1.状态　　dp[i][j] 表示以i和j作为正方形右下角可以拓展的最大边长

　　　　　　　　upper[i][j] 表示以i, j 作为全为0的向上长条有多长

　　　　　　　　left[i][j] 表示以i, j 作为全为0的向左长条有多长

　　　2.方程　　if matrix[i][j] == 1　　dp[i][j] = 1 + Math.min(dp[i - 1][j - 1], Math.min(up[i - 1][j], left[i][j - 1]))

　　　　　　　　　　　　　　　　　　　  up[i][j] = 0

　　　　　　　　　　　　　　　　　　　  left[i][j] = 0

　　　　　　　　if matrix[i][j] == 0　　dp[i][j] = 0

　　　　　　　　　　　　　　　　　　　  up[i][j] = 1 + up[i - 1][j]

　　　　　　　　　　　　　　　　　　　  left[i][j] = 1 + left[i][j - 1]

　　　3.初始化　　不需要

　　　4.答案　　max{dp[i][j]} * max{dp[i][j]} 

public class Solution {
    /**
     * @param matrix a matrix of 0 and 1
     * @return an integer
     */
    public int maxSquare2(int[][] matrix) {
        // write your code here
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }
        int n = matrix.length;
        int m = matrix[0].length;
        int[][] dp = new int[n][m];
        int[][] up = new int[n][m];
        int[][] left = new int[n][m];
        int length = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (matrix[i][j] == 0) {
                    dp[i][j] = 0;
                    up[i][j] = 1;
                    left[i][j] = 1;
                    if (i > 0) {
                        up[i][j] += up[i - 1][j];
                    }
                    if (j > 0) {
                        left[i][j] += left[i][j - 1];
                    }
                } else {
                    dp[i][j] = 1;
                    if (i > 0 && j > 0) {
                        dp[i][j] = 1 + Math.min(dp[i - 1][j - 1],
                            Math.min(up[i - 1][j], left[i][j - 1]));
                    }
                    up[i][j] = 0;
                    left[i][j] = 0;
                }
                length = Math.max(length, dp[i][j]);
            }
        }
        return length * length;
    }
}

 

区间类DP

特点：1. 求一段区间的解max/min/count

　　　2. 转移方程通过区间更新

　　　3. 从大到小的更新

 

Stone Game

There is a stone game.At the beginning of the game the player picks n piles of stones in a line.

The goal is to merge the stones in one pile observing the following rules:

At each step of the game,the player can merge two adjacent piles to a new pile.
The score is the number of stones in the new pile.
You are to determine the minimum of the total score.

Have you met this question in a real interview? Yes
Example
For [4, 1, 1, 4], in the best solution, the total score is 18:

1. Merge second and third piles => [4, 2, 4], score +2
2. Merge the first two piles => [6, 4]，score +6
3. Merge the last two piles => [10], score +10
Other two examples:
[1, 1, 1, 1] return 8
[4, 4, 5, 9] return 43

思路：1.状态　　dp[i][j] 表示把第i到第j个石子合并到一起的最小花费 

　　　2.方程　　dp[i][j] = min(dp[i][k]+dp[k+1][j]+sum[i,j]) (记得提前初始化sum[i][j])  for k: i ~ j - 1

　　　3.初始化　dp[i][i] = 0 

　　　4.答案　　dp[0][n-1] 

public class Solution {
    /**
     * @param A an integer array
     * @return an integer
     */
    public int stoneGame(int[] A) {
        // Write your code here
        if (A == null || A.length == 0) {
            return 0;
        }
        int n = A.length;
        int[][] sum = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = i; j < n; j++) {
                if (j == i) {
                    sum[i][j] = A[j];
                } else {
                    sum[i][j] = sum[i][j - 1] + A[j];
                }
            }
        }
        int[][] dp = new int[n][n];
        for (int i = 0; i < n; i++) {
            dp[i][i] = 0;
        }
        for (int len = n - 1; len >= 1; len--) {
            for (int i = 0, j = n - len; i < len; i++, j++) {
                dp[i][j] = Integer.MAX_VALUE;
                for (int k = i; k < j; k++) {
                    dp[i][j] = Math.min(dp[i][j], dp[i][k] + dp[k + 1][j] + sum[i][j]);
                }
            }
        }
        return dp[0][n - 1];
    }
}

 

Stone Game II

There is a stone game.At the beginning of the game the player picks n piles of stones in a circle.

The goal is to merge the stones in one pile observing the following rules:

At each step of the game,the player can merge two adjacent piles to a new pile.
The score is the number of stones in the new pile.
You are to determine the minimum of the total score.

Have you met this question in a real interview? Yes
Example
For [1, 4, 4, 1], in the best solution, the total score is 18:

1. Merge second and third piles => [2, 4, 4], score +2
2. Merge the first two piles => [6, 4]，score +6
3. Merge the last two piles => [10], score +10
Other two examples:
[1, 1, 1, 1] return 8
[4, 4, 5, 9] return 43

思路：数组变成循环数组。解决循环方式有三种：1.拆环  2.复制  3.取反

　　　这里采用复制数组的方式解决循环问题。复制前len - 1个元素到原数组末尾，对得到的新数组用Stone Game中一样的方法DP，最后在得到的dp数组中找到长度为len并且score最小子数组。

　　　1.状态　　dp[i][j] 表示把第i到第j个石子合并到一起的最小花费 (dp[2 * n - 1][2 * n - 1])

　　　2.方程　　dp[i][j] = min(dp[i][k]+dp[k+1][j]+sum[i,j]) (记得提前初始化sum[i][j])  for k: i ~ j - 1

　　　3.初始化　dp[i][i] = 0 

　　　4.答案　　dp[i][i + n - 1]  for i : 0 ~ n - 1 

public class Solution {
    /**
     * @param A an integer array
     * @return an integer
     */
    public int stoneGame2(int[] A) {
        // Write your code here
        if (A == null || A.length == 0) {
            return 0;
        }
        int n = A.length;
        int[][] sum = new int[2 * n - 1][2 * n - 1];
        for (int i = 0; i < 2 * n - 1; i++) {
            for (int j = i; j < 2 * n - 1; j++) {
                if (j == i) {
                    sum[i][j] = A[j % n];
                } else {
                    sum[i][j] = sum[i][j - 1] + A[j % n];
                }
            }
        }
        int[][] dp = new int[2 * n - 1][2 * n - 1];
        for (int i = 0; i < 2 * n - 1; i++) {
            dp[i][i] = 0;
        }
        for (int len = 2 * n - 2; len >= 1; len--) {
            for (int i = 0, j = 2 * n - 1 - len; i < len; i++, j++) {
                dp[i][j] = Integer.MAX_VALUE;
                for (int k = i; k < j; k++) {
                    dp[i][j] = Math.min(dp[i][j],
                        dp[i][k] + dp[k + 1][j] + sum[i][j]);
                }
            }
        }
        int result = Integer.MAX_VALUE;
        for (int i = 0; i < n; i++) {
            result = Math.min(result, dp[i][i + n - 1]);
        }
        return result;
    }
}

 

Copy Books

Given n books and the ith book has A[i] pages. You are given k people to copy the n books.

n books list in a row and each person can claim a continous range of the n books. For example one copier can copy the books from ith to jth continously, but he can not copy the 1st book, 2nd book and 4th book (without 3rd book).

They start copying books at the same time and they all cost 1 minute to copy 1 page of a book. What's the best strategy to assign books so that the slowest copier can finish at earliest time?

Have you met this question in a real interview? Yes
Example
Given array A = [3,2,4], k = 2.

Return 5( First person spends 5 minutes to copy book 1 and book 2 and second person spends 4 minutes to copy book 3. )

思路I：二分法。二分答案，即二分抄完书所花费的最短时间。初始范围max ～ sum。如果这些人在二分的时间mid内抄完书所用的最少人数（贪心来求该人数）<=k，说明能完成任务，时间end=mid；否则start = mid。最后Double Check。

public class Solution {
    /**
     * @param pages: an array of integers
     * @param k: an integer
     * @return: an integer
     */
    public int copyBooks(int[] pages, int k) {
        // write your code here
        if (pages == null || pages.length == 0 || k < 1) {
            return 0;
        }
        int max = 0;
        int sum = 0;
        for (int i = 0; i < pages.length; i++) {
            max = Math.max(max, pages[i]);
            sum += pages[i];
        }
        int start = max;
        int end = sum;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (countCopiers(mid, pages) <= k) {
                end = mid;
            } else {
                start = mid;
            }
        }
        if (countCopiers(start, pages) <= k) {
            return start;
        }
        return end;
    }
    public int countCopiers(int time, int[] pages) {
        int copiers = 1;
        int sum = 0;
        for (int i = 0; i < pages.length; i++) {
            if (sum + pages[i] > time) {
                copiers++;
                sum = 0;
            }
            sum += pages[i];
        }
        return copiers;
    }
}

思路II：动态规划。思路同Copy Books II。需要预先求得一个人抄完前i本书所花费的时间sum[i]数组，为状态方程做准备。

　　　1.状态　　dp[i][j] 表示前i+1个人，抄前j本书的最小完成时间。

　　　2.方程　　dp[i][j] = min{max{dp[i - 1][j - k], sum[j] - sum[j - k]}}　　for k：0 ～ j

　　　3.初始化　dp[0][j] = sum[j] for j：0 ~ n;　　dp[i][0] = 0 for i：0 ~ len - 1

　　　4.答案　　dp[len - 1][n]

public class Solution {
    /**
     * @param pages: an array of integers
     * @param k: an integer
     * @return: an integer
     */
    public int copyBooks(int[] pages, int k) {
        // write your code here
        if (pages == null || pages.length == 0) {
            return 0;
        }
        if (k < 1) {
            return Integer.MAX_VALUE;
        }
        int n = pages.length;
        int[] sum = new int[n + 1];
        for (int i = 1; i <= n; i++) {
            sum[i] = sum[i - 1] + pages[i - 1];
        }
        int[][] dp = new int[2][n + 1];
        for (int i = 0; i <= n; i++) {
            dp[0][i] = sum[i];
        }
        for (int i = 1; i < k; i++) {
            for (int j = 1; j <= n; j++) {
                dp[i % 2][j] = Integer.MAX_VALUE;
                for (int t = 0; t <= j; t++) {
                    if (dp[(i - 1) % 2][j - t] < sum[j] - sum[j - t]) {
                        dp[i % 2][j] = Math.min(dp[i % 2][j],
                                                sum[j] - sum[j - t]);
                        break;
                    } else {
                        dp[i % 2][j] = Math.min(dp[i % 2][j],
                                                dp[(i - 1) % 2][j - t]);
                    }
                }
            }
        }
        return dp[(k - 1) % 2][n];
    }
}

 

Copy Books II

Given n books( the page number of each book is the same) and an array of integer with size k means k people to copy the book and the i th integer is the time i th person to copy one book). You must distribute the continuous id books to one people to copy. (You can give book A[1],A[2] to one people, but you cannot give book A[1], A[3] to one people, because book A[1] and A[3] is not continuous.) Return the number of smallest minutes need to copy all the books.

Have you met this question in a real interview? Yes
Example
Given n = 4, array A = [3,2,4], .

Return 4( First person spends 3 minutes to copy book 1, Second person spends 4 minutes to copy book 2 and 3, Third person spends 4 minutes to copy book 4. )

思路：1.状态　　dp[i][j] 表示前i+1个人，抄前j本书的最小完成时间。

　　　2.方程　　dp[i][j] = min{max{dp[i - 1][j - k], k * times[i]}} for k：0 ～ j

　　　3.初始化　dp[0][j] = j * times[0] for j：0 ~ n；dp[i][0] = 0 for i：0 ~ len - 1

　　　4.答案　　dp[len-1][n]

注意：这道题卡时间复杂度和空间复杂度，代码中要注意的地方已经标记。

public class Solution {
    /**
     * @param n: an integer
     * @param times: an array of integers
     * @return: an integer
     */
    public int copyBooksII(int n, int[] times) {
        // write your code here
        if (n <= 0) {
            return 0;
        }
        if (times == null || times.length == 0) {
            return Integer.MAX_VALUE;
        }
        int len = times.length;
        // 这道题对空间复杂度卡的比较严，当人数很多时空间复杂度过大，所以要用滚动数组优化。
        int[][] dp = new int[2][n + 1];
        for (int i = 0; i <= n; i++) {
            dp[0][i] = i * times[0];
        }
        for (int i = 1; i < len; i++) {
            for (int j = 1; j <= n; j++) {
                dp[i % 2][j] = Integer.MAX_VALUE;
                for (int k = 0; k <= j; k++) {
                    if (dp[(i - 1) % 2][j - k] < k * times[i]) {
                        dp[i % 2][j] = Math.min(dp[i % 2][j], k * times[i]);
                        // 这道题对时间复杂度卡的比较严，当进入改if判断语句内说明此时第i + 1个人抄书的时间占大头，
                        // 因此再循环时还会进入改if语句，并且这个时间会越来越大，所以这个if语句只需要进来一次就可以break了。
                        // 实际上当k比较小的时候进入else语句，前i个人的抄书时间占大头；当k较大的时候，进入if语句，
                        // 第i + 1个人抄书的时间占大头,而且if语句执行一次后就break即可。相当于剪枝来优化时间复杂度。
                        break;
                    } else {
                        dp[i % 2][j]
                            = Math.min(dp[i % 2][j], dp[(i - 1) % 2][j - k]);
                    }
                }
                
            }
        }
        return dp[(len - 1) % 2][n];
    }
}

 

Post Office Problem

On one line there are n houses. Give you an array of integer means the the position of each house. Now you need to pick k position to build k post office, so that the sum distance of each house to the nearest post office is the smallest. Return the least possible sum of all distances between each village and its nearest post office.

Have you met this question in a real interview? Yes
Example
Given array a = [1,2,3,4,5], k = 2.
return 3.

思路：

dp[i][j]表示在前i个村庄中建j个post的最短距离，l为分隔点，可以将问题转化为在前l个村庄建j－1个post的最短距离＋在第l＋1到第i个村庄建1个post的最短距离。其中有个性质，如元素是单调排列的，则在中间位置到各个元素的距离和最小。

1. 初始化dis矩阵，枚举不同开头和结尾的村庄之间建1个post的最小距离，即求出开头和结尾村庄的中间点，然后计算开头到结尾的所有点到中间点的距离。记得要对原矩阵排序，这样才能用中间点距离最小性质。

2. 初始化dp矩阵，即初始化dp[i][1]，求前i个村庄建1个post的最小距离（可根据dis求出）。

3. post数l从2枚举到k，开始村庄i从j枚举到结尾（因为要建j个post至少需要j个村庄，否则没有意义,其实可以从j + 1开始枚举），然后根据状态函数求dp[i][j]，分割点l从j－1枚举到i-1（前l个村庄建j－1个post则至少需要j－1个村庄），在这些分隔点的情况下求dp[i][j]的最小值。

4.返回dp[n][k]即可。

　　　1.状态　　dp[i][j] 表示前i个村庄中建j个邮局的最短距离

　　　2.方程　　dp[i][j] = min{dp[l][j - 1] + dis[l + 1][i]　　for j - 1 <= l < i}

　　　3.初始化　dp[i][1] = dis[1][i]　　for 1 <= i <= n

　　　4.答案　　dp[n][k]

public class Solution {
    /**
     * @param A an integer array
     * @param k an integer
     * @return an integer
     */
    public int postOffice(int[] A, int k) {
        // Write your code here
        if (A == null || A.length == 0 || k <= 0 || k >= A.length) {
            return 0;
        }
        //一个Array只有单调才满足中间的数和其它所有数的差的绝对值之和最小
        Arrays.sort(A);
        int[][] dis = initial(A);
        int n = A.length;
        int[][] dp = new int[n + 1][k + 1];
        for (int i = 1; i <= n; i++) {
            dp[i][1] = dis[1][i];
        }
        for (int j = 2; j <= k; j++) {
            for (int i = j + 1; i <= n; i++) {
                dp[i][j] = Integer.MAX_VALUE;
                for (int l = j - 1; l < i; l++) {
                    dp[i][j] = Math.min(dp[i][j], dp[l][j - 1] + dis[l + 1][i]);
                }
            }
        }
        return dp[n][k];
    }
    public int[][] initial(int[] A) {
        int n = A.length;
        int[][] dis = new int[n + 1][n + 1];
        for (int i = 1; i < n; i++) {
            for (int j = i + 1; j <= n; j++) {
                int mid = (i + j) / 2;
                for (int k = i; k <= j; k++) {
                    dis[i][j] += Math.abs(A[k - 1] - A[mid - 1]);
                }
            }
        }
        return dis;
    }
}

 

 双序列DP

1. state: f[i][j]代表了第一个sequence的前i个数字/字符，配上第二个sequence的前j个...

2. function: f[i][j] = 研究第i个和第j个的匹配关系
3. initialize: f[i][0] 和 f[0][i]
4. answer: f[n][m] min/max/数目/存在关系

5. n = s1.length()　　m = s2.length() 

解题技巧画矩阵，填写矩阵 

 

Edit Distance

Given two words word1 and word2, find the minimum number of steps required to convert word1 to word2. (each operation is counted as 1 step.)

You have the following 3 operations permitted on a word:

Insert a character
Delete a character
Replace a character
Have you met this question in a real interview? Yes
Example
Given word1 = "mart" and word2 = "karma", return 3.

思路：1.状态　　dp[i][j]表示A的前i个字符最少要用几次编辑可以变成B的前j个字符

　　　2.方程　　A[i - 1] == B[j - 1]，dp[i][i] = dp[i - 1][j - 1]；A[i - 1] != B[j - 1]，dp[i][j] = 1 + Math.min(Math.min(dp[i - 1][j], dp[i][j - 1]), 　　　　　　　　dp[i - 1][j - 1])。

　　　3.初始化　dp[i][0] = i　　dp[0][j] = j

　　　4.答案　　dp[n][m]

　　　5. 可以用滚动数组优化空间复杂度

public class Solution {
    /**
     * @param word1 & word2: Two string.
     * @return: The minimum number of steps.
     */
    public int minDistance(String word1, String word2) {
        // write your code here
        if (word1 == null || word2 == null) {
            return 0;
        }
        int n = word1.length();
        int m = word2.length();
        int[][] dp = new int[2][m + 1];
        for (int j = 0; j < m + 1; j++) {
            dp[0][j] = j;
        }
        for (int i = 1; i < n + 1; i++) {
            for (int j = 0; j < m + 1; j++) {
                if (j == 0) {
                    dp[i % 2][j] = i;
                } else {
                    if (word1.charAt(i - 1) == word2.charAt(j - 1)) {
                        dp[i % 2][j] = dp[(i - 1) % 2][j - 1];
                    } else {
                        dp[i % 2][j] =
                            Math.min(dp[(i - 1) % 2][j - 1],
                                Math.min(dp[(i - 1) % 2][j],
                                    dp[i % 2][j - 1])) + 1;
                    }
                }
            }
        }
        return dp[n % 2][m];
    }
}

 

K Edit Distance

Given a set of strings which just has lower case letters and a target string, output all the strings for each the edit distance with the target no greater than k.

You have the following 3 operations permitted on a word:

Insert a character
Delete a character
Replace a character
Have you met this question in a real interview? Yes
Example
Given words = ["abc", "abd", "abcd", "adc"] and target = "ac", k = 1
Return ["abc", "adc"]

思路：暴力法，按Edit Distance思路对每个word计算最短编辑距离然后判断该距离是否小于等于k，不可取。考虑到这些word有很多重复，因此这些word可以用trie树来存储，从而减少重复字母的最小编辑距离的计算。也就是在trie树上跑动态规划。

class TrieNode {
    Map<Character, TrieNode> children;
    boolean hasWord;
    String word;
    public TrieNode() {
        children = new HashMap<>();
        hasWord = false;
        word = null;
    }
}
class Trie {
    TrieNode root;
    public Trie() {
        root = new TrieNode();
    }
    public void insert(String word) {
        TrieNode cur = root;
        char[] wordArray = word.toCharArray();
        for (char c : wordArray) {
            if (!cur.children.containsKey(c)) {
                cur.children.put(c, new TrieNode());
            }
            cur = cur.children.get(c);
        }
        cur.hasWord = true;
        cur.word = word;
    }
}
public class Solution {
    /**
     * @param words a set of stirngs
     * @param target a target string
     * @param k an integer
     * @return output all the strings that meet the requirements
     */
    public List<String> kDistance(String[] words, String target, int k) {
        // Write your code here
        List<String> result = new ArrayList<>();
        if (words == null) {
            return result;
        }
        Trie trie = new Trie();
        for (int i = 0; i < words.length; i++) {
            trie.insert(words[i]);
        }
        int n = target.length();
        int[] dp = new int[n + 1];
        for (int i = 0; i <= n; i++) {
            dp[i] = i;
        }
        find(trie.root, target, dp, k, result);
        return result;
    }
    public void find(TrieNode node, String target, int[] dp, int k,
        List<String> result) {
        int n = target.length();
        if (node.hasWord && dp[n] <= k) {
            result.add(node.word);
        }
        int[] next = new int[n + 1];
        for (Character c : node.children.keySet()) {
            next[0] = dp[0] + 1;
            for (int i = 1; i <= n; i++) {
                if (c == target.charAt(i - 1)) {
                    next[i] = dp[i - 1];
                } else {
                    next[i] = 1 + Math.min(Math.min(dp[i - 1], dp[i]),
                        next[i - 1]);
                }
            }
            find(node.children.get(c), target, next, k, result);
        }
    }
}

 

动态规划 & 贪心

121. Best Time to Buy and Sell Stock

Say you have an array for which the ith element is the price of a given stock on day i.

If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.

Example 1:
Input: [7, 1, 5, 3, 6, 4]
Output: 5

max. difference = 6-1 = 5 (not 7-1 = 6, as selling price needs to be larger than buying price)
Example 2:
Input: [7, 6, 4, 3, 1]
Output: 0

In this case, no transaction is done, i.e. max profit = 0.

思路I：动态规划  动态规划的一般方式是利用一个数组dp[]用来存储如果以今天结尾, 能得到的结果。 对于我们这个问题来说, 就是用来存储到第i天的为止, 如果只能买卖一次股票, 所能获得的最大收益。 这个收益和截止到前一天为止的最大收益有关 — 或者说是昨天的收益有关, 我们将这个收益称为A。 它还和今天的股价有关, 确切的说, 是和今天的股价和截止到今天为止的最小股价的差有关, 这个差即为如果今天卖出, 可以得到 的最大收益, 我们将这个收益称为B。 今天的最终最大收益则为A和B中大的那个。

public class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length <= 1) {
            return 0;
        }
        int n = prices.length;
        int[] dp = new int[n + 1];
        int min = prices[0];
        for (int i = 2; i <= n; i++) {
            dp[i] = Math.max(dp[i - 1], prices[i - 1] - min);
            min = Math.min(min, prices[i - 1]);
        }
        return dp[n];
    }
}

思路II：贪心  如果用贪心的思想, 我们不需要保存每天的状态, 而只需要保存截至到目前为止最大的收益即可, 则最后一天的最大的收益即为最后的收益。

public class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length <= 1) {
            return 0;
        }
        int min = prices[0];
        int max = 0;
        for (int i = 1; i < prices.length; i++) {
            min = Math.min(min, prices[i - 1]);
            max = Math.max(max, prices[i] - min);
        }
        return max;
    }
}

 

122. Best Time to Buy and Sell Stock II

Say you have an array for which the ith element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

这道题与前一道题的区别在于, 我们可以买卖股票很多次(as many as you want), 求最大收益。

这道题相对简单，不要把自己绕进去，其实只要比较是不是今天比昨天贵， 不用管之前的情况。举个简单的栗子，比如考虑第三天的情况的时候， 因为day3 - day1 = day3 - day2 + day2 - day1, 而day2 - day1 又已经包含在dp[day2]中，所以，只要day3比day2大，则，dp[day3] = dp[day2] + day3 - day2

思路I：动态规划

public class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length <= 1) {
            return 0;
        }
        int n = prices.length;
        int[] dp = new int[n + 1];
        int max = 0;
        for (int i = 2; i <= n; i++) {
            if (prices[i - 1] > prices[i - 2]) {
                dp[i] = dp[i - 1] + prices[i - 1] - prices[i - 2];
            } else {
                dp[i] = dp[i - 1];
            }
        }
        return dp[n];
    }
}

思路II：贪心

public class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length <= 1) {
            return 0;
        }
        int result = 0;
        for (int i = 1; i < prices.length; i++) {
            if (prices[i] > prices[i - 1]) {
                result += prices[i] - prices[i - 1];
            }
        }
        return result;
    }
}

 

309. Best Time to Buy and Sell Stock with Cooldown

Say you have an array for which the ith element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete as many transactions as you like (ie, buy one and sell one share of the stock multiple times) with the following restrictions:

You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
After you sell your stock, you cannot buy stock on next day. (ie, cooldown 1 day)
Example:

prices = [1, 2, 3, 0, 2]
maxProfit = 3
transactions = [buy, sell, cooldown, buy, sell]

思路：动态规划

很好的一道题， 很容易把自己绕乎进去。

每天都有两种可能性，要么卖，要么啥都不干。 当然这天的最大收益则是这两个方案中大的那个。 按照DP的思想，不如开两个数组，一个表示今天要卖，另一个表示今天啥也不干。

profitDoNothing[i]比较容易想，因为今天啥也不干，所以今天就继承昨天的结果，昨天的结果又有两种可能 --- 卖、啥也不干，当然要继承它俩中大的那个，所以profitDoNothing[i] = Math.max(profitSell[i-1], profitDoNothing[i-1])。

重点来了，profitSell[i]怎么算。其实也有两种情况，如果day[i-1]我买入了（或者卖了，因为卖完了可以再买回来），则day[i]可以直接卖，收益是:profitSell[i] = profitSell[i-1] + prices[i] - prices[i-1]。但是还有一种情况，就是day[i-1]是啥也没干的，所以day[i]需要把自己先买回来，再卖，收益是：profitSell[i] = profitDoNothing[i-1] + prices[i] - prices[i] = profitDoNothing[i-1]。最终取这两个大的就行了。

public class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length <= 1) {
            return 0;
        }
        int n = prices.length;
        int[] profitDoNothing = new int[n + 1];
        int[] profitSell = new int[n + 1];
        profitDoNothing[0] = 0;
        profitDoNothing[1] = 0;
        profitSell[0] = 0;
        profitSell[1] = 0;
        for (int i = 2; i <= n; i++) {
            profitDoNothing[i] = Math.max(profitDoNothing[i - 1], profitSell[i - 1]);
            profitSell[i] = Math.max(profitSell[i - 1] + prices[i- 1] - prices[i - 2], profitDoNothing[i - 1]);
        }
        return Math.max(profitDoNothing[n], profitSell[n]);
    }
}

思路II：贪心

仔细看你的动态规划的状态转移方程，你会发现其实你不需要一个数组，你只需要两个数： profitSell & profitDoNothing  然后每次比较的时候创建一个中间变量即可。

public class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length <= 1) {
            return 0;
        }
        int n = prices.length;
        int profitDoNothing = 0;
        int profitSell = 0;
        for (int i = 1; i < n; i++) {
            int temp = profitDoNothing;
            profitDoNothing = Math.max(profitSell, profitDoNothing);
            profitSell = Math.max(profitSell + prices[i] - prices[i - 1], temp);
        }
        return Math.max(profitDoNothing, profitSell);
    }
}

 

123. Best Time to Buy and Sell Stock III

Say you have an array for which the ith element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete at most two transactions.

Note:
You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

思路：动态规划

使用”局部最优解和全局最优解”的思想, 和Cooldown那道题的思路很像, 每一天将有两个状态 – “卖出”和”不卖出”。 利用两个动态规划数组local和global分别来存储局部最优解和全局最优解, 难点在于 这道题的状态更复杂, 因为要在两个维度计算, 第一个维度是天数的维度, 第二个维度是交易次数的维度, 所以local和global都是二维数组。 其中, global[i][j]表示到第i天最多进行j次交易可以达到的最大利润，而 local[i][j]表示到第i天最多进行j次交易，并且在第i天卖出可以达到的最大利润。

则： global[i][j] = Math.max(local[i][j], global[i-1][j]) 也就是到今天为止的全局最好，是到今天为止的局部最好与到昨天的全局最好中大的那个。因为今天的最大利润有两种情况，第一是几天卖出了（既local[i][j]），另一种是今天什么都没做，那今天的最好的情况就是昨天的全局最好情况

而： local[i][j] = Math.max(global[i-1][j-1] + prices[i] - prices[i-1], local[i-1][j] + prices[i] - prices[i-1]) — 这里是local[i-1][j]因为就算第i-1天卖了， 可以再买回来在第i天再卖，所以并不增加transaction。 这里就不太好理解了， 因为今天需要卖出，所以需 要加prices[i] - prices[i-1], 两种加的可能性，（1） 和全局比，（2）和局部比。

public class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length <= 1) {
            return 0;
        }
        int n = prices.length;
        int[][] local = new int[n][3];
        int[][] global = new int[n][3];
        for (int i = 1; i < n; i ++) {
            int profitToday = prices[i] - prices[i - 1];
            for (int j = 1; j <= 2; j++) {
                local[i][j] = Math.max(local[i - 1][j] + profitToday, global[i - 1][j - 1] + profitToday);
                global[i][j] = Math.max(local[i][j], global[i - 1][j]);
            }
        }
        return global[n - 1][2];
    }
}

思路：贪心

如果用贪心的做法, 则不需要维护天数的维度, 因为我们只需要记录每天的local和global即可, 后一天的根据前一天的结果进行计算。 如果只是两次操作，相当于j = 2。但是贪心的时候有一个小技巧需要注意一下, 就是我们需要倒序的算, 因为我们其实需要和前一天第2次操作的比, 所以我们不希望这个值被覆盖掉。

这里倒序的原因是不想让global[k]被覆盖掉 --- 这里也是难理解的一个点， 因为我们简化了二维数组，而选择只用一维数组

所以相当于这个数组只维护了前一天的信息，而今天的量也只和前一天有关，而我们只care最后一天k次交易的情况，这个情况跟前一天的k-1次交易有关，所以为了不让这个值被覆盖掉，我们选择倒叙

如果用二维数组则没有这个问题

public class Solution {
    public int maxProfit(int[] prices) {
        if (prices == null || prices.length <= 1) {
            return 0;
        }
        int n = prices.length;
        int[] local = new int[3];
        int[] global = new int[3];
        for (int i = 1; i < n; i++) {
            int profitToday = prices[i] - prices[i - 1];
            for (int j = 2; j >= 1; j--) {
                local[j] = Math.max(local[j] + profitToday, global[j - 1] + profitToday);
                global[j] = Math.max(local[j], global[j]);
            }
        }
        return global[2];
    }
}

 

188. Best Time to Buy and Sell Stock IV

Say you have an array for which the ith element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete at most k transactions.

Note:
You may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).

思路I：动态规划

第四题是第三题的推广, 由第三题中只能卖两次, 推广到现在可以卖k次。 思路和第三题是一样的, 我们在这里不再赘述。

但是需要注意的一点技巧是, 需要注意一个细节, 当k比prices.length的一半还要大的时候, 说明我们无法买卖够k次, 那么这道题就转变为了第二题。 这一点需要提前考虑到, 否则会得到一个TLE。不考虑这一点的话，当k很大的时候时间复杂度就比较高了！O(n * k)

public class Solution {
    public int maxProfit(int k, int[] prices) {
        if (prices == null || prices.length <= 1) {
            return 0;
        }
        int n = prices.length;
        if (k > n / 2) {
            int[] dp = new int[n + 1];
            for (int i = 2; i <= n; i++) {
                if (prices[i - 1] > prices[i - 2]) {
                    dp[i] = dp[i - 1] + prices[i - 1] - prices[i - 2];
                } else {
                    dp[i] = dp[i - 1];
                }
            }
            return dp[n];
        }
        int[][] local = new int[n][k + 1];
        int[][] global = new int[n][k + 1];
        for (int i = 1; i < n; i++) {
            int profitToday = prices[i] - prices[i - 1];
            for (int j = 1; j <= k; j++) {
                local[i][j] = Math.max(local[i - 1][j] + profitToday, global[i - 1][j - 1] + profitToday);
                global[i][j] = Math.max(local[i][j], global[i - 1][j]);
            }
        }
        return global[n - 1][k];
    }
}

思路II：贪心

public class Solution {
    public int maxProfit(int k, int[] prices) {
        if (prices == null || prices.length <= 1) {
            return 0;
        }
        int n = prices.length;
        if (k > n / 2) {
            int result = 0;
            for (int i = 1; i < n; i++) {
                if (prices[i] > prices[i - 1]) {
                    result += prices[i] - prices[i - 1];
                }
            }
            return result;
        }
        int[] local = new int[k + 1];
        int[] global = new int[k + 1];
        for (int i = 1; i < n; i++) {
            int profitToday = prices[i] - prices[i - 1];
            for (int j = k; j >= 1; j--) {
                local[j] = Math.max(local[j] + profitToday, global[j - 1] + profitToday);
                global[j] = Math.max(local[j], global[j]);
            }
        }
        return global[k];
    }
}

 

 

第7周　----　Follow Up Question

子数组和

Subarray Sum

Given an integer array, find a subarray where the sum of numbers is zero. Your code should return the index of the first number and the index of the last number.

 Notice

There is at least one subarray that it's sum equals to zero.

Have you met this question in a real interview? Yes
Example
Given [-3, 1, 2, -3, 4], return [0, 2] or [1, 3].

思路：map记录子数组的和与子数组最后一个元素索引的映射，注意一开始map.put(0, 1)。

public class Solution {
    /**
     * @param nums: A list of integers
     * @return: A list of integers includes the index of the first number
     *          and the index of the last number
     */
    public ArrayList<Integer> subarraySum(int[] nums) {
        // write your code here
        ArrayList<Integer> result = new ArrayList<>();
        if (nums == null || nums.length == 0) {
            return result;
        }
        Map<Integer, Integer> map = new HashMap<Integer, Integer>();
        map.put(0, -1);
        int sum = 0;
        for (int i = 0; i < nums.length; i++) {
            sum += nums[i];
            if (map.containsKey(sum)) {
                result.add(map.get(sum) + 1);
                result.add(i);
                return result;
            }
            map.put(sum, i);
        }
        return result;
    }
}

 

Subarray Sum II

Given an integer array, find a subarray where the sum of numbers is in a given interval. Your code should return the number of possible answers. (The element in the array should be positive)

Have you met this question in a real interview? Yes
Example
Given [1,2,3,4] and interval = [1,3], return 4. The possible answers are:

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

思路：这里由于是求范围，一边求的前缀和数组prefixSum[i]，一边判断前缀和数组中的前面的元素是否有prefixSum[i] - end ~ prefixSum[i] - start这个范围的元素出现，这个判断过程如果直接依次遍历前面的元素是O(n)的，为了加快查找速度，用二分查找，转化为查找prefixSum[i] - end和prefixSum[i] - start + 1（注意：一定要+1,否则会出现错误！！！【0，1，3】查找3～3和3～4的区别）这两个元素的索引，然后这两个索引的差值就是当前满足条件的子数组的个数。遍历整个i即可求的总共的子数组个数。注意这一题中的二分查找的写法，最后返回索引，这个索引是不能随便返回的，按照模版写法最后要进行详细的判断过程。

public class Solution {
    /**
     * @param A an integer array
     * @param start an integer
     * @param end an integer
     * @return the number of possible answer
     */
    public int subarraySumII(int[] A, int start, int end) {
        // Write your code here
        if (A == null || A.length == 0
            || start <= 0 || end <= 0 || start > end) {
            return 0;
        }
        int n = A.length;
        int[] prefixSum = new int[n + 1];
        int count = 0;
        for (int i = 1; i <= n; i++) {
            prefixSum[i] = prefixSum[i - 1] + A[i - 1];
            int low = prefixSum[i] - end;
            int high = prefixSum[i] - start + 1;
            count += binarySearch(prefixSum, i, high)
                - binarySearch(prefixSum, i, low);
        }
        return count;
    }
    public int binarySearch(int[] num, int len, int target) {
        int start = 0;
        int end = len - 1;
        while (start + 1 < end) {
            int mid = start + (end - start) / 2;
            if (num[mid] == target) {
                return mid;
            } else if (num[mid] < target) {
                start = mid;
            } else {
                end = mid;
            }
        }
        if (num[start] == target) {
            return start;
        }
        if (num[start] > target) {
            return start;
        }
        if (num[end] == target) {
            return end;
        }
        if (num[end] > target) {
            return end;
        }
        return end + 1;
    }
}

 

Submatrix Sum

Given an integer matrix, find a submatrix where the sum of numbers is zero. Your code should return the coordinate of the left-up and right-down number.

Have you met this question in a real interview? Yes
Example
Given matrix

[
  [1 ,5 ,7],
  [3 ,7 ,-8],
  [4 ,-8 ,9],
]
return [(1,1), (2,2)]

思路：先前缀和预处理，prefixSum[i][j] = sum of submatrix [(0,0), (i - 1,j - 1)].然后对于行数枚举，low:0 ~ n - 1; high:low + 1 ~ n。这样固定了矩阵的宽度，再建立一个map，对高度j进行枚举，只要有两个同高不等宽的子矩阵的和相同，说明这两个子矩阵的非重叠部分的子矩阵的和为0，这样转化为Subarray Sum这道一维的题目。

public class Solution {
    /**
     * @param matrix an integer matrix
     * @return the coordinate of the left-up and right-down number
     */
    public int[][] submatrixSum(int[][] matrix) {
        // Write your code here
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return new int[0][0];
        }
        int n = matrix.length;
        int m = matrix[0].length;
        int[][] prefixSum = new int[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                prefixSum[i][j] = prefixSum[i - 1][j] + prefixSum[i][j - 1] - prefixSum[i - 1][j - 1] + matrix[i - 1][j - 1];
            }
        }
        for (int low = 0; low < n; low++) {
            for (int high = low + 1; high <= n; high++) {
                Map<Integer, Integer> map = new HashMap<>();
                for (int j = 0; j <= m; j++) {
                    int difference = prefixSum[high][j] - prefixSum[low][j];
                    if (map.containsKey(difference)) {
                        int[][] result = new int[2][2];
                        result[0][0] = low;
                        result[0][1] = map.get(difference);
                        result[1][0] = high - 1;
                        result[1][1] = j - 1;
                        return result;
                    } else {
                        map.put(difference, j);
                    }
                }
            }
        }
        return new int[0][0];
    }
}

 

Sliding Window Maximum

Given an array of n integer with duplicate number, and a moving window(size k), move the window at each iteration from the start of the array, find the maximum number inside the window at each moving.

Have you met this question in a real interview? Yes
Example
For array [1, 2, 7, 7, 8], moving window size k = 3. return [7, 7, 8]

At first the window is at the start of the array like this

[|1, 2, 7| ,7, 8] , return the maximum 7;

then the window move one step forward.

[1, |2, 7 ,7|, 8], return the maximum 7;

then the window move one step forward again.

[1, 2, |7, 7, 8|], return the maximum 8;

思路：用到双端队列deque在左边删除，右边插入和删除，每次一个元素入列，把列中小于该元素的元素全部出列，列中只保存可能是当前最大值的元素。

public class Solution {
    /**
     * @param nums: A list of integers.
     * @return: The maximum number inside the window at each moving.
     */
    public ArrayList<Integer> maxSlidingWindow(int[] nums, int k) {
        // write your code here
        ArrayList<Integer> result = new ArrayList<>();
        if (nums == null || nums.length == 0 || k <= 0 || k > nums.length) {
            return result;
        }
        Deque<Integer> deque = new ArrayDeque<>();
        for (int i = 0; i < k - 1; i++) {
            inQueue(deque, nums[i]);
        }
        for (int i = k - 1; i < nums.length; i++) {
            inQueue(deque, nums[i]);
            result.add(deque.peekFirst());
            outQueue(deque, nums[i - k + 1]);
        }
        return result;
    }
    public void inQueue(Deque<Integer> deque, int num) {
        //不能取等号！当有两个相同最大数字入列时，取等号会把前面一个最大数字
        //去掉，当outQueue时又会把当前最大数字出列，造成错误。
        while (!deque.isEmpty() && num > deque.peekLast()) {
            deque.pollLast();
        }
        deque.offerLast(num);
    }
    public void outQueue(Deque<Integer> deque, int num) {
        if (num == deque.peekFirst()) {
            deque.pollFirst();
        }
    }
}

 

Sliding Window Matrix Maximum

Given an array of n * m matrix, and a moving matrix window (size k * k), move the window from top left to botton right at each iteration, find the maximum number inside the window at each moving.
Return 0 if the answer does not exist.

Have you met this question in a real interview? Yes
Example
For matrix

[
  [1, 5, 3],
  [3, 2, 1],
  [4, 1, 9],
]
The moving window size k = 2. 
return 13.

At first the window is at the start of the array like this

[
  [|1, 5|, 3],
  [|3, 2|, 1],
  [4, 1, 9],
]
,get the sum 11;
then the window move one step forward.

[
  [1, |5, 3|],
  [3, |2, 1|],
  [4, 1, 9],
]
,get the sum 11;
then the window move one step forward again.

[
  [1, 5, 3],
  [|3, 2|, 1],
  [|4, 1|, 9],
]
,get the sum 10;
then the window move one step forward again.

[
  [1, 5, 3],
  [3, |2, 1|],
  [4, |1, 9|],
]
,get the sum 13;
SO finally, get the maximum from all the sum which is 13.

思路：先前缀和预处理，prefixSum[i][j] = sum of submatrix [(0,0), (i - 1,j - 1)].然后对于行数和列数枚举，i:0 ~ n - k  j : 0 ~ m - k  然后依次遍历每个k * k矩阵，求出每个k * k矩阵的最大值，最后返回这些值中的最大值即可。

public class Solution {
    /**
     * @param matrix an integer array of n * m matrix
     * @param k an integer
     * @return the maximum number
     */
    public int maxSlidingMatrix(int[][] matrix, int k) {
        // Write your code here
        if (matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return 0;
        }
        if (k > matrix.length || k > matrix[0].length) {
            return 0;
        }
        int n = matrix.length;
        int m = matrix[0].length;
        int[][] prefixSum = new int[n + 1][m + 1];
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                prefixSum[i][j] = prefixSum[i - 1][j] + prefixSum[i][j - 1]
                    - prefixSum[i - 1][j - 1] + matrix[i - 1][j - 1];
            }
        }
        int max = Integer.MIN_VALUE;
        for (int i = 0; i <= n - k; i++) {
            for (int j = 0; j <= m - k; j++) {
                int num = prefixSum[i + k][j + k] - prefixSum[i][j + k] - prefixSum[i + k][j] + prefixSum[i][j];
                if (num > max) {
                    max = num;
                }
            }
        }
        return max;
    }
}

 

循环连续子序列

Continuous Subarray Sum

Given an integer array, find a continuous subarray where the sum of numbers is the biggest. Your code should return the index of the first number and the index of the last number. (If their are duplicate answer, return anyone)

Have you met this question in a real interview? Yes
Example
Give [-3, 1, 3, -3, 4], return [1,4].

思路：求连续子数组最大和／最小和的模版，记下来。是一个叫***算法。

public class Solution {
    /**
     * @param A an integer array
     * @return  A list of integers includes the index of the first number and the index of the last number
     */
    public ArrayList<Integer> continuousSubarraySum(int[] A) {
        // Write your code here
        ArrayList<Integer> result = new ArrayList<>();
        if (A == null || A.length == 0) {
            return result;
        }
        result.add(0);
        result.add(0);
        int start = 0;
        int end = 0;
        int sum = 0;
        int max = Integer.MIN_VALUE;
        for (int i = 0; i < A.length; i++) {
            if (sum > 0) {
                sum += A[i];
                end = i;
            } else {
                sum = A[i];
                start = i;
                end = i;
            }
            if (sum > max) {
                max = sum;
                result.set(0, start);
                result.set(1, end);
            }
        }
        return result;
    }
}

 

Continuous Subarray Sum II

Given an circular integer array (the next element of the last element is the first element), find a continuous subarray in it, where the sum of numbers is the biggest. Your code should return the index of the first number and the index of the last number.

If duplicate answers exist, return any of them.

Have you met this question in a real interview? Yes
Example
Give [3, 1, -100, -3, 4], return [4,1].

思路：这道题数组变成循环数组了。分两步，第一步跟Continuous Subarray Sum一样求0 ～ len - 1之间的连续子数组的最大和及索引对；第二步考虑尾->首的数组情况，将问题等价于求1 ～ len - 2之间的连续子数组的最小和及索引对，然后用数组和total减去这个最小和就是尾->首的子数组元素和。返回这两步中的最大和及其索引对。

public class Solution {
    /**
     * @param A an integer array
     * @return  A list of integers includes the index of the first number and the index of the last number
     */
    public ArrayList<Integer> continuousSubarraySumII(int[] A) {
        // Write your code here
        ArrayList<Integer> result = new ArrayList<>();
        if (A == null || A.length == 0) {
            return result;
        }
        result.add(0);
        result.add(0);
        int max = Integer.MIN_VALUE;
        int total = 0;
        int sum = 0;
        int start = 0;
        int end = 0;
        for (int i = 0; i < A.length; i++) {
            total += A[i];
            if (sum > 0) {
                sum += A[i];
                end = i;
            } else {
                sum = A[i];
                start = i;
                end = i;
            }
            if (sum > max) {
                max = sum;
                result.set(0, start);
                result.set(1, end);
            }
        }
        start = 1;
        end = 1;
        sum = 0;
        for (int i = 1; i < A.length - 1; i++) {
            if (sum < 0) {
                sum += A[i];
                end = i;
            } else {
                sum = A[i];
                start = i;
                end = i;
            }
            if (total - sum > max) {
                max = total - sum;
                result.set(0, end + 1);
                result.set(1, start - 1);
            }
        }
        return result;
    }
}

 

Partition Follow UP 

Kth Largest问题

PriorityQueue
• 时间复杂度O(nlogk)　　• 更适合Topk

• QuickSelect

• 时间复杂度O(n)　　　　• 更适合第k大 

 

Wiggle Sort

Given an unsorted array nums, reorder it in-place such that

nums[0] <= nums[1] >= nums[2] <= nums[3]....
 Notice

Please complete the problem in-place.

Have you met this question in a real interview? Yes
Example
Given nums = [3, 5, 2, 1, 6, 4], one possible answer is [1, 6, 2, 5, 3, 4].

思路：很简单。对索引分奇偶考虑，如果索引奇且当前值小于前一个值或者索引偶且当前值大于前一个值，则交换。

public class Solution {
    /**
     * @param nums a list of integer
     * @return void
     */
    public void wiggleSort(int[] nums) {
        // Write your code here
        if (nums == null || nums.length == 0) {
            return;
        }
        for (int i = 1; i < nums.length; i++) {
            if (i % 2 == 1 && nums[i] < nums[i - 1] || i % 2 == 0 && nums[i] > nums[i - 1]) {
                swap(nums, i - 1, i);
            }
        }
    }
    public void swap(int[] nums, int a, int b) {
        int temp = nums[a];
        nums[a] = nums[b];
        nums[b] = temp;
    }
}

 

Wiggle Sort II

Given an unsorted array nums, reorder it such that

nums[0] < nums[1] > nums[2] < nums[3]....
 Notice

You may assume all input has valid answer.

Have you met this question in a real interview? Yes
Example
Given nums = [1, 5, 1, 1, 6, 4], one possible answer is [1, 4, 1, 5, 1, 6].

Given nums = [1, 3, 2, 2, 3, 1], one possible answer is [2, 3, 1, 3, 1, 2].

思路I：先排序，然后排好序的数组分一半，依次从前一半的末尾和后一半的末尾取数放在原数组中。时间复杂度O(nlgn)。

public class Solution {
    /**
     * @param nums a list of integer
     * @return void
     */
    public void wiggleSort(int[] nums) {
        // Write your code here
        if (nums == null || nums.length == 0) {
            return;
        }
        int[] temp = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            temp[i] = nums[i];
        }
        Arrays.sort(temp);
        int j = nums.length - 1;
        int k = (nums.length + 1) / 2 - 1;
        for (int i = 0; i < nums.length; i++) {
            if (i % 2 == 0) {
                nums[i] = temp[k--];
            } else {
                nums[i] = temp[j--];
            }
        }
    }
}

 思路II：用QuickSelect模版选择第(length + 1) / 2大的数mid，新建temp数组，初始化为mid。然后遍历nums数组，将大于mid的元素从前往后放入temp，将小于mid的元素从后往前（注意初始化的位置由nums数组长度的奇偶来决定是nums.length - 1还是nums.length - 2）放入temp,来分割重复元素，最后将temp中的元素复制到nums中。

public class Solution {
    /**
     * @param nums a list of integer
     * @return void
     */
    public void wiggleSort(int[] nums) {
        // Write your code here
        if (nums == null || nums.length == 0) {
            return;
        }
        int n = nums.length;
        int mid = 0;
        if (n % 2 == 0) {
            mid = partition(nums, 0, n - 1, n / 2);
        } else {
            mid = partition(nums, 0, n - 1, (n + 1) / 2);
        }
        int[] temp = new int[n];
        for (int i = 0; i < n; i++) {
            temp[i] = mid;
        }
        int l = 1;
        int r = n - 2;
        if (n % 2 == 1) {
            r = n - 1;
        }
        for (int i = 0; i < n; i++) {
            if (nums[i] < mid) {
                temp[r] = nums[i];
                r -= 2;
            } else if (nums[i] > mid) {
                temp[l] = nums[i];
                l += 2;
            }
        }
        for (int i = 0; i < n; i++) {
            nums[i] = temp[i];
        }
    }
    public int partition(int[] nums, int start, int end, int k) {
        if (start == end) {
            return nums[start];
        }
        int pivot = nums[start + (end - start) / 2];
        int left = start;
        int right = end;
        while (left <= right) {
            while (left <= right && nums[left] < pivot) {
                left++;
            }
            while (left <= right && nums[right] > pivot) {
                right--;
            }
            if (left <= right) {
                int temp = nums[left];
                nums[left] = nums[right];
                nums[right] = temp;
                left++;
                right--;
            }
        }
        if (k <= right - start + 1) {
            return partition(nums, start, right, k);
        }
        if (k >= left - start + 1) {
            return partition(nums, left, end, k - (left - start));
        }
        return nums[left - 1];
    }
}

 

Nuts & Bolts Problem

Given a set of n nuts of different sizes and n bolts of different sizes. There is a one-one mapping between nuts and bolts. Comparison of a nut to another nut or a bolt to another bolt is not allowed. It means nut can only be compared with bolt and bolt can only be compared with nut to see which one is bigger/smaller.

We will give you a compare function to compare nut with bolt.

Have you met this question in a real interview? Yes
Example
Given nuts = ['ab','bc','dd','gg'], bolts = ['AB','GG', 'DD', 'BC'].

Your code should find the matching bolts and nuts.

one of the possible return:

nuts = ['ab','bc','dd','gg'], bolts = ['AB','BC','DD','GG'].

we will tell you the match compare function. If we give you another compare function.

the possible return is the following:

nuts = ['ab','bc','dd','gg'], bolts = ['BC','AA','DD','GG'].

So you must use the compare function that we give to do the sorting.

The order of the nuts or bolts does not matter. You just need to find the matching bolt for each nut.

思路：先从bolts中选一个pivot，对nuts进行partition，然后返回与该pivot对应的nuts中的索引，再以此相对应的pivot对bolts进行partition，这样nuts和bolts就都有一个元素相对应了。然后递归处理左右两边即可。注意这道题由于要nuts的pivot与bolts的pivot的位置对齐，所以不能用令狐冲老师讲的partition模版，这个模版只能将数组分成左右两半部分，但是pivot的索引不定，很可能不会再最终的位置上。所以这里用到另一种确保pivot在最终位置上的partiton写法，记住这个写法，考研的时候学过，具体看程序即可。

/**
 * public class NBCompare {
 *     public int cmp(String a, String b);
 * }
 * You can use compare.cmp(a, b) to compare nuts "a" and bolts "b",
 * if "a" is bigger than "b", it will return 1, else if they are equal,
 * it will return 0, else if "a" is smaller than "b", it will return -1.
 * When "a" is not a nut or "b" is not a bolt, it will return 2, which is not valid.
*/
public class Solution {
    /**
     * @param nuts: an array of integers
     * @param bolts: an array of integers
     * @param compare: a instance of Comparator
     * @return: nothing
     */
    public void sortNutsAndBolts(String[] nuts, String[] bolts, NBComparator compare) {
        // write your code here
        if (nuts == null || nuts.length == 0 || bolts == null
            || bolts.length == 0 || nuts.length != bolts.length) {
            return;
        }
        quickSort(nuts, bolts, compare, 0, nuts.length - 1);
    }
    public void quickSort(String[] nuts, String[] bolts, NBComparator compare, int start, int end) {
            if (start >= end) {
                return;
            }
            int index= partition(nuts, bolts[start], compare, start, end);
            partition(bolts, nuts[index], compare, start, end);
            quickSort(nuts, bolts, compare, start, index - 1);
            quickSort(nuts, bolts, compare, index + 1, end);
    }
    public int partition(String[] str, String pivot, NBComparator compare,
        int start, int end) {
        for (int i = start ; i <= end; i++) {
            if (compare.cmp(str[i], pivot) == 0 || compare.cmp(pivot, str[i]) == 0) {
                swap(str, start, i);
                break;
            }
        }
        String buffer = str[start];
        int left = start;
        int right = end;
        while (left < right) {
            while (left < right && (compare.cmp(str[right], pivot) == 1 || compare.cmp(pivot, str[right]) == -1)) {
                right--;
            }
            str[left] = str[right];
            while (left < right && (compare.cmp(str[left], pivot) == -1 || compare.cmp(pivot, str[left]) == 1)) {
                left++;
            }
            str[right] = str[left];
        }
        str[left] = buffer;
        return left;
    }
    public void swap(String[] str, int a, int b) {
        String temp = str[a];
        str[a] = str[b];
        str[b] = temp;
    }
}

 

迭代器相关：

Flatten List

Given a list, each element in the list can be a list or integer. flatten it into a simply list with integers.

 Notice

If the element in the given list is a list, it can contain list too.

Have you met this question in a real interview? Yes
Example
Given [1,2,[1,2]], return [1,2,1,2].

Given [4,[3,[2,[1]]]], return [4,3,2,1].

思路：遍历每个元素，如果元素是Integer，加入到结果中，否则递归调用该函数。

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * public interface NestedInteger {
 *
 *     // @return true if this NestedInteger holds a single integer,
 *     // rather than a nested list.
 *     public boolean isInteger();
 *
 *     // @return the single integer that this NestedInteger holds,
 *     // if it holds a single integer
 *     // Return null if this NestedInteger holds a nested list
 *     public Integer getInteger();
 *
 *     // @return the nested list that this NestedInteger holds,
 *     // if it holds a nested list
 *     // Return null if this NestedInteger holds a single integer
 *     public List<NestedInteger> getList();
 * }
 */
public class Solution {

    // @param nestedList a list of NestedInteger
    // @return a list of integer
    public List<Integer> flatten(List<NestedInteger> nestedList) {
        // Write your code here
        List<Integer> result = new ArrayList<>();
        for (NestedInteger nest : nestedList) {
            if (nest.isInteger()) {
                result.add(nest.getInteger());
            } else {
                result.addAll(flatten(nest.getList()));
            }
        }
        return result;
    }
}

 

Flatten Nested List Iterator

Given a nested list of integers, implement an iterator to flatten it.

Each element is either an integer, or a list -- whose elements may also be integers or other lists.

 Notice

You don't need to implement the remove method.

Have you met this question in a real interview? Yes
Example
Given the list [[1,1],2,[1,1]], By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,1,2,1,1].

Given the list [1,[4,[6]]], By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,4,6].

思路：1. List转Stack 2. 主函数放在hasNext()中，next只做一次pop处理。

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * public interface NestedInteger {
 *
 *     // @return true if this NestedInteger holds a single integer,
 *     // rather than a nested list.
 *     public boolean isInteger();
 *
 *     // @return the single integer that this NestedInteger holds,
 *     // if it holds a single integer
 *     // Return null if this NestedInteger holds a nested list
 *     public Integer getInteger();
 *
 *     // @return the nested list that this NestedInteger holds,
 *     // if it holds a nested list
 *     // Return null if this NestedInteger holds a single integer
 *     public List<NestedInteger> getList();
 * }
 */
import java.util.Iterator;

public class NestedIterator implements Iterator<Integer> {
    Stack<NestedInteger> stack;
    public void pushListToStack(List<NestedInteger> nestedList) {
        Stack<NestedInteger> temp = new Stack<>();
        for (NestedInteger nested : nestedList) {
            temp.push(nested);
        }
        while (!temp.isEmpty()) {
            stack.push(temp.pop());
        }
    }
    public NestedIterator(List<NestedInteger> nestedList) {
        // Initialize your data structure here.
        stack = new Stack<NestedInteger>();
        pushListToStack(nestedList);
    }

    // @return {int} the next element in the iteration
    @Override
    public Integer next() {
        // Write your code here
        if (!hasNext()) {
            return null;
        }
        return stack.pop().getInteger();
    }

    // @return {boolean} true if the iteration has more element or false
    @Override
    public boolean hasNext() {
        // Write your code here
        while (!stack.isEmpty() && !stack.peek().isInteger()) {
            pushListToStack(stack.pop().getList());
        }
        return !stack.isEmpty();
    }

    @Override
    public void remove() {}
}

/**
 * Your NestedIterator object will be instantiated and called as such:
 * NestedIterator i = new NestedIterator(nestedList);
 * while (i.hasNext()) v.add(i.next());
 */

 

Flatten 2D Vector

Implement an iterator to flatten a 2d vector.

Have you met this question in a real interview? Yes
Example
Given 2d vector =

[
  [1,2],
  [3],
  [4,5,6]
]
By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1,2,3,4,5,6].

思路：同Flatten Nested List Iterator 

public class Vector2D implements Iterator<Integer> {
    Stack<List<Integer>> stack1;
    Stack<Integer> stack2;
    
    public void pushListListToStack(List<List<Integer>> vec2d) {
        Stack<List<Integer>> temp = new Stack<>();
        for (List<Integer> nested : vec2d) {
            temp.push(nested);
        }
        while (!temp.isEmpty()) {
            stack1.push(temp.pop());
        }
    }
    
    public void pushListToStack(List<Integer> vec) {
        Stack<Integer> temp = new Stack<>();
        for (Integer nested : vec) {
            temp.push(nested);
        }
        while (!temp.isEmpty()) {
            stack2.push(temp.pop());
        }
    }
    
    public Vector2D(List<List<Integer>> vec2d) {
        // Initialize your data structure here
        stack1 = new Stack<>();
        pushListListToStack(vec2d);
        stack2 = new Stack<>();
    }

    @Override
    public Integer next() {
        // Write your code here
        if (!hasNext()) {
            return null;
        }
        return stack2.pop();
    }

    @Override
    public boolean hasNext() {
        // Write your code here
        while (stack2.isEmpty() && !stack1.isEmpty()) {
            pushListToStack(stack1.pop());
        }
        return !stack2.isEmpty();
    }

    @Override
    public void remove() {}
}

/**
 * Your Vector2D object will be instantiated and called as such:
 * Vector2D i = new Vector2D(vec2d);
 * while (i.hasNext()) v[f()] = i.next();
 */

 

Binary Search Tree Iterator

Design an iterator over a binary search tree with the following rules:

Elements are visited in ascending order (i.e. an in-order traversal)
next() and hasNext() queries run in O(1) time in average.
Have you met this question in a real interview? Yes
Example
For the following binary search tree, in-order traversal by using iterator is [1, 6, 10, 11, 12]

   10
 /    \
1      11
 \       \
  6       12

思路：同Flatten Nested List Iterator。注意当中序非递归把元素压栈之后，要及时把cur指针置为null，否则cur指针还是指向原来的位置而不改变！！！

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 * Example of iterate a tree:
 * BSTIterator iterator = new BSTIterator(root);
 * while (iterator.hasNext()) {
 *    TreeNode node = iterator.next();
 *    do something for node
 * }
 */
public class BSTIterator {
    private Stack<TreeNode> stack;
    private TreeNode cur;
    
    public void pushNodeToStack(TreeNode root) {
        while (root != null) {
            stack.push(root);
            root = root.left;
        }
    }
    
    //@param root: The root of binary tree.
    public BSTIterator(TreeNode root) {
        // write your code here
        stack = new Stack<TreeNode>();
        cur = root;
    }

    //@return: True if there has next node, or false
    public boolean hasNext() {
        // write your code here
        if (cur != null) {
            pushNodeToStack(cur);
            //注意这里一定要将cur置为null
            cur = null;
        }
        return !stack.isEmpty();
    }
    //@return: return next node
    public TreeNode next() {
        // write your code here
        if (!hasNext()) {
            return null;
        }
        TreeNode node = stack.pop();
        cur = node.right;
        return node;
    }
}

 

Zigzag Iterator

Given two 1d vectors, implement an iterator to return their elements alternately.

Have you met this question in a real interview? Yes
Example
Given two 1d vectors:

v1 = [1, 2]
v2 = [3, 4, 5, 6]
By calling next repeatedly until hasNext returns false, the order of elements returned by next should be: [1, 3, 2, 4, 5, 6].

思路：用计数器count控制取两个中的哪一个。

public class ZigzagIterator {
    List<Integer> l1;
    List<Integer> l2;
    int count;
    /**
     * @param v1 v2 two 1d vectors
     */
    public ZigzagIterator(List<Integer> v1, List<Integer> v2) {
        // initialize your data structure here.
        l1 = v1;
        l2 = v2;
        count = 0;
    }

    public int next() {
        // Write your code here
        if (!hasNext()) {
            return 0;
        }
        int result = 0;
        if (l1.size() > 0 && l2.size() > 0) {
            if (count % 2 == 0) {
                result = l1.remove(0);
            } else {
                result = l2.remove(0);
            }
        } else if (l1.size() > 0) {
            result = l1.remove(0);
        } else {
            result = l2.remove(0);
        }
        count++;
        return result;
    }

    public boolean hasNext() {
        // Write your code here
        return l1.size() > 0 || l2.size() > 0;
    }
}

/**
 * Your ZigzagIterator object will be instantiated and called as such:
 * ZigzagIterator solution = new ZigzagIterator(v1, v2);
 * while (solution.hasNext()) result.add(solution.next());
 * Output result
 */

 

Zigzag Iterator II

Follow up Zigzag Iterator: What if you are given k 1d vectors? How well can your code be extended to such cases? The "Zigzag" order is not clearly defined and is ambiguous for k > 2 cases. If "Zigzag" does not look right to you, replace "Zigzag" with "Cyclic".

Have you met this question in a real interview? Yes
Example
Given k = 3 1d vectors:

[1,2,3]
[4,5,6,7]
[8,9]
Return [1,4,8,2,5,9,3,6,7].

思路：用计数器count控制取k个中的哪一个，当count对应的list没有元素时count++，直到找到含有元素的list。

public class ZigzagIterator2 {
    ArrayList<ArrayList<Integer>> lists;
    int count;
    /**
     * @param vecs a list of 1d vectors
     */
    public ZigzagIterator2(ArrayList<ArrayList<Integer>> vecs) {
        // initialize your data structure here.
        lists = vecs;
        count = 0;
    }

    public int next() {
        // Write your code here
        if (!hasNext()) {
            return 0;
        }
        int result = 0;
        while (lists.get(count % lists.size()).size() == 0) {
            count++;
        }
        result = lists.get(count % lists.size()).remove(0);
        count++;
        return result;
    }

    public boolean hasNext() {
        // Write your code here
        if (lists == null || lists.size() == 0) {
            return false;
        }
        for (int i = 0; i < lists.size(); i++) {
            if (lists.get(i) != null && lists.get(i).size() != 0) {
                return true;
            }
        }
        return false;
    }
}

/**
 * Your ZigzagIterator2 object will be instantiated and called as such:
 * ZigzagIterator2 solution = new ZigzagIterator2(vecs);
 * while (solution.hasNext()) result.add(solution.next());
 * Output result
 */

 

Maximum Gap

Given an unsorted array, find the maximum difference between the successive elements in its sorted form.

Return 0 if the array contains less than 2 elements.

 Notice

You may assume all elements in the array are non-negative integers and fit in the 32-bit signed integer range.

Have you met this question in a real interview? Yes
Example
Given [1, 9, 2, 5], the sorted form of it is [1, 2, 5, 9], the maximum gap is between 5 and 9 = 4.

思路：桶排序(bucket sort)

假设有N个元素A到B。

那么最大差值不会小于ceiling[(B - A) / (N - 1)] (ceiling为向上取整)

令bucket（桶）的大小len = ceiling[(B - A) / (N - 1)]，则最多会有(B - A) / len + 1个桶

对于数组中的任意整数K，很容易通过算式loc = (K - A) / len找出其桶的位置，然后维护每一个桶的最大值和最小值

由于同一个桶内的元素之间的差值至多为len - 1，因此最终答案不会从同一个桶中选择。

对于每一个非空的桶p，找出下一个非空的桶q，则q.min - p.max可能就是备选答案。返回所有这些可能值中的最大值。

class Solution {
    /**
     * @param nums: an array of integers
     * @return: the maximum difference
     */
    public int maximumGap(int[] nums) {
        // write your code here
        if (nums == null || nums.length <  2) {
            return 0;
        }
        int max = -1;
        int min = Integer.MAX_VALUE;
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] > max) {
                max = nums[i];
            }
            if (nums[i] < min) {
                min = nums[i];
            }
        }
        int capacity = Math.max(1, (max - min - 1) / (nums.length - 1) + 1);
        int length = (max - min) / capacity + 1;
        int[] localMin = new int[length];
        int[] localMax = new int[length];
        for (int i = 0; i < length; i++) {
            localMin[i] = Integer.MAX_VALUE;
            localMax[i] = -1;
        }
        for (int i = 0; i < nums.length; i++) {
            int index = (nums[i] - min) / capacity;
            localMin[index] = Math.min(localMin[index], nums[i]);
            localMax[index] = Math.max(localMax[index], nums[i]);
        }
        int upMax = localMax[0];
        int result = 0;
        for (int i = 1; i < length; i++) {
            if (localMax[i] == -1) {
                continue;
            }
            result = Math.max(result, localMin[i] - upMax);
            upMax = localMax[i];
        }
        return result;
    }
}

 

Bomb Enemy

Given a 2D grid, each cell is either a wall 'W', an enemy 'E' or empty '0' (the number zero), return the maximum enemies you can kill using one bomb.
The bomb kills all the enemies in the same row and column from the planted point until it hits the wall since the wall is too strong to be destroyed.

 注意事项

You can only put the bomb at an empty cell.

您在真实的面试中是否遇到过这个题？ Yes
样例
Given a grid:

0 E 0 0
E 0 W E
0 E 0 0
return 3. (Placing a bomb at (1,1) kills 3 enemies)

思路：扫描矩阵，用rows表示该点所在行内有多少敌人可见。用cols[i]表示该点所在列i内有多少敌人可见。然后该点可见的敌人为两者之和。

　　　初始时两值为0. 

　　　当我们位于行首或者该行上一格为墙，那么在该行向右扫描直到行尾或者遇见一堵墙，更新rows。

　　　当我们位于列首或者该列上一格为墙，那么在该列向下扫描直到列尾或者遇见一堵墙，更新cols[i]。

　　　时间复杂度O(mn)(这个复杂度我还没想明白)，空间复杂度O(N)。

public class Solution {
    /**
     * @param grid Given a 2D grid, each cell is either 'W', 'E' or '0'
     * @return an integer, the maximum enemies you can kill using one bomb
     */
    public int maxKilledEnemies(char[][] grid) {
        // Write your code here
        if (grid == null || grid.length == 0 || grid[0].length == 0) {
            return 0;
        }
        int n = grid.length;
        int m = grid[0].length;
        int result = 0;
        int rows = 0;
        int[] cols = new int[m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (j == 0 || grid[i][j - 1] == 'W') {
                    rows = 0;
                    for (int k = j; k < m && grid[i][k] != 'W'; k++) {
                        if (grid[i][k] == 'E') {
                            rows++;
                        }
                    }
                }
                if (i == 0 || grid[i - 1][j] == 'W') {
                    cols[j] = 0;
                    for (int k = i; k < n && grid[k][j] != 'W'; k++) {
                        if (grid[k][j] == 'E') {
                            cols[j]++;
                        }
                    }
                }
                if (grid[i][j] == '0' && rows + cols[j] > result) {
                    result = rows + cols[j];
                }
            }
        }
        return result;
    }
}