数据结构 hbb(汉堡包)

数据结构 hbb(汉堡包)

问题描述

　　汉堡包有收集汉犇犇的癖好，它喜欢把汉犇犇一个叠一个的放置。
　　因为它有强迫症，所以每当它想放一个新的汉犇犇进去的时候并不一定想直
接叠在最上面，简单的说，当他想放第 A 个新的汉犇犇的时候，他想把它插入到
汉犇犇 Ai（保证汉犇犇 Ai 存在）的上面；
　　除此之外，有时候他会吃掉收集的部分汉堡包，因为不满足于只吃一个，每
次会吃掉某个汉犇犇开始，往上连续的 x（x>=1）个汉犇犇。
　　给定 n 个操作，输出 n 个操作后活下来的汉犇犇的编号（从最底下的汉犇犇
开始到最顶）：

1 a    ： 1 代表一个新的汉犇犇（第一个出现的汉犇犇编号为 1，第二个为 2，以此类推），汉堡包想把他放在编号为 a 的汉犇犇上面，如果不存在编号 a的汉犇犇，则放在所有汉犇犇的最上面即可；

2 a b ： 2 代表汉堡包想吃掉编号 a 的汉犇犇开始（如果 a 不存在则从最底下的汉堡包开始），按叠好的顺序，往上共计 b 个汉犇犇（算上编起始位置一共 b 个)，若不够 b 个，则吃到顶结束;

★数据输入

输入第一行为一个正整数 n，代表操作数量。

接下来 n 行操作，如题意；

对于 50%的数据， 1<=n<=1000;

对于 100%的数据， 1<=n<=100000， 0 <= a, b <= 100000

★数据输出

输出自底向上的汉犇犇编号，数字之间用空格隔开，行末无空格，无换行；

输入示例	输出示例
3 1 10 1 10 1 1	1 3 2

输入示例	输出示例
4 1 10 1 10 1 1 2 1 2	2

示例一解释：
（1） 第一个操作，加入汉犇犇 1 放在汉堡包 10 上面，汉堡包 10 不存在，所以直
接放最上{ 1 }
（2） 第二个操作，加入汉犇犇 2 放在汉犇犇 10 上面，汉犇犇 10 不存在，所以
直接放最上{ 1， 2}
（3） 第三个操作，加入汉犇犇 3 放在汉犇犇 1 上面，汉犇犇 1 存在，所以放 1
上{ 1， 3， 2}

示例二解释：
（1） 前面部分操作和示例一一样，为 {1， 3， 2}；
（2） 接着汉堡包吃掉汉犇犇 1 是的 2 个汉犇犇，所以{1， 3}被吃掉
（3） 故输出 2

解题思路

　　双向链表+数组存对应节点的地址

code（未验证）

 #include <stdio.h>
 #include <stdlib.h>
 #include <iostream>
 using namespace std;
 #include <string.h>

 #define MAXN 100002

 struct Node
 {
     Node(int _data)
         :data(_data),bef(NULL),next(NULL){}
     int data;
     Node *bef;//before
     Node *next;
 };

 Node *addr[MAXN] = {};
 Node *head = NULL, *tail = NULL;

 void Init();
 void Insert(int &prenum,int &thisnum);
 void Eat(int &start,int &num);
 void DisAll();

 int main()
 {
     Init();
     DisAll();

     return ;
 }

 void Init()
 {
     int i=,j=;
     int opnum=,op=,hbbnum=;
     int a=,b=;

     scanf("%d",&opnum);
     head = new Node(-);
     tail = head;

     for(i=;i<=opnum;i++)
     {
         scanf("%d",&op);
         if(op==)
         {
             scanf("%d",&a);
             Insert(a,hbbnum);
             ++hbbnum;
         }
         else//op==2
         {
             scanf("%d %d",&a,&b);
             Eat(a,b);
         }
 //        DisAll();
     }
 }

 void Insert(int &prenum,int &thisnum)
 {
     Node *pnew = new Node(thisnum);
     if(addr[prenum] && addr[prenum]->next)//要找的数存在 且 不是最后一个
     {
         addr[thisnum] = pnew;
         pnew->next = addr[prenum]->next;
         addr[prenum]->next->bef = pnew;
         pnew->bef = addr[prenum];
         addr[prenum]->next = pnew;
     }
     else//数不存在 或 数是最后一个
     {
         addr[thisnum] = pnew;
         pnew->bef = tail;
         tail->next = pnew;
         tail = pnew;
     }
 }

 void Eat(int &start,int &num)
 {
     int i;
     Node *p;
     if(addr[start]==NULL)//要找的数不存在，从头开始删
     {
         for(i=, p=head->next; p && i<=num; i++, p=p->next)
         {
             addr[p->data] = NULL;
         }
         head->next = p;
         if(p==NULL) tail = head;
         else        p->bef = head;
     }
     else//找的数存在，获取地址，开始删
     {
         Node *pl = addr[start]->bef;
         for(i=, p=addr[start]; p && i<=num; i++, p=p->next)
         {
             addr[p->data] = NULL;
         }
         pl->next = p;
         if(p==NULL) tail = pl;
         else         p->bef = pl;
     }
 }

 void DisAll()
 {
     for(Node *p = head->next; p; p=p->next)
     {
         if(p==head->next)
             printf("%d",p->data);
         else
             printf(" %d",p->data);
     }
 }