【栈】【双端队列】【stack】【deque】hdu 4286

最新推荐文章于 2019-10-09 20:26:51 发布
最新推荐文章于 2019-10-09 20:26:51 发布
阅读量993 收藏
点赞数
分类专栏： 算法 C/C++ OJ题目 STL 文章标签： STL stack deque acm hdu
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/duyiwuer2009/article/details/23132005
版权
C/C++ 同时被 3 个专栏收录
49 篇文章 0 订阅
订阅专栏
STL
16 篇文章 0 订阅
订阅专栏
算法
10 篇文章 0 订阅
订阅专栏

http://acm.hdu.edu.cn/showproblem.php?pid=4286

思路：左边、右边为栈，中间为双端队列


栈空间的限制

这题如果将 n*50w 的 int 数组放在栈中，会报出“stack overflow”的错误，关于栈空间的大小限制 Linux 平台可用如下命令查看：

ulimit -a
具体讨论见： http://www.cs.nyu.edu/exact/core/doc/stackOverflow.txt


实现一：数组模拟栈和双端队列

/*
 * hdu 4286
 * http://acm.hdu.edu.cn/showproblem.php?pid=4286
 * 【栈】【双端队列】
 * 自己实现栈和双端队列（不用 STL）
 */
#include <cstdio>
#include <cstdlib>
using namespace std;

#define MAX         500002
#define POSITIVE    1
#define MAX_CMD     20

int arriDeque[4*MAX];
int arriStackL[2*MAX], arriStackR[2*MAX];
int arriPrint[2*MAX]; // 临时存储用于输出

int main()
{
    int iHead, iTail;   // 双端队列的首和尾
    int iTmpHead;
    int iDirect;        // 双端队列的方向
    int iTopL, iTopR;   // 左边栈和右边栈的顶指针
    int iCases, iNums, iLeft, iRight, iCmds, iData;
    char szCmd[MAX_CMD];
    char *pszTmp;
    int i;
    int j;

    scanf("%d", &iCases);
    while (iCases--)
    {
        iDirect     = POSITIVE;
        iTmpHead    = 2*MAX;

        scanf("%d", &iNums);
        for (i = 0; i < iNums; ++i)
        {
            scanf("%d", &arriDeque[iTmpHead+i]);
        }
        scanf("%d%d", &iLeft, &iRight);
        iHead   = iTmpHead + iLeft - 1;
        iTail   = iTmpHead + iRight - 1;
        iTopL   = -1;
        iTopR   = -1;
        for (i = 1; i < iLeft; ++i)
        {
            arriStackL[++iTopL] = arriDeque[iTmpHead+i-1];
        }
        for (i = iNums; i > iRight; --i)
        {
            arriStackR[++iTopR] = arriDeque[iTmpHead+i-1];
        }

        // 处理命令
        scanf("%d", &iCmds);
        getchar();  // 吸收 '\n', 防止被 fgets 吸入
        while (iCmds--)
        {
            fgets(szCmd, MAX_CMD, stdin);
            switch (szCmd[0])
            {
            case 'M':
                if ('L' == szCmd[4])    // MoveLeft
                {
                    if ('L' == szCmd[9])    // MoveLeft L
                    {
                        if (POSITIVE == iDirect)
                        {
                            arriDeque[--iHead]  = arriStackL[iTopL--];
                        }
                        else
                        {
                            arriDeque[++iTail]  = arriStackL[iTopL--];
                        }
                    }
                    else if ('R' == szCmd[9])   // MoveLeft R
                    {
                        if (POSITIVE == iDirect)
                        {
                            arriStackR[++iTopR] = arriDeque[iTail--];
                        }
                        else
                        {
                            arriStackR[++iTopR] = arriDeque[iHead++];
                        }
                    }
                }
                else if ('R' == szCmd[4])   // MoveRight
                {
                    if ('L' == szCmd[10])   // MoveRight L
                    {
                        if (POSITIVE == iDirect)
                        {
                            arriStackL[++iTopL] = arriDeque[iHead++];
                        }
                        else
                        {
                            arriStackL[++iTopL] = arriDeque[iTail--];
                        }
                    }
                    else if ('R' == szCmd[10])  // MoveRight R
                    {
                        if (POSITIVE == iDirect)
                        {
                            arriDeque[++iTail]  = arriStackR[iTopR--];
                        }
                        else
                        {
                            arriDeque[--iHead]  = arriStackR[iTopR--];
                        }
                    }
                }
                break;
            case 'I':
                pszTmp  = szCmd + 9;
                iData   = atoi(pszTmp);
                if ('L' == szCmd[7])    // Insert L X
                {
                    if (POSITIVE == iDirect)
                    {
                        arriDeque[--iHead]  = iData;
                    }
                    else
                    {
                        arriDeque[++iTail]  = iData;
                    }
                }
                else if ('R' == szCmd[7])   // Insert R X
                {
                    if (POSITIVE == iDirect)
                    {
                        arriDeque[++iTail]  = iData;
                    }
                    else
                    {
                        arriDeque[--iHead]  = iData;
                    }
                }
                break;
            case 'D':
                if ('L' == szCmd[7])    // Delete L
                {
                    if (POSITIVE == iDirect)
                    {
                        ++iHead;
                    }
                    else
                    {
                        --iTail;
                    }
                }
                else if ('R' == szCmd[7])   // Delete R
                {
                    if (POSITIVE == iDirect)
                    {
                        --iTail;
                    }
                    else
                    {
                        ++iHead;
                    }
                }
                break;
            case 'R':   // Reverse
                iDirect = !iDirect;
                break;
            default:
                break;
            }
        }

        // 输出结果
        j = 0;
        for (i = 0; i <= iTopL; ++i)
        {
            arriPrint[j++] = arriStackL[i];
        }
        if (POSITIVE == iDirect)
        {
            for (i = iHead; i <= iTail; ++i)
            {
                arriPrint[j++] = arriDeque[i];
            }
        }
        else
        {
            for (i = iTail; i >= iHead; --i)
            {
                arriPrint[j++] = arriDeque[i];
            }
        }
        for (i = iTopR; i >= 0; --i)
        {
            arriPrint[j++] = arriStackR[i];
        }
        --j;
        for (i = 0; i < j; ++i)
        {
            printf("%d ", arriPrint[i]);
        }
        printf("%d\n", arriPrint[i]);
    }

    return 0;
}


