leetcode记录

最新推荐文章于 2024-07-21 08:37:44 发布
最新推荐文章于 2024-07-21 08:37:44 发布
阅读量551 收藏 30
点赞数 29
文章标签： leetcode 算法 动态规划
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shyYukino/article/details/139010961
版权

2.最大子数组和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组是数组中的一个连续部分。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：

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

示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

提示：

  • 1 <= nums.length <= 10^5
  • -10^4 <= nums[i] <= 10^4

思路

简单动态规划思路，原问题要求最大和的连续子数组，而对于每个连续子数组，都唯一对应着一个末尾元素。在数组 nums 中，每个元素都可以作为某个子数组的末尾元素。所以我们只用求出以 nums[i] 结尾的最大连续子数组的最大和即可。

定义一个 dp[len] 数组，len 是数组的长度，dp[i] 表示以 nums[i] 结尾的最大子数组和。遍历一次 nums 数组，对于每个元素，判断 (dp[i - 1] + nums[i]) 和 nums[i] 哪个更大，将更大的值赋给dp[i]，并实时更新max的值即可。代码如下

class Solution {
public:
    int maxSubArray(vector<int>& nums) {
        int len = nums.size();
        int dp[len + 5]; // dp[i]表示以nums[i]结尾的最大子数组和

        dp[0] = nums[0];
        int max = dp[0];
        for (int i = 1; i < len; ++i) {
            if (nums[i] + dp[i - 1] > nums[i]) 
                dp[i] = nums[i] + dp[i - 1];
            else dp[i] = nums[i];
            if (dp[i] > max) max = dp[i];
        }
        return max;
    }
};

13.合并区间

以数组 intervals 表示若干个区间的集合，其中单个区间为 intervals[i] = [starti, endi] 。请你合并所有重叠的区间，并返回 一个不重叠的区间数组，该数组需恰好覆盖输入中的所有区间 。

示例 1：

输入：intervals = [[1,3],[2,6],[8,10],[15,18]]
输出：[[1,6],[8,10],[15,18]]
解释：区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].

示例 2：

输入：intervals = [[1,4],[4,5]]
输出：[[1,5]]
解释：区间 [1,4] 和 [4,5] 可被视为重叠区间。

提示：

  • 1 <= intervals.length <= 10^4
  • intervals[i].length == 2
  • 0 <= starti <= endi <= 10^4

思路

对于题目给定的这样一个数组，我们可以先按照左边界进行升序排序。这样操作后，可以合并的区间一定在原来的数组中位置连续。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

然后定义一个ans数组存放结果，将ans数组中最后一个元素的右边界（整个ans的右边界）与遍历到的区间的左边界进行比较，选择更新ans的右边界或者将该区间压入ans。具体代码如下

class Solution {
public:
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        if (intervals.size() == 0) return {};
        // 先按照左边界排序
        sort(intervals.begin(), intervals.end());
        vector<vector<int>> merged;
        for (int i = 0; i < intervals.size(); ++i) {
            int left = intervals[i][0], right = intervals[i][1];
            // 如果merged数组为空，或者与merged的最后一个数组没有重叠部分
            if (!merged.size() || merged.back()[1] < left) {
                merged.push_back({left, right});
            } else { // 有重叠部分，更新merged末尾的右边界（合并）
                merged.back()[1] = max(merged.back()[1], right);
            }
        }
        return merged;
    }
};

14.最小覆盖子串

给你一个字符串 s 、一个字符串 t 。返回 s 中涵盖 t 所有字符的最小子串。如果 s 中不存在涵盖 t 所有字符的子串，则返回空字符串 "" 。

注意：

  • 对于 t 中重复字符，我们寻找的子字符串中该字符数量必须不少于 t 中该字符数量。
  • 如果 s 中存在这样的子串，我们保证它是唯一的答案。

示例 1：

