最小生成树

P3366 【模板】最小生成树

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
int f[5005],n,m,ans,k;
struct point{
    int x,y,z;//x和y之间有一条长度为z的连边 
}p[200005];
bool cmp(const point &a,const point &b){
    return a.z<b.z;
}
int father(int x){//返回x的父亲 
    if(f[x]!=x)f[x]=father(f[x]);//如果还未到祖先(祖先的父亲是自己) 
    return f[x];//继续递归 
}
void unionn(int x,int y){
    int fa=father(x),fb=father(y);
    if(fa!=fb)f[fa]=fb;//合并集合 
} 
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)f[i]=i;//初始化 
    for(int i=1;i<=m;i++)scanf("%d%d%d",&p[i].x,&p[i].y,&p[i].z);
    sort(p+1,p+m+1,cmp);
    
    for(int i=1;i<=m;i++){
        if( father(p[i].x)!=father(p[i].y) ){
            ans+=p[i].z;//加入这条边 
            unionn(p[i].x,p[i].y);//加入集合 
            k++;
        }
        if(k==n-1)break;//树只有n-1条边 
    }
    printf("%d",ans);
    return 0;
}

 

P1194 买礼物

因为起点有权值，所以ans+=A;

若连边为空，或权值大于A，修改为A;

正常跑一边模板...

#include <iostream>
#include <cstdio>
#include <algorithm>
#define M 550
#define N 250005
#define R register
using namespace std;
int A,B;
int f[M],ans,k,kk;
struct node{
    int x,y,v;
}p[N];
inline int ri(){
    char c=getchar();int x=0,w=1;
    while(!isdigit(c)){if(c=='-')w=-1;c=getchar();}
    while( isdigit(c)){x=(x<<3)+(x<<1)+c-48;c=getchar();}
    return x*w;
}
inline bool cmp(const node &a,const node &b){
    return a.v<b.v;
}
inline int father(int x){
    if(f[x]!=x)f[x]=father(f[x]);
    return f[x];
}
inline void unionn(int x,int y){
    int fa=father(x),fb=father(y);
    if(fa!=fb)f[fa]=fb;
}
int main(){
    A=ri(),B=ri();
    for(R int i=1;i<=B;i++)f[i]=i;
    for(R int i=1;i<=B;i++)
        for(R int j=1;j<=B;j++){
            p[++kk].v=ri();
            p[kk].x=i,p[kk].y=j;
            if(!p[kk].v||p[kk].v>A)p[kk].v=A;
        }
    sort(p+1,p+kk+1,cmp);
    for(R int i=1;i<=kk;i++){
        if(father(p[i].x)!=father(p[i].y)){
            ans+=p[i].v;
            unionn(p[i].x,p[i].y);
            k++;
        }
        if(k==B-1)break;
    }
    printf("%d",ans+A);
    return 0;
}

 最优布线问题

题目描述

    学校有 n 台计算机，为了方便数据传输，现要将它们用数据线连接起来。两台计算机被连接是指它们时间有数据线连接 。由于计算机所处的位置不同，因此不同的两台计算机的连接费用往往是不同的。 
    当然，如果将任意两台计算机都用数据线连接，费用将是相当庞大的。为了节省费用，我们采用数据的间接传输手段，即一台计算机可以间接 的通过若干台计算机（作为中转 ）来实现与另一台计算机的连接 。 
    现在由你负责连接这些计算机，你的任务是使任意两台计算机都连通 （不管是直接的或间接的），且总费用最小。

输入格式

    第一行为整数 n （2<=n<=100），表示计算机的数 目。此后的 n 行，每行 n 个整数。第 x+1 行 y 列的整数表示直接连接第 x 台计算机和第 y 台计算机的费用（不大于10000），如果费用为0表示(x,y)之间不通。

输出格式

一个整数，表示最小的连接费用。

样例

样例输入1

3
0 1 2
1 0 1
2 1 0

样例输出1

2

 emm类似的模板题..

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int n,z,k,ans;
int f[110];
struct node{
    int x,y,v;
}p[10005];
inline bool cmp(const node &a,const node &b){
    return a.v<b.v;
}
inline int father(int x){
    if(f[x]!=x)f[x]=father(f[x]);
    return f[x];
}
inline void unionn(int a,int b){
    int fa=father(a),fb=father(b);
    if(fa!=fb)f[fa]=fb;
}
int main(){
    cin>>n;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++){
            cin>>z;
            if(z)p[++k].x=i,p[k].y=j,p[k].v=z;        
        }
    sort(p+1,p+k+1,cmp),k=0;    
    for(int i=1;i<=n;i++)f[i]=i;
    for(int i=1;i<=n*n;i++){
        if(father(p[i].x)!=father(p[i].y)){
            ans+=p[i].v;
            k++;
            unionn(p[i].x,p[i].y);
        }
        if(k==n-1)break;
    }
    cout<<ans;
}

 征兵

