力扣单调栈专题 739. 每日温度 496.下一个更大元素I 503.下一个更大元素II 42. 接雨水 84.柱状图中最大的矩形 步骤及C++实现 总结

最新推荐文章于 2024-11-04 12:20:00 发布
最新推荐文章于 2024-11-04 12:20:00 发布
阅读量366 收藏
点赞数
分类专栏： C++刷题-LeetCode-牛客 文章标签： leetcode c++ 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/UUUUU22/article/details/131385517
版权

文章目录

739. 每日温度

在这里插入图片描述

  1. 暴力解法，双层for循环，时间复杂度是O(n^2)。

  2. 什么时候用单调栈？
    通常是一维数组，要找任一个元素的右边（左边）第一个比自己大（小）的元素的位置，此时优先考虑单调栈，时间复杂度为O(n)。

  3. 使用单调栈时，首先要明确如下几点：

 1）单调栈里存放的元素是什么？
   单调栈只需要存放元素的下标i，T[i]直接获取对应的元素。

 2）单调栈里元素是递增还是递减？
   本题使用递增顺序（从栈头到栈底的顺序）。当单调栈递增，元素i入栈时，才能保证 元素i 是 栈顶元素 在数组中右边第一个比自己大的元素，也就是说找到栈顶元素 右边第一个比自己大的元素是 元素i。

 3）三种情况：
  当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况
  当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况
  当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况

  1. C++实现
class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        //递增栈
        stack<int> st;//存放对应元素的下标
        vector<int> result(temperatures.size(), 0);
        st.push(0);//初始化
        for(int i=1; i<temperatures.size(); i++)
        {
            if(temperatures[i] < temperatures[st.top()]) st.push(i);//情况1  当前元素比栈顶元素小 当前元素入栈 
            else if(temperatures[i] == temperatures[st.top()]) st.push(i);//情况2  当前元素等于栈顶元素 当前元素入栈 
            else//情况3 当前元素比栈顶元素大 保存结果 栈顶出栈 当前元素入栈 
            {
                while(!st.empty() && temperatures[i] > temperatures[st.top()])
                {
                    result[st.top()] = i - st.top();
                    st.pop();
                }
                st.push(i);
            }
        }
        return result;
    }
};

简化

class Solution {
public:
    vector<int> dailyTemperatures(vector<int>& temperatures) {
        //递增栈 简化
        stack<int> st;
        vector<int> result(temperatures.size(), 0);
        st.push(0);
        for(int i=1; i<temperatures.size(); i++)
        {
            while(!st.empty() && temperatures[i] > temperatures[st.top()])
            {
                result[st.top()] = i - st.top();
                st.pop();
            }
            st.push(i);
        }
        return result;
    }
};

496.下一个更大元素 I

在这里插入图片描述
需要注意点：

  1. result数组初始化应该为多少？
     题目提示，如果不存在下一个更大元素就输出 -1，所以result数组初始化为-1。

  2. 遍历nums2时需要判断nums2[i]在nums1中是否出现过，因为最后是根据nums1元素的下标来更新result数组。

  3. 题目提示nums1 和 nums2是不重复的数组，因此可以用map做映射，根据数值快速找到下标，还可以判断nums2[i]是否在nums1中出现过。使用集合来解决哈希问题时，优先使用unordered_set，它的查询和增删效率是最优的。

  4. 单调递增栈顺序，栈头到栈底元素顺序要从小到大。栈内元素递增才能找到右边第一个比自己大的元素。

  5. 三种情况：

  • 当前遍历的元素T[i]小于栈顶元素T[st.top()]，满足递增栈，直接入栈。
  • 当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况，直接入栈，求的是右边第一个比自己大的元素，而不是大于等于
  • 当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况，不满足递增栈，找到右边第一个比自己大的元素，对元素进行处理：栈里的元素是nums2的元素，判断栈顶元素是否在nums1里出现过。如果出现过就记录，此时栈顶元素在nums2数组中右面第一个大的元素是当前遍历元素nums2[i]。

