【CODE】单调栈应用

最新推荐文章于 2021-09-19 21:40:08 发布
最新推荐文章于 2021-09-19 21:40:08 发布
阅读量491 收藏
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Li_Jiaqian/article/details/104834201
版权

目录

33. Search in Rotated Sorted Array

81. Search in Rotated Sorted Array II

153. Find Minimum in Rotated Sorted Array

154. Find Minimum in Rotated Sorted Array II

129. Sum Root to Leaf Numbers

670. Maximum Swap

321. Create Maximum Number

402. Remove K Digits

738. Monotone Increasing Digits

33. Search in Rotated Sorted Array

Medium

3871407Add to ListShare

Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e., [0,1,2,4,5,6,7] might become [4,5,6,7,0,1,2]).

You are given a target value to search. If found in the array return its index, otherwise return -1.

You may assume no duplicate exists in the array.

Your algorithm's runtime complexity must be in the order of O(log n).

Example 1:

Input: nums = [4,5,6,7,0,1,2], target = 0
Output: 4

Example 2:

Input: nums = [4,5,6,7,0,1,2], target = 3
Output: -1
class Solution {
public:
    /*Runtime: 4 ms, faster than 80.01% of C++ online submissions for Search in Rotated Sorted Array.
    Memory Usage: 7.9 MB, less than 100.00% of C++ online submissions for Search in Rotated Sorted Array.*/
    int search(vector<int>& nums, int target) {
        int mid = 0;
	    for (int i = 1; i < nums.size(); i++) {
            if (nums[i] < nums[i - 1]) {
                mid = i; break;
            }
        }
        int left, right;
        if (mid - 1 < 0 || (nums[0] > target || nums[mid - 1] < target)) {
            left = mid; right = nums.size() - 1;
        }
        else if (nums[mid]<target || nums.back()>target) {
            left = 0; right = mid - 1;
        }
        else if(nums[0]==target) return 0;
        else if(nums[mid-1]==target) return mid-1;
        else if(nums[mid]==target) return mid;
        else if(nums.back()==target) return nums.size()-1;
        while (left <= right) {
            mid = left + (right - left) / 2;
            if (nums[mid] < target) left = mid + 1;
            else if (nums[mid] > target) right = mid - 1;
            else return mid;
        }
        return -1;
    }
};

81. Search in Rotated Sorted Array II

Medium

997417Add to ListShare

Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e., [0,0,1,2,2,5,6] might become [2,5,6,0,0,1,2]).

You are given a target value to search. If found in the array return true, otherwise return false.

Example 1:

Input: nums = [2,5,6,0,0,1,2], target = 0
Output: true

Example 2:

Input: nums = [2,5,6,0,0,1,2], target = 3
Output: false

Follow up:

  • This is a follow up problem to Search in Rotated Sorted Array, where nums may contain duplicates.
  • Would this affect the run-time complexity? How and why?
/*81. Search in Rotated Sorted Array II
二分法
Runtime: 8 ms, faster than 60.83% of C++ online submissions for Search in Rotated Sorted Array II.
Memory Usage: 8 MB, less than 100.00% of C++ online submissions for Search in Rotated Sorted Array II.*/
bool search(vector<int>& nums, int target) {
	int mid = 0;
	for (int i = 1; i < nums.size(); i++) {
		if (nums[i] < nums[i - 1]) {
			mid = i; break;
		}
	}
	int left, right;
	if (mid - 1 < 0 || (nums[0] > target || nums[mid - 1] < target)) {
		left = mid; right = nums.size() - 1;
	}
	else if (nums[mid]<target || nums.back()>target) {
		left = 0; right = mid - 1;
	}
	else return true;
	while (left <= right) {
		mid = left + (right - left) / 2;
		if (nums[mid] < target) left = mid + 1;
		else if (nums[mid] > target) right = mid - 1;
		else return true;
	}
	return false;
}

153. Find Minimum in Rotated Sorted Array

Medium

