1074 Reversing Linked List (25分)(链表区间反转)

1074 Reversing Linked List (25分)

 

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 (≤) which is the total number of nodes, and a positive K (≤) 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 <cstdio>
using namespace std;

const int maxn = 1e6 + 5, maxm = 1e5 + 5;

struct Linked {
    int pre, next, data;
} lists[maxn];
int val[maxm], cnt;

int main() {
    int head, n, k, u, v, data;
    scanf("%d %d %d", &head, &n, &k);
    for(int i = 0; i < n; i ++) {
        scanf("%d %d %d", &u, &data, &v);
        lists[u].next = v;
        lists[v].pre = u;
        lists[u].data = data;
        if(u == head) lists[u].pre = -1;
    }
    while(~head) {
        Linked temp = lists[head];
        val[++ cnt] = head;
        head = temp.next;
    }
    if(cnt >= k) {
        for(int i = 1; i <= cnt / k; i ++) {
            for(int j = i * k; j > (i - 1) * k + 1; j --) {
                Linked temp = lists[val[j]];
                printf("%05d %d %05d
", val[j], temp.data,temp.pre);
            }
            Linked temp = lists[val[k * (i - 1) + 1]];
            if(i < cnt / k) printf("%05d %d %05d
", val[k * (i - 1) + 1], temp.data, val[k * (i + 1)]);
            else {
                if(cnt % k) {
                    printf("%05d %d %05d
", val[k * (i - 1) + 1], temp.data, val[k * i + 1]);
                    int flag = (cnt / k) * k;
                    for(int j = 1; j < cnt % k; j ++) {
                        Linked temp = lists[val[flag + j]];
                        printf("%05d %d %05d
", val[flag + j], temp.data, temp.next);
                    }
                    printf("%05d %d -1
", val[flag + cnt % k], lists[val[flag + cnt % k]].data);
                } else {
                    printf("%05d %d -1
", val[k * (i - 1) + 1], temp.data);
                }
            }
        }
    } else {
        for(int i = 1; i < cnt; i ++) {
            printf("%05d %d %05d
", val[i], lists[val[i]].data, lists[val[i]].next);
        }
        printf("%05d %d -1
", val[cnt], lists[val[cnt]].data);
    }
    return 0;
}