Problem

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.

Note: A leaf is a node with no children.

Example:

Given the below binary tree and sum = 22,

      5
     / \
    4   8
   /   / \
  11  13  4
 /  \      \
7    2      1

return true, as there exist a root-to-leaf path 5->4->11->2 which sum is 22.

Solution: Recursion

Time complexity: O(n)

Space complexity: O(n)

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  bool hasPathSum(TreeNode* root, int sum) {
    if (!root) return false;
    if (!root->left && !root->right) return root->val==sum;
    int new_sum = sum - root->val;
    return hasPathSum(root->left, new_sum) || hasPathSum(root->right, new_sum);
  }
};

Related Problems

• 花花酱 LeetCode 113. Path Sum II
• 花花酱 LeetCode 437. Path Sum III

The post 花花酱 LeetCode 112. Path Sum appeared first on Huahua's Tech Road.

题目大意：给你一棵二叉树，返回单向的路径和等于sum的路径数量。

https://leetcode.com/problems/path-sum-iii/description/

You are given a binary tree in which each node contains an integer value.

Find the number of paths that sum to a given value.

The path does not need to start or end at the root or a leaf, but it must go downwards (traveling only from parent nodes to child nodes).

The tree has no more than 1,000 nodes and the values are in the range -1,000,000 to 1,000,000.

Example:

root = [10,5,-3,3,2,null,11,3,-2,null,1], sum = 8

      10
     /  \
    5   -3
   / \    \
  3   2   11
 / \   \
3  -2   1

Return 3. The paths that sum to 8 are:

1.  5 -> 3
2.  5 -> 2 -> 1
3. -3 -> 11

Solution 1: Recursion

Time complexity: O(n^2)

Space complexity: O(n)

C++

// Author: Huahua
// Running time: 21 ms
class Solution {
public:
  int pathSum(TreeNode* root, int sum) {
    if (!root) return 0;
    return numberOfPaths(root, sum) + pathSum(root->left, sum) + pathSum(root->right, sum);
  }
private:
  int numberOfPaths(TreeNode* root, int left) {
    if (!root) return 0;    
    left -= root->val;
    return (left == 0 ? 1 : 0) + numberOfPaths(root->left, left) + numberOfPaths(root->right, left);
  }
};

Solution 2: Running Prefix Sum

Same idea to 花花酱 LeetCode 560. Subarray Sum Equals K

Time complexity: O(n)

Space complexity: O(h)

C++

// Author: Huahua
// Running time: 13 ms (beats 97.74%)
public:
  int pathSum(TreeNode* root, int sum) {
    ans_ = 0;
    sums_ = {{0, 1}};
    pathSum(root, 0, sum);
    return ans_;
  }
private:
  int ans_;
  unordered_map<int, int> sums_;
  
  void pathSum(TreeNode* root, int cur, int sum) {
    if (!root) return;
    cur += root->val;
    ans_ += sums_[cur - sum];
    ++sums_[cur];
    pathSum(root->left, cur, sum);
    pathSum(root->right, cur, sum);
    --sums_[cur];
  }
};

Related Problem

• 花花酱 LeetCode 560. Subarray Sum Equals K

The post 花花酱 LeetCode 437. Path Sum III appeared first on Huahua's Tech Road.

题目大意：给你樱桃田的地图（1: 樱桃, 0: 空, -1: 障碍物）。然你从左上角走到右下角（只能往右或往下），再从右下角走回左上角（只能往左或者往上）。问你最多能采到多少棵樱桃。

Problem:

In a N x N grid representing a field of cherries, each cell is one of three possible integers.

• 0 means the cell is empty, so you can pass through;
• 1 means the cell contains a cherry, that you can pick up and pass through;
• -1 means the cell contains a thorn that blocks your way.

Your task is to collect maximum number of cherries possible by following the rules below:

• Starting at the position (0, 0) and reaching (N-1, N-1) by moving right or down through valid path cells (cells with value 0 or 1);
• After reaching (N-1, N-1), returning to (0, 0) by moving left or up through valid path cells;
• When passing through a path cell containing a cherry, you pick it up and the cell becomes an empty cell (0);
• If there is no valid path between (0, 0) and (N-1, N-1), then no cherries can be collected.