1639211Add to ListShare

Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e.,  [0,1,2,4,5,6,7] might become  [4,5,6,7,0,1,2]).

Find the minimum element.

You may assume no duplicate exists in the array.

Example 1:

Input: [3,4,5,1,2] 
Output: 1

Example 2:

Input: [4,5,6,7,0,1,2]
Output: 0
class Solution {
public:
    /*Runtime: 4 ms, faster than 75.40% of C++ online submissions for Find Minimum in Rotated Sorted Array.
    Memory Usage: 7.9 MB, less than 100.00% of C++ online submissions for Find Minimum in Rotated Sorted Array.*/
    int findMin(vector<int>& nums) {
        int left=0,right=nums.size()-1;
        while(left<right){
            int mid=left+(right-left)/2;
            if(nums[mid]<nums[right]) right=mid;
            else if(nums[mid]>nums[right]) left=mid+1;
        }
        return nums[right];
    }
};

154. Find Minimum in Rotated Sorted Array II

Hard

683191Add to ListShare

Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.

(i.e.,  [0,1,2,4,5,6,7] might become  [4,5,6,7,0,1,2]).

Find the minimum element.

The array may contain duplicates.

Example 1:

Input: [1,3,5]
Output: 1

Example 2:

Input: [2,2,2,0,1]
Output: 0

Note:

class Solution {
public:
    /*当数组中存在大量的重复数字时，就会破坏二分查找法的机制，
    将无法取得 O(lgn) 的时间复杂度，又将会回到简单粗暴的 O(n)，
    比如这两种情况：{2, 2, 2, 2, 2, 2, 2, 2, 0, 1, 1, 2} 和 
    {2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2}，可以发现，
    当第一个数字和最后一个数字，还有中间那个数字全部相等的时候，
    二分查找法就崩溃了，因为它无法判断到底该去左半边还是右半边。
    这种情况下，将右指针左移一位（或者将左指针右移一位），略过一个相同数字，
    这对结果不会产生影响，因为只是去掉了一个相同的，
    然后对剩余的部分继续用二分查找法，在最坏的情况下，
    比如数组所有元素都相同，时间复杂度会升到 O(n).
    Runtime: 8 ms, faster than 59.29% of C++ online submissions for Find Minimum in Rotated Sorted Array II.
    Memory Usage: 8 MB, less than 100.00% of C++ online submissions for Find Minimum in Rotated Sorted Array II.*/
    int findMin(vector<int>& nums) {
        int left=0,right=nums.size()-1;
        while(left<right){
            int mid=left+(right-left)/2;
            if(nums[mid]<nums[right]) right=mid;
            else if(nums[mid]>nums[right]) left=mid+1;
            else right--;
        }
        return nums[right];
    }
};

129. Sum Root to Leaf Numbers

Medium

100730Add to ListShare

Given a binary tree containing digits from 0-9 only, each root-to-leaf path could represent a number.

An example is the root-to-leaf path 1->2->3 which represents the number 123.

Find the total sum of all root-to-leaf numbers.

Note: A leaf is a node with no children.

Example:

Input: [1,2,3]
    1
   / \
  2   3
Output: 25
Explanation:
The root-to-leaf path 1->2 represents the number 12.
The root-to-leaf path 1->3 represents the number 13.
Therefore, sum = 12 + 13 = 25.

Example 2:

Input: [4,9,0,5,1]
    4
   / \
  9   0
 / \
5   1
Output: 1026
Explanation:
The root-to-leaf path 4->9->5 represents the number 495.
The root-to-leaf path 4->9->1 represents the number 491.
The root-to-leaf path 4->0 represents the number 40.
Therefore, sum = 495 + 491 + 40 = 1026.
/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    /*Runtime: 4 ms, faster than 74.01% of C++ online submissions for Sum Root to Leaf Numbers.
    Memory Usage: 11.5 MB, less than 100.00% of C++ online submissions for Sum Root to Leaf Numbers.*/
    int sumNumbers(TreeNode* root) {
        stack<TreeNode*> s;
        int res=0;
        TreeNode *pre=NULL;
        string num="";
        while(root || !s.empty()){
            while(root){
                s.push(root);
                num+=(root->val+'0');
                root=root->left;
            }
            TreeNode *tmp=s.top();
            if(tmp->right==NULL || tmp->right==pre){
                s.pop();
                pre=tmp;
                root=NULL;
                if(tmp->right==NULL && tmp->left==NULL){
                    res+=stoi(num);
                }
                num=num.substr(0,num.size()-1);
            }else root=tmp->right;
        }
        return res;
    }
};

