Acwing.1375 奶牛回家(最短路&朴素dijkstra)

题目

晚餐时间马上就到了，奶牛们还在各自的牧场中悠闲的散着步。

当农夫约翰摇动铃铛，这些牛就要赶回牛棚去吃晚餐。

在吃晚餐之前，所有奶牛都在自己的牧场之中，有些牧场中可能没有奶牛。

每个牧场都通过一条条道路连接到一个或多个其他牧场（可能包括其自身）。

有时，两个（可能是相同的）牧场通过一条以上的道路相连。

至少存在一个牧场与牛棚通过一条道路直接相连。

所有奶牛都能够成功的从自己的牧场沿道路返回牛棚。

聪明的奶牛们总会选择最短的路径回到牛棚之中。

每条道路都是可以双向行走的，奶牛的行走速度也都一样。

我们用 a∼z 和 A∼Y 来标记所有的牧场。

所有用大写字母标记的牧场中都存在一头奶牛，所有用小写字母标记的牧场中都不存在奶牛。

牛棚的标记为 Z ，这里最初是没有奶牛的。

现在你需要确定，哪一头奶牛能够最快到达牛棚，输出它最初所在的牧场的标记，并输出它走过的路径的长度。

注意，同一字母大小写标记的两个牧场（例如，牧场 A 和牧场 a ）是两个完全不同的牧场。

输入格式

第一行包含整数 P ，表示连接牧场以及牛棚的道路的条数。

接下来 P 行，每行包含两个字母以及一个整数，表示被一条道路连接的两个牧场的标记，以及这条道路的长度。

输出格式

输出一个字母和一个整数，表示最快回到牛棚的牛最初所在的牧场的标记以及它走过的路径的长度。

数据保证最快回到牛棚的牛只有一头。

数据范围

1≤P≤10000 , 所有道路长度均不超过 1000 。

• 输入样例：

5
A d 6
B d 3
C e 9
d Z 8
e Z 3

• 输出样例：

B 11

题解

import java.io.*;
import java.util.Arrays;

/**
 * @author akuya
 * @create 2024-04-13-12:29
 */
public class CowGoHome {
    static int N=60;
    static int n=52,m;
    static int g[][]=new int[N][N];
    static int dist[]=new int[N];
    static boolean st[]=new boolean[N];
    public static void main(String[] args) throws IOException {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        PrintWriter pw=new PrintWriter(new OutputStreamWriter(System.out));

        for(int i=0;i<N;i++){
            Arrays.fill(g[i],0x3f3f3f);
        }

        m=Integer.parseInt(br.readLine());
        while(m--!=0){
            String s[]=br.readLine().split(" ");
            char a=s[0].charAt(0);
            char b=s[1].charAt(0);
            int r=Integer.parseInt(s[2]);
            int A=get(a);
            int B=get(b);
            g[A][B]=g[B][A]=Math.min(g[A][B],r);
        }

        Dijkstra();

        int res=1;
        for(int i=2;i<=25;i++)
            if(dist[i]<dist[res])
                res=i;

        pw.println((char)(res-1+'A')+" "+dist[res]);
        br.close();
        pw.flush();
        pw.close();

    }

    public static int get(char c){
        if(c<='Z'){
            return c-'A'+1;
        }else return c-'a'+27;

    }

    public static void Dijkstra(){
        Arrays.fill(dist,0x3f3f3f);
        dist[26]=0;

        for(int i=0;i<n-1;i++){
            int t=-1;
            for(int j=1;j<=n;j++){
                if(!st[j]&&(t==-1||dist[j]<dist[t]))
                    t=j;
            }

            st[t]=true;

            for(int j=1;j<=n;j++)
                dist[j]=Math.min(dist[j],dist[t]+g[t][j]);

        }
    }

}

思路

本题为经典的单源最短路问题，因为可以从终点往其他节点遍历。然后是如何选择的问题，最短路选择什么方法。具体选择方法如图所示。这道题优先选择朴素dijstra算法，背诵模板使用即可。