#include <bits/stdc++.h>
#define DIM 410
#define INF 2000000000
using namespace std;

vector <int> L[DIM],w;
deque <int> c;
int a[DIM][DIM],capacitate[DIM][DIM],flux[DIM][DIM],cst[DIM][DIM],t[DIM],dist[DIM],viz[DIM];
int n,i,j,sursa,dest;

void add_edge (int x, int y, int cap, int cost){
    L[x].push_back(y);
    L[y].push_back(x);
    capacitate[x][y] = cap;
    cst[x][y] = cost;
    cst[y][x] = -cost;
}

int bellman_ford (int start){

    for (int i=sursa;i<=dest;i++)
        dist[i] = INF, t[i] = -1, viz[i] = 0;
    c.clear();

    c.push_back(start);
    viz[start] = 1;
    dist[start] = 0;
    while (!c.empty()){
        int nod = c.front();
        c.pop_front();
        viz[nod] = 0;

        for (auto vecin : L[nod]){
            if (capacitate[nod][vecin] <= flux[nod][vecin])
                continue;

            if (dist[nod] + cst[nod][vecin] < dist[vecin]){
                dist[vecin] = dist[nod] + cst[nod][vecin];
                t[vecin] = nod;
                //w[nod].clear();
                //w[nod].push_back(vecin);
                if (!viz[vecin]){
                    c.push_back(vecin);
                    viz[vecin] = 1;
                }
            } /*else {
                if (dist[nod] + cst[nod][vecin] == dist[vecin])
                    w[nod].push_back(vecin);
            }*/
        }
    }

    return dist[dest] != INF;
}

int find_flux (){

    int sol = 0;
    while (bellman_ford(0)){
        int x = dest, dif = INF;
        while (x != sursa){
            dif = min (dif,capacitate[t[x]][x] - flux[t[x]][x]);
            x = t[x];
        }

        x = dest;
        while (x != sursa){
            flux[t[x]][x] += dif;
            flux[x][t[x]] -= dif;
            sol += dif * cst[t[x]][x];
            x = t[x];
        }

    }

    return sol;

}

int main (){

    ifstream cin ("paznici2.in");
    ofstream cout ("paznici2.out");

    cin>>n;
    for (i=1;i<=n;i++)
        for (j=1;j<=n;j++){
            cin>>a[i][j];
            add_edge (i,j+n,1,a[i][j]);
        }

    sursa = 0, dest = 2*n+1;

    for (i=1;i<=n;i++){
        add_edge (sursa,i,1,0);
        add_edge (i+n,dest,1,0);
    }


    int sol = find_flux();
    cout<<sol<<"\n";

    for (i=n+1;i<=2*n;i++){

        bellman_ford(i);

        w.clear();
        for (j=1;j<=n;j++)
            if (dist[j] == cst[i][j])
                w.push_back(j);

        sort (w.begin(), w.end());

        cout<<w.size()<<" ";
        for (auto it : w)
            cout<<it<<" ";

        cout<<"\n";
    }



    return 0;
}