《算法竞赛进阶指南》0x11栈

栈是一种“后进先出”的线性数据结构。栈只有一端能进出元素，我们一般称这一端为栈顶，另一端为栈底。添加或删除栈中元素时，我们只能将其插入栈顶，或者将栈顶元素取出。

例题
acwing41.包含min函数的栈

我们可以使用一个线性结构保存历史上每个时刻的最小值，这样不管我们退栈到什么场景都可以O(1)时间复杂度得到当前的最小值。建立两个栈，栈A存储原来的的数据，栈B存储A中以栈底开头的每段数据的最小值。

class MinStack {
public:
    /** initialize your data structure here. */
    stack<int>svalue;
    stack<int>smin;
    MinStack() {
        
    }
    
    void push(int x) {
        svalue.push(x);
        if(smin.empty())smin.push(x);
        else smin.push(min(smin.top(),x));
    }
    
    void pop() {
        svalue.pop();
        smin.pop();
    }
    
    int top() {
        return svalue.top();
    }
    
    int getMin() {
        return smin.top();
    }
};

/**
 * Your MinStack object will be instantiated and called as such:
 * MinStack obj = new MinStack();
 * obj.push(x);
 * obj.pop();
 * int param_3 = obj.top();
 * int param_4 = obj.getMin();
 */

acwing128.编辑器

对顶栈，栈A存储从序列开头到当前光标位置的这一段序列，栈B存储当前光标到序列结尾的这一段序列。

#include<iostream>
#include<stack>
using namespace std;
#define MAX_N 1000000
int q;
int sum[MAX_N+5];
int f[MAX_N+5]={-1000};
int cnt1=0,cnt2=0;
int main()
{
    stack<int>s1,s2;
    cin>>q;
    while(q--)
    {
        char op;
		int x;
        cin>>op;
        if(op=='I')
        {
            scanf("%d",&x);
            cnt1+=1;
            s1.push(x);
            sum[cnt1]=sum[cnt1-1]+x;
            f[cnt1]=max(f[cnt1-1],sum[cnt1]);
        }
        else if(op=='D')
        {
            if(cnt1)
			{
				cnt1-=1;
				s1.pop();
			}
        }
        else if(op=='L')
        {
            if(cnt1)
            {
                cnt1-=1;
                cnt2+=1;
                
				s2.push(s1.top());
				s1.pop();    
            }
        }
        else if(op=='R')
        {
            if(cnt2)
            {
                cnt1+=1;
                cnt2-=1;
                sum[cnt1]=sum[cnt1-1]+s2.top();
                s1.push(s2.top());
                s2.pop();
            	f[cnt1]=max(f[cnt1-1],sum[cnt1]);
            }
        }
        else{
            scanf("%d",&x);
            if(x>cnt1)cout<<f[cnt1]<<'\n';
            else cout<<f[x]<<'\n';
        }
    }
    return 0;
}

acwing129.火车进站

搜索，为了保证字典序最小所以优先进行出栈，其次考虑进站。

#include<iostream>
#include<vector>
#include<stack>
using namespace std;
int n;
vector<int>state1;
stack<int>state2;
int state3=1;
int cnt=0;
void dfs()
{
    if(cnt==20)return ;
    if(state1.size()==n)
    {
        cnt++;
        for(auto k:state1)cout<<k;
        cout<<endl;
        return ;
    }
    if(state2.size())
    {
        int k=state2.top();
        state1.push_back(k);
        state2.pop();
        dfs();
        state2.push(k);
        state1.pop_back();
    }
    if(state3<=n)
    {
        state2.push(state3);
        state3++;
        dfs();
        state2.pop();
        state3--;
    }
    return ;
}
int main()
{
    cin>>n;
    dfs();
    return 0;
}

表达式计算

中缀表达式 最常见的表达式，例如3*（1-2）
前缀表达式 又称波兰式，形如 op A B，其中op是一个运算符，A B是另两个前缀表达式，例如 *3-12
后缀表达式 又称逆波兰式，形如 A B op,例如12-3*

后缀表达式求值
1.建立一个用于存数的栈，逐一扫描该后缀是的元素。
a.如果遇到一个数，则把该数入栈。
b.如果遇到运算符，就取出栈顶两个数计算，把结果入栈。
2.扫描完成后，栈中恰好剩一个数，就是该后缀表达式的值。

想要求中缀表达式的值，一般可以转化为后缀式计算，也可以递归来算。

中缀表达式转后缀表达式
1.建立一个用于存运算符的栈，注意扫描该中缀表达式的元素。
a.如果遇到一个数，输出该数。
b.如果遇到左括号，把左括号进栈。
c.如果遇到右括号，不断取出栈顶并输出，直到栈顶为左括号，然后把左括号出栈。
d.如果遇到运算符，只要栈顶符号优先级不低于新符号，就不断取出栈顶并输出，最后把新符号进栈。优先级为乘除>加减>左括号。
2.依次取出并输出栈中的所有剩余符号，最终输出的序列是一个与源中缀表达式等价的后缀表达式。
中缀表达式的递归法求值
目标：求解中缀表达式S[1~N]的值。
子问题：求解中缀表达式S的子区间表达式S[L~R]的值。
1.在L~R中考虑没有被任何括号包含的运算符。
a.若存在加减号，选其中最后一个，分成左右两半递归。
b.若存在乘除号，选其中最后一个，分成左右两半递归。
2.若不存在没有被任何括号包含的运算符。
a.若首尾字符是括号，递归求解S[L+1~R±1]，把结果返回。
b.否则，说明区间S[L~R]是一个数，直接返回数值。

单调栈

acwing131.直方图中最大的矩形

对于每一个小矩形，以他的高度为大长方形的高度，找到左右最近小于它的高度的位置，这样得到的一个大长方形的面积就是(r[i]-l[i]-1)*arr[i]，找到所有面积中最大的一个。

#include<iostream>
#include<vector>
#include<stack>
using namespace std;
#define MAX_N 100000
int arr[MAX_N+5];
int n;
long long ans=0;
int l[MAX_N+5],r[MAX_N+5];
int main()
{
    while(1)
    {
        ans=0;
        cin>>n;
        if(n==0)break;
        stack<int>s;
        arr[0]=0;
        for(int i=1;i<=n;i++)
        scanf("%d",arr+i);
        arr[n+1]=-1;
        for(int i=0;i<=n+1;i++)
	    {
		    while(!s.empty()&&arr[s.top()]>arr[i])
		    {
		    	r[s.top()]=i;
		    	s.pop();
		    }
		    s.push(i);
	    }
		for(int i=n+1;i>=0;i--)
	    {
	    	while(!s.empty()&&arr[s.top()]>arr[i])
		    {
		    	l[s.top()]=i;
		    	s.pop();
		    }
		    s.push(i);
	    }
        for(int i=1;i<=n;i++)
        {
            ans=max(1ll*(r[i]-l[i]-1)*arr[i],ans);      
        }
        cout<<ans<<endl;
    }
    return 0;
}