问题描述

小蓝国是一个水上王国, 有 2021 个城邦, 依次编号 1 到 2021。在任意两个城邦之间, 都有一座桥直接连接。

为了庆祝小蓝国的传统节日, 小蓝国政府准备将一部分桥装饰起来。

对于编号为 a 和 b 的两个城邦, 它们之间的桥如果要装饰起来, 需要的费用如下计算:

找到 a 和 b 在十进制下所有不同的数位, 将数位上的数字求和。

例如, 编号为 2021 和 922 两个城邦之间, 千位、百位和个位都不同, 将这些数位上的数字加起来是 (2+0+1)+(0+9+2)=14 。注意 922 没有千位, 千位看成 0 。

为了节约开支, 小蓝国政府准备只装饰 2020 座桥, 并且要保证从任意一个城邦到任意另一个城邦之间可以完全只通过装饰的桥到达。

请问, 小蓝国政府至少要花多少费用才能完成装饰。

提示: 建议使用计算机编程解决问题。

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数, 在提交答案时只填写这个整数, 填写多余的内容将无法得分。

本题答案是：4046。

运行限制

最大运行时间：1s
最大运行内存: 256M

思路分析

首先，他的花费计算是，两个数A,B，如果A和B相对应的位数不同，就相加。

如：2017和917这两个数的花费是:(2+0)+(0+9),因为个位他们都是7，所以省略了，十位也是同理，然后917没有千位，默认是0。所以2017和917的花费就是(2+0)+(0+9)=11

然后再看题目，很明显跟图有关，一共有2021个节点，题目要求我们让所有节点都能连通起来，让我们使用2020条边，同时要求花费最少。

判断是否连通需要用到并查集，然后在确保花费最少可以用贪心的策略，每次选择花费最少的一条边，让两个节点相连。

条件这么清楚了，很明显的要用到最小生成树了，这道题就是经典板子题。

如果不了解什么是最小生成树，可以搭配视频理解，我下面简单说一下。

视频链接：最小生成树(Kruskal(克鲁斯卡尔)和Prim(普里姆))算法动画演示

首先，需要是一个带权的图，在本题中，两个城堡之间如果需要连接起来，那么需要花费一定费用，将两座城堡之间建立连接。那么，换个思路来，两个城堡是图中的节点，然后他们之间互相连接的边，就是这两座城邦建立连接所需要的花费；而且，我们需要任意一个城堡都能到达另一个城堡，那么，就代表着这些节点之间需要互相连通，这样他们才能互相到达另一边。

因此可以把题目的城堡当作连通带权无向图来处理。

题目条件也给出了，一共有2021个城堡，也就是一共有2021个节点。我们需要用2020座桥把他们连接起来，也就是一共有2020条边。并且我们要让花费最小。

所谓的最小成本了：就是n个顶点，用n-1条边把一个连通图连接起来，并使得权值的和最小。所以，我们把构成连通图的最小代价生成树叫做最小生成树。

而最小生成树，有两个经典的算法，Kruskal和Prim，这里我们使用Kruskal比较容易理解。

我们可以将节点x与节点y的花费存起来，用一个类（结构体）来存储节点x，节点y，节点x与y的连通花费。

class Node{
        // x <-> y
        int x;  //节点x
        int y;  //节点y
        int cost;   //连接x和y的花费
        public Node(int x, int y, int cost) {
            this.x = x;
            this.y = y;
            this.cost = cost;
        }
    }

然后将其存入一个数组之中，之后遍历1-2021，算出所有节点互相之间连通需要的花费，并存入数组之中，后续按照连通花费，进行升序排序，这样保证前面的连通花费是最少的，我们根据Kruskal的思想，从最少连通花费进行连接，把x和y连接起来。

将1-2021之间所有节点与边的关系添加到数组之后，我们就需要对数组进行排序了，要完成Kruskal算法之中花费从小到大排序，也就是升序，我们就需要对数组进行排序。

