【力扣】路径总和系列
Leetcode 0112 路径总和
题目描述：Leetcode 0112 路径总和
分析
-
本题的考点：二叉树。
-
递归，自顶向下从根节点往叶节点走，如果走到空节点，返回false；如果走到某个叶节点时，且
sum恰好为该节点的值，则说明找到一条满足要求的路径，返回true； -
否则是内部节点的，就让
sum减去该节点的值，递归求解。 -
只要找到一条满足要求的路径，递归即可返回。
代码
- C++
class Solution {
public:
bool hasPathSum(TreeNode* root, int tg) {
if (!root) return false;
if (!root->left && !root->right) return root->val == tg;
return hasPathSum(root->left, tg - root->val) || hasPathSum(root->right, tg - root->val);
}
};
- Java
class Solution {
public boolean hasPathSum(TreeNode root, int tg) {
if (root == null) return false;
if (root.left == null && root.right == null) return tg == root.val;
return hasPathSum(root.left, tg - root.val) || hasPathSum(root.right, tg - root.val);
}
}
时空复杂度分析
-
时间复杂度： O ( n ) O(n) O(n)，
n为树中节点数。 -
空间复杂度： O ( n ) O(n) O(n)。
Leetcode 0113 路径总和 II
分析
-
本题的考点：二叉树。
-
递归的过程中首先将当前递归到的节点添加到
path中，并让sum减去当前节点的值，如果当前节点是叶节点并且sum == 0说明找到一个合法路径，加入到ans中，否则的话如果不是根节点的话，递归遍历即可。
代码
- C++
class Solution {
public:
vector<vector<int>> ans;
vector<int> path;
vector<vector<int>> pathSum(TreeNode* root, int sum) {
if (root) dfs(root, sum);
return ans;
}
void dfs(TreeNode* root, int sum) {
path.push_back(root->val);
sum -= root->val;
if (!root->left && !root->right) {
if (!sum) ans.push_back(path);
} else {
if (root->left) dfs(root->left, sum);
if (root->right) dfs(root->right, sum);
}
path.pop_back();
}
};
- Java
class Solution {
List<List<Integer>> ans = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
public List<List<Integer>> pathSum(TreeNode root, int sum) {
if (root != null) dfs(root, sum);
return ans;
}
private void dfs(TreeNode root, int sum) {
path.add(root.val);
sum -= root.val;
if (root.left == null && root.right == null) {
if (sum == 0)
ans.add(new LinkedList<>(path));
} else {
if (root.left != null) dfs(root.left, sum);
if (root.right != null) dfs(root.right, sum);
}
path.removeLast();
}
}
时空复杂度分析
- 时间复杂度：
O
(
n
)
O(n)
O(n)，
n为树中节点数。 - 空间复杂度： O ( n ) O(n) O(n)。
Leetcode 0437 路径总和 III
分析
- 本题的考点：前缀和、哈希表、递归。
- 本题存在两种解法，这里都将讲解一下：
方法1
-
考虑本题的一个简化形式，如果给我们一个一维数组，让我们求子数组等于某值的区间个数，可以使用前缀和，具体可以参考Leetcode 0560 和为K的子数组。
-
本题也可以使用前缀和，在递归遍历的过程中，使用
cur表示当前路径的前缀和，当我们考虑当前节点时，我们需要找到当前路径前面存在多少个节点的前缀和t，使得cur-t=sum，相当于让我们找到存在多少个cur-sum，因此可以使用哈希表记录前面数据出现的次数即可。 -
使用
C++实现这种方法。因为每个节点只会被遍历一遍，因此时间复杂度是O(n)的，n是树中节点数目。 -
另外值得一提的是，LC560除了这种扩展方式，还可以扩展成多维，例如二维，对应Leetcode 1074 元素和为目标值的子矩阵数量。
方法2
-
还存在一种直接使用递归的做法，
pathSum(root, sum)表示的含义是：在以root为根结点的二叉树中，寻找和为sum的路径，返回这样的路径个数。我们可以拆分成两部分考虑：（1）包含root且和为sum的路径条数；（2）不包含root且和为sum的路径条数（递归遍历root的左右孩子）。 -
使用
Java实现这种方式。时间复杂度是 O ( n 2 ) O(n ^ 2) O(n2)的，n是树中节点数目。
代码
- C++
class Solution {
public:
unordered_map<int, int> cnt; // (前缀和，出现的次数)
int res = 0;
int pathSum(TreeNode* root, int sum) {
cnt[0]++;
dfs(root, sum, 0);
return res;
}
// cur: 前缀和
void dfs(TreeNode* root, int sum, int cur) {
if (!root) return;
cur += root->val;
res += cnt[cur - sum];
cnt[cur]++;
dfs(root->left, sum, cur), dfs(root->right, sum, cur);
cnt[cur]--;
}
};
- Java
class Solution {
// 在以root为根结点的二叉树中，寻找和为sum的路径，返回这样的路径个数
public int pathSum(TreeNode root, int sum) {
if (root == null) return 0;
int res = findPath(root, sum); // 包含结点root其和为sum的个数
res += pathSum(root.left, sum); // 进入左子树，寻找和为sum的路径
res += pathSum(root.right, sum); // 进入右子树，寻找和为sum的路径
return res;
}
// 在以node为根结点的二叉树中，寻找包含node的路径，和为sum, 返回这样的路径个数
private int findPath(TreeNode node, int sum) {
if (node == null) return 0;
int res = 0;
sum -= node.val;
if (sum == 0) res += 1;
res += findPath(node.left, sum);
res += findPath(node.right, sum);
return res;
}
}
时空复杂度分析
-
时间复杂度：
C++： O ( n ) O(n) O(n)，n为树中节点数目。Java： O ( n 2 ) O(n^2) O(n2)。 -
空间复杂度：和递归深度有关。
相关题目
Leetcode 0560 和为K的子数组
分析
-
本题的考点：前缀和、哈希表。
-
我们使用数组
s表示nums的前缀和，当我们考虑s[i]时，我们希望找到存在多少个j，使得s[i]-s[j-1]=k，其中1<=j<=i，相当于让我们找到存在多少个s[i]-k，因此可以使用哈希表记录前面数据出现的次数即可。 -
本题有两个扩展方向，可以扩展成多维，例如二维，对应Leetcode 1074 元素和为目标值的子矩阵数量。还可以在树上扩展，对应Leetcode 0437 路径总和 III。
代码
- C++
class Solution {
public:
int subarraySum(vector<int>& nums, int k) {
int n = nums.size();
vector<int> s(n + 1);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + nums[i - 1];
unordered_map<int, int> hash; // (数据，出现次数)
hash[0] = 1;
int res = 0;
for (int i = 1; i <= n; i++) {
res += hash[s[i] - k];
hash[s[i]]++;
}
return res;
}
};
- Java
class Solution {
public int subarraySum(int[] nums, int k) {
int n = nums.length;
int[] s = new int[n + 1];
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + nums[i - 1];
HashMap<Integer, Integer> hash = new HashMap<>();
hash.put(0, 1);
int res = 0;
for (int i = 1; i <= n; i++) {
res += hash.getOrDefault(s[i] - k, 0);
hash.put(s[i], hash.getOrDefault(s[i], 0) + 1);
}
return res;
}
}
- Python
class Solution:
def subarraySum(self, nums: List[int], k: int) -> int:
n = len(nums)
s = [0 for _ in range(n + 1)]
for i in range(1, n + 1):
s[i] = s[i - 1] + nums[i - 1]
hash = {}
hash[0] = 1
res = 0
for i in range(1, n + 1):
if s[i] - k in hash:
res += hash[s[i] - k]
if s[i] in hash:
hash[s[i]] += 1
else:
hash[s[i]] = 1
return res
时空复杂度分析
-
时间复杂度： O ( n ) O(n) O(n)，
n为数组长度。 -
空间复杂度： O ( n ) O(n) O(n)。
Leetcode 1074 元素和为目标值的子矩阵数量
分析
-
本题的考点：前缀和、哈希表。
-
我们枚举子矩阵的上下边界，并计算出该边界内每列的元素和，则原问题转换成了如下一维问题：给定一个整数数组和一个整数
target，计算该数组中子数组和等于target的子数组个数。对应Leetcode 0560 和为K的子数组问题。
代码
- C++
class Solution {
public:
// Leetcode 0560 和为K的子数组
int subarraySum(vector<int> &nums, int target) {
int n = nums.size();
vector<int> s(n + 1);
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + nums[i - 1];
unordered_map<int, int> hash;
hash[0] = 1;
int res = 0;
for (int i = 1; i <= n; i++) {
res += hash[s[i] - target];
hash[s[i]]++;
}
return res;
}
int numSubmatrixSumTarget(vector<vector<int>>& matrix, int target) {
int n = matrix.size(), m = matrix[0].size();
int res = 0;
for (int i = 0; i < n; i++) { // 枚举上边界
vector<int> nums(m);
for (int j = i; j < n; j++) { // 枚举下边界
for (int k = 0; k < m; k++)
nums[k] += matrix[j][k];
res += subarraySum(nums, target);
}
}
return res;
}
};
- Java
class Solution {
public int numSubmatrixSumTarget(int[][] matrix, int target) {
int n = matrix.length, m = matrix[0].length;
int res = 0;
for (int i = 0; i < n; i++) { // 枚举上边界
int[] nums = new int[m];
for (int j = i; j < n; j++) { // 枚举下边界
for (int k = 0; k < m; k++)
nums[k] += matrix[j][k];
res += subarraySum(nums, target);
}
}
return res;
}
private int subarraySum(int[] nums, int target) {
int n = nums.length;
HashMap<Integer, Integer> hash = new HashMap<>();
hash.put(0, 1);
int s = 0, res = 0; // s: 前缀和
for (int i = 1; i <= n; i++) {
s += nums[i - 1];
res += hash.getOrDefault(s - target, 0);
hash.put(s, hash.getOrDefault(s, 0) + 1);
}
return res;
}
}
- Python
class Solution:
def numSubmatrixSumTarget(self, matrix: List[List[int]], target: int) -> int:
n = len(matrix); m = len(matrix[0])
res = 0
for i in range(n):
nums = [0 for _ in range(m)]
for j in range(i, n):
for k in range(m):
nums[k] += matrix[j][k]
res += self.subarraySum(nums, target)
return res
def subarraySum(self, nums: List[int], k: int) -> int:
n = len(nums)
s = [0 for _ in range(n + 1)]
for i in range(1, n + 1):
s[i] = s[i - 1] + nums[i - 1]
hash = {}
hash[0] = 1
res = 0
for i in range(1, n + 1):
if s[i] - k in hash:
res += hash[s[i] - k]
if s[i] in hash:
hash[s[i]] += 1
else:
hash[s[i]] = 1
return res
时空复杂度分析
-
时间复杂度： O ( n 2 × m ) O(n^2 \times m) O(n2×m)，
n、m为行数、列数。 -
空间复杂度： O ( m ) O(m) O(m)。
324
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
