《算法竞赛进阶指南》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;
}

猜你喜欢

转载自www.cnblogs.com/wmxnlfd/p/10885089.html
0条评论
添加一条新回复
  
今日推荐