## 1) Abridged problem statement

Given **N (1 ≤ N ≤ 2005)** players in a **round-robin** tournament, every pair of players must play **exactly once**. Split all matches into **tours/rounds** so that **no player plays more than one match in the same tour**, and the **number of tours is minimal**.

Output:
- First line: minimal number of tours **T**.
- Then an **N×N** matrix `A` where `A[i][j]` is the tour number (1..T) of the match between players `i` and `j`, `A[i][i]=0`, and `A[i][j]=A[j][i]`.

Any optimal schedule is accepted.

---

## 2) Detailed editorial (how the solution works)

This is exactly the classic problem of **edge-coloring the complete graph** \(K_N\) with the minimum number of colors, where:
- vertices = players,
- edges = matches,
- colors = tours,
- constraint “a player plays at most once per tour” means each color class must be a **matching**.

### Key facts (lower bound and optimal value)

- In one tour, each player can play at most one match.
- So a single tour can contain at most \(\lfloor N/2 \rfloor\) matches.
- Total matches are \(\binom{N}{2}\).

Also, for any vertex, its degree in \(K_N\) is \(N-1\). Since all incident edges must have distinct colors (a player cannot play twice in one tour), we need at least \(N-1\) colors.

Therefore:
- If **N is even**, it’s possible to do it in **T = N − 1** tours (this is optimal).
- If **N is odd**, it’s possible to do it in **T = N** tours (also optimal), because in each tour one player must sit out (a perfect matching cannot exist in odd-sized complete graph).

This matches a known theorem:
- \(\chi'(K_N) = N-1\) if \(N\) even, else \(N\).

### Constructing an optimal schedule (circle / round-robin method)

We explicitly build a **1-factorization** (decomposition into perfect matchings) for even case, and a near-perfect decomposition for odd case.

#### Case A: N is odd (T = N)
Arrange players 0..N-1 around a “table” (a circle idea). For each round `r`:
- Pair people symmetric around the table:
  - for `i = 1..(N-1)/2`, pair:
    - `p1 = (i - r) mod N`
    - `p2 = (N - i - r) mod N`
- Player at “head seat” is left out implicitly (no pairing uses it).

Rotating by `r` ensures every pair appears exactly once across the N rounds.

#### Case B: N is even (T = N − 1)
Use only the first `N-1` players (0..N-2) around the table (so table size is odd, which makes the rotation property work cleanly), and keep player `N-1` as the “standing” player.
For each round `r`:
1) Standing player `N-1` plays the current “head” person:
   - `head = (table_size - r) mod table_size`
   - pair `head` with `N-1`
2) Among seated players, pair symmetric positions as in the odd case on the table of size `N-1`:
   - for `i = 1..(table_size-1)/2`, pair
     - `p1 = (i - r) mod table_size`
     - `p2 = (table_size - i - r) mod table_size`

This creates `N-1` rounds, each round is a perfect matching of all N players, and every pair appears exactly once.

### Output matrix
We fill `schedule[i][j]` with the round index (1-based) whenever players i and j are paired in that round; diagonal remains 0.

Complexity:
- Filling pairings per round is \(O(N^2)\).
- Outputting the matrix is also \(O(N^2)\).
- Fits for N ≤ 2005.

---

## 3) C++ Solution

