洛谷 1155 (NOIp2008)双栈排序——仔细分析不合法的条件

最新推荐文章于 2024-11-08 15:35:46 发布
最新推荐文章于 2024-11-08 15:35:46 发布
阅读量95 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/Narh/p/9213825.html
版权

题目：https://www.luogu.org/problemnew/show/P1155

这道题教会我们要多思考。

好好分析过后发现同一个栈里不能有升序。就用它写了一个30分。

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=1005;
int n,stack[2][N],top[2],nw,tot,ps[N];
char ch[N<<1];
bool flag;
int main()
{
    scanf("%d",&n);int x;nw=1;
    stack[0][0]=stack[1][0]=n+1;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&x);
        if(stack[0][top[0]]>x){
            stack[0][++top[0]]=x;
            ch[++tot]='a';ps[x]=1;
        }
        else if(stack[1][top[1]]>x){
            stack[1][++top[1]]=x;
            ch[++tot]='c';ps[x]=2;
        }
        else {
            flag=1;break;
        }
        while(ps[nw])
        {
            if(ps[nw]==1){
                top[0]--;ch[++tot]='b';
            }
            else{
                top[1]--;ch[++tot]='d';
            }
            nw++;
        }
    }
    if(flag)printf("0");
    else for(int i=1;i<=tot;i++)printf("%c ",ch[i]);
    return 0;
}
View Code

然后发现只有30分。想想自己想得太简单了。于是写了个深搜30分。

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=1005;
int n,stack[2][N],top[2],tot,ps[N],a[N];
char ch[N<<1];
bool flag;
void rd(int x,int k)
{
    stack[k][++top[k]]=x;ch[++tot]=(k?'c':'a');ps[x]=k+1;
//    printf("stack%d=%d(top[k]=%d)\n",k,stack[k][top[k]],top[k]);
}
void clr(int x,int k)
{
    top[k]--;tot--;ps[x]=0;
}
void cd(int &nw)
{
//    printf("cd!\n");
    while(ps[nw])
    {
        if(ps[nw]==1){
            top[0]--;ch[++tot]='b';
        }
        else{
            top[1]--;ch[++tot]='d';
        }
        nw++;
    }
}
void dfs(int cr,int nw)
{
    if(cr>n)return;
    int x=a[cr],tnw=nw;bool cflag=0;
    int tsk[2][N];memcpy(tsk,stack,sizeof stack);
    if(stack[0][top[0]]>x&&stack[1][top[1]]<x)
    {
        rd(x,0);
        if(ps[nw])cflag=1,cd(nw);
//        printf("cr=%d 0\n",cr);
        dfs(cr+1,nw);
        if(flag){
            if(cflag){
                tot-=nw-tnw;top[0]+=nw-tnw;nw=tnw;
                memcpy(stack,tsk,sizeof tsk);
            }
            clr(x,0);
//            printf("ret cr=%d flag=1\n",cr);
        }
    }
    else if(stack[1][top[1]]>x&&stack[0][top[0]]<x)
    {
        rd(x,1);
        if(ps[nw])cflag=1,cd(nw);
//        printf("cr=%d 1\n",cr);
        dfs(cr+1,nw);
        if(flag){
            if(cflag){
                tot-=nw-tnw;top[1]+=nw-tnw;nw=tnw;
                memcpy(stack,tsk,sizeof tsk);
            }
            clr(x,1);
//            printf("ret cr=%d flag=1\n",cr);
        }
    }
    else if(stack[1][top[1]]<x&&stack[0][top[0]]<x)
    {
//        printf("cr=%d flag=1!\n",cr);
        flag=1;return;
    }
    else{
//        printf("stack0=%d stack1=%d(top0=%d top1=%d)\n",stack[0][top[0]],stack[1][top[1]],top[0],top[1]);
        rd(x,0);
        if(ps[nw])cflag=1,cd(nw);
//        printf("cr=%d try0\n",cr);
        dfs(cr+1,nw);
        if(flag){
            if(cflag){
                tot-=nw-tnw;top[0]+=nw-tnw;nw=tnw;
                memcpy(stack,tsk,sizeof tsk);
            }
            clr(x,0);
//            printf("cr=%d failtry0 try1\n",cr);
            flag=0;cflag=0;rd(x,1);
            if(ps[nw])cflag=1,cd(nw);
            dfs(cr+1,nw);
            if(flag){
                if(cflag){
                    tot-=nw-tnw;top[1]+=nw-tnw;nw=tnw;
                    memcpy(stack,tsk,sizeof tsk);
                }
                clr(x,1);
//                printf("cr=%d failtry1\n",cr);
            }
        }
    }
}
int main()
{
    scanf("%d",&n);int x;
    stack[0][0]=stack[1][0]=n+1;
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    dfs(1,1);
    if(flag)printf("0");
    else for(int i=1;i<=tot;i++)printf("%c ",ch[i]);
    return 0;
}
View Code

