hdu 6375 百度之星 度度熊学队列

题目链接

Problem Description

度度熊正在学习双端队列，他对其翻转和合并产生了很大的兴趣。

初始时有 N 个空的双端队列（编号为 1 到 N ），你要支持度度熊的 Q 次操作。

①1 u w val 在编号为 u 的队列里加入一个权值为 val 的元素。（w=0 表示加在最前面，w=1 表示加在最后面）。

②2 u w 询问编号为 u 的队列里的某个元素并删除它。（ w=0 表示询问并操作最前面的元素，w=1 表示最后面）

③3 u v w 把编号为 v 的队列“接在”编号为 u 的队列的最后面。w=0 表示顺序接（队列 v 的开头和队列 u 的结尾连在一起，队列v 的结尾作为新队列的结尾）, w=1 表示逆序接（先将队列 v 翻转，再顺序接在队列 u 后面）。且该操作完成后，队列 v 被清空。

Input

有多组数据。

对于每一组数据，第一行读入两个数 N 和 Q。

接下来有 Q 行，每行 3~4 个数，意义如上。

N≤150000,Q≤400000

1≤u,v≤N,0≤w≤1,1≤val≤100000

所有数据里 Q 的和不超过500000

Output

对于每组数据的每一个操作②，输出一行表示答案。

注意，如果操作②的队列是空的，就输出−1且不执行删除操作。

Sample Input

2 10
1 1 1 23
1 1 0 233
2 1 1
1 2 1 2333
1 2 1 23333
3 1 2 1
2 2 0
2 1 1
2 1 0
2 1 1

Sample Output

23
-1
2333
233
23333

提示

由于读入过大，C/C++ 选手建议使用读入优化。
一个简单的例子：
void read(int &x){
char ch = getchar();x = 0;
for (; ch < '0' || ch > '9'; ch = getchar());
for (; ch >='0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
}

题意

实现双向队列，要求的功能有：维护N个双向队列，在首/尾部进行插入/删除，以及将一个队列顺序/逆序附到另一个队列尾部，并且清空原序列。

分析

为了避免双向队列颠倒的复杂度，其实完全可以忽略节点的先后顺序，把双向队列想象成一个所有节点入度出度都为1的连通图，那么对链表所有的操作，都可以看作是在图上的加边减边操作，因此，只需要维护每个节点的两条边就行了。
具体的来说，队列加点=连通图中新增一个节点并连一条边到指定的边界；队列删点=图删边；队列附加=两个连通图之间加一条边，连接两个边界点。
因为总是在队列首尾操作，也就是图的边界点，因此记录下每个连通图的两个边界，每次只需要找到图上边界点的相邻的点进行操作，并在操作完后，更新连通图的边界点。

注意

空队列不能被删除，但可以添加一个非空队列到他的后面

代码

#include<stdio.h>
#include<memory.h>
int head[], tail[];
int n, q;
int id = ;
//双向链表节点
struct thing
{
    int v;
    int t1, t2;//不必记录顺序
    thing() :v(), t1(-), t2(-) {}
    void conn(int x) {
        if (t1 == -)t1 = x;
        else t2 = x;
    }
    void brk(int x) {
        if (t1 == x)t1 = -;
        else if (t2 == x)t2 = -;
    }
}node[];

//头部插入
void qaddf(int qid, int nid) {
    if (head[qid] == -) {
        head[qid] = nid;
        tail[qid] = nid;
    }
    else {
        int h = head[qid];
        node[nid].conn(h);
        node[h].conn(nid);
        head[qid] = nid;
    }
}

//尾部插入
void qadde(int qid, int nid) {
    if (head[qid] == -) {
        head[qid] = nid;
        tail[qid] = nid;
    }
    else {
        int t = tail[qid];
        node[nid].conn(t);
        node[t].conn(nid);
        tail[qid] = nid;
    }
}

//头部删除
int delf(int qid) {
    int s = head[qid];
    if (s == -)return -;

    if (head[qid] == tail[qid]) {
        head[qid] = -; tail[qid] = -;
        return node[s].v;
    }

    int next = (node[s].t1 != - ? node[s].t1 : node[s].t2);
    node[next].brk(s);
    head[qid] = next;
    return node[s].v;
}

//尾部删除
int dele(int qid) {
    int s = tail[qid];
    if (s == -)return -;

    if (head[qid] == tail[qid]) {
        head[qid] = -; tail[qid] = -;
        return node[s].v;
    }

    int next = (node[s].t1 != - ? node[s].t1 : node[s].t2);
    node[next].brk(s);
    tail[qid] = next;
    return node[s].v;
}

//顺序连接
void linkf(int q1, int q2) {
    if (head[q2] == -)return;
    if (head[q1] != -) {
        node[tail[q1]].conn(head[q2]);
        node[head[q2]].conn(tail[q1]);
        tail[q1] = tail[q2];

    }
    else
    {
        head[q1] = head[q2];
        tail[q1] = tail[q2];
    }
    head[q2] = -; tail[q2] = -;
}

//逆序连接
void linke(int q1, int q2) {
    if(head[q2]==-)return;
    if (head[q1] != -) {
        node[tail[q1]].conn(tail[q2]);
        node[tail[q2]].conn(tail[q1]);
        tail[q1] = head[q2];

    }
    else
    {
        tail[q1] = head[q2];
        head[q1] = tail[q2];
    }
    head[q2] = -; tail[q2] = -;
}

//简易读外挂
void getn(int&x) {
    x = ;
    char ch;
    do ch = getchar(); while (ch<'' || ch>'');
    do { x = x *  + ch - ''; ch = getchar(); } while ('' <= ch&&ch <= '');
}

int main() {
    int ipt[];
    while (~scanf("%d %d", &n, &q)) {
        id = ;
        memset(head, -, sizeof head);
        memset(tail, -, sizeof tail);
        for (int i = ; i<q; ++i) {
            getn(ipt[]);
            switch (ipt[]) {
            case ://在队列ipt[1]中插入ipt[3]到头/尾部(ipt[2]=0/1)
                getn(ipt[]); getn(ipt[]); getn(ipt[]);
                node[++id].v = ipt[]; node[id].t1 = -; node[id].t2 = -;
                if (ipt[] == ) {
                    qaddf(ipt[], id);
                }
                else {
                    qadde(ipt[], id);
                }
                break;
            case ://在队列ipt[1]中删除头/尾部(ipt[2]=0/1)
                getn(ipt[]); getn(ipt[]);
                if (ipt[] == ) {
                    printf("%d\n", delf(ipt[]));
                }
                else {
                    printf("%d\n", dele(ipt[]));
                }
                break;
            case ://将队列ipt[2]正/反接到ipt[1]后面(ipt[3]=0/1)
                getn(ipt[]); getn(ipt[]); getn(ipt[]);
                if (ipt[] == )
                    linkf(ipt[], ipt[]);
                else
                    linke(ipt[], ipt[]);
                break;
            default:
                break;
            }
        }
    }
}
#define tree \
\
*\
**\
***\
||