PTA Reversing Linked List (25分)

It is the human mind that releases infinite light, and it is also the human mind that creates boundless darkness. Light and darkness are intertwined and fight together. This is the world for which we are nostalgic and helpless.

Given a constant K and a singly linked list L, you are supposed to reverse the links of every K elements on L. For example, given L being 1→2→3→4→5→6, if K=3, then you must output 3→2→1→6→5→4; if K=4, you must output 4→3→2→1→5→6.

Input Specification:

Each input file contains one test case. For each case, the first line contains the address of the first node, a positive N (≤10​5​​) which is the total number of nodes, and a positive K (≤N) which is the length of the sublist to be reversed. The address of a node is a 5-digit nonnegative integer, and NULL is represented by -1.

Then N lines follow, each describes a node in the format:

Address Data Next

where Address is the position of the node, Data is an integer, and Next is the position of the next node.

Output Specification:

For each case, output the resulting ordered linked list. Each node occupies a line, and is printed in the same format as in the input.

Sample Input:

00100 6 4
00000 4 99999
00100 1 12309
68237 6 -1
33218 3 00000
99999 5 68237
12309 2 33218

Sample Output:

00000 4 33218
33218 3 12309
12309 2 00100
00100 1 99999
99999 5 68237
68237 6 -1

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <string>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <vector>
#include <ctime>
#include <cctype>
#include <bitset>
#include <utility>
#include <sstream>
#include <complex>
#include <iomanip>
#include<climits>//INT_MAX
//#include<bits/stdc++.h>
#define PP pair<ll,int>
#define inf 0x3f3f3f3f
#define llinf 0x3f3f3f3f3f3f3f3fll
#define dinf 1000000000000.0
#define PI 3.1415926
typedef long long ll;
using namespace std;
int const mod=1e9+7;
const int maxn=1e6+10;
struct node{
    int add;
    int data;
    int nx;
}a[maxn];
vector<node>V,jg;
int head,n,k;
int main()
{
    for(int i=-0;i<maxn;i++)
        a[i].add=i;
    scanf("%d%d%d",&head,&n,&k);
    for(int i=0;i<n;i++)
    {
        int dz;
        scanf("%d",&dz);
        scanf("%d%d",&a[dz].data,&a[dz].nx);
    }
    int p=head;
    while(p!=-1)
    {
        V.push_back(a[p]);
        p=a[p].nx;
    }
    int ls=V.size()/k;
    for(int i=0;i<ls;i++)
        reverse(V.begin()+i*k,V.begin()+i*k+k);
    for(int i=0;i<V.size();i++)
    {
        if(i!=V.size()-1)
            printf("%05d %d %05d\n",V[i].add,V[i].data,V[i+1].add);
        else
            printf("%05d %d -1\n",V[i].add,V[i].data);
    }
    return 0;
}