FZU - 2254 英语考试(最小生成树）

在过三个礼拜，YellowStar有一场专业英语考试，因此它必须着手开始复习。

这天，YellowStar准备了n个需要背的单词，每个单词的长度均为m。

YellowSatr准备采用联想记忆法来背诵这n个单词：

1、如果YellowStar凭空背下一个新词T，需要消耗单词长度m的精力

2、如果YellowSatr之前已经背诵了一些单词，它可以选择其中一个单词Si，然后通过联想记忆的方法去背诵新词T，需要消耗的精力为hamming(Si, T) * w。

hamming(Si, T)指的是字符串Si与T的汉明距离，它表示两个等长字符串之间的汉明距离是两个字符串对应位置的不同字符的个数。

由于YellowStar还有大量繁重的行政工作，因此它想消耗最少的精力背诵下这n个单词，请问它最少需要消耗多少精力。

Input

包含多组测试数据。

第一行为n, m, w。

接下来n个字符串，每个字符串长度为m，每个单词均为小写字母'a'-'z'组成。

1≤n≤1000

1≤m, w≤10

Output

输出一个值表示答案。

Sample Input

3 4 2
abch
abcd
efgh

Sample Output

10

Hint

最优方案是：先凭空记下abcd和efgh消耗精力8,在通过abcd联想记忆去背诵abch，汉明距离为1,消耗为1 * w = 2,总消耗为10。

大体就是个最小生成树的问题， 每个单词就是一个点， 每两点间的权值为min（m, hamming(Si, T) * w)。

#include <iostream>
#include <cstring>
#include <algorithm>
#include <cstdio>
#define N 1123
#define INF 0x3f3f3f3f
using namespace std;
int Map[N][N];//存图
int dis[N];
int n, m, w;
int vis[N];
char str[N][15];//存单词
int prim();
int main()
{
    while(cin >> n >> m >> w)
    {
        cin.get();
        for(int i = 0; i < n; i++)
        {
            cin >> str[i];
        }
        memset(dis, 0, sizeof(dis));
        int i, j;
        for(i = 0; i < n; i++)
        {
            for(j = 0; j < n; j++)
            {
                int cnt = 0;
                for(int k = 0; k < m; k++)
                {
                    if(str[i][k] != str[j][k])
                    {
                        cnt++;
                    }
                }
                Map[i][j] = min(m, cnt * w);
            }
            Map[i][i] = INF;


        }
        cout << prim() << endl;

    }
    return 0;
}
int prim()
{
    memset(vis, 0, sizeof(vis));
    memset(dis, INF, sizeof(dis));
    for(int i = 1; i < n; i++)
    {
        dis[i] = Map[0][i];
    }
    int ans = 0;
    dis[0] = 0;
    vis[0] = 1;
    for(int j = 1; j < n; j++)
    {
        int Min = INF;
        int pos;
        for(int i = 1; i < n; i++)
        {
            if(Min > dis[i] && !vis[i])
            {
                Min = dis[i];
                pos = i;
            }
        }
        vis[pos] = 1;
        ans += Min;
        for(int i = 1; i < n; i++)
        {
            if(!vis[i] && Map[pos][i] < dis[i])
            {
                dis[i] = Map[pos][i];
            }
        }
    }
    return ans + m;
}