刷题记录:牛客NC16539&&牛客NC21181(表达式求值的一些事)

已于 2022-08-01 15:13:38 修改
阅读量309 收藏
点赞数
分类专栏： c++算法 文章标签： c++ 算法
于 2022-08-01 13:54:58 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yingjiayu12/article/details/126099186
版权

首先是牛客NC16539

给定一个只包含加法和乘法的算术表达式，请你编程计算表达式的值。
输出只有一行，包含一个整数，表示这个表达式的值。注意：当答案长度多于4位时，请只输出最后4位，前导0不输出。
输入:
1+1234567890*1
输出:
7891

首先这道题是NOIP普及组的一道题,思维复杂度也不大,一看题目就有了一种比较显然的做法:因为只有乘号和加号,因此这个表达式肯定符合这么的一种形式即数字+符号为组的重复序列,因此我们只要记录乘号的组数,那么乘法的运算就是当前组数的数字*下一组数的数字,然后将前面的数字清空(因为可能有连乘的存在,后面的数字要保留),最后累加一下就解决了

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <string.h>
using namespace std;
typedef long long ll;
#define inf 0x3f3f3f3f
#define root 1,n,1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
char c[1000005];
ll a[1000005];int sum=0;
int main() {
	sum++;
	while(c[sum]!='\n') {
		sum++;
		cin>>a[sum];
		a[sum]%=10000;
		c[sum]=getchar();
	}
	for(int i=sum;i>=1;i--) {
		if(c[i]=='*') {
			a[i]*=a[i+1];
			a[i]%=10000;
			a[i+1]=0;
		}
	}
	ll ans=0;
	for(int i=1;i<=sum;i++) {
		ans+=a[i];
		ans%=10000;
	}
	cout<<ans<<endl;
	return 0;
}

是不是觉得很好,但是当我在做下一道进阶题的时候,运用这种思想却发生了奇怪的事情

看这道进阶题

第一行，一个整数T (1≤T≤100000)，表示案例的个数。
接下来的T行，每行一个字符串（长度小于等于100），字符串仅由0-9、+、-、*、/、^、!字符组成，数字表示一个数值，范围为[0,9]，且数字不存在前导零，其他符号表示一种运算规则，规则的描述如下：
+：数字1 +数字2 =两个数字之和，+号的优先级为1
-：数字1 -数字2 =两个数字之差，-号的优先级为1
*：数字1 *数字2 =两个数字之积，*号的优先级为2
/：数字1 /数字2 =两个数字之商（舍去小数），/号的优先级为2
^：数字1 ^数字2 =数字1的数字2次方，^号的优先级为3
!：数字1 ! =数字1的阶乘，!号的优先级为4
按照优先级从高到低的顺序依次计算，同级运算时，从左到右依次计算。
输入保证对于每个字符串，满足上述条件，一行输入，以换行符结束。保证式子的表达式语义正确。特别的，一切数值计算均受限于模65536的数域，即每一步运算都要对65536取模，取模的规则同C语言规范。同时，任意数的0次方等于1。

