#include <iostream>
#include <fstream>
#include <deque>
#include <vector>
#include <algorithm>

using namespace std;

const char iname[] = "paznici2.in";
const char oname[] = "paznici2.out";

#define MAXN  405
#define FOR(i, a, b)  for (int i = (a); i <= (b); ++ i)

int cst[MAXN][MAXN], cap[MAXN][MAXN];

vector <int> adj[MAXN];

void BF(const int src, vector <int>& dist, vector <int>& prt)
{
    const int infinity = int(1e9);

    deque <int> que;
    vector <int> inq(MAXN, 0);
    vector <int>::iterator it;

    dist.assign(MAXN, infinity);
    prt.assign(MAXN, -1);

    dist[src] = 0, que.push_back(src), inq[src] = 1;
    for (; que.size(); que.pop_front())
    {
        int x = que.front();
        for (it = adj[x].begin(); it != adj[x].end(); ++ it)
        {
            if (cap[x][*it] < 1)   continue ;

            if (dist[*it] > dist[x] + cst[x][*it])
            {
                dist[*it] = dist[x] + cst[x][*it];
                prt[*it] = x;
                if (!inq[*it])
                    que.push_back(*it), inq[*it] = 1;
            }
        }
        inq[x] = 0;
    }
}

int main(void)
{
    ifstream in(iname);  ofstream out(oname);
    int n;

    in >> n;
    FOR (i, 1, n) FOR (j, 1, n) {
        in >> cst[i][n + j];
        cst[n + j][i] = -cst[i][n + j];
        cap[i][n + j] = 1;
        adj[i].push_back(n + j), adj[n + j].push_back(i);
    }
    int src = 0;
    FOR (i, 1, n)
        cst[src][i] = 0, cap[src][i] = 1, adj[src].push_back(i);
    int sink = 2 * n + 1;
    FOR (i, n + 1, 2 * n)
        cst[i][sink] = 0, cap[i][sink] = 1, adj[i].push_back(sink);

    int res = 0;
    vector <int> dist(MAXN), prt(MAXN);
    FOR (i, 1, n) {
        BF(src, dist, prt);
        res += dist[sink];
        for (int node = sink; prt[node] != -1; node = prt[node])
            cap[ prt[node] ][node] --,
            cap[node][ prt[node] ] ++;
    }

    out << res << "\n";

    FOR (i, 1, n) {
        BF(n + i, dist, prt);

        vector <int> sol;
        FOR (j, 1, n) if (dist[j] + cst[j][n + i] == 0)
            sol.push_back(j);

        out << sol.size();
        for (size_t j = 0; j < sol.size(); ++ j)
            out << " " << sol[j];
        out << "\n";
    }

    in.close(), out.close();
    return 0;
}