在这个题目中，我们寻找数组的最大子串时，运用了单调栈的特性。但并非完全单调，以下，仅提供寻找最大子串func部分：

注意：这里的最大子串，指的是数组截选出来的子数组中元素相对位置不改变

vector<int> MaxSubNums(vector<int>& nums, int n)
	{
		// 如果为空，不用遍历
		if (n == 0) {
			return {};
		}
		stack<int> resStack;
		int pos = 0;
		while (pos < nums.size()) {
			// 余下+当前大小 > 目标大小
			if ((resStack.size() + nums.size() - pos) == n) break;

			// 如果栈为空
			if (resStack.empty()) {
				resStack.push(nums[pos]);
				pos++;
				continue;
			}
			// 如果栈满了 且大于栈顶
			if (resStack.size() == n) {
				if (nums[pos] > resStack.top()) {
					resStack.pop();
					continue;
				}
				else {
					pos++;
				}
			}
			if (resStack.size() < n) {
				// 小于等于，直接push
				if (nums[pos] <= resStack.top()) {
					resStack.push(nums[pos]);
					pos++;
				}
				else {
					resStack.pop();
				}
			}
		}
		while (resStack.size() < n && pos < nums.size()) {
			resStack.push(nums[pos]);
			pos++;
		}

		vector<int> result;
		while (!resStack.empty()) {
			result.push_back(resStack.top());
			resStack.pop();
		}
		std::reverse(result.begin(), result.end());
		return result;
	}

题目：给你一个字符串 s ，请你去除字符串中重复的字母，使得每个字母只出现一次。需保证 返回结果的字典序最小（要求不能打乱其他字符的相对位置）。

解法：因为要使结果为字典序最小，我们利用单调栈性质，使其从底至上为升序（非完全）

我们需要一个map（strCount）用于记录余下字符串中，某字符剩余多少

还需要一个set用于记录栈中已存在哪些元素

遍历字符串，入栈规则：

• 首先：strCount[cur]–

1、若当前字符cur已在栈中，略过，

2、若当前字符cur未在栈中：

1. cur > stack.top() || stack.empty() ，跳到第3步。
2. cur < stack.top()
   1. 如果栈顶元素之后还会出现，弹出
   2. 循环上述操作，直到 栈空 或者 cur > stack.top() 或者栈顶元素在之后不再出现，结束循环
3. 入栈，并在set中记录

遍历完字符串后，栈底到栈顶的元素拼起来就是最终答案。

class Solution
{
public:
    string removeDuplicateLetters(string s)
    {
        // 判断该字符余下还有多少个
        unordered_map<char, int> strCount;
        // 判断栈中是否包含这个元素，如果有就不可以push
        unordered_set<char> inStack;

        for (auto c : s)
        {
            strCount[c]++;
        }
        // 单调栈，保持从栈底往上升序（非完全）
        stack<char> strStack;
        for (auto c : s)
        {
            // 当前字符剩余个数减1
            strCount[c]--;
            // 栈中已有该元素，遍历下一个
            if (inStack.count(c) != 0)
                continue;
            // 如果当前栈不为空 且  当前元素大于栈顶元素，且栈顶元素在剩余字符中还会出现
            while (!strStack.empty() && c < strStack.top() && strCount[strStack.top()] > 0)
            {
                inStack.erase(strStack.top());
                strStack.pop();
            }
            // 入栈
            strStack.push(c);
            // 记录该元素已经在栈中出现过
            inStack.insert(c);
        }
        string ans = "";
        while (!strStack.empty())
        {
            ans = strStack.top() + ans;
            strStack.pop();
        }
        return ans;
    }
};