输入：s = "ADOBECODEBANC", t = "ABC"
输出："BANC"
解释：最小覆盖子串 "BANC" 包含来自字符串 t 的 'A'、'B' 和 'C'。

示例 2：

输入：s = "a", t = "a"
输出："a"
解释：整个字符串 s 是最小覆盖子串。

示例 3:

输入: s = "a", t = "aa"
输出: ""
解释: t 中两个字符 'a' 均应包含在 s 的子串中，
因此没有符合条件的子字符串，返回空字符串。

提示：

  • m == s.length
  • n == t.length
  • 1 <= m, n <= 10^5
  • s 和 t 由英文字母组成

思路

考虑到这是一个查找最小子串问题，我们可以往子集问题上联想，自然而然就会考虑使用哈希表来尝试解题。该问题的一个核心点是我们如何判断当前在字符串s 中的子串包含了字符串 t。对于找字符串 s 中的子串，我们可以用滑动窗口。我们再考虑哈希表，我们创建一个哈希表 hash_t 来存放字符串 t 中出现的字母与其出现的次数（这样定义键值对是考虑了字符串 t 中有重复字符），然后我们再创建另一个哈希表 hash_s 来维护当前字符串 s 中遍历到的子串中的字母及其出现次数。对于拿到的子串，这个子串对应的哈希表中要包含 t 的哈希表中的所有字符，并且对应的个数都不小于 t 的哈希表中各个字符的个数。

当我们拿到包含 t 的子串时，再考虑收缩滑动窗口，得到一个最小的子串。

具体代码如下

class Solution {
public:
    // ori记录t字符串，cnt记录s字符串
    unordered_map <char, int> ori, cnt; 

    // 判断是否包含子串
    bool check() {
        for (const auto &p: ori) {
            if (cnt[p.first] < p.second) {
                return false;
            }
        }
        return true;
    }

    string minWindow(string s, string t) {
        // 维护一个t串的哈希表
        for (const auto &c: t) {
            ++ori[c];
        }

        // 左右指针
        int l = 0, r = -1;
        // len为当前s中的长度，ansL与ansR记录答案子串的首尾索引
        int len = INT_MAX, ansL = -1, ansR = -1;

        while (r < int(s.size())) {
            // 扩展窗口
            if (ori.find(s[++r]) != ori.end()) {
                ++cnt[s[r]];
            }
            // 判断子串是否包含t字符串
            while (check() && l <= r) {
                // 长度更短则更新
                if (r - l + 1 < len) {
                    len = r - l + 1;
                    ansL = l; // 更新答案首部索引
                }
                // 尝试收缩滑动窗口
                if (ori.find(s[l]) != ori.end()) {
                    --cnt[s[l]];
                }
                ++l;
            }
        }
        return ansL == -1 ? "" : s.substr(ansL, len);
    }
};

15.轮转数组

给定一个整数数组 nums，将数组中的元素向右轮转 k 个位置，其中 k 是非负数。

示例 1:

输入: nums = [1,2,3,4,5,6,7], k = 3
输出: [5,6,7,1,2,3,4]
解释:
向右轮转 1 步: [7,1,2,3,4,5,6]
向右轮转 2 步: [6,7,1,2,3,4,5]
向右轮转 3 步: [5,6,7,1,2,3,4]

示例 2:

输入：nums = [-1,-100,3,99], k = 2
输出：[3,99,-1,-100]
解释: 
向右轮转 1 步: [99,-1,-100,3]
向右轮转 2 步: [3,99,-1,-100]

提示：

  • 1 <= nums.length <= 10^5
  • -2^31 <= nums[i] <= 2^31 - 1
  • 0 <= k <= 10^5

思路

直接模拟，最后一个测试点数据太大会爆超时

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int len = nums.size();
        int i = len - 1;
        while (k--) {
            while (i > 0) {
                swap(nums[i], nums[i - 1]);
                i--;
            }
            i = len - 1;
        }
    }
};

