【备战秋招】每日一题:2023.05.10-华为OD机试(第三题)-快乐校园跑

为了更好的阅读体检，可以查看我的算法学习博客
在线评测链接:P1308

题目描述

国内大多数高校都会有一个活动，叫做校园跑。校园跑是一种在校园内进行的跑步运动，旨在提高学生的身体素质和团队合作能力。校园跑的规则是，每个参与者都要从自己所在的建筑物出发，沿着校园内的道路跑步，每到一个建筑他们需要到达这个建筑物的必经点，这样他们的手机会自动记录一次该建筑物。每个参与者都要尽可能多地经过必经点，同时也要尽可能快地完成跑步。

每个参与者的成绩由两个指标决定：经过的必经点个数和跑步总时间。经过的必经点个数越多，跑步总时间越短，成绩越好。校园跑不仅可以锻炼身体，还可以增加对校园各个建筑物的了解和认同感。

塔子哥也参加了他的学校的这个活动，由很多个建筑物组成，每个建筑物都有一个编号，从1到 $n$ 。一个学生从某个建筑物开始，沿着校园中的道路跑步。

由于学社联为了丰富这个活动的内容，让这个活动变得更好玩，他们会在一些建筑物的必经点安排一些小游戏，到达必经点后需要完成这些小游戏才能继续进行跑步。

但是仅一个人把学校所有的建筑物都跑完并完成小游戏，又会过于疲惫，于是学社联允许参加的学生们进行组队，以用时最长的那个人的成绩作为最终成绩。

塔子哥和他的同学组成了一支小队（不限人数），他们想知道，从某个建筑物开始跑步，最多能经过多少个必经点，以及完成跑步的最快时间是多少。

我们已经知道了每个建筑物之间跑步的时间，以及每个必经点完成小游戏的时间，这些时间都用 $runTimes$ 列表给出了。

$runTimes[i]$ 表示从建筑物 $u$ 到 $v$ 建筑物的时间是 $runTime$ ，如果 $u$ 和 $v$ 相同，就表示是这个必经点需要玩小游戏的时间。那么，从 $u$ 到 $v$ 的时间就是两者相加。现在给定一个起始建筑物 $x$，请计算出完成跑步后能经过的最多必经点数和最终成绩时间。

输入描述

输入第一行为一个正整数 $n$ ，表示建筑物的个数.($1\le n\le 100$)

输入第二行为一个正整数 $m$ ，表示路径的条数.($1\le m\le 10^4$)

接下来 m 行输入每行为三个正整数 $u,v,runTime$，表示 $runTimes[i]$ 的三个元素，即从 u->v 需要的时间为 $runTime$,但不代表 v->u 也是如此.($1\le u,v,runTime\le 100$)

最后一行输出校园跑的起点 $x$.($1\le x\le n$)

输出描述

输出为2行。第一行输出为最终可经过的的必经点个数，第二行输出这些塔子哥小队全部完成跑步后的具体时间。

样例1

样例输入

5
9
1 2 3
1 3 4
2 4 6
2 5 7
5 5 5
4 4 4
3 3 3
2 2 2
1 1 1
1

样例输出

5
17

样例解释

​ 以建筑物1为起点计算小队最长耗时，分析可能会存在三条最大耗时路径,分别为1->3以及1->2->5以及1->2->4。

​ 第一条路径1->3路径下,总耗时为4(1->3耗时)+3(3自身耗时)=7。第二条路径1->2->5路径下,总耗时为3(1->2耗时)+2(2自身耗时)+7(2->5耗时)+5(5自身耗时)=17。第三条路径1->2->4路径下,总耗时为3(1->2耗时)+2(2自身耗时)+6(2->4耗时)+4(4自身耗时)=15。

​ 所以在此场景下，小队完成跑步的最短时间为38分钟，为可以经过的所有必经点的最长时间。

​ 最终输出结果分两行输出，最终12345五个必经点都可以经过，所以最终输出结果如样例1输出。

样例2

样例输入

5
6
1 2 10
1 3 20
2 4 30
3 4 40
4 5 50
5 1 60
3

样例输出

5
160

思路：floyd最短路

通过理解题意我们可以知道，由于组队不限人数，因此答案即为从起点出发，到达其它任一建筑物所需要花费的最长的时间(可以想象队里无数个人，每个人出发只去一个建筑物，最长的时间就是花费最多时间的那个人所耗时)，而最多必经点数则为从起点出发能够到达的点。

floyd算法：

定义 $f[i][j]$ 为从 $i$ 出发到达 $j$ 点所需要花费的时间。

直观理解上，我们从 $i$ 到 $j$ ，无非就是两个选择；

1. $i$ 到 $j$ 有直达的路，所以直接从 $i$ 前往 $j$
2. 通过另一个点 $k$ 作为中继，先去 $k$ ，再从 $k$ 去 $j$

于是其算法方程就出来了：$f[i][j]=min(f[i][j],f[i][k]+f[k][j])$

