2023-05-12：存在一个由 n 个节点组成的无向连通图，图中的节点按从 0 到 n - 1 编号， 给你一个数组 graph 表示这个图， 其中，graph[i] 是一个列表，由所有与节点 i

2023-05-12：存在一个由 n 个节点组成的无向连通图，图中的节点按从 0 到 n - 1 编号，

给你一个数组 graph 表示这个图，

其中，graph[i] 是一个列表，由所有与节点 i 直接相连的节点组成。

返回能够访问所有节点的最短路径的长度。

你可以在任一节点开始和停止，也可以多次重访节点，并且可以重用边。

输入：graph = [[1,2,3],[0],[0],[0]]。

输出：4。

答案2023-05-12：

大体步骤如下：

1.首先，在 main 函数中调用 shortestPathLength 函数，并将图的邻接表 graph 作为参数传入。

2.在 shortestPathLength 函数中，获取图中节点的个数 n，使用 Floyd 算法计算所有节点之间的最短路径距离，并将结果保存到 distance 二维数组中，同时初始化一个 ans 变量为整型最大值。

3.接下来，初始化一个 dp 数组，其中 dp[i][j] 表示当前状态为 i（二进制表示），当前在节点 j 的情况下，能形成的最短路径长度。同时，对于 dp 数组进行初始化，将所有元素的值设为 -1。

4.循环遍历每个节点 i，从 i 节点出发，通过 process 函数求出访问所有节点的最短路径长度，并更新 ans 的值。

5.在 process 函数中，首先判断当前状态是否已经访问了所有节点，如果是，返回 0 表示已经完成访问。如果 dp 数组中已有对应状态和当前节点的最短路径长度，则直接返回该值，避免重复计算。

6 如果上述条件都不满足，则遍历所有未访问过的且与当前节点 cur 相邻的节点 next，对于这些节点，递归调用 process 函数，并记录访问当前节点 cur 和下一个节点 next 所需的距离 distance[cur][next]，然后将其加上递归得到的 nextAns 值，更新 ans 的值。

7.最后，将计算出的最短路径长度 ans 保存到 dp 数组中，并返回该值。在主函数中输出 ans 的值即为能够访问所有节点的最短路径的长度。

时间复杂度：本算法中使用了 Floyd 算法计算所有节点之间的最短路径，其时间复杂度为 O(n^3)；同时，使用动态规划求解当前状态下访问所有节点的最短路径长度，需要遍历状态空间和邻接表，时间复杂度为 O(2^n * n^2)。因此，总的时间复杂度为 O(n^3 + 2^n * n^2)。

空间复杂度：本算法中使用了一个距离矩阵 distance 数组来存储节点之间的最短路径距离，其空间复杂度为 O(n^2)；同时，使用了一个 dp 数组来记录状态和节点的最短路径长度，其空间复杂度也是 O(2^n * n)。因此，总的空间复杂度为 O(n^2 + 2^n * n)。

go语言完整代码如下：

package main

import (
	"fmt"
	"math"
)

func shortestPathLength(graph [][]int) int {
	n := len(graph)
	distance := floyd(n, graph)
	ans := math.MaxInt32
	dp := make([][]int, 1<<n)
	for i := 0; i < (1 << n); i++ {
		dp[i] = make([]int, n)
		for j := 0; j < n; j++ {
			dp[i][j] = -1
		}
	}
	for i := 0; i < n; i++ {
		ans = min(ans, process(1<<i, i, n, distance, dp))
	}
	return ans
}

func floyd(n int, graph [][]int) [][]int {
	distance := make([][]int, n)
	for i := 0; i < n; i++ {
		distance[i] = make([]int, n)
		for j := 0; j < n; j++ {
			distance[i][j] = math.MaxInt32
		}
	}
	for i := 0; i < n; i++ {
		distance[i][i] = 0
	}
	for cur := 0; cur < n; cur++ {
		for _, next := range graph[cur] {
			distance[cur][next] = 1
			distance[next][cur] = 1
		}
	}
	for jump := 0; jump < n; jump++ {
		for from := 0; from < n; from++ {
			for to := 0; to < n; to++ {
				if distance[from][jump] != math.MaxInt32 && distance[jump][to] != math.MaxInt32 &&
					distance[from][to] > distance[from][jump]+distance[jump][to] {
					distance[from][to] = distance[from][jump] + distance[jump][to]
				}
			}
		}
	}
	return distance
}

