P1160 队列安排（list vector 链表）

最新推荐文章于 2024-08-02 08:11:13 发布
最新推荐文章于 2024-08-02 08:11:13 发布
阅读量381 收藏 6
点赞数
分类专栏： 洛谷
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43590403/article/details/101932537
版权

题的链接： 点击这里：P1160 队列安排

题解： 介意看1.0和3.0，其他两个。。。。
参考代码1.0： 结构体数组实现（模拟链表）

注意：

  • 初始化第一个同学前后都没有人
  • 插入时，将当前人物的前后分别指向要插入k的前后，再将k前的人的next改到当前人数i,将k后的人pre指向i，右操作类似；
		L[i].pre = L[K].pre;
        L[i].next = K;
        L[L[K].pre].next = i;
        L[K].pre = i;
  • 删除时，先判断删没删过，没删过则开始删，即修改删除元素前后元素的指向，删除掉后，将删除元素前后都置为-1，表示已经删除。
	L[L[X].pre].next = L[X].next;
    L[L[X].next].pre = L[X].pre;
    L[X].pre = L[X].next = -1;
  • 从链表头输出时，需要找到表头，即该元素的pre为0的那个，找到后，输出，同时让pos = L[pos].next 。
  • 删除元素的pre和next都等于-1 。
#include <queue>
#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
#define INF 0x3f3f3f3f
#define MAX 5010
using namespace std;

typedef struct Node
{
    int pre, next;
}List;

List L[100010];

int N, k, p, M, x;

void InitList()
{
    L[1].next = L[1].pre = 0;
}

void InsertList(int i, int K, int P)
{
    if(P == 0)//左
    {
        L[i].pre = L[K].pre;
        L[i].next = K;
        L[L[K].pre].next = i;
        L[K].pre = i;
    }
    else//右
    {
        L[i].pre = K;
        L[i].next = L[K].next;
        L[L[K].next].pre = i;
        L[K].next = i;
    }
}

void DeleteList(int X)
{
    if(L[X].pre == -1 && L[X].next == -1) return;

    L[L[X].pre].next = L[X].next;
    L[L[X].next].pre = L[X].pre;
    L[X].pre = L[X].next = -1;
}

void PrintList()
{
    int pos;
    for(int i = 1; i <= N; i++)
        if(L[i].pre == 0) {pos = i; break;}

    while(pos > 0)
    {
        cout << pos <<" ";
        pos = L[pos].next;
    }
}

int main()
{
    cin >> N;
    InitList();
    for(int i = 2; i <= N; i++)
    {
        cin >> k >> p;
        InsertList(i, k, p);
    }
    cin >> M;
    for(int i = 0; i < M; i++)
    {
        cin >> x;
        DeleteList(x);
    }
    PrintList();
    return 0;
}
参考代码2.0： 结构体指针实现（双向链表），用vis来标记是否已经删过，删过则直接return，但是仅仅能通过前连个测试点，后面都超时（原因： 应该是每次在插入和删除时都要一个个循环来找位置，浪费大量时间，建议用代码1.0，数组实现时在查找和删除时都是O(1)的），（结论：数据量大的时候，链表最好用数组实现）
#include <queue>
#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
#define INF 0x3f3f3f3f
#define MAX 5010
using namespace std;

typedef struct Node
{
    int data;
    Node *pre, *next;
}*List;

int N, k, p, M, x;
bool vis[10010];

List InitList()
{
    List L, head;
    L = (List)malloc(sizeof(Node));
    L->pre = L->next = NULL;
    head = (List)malloc(sizeof(Node));

    head->data = 1;
    head->next = L->next;
    if(L->next != NULL) L->next->pre = head;
    L->next = head;
    head->pre = L;
    return L;
}

void InsertList(List L, int i, int K, int P)
{
    List t = L->next;
    List s = (List)malloc(sizeof(Node));
    s->data = i;
    while(t->data != K && t != NULL)
    {
        t = t->next;
    }

    if(t == NULL) return;
    if(P == 0) t = t->pre;

    s->next = t->next;
    if(t->next != NULL) t->next->pre = s;
    s->pre = t;
    t->next = s;
}

void DeleteList(List L, int X)//2 3 4 1
{
    if(vis[X]) return;
	vis[X] = true;
	
    List t = L->next;
    List s;
    int i = 0;
    while(t->data != X && t != NULL)
    {
        t = t->next;
    }
    if(t == NULL) return;

    s = t->pre;

    s->next = t->next;
    if(t->next != NULL) t->next->pre = s;
    free(t);
}

