【最小生成树杂题】

• 这里谈一下最小生成树
• 生成树的概念：连通图G的一个子图如果是一棵包含G的所有顶点的树，则该子图称为G的生成树。生成树是连通图的极小连通子图。所谓极小是指：若在树中任意增加一条边，则将出现一个回路；若去掉一条边，将会使之变成非连通图。 生成树各边的权值总和称为生成树的权。权最小的生成树称为最小生成树。
• 最小生成树一个有 n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n 个结点，并且有保持图连通的最少的边。常用于求最小生成树得算法包括kruskal（克鲁斯卡尔）算法或Prim（普里姆）算法。
• 最常用的是kruscal算法。kruscal算法的实质是用贪心策略来求得图的最小生成树。初始状态图中一条边也没有，每个点独立的存在于集合中；每次取出当前边权最小的边，判断能否将此边加入生成树中，判断依据：边的两个端点是否在一个集合中。若两点在一个集合中，则不需加入该边；若两点不在一个集合中，则将两点所在的集合合并，即集合中的点可以互相到达，无需两两之间再建边；如此做直到集合中各个点都联通或边全部枚举完毕；若此图联通，则为最小生成树。保证边权递增可以用快速排序的思想，维护集合关系可以用并查集的思想。排序复杂度O(eloge)，枚举复杂度O(e)，总体复杂度O(eloge)。
• 相比于kruscal算法，prim算法比较复杂；同样的是，prim算法也使用了贪心的策略，不过该算法是由点来贪心的。初始时边集u为空，点集v有一个点x，x为任意一点。操作步骤：在所有点中找到一点y，使d[y,r]最小，其中r∈v；把该边加入u，改点加入v，更新答案。如此做直到每个点都在点集中或某些点无法加入点集。若所有点都在点集中，则为最小生成树。枚举每个点加入集合，复杂度O(n)，枚举该点与点集的距离，复杂度O(n)，总体复杂度O(n²)。若用堆优化枚举距离的过程，复杂度降至O(nlogn)。
• 下面是关于最小生成树的几道杂题。

Problem 1 最小生成树

题目描述

如题，给出一个无向图，求出最小生成树，如果该图不连通，则输出orz

输入输出格式

输入格式：

第一行包含两个整数N、M，表示该图共有N个结点和M条无向边。（N<=5000，M<=200000）

接下来M行每行包含三个整数Xi、Yi、Zi，表示有一条长度为Zi的无向边连接结点Xi、Yi

输出格式：

输出包含一个数，即最小生成树的各边的长度之和；如果该图不连通则输出orz

输入输出样例

输入样例#1：

4 5
1 2 2
1 3 2
1 4 3
2 3 4
3 4 3

输出样例#1：

7

说明

时空限制：1000ms,128M

数据规模：

对于20%的数据：N<=5，M<=20

对于40%的数据：N<=50，M<=2500

对于70%的数据：N<=500，M<=10000

对于100%的数据：N<=5000，M<=200000

样例解释：

所以最小生成树的总边权为2+2+3=7

• 最小生成树模板题，由数据范围可知，kruscal算法即可。复杂度O(mlogm)。

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;

struct bian {
    int x,y,a;    
} e[200050];

bool cmp(const bian p,const bian q){
    return p.a<q.a;
}

int n,m,ans,t,father[5050];

int gf(int x) {
    if (father[x]==x) return(x);
    father[x]=gf(father[x]);
    return(father[x]);
}

int main(){
    scanf("%d%d",&n,&m);
    for (int i=1; i<=m; i++) scanf("%d%d%d",&e[i].x,&e[i].y,&e[i].a);
    for (int i=1; i<=n; i++) father[i]=i;
    sort(e+1,e+m+1,cmp);
    for (int i=1; i<=m; i++) {
        int fx=gf(e[i].x);
        int fy=gf(e[i].y);
        if (fx!=fy) {
            father[fx]=fy;
            ans+=e[i].a;
        }
    }
    t=gf(1);
    bool f=true;
    for (int i=2; i<=n; i++) {
        if (gf(i)!=t) {
            printf("orz");
            f=0;
            break;
        }
    }
    if (f) printf("%d",ans);
    return 0;
}

