13 solutions

  • 5
    @ 2022-1-2 22:47:28

    这题挺有趣的,思路就是先让A轨的挨个入栈(C),同时进来一节你就告诉轨道管理员该出哪节车厢,轨道管理员先看到进来的不是这节就会等,但也会记住你后面讲的顺序,等管理员看到第一节了,他就先放这节去B,然后检查留在C的最外面那节是不是第二个该出栈的,如果是就让他出去,继续检查下一个,如果不是就算了,等看到了再说。等车厢进完了,管理员再检查最后一次留在栈里的能不能按顺序出去,如果能,管理员知道你没有耍他,就会拍拍你的肩膀说一句YES,如果他发现不能按顺序出完就知道你在耍他,把你暴打一顿,打你的时候你大喊NO!!!!!!

    #include<stdio.h>
    #include<stack>
    using namespace std;
    const int N=1e5+7;
    int b[N];//可以用i来代替A轨,就不用另开
    stack <int> s;//C轨
    int main(){
    	int n;
    	scanf("%d",&n);
    	int t=1;//计数器,作用是看出到第几节了
    	for(int i=1;i<=n;i++){  //i就是A轨
    		scanf("%d",&b[i]);  //告诉管理员按顺序出哪节
    		while(!s.empty()&&s.top()==b[t]){  //管理员检查留在C的能不能出,如果能,就帮他出个柜
    			s.pop();
    			t++;
    		}
    		if(b[t]!=i)s.push(i);//如果不是管理员所期待的那一节,他会把这节狠狠地按进C柜里
    		if(b[t]==i)t++;//终于等到你,还好我没放弃
    		
    	}
    	while(!s.empty()){  //最后帮尔等出个柜,希望不要不识好歹
    		if(s.top()==b[t]){
    		t++;
    		s.pop();
    		}
    		else break;
    	}
    	if(s.empty())printf("That's ♂ good!");//来自管理的夸奖(doge)
    	else printf("NO!!!!!!");//来自管理的爱抚(doge)
    	return 0;
    }
    
  • 2
    @ 2022-4-2 10:41:33

    这题 真的很好,我被 题目 的意思 给卡住了。读了半天 都没太理解什么意思。看了下 其他人的 题解,发现 原来 C 站 是要 先进后出好像。那就简单多了,无非就是 在 A 轨道 选择一下数,看下 有没有,如果没有对应上的,那就 去 看看 C 站 里 有没有,如果 俩者 都不行,那算了,那就把这个数字 放到 C 站立就行了。

    依次 选择数字下去,如果 能够 凑出 给定的顺序 就是 YES,如果凑不出,那就是 NO。

    #define _CRT_SECURE_NO_WARNINGS
    
    #include <iostream>
    #include <stack>
    
    using namespace std;
    
    const int N = 1e5 + 7;
    
    int B[N];// 我们给的顺序 也是 最后 B 轨道 应该的顺序
    
    int main(void) {
    	// 从 A 方向 来的火车 进入 C 车站之前 都不是 连接着的。
    	// 这些火车 可以 自行 移动到 B 处 的 铁轨
    	// C 车站 可以 随意 停放 多节车厢
    	// 进入到了 C 车站后,就不能 再回到 A 方向的铁轨
    	// 进入了 B 方向 铁轨 也不能再回到 车站 C
    	// 从 C 车站到 B 的,必须 按照 先进后出的 顺序 !!!
    
    
    	//最终目的 是 使其 a1 a2 a3 的顺序 从 B 方向驶出。这个 顺序 是我们指定的
    	int n;
    	cin >> n;
    
    	for (int i = 0; i < n; ++i) {
    		cin >> B[i];
    	}
    	int sub = 0;// 
    	stack<int> s;
    	// 先从 A 轨道 选 车厢
    	for (int i = 1; i <= n; ++i) {
    		while (!s.empty() && s.top() == B[sub]) {// 可能 C 车站里 有车厢 可以选
    			sub++;
    			s.pop();
    		}
    		if (i == B[sub]) {// 则 满足 条件,
    			sub++;// 证明 从 A 直接 到 B 就行,然后 下一个 位置的 数字需要 进行判断
    		}
    		else {
    			s.push(i);// 不能选的话,那就放到 C 车站里
    		}
    	}
    
    	bool flag = true;// 默认是可以 实现目的的
    
    	while (!s.empty()) {
    		if (s.top() != B[sub]) {
    			flag = false;
    			break;
    		}
    		else {
    			s.pop();
    			sub++;
    		}
    	}
    
    	
    	if (flag) {
    		cout << "YES" << endl;
    	}
    	else {
    		cout << "NO" << endl;
    	}
    
    
    	return 0;
    }
    

    代码 可能 跟 第一位 大佬的题解差不多,但是 根据思路来说,确实 也不会写的 相差多少。反而 是接近一样才对。

    • 2
      @ 2022-1-2 13:03:57

      感觉我代码挺好理解的,不知道有没有bug

      #include <bits/stdc++.h>
      using namespace std;
      int main()
      {
          int n;
          cin>>n;
          stack <int> s;
          int flag=0;
          int k[1007];//开个数组读入需要的序列
          for(int i=0;i<n;i++)
          {
          	scanf("%d",&k[i]);
      	} 
      	for(int i=1;i<=n;i++)
      	{  
      		while(!s.empty()&&s.top()==k[flag])
      		{
      			s.pop();
      			flag++;
      		}
      		s.push(i); 
      	}//中途可以先出车站的就先出去,不能不出的就存下来
      if(!s.empty())
      {	
      	for(int j=flag;j<n;j++)//flag可以记录从车站出去的火车到第几辆了
      	{
      		if(k[j]==s.top()) s.pop();
      		else
      		{
      			break;
      		}
      	}
      }//继续匹配车站中剩下的
      	s.empty()?cout<<"YES":cout<<"NO";//判断
          return 0;
      }
      
      • 1
        @ 2022-1-10 22:22:45

        看懂题意就简单了,以下是不正规写法; 当输入的数为n时,只要保证后面的数顺序减小便成立;

        #include<bits/stdc++.h>
        using namespace std;
        int main()
        {
        	int a[1005];
        	int n,t,count=1,temp=0,flag=0;
        	cin>>n;
        	for(int i=0;i<n;i++){
        		cin>>t;
        		if(temp==1){
        			a[count]=t;
        			count++;
        		}
        		if(t==n)
        		temp=1;
        	}
        	if(count>1){
        		for(int i=0;i<count-1;i++){
        			if(a[i]<a[i+1]){
        				flag=1;
        				break;
        			}
        		}
        	}
        	if(flag==1)
        	cout<<"NO";
        	else if(flag==0||count==1)
        	cout<<"YES";
        	return 0;
        }
        • 1
          @ 2022-1-2 19:56:31
          #include<bits/stdc++.h>
          using namespace std;
          	stack<int> pp;//a栈
          	stack<int> dd;//b栈
          	int n,i[1005];
          int main()
          {
          	cin>>n;
          	for(int c=0;c<n;c++){
          		cin>>i[c];
          		pp.push(n-c);//按顺序将对应车厢压入a栈中
          	}
          	for(int c=0;c<=n;c++){
          		if(c==n){
          			cout<<"YES";
          			return 0;
          		}
          		else if(dd.empty()){
          		while(pp.top()<=i[c]){
          		dd.push(pp.top());
          		pp.pop();
          		if(pp.empty()) break;
          			}
          		dd.pop();//while循环后对于c站栈顶的车厢号就是我们所需要车厢号
          		}else{
          			if(i[c]>dd.top()){
          				if(pp.empty()){
          					cout<<"NO"; //c站栈顶车厢号不为所需车厢号且a站中已无车厢
          					return 0;
          				}
          				if(pp.top()>i[c]){//a站中无所需车厢
          					cout<<"NO";
          					return 0;
          				}else{
          				while(pp.top()<=i[c]){//a站中存在有当前所需的车厢号
          					dd.push(pp.top());
          					pp.pop();
          					if(pp.empty()) break;
          					}
          					dd.pop();//while循环后对于c站栈顶的车厢号就是我们所需要车厢号
          				}
          			}else{
          				if(i[c]==dd.top())dd.pop();		
          				else{ 
          					cout<<"NO";
          					return 0;
          					}
          				}
          			}
          		}
          }
          

          若某栈已为空 再进行top()操作会出现sgmentation fault 的错误

          • @ 2022-1-2 20:05:10

            别看我的 写复杂了

          • @ 2022-1-4 17:56:31

            @ 好谦虚啊锋哥

          • @ 2022-1-4 17:58:01

            @ 啊,是大佬,我死了

        • 1
          @ 2022-1-1 22:16:52

          用一个栈来充当C,用一个数组来充当A,先将需要的顺序进行存储,接着从第一个存储的数开始从未入栈的数列里开始查找,如果等于当前查找的数,或着等于栈顶的数就进行下一次查找,否则就将当前的数压入栈中,如果找不到当前要查找的数就break。注意的是这里的查找是一次性的,意思是会接着上一次查找的位置继续查找,因为那些不匹配的数已经压入栈中了。最后只需要判断是否查找完,没有查找完就是NO,否则是YES。

          #include <bits/stdc++.h>
          using namespace std;
          int w[1007];
          stack<int>s;
          int main(){
          	int n,opt=1,ss=0;//个数,查找的位置,当前查找的数
          	cin>>n;
          	for(int i=1;i<=n;i++){
          		cin>>w[i];
          	}
          	s.push(-1);//先存储一个数,避免当s为空时出问题
          	for(ss=1;ss<=n;ss++){//当前查找的数
          		int k=w[ss];
          		int flag=0; 
          		if(s.top()==k) flag=1,s.pop();//是否在栈顶
          		else{//是否在未入栈的数列里面
          			for(;opt<=n;opt++){
          				if(k==opt){//找到就退出
          					opt++,flag=1;break;
          				}//不是当前要找的数就压入栈中
          				else s.push(opt);
          			}
          		}
          		if(flag==0) break;//判断是否找到
          	}
          	if(ss==n+1) cout<<"YES";
          	else cout<<"NO";
          	return 0;
          }
          • 0
            @ 2022-3-24 11:36:24

            不才,斗胆发一下自己的写法....可能很菜0.0

            #include<bits/stdc++.h>
            #define MAX 1000
            using namespace std;
            
            int  B[MAX];
            int main(){
            stack<int>   c;
            int n;
            cin>>n;
            for(int i=1;i<=n;i++){
            cin>>B[i];
            }
            int j=1;
            int i=1;
            do{
            if(c.empty()==0){
            if(c.top()==B[j]){
            c.pop();
            j++;
            continue;
            }
            }
            if(i<=n){
            c.push(i);
            i++;
            continue;
            }
            if(!c.empty()&&i>n){
            cout<<"NO"<<endl;
            break;
            }
            }while(j<=n);
            if(j>n)   cout<<"YES"<<endl;
            return 0;
            }
            
            • 0
              @ 2022-2-7 23:38:36

              直接利用一个规则 i<j<k a[i]>a[k]>a[j]; 代码 #include #include <math.h> using namespace std; int a[1005]; int main() { int m;cin>>m; for(int i=1;i<=m;++i) { cin>>a[i]; }

              for(int i=1;i<=m;++i)
              {
              	for(int j=i+1;j<=m;++j)
              	if(a[i]>a[j])
              	{
              	for(int k=j+1;k<=m;k++)
              	{
              		if(a[i]>a[k]&&a[j]<a[k])
              		{
              			cout<<"NO";
              			return 0;
              		}
              	}
              		
              	}
              	
              }
              cout<<"YES";
              return 0;
              

              }

              • 0
                @ 2022-1-12 15:45:40

                用栈模拟就完了

                不过这个题目我真的是费了好大力气才读懂,感觉实在是.....

                我这个代码有些复杂,其实有很多可以简化,

                我太懒了就没去搞,有兴趣的可以弄一下

                #include<bits/stdc++.h>
                using namespace std;
                int n,num[1005],ans[1005],cnt;
                int main()
                {
                	std::ios::sync_with_stdio(false);
                	cin>>n;
                	stack<int> st;
                	for(int i=1;i<=n;i++)
                		cin>>num[i];
                	if(num[1]==1)
                		ans[1]=1;
                	for(int i=1,j=1;i<=n;i++)
                	{
                		if(num[i]>=i)//如果指定车厢比目前的数字大 
                		{
                			for(;j<=num[i];j++)//j要从1开始变 
                				st.push(j);
                			if(st.top()==num[i]){
                				st.pop();//出一个栈顶的元素 
                				ans[i]=num[i];
                			}
                			else{
                				cout<<"NO";
                				break;
                			}
                		}
                		if(num[i]<i)//如果指定车厢比目前的数字小 
                		{
                			if(st.empty())//如果栈为空就直接no 
                			{
                				cout<<"NO";
                				break;
                			}
                			
                			if(st.top()==num[i])//如果栈顶是该数字 
                			{
                				ans[i]=num[i];
                				st.pop();//出栈 
                			}
                			else{
                				cout<<"NO";
                				break;
                			} 
                		}
                	}
                	for(int i=1;i<=n;i++)
                	{
                		if(ans[i]==num[i])
                			cnt++;
                	} 
                	if(cnt==n)
                		cout<<"YES";
                	return 0;
                } 
                
                • 0
                  @ 2022-1-2 21:55:15
                  #include<bits/stdc++.h>
                  using namespace std;
                  stack <int> s;
                  int pos[1000000];
                  int main(){
                  	int n;
                  	cin>>n;
                  	for(int i=0;i<n;i++){
                  		cin>>pos[i];
                  	}
                  	int i=0;
                  	for(int j=1;j<=n;j++){
                  		s.push(j);
                  		if(pos[i]==s.top()){
                  			while(!s.empty()){
                  				if(pos[i]==s.top()){
                  					s.pop();
                  					i++;
                  				}
                  				else{
                  					break;
                  				}
                  			}
                  		}
                  	}
                  	if(!s.empty()){
                  		cout<<"NO";
                  	}
                  	else{
                  		cout<<"YES";
                  	}
                  	
                  	return 0;
                  }
                  
                  • 0
                    @ 2022-1-2 17:56:45

                    借鉴了大佬的代码= =,我是蒟蒻 难点在理解题意。 主要思路就是判断是否—————栈中的数比输入的数小

                    #include<bits/stdc++.h>
                    using namespace std;
                    int n,fg,k,countt;
                    int a[1015];
                    stack<int> s;
                    int main()
                    {
                    	cin>>n;
                    	for(int i=1;i<=n;++i)
                    	{
                    		cin>>a[i];
                    	}
                    	countt=1;//记录有多少数进栈 
                    	for(int i=1;i<=n;++i)
                    	{
                    		k=a[i];
                    		while(countt<=k)//小于a[i]的数必须在栈中 (难点)
                    		{
                    			s.push(countt);//依次进栈   
                    			countt++;
                    		}
                    		if(s.top()!=a[i])// 大数,一定可以出栈 
                    		{                // 小于k的数, 必须从大到小依次出栈, 否则就不符合 
                    			cout<<"NO";
                    			return 0;
                    		}
                    		s.pop();//符合要求a[i]就出栈 到B 
                    	}
                    	cout<<"YES";
                    	return 0;
                     } 
                    
                    
                    • 0
                      @ 2022-1-2 17:11:51
                      #include<stdio.h>
                      #include<stack>
                      #include <vector>
                      #include<iostream>
                      #include<string.h>
                      using namespace std;
                      int main()
                      {
                          int num;
                          int s1[100];
                          int s2[100];
                          	scanf("%d",&num);
                          	stack<int> train;
                              vector<int> member;
                              int j = 0;
                              for(int i = 0;i<num;i++){
                              	scanf("%d",&s2[i]);
                      		}
                              for(int i = 0;i<num;i++){
                              	s1[i] = (i+1);
                      		}
                              for(int k = 0;k < num;k++)
                              {
                              	train.push(s1[k]);
                              	member.push_back(1);
                              	while(!train.empty()&&train.top() == s2[j])
                              	{
                              		member.push_back(0);
                              		train.pop();
                              		j++;
                      			}
                      		}
                      		if(train.size()==0){
                      			printf("YES\n");
                      		}
                      		else
                      		{
                      			printf("NO\n");
                      		}
                      		memset(s1,0,sizeof(s1)); 
                      		memset(s2,0,sizeof(s2)); 
                      	return 0;
                       } 
                      
                      • 0
                        @ 2022-1-2 12:03:37

                        写的有点复杂,开了三个栈

                        #include<bits/stdc++.h>
                        using namespace std; 
                        stack <int> a;
                        stack <int> b;
                        stack <int> c;
                        int main(){
                         int n,en[1005],be[1005];
                         cin>>n;
                         for(int i=1;i<=n;i++){
                         	be[i]=i;//将开始的火车存入be数组 
                         }
                         for(int i=1;i<=n;i++){
                         	cin>>en[i];
                         	a.push(en[i]);//将最终的火车压入栈a 
                         }
                         int j=1;//查找开始火车,一节一节查找 
                          	for(int i=1;i<=n;i++){
                          	if(en[j]==be[i]){//相等直接压入 
                          		b.push(be[i]); 
                          		j++;
                          	}
                         		else if(!c.empty()&&en[j]==c.top()){//查找是否与c站压顶相等 
                          		b.push(c.top());				//一定要判断c栈为空,害我改了一小时,我是fw 
                          		c.pop();
                          		j++;
                          		i--;
                          	}
                          	else{
                          		c.push(be[i]);
                          }
                          }
                          while(!c.empty()){//将c栈中的数压入b栈 
                          	b.push(c.top());
                          	c.pop();
                          }
                          if(a==b) cout<<"YES";//判断 
                          else cout<<"NO";
                          return 0;
                        }
                        
                        • 1

                        Information

                        ID
                        291
                        Time
                        1000ms
                        Memory
                        128MiB
                        Difficulty
                        6
                        Tags
                        # Submissions
                        139
                        Accepted
                        44
                        Uploaded By