然后发现只有30分。那就剪剪枝吧。

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=1005;
int n,stack[2][N],top[2],tot,ps[N],a[N];
char ch[N<<1];
bool flag;
void rd(int x,int k)
{
    stack[k][++top[k]]=x;ch[++tot]=(k?'c':'a');ps[x]=k+1;
//    printf("stack%d=%d(top[k]=%d)\n",k,stack[k][top[k]],top[k]);
}
void clr(int x,int k)
{
    top[k]--;tot--;ps[x]=0;
}
void cd(int &nw)
{
//    printf("cd!\n");
    while(ps[nw])
    {
        if(ps[nw]==1){
            top[0]--;ch[++tot]='b';
        }
        else{
            top[1]--;ch[++tot]='d';
        }
        nw++;
    }
}
bool check(int cr,int x)
{
    int i;
    for(i=cr+1;i<=n;i++)if(a[i]>a[cr]&&a[i]>x)break;
    for(int j=i+1;j<=n;j++)if(a[j]<a[cr])return 0;//导致在j之前cr不能弹出 
    return 1;
}
void dfs(int cr,int nw)
{
    if(cr>n)return;
    int x=a[cr],tnw=nw;bool cflag=0;
    int tsk[2][N];memcpy(tsk,stack,sizeof stack);
    if(stack[0][top[0]]>x&&stack[1][top[1]]<x)
    {
        rd(x,0);
        if(ps[nw])cflag=1,cd(nw);
//        printf("cr=%d 0\n",cr);
        dfs(cr+1,nw);
        if(flag){
            if(cflag){
                tot-=nw-tnw;top[0]+=nw-tnw;nw=tnw;
                memcpy(stack,tsk,sizeof tsk);cflag=0;
            }
            clr(x,0);
//            printf("ret cr=%d flag=1\n",cr);
        }
    }
    else if(stack[1][top[1]]>x&&stack[0][top[0]]<x)
    {
        rd(x,1);
        if(ps[nw])cflag=1,cd(nw);
//        printf("cr=%d 1\n",cr);
        dfs(cr+1,nw);
        if(flag){
            if(cflag){
                tot-=nw-tnw;top[1]+=nw-tnw;nw=tnw;
                memcpy(stack,tsk,sizeof tsk);cflag=0;
            }
            clr(x,1);
//            printf("ret cr=%d flag=1\n",cr);
        }
    }
    else if(stack[1][top[1]]<x&&stack[0][top[0]]<x)
    {
//        printf("cr=%d flag=1!\n",cr);
        flag=1;return;
    }
    else{
//        printf("stack0=%d stack1=%d(top0=%d top1=%d)\n",stack[0][top[0]],stack[1][top[1]],top[0],top[1]);
        if(check(cr,stack[1][top[1]]))
        {
            rd(x,0);
            if(ps[nw])cflag=1,cd(nw);
//            printf("cr=%d try0\n",cr);
            dfs(cr+1,nw);
            if(flag){
                if(cflag){
                    tot-=nw-tnw;top[0]+=nw-tnw;nw=tnw;
                    memcpy(stack,tsk,sizeof tsk);cflag=0;
                }
                clr(x,0);
            }
        }
        if(flag&&check(cr,stack[0][top[0]]))
        {
            flag=0;rd(x,1);
            if(ps[nw])cflag=1,cd(nw);
            dfs(cr+1,nw);
            if(flag){
                if(cflag){
                    tot-=nw-tnw;top[1]+=nw-tnw;nw=tnw;
                    memcpy(stack,tsk,sizeof tsk);cflag=0;
                }
                clr(x,1);
//                printf("cr=%d failtry1\n",cr);
            }
        }
        if(flag||(!check(cr,stack[0][top[0]])&&!check(cr,stack[1][top[1]])))flag=1;
    }
}
int main()
{
    scanf("%d",&n);int x;
    stack[0][0]=stack[1][0]=n+1;
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    dfs(1,1);
    if(flag)printf("0");
    else for(int i=1;i<=tot;i++)printf("%c ",ch[i]);
    return 0;
}
View Code

