【LeetCode】深搜DFS（共85題）

時間 2019-11-18

標籤 LeetCode dfs 欄目應用數學简体版

原文原文鏈接

【98】Validate Binary Search Tree git

【99】Recover Binary Search Tree 算法

【100】Same Tree express

【101】Symmetric Tree 數組

【104】Maximum Depth of Binary Tree dom

【105】Construct Binary Tree from Preorder and Inorder Traversal ide

【106】Construct Binary Tree from Inorder and Postorder Traversal this

【108】Convert Sorted Array to Binary Search Tree google

【109】Convert Sorted List to Binary Search Tree spa

【110】Balanced Binary Tree code

【111】Minimum Depth of Binary Tree

【112】Path Sum

【113】Path Sum II

【114】Flatten Binary Tree to Linked List

【116】Populating Next Right Pointers in Each Node

【117】Populating Next Right Pointers in Each Node II

【124】Binary Tree Maximum Path Sum

【129】Sum Root to Leaf Numbers

【130】Surrounded Regions

【133】Clone Graph

【199】Binary Tree Right Side View

【200】Number of Islands

【207】Course Schedule

【210】Course Schedule II

【257】Binary Tree Paths

【261】Graph Valid Tree

【301】Remove Invalid Parentheses

【323】Number of Connected Components in an Undirected Graph

【329】Longest Increasing Path in a Matrix

【332】Reconstruct Itinerary

【337】House Robber III

【339】Nested List Weight Sum （2019年2月12日）

給了一個嵌套的list，每一個元素當前的權重 = 當前的深度* 數字的大小。最外面一層深度爲1，而後逐層遞增。返回整個列表的權重。

 1 /**
 2  * // This is the interface that allows for creating nested lists.
 3  * // You should not implement it, or speculate about its implementation
 4  * class NestedInteger {
 5  *   public:
 6  *     // Constructor initializes an empty nested list.
 7  *     NestedInteger();
 8  *
 9  *     // Constructor initializes a single integer.
10  *     NestedInteger(int value);
11  *
12  *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
13  *     bool isInteger() const;
14  *
15  *     // Return the single integer that this NestedInteger holds, if it holds a single integer
16  *     // The result is undefined if this NestedInteger holds a nested list
17  *     int getInteger() const;
18  *
19  *     // Set this NestedInteger to hold a single integer.
20  *     void setInteger(int value);
21  *
22  *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
23  *     void add(const NestedInteger &ni);
24  *
25  *     // Return the nested list that this NestedInteger holds, if it holds a nested list
26  *     // The result is undefined if this NestedInteger holds a single integer
27  *     const vector<NestedInteger> &getList() const;
28  * };
29  */
30 class Solution {
31 public:
32     int depthSum(vector<NestedInteger>& nestedList) {
33         return depthSum(nestedList, 1);
34     }
35     int depthSum(vector<NestedInteger>& nestedList, int level) {
36         int ans = 0;
37         for (int idx = 0; idx < nestedList.size(); ++ idx) {
38             if (nestedList[idx].isInteger()) {
39                 ans += nestedList[idx].getInteger() * level;
40             } else {
41                 ans += depthSum(nestedList[idx].getList(), level + 1);
42             }
43         }
44         return ans;
45     }
46 };

View Code

【364】Nested List Weight Sum II （2019年2月12日）

給了一個嵌套的list，每一個元素當前的權重 = 當前的深度* 數字的大小。深度最裏面一層爲1，而後逐層遞增。返回整個列表的權重。