考虑直接将末尾的 k 个元素扔到数组前面（通过新创建一个数组实现），就能得到答案。但这样的做法有一个前提：数组长度 len 要比 k 更大。所以可以分两种情况解答

  • len > k 时采用将末尾的 k 个元素扔到数组前面
  • len <= k 时直接模拟

代码如下

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        vector<int> ans;
        int len = nums.size();
        if (len > k) {
            int p = len - k;
            for (int i = p; i < len; ++i)
                ans.push_back(nums[i]);
            for (int i = 0; i < p; ++i)
                ans.push_back(nums[i]);
            nums = ans;
        } else {
            int i = len - 1;
            while (k--) {
                while (i > 0) {
                    swap(nums[i], nums[i - 1]);
                    i--;
                }
                i = len - 1;
            }
        }
    }
};

为了代码更简短，可以将两种情况进行合并，我们只需要遍历原数组，将原数组下标为 i 的元素放到新数组下标为 (i + k) mod n 的位置

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        vector<int> newArr(n);
        for (int i = 0; i < n; ++i) {
            newArr[(i + k) % n] = nums[i];
        }
        nums.assign(newArr.begin(), newArr.end());
    }
};

16.除自身以外数组的乘积

给你一个整数数组 nums，返回 数组 answer ，其中 answer[i] 等于 nums 中除 nums[i] 之外其余各元素的乘积

题目数据 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内

请 **不要使用除法，**且在 O(n) 时间复杂度内完成此题

示例 1:

输入: nums = [1,2,3,4]
输出: [24,12,8,6]

示例 2:

输入: nums = [-1,1,0,-3,3]
输出: [0,0,9,0,0]

提示：

  • 2 <= nums.length <= 10^5
  • -30 <= nums[i] <= 30
  • 保证 数组 nums之中任意元素的全部前缀元素和后缀的乘积都在 32 位 整数范围内

思路

暴力的思路就是遍历一边 nums 数组，每对于遍历到的每个元素分别计算除它以外的乘积。但看数据范围，一定会超时。考虑问题的性质，这个问题可以通过前缀和的思想解决。

对于 nums 数组中的每个元素，我们可以通过下面的方法计算除它以外的乘积：计算结果分为两部分，以当前元素为界，该元素前半部分与该元素后半部分。在遍历 nums 数组前，我们先行分别计算这两部分的结果存放到数组中，然后再遍历 nums 数组，对于每个取到的元素，分别到前面创建的两个数组里取值相乘即可。代码如下

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) {
        vector<int> ans;
        vector<int> pre_front; // 前缀乘积
        vector<int> pre_back; // 后缀乘积
        int len = nums.size();

        int tmp = 1;
        // 计算前缀乘积
        for (int i = 0; i < len; ++i) {
            tmp *= nums[i];
            pre_front.push_back(tmp);
        }
        tmp = 1;
        // 计算后缀乘积
        for (int i = len - 1; i >= 0; --i) {
            tmp *= nums[i];
            pre_back.push_back(tmp);
        }

        for (int i = 0; i < len; ++i) {
            if (i == 0) {
                ans.push_back(pre_back[len - 2]);
            } else if (i == len - 1) {
                ans.push_back(pre_front[len - 2]);
            } else {
                ans.push_back(pre_front[i - 1] * pre_back[len - 2 - i]);
            }
        }
        return ans;
    }
};

17.缺失的第一个正数

给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。

请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。

示例 1：

输入：nums = [1,2,0]
输出：3
解释：范围 [1,2] 中的数字都在数组中。

示例 2：

输入：nums = [3,4,-1,1]
输出：2
解释：1 在数组中，但 2 没有。

示例 3：

输入：nums = [7,8,9,11,12]
输出：1
解释：最小的正数 1 没有出现。

提示：

  • 1 <= nums.length <= 10^5
  • -2^31 <= nums[i] <= 2^31 - 1

