LeetCode 下一个更大元素
题目描述:
解法(单调栈+哈希表):
class Solution {
public:
vector<int> nextGreaterElement(vector<int>& nums1, vector<int>& nums2) {
int n=nums2.size();
unordered_map<int,int> record;
stack<int> stk;
for(int i=n-1;i>=0;i--){
while(!stk.empty()&&nums2[i]>stk.top()){
stk.pop();
}
record[nums2[i]]=stk.empty()? -1:stk.top();
stk.push(nums2[i]);
}
vector<int> res;
for(int i=0;i<nums1.size();i++){
res.push_back(record[nums1[i]]);
}
return res;
}
};
题目描述:
解法一(跳跃):
//最开始的做法
class Solution {
public:
vector<int> nextGreaterElements(vector<int>& nums) {
int len = nums.size();
if (len<2) return vector<int>(len, -1);
vector<int> res(len, -1); //存结果
vector<int> temp(2 * len - 1, -1); //存下一个较大数的索引
for (int i = 0; i<len - 1; i++) { //扩展数组
nums.push_back(nums[i]);
}
for (int i = 2 * len - 3; i >= 0; i--) {
for (int j = i + 1; j < 2 * len - 1; j = temp[j]) { //跳跃寻找
if (nums[i]<nums[j]) {
temp[i] = j;
break;
}
else if (temp[j] == -1) {
temp[i] = -1;
break;
}
}
}
for (int i = 0; i<len; i++) {
if (temp[i] == -1)
res[i] = -1;
else
res[i] = nums[temp[i] % len];
}
return res;
}
};
解法二(单调栈):
class Solution {
public:
vector<int> nextGreaterElements(vector<int>& nums) {
int n=nums.size();
if(n==0) return vector<int>();
vector<int> res(2*n-1,0);
stack<int> stk;
for(int i=0;i<n-1;i++)
nums.push_back(nums[i]);
for(int i=2*n-2;i>=0;i--){
while(!stk.empty()&&nums[i]>=stk.top()){
stk.pop();
}
res[i]=stk.empty()? -1:stk.top();
stk.push(nums[i]);
}
res.erase(res.begin()+n,res.end());
return res;
}
};
解法三(求模):
我们可以不用构造新数组,而是利用循环数组的技巧来模拟。
class Solution {
public:
vector<int> nextGreaterElements(vector<int>& nums) {
int n=nums.size();
vector<int> res(n,-1);
stack<int> stk;
for(int i=2*n-2;i>=0;i--){
while(!stk.empty()&&nums[i%n]>=stk.top()){
stk.pop();
}
res[i%n]=stk.empty()? -1:stk.top();
stk.push(nums[i%n]);
}
return res;
}
};
题目描述:
解法一:
class Solution {
public:
int nextGreaterElement(int n) {
string str = to_string(n); //转为字符串
int len = str.size();
int change = -1, i;
for (i = len - 2; i >= 0; i--) {
if (str[i]<str[i + 1]) { //寻找第一个不满足从尾到头递增的位置i
int j = i + 1;
while (j<len&&str[j]>str[i]) //找到i位置之后比i位置的数大的最小的数。
j++;
change = j - 1;
break;
}
}
if (change == -1)
return -1;
else
swap(str[i], str[change]); //交换
reverse(str.begin() + i + 1, str.end()); //重排
long long res = stoll(str);
if (res>INT_MAX) return -1;
return res;
}
};
解法二:
class Solution {
public:
int nextGreaterElement(int n) {
string str = to_string(n); //转为字符串
bool ff=next_permutation(str.begin(), str.end());
if (!ff) return -1;
long res = stol(str);
if (res>INT_MAX) return -1;
else return res;
}
};
C++ STL中的组合数函数:next_permutation()
这是一个求一个排序的下一个排列的函数,可以遍历全排列,要包含头文件<algorithm>
STL提供了两个用来计算排列组合关系的算法,分别是next_permutation和prev_permutation。首先我们必须了解什么是“下一个”排列组合,什么是“前一个”排列组合。考虑三个字符所组成的序列{a,b,c}。
这个序列有六个可能的排列组合:abc,acb,bac,bca,cab,cba。这些排列组合根据less-than操作符做字典顺序(lexicographical)的排序。也就是说,abc名列第一,因为每一个元素都小于其后的元素。acb是次一个排列组合,因为它是固定了a(序列内最小元素)之后所做的新组合。
同样道理,那些固定b(序列中次小元素)而做的排列组合,在次序上将先于那些固定c而做的排列组合。以bac和bca为例,bac在bca之前,因为次序ac小于序列ca。面对bca,我们可以说其前一个排列组合是bac,而其后一个排列组合是cab。序列abc没有“前一个”排列组合,cba没有“后一个”排列组合。
next_permutation()会取得[first,last)所标示之序列的下一个排列组合,如果没有下一个排列组合,便返回false;否则返回true。这个算法有两个版本。版本一使用元素型别所提供的less-than操作符来决定下一个排列组合,版本二则是以仿函数comp来决定。
上面的解法二其实也是解法一的翻版,因为next_permutation()函数用的是跟解法一相同的原理!
next_permutation()函数算法思想:
1.首先从最尾端开始往前寻找两个相邻元素,令第一元素为*i,第二元素为*ii,且满足*i<*ii。
2.找到这样一组相邻元素后,再从最尾端开始往前检验,找出第一个大于*i的元素,令为*j,将i,j元素对调(swap)。
3.再将ii之后的所有元素颠倒(reverse)排序。
举个实例,假设有序列{0,1,2,3,4},下图便是套用上述演算法则,一步一步获得“下一个”排列组合。图中只框出那符合“一元素为*i,第二元素为*ii,且满足*i<*ii ”的相邻两元素,至于寻找适当的j、对调、逆转等操作并未显示出。
以下便是版本一的实现细节。版本二相当类似,就不列出来了。
template<calss BidrectionalIterator>
bool next_permutation(BidrectionalIterator first,BidrectionalIterator last)
{
if(first == lase) return false; /* 空区间 */
BidrectionalIterator i = first;
++i;
if(i == last) return false; /* 只有一个元素 */
i = last; /* i指向尾端 */
--i;
for(;;)
{
BidrectionalIterator ii = i;
--i;
/* 以上锁定一组(两个)相邻元素 */
if(*i < *ii) /* 如果前一个元素小于后一个元素 */
{
BidrectionalIterator j = last; /* 令j指向尾端 */
while(!(*i < *--j)); /* 由尾端往前找,直到遇到比*i大的元素 */
iter_swap(i,j); /* 交换i,j */
reverse(ii,last); /* 将ii之后的元素全部逆序重排 */
return true;
}
if(i == first) /* 进行至最前面了 */
{
reverse(first,last); /* 全部逆序重排 */
return false;
}
}
}
参考:https://blog.csdn.net/c18219227162/article/details/50301513