func process(status, cur, n int, distance, dp [][]int) int {
	if status == (1<<n)-1 {
		return 0
	}
	if dp[status][cur] != -1 {
		return dp[status][cur]
	}
	ans := math.MaxInt32
	for next := 0; next < n; next++ {
		if status&(1<<next) == 0 && distance[cur][next] != math.MaxInt32 {
			nextAns := process(status|(1<<next), next, n, distance, dp)
			if nextAns != math.MaxInt32 {
				ans = min(ans, distance[cur][next]+nextAns)
			}
		}
	}
	dp[status][cur] = ans
	return ans
}

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

func main() {
	graph := [][]int{{1, 2, 3}, {0}, {0}, {0}}
	ans := shortestPathLength(graph)
	fmt.Println(ans)
}

rust语言完整代码如下：

fn shortest_path_length(graph: Vec<Vec<i32>>) -> i32 {
    let n = graph.len();
    let distance = floyd(n, &graph);
    let mut ans = std::i32::MAX;
    let mut dp = vec![vec![-1; n]; 1 << n];
    for i in 0..(1 << n) {
        for j in 0..n {
            dp[i][j] = -1;
        }
    }
    for i in 0..n {
        ans = ans.min(process(1 << i, i, n, &distance, &mut dp));
    }
    return ans;
}

fn floyd(n: usize, graph: &Vec<Vec<i32>>) -> Vec<Vec<i32>> {
    let mut distance = vec![vec![std::i32::MAX; n]; n];
    // 初始化认为都没路
    for i in 0..n {
        for j in 0..n {
            distance[i][j] = std::i32::MAX;
        }
    }
    // 自己到自己的距离为0
    for i in 0..n {
        distance[i][i] = 0;
    }
    // 支持任意有向图，把直接边先填入
    for cur in 0..n {
        for &next in graph[cur].iter() {
            distance[cur][next as usize] = 1;
            distance[next as usize][cur] = 1;
        }
    }
    // O(N^3)的过程
    // 枚举每个跳板
    // 注意! 跳板要最先枚举，然后是from和to
    for jump in 0..n {
        for from in 0..n {
            for to in 0..n {
                if distance[from][jump] != std::i32::MAX
                    && distance[jump][to] != std::i32::MAX
                    && distance[from][to] > distance[from][jump] + distance[jump][to]
                {
                    distance[from][to] = distance[from][jump] + distance[jump][to];
                }
            }
        }
    }
    return distance;
}

// status : 所有已经走过点的状态
// 0 1 2 3 4 5
// int
//        5 4 3 2 1 0
//        0 0 1 1 0 1
// cur : 当前所在哪个城市！
// n : 一共有几座城
// 返回值 : 从此时开始，逛掉所有的城市，至少还要走的路，返回！
fn process(
    status: i32,
    cur: usize,
    n: usize,
    distance: &Vec<Vec<i32>>,
    dp: &mut Vec<Vec<i32>>,
) -> i32 {
    // 5 4 3 2 1 0
    // 1 1 1 1 1 1
    // 1 << 6 - 1
    if status == (1 << n) - 1 {
        return 0;
    }
    if dp[status as usize][cur] != -1 {
        return dp[status as usize][cur];
    }
    let mut ans = std::i32::MAX;
    // status:
    // 5 4 3 2 1 0
    // 0 0 1 0 1 1
    // cur : 0
    // next : 2 4 5
    for next in 0..n {
        if (status & (1 << next)) == 0 && distance[cur][next] != std::i32::MAX {
            let next_ans = process(status | (1 << next), next, n, distance, dp);
            if next_ans != std::i32::MAX {
                ans = ans.min(distance[cur][next] + next_ans);
            }
        }
    }
    dp[status as usize][cur] = ans;
    return ans;
}