思路

先不考虑如何优化，我们要找出没有出现的最小正数，先对给定的数组排序，然后遍历该数组，找到第一个正数。因为事先已经排好序，所以这个一定是最小正数。如果这个正数不是1，那么答案就直接返回1，否则就继续判断。

我们从最小正数的下一位开始，找到两个相邻且两者之差不为1或0的数 nums[i]和nums[i-1]，返回 nums[i-1] + 1 即为答案。如果一直找到末尾都没有找到这样的两个数，那么就说明数组中的正整数都连续，返回最后一个元素 + 1 即可。

代码如下

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        int len = nums.size();
        long long ans;
        sort(nums.begin(), nums.end());
        // 假设给定数组的正整数部分都连续，答案就是最后一个元素+1
        if (nums[len - 1] > 0) {
            // 有一个数据点是INT_MAX，这里先强转一下防溢出
            ans = (long long)nums[len - 1] + 1;
        } else { // 若数组中没有正整数，答案就为1
            ans = 1;
        }
        int min = 1;
        int flag; // 记录最小正整数的index
        for (int i = 0; i < len; ++i) {
            if (nums[i] > 0) {
                min = nums[i];
                flag = i;
                break;
            }
        }

        if (min != 1) {
            return 1;
        } else { // 寻找不连续的两个正整数
            for (int i = flag + 1; i < len; ++i) {
                if (nums[i] - nums[i - 1] != 1 && nums[i] - nums[i - 1] != 0) {
                    ans = nums[i - 1] + 1;
                    break;
                }
            }
        }
        return ans;
    }
};

18.矩阵置零

给定一个 m x n 的矩阵，如果一个元素为 0 ，则将其所在行和列的所有元素都设为 0 。请使用 原地 算法。

示例 1：

img

输入：matrix = [[1,1,1],[1,0,1],[1,1,1]]
输出：[[1,0,1],[0,0,0],[1,0,1]]

示例 2：

img

输入：matrix = [[0,1,2,0],[3,4,5,2],[1,3,1,5]]
输出：[[0,0,0,0],[0,4,5,0],[0,3,1,0]]

提示：

  • m == matrix.length
  • n == matrix[0].length
  • 1 <= m, n <= 200
  • -2^31 <= matrix[i][j] <= 2^31 - 1

思路

最直观的方案是使用额外的O(mn)的空间，记录原矩阵中哪些是0，将其所在的行列均置为0即可。代码如下

class Solution {
public:
    void setZeroes(vector<vector<int>>& matrix) {
        int m = matrix.size(); // 行数
        int n = matrix[0].size(); // 列数
        bool isZero[205][205] = {false}; // 判断原来矩阵中哪些是0

        for (int i = 0; i < m; ++i) 
            for (int j = 0; j < n; ++j) 
                if (matrix[i][j] == 0) isZero[i][j] = true;

        for (int i = 0; i < m; ++i) 
            for (int j = 0; j < n; ++j)
                if (isZero[i][j]) {
                    for (int p = 0; p < m; ++p) 
                        matrix[p][j] = 0;
                    for (int q = 0; q < n; ++q) 
                        matrix[i][q] = 0;
                }
    }
};

对于记录0的位置，可以进一步减小内存到O(m+n)。我们并不需要用整个矩阵存储为0的坐标，只需要用vector记录为0的坐标即可。代码如下

class Solution {
public:
    void setZeroes(vector<vector<int>>& matrix) {
        int m = matrix.size(); // 行数
        int n = matrix[0].size(); // 列数
        vector<pair<int, int>> flag; // 记录0的坐标

        for (int i = 0; i < m; ++i) 
            for (int j = 0; j < n; ++j) 
                if (matrix[i][j] == 0) flag.push_back({i, j});

        for (int i = 0; i < flag.size(); ++i) {
            for (int p = 0; p < m; ++p)
                matrix[p][flag[i].second] = 0;
            for (int q = 0; q < n; ++q) 
                matrix[flag[i].first][q] = 0;
        }
    }
};