void PrintList(List L)
{
    List t = L->next;
    while(t != NULL)
    {
        cout << t->data <<" ";
        t = t->next;
    }
    cout << endl;
}

int main()
{
    cin >> N;
    List L = InitList();
    for(int i = 2; i <= N; i++)
    {
        cin >> k >> p;
        InsertList(L, i, k, p);
    }
    cin >> M;
    for(int i = 0; i < M; i++)
    {
        cin >> x;
        DeleteList(L, x);
    }
    PrintList(L);
    return 0;
}
参考代码3.0： STL的list实现，用迭代器数组指向每个元素的迭代器，插入左边可以直接用insert函数，调用pos[k]，并将插入元素的迭代器返回到pos[i]；插入右边要先找到k的下一个迭代器，可以用next（）函数找到下一个迭代器，再插入，并将插入元素的迭代器返回到pos[i]；删除也可以直接调用erase函数，参数为删除元素的迭代器；用vis数组标记是否删除过；遍历直接用迭代器遍历就可以；
注意：
#include <list>
#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
#define INF 0x3f3f3f3f
#define MAX 5010
using namespace std;

list<int>::iterator pos[100010];
//pos[x] 表示x的迭代器
list<int> L;
bool vis[100010];
int N, k, p, M, x;

int main()
{
    cin >> N;
    L.push_front(1);
    //默认1迭代器地址为begin
    pos[1] = L.begin();
    for(int i = 2; i <= N; i++)
    {
        cin >> k >> p;
        //insert返回值也为迭代器
        if(p == 0) pos[i] = L.insert(pos[k], i);
        else
        {
            //或者 auto nex = next(pos[k]);
            //往k的右边插入，要找到k的下一个迭代器，用next查找
            list<int>::iterator nex = next(pos[k]);
            pos[i] = L.insert(nex, i);
        }
    }
    cin >> M;
    for(int i = 0; i < M; i++)
    {
        cin >> x;
        if(!vis[x]) L.erase(pos[x]), vis[x] = true;
    }
    for(list<int>::iterator it = L.begin(); it != L.end(); it++) cout << *it <<" ";
    //或者 for(auto X : L) cout << X <<" ";
    return 0;
}
参考代码4.0： STL的vector实现，会超时，应该可以写的和list一样也行，但是内存又会出问题，所以用find函数来找，但是仍然超时，省去删除操作，也会超时。。。；
#include <vector>
#include <cstdio>
#include <string>
#include <cstring>
#include <iostream>
#include <algorithm>
#define INF 0x3f3f3f3f
#define MAX 5010
using namespace std;

vector<int> v;
bool vis[100010];
int N, k, p, M, x;