fn main() {
    let graph = vec![vec![1, 2, 3], vec![0], vec![0], vec![0]];
    let ans = shortest_path_length(graph);
    println!("{}", ans);
}

c语言完整代码如下：

#include <iostream>
#include <vector>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 15, INF = 0x3f3f3f3f;

int n;
int dist[N][N], dp[1 << N][N];

int floyd(vector<vector<int>>& graph)
{
    n = graph.size();
    memset(dist, 0x3f, sizeof dist);

    for (int i = 0; i < n; i++)
        for (auto j : graph[i])
            dist[i][j] = 1;

    for (int k = 0; k < n; k++)
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);

    return 0;
}

int dfs(int status, int cur)
{
    if (status == (1 << n) - 1)
        return 0;

    if (dp[status][cur] != -1)
        return dp[status][cur];

    int ans = INF;

    for (int next = 0; next < n; next++)
        if ((status & (1 << next)) == 0 && dist[cur][next] != INF)
        {
            int nextAns = dfs(status | (1 << next), next);
            if (nextAns != INF)
                ans = min(ans, dist[cur][next] + nextAns);
        }

    return dp[status][cur] = ans;
}

int shortestPathLength(vector<vector<int>>& graph) {
    memset(dp, -1, sizeof dp);
    floyd(graph);

    int ans = INF;
    for (int i = 0; i < n; i++)
        ans = min(ans, dfs(1 << i, i));
    return ans;
}

int main()
{
    vector<vector<int>> graph = { {1,2,3},{0},{0},{0} };
    cout << shortestPathLength(graph) << endl;

    return 0;
}

c++语言完整代码如下：

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

#define N 15
#define INF 0x3f3f3f3f

int n;
int dist[N][N], dp[1 << N][N];

void floyd(int** graph, int graphSize, int* graphColSize)
{
    n = graphSize;
    memset(dist, 0x3f, sizeof dist);

    for (int i = 0; i < n; i++)
        for (int j = 0; j < graphColSize[i]; j++)
            dist[i][graph[i][j]] = 1;

    for (int k = 0; k < n; k++)
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                dist[i][j] = dist[i][j] < dist[i][k] + dist[k][j] ? dist[i][j] : dist[i][k] + dist[k][j];
}

int dfs(int status, int cur)
{
    if (status == (1 << n) - 1)
        return 0;

    if (dp[status][cur] != -1)
        return dp[status][cur];

    int ans = INF;

    for (int next = 0; next < n; next++)
        if ((status & (1 << next)) == 0 && dist[cur][next] != INF)
        {
            int nextAns = dfs(status | (1 << next), next);
            if (nextAns != INF)
                ans = ans < dist[cur][next] + nextAns ? ans : dist[cur][next] + nextAns;
        }

    return dp[status][cur] = ans;
}

int shortestPathLength(int** graph, int graphSize, int* graphColSize) {
    memset(dp, -1, sizeof dp);
    floyd(graph, graphSize, graphColSize);

    int ans = INF;
    for (int i = 0; i < n; i++)
        ans = ans < dfs(1 << i, i) ? ans : dfs(1 << i, i);
    return ans;
}

int main()
{
    int graphSize = 4;
    int graphColSize[] = { 3, 1, 1, 1 };
    int** graph = (int**)malloc(sizeof(int*) * graphSize);
    for (int i = 0; i < graphSize; i++)
    {
        graph[i] = (int*)malloc(sizeof(int) * graphColSize[i]);
        memcpy(graph[i], (int[]) { 0 }, sizeof(int)* graphColSize[i]);
    }
    graph[0][0] = 1;
    graph[0][1] = 2;
    graph[0][2] = 3;

    printf("%d\n", shortestPathLength(graph, graphSize, graphColSize));

    for (int i = 0; i < graphSize; i++)
        free(graph[i]);
    free(graph);

    return 0;
}