2019 湖南省省赛 K 双向链表练习题

2019 湖南省省赛 K 双向链表练习题

题目描述

Bobo 有 n 个列表 L 1 , L 2 , … , L n L_1, L_2, \dots, L_n L1,L2,,Ln.
初始时, L i L_i Li 仅包含元素 i i i, 即 L i = [ i ] L_i = [i] Li=[i].
他依次执行了 m m m 次操作。第$ i $次操作由两个整数 a i , b i a_i, b_i ai,bi​ 指定, 每次操作分为两步:

  • 1. L a i ← r e v e r s e ( L a i + L b i ) L_{a_i} \leftarrow \mathrm{reverse}(L_{a_i} + L_{b_i}) Laireverse(Lai+Lbi), 其中 ← \leftarrow 表示赋值, + + + 表示列表的连接, r e v e r s e \mathrm{reverse} reverse表示列表的反转。例如, r e v e r s e ( [ 1 , 2 ] + [ 3 , 4 , 5 ] ) = [ 5 , 4 , 3 , 2 , 1 ] \mathrm{reverse}([1, 2] + [3, 4, 5]) = [5, 4, 3, 2, 1] reverse([1,2]+[3,4,5])=[5,4,3,2,1].
  • 2. L b i ← [ ] L_{b_i} \leftarrow [] Lbi[]. 其中 [] 表示空的列表。

输出 m 次操作后, L 1 L_1 L1​ 的元素。

输入描述:

输入文件包含多组数据,请处理到文件结束。

每组数据的第一行包含两个整数 n 和 m.接下来 m 行,其中第 i 行包含 2 个整数 a i , b i a_i, b_i ai,bi.

  • 1 ≤ n , m ≤ 1 0 5 1 \leq n, m \leq 10^5 1n,m105
  • 1 ≤ a i , b i ≤ n , a i ≠ b i 1 \leq a_i, b_i \leq n, a_i \neq b_i 1ai,bin,ai=bi
  • n 的 总 和 , m 的 总 和 都 不 超 过 5 × 1 0 5 . n 的总和,m 的总和都不超过 5 \times 10^5. nm5×105.

输出描述:

对 于 每 组 数 据 , 先 输 出 L 1 的 长 度 ∣ L 1 ∣ , 再 输 出 ∣ L 1 ∣ 个 整 数 , 表 示 L 1 的 元 素 。 对于每组数据,先输出 L_1 的长度 |L_1|,再输出 |L_1| 个整数,表示 L_1 的元素。 L1L1L1L1

示例1

输入

2 1
1 2
2 1
2 1
3 3
3 2
3 2
1 3

输出