然后发现只有30分。而且T1WA6。

在写搜索之前看了看TJ，体现在最后那个check里。就是如果a[1],a[2],a[3]满足a[2]>a[1],a[3]<a[1]的话，在a[3]来之前a[1]不能出栈，就被堵在了a[2]后面，从而GG。

但是这竟然就是唯一的GG条件！需要仔细思考。

这个性质和自己开始分析出来的浅显性质的不同之处：

1.自己的那个只有在过程中才能判断，因为一开始有升序，也可能前面小的先出栈，后面大的再进来。

　　而正解的想法是把这个不确定因素也分析掉，得出如果在这个大的后面又有一个比最前面的更小的，就真的不行了。

　　　　这样就能不在过程中判断而可以预先判断了。

2.自己对“两个栈”认识不足。明明可以把它看成一个主栈和一个辅助栈，用上一条判断出不能往主栈放就放在辅助栈里，可自己……

　　没错，正解这样想的话就可以只关注元素能不能放在同一个栈中。然后想到只有两个栈，于是二分图染色就有了。

因为判掉了无解，所以最后的模拟可以开放又随便。

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=1005;
int n,a[N],head[N],xnt,col[N],ps[N],now,f[N];
bool flag;
struct Edge{
    int next,to;
    Edge(int n=0,int t=0):next(n),to(t) {}
}edge[N*N];
void add(int x,int y)
{
    edge[++xnt]=Edge(head[x],y);head[x]=xnt;
    edge[++xnt]=Edge(head[y],x);head[y]=xnt;
}
void init()
{
    f[n]=n+1;
    for(int i=n-1;i;i--)
    {
        f[i]=min(f[i+1],a[i+1]);
        for(int j=i+1;j<=n;j++)
            if(a[j]>a[i]&&f[j]<a[i])add(i,j);
    }
}
void dfs(int cr)
{
    for(int i=head[cr],v;i;i=edge[i].next)
    {
        if(col[v=edge[i].to]==col[cr])
            {flag=1;return;}
        else if(!col[v])col[v]=(col[cr]^1),dfs(v);
        if(flag)return;
    }
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)scanf("%d",&a[i]);
    init();
    for(int i=1;i<=n;i++) if(!col[i])
    {
        col[i]=2;dfs(i);if(flag)break;
    }
    if(flag){
        printf("0");return 0;
    }
    now=1;
    for(int i=1;i<=n;i++)
    {
        ps[a[i]]=col[i];
        if(col[i]==2)printf("a ");
        else printf("c ");
        while(ps[now]){
            if(ps[now++]==2)printf("b ");
            else printf("d ");
        }
    }
    return 0;
}
View Code

从代码的col和ps可以看出二分图染色和最后的模拟有一定程度的重复。其实可以大胆地直接模拟就行了。