实现二：STL

/*
 * hdu 4286
 * http://acm.hdu.edu.cn/showproblem.php?pid=4286
 * 【栈】【双端队列】【STL】
 * STL 实现
 */
#include <iostream>
#include <string>
#include <deque>
#include <stack>
#include <cstdlib>
#include <cstdio>
using namespace std;

#define MAX         500002
#define POSITIVE    1
#define MAX_CMD     20

int arriTmp[2*MAX];

int main()
{
    deque<int>  deqDeque;
    stack<int>  stkStackL, stkStackR;
    int iDirect;    // 双端队列的方向
    int iCases, iNums, iLeft, iRight, iCmds, iData;
    char szCmd[MAX_CMD];
    char *pszTmp;
    int i, j, iSize;

    scanf("%d", &iCases);
    while (iCases--)
    {
        /* 这里不需要手动清空 stack */
        deqDeque.clear();
        iDirect     = POSITIVE;

        scanf("%d", &iNums);
        for (i = 0; i < iNums; ++i)
        {
            scanf("%d", &arriTmp[i]);
        }
        scanf("%d%d", &iLeft, &iRight);
        for (i = 1; i < iLeft; ++i)
        {
            stkStackL.push(arriTmp[i-1]);
        }
        for (i = iLeft; i <= iRight; ++i)
        {
            deqDeque.push_back(arriTmp[i-1]);
        }
        for (i = iNums; i > iRight; --i)
        {
            stkStackR.push(arriTmp[i-1]);
        }

        // 处理命令
        scanf("%d", &iCmds);
        getchar();  // 吸收 '\n', 防止被 fgets 吸入
        while (iCmds--)
        {
            fgets(szCmd, MAX_CMD, stdin);
            switch (szCmd[0])
            {
            case 'M':
                if ('L' == szCmd[4])    // MoveLeft
                {
                    if ('L' == szCmd[9])    // MoveLeft L
                    {
                        if (POSITIVE == iDirect)
                        {
                            deqDeque.push_front(stkStackL.top());
                        }
                        else
                        {
                            deqDeque.push_back(stkStackL.top());
                        }
                        stkStackL.pop();
                    }
                    else if ('R' == szCmd[9])   // MoveLeft R
                    {
                        if (POSITIVE == iDirect)
                        {
                            stkStackR.push(deqDeque.back());
                            deqDeque.pop_back();

                        }
                        else
                        {
                            stkStackR.push(deqDeque.front());
                            deqDeque.pop_front();
                        }
                    }
                }
                else if ('R' == szCmd[4])   // MoveRight
                {
                    if ('L' == szCmd[10])   // MoveRight L
                    {
                        if (POSITIVE == iDirect)
                        {
                            stkStackL.push(deqDeque.front());
                            deqDeque.pop_front();
                        }
                        else
                        {
                            stkStackL.push(deqDeque.back());
                            deqDeque.pop_back();
                        }
                    }
                    else if ('R' == szCmd[10])  // MoveRight R
                    {
                        if (POSITIVE == iDirect)
                        {
                            deqDeque.push_back(stkStackR.top());
                        }
                        else
                        {
                            deqDeque.push_front(stkStackR.top());
                        }
                        stkStackR.pop();
                    }
                }
                break;
            case 'I':
                pszTmp  = szCmd + 9;
                iData   = atoi(pszTmp);
                if ('L' == szCmd[7])    // Insert L X
                {
                    if (POSITIVE == iDirect)
                    {
                        deqDeque.push_front(iData);
                    }
                    else
                    {
                        deqDeque.push_back(iData);
                    }
                }
                else if ('R' == szCmd[7])   // Insert R X
                {
                    if (POSITIVE == iDirect)
                    {
                        deqDeque.push_back(iData);
                    }
                    else
                    {
                        deqDeque.push_front(iData);
                    }
                }
                break;
            case 'D':
                if ('L' == szCmd[7])    // Delete L
                {
                    if (POSITIVE == iDirect)
                    {
                        deqDeque.pop_front();
                    }
                    else
                    {
                        deqDeque.pop_back();
                    }
                }
                else if ('R' == szCmd[7])   // Delete R
                {
                    if (POSITIVE == iDirect)
                    {
                        deqDeque.pop_back();
                    }
                    else
                    {
                        deqDeque.pop_front();
                    }
                }
                break;
            case 'R':   // Reverse
                iDirect = !iDirect;
                break;
            default:
                break;
            }
        }

        // 输出结果
        deque<int>::iterator            it;
        deque<int>::reverse_iterator    rit;
        j = 0;
        iSize = stkStackL.size();
        for (i = iSize - 1; i >= 0; --i)
        {
            arriTmp[i] = stkStackL.top();
            stkStackL.pop();
        }
        j += iSize;
        if (POSITIVE == iDirect)
        {
            for (it = deqDeque.begin(); it != deqDeque.end(); ++it)
            {
                arriTmp[j++] = *it;
            }
        }
        else
        {
            for (rit = deqDeque.rbegin(); rit != deqDeque.rend(); ++rit)
            {
                arriTmp[j++] = *rit;
            }
        }
        iSize = stkStackR.size();
        for (i = 0; i < iSize; ++i)
        {
            arriTmp[j+i] = stkStackR.top();
            stkStackR.pop();
        }
        j += i;

        for (i = 0; i < j - 1; ++i)
        {
            printf("%d ", arriTmp[i]);
        }
        printf("%d\n", arriTmp[i]);
    }

    return 0;
}


