Basic Data Structure

最新推荐文章于 2019-12-13 12:28:33 发布
最新推荐文章于 2019-12-13 12:28:33 发布
阅读量182 收藏
点赞数
分类专栏： 模拟
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37605573/article/details/78379425
版权

Basic Data Structure

Time Limit: 7000/3500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 2782    Accepted Submission(s): 603


Problem Description
Mr. Frog learned a basic data structure recently, which is called stack.There are some basic operations of stack：

∙ PUSH x： put x on the top of the stack, x must be 0 or 1.
∙ POP： throw the element which is on the top of the stack.

Since it is too simple for Mr. Frog, a famous mathematician who can prove "Five points coexist with a circle" easily, he comes up with some exciting operations：

∙ REVERSE： Just reverse the stack, the bottom element becomes the top element of the stack, and the element just above the bottom element becomes the element just below the top elements... and so on.
∙ QUERY： Print the value which is obtained with such way： Take the element from top to bottom, then do NAND operation one by one from left to right, i.e. If   atop,atop−1,⋯,a1 is corresponding to the element of the Stack from top to the bottom, value=atop nand atop−1 nand ... nand a1 . Note that the Stack will not change after QUERY operation. Specially, if the Stack is empty now，you need to print ”Invalid.”(without quotes).

By the way, NAND is a basic binary operation：

∙ 0 nand 0 = 1
∙ 0 nand 1 = 1
∙ 1 nand 0 = 1
∙ 1 nand 1 = 0

Because Mr. Frog needs to do some tiny contributions now, you should help him finish this data structure： print the answer to each QUERY, or tell him that is invalid.
 

Input
The first line contains only one integer T ( T≤20 ), which indicates the number of test cases.

For each test case, the first line contains only one integers N ( 2≤N≤200000 ), indicating the number of operations.

In the following N lines, the i-th line contains one of these operations below：

∙ PUSH x (x must be 0 or 1)
∙ POP
∙ REVERSE
∙ QUERY

It is guaranteed that the current stack will not be empty while doing POP operation.
 

Output
For each test case, first output one line "Case #x：w, where x is the case number (starting from 1). Then several lines follow,  i-th line contains an integer indicating the answer to the i-th QUERY operation. Specially, if the i-th QUERY is invalid, just print "Invalid."(without quotes). (Please see the sample for more details.)
 

Sample Input 
  
  

   
   2
8
PUSH 1
QUERY
PUSH 0
REVERSE
QUERY
POP
POP
QUERY
3
PUSH 0
REVERSE
QUERY
 

Sample Output 
  
  

   
   Case #1:
1
1
Invalid.
Case #2:
0

   
   

    
    

     
     Hint
    
    

    
    
In the first sample： during the first query, the stack contains only one element 1, so the answer is 1. then in the second query, the stack contains 0, l
(from bottom to top), so the answer to the second is also 1. In the third query, there is no element in the stack, so you should output Invalid.



模拟题，调了好长时间。。。。。。。。。


通过真值表我们很快就能发现规律,若栈头元素是0，栈中只有一个元素，则值为0，否则为1；

若栈头元素是1，如果栈中没有0，则根据栈中1的个数判断，若个数是奇数则为1，为偶数是0，否则，找到与栈头最近元素是0的位置，若该位置是栈尾位置，则根据栈尾到栈头之间的1的个数来判断，若个数是奇数则为1，为偶数是0，其他，根据栈尾到栈头之间的1的个数+1来判断，若个数是奇数则为1，为偶数是0


代码如下：