（此方法源自洛谷用户cmd2001。在洛谷题解的第2页可以看到。）

#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int N=1005;
int n,r[N],ct,now,a[N],ta,b[N],tb,tot;
char ch[N<<1];
bool flag;
bool check(int cr)
{
    int i;
    for(i=cr+1;i<=n;i++)if(r[i]>r[cr]&&r[i]>b[tb])break;
    for(int j=i+1;j<=n;j++)if(r[j]<r[cr])return 0;
    return 1;
}
int main()
{
    scanf("%d",&n);int lm=(n<<1);now=1;ct=1;
    for(int i=1;i<=n;i++)scanf("%d",&r[i]);
    a[0]=b[0]=n+1;
    for(int i=1;i<=lm;i++)
    {
        if(a[ta]==now)
        {
            ch[++tot]='b';ta--;now++;
            continue;
        }
        if(b[tb]==now)
        {
            ch[++tot]='d';tb--;now++;
            continue;
        }
        if(ct<=n&&r[ct]<a[ta]&&check(ct))
        {
            a[++ta]=r[ct++];ch[++tot]='a';
            continue;
        }
        if(ct<=n&&r[ct]<b[tb])
        {
            b[++tb]=r[ct++];ch[++tot]='c';
            continue;
        }
        flag=1;break;
    }
    if(flag)printf("0");
    else for(int i=1;i<=lm;i++)printf("%c ",ch[i]);
    return 0;
}
View Code

这道题教会我们要好好分析性质。别只分析出一个浅显的了！

转载于:https://www.cnblogs.com/Narh/p/9213825.html

