這周lc比賽最後一題比較複雜拿出來說下

An undirected, connected graph of N nodes (labeled 0, 1, 2, ..., N-1) is given as graph.

graph.length = N, and j != i is in the list graph[i] exactly once, if and only if nodes i and j are connected.

Return the length of the shortest path that visits every node. You may start and stop at any node, you may revisit nodes multiple times, and you may reuse edges.



Example 1:

Input: [[1,2,3],[0],[0],[0]]
Output: 4
Explanation: One possible path is [1,0,2,0,3]
Example 2:

Input: [[1],[0,2,4],[1,3,4],[2],[1,2]]
Output: 4
Explanation: One possible path is [0,1,4,2,3]


Note:

1 <= graph.length <= 12
0 <= graph[i].length < graph.length
 

1.一開始的思路 – 能否在圖中拿出一條最長的尤拉路 然後填上尤拉路中沒有的點 每次新增一個ans+2

2.tle但是正確的解，從某個點開始dfs，ans= 搜到的最到深度+（總數-搜到的最大深度）*2

class Solution {
public:
    int ans ;
    map< pair< int ,int >  ,int > dp ;
    int  dfs( int u , vector < vector< int > >  & graph , int depth,map< int , int
 
 > & check ){
        int ans = 0 ; 
        for( int i=0 ; i< graph[u].size() ; i++){
            int v=  graph[u][i] ; 
            if( check[v] == 0 ){
                check[v]++;

                int t = 1 + dfs(  v, graph , depth+1 ,check ) ; 
                //dp[ {u,v} ] = t -1 ; 
                ans = max( ans , t ) ; 
                check[v]--;
            }
        }

        return
 
 ans ; 
    }
    int shortestPathLength(vector<vector<int>>& graph) {
        int n = graph.size() ; 
        int res = INT_MAX ;  

        for( int i=0 ; i< n ; i++){
            map< int , int > check ; 
            ans = 0 ; 
            check[i]++;
            int ans  = dfs( i , graph , 0 , check ) ; 
            int t = n -( ans + 1) ;  
            res = min ( res,  t*2 + ans ) ; 
        }

        return res ; 
    }
};

在上面的程式碼中我開了沒有用到dp，想要通過記憶化搜尋去ac程式碼

思路是如果這個點搜過了，並且知道它最大的深度直接加上最大深度即可

但是有個問題那就是進來的點需要判斷是否在能搜到的最大深度的子集裡

最後這題看了discuss 得知壓縮dp通過S記錄所有點的狀態

dp[S][i] 代表著在 i 這個點的時候 ，我們搜了集合S中的狀態

如果S的二進位制是 10101代表 vertex 0，2，4 我們搜過了

如果此時的i為 1 如 dp[10101][1] 代表我們在 1 這個點時 ，搜掉10101所使用的最小代價

定義了狀態 ， 需要初始化dp

對於每個vertex應該有 dp[1 << i][i] = 0 因為我們不用走就已經可以得到S這個狀態

接著是狀態轉移 和產生的代價

此處需要舉個例子

如dp[11][0] 代表此時在0處集合為11的代價，那麼他就應該滿足

dp[11][0] = min( dp[11][0] , dp[10][1] + dis[1][0] ) 

class Solution {
public:
    int dp[1<<12][12];
    int dis[12][12] ; 
    void floyd( vector< vector< int> > & graph ){
        int n = graph.size(); 
        { //floyd algorithm
        //   init floyd algorithm
        for( int i =0 ; i < n; i++){
            for( int j =0 ; j<n ; j++){
                dis[i][j] = n*n ; 
            }
        }
        for( int i  =0 ; i< n; i ++){
            dis[i][i] = 0 ; 
        }
        for( int u = 0 ; u<n ; u++){
            for( auto & v : graph[u] ){
                dis[u][v] = 1 ;
                dis[v][u] = 1; 
            }
        }
        // get the table of dis[i][j] 
            for( int k =0 ; k< n ;k++){
                for( int i =0 ; i<n ; i++){
                    for( int j=0 ; j<n ; j++){
                        if( k!=i && k!=j ){
                            dis[i][j] = min( dis[i][j] , dis[i][k] +dis[k][j] ) ; 
                        }
                    }
                }
            }
        }
    }
    int shortestPathLength(vector<vector<int>>& graph) {
        int n = graph.size() ; 
        floyd( graph ) ; 
        // init  dp array ;
        for( int i=0 ; i< n ; i++){
            for( int j=0 ; j<( 1<<n ) ; j++){
                dp[j][i] = n*n; 
            }
        }
        for( int i=0 ; i< n; i++){
            dp[1<<i][i] = 0 ; 
        }
        for( int j=1 ; j<(1<<n) ;  j++){
            for(int i=0;i<n ;i++){
                if( j &(1<<i) ) { // now the ith vertex is actually in the Set j 
                    for( int k=0 ;k<n ;k++){
                        dp[j][i] = min( dp[j][i] , dp[j^(1<<i)][k]+dis[k][i] ) ; 
                    }
                }
            }
        }
        int res = 1<< 15 ; 
        for( int i=0 ; i< n; i++){
            res = min ( res , dp[(1<<n) -1][i] ) ; 
        }
        return res; 
    }
};

此處求點對的最短路使用的是floyd演算法， 但是也可以使用n次bfs達到