C++实现

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        stack<int> st;
        vector<int> result(nums1.size(), -1);//处理的是nums1的元素
        if(nums1.size() == 0) return result;
        //没有重复元素 map做映射 根据数值快速找到下标，判断nums2[i]是否在nums1中出现过。
        unordered_map<int, int> umap;// key:下标元素，value：下标  为了快速查找元素
        for(int i=0; i<nums1.size(); i++) umap[nums1[i]] = i;
        st.push(0);
        for(int i=1; i<nums2.size(); i++)
        {
            if(nums2[i] < nums2[st.top()]) st.push(i);
            else if(nums2[i] == nums2[st.top()]) st.push(i);
            else{
                while(!st.empty() && nums2[i] > nums2[st.top()])
                {
                    if(umap.count(nums2[st.top()]) > 0)//判断nums2[i]是否在nums1中出现过
                    {
                        int index = umap[nums2[st.top()]];
                        result[index] = nums2[i];//nums2[i]在nums1出现过，记录结果
                    }
                    st.pop();
                }
                st.push(i);
            }
        }
        return result;
    }
};

简化

class Solution {
public:
    vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
        //三种情况合并写
        stack<int> st;
        vector<int> result(nums1.size(), -1);
        if(nums1.size() == 0) return result;
        st.push(0);

        //映射容器
        unordered_map<int, int> umap;
        for(int i=0; i<nums1.size(); i++) umap[nums1[i]] = i;

        //遍历nums2
        for(int i=1; i<nums2.size(); i++)
        {
            while(!st.empty() && nums2[i] > nums2[st.top()])
            {
                if(umap.count(nums2[st.top()]) > 0)
                {
                    int index = umap[nums2[st.top()]];
                    result[index] = nums2[i];
                }
                st.pop();
            }
            st.push(i);
        }
        return result;
    }
};

503.下一个更大元素II

在这里插入图片描述
在题496变形，一个循环数组找下一个更大的元素

方法一 数组拼接

把nums数组首尾拼接组成新的nums来操作，最后resize再返回结果。

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        //拼接数组
        vector<int> nums1(nums.begin(), nums.end());
        nums.insert(nums.end(), nums1.begin(), nums1.end());

        vector<int> result(nums.size(), -1);
        if(nums.size() == 0) return result;

        stack<int> st;
        st.push(0);
        for(int i=1; i<nums.size(); i++)
        {
            if(nums[i] < nums[st.top()]) st.push(i);
            else if(nums[i] == nums[st.top()]) st.push(i);
            else
            {
                while(!st.empty() && nums[i] > nums[st.top()])
                {
                    result[st.top()] = nums[i];
                    st.pop();
                }
                st.push(i);
            }
        }
        result.resize(nums.size() / 2);
        return result;
    }
};

方法二 模拟遍历两边nums

在遍历的过程中模拟走了两边nums，用i % nums.size()来代替i 操作

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        //遍历中模拟走了两边nums 用i % nums.size()来操作
        vector<int> result(nums.size(), -1);
        if(nums.size() == 0) return result;
        stack<int> st;
        st.push(0);

        for(int i=1; i<nums.size() * 2; i++)
        {
            if(nums[i % nums.size()] < nums[st.top()]) st.push(i % nums.size());
            else if(nums[i % nums.size()] == nums[st.top()]) st.push(i % nums.size());
            else 
            {
                while(!st.empty() && nums[i % nums.size()] > nums[st.top()])
                {
                    result[st.top()] = nums[i % nums.size()];
                    st.pop();
                }
                st.push(i % nums.size());
            }
        }
        return result;
    }
};

简化

class Solution {
public:
    vector<int> nextGreaterElements(vector<int>& nums) {
        //简化 遍历中模拟走了两边nums 用i % nums.size()来操作
        vector<int> result(nums.size(), -1);
        if(nums.size() == 0) return result;
        stack<int> st;
        st.push(0);

        for(int i=1; i<nums.size() * 2; i++)
        {
            while(!st.empty() && nums[i % nums.size()] > nums[st.top()])
            {
                result[st.top()] = nums[i % nums.size()];
                st.pop();
            }
            st.push(i % nums.size());
        }
        return result;
    }
};

