P3952 [NOIP2017 提高组] 时间复杂度 题解

[NOIP2017 提高组] 时间复杂度

题目背景

NOIP2017 提高组 D1T2

题目描述

小明正在学习一种新的编程语言 A++，刚学会循环语句的他激动地写了好多程序并 给出了他自己算出的时间复杂度，可他的编程老师实在不想一个一个检查小明的程序， 于是你的机会来啦！下面请你编写程序来判断小明对他的每个程序给出的时间复杂度是否正确。

A++语言的循环结构如下：

F i x y
    循环体
E

其中F i x y表示新建变量 $i$（变量 $i$ 不可与未被销毁的变量重名）并初始化为 $x$， 然后判断 $i$ 和 $y$ 的大小关系，若 $i$ 小于等于 $y$ 则进入循环，否则不进入。每次循环结束后 $i$ 都会被修改成 $i+1$，一旦 $i$ 大于 $y$ 终止循环。

$x$ 和 $y$ 可以是正整数（$x$ 和 $y$ 的大小关系不定）或变量 $n$。$n$ 是一个表示数据规模的变量，在时间复杂度计算中需保留该变量而不能将其视为常数，该数远大于 $100$。

E 表示循环体结束。循环体结束时，这个循环体新建的变量也被销毁。

注：本题中为了书写方便，在描述复杂度时，使用大写英文字母 $O$ 表示通常意义下 $\Theta$ 的概念。

输入格式

输入文件第一行一个正整数 $t$，表示有 $t$（$t\le 10$）个程序需要计算时间复杂度。 每个程序我们只需抽取其中 F i x y 和 E 即可计算时间复杂度。注意：循环结构允许嵌套。

接下来每个程序的第一行包含一个正整数 $L$ 和一个字符串，$L$ 代表程序行数，字符串表示这个程序的复杂度，O(1) 表示常数复杂度，O(n^w) 表示复杂度为 $n^w$，其中 $w$ 是一个小于 $100$ 的正整数，输入保证复杂度只有 O(1) 和 O(n^w) 两种类型。

接下来 $L$ 行代表程序中循环结构中的F i x y或者 E。 程序行若以F开头，表示进入一个循环，之后有空格分离的三个字符（串）i x y， 其中 $i$ 是一个小写字母（保证不为$n$），表示新建的变量名，$x$ 和 $y$ 可能是正整数或 $n$ ，已知若为正整数则一定小于 $100$。

程序行若以E开头，则表示循环体结束。

输出格式

输出文件共 $t$ 行，对应输入的 $t$ 个程序，每行输出 Yes 或 No 或者 ERR，若程序实际复杂度与输入给出的复杂度一致则输出 Yes，不一致则输出 No，若程序有语法错误（其中语法错误只有: ① F 和 E 不匹配 ②新建的变量与已经存在但未被销毁的变量重复两种情况），则输出 ERR。

注意：即使在程序不会执行的循环体中出现了语法错误也会编译错误，要输出 ERR。

样例 #1

样例输入 #1

8
2 O(1)
F i 1 1
E
2 O(n^1)
F x 1 n
E
1 O(1)
F x 1 n
4 O(n^2)
F x 5 n
F y 10 n
E
E
4 O(n^2)
F x 9 n
E
F y 2 n
E
4 O(n^1)
F x 9 n
F y n 4
E
E
4 O(1)
F y n 4
F x 9 n
E
E
4 O(n^2)
F x 1 n
F x 1 10
E
E

样例输出 #1

Yes
Yes
ERR
Yes
No
Yes
Yes
ERR

提示

【输入输出样例解释 $1$】

第一个程序 $i$ 从 $1$ 到 $1$ 是常数复杂度。

第二个程序 $x$ 从 $1$ 到 $n$ 是 $n$ 的一次方的复杂度。

第三个程序有一个 F 开启循环却没有 E 结束，语法错误。

第四个程序二重循环，$n$ 的平方的复杂度。

第五个程序两个一重循环，$n$ 的一次方的复杂度。

第六个程序第一重循环正常，但第二重循环开始即终止（因为 $n$ 远大于 $100$，$100$ 大于 $4$）。

第七个程序第一重循环无法进入，故为常数复杂度。

第八个程序第二重循环中的变量 $x$ 与第一重循环中的变量重复，出现语法错误②，输出 ERR。

【数据规模与约定】

对于 $30\%$ 的数据：不存在语法错误，数据保证小明给出的每个程序的前 $L/2$ 行一定为以 F 开头的语句，第 $L/2+1$ 行至第 $L$ 行一定为以 E 开头的语句，$L\le 10$，若 $x$、$y$ 均为整数，$x$ 一定小于 $y$，且只有 $y$ 有可能为 $n$。

对于 $50\%$ 的数据：不存在语法错误，$L\le 100$，且若 $x$、$y$ 均为整数，$x$ 一定小于 $y$， 且只有 $y$ 有可能为 $n$。

对于 $70\%$ 的数据：不存在语法错误，$L\le 100$。

对于 $100\%$ 的数据：$L\le 100$。

---

如果需要Hack请私信@zhouyonglong或发讨论，提供数据和能Hack掉的本题的AC记录。

题解

