LeetCode 下一个更大元素

496. 下一个更大元素 I

题目描述：

解法（单调栈+哈希表）：

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;
    }
};

 

503. 下一个更大元素 II

题目描述：

解法一（跳跃）：

//最开始的做法
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;
    }
};

556. 下一个更大元素 III

题目描述：

解法一：

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