42. 接雨水

在这里插入图片描述

双指针 暴力法

按照列来计算，宽度w=1，每一列雨水的高度取决于该列左侧最高的柱子和 右侧最高的柱子 ，两者中较矮的柱子高度。

  • 列4的雨水高度 = min(列3高度， 列7高度) — 列4高度，height = min(lefth, righth) - h，列4雨水体积 = w * height。
    • 列4 左侧最高的柱子是列3，高度为2，lefth；
    • 列4 右侧最高的柱子是列7，高度为3，righth；
    • 列4 柱子的高度h为1；
  • 从头遍历所有列，求出每一列的雨水体积，再累加就是总雨水体积。注意第一个柱子和最后一个柱子不接雨水。
  • 双指针-超时 时间复杂度是 O ( n 2 ) O(n^2) O(n2)
class Solution {
public:
    int trap(vector<int>& height) {
        //双指针法 暴力解法 超时
        int sum = 0;
        for(int i=0 ;i<height.size(); i++)
        {
            //第一个和最后一个柱子不接水
            if(i == 0 || i == height.size()-1) continue;

            //更新当前柱子 左右两边柱子的最高高度
            int leftheight = height[i];// 记录左边柱子的最高高度
            int rightheight = height[i];// 记录右边柱子的最高高度
            for(int l=i-1; l>=0; l--)
            {
                if(height[l] > leftheight) leftheight = height[l];
            }
            for(int r=i+1; r<height.size(); r++)
            {
                if(height[r] > rightheight) rightheight = height[r];
            }

            //统计高度差 累加
            int h = min(rightheight, leftheight) - height[i];
            if(h > 0) sum += h;
        }
        return sum;
    }
};

双指针优化

暴力解法中，通过列来计算每一列的雨水体积再累加求出雨水总体积，其中，当前列雨水面积 = 1 * (min(左边柱子的最高高度，记录右边柱子的最高高度) - 当前柱子高度)。双指针遍历时，每到一个柱子都向两边遍历一遍，有重复计算。

优化：把每一个位置的左边最高高度记录在一个数组上maxLeft，右边最高高度记录在一个数组上maxRight，避免了重复计算：

  • 从左向右遍历：maxLeft[i] = max(height[i], maxLeft[i - 1]);
  • 从右向左遍历：maxRight[i] = max(height[i], maxRight[i + 1]);
  • 时间复杂度是 O ( n ) O(n) O(n)
class Solution {
public:
    int trap(vector<int>& height) {
        //双指针法 
        if(height.size() <= 2) return 0;

        //统计当前柱子左右两侧柱子最高高度
        vector<int> maxleft(height.size(), 0);
        vector<int> maxright(height.size(), 0);
        int size = maxright.size();
        //左边柱子 正序 当前柱子高度 容器上一个柱子高度
        maxleft[0] = height[0];//for循环从1开始遍历
        for(int i=1; i<size; i++) maxleft[i] = max(height[i], maxleft[i-1]);
        //右边柱子 倒叙 当前柱子高度 容器上一个柱子高度
        maxright[size-1] = height[size-1];
        for(int i=size-2; i>=0; i--) maxright[i] = max(height[i], maxright[i+1]);

        //累计高度 左右柱子中较矮的柱子高度-当前柱子高度=雨水长度
        //求的是面积 宽度=1 相当于统计长度
        int sum = 0;
        int h = 0;
        for(int i=0; i<size; i++)
        {
            h = min(maxright[i], maxleft[i]) - height[i];
            if(h>=0) sum += h;
        }
        return sum;
    }
};

单调栈

