其实是道大模拟题目。

题目分析：

时间复杂度介绍：

‌时间复杂度是衡量算法运行时间随输入规模增长的变化趋势‌，用大 $O$ 符号表示，忽略常数项和低阶项，只关注最高阶项的增长量级 。‌‌————百度百科

而这道题保证表示时间复杂度的只有 $O(1)$ 和 $O(n^k)$ 两种类型。

如何判断时间复杂度为 O(1)：

看程序中是否存在一层能够执行、并且循环次数随 n 增长的循环。

如果不存在这样的循环，那么程序的时间复杂度就是 $O(1)$。

如何判断时间复杂度为 ：

看程序中是否存在一层能够执行、并且循环次数随 $n$ 增长的循环。

如果最大有效嵌套层数是 1，那么时间复杂度就是 $O(n)$。

同理如果嵌套层数是 2 则为$O(n^2)$，嵌套层数是 3 则为$O(n^3)$，以此类推。

以下是各个循环对时间复杂度的贡献值，用的数是举例，可借此延伸到其它同类型的数。

循环形式	循环次数	复杂度
F i 1 10	固定次数	$O(1)$
F i 1 n	随 $n$ 增长	$O(n)$
F i n 10	一次也不执行	不执行
F i n n	执行一次	$O(1)$

代码思路：

对于循环语句 F i x y，我用了变量$d$来判断对时间复杂度的贡献。

循环条件	d 的值	含义	对复杂度的贡献
x 是整数，y 是 n	1	循环大约执行 $n$ 次	增加一阶
x 是 n，y 是整数	-1	循环一次也不执行	不贡献复杂度，并使内部循环失效
两者都是整数，且 x > y	-1	循环一次也不执行	不贡献复杂度，并使内部循环失效
两者都是整数，且 x <= y	0	循环执行常数次	不增加复杂度
两者都是 n	0	循环执行常数次	不增加复杂度

例如：

F i 1 n
F j 1 n
E
E

两层循环都贡献一阶，因此时间复杂度是 $O(n^2)$。

F i 1 n
E
F j 1 n
E

第一段执行约 $n$ 次，第二段也执行约 $n$ 次。

总次数约为 $n+n=2n$，因此复杂度仍然是 $O(n)$，而不是 $O(n^2)$。

雷点：

F i n 5
F j 1 n
E
E

外层循环根本不执行，因此内部循环即使看起来是 $O(n)$，整个程序仍然是 $O(1)$。

雷点分析：如果某一层循环永远不执行，它内部所有循环对整个程序的复杂度都没有贡献。

所以要用一个$flag$标记来辅助判断。

检查语法错误

$1.$F 和 E 不匹配，例如少写一个 E，或者多写一个 E。

$2.$变量重复定义，例如外层变量 x 尚未销毁，又在内层定义 x。

雷点：即使错误出现在无法执行的循环中，也必须判定为 ERR。

所以需要：

$1.$用栈匹配 F 和 E。

$2.$用变量标记记录哪些变量仍然处于使用状态。

最后比较复杂度然后输出

假设分析得出的实际复杂度是 $O(n^a)$，题目给出的复杂度是 $O(n^b)$。

按一下顺序判断并输出：

$1.$如果有语法错误，输出 ERR。

$2.$如果没有语法错误，且 a=b，输出 Yes。
$3.$如果不满足以上任何情况，输出 No。

整个解题流程

读取题目给出的复杂度 → 逐行读取循环，判断循环类型 → 利用栈处理嵌套，统计最大有效增长层数 → 检查变量重名和 F、E 是否匹配 → 有语法错误输出 ERR；否则比较指数，输出 Yes 或 No。

总结：用栈处理嵌套，用变量标记检查语法错误，用最大有效增长循环层数计算复杂度，最后比较指数。

重点：这道题的关键不是计算循环具体执行多少次，而是判断哪些循环有效，以及它们最多有多少层真正嵌套执行。

终于写完了

AC code

#include<bits/stdc++.h>
using namespace std;
struct node{
    char c;
    int d;
    bool flag;
};
bool vis[26];
int main(){
    int t;
    cin>>t;
    while(t--){
        memset(vis,0,sizeof(vis));
        int k;
        string s;
        cin>>k>>s;
        int w=0;
        if(s!="O(1)"){
            int i=s.find('^');
            w=stoi(s.substr(i+1,s.size()-i-2));
        }
        stack<node> st;
        bool flag1=0;
        int sum=0,ans=0;
        for(int i=1;i<=k;i++){
            char c;
            cin>>c;
            if(c=='F'){
                char c1;
                string s1,s2;
                cin>>c1>>s1>>s2;
                if(vis[c1-'a']){
                    flag1=1;
                }
                vis[c1-'a']=1;
                int d=0;
                if(s1!="n"&&s2=="n"){
                    d=1;
                }
                else if(s1=="n"&&s2!="n"){
                    d=-1;
                }
                else if(s1!="n"&&s2!="n"&&stoi(s1)>stoi(s2)){
                    d=-1;
                }
                bool flag=(!st.empty()&&st.top().flag);
                if(d==-1){
                    flag=1;
                }
                if(d==1&&!flag){
                    sum++;
                    ans=max(ans,sum);
                }
                st.push({c1,d,flag});
            }
            else{
                if(st.empty()){
                    flag1=1;
                }
                else{
                    node u=st.top();
                    st.pop();
                    vis[u.c-'a']=0;
                    if(u.d==1&&!u.flag){
                        sum--;
                    }
                }
            }
        }
        if(!st.empty()){
            flag1=1;
        }
        if(flag1){
            cout<<"ERR"<<endl;
        }
        else if(ans==w){
            cout<<"Yes"<<endl;
        }
        else{
            cout<<"No"<<endl;
        }
    }
    return 0;
}