《算法竞赛进阶指南》1.8总结与练习(1)

150. 括号画家

达达是一名漫画家，她有一个奇特的爱好，就是在纸上画括号。
这一天，刚刚起床的达达画了一排括号序列，其中包含小括号( )、中括号[ ]和大括号{ }，总长度为N。
这排随意绘制的括号序列显得杂乱无章，于是达达定义了什么样的括号序列是美观的：
(1) 空的括号序列是美观的；
(2) 若括号序列A是美观的，则括号序列 (A)、[A]、{A} 也是美观的；
(3) 若括号序列A、B都是美观的，则括号序列AB也是美观的。
例如 (){} 是美观的括号序列，而)({)[}]( 则不是。
现在达达想在她绘制的括号序列中，找出其中连续的一段，满足这段子序列是美观的，并且长度尽量大。
你能帮帮她吗？

输入格式
输入一行由括号组成的字符串。

输出格式
输出一个整数，表示最长的美观的子段的长度。

数据范围
字符串长度不超过100000。

输入样例：
({({(({()}})}{())})})[){{{([)()((()]]}])[{)]}{[}{)

输出样例：
4

#include <iostream>
#include <cstring>
#include <stack>

using namespace std;

int main()
{
    string str;
    cin >> str;
    stack<int> stk; //存储下标 下标之差就是被删掉序列的长度
    
    int res = 0;
    for(int i = 0; i < str.size(); i++)
    {
        char c = str[i];
        if(stk.size()) //栈非空
        {
            char t = str[stk.top()]; //t存储栈顶是什么
            if(c == ')' && t == '(' || c == ']' && t =='[' || c == '}' && t == '{') stk.pop(); //匹配 出栈
            else stk.push(i);
        }
        else stk.push(i); //如果栈为空 直接push
        
        if(stk.size()) res = max(res, i - stk.top()); //栈里有元素 计算删除的长度 i 到栈顶
        else res = max(res, i + 1); //没有元素 长度为 0 到 i的长度
    }
    
    cout << res << endl;
    return 0;
}

151. 表达式计算4

给出一个表达式,其中运算符仅包含+,-,*,/,^（加 减 乘 整除 乘方）要求求出表达式的最终值。
数据可能会出现括号情况，还有可能出现多余括号情况。
数据保证不会出现大于或等于231的答案。
数据可能会出现负数情况。

输入格式
输入仅一行，即为表达式。

输出格式
输出仅一行，既为表达式算出的结果。

输入样例：
(2+2)^(1+1)

输出样例：
16

#include <iostream>
#include <stack>

using namespace std;

stack<int> nums;
stack<char> ops; //操作符

void cal()
{
    int a = nums.top(); nums.pop(); //第一个数字
    int b = nums.top(); nums.pop(); // 第二个数字
    char c = ops.top(); ops.pop(); //操作符
    int d; //储存结果
    
    if(c == '+') d = b + a;
    else if(c == '-') d = b - a;
    else if(c == '*') d = b * a;
    else if(c == '/') d = b / a;
    else // 乘方
    {
        d = 1;
        while(a --) d *= b;
    }
    nums.push(d);
}

int main()
{
    string str;
    cin >> str;
    //有多余括号，先看序列长度 补充左括号，保证左括号比右括号多，因为右括号多有问题
    string left;
    for(int i = 0; i <= str.size(); i++) left += '(';
    str = left + str + ')';
    
    for(int i = 0; i < str.size(); i ++)
    {
        if(str[i] >= '0' && str[i] <= '9') //数字可能不止一位
        {
            int j = i, t = 0;
            while(str[j] >= '0' && str[j] <= '9')
            {
                t = t * 10 + str[j] - '0';
                j++;
            }
            i = j - 1;
            nums.push(t);
        }
        else
        {
            char c = str[i];
            if(c == '+' || c == '-')
            {
                //前一位是数字或者右括号是减号,取反就是负号
                if(c == '-' && i && !(str[i - 1] >= '0' && str[i - 1] <= '9' || str[i - 1] == ')'))
                {
                    int j = i + 1, t = 0; //j从i+1开始 因为第i位是负号
                    while(str[j] >= '0' && str[j] <= '9')
                    {
                        t = t * 10 + str[j] - '0';
                        j++;
                    }
                    i = j - 1;
                    nums.push(-t);
                }
                else
                {
                    while(ops.top() != '(') cal(); //栈顶不是左括号
                    ops.push(c); //把当前运算符加进去
                }
            }
            else if(c == '*' || c == '/')
            {
                while(ops.top() == '*' || ops.top() == '/' || ops.top() == '^') cal(); //栈顶优先级比当前高或者相等的话 进行操作
                ops.push(c);
            }
            else if(c == '^')
            {
                while(ops.top() == '^') cal(); //乘方的优先级 只能栈顶操作符一样
                ops.push(c); //操作完 push 进 当前操作符
            }
            else if(c == ')')
            {
                while(ops.top() != '(') cal();
                ops.pop(); //删除 左括号
            }
            else if(c == '(') ops.push(c);
            else puts("invalid operator!");
        }
    }
    cout << nums.top() << endl;
    return 0;
}

152. 城市游戏

有一天，小猫rainbow和freda来到了湘西张家界的天门山玉蟾宫，玉蟾宫宫主蓝兔盛情地款待了它们，并赐予它们一片土地。
这片土地被分成NM个格子，每个格子里写着’R’或者’F’，R代表这块土地被赐予了rainbow，F代表这块土地被赐予了freda。
现在freda要在这里卖萌。。。它要找一块矩形土地，要求这片土地都标着’F’并且面积最大。
但是rainbow和freda的OI水平都弱爆了，找不出这块土地，而蓝兔也想看freda卖萌（她显然是不会编程的……），所以它们决定，如果你找到的土地面积为S，它们将给你3S两银子。

输入格式
第一行包括两个整数N,M，表示矩形土地有N行M列。
接下来N行，每行M个用空格隔开的字符’F’或’R’，描述了矩形土地。
每行末尾没有多余空格。

输出格式
输出一个整数，表示你能得到多少银子，即(3*最大’F’矩形土地面积)的值。

数据范围
1≤N,M≤1000

输入样例：
5 6
R F F F F F
F F F F F F
R R R F F F
F F F F F F
F F F F F F

输出样例：
45

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 1010;

int n, m;
int h[N][N]; //每个格子上面有多少个连续f
char g[N][N]; //存的 图
int q[N], l[N], r[N]; //单调队列 左边对应点的位置 右边对应点的位置

void get(int a[], int left[]) //从左往右算
{
    int tt = 0; //单调栈 栈顶
    q[0] = 0; //栈里面 存的是下标
    a[0] = -1; //哨兵
    for(int i = 1; i <= m; i++)
    {
        while(a[q[tt]] >= a[i]) tt--; //栈的元素比当前元素要大或者相等 出栈 根据求最大子矩阵的知识：找到左边第一个比当前小的矩阵
        left[i] = q[tt] + 1; //能往左边扩展的最后一个元素 找到比我小的元素 最近的 下一个位置 left[i] = 栈顶元素 + 1
        q[++ tt] = i; //那当前的值 加到 单调栈里面
    }
}

int work(int a[]) //对这个数组 求连续最大子矩阵面积
{
    get(a, l); //求一下左边的值
    reverse(a + 1, a + 1 + m); //列数m
    get(a, r);
    reverse(a + 1, a + 1 + m);
    
    int res = 0;
    for(int i = 1; i <= m; i++)
    {
        int left = l[i]; //左边位置 
        int right = m + 1 - r[m + 1 - i]; //右边位置 因为是翻转后的从右往左数 要 n+1-i 值也是 n+1-x 两次翻转 下标 和 值
        res = max(res, a[i] * (right - left + 1)); //高度a[i] 宽度right - left + 1
    }
    
    // for(int i = 1; i <= m; i++) cout << a[i] << ' ';
    // cout << endl;
    // cout << res << endl;
    return res;
}

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; i++) //n行
        for(int j = 1; j <= m; j++) //m列
        {
            char c;
            cin >> c; //用cin读入可以过滤特殊符号
            g[i][j] = c;
            if(c == 'F') h[i][j] = h[i - 1][j] + 1; 
            else h[i][j] = 0;
        }
    int res = 0;
    for(int i  = 1; i <= n; i++) res = max(res, work(h[i])); //枚举第i行的结果
    
    cout << res * 3 << endl;
    return 0;
}