完全 C++  风格（因为输入输出用 C++ 方式，提交超时）

/*
 * 输入全部用 C++ 方式：超时
 */
#include <iostream>
#include <string>
#include <deque>
#include <stack>
#include <cstdlib>
using namespace std;

#define MAX         500002
#define POSITIVE    1

int arriTmp[2*MAX];

int main()
{
    deque<int>  deqDeque;
    stack<int>  stkStackL, stkStackR;
    int iDirect;    // 双端队列的方向
    int iCases, iNums, iLeft, iRight, iCmds, iData;
    string      strCmd;
    int i, j, iSize;

    cin >> iCases;
    while (iCases--)
    {
        /* 这里不需要手动清空 stack */
        deqDeque.clear();
        iDirect     = POSITIVE;

        cin >> iNums;
        for (i = 0; i < iNums; ++i)
        {
            cin >> arriTmp[i];
        }
        cin >> iLeft >> iRight;
        for (i = 1; i < iLeft; ++i)
        {
            stkStackL.push(arriTmp[i-1]);
        }
        for (i = iLeft; i <= iRight; ++i)
        {
            deqDeque.push_back(arriTmp[i-1]);
        }
        for (i = iNums; i > iRight; --i)
        {
            stkStackR.push(arriTmp[i-1]);
        }

        // 处理命令
        cin >> iCmds;
        cin.get();  // 吸收 '\n', 防止被 fgets 吸入
        while (iCmds--)
        {
            getline(cin, strCmd);
            switch (strCmd[0])
            {
            case 'M':
                if ('L' == strCmd[4])    // MoveLeft
                {
                    if ('L' == strCmd[9])    // MoveLeft L
                    {
                        if (POSITIVE == iDirect)
                        {
                            deqDeque.push_front(stkStackL.top());
                        }
                        else
                        {
                            deqDeque.push_back(stkStackL.top());
                        }
                        stkStackL.pop();
                    }
                    else if ('R' == strCmd[9])   // MoveLeft R
                    {
                        if (POSITIVE == iDirect)
                        {
                            stkStackR.push(deqDeque.back());
                            deqDeque.pop_back();

                        }
                        else
                        {
                            stkStackR.push(deqDeque.front());
                            deqDeque.pop_front();
                        }
                    }
                }
                else if ('R' == strCmd[4])   // MoveRight
                {
                    if ('L' == strCmd[10])   // MoveRight L
                    {
                        if (POSITIVE == iDirect)
                        {
                            stkStackL.push(deqDeque.front());
                            deqDeque.pop_front();
                        }
                        else
                        {
                            stkStackL.push(deqDeque.back());
                            deqDeque.pop_back();
                        }
                    }
                    else if ('R' == strCmd[10])  // MoveRight R
                    {
                        if (POSITIVE == iDirect)
                        {
                            deqDeque.push_back(stkStackR.top());
                        }
                        else
                        {
                            deqDeque.push_front(stkStackR.top());
                        }
                        stkStackR.pop();
                    }
                }
                break;
            case 'I':
                iData = atoi(strCmd.substr(9).c_str());
                if ('L' == strCmd[7])    // Insert L X
                {
                    if (POSITIVE == iDirect)
                    {
                        deqDeque.push_front(iData);
                    }
                    else
                    {
                        deqDeque.push_back(iData);
                    }
                }
                else if ('R' == strCmd[7])   // Insert R X
                {
                    if (POSITIVE == iDirect)
                    {
                        deqDeque.push_back(iData);
                    }
                    else
                    {
                        deqDeque.push_front(iData);
                    }
                }
                break;
            case 'D':
                if ('L' == strCmd[7])    // Delete L
                {
                    if (POSITIVE == iDirect)
                    {
                        deqDeque.pop_front();
                    }
                    else
                    {
                        deqDeque.pop_back();
                    }
                }
                else if ('R' == strCmd[7])   // Delete R
                {
                    if (POSITIVE == iDirect)
                    {
                        deqDeque.pop_back();
                    }
                    else
                    {
                        deqDeque.pop_front();
                    }
                }
                break;
            case 'R':   // Reverse
                iDirect = !iDirect;
                break;
            default:
                break;
            }
        }

        // 输出结果
        deque<int>::iterator            it;
        deque<int>::reverse_iterator    rit;
        j = 0;
        iSize = stkStackL.size();
        for (i = iSize - 1; i >= 0; --i)
        {
            arriTmp[i] = stkStackL.top();
            stkStackL.pop();
        }
        j += iSize;
        if (POSITIVE == iDirect)
        {
            for (it = deqDeque.begin(); it != deqDeque.end(); ++it)
            {
                arriTmp[j++] = *it;
            }
        }
        else
        {
            for (rit = deqDeque.rbegin(); rit != deqDeque.rend(); ++rit)
            {
                arriTmp[j++] = *rit;
            }
        }
        iSize = stkStackR.size();
        for (i = 0; i < iSize; ++i)
        {
            arriTmp[j+i] = stkStackR.top();
            stkStackR.pop();
        }
        j += i;
        for (i = 0; i < j - 1; ++i)
        {
            cout << arriTmp[i] << " ";
        }
        cout << arriTmp[i] << endl;
    }

    return 0;
}