题目描述

一个国王，他拥有一个国家。最近他因为国库里钱太多了，闲着蛋疼要征集一只部队要保卫国家。他选定了N个女兵(编号0...N-1)和M个男兵(编号0...M-1)，但事实上每征集一个兵他就要花10000RMB，即使国库里钱再多也伤不起啊。他发现，某男兵和某女兵之间有某种关系（往正常方面想，一共R种关系），这种关系可以使KING少花一些钱就可以征集到兵，不过国王也知道，在征兵的时候，每一个兵只能使用一种关系来少花钱。这时国王向你求助，问他最少要花多少的钱。

输入格式

第一行：T，一共T组数据。

接下来T组数据，

第一行包括N,M,R

接下来的R行包括Xi,Yi,Vi 表示如果招了第Xi个女兵，再招第Yi个男兵能省Vi元（同样表示如果招了第Yi个男兵，再招第Xi个女兵能也省Vi元）

输出格式

共T行，表示每组数据的最终花费是多少（因为国库里的钱只有2^31-1，所以保证最终花费在maxlongint范围内）

样例

样例输入1

2

5 5 8
4 3 6831
1 3 4583
0 0 6592
0 1 3063
3 3 4975
1 3 2049
4 2 2104
2 2 781

5 5 10
2 4 9820
3 2 6236
3 1 8864
2 4 8326
2 0 5156
2 0 1463
4 1 2439
0 4 4373
3 4 8889
2 4 3133

样例输出1

71071
54223

最大权森林....最短路实现。

我们设想这样一个无向图:在征募某个人a时，如果使用了a和b之间的关系，就连一条a到b的边。不可能存在一个圈，因为题目要求是男女之间的关系，一个圈最少三个人，三个人不可能满足相邻的人异性，n(n>=3)时类似。因此可知这个图是一片森林(两个连通分量，男生和女生分别在一个连通分量中)。反之，如果给定了一个森林，就可以确定征募的顺序。

因此，把人看成顶点、把关系看成边，这个问题就转化为求解无向图的最大权森林问题。最大权森林问题可以通过把所有边的权值取反之后用最小生成树的算法求解。

原文：这里。

男女编号都是从0开始坑了半天..其实只要男生编号输入完 + n 。

前几道题都是敲kruaskal吧..接下来还有prim。

当然。个人码风如下。

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int maxn=2e4+5;
int n,m,r;
int f[maxn];
struct node{
    int u,v,cost;
}p[50005];
inline bool cmp(const node &a,const node &b){
    return a.cost<b.cost;
}
int father(int x){
    return f[x]==x ? x : f[x]=father(f[x]) ;
}
void unionn(int x,int y){
    int fa=father(x),fb=father(y);
    if(fa!=fb)f[fa]=fb;
}
inline void Kruskal(){
    int ans=0;
    for(int i=0;i<n+m;i++)f[i]=i;
    sort(p,p+r,cmp);
    for(int i=0;i<r;i++){
        node e=p[i];
        if(father(e.u)!=father(e.v)){
            unionn(e.u,e.v);
            ans+=e.cost;
        }
    }
    printf("%d
",10000*(n+m)+ans);
}
int main(){
    int t,a,b,c;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d%d",&n,&m,&r);
        for(int i=0;i<r;i++){
            scanf("%d%d%d",&a,&b,&c);
            p[i]=(node){a,b+n,-c};
        }
        Kruskal();
    }
    return 0;
}

 P1656 炸铁路

额。据说正解是tarjan。

我并没有学过啊。。。

看着dalao的博客，这题在kruaskal中。

再看了看数据范围。

哦。大力枚举啊。m^2呢。

每次删一条边。然后做一次假的kruaskal，看是否能够成树。也就是是否能连通。

没有边长。排序的技巧就在于满足恶心的输出要求，从小到大。

tarjan。。以后学了再说吧？？

所以自己bb了一下假的kruaskal代码。