153. 双栈排序

Tom最近在研究一个有趣的排序问题。
通过2个栈S1和S2，Tom希望借助以下4种操作实现将输入序列升序排序。
操作a
如果输入序列不为空，将第一个元素压入栈S1
操作b
如果栈S1不为空，将S1栈顶元素弹出至输出序列
操作c
如果输入序列不为空，将第一个元素压入栈S2
操作d
如果栈S2不为空，将S2栈顶元素弹出至输出序列
如果一个1~n的排列P可以通过一系列操作使得输出序列为1, 2,…,(n-1), n，Tom就称P是一个”可双栈排序排列”。
例如(1, 3, 2, 4)就是一个”可双栈排序序列”，而(2, 3, 4, 1)不是。
下图描述了一个将(1, 3, 2, 4)排序的操作序列：<a, c, c, b, a, d, d, b>

当然，这样的操作序列有可能有几个，对于上例(1, 3, 2, 4)，<a, c, c, b, a, d, d, b>是另外一个可行的操作序列。
Tom希望知道其中字典序最小的操作序列是什么。

输入格式
输入的第一行是一个整数p，代表有p组测试数据。
每组测试数据的第一行有一个正整数n，第二行有n个用空格隔开的正整数，构成一个1~n的排列。

输出格式
输出共p行，如果输入的排列不是”可双栈排序排列”，输出数字0。
否则输出字典序最小的操作序列，每两个操作之间用空格隔开，行尾没有空格。

