洛谷 P1160 队列安排02

洛谷团队 - 洛谷

队列安排 - 洛谷

题目描述

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

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

2. 2-N2−N 号同学依次入列，编号为 ii 的同学入列方式为：老师指定编号为 ii 的同学站在编号为 1\sim(i-1)1∼(i−1) 中某位同学（即之前已经入列的同学）的左边或右边；

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

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

输入格式

第 11 行为一个正整数 NN，表示了有 NN 个同学。

第 2\sim N2∼N行，第 ii 行包含两个整数 k,pk,p，其中 kk 为小于 ii 的正整数，pp 为 00 或者 11。若 pp 为00，则表示将 ii 号同学插入到 kk 号同学的左边，pp 为 11 则表示插入到右边。

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

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

输出格式

11 行，包含最多 NN 个空格隔开的正整数，表示了队列从左到右所有同学的编号，行末换行且无空格。

输入输出样例

输入 #1复制

4
1 0
2 1
1 0
2
3
3

输出 #1复制

2 4 1

说明/提示

样例解释：

将同学 22 插入至同学 11 左边，此时队列为：

2 1

将同学 33 插入至同学 22 右边，此时队列为：

2 3 1

将同学 44 插入至同学 11 左边，此时队列为：

2 3 4 1

将同学 33 从队列中移出，此时队列为：

2 4 1

同学 33 已经不在队列中，忽略最后一条指令

最终队列：

2 4 1

数据范围

对于 20\%20% 的数据，有 1\leq N\leq 101≤N≤10；

对于 40\%40% 的数据，有 1\leq N\leq 10001≤N≤1000；

对于 100\%100% 的数据，有 1\leq N,M\leq1000001≤N,M≤100000。

方法一：

#include <cstdio>
#include <list>
using namespace std;
using Iter = list<int>::iterator;
const int maxN = 1e5 + 10;
Iter pos[maxN];
list<int> queList;
bool erased[maxN];
int N;

void buildQueue()
{
  queList.push_front(1);
  pos[1] = queList.begin();

  for (int i = 2; i <= N; i++)
  {
      int k, p;
      scanf("%d%d", &k, &p);
      if (p == 0)
      {
          pos[i] = queList.insert(pos[k], i); //left
      }
      else
      {
          auto nextIter = next(pos[k]);
          pos[i] = queList.insert(nextIter, i); //right
      }
  }
  int M;
  scanf("%d", &M);
  for (int x, i = 1; i <= M; i++)
  {
      scanf("%d", &x);
      if (!erased[x])
      {
          queList.erase(pos[x]);
      }
      erased[x] = true;
  }
}

int main()
{
  scanf("%d", &N);
  buildQueue();
  bool first = true;
  for (int x: queList)
  {
      if (!first)
          putchar(' ');
      first = false;
      printf("%d", x);
  }
  putchar('\n');
  return 0;
}

方法二：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
//定义链表节点，l表示左边节点，r表示右边节点
struct node {
    int l, r;
        //定义构造函数
    node() {
        l = -1;
        r = -1;
    }
};
int main() {
    int n, m;
    cin >> n;
    node li[n+1];
    for (int i = 2; i <= n; i++) {
        int k, p;
        cin >> k >> p;
        if (p == 0) {
        //如果此节点是插入在两个节点，先将左右两个节点的l和r改变，再进行普通操作
            if (li[k].l != -1) {
                li[li[k].l].r = i;
                li[i].l = li[k].l;
            }
            li[k].l = i;
            li[i].r = k;
        } else {
                        //p==1的情况，与上同理，只是l和r要交换
            if (li[k].r != -1) {
                li[li[k].r].l = i;
                li[i].r = li[k].r;
            }
            li[k].r = i;
            li[i].l = k;
        }
    }
    int mark[n+1], t;        //mark数组用于存储此节点还在不在队列中，0表示还在，1表示已被删除
                                         //注意数组大小应开到n+1
    memset(mark, 0, sizeof(mark));
    cin >> m;
    for (int i = 0; i < m; i++) {
        cin >> t;
        mark[t] = 1;
    }
    int head;        //head表示最左边的节点的编号，相当于链表表头
        //寻找head
    for (head = 1; head <= n; head++) {
        if (li[head].l == -1) {
            break;
        }
    }
    for(;;) {
        if (mark[head] == 0) {
            cout << head << " ";        //当此节点还在队列中时才输出
        }
        if (li[head].r == -1) {
            break;        //若此节点右边没有更多节点，则输出完毕
        }
        head = li[head].r;
    }
    return 0;
}