Problem 2 公路修建

题目描述

某国有n个城市，它们互相之间没有公路相通，因此交通十分不便。为解决这一“行路难”的问题，政府决定修建公路。修建公路的任务由各城市共同完成。

修建工程分若干轮完成。在每一轮中，每个城市选择一个与它最近的城市，申请修建通往该城市的公路。政府负责审批这些申请以决定是否同意修建。

政府审批的规则如下：

（1）如果两个或以上城市申请修建同一条公路，则让它们共同修建；

（2）如果三个或以上的城市申请修建的公路成环。如下图，A申请修建公路AB，B申请修建公路BC，C申请修建公路CA。则政府将否决其中最短的一条公路的修建申请；

（3）其他情况的申请一律同意。

一轮修建结束后，可能会有若干城市可以通过公路直接或间接相连。这些可以互相：连通的城市即组成“城市联盟”。在下一轮修建中，每个“城市联盟”将被看作一个城市，发挥一个城市的作用。

当所有城市被组合成一个“城市联盟”时，修建工程也就完成了。

你的任务是根据城市的分布和前面讲到的规则，计算出将要修建的公路总长度。

输入输出格式

输入格式：

第一行一个整数n，表示城市的数量。(n≤5000)

以下n行，每行两个整数x和y，表示一个城市的坐标。(-1000000≤x，y≤1000000)

输出格式：

一个实数，四舍五入保留两位小数，表示公路总长。（保证有惟一解）

输入输出样例

输入样例#1：

4
0 0
1 2
-1 2
0 4

输出样例#1：

6.47

说明

修建的公路如图所示：

• 本题思路比较明确，即求出最小生成树即可。
• 数据范围，n≤5000。相当于5000*5000条边（kruscal已gg），那只能用prim了。
• 复杂度O(n²)，应该是能通过的。

#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cmath>

int n,x[5050],y[5050];
double d[5050],ans;
bool v[5050];

double cal(int a,int b)
{
     double e1,e2;
     e1=abs(x[a]-x[b]);e2=abs(y[a]-y[b]);
     return sqrt(e1*e1+e2*e2);
}      

int main() {
    scanf("%d",&n);
    for (int i=1; i<=n; i++) scanf("%d%d",&x[i],&y[i]);
    for (int i=2; i<=n; i++) d[i]=cal(1,i);
    d[1]=0;
    v[1]=1;
    for (int i=2; i<=n; i++) {
        double minn=2147483647;
        int cur=0;
        for (int j=1; j<=n; j++) 
            if (!v[j] && d[j]<minn) {
                minn=d[j];
                cur=j;
            }
        ans=ans+d[cur];
        v[cur]=1;
        for (int j=1; j<=n; j++) if (!v[j] && d[j]>cal(cur,j)) d[j]=cal(cur,j);
    }
    printf("%.2lf",ans);
    return 0;
}

Problem 3 清理仓库

题目描述

李老师的仓库已经有很多年没有清扫了，所以这次的计划是用河水来冲。仓库是一个N*M的矩形，且每个格子里都堆满了尘土。相邻的格子之间都有门，要想让水冲进去，就必须打开这些门。这可不是一件容易的事情。因为有些格子里土堆得很高，因此打开门就很费劲。推开（或拉开）一扇从A格子到B格子的门，需要的力度值为B房间里土堆的高度。写一个程序计算至少需要花费多少力气，才能使所有的格子都进水。

输入输出格式

输入格式：

第一行为N和M(N, M <= 40)，代表仓库的大小。

以后N行，每行N个整数（每个数不超过100），分别表示每个格子里土堆的厚度。

输出格式：

你得到的结果。所有的格子必须都进水。水是从左上角的格子进去的。

输入输出样例

输入样例#1：

3 4
3 5 2 1
7 3 4 8
1 6 5 7

输出样例#1：

26

• 一道最小生成树建模的题。由题意，若要两个房间联通，需要打开中间的门，而开门只有两种方式，即推开和拉开，据此建边，求最小生成树即可。
• 时间复杂度O(n*m*4*log (n*m*4)),可以通过该题。

