leetcode刷题记录16（2023-08-22）【路径总和 III(前缀树) | 找到字符串中所有字母异位词(哈希、滑动窗口) | 找到所有数组中消失的数字(取余) | 汉明距离(位运算)】

Cherries Man

已于 2024-01-11 11:13:08 修改

阅读量916

点赞数 17

分类专栏：刷题笔记文章标签： leetcode 哈希算法算法

于 2024-01-11 11:12:27 首次发布

本文链接：https://blog.csdn.net/myf_666/article/details/132429408

版权

刷题笔记专栏收录该内容

53 篇文章 0 订阅

订阅专栏

437. 路径总和 III

给定一个二叉树的根节点 root ，和一个整数 targetSum ，求该二叉树里节点值之和等于 targetSum 的路径的数目。

路径不需要从根节点开始，也不需要在叶子节点结束，但是路径方向必须是向下的（只能从父节点到子节点）。

示例 1：

在这里插入图片描述

输入：root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8
输出：3
解释：和等于 8 的路径有 3 条，如图所示。

示例 2：

输入：root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22
输出：3

提示:

二叉树的节点个数的范围是 [0,1000]
$10^9 <= Node.val <= 10^9$
$- 1000 <= t a r g e tS u m <= 1000$

这道题目很直观的做法就是dfs，从所有的节点开始dfs一遍，同时记录路径和，如果等于路径和，那么更新结果，即res++；代码如下：

class Solution {
    void dfs(TreeNode* root, int& res, long long curSum, int targetSum) {
        if (root == nullptr) return;
        if (curSum + root->val == targetSum) {
            res++;
        }
        dfs(root->left, res, curSum + root->val, targetSum);
        dfs(root->right, res, curSum + root->val, targetSum);
    }
public:
    int pathSum(TreeNode* root, int targetSum) {
        if (root == nullptr) return 0;
        queue<TreeNode*> que;
        que.push(root);
        int res = 0;
        while (!que.empty()) {
            TreeNode* node = que.front();
            if (node->left != nullptr) {
                que.push(node->left);
            }
            if (node->right != nullptr) {
                que.push(node->right);
            }
            que.pop();
            dfs(node, res, 0, targetSum);
        }
        return res;
    }
};

采用一个队列来记录所有的节点，当队列为空的时候代表所有节点访问完毕，循环结束。

在这个过程中进行了一系列的重复计算，比如：我从后继节点开始的dfs计算的路径在前继节点dfs的时候就已经计算了，如果我们把这部分的数据（前缀和）保存下来，时间上就可以从O(n^2)优化到只遍历一次二叉树为O(n)。

我们采用unordered_map来记录这部分数据。

class Solution {
    unordered_map<long long, int> prefix; // 记录前缀和
    int dfs(TreeNode* root, long long curr, int targetSum) {
        if (root == nullptr) {
            return 0;
        }
        int ret = 0;
        curr += root->val;
        if (prefix.find(curr - targetSum) != prefix.end()) {
            // 如果存在，存在几个就有几个不同的路径
            ret = prefix[curr - targetSum];
        }

        // 维护prefix
        prefix[curr]++;
        ret += dfs(root->left, curr, targetSum);
        ret += dfs(root->right, curr, targetSum);
        prefix[curr]--;

        return ret;
    }
public:
    int pathSum(TreeNode* root, int targetSum) {
        // 如果搜到了 0 的前缀，说明全路径和为targetSum，所以初始化为1
        prefix[0] = 1;
        return dfs(root, 0, targetSum);
    }
};

438. 找到字符串中所有字母异位词

给定两个字符串 s 和 p，找到 s 中所有 p 的异位词的子串，返回这些子串的起始索引。不考虑答案输出的顺序。

异位词指由相同字母重排列形成的字符串（包括相同的字符串）。

示例 1:

输入: s = “cbaebabacd”, p = “abc”
输出: [0,6]
解释:
起始索引等于 0 的子串是 “cba”, 它是 “abc” 的异位词。
起始索引等于 6 的子串是 “bac”, 它是 “abc” 的异位词。

示例 2:

输入: s = “abab”, p = “ab”
输出: [0,1,2]
解释:
起始索引等于 0 的子串是 “ab”, 它是 “ab” 的异位词。
起始索引等于 1 的子串是 “ba”, 它是 “ab” 的异位词。
起始索引等于 2 的子串是 “ab”, 它是 “ab” 的异位词。

提示:

$1 <= s.length, p.length <= 3 * 10^4$
s 和 p 仅包含小写字母

这道题目和之前做过的一道题目很像，主要利用滑动窗口，同时用一个vector记录当前窗口中是否需要这种字母，如果为正，那么就是当前需要的，如果为负，就是当前多出来的。

#include<vector>
#include<iostream>
#include<string>
#include<unordered_map>

using namespace std;

