LeetCode 热题 HOT 100 第四天

最新推荐文章于 2025-11-24 16:32:05 发布

原创最新推荐文章于 2025-11-24 16:32:05 发布 · 125 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #算法 #c++

Leetcode刷题专栏收录该内容

40 篇文章

订阅专栏

本文介绍了四个算法问题的解决方案，包括搜索旋转排序数组中的目标值、在排序数组中查找元素的第一个和最后一个位置、组合总和的计算以及接雨水问题。采用二分查找和递归的方法解决各种数组操作，同时提供了全排列的两种实现方式，分别是利用next_permutation函数和爆搜。这些算法在数组处理和搜索问题中有着广泛应用。

16. 搜索旋转排序树组

思路

二分找到两段的端点，再次二分找到第一个大于等于 $t a r g e t$ 的下标，如果不等于就返回-1

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int l = 0, r = nums.size() - 1;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if (nums[mid] >= nums[0]) l = mid;
            else r = mid - 1;
        }

        if (target >= nums[0]) l = 0;
        else l = r + 1, r = nums.size() - 1;
        while (l < r) {
            int mid = l + r >> 1;
            if (nums[mid] >= target) r = mid;
            else l = mid + 1;
        }
        if (nums[r] == target) return r;
        else return -1;
    }
};

17. 在排序树组中查找元素的第一个和最后一个位置

思路

二分区间左端点，找不到返回-1，二分区间右端点，返回左右端点

class Solution {
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        if (nums.empty()) return {-1, -1};
        int l = 0, r = nums.size() - 1;
        while (l < r) {
            int mid = l + r >> 1;
            if (nums[mid] >= target) r = mid;
            else l = mid + 1;
        }

        if (nums[r] != target) return {-1, -1};

        int L = r;
        l = r, r = nums.size() - 1;
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if (nums[mid] <= target) l = mid;
            else r = mid - 1;
        }
        return {L, r};
    }
};

18. 组和总和

思路

枚举所有结果，爆搜， $r e s$ 存答案， $p a t h$ 存每一个可能的结果，每个数选择的方案数从 $i = 0$ 到 $c [u] * i < = t a r g e t$ ，枚举下一个数。
返回：此时目标为0保存答案，或者搜索到第n个数返回
这种题必须要记得恢复现场

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

    vector<vector<int>> combinationSum(vector<int>& c, int target) {
        dfs(c, 0, target);
        return res;
    }

    void dfs(vector<int>& c, int u, int target) {
        if (target == 0) {
            res.push_back(path);
            return ;
        }
        if (u == c.size()) return ;

        for (int i = 0; c[u] * i <= target; i ++ ) {
            dfs(c, u + 1, target - i * c[u]);
            path.push_back(c[u]);
        }

        for (int i = 0; c[u] * i <= target; i ++ ) {
            path.pop_back();
        }
    }
};

19. 接雨水

思路：双指针

两个指针分别从左边和右边走，记录两边最高的高度，如果此时指针指向高度：比如 $l m > h e i g h t [l]$ ，说明左边一定有一个墙，如果这个时候右边的指针高度高的话，那么左指针指向的区域一定可以填满。
因此，判断哪一边的指针高，从低的开始补直到两个指针相遇

class Solution {
public:
    int trap(vector<int>& height) {
        int n = height.size(), res = 0;
        int l = 0, r = n - 1;
        int lm = 0, rm = 0;
        while (l < r){
            lm = max(lm, height[l]);
            rm = max(rm, height[r]);
            if (height[l] < height[r]){
                res += lm - height[l];
                l ++ ;
            }
            else {
                res += rm - height[r];
                r -- ;
            }
        }
        return res;
    }
};

20. 全排列

思路一：next_permutation

使用该用法的时候，原数组必须排序才可以使用

class Solution {
public:
    vector<vector<int>> permute(vector<int>& nums) {
        vector<vector<int>> res;
        sort(nums.begin(), nums.end());
        do {
            res.push_back(nums);
        }while(next_permutation(nums.begin(), nums.end()));
        return res;
    }
};

思路二：爆搜

两个数组，一个存当前枚举的所有数字，一个枚举哪些数字是否使用过，当 $u = = n$ 存入 $r e s$

class Solution {
public:
    vector<vector<int>> res;
    vector<int> path;
    vector<bool> st;

    vector<vector<int>> permute(vector<int>& nums) {
        path = vector<int>(nums.size());
        st = vector<bool>(nums.size());
        dfs(nums, 0);
        return res;
    }

    void dfs(vector<int>& nums, int u) {
        if (u == nums.size()) {
            res.push_back(path);
            return ;
        }

        for (int i = 0; i < nums.size(); i ++ ) {
            if (!st[i]) {
                st[i] = true;
                path[u] = nums[i];
                dfs(nums, u + 1);
                st[i] = false;
            }
        }
    }
};