AcWing347.野餐规划 最小生成树

这个问题转化成,给定一个N个点,M条边的无向图,求出无向图的一颗最小生成树,满足1号节点的入度不超过给定的整数s.

我们把1号点去除,得到的连通块的数量就是1号节点的入度T,用dfs划分连通块,若T>S,则该题无解

对于每个连通块,我们求出其最小生成树,再将每个连通块中距离1号点最近的点与1号点相连.

然后我们可以继续修改S-T次使得答案更优.我们考虑从1号点出发的每条边(1,x),边权是z.若这条边不在已经存在的生成树中,那么我们就继续寻找当前生成树中从x到1的路径上权值最大的边(u,v),边权是w.然后求出使得w-z最大的点x0.若w0-z0>0,则删除(u0,v0),加入边(1,x0),答案会变小w0-z0

重复S-T次步骤,或者直到w0-z0<=0,得到题目中的最小生成树.

 

AC代码:

// 1.读入边,区分1号点和其他点,读入s
// 2.划分连通块,对于每个连通块,用kruskal求最小生成树的总权值,加入到答案中.
// 3.遍历每个连通块,找出每个连通块距离1号点最近的点;并将这个点与1号点"相连"
// 4.找出与1号点"相连"的每个点x,假设与其的边权是z,求出不"相连"的点y,使得1~y的路径上的最大的边权w满足w-z最大并且w-z>0,更新答案
#include <bits/stdc++.h>
#define IOS ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
#define DEBUG freopen("input.in", "r", stdin)
using namespace std;
unordered_map<string, int> mp;
const int N = 1010;
int ans;
int tot, n, s, cnt = 0, cntpd = 0, g2[30][30], fa[N], vis[31];
bool intg[31][31];//表示这条边是否在最小生成树中
struct rec__{
    int x, y, z;
    bool friend operator <(rec__ A, rec__ B){
        return A.z < B.z;
    }
}g1[N];

struct rec{
    int u, v, d;
    inline void inits(){
        u = v = 0;
        d = -1;
    }
}dp[N];

inline int find(int x)
{
    return x == fa[x] ? x : fa[x] = find(fa[x]);
}
struct rec_
{
    inline void add_edge1(int a, int b, int c)
    {
        ++cnt;
        g1[cnt].x = a;
        g1[cnt].y = b;
        g1[cnt].z = c;
    }

    inline int kruskal()
    { //对同一个连通块的节点(除了1号点以外)求最小生成树的权值和
        sort(g1 + 1, g1 + cnt + 1);
        int res = 0;
        for (int i = 1; i <= cnt; ++i)
        {
            int x = find(g1[i].x);
            int y = find(g1[i].y);
            if (x == y || x == 1 || y == 1)
                continue;
            fa[x] = y;
            res += g1[i].z;
            intg[g1[i].x][g1[i].y] = intg[g1[i].y][g1[i].x] = true; //已经在最小生成树中
        }
        return res;
    }
} g;

inline void init(){
    mp["Park"] = 1;
    tot = 1;
}

inline void add_edge2(int a, int b, int c){
    g2[a][b] = g2[b][a] = c;
}

inline void read(){
    IOS;
    // DEBUG;
    init();
    cin >> n;
    string s1, s2;
    for (int i = 1, l; i <= n; ++i){
        cin >> s1 >> s2 >> l;
        if(!mp[s1])
            mp[s1] = ++tot;
        if(!mp[s2])
            mp[s2] = ++tot;
        g.add_edge1(mp[s1], mp[s2], l);//用于kruskal的边集
        add_edge2(mp[s1], mp[s2], l);//用于划分连通块的边集
        fa[i] = i;//初始化每个集合
    }
    cin >> s;
}

inline int get(int v){
    int res = 0x3f3f3f3f, node;
    for (int i = 2; i <= tot; ++i){
        if(vis[i] != v)
            continue;
        if(res > g2[1][i] && g2[1][i]){
            res = g2[1][i];
            node = i;
        }
    }
    return node;
}


void dfs(int u){
    vis[u] = cntpd;
    for (int i = 2; i <= tot; ++i)
        if(!vis[i] && g2[u][i])
            dfs(i);
}

void dfs(int now, int last){
    for (int i = 2; i <= tot; ++i){
        if(i == last || !intg[now][i] || dp[i].d != -1)
            continue;
        if(dp[now].d > g2[now][i])
            dp[i] = dp[now];
        else{
            dp[i].u = now;
            dp[i].v = i;
            dp[i].d = g2[now][i];
        }
        dfs(i, now);
    }
}
inline void pd(){
    for (int i = 2; i <= tot; ++i)
        if(!vis[i]){
            ++cntpd;
            dfs(i);
        }
}

void work(){
    pd();//划分除了1号节点以外的节点的连通块
    ans += g.kruskal(); //求出每个连通块的最小生成树的总权值和
    for (int i = 1, node; i <= cntpd; ++i){
        node = get(i);          //求出每个连通块中距离1号点最近的点,并把这个点跟1号点"相连"
        //把这些连通块的点到1号点的边的权值加入到答案
        ans += g2[1][node];
        intg[1][node] = intg[node][1] = true;
    }

    for (int k = cntpd + 1; k <= s; ++k){
        for (int i = 1; i <= 1010; ++i)
            dp[i].inits();
        dfs(1, -1);
        int now = 0, idx = 0;
        for (int j = 2; j <= tot; ++j)
            if (now < dp[j].d - g2[1][j] && g2[1][j]){
                now = dp[j].d - g2[1][j];
                idx = j;
            }
        if(now <= 0)
            break;
        ans -= now;
        intg[dp[idx].u][dp[idx].v] = false;
        intg[1][idx] = intg[idx][1] = true;
    }

    cout << "Total miles driven: " << ans << '\n';
}

int main(){
    read();
    work();
}