var
    n,m,i,j,k,fx,fy,ans        :longint;
    father                    :array[0..2050] of longint;
    a                        :array[0..2050] of longint;
    l,r,w                    :array[0..10050] of longint;
    
procedure swap(var x,y:longint);
var
    t                        :longint;
begin
    t:=x;
    x:=y;
    y:=t;
end;
    
procedure sort(ll,rr:longint);
var
    i,j,x                    :longint;
begin
    i:=ll; j:=rr; x:=w[(ll+rr)>>1];
    while i<j do
    begin
        while w[i]<x do inc(i);
        while w[j]>x do dec(j);
        if i<=j then
        begin
            swap(w[i],w[j]);
            swap(l[i],l[j]);
            swap(r[i],r[j]);
            inc(i);
            dec(j);
        end;
    end;
    if i<rr then sort(i,rr);
    if j>ll then sort(ll,j);
end;

function min(x,y:longint):longint;
begin
    if x<y then exit(x) else exit(y);
end;
    
function gf(x:longint):longint;
begin
    if father[x]=x then exit(x);
    father[x]:=gf(father[x]);
    exit(father[x]);
end;    
    
begin
    read(n,m);
    for i:=1 to n*m do read(a[i]);
    for i:=1 to n*m do father[i]:=i;
    for i:=1 to n*m do
    begin
        if i mod m<>0 then
        begin
            inc(k);
            l[k]:=i;
            r[k]:=i+1;
            w[k]:=min(a[l[k]],a[r[k]]);
        end;
        if i<=(n-1)*m then
        begin
            inc(k);
            l[k]:=i;
            r[k]:=i+m;
            w[k]:=min(a[l[k]],a[r[k]]);
        end;
    end;
    sort(1,k);
    for i:=1 to k do
    begin
        fx:=gf(l[i]);
        fy:=gf(r[i]);
        if fx<>fy then
        begin
            father[fx]:=fy;
            inc(ans,w[i]);
        end;
    end;
    writeln(ans);
end.

Problem 4 [NOIP2013] 货车运输

题目描述

A 国有 n 座城市，编号从 1 到 n，城市之间有 m 条双向道路。每一条道路对车辆都有重量限制，简称限重。现在有 q 辆货车在运输货物， 司机们想知道每辆车在不超过车辆限重的情况下，最多能运多重的货物。

输入输出格式

输入格式：

输入文件名为 truck.in。

输入文件第一行有两个用一个空格隔开的整数 n，m，表示 A 国有 n 座城市和 m 条道

路。 接下来 m 行每行 3 个整数 x、 y、 z，每两个整数之间用一个空格隔开，表示从 x 号城市到 y 号城市有一条限重为 z 的道路。意：x 不等于 y，两座城市之间可能有多条道路。

接下来一行有一个整数 q，表示有 q 辆货车需要运货。

接下来 q 行，每行两个整数 x、y，之间用一个空格隔开，表示一辆货车需要从 x 城市运输货物到 y 城市，注意：x 不等于 y。

输出格式：

输出文件名为 truck.out。

输出共有 q 行，每行一个整数，表示对于每一辆货车，它的最大载重是多少。如果货

车不能到达目的地，输出-1。

输入输出样例

输入样例#1：

4 3
1 2 4
2 3 3
3 1 1
3
1 3
1 4
1 3

输出样例#1：

3
-1
3

说明

对于 30%的数据，0 < n < 1,000，0 < m < 10,000，0 < q< 1,000； 对于 60%的数据，0 < n < 1,000，0 < m < 50,000，0 < q< 1,000； 对于 100%的数据，0 < n < 10,000，0 < m < 50,000，0 < q< 30,000，0 ≤ z ≤ 100,000。

 

• 由题意可知本题要求图中联通边尽量大，所以可以想到最大生成树。
• 首先可以用kruscal算法得到一颗最大生成树，接着要找出两点间连边最小边权的边。比较简单的想法：暴力的求出路径上边的最小值，但复杂度较高，不是理想的策略。我们可以用倍增的想法，维护两点的最近公共祖先(lca)以及它们到最近公共祖先之间的距离。该算法复杂度O(mlogm+qlogn)，比较理想，可以通过本题。

