【LeetCode】深搜DFS（共85题）

【98】Validate Binary Search Tree 

【99】Recover Binary Search Tree 

【100】Same Tree 

【101】Symmetric Tree 

【104】Maximum Depth of Binary Tree 

【105】Construct Binary Tree from Preorder and Inorder Traversal 

【106】Construct Binary Tree from Inorder and Postorder Traversal 

【108】Convert Sorted Array to Binary Search Tree 

【109】Convert Sorted List to Binary Search Tree 

【110】Balanced Binary Tree 

【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，然后逐层递增。返回整个列表的权重。

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * class NestedInteger {
 *   public:
 *     // Constructor initializes an empty nested list.
 *     NestedInteger();
 *
 *     // Constructor initializes a single integer.
 *     NestedInteger(int value);
 *
 *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
 *     bool isInteger() const;
 *
 *     // Return the single integer that this NestedInteger holds, if it holds a single integer
 *     // The result is undefined if this NestedInteger holds a nested list
 *     int getInteger() const;
 *
 *     // Set this NestedInteger to hold a single integer.
 *     void setInteger(int value);
 *
 *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
 *     void add(const NestedInteger &ni);
 *
 *     // Return the nested list that this NestedInteger holds, if it holds a nested list
 *     // The result is undefined if this NestedInteger holds a single integer
 *     const vector<NestedInteger> &getList() const;
 * };
 */
class Solution {
public:
    int depthSum(vector<NestedInteger>& nestedList) {
        return depthSum(nestedList, 1);
    }
    int depthSum(vector<NestedInteger>& nestedList, int level) {
        int ans = 0;
        for (int idx = 0; idx < nestedList.size(); ++ idx) {
            if (nestedList[idx].isInteger()) {
                ans += nestedList[idx].getInteger() * level;
            } else {
                ans += depthSum(nestedList[idx].getList(), level + 1);
            }
        }
        return ans;
    }
};

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

给了一个嵌套的list，每个元素当前的权重 = 当前的深度* 数字的大小。深度最里面一层为1，然后逐层递增。返回整个列表的权重。

题解：先计算下深度最深有多少，然后在逐层遍历。

/**
 * // This is the interface that allows for creating nested lists.
 * // You should not implement it, or speculate about its implementation
 * class NestedInteger {
 *   public:
 *     // Constructor initializes an empty nested list.
 *     NestedInteger();
 *
 *     // Constructor initializes a single integer.
 *     NestedInteger(int value);
 *
 *     // Return true if this NestedInteger holds a single integer, rather than a nested list.
 *     bool isInteger() const;
 *
 *     // Return the single integer that this NestedInteger holds, if it holds a single integer
 *     // The result is undefined if this NestedInteger holds a nested list
 *     int getInteger() const;
 *
 *     // Set this NestedInteger to hold a single integer.
 *     void setInteger(int value);
 *
 *     // Set this NestedInteger to hold a nested list and adds a nested integer to it.
 *     void add(const NestedInteger &ni);
 *
 *     // Return the nested list that this NestedInteger holds, if it holds a nested list
 *     // The result is undefined if this NestedInteger holds a single integer
 *     const vector<NestedInteger> &getList() const;
 * };
 */
class Solution {
public:
    int maxDepth = 0;
    int depthSumInverse(vector<NestedInteger>& nestedList) {
        getMaxDepth(nestedList, 1);
        int curDepth = maxDepth;
        return calRes(nestedList, curDepth);
    }
    void getMaxDepth(const vector<NestedInteger>& nestedList, int curDepth) {
        maxDepth = max(maxDepth, curDepth);
        for (auto& element : nestedList) {
            if(!element.isInteger()) {
                getMaxDepth(element.getList(), curDepth + 1);
            }
        }
        return;
    }
    int calRes(const vector<NestedInteger>& nestedList, int curDepth) {
        int res = 0;
        for (auto& ele : nestedList) {
            if (ele.isInteger()) {
                res += ele.getInteger() * curDepth;
            } else {
                res += calRes(ele.getList(), curDepth - 1);
            }
        }
        return res;
    }
};