670. Maximum Swap

Medium

77255Add to ListShare

Given a non-negative integer, you could swap two digits at most once to get the maximum valued number. Return the maximum valued number you could get.

Example 1:

Input: 2736
Output: 7236
Explanation: Swap the number 2 and the number 7.

Example 2:

Input: 9973
Output: 9973
Explanation: No swap.

Note:

  1. The given number is in the range [0, 108]
class Solution {
public:
    /*Runtime: 0 ms, faster than 100.00% of C++ online submissions for Maximum Swap.
    Memory Usage: 7.9 MB, less than 100.00% of C++ online submissions for Maximum Swap.*/
    int maximumSwap(int num) {
        vector<int> n;
        vector<pair<int,int> > dp;
        while(num){
            n.push_back(num%10);
            num/=10;
        }
        dp.push_back(make_pair(n[0],0));
        for(int i=1;i<n.size();i++){
            if(n[i]>dp.back().first)
                dp.push_back(make_pair(n[i],i));
            else dp.push_back(dp.back());
        }
        for(int i=dp.size()-1;i>=0;i--){
            if(dp[i].first==n[i]) continue;
            int tmp=n[i];
            n[i]=dp[i].first;
            n[dp[i].second]=tmp;
            break;
        }
        
        int res=0;
        for(int i=n.size()-1;i>=0;i--){
            res=res*10+n[i];
        }
        return res;
    }
};

321. Create Maximum Number

Hard

558196Add to ListShare

Given two arrays of length m and n with digits 0-9 representing two numbers. Create the maximum number of length k <= m + n from digits of the two. The relative order of the digits from the same array must be preserved. Return an array of the k digits.

Note: You should try to optimize your time and space complexity.

Example 1:

Input:nums1 = [3, 4, 6, 5]nums2 = [9, 1, 2, 5, 8, 3]k = 5

Output:[9, 8, 6, 5, 3]

Example 2:

Input:nums1 = [6, 7]nums2 = [6, 0, 4]k = 5

Output:[6, 7, 6, 0, 4]

Example 3:

Input:nums1 = [3, 9]nums2 = [8, 9]k = 3

Output:[9, 8, 9]
#include"pch.h"
#include<iostream>
#include<vector>
#include<unordered_map>
#include<unordered_set>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
using namespace std;
/*321. Create Maximum Number
Runtime: 224 ms, faster than 22.70% of C++ online submissions for Create Maximum Number.
Memory Usage: 24.5 MB, less than 80.00% of C++ online submissions for Create Maximum Number.*/
vector<int> mergeVector ( vector<int> nums1, vector<int> nums2){
	//已经从nums1和nums2中取出元素了，现在混合，使之形成的整数最大
	vector<int> res;
	while (!nums1.empty() || !nums2.empty()) {
		//vector可以直接比较大小
		vector<int> &tmp = (nums1 > nums2) ? nums1 : nums2;
		res.push_back(tmp[0]);
		tmp.erase(tmp.begin());//tmp是nums1或nums2的地址，所以删除相当于删除nums1或nums2
	}
	return res;
}
vector<int> maxVector(vector<int> &nums, int k) {
	//在一个nums里面选出k个，组成最大的
	int drop = nums.size() - k;
	vector<int> res;
	for (auto num : nums) {
		while (drop > 0 && !res.empty() && res.back() < num) {
			res.pop_back();
			--drop;
		}
		res.push_back(num);
	}
	res.resize(k);
	return res;
}
vector<int> maxNumber(vector<int>& nums1, vector<int>& nums2, int k) {
	/*从nums1中取i个元素，从nums2中取k-i个元素，i的范围：
	最小值：max(0,k-nums2.size())
	最大值：min(nums1.size(),k)*/
	int i;
	int n1 = nums1.size(), n2 = nums2.size();
	//这里需要使用n1和n2！！！
	int down = 0 > (k - n2) ? 0 : (k - n2);
	int up = n1 < k ? n1 : k;
	vector<int> res;
	for (i = down;i<=up; i++) {
		cout << i << endl;
		res = max(res, mergeVector(maxVector(nums1, i), maxVector(nums2, k - i)));
	}
	return res;
}
int main() {
	vector<int> nums1 = { 3,4,6,5 }, nums2 = { 9,1,2,5,8,3,5 };
	vector<int> res = maxNumber(nums1, nums2, 5);
	for (int i = 0; i < res.size(); i++) cout << res[i] << " ";
	return 0;
}

