大臣的旅费

最新推荐文章于 2021-03-01 23:29:55 发布

糖人豆丁

最新推荐文章于 2021-03-01 23:29:55 发布

阅读量1.3k

点赞数 1

分类专栏：算法搜索图论文章标签：图论搜索算法

本文链接：https://blog.csdn.net/newmemory/article/details/50853263

版权

算法同时被 3 个专栏收录

20 篇文章 0 订阅

订阅专栏

搜索

16 篇文章 0 订阅

订阅专栏

图论

4 篇文章 0 订阅

订阅专栏

问题描述
很久以前，T王国空前繁荣。为了更好地管理国家，王国修建了大量的快速路，用于连接首都和王国内的各大城市。

为节省经费，T国的大臣们经过思考，制定了一套优秀的修建方案，使得任何一个大城市都能从首都直接或者通过其他大城市间接到达。同时，如果不重复经过大城市，从首都到达每个大城市的方案都是唯一的。

J是T国重要大臣，他巡查于各大城市之间，体察民情。所以，从一个城市马不停蹄地到另一个城市成了J最常做的事情。他有一个钱袋，用于存放往来城市间的路费。

聪明的J发现，如果不在某个城市停下来修整，在连续行进过程中，他所花的路费与他已走过的距离有关，在走第x千米到第x+1千米这一千米中（x是整数），他花费的路费是x+10这么多。也就是说走1千米花费11，走2千米要花费23。

J大臣想知道：他从某一个城市出发，中间不休息，到达另一个城市，所有可能花费的路费中最多是多少呢？

输入格式
输入的第一行包含一个整数n，表示包括首都在内的T王国的城市数

城市从1开始依次编号，1号城市为首都。

接下来n-1行，描述T国的高速路（T国的高速路一定是n-1条）

每行三个整数Pi, Qi, Di，表示城市Pi和城市Qi之间有一条高速路，长度为Di千米。

输出格式
输出一个整数，表示大臣J最多花费的路费是多少。

样例输入1
5
1 2 2
1 3 1
2 4 5
2 5 4
样例输出1
135
输出格式
大臣J从城市4到城市5要花费135的路费。

因为需要存储权值，所以需要使用邻接矩阵。

1.解法1：使用弗洛伊德算法（超时）
根据题意，这是一个无圈的连通图，而且由于其边数等于顶点数-1，所以这是一棵树。所以在给定权值的情况下，顶点到其余顶点的距离是固定的，不存在最大最小值问题，所以这道题也可以使用弗洛伊德算法。
求解所有两点间的最短路的问题叫做任意两点间的最短路问题，可以使用Floyd-Warshall算法求解。
但需要注意的是弗洛伊德算法的时间复杂度高达O(n^3),很容易就超时了，所以不适用于有大规模测试数据的程序


import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        final int INF = 10000000;
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            int N = in.nextInt();
            int[][] graph = new int[N+10][N+10];
            /*注意graph[i][j]表示权值，不存在时设为INF(无穷大，很形象），不过尤其要注意的是grap[i][i]=0*/
            for(int i=0;i<N+10;i++){
                for(int j=0;j<N+10;j++){
                    if(i==j) graph[i][j] = 0;
                    else graph[i][j] = INF;
                }
            }
            int s,d,v;
            for(int i=1;i<N;i++){
                s = in.nextInt();
                d = in.nextInt();
                v = in.nextInt();
                graph[s][d] = graph[d][s] = v;
            }
            long t1 = System.currentTimeMillis();
            int maxLen=-1;
            for(int k=1;k<=N;k++){
                for(int i=1;i<=N;i++){
                    for(int j=1;j<=N;j++) {
                        graph[i][j] = Math.min(graph[i][j], graph[i][k]+graph[k][j]);
                        if((graph[i][j]!=INF)&&(maxLen<graph[i][j])) maxLen = graph[i][j];
                    }
                }
            }
            int ans = 11*maxLen+(maxLen*(maxLen-1))/2;
            System.out.println(ans);
            long t2 = System.currentTimeMillis();
            //System.out.println("Time cost:"+(t2-t1));
        }
    }

}

基本思想就是：最开始只允许经过1号顶点进行中转，接下来只允许经过1和2号顶点进行中转……允许经过1~n号所有顶点进行中转，求任意两点之间的最短路程。用一句话概括就是：从i号顶点到j号顶点只经过前k号点的最短路程。其实这是一种“动态规划”的思想。
其状态转移方程如下： map[i,j]:=min{map[i,k]+map[k,j],map[i,j]}；
map[i,j]表示i到j的最短距离，K是穷举i,j的断点，map[n,n]初值应该为0，或者按照题目意思来做。当然，如果这条路没有通的话，还必须特殊处理，比如没有map[i,k]这条路。

当N取10000时，时间复杂度达到10^12，这在1s的时间限制内肯定爆掉！
这里写图片描述