duyiwuer2009
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
双端队列Deque及Python实现
12-21
双端队列Deque及Python实现双端队列Deque双端队列Deque的Python实现双端队列Deque的应用：“回文词”判断 双端队列Deque 与队列类似，双端队列有两个人口，不同之处在于双端队列的两个口都既可以是入口也可以是出口...
C++初阶----deque(双端队列)+stack queue模拟实现
qq_41420788的博客
11-23 1236
stack queue模拟实现+dequedeque(双端队列)概念结构deque迭代器应用（优缺点）stackqueue deque(双端队列) 概念 deque(双端队列)：是一种双开口的"连续"空间的数据结构(和队列没关系)，双开口的含义是：可以头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素；与list比较，空间利用率比较高 结构 deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组，其底
C++ deque（double-ended-queue）双端队列
cjc211322的专栏
03-10 1016
ostream_iterator输出流迭代器模板的使用，选自MSDN #include //迭代器头文件 #include //向量容器头文件 #include using namespace std; int main(void) { // ostream_iterator for stream cout ostream_iterator intOut ( cout ,
栈——双端栈（两栈共享空间）
Revendell的博客
10-09 1301
1、使用双端栈通常是当两个栈的空间需求有相反关系时，也就是一个栈增长时另一个栈在缩短的情况。 2、双端栈只是针对两个具有相同数据类型的栈的一个设计上的技巧，如果是不相同数据类型的栈，这种办法不但不能更好地处理问题，反而会使问题变得更加复杂。 #include<iostream> using namespace std; #define TRUE 1 #define FALSE 0...
HDU5929 Basic Data Structure(双端队列)
KeyboardPianist的博客
10-23 470
Basic Data Structure Time Limit: 7000/3500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 928    Accepted Submission(s): 246 Problem Description Mr. Frog
stack-and-queue-.zip_栈和队列
09-14
数据结构 栈和队列及其应用 对栈进行一些操作
Queue_栈队列_pop_
09-30
任务描述栈和队列都提供 Push/Pop 两... 输出描述对每组测试数据输出一行， 输出该组数据对应的线性结构，若为栈则输出”Stack”，若为队列则输出“Queue”，若两者都是则输出“Both”，若两者都不是则输出“Error”。
C++中栈与队列的函数
12-22
栈的应用： 　头文件include<stack> 　定义栈 　stack<type>q; 　其中type是栈中数据的类型、q是定义的栈的名字； 　比较常用的函数： 　q.push();将元素压入栈中； 　q.pop(); 将栈顶元素删除； 　q.empty...
数据结构：导论、栈与队列
01-20
导论 算法的特征：有穷性（finiteness），确定性（definiteness），输入，输出，有效性/可行性（effectiveness） O表示法表示的是当N->某一值或者无穷大时，斜率的变化。重要的是曲线的形状，而不是...栈（Stack） LIF
C++ string 陷阱—— append() 与相加
码农
12-11 5674
#include #include #include // xxx.so --> xxx --> xxx_get_inst int main() { std::string so_name = "xxx.so"; const char* dot_pos = strstr(so_name.c_str(), "."); if (NULL == dot_pos)
STL中map,multimap,set,multiset,unordered_map,unordered_multimap,unordered_set,unordered_multiset的实现方法
码农
04-15 2577
1. set, multiset, map, multimap, unordered_map
元素为自定义复合结构时 map,set 如何处理重复 key 及排序？
码农
07-26 2160
map, set 为 类模板，默认使用的 comparator 为类模板 less, 因此我们需要重载关系运算符 ". 下面的例子是一个排行榜，排序规则如下： 1. 按分数由高到低排； 2. 分数一样的情况下，按时间由新到旧排； 3. 时间也一样的情况下，按用户 ID 由小到大排。 #include #include namespace test { // sorted
【优先队列】【堆】STL之priority_queue、make_heap()、push_heap()、pop_heap()、容器适配器
码农
04-11 1692
explicit priority_queue (const Compare& comp = Compare(), const Container& ctnr = Container()); template priority_queue (InputIterator first, InputIterator last, const Compare& comp = Comp
【STL】ostringstream, istringstream, stringstream
码农
04-08 1531
#include #include #include using namespace std; int main() { /* * ostringstream * 可以理解为将输出重定向至 ostringstream 对象（内存区域） */ ostringstream oss; oss << 3.1415926 << " " << 3.
【队列】poj 3125
码农
04-08 1337
/* * poj 3125 * http://poj.org/problem?id=3125 * 【队列】此题不适用用 STL 做，反而会是操作麻烦 * 思路：找到第一个优先级最高的任务处理掉，其前面的任务插入队尾。 * 1. 为了节省空间，实际操作不移动最大优先级任务之前的任务，而是将 * 头指针指向后面一个任务，队列循环使用。 * 2. 已经处理掉的任务优先级设为 0 *
【双端队列】【栈】【队列】STL之deque、stack、queue、容器适配器
码农
04-11 1253
h explicit deque (const allocator_type& alloc = allocator_type()); explicit deque (size_type n, const value_type& val = value_type(), const allocator_type& alloc = allocator_type()); template
【STL】<algorithm><numeric><functional> 中的常用算法
码农
04-09 1243
1. find 1. 从 first 到 last 顺序和 val 比较 2. 比较操作符 "==" http://www.cplusplus.com/reference/algorithm/find/
STL map, multimap, set, multiset 函数介绍
码农
04-18 970
1. 类模板和构造函数 和前面介绍的ro
stack queue deque priority_queue
最新发布
08-13
栈（Stack）、队列（Queue）、双端队列（Deque）和优先队列（Priority Queue）是常见的数据结构。 栈（Stack）是一种后进先出（LIFO）的数据结构，类似于我们叠放书籍的方式。元素只能在栈顶进行插入和删除操作。 ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值