在这里插入图片描述

  • 需要找一个元素，及其右边最大元素和左边最大元素来计算雨水面积
  • 按照行方向来计算雨水，当前柱子左右两边柱子的高度差就是雨水面积的长度，下标差就是宽度
  • 单调栈内元素的顺序是从小到大，如果当前柱子高度大于栈头元素高度，出现凹槽，栈头元素就是凹槽底部的柱子，栈头第二个元素就是凹槽左边的柱子，添加元素就是凹槽右边的柱子。
  • 栈里要保存什么数值：使用单调栈，也是通过 长 * 宽 来计算雨水面积的。长就是通过柱子的高度来计算，宽是通过柱子之间的下标来计算
  • 单调栈处理逻辑，主要有三种情况
    • 情况一：当前遍历的元素（柱子）高度小于栈顶元素的高度 height[i] < height[st.top()]
    • 情况二：当前遍历的元素（柱子）高度等于栈顶元素的高度 height[i] == height[st.top()]
    • 情况三：当前遍历的元素（柱子）高度大于栈顶元素的高度 height[i] > height[st.top()]
  • 注意点：
    • 遇到相同高度的柱子，即相同的元素时，更新栈内下标，弹出栈内元素（旧下标），栈内加入新元素（新下标），如5、5、1、3，如果添加第二个5时，先将第一个5的下标弹出，再把第二个5入栈
    • 栈内存放元素下标，通过height[stack.top()]直接获取对应下标的高度
    • 栈中存放遍历过的元素，因此先将下标0入栈，st.push(0);
class Solution {
public:
    int trap(vector<int>& height) {
        //单调栈
        if(height.size() <= 2) return 0;

        stack<int> st;//柱子下标-雨水长度
        st.push(0);
        int sum = 0;
        int mid = 0;//凹槽最低
        int h = 0, w = 0;
        for(int i=1; i<height.size(); i++)
        {
            if(height[i] < height[st.top()]) st.push(i);//情况一
            else if(height[i] == height[st.top()])//情况二 保存较近的柱子高度
            {
                st.pop();
                st.push(i);
            }
            else//情况三 出现凹槽
            {
                while(!st.empty() && height[i] > height[st.top()])
                {
                    mid = st.top();//注意这是柱子下标
                    st.pop();//弹出凹槽底部
                    if(!st.empty())//如果还有元素 该栈顶元素才是凹槽左边高度
                    {
                        h = min(height[st.top()], height[i]) - height[mid];
                        w = i - st.top() - 1; // 注意减一，只求中间宽度
                        sum += h * w;
                    }
                }
                st.push(i);
            }
        }
        return sum;
    }
};

简化

class Solution {
public:
    int trap(vector<int>& height) {
        //单调栈 简化
        if(height.size() <= 2) return 0;
        stack<int> st;
        st.push(0);
        int sum = 0;
        int mid = 0, h = 0, w = 0;
        for(int i=1; i<height.size(); i++)
        {
            while(!st.empty() && height[i] > height[st.top()])
            {
                mid = st.top();//凹槽底部
                st.pop();
                if(!st.empty())
                {
                    h = min(height[i], height[st.top()]) - height[mid];
                    w = i - st.top() - 1;//减1才是凹槽底部的宽度
                    sum += h * w;
                }
            }
            st.push(i);
        }
        return sum;

    }
};

84.柱状图中最大的矩形

在这里插入图片描述

暴力解法

时间复杂度是 O ( n 2 ) O(n^2) O(n2)

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        //暴力解法 双指针 找左右最高柱子
        int sum = 0;
        for(int i=0; i<heights.size(); i++)
        {
            int left = i;
            int right = i;
            for(; left>=0; left--)
            {
                if(heights[left] < heights[i]) break;
            }
            for(; right<heights.size(); right++)
            {
                if(heights[right] < heights[i]) break;
            }
            int w = right - left - 1;
            int h = heights[i];
            sum = max(sum, h*w);
        }
        return sum;
    }
};

双指针解法