type
    rec                    =record
    l,r,w                :longint;
end;

var
    n,m,i,j,x,y,z,q,fx,fy,root,l    :longint;
    e                                :array[0..100050] of rec;
    pre,last,other,len,d            :array[0..100050] of longint;
    vis                                :Array[0..100050] of boolean;
    father                            :array[0..100050] of longint;
    anc                                :array[0..100050,0..30] of longint;
    minn                            :Array[0..100050,0..30] of longint;
    
function min(x,y:longint):longint;
begin
    if x<y then exit(x) else exit(y);
end;
    
procedure swap(var a,b:rec);
var
    c                                :rec;
begin
    c:=a;
    a:=b;
    b:=c;
end;
    
procedure sort(l,r:longint);
var
    i,j,x                            :longint;
begin
    i:=l; j:=r; x:=e[(l+r)>>1].w;
    while i<j do
    begin
        while e[i].w<x do inc(i);
        while e[j].w>x do dec(j);
        if i<=j then
        begin
            swap(e[i],e[j]);
            inc(i);
            dec(j);
        end;
    end;
    if i<r then sort(i,r);
    if j>l then sort(l,j);
end;

function gf(x:longint):longint;
begin
    if father[x]=x then exit(x);
    father[x]:=gf(father[x]);
    exit(father[x]);
end;

procedure add(u,v,r:longint);
begin
    inc(l);
    pre[l]:=last[u];
    last[u]:=l;
    other[l]:=v;
    len[l]:=r;
end;

procedure dfs(x:longint);
var
    p,q                                :longint;
begin
    p:=last[x];
    while p<>0 do
    begin
        q:=other[p];
        if (not vis[q]) then
        begin
            vis[q]:=true;
            d[q]:=d[x]+1;
            minn[q,0]:=len[p]; 
            anc[q,0]:=x;
            dfs(q);
        end;
        p:=pre[p];
    end;
end;

procedure bz;
var
    i,j                                :longint;
begin
    for j:=1 to 25 do
        for i:=1 to n do
        begin
            minn[i,j]:=min(minn[i,j-1],minn[anc[i,j-1],j-1]);
            anc[i,j]:=anc[anc[i,j-1],j-1];
        end;
end;

function lca(u,v:longint):longint;
var
    t,ans,i                            :longint;
begin
    if d[u]<d[v] then
    begin
        t:=u;
        u:=v;
        v:=t;
    end;
    ans:=maxlongint;
    for i:=25 downto 0 do
    begin
        if d[anc[u,i]]>=d[v] then 
        begin
            ans:=min(ans,minn[u,i]);
            u:=anc[u,i];
        end;
    end;
    if u=v then exit(ans);
    for i:=25 downto 0 do
    begin
        if (anc[u,i]<>anc[v,i]) then
        begin
            ans:=min(ans,minn[u,i]);
            ans:=min(ans,minn[v,i]);
            u:=anc[u,i];
            v:=anc[v,i];
        end;
    end;
    ans:=min(ans,minn[u,0]);
    ans:=min(ans,minn[v,0]);
    exit(ans);
end;
    
begin
    read(n,m);
    for i:=1 to n do father[i]:=i;
    for i:=1 to m do read(e[i].l,e[i].r,e[i].w);
    sort(1,m);
    for i:=m downto 1 do
    begin
        fx:=gf(e[i].l);
        fy:=gf(e[i].r);    
        if (fx<>fy) then
        begin
            father[fx]:=fy;
            add(e[i].l,e[i].r,e[i].w);
            add(e[i].r,e[i].l,e[i].w);
            root:=e[i].l;
        end;
    end;
    d[root]:=1;
    vis[root]:=true;
    dfs(root);
    bz;
    {writeln(root);
    for i:=1 to n do
    begin
        for j:=0 to 10 do write(anc[i,j]);
        writeln;
    end;
    for i:=1 to n do writeln(d[i]);}
    read(q);
    for i:=1 to q do
    begin
        read(x,y);
        if gf(x)<>gf(y) then writeln(-1) else writeln(lca(x,y));
    end;
end.