2024年2月16日力扣题目训练

2024年2月16日第二十三天编程训练，今天主要是进行一些题训练，包括简单题3道、中等题2道和困难题1道。惰性太强现在才完成，不过之后我会认真完成的,我会慢慢补回来，争取一天发两篇，把之前的都补上。

645. 错误的集合

链接: 错误的集合
难度： 简单
题目：

运行示例：

思路：
这道题本质就是计数，我采用的就是遍历计数，还可以采用位运算大家可以尝试一下。
代码：

class Solution {
public:
    vector<int> findErrorNums(vector<int>& nums) {
        vector<int> ans;
        vector<int>tmp(nums.size(),0);
        for(int i = 0; i < nums.size(); i++){
            tmp[nums[i]-1]++;
        }
        int a =0, b = 0;
        for(int i = 0; i < nums.size(); i++){
            if(tmp[i] == 2) a = i + 1;
            if(tmp[i] == 0) b = i + 1;
        }
        cout<<a<<endl;
        ans.push_back(a);
        ans.push_back(b);
        return ans;
    }
};

653. 两数之和 IV - 输入二叉搜索树

链接: 两数之和
难度： 简单
题目：

运行示例：

思路：
这道题可以看到我们可以利用深度优先搜索 得到节点的值，利用哈希表记录所有节点的值。
代码：

class Solution {
public:
    unordered_set<int> hashTable;
    bool findTarget(TreeNode* root, int k) {
        if(root == NULL) return false;
        if(hashTable.count(k-root->val)) return true;
        hashTable.insert(root->val);
        return findTarget(root->left,k)||findTarget(root->right,k);
    }
};

657. 机器人能否返回原点

链接: 返回原点
难度： 简单
题目：

运行示例：

思路：
这道题我们只需计算进行判断即可。
代码：

class Solution {
public:
    bool judgeCircle(string moves) {
        int up = 0,down = 0,left = 0,right = 0;
        for(char move : moves){
            if(move == 'U') up++;
            if(move == 'D') down++;
            if(move == 'L') left++;
            if(move == 'R') right++;
        }
        return (up == down) && (left == right);
    }
};

307. 区域和检索 - 数组可修改

链接: 区域和检索 - 数组可修改
难度： 中等
题目：

运行示例：

思路：
这道题我本来是用前缀和解决，但是在遇到修改时复杂度会很大，我的时间超过，我看官方解析是采用线段树，这是我之前没接触过的。我参考了知乎的线段树这篇文章以及官方题解。
代码：

class NumArray {
private:
    vector<int> tree;
    int n;
public:
    void build(int l, int r, int p,vector<int> &nums){
        if(l == r){
            tree[p] = nums[l]; 
            return;
        }
        int mid = l + (r - l)/2;
        build(l, mid, p * 2 + 1, nums);
        build(mid+1, r, p * 2 + 2, nums);
        cout<<1<<endl;
        tree[p] = tree[p * 2 + 1]+tree[p * 2 + 2];
    }
    void change(int index, int val, int node, int s, int e) {
        if (s == e) {
            tree[node] = val;
            return;
        }
        int m = s + (e - s) / 2;
        if (index <= m) {
            change(index, val, node * 2 + 1, s, m);
        } else {
            change(index, val, node * 2 + 2, m + 1, e);
        }
        tree[node] = tree[node * 2 + 1] + tree[node * 2 + 2];
    }

    int range(int left, int right, int node, int s, int e) {
        if (left == s && right == e) {
            return tree[node];
        }
        int m = s + (e - s) / 2;
        if (right <= m) {
            return range(left, right, node * 2 + 1, s, m);
        } else if (left > m) {
            return range(left, right, node * 2 + 2, m + 1, e);
        } else {
            return range(left, m, node * 2 + 1, s, m) + range(m + 1, right, node * 2 + 2, m + 1, e);
        }
    }


    NumArray(vector<int>& nums): n(nums.size()), tree(nums.size() * 4)  {
        build(0, n - 1, 0, nums);
    }
    
    void update(int index, int val) {
        change(index, val, 0, 0, n - 1);
    }
    
    int sumRange(int left, int right) {
        return range(left, right, 0, 0, n - 1);
    }
};

309. 买卖股票的最佳时机含冷冻期

链接: 买卖股票
难度： 中等
题目：

运行示例：

思路：
这道题，我采用的是动态规划。用 f[i]表示第 i 天结束之后的累计最大收益。根据题目描述，由于我们最多只能同时买入（持有）一支股票，并且卖出股票后有冷冻期的限制，因此我们会有三种不同的状态：
我们目前持有一支股票，对应的累计最大收益记为 f[i][0]；
我们目前不持有任何股票，并且处于冷冻期中，对应的累计最大收益记为 f[i][1]；
我们目前不持有任何股票，并且不处于冷冻期中，对应的累计最大收益记为 f[i][2]。
因此状态转移方程为：
f[i][0]=max⁡(f[i−1][0],f[i−1][2]−prices[i])
f[i][1]=f[i−1][0]+prices[i]
f[i][2]=max⁡(f[i−1][1],f[i−1][2])
代码：

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() == 0) return 0;
        int n = prices.size();
        vector<vector<int>> f(n,vector<int>(3,0));
        f[0][0] = -prices[0];
        for(int i = 1; i < n; i++){
            f[i][0] = max(f[i - 1][0], f[i - 1][2] - prices[i]);
            f[i][1] = f[i - 1][0] + prices[i];
            f[i][2] = max(f[i - 1][1], f[i - 1][2]);
        }
        return max(f[n-1][1],f[n-1][2]);
    }
};

174. 地下城游戏

链接: 地下城游戏
难度： 困难
题目：

运行示例：

思路：
这道题根据题意以及限制条件，我们很容易想到需要利用动态规划，但是普通动态规划是从左上到右下，而本题的话我们则需要从右下到左上。dp[i][j] 表示从坐标 (i,j)到终点所需的最小初始值。
代码：

class Solution {
public:
    int calculateMinimumHP(vector<vector<int>>& dungeon) {
        int n = dungeon.size();
        int m = dungeon[0].size();
        vector<vector<int>>dp(n+1,vector<int>(m+1,INT_MAX));
        dp[n][m-1] = dp[n-1][m] = 1;
        for(int i = n-1 ; i >= 0; i--){
            for(int j = m-1; j >= 0; j--){
                int minn = min(dp[i+1][j],dp[i][j+1]);
                dp[i][j] = max(minn-dungeon[i][j],1);
            }
        }
        return dp[0][0];
    }
};