NOIp2017D1T2 时间复杂度【模拟】

说一说

题目分析请从目录空降...

没想到模拟题还会卡这么久...菜得真实...

这是一个励志的故事：从$0pts->9pts->18pts->27pts->36tps->54pts->72pts->84pts->100pts$

（还不是面向数据编程，虽然这个分数的变化看来很像...）

题目分析

题目传送门

非常明显的模拟题。

由$F$和$E$的匹配关系可以想到像括号匹配那样用栈来做。（其实之前没有想到用栈的，是想用一个$tot$变量来判断能不能匹配，但是后面发现要找层次关系，要找$E$对应的$F$是什么）

我的做法是在线的，给出的程序只扫了一遍（当然还是存下来以便后续读取），主要思路就是：

用栈来维护，遇到一个$F$就压进去，$tot++$，标记变量已经被使用，顺便判断变量重名；遇到一个$E$就弹栈，弹出来的就是和自己配对的$F$，清除变量名的标记，计算自己这一层的复杂度：

常数->常数 —— $0$

常数->$n$ —— $1$

$n$->$n$ —— $0$

$n$->常数 —— $0$

并更新统计答案。再说一下重点，统计答案：（不知道有没有雷同的，感觉自己的思路很清奇，不一定说得清楚qwq）

之前想过用递归写，因为时间复杂度是同层取$max$，不同层累计（外层的答案相当于是内层的最大值$+1/0$（外层计算出来的自己这一层的复杂度））。

$tot$表示层级，比如：

每一层循环都用$F$开始那个$tot$标号，就可以表示层级关系。

定义数组$ans[tot]$表示$tot$这一层的答案，在这一层需要干的事情就是更新$ans[tot]=max(ans[tot],ans[tot+1]+1/0$

然后要将$ans[tot+1]$赋为$0$，是为了同一层并列的情况。和这一层并列的循环不能使用当前循环的循环体内嵌套的循环来更新它（这句话好像有点绕...）因为这里是碰到$E$了，马上就要$tot--$，说明现在的$tot+1$是当前循环的内层循环，这个答案只能用来更新当前循环，而不能更新和当前循环并列的循环，而且进行到这一步说明内层循环已经没了，所以可以直接清成$0$。

注意有个特殊情况，就是外层循环根本就进不去，也就是$x>y$，这个时候这一层的答案是$0$，这里可以把$n$看成$INF$

最后计算出来的时间复杂度是$ans[1]$，把它和小明的答案进行比较就可以了。要注意小明的答案是用字符串读入的，而且有可能是个多位数，要转化成数字再和$ans[1]$比较。

遍历结束之后再看一下栈里面还有没有东西（或$tot>=0$），如果有，就$ERR$

判断$ERR$之后不要马上$break$，因为是多组数据而且是在线的，要把这组数据输入完，不然会影响后面数据的读入。

主要思路比较简单，但是细节有很多要处理，要小心。

 #include<cstdio>
 #include<algorithm>
 #include<vector>
 #include<cstring>
 #include<queue>
 #include<map>
 #include<iostream>
 #include<stack>
 using namespace std;
 #define ll long long
 #define INF 0x3f3f3f3f
 int rd()
 {
     int f=,s=;char c=getchar();
     while(c<''||c>''){if(c=='-') f=-;c=getchar();}
     while(c>=''&&c<=''){s=(s<<)+(s<<)+(c^);c=getchar();}
     return f*s;
 }
 char /*cd[105][20],输入太怀疑人生了*/opt[];//不要在意这个名字(其实是因为懒得改了
 bool vis[];
 int ans[];
 stack<int>s;
 struct node{
     string st,bl;
     int ss,tt;
 }cd[];
 string t;
 int main()
 {
     int T=rd();
     while(T--)
     {
         memset(ans,,sizeof(ans));
         memset(vis,,sizeof(vis));
         int L=rd();
         scanf("%s",opt+);
         scanf("\n");
         bool flag=;
         int tot=;
         for(int i=;i<=;i++)
             cd[i].st="",cd[i].bl="",cd[i].ss=,cd[i].tt=;
         for(int i=;i<=L;i++)
         {
             cin>>cd[i].st;
             if(cd[i].st[]=='F')
             {
                 cin>>cd[i].bl;
                 string t;cin>>t;
                 if(t=="n") cd[i].ss=INF;
                 else
                 {
                     for(int k=;k<t.size();k++)
                         cd[i].ss=cd[i].ss*+(t[k]-'');
                 }
                 cin>>t;
                 if(t=="n") cd[i].tt=INF;
                 else
                 {
                     for(int k=;k<t.size();k++)
                         cd[i].tt=cd[i].tt*+(t[k]-'');
                 }
                 tot++;
                 s.push(i);
                 if(vis[cd[i].bl[]-'a'])
                     flag=;
                 vis[cd[i].bl[]-'a']=;
             }
             if(cd[i].st[]=='E')
             {
                 if(s.empty())
                 {//这里要用栈 实际上后面的tot<0就是在判这个东西 但是这里已经调用了栈 所以没用 会RE
                     flag=;
                     continue;//break;不能break啊 多组数据要影响输入
                 }
                 int k=s.top(),tmp=;s.pop();
                 vis[cd[k].bl[]-'a']=;
                 if(cd[k].ss!=INF&&cd[k].tt==INF) tmp=;
                 ans[tot]=max(ans[tot+]+tmp,ans[tot]);
                 ans[tot+]=;
                 //注意这里清空 后面tot会-- 这一层已经搞完了
                 //后面和这一层并列的东西不能从它的儿子部分得到
                 if(cd[k].ss>cd[k].tt) ans[tot]=;
                 tot--;
                 if(tot<)
                 {
                     flag=;
                     continue;//break;不能break啊 多组数据要影响输入
                 }
             }
         }
         if(tot) flag=;
         if(flag)
         {
             puts("ERR");
             continue;
         }
         //printf("%d\n",ans[1]);
         int res=;
         int m=;
         while(opt[m]>=''&&opt[m]<=''){res=res*+(opt[m]-'');m++;}
         if(ans[]==&&opt[]=='') puts("Yes");
         else if(ans[]==res) puts("Yes");
         else puts("No");
     }
     return ;
 }

Code