Zepto Code Rush 2014——Dungeons and Candies

const int maxn = 1100;

struct Edge
{
    int from, to, dist;
    int operator< (const Edge& rhs) const
    {
        return dist < rhs.dist;
    }
    Edge (int from = 0, int to = 0, int dist = 0)
    {
        this->from = from;
        this->to = to;
        this->dist = dist;
    }
};

vector<Edge> G[maxn];
int in[maxn];
vector<Edge> edges;
int fa[maxn];
char ipt[maxn][105];
int diff[maxn][maxn];
int n, m, k, w;
int find(int n)
{
    return (n == fa[n]) ? n : (fa[n] = find(fa[n]));
}
void init(int n)
{
    REP(i, n)
    {
        fa[i] = i;
        G[i].clear();
        in[i] = 0;
    }
    edges.clear();
}
void AddEdge(int u, int v, int dist)
{
    edges.push_back(Edge(u, v, dist));
}
void dfs(int u, int fa)
{
    REP(i, G[u].size())
    {
        Edge& e = G[u][i];
        if (e.to != fa)
        {
            if (e.dist == m * n)
                cout << e.to + 1 << ' ' << 0 << endl;
            else
                cout << e.to + 1 << ' ' << u + 1 << endl;
            dfs(e.to, u);
        }
    }
}
void solve()
{
    int ret = 0;
    sort(all(edges));
    REP(i, edges.size())
    {
        Edge& e = edges[i];
        int ru = find(e.from), rv = find(e.to);
        if (ru != rv)
        {
            fa[ru] = rv;
            ret += e.dist;
            G[e.from].push_back(Edge(e.from, e.to, e.dist));
            G[e.to].push_back(Edge(e.to, e.from, e.dist));
            in[e.from]++;
            in[e.to]++;
        }
    }
    WI(ret + n * m);
    REP(i, k)
    {
        if (in[i] <= 1)
        {
            cout << i + 1 << ' ' << 0 << endl;
            dfs(i, -1);
            break;
        }
    }
}

int judge(int a, int b)
{
    int cnt = 0;
    REP(i, n * m)
        cnt += (ipt[a][i] != ipt[b][i]);
    return cnt;
}

int main()
{
//    freopen("in.txt", "r", stdin);
    while (~RIV(n, m, k, w))
    {
        CLR(diff, 0);
        REP(i, k)
        {
            int len = 0;
            REP(j, n)
            {
                RS(ipt[i] + len);
                len = strlen(ipt[i]);
            }
        }
        REP(i, k) REP(j, k) REP(t, n * m)
            diff[i][j] += (ipt[i][t] != ipt[j][t]);
        init(k);
        REP(i, k) REP(j, k)
        {
            if (i == j)
                continue;
            AddEdge(i, j, min(diff[i][j] * w, n * m));
        }
        solve();
    }
    return 0;
}