队列 P1160 队列安排（啊啊 不会啊）

洛谷

题目描述

一个学校里老师要将班上N个同学排成一列，同学被编号为1～N，他采取如下的方法：

1.先将1号同学安排进队列，这时队列中只有他一个人；

2.2～N号同学依次入列，编号为i的同学入列方式为：老师指定编号为i的同学站在编号为1～i -1中某位同学（即之前已经入列的同学）的左边或右边；

3.从队列中去掉M（M<N）个同学，其他同学位置顺序不变。

在所有同学按照上述方法队列排列完毕后，老师想知道从左到右所有同学的编号。

输入输出格式

输入格式：

 

输入文件arrange.in的第1行为一个正整数N，表示了有N个同学。

第2～第N行，第i行包含两个整数k，p，其中k为小于i的正整数，p为0或者1。若p为0，则表示将i号同学插入到k号同学的左边，p为1则表示插入到右边。

第N+1行为一个正整数M，表示去掉的同学数目。

接下来M行，每行一个正整数x，表示将x号同学从队列中移去，如果x号同学已经不在队列中则忽略这一条指令。

 

输出格式：

 

输入文件arrange.out仅包括1行，包含最多N个空格隔开的正整数，表示了队列从左到右所有同学的编号，行末换行且无空格。

 

输入输出样例

输入样例#1：

4
1 0
2 1
1 0
2
3
3

输出样例#1：

2 4 1

将同学2插入至同学1左边，此时队列为：
2 1
将同学3插入至同学2右边，此时队列为：
2 3 1
将同学4插入至同学1左边，此时队列为：
2 3 4 1
将同学3从队列中移出，此时队列为：
2 4 1
同学3已经不在队列中，忽略最后一条指令
最终队列：
2 4 1

说明

对于20%的数据，有N≤10；

对于40%的数据，有N≤1000；

对于100%的数据，有N, M≤100000。

 

大神的代码

觉得自己的代码看起来最舒服所以贴一个。

思路就是插入的时候改变插入的位置左右两边节点的指向

前继改变next域，后继pre，然后插入。

删除的时候把两个值搞成-1就行了。

把0的next指向第一个节点，最后输出就行了。

#include<iostream>
using namespace std;
#include<cstring>

struct node{
    int pre;
    int next;
}queue[100010];
int n,m,head;

int main()
{
    cin>>n;
    queue[0].next = 1;
    queue[1].pre = 0;queue[1].next = -1;
    for(int i = 2;i <= n;i++)
    {
        int k,p;cin>>k>>p;
        if(p)
        {
            queue[i].pre = k;
            queue[queue[k].next].pre = i;
            queue[i].next = queue[k].next;
            queue[k].next = i;
        }else
        {
            queue[i].next = k;
            queue[queue[k].pre].next = i;
            queue[i].pre = queue[k].pre;
            queue[k].pre = i;
        }
    }
    cin>>m;
    for(int i = 1;i <= m;i++)
    {
        int temp;cin>>temp;

        if(queue[temp].next == -1 && queue[temp].pre == -1)
            continue;

        queue[queue[temp].pre].next = queue[temp].next;
        queue[queue[temp].next].pre = queue[temp].pre;
        queue[temp].next = queue[temp].pre = -1;
    }
    int k = queue[0].next;
    while(k != -1)
    {
        cout<<k<<' ';
        k = queue[k].next;
    }
    return 0;
}
编辑人：nkoi18 更新时间2016-10-30 21:07 举报
简单的链表模拟

看了一下下面的题解，都是输出是去找队首，其实可以定一个first变量记录队首变化：

1.在队首左边插入时修改队首

2.在删除时修改队首为右边的人

附上代码 希望对大家有帮助

#include <iostream>
#include <cstdio>
struct ff{
    int left;
    int right;
    ff() {
        left=0;
        right=0;
    }
}queue[100001];
using namespace std;
int fl[100001]={0};
int main()
{
    int n,m,first=1;fl[1]=1;
    cin>>n;
    for(int i=2;i<=n;i++)
      {
          int k,p;
          cin>>k>>p;
          if(p)
            {
                if(queue[k].right)
                  {
                      queue[queue[k].right].left=i;
                      queue[i].right=queue[k].right;
                  }
                 queue[k].right=i;
                 queue[i].left=k;
            }
          else
            {
                if(queue[k].left)
                  {
                      queue[queue[k].left].right=i;
                      queue[i].left=queue[k].left;
                      queue[k].left=i;
                      queue[i].right=k;
                  }
                else
                  {
                      queue[k].left=i;
                      queue[i].right=k;
                      first=i;
                  }
            }
          fl[i]=1;
      }
    cin>>m;
    for(int i=1;i<=m;i++)
      {
          int x;
          cin>>x;
          if(fl[x])
            {
                queue[queue[x].left].right=queue[x].right;
                queue[queue[x].right].left=queue[x].left;
                fl[x]=0;
                if(x==first)
                  first=queue[x].right;
            }
      }
    int c=first;
    while(c)
      {
          cout<<c<<" ";
          c=queue[c].right;
      }
    return 0;
}

/*蒟蒻思路：当元素在左侧插入时看做一个先进先出的队列，
在右侧插入时看做一个先进后出的栈。通过c++的STL中的vector和stack
实现了这两种数据结构，并通过递归完成输出*/
#include<cstdio>
#include<stack>
#include<vector>
#define N 100005

using namespace std;

vector<int>left[N];
stack<int>right[N];
int tot;
bool hash[N];

void print(int k)
{
    for (int i=0;i<left[k].size();i++) print(left[k][i]);

    if (hash[k]) 
    {
        tot--;
        if (!tot) printf("%d\n",k);
            else printf("%d ",k);
    }
    while (!right[k].empty())
    {
        print(right[k].top());
        right[k].pop();
    }
}

int main()
{
    int n,a,b,tmp;
    scanf("%d",&n);
    for (int i=2;i<=n;i++)
    {
        scanf("%d%d",&a,&b);
        if (!b) left[a].push_back(i);
            else right[a].push(i);
    }
    for (int i=1;i<=n;i++) hash[i]=true;
    tot=n;
    scanf("%d",&n);
    for (int i=1;i<=n;i++) 
    {
        scanf("%d",&tmp);
        if (hash[tmp])
        {
            tot--;
            hash[tmp]=false;
        }
    }
    print(1);
}

小的打了一半就不回答的代码

我想让他每一个人的右边的人都能知道；
即它的编号是她右边的人的编号的下标
第一维存顺序
但我不知道该真么把它删除啊


#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
int n,m,x,y,r[101][101],q,p;
bool b[101]=true;
int main()
{
    scanf("%d",&n);
    for(int i=2;i<=n;i++)
    {                                 
        scanf("%d%d",&x,&y);
        if(y==1)
          r[++q][x]=i;
        else   r[++q][i]=x;
    }
    scanf("%d",&m);
    for(int i=1;i<=m;i++)
      {
          scanf("%d",&x);
          r[p][x]=;
      }
    for(int i=1;i<=q;i++)
      
    
    return 0;
}

 

转载于:https://www.cnblogs.com/z360/p/6581190.html