題解：先計算下深度最深有多少，而後在逐層遍歷。

 1 /**
 2  * // This is the interface that allows for creating nested lists.
 3  * // You should not implement it, or speculate about its implementation
 4  * class NestedInteger {
 5  *   public:
 6  *     // Constructor initializes an empty nested list.
 7  *     NestedInteger();
 8  *
 9  *     // Constructor initializes a single integer.
10  *     NestedInteger(int value);
11  *
12  *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
13  *     bool isInteger() const;
14  *
15  *     // Return the single integer that this NestedInteger holds, if it holds a single integer
16  *     // The result is undefined if this NestedInteger holds a nested list
17  *     int getInteger() const;
18  *
19  *     // Set this NestedInteger to hold a single integer.
20  *     void setInteger(int value);
21  *
22  *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
23  *     void add(const NestedInteger &ni);
24  *
25  *     // Return the nested list that this NestedInteger holds, if it holds a nested list
26  *     // The result is undefined if this NestedInteger holds a single integer
27  *     const vector<NestedInteger> &getList() const;
28  * };
29  */
30 class Solution {
31 public:
32     int maxDepth = 0;
33     int depthSumInverse(vector<NestedInteger>& nestedList) {
34         getMaxDepth(nestedList, 1);
35         int curDepth = maxDepth;
36         return calRes(nestedList, curDepth);
37     }
38     void getMaxDepth(const vector<NestedInteger>& nestedList, int curDepth) {
39         maxDepth = max(maxDepth, curDepth);
40         for (auto& element : nestedList) {
41             if(!element.isInteger()) {
42                 getMaxDepth(element.getList(), curDepth + 1);
43             }
44         }
45         return;
46     }
47     int calRes(const vector<NestedInteger>& nestedList, int curDepth) {
48         int res = 0;
49         for (auto& ele : nestedList) {
50             if (ele.isInteger()) {
51                 res += ele.getInteger() * curDepth;
52             } else {
53                 res += calRes(ele.getList(), curDepth - 1);
54             }
55         }
56         return res;
57     }
58 };

View Code

【366】Find Leaves of Binary Tree

【394】Decode String

【417】Pacific Atlantic Water Flow

【430】Flatten a Multilevel Doubly Linked List

【439】Ternary Expression Parser

【472】Concatenated Words （2018年12月18日，算法羣，相似題目 140）

【473】Matchsticks to Square (2019年2月23日，算法羣) （M）

給了一個數組，每一個數組的元素表明一根火柴棍的長度，問這些火柴棍能不能圍成一個正方形。火柴棍只能拼接，不能折斷。

Input: [1,1,2,2,2]
Output: true

Explanation: You can form a square with length 2, one side of the square came two sticks with length 1.

題解：dfs求解。

 1 class Solution {
 2 public:
 3     bool makesquare(vector<int>& nums) {
 4         n = nums.size();
 5         if (n == 0) {return false;}
 6         sort(nums.begin(), nums.end());
 7         int tot = 0;
 8         for (auto& num : nums) {
 9             tot += num;
10         }
11         if (tot % 4) {return false;}
12         int len = tot / 4;
13         if (nums.back() > len) {return false;}
14         vector<int> visit(n, -1);
15         return dfs(nums, visit, len, 0, 0);
16     }
17     int n;
18     bool dfs(vector<int>& nums, vector<int>& visit, const int len, int side, int curLen) {
19         if (side == 4) {return true;}
20         for (int i = n - 1; i >= 0; --i) {
21             bool res = false;
22             if (visit[i] != -1) {continue;}
23             if (curLen + nums[i] > len) {return false;}
24             visit[i] = side;
25             if (curLen + nums[i] == len) {
26                 res = dfs(nums, visit, len, side + 1, 0);
27             } else {
28                 res = dfs(nums, visit, len, side, curLen + nums[i]);
29             }
30             visit[i] = -1;
31             if (res) {return res;}
32         }
33         return false;
34     }
35 };

View Code

【488】Zuma Game

【489】Robot Room Cleaner

【490】The Maze

【491】Increasing Subsequences

【494】Target Sum

【499】The Maze III

【505】The Maze II

【513】Find Bottom Left Tree Value

【514】Freedom Trail

【515】Find Largest Value in Each Tree Row

【529】Minesweeper (2019年2月25日，微軟tag)

給了一個遊戲規則，輸入是掃雷的當前局面，和當前想點擊的座標，返回掃雷遊戲當前局面的下一個局面。

遊戲規則以下：

If a mine ('M') is revealed, then the game is over - change it to 'X'.
If an empty square ('E') with no adjacent mines is revealed, then change it to revealed blank ('B') and all of its adjacent unrevealed squares should be revealed recursively.
If an empty square ('E') with at least one adjacent mine is revealed, then change it to a digit ('1' to '8') representing the number of adjacent mines.
Return the board when no more squares will be revealed.

題解：咱們用dfs求解，若是是 M 或者周圍有 mine 的 E 的話，就在這個位置上返回 ‘X’ 或者雷的個數。若是是周圍沒有 mine 的 E 的話，就把當前的位置set 成爲 ’B‘，而後把dfs他的八聯通的格子。

 1 class Solution {
 2 public:
 3     vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
 4         n = board.size(), m = board[0].size();
 5         auto res = board;
 6         dfs(res, click[0], click[1]);
 7         return res;
 8     }
 9     int n, m;