还可以进一步将空间复杂度降为O(1)。我们可以用矩阵的第一行和第一列代替标记数组，但这样会导致原数组的第一行和第一列被修改，无法记录它们原来是否包含0。所以我们需要额外使用两个标记变量分别记录第一行和第一列是否包含0。

实际操作起来，我们先预处理两个标记变量，接着使用其他行和列去处理第一行和第一列，再反过来根据第一行和第一列更新剩余矩阵，最后用两个标记变量更新第一行与第一列即可。

class Solution {
public:
    void setZeroes(vector<vector<int>>& matrix) {
        int m = matrix.size();
        int n = matrix[0].size();
        int flag_col0 = false, flag_row0 = false;
        for (int i = 0; i < m; i++) {
            if (!matrix[i][0]) {
                flag_col0 = true;
            }
        }
        for (int j = 0; j < n; j++) {
            if (!matrix[0][j]) {
                flag_row0 = true;
            }
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (!matrix[i][j]) {
                    matrix[i][0] = matrix[0][j] = 0;
                }
            }
        }
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (!matrix[i][0] || !matrix[0][j]) {
                    matrix[i][j] = 0;
                }
            }
        }
        if (flag_col0) {
            for (int i = 0; i < m; i++) {
                matrix[i][0] = 0;
            }
        }
        if (flag_row0) {
            for (int j = 0; j < n; j++) {
                matrix[0][j] = 0;
            }
        }
    }
};

19.螺旋矩阵

给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

示例 1：

img

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

示例 2：

img

输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]

提示：

  • m == matrix.length
  • n == matrix[i].length
  • 1 <= m, n <= 10
  • -100 <= matrix[i][j] <= 100

思路

直接模拟就行，从左往右、从上往下、从右往左、从下往上分别模拟，具体可以参考以下代码，模拟方法比较巧妙

class Solution {
public:
    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if (matrix.size() == 0 || matrix[0].size() == 0) {
            return {};
        }

        vector<int> ans;
        // 行的开头和结尾
        int lineBegin = 0, lineEnd = matrix[0].size() - 1;
        // 列的开头和结尾
        int listBegin = 0, listEnd = matrix.size() - 1;

        while (1) {
            // 从左到右
            for (int i = lineBegin; i <= lineEnd; ++i)
                ans.push_back(matrix[listBegin][i]);
            if (++listBegin > listEnd) break;

            // 从上往下
            for (int i = listBegin; i <= listEnd; ++i)
                ans.push_back(matrix[i][lineEnd]);
            if (--lineEnd < lineBegin) break;

            // 从右往左
            for (int i = lineEnd; i >= lineBegin; --i)
                ans.push_back(matrix[listEnd][i]);
            if (--listEnd < listBegin) break;

            // 从下往上
            for (int i = listEnd; i >= listBegin; --i)
                ans.push_back(matrix[i][lineBegin]);
            if (++lineBegin > lineEnd) break;
        }
        return ans;
    }
};

20.旋转图像

给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。

你必须在** 原地** 旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要 使用另一个矩阵来旋转图像。

示例 1：

img

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

示例 2：

img

输入：matrix = [[5,1,9,11],[2,4,8,10],[13,3,6,7],[15,14,12,16]]
输出：[[15,13,2,5],[14,3,4,1],[12,6,8,9],[16,7,10,11]]

提示：

  • n == matrix.length == matrix[i].length
  • 1 <= n <= 20
  • -1000 <= matrix[i][j] <= 1000

思路