Example 1:

Input: grid =
[[0, 1, -1],
 [1, 0, -1],
 [1, 1,  1]]
Output: 5
Explanation: 
The player started at (0, 0) and went down, down, right right to reach (2, 2).
4 cherries were picked up during this single trip, and the matrix becomes [[0,1,-1],[0,0,-1],[0,0,0]].
Then, the player went left, up, up, left to return home, picking up one more cherry.
The total number of cherries picked up is 5, and this is the maximum possible.

Note:

• grid is an N by N 2D array, with 1 <= N <= 50.
• Each grid[i][j] is an integer in the set {-1, 0, 1}.
• It is guaranteed that grid[0][0] and grid[N-1][N-1] are not -1.

Idea:

DP

Key observation: (0,0) to (n-1, n-1) to (0, 0) is the same as (n-1,n-1) to (0,0) twice

1. Two people starting from (n-1, n-1) and go to (0, 0).
2. They move one step (left or up) at a time simultaneously. And pick up the cherry within the grid (if there is one).
3. if they ended up at the same grid with a cherry. Only one of them can pick up it.

Solution: DP / Recursion with memoization.

x1, y1, x2 to represent a state y2 can be computed: y2 = x1 + y1 – x2

dp(x1, y1, x2) computes the max cherries if start from {(x1, y1), (x2, y2)} to (0, 0), which is a recursive function.

Since two people move independently, there are 4 subproblems: (left, left), (left, up), (up, left), (left, up). Finally, we have:

dp(x1, y1, x2)= g[y1][x1] + g[y2][x2] + max{dp(x1-1,y1,x2-1), dp(x1,y1-1,x2-1), dp(x1-1,y1,x2), dp(x1,y1-1,x2)}

Time complexity: O(n^3)

Space complexity: O(n^3)

Solution: DP

Time complexity: O(n^3)

Space complexity: O(n^3)

// Author: Huahua
// Runtime: 32 ms
class Solution {
public:
    int cherryPickup(vector<vector<int>>& grid) {
        const int n = grid.size();
        grid_ = &grid;
        m_ = vector<vector<vector<int>>>(
                n, vector<vector<int>>(n, vector<int>(n, INT_MIN)));
        return max(0, dp(n - 1, n - 1, n - 1));
    }
private:
    // max cherries from (x1, y1) to (0, 0) + (x2, y2) to (0, 0)
    int dp(int x1, int y1, int x2) {
        const int y2 = x1 + y1 - x2;
        if (x1 < 0 || y1 < 0 || x2 < 0 || y2 < 0) return -1;
        if ((*grid_)[y1][x1] < 0 || (*grid_)[y2][x2] < 0) return -1;
        if (x1 == 0 && y1 == 0) return (*grid_)[y1][x1];
        if (m_[x1][y1][x2] != INT_MIN) return m_[x1][y1][x2];        
        int ans =  max(max(dp(x1 - 1, y1, x2 - 1), dp(x1, y1 - 1, x2)),
                       max(dp(x1, y1 - 1, x2 - 1), dp(x1 - 1, y1, x2)));
        if (ans < 0) return m_[x1][y1][x2] = -1;
        ans += (*grid_)[y1][x1];
        if (x1 != x2) ans += (*grid_)[y2][x2];
        
        return m_[x1][y1][x2] = ans;
    }
    
    vector<vector<vector<int>>> m_;
    vector<vector<int>>* grid_; // does not own the object
};