10     const int dirx[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
11     const int diry[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
12     void dfs(vector<vector<char>>& res, int x, int y) {
13         if (x < 0 || x >= n || y < 0 || y >= m) {return;}
14         if (res[x][y] == 'M') {
15             res[x][y] = 'X'; return;
16         }
17         if (res[x][y] == 'B') {return;}
18         int count = getAdjMine(res, x, y);
19         if (count) {
20             res[x][y] = count + '0'; return;
21         }
22         res[x][y] = 'B';
23         for (int k = 0; k < 8; ++k) {
24             int newx = dirx[k] + x, newy = diry[k] + y;
25             dfs(res, newx, newy);
26         }
27     }
28     int getAdjMine(vector<vector<char>>& res, int x, int y) {
29         int cnt = 0;
30         for (int k = 0; k < 8; ++k) {
31             int newx = dirx[k] + x, newy = diry[k] + y;
32             if (newx < 0 || newx >= n || newy < 0 || newy >= m) { continue; }
33             if (res[newx][newy] == 'M') {
34                 ++cnt;
35             }
36         }
37         return cnt;
38     }
39 };

View Code

【531】Lonely Pixel I

【533】Lonely Pixel II

【542】01 Matrix

【546】Remove Boxes

【547】Friend Circles

【559】Maximum Depth of N-ary Tree

【576】Out of Boundary Paths

【638】Shopping Offers (2018年12月24日，算法羣)

有幾種商品，每種商品有特定的單價，也有幾種商品組合的special offer，給了一個購買清單，（每種商品買幾個）。問最小花費。組合價格能夠隨便用不少次均可以。

Input: [2,5], [[3,0,5],[1,2,10]], [3,2]
Output: 14
Explanation: 
There are two kinds of items, A and B. Their prices are $2 and $5 respectively. 
In special offer 1, you can pay $5 for 3A and 0B
In special offer 2, you can pay $10 for 1A and 2B. 
You need to buy 3A and 2B, so you may pay $10 for 1A and 2B (special offer #2), and $4 for 2A.

題解：dfs，商品最差是個數*單價的累加和。咱們在每一層dfs中嘗試用一個組合價去遞歸，遍歷全部解集找出答案。

 1 class Solution {
 2 public:
 3     int shoppingOffers(vector<int>& price, vector<vector<int>>& special, vector<int>& needs) {
 4         n = price.size();
 5         m = special.size();
 6         vector<int> allZero(n, 0);
 7         string str = vec2str(allZero);
 8         memo[str] = 0;
 9         int ret = dfs(price, special, needs);
10         return ret;
11     }
12     int n, m;
13     unordered_map<string, int> memo;
14     inline string vec2str(const vector<int>& needs) {
15         string ret = to_string(needs[0]);
16         for (int i = 1; i < n; ++i) {
17             ret = ret + ";" + to_string(needs[i]);
18         }
19         return ret;
20     } 
21     int dfs (vector<int>& price, vector<vector<int>>& special, vector<int>& needs) {
22         string strNeeds = vec2str(needs);
23         if (memo.find(strNeeds) != memo.end()) {
24             return memo[strNeeds];
25         }
26         int ret = 0;
27         for (int i = 0; i < n; ++i) {
28             ret += price[i] * needs[i];
29         }
30         for (auto& sp : special) {
31             bool canCal = true;
32             auto newNeeds = needs;
33             for (int i = 0; i < n; ++i) {
34                 if (newNeeds[i] < sp[i]) {
35                     canCal = false;
36                     break;
37                 }
38                 newNeeds[i] -= sp[i];
39             } 
40             if (canCal) {
41                 ret = min(ret,  sp.back() + dfs(price, special, newNeeds));
42             }
43         }
44         memo[strNeeds] = ret;
45         return ret;
46     }
47 };

View Code

【664】Strange Printer

【679】24 Game (2019年3月11日，google tag)

給了四個數，問這四個數能不能經過加減乘除和括號獲得 24。能的話返回 true，不能的話返回 false。

Example 1:
Input: [4, 1, 8, 7]
Output: True
Explanation: (8-4) * (7-1) = 24
Example 2:
Input: [1, 2, 1, 2]
Output: False
Note:
The division operator / represents real division, not integer division. For example, 4 / (1 - 2/3) = 12.
Every operation done is between two numbers. In particular, we cannot use - as a unary operator. For example, with [1, 1, 1, 1] as input, the expression -1 - 1 - 1 - 1 is not allowed.
You cannot concatenate numbers together. For example, if the input is [1, 2, 1, 2], we cannot write this as 12 + 12.

題解：dfs

 1 class Solution {
 2 public:
 3     bool judgePoint24(vector<int>& nums) {
 4         vector<double> numbers(4);
 5         for (int i = 0; i < nums.size(); ++i) {
 6             numbers[i] = (double)nums[i];
 7         }
 8         return dfs(numbers);
 9     }
10     const double EPS = 1e-6; 
11     bool dfs(vector<double>& nums) {
12         if (nums.size() == 1) {
13             return abs(nums[0] -24.0) < EPS;
14         }
15         const int n = nums.size();
16         for (int i = 0; i < n; ++i) {
17             for (int j = i + 1; j < n; ++j) {
18                 vector<double> next;
19                 for (int k = 0; k < n; ++k) {
20                     if (i != k && j != k) {
21                         next.push_back(nums[k]);
22                     }
23                 }
24                 next.push_back(1.0);
25                 vector<double> candidate;
26                 const double a = nums[i], b = nums[j];
27                 candidate.push_back(a+b);
28                 candidate.push_back(a-b);
29                 candidate.push_back(b-a);
30                 candidate.push_back(a*b);
31                 if (abs(a - 0.0) > EPS) {candidate.push_back(b/a);}
32                 if (abs(b - 0.0) > EPS) {candidate.push_back(a/b);}
33                 for (auto& e : candidate) {
34                     next.back() = e;
35                     bool res = dfs(next);
36                     if (res) {return true;}
37                 }
38             }
39         }
40         return false;
41     }
42 };

View Code

【685】Redundant Connection II

【690】Employee Importance

【694】Number of Distinct Islands (2019年3月12日，google tag)

給了一個grid，上面 1 的聯通區域表明一個島嶼，問一共有多少個 distinct 的島嶼。

Given a non-empty 2D array grid of 0's and 1's, an island is a group of 1's (representing land) connected 4-directionally (horizontal or vertical.) You may assume all four edges of the grid are surrounded by water.

Count the number of distinct islands. An island is considered to be the same as another if and only if one island can be translated (and not rotated or reflected) to equal the other.

Example 1:

Given the above grid map, return 1.

Example 2:

Given the above grid map, return 3.
Notice that:

11
1

and

 1
11

are considered different island shapes, because we do not consider reflection / rotation.

Note: The length of each dimension in the given grid does not exceed 50.

題解：dfs這個 grid，怎麼存島嶼有兩種存法，第一個是存整個島嶼全部的座標和一開始dfs的點的offset。第二個是把島嶼encode成字符串。

第一種方法：

 1 class Solution {
 2 public:
 3     int numDistinctIslands(vector<vector<int>>& grid) {
 4         n = grid.size(), m = grid[0].size();
 5         set<vector<pair<int, int>>> st; //vector<pair<int, int>> 記錄聯通區域內的每個點距離一開始遍歷點的offset
 6         for (int i = 0; i < n; ++i) {
 7             for (int j = 0; j < m; ++j) {
 8                 if (grid[i][j] == 1) {
 9                     vector<pair<int, int>> offset;
10                     dfs(grid, i, j, i, j, offset);
11                     st.insert(offset);
12                 }
13             }
14         }
15         return st.size();
16     }
17     void dfs(vector<vector<int>>& grid, const int orix, const int oriy, int x, int y, vector<pair<int, int>>& offset) {
18         grid[x][y] = -1;
19         offset.push_back(make_pair(x-orix, y-oriy));
20         for (int k = 0; k < 4; ++k) {
21             int newx = x + dirx[k], newy = y + diry[k];
22             if (newx < 0 || newx >= n || newy < 0 || newy >= m || grid[newx][newy] != 1) {continue;}
23             dfs(grid, orix, oriy, newx, newy, offset);
24         }
25         return;
26     }
27     int n, m;
28     int dirx[4] = {-1, 0 ,1, 0};
29     int diry[4] = {0, -1, 0, 1};
30 };