#include <iostream>
#include <cstdio>
#include <algorithm>
#define R register
using namespace std;
int n,m,f[200],tot;
struct node{
    int x,y;
}p[5010];
inline int ri(){
    char c=getchar();int x=0,w=1;
    while(!isdigit(c)){if(c=='-')w=-1;c=getchar();}
    while( isdigit(c)){x=(x<<3)+(x<<1)+c-48;c=getchar();}
    return x*w;
}
inline bool cmp(const node &a,const node &b){
    if(a.x<b.x || (a.x==b.x&&a.y<b.y) )return 1;
    return 0;
}
inline int father(int x){
    return f[x]==x ? x : f[x]=father(f[x]);
}
inline void unionn(int x,int y){
    int fa=father(x),fb=father(y);
    if(fa!=fb)f[fa]=fb,tot++;
}
int main(){
    int a,b;
    n=ri(),m=ri();
    for(R int i=1;i<=m;++i){
        a=ri(),b=ri();
        p[i].x=min(a,b),p[i].y=max(a,b);
    }
    sort(p+1,p+m+1,cmp);
    for(R int i=1;i<=m;++i){//每次删第i条边 
        tot=0;
        for(R int j=1;j<=n;++j)f[j]=j;
        for(R int j=1;j<=m;++j){
            if(i!=j)unionn(p[j].x,p[j].y);
            if(tot==n-1)break; 
        }
        if(tot!=n-1)printf("%d %d
",p[i].x,p[i].y);
    }
    return 0;
} 

 P1195 口袋的天空

求连通块啊。

别方。

这和求最小生成树没什么区别。只是最小生成树要连所有的点，这题只要连通块为k。

kruaskal。

初始，连通块个数为n。

加上一条边，连通块的个数- -。

加到连通块的个数减到k为止。

减不到？输出无解。

要求代价最小，边权排个序。

#include <iostream>
#include <cstdio>
#include <algorithm>
#define R register 
using namespace std;
int n,m,k,f[1010],ans;
struct node{
    int x,y,v;
}p[10005];
inline int ri(){
    char c=getchar();int x=0,w=1;
    while(!isdigit(c)){if(c=='-')w=-1;c=getchar();}
    while( isdigit(c)){x=(x<<3)+(x<<1)+c-48;c=getchar();}
    return x*w;
}
inline bool cmp(node a,node b){
    return a.v<b.v;
}
inline int father(int x){
    return f[x]==x ? x : f[x]=father(f[x]);
}
inline void unionn(int x,int y){
    int fa=father(x),fb=father(y);
    if(fa!=fb)f[fa]=fb;
}
int main(){
    n=ri(),m=ri(),k=ri();
    int tot=n;
    for(R int i=1;i<=m;i++)p[i].x=ri(),p[i].y=ri(),p[i].v=ri();
    for(R int i=1;i<=n;i++)f[i]=i;
    sort(p+1,p+m+1,cmp);
    for(R int i=1;i<=m;i++){
        node e=p[i];
        if(father(e.x)!=father(e.y)){
            tot--,ans+=e.v;
            unionn(e.x,e.y);
        }
        if(tot==k){
            printf("%d",ans);
            return 0;
        }
    }
    printf("No Answer");
    return 0;
}

 1443 公路修建

题目描述

      某国有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

5000个点。12497500条边。排序边要超时呀。kruaskal

所以prim。n^2可接受呢。

无比类似于模板了。define用得比较多，为了代码好看。。。

prim的思想就是，首先预处理。

 for(R int i=2;i<=n;i++)dis[i]=INF;//到dis[i]的最优距离 

然后第一层for，找与这个点连得最小边。

第二层for，找到后，找每个点与这个当前选中的点的距离，看能否刷新dis。

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
#define R register
#define MN 5005
#define INF 1e9
#define t work(p[dx][0],p[dx][1],p[j][0],p[j][1])
#define x2 (x-xx)*(x-xx)
#define y2 (y-yy)*(y-yy)
using namespace std;
int p[MN][2];//第i个点坐标：(p[i][0],p[i][1]) 
bool uesd[MN];//prim算法，这个点用过没有
double dis[MN],ans;//到dis[i]的最优距离
inline double work(int x,int y,int xx,int yy){//算距离 
    return sqrt( (double)x2 + (double)y2 );
} 
inline int ri(){
    char c=getchar();int x=0,w=1;
    while(!isdigit(c)){if(c=='-')w=-1;c=getchar();}
    while( isdigit(c)){x=(x<<3)+(x<<1)+c-48;c=getchar();}
    return x*w;
}
int main(){
    int n; n=ri();
    for(R int i=1;i<=n;i++)p[i][0]=ri(),p[i][1]=ri();
    for(R int i=2;i<=n;i++)dis[i]=INF;//基本操作 设为inf
    int dx; double dy;//目前加的点，及其边权
    for(R int i=1;i<=n;i++){ 
        dy=INF;
        for(R int j=1;j<=n;j++)
            if(!uesd[j]&&dis[j]<dy){//找到更短
                dx=j, //这个点存下 
                dy=dis[j];//记下新的最短值        
        }
        ans+=dy;//搜完了,记下最优的答案 
        uesd[dx]=1;//标记为用过 
        for(R int j=1;j<=n;j++)//刷新。当前加入的点能到达的每个点，尝试能否刷新他们的dis 
            if(t<dis[j])dis[j]=t;//t见define 
    } 
    printf("%.2lf
",ans);
    return 0; 
}