2 2 1
0
3 2 3 1
#include<bits/stdc++.h>
#include <unordered_map>
using namespace std;
template<class...Args>
void debug(Args... args) {//Parameter pack
    auto tmp = { (cout << args << ' ', 0)... };
    cout << "\n";
}
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll>pll;
typedef pair<int, int>pii;
const ll N = 5e5 + 5;
const ll INF = 0x7fffffff;
list<int> a[N];//拼接已翻转的串
list<int> b[N];//拼接未翻转的串
int main() {
    ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);
 
    int n, m;
    while (cin >> n >> m) {
        for (int i = 1; i <= n; i++) {//初始化
            a[i].clear();
            a[i].push_back(i);
            b[i].clear();
            b[i].push_back(i);
        }
        for (int i = 0; i < m; i++) {
            int x, y;
            cin >> x >> y;
            //题目的特殊性,由一个一个转移过来
            //1+2->12 2+1->21
            a[x].splice(a[x].end(), a[y]);//将前后正序拼接(尾插法)  21+3->213
            b[y].splice(b[y].end(), b[x]);//将前后逆序拼接(头插法)  3+12->312 
     		//再通过swap操作维护a[x]中保存的是与a[y]合并后的逆序
            swap(a[x], b[y]);
            swap(b[x], b[y]);
 			//a[x] [213] a[y] []
 			//b[x] []    b[y] [312]
 			//swaped
 			//a[x] [312] a[y] []
 			//b[x] [213] b[y] []
        }
        cout << a[1].size() << " ";
        for (auto i : a[1]) cout << i << " ";
        cout << "\n";
    }
   
    return 0;
}
A:好的,下面是K - 双向链表练习题的解答。 目描述: 设计一个数据结构,要求实现双向链表的基本操作:插入、删除、反转等,并实现一个方法向链表中添加一个元素。同时,该数据结构需要支持以下操作: 1. get(k):返回链表中第 k 个节点的值。如果 k 小于 1 或大于链表的长度,则返回 -1。 2. addAtHead(val):在链表的头部插入一个值为 val 的节点。 3. addAtTail(val):在链表的尾部插入一个值为 val 的节点。 4. addAtIndex(index,val):在链表中的第 index 个节点前插入一个值为 val 的节点。如果 index 等于链表的长度,则在链表的末尾添加该节点。如果 index 大于链表的长度,则不会插入。 5. deleteAtIndex(index):如果索引 index 有效,则删除链表中的第 index 个节点。 解思路: 目要求我们设计一个双向链表数据结构,并提供选定的一些操作。这是一个经典的链表,我们需要先设计链表节点的结构体,并在节点中保留前驱和后继指针,便于双向操作。然后,我们可以定义一个链表类,在该类中定义一些方法来实现链表的基本操作。 本需要实现的方法包括: 1. get(k):遍历链表,找到第 k 个节点并返回该节点的值。 2. addAtHead(val):创建一个新节点,将该节点作为头节点,并更新头节点的前驱指针。 3. addAtTail(val):创建一个新节点,将该节点作为尾节点,并更新尾节点的后继指针。 4. addAtIndex(index,val):遍历链表,找到第 index - 1 个节点,创建一个新节点,并将其插入到该节点的后面。如果 index 为零,则将新节点插入到头部。如果 index 等于链表的长度,则将新节点插入到末尾。 5. deleteAtIndex(index):遍历链表,找到第 index - 1 个节点,并将其后继指针指向第 index + 1 个节点。如果 index 为零,则更新头节点。如果 index 等于链表的长度 - 1,则更新尾节点。 代码实现: 下面是基于C++的实现代码,其中Node是一个链表节点的结构体,List是链表类的定义: ```cpp #include<iostream> using namespace std; // 链表节点结构体 struct Node { int val; // 节点的值 Node* pre; // 前驱指针 Node* nxt; // 后继指针 Node(int _val):val(_val),pre(nullptr),nxt(nullptr){} // 构造函数 }; // 链表类 class List{ private: Node* head; // 头节点 Node* tail; // 尾节点 int size; // 链表长度 public: List():head(nullptr),tail(nullptr),size(0){} // 构造函数 int get(int k){ if(k < 1 || k > size) // 判断k是否合法 return -1; Node* p = head; for(int i=1; i<k; i++) // 遍历链表,找到第k个节点 p = p->nxt; return p->val; // 返回节点的值 } void addAtHead(int val){ Node* p = new Node(val); // 创建新节点 if(size == 0){ // 链表为空的情况 head = p; tail = p; }else{ // 链表非空的情况 p->nxt = head; // 插入节点 head->pre = p; head = p; } size++; // 更新链表长度 } void addAtTail(int val){ Node* p = new Node(val); // 创建新节点 if(size == 0){ // 链表为空的情况 head = p; tail = p; }else{ // 链表非空的情况 tail->nxt = p; // 插入节点 p->pre = tail; tail = p; } size++; // 更新链表长度 } void addAtIndex(int index, int val){ if(index > size) // index不合法,不插入 return; if(index <= 0) // 如果index小于等于0,插入到头部 addAtHead(val); else if(index == size) // 如果index等于size,插入到尾部 addAtTail(val); else{ // 如果index在链表中 Node* p = head; for(int i=1; i<index; i++) // 找到第index-1个节点 p = p->nxt; Node* q = new Node(val); // 创建新节点 q->nxt = p->nxt; // 插入节点 p->nxt->pre = q; p->nxt = q; q->pre = p; size++; // 更新链表长度 } } void deleteAtIndex(int index){ if(index < 0 || index >= size) // index不合法,不删除 return; if(index == 0){ // 如果要删除的是头节点 head = head->nxt; // 更新头节点 if(head == nullptr) // 如果链表为空,尾节点也需要更新 tail = nullptr; else head->pre = nullptr; }else if(index == size-1){ // 如果要删除的是尾节点 tail = tail->pre; // 更新尾节点 tail->nxt = nullptr; }else{ // 如果要删除的是中间节点 Node* p = head; for(int i=1; i<index; i++) // 找到第index-1个节点 p = p->nxt; p->nxt = p->nxt->nxt; // 删除节点 p->nxt->pre = p; } size--; // 更新链表长度 } }; int main(){ List l; l.addAtHead(1); l.addAtTail(3); l.addAtIndex(1,2); // 链表变为[1,2,3] cout<<l.get(1)<<" "; // 返回2 l.deleteAtIndex(1); // 现在链表是[1,3] cout<<l.get(1)<<" "; // 返回3 return 0; } ``` 总结: 双向链表实现相对较多的语言,相对单向链表更适合一些场景;比如说LUR Cache。对于双向链表的实现,我们需要注意节点间指针的指向关系,以及头节点和尾节点的处理。感兴趣的读者可以继续尝试其他链表,如链表的分割、链表的反转等。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值