Sicily 1058. Fully Diversified Sequence

1058. Fully Diversified Sequence

Constraints

Time Limit: 1 secs, Memory Limit: 32 MB , Special Judge

Description

Given a positive integer n, let N be the set of integers from 1 to n. A finite sequence A1, …, Ak of subsets of N is fully diversified if:

a. Each subset Ai has an even number of elements.
b. For each element m in N, there are exactly m sets Ai in the sequence with m as a member.

For example, the sequence of subsets {1, 3}, {2, 3}, {2, 3} is a fully diversified sequence of subsets of {1, 2, 3}. (Note that subsets in the sequence may be the same.)

A fully diversified sequence of subsets of N is minimal if no other fully diversified sequence of subsets of N has a smaller sequence count. The example above is minimal since the element 3 must occur in 3 different sets.

Write a program, which, given an integer n, determines whether there is a fully diversified sequence of subsets of the corresponding set N and, if there is a fully diversified sequence, finds a minimal fully diversified sequence of subsets of N.

Input

The input will be a sequence of positive integers n (n<=100), one per line followed by a zero (0) (on another line) indicating the end of the input.

Output

If there is no fully diversified sequence of subsets of the corresponding set N, output a 0 on one line followed by a blank line.

If there is a fully diversified sequence of subsets of the corresponding set N, output the number of sets in your minimal sequence on one line, followed by the sets, one per line, followed by a blank line.

The elements of each set should be output in increasing order with a single space between numbers. The sets of sequences should be output in lexicographical order. There may be many possible solutions to each problem.

Sample Input

8
9
11
17
23
0

Sample Output

8
1 3 5 6 7 8
2 4 5 6 7 8
2 4 5 6 7 8
3 4 5 6 7 8
3 4 5 6 7 8
6 8
7 8
7 8

0

11
1 5 7 8 9 11
2 5 7 8 10 11
2 5 7 8 10 11
3 5 7 9 10 11
3 6 7 9 10 11
3 6 7 9 10 11
4 6 8 9 10 11
4 6 8 9 10 11
4 6 8 9 10 11
4 6 8 9 10 11
5 7 8 9 10 11

0

23
1 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
5 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
9 11 12 13 14 15 16 17 18 19 20 21 22 23
10 11 12 13 14 15 16 17 18 19 20 21 22 23
10 11 12 13 14 15 16 17 18 19 20 21 22 23
12 13 14 15 16 17 18 19 20 21 22 23
13 15 16 17 18 19 20 21 22 23
14 15 16 17 18 19 20 21 22 23
14 15 16 17 18 19 20 21 22 23
16 17 18 19 20 21 22 23
17 19 20 21 22 23
18 19 20 21 22 23
18 19 20 21 22 23
20 21 22 23
21 23
22 23
22 23
// Problem#: 1058
// Submission#: 3459542
// The source code is licensed under Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License
// URI: http://creativecommons.org/licenses/by-nc-sa/3.0/
// All Copyright reserved by Informatic Lab of Sun Yat-sen University
#include <stdio.h>
#include <iostream>
#include <vector>
#include <string>
#include <stack>
#include <iomanip>
#include <algorithm>
#include <queue>
#include <functional>
#include <map>
#include <string.h>
#include <math.h>
#include <list>
#include <set>
using namespace std;

int N;
vector<vector<int> > v;

void output() {
    cout << N << endl;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < v[i].size(); j++) {
            if (j) cout << " ";
            cout << v[i][j];
        }
        cout << endl;
    }
    cout << endl;
}

int main() {

    std::ios::sync_with_stdio(false);

    while (1) {
        cin >> N;
        if (!N) break;
        if (((1 + N) * N / 2) % 2 == 1) {
            cout << 0 << endl << endl;
            continue;
        }
        v.clear();
        v.resize(N);
        int put;
        int vSize;
        if (N % 2) {
            put = 3;
            vSize = -1;
        } else {
            put = 4;
            vSize = 0;   
        }
        while (put <= N) {
            for (int i = 0; i <= vSize; i++) {
                v[i].push_back(put - 3);
                v[i].push_back(put - 2);
                v[i].push_back(put - 1);
                v[i].push_back(put);
            }
            v[vSize + 1].push_back(put - 2); v[vSize + 1].push_back(put);
            v[vSize + 2].push_back(put - 1); v[vSize + 2].push_back(put);
            v[vSize + 3].push_back(put - 1); v[vSize + 3].push_back(put);
            vSize += 4;
            put += 4;
        }
        output();
    }

    return 0;
}