思路:
我运用了之前的经验然后搞出了下面这个代码:具体思路就是先读一遍,因为阶乘的形式不符合数字+符号+数字的格式,所以我先把阶乘计算好直接使用数字代替了,保证它符合之前只有乘号和加号的形式,然后再枚举一遍,计算^的值,这样的话就只剩下乘法除法和加减法了,基本上就等同于之前的那道题了

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <string.h>
using namespace std;
typedef long long ll;
#define inf 0x3f3f3f3f
#define root 1,n,1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
char c[100000];ll a[100000];
ll aa[100000];char cc[100000];
ll mod=65536;ll f[65536];
ll power(ll x,ll y){
	if(y==0)return 1;
    ll sum=1;
    while(y){
    	if(y&1){
        	sum=sum*x%mod;
        }
        x=x*x%mod;
        y=y>>1;
    }
    return sum;
}
int main() {
	int T;
	cin>>T;
	f[0]=1;
	for(int i=1;i<mod;i++) f[i]=f[i-1]*i%mod;
	while(T--) {
		memset(c,'\0',sizeof(0));
		memset(cc,'\0',sizeof(0));
		memset(a,0,sizeof(a));
		memset(aa,0,sizeof(aa));
		ll sum=0;ll sum2=0;
		while(c[sum]!='\n') {
			sum++;
			scanf("%d",&a[sum]);
			a[sum]%=mod;
			c[sum]=getchar();
			while(c[sum]=='!') {
				a[sum]=f[a[sum]];
				a[sum]%=mod;
				c[sum]=getchar();
			}
		}
		ll n=1;
		while(n<=sum) {
			sum2++;
			aa[sum2]=a[n];
			aa[sum2]%=mod;
			cc[sum2]=c[n];
			while(cc[sum2]=='^') {
				aa[sum2]=power(aa[sum2],a[n+1]);
				aa[sum2]%=mod;
				n++;
				cc[sum2]=c[n];
			}
			n++;
		}
		bool flag=false; 
		for(int i=1;i<=sum2;i++) {
			if(cc[i]=='-') {
				aa[i+1]=-aa[i+1];
			}
			if(cc[i]=='*') {
				aa[i+1]*=aa[i];
				aa[i]=0;
				aa[i+1]%=mod;
			}else if(cc[i]=='/') {
				if(aa[i+1]==0) {
					cout<<"ArithmeticException"<<endl;
					flag=true;
					break;
				}else {
					aa[i+1]=aa[i]/aa[i+1];
					aa[i+1]%=mod;
					aa[i]=0;
				}
			}
		}
		if(flag==false) {
			ll ans=0;
			for(int i=1;i<=sum2;i++) {
				ans+=aa[i];
			}
			printf("%lld\n",ans);
		}
	}
	return 0;
}

然而交上去发现竟然T了一个点,得了66.66分,一看题解发现是用分治写的,唉没想到啊,还是分治大法NB啊,然后我就采用了分治方法冲了一下
分治的代码

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <string.h>
using namespace std;
typedef long long ll;
#define inf 0x3f3f3f3f
#define root 1,n,1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
const int mod=65536;
int f[mod];
int power(int x,int y){
	if(y==0)return 1;
    ll sum=1;
    while(y){
    	if(y&1){
        	sum=sum*x%mod;
        }
        x=x*x%mod;
        y=y>>1;
    }
    return sum;
}
string a;
int toNum(int l,int r) {
	int sum=0;
	for(int i=l;i<=r;i++) {
		sum=sum*10+a[i]-'0';
	}
	return sum;
}
int flag=0;
int calc(int l,int r) {
	int pos1=-1,pos2=-1,pos3=-1,pos4=-1;
	for(int i=l;i<=r;i++) {
		if(a[i]=='+'||a[i]=='-') pos1=i;
		else if(a[i]=='*'||a[i]=='/') pos2=i;
		else if(a[i]=='^') pos3=i;
		else if(a[i]=='!') pos4=i;
	}
	if(pos1==-1&&pos2==-1&&pos3==-1&&pos4==-1) return toNum(l,r);
	else if(pos1!=-1) {
		if(a[pos1]=='+') return (calc(l,pos1-1)+calc(pos1+1,r))%mod;
		else return (calc(l,pos1-1)-calc(pos1+1,r))%mod;
	}
	else if(pos2!=-1) {
		if(a[pos2]=='*') return (calc(l,pos2-1)*calc(pos2+1,r))%mod;
		else {
			if(calc(pos2+1,r)==0) flag=1;
			else return (calc(l,pos2-1)/calc(pos2+1,r))%mod;
		}
	}
	else if(pos3!=-1) {
		return power(calc(l,pos3-1),calc(pos3+1,r));
	}
	else if(pos4!=-1) {
		int aa=calc(l,pos4-1);
		return f[aa];
	}
	return 0;
}
int main() {
	int T;cin>>T;
	f[0]=1;
	for(int i=1;i<mod;i++) f[i]=f[i-1]*i%mod;
	while(T--) {
		cin>>a;flag=0;
		int ans=calc(0,a.size()-1);
		if(flag==0) cout<<ans<<endl;
		else cout<<"ArithmeticException"<<endl;
	}
	return 0;
}