weixin_34259159
关注
BZOJ2080 POI2010 Railway & NOIP2008 双栈排序
Kanosword的博客
09-26 1874
BZOJ2080 POI2010 Railway & NOIP2008 双栈排序
NOIP 双栈排序（贪心算法）
qq_41493339的博客
02-26 698
题目描述 Tom最近在研究一个有趣的排序问题。如图所示，通过2个栈S1和S2，Tom希望借助以下4种操作实现将输入序列升序排序。 操作a 如果输入序列不为空，将第一个元素压入栈S1 操作b 如果栈S1不为空，将S1栈顶元素弹出至输出序列 操作c 如果输入序列不为空，将第一个元素压入栈S2 操作d 如果栈S2不为空，将S2栈顶元素弹出至输出序列 如果一个1~n的排列P可以通过一系列操作使得输出序列...
洛谷：P1155 [NOIP2008 提高组] 双栈排序（二分图、模拟）
酒姬民的博客
02-14 542
双城之栈 第一步：判断能否双栈排序 感性地理解，我们要让最后输出的序列是升序，显然栈里面数字都要保证是降序的； 摘自 zjp_shadow的题解 {1，2，3} 这组数据是可以放入同一个栈中的，无非是放入就立刻拿出 如果二分图染色成功，每个数字都会得到一个颜色，同样颜色的数字必须在一个栈中 第二步：输出最小字典序的排序 一个较为麻烦的模拟，需要特判很多情况 因为不同操作的顺序会影响字典序，我们应该优先完成第一个栈的入栈和出栈，再考虑第二个栈，即：栈2的任何操作前都考虑栈1能不能操作 同时很重要的
洛谷 P1155 双栈排序
sdfzrlt的博客
10-12 622
二分图
洛谷博客地址
一个菜的不行的人的博客
06-26 637
新开的洛谷博客
EOJ 1808 冒泡排序
Juice_p的博客
12-27 405
#include #include #include void sort(int a[],int n) { int i,j,t; for(i=0;i<n-1;i++)//共执行n-1遍 { for(j=0;j<n-1-i;j++)//每次从0开始执行到n-1-j { if(a[j]>a[j+1])//把a[j]和
双栈排序
pipiang的博客
02-19 403
题目描述： 请编写一个程序，按升序对栈进行排序（即最大元素位于栈顶），要求最多只能使用一个额外的栈存放临时数据，但不得将元素复制到别的数据结构中。给定一个int[] numbers(C++中为vector&amp;ltint&gt;)，其中第一个元素为栈顶，请返回排序后的栈。请注意这是一个栈，意味着排序过程中你只能访问到第一个元素。测试样例：[1,2,3,4,5]返回：[5,4,3,2,1]思路先...
noip 2008 双栈排序
weixin_33777877的博客
06-08 87
洛谷——P1155 双栈排序 题目描述 Tom最近在研究一个有趣的排序问题。如图所示，通过2个栈S1和S2，Tom希望借助以下4种操作实现将输入序列升序排序。 操作a 如果输入序列不为空，将第一个元素压入栈S1 操作b 如果栈S1不为空，将S1栈顶元素弹出至输出序列 操作c 如果输入序列不为空，将第一个元素压入栈S2 操作d 如果栈S2不为空，将S2栈顶元素弹出至输出序列...
NOIP2008·洛谷·双栈排序
樱狸✨愿携清风归来处
10-27 183
洛谷P1155 双栈排序 二分图染色+贪心模拟
洛谷p2615用c语言怎么解,洛谷 P2615 神奇的幻方 题解
weixin_42407739的博客
05-20 365
每日一题系列day1 打卡Analysis水货模拟，不多说了#include#include#include#include#define maxn 39+10using namespace std;inline int read(){int x=;bool f=;char c=getchar();for(; !isdigit(c); c=getchar()) if(c=='-') f=;for(...
CSP(NOIP)复习资料——数学知识.docx
03-11
根据给定文件的信息，我们可以推断出这是一份关于CSP(NOIP)竞赛中的数学复习资料。虽然描述和标签部分没有提供具体信息，但从标题中我们可以确定这份文档旨在帮助准备参加CSP(NOIP)竞赛的学生们复习数学相关知识点。...
CSP(NOIP)复习资料——数学知识.pdf
03-11
。
决策树算法
hawk2014bj的博客
11-05 211
决策树根据交叉熵或者基尼指数对数据进行分类并最终生成决策树，可以应用一些相对确定的分类场景。
动态规划26：467. 环绕字符串中唯一的子字符串
2301_76197086的博客
11-07 389
详解动态规划26：467. 环绕字符串中唯一的子字符串（子数组问题）
【LeetCode】【算法】160.相交链表
passer__jw767的博客
11-05 358
Leetcode 160. 相交链表
LeetCode 876.链表的中间结点
最新发布
qq_57349657的博客
11-08 241
链表快慢指针 练习题 ： 链表的中间结点
二叉树(一)
m0_74340589的博客
11-05 463
/ 写递归算法的关键是要明确函数的「定义」是什么，然后相信这个定义，利用这个定义推导最终结果，绝不要试图跳入递归。// 再说说归并排序的逻辑，若要对nums[lo…// 再看看回溯算法，前文回溯算法详解干脆直接说了，回溯算法就是个 N 叉树的前后序遍历问题，没有例外。// 其实很多动态规划问题就是在遍历一棵树，你如果对树的遍历操作烂熟于心，起码知道怎么把思路转化成代。//快速排序的逻辑是，若要对nums[lo….所有回溯、动归、分治算法，其实都是树的问题，而树的问题就永远逃不开树的递归遍历。
详解复杂度
weixin_63997543的博客
11-05 789
详解复杂度
爬台阶问题
小杏儿的小家
11-05 561
爬楼梯问题的分析，思考，解析以及如何动手用代码进行实践。
「NOIP2008」双栈排序
03-18
「NOIP2008」双栈排序是一个经典的算法问题，它要求使用两个栈来对一个乱序的数组进行排序。具体的步骤如下： 1. 创建两个栈，一个用于存放待排序的数组元素，另一个用于辅助排序。 2. 将待排序的数组元素依次入栈1...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值