图中最相似的路径

// Java Stream 解法
// 题目思路：
// 与Java解法类似，只是在遍历图的过程中使用Stream API进行简化操作。

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class SolutionStream {
    public List<Integer> mostSimilar(int n, int[][] roads, String[] names, String[] targetPath) {
        List<List<Integer>> graph = IntStream.range(0, n)
            .mapToObj(i -> new ArrayList<Integer>())
            .collect(Collectors.toList());
        Arrays.stream(roads).forEach(road -> {
            graph.get(road[0]).add(road[1]);
            graph.get(road[1]).add(road[0]);
        });
        int m = targetPath.length;
        int[][] dp = new int[m][n];
        int[][] path = new int[m][n];
        IntStream.range(0, n).forEach(j -> {
            dp[0][j] = names[j].equals(targetPath[0]) ? 0 : 1;
            path[0][j] = -1;
        });
        IntStream.range(1, m).forEach(i -> {
            IntStream.range(0, n).forEach(j -> {
                dp[i][j] = IntStream.range(0, graph.get(j).size())
                    .map(k -> {
                        int prev = graph.get(j).get(k);
                        return dp[i - 1][prev] + (names[j].equals(targetPath[i]) ? 0 : 1);
                    })
                    .min().orElse(Integer.MAX_VALUE);
                path[i][j] = IntStream.range(0, graph.get(j).size())
                    .map(k -> graph.get(j).get(k))
                    .reduce((a, b) -> dp[i - 1][a] + (names[j].equals(targetPath[i]) ? 0 : 1) < dp[i - 1][b] + (names[j].equals(targetPath[i]) ? 0 : 1) ? a : b)
                    .orElse(-1);
            });
        });
        int minCost = IntStream.range(0, n).reduce((a, b) -> dp[m - 1][a] < dp[m - 1][b] ? a : b).orElse(-1);
        List<Integer> result = new ArrayList<>();
        for (int i = m - 1; i >= 0; i--) {
            result.add(minCost);
            minCost = path[i][minCost];
        }
        Collections.reverse(result);
        return result;
    }
}