重点在于要记录每个柱子的左边第一个小于该柱子的下标，而不是高度。所以需要循环查找，使用while

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        //双指针 优化
        //记录的是左右两边最矮柱子中离得最近的柱子的下标
        int size = heights.size();
        vector<int> minleftindex(size);
        vector<int> minrightindex(size);

        // 记录每个柱子 左边第一个小于该柱子的下标
        minleftindex[0] = -1;//初始化，防止下面while死循环
        for(int i=1; i<size; i++)
        {
            int t = i-1;
            //找到离得最近的左边最矮柱子 不用if，而是不断向左寻找的过程
            while(t>=0 && heights[t] >= heights[i]) t = minleftindex[t];//记录该柱子的下标
            minleftindex[i] = t;//容器中更新下标
        }

        // 记录每个柱子 右边第一个小于该柱子的下标
        minrightindex[size-1] = size;
        for(int i=size-2; i>=0; i--)
        {
            int t = i+1;
            //不用if，而是不断向左寻找的过程
            while(t<size && heights[t] >= heights[i]) t = minrightindex[t];
            minrightindex[i] = t;
        }

        int sum = 0;
        int result = 0;
        for(int i=0; i<size; i++)
        {
            sum = heights[i] * (minrightindex[i] - minleftindex[i] - 1);
            result = max(sum, result);
        }
        return result;
    }
};

单调栈

  • 题42是找每个柱子左右两边第一个大于该柱子高度的柱子，而本题是找每个柱子左右两边第一个小于该柱子高度的柱子，因此单调栈的元素顺序是从大到小，这样才能保证栈顶元素找到左右两边第一个小于栈顶元素的柱子。
  • 要求的最大面积是由当前元素（要入栈元素）、栈顶元素、栈顶下一个元素组成凸性面积：
    • 当前元素是height[i] = 40，凸形的右边（相对于柱子60下标）
    • 栈顶元素是height[st.top()] = 60，凸形的顶部，中间位置
    • 栈顶下一个元素是50，凸形的左边（相对于柱子60下标）
  • 单调栈处理逻辑，主要有三种情况
    • 情况一：当前遍历的元素heights[i]大于栈顶元素heights[st.top()]的情况
    • 情况二：当前遍历的元素heights[i]等于栈顶元素heights[st.top()]的情况
    • 情况三：当前遍历的元素heights[i]小于栈顶元素heights[st.top()]的情况
class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        //单调栈
        int result = 0;
        stack<int> st;
        //原数组头尾加入数字0分别为了避免数组是降序 升序时无法去三个值组成面积
        heights.insert(heights.begin(), 0);
        heights.push_back(0);
        st.push(0);
        //从大到小入栈 才能找到凸形面积
        for(int i=1; i<heights.size(); i++)//数组第一个元素已经入栈
        {
            if(heights[i] > heights[st.top()]) st.push(i);
            else if(heights[i] == heights[st.top()]) st.push(i);
            else
            {
                while(!st.empty() && heights[i] < heights[st.top()])
                {
                    int mid = st.top();
                    st.pop();
                    if(!st.empty())
                    {
                        int left = st.top();
                        int right = i;
                        int w = right - left - 1;//只要最高柱子的宽度
                        result = max(result, w * heights[mid]);
                    }
                }
                st.push(i);
            }
        }
        return result;
    }
};

化简

class Solution {
public:
    int largestRectangleArea(vector<int>& heights) {
        //单调栈 简化
        int result = 0;
        stack<int> st;
        heights.insert(heights.begin(), 0);
        heights.push_back(0);
        st.push(0);
        for(int i=1; i<heights.size(); i++)
        {
            while(!st.empty() && heights[i] < heights[st.top()])
            {
                int mid = st.top(); 
                st.pop();
                if(!st.empty())
                {
                    //int left = st.top();
                    //int right = i;
                    //right - left - 1
                    int w = i - st.top() - 1;
                    result = max(result, heights[mid] * w);
                }
            }
            st.push(i);
        }
        return result;
    }
};

