Skip to main content

Depth-first-search - Medium Level - Question 1

Depth-first-search - Medium Level - Question 1


Leetcode 113. Path Sum II

Given the root of a binary tree and an integer targetSum, return all root-to-leaf paths where each path's sum equals targetSum.

A leaf is a node with no children.

Constraints:

The number of nodes in the tree is in the range [0, 5000].

-1000 <= Node.val <= 1000

-1000 <= targetSum <= 1000


Analysis:

If the root is null, we can stop searching.

Starting with the root, we only have two ways to go: the left child and the right child.

Once we move on to the next step, we need to update the conditions: the sum and the path.

When the node is a leaf, we should check the sum, to see whether it reaches 0 or not (here we use the targetSum - node.val. You can use the sum of all the nodes on the path, but need one more variable).

If the sum is 0, then we find one path, so we can save it in the final answer; if not, we will stop this route and continue the search with other routes.

Since we switch from on path to the other (from the left child to the right child, we just need to pop out the last element in the path, so a path with reference (or in macro) can be used.


See the code below:


/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<vector<int>> res;
        vector<int> path;
        dsf(root, sum, res, path);
        return res;
    }
private:
    void dsf(TreeNode* r, int s, vector<vector<int>>& res, vector<int>& ps){
        if(!r) return;
        ps.push_back(r->val);
        if(!r->left && !r->right && s == r->val) res.push_back(ps);
        dsf(r->left, s - r->val, res, ps);
        dsf(r->right, s - r->val, res, ps);
        ps.pop_back();
    }
};


Upper Layer


 

Comments

Popular posts from this blog

Trie

Trie is a data structure belonging to n-ary trees, which is designed for some specific questions, such as, prefix of strings. (If you have never known what binary tree is, maybe you can check binary tree first before read more about Trie). The fact that there are only 26 different letters greatly reduce the possible choices for each position. Or to make it clear, for each position, there are 26 different choices. In mathematics, it seems to be very large (height^26 for the full tree), but in reality, it is rare to be a full tree for the set of meaningful strings (needs at least height^26 strings to be a full tree!), since the height or length of English words are less than 10 in most cases. Therefore, it is popular in string matching or related operations. Please be noted that the trie structure is not only limited to strings, the same idea can be extended to other data types, such as integer (then it becomes a binary tree, since for bit, there are only two possible values). In the cod...

Dynamic Programming - Hard Level - Question 1

Dynamic Programming - Hard Level - Question 1  Leetcode 1937  Maximum Number of Points with Cost You are given an m x n integer matrix points (0-indexed). Starting with 0 points, you want to maximize the number of points you can get from the matrix. To gain points, you must pick one cell in each row. Picking the cell at coordinates (r, c) will add points[r][c] to your score. However, you will lose points if you pick a cell too far from the cell that you picked in the previous row. For every two adjacent rows r and r + 1 (where 0 <= r < m - 1), picking cells at coordinates (r, c1) and (r + 1, c2) will subtract abs(c1 - c2) from your score. Return the maximum number of points you can achieve. abs(x) is defined as: x for x >= 0. -x for x < 0. Constraints: m == points.length n == points[r].length 1 <= m, n <= 10^5 1 <= m * n <= 10^5 0 <= points[r][c] <= 10^5 Analysis: Based on the description, we can define dp[i][j] as the maximum number of points wit...