// Author: Huahua
class Solution {
  private int[][] grid;
  private int[][][] memo;  
  public int cherryPickup(int[][] grid) {
    this.grid = grid;
    int m = grid.length;
    int n = grid[0].length;
    memo = new int[m][n][n];
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j)
        Arrays.fill(memo[i][j], Integer.MIN_VALUE);
    return Math.max(0, dp(n - 1, m - 1, n - 1));
  }
  
  private int dp(int x1, int y1, int x2) {
    final int y2 = x1 + y1 - x2;
    if (x1 < 0 || y1 < 0 || x2 < 0 || y2 < 0) return -1;
    if (grid[y1][x1] < 0 || grid[y2][x2] < 0) return -1;
    if (x1 == 0 && y1 == 0) return grid[y1][x1];
    if (memo[y1][x1][x2] != Integer.MIN_VALUE) return memo[y1][x1][x2];
    memo[y1][x1][x2] = Math.max(Math.max(dp(x1 - 1, y1, x2 - 1), dp(x1, y1 - 1, x2)),
                                Math.max(dp(x1, y1 - 1, x2 - 1), dp(x1 - 1, y1, x2)));
    
    if (memo[y1][x1][x2] >= 0) {
      memo[y1][x1][x2] += grid[y1][x1];
      if (x1 != x2) memo[y1][x1][x2] += grid[y2][x2];
    }
    
    return memo[y1][x1][x2];
  }
}

Related Problems:

• [解题报告] LeetCode 64. Minimum Path Sum
• [解题报告] LeetCode 63. Unique Paths II
• [解题报告] LeetCode 62. Unique Paths

The post 花花酱 LeetCode 741. Cherry Pickup appeared first on Huahua's Tech Road.

Problem:

5
             / \
            4   8
           /   / \
          11  13  4
         /  \    / \
        7    2  5   1

[
   [5,4,11,2],
   [5,8,4,5]
]

// Author: Huahua
// Runtime: 9 ms
class Solution {
public:
    vector<vector<int>> pathSum(TreeNode* root, int sum) {
        vector<vector<int>> ans;
        vector<int> curr;
        pathSum(root, sum, curr, ans);
        return ans;
    }
private:
    void pathSum(TreeNode* root, int sum, vector<int>& curr, vector<vector<int>>& ans) {
        if(root==nullptr) return;
        if(root->left==nullptr && root->right==nullptr) {
            if(root->val == sum) {
                ans.push_back(curr);
                ans.back().push_back(root->val);
            }
            return;
        }
        
        curr.push_back(root->val);
        int new_sum = sum - root->val;
        pathSum(root->left, new_sum, curr, ans);
        pathSum(root->right, new_sum, curr, ans);
        curr.pop_back();
    }
};

The post 花花酱 LeetCode 113. Path Sum II appeared first on Huahua's Tech Road.

Problem:

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 must contain at least one node and does not need to go through the root.

For example:
Given the below binary tree,

1
      / \
     2   3

Return 6.

Idea:

Recursion

Time complexity O(n)

Space complexity O(h)

Solution: Recursion

// Author: Huahua
// Runtime: 19 ms
class Solution {
public:
    int maxPathSum(TreeNode* root) {
        if (!root) return 0;
        int ans = INT_MIN;
        maxPathSum(root, ans);
        return ans;
    }
private:
    int maxPathSum(TreeNode* root, int& ans) {
        if (!root) return 0;
        int l = max(0, maxPathSum(root->left, ans));
        int r = max(0, maxPathSum(root->right, ans));
        int sum = l + r + root->val;
        ans = max(ans, sum);
        return max(l, r) + root->val;
    }
};

"""
Author: Huahua
Runtime: 138 ms (< 90.38%)
"""
class Solution(object):
    def _maxPathSum(self, root):
        if not root: return -sys.maxint
        l = max(0, self._maxPathSum(root.left))
        r = max(0, self._maxPathSum(root.right))
        self.ans = max(self.ans, root.val + l + r)
        return root.val + max(l, r)
        
    def maxPathSum(self, root):
        self.ans = -sys.maxint
        self._maxPathSum(root)
        return self.ans

Related Problems:

• [解题报告] LeetCode 687. Longest Univalue Path
• [解题报告] LeetCode 543. Diameter of Binary Tree

The post 花花酱 LeetCode 124. Binary Tree Maximum Path Sum appeared first on Huahua's Tech Road.