402. Remove K Digits

Medium

140679Add to ListShare

Given a non-negative integer num represented as a string, remove k digits from the number so that the new number is the smallest possible.

Note:

  • The length of num is less than 10002 and will be ≥ k.
  • The given num does not contain any leading zero

Example 1:

Input: num = "1432219", k = 3
Output: "1219"
Explanation: Remove the three digits 4, 3, and 2 to form the new number 1219 which is the smallest.

Example 2:

Input: num = "10200", k = 1
Output: "200"
Explanation: Remove the leading 1 and the number is 200. Note that the output must not contain leading zeroes.

Example 3:

Input: num = "10", k = 2
Output: "0"
Explanation: Remove all the digits from the number and it is left with nothing which is 0.
#include"pch.h"
#include<iostream>
#include<vector>
#include<unordered_map>
#include<unordered_set>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
#include<string>
using namespace std;
/*402. Remove K Digits
n=num.size()，如果要去除k个，那么剩下n-k个，如何判断哪些数字应该去掉呢？
如果数字递增，那需要从后面移除最大的数字，
如果是乱序，单调栈：：：只要发现当前的数字小于栈顶元素，就将栈顶元素移除，
开始遍历num的每一位，对于当前遍历到的数字c，进行while循环，
如果res不为空，且k>0，且res的最后一位>c，那么应该将res的最后一位移除，k-1
当跳出while循环后，将c加入res，最后将res的大小重设为n-k，
需要用一个while循环来去掉前面所有的0，然后返回时判断是否为空
Runtime: 4 ms, faster than 91.24% of C++ online submissions for Remove K Digits.
Memory Usage: 8.3 MB, less than 100.00% of C++ online submissions for Remove K Digits.*/
string removeKdigits1(string num, int k) {
	string res = "";
	int n = num.size(), keep = n - k;
	for (char c : num) {
		while (k && res.size() && res.back()>c) {
			res.pop_back();
			k--;
		}
		res.push_back(c);
	}
	res.resize(keep);
	while (!res.empty() && res[0] == '0') res.erase(res.begin());
	return res.empty() ? "0" : res;
}
/*Runtime: 4 ms, faster than 91.24% of C++ online submissions for Remove K Digits.
Memory Usage: 8.5 MB, less than 100.00% of C++ online submissions for Remove K Digits.*/
string removeKdigits(string num, int k) {
	string res = "";
	for (char c : num) {
		while(k && res.size() && res.back()>c){
			res.pop_back();
			k--;
		}
		if (res.size() || c != '0') res.push_back(c);
		//如果res为空，并且c为‘0’，那么这个c不放进去，在这一步杜绝了leading zero
	}
	while (res.size() && k) {
		res.pop_back();
		k--;
	}
	return res.empty() ? "0" : res;
}
int main() {
	cout << removeKdigits("10200",1);
	return 0;
}

738. Monotone Increasing Digits

Medium

34453Add to ListShare