真的很考验逻辑是否清晰的一个题，如果逻辑不清晰估计做半中间就崩溃了
建议先耐心看完题干和样例数据的讲解，想好至少80%再开始敲代码，否则后面就全是bug了
先整理一遍题意，判断时间复杂度，首先给的数据可能是出错的，如果数据无误的情况下，F进入循环，E退出循环，进入循环时变量字母不能在销毁前重名，x和y可以是数字或n，如果是x>y则无法进入循环，相当于这个循环整体是O(1)，如果可以进入循环，看循环次数，如果循环次数与n有关，计入时间复杂度，否则不计入（因为影响的是常数）
因为数据即使已经判断出错误，也要继续装模作样读入，还不如放弃边读入边处理，索性先读入，读入完成后判断是否有错，无错则计算时间复杂度。为了简化，我选择生成时间复杂度的字符串与数据中的时间复杂度字符串对比，而不是从他给的字符串里去提取次数

整理思路如下：

1. 读入数据，存储指令在数组中
2. 判断数据是否有误
3. 计算时间复杂度
4. 生成表达时间复杂度的字符串并比对

那么接下来对于每一块的实现细节进行阐述：

1. 读入数据

注意F/E是字符，使用变量名也是字符，可以存在char数组里
对于起始/结尾的数字，可能是两位数，那么用字符串string来存

那么我们可能会用到字符串转数字，数字转字符串，可以用string内置的函数，也可以手写

2. 判断数据是否有误

先判断一下F和E数量是不是偶数，奇数那肯定语法错误了
然后用栈来判断F和E是否匹配

开一个数组来哈希判断是否重复用名了，因为变量名是小写字母，直接用ASCII码就挺方便

3. 计算时间复杂度

用一个变量计算”当前层“属于的时间复杂度，那么题目的答案自然是所有”当前层“时间复杂度的最大值

然后看细节
如果是F，则分为四种情况：

1. n n 这种肯定能进入
2. n 数字 这种肯定不能进入
3. 数字 n 这种肯定能进入，且要计入时间复杂度
4. 数字 数字 这种需要字符串转数字然后判断一下能不能进入

如果能进入，那就直接进入了。
注意：如果无法进入，不能break跳出来，而是标记一下层号，不断F”假“进入，再E不断跳出，直至回到原来那层

如果是E，则还要开一个数组标记曾经加过时间复杂度的层，看一下要不要减时间复杂度的计数，不能盲目地直接减，因为有的层执行次数是常数

4. 生成表示时间复杂度的字符串并比对

时间复杂度一共两种表示O(1)和O(n^m)
if判断一下用哪种就行了

代码如下：

#include<iostream>
using namespace std;
int book[123];//97-122 //记录是否用过小写字母

char order[101],a[101];
string b[101],c[101]; //储存指令

bool check_error(int lines) //检查语法错误
{
	if(lines%2==1) return true;
	
	//初始化
	int stack[101]={0},cnt=1;
	for(int i=97;i<=122;i++) book[i]=0; 
	
	//查错
	for(int i=1;i<=lines;i++)
	{
		if(!cnt) return true;
		if(order[i]=='F') {
			if(book[(int)a[i]]) return true;
			book[(int)a[i]]=1;
			stack[++cnt]=(int)a[i];
		}
		else {
			book[stack[cnt]]=0;
			cnt--;
		}
	}
	
	if(cnt!=1) return true;
	else return false;
}

int turn_num(string s) //字符串转数字
{
	int sum=0;
	for(int i=0;i<s.length();i++)
	{
		sum*=10;
		sum+=s[i]-'0';
	}
	return sum;
}

int main()
{
	int t;
	cin>>t;
	for(int i=1;i<=t;i++)
	{
		//数据读入
		int l;string s;
		cin>>l>>s;
		for(int j=1;j<=l;j++)
		{
			cin>>order[j];
			if(order[j]=='E');
			else{
				cin>>a[j]>>b[j]>>c[j];
			}
		}
		
		//判断数据是否有错
		if(check_error(l)) {
			cout<<"ERR"<<endl;
			continue;
		}
		
		//无错则统计时间复杂度
		int cnt=0,maxn=0,num=0;
		bool flag[101]={0};
		for(int i=1;i<=l;i++)
		{
			//进
			if(order[i]=='F')
			{
				if(b[i]=="n" && c[i]=="n") num++; //进入内层
				else if(b[i]=="n") { //不能进入内层
					int num_flag=num;num++;
					while(i<=l&&num!=num_flag) {
						i++;
						if(order[i]=='F') num++;
						else num--;
					}
				} 
				else if(c[i]=="n") { //进入内层并统计
					num++;cnt++; 
					flag[num]=1; //记录是在第几层计入时间复杂度的
				}
				else
				{ 
					//数字要亲自判断能不能进入内层
					int st_num=turn_num(b[i]);
					int ed_num=turn_num(c[i]);
					if(st_num>ed_num) {
						int num_flag=num;num++;
						while(i<=l&&num!=num_flag) {
							i++;
							if(order[i]=='F') num++;
							else num--;
						}
					}
					else num++;
				}
			}
			
			//退
			else
			{
				if(flag[num]) {
					flag[num]=0;
					cnt--;
				}
				num--;
			}
			
			maxn=cnt>maxn? cnt:maxn;//更新时间复杂度的统计
		}
		
		//生成时间复杂度的字符串并对比
		string ans="O(";
		if(maxn==0) ans+="1)";
		else{
			ans+="n^";
			//数字转字符串
			ans+=to_string(maxn);
			ans+=")";
		}
		if(ans==s) cout<<"Yes"<<endl;
		else cout<<"No"<<endl;
	}
	return 0;
}