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

原文地址：https://www.cnblogs.com/wmxnlfd/p/10943420.html

时间： 2024-10-08 15:16:20

《算法竞赛进阶指南》1.8总结与练习(1)的相关文章

《算法竞赛进阶指南》学习总结 #include&lt;algorithm&gt;

今天下午大致学完了进阶指南中algorithm头文件下的内容,在这里进行一个总结.   reverse翻转   顾名思义,reverse进行的操作就是翻转原来的顺序,理解非常简单,故不赘述. 操作样例: #include<bits/stdc++.h> using namespace std; vector<int>a; int b[233]; int main() { int na,nb; //vector的实现 scanf("%d",&na); for

《算法竞赛进阶指南》学习总结 二分与三分

首先......我是一个很菜很菜的萌新,所以这篇文章写得很详细,有很多我自己的口水话方便我理解,请各位谨慎食用qwq 以前在网上找过很多介绍二分的博客,但都感觉对萌新不太友好,反正我当时连跳石头都没看懂,所以决定自己写一篇!其中有我的想法,也借鉴了书里的很多内容,感谢lyd. 二分答案,顾名思义,就是对我们所需要的答案进行二分,对我们要求的值进行二分.二分的基础用法是在单调序列或者单调函数当中查找,当答案具有单调性,我们就可以采用二分来计算,当然还有三分,在后面我会详细讲到 整数集合上的二分 在

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

116. 飞行员兄弟 "飞行员兄弟"这个游戏,需要玩家顺利的打开一个拥有16个把手的冰箱. 已知每个把手可以处于以下两种状态之一:打开或关闭. 只有当所有把手都打开时,冰箱才会打开. 把手可以表示为一个4х4的矩阵,您可以改变任何一个位置[i,j]上把手的状态. 但是,这也会使得第i行和第j列上的所有把手的状态也随着改变. 请你求出打开冰箱所需的切换把手的次数最小值是多少. 输入格式 输入一共包含四行,每行包含四个把手的初始状态. 符号"+"表示把手处于闭合状态,而

算法竞赛进阶指南做题记录

基本算法 递归与递推 费解的开关 Strange Towers of Hanoi Sumdiv Fractal Streets 前缀和与差分 激光炸弹 IncDec Sequence Tallest Cow 二分 Best Cow Fences 排序 Cinema 货舱选址 七夕祭 Running Median 第K大数 Ultra-QuickSort 奇数码问题 原文地址:https://www.cnblogs.com/Maktub-blog/p/11009723.html

算法竞赛进阶指南 走廊泼水节

原题链接 题目描述 给定一棵N个节点的树,要求增加若干条边,把这棵树扩充为完全图,并满足图的唯一最小生成树仍然是这棵树. 求增加的边的权值总和最小是多少. 输入格式 第一行包含整数t,表示共有t组测试数据. 对于每组测试数据,第一行包含整数N. 接下来N-1行,每行三个整数X,Y,Z,表示X节点与Y节点之间存在一条边,长度为Z. 输出格式 每组数据输出一个整数,表示权值总和最小值. 每个结果占一行. 数据范围 \(N \le 6000,Z \le 100\) 输入样例: 2 3 1 2 2 1

bzoj 1787 &amp;&amp; bzoj 1832: [Ahoi2008]Meet 紧急集合（倍增LCA）算法竞赛进阶指南

题目描述 原题连接 Y岛风景美丽宜人,气候温和,物产丰富. Y岛上有N个城市(编号\(1,2,-,N\)),有\(N-1\)条城市间的道路连接着它们. 每一条道路都连接某两个城市. 幸运的是,小可可通过这些道路可以走遍Y岛的所有城市. 神奇的是,乘车经过每条道路所需要的费用都是一样的. 小可可,小卡卡和小YY经常想聚会,每次聚会,他们都会选择一个城市,使得3个人到达这个城市的总费用最小. 由于他们计划中还会有很多次聚会,每次都选择一个地点是很烦人的事情,所以他们决定把这件事情交给你来完成. 他们

《算法竞赛进阶指南》打卡活动 #0x00 基本算法

101. 最高的牛 题目链接:https://www.acwing.com/problem/content/103/ 作为一个银牌水平的主演数据结构的演员来说,这题现在发现非常好想,每个牛分配一个优先度.我搞一个区间线段树,每次update中间一段使得他们的优先度整体下降到比两端中较小的优先度还要小.然后反过来按照优先度分配身高.哈哈!根本不需要什么算法.不过每次都不询问为什么要线段树呢?差分不香吗?当然不香,每次询问当前的优先度啊! const int MAXN = 10000; int re

《算法竞赛进阶指南》刷题记录

总算闲下来一些辣!然后最近发现其实看书是真真很有效但是一直没有落实!所以决定落实一下这段时间把这本书看完题目做完! 然后发现还有挺多题目挺巧妙的于是一堆博客预警,,,可能最近会写很多比较水(但是我还是不会做)的题目的题解 先放个空壳子晚上再来写qwq 原文地址:https://www.cnblogs.com/lqsukida/p/9988445.html

【算法竞赛进阶指南】USACO07Tallest Cow

前缀和,利用左右端点操作代替对区间的操作,从而优化输入,最后进行一次前缀和的操作,求得结果,这道题里面有个很关键的问题,就是需要去重,本来我想用set,但貌似有点鬼畜,算了,利用map去重,还有pair类型(学一下) #include <iostream> #include <algorithm> #include <map> #include <utility> using namespace std; map<pair<int,int>

【算法竞赛进阶指南】POJ1845Sumdiv

本题目是一道数论的综合题目,主要的一个点就是利用二分法来求等比数列的和,其余的点就是唯一分解定理分解质因数,还有就是快速幂 A^B约数和\(=(1+p_{1}+p_{1}^{2}+\cdot\cdot\cdot+p_{1}^{c1})*(1+p_{2}+p_{2}^{2}+\cdot\cdot\cdot+p_{2}^{c2})*\cdot\cdot\cdot*(1+p_{n}+p_{n}^{2}+\cdot\cdot\cdot+p_{n}^{cn})\) 如果c是奇数(一共有偶数项)\(sum(