标签：根据 输入 tom led rev break else 负数 EDA
达达是一名漫画家，她有一个奇特的爱好，就是在纸上画括号。
这一天，刚刚起床的达达画了一排括号序列，其中包含小括号( )、中括号[ ]和大括号{ }，总长度为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;
}给出一个表达式,其中运算符仅包含+,-,*,/,^（加 减 乘 整除 乘方）要求求出表达式的最终值。
数据可能会出现括号情况，还有可能出现多余括号情况。
数据保证不会出现大于或等于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;
}有一天，小猫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;
}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;
}标签：根据 输入 tom led rev break else 负数 EDA
原文地址：https://www.cnblogs.com/wmxnlfd/p/10943420.html
