【Leetcode】847. Shortest Path Visiting All Nodes

Subject address:

https://leetcode.com/problems/shortest-path-visiting-all-nodes/

Given a $n-$ order undirected connected graph, vertex number$1\sim n-1.$ Find the shortest Hamilton loop length.

For the BFS solution refer to https://blog.csdn.net/qq_46105170/article/details/109913464 . The following describes the dynamic programming method.

State compression can be used here to make a number xxThe binary bits of$x$ respectively indicate whether a certain vertex has been visited, and then let$f\left[i\right]\left[x\right]$ means that it is currently at numberiithe vertex of$i$ , and the situation facing is$When\; x$ (meaning that the status of the visited and unvisited points is$x$ ), the length of the shortest path of all points. Then$f[i][2^n-1]=0$ , which means that all points have been completed. Obviously the shortest path length is$0$ . For other cases, there are: f [i] [s] = 1 + min ⁡ i → k {f [k] [s ∣ (1 <<k)]} f[i][s]=1+\min_ {i\to k}\{f[k][s|(1<<k)]\}f[i][s]=1+i→kme{ f[k][s∣(1<<k ) ] } Last solution${\min }_{i=0,1,...,n-1}f[i][1<<i]$ . Obviously when looping,$s$ Required$2^n-2\to 0$ to loop in this order, but there is a problem here, if you are looking for$When\; f\left[i\right]\left[s\right]$ , it happens to use a certain$f\left[j\right]\left[s\right]$ (The key here is that$s|(1<<k)=s$ ), but at this time$f\left[j\right]\left[s\right]$ may not be calculated yet, which will lead to wrong answers. The solution is to find a certain$When\; f\left[i\right]\left[s\right]$ is updated to a smaller value, the loop will be repeated again until the loop cannot get a better solution. Here is why there is no infinite loop. If there is an infinite loop, you will get the situation of "update yourself", but the edge weights of this graph are all$1.$ There is no negative loop, so there is no endless loop. code show as below:

import java.util.Arrays;

public class Solution {
    
    
    public int shortestPathLength(int[][] graph) {
    
    
        int n = graph.length;
        int[][] dp = new int[n][1 << n];
        for (int[] row : dp) {
    
    
            Arrays.fill(row, n * n);
            row[(1 << n) - 1] = 0;
        }
        
        for (int s = (1 << n) - 2; s > 0; s--) {
    
    
            for (boolean repeat = true; repeat; ) {
    
    
                repeat = false;
                for (int cur = 0; cur < n; cur++) {
    
    
                    if ((s >> cur & 1) == 1) {
    
    
                        for (int next : graph[cur]) {
    
    
                            int ne = s | (1 << next);
                            if (1 + dp[next][ne] < dp[cur][s]) {
    
    
                                dp[cur][s] = 1 + dp[next][ne];
                                // 一旦发现被更新为更优解了，则追加一次循环
                                repeat = true;
                            }
                        }
                    }
                }
            }
        }
        
        int res = n * n;
        for (int i = 0; i < n; i++) {
    
    
            res = Math.min(res, dp[i][1 << i]);
        }
        
        return res;
    }
}

Time complexity $O\left(V^2{2}^V\right)$, space$O\left(V{2}^V\right)$。

The status setting is not unique. We can also set $F\left[I\right]\left[S\right]$为从$i$ start and form state$s$ shortest length. The initial condition at this time is$f[i][1<<i]=0$ , the answer to be returned is${\min }_{i=0,1,....n-1}f[i][2^n-1]$，转移方程为：$$f[k][s|(1<<k)]=1+\underset{i\to k}{\mathrm{me}}\{f\left[i\right]\left[s\right]\}\; The$$ code is as follows:

import java.util.Arrays;

public class Solution {
    
    
    public int shortestPathLength(int[][] graph) {
    
    
        int n = graph.length;
        int[][] dp = new int[n][1 << n];
        for (int i = 0; i < n; i++) {
    
    
            Arrays.fill(dp[i], n * n);
            dp[i][1 << i] = dp[i][0] = 0;
        }
        
        for (int s = 1; s < 1 << n; s++) {
    
    
            for (boolean repeat = true; repeat; ) {
    
    
                repeat = false;
                for (int cur = 0; cur < n; cur++) {
    
    
                    if ((s >> cur & 1) == 1) {
    
    
                        for (int next : graph[cur]) {
    
    
                            if (1 + dp[cur][s] < dp[next][s | (1 << next)]) {
    
    
                                dp[next][s | (1 << next)] = 1 + dp[cur][s];
                                repeat = true;
                            }
                        }
                    }
                }
            }
        }
        
        int res = n * n;
        for (int i = 0; i < n; i++) {
    
    
            res = Math.min(res, dp[i][(1 << n) - 1]);
        }
        
        return res;
    }
}

The time and space complexity is the same.