int main()
{
    cin >> N;
    v.push_back(1);
    pos[1] = v.begin();
    for(int i = 2; i <= N; i++)
    {
        cin >> k >> p;
        if(p == 0) v.insert(find(v.begin(), v.end(), k), i);
        else v.insert(find(v.begin(), v.end(), k) + 1, i);
    }
    cin >> M;
//    for(int i = 0; i < M; i++)
//    {
//        cin >> x;
//        if(!vis[x]) v.erase(pos[x]), vis[x] = true;
//    }
    for(int i = 0; i < M; i++)
    {
        cin >> x;vis[x] = true;
    }
    for(vector<int>::iterator it = v.begin(); it != v.end(); it++)
        if(!vis[*it]) cout << *it <<" ";
    //for(auto X : v) cout << X <<" ";
    return 0;
}
ITNXD
关注
专栏目录
P1160 队列安排
weixin_44132485的博客
05-14 127
一、题目 二、解题思路 由于该题每步都为插入，因此为明显的链表题。由于不想写链表，首先尝试使用数组去求解：直接记录每位同学的位置，插入情况就两种，插在邻居的左边或者右边；当插在邻居左边时，新插入同学的位置为邻居的位置，然后邻居及站在该邻居后面的同学位置全都加一，而插在邻居右边时，新插入同学的位置为邻居的位置+1，该邻居后面的同学同样位置全都加一。很遗憾，超时！只能写链表了。 由于担心超时，我采用了空间换时间的策略，使用双链表存储整个队列。对于每个同学，我们只需要记录其左右邻居是谁，当知道队头或者队尾时，
P1160 队列安排（list）
sugarbliss
12-06 405
题目链接：https://www.luogu.org/problemnew/show/P1160 思路：直接用list容器按要求模拟，另外要用一个pos数组记录每一位同学在迭代器的位置。list容器是一个双向链表,可以高效地进行插入删除元素。使用list容器之前必须加上&lt;list&gt;头文件：#include&lt;list&gt; AC代码： #include &lt;bits/...
P1160 队列安排【list】
最新发布
海岛Blog
08-02 518
一个学校里老师要将班上N个同学排成一列，同学被编号为1∼N，他采取如下的方法：先将1号同学安排进队列，这时队列中只有他一个人；2∼N号同学依次入列，编号为i的同学入列方式为：老师指定编号为i的同学站在编号为1∼i−1中某位同学（即之前已经入列的同学）的左边或右边；从队列中去掉M个同学，其他同学位置顺序不变。在所有同学按照上述方法队列排列完毕后，老师想知道从左到右所有同学的编号。
P1160 队列安排（链表）
hjx
04-09 596
https://www.luogu.org/problem/show?pid=1160#sub 模拟，链表实现即可#include<iostream> #include<cstdio> #include<algorithm> #include<cstring> #include<string> #include<vector> using namespace std; bool f[100009]
list (链表)和 vector 区别及 list 容器详解
一丁的博客
05-21 3734
注：读者在阅读本文前，需要有 vector 容器的基础。想学习 vector 请看博主的另一篇文章：https://blog.csdn.net/qq_41291253/article/details/89840185 一、list 简介 链表是顺序容器，允许在序列中的任何位置进行恒定时间插入和擦除操作，并在两个方向上进行迭代。 链表容器实现为双向链表; 双向链表可以将它们包含的每个元素存储在...
数据结构：线性表、链表、队列、栈、串
11-24
在实际编程中，C++提供了标准模板库（STL），其中的`std::vector`可以作为线性表的实现，`std::list`作为链表，`std::deque`作为双端队列，`std::stack`作为栈。这些容器提供了丰富的接口，简化了数据结构的使用。 ...
02-链表与队列1
08-04
而链表（如std::list）的插入和删除操作通常是O(1)，因为只需要修改相邻节点的指针，但随机访问（查找）则需要遍历链表，时间复杂度为O(N)。 【链表实现】 在C/C++中，链表可以使用数组或者指针来实现。数组实现的...
vector,map,list,queue的区别详细解析
09-05
在C++标准库中，`vector`、`map`、`list`和`queue`是四种常见的容器，它们各自有着不同的特性和用途。下面将详细分析这些容器的区别以及何时选择它们。 1. **vector** - **特性**：`vector`是一种动态数组，它的...
Stack/Queue与Vector/List的联系
xxpresent的博客
11-25 1069
Vector:(顺序表【数组存储】) 1.当申请的空间不足的时候，需要再次开辟一块更大的空间，并把值拷过去。 2.对于尾删和尾插是比较方便的，只需要改动最后一个元素即可。不会改动原有的空间。适用于多次重复的对尾部插删。 3.顺序存储，地址是连续的。 4.头插和头删都需要移动一定的大小。时间复杂度为o(N)。而链表只需o(1)。 List:(链表) 1.需要每次都创建节点。 2.适用于
[P1160]队列安排
今天的北宅依旧没有回家
04-09 625
原题链接简单的模拟#include<iostream> #include<cstdio> #include<cstring> #include<string> #include<algorithm> #include<cmath> #include<vector> #include<queue> using namespace std;int n,head,k,p,pre[100005],nxt[1
P1160 队列安排题解【STL双向链表】
李响
09-16 500
除上述主要操作以外，list还提供了其他一些实用的成员函数：size()返回链表内元素的个数，empty()判断链表是否为空，remove(val)用于移除所有值为val的节点，以及作为成员函数的sort()和unique()。这个“末尾位置”指的是最后一个元素再往后一位，也就是说end()所指的位置不包含有效元素，它相当于一个虚设的节点。it为该链表的一个迭代器，val为待插入的值，插入后val位于it所指位置的前一位。这段代码演示的是list提供的，用于访问内部元素的迭代器。
P1160 队列安排 （模拟链表）
Whyckck的博客
07-27 448
题目描述 一个学校里老师要将班上 NNN 个同学排成一列，同学被编号为 $1～N$ ，他采取如下的方法： 先将 111 号同学安排进队列，这时队列中只有他一个人； 2−N2-N2−N 号同学依次入列，编号为i的同学入列方式为：老师指定编号为i的同学站在编号为 1−(i−1)1-(i -1)1−(i−1) 中某位同学（即之前已经入列的同学）的左边或右边； 3.从队列中去掉 M(...
STL list容器详解：双向链表的高效操作
`deque`（双端队列）则结合了`vector`和`list`的优点。它支持随机访问，就像`vector`一样，同时可以在两端进行高效的插入和删除。`deque`内部结构复杂，但允许在不破坏连续内存块的情况下提供高效操作。 在选择容器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值