经过观察，旋转后的矩阵的每一行的内容，是从原来矩阵每一列的最后一个元素开始一直到第一个元素为止，所以很容易能想到先创建一个新矩阵，再用这种方法遍历原矩阵，将旋转后的结果存储到新矩阵中，最后用新矩阵将原矩阵覆盖掉即可。代码如下

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();
        vector<vector<int>> tmp(n);
        for (int i = 0; i < n; ++i) {
            for (int j = n - 1; j >= 0; --j) {
                tmp[i].push_back(matrix[j][i]);
            }
        }
        matrix = tmp;
    }
};

但题目要求不能新建矩阵，所以下面换一个思路：通过翻转矩阵实现。

注意到目标矩阵可以通过原矩阵进行翻转变换得到，具体翻转过程是先通过水平轴翻转一次，再通过主对角线翻转一次。

水平轴翻转

在这里插入图片描述

主对角线翻转
在这里插入图片描述

水平轴翻转的坐标变换如下
在这里插入图片描述

主对角线翻转变换的坐标变换如下
在这里插入图片描述

具体代码如下

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();
        // 水平翻转
        for (int i = 0; i < n / 2; ++i) {
            for (int j = 0; j < n; ++j) {
                swap(matrix[i][j], matrix[n - i - 1][j]);
            }
        }
        // 主对角线翻转
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < i; ++j) {
                swap(matrix[i][j], matrix[j][i]);
            }
        }
    }
};
YUKIPEDIA~
关注
  • 29
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
leetcode:leetcode记录
06-15
标题“LeetCode: LeetCode 记录”暗示了这是一个关于在LeetCode上解决问题并积累经验的过程，而描述中的“标记出色且干净的代码”则强调了代码质量和可读性的重要性。 在LeetCode上，用户通常会用不同的编程语言来...
leetcode:每日LeetCode记录
05-01
LeetCode记录大批先锋和法给定一个整数数组nums ，编写一个返回该数组“ pivot”索引的方法。 我们将枢轴索引定义为索引，其中索引左侧的数字总和等于索引右侧的数字总和。 如果不存在这样的索引，则应返回-1。 如果...
LeetCode记录
cmqwan的博客
08-02 7437
LeetCode记录 写在前面 最近开始对算法感兴趣(主要是自己太水了哈)，毕竟自己不是专业毕业的，希望能务实基础。就想着做一下算法题目。 就当是一个记录，后面会把自己的解题思路和代码写进去 看了网上大佬们的意见，不按照题目编号直接做。 按照题目难易程度做下去 导航...
Leetcode 记录二
Primer5
06-18 147
Leetcode 记录二
leetcode记录说明
weixin_30297281的博客
08-02 109
　　leetcode是一个在线算法测试网站，上面有很多经典的算法题目，经常会在程序员面试中出现。 　　作为一个初级coder，这些题目对我的提升还是很大的。我准备做完上面的题目后，记录在这里，也算是挺有意思的一件事。 　　目前已经做过了42道题，这些我有的代码已经丢失，等最终全部做完有时间再重新做。 　　就这样，开更！ 转载于:https://www.cnblogs.com/nvbxmmd/...
Leetcode练习记录
weixin_47532216的博客
01-07 468
文章目录1. 第一天 1. 第一天
刷leetcode记录
blue0710的专栏
04-20 475
刷leetcode记录 目前已经刷了102道题目，进入hard攻克阶段。昨天围观大神敲代码，感到大神已经将很多内容训练为内隐知识。 另一方面感觉到，目前可以先不求甚解。熟练了之后很多东西，自然而然就会了。先记熟练会了再说。 1.Regular Expression Matching 已经困扰了很多天了，http://blog.csdn.net/doc_sgl/article/details/
Leetcode学习记录
shi895157565的博客
05-07 292
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录二分查找模板、左值二分模板、右值二分模板 二分查找模板、左值二分模板、右值二分模板 作者：naruto-gyb 链接：https://leetcode-cn.com/problems/find-first-and-last-position-of-element-in-sorted-array/solution/zuo-zhi-by-naruto-gyb-l152/ 来源：力扣（LeetCode）34.在排序数组中查找元素的第一.
leetcode刷题记录
Petrichor15的博客
03-18 423
好记性不如烂笔头，一天一道leetcode刷题记录
LeetCode 记录(c#版)
qq_22161487的博客
09-27 416
LeetCode 记录(c#版) 26. Remove Duplicates from Sorted Array(Tag—-Array) 原题: Given a sorted array, remove the duplicates in place such that each element appear only once and return the new length.Do not a
leetcode记录-633-平方数之和
Slay__的博客
02-05 6394
633.平方数之和 思路 如果存在两个数平方和等于c，这两个数一定小于根号c取整（设为a），因此左指针l取0（0莫忘），右指针r取a，若平方和小于c，l++，大于c，r++，等于c，返回true。 代码 class Solution { public boolean judgeSquareSum(int c) { long left = 0; long right = (long) Math.sqrt(c); while (left <= ri
我的Leetcode记录
02-17
"我的LeetCode记录"很可能是你在LeetCode上完成的练习和挑战的集合，主要关注Python编程语言。在这个过程中，你可能积累了丰富的经验，解决了各种类型的问题，包括但不限于数组、字符串、二叉树、动态规划等。 ...
leetcode答案-leetcode:leetcode记录
06-30
这个资源包“leetcode答案-leetcode:leetcode记录”显然是一个关于LeetCode题目解答的开源项目，名为"leetcode-master"，意味着它可能包含了对LeetCode各种问题的解法，涵盖多种编程语言。 在LeetCode上，你可以...
leetcode题库-leetcode:leetcode记录
06-29
这个压缩包“leetcode题库-leetcode:leetcode记录”显然是一个与LeetCode相关的资源，可能是某位用户在刷题过程中的个人记录或解决方案集合。 在LeetCode上，用户可以通过解决不同难度级别的问题来锻炼自己的编程...
stack(leetcode练习题)
2301_81692739的博客
07-19 380
最开始写的，总会有一些样例过不了，没考虑全，后来看题解上的方法，将下标压入栈中，用右括号的下标减去栈顶下标，就是有效长度。不然只顾着最长，反而无法得到正确的有效长度。一个完整的括号，要么是1，要么里边包含其他括号，进行了 *2。所以，可以每遇到一个右括号，进行一次运算，第一次为 1，以后每次乘二，累加到栈顶。遇到左括号，就向栈压入0，重新运算，当遇到右括号，再弹出.如果数字比栈顶小就压入，否则，将栈顶删除直到，比栈顶小或这栈为空。关于stack的知识，可以看点击查看上面的博客，以下题目全在。
【LeetCode】分隔链表
qq_26521261的博客
07-20 323
给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。简单粗暴的做法：遍历原链表，当前节点新建一个，遇到小的，放到小的链表中，遇到大的，放到大的链表中，最后合并一下。输入：head = [1,4,3,2,5,2], x = 3。你应当 保留 两个分区中每个节点的初始相对位置。输入：head = [2,1], x = 2。链表中节点的数目在范围 [0, 200] 内。输出：[1,2,2,4,3,5]
LeetCode 188题： 买卖股票的最佳时机IV优化（原创）
最新发布
it_fly的专栏
07-21 146
算法思路：1.买了j次的最大获利值等于：昨天买了j次，和昨天卖了j-1次，今天再买的最大值；2.卖了j次的最大获利值等于：昨天卖了j次，和昨天买了j次，今天再卖掉的最大值
Leetcode—207. 课程表【中等】
Atticus的博客
07-19 292
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
"详细代码解析：Leetcode刷题记录
在本文中，我将分享我的leetcode刷题记录，包括我在解决每个问题时所使用的代码和思路讲解。这份记录非常详细，旨在帮助其他人更好地理解leetcode题目的解法和编程技巧。 21、TWO SUM 这道题的关键在于要找到数组中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

YUKIPEDIA~

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值