473-82（40、662、31、98、189）

最新推荐文章于 2024-05-30 20:15:33 发布

liufeng2023

最新推荐文章于 2024-05-30 20:15:33 发布

阅读量223

点赞数

分类专栏：剑指offer 文章标签：算法 leetcode c++

本文链接：https://blog.csdn.net/Edward_LF/article/details/125944186

版权

剑指offer 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

40. 组合总和 II

在这里插入图片描述

class Solution {
private:
    vector<vector<int>> res;
    vector<int> path;


    void backtracking(vector<int>& candidates, int target, int sum, int start_index)
    {
        if (sum == target)
        {
            res.push_back(path);
            return;
        }

        for (int i = start_index; i < candidates.size() && candidates[i] + sum <= target; i++)
        {
            if (i > start_index && candidates[i] == candidates[i - 1])
            {
                continue;
            }

            sum += candidates[i];
            path.push_back(candidates[i]);
            backtracking(candidates, target, sum, i + 1);
            sum -= candidates[i];
            path.pop_back();
        }
    }

public:
    vector<vector<int>> combinationSum2(vector<int>& candidates, int target) {
        res.clear();
        path.clear();

        sort(candidates.begin(), candidates.end());

        backtracking(candidates, target, 0, 0);
        return res;
    }
};

在这里插入图片描述

662. 二叉树最大宽度

在这里插入图片描述

class Solution {
public:
    int widthOfBinaryTree(TreeNode* root) {

        queue<TreeNode*> que;
        if (root != nullptr)
        {
            root->val = 0;
            que.push(root);
        }

        int res = 0;
        int max = INT_MIN;

        while (!que.empty())
        {
            res = std::max(res, que.back()->val - que.front()->val + 1);
            int size = que.size();

            int start = que.front()->val;

            for (int i = 0; i < size; i++)
            {
                TreeNode* node = que.front();
                que.pop();

                if (node->left)
                {
                    node->left->val = 2 * node->val - 2*start;
                    que.push(node->left);
                }
                if (node->right)
                {
                    node->right->val = 2 * node->val + 1 - 2* start;
                    que.push(node->right);
                }
            }
        }
        return res;
    }
};

31. 下一个排列

在这里插入图片描述

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
        int n = nums.size();

        int i = 0;
        int j = 0;
        for (i = n - 2; i >= 0; i--)
        {
            if (nums[i] < nums[i + 1])
            {
                break;
            }
        }

        if (i == -1)
        {
            reverse(nums.begin(), nums.end());
        }
        else
        {
            for (j = n - 1; j >= i + 1; j--)
            {
                if (nums[j] > nums[i])
                {
                    break;
                }
            }

            swap(nums[i], nums[j]);
            reverse(nums.begin() + i + 1, nums.end());
        }
    }
};

在这里插入图片描述

98. 验证二叉搜索树

在这里插入图片描述

class Solution {
private:
    vector<int> res;

    void traversal(TreeNode* root)
    {
        if (root == nullptr)    return;

        traversal(root->left);
        res.push_back(root->val);
        traversal(root->right);
    }
public:
    bool isValidBST(TreeNode* root) {
        res.clear();
        traversal(root);


        for (int i = 1; i < res.size(); i++)
        {
            if (res[i - 1] < res[i])
            {
                continue;
            }
            else
            {
                return false;
            }
        }
        return true;
    }
};

在这里插入图片描述

189. 轮转数组

在这里插入图片描述

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        
        int n = nums.size();
        vector<int> temp(n);

        for (int i = 0; i < n; i++)
        {
            temp[(i + k) % n] = nums[i];
        }

        nums.assign(temp.begin(), temp.end());
    }
};