5538. 统计子树中城市之间最大距离

最新推荐文章于 2021-12-14 11:26:49 发布

原创最新推荐文章于 2021-12-14 11:26:49 发布 · 340 阅读

0 ·

本内容遵循CC 4.0 BY-SA版权协议

收录于

力扣Leetcode

本文介绍了一种用于计算图中所有可能子图直径的高效算法，并详细展示了如何通过动态规划的方法来解决这一问题。核心思路在于枚举子集并验证各节点间的可达性，最终统计不同直径的子图数量。

传送门

在这里插入图片描述

解题思路：枚举子集，每次枚举都先判断是否可以相互到达。

主要是判断方法：
若a,b,c,d,e,…,z可以相互到达，那么必存在一个点，去除这个点后剩下点可以相互到达，且这个点与剩下的这些点中至少一个相连接。

class Solution {
public:
    bool vis[20][20];
    int dis[20][20];
    int sum[20];
    int dp[(1<<15)+10];
    void check(vector<int>& temp,int now,int num)
    {
        bool st=0;
        int z=0x3f3f3f3f;
        if(num==1)
        {
            dp[now]=0;
            return;
        }
        for(int i=0;i<num;++i)
        {
            int v=now-(1<<temp[i]);
            if(dp[v]==0x3f3f3f3f) continue;
            for(int j=0;j<num;++j)
            {
                if(j==i) continue;
                if(vis[temp[i]][temp[j]]) 
                {
                    st=1;
                    z=dp[v];
                    for(int k=0;k<num;++k)
                    {
                        z=max(z,dis[temp[i]][temp[k]]);
                    }
                    break;
                }
            }
            if(st) break; 
        }
        dp[now]=z;
        if(z!=0x3f3f3f3f) ++sum[z];
        //if(z==2) cout<<now<<endl;
    }
    vector<int> countSubgraphsForEachDiameter(int n, vector<vector<int>>& edges)    {
        int len=edges.size();
        memset(dis,0x3f,sizeof(dis));
        memset(dp,0x3f,sizeof(dp));
        memset(vis,0,sizeof(vis));
        for(int i=0;i<len;++i)
        {
            dis[edges[i][0]-1][edges[i][1]-1]=1;
            dis[edges[i][1]-1][edges[i][0]-1]=1;
            vis[edges[i][0]-1][edges[i][1]-1]=1;
            vis[edges[i][1]-1][edges[i][0]-1]=1;
        }
        for(int i=0;i<n;++i) dis[i][i]=0;
        for(int k=0;k<n;++k)
        {
            for(int i=0;i<n;++i)
            {
                for(int j=0;j<n;++j)
                {
                    dis[j][i]=dis[i][j]=min(dis[i][j],dis[i][k]+dis[k][j]);
                }
            }
        }
        dp[0]=0;
        memset(sum,0,sizeof(sum));
        vector<int> solve(n-1,0);
        for(int i=1;i<(1<<n);++i)
        {
            int num=0;
            vector<int> temp;
            for(int j=0;j<n;++j)
            {
                if(i&(1<<j))
                {
                    ++num;
                    temp.push_back(j);
                }
            }
            check(temp,i,num);
        }
        for(int i=0;i<n-1;++i)
        {
            solve[i]=sum[i+1];
        }
        return solve;
    }
};