Given a non-negative integer N, find the largest number that is less than or equal to N with monotone increasing digits.

(Recall that an integer has monotone increasing digits if and only if each pair of adjacent digits x and y satisfy x <= y.)

Example 1:

Input: N = 10
Output: 9

Example 2:

Input: N = 1234
Output: 1234

Example 3:

Input: N = 332
Output: 299

Note: N is an integer in the range [0, 10^9].

#include"pch.h"
#include<iostream>
#include<vector>
#include<unordered_map>
#include<unordered_set>
#include<queue>
#include<map>
#include<set>
#include<algorithm>
#include<string>
using namespace std;
/*738. Monotone Increasing Digits
Runtime: 0 ms, faster than 100.00% of C++ online submissions for Monotone Increasing Digits.
Memory Usage: 7.7 MB, less than 100.00% of C++ online submissions for Monotone Increasing Digits.*/
int monotoneIncreasingDigits(int N) {
	/*≤N的单调递增整数*/
	int res = 0;
	vector<int> num, st;
	while (N) {
		num.push_back(N % 10);
		N /= 10;
	}
	int start = -1;
	for (int i = num.size() - 2; i >= 0; i--) {
		if (num[i] < num[i + 1]) {
			start = i + 1;
			break;
		}
	}
	if (start == -1) {
		for (int i = num.size() - 1; i >= 0; i--) {
			res = res * 10 + num[i];
		}
		return res;
	}
	while (start < num.size()) {
		if (start + 1 < num.size() && num[start] > num[start + 1]) {
			num[start] -= 1; break;
		}
		else {
			start++;
		}
	}
	if (start == num.size()) { num[start - 1]--; start--; }
	for (int i = 0; i < start; i++) num[i] = 9;
	for (int i = num.size() - 1; i >= 0; i--) {
		res = res * 10 + num[i];
	}
	return res;
}
int main() {
	cout << monotoneIncreasingDigits(322);
	return 0;
}

 