数据范围
1≤n≤1000

输入样例：
1
3
2 3 1

输出样例：
a c a b b d

#include <iostream>
#include <algorithm>
#include <stack>
#include <cstring>

using namespace std;

const int N = 1010;

int n;
int a[N], f[N]; // f表示 ai 到 an的最小值
int color[N];
bool g[N][N]; //用邻接矩阵来存

bool dfs(int u, int c)
{
    color[u] = c;
    for(int i = 1; i <= n; i++)
        if(g[u][i]) //两个点之间有边
        {
            if(color[i] == c) return false; //邻边的颜色和 当前变颜色相同 不合法
            if(color[i] == -1 && !dfs(i, !c)) return false;
        }
    return true; 
}

int main()
{
    int T;
    cin >> T;
    while(T --)
    {
        cin >> n;
        for(int i = 1; i <= n; i++) cin >> a[i];
        f[n + 1] = n + 1;
        memset(g, false, sizeof g); //初始化图
        for(int i = n; i; i--) f[i] = min(f[i + 1], a[i]); //和当前值取min
        
        for(int i = 1; i <= n; i++)
            for(int j = i + 1; j <= n; j++) //j从 i + 1开始
                if(a[i] < a[j] && f[j + 1] < a[i]) //f[j + 1]
                    g[i][j] = g[j][i] = true;
                    
        memset(color, -1, sizeof color);
        
        bool flag = true;
        for(int i = 1; i <= n; i++) //保证字典序最小 尽量赋给第一个栈 0表示 赋给第一个栈 1表示 赋给第二个栈
            if(color[i] == -1 && !dfs(i, 0))
            {
                flag = false;
                break;
            }
            
        if(!flag)
        {
            cout << 0 << endl;
            continue;
        }
        
        stack<int> stk1, stk2;
        
        int now = 1; //从1开始弹栈
        for(int i = 1; i <= n; i++)
        {
            if(color[i] == 0) //当前颜色为0 加入到第一个栈
            {
                stk1.push(a[i]);
                cout << "a " ;
            }
            else
            {
                stk2.push(a[i]);
                cout << "c ";
            }
            
            while(true)
                if(stk1.size() && stk1.top() == now)
                {
                    stk1.pop();
                    cout << "b ";
                    now ++;
                }
                else if(stk2.size() && stk2.top() == now)
                {
                    stk2.pop();
                    cout << "d ";
                    now ++;
                }
                else break;
        }
        cout << endl;
    }
    return 0;
}