#include<stdio.h>
#include<string>
#include<string.h>
#include<iostream>
using namespace std;
const int N=6000000+6;
int a[N];
int o[N];
int main()
{
    char s[30];
    int t,count=0;
    int n,m;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        int et;
        int st=et=3000000;
        int st1,et1;
        st1=et1=3000000;
        int flag=0;
        printf("Case #%d:\n",++count);
        int ans;
        while(n--)
        {
            scanf("%s",s);
            if(strcmp(s,"PUSH")==0)
            {
                scanf("%d",&m);
                if(flag==0)
                {
                    a[et++]=m;
                    if(m==0)
                        o[et1++]=et-1;
                }
                else
                {
                    a[--st]=m;
                    if(m==0)
                        o[--st1]=st;
                }
            }
            else if(strcmp(s,"QUERY")==0)
            {
                if(st==et)
                    printf("Invalid.\n");
                else
                {
                    if(!flag)
                    {
                        if(a[st]==0)
                        {
                            if(et-st==1)
                            {
                                ans=0;
                                printf("%d\n",ans);
                            }
                            else
                            {
                                ans=1;
                                printf("%d\n",ans);
                            }
                        }
                        else
                        {
                            if(st1==et1)
                            {
                                int m=et-st;
                                if(m%2==0)
                                    ans=0;
                                else
                                    ans=1;
                                printf("%d\n",ans);
                            }
                            else
                            {
                                int x=o[st1],m;//m 1
                                if(x==et-1)
                                    m=x-st;
                                else
                                    m=x-st+1;
                                if(m%2==0)
                                    ans=0;
                                else
                                    ans=1;
                                printf("%d\n",ans);
                            }

                        }
                    }
                    else
                    {
                        if(a[et-1]==0)
                        {
                            if(et-st==1)
                            {
                                ans=0;
                                printf("%d\n",ans);
                            }
                            else
                            {
                                ans=1;
                                printf("%d\n",ans);
                            }
                        }
                        else
                        {
                            if(st1==et1)
                            {
                                int m=et-st;
                                if(m%2==0)
                                    ans=0;
                                else
                                    ans=1;
                                printf("%d\n",ans);
                            }
                            else
                            {

                                int x=o[et1-1],m;//m 1
                                if(x==st)
                                    m=et-x-1;
                                else
                                    m=et-x;
                                if(m%2==0)
                                    ans=0;
                                else
                                    ans=1;
                                printf("%d\n",ans);
                            }
                        }

                    }

                }
            }
            else if(strcmp(s,"REVERSE")==0)
                if(flag==1)
                    flag=0;
                else
                    flag=1;
            else if(strcmp(s,"POP")==0)
            {
                if(st!=et)
                {
                    if(!flag)
                    {
                        if(o[et1-1]>=et-1)
                            et1--;
                        et--;
                    }
                    else
                    {
                        if(o[st1]<=st)
                           st1++;
                        st++;
                    }
                }
            }
        }
    }
    return 0;
}

简化代码： 

#include<stdio.h>
#include<string>
#include<string.h>
#include<iostream>
using namespace std;
const int N=600000+6;
int a[N];
int o[N];
int main()
{
    char s[30];
    int t,count=0;
    int n,m;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        int et=300000;
        int st=300000-1;
        int et1=300000;
        int st1=300000-1;
        int flag=0;
        printf("Case #%d:\n",++count);
        int len=0,le=0;
        int ans;
        while(n--)
        {
            scanf("%s",s);
            if(strcmp(s,"PUSH")==0)
            {
                scanf("%d",&m);
                if(flag==0)
                {
                    a[et++]=m;
                    if(m==0)
                        o[et1++]=et-1,le++;
                }
                else
                {
                    a[st--]=m;
                    if(m==0)
                        o[st1--]=st+1,le++;
                }
                len++;
            }
            else if(strcmp(s,"QUERY")==0)
            {
                if(st+1==et)
                    printf("Invalid.\n");
                else if(le<=0)
                    printf("%d\n",len%2);
                   else if(!flag)
                {
                    int sl=o[st1+1];
                    if(sl==et-1)
                        printf("%d\n",(sl-st+1)%2);
                    else  printf("%d\n",(sl-st)%2);
                }
                else
                {
                    int sr=o[et1-1];
                    if(sr==st+1)
                        printf("%d\n",(et-sr+1)%2);
                    else printf("%d\n",(et-sr)%2);
                }
            }
            else if(strcmp(s,"REVERSE")==0)
                flag^=1;
            else if(strcmp(s,"POP")==0)
            {
                if(st!=et)
                {
                    if(!flag)
                    {
                        if(a[et-1]==0)
                            et1--,le--;
                        et--;
                    }
                    else
                    {
                        if(a[st+1]==0)
                            st1++,le--;
                        st++;
                    }
                }
                len--;
            }
        }
    }
    return 0;
}