2 . 解法2：使用深度优先遍历
首先，这道题涉及到《算法导论》中的一个问题，求树的直径，何为树的直径呢？
树T=（V,E）的直径（diameter）定义为max(u,v)，亦即，树的直径是树中所有最短路径长度中的最大值。
求一个树的直径有如下算法：
s1: 以树中任一结点t为源点，进行搜索（DFS，BFS）至叶子节点u。
s2: 从u继续搜索，直至不能搜了，到点v，并记录其长度。
u与v之间的距离，即为所求树的直径。
为什么呢？
这可以通过反证法来进行证明。
证明：path(t,u)与树的直径没有任何公共点，但由于在树中，可以从直径向u引一条线，结果就会得到一条更长的树的直径，这就与已经得到的树的直径相矛盾了。所以path(t,u)一定与树的直径有至少一个公共点，取其中一个记为k，则path(k,u)一定是树直径的一部分。为什么不是path(t,k)呢？因为u一定是叶子节点（通过第一次搜索得到的）。
然后就保证了u是树的直径的一个端点，然后从u开始再进行搜索，就会得到树的另一个端点v。

本题实际上是要求树中最远的两个点，可以使用两遍深度优先遍历解决。第一遍从1号点开始，找到距1号点最远的点a，如果有多个任取一个即可。第二遍从2号点开始，找到距a最远的点b，则a和b就是最远的两个点。

detail：
1. 本来也是用邻接矩阵进行图的存储的，毕竟便于查找吗，可是交了几次后却总是最后一个样例过不了，看其评测状态时才发现内存使用达到了400MB以上。平时总是注意算法的时间复杂度，却忽视了空间复杂度！
2. 使用邻接矩阵的好处是可以在常数时间内判断两点之间是否有边存在，但是需要花费O(|V|^2)的空间。在|V|达到1000000时，即使邻接矩阵中的每个元素只需要1个字节的空间，整个数组也需要1TB才能存下！在这道题中使用邻接表才能通过
3. 使用邻接表来存储图，由于边上有权值，所以需要两个arraylist，一个存储顶点，一个存储对应的边。因为当初始点固定的时候，其余的顶点与其之间的边是一一对应的，可以用一个for循环进行控制，这也是为什么在DFS中还需要每次获取当前顶点的size，而不是使用foreach循环的原因。
4. 注意我们获取一个点t到其余点的最大距离，是通过一个数组dis来实现的，由于初始置dis[t]=0，并在后续搜索中将与t相邻的点通过dis[t]= dis[t] + edges[t].edge.get(i)来一步一步递推维护，最终即可得到最长边和最长边对应的端点

代码如下：


import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;

//包含一个arraylist
class Edge{
    ArrayList<Integer> edge = new ArrayList<Integer>(); 
}
class Vertex{
    ArrayList<Integer> ver = new ArrayList<Integer>();
}

public class Main {

    public static boolean DEBUG = true;
    public static int N,INF=1000000000 ;
    public static Vertex[] vertexs;
    public static Edge[] edges ;
    public static int[] dis;
    public static boolean[] visited;

    public static void init(){
        for(int i=0;i<N+10;i++){
            vertexs[i] = new Vertex();
            edges[i] = new Edge();
        }
    }
    public static void show(){
        System.out.println("Output graph:");
        for(int i=1;i<=N;i++){
            int t = vertexs[i].ver.size();
            for(int j=0;j<t;j++){
                System.out.print("i:"+i+",");
                System.out.println(vertexs[i].ver.get(j)+":"+edges[i].edge.get(j));
            }
        }
        System.out.println();
    }
    public static void show1(){
        for(int i=1;i<=N;i++) System.out.println(i+":"+dis[i]);
    }
    public static void test(){
        System.out.println("test!");
    }
    //搜索将结果存到数组中，然后一次次的递推
    //求起始点到其余点的距离,在上一层的递归中已经给出了i到t的距离，存储在了dis[t]中，所以与t相邻的再直接加上dis[t]就是源点到其距离

    public static void DFS(int t){
        int size = vertexs[t].ver.size();
        for(int i=0;i<size;i++){//第t个节点的所有边的另一顶点
            int j = vertexs[t].ver.get(i);
            if(!visited[j]){
                dis[j] = dis[t] + edges[t].edge.get(i);
                visited[j] = true;
                DFS(j);
            }
        }

    }
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Scanner in = new Scanner(System.in);
        while(in.hasNext()){
            N = in.nextInt();
            vertexs = new Vertex[N+10];
            edges = new Edge[N+10];
            visited = new boolean[N+10];
            dis = new int[N+10];
            init();
            int s,d,v;
            for(int i=1;i<N;i++){
                s = in.nextInt();
                d = in.nextInt();
                v = in.nextInt();
                //边与顶点一一对应
                vertexs[s].ver.add(d);
                edges[s].edge.add(v);

                vertexs[d].ver.add(s);
                edges[d].edge.add(v);
            }
            //show();
            Arrays.fill(visited, false);
            Arrays.fill(dis, INF);
            dis[1] = 0;
            visited[1] = true;
            DFS(1);
            //show1();
            int start=-1,maxLen=-1;
            for(int i=1;i<=N;i++){
                if(dis[i]!=INF&&maxLen<dis[i]){
                    start = i;
                    maxLen = dis[i];
                }
            }
            //System.out.println("start:"+start+",maxlen:"+maxLen);
            Arrays.fill(visited, false);
            Arrays.fill(dis, INF);
            dis[start] = 0;
            visited[start] = true;
            DFS(start);
            //show1();
            for(int i=1;i<=N;i++){
                if(dis[i]!=INF&&maxLen<dis[i]){
                    start = i;
                    maxLen = dis[i];
                }
            }
            long ans = maxLen*11+(maxLen*(maxLen-1))/2;
            System.out.println(ans);
        }
    }

}