《算法竞赛进阶指南》1.1栈
41. 包含min函数的栈
设计一个支持push，pop，top等操作并且可以在O(1)时间内检索出最小元素的堆栈。
push(x)–将元素x插入栈中
pop()–移除栈顶元素
top()–得到栈顶元素
getMin()–得到栈中最小元素
样例
MinStack minStack = new MinStack();
minStack.push(-1);
minStack.push(3);
minStack.push(-4);
minStack.getMin(); --> Returns -4.
minStack.pop();
minStack.top(); --> Returns 3.
minStack.getMin(); --> Returns -1.
class MinStack {
public:
/** initialize your data structure here. */
stack<int> stk, stk_min;
MinStack() {
}
void push(int x) {
stk.push(x);
if(stk_min.size()) x = min(x, stk_min.top());
stk_min.push(x);
}
void pop() {
stk.pop();
stk_min.pop();
}
int top() {
return stk.top();
}
int getMin() {
return stk_min.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();
*/
128. 编辑器
你将要实现一个功能强大的整数序列编辑器。
在开始时，序列是空的。
编辑器共有五种指令，如下：
1、“I x”，在光标处插入数值x。
2、“D”，将光标前面的第一个元素删除，如果前面没有元素，则忽略此操作。
3、“L”，将光标向左移动，跳过一个元素，如果左边没有元素，则忽略此操作。
4、“R”，将光标向右移动，跳过一个元素，如果右边没有元素，则忽略次操作。
5、“Q k”，假设此刻光标之前的序列为a1,a2,…,an,输出max1≤i≤kSi，其中Si=a1+a2+…+ai。
输入格式
第一行包含一个整数Q，表示指令的总数。
接下来Q行，每行一个指令，具体指令格式如题目描述。
输出格式
每一个“Q k”指令，输出一个整数作为结果，每个结果占一行。
数据范围
1≤Q≤106,
|x|≤103,
1≤k≤n
输入样例：
8
I 2
I -1
I 1
Q 3
L
D
R
Q 2
输出样例：
2
3
#include <iostream>
#include <algorithm>
#include <limits.h>
using namespace std;
const int N = 1000010;
int stkl[N], stkr[N], tl, tr;//tl，tr表示栈顶
int s[N], f[N]; //s表示左边的栈的前缀和，f表示前i个前缀和的最大值
void push_left(int x) //往左边插入一个元素
{
stkl[ ++ tl] = x;
s[tl] = s[tl - 1] + x; //左边前缀和
f[tl] = max(f[tl - 1], s[tl]);
}
int main()
{
int n;
scanf("%d", &n);
f[0] = INT_MIN; //初始化负数
while(n --)
{
char str[2];//输入一个字母可以使用 读入字符串，不用处理回车空格等特殊格式
int x;
scanf("%s", str);
if(*str == 'I') //*str等价于s[0]
{
scanf("%d", &x);
push_left(x);
}
else if(*str == 'D')
{
if(tl > 0) tl--; //要先判断，在最左侧不能移动，移动无效
}
else if(*str == 'L')
{
if(tl > 0) stkr[ ++ tr] = stkl[tl --]; //左边插入右边，要判断tl > 0才可以往左移动
}
else if(*str == 'R')
{
if(tr > 0)push_left(stkr[tr --]); //从右边移动左边，要判断tl > 0才可以往左移动
}
else //查询，返回前k个前缀和最小值
{
scanf("%d", &x);
printf("%d\n", f[x]);
}
}
return 0;
}
129. 火车进栈
这里有n列火车将要进站再出站，但是，每列火车只有1节，那就是车头。
这n列火车按1到n的顺序从东方左转进站，这个车站是南北方向的，它虽然无限长，只可惜是一个死胡同，而且站台只有一条股道，火车只能倒着从西方出去，而且每列火车必须进站，先进后出。
也就是说这个火车站其实就相当于一个栈，每次可以让右侧头火车进栈，或者让栈顶火车出站。
车站示意如图：
出站<—— <——进站
|车|
|站|
|__|
现在请你按《字典序》输出前20种可能的出栈方案。
输入格式
输入一个整数n，代表火车数量。
输出格式
按照《字典序》输出前20种答案，每行一种，不要空格。
数据范围
1≤n≤20
输入样例：
3
输出样例：
123
132
213
231
321
#include <iostream>
#include <algorithm>
#include <vector>
#include <stack>
using namespace std;
int n, cnt = 20;
vector<int> state1; //state1位当前出栈的序列(用vector表示)
stack<int> state2; //stack2是一个栈
int state3 = 1; //没有进来的元素，初始化为1
void dfs()
{
if(!cnt) return; //cnt减为0
if(state1.size() == n) //弹出的元素等于输入的元素
{
cnt --; //输出前20个
for(auto x : state1) cout << x ;
cout << endl;
return;
}
if(state2.size()) //state2不为空 才可以进行出栈操作
{
state1.push_back(state2.top());
state2.pop();
dfs();
state2.push(state1.back()); //操作完恢复原状
state1.pop_back();
}
if(state3 <= n) //还有火车可以进站，进行进栈操作
{
state2.push(state3); //队列 push_back 栈 push
state3 ++;
dfs();
state3 --; //操作完，恢复原状
state2.pop();
}
}
int main()
{
cin >> n;
dfs();
return 0;
}
130. 火车进出栈问题
一列火车n节车厢，依次编号为1,2,3,…,n。
每节车厢有两种运动方式，进栈与出栈，问n节车厢出栈的可能排列方式有多少种。
输入格式
输入一个整数n，代表火车的车厢数。
输出格式
输出一个整数s表示n节车厢出栈的可能排列方式数量。
数据范围
1≤n≤60000
输入样例：
3
输出样例：
5
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long LL;
const int N = 120010;
int powers[N]; // 每个质数的次数
int primes[N], cnt; //1-2n所有的质数
bool st[N];
void get_primes(int n) //***筛法求质数
{
for(int i = 2; i <= n; i++)
if(!st[i]) //没有被筛过
{
primes[cnt ++] = i;
for(int j = i * 2; j <= n; j += i) //从两倍i开始 把所有倍数筛掉
st[j] = true;
}
}
//***求n阶乘里面有多少个因子p
int get(int n, int p) //返回n的阶乘里面有多少个因子p，即等于多少个p相乘
{
int s = 0;
while(n)
{
s += n / p;
n /= p;
}
return s;
}
//***高精度乘法
void multi(vector<LL> &a, int b)
{
int t = 0; //进位
for(int i = 0; i < a.size(); i ++)
{
a[i] = a[i] * b + t;
t = a[i] / 100000000; //进位 无优化效率：11210ms int存四位/10000：2903ms 压8位：1374ms
a[i] %= 100000000; //当前位
}
while(t) //检测最高位是否有
{
a.push_back(t % 100000000);
t /= 100000000;
}
}
void out(vector<LL> &a) //输出从高位到低位
{
printf("%lld", a.back());
for(int i = a.size() - 2; i >= 0; i--) printf("%08lld", a[i]); //cout << a[i];
cout << endl;
}
int main()
{
int n;
cin >> n;
get_primes(n * 2);
for(int i = 0; i < cnt; i ++) //枚举每个质数的次数
{
int p = primes[i];
powers[p] = get(n * 2, p) - get(n, p) * 2;
}
int k = n + 1;
for(int i = 0; i < cnt && primes[i] <= k; i++)
{
int p = primes[i], s = 0;
while(k % p == 0)
{
s ++;
k /= p;
}
powers[p] -= s; // 减去n+1 里面含有的 质数个数
}
//高精度运算 把所有质数相乘
vector<LL> res;
res.push_back(1);
for(int i = 2; i <= n * 2; i++)
for(int j = 0; j < powers[i]; j++)
multi(res, i);
out(res);
return 0;
}
131. 直方图中最大的矩形
直方图是由在公共基线处对齐的一系列矩形组成的多边形。
矩形具有相等的宽度，但可以具有不同的高度。
例如，图例左侧显示了由高度为2,1,4,5,1,3,3的矩形组成的直方图，矩形的宽度都为1：
通常，直方图用于表示离散分布，例如，文本中字符的频率。
现在，请你计算在公共基线处对齐的直方图中最大矩形的面积。
图例右图显示了所描绘直方图的最大对齐矩形。
输入格式
输入包含几个测试用例。
每个测试用例占据一行，用以描述一个直方图，并以整数n开始，表示组成直方图的矩形数目。
然后跟随n个整数h1，…，hn。
这些数字以从左到右的顺序表示直方图的各个矩形的高度。
每个矩形的宽度为1。
同行数字用空格隔开。
当输入用例为n=0时，结束输入，且该用例不用考虑。
输出格式
对于每一个测试用例，输出一个整数，代表指定直方图中最大矩形的区域面积。
每个数据占一行。
请注意，此矩形必须在公共基线处对齐。
数据范围
1≤n≤100000,
0≤hi≤1000000000
输入样例：
7 2 1 4 5 1 3 3
4 1000 1000 1000 1000
0
输出样例：
8
4000
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int N = 100010;
int n;
int h[N], q[N], l[N], r[N]; //q[N]单调队列
void get(int bound[N]) //求左边界
{
int tt = 0; //栈的最后一个元素
h[0] = -1;
for(int i = 1; i <= n; i++)
{
while(h[q[tt]] >= h[i]) tt --; //栈顶元素>=h[i]当前元素，则删掉
bound[i] = q[tt];
q[++ tt] = i;
}
}
int main()
{
while(cin >> n, n) //读入一个n，判断n是不是0 0就break
{
for(int i = 1; i <= n; i++) cin >> h[i];
// h[0] = -1; //左边界处理成-1
get(l);
reverse(h + 1, h + 1 + n);
get(r);
LL res = 0;
for(int i = 1,j = n; i <= n; i++, j--) //i对应right下标 j 对应left下标 因为上面翻转了 所以反了
res = max(res, h[i] * (n + 1 - l[j] - r[i] - 1ll)); //i和j之间的个数 第一个变量LL类型 第二个变量也要变成LL类型（其中一个变LL即可）
cout << res << endl;
}
return 0;
}
