简单图论－最小生成树—kruskal+prim

所以prim是每次是选点进集合，而kruskal是选边进集合(稀疏的时候很有用)

另外这两个算法只用于无向图的，双向不同的值是不能用这两个算法的

有向的要使用貌似一个叫有向树形图的算法

kruskal hdu1102 没AC

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>

using namespace std;

struct edge
{
int a;
int b;
int value;
};

int comp(const void *a,const void *b)
{
edge *t1=(edge*)a;
edge *t2=(edge*)b;
return t1->value - t2->value ;
}

//kruskal
//n是点，m是边
//时间复杂度是 mlog(m)+m*n
//前面是由于排序的关系
//后面是因为每次用贪心取最小的边，但是取了这个边不能构成环
//要取n-1次，所以有这个时间复杂度

class ckruskal
{
private:
static const int MAX=200;
static const int INF=0x7fffffff;
int dis[MAX][MAX];
int set[MAX];
edge len[MAX]; //边数组
int sig[MAX][MAX];
int n,m; //n个点，m条边
int rm;
public:
void input();
void output();
int kruskal();
void solve();
int find(int t);
};

int ckruskal::find(int t)
{
int i,tt=t;
while(set[t]!=t)
t=set[t];

while(tt!=t) //压缩
{ i=set[tt];
set[tt]=t;
tt=i;
}
return t;
}

void ckruskal::solve()
{
input();
}

void ckruskal::input()
{
int i,j,tm;
while(scanf("%d",&n)!=EOF){
m=0; //这里不是稀疏矩阵，所以导致这种情况 m的值很大
for(i=1;i<=n;i++)
for(j=1;j<=n;j++)
{ scanf( "%d",&dis[i][j] );
if(!dis[i][j])
dis[i][j]=INF;
if( i<j )
{ len[m].a=i;len[m].b=j;len[m].value=dis[i][j];m++;}
}

memset(sig,0,sizeof(sig));
for(i=1;i<=n;i++)
set[i]=i; //并查集初始化
int a,b;
scanf("%d",&tm);
rm=0;
for(i=1;i<=tm;i++)
{ scanf("%d %d",&a,&b);
sig[a][b]=1; //这条边已经连过了
sig[b][a]=1;
a=find(a);
b=find(b);
if(a!=b)
{ set[a]=b;
rm++;
}
}
rm=n-1-rm;
output();

}
}

int ckruskal::kruskal()
{
int i=0,cnt;
int ll=0;
qsort(len,m,sizeof(edge),::comp); //排序，每次取最小的

for(cnt=1;cnt<=rm;) //n-1条边就是最小生成树了,这里是特殊情况
{
if( sig[len[i].a][len[i].b] )
{
i++;
continue;
}

int t1=find(len[i].a);
int t2=find(len[i].b);
if(t1==t2)
{
i++;
continue;
}

set[t1]=t2;

ll+=len[i].value;
cnt++;
i++;
}

return ll;

}

void ckruskal::output()
{
printf("%d/n",kruskal());
}

int main()
{
ckruskal kl;
kl.solve();

return 0;
}

hdu 1875 PRIM算法 AC

#include <cstdio>
#include <iostream>
#include <cstdlib>
#include <cstring>

using namespace std;

//n^2的时间复杂度
//思想是 把所有点集 分成lh和rh
//lh是已经选入集合的点 rh是集合外的点
//从rh中选择 lh和rh边最短的边 的点
//然后更新 lh到rh的各点的边长。
//hoho~经典啊

class cprim
{
private:
static const int MAX=400;
static const int INF=0x7fffffff;
int sig[MAX];
int dis[MAX][MAX];
int t,n,m;

public:
int prim();
void input();
inline void output()
{
printf("%d/n",prim());
}

};

void cprim::input()
{
int a,b,c;
while(scanf("%d",&n) && n!=0)
{ memset(sig,0,sizeof(sig));
for(a=1;a<=n;a++)
dis[a][a]=INF;
m=n*(n-1)/2;
while(m--)
{
scanf("%d %d %d",&a,&b,&c);
dis[a][b]=c;
dis[b][a]=c;
}
output();
}
}

int cprim::prim()
{
int min=INF;
int lh[MAX]; //left_hand的array,代表当前选进点组成的所有点到点的距离

int i,idx,len=0,cnt=1;
if( n==1 )
return 0;

idx=1;sig[idx]=1; //选入lh;
for(i=1;i<=n;i++)
lh[i]=INF;
while( cnt<n )
{
for(i=1;i<=n;i++)
{
if( dis[idx][i]<lh[i] && !sig[i] )
lh[i]=dis[idx][i];
}
min=INF;
for(i=1;i<=n;i++)
{
if( !sig[i] && lh[i]<min )
{
min=lh[i];
idx=i;
}
}
sig[idx]=1;
len+=lh[idx];
cnt++;
}
return len;
}

int main()
{

cprim tp;
tp.input();
return 0;
}