然后最奇怪的地方出现了,当我用分块的方法去做之前的那道题的时候(也就是只有加法和乘法的那道题),发现竟然又T掉了两个点,我直接???,代码如下方

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <string.h>
using namespace std;
typedef long long ll;
#define inf 0x3f3f3f3f
#define root 1,n,1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
const int mod=10000;
string a;
ll toNum(ll l,ll r) {
	int sum=0;
	for(int i=l;i<=r;i++) {
		sum=sum*10+a[i]-'0';
	}
	return sum;
}
int flag=0;
ll calc(ll l,ll r) {
	int pos1=-1,pos2=-1;
	for(int i=l;i<=r;i++) {
		if(a[i]=='+') pos1=i;
		else if(a[i]=='*') pos2=i;
	}
	if(pos1==-1&&pos2==-1) return toNum(l,r);
	else if(pos1!=-1) {
		if(a[pos1]=='+') return (calc(l,pos1-1)+calc(pos1+1,r))%mod;
	}
	else if(pos2!=-1) {
		if(a[pos2]=='*') return (calc(l,pos2-1)*calc(pos2+1,r))%mod;
	}
	return 0;
}
int main() {
	f[0]=1;
	cin>>a;flag=0;
	ll ans=calc(0,a.size()-1)%mod;
	if(flag==0) cout<<ans<<endl;
	else cout<<"ArithmeticException"<<endl;
	return 0;
}

在思考了很久并且在某古上求助的帮助下,我明白了问题的所在性,这个问题在于之前的那道分治算法并不是完美的,他每次都是只枚举到符号的最后一位,如果遇到数据比较卡的情况,比如1+1+1+1+...+1,就会被卡到n^2的情况,这个时候就要怪之前的数据没有卡这种情况了,这时候我们就需要rand函数来随性性优化我们的查找算法(类似于一种快速排序的方法)

