[topcoder]KingdomReorganization

http://community.topcoder.com/stat?c=problem_statement&pm=11282&rd=14724

这道题是最小生成树，但怎么转化是关键。首先是把所有的路都destroy掉，得到基本的MassiveCost，然后在选MST的过程中，遇上这些边相当于还回去，它们的cost就是-destroy[i][j]。这样转化完毕。

用Kruskal来做，注意生成Edge的过程，第二层循环j要从i+1开始，主要是避免把i到i的路也放进去。

此题算是比较经典的K算法的题了。（没有用并查集）

import java.util.*;
public class KingdomReorganization
{
    public int getCost(String[] kingdom, String[] build, String[] destroy)
    {
        ArrayList<Edge> edges = new ArrayList<Edge>();
        int len = kingdom.length;
        int basicCost = 0;
        // create edges with cost
        for (int i = 0; i < len; i++)
        {
            for (int j = i+1; j < len; j++)
            {
                Edge edge = new Edge();
                edge.a = i; edge.b = j;
                if (kingdom[i].charAt(j) == '0')
                {
                    edge.cost = getValue(build, i, j);
                }
                else
                {
                    int tmp = getValue(destroy, i, j);
                    basicCost += tmp;
                    edge.cost = -tmp;
                }
                edges.add(edge);
            }
        }
        // Kruskal algo
        Collections.sort(edges);
        int[] color = new int[len];
        for (int i = 0; i < len; i++)
        {
            color[i] = i;
        }
        int cost = basicCost;
        for (int i = 0; i < edges.size(); i++)
        {
            Edge e = edges.get(i);
            if (color[e.a] == color[e.b]) continue;
            cost += e.cost;
            int oldColor = color[e.a];
            for (int k = 0; k < len; k++)
            {
                if (color[k] == oldColor)
                {
                    color[k] = color[e.b];
                }
            }
        }
        return cost;
    }

    private int getValue(String[] costs, int i, int j)
    {
        char c = costs[i].charAt(j);
        if (c >= 'A' && c <= 'Z')
        {
            return c - 'A';
        }
        else
            return c - 'a' + 26;
    }
}

class Edge implements Comparable<Edge>
{
    public int a;
    public int b;
    public int cost;
    public int compareTo(Edge rhs)
    {
        return this.cost - rhs.cost;
    }
}