Li_JiaQian
关注
专栏目录
【c++提高1】数据结构之单调栈
小学生蒟蒻
08-23 839
单调栈是栈的一种特殊的形式，必须要求栈内元素单调，当题目有单调性的话（不是答案具有单调性，是信息具有单调性），一般可以使用单调栈，避免重复执行不必要的操作，从而将时间复杂度降低。单调栈没有什么特定的算法，也没有啥模板，所以就不讲太多关于单调栈算法一类的东西了就将一些例题吧。
单调栈和单调队列应用
胖亚亚的小酒馆
02-12 244
1.单调栈 单调栈是指一个栈内部的元素是具有严格单调性的一种数据结构，分为单调递增栈和单调递减栈。 单调栈有两个性质 1.满足从栈顶到栈底的元素具有严格的单调性 2.满足栈的后进先出特性越靠近栈底的元素越早进栈 元素进栈过程 对于一个单调递增栈来说 若当前进栈的元素为 a 如果a &lt; 栈顶元素则直接将a 进栈 如果 a &gt;= 当前栈顶元素则不断将栈顶元素出栈知道满足 a &...
单调栈 c++实现
qq_36276431的博客
06-01 927
单调栈 ---c++ 实现什么是单调栈，单调栈的作用单调栈原理数组无重复值时使用单调栈示例代码：数组有重复值时使用单调栈示例代码：完整代码演示： 今天学了单调栈，然后自己用c++实现了一下 什么是单调栈，单调栈的作用 单调栈就是一个栈，并且栈内数据元素是从栈底到栈顶是单调递增或递减的。使用单调栈来解决求一个数组的每个元素的左边和右边离它最近的比它大的值。且时间复杂度为O(N)，每个数仅仅入栈出栈1次。以下图为例： 数组arr={5,4,6,7};L表示左边离下为i的数组元素最近比它大的值，R表示右边离下为
初识单调栈并使用c++代码解决具体问题
着急的羊的博客
12-20 225
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 单调栈在LeetCode题目中的使用前言一、单调栈是什么？二、使用单调栈解决具体问题LeetCode402. 移掉K位数字思路c++实现总结 前言 在解决LeetCode402移掉K位数字时遇到了问题，在仔细查看其他人的题解后了解到了栈的新用法——单调栈。在之前的使用过程中，我对栈的理解就是可以正序输入倒序输出，而如果使用单调栈就可以形成一个单调递增或者递减的数据结构，在解决一些问题的时候会非常轻松。 提示：以下是本篇文章正文内容，下面
C++之单调栈
qq_45836635的博客
02-20 5948
单调栈的性质 单调栈是一种特殊的栈，特殊之处在于栈内的元素都保持一个单调性。 假设下图是一个栈内元素的排列情况(单调递增的栈)： 此时插入情况有两种： （1）插入元素大于栈顶元素： 因为7 > 6，满足栈内元素单调递增的性质，所以可以直接插入7到栈顶 （2）当插入元素小于栈顶元素的时候，当插入3的时候，需要将栈顶的6，4弹出，在插入，例如： 功能 利用单调栈可以找出从左/右遍历第一个比...
神奇的单调栈
10-27
如果你不知道单调栈的应用,那么你就out了!赶快学习一下吧,保证你看的懂!
单调栈结构及其应用
qq_43536978的博客
09-19 105
单调栈结构及其应用 1.单调栈结构 给定一个不含有重复值的数组 arr，找到每一个 i 位置左边和 右边离 i 位置最近且值比 arr[i] 小的位置。返回所有位置相应的信息。 package hello; import java.util.LinkedList; import java.util.Scanner; import java.util.Stack; public class danDiaoStack {//单调栈结构 public static int[][] process1(int
求最大子矩阵的大小（单调栈的应用）
weixin_44726516的博客
12-23 177
求最大子矩阵的大小 题目 给定一整型矩阵，其中的值只有0和1两种，求其中全是1的所有矩形区域中，最大矩形区域为1的数量。 例如 1 1 1 0 其中最大的矩形区域有3个1，所以返回3. 1 0 1 1 1 1 1 1 1 1 1 0 最大的矩形区域有6个1，所以返回6. 解答 矩阵大小为O（N* M），可以进行到时间复杂度为O（M* N） ...
单调队列与单调栈用法详解
Glory 的 博客
08-27 1万+
基本数据结构的应用一 栈和队列 单调栈 单调队列 和  优先队列的应用 1.单调栈 单调栈是指一个栈内部的元素是具有严格单调性的一种数据结构，分为单调递增栈和单调递减栈。 单调栈有两个性质 1.满足从栈顶到栈底的元素具有严格的单调性 2.满足栈的后进先出特性越靠近栈底的元素越早进栈 元素进栈过程 对于一个单调递增栈来说 若当前进栈的元素为 a 如果a = 当前栈顶元素则不断将栈顶元
算法基础13-《进阶》单调栈和窗口及其更新结构
weixin_42503072的博客
04-01 303
文章目录1 单调栈和窗口及其更新结构1.1 窗口1.1.1 滑动窗口是什么？1.1.2 滑动窗口能做什么？1.1.3 维护窗口滑动的更新结构1.1.4 高频题：求滑动窗口最大值1.1.5 高频题二：达标子数组数量问题---560（不算）1.1.6 如何优化一个问题？1.2 单调栈1.2.1 单调栈结构1.2.2 单调栈的应用 1 单调栈和窗口及其更新结构 1.1 窗口 1.1.1 滑动窗口是什么？ 窗口只是我们脑海中的一个范围，用过L和R来规定我们窗口的边界。保证L<=R这个条件 1、滑动窗口是一
#2377. 「AHOI2013」 差异(后缀数组+单调栈）
whilt_hand的博客
09-14 131
题意描述 给定一个字符串，令 Ti表示它从第 i个字符开始的后缀求 ∑1<=i<j<=nlen(Ti)+len(Tj)−2∗lcp(Ti,Tj)\sum_{1<=i<j<=n}len(Ti)+len(Tj)-2*lcp(Ti,Tj)1<=i<j<=n∑​len(Ti)+len(Tj)−2∗lcp(Ti,Tj) 分析 前两项应用数学公式为(n)(n+1)(n−1)2\frac{(n)(n+1)(n-1)}{2}2(n)(n+1)(n−1)​所以这道题就转换
单调栈stack--c++
没得选择丶
04-22 1794
单调递减栈 遍历高度，如果此时栈为空，或者当前高度小于等于栈顶高度，则把当前高度的坐标压入栈，注意我们不直接把高度压入栈，而是把坐标压入栈，这样方便我们在后来算水平距离。当我们遇到比栈顶高度大的时候，就说明有可能会有坑存在，可以装雨水。此时我们栈里至少有一个高度，如果只有一个的话，那么不能形成坑，我们直接跳过，如果多余一个的话，那么此时把栈顶元素取出来当作坑，新的栈顶元素就是左边界，当前高度是右...
单调栈总结
热门推荐
新熊君的博客
04-11 2万+
单调栈总结目录 定义 性质 功能 例题 HDU 1506 HDU 5033 PKU 2796 PKU 3250 定义性质下面引自百度百科 单调递增或单调减的栈，跟单调队列差不多，但是只用到它的一端，利用它可以用来解决一些ACM/ICPC和OI的题目，如RQNOJ 的诺诺的队列等。 单调栈是一种特殊的栈，特殊之处在于栈内的元素都保持一个单调性。 假设下图是一个栈内元素的排列情况(单调递增的
单调栈（模板）
ojzha的博客
10-02 1753
模板题目：poj 3250 Bad Hair Day Time Limit: 2000MS Memory Limit: 65536K Total Submissions: 19813 Accepted: 6788 DescriptionSome of Farmer John’s N cows (1 ≤ N ≤ 80,000) are having a bad hair
单调栈的分析与代码的实现
sheep_princess的博客
02-02 533
1.单调栈 顾名思义，就是有单调顺序的的栈，既可以是单调递增也可以是单调递减（允许存在相等的数）。 2.作用 利用单调栈，可以找到从左（或者右）遍历第一个比它小（或者大）的元素的位置。 也可以说是 求某组数以其中某一个数字为最小值的最大延伸区间 具体作用就通过举例子来感受吧 题目网址： https://www.acwing.com/problem/content/description/133/ ...
【CODE】01 矩阵（01 Matrix）
Li_Jiaqian的博客
04-15 2143
542. 01 矩阵 难度中等192收藏分享切换为英文关注反馈 给定一个由 0 和 1 组成的矩阵，找出每个元素到最近的 0 的距离。 两个相邻元素间的距离为 1 。 示例 1: 输入: 0 0 0 0 1 0 0 0 0 输出: 0 0 0 0 1 0 0 0 0 示例 2: 输入: 0 0 0 0 1 0 1 1 1 输出: 0 0 0 0 1 0 1 2 ...
【CODE】nSum问题
Li_Jiaqian的博客
03-02 1176
目录 1.Two Sum 15.3Sum 16.3Sum Closest 259. 3Sum Smaller 923.3Sum With Multiplicity 18.4Sum 454.4Sum II 1.Two Sum Easy 13693502Add to ListShare Given an array of integers, returnindi...
【CODE】Top Interview Questions && 并查集
Li_Jiaqian的博客
03-12 1065
目录 78.Subsets 90.Subsets II 825.Friends Of Appropriate Ages 230.Kth Smallest Element in a BST 48.Rotate Image 49.Group Anagrams 328.Odd Even Linked List 725.Split Linked List in Parts ...
visual studio code应用商店
最新发布
06-01
Visual Studio Code 应用商店是一个扩展平台，允许用户轻松地安装、管理和更新 Visual Studio Code 中的扩展。应用商店包含大量的扩展，包括编程语言、框架、工具和主题等，这些扩展可以帮助用户提高生产力和改善...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值