bluecode-2023A-微服务的集成测试

时间限制：C/C++ 1000MS，其他语言 2000MS
内存限制：C/C++ 128MB，其他语言 256MB
难度：困难

描述

现在有 n 个容器服务，服务的启动可能有一定的依赖性（有些服务启动没有依赖），其次服务自身启动加载会消耗一些时间。

给你一个 nxn 的二维矩阵 useTime，其中 useTime[i][i] = 10 表示服务 i 自身启动加载需要消耗 10s，useTime[i][j] = 1 表示服务 i 启动依赖服务 j 启动完成，useTime[i][k] = 0，表示服务 i 启动不依赖服务 k。存在0 <= i，j，k < n。

服务之间启动没有循环依赖（不会出现环），若想对任意一个服务 i 进行集成测试（服务 i 自身也需要加载），求最少需要等待多少时间。

输入描述

第一行输入服务总量 n，之后的 n 行表示服务启动的依赖关系以及自身启动加载耗时                 最后输入 k 表示计算需要等待多少时间后可以对服务 k 进行集成测试                 其中 1 <= k <= n，1<=n<=100

输出描述

最少需要等待多少时间(s)后可以对服务 k 进行集成测试

用例输入 1 **

3
5 0 0
1 5 0
0 1 5
3

用例输出 1 **

15

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
 
int main() {
	int n;
    cin >> n;
    
    vector<vector<int>> use_time(n, vector<int>(n));
    for(int i = 0; i < n; ++i){
        for(int j = 0; j < n; ++j){
			cin >> use_time[i][j];
        }
    }
    
    int k;
    cin >> k;
    k -= 1;
    
    vector<vector<int>> graph(n);
    vector<int> in_degree(n, 0);
    
    for(int i = 0; i < n; ++i){
        for(int j = 0; j < n; ++j){
            if(i != j && use_time[i][j] == 1){
                graph[j].push_back(i);
                in_degree[i]++;
            }
        }
    }
    
    vector<int> dp(n, 0);
    
    for(int i = 0; i < n; ++i){
        dp[i] = use_time[i][i];
    }
    
    queue<int> q;
    for(int i = 0; i < n; ++i){
        if(in_degree[i] == 0){
            q.push(i);
        }
    }
    
    while(!q.empty()){
        int node = q.front();
        q.pop();
        
        for(int neighbour : graph[node]){
            dp[neighbour] = max(dp[neighbour], dp[node] + use_time[neighbour][neighbour]);
            in_degree[neighbour]--;
            if(in_degree[neighbour] == 0){
                q.push(neighbour);
            }
        }
    }
 	
    cout << dp[k] << endl;
    
    return 0;
}

package main

import (
	"bufio"
    "fmt"
    "os"
    "strconv"
    "strings"
)


func main(){
    scanner := bufio.NewScanner(os.Stdin)
    scanner.Scan()
    n, _  := strconv.Atoi(scanner.Text())
    
    use_time := make([][]int, n)
    for i := 0; i < n; i++ {
        scanner.Scan()
        row := strings.Split(scanner.Text(), " ")
        use_time[i] = make([]int, n)
        for j:=0; j < n; j++ {
            use_time[i][j], _ = strconv.Atoi(row[j])
        }
    }
    
    scanner.Scan()
    k, _ := strconv.Atoi(scanner.Text())
    k--
    
    graph := make(map[int][]int)
    in_degree := make([]int, n)
    
    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            if i != j && use_time[i][j] == 1{
                graph[j] = append(graph[j], i)
                in_degree[i]++;
            }
        }
    }
    
    dp := make([]int, n)
    for i:=0;i < n; i++ {
        dp[i] = use_time[i][i]
    }
    
    queue := make([]int, 0)
    for i:= 0; i < n; i++ {
        if in_degree[i] == 0 {
            queue = append(queue, i)
        }
    }
    
    for len(queue) > 0 {
        node := queue[0]
        queue = queue[1:]
        
        for _, neighbour :=range graph[node] {
            dp[neighbour] = max(dp[neighbour], dp[node] + use_time[neighbour][neighbour])
            in_degree[neighbour]--;
            if(in_degree[neighbour] == 0){
                queue = append(queue, neighbour)
            }
        }
    }
    
    fmt.Println(dp[k])
}

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

import sys
from collections import deque

def main():
    n = int(sys.stdin.readline().strip())
    
    use_time = []
    for _ in range(n):
        use_time.append(list(map(int, sys.stdin.readline().strip().split())))
    
    k = int(sys.stdin.readline().strip()) - 1
    
    graph = {i: [] for i in range(n)}
    in_degree = [0] * n
    for i in range(n):
        for j in range(n):
            if i != j and use_time[i][j] == 1:
                graph[j].append(i)
                in_degree[i] += 1
     
    dp = [use_time[i][i] for i in range(n)]
    
    queue = deque()
    for i in range(n):
        if in_degree[i] == 0:
            queue.append(i)
	
    while queue:
        node = queue.popleft()
        
        for neighbour in graph[node]:
            dp[neighbour] = max(dp[neighbour], dp[node] + use_time[neighbour][neighbour])
            in_degree[neighbour] -= 1
            if in_degree[neighbour] == 0:
                queue.append(neighbour)
        
    print(dp[k])
    
if __name__ == "__main__":
    main()