总结

  1. 什么时候用单调栈？
  • 通常是一维数组，要找任一个元素的右边（左边）第一个比自己大（小）的元素的位置，此时优先考虑单调栈，时间复杂度为O(n)
  • 找右边第一个比自己大的元素位置，单调递增栈——题739、题496、题503
  • 找左边和右边第一个比自己大的元素位置，单调递增栈——题42
  • 找左边和右边第一个比自己小的元素位置，单调递递减——题84
  1. 单调栈的原理是什么？为什么时间复杂度是O(n)？
  • 单调栈的本质是空间换时间，因为在遍历过程中需要用一个栈来记录右边第一个比当前元素大的元素。
  • 优点是整个数组只需要遍历一次，因此时间复杂度是O(n)。
  • 单调栈是用来记录遍历过的元素。遍历数组时，如果不知道哪些元素是遍历过的，会导致无法得知是否有一个比当前元素更小的元素被遍历了。所以要用一个容器——单调栈，来记录遍历过的元素。
  1. 使用单调栈时，首先要明确如下几点：

 1）单调栈里存放的元素是什么？
   单调栈只需要存放元素的下标i，T[i]直接获取对应的元素。

 2）单调栈里元素是递增还是递减？
   如果求一个元素右边第一个更大元素，单调栈是递增的，如果求一个元素右边第一个更小元素，单调栈是递减的。
   当单调栈递增，元素i入栈时，才能保证 元素i 是 栈顶元素 在数组中右边第一个比自己大的元素，也就是说找到栈顶元素 右边第一个比自己大的元素是 元素i。

 3）三种情况：
  当前遍历的元素T[i]小于栈顶元素T[st.top()]的情况
  当前遍历的元素T[i]等于栈顶元素T[st.top()]的情况
  当前遍历的元素T[i]大于栈顶元素T[st.top()]的情况