但是我们开的数组肯定是远大于我们实际需要使用到的大小，所以我们需要用一个变量记录使用到哪个位置，然后排序的时候选择从0-变量记录的位置，然后使用升序排序即可（一般默认排序都是升序排序）。之后就是判断连通的问题了。

既然要判断是否连通，那么就要用到并查集来检查连通了。

如果对并查集不太懂，可以看：【算法与数据结构】—— 并查集（写的非常好）。

这里贴上代码，不展开介绍了。

    int[] pre;
    public void initPre(){
        //并查集找连通
        pre = new int[2022];
        //初始化并查集
        for(int i = 0;i<pre.length;i++){
            pre[i] = i;
        }
    }
    public int find(int x){
        //做一下路径压缩
        if(pre[x] == x) return x;
        return pre[x] = find(pre[x]);
    }
    public void join(int x,int y){
        int fx = find(x);
        int fy = find(y);
        if(fx!=fy)
            pre[fx] = fy;
    }

如果将x和y连通，将产生环，该如何判断呢？

我们需要通过并查集找到节点x它的父亲是谁，和y的父亲进行比较，如果他们的父亲相同，代码x已经可以和y同时到达同一个地点，如果我们再让x和y进行连接，那么肯定会产生环。

如：

如果我们的x是1，y是3，我们通过并查集的find()可以知道他们的父亲都是4，如果再让他们连通，则肯定会产生环。

所以我们需要判断x和y的父亲是不是同一个，如果不是，那么就可以使用并查集的join()将他们连接起来，并且将连接他们的花费记录到答案之中，因为这是构造连通的最优解。

之后根据定义，我们只需要成功连通2020个边（n个节点需要n-1个边），就完成了1-2021之间的连通，他们之间就可以从任意一个节点到另一个节点，并且花费是最小的了。

代码（Java）

不知道为什么在蓝桥那边提交显示超时，我在本地跑就只用了380±20ms。

import java.util.*;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    static int[] pre;
    public static int find(int x){
        //做一下路径压缩
        if(pre[x] == x) return x;
        return pre[x] = find(pre[x]);
    }
    public static void join(int x,int y){
        int fx = find(x);
        int fy = find(y);
        if(fx!=fy)
            pre[fx] = fy;
    }

    static class Node{
        // x <-> y
        int x;  //节点x
        int y;  //节点y
        int cost;   //连接x和y的花费
        public Node(int x, int y, int cost) {
            this.x = x;
            this.y = y;
            this.cost = cost;
        }
    }
    public static void main(String[] args) {
        //程序开始时间
        long startTime = System.currentTimeMillis();

        //并查集找连通
        pre = new int[2022];
        //初始化并查集
        for(int i = 0;i<pre.length;i++){
            pre[i] = i;
        }
        //空间换时间
        Node[] minTree = new Node[2021*2021];
        int index = 0;
        //将边的信息存储到数组中
        for(int i = 1;i<2021;i++){
            for(int j = i+1;j<=2021;j++){
                int cost = cost(i,j);
                minTree[index++] = new Node(i,j,cost);
            }
        }
        //按照花费进行升序排序,排序范围是0-index，也就是存储有边信息的部分
        Arrays.sort(minTree,0,index,(n1,n2)->(n1.cost-n2.cost));
        //总花费
        int res = 0;
        //依次取出顶部（前面）的边，判断该x和y添加进去是否会产生环，如果不会就使用这条边；如果会就丢弃这条边
        for(int i = 0;i<index;i++){
            Node node = minTree[i];
            if(find(node.x)!=find(node.y)){
                join(node.x,node.y);
                res += node.cost;
            }
        }

        System.out.println(res);

        //程序结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("程序执行耗时: "+(endTime-startTime)+" ms");
    }

    public static int cost(int x,int y){
        int res = 0;
        while(x>0 || y>0){
            int a = x%10;
            int b = y%10;
            if(a!=b) res += a+b;
            x /= 10;
            y /= 10;
        }
        return res;
    }
}

程序运行结果：