直观理解就是，在两个路线的方案选择中，选择耗时较少的方案。

于是为了求出任意 $f[i][j]$ ，我们需要枚举 $k,i,j$ 三个变量，每个都可以从 $N$ 个点中选择其一，所以其时间复杂度为$O(N^3)$，一般看到数据量为100左右，就很有可能是该算法。

在本题中，需要稍稍做点修改：

其中，$a[i]$ 为在 $i$ 点做游戏所需要的时间。可以就着原理稍微理解一下。

if(k==j){// 中继点和终点相同，相当于直接从i前往j 
    f[i][j]=min(f[i][j],f[i][k]+a[k]);
}else{// 中继点和终点不同，通过中继点更新 
    f[i][j]=min(f[i][j],f[i][k]+f[k][j]);
}

类似题目推荐

代码

C++

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;

int n,m;
int Map[105][105];
int f[105][105];
int a[105];
int s;

int main(){
	scanf("%d %d",&n,&m);
	// floyd算法
	// 初始化 
	// 初始化为极大值 
	memset(f,0x3f,sizeof(f));
	for(int i=1,x,y,t;i<=m;++i){
		scanf("%d %d %d",&x,&y,&t);
		if(x!=y) f[x][y]=t;
		else a[x]=t;
	}
	// 更新从i到j所需要时间加上玩游戏的时间 
	for(int i=1;i<=n;++i){
		for(int j=1;j<=n;++j){
			if(i!=j) f[i][j]+=a[j];
		}
	} 
	for(int i=1;i<=n;++i) f[i][i]=0;// 由于玩游戏时间已经加在路程时间上了，因此从i到i时间应该为0 
	// 求解 
	for(int k=1;k<=n;++k){
		for(int i=1;i<=n;++i){
			for(int j=1;j<=n;++j){
				if(i==j) continue;
				if(k==j){// 中继点和终点相同，相当于直接从i前往j 
					f[i][j]=min(f[i][j],f[i][k]+a[k]);
				}else{// 中继点和终点不同，通过中继点更新 
					f[i][j]=min(f[i][j],f[i][k]+f[k][j]);
				}
			}
		}
	}
	scanf("%d",&s);
	int sum=0,maxx=0;
	for(int i=1;i<=n;++i){
		if(i==s) continue;
		if(f[s][i]<0x3f3f3f3f){
			sum++;
			maxx=max(maxx,f[s][i]);
		}
	}
	printf("%d\n%d",sum+1,maxx);// 别忘记答案加上起点 
	
	return 0;
}

python

import sys

n, m = map(int, sys.stdin.readline().split())
Map = [[float('inf')] * 105 for _ in range(105)]
f = [[float('inf')] * 105 for _ in range(105)]
a = [0] * 105
s = 0

for i in range(1, m + 1):
    x, y, t = map(int, sys.stdin.readline().split())
    if x != y:
        Map[x][y] = t
    else:
        a[x] = t

for i in range(1, n + 1):
    for j in range(1, n + 1):
        if i != j:
            Map[i][j] += a[j]  # 更新从i到j所需要时间加上玩游戏的时间

for i in range(1, n + 1):
    f[i][i] = 0  # 由于玩游戏时间已经加在路程时间上了，因此从i到i时间应该为0

# 求解
for k in range(1, n + 1):
    for i in range(1, n + 1):
        for j in range(1, n + 1):
            if i == j:
                continue
            if k == j:  # 中继点和终点相同，相当于直接从i前往j
                f[i][j] = min(f[i][j], f[i][k] + a[k])
            else:  # 中继点和终点不同，通过中继点更新
                f[i][j] = min(f[i][j], f[i][k] + f[k][j])

s = int(sys.stdin.readline())
sum = 0
maxx = 0

for i in range(1, n + 1):
    if i == s:
        continue
    if f[s][i] < float('inf'):
        sum += 1
        maxx = max(maxx, f[s][i])

print(sum + 1, maxx)

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int[][] Map = new int[105][105];
        int[][] f = new int[105][105];
        int[] a = new int[105];
        int s;

        // floyd算法
        // 初始化
        // 初始化为极大值
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                f[i][j] = Integer.MAX_VALUE / 2;
            }
        }

        for (int i = 1; i <= m; i++) {
            int x = scanner.nextInt();
            int y = scanner.nextInt();
            int t = scanner.nextInt();
            if (x != y) {
                Map[x][y] = t;
            } else {
                a[x] = t;
            }
        }

        // 更新从i到j所需要时间加上玩游戏的时间
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= n; j++) {
                if (i != j) {
                    Map[i][j] += a[j];
                }
            }
        }

        for (int i = 1; i <= n; i++) {
            f[i][i] = 0; // 由于玩游戏时间已经加在路程时间上了，因此从i到i时间应该为0
        }

        // 求解
        for (int k = 1; k <= n; k++) {
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    if (i == j) {
                        continue;
                    }
                    if (k == j) { // 中继点和终点相同，相当于直接从i前往j
                        f[i][j] = Math.min(f[i][j], f[i][k] + a[k]);
                    } else { // 中继点和终点不同，通过中继点更新
                        f[i][j] = Math.min(f[i][j], f[i][k] + f[k][j]);
                    }
                }
            }
        }

        s = scanner.nextInt();
        int sum = 0;
        int maxx = 0;
        for (int i = 1; i <= n; i++) {
            if (i == s) {
                continue;
            }
            if (f[s][i] < Integer.MAX_VALUE / 2) {
                sum++;
                maxx = Math.max(maxx, f[s][i]);
            }
        }

        System.out.println((sum + 1) + "\n" + maxx); // 别忘记答案加上起点
    }
}

