洛谷P3952 时间复杂度【字符串】【模拟】

题目描述

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

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

F i x y
    循环体
E

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

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

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

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

输入输出格式

输入格式：

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

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

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

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

输出格式：

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

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

输入输出样例

输入样例#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】

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

第二个程序 xx 从 1 到 nn 是 nn 的一次方的复杂度。

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

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

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

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

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

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

【数据规模与约定】

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

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

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

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

---

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

题意：

一个循环表示为$F i x y$其中$i$表示这一层循环的变量$x$表示循环开始的值$y$表示当变量小于等于$y$时始终执行循环

$E$是一层循环的结束标志。

现在给定一段程序判断这段程序的复杂度和给定的是否一致。

思路：

啊我好菜。刚开始思路不清晰对着样例debug半天。

后来列了个表格分了情况稍微重新写了一次，但是情况没有考虑全面。

ERR的情况是，E和F的个数不匹配（计数）或外层循环和内层循环的变量名重复了（set和stack并用），比较好判断。

当出现x是数字而y是n时，这层循环对复杂度有1的贡献。

当出现数字数字和nn时，这层循环对复杂度没有贡献。

当出现n数字，或是x的数字比y的数字大的时候这层循环以及这层循环内部的循环都不会进入。

 //#include<bits/stdc++.h>
 #include<set>
 #include<iostream>
 #include<stdio.h>
 #include<stdlib.h>
 #include<cstring>
 #include<stack>
 #include<algorithm>

 using namespace std;

 int t, lines;

 int getO(string s)
 {
     int i = , res = ;
     if(s[] == '')return ;
     while(s[i] != ')'){
         res *= ;
         res += s[i] - '';
         i++;
     }
     return res;
 }

 int getnumber(string s)
 {
     int i = , len = s.length();
     int res = ;
     while(i < len){
         res *= ;
         res += s[i] - '';
         i++;
     }
     return res;
 }

 int main()
 {
     scanf("%d", &t);
     while(t--){
         scanf("%d", &lines);
         string O;
         cin>>O;

         stack<string>v_ar;
         set<string>var;
         int deep = , now = ;
         bool flag = true;
         bool allone = false;
         int EFs = ;
         for(int i = ; i < lines; i++){
             char ch;
             getchar();
             scanf("%c", &ch);
             if(ch == 'E'){
                 EFs -= ;
                 now -= ;
                 if(!v_ar.empty()){
                     string v = v_ar.top();v_ar.pop();
                     var.erase(v);
                 }
                 if(!EFs){
                     allone = false;
                     now = ;
                     //var.clear();
                 }
             }
             else if(ch == 'F'){
                 EFs += ;
                 string v, x, y;
                 cin>>v>>x>>y;
                 if(var.find(v) != var.end())flag = false;
                 else{
                     var.insert(v);
                     v_ar.push(v);
                     if(x[] >= '' && x[] <= '' && y[] == 'n'){
                         if(!allone)now += ;
                         deep = max(deep, now);
                     }
                     else if(x[] == 'n' && y[] >= '' && y[] <= '' || getnumber(x) > getnumber(y))allone = true;
                 }
             }
         }

         //cout<<deep<<endl;
         if(EFs || !flag){
             printf("ERR\n");
         }
         else if(getO(O) == deep){
             printf("Yes\n");
         }
         else{
             printf("No\n");
         }
     }

     return ;
 }