```cpp
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
};

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
};

int n;

void read() { cin >> n; }

void solve() {
    // We want to partition the edges of a complete graph into the least number
    // of matchings. This is actually called the 1-factorization of a graph, but
    // there is also a simple approach to think about this.
    //
    // Let's consider the case of n being odd. In this case at each round we
    // will always leave one vertex out so it's not hard to observe that we will
    // need at least n rounds. From now we will call the vertices people, and
    // the edges at one round handshakes. We will place the n people around a
    // rectangular table with one head chair and (n-1)/2 chairs on each side.
    // For a given arrangement of people, let's have a handshake between people
    // staying opposite of each other, where the person staying at the head
    // table will be left out. Now let's rotate everyone clockwise and repeat
    // the same process N times. We claim that each pair of people will make a
    // handshake exactly once. One way to convince ourselves of that is to
    // choose an arbitrary person and reflect the offset from him for his
    // handshakes. Consider it's the person staying "last", on the "top" part of
    // the table. On the first round he will shake hands with the person with
    // offset 1 from him. On the second round they rotate so he shakes hands
    // with person before him that has offset n-1 from him, afterwards he moves
    // but everyone else moves so it's n-3, and if we continue we will see that
    // the offset always changes by 2. This is also true for any other person,
    // it's just that the initial offset could be different. We know that n is
    // odd and the change is also 2, so gcd(n, 2) = 1 and each of the offsets
    // will be visited exactly once in n steps.
    //
    // For even n, the case is almost the same - we will use the same table so
    // that gcd(size_table, 2) = 1, but one person will be left standing. They
    // will always do a handshake with the person sitting on the head space and
    // it's clear this means that they will shake hands with everyone too. In
    // this case we only need n-1 rounds.

    if (n == 1) {
        cout << "0\n0\n";
        return;
    }

    int num_rounds = (n % 2 == 0) ? n - 1 : n;
    cout << num_rounds << '\n';

    int table_size = (n % 2 == 0) ? n - 1 : n;
    vector<vector<int>> schedule(n, vector<int>(n, 0));

    for(int r = 0; r < num_rounds; r++) {
        if(n % 2 == 0) {
            int head_person = (table_size - r) % table_size;
            schedule[head_person][n - 1] = r + 1;
            schedule[n - 1][head_person] = r + 1;
        }

        for(int i = 1; i <= (table_size - 1) / 2; i++) {
            int p1 = ((i - r) % table_size + table_size) % table_size;
            int p2 =
                ((table_size - i - r) % table_size + table_size) % table_size;
            schedule[p1][p2] = r + 1;
            schedule[p2][p1] = r + 1;
        }
    }

    for(int i = 0; i < n; i++) {
        for(int j = 0; j < n; j++) {
            if(j > 0) {
                cout << ' ';
            }
            cout << schedule[i][j];
        }
        cout << '\n';
    }
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}
```

---

## 4) Python solution (same algorithm, detailed comments)

```python
import sys

def main():
    data = sys.stdin.read().strip().split()
    n = int(data[0])

    # Special case: N=1, no matches and thus 0 rounds; matrix is just [0].
    if n == 1:
        sys.stdout.write("0\n0\n")
        return

    # Minimal number of tours for complete graph K_n edge-coloring:
    # even n -> n-1, odd n -> n
    num_rounds = n - 1 if (n % 2 == 0) else n
    out_lines = [str(num_rounds)]

    # Size of the rotating "table":
    # odd n -> table has all n players
    # even n -> table has n-1 players, last player is "standing" and pairs with head each round
    table_size = n - 1 if (n % 2 == 0) else n

    # Initialize NxN schedule matrix with zeros
    schedule = [[0] * n for _ in range(n)]

    # For each round r (0-based internally; store r+1 in the matrix)
    for r in range(num_rounds):

        # Even case: pair the standing player (n-1) with the current "head" of the table
        if n % 2 == 0:
            head = (table_size - r) % table_size
            schedule[head][n - 1] = r + 1
            schedule[n - 1][head] = r + 1

        # Pair symmetric players on the table
        # There are (table_size-1)//2 pairs among table_size players each round
        half = (table_size - 1) // 2
        for i in range(1, half + 1):
            # Compute indices after rotation by r; Python % is already non-negative
            p1 = (i - r) % table_size
            p2 = (table_size - i - r) % table_size

            schedule[p1][p2] = r + 1
            schedule[p2][p1] = r + 1

    # Output the matrix with spaces
    for i in range(n):
        out_lines.append(" ".join(map(str, schedule[i])))

    sys.stdout.write("\n".join(out_lines) + "\n")

if __name__ == "__main__":
    main()
```

---

## 5) Compressed editorial

We need a round-robin schedule with minimum tours where each player plays at most once per tour. This is an edge-coloring of \(K_N\): minimum tours is \(N-1\) if \(N\) even, else \(N\).

Construction (circle method):
- If \(N\) is odd: for rounds \(r=0..N-1\), pair \((i-r) \bmod N\) with \((N-i-r)\bmod N\) for \(i=1..(N-1)/2\).
- If \(N\) is even: use a table of size \(N-1\) (players 0..N-2) and keep player \(N-1\) standing. Each round pairs standing player with head \((N-1-r)\bmod(N-1)\), and also pairs symmetric seated players as above on modulo \(N-1\).

Fill an \(N\times N\) matrix with round numbers (1-based), diagonal 0. Complexity \(O(N^2)\).