class Solution {
public:
    vector<int> findAnagrams(string s, string p) {
        if (s.size() < p.size())return {};
        // 当前尚且需要的字母数量
        int lenNeeded = (int)p.size();
        unordered_map<char, bool> mp;

        // 每个字母需要的次数，如果为负数，证明当前窗口中多了几个单词
        vector<int> numChars(26);
        for (int i = 0; i < p.size(); i++) {
            mp[p[i]] = true;
            numChars[p[i] - 'a']++;
        }
        vector<int> res;
        for (int i = 0; i < s.size(); i++) {
            // 右边扩张
            if (mp[s[i]] == true) {
                numChars[s[i] - 'a']--;
                if (numChars[s[i] - 'a'] < 0) {
                    lenNeeded++;
                }
                else {
                    lenNeeded--;
                }

            }
            // 左边收缩
            int pos = i - (int)p.size();
            if (pos >= 0) {
                if (mp[s[pos]] == true) {
                    numChars[s[pos] - 'a']++;
                    if (numChars[s[pos] - 'a'] <= 0) {
                        lenNeeded--;
                    }
                    else {
                        lenNeeded++;
                    }
                }
            }
			// 如果当前需要的为0，插入到结果数组中
            if (lenNeeded == 0) {
                res.push_back(i - (int)p.size() + 1);
            }
        }
        return res;
    }
};

int main() {
    Solution sol;
    vector<int> res = sol.findAnagrams("abab", "ab");
    for (auto num : res) {
        cout << num << endl;
    }
    return 0;
}

448. 找到所有数组中消失的数字

给你一个含 n 个整数的数组 nums ，其中 nums[i] 在区间 [1, n] 内。请你找出所有在 [1, n] 范围内但没有出现在 nums 中的数字，并以数组的形式返回结果。

示例 1：

输入：nums = [4,3,2,7,8,2,3,1]
输出：[5,6]

示例 2：

输入：nums = [1,1]
输出：[2]

提示：

$n == n u m s . l e n g t h$
$1 <= n <= 10^5$
$1 <= n u m s [i] <= n$
进阶：你能在不使用额外空间且时间复杂度为 O(n) 的情况下解决这个问题吗? 你可以假定返回的数组不算在额外空间内。

额外开辟一个 bool 类型的 vector，如下：

class Solution {
public:
    vector<int> findDisappearedNumbers(vector<int>& nums) {
        vector<bool> isHaveNum(nums.size());
        vector<int> res;
        for (auto num : nums)isHaveNum[num - 1] = true;
        for (int i = 0; i < isHaveNum.size(); i++) {
            if (isHaveNum[i] == false) {
                res.push_back(i + 1);
            }
        }
        return res;
    }
};

原地修改的方法，通过 +n 与对 n 取余的操作，没有对数组的结构造成破坏，同时统计了没有被访问过的元素。

// 原地修改，参考题解
// https://leetcode.cn/problems/find-all-numbers-disappeared-in-an-array/solutions/601946/zhao-dao-suo-you-shu-zu-zhong-xiao-shi-d-mabl/
class Solution {
public:
    vector<int> findDisappearedNumbers(vector<int>& nums) {
        int n = nums.size();
        // 如果这个数在
        for (auto num : nums) {
            // 这里很巧妙，因为我是 +n 处理的，因此这里不会对index造成破坏
            int x = (num - 1) % n; 
            nums[x] += n;
        }
        vector<int> res;
        for (int i = 0; i < n;i++) {
            // 如果这个数 <= n，则证明这个数没有被访问过，即数组中消失了
            if (nums[i] <= n) {
                res.push_back(i + 1);
            }
        }
        return res;
    }
};

461. 汉明距离

两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。

给你两个整数 x 和 y，计算并返回它们之间的汉明距离。

示例 1：

输入：x = 1, y = 4
输出：2
解释：
1 (0 0 0 1)
4 (0 1 0 0)
↑ ↑
上面的箭头指出了对应二进制位不同的位置。

示例 2：

输入：x = 3, y = 1
输出：1

提示：

$0 <= x, y <= 2^{31} - 1$

主要思路就是与运算 + 移位运算

class Solution {
public:
    int hammingDistance(int x, int y) {
        int res = 0;
        while(x!=0 || y!=0){
            res += (x & 1) == (y & 1) ? 0 : 1;
            x = x>>1;
            y = y>>1;
        }
        return res;
    }
};

Cherries Man

关注

17
点赞
踩
20

收藏

觉得还不错? 一键收藏
打赏
0
评论
leetcode刷题记录16（2023-08-22）【路径总和 III(前缀树) | 找到字符串中所有字母异位词(哈希、滑动窗口) | 找到所有数组中消失的数字(取余) | 汉明距离(位运算)】

【路径总和 III(前缀树) | 找到字符串中所有字母异位词(哈希、滑动窗口) | 找到所有数组中消失的数字(取余) | 汉明距离(位运算)】
复制链接

扫一扫