prim算法多用于边多的稠密图（边多排序就多，不能用kruskal），kruskal算法多用于边少的稀疏图（边少排序少，就更快）
还是畅通工程
Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 65781 Accepted Submission(s): 29799
Problem Description
某省调查乡村交通状况，得到的统计表中列出了任意两村庄间的距离。省政府“畅通工程”的目标是使全省任何两个村庄间都可以实现公路交通（但不一定有直接的公路相连，只要能间接通过公路可达即可），并要求铺设的公路总长度为最小。请计算最小的公路总长度。
Input
测试输入包含若干测试用例。每个测试用例的第1行给出村庄数目N ( < 100 )；随后的N(N-1)/2行对应村庄间的距离，每行给出一对正整数，分别是两个村庄的编号，以及此两村庄间的距离。为简单起见，村庄从1到N编号。
当N为0时，输入结束，该用例不被处理。
Output
对每个测试用例，在1行里输出最小的公路总长度。
Sample Input
3 1 2 1 1 3 2 2 3 4 4 1 2 1 1 3 4 1 4 1 2 3 3 2 4 2 3 4 5 0
Sample Output
3 5
Hint
Hint Huge input, scanf is recommended. |
prim算法，从指定点开始寻找连接的min边，把新点加入，再在走过的所有点中寻找最短边（优先队列，堆优化可以加快速度）（从哪个节点开始结果都一致）
bool operator <(const node &a) const //以dis从小到大为排序的基准方法
{
return a.dis < dis;
}
friend bool operator < (const node& x,const node& y)//优先队列即最小堆
{
return x.dis > y.dis; // <为从大到小排列，>为从小到大排列
}///多用于优先队列
node(int a, int b): v(a), dis(b) {}; //声明一个使用方法node(int ,int)
方法这样用q.push(node(1, 0));
bool cmp(node a,node b)//多用于快排
{
return a.dis<b.dis;
}
memset(dis, inf, sizeof(dis));
//只是线段的距离，从1开始，1到自身的距离为0
//代表到这节点的线段的长度，进行排除得出最短的线段
for(int i = 1; i <= n; i++)
{//先尽可能选小的距离，可以会出现大到小的数据情况
if( vis[i]==0 && dis[i] > mp[tmp][i] )//代表到这节点的线段的长度，进行排除得出最短的线段，就是从走节点到未走节点的线段的距离，比如上图dis[5]原来值为5，现在选了节点6之后，dis[5]想变8，但是原来的值5才是从以标记节点到节点5的现在的最小距离值
{
//但只会选中其中最短的边出队，之后出队的边都是大的，不会影响最小值;
dis[i] = mp[tmp][i];
q.push(node(i, dis[i]));
}
}
也可以使用邻结表进行优化，但只是时间复杂度的优化！
也就是每个点出去的边的遍历的设计，这
vector<node> vi[106];（更加麻烦的设计和耗时）
#include <iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
const int inf = 0x3f3f3f3f;
int n, m;
int dis[105], vis[105];//dis为距离，就是点与点之间的距离
struct node
{
int v, dis;//v为节点，dis为到这个节点的距离
node(int a, int b): v(a), dis(b) {}; //声明一个使用方法node(int ,int)
/*bool operator <(const node &a) const //以dis从小到大为排序的基准方法
{
return a.dis < dis;
}
*/
friend bool operator < (const node& x,const node& y)//优先队列即最小堆
{
return x.dis > y.dis;// <为从大到小排列，>为从小到大排列
}
};
vector<int> vi[106];
bool cmp(node a,node b)
{
return a.dis<b.dis;
}
int mp[105][105];//图的距离
void dij()
{
int sum = 0;
int ans = 0;//节点数目
priority_queue<node>q;
q.push(node(1, 0));
while(!q.empty())//每次所有节点中最小距离值出队
{
//cout<<1<<endl;
int tmp = q.top().v;
int cost = q.top().dis;//dis为距离，就是点与点之间的距离
q.pop();
if(vis[tmp])
continue;
sum += cost;//总路程
ans++;
vis[tmp] = 1;
for(vector<int>::iterator it=vi[tmp].begin() ; it!=vi[tmp].end() ; it++ )
//for(int i = 1; i <= n; i++)
{//先尽可能选小的距离，可以会出现大到小的数据情况
if( vis[*it] == 0 && dis[*it] > mp[tmp][*it] )//只是入队，但不代表被标记，同一个节点有多个边可能入队，
{
//但只会选中其中最短的边出队，之后出队的边都是大的，不会影响最小值;
dis[*it] = mp[tmp][*it];
q.push(node(*it, dis[*it]));
}
}
}
if(ans == n) //n为节点数，m为边数
printf("%d\n", sum);
else
printf("?\n");
}
int main()
{
while(~scanf("%d%d", &m, &n), m)
{
//<<n*(n-1)/2;
memset(mp, inf, sizeof(mp));
memset(dis, inf, sizeof(dis));//距离，从1开始，1到自身的距离为0
memset(vis,0,sizeof(vis));
dis[1] = 0; //从1开始，从1到1的距离为为0
for(int i = 1; i <= m; i++)
{
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
vi[u].push_back(v);
vi[v].push_back(u);
//cout<<2<<endl;
mp[u][v] = w;
mp[v][u] = w;
}
//cout<<1<<endl;
dij();
}
return 0;
}
/*
12 7
0 1 4
0 6 2
0 5 5
5 6 8
1 6 1
5 4 1
1 2 2
4 6 4
2 6 3
3 6 7
3 4 6
2 3 10
*/
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int n, m;
int dis[105], vis[105];
struct node
{
int v, dis;
node(int a, int b): v(a), dis(b) {};
bool operator <(const node &a) const
{
return a.dis < dis;
}
} ;
int mp[105][105];
void dij()
{
int sum = 0;
int ans = 0;
priority_queue<node>q;
q.push(node(1, 0));
while(!q.empty())
{
int tmp = q.top().v;
int cost = q.top().dis;
q.pop();
if(vis[tmp])
continue;
sum += cost;
ans++;
vis[tmp] = 1;
for(int i = 1; i <= n; i++)
{
if(!vis[i] && dis[i] > mp[tmp][i])//只是入队，但不代表被标记，同一个节点有多个边的入队，
{//但只会选中其中最短的边出队，之后出队的边都是大的，不会影响最小值;
dis[i] = mp[i][tmp];
q.push(node(i, dis[i]));
}
}
}
// printf("%d %d\n",ans,sum);
if(ans == n)
printf("%d\n", sum);
else
printf("?\n");
}
int main()
{
while(~scanf("%d%d", &m, &n), m)
{
memset(mp, inf, sizeof(mp));
memset(dis, inf, sizeof(dis));
memset(vis,0,sizeof(vis));
dis[1] = 0;
for(int i = 1; i <= m; i++)
{
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
mp[u][v] = w;
mp[v][u] = w;
}
dij();
}
return 0;
}
#include <iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
const int inf = 0x3f3f3f3f;
int n, m;
int dis[105], vis[105];//dis为距离，就是点与点之间的距离
struct node
{
int v, dis;//v为节点，dis为到这个节点的距离
node(int a, int b): v(a), dis(b) {}; //声明一个使用方法node(int ,int)
bool operator <(const node &a) const //以dis从小到大为排序的基准方法
{
return a.dis < dis;
}
};
int mp[105][105];//图的距离
void dij()
{
int sum = 0;
int ans = 0;//节点数目
priority_queue<node>q;
q.push(node(1, 0));
while(!q.empty())//每次所有节点中最小距离值出队
{
int tmp = q.top().v;
int cost = q.top().dis;//dis为距离，就是点与点之间的距离
q.pop();
if(vis[tmp])
continue;
sum += cost;//总路程
ans++;
vis[tmp] = 1;
for(int i = 1; i <= n; i++)
{//先尽可能选小的距离，可以会出现大到小的数据情况
if( vis[i]==0 && dis[i] > mp[tmp][i] )//只是入队，但不代表被标记，同一个节点有多个边可能入队，
{
//但只会选中其中最短的边出队，之后出队的边都是大的，不会影响最小值;
dis[i] = mp[tmp][i];
q.push(node(i, dis[i]));
}
}
}
if(ans == n) //n为节点数，m为边数
printf("%d\n", sum);
else
printf("?\n");
}
int main()
{
while(~scanf("%d", &n), n)
{
//<<n*(n-1)/2;
memset(mp, inf, sizeof(mp));
memset(dis, inf, sizeof(dis));//距离，从1开始，1到自身的距离为0
memset(vis,0,sizeof(vis));
dis[1] = 0; //从1开始，从1到1的距离为为0
for(int i = 1; i <= n*(n-1)/2; i++)
{
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
mp[u][v] = w;
mp[v][u] = w;
}
dij();
}
return 0;
}
/*
12 7
0 1 4
0 6 2
0 5 5
5 6 8
1 6 1
5 4 1
1 2 2
4 6 4
2 6 3
3 6 7
3 4 6
2 3 10
*/
#include <iostream>
#include<stdio.h>
#include<string.h>
#include<queue>
using namespace std;
const int inf = 0x3f3f3f3f;
int n, m;
int dis[105], vis[105];//dis为距离，就是点与点之间的距离
struct node
{
int v, dis;//v为节点，dis为到这个节点的距离
node(int a, int b): v(a), dis(b) {}; //声明一个使用方法node(int ,int)
/*bool operator <(const node &a) const //以dis从小到大为排序的基准方法
{
return a.dis < dis;
}
*/
friend bool operator < (const node& x,const node& y)//优先队列即最小堆
{
return x.dis > y.dis;// <为从大到小排列，>为从小到大排列
}
};
bool cmp(node a,node b)
{
return a.dis<b.dis;
}
int mp[105][105];//图的距离
void dij()
{
int sum = 0;
int ans = 0;//节点数目
priority_queue<node>q;
q.push(node(1, 0));
while(!q.empty())//每次所有节点中最小距离值出队
{
int tmp = q.top().v;
int cost = q.top().dis;//dis为距离，就是点与点之间的距离
q.pop();
if(vis[tmp])
continue;
sum += cost;//总路程
ans++;
vis[tmp] = 1;
for(int i = 1; i <= n; i++)
{//先尽可能选小的距离，可以会出现大到小的数据情况
if( vis[i]==0 && dis[i] > mp[tmp][i] )//只是入队，但不代表被标记，同一个节点有多个边可能入队，
{
//但只会选中其中最短的边出队，之后出队的边都是大的，不会影响最小值;
dis[i] = mp[tmp][i];
q.push(node(i, dis[i]));
}
}
}
if(ans == n) //n为节点数，m为边数
printf("%d\n", sum);
else
printf("?\n");
}
int main()
{
while(~scanf("%d", &n), n)
{
//<<n*(n-1)/2;
memset(mp, inf, sizeof(mp));
memset(dis, inf, sizeof(dis));//距离，从1开始，1到自身的距离为0
memset(vis,0,sizeof(vis));
dis[1] = 0; //从1开始，从1到1的距离为为0
for(int i = 1; i <= n*(n-1)/2; i++)
{
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
mp[u][v] = w;
mp[v][u] = w;
}
dij();
}
return 0;
}
/*
12 7
0 1 4
0 6 2
0 5 5
5 6 8
1 6 1
5 4 1
1 2 2
4 6 4
2 6 3
3 6 7
3 4 6
2 3 10
*/
本文深入探讨Prim算法在解决最小生成树问题中的应用，特别是在稠密图中寻找最小公路总长度的场景。通过具体实例，详细解释了Prim算法的实现过程，包括如何使用优先队列优化算法效率，以及如何在节点间寻找最短路径。
扫一扫
7749
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