Go

package main

import (
	"fmt"
)

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	var n, m int
	fmt.Scanf("%d %d", &n, &m)
	Map := make([][]int, 105)
	f := make([][]int, 105)
	for i := range Map {
		Map[i] = make([]int, 105)
		f[i] = make([]int, 105)
	}
	a := make([]int, 105)
	var s int

	// floyd算法
	// 初始化
	// 初始化为极大值
	for i := 1; i <= n; i++ {
		for j := 1; j <= n; j++ {
			f[i][j] = 1 << 30
		}
	}

	for i := 1; i <= m; i++ {
		var x, y, t int
		fmt.Scanf("%d %d %d", &x, &y, &t)
		if x != y {
			Map[x][y] = t
		} else {
			a[x] = t
		}
	}

	// 更新从i到j所需要时间加上玩游戏的时间
	for i := 1; i <= n; i++ {
		for j := 1; j <= n; j++ {
			if i != j {
				Map[i][j] += a[j]
			}
			f[i][j] = Map[i][j]
		}
	}

	// 求解
	for k := 1; k <= n; k++ {
		for i := 1; i <= n; i++ {
			for j := 1; j <= n; j++ {
				if i == j {
					continue
				}
				if k == j { // 中继点和终点相同，相当于直接从i前往j
					f[i][j] = min(f[i][j], f[i][k]+a[k])
				} else { // 中继点和终点不同，通过中继点更新
					f[i][j] = min(f[i][j], f[i][k]+f[k][j])
				}
			}
		}
	}

	fmt.Scanf("%d", &s)
	sum := 0
	maxx := 0
	for i := 1; i <= n; i++ {
		if i == s {
			continue
		}
		if f[s][i] < 1<<30 {
			sum++
			maxx = max(maxx, f[s][i])
		}
	}

	fmt.Printf("%d\n%d\n", sum+1, maxx) // 别忘记答案加上起点
}

Js

function min(a, b) {
  return a < b ? a : b;
}

function max(a, b) {
  return a > b ? a : b;
}

function main() {
  const readline = require('readline');
  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
  });

  rl.on('line', function(line) {
    const input = line.trim().split(' ').map(Number);
    const n = input[0];
    const m = input[1];
    const Map = Array.from({ length: 105 }, () => Array(105).fill(0));
    const f = Array.from({ length: 105 }, () => Array(105).fill(0));
    const a = Array(105).fill(0);
    let s;

    // floyd算法
    // 初始化
    // 初始化为极大值
    for (let i = 1; i <= n; i++) {
      for (let j = 1; j <= n; j++) {
        f[i][j] = Infinity;
      }
    }

    let count = 0;
    rl.on('line', function(line) {
      const input = line.trim().split(' ').map(Number);
      const x = input[0];
      const y = input[1];
      const t = input[2];
      if (x !== y) {
        Map[x][y] = t;
      } else {
        a[x] = t;
      }
      count++;
      if (count === m) {
        rl.close();
      }
    });

    rl.on('close', function() {
      // 更新从i到j所需要时间加上玩游戏的时间
      for (let i = 1; i <= n; i++) {
        for (let j = 1; j <= n; j++) {
          if (i !== j) {
            Map[i][j] += a[j];
          }
          f[i][j] = Map[i][j];
        }
      }

      // 求解
      for (let k = 1; k <= n; k++) {
        for (let i = 1; i <= n; i++) {
          for (let j = 1; j <= n; j++) {
            if (i === j) {
              continue;
            }
            if (k === j) { // 中继点和终点相同，相当于直接从i前往j
              f[i][j] = min(f[i][j], f[i][k] + a[k]);
            } else { // 中继点和终点不同，通过中继点更新
              f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
            }
          }
        }
      }

      rl.on('line', function(line) {
        s = Number(line.trim());

        let sum = 0;
        let maxx = 0;
        for (let i = 1; i <= n; i++) {
          if (i === s) {
            continue;
          }
          if (f[s][i] < Infinity) {
            sum++;
            maxx = max(maxx, f[s][i]);
          }
        }

        console.log((sum + 1) + '\n' + maxx); // 别忘记答案加上起点
      });
    });

题目内容均收集自互联网，如如若此项内容侵犯了原著者的合法权益，可联系我: (CSDN网站注册用户名: 塔子哥学算法) 进行删除。