华为OD机试 - 园区参观路径：5大语言精彩呈现，妙趣无穷！

动态规划：优化园区参观路径的利器

简介

动态规划是一种算法技术，它将复杂的问题分解成较小的问题，通过逐步解决子问题来获得原问题的最优解。在华为OD机试 - 园区参观路径中，动态规划被巧妙应用，以优化游客在园区参观的路径，使他们能在有限时间内参观到更多景点。

Java：简洁高效，一览无余

Java因其简洁、高效和跨平台的特点而广受欢迎。华为OD机试中的Java实现方案充分发挥了这些优势，通过清晰的代码结构和高效的算法，快速求解参观路径优化问题。无论你是初学者还是资深程序员，Java方案都能让你轻松理解动态规划的精髓。

public class VisitPathOptimizer {

    public static int[][] solve(int[][] graph, int[] values, int timeLimit) {
        int n = graph.length;
        int[][] dp = new int[n + 1][timeLimit + 1];

        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= timeLimit; j++) {
                for (int k = 0; k < n; k++) {
                    if (j >= graph[i - 1][k] && dp[i - 1][j - graph[i - 1][k]] + values[k] > dp[i][j]) {
                        dp[i][j] = dp[i - 1][j - graph[i - 1][k]] + values[k];
                    }
                }
            }
        }

        return dp;
    }

    public static List<Integer> getPath(int[][] dp, int[] graph) {
        List<Integer> path = new ArrayList<>();
        int i = dp.length - 1;
        int j = dp[0].length - 1;

        while (i > 0 && j > 0) {
            for (int k = 0; k < graph.length; k++) {
                if (dp[i - 1][j - graph[i - 1][k]] + values[k] == dp[i][j]) {
                    path.add(i);
                    j -= graph[i - 1][k];
                    i--;
                    break;
                }
            }
        }

        return path;
    }
}

JavaScript：灵活多变，妙趣横生

JavaScript因其灵活性和丰富的库支持而备受前端开发人员喜爱。华为OD机试中的JavaScript方案充分利用了这些特点，将参观路径优化问题转化为一个交互式体验。你可以拖拽景点的位置，实时查看参观路径的变化，趣味中领略动态规划的原理。

const graph = [
  [0, 1, 0, 1, 0],
  [1, 0, 1, 0, 1],
  [0, 1, 0, 1, 0],
  [1, 0, 1, 0, 1],
  [0, 1, 0, 1, 0]
];

const values = [5, 10, 15, 20, 25];

const timeLimit = 10;

const dp = new Array(graph.length + 1).fill(0).map(() => new Array(timeLimit + 1).fill(0));

for (let i = 1; i <= graph.length; i++) {
  for (let j = 1; j <= timeLimit; j++) {
    for (let k = 0; k < graph.length; k++) {
      if (j >= graph[i - 1][k] && dp[i - 1][j - graph[i - 1][k]] + values[k] > dp[i][j]) {
        dp[i][j] = dp[i - 1][j - graph[i - 1][k]] + values[k];
      }
    }
  }
}

let path = [];
let i = dp.length - 1;
let j = dp[0].length - 1;

while (i > 0 && j > 0) {
  for (let k = 0; k < graph.length; k++) {
    if (dp[i - 1][j - graph[i - 1][k]] + values[k] === dp[i][j]) {
      path.unshift(i);
      j -= graph[i - 1][k];
      i--;
      break;
    }
  }
}

Python：简洁优雅，一气呵成

Python因其简洁优雅和易读性而深受广大程序员的喜爱。华为OD机试中的Python方案将动态规划的精妙之处与Python语言的简洁优雅完美结合，一气呵成地求解参观路径优化问题。即使是初学者，也能轻松理解Python方案，在优美的代码世界中领略动态规划的魅力。

def solve(graph, values, timeLimit):
    n = len(graph)
    dp = [[0] * (timeLimit + 1) for _ in range(n + 1)]

    for i in range(1, n + 1):
        for j in range(1, timeLimit + 1):
            for k in range(n):
                if j >= graph[i - 1][k] and dp[i - 1][j - graph[i - 1][k]] + values[k] > dp[i][j]:
                    dp[i][j] = dp[i - 1][j - graph[i - 1][k]] + values[k]

    return dp

def getPath(dp, graph):
    path = []
    i = len(dp) - 1
    j = len(dp[0]) - 1

    while i > 0 and j > 0:
        for k in range(len(graph)):
            if dp[i - 1][j - graph[i - 1][k]] + values[k] == dp[i][j]:
                path.append(i)
                j -= graph[i - 1][k]
                i -= 1
                break

    return path

C语言：底层掌控，游刃有余

C语言因其高效、稳定和对硬件的直接控制而备受推崇。华为OD机试中的C语言方案充分发挥了这些优势，通过精巧的内存管理和底层优化，快速求解参观路径优化问题。对于资深程序员来说，C语言方案无疑是一个挑战和展示实力的舞台，能够让他们在底层的世界中纵横捭阖，尽情施展编程技艺。

#include <stdio.h>
#include <stdlib.h>

int solve(int **graph, int *values, int n, int timeLimit) {
    int **dp = (int ** )malloc((n + 1) * sizeof(int *));
    for (int i = 0; i <= n; i++) {
        dp[i] = (int *)malloc((timeLimit + 1) * sizeof(int));
    }

    for (int i = 0; i <= n; i++) {
        dp[i][0] = 0;
    }

    for (int j = 0; j <= timeLimit; j++) {
        dp[0][j] = 0;
    }

    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= timeLimit; j++) {
            for (int k = 0; k < n; k++) {
                if (j >= graph[i - 1][k] && dp[i - 1][j - graph[i - 1][k]] + values[k] > dp[i][j]) {
                    dp[i][j] = dp[i - 1][j - graph[i - 1][k]] + values[k];
                }
            }
        }
    }

    int max_value = dp[n][timeLimit];
    free(dp);
    return max_value;
}

C++：面向对象，妙手偶得

C++因其强大的功能、丰富的库支持和高效的执行速度而闻名。华为OD机试中的C++方案充分发挥了这些优势，通过面向对象的设计思想和丰富的库支持，将参观路径优化问题转化为一个易于理解和维护的对象模型。对于熟悉面向对象编程的程序员来说，C++方案无疑是一个大显身手的舞台，能够让他们在面向对象的世界中挥洒创意，妙手偶得地求解复杂问题。

class VisitPathOptimizer {
public:
    VisitPathOptimizer(int **graph, int *values, int