关于rand函数
一般的 rand()%(b-a+1)+a ; 就表示 a~b 之间的一个随机整数。(两边都是闭区间)

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <string.h>
#include <time.h>
using namespace std;
typedef long long ll;
#define inf 0x3f3f3f3f
#define root 1,n,1
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
inline ll read() {
	ll x=0,w=1;char ch=getchar();
	for(;ch>'9'||ch<'0';ch=getchar()) if(ch=='-') w=-1;
	for(;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
	return x*w;
}
#define maxn 1000000
const int mod=10000;
string a;int jia[100000],cheng[100000];
ll toNum(ll l,ll r) {
	int sum=0;
	for(int i=l;i<=r;i++) {
		sum=sum*10+a[i]-'0';
	}
	return sum;
}
int flag=0;
ll calc(ll l,ll r) {
	srand((int)time(0));
	int num1=0,num2=0;
	for(int i=l;i<=r;i++) {
		if(a[i]=='+'){
			num1++;jia[num1]=i;
		}
		else if(a[i]=='*') {
			num2++;cheng[num2]=i;
		}
	}
	if(num1==0&&num2==0) return toNum(l,r);
	else if(num1!=0) {
		int rnd=jia[rand()%(num1-1+1)+1];
//		cout<<"jia"<<" "<<rnd<<endl;
		return (calc(l,rnd-1)+calc(rnd+1,r))%mod;
	}
	else if(num2!=0) {
		int rnd=cheng[rand()%(num2-1+1)+1];
//		cout<<"cheng"<<" "<<rnd<<endl;
		return (calc(l,rnd-1)*calc(rnd+1,r))%mod;
	}
	return 0;
}
int main() {
	cin>>a;int jN=0,cN=0;
	flag=0;
	ll ans=calc(0,a.size()-1)%mod;
	if(flag==0) cout<<ans<<endl;
	else cout<<"ArithmeticException"<<endl;
	return 0;
}

然后我们就会发现成功的AC啦!!

yingjiayu12
关注
专栏目录
刷题记录:牛客NC50999表达式计算4
yingjiayu12的博客
08-01 239
刷题记录:牛客NC50999表达式计算4
刷题记录:牛客NC19427换个角度思考 [可持久化线段树]
yingjiayu12的博客
02-19 165
刷题记录:牛客NC19427换个角度思考 [可持久化线段树]
牛客-NC137-表达式求值
dingzhi4469的博客
07-08 695
NC137. 表达式求值（medium）方法一：双栈法(表达式计算的通用解法) 方法一：双栈法(表达式计算的通用解法) 思路：这里借鉴了三叶大佬的题解，自己在这写一遍加深印象。 对于任何表达式而言，我们可以使用两个栈nums和ops： nums：存放所有的数字 ops：存放所有的数字之外的操作 然后从前往后遍历，对遍历的字符分情况讨论： 空格：跳过 (：直接加入ops中，等待与之匹配的) )：使用现有的nums和ops进行计算，直到遇到左边最近的一个左括号为止，计算结果放到nums中 数字：从当前位置开
中缀表达式转为逆波兰式并求值（牛客NC137-表达式求值-C++实现）
powerof10的博客
10-21 867
今天刷牛客遇到一个表达式求值的题，题目链接如下： 牛客NC137-表达式求值 这道题与Leetcode 224-基本计算器类似，但Leetcode这道题没有要求乘法 涉及到编译原理的内容，后缀表达式计算起来比较容易，复习了一下将中缀表达式转化为后缀表达式的方法。 ①要用到两个stack：一个放数字、一个放运算符，由于数字可能有多位，且存在运算符栈顶pop后向数字栈push的情况，因此两个stack数据类型定义为string。 ②由于放数字的栈存放最后后缀表达式，且需要一次弹出逆序，果断一开始就用queue来
牛客NC216 逆波兰表达式求值【中等 栈 C++/Java/Go/PHP】
weixin_37991016的博客
04-24 210
题目链接：https://www.nowcoder.com/practice/885c1db3e39040cbae5cdf59fb0e9382。
【牛客刷题-算法】 NC13 二叉树的最大深度
成长之路
09-23 984
求给定二叉树的最大深度， 深度是指树的根节点到任一叶子节点路径上节点的数量。 最大深度是所有叶子节点的深度的最大值。
牛客NC50999 表达式计算4（递归计算）
NaNa
09-10 444
NC50999 表达式计算4 题目链接 题目描述 给出一个表达式,其中运算符仅包含 +, -, *, /, ^（加 减 乘 整除 乘方）要求求出表达式的最终值 数据可能会出现括号情况，还有可能出现多余括号情况 数据保证不会出现 ≥231\geq 2^{31}≥231 的答案 数据可能会出现负数情况 code #include <bits/stdc++.h> using namespace std; string s; int qpow(int a, int b) { int res
2022.03.06 - NC034.BM49 表达式求值
阿财继续努力
03-06 356
文章目录1. 题目2. 思路(1) 栈3. 代码 1. 题目 2. 思路 (1) 栈 利用一个栈存放操作数，另一个栈存放操作符。 若遇到左括号，则直接压入操作符栈中；若遇到右括号，则弹出操作符栈的栈顶元素，以及两个操作数栈的栈顶元素进行计算，结果压入操作数栈中，如此循环，直到操作符栈的栈顶元素是左括号，则直接弹出即可。 若遇到数字，则直接压入操作数栈中。 若遇到操作符，可以先判断操作符栈的栈顶元素的优先级是否大于或等于当前操作符，若大于或等于，则可以先将之前的操作计算出来，然后再将操作符压入操作符栈中。
表达式求值（NC137/考察次数Top48/难度中等）
weixin_43852700的博客
06-18 250
描述: 请写一个整数计算器，支持加减乘三种运算和括号。 示例1 输入： “1+2” 返回值： 3 示例2 输入： “(2*(3-4))*5” 返回值： -10 (题目来自牛客网) 用C++实现如下 class Solution { public: /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * 返回表达式的值 * @param s string字符串 待计算的表达式 * @return int整型 */
【牛客题库整理】NC1 大数加法
Charlotte_LIU_的博客
02-19 317
题目 题解 C /** * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可 * 计算两个数之和 * @param s string字符串 表示第一个整数 * @param t string字符串 表示第二个整数 * @return string字符串 */ char* solve(char* s, char* t ) { // write code here int sLen = strlen(s); int tLen = strlen(t);
NC100 把字符串转换成整数(atoi)
我不是萧海哇的博客
02-15 593
描述 写一个函数 StrToInt，实现把字符串转换成整数这个功能。不能使用 atoi 或者其他类似的库函数。传入的字符串可能有以下部分组成: 1.若干空格 2.（可选）一个符号字符（’+’ 或 ‘-’） 3. 数字，字母，符号，空格组成的字符串表达式 4. 若干空格 示例1 输入： "82" 返回值： 82 示例2 输入： " -12 " 返回值： -12 说明： 去掉前后的空格，为-12 示例3 输入： "4396 clearlove" 返回值： 4396 说明： 6后面的字符不属于有.
牛客面试必考真题【算法篇】高频Top200 题目汇总
31楼下小黑的博客
08-25 1605
NC6 二叉树的最大路径和
C++——C++11新语法（中）
Wangx_wang的博客
11-06 1023
介绍了C++11中的引用折叠、可变模板参数、类的新功能、lambda
STL set
最新发布
hls0611的博客
11-09 200
练习题：P1059 [NOIP2006 普及组] 明明的随机数。
C++_用 using 语句继承基类的构造函数
学海无涯
11-09 93
**默认情况下**，派生类会继承基类的所有成员，包括数据成员和函数成员，但不会继承基类的**构造函数和析构函数**，因为构造函数和析构函数的作用是创建和销毁对象，派生类通常需要有自己的构造和析构的逻辑。C++11 引入了using语句，使得派生类可以通过 using 关键字使用基类的构造函数，更方便地复用基类的构造逻辑。
常用的c++特性--＞day02
m0_69093426的博客
11-06 551
C++11中为我们提供了一个模板类叫做std::enable_shared_from_this，这个类中有一个方法叫做shared_from_this()，通过这个方法可以返回一个共享智能指针，在函数的内部就是使用weak_ptr来监测this对象，并通过调用weak_ptr的lock()方法返回一个shared_ptr对象。通过打印的结果可以知道，虽然弱引用智能指针wp3、wp4、wp5监测的资源是同一个，但是它的引用计数并没有发生任何的变化，也进一步证明了weak_ptr只是监测资源，并不管理资源。
GitLab 提交 C++ 技巧
nbspzs的专栏
11-08 220
在 GitLab 中提交 C++ 代码时，通常应只提交 源代码文件（例如 .cpp、.h）和 CMake 配置文件（例如 CMakeLists.txt），而不要提交通过 CMake 编译后的中间文件或构建产物。这样，当其他开发者克隆你的项目后，他们可以在自己的机器上使用 cmake 构建项目，而不需要下载编译产物。2. 跨平台兼容性：不同的开发者和平台可能会生成不同的编译产物，提交这些文件会造成不必要的冲突和问题。1. 在 .gitignore 文件中忽略编译生成的文件和目录。
西南科技大学C++作业1——组合依赖关系实验代码
m0_74312676的博客
11-05 619
合理设计类与类的组合关系，即一个类要嵌套另一个类的对象作为成员变量，根据问题的需要可以是同一个类的多个对象(可以使用对象数组)，也可以是不同类的多个不同对象。让所设计的功能发挥作用。对学生和图书进行抽象，抽象出应有的成员变量，和基本的初始化，修改等成员函数，学生可以发起借书的操作，这是一种依赖关系，在学生类中将设计相应的成员函数体现这一功能操作，合理即可，可以用输出借书是否成功的结果，有一定示意就可以。其他操作：计算得到正确答案，输入自己的题目的答案，向题库内增加题目，在题库内删除题目，查询题库的题目。
【C++】详解RAII思想与智能指针
谁在夜里看海.的博客
11-09 1524
上一篇关于异常处理的文章，我们提到，异常处理是存在内存泄漏风险的，由于异常捕获会导致程序运行时执行流的跳转，并且在某些资源释放之前就进行了跳转，此时就会引发内存泄漏。什么是内存泄漏呢？内存泄漏是指程序在运行的过程中，动态分配的内存被占用但没有得到释放，从而导致资源不能被回收，最终可能导致系统性能下降甚至崩溃。
掌握编程精髓: LeetCode & 牛客编程题题库解析
资源摘要信息: "LeetCode题库是专注于编程面试准备的在线平台，提供了大量的算法题目供用户练习和挑战。该题库不仅覆盖了算法与数据结构的核心知识点，也囊括了实际编程工作中可能遇到的各种问题场景，是程序员特别...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值