【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求解。

class Solution {
public:
    bool makesquare(vector<int>& nums) {
        n = nums.size();
        if (n == 0) {return false;}
        sort(nums.begin(), nums.end());
        int tot = 0;
        for (auto& num : nums) {
            tot += num;
        }
        if (tot % 4) {return false;}
        int len = tot / 4;
        if (nums.back() > len) {return false;}
        vector<int> visit(n, -1);
        return dfs(nums, visit, len, 0, 0);
    }
    int n;
    bool dfs(vector<int>& nums, vector<int>& visit, const int len, int side, int curLen) {
        if (side == 4) {return true;}
        for (int i = n - 1; i >= 0; --i) {
            bool res = false;
            if (visit[i] != -1) {continue;}
            if (curLen + nums[i] > len) {return false;}
            visit[i] = side;
            if (curLen + nums[i] == len) {
                res = dfs(nums, visit, len, side + 1, 0);
            } else {
                res = dfs(nums, visit, len, side, curLen + nums[i]);
            }
            visit[i] = -1;
            if (res) {return res;}
        }
        return false;
    }
};

【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)

给了一个游戏规则，输入是扫雷的当前局面，和当前想点击的坐标，返回扫雷游戏当前局面的下一个局面。

游戏规则如下：

1. If a mine ('M') is revealed, then the game is over - change it to 'X'.
2. 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.
3. 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.
4. Return the board when no more squares will be revealed.

题解：我们用dfs求解，如果是 M 或者周围有 mine 的 E 的话，就在这个位置上返回 ‘X’ 或者雷的个数。如果是周围没有 mine 的 E 的话，就把当前的位置set 成为 ’B‘，然后把dfs他的八联通的格子。

class Solution {
public:
    vector<vector<char>> updateBoard(vector<vector<char>>& board, vector<int>& click) {
        n = board.size(), m = board[0].size();
        auto res = board;
        dfs(res, click[0], click[1]);
        return res;
    }
    int n, m;
    const int dirx[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
    const int diry[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
    void dfs(vector<vector<char>>& res, int x, int y) {
        if (x < 0 || x >= n || y < 0 || y >= m) {return;}
        if (res[x][y] == 'M') {
            res[x][y] = 'X'; return;
        }
        if (res[x][y] == 'B') {return;}
        int count = getAdjMine(res, x, y);
        if (count) {
            res[x][y] = count + '0'; return;
        }
        res[x][y] = 'B';
        for (int k = 0; k < 8; ++k) {
            int newx = dirx[k] + x, newy = diry[k] + y;
            dfs(res, newx, newy);
        }
    }
    int getAdjMine(vector<vector<char>>& res, int x, int y) {
        int cnt = 0;
        for (int k = 0; k < 8; ++k) {
            int newx = dirx[k] + x, newy = diry[k] + y;
            if (newx < 0 || newx >= n || newy < 0 || newy >= m) { continue; }
            if (res[newx][newy] == 'M') {
                ++cnt;
            }
        }
        return cnt;
    }
};

  

【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中尝试用一个组合价去递归，遍历所有解集找出答案。

class Solution {
public:
    int shoppingOffers(vector<int>& price, vector<vector<int>>& special, vector<int>& needs) {
        n = price.size();
        m = special.size();
        vector<int> allZero(n, 0);
        string str = vec2str(allZero);
        memo[str] = 0;
        int ret = dfs(price, special, needs);
        return ret;
    }
    int n, m;
    unordered_map<string, int> memo;
    inline string vec2str(const vector<int>& needs) {
        string ret = to_string(needs[0]);
        for (int i = 1; i < n; ++i) {
            ret = ret + ";" + to_string(needs[i]);
        }
        return ret;
    } 
    int dfs (vector<int>& price, vector<vector<int>>& special, vector<int>& needs) {
        string strNeeds = vec2str(needs);
        if (memo.find(strNeeds) != memo.end()) {
            return memo[strNeeds];
        }
        int ret = 0;
        for (int i = 0; i < n; ++i) {
            ret += price[i] * needs[i];
        }
        for (auto& sp : special) {
            bool canCal = true;
            auto newNeeds = needs;
            for (int i = 0; i < n; ++i) {
                if (newNeeds[i] < sp[i]) {
                    canCal = false;
                    break;
                }
                newNeeds[i] -= sp[i];
            } 
            if (canCal) {
                ret = min(ret,  sp.back() + dfs(price, special, newNeeds));
            }
        }
        memo[strNeeds] = ret;
        return ret;
    }
};

【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

class Solution {
public:
    bool judgePoint24(vector<int>& nums) {
        vector<double> numbers(4);
        for (int i = 0; i < nums.size(); ++i) {
            numbers[i] = (double)nums[i];
        }
        return dfs(numbers);
    }
    const double EPS = 1e-6; 
    bool dfs(vector<double>& nums) {
        if (nums.size() == 1) {
            return abs(nums[0] -24.0) < EPS;
        }
        const int n = nums.size();
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                vector<double> next;
                for (int k = 0; k < n; ++k) {
                    if (i != k && j != k) {
                        next.push_back(nums[k]);
                    }
                }
                next.push_back(1.0);
                vector<double> candidate;
                const double a = nums[i], b = nums[j];
                candidate.push_back(a+b);
                candidate.push_back(a-b);
                candidate.push_back(b-a);
                candidate.push_back(a*b);
                if (abs(a - 0.0) > EPS) {candidate.push_back(b/a);}
                if (abs(b - 0.0) > EPS) {candidate.push_back(a/b);}
                for (auto& e : candidate) {
                    next.back() = e;
                    bool res = dfs(next);
                    if (res) {return true;}
                }
            }
        }
        return false;
    }
};

