class Solution

 {

 public:

     vector<int> nextGreaterElement(vector<int>& findNums, vector<int>& nums)

     {

         const int m = findNums.size(), n = nums.size();

         int i, j;

         unordered_map<int, int> table;

         vector<int> output;

         for (i = ; i < n; table[nums[i]] = i, i++);

         for (i = ; i < m; i++)

         {

             if (findNums[i] == nums[n - ])

             {

                 output.push_back(-);

                 continue;

             }

             for (j = table[findNums[i]] + ; j < n && nums[j] < findNums[i]; j++);

             if (j == n)

                 output.push_back(-);

             else

                 output.push_back(nums[j]);

         }

         return output;

     }

 };

 class Solution

 {

 public:

     vector<int> nextGreaterElements(vector<int>& nums)

     {

         const int n = nums.size();

         int i, mark;

         vector<int> output(n, -);

         for (mark = ; mark < n -  && nums[mark] <= nums[n - ]; mark++);

         if (mark < n - )   // 找到了某个位置，标记上，若 mark == n - 1，说明 nums[n - 1] 就是最大的

             output[n - ] = nums[mark];

         for (i = n - ; i >= ; i--)

         {

             if (nums[i] < nums[i + ])

             {

                 output[i] = nums[i + ];

                 mark = i + ;

             }

             else

             {

                 for (; mark != i && nums[mark] <= nums[i]; mark = (mark + ) % n);

                 if (mark != i)

                     output[i] = nums[mark];

             }

         }

         return output;

     }

 };

 class Solution

 {

 public:

     vector<int> nextGreaterElements(vector<int>& nums)

     {

         const int n = nums.size();

         int i, num, ind;

         stack<int> st;             // 栈维护 num 的单调递减的子列的下标，遇到较大的当前值的时候出栈，出到元素值大于当前值为止

         vector<int> result(n, -);

         for (i = ; i <  * n; i++)// 扫描两趟，确保末尾的元素找到后继

         {

             for (num = nums[i % n]; !st.empty() && num > nums[st.top()]; ind = st.top(), st.pop(), result[ind] = num);

                 // 若 num 较大，则把栈中的较小元素都指向 num

             st.push(i % n); // 空栈，或者剩余部分的值大于当前值，将当前值压栈

         }

         return result;

     }

 };

 class Solution

 {

 public:

     vector<int> nextGreaterElements(vector<int> nums)

     {

         const int n = nums.size();

         if(n==)

             return vector<int>();

         vector<int> res(n);

         int i, maxValue, index, real;

         for (maxValue = nums[], i = index = ; i < n; i++)// 第一轮，将两种情况的第 k 元素进行标记：

         {                                                  // ① nums[ k ] < nums[ k + 1 ]

             if (nums[i] > maxValue)                        // ② nums[ k ] >= nums[ k + 1 ] ... nums[ k + m ] 且 nums[ k ] < nums[ k + m ]

             {                                              // 注意第一轮结束时 index 等于数组最大元素的下标

                 res[i - ] = i;

                 res[index] = i;

                 maxValue = nums[i];

                 index = i;

             }

         }

         for (res[index] = -, i = index - ; i > index - n; i--)// 将数组最大元素的输出值置 -1，从最大元素开始向左遍历数组

         {

             real = (i + n) % n;

             if (res[real] != )

                 continue;

             res[real] = (real == n -  ?  : real + );// 让该元素的输出值初始化为它右边那个元素

             for (; res[real] != - && nums[real] >= nums[res[real]]; res[real] = res[res[real]]);// 寻找该元素的真实输出值

         }

         for (i = ; i < n; i++)// 将下标置换回元素的值

         {

             if (res[i] != -)

                 res[i] = nums[res[i]];

         }

         return res;

     }

 };