判断出栈队列的正确与否

告诉你一个入栈队列和一个出栈队列，当然这一个队列里边不容许出现一样的数，判断这个出栈队列是不是合理的出站队列。。。

比如说告诉你一个入栈队列，1 2 3 4 5 6，当然这个不一定是这样单调递增的，还告诉你一个出站队列1 2 5 6 4 3，结果是yes，

但是如果告诉的入栈队列是1 2 3 4 5 6，出站队列是4 3 6 1 2 5那是不可能有这样的出站队列的，所以输出no。

#include<iostream>
#include<stack>
#include<cstdio>
using namespace std;
bool solve(int a[],int b[],int n){
    //a数组是出栈队列，b数组是入栈队列，n是a和b的数组大小
    int ok=false;
    if(!n)return ok;
    int i=0,j=0;
    stack<int> s;
    while(j<n){
        while(i<n&&b[i]!=a[j]){
            s.push(b[i]);i++;
        }
        i++;j++;
        while(!s.empty()&&j<n){
            int top = 0;
            top=s.top();
            s.pop();
            if (top == a[j]) {
j++;
            } else {
                s.push(top);
break;
}
        }
        if(i>=n&&s.empty()){ok=true;return ok;}
    }
//    while(i<n){//猪似的这部分是只适用于b数组（入栈队列）是单调递增的，这个是自己写的！！！
//        while(j<n&&a[i]>b[j]){
//                s.push(b[j]);
//                j++;
//        }
//        if(a[i]>b[j])return false;
//        while(a[i]==b[j]&&j<n){i++;j++;}
//        if(j==n){
//                if(i<n)
//            {
//                while(!s.empty()){
//                int t=s.top();
//                if(t!=a[i++])return false;
//                s.pop();
//            }
//            return true;
//            }
//            else{
//                if(!s.empty())return false;
//                else return true;
//            }
//        }
//        if(a[i]<b[j])
//        {
//            if(!s.empty())
//            {
//                int t=s.top();
//            if(t!=a[i])return false;
//            s.pop();
//            i++;
//            }
//            else return false;
//        }
//    }
//    if(j<n)return false;
//    if(!s.empty())return false;
    return ok;
}
int a[1010],b[1010],n;
int main(){
while(~scanf("%d",&n))
{
    for(int i=0;i<n;i++)scanf("%d",&a[i]);
    for(int i=0;i<n;i++)b[i]=i+1;
    if(solve(a,b,n)) cout<<"Yes"<<endl;
    else cout<<"No"<<endl;
}
}