DFS
Coding Style
- The name for Class, Method, Variable: Camel case
- Constant Value: All Upper Case
- Space, empty lines, Braces
- How long should be one method?
- Reusable code
- Comments
DFS
- Depth First Search
- One starts at the root (selecting some arbitrary node as the root in the case of a graph) and explores as far as possible along each branch before backtracking.
BFS
- Breadth First Search
- One starts at the root (selecting some arbitrary node as the root in the case of a graph) and explores the neighbor nodes first, before moving to the next level neighbors.
Searching Algorithm
Problem
sub-Problem
sub-Problem
sub-Problem
sub-sub-Problem
sub-sub-Problem
sub-sub-sub-Problem
base-
problem
Depth First Search
Search Order:
- U, R, D, L
- D, L, U, R
Search Order:
- U, R, D, L
- D, L, U, R
Problem
sub-Problem
sub-Problem
sub-Problem
sub-sub-Problem
sub-sub-Problem
Breadth First Search
sub-sub-Problem
sub-sub-Problem
Search Order:
- U, R, D, L
- D, L, U, R
Search Order:
- U, R, D, L
- D, L, U, R
A
/ \
B C
/ \ / \
D E F G
/ \
H I
- Preorder Traversal
- A B D E H C F G I
- DFS Search Path
- Level Order Traversal
- A B C D E F G H I
- BFS Search Path
Tree Traversal
DFS Search Order:
U, R, D, L
Filling the Grid
DFS Search Order:
U, R, D, L
Filling the Grid
BFS Search Order:
U, R, D, L
Filling the Grid
BFS Search Order:
U, R, D, L
Filling the Grid
Use Case
DFS and BFS are both algorithms for searching TREE and GRAPH, but we will ONLY focus on trees, which is more common in interviews.
- DFS
- Recursion and backtrace
- Stack
- BFS
- Find minimum path/distance/...
- Queue
DFS
- Most DFS related problems in interview is for trees.
- Balanced Binary Tree
- Symmetric Tree
- Minimum Depth of Binary Tree
- etc.
- More general, most recursion problems are also DFS.
- Permutation, Combination, Combination Sum.
- Letter Combination of Phone Number, Generate Parenthesis.
- Surrounded Regions, Word Search,
Basic Terms of Tree
- Root
- Node (internal node)
- Leaf (external node)
- Parent
- Child
- Siblings
- Cousin
- Ancestor
- Descendant
- Edge (N - 1)
- Path
- Height
- Depth
A
B
C
F
E
D
PreOrder Traversal
InOrder Traversal
PostOrder Traversal
They are all DFS
Depth of Tree
Given a binary tree, calculate its depth.
1
2
3
Depth: 3
1
2
3
4
Depth: 4
3
2
3
3
4
1
2
3
4
2
Depth: 4
Depth of Tree
Given a binary tree, calculate its depth.
public int depth(TreeNode root) {
if (root == null) {
return 0;
}
return Math.max(depth(root.left), depth(root.right)) + 1;
}Balanced Binary Tree
Given a binary tree, determine if it is height-balanced.
For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.
1
2
2
3
3
4
4
False
1
2
3
4
True
3
2
3
3
4
Balanced Binary Tree
Given a binary tree, determine if it is height-balanced.
For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.
- root is balanced
- Diff(depth(root.left), depth(root.right)) <= 1
- root.left is balanced && root.right is balanced.
Balanced Binary Tree
Given a binary tree, determine if it is height-balanced.
For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.
public boolean isBalanced(TreeNode root) {
if (root == null)
return true;
if (Math.abs(getDepth(root.left) - getDepth(root.right)) > 1)
return false;
return isBalanced(root.left) && isBalanced(root.right);
}
int getDepth(TreeNode root) {
if (root == null)
return 0;
return Math.max(getDepth(root.left), getDepth(root.right)) + 1;
}Something wrong? Redundant recursions
Balanced Binary Tree
Given a binary tree, determine if it is height-balanced.
For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1.
public boolean isBalanced(TreeNode root) {
return depth(root) != -1;
}
public int depth(TreeNode root) {
if (root == null) {
return 0;
}
int leftDepth = depth(root.left);
int rightDepth = depth(root.right);
if (leftDepth == -1 || rightDepth == -1 ||
Math.abs(leftDepth - rightDepth) > 1) {
return -1;
}
return Math.max(leftDepth, rightDepth) + 1;
}Symmetric Tree
Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).
1 / \ 2 2 / \ / \ 3 4 4 3
True
1 / \ 2 2 \ \ 3 3
False
1 / \ 2 2 / \ / \ 4 3 4 3
False
1 / \ 2 2 / \ 3 3
True
Symmetric Tree
Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).
1 / \ 2 2 / \ / \ 3 4 4 3
True
1 / \ 2 2 \ \ 3 3
False
- Root is Symmetric
- root.left is symmetric to root.right
- A is symmetric to B
- A.val == B.val
- A.left is symmetric to B.right
- A.right is symmetric to B.left
Symmetric Tree
Given a binary tree, check whether it is a mirror of itself (ie, symmetric around its center).
public boolean isSymmetric(TreeNode root) {
if (root == null) {
return true;
}
return isSymmetric(root.left, root.right);
}
public boolean isSymmetric(TreeNode left, TreeNode right) {
if (left == null && right == null) {
return true;
}
if (left == null && right != null) {
return false;
}
if (left != null && right == null) {
return false;
}
if (left.val != right.val) {
return false;
}
return isSymmetric(left.left, right.right)
&& isSymmetric(left.right, right.left);
}Minimum Depth of Binary Tree
Given a binary tree, find its minimum depth.
The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.
1 / \ 2 2 / \ / \ 3 4 4 3
3
1 / \ 2 2 / \ 3 4
2
1 / \ 2 2 / \ 3 3
3
Minimum Depth of Binary Tree
Given a binary tree, find its minimum depth.
The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.
- Minimum depth of Root
- if root is leaf, 1.
- if root.left is null, return right + 1.
- if root.right is null, return left + 1.
- return the minimum of (left, right) + 1.
Minimum Depth of Binary Tree
Given a binary tree, find its minimum depth.
The minimum depth is the number of nodes along the shortest path from the root node down to the nearest leaf node.
public int minDepth(TreeNode root) {
if (root == null) {
return 0;
}
int leftDepth = minDepth(root.left);
int rightDepth = minDepth(root.right);
if (leftDepth == 0) {
return rightDepth + 1;
} else if (rightDepth == 0) {
return leftDepth + 1;
}
return Math.min(leftDepth, rightDepth) + 1;
}Path Sum
Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.
5
/ \
4 8
/ / \
11 13 4
/ \ \
7 2 1
22: [5, 4, 11, 2]
3
/ \
2 6
/ / \
9 22 9
/ \ \
7 2 1
31: [3, 6, 22]
Path Sum
Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.
5
/ \
4 8
/ / \
11 13 4
/ \ \
7 2 1
22: [5, 4, 11, 2]
Knapsack:
- Except picking from all of numbers, only path from root to leaf is acceptable.
- hasSum(TreeNode root, int sum)
- Base case: root is leaf.
- hasSum(root, sum) = hasSum(root.left, sum-root.val) || hasSum(root.right, sum-root.val)
Path Sum
Given a binary tree and a sum, determine if the tree has a root-to-leaf path such that adding up all the values along the path equals the given sum.
5
/ \
4 8
/ / \
11 13 4
/ \ \
7 2 1
22: [5, 4, 11, 2]
public boolean hasPathSum(TreeNode root, int sum) {
if (root == null) {
return false;
}
if (root.left == null && root.right == null) {
if (sum == root.val) {
return true;
}
return false;
}
return hasPathSum(root.left, sum-root.val) ||
hasPathSum(root.right, sum-root.val);
}Binary Tree Maximum Path Sum
Given a binary tree, find the maximum path sum.
For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path does not need to go through the root.
5
/ \
4 8
/ / \
11 13 4
/ \ \
7 2 1
maxSum = 7 + 11 + 4 + 5 + 8 + 13 = 48
5 / \ 4 8 / / \ 11 13 4 / \ \ 7 2 1
Binary Tree Maximum Path Sum
Given a binary tree, find the maximum path sum.
For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path does not need to go through the root.
5 / \ -4 -8
-
Branch Sum (root):
- Sum of nodes that end at root.
-
Maximum Path Sum (root):
- root.val
- root.val + maxbranchSum(root.left)
- root.val + maxbranchSum(root.right)
- root.val + maxbranchSum(root.left) + maxbranchSum(root.right)
5 / \ 4 -8
5 / \ 4 8
5 / \ -4 8
Binary Tree Maximum Path Sum
Given a binary tree, find the maximum path sum.
For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path does not need to go through the root.
- branchSum (root)
- root.val
- root.val + branchSum(root.left)
- root.val + branchSum(root.right)
- Why do we need branchSum? Only branchSum can be used in the recursion
Binary Tree Maximum Path Sum
Given a binary tree, find the maximum path sum.
For this problem, a path is defined as any sequence of nodes from some starting node to any node in the tree along the parent-child connections. The path does not need to go through the root.
int max_sum = Integer.MIN_VALUE;
public int maxPathSum(TreeNode root) {
if (root == null)
return 0;
max_sum = Integer.MIN_VALUE;
maxBranchSum(root);
return max_sum;
}
public int maxBranchSum(TreeNode root) {
if (root == null) {
return 0;
}
int leftSum = maxBranchSum(root.left);
int rightSum = maxBranchSum(root.right);
int branchMaxSum = root.val + Math.max(0, Math.max(leftSum, rightSum));
max_sum = Math.max(max_sum,
Math.max(branchMaxSum, leftSum + root.val + rightSum));
return branchMaxSum;
}Binary Tree Maximum Path Sum
Given a binary tree, find the maximum path sum.
Use int[] to pass the maximum through the recursion
public static int maxPathSum(TreeNode root) {
if (root == null)
return 0;
int[] max = {Integer.MIN_VALUE};
maxBranchSum(root, max);
return max[0];
}
public static int maxBranchSum(TreeNode root, int[] max) {
if (root == null) {
return 0;
}
int leftSum = maxBranchSum(root.left, max);
int rightSum = maxBranchSum(root.right, max);
int branchMaxSum = root.val + Math.max(0, Math.max(leftSum, rightSum));
max[0] = Math.max(max[0], Math.max(branchMaxSum, leftSum + root.val + rightSum));
return branchMaxSum;
}DFS for Trees
- Complete Search
- If you need to traverse all the nodes in the tree.
- No need for minimum/shortest/... depth, etc.
- Normal Recursion
- Tree is recursive definition, so applying recursion on trees are very direct and easy understanding
- Sub-problem
- Base case
- Recursion rule
- ALWAYS think about two branches (left and right), pseudo code is helpful.
More general DFS
- One Dimension
- Letter Combination of Phone Number
- Generate Parenthesis
- Palindrome Partitioning
- etc.
- Two Dimensions
- Maze
- N Queens
- Word Search
- etc.
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.
For example, given a board,
[
['A','B','C','E'],
['S','F','C','S'],
['A','D','E','E']
]
word = "ABCCED", -> returns true,
word = "SEE", -> returns true,
word = "ABCB", -> returns false.
Word Search
public boolean exist(char[][] board, String word) {
if (board.length == 0 || board[0].length == 0)
return false;
boolean[][] flag = new boolean[board.length][board[0].length];
//for (int i = 0; i < board.length; i++) {
// Arrays.fill(flag[i], false);
//}
for (int i = 0; i < board.length; i++) {
for (int j = 0; j < board[0].length; j++) {
if (exist(board, i, j, word, 0, flag))
return true;
}
}
return false;
}
public boolean exist(char[][] board, int x, int y, String word, int index, boolean[][] flag) {
if (index == word.length())
return true;
if (x < 0 || y < 0 || x >= board.length || y >= board[0].length
|| flag[x][y] || board[x][y] != word.charAt(index))
return false;
int[] dx = {1, 0, -1, 0};
int[] dy = {0, 1, 0, -1};
flag[x][y] = true;
for (int i = 0; i < 4; i++) {
if (exist(board, x+dx[i], y+dy[i], word, index+1, flag))
return true;
}
flag[x][y] = false;
return false;
}Note:
more than 1 recursion
share the flag
Palindrome Partitioning
Given a string s, partition s such that every substring of the partition is a palindrome.
Return all possible palindrome partitioning of s.
Example:
Input: "aab"
Output: [ ["aa", "b"], ["a", "a", "b"] ]
Given a string s, partition s such that every substring of the partition is a palindrome.
Return all possible palindrome partitioning of s.
- Try substring from the beginning.
- If it's palindrome, then palindrome partition the left part and merge the results.
Palindrome Partitioning
Palindrome Partitioning
public List<List<String>> partition(String s) {
List<List<String>> results = new ArrayList<>();
partition(results, s, 0, new ArrayList<String>());
return results;
}
public void partition(List<List<String>> results, String s, int start,
List<String> path) {
if (start == s.length()) {
results.add(new ArrayList<>(path));
return;
}
for (int i = start + 1; i <= s.length(); i++) {
String sub = s.substring(start, i);
if (isPalindrome(sub)) {
path.add(sub);
partition(results, s, i, path);
path.remove(path.size() - 1);
}
}
}
public boolean isPalindrome(String s) {
for (int i = 0, j = s.length()-1; i < j; i++, j--) {
if (s.charAt(i) != s.charAt(j))
return false;
}
return true;
}- Is there any improvement we can do?
- Think about this, we have to check if string s is a palindrome every single time, do we have a way to simplify the check?
- keep the palindrome result when computing
- substring(a,b) -> substring(a+1, b-1)
- Pre-generate all the palindrome result
- A two-dimension array result
Palindrome Partitioning
boolean[][] generatePalindrome(String s) {
int len = s.length();
boolean[][] m = new boolean[len][len];
for (int i = 0; i < len; i ++) {
m[i][i] = true;
}
for (int i = 0; i < len - 1; i ++) {
m[i][i+1] = s.charAt(i) == s.charAt(i+1);
}
for (int i = 2; i < len; i ++) {
for (int j = 0; j < len - i; j ++) {
m[j][j+i] = s.charAt(j) == s.charAt(j+i) && m[j+1][j+i-1];
}
}
return m;
}Coin Change
You are given coins of different denominations and a total amount of money amount. Write a function to compute the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.
Example 1:
coins = [1, 2, 5], amount = 11
return 3 (11 = 5 + 5 + 1)
Example 2:
coins = [2], amount = 3
return -1.
Coin Change
You are given coins of different denominations and a total amount of money amount. Write a function to compute the fewest number of coins that you need to make up that amount. If that amount of money cannot be made up by any combination of the coins, return -1.
Two choices:
Use it or not -> inefficient
which one is the first to use?
Coin Change
static int min;
public int coinChange(int[] coins, int amount) {
Arrays.sort(coins);
min = Integer.MAX_VALUE;
if (helper(coins, amount, coins.length - 1, 0)) {
return min;
}
return -1;
}
public boolean helper(int[] coins, int rest, int current, int count) {
if (rest < 0) return false;
if (rest == 0) {
if (count < min) {
min = count;
}
return true;
}
if (count >= min) return false;
boolean result = false;
for (int j = current; j >= 0; j --) {
result = result || helper(coins, rest - coins[j], j, count + 1);
}
return result;
}WRONG ANSWER! WHY?
How does || work?
Coin Change
- Get i or not -> the most inefficient way
- Get the first i -> better than option 1
-
Get how many i?
- Why is this one even better?
Coin Change
static int min;
public int coinChange(int[] coins, int amount) {
Arrays.sort(coins);
min = Integer.MAX_VALUE;
if (helper(coins, amount, coins.length - 1, 0)) {
return min;
}
return -1;
}
public boolean helper(int[] coins, int rest, int current, int count) {
if (rest == 0) {
if (count < min) {
min = count;
}
return true;
}
if (current < 0 || rest < 0) return false;
if (count >= min) return false;
boolean result = false;
for (int i = rest / coins[current]; i >= 0; i --) {
if (helper(coins, rest - i * coins[current], current - 1, count + i)) {
result = true;
}
}
return result;
}Coin Change
Still it won't pass all the test cases because it is not efficient. We will introduce a better solution in Dynamic Programming
General DFS
- Depth First Search
- Search solutions from the whole possible search space
- Search is a process of trying and backtracking
- Pruning is important
Homework
【直通硅谷】03 DFS
By ZhiTongGuiGu