虚假自律就会真自律！
关注
专栏目录
这是一个用来爬取力扣中国(LeetCode CN)提交代码的爬虫。.zip
03-01
爬虫（Web Crawler）是一种自动化程序，用于从互联网上收集信息。其主要功能是访问网页、提取数据并存储，以便后续分析或展示。爬虫通常由搜索引擎、数据挖掘工具、监测系统等应用于网络数据抓取的场景。 爬虫的...
力扣题库刷题笔记34-在排序数组中查找元素的第一个和最后一个位置
07-07
力扣题库刷题笔记34-在排序数组中查找元素的第一个和最后一个位置
hackhu2019#LeetCode#LeetCode31. 下一个排列1
07-25
来源：力扣（LeetCode） 链接：：过滤特殊情况，
[力扣] 203.移除链表元素
12-23
链表节点一般由两部分组成：一个存储数据的 `val` 字段和一个指向下一个节点的 `next` 指针。 在解决这个问题时，我们采取以下策略： 1. **初始化**：创建两个指针 `prev` 和 `cur`，`prev` 用于保存当前节点的前...
84. 柱状图中最大的矩形 - 力扣（LeetCode）.html
03-04
84. 柱状图中最大的矩形 - 力扣（LeetCode）.html
【力扣 + 牛客 | SQL题 | 每日5题】牛客SQL热题216，217，223
2301_80912559的博客
10-30 1013
你正在搭建一个用户活跃度的画像，其中一个与活跃度相关的特征是“最长连续登录天数”， 请用SQL实现“2023年1月1日-2023年1月31日用户最长的连续登录天数”一句话：两个记录的日期的差值如果等于两记录的排名差值，说明中间一直是连续的。使用join查询方式找出没有分类的电影id以及其电影名称。这不一眼窗口函数么。
Leetcode 62. 不同路径 动态规划+空间优化
想买很多漂亮衣服但是买不起的博客
11-01 293
【代码】Leetcode 62. 不同路径 动态规划+空间优化。
【力扣专题栏】合并K个升序链表，3种解法讲解如何实现vector容器里面多个链表的合并？
2301_78704584的博客
10-30 351
解释：首先vector容器里面放有多个元素，每个元素是一个链表，每个链表含有0个或多个节点。当到达递归结束条件时，就开始往回归并。
抓住问题的关键解决LeetCode第3337题字符串转换后的长度II
最新发布
2302_79682652的博客
11-04 329
将s[i]替换为字母表中后续的nums[s[i]-'a']个连续字符。例如，如果s[i]='y'且nums[24]=3，则字符'y'转换为它后面的3个连续字符，结果为"zab"。输入：s="abcyy",t=2,nums=[1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,2]输入：s="azbk",t=1,nums=[2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2]
【二分查找】【三种写法】——在排序数组中查找元素的第一个和最后一个位置#力扣hot100
weixin_47868976的博客
10-31 1079
给你一个按照非递减顺序排列的整数数组nums，和一个目标值target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值target，返回[-1, -1]。必须设计并实现时间复杂度为O(log n)的算法解决此问题。
leetcode动态规划（二十四）-最长递增子序列
weixin_40198632的博客
11-04 134
给你一个整数数组nums，找到其中最长严格递增子序列的长度。是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余元素的顺序。例如，[3,6,2,7]是数组的子序列。4最长递增子序列是 [2,3,7,101]，因此长度为 4。41。
【Python3】【力扣题】409. 最长回文串
yannan20190313的博客
11-01 296
【Python3】【力扣题】409. 最长回文串
力扣——另一个的子树（C语言）
2401_83456040的博客
10-30 192
原理：这里调用前面比较两颗树是否相同的函数（小编之前文章里面有：相同的树），将节点与subRoot传入函数，向下递归，左右节点，只要找到一个返回true，说明存在子树，即最后返回true。具有相同结构和节点值的子树。的某个节点和这个节点的所有后代节点。也可以看做它自身的一棵子树。
【leetcode】动态规划刷题总结-区间问题
zs16113的博客
10-30 307
区间DP问题一般从数组的左右两端不断缩短，求解关于某段下标区间的最优值，dp[i][j]一般定义为下标区间[i,j]的最优值。
Leetcode 热题100之二叉树2
qq_43060884的博客
11-02 712
深搜不行就广搜~
C++ | Leetcode C++题解之第522题最长特殊序列II
Ddddddd_158的博客
10-31 222
C++ | Leetcode C++题解之第522题最长特殊序列II
【LeetCode:153. 寻找旋转排序数组中的最小值 + 二分】
Coder_ljw的博客
11-03 726
【LeetCode:153. 寻找旋转排序数组中的最小值 + 二分】已知一个长度为 n 的数组，预先按照升序排列，经由 1 到 n 次 旋转 后，得到输入数组。例如，原数组 nums = [0,1,2,4,5,6,7] 在变化后可能得到： - 若旋转 4 次，则可以得到 [4,5,6,7,0,1,2] - 若旋转 7 次，则可以得到 [0,1,2,4,5,6,7] 注意，数组 [a[0], a[1], a[2], ..., a[n-1]] 旋转一次 的结果为数组 [a[n-1], a[0], a[1],
LeetCode22:括号生成
qq_36070104的博客
11-01 557
代表生成括号的对数，请你设计一个函数，用于能够生成所有可能的并且。题目要求生成所有有效的括号组合。有效的括号组合是指每个左括号。，且在任意前缀中左括号的数量不少于右括号的数量。
LeetCode 每日一题 2024/10/28-2024/11/3
AlphaTao的博客
11-03 638
记录了初步解题思路 以及本地实现代码；并不一定为最优 也希望大家能一起探讨 一起进步
力扣2469. 温度转换
10-31
力扣2469题目要求将摄氏度转换为开氏度和华氏度，并以数组的形式返回结果。其中开氏度等于摄氏度加上273.15，华氏度等于摄氏度乘以1.8再加上32。这道题的解法非常简单，只需要按照公式计算即可。时间复杂度和空间...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值