Jade1998
关注
专栏目录
ADaM---Analyis Data Model implementation Guide V1.3
weixin_44642820的博客
07-16 1144
根据这个rule代表会有多个组行，其中每个组行对应的基线的特定定义需要BASETYPE列，与每行中的BASE的值相对应。
CDISC的ADaMIG (V1.2) 中英文对照【3】_第三章（下） 标准ADaM变量
PTDCDISC的博客
08-25 3568
本AdaMIG (v1.2)来自CDISC官网以下链接： https://www.cdisc.org/standards/foundational/adam/adam-implementation-guide-v1-2-release-package 第3章（下） （第3章拆分为上下2部分，因字数太多，被限制发表。） 3.3.3 Timing Variables for BDS Datasets Any SDTM timing variables (including, but not li.
Basic Data Structurek（模拟，双向队列）
spark__s的博客
10-06 1201
Basic Data Structure Time Limit: 7000/3500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 260    Accepted Submission(s): 62 Problem Description Mr. Frog
hdu 5929 Basic Data Structure
weixin_33766168的博客
10-06 104
ゲート 分析： 这题看出来的地方就是这个NAND是左结合的，不适用结合律，交换律。 所以想每次维护答案就不怎么可能了。比赛的时候一开始看成了异或，重读一遍题目了以后就一直去想了怎么维护答案。。。。。。 但是很容易看出来0是置1， 1是取反。于是维护一下最左边以及最右边的0的位置就可以了。要注意一下特殊情况，只有一个0是0，只有一个1是1。 剩下的就是用一个数组模拟栈，...
HDU 5929 Basic Data Structure 【模拟】 （2016CCPC东北地区大学生程序设计竞赛）
Coolxxx的博客
10-21 530
Basic Data Structure Time Limit: 7000/3500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 872    Accepted Submission(s): 236 Problem Description Mr.
Swift Data Structure and Algorithms [2016]
12-08
Swift Data Structure and Algorithms by Erik Azar English | 18 Nov. 2016 | ISBN: 1785884506 | 286 Pages | AZW3/MOBI/EPUB/PDF (conv) | 22.7 MB Master the most common algorithms and data structures, and...
basic-knowledge-of-data-structure.rar_Knowledge_kmp p_线性表
09-22
本知识库“basic-knowledge-of-data-structure.rar”包含了数据结构的基本入门教程，共计33个PPT，涵盖了多个关键主题。下面我们将深入探讨其中的重点——线性表以及KMP算法。 线性表是最基础的数据结构之一，它是...
HDU 2217 Data Structure?
qq_18661257的专栏
06-12 868
C - Data Structure? Time Limit:5000MS     Memory Limit:65536KB     64bit IO Format:%I64d & %I64u Submit Status Practice HDU 4217 Description Data structure is one of the basic skills
Basic data structure
qq_39442472的博客
12-13 152
扎实的R数据结构，语法，算法以及程序包的熟练使用对于其在生信，金融，大数据挖掘等领域是举足轻重的地位。稳定的发挥R的全部功能是极其必要的，对于一个复杂的实际应用项目。而各个功能的实现则取决于对R丰富的程序包和社区应用的恰当使用。因此，R语言的数据结构，对数据类型的操作应当吹毛求疵，不遗余力。
hdu5929Basic Data Structure
Fsss
10-06 1469
链接：http://acm.hdu.edu.cn/showproblem.php?pid=5929 题意：要求模拟一个存入0,1的栈，有4个操作1：push a，在栈顶插入a。2：pop，删除栈顶。3：reverse，将这个栈翻转一下。4：query，询问栈顶到栈底的atop nand atop-1 nand ... a1。 分析：前3个操作都很容易实现，唯一的难度就是快速就是这个答案。我们会
Basic Data Structure（弱校联盟十一专场）
peach_yang的博客
10-06 331
Question：题目详情(http://acm.hdu.edu.cn/contests/contest_showproblem.php?pid=1008&cid=729) 题目大意：有一个栈有四个操作∙ PUSH x (x must be 0 or 1) ∙ POP(弹出栈顶元素） . REVERSE（ 置逆） ∙ QUERY（根据与非的出最终答案） 与非：0~1->1;0~0-
【HDU - 5929】 Basic Data Structure 【双向链表+模拟】
lzs_lazy
11-08 225
Mr. Frog learned a basic data structure recently, which is called stack.There are some basic operations of stack： ∙∙ PUSH x： put x on the top of the stack, x must be 0 or 1. ∙∙ POP： throw the element
hdu 5929 Basic Data Structure（找规律，模拟）
HARD_UNDERSTAND
10-06 1436
题目：http://acm.hdu.edu.cn/showproblem.php?pid=5929 题意： 维护一个栈，支持往栈里塞 0/1 ，弹栈顶，翻转栈，询问从栈顶到栈底按顺序 NAND 的值。 分析： 【题解】只要知道最后的 000 后面 111 的个数的奇偶性就行。可以用链表把所有 000 的位置存下来。 思路基本和题解一样，都是先把0的位置保存起来，然后做相应的判断
H - Basic Data Structure HDU - 5929（思维+模拟+双端队列）
DeathYmz的博客
10-03 342
H - Basic Data Structure HDU - 5929 分类：思维+模拟+双端队列 题意：给四个操作，push，pop，反转，查询。push放在栈的顶端，pop是弹出栈顶元素，反转是将栈的元素反转，查询从栈顶第一个数开始和后面一个数判断0 1=1，0 0=1，1 0=1，输出最后的答案。 思路：1、直接判断队尾的最后一个数，如果是0，直接输出1。如果是1，判断队尾第一0的位置...
HDU 5929 Basic Data Structure 双向队列
DlPF_C的博客
07-19 214
Mr. Frog learned a basic data structure recently, which is called stack.There are some basic operations of stack：  ∙∙ PUSH x： put x on the top of the stack, x must be 0 or 1.  ∙∙ POP： throw the elemen...
C#实用数据结构与算法教程：从基础到高级
他的背景使他能够以易于理解的方式讲解这些概念，他的其他著作，如《使用Visual Basic.NET进行面向对象编程》和《使用Visual Basic.NET实现数据结构和算法》，也表明他在编程教学方面有深厚的经验。 通过阅读《C# ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值