【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:

11000
11000
00011
00011

Given the above grid map, return 1.

Example 2:

11011
10000
00001
11011

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成字符串。

第一种方法：

class Solution {
public:
    int numDistinctIslands(vector<vector<int>>& grid) {
        n = grid.size(), m = grid[0].size();
        set<vector<pair<int, int>>> st; //vector<pair<int, int>> 记录联通区域内的每一个点距离一开始遍历点的offset
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < m; ++j) {
                if (grid[i][j] == 1) {
                    vector<pair<int, int>> offset;
                    dfs(grid, i, j, i, j, offset);
                    st.insert(offset);
                }
            }
        }
        return st.size();
    }
    void dfs(vector<vector<int>>& grid, const int orix, const int oriy, int x, int y, vector<pair<int, int>>& offset) {
        grid[x][y] = -1;
        offset.push_back(make_pair(x-orix, y-oriy));
        for (int k = 0; k < 4; ++k) {
            int newx = x + dirx[k], newy = y + diry[k];
            if (newx < 0 || newx >= n || newy < 0 || newy >= m || grid[newx][newy] != 1) {continue;}
            dfs(grid, orix, oriy, newx, newy, offset);
        }
        return;
    }
    int n, m;
    int dirx[4] = {-1, 0 ,1, 0};
    int diry[4] = {0, -1, 0, 1};
};

【695】Max Area of Island 

【711】Number of Distinct Islands II 

【721】Accounts Merge 

【733】Flood Fill 

【737】Sentence Similarity II 

【743】Network Delay Time 

【749】Contain Virus 

【753】Cracking the Safe 

【756】Pyramid Transition Matrix 

【778】Swim in Rising Water 

【785】Is Graph Bipartite? 

【802】Find Eventual Safe States 

【827】Making A Large Island 

【834】Sum of Distances in Tree 

【839】Similar String Groups 

【841】Keys and Rooms 

【851】Loud and Rich 

【863】All Nodes Distance K in Binary Tree 

【872】Leaf-Similar Trees 

【886】Possible Bipartition 

【897】Increasing Order Search Tree