挑战程序设计竞赛 算法和数据结构 第13章 加权图

最新推荐文章于 2021-10-19 12:06:11 发布
最新推荐文章于 2021-10-19 12:06:11 发布
阅读量595 收藏
点赞数 1
分类专栏： 挑战程序设计竞赛 算法和数据结构 文章标签： NOIP 提高组 初赛
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mrcrack/article/details/78152493
版权

挑战程序设计竞赛 算法和数据结构 第13章 加权图

13.2 最小生成树

ALDS1_12_A:Minimum Spanning Tree

原书AC代码：

//ALDS1_12_A:Minimum Spanning Tree
#include <iostream>
using namespace std;
static const int MAX=100;
static const int INFTY=(1<<21);
static const int WHITE=0;
static const int GRAY=1;
static const int BLACK=2;
int n,M[MAX][MAX];
int prim(){
    int u,minv;
    int d[MAX],p[MAX],color[MAX];
    for(int i=0;i<n;i++){
        d[i]=INFTY;
        p[i]=-1;
        color[i]=WHITE;
    }
    d[0]=0;
    while(1){
        minv=INFTY;
        u=-1;
        for(int i=0;i<n;i++){
            if(minv>d[i]&&color[i]!=BLACK){
                u=i;
                minv=d[i];
            }
        }
        if(u==-1)break;
        color[u]=BLACK;
        for(int v=0;v<n;v++){
            if(color[v]!=BLACK&&M[u][v]!=INFTY){
                if(d[v]>M[u][v]){
                    d[v]=M[u][v];
                    p[v]=u;
                    color[v]=GRAY;
                }
            }
        }
    }
    int sum=0;
    for(int i=0;i<n;i++){
        if(p[i]!=-1)sum+=M[i][p[i]];
    }
    return sum;
}
int main(){
    cin>>n;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            int e;cin>>e;
            M[i][j]=(e==-1)?INFTY:e;
        }
    }
    cout<<prim()<<endl;
    return 0;
}


参考上述代码，同时也翻看本人以前的编码，本人编写的C语言AC代码如下：

//ALDS1_12_A:Minimum Spanning Tree
//样例通过，提交AC 2017-10-3 18:08
#include <stdio.h>
#include <string.h>
#define INF 999999
int e[110][110],d[110],vis[110];//d[i]  i点到生成树的最短距离
int n;
int min_pos(){
    int i,min=INF,j;
    for(i=1;i<=n;i++)
        if(vis[i]==0&&d[i]<min){
            min=d[i];
            j=i;
        }
    return j;
}
int prim(){
    int sum=0,i,j,k,count=1;
    d[1]=0;
    for(i=2;i<=n;i++)从顶点1开始
        d[i]=e[1][i];
    while(count<=n-1){
        j=min_pos();
        vis[j]=1;
        for(i=1;i<=n;i++)
            if(vis[i]==0&&d[i]>e[j][i])
                d[i]=e[j][i];
        count++;
    }
    for(i=1;i<=n;i++)
        sum+=d[i];
    return sum;
}
int main(){
    int i,j,w;
    memset(e,0,sizeof(e));
    memset(vis,0,sizeof(vis));
    scanf("%d",&n);
    for(i=1;i<=n;i++)//无向图，读取数据
        for(j=1;j<=n;j++){
            scanf("%d",&w);
            if(i!=j){
                if(w==-1)
                    e[i][j]=INF,e[j][i]=INF;
                else
                    e[i][j]=w,e[j][i]=w;
            }
        }
    printf("%d\n",prim());
    return 0;
}



13.3 单源最短路径

ALDS1_12_B:Single Source Shortest Path I

原书AC代码：

//ALDS1_12_B:Single Source Shortest Path I
//C++
#include <iostream>
using namespace std;
static const int MAX=100;
static const int INFTY=(1<<21);
static const int WHITE=0;
static const int GRAY=1;
static const int BLACK=2;
int n,M[MAX][MAX];
void dijkstra(){
    int minv;
    int d[MAX],color[MAX];
    for(int i=0;i<n;i++){
        d[i]=INFTY;
        color[i]=WHITE;
    }
    d[0]=0;
    color[0]=GRAY;
    while(1){
        minv=INFTY;
        int u=-1;
        for(int i=0;i<n;i++){
            if(minv>d[i]&&color[i]!=BLACK){
                u=i;
                minv=d[i];
            }
        }
        if(u==-1)break;
        color[u]=BLACK;
        for(int v=0;v<n;v++){
            if(color[v]!=BLACK&&M[u][v]!=INFTY){
                if(d[v]>d[u]+M[u][v]){
                    d[v]=d[u]+M[u][v];
                    color[v]=GRAY;
                }
            }
        }
    }
    for(int i=0;i<n;i++){
        cout<<i<<" "<<(d[i]==INFTY?-1:d[i])<<endl;
    }
}
int main(){
    cin>>n;
    for(int i=0;i<n;i++){
        for(int j=0;j<n;j++){
            M[i][j]=INFTY;
        }
    }
    int k,c,u,v;
    for(int i=0;i<n;i++){
        cin>>u>>k;
        for(int j=0;j<k;j++){
            cin>>v>>c;
            M[u][v]=c;
        }
    }
    dijkstra();
    return 0;
}


未参考上述代码，本人按自己的理解编写的C语言AC代码如下：

//ALDS1_12_B:Single Source Shortest Path I
//采用邻接表方式的迪杰斯特拉算法，样例很快通过，提交AC 2017-10-3 21:13
#include <stdio.h>
#include <string.h>
#define INF 999999999
int e[110][110],vis[110],d[110],n;
int min_pos(){
    int i,min=INF,j;
    for(i=0;i<=n-1;i++)
        if(vis[i]==0&&d[i]<min){
            min=d[i];
            j=i;
        }
    return j;
}
void dijstra(){
    int i,j,count=1;
    vis[0]=1;
    for(i=0;i<=n-1;i++)
        d[i]=e[0][i];
    while(count<=n-1){//剩下n-1个点
        j=min_pos();
        vis[j]=1;
        for(i=0;i<=n-1;i++)
            if(vis[i]==0&&d[i]>d[j]+e[j][i])
                d[i]=d[j]+e[j][i];
        count++;
    }
}
int main(){
    int u,k,v,c,i,j;
    memset(e,0,sizeof(e));
    memset(vis,0,sizeof(vis));
    scanf("%d",&n);
    for(i=0;i<=n-1;i++)
        for(j=0;j<=n-1;j++)
            if(i==j) e[i][j]=0;
            else e[i][j]=INF;
    for(i=1;i<=n;i++){
        scanf("%d%d",&u,&k);
        for(j=1;j<=k;j++){
            scanf("%d%d",&v,&c);
            e[u][v]=c;
        }
    }
    dijstra();
    for(i=0;i<=n-1;i++)
        printf("%d %d\n",i,d[i]);
    return 0;
}


ALDS1_12_C:Single Source Shortest Path II

原书AC代码：

//ALDS1_12_C:Single_Source_Shortest Path II
//C++
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
static const int MAX=10000;
static const int INFTY=(1<<20);
static const int WHITE=0;
static const int GRAY=1;
static const int BLACK=2;
int n;
vector<pair<int,int> >adj[MAX];//加权有向图的邻接表表示法
void dijkstra(){
    priority_queue<pair<int,int> > PQ;
    int color[MAX];
    int d[MAX];
    for(int i=0;i<n;i++){
        d[i]=INFTY;
        color[i]=WHITE;
    }
    d[0]=0;
    PQ.push(make_pair(0,0));
    color[0]=GRAY;
    while(!PQ.empty()){
        pair<int,int> f=PQ.top();PQ.pop();
        int u=f.second;
        color[u]=BLACK;
        //取出最小值，如果不是最短路径则忽略
        if(d[u]<f.first*(-1))continue;
        for(int j=0;j<adj[u].size();j++){
            int v=adj[u][j].first;
            if(color[v]==BLACK)continue;
            if(d[v]>d[u]+adj[u][j].second){
                d[v]=d[u]+adj[u][j].second;
                //priority_queue priority_queue 默认优先最大值，因此要乘以-1.
                PQ.push(make_pair(d[v]*(-1),v));
                color[v]=GRAY;
            }
        }
    }
    for(int i=0;i<n;i++){
        cout<<i<<" "<<(d[i]==INFTY?-1:d[i])<<endl;
    }
}
int main(){
    int k,u,v,c;
    cin>>n;
    for(int i=0;i<n;i++){
        cin>>u>>k;
        for(int j=0;j<k;j++){
            cin>>v>>c;//1 此处写成cin>>v>>v; 查了会
            adj[u].push_back(make_pair(v,c));
        }
    }
    dijkstra();
    return 0;
}


仿照上述代码，本人编写的C++语言AC代码如下：

//ALDS1_12_C:Single_Source_Shortest Path II
//样例通过，提交Compile Error，添加头文件 #include <cstdio>,提交AC 2017-10-4 16:06
#include <cstdio>
#include <queue>
#include <cstring>
#define INF 999999999
using namespace std;
vector<pair<int,int> > a[10100];//a相当于二维数组，a[i][j] 里面的数据类型是 整数对 pair<int,int>
int n,d[10100],vis[10100];
void dijkstra(){
    int u,v,i,j;
    priority_queue<pair<int,int> > pq;
    pq.push(make_pair(0,0));//1 请注意不是 pq.push_back(make_pair(0,0));
    for(i=0;i<n;i++)
        d[i]=INF;
    d[0]=0;
    while(!pq.empty()){
        u=pq.top().second;
        pq.pop();
        if(vis[u]==1)continue;//已经访问过
        vis[u]=1;
        for(j=0;j<a[u].size();j++){
            v=a[u][j].second;
            if(vis[v]==0&&d[v]>d[u]+a[u][j].first){//2 此处写成 if(vis[v]==0&&d[u]>d[v]+a[u][j].first)
                d[v]=d[u]+a[u][j].first;//2 此处写成 d[u]=d[v]+a[u][j].first;
                pq.push(make_pair(d[v]*(-1),v));//2 此处写成  pq.push(make_pair(d[u]*(-1),v)); 1 请注意不是 pq.push_back(make_pair(d[u]*(-1),v));
            }
        }
    }
    for(i=0;i<n;i++)
        printf("%d %d\n",i,d[i]);
}
int main(){
    int u,k,v,c,i,j;
    memset(vis,0,sizeof(vis));
    scanf("%d",&n);
    for(i=1;i<=n;i++){
        scanf("%d%d",&u,&k);
        for(j=1;j<=k;j++){
            scanf("%d%d",&v,&c);
            a[u].push_back(make_pair(c,v));//邻接表；先放权重，再放连接的点，这样与 优先队列的数据一致  
        }
    }
    dijkstra();
    return 0;
}

一切都自己写，重写该道题

//ALDS1_12_C:Single_Source_Shortest Path II
//准备采用C语言来编写该题，邻接表，自己写；堆自己写，最小堆
//样例很快通过，提交AC 2017-10-4 17:06
#include <stdio.h>
#include <string.h>
#define INF 999999999
struct node{
    int to,c,next;
}e[500100];//有向图
struct node2{
    int c,v;//c权重，v点
}heap[10000*10];//堆中会有冗余元素，故扩大10倍
int cnt=0,head[10100],n,s=0,vis[10100],d[10100];//  s用来标记堆的最后一个元素
void addedge(int u,int v,int c){
    cnt++,e[cnt].to=v,e[cnt].c=c,e[cnt].next=head[u],head[u]=cnt;
}
//堆操作 最小堆
void push(struct node2 a){//将元素插入堆 最小堆
    int p;//堆中位置
    s++;
    p=s;
    while(p>1&&a.c<heap[p/2].c){//翻看了以前堆的写法，才写出，看来模板就是模板，需要常写常记
        heap[p]=heap[p/2];
        p/=2;
    }
    heap[p]=a;
}
void adjust(int t){//翻看了以前堆的写法
    int left=2*t,right=2*t+1,k=t;
    struct node2 b;
    if(left<=s)k=heap[k].c<heap[left].c?k:left;//找出left right k中对应的heap[].c最小值
    if(right<=s)k=heap[k].c<heap[right].c?k:right;
    if(k!=t){
        b=heap[k],heap[k]=heap[t],heap[t]=b;
        adjust(k);
    }
}
void pop(){
    heap[1]=heap[s];
    s--;
    adjust(1);//翻看了以前堆的写法
}
struct node2 top(){
    return heap[1];
}
int empty(){
    return !s;
}
void dijkstra(){
    int i,b,u,v;//b边
    struct node2 a;
    memset(vis,0,sizeof(vis));
    for(i=0;i<n;i++)
        d[i]=INF;
    d[0]=0;
    a.c=0,a.v=0;
    push(a);
    while(!empty()){//1此处写成 while(empty())
        a=top();
        pop();
        u=a.v;
        if(vis[u]==1)continue;//已经访问过
        vis[u]=1;
        for(b=head[u];b;b=e[b].next){
            v=e[b].to;
            if(vis[v]==0&&d[v]>d[u]+e[b].c){
                d[v]=d[u]+e[b].c;
                a.v=v,a.c=d[v];
                push(a);
            }
        }
    }
    for(i=0;i<n;i++)
        printf("%d %d\n",i,d[i]);
}
int main(){
    int i,j,u,k,v,c;
    memset(head,0,sizeof(head));
    scanf("%d",&n);
    for(i=1;i<=n;i++){
        scanf("%d%d",&u,&k);
        for(j=1;j<=k;j++){
            scanf("%d%d",&v,&c);
            addedge(u,v,c);
        }
    }
    dijkstra();
    return 0;
}

2017-10-4 17:06 AC该章节内容


mrcrack
关注
专栏目录
【软件测试】面试题之数据结构与算法篇
weixin_46453070的博客
01-08 1176
数组更适合于索引访问密集型的场景，其中插入和删除操作相对较少。链表则适用于元素经常变化的场景，尤其是在列表的头部或中间插入和删除操作频繁发生的情况。在选择使用数组还是链表时，需要根据应用的需求和上述特点来决定。栈提供了快速的插入和删除操作，适合需要后进先出顺序的场景。队列提供了有序的插入和删除操作，适合需要先进先出顺序的场景。在选择栈还是队列时，关键是考虑数据的访问顺序和处理方式。哈希表通过将键映射到数组的索引上，提供了快速的数据访问速度。
数据结构：加权图的API
earayu的博客
10-22 878
加权图是一种为每条边关联一个权值或者成本的图模型 在之前的例子中，邻接表取得了很好的效果。要表示加权图，我们只需要扩展一下之前的代码即可。之前我们直接在邻接表中存放顶点信息，现在我们改为存放Edge对象。package MST;public class Edge implements Comparable<Edge>{ private final int v;//己方顶点 privat
数据结构 笔记
hfjakl的博客
10-19 1302
剑指 Offer 刷题集剑指 Offer 05. 替换空格剑指 Offer 07. 重建二叉树剑指 Offer 12 单词搜索（DFS+剪枝）剑指 Offer 13. 机器人的运动范围剑指 Offer 15.Pow(x, n)（快速幂）剑指 Offer 49. 丑数（多路归并）剑指 Offer 50. 第一个只出现一次的字符（哈希表） 剑指 Offer 05. 替换空格 请实现一个函数，把字符串 s 中的每个空格替换成"%20"。 示例 1： 输入：s = “We are happy.” 输出：“We%20
数据结构(9)之带权图
star时光的博客
05-14 6676
1.        带权图中，边带有一个数字，叫做权，它可能代表距离、耗费、时间或其他意义。 2.        带权图用来最常解决的问题是最短路径问题（pps）。 3.        带权图的最小生成树中有所有的顶点和连接它们的必要的边，且这些边的权值最小。 4.        优先级队列的算法可用于寻找带权图的最小生成树。 5.        解决无向带权图的最小生成树的方法 1) 
算法——图之加权图
a60782885的博客
05-25 1万+
加权图这里指无向加权图。 加权图是一种为每条边关联一个权值或成本的图模型。也就是在无向图的基础上，每条边加上权值。 加权图有很多应用，例如航空图中，边表示航线，权值表示距离或是费用。还能表示电路图，边表示导线，权值表示导线长度或是成本等等。 在这些情形下，我们最感兴趣的当然是成本最小化，也就是最小生成树问题。 最小生成树 一副加权无向图的最小生成树(MST)是一棵权值之和最小的生
加权无向图
luoxn28的专栏
11-16 6342
用数学语言讲，设G为图，对图的每一条边e来说，都对应于一个实数W(e)（可以通俗的理解为边的“长度”，只是在数学定义中图的权可以为负数），我们把W（e）称为e的“权”。把这样的图G称为“加权图”。 加权无向图数据结构使用邻接表来存储 源代码示例： #include #include #include #include #include using namespac
挑战程序设计竞赛2 算法和数据结构 读后感
小酷Miki的专栏
12-21 5069
介绍 本篇主要是讲《挑战程序设计竞赛2 算法和数据结构》书的读后感和部分题目的再次解读、编程。包括书中的部分代码和一些个人的见解。如果想深入了解，建议去网上买一本回来看，比较适合学习算法的初学者。 章节 第一章 第一章主要让你在AOJ处注册登录，然后开始做题 第二章 2.5 入门问题 ALDS1_1_D:Maximum Profit 第三章 初等排序 ...
ACM_算法模板程序设计协会ACM算法模板集.docxACM_算法模板程序设计协会ACM算法模板集ACM训练ACM集训算法入门参
最新发布
05-02
根据给定文件的信息，本文将围绕“ACM算法模板程序设计协会ACM算法模板集”进行深入探讨。主要内容包括：重要公式与定理、大数模板、数论算法、图论算法、几何算法以及专题讨论等多个方面。 ### 重要公式与定理 ##...
数据结构、算法与应用：C++语言描述（原书第2版）第二部分
12-06
第13章 竞赛树 13.1 赢者树和应用 13.2 抽象数据类型WinnerTree 13.3 赢者树的实现 13.3.1 表示 13.3.2 赢者树的初始化 13.3.3 重新组织比赛 13.3.4 类completeWinnerTree 13.4 输者树 13.5 应用 13.5.1 用最先适配...
【算法与数据结构全面攻略】：掌握这些秘诀，成为编程高手
![【算法与数据结构全面攻略】：掌握这些秘诀，...无论是在学术研究还是实际应用中，算法和数据结构都是构建软件系统的基础。 ## 算法与数据结构的重要性 数据结构和算法是IT专业人士技术栈的关键组成部分。良好的数
数据结构有向加权图（采用邻接矩阵存储结构）
Lin_junhan的博客
01-15 3589
1题目： 元素类型：字符 存储结构：邻接矩阵 抽象数据类型：有向加权图    ADT List{            数据对象：D＝{ ai | ai∈ElemSet, i=1,2,...,n,  n≥0 }            数据关系：R1＝{ &lt;ai-1, ai&gt;|ai-1, ai∈D, i=2,...,n }            基本操作： Status...
ALDS1_12_A:Minimun Spanning Tree
qq_41998938的博客
11-08 155
ALDS1_12_A:Minimun Spanning Tree 题目： https://cn.vjudge.net/problem/Aizu-ALDS1_12_A 代码如下： #include &lt;bits/stdc++.h&gt; using namespace std; #define MAX 105 #define NIL (1 &lt;&lt; 21) #define WHITE 0...
数据结构：图结构的实现
热门推荐
小谷王左的随笔空间
02-07 4万+
图是一种很重要的数据结构，不解释。
图论算法——加权无向图的数据结构
日积月累，天道酬勤
05-24 5629
引言 我们要在一幅加权连通无向图中找到它的最小生成树。首先要考虑的是如何表示这个无向图。 加权边的表示 package com.algorithms.graph; /** * 带权重的无向边的数据结构(不可变类) * * @author yjw * @date 2019/5/23/023 */ public final class Edge implements Comparable&...
程序设计基础26 弗洛伊德算法
qq2285580599的博客
09-27 242
题目描述 在带权有向图G中，求G中的任意一对顶点间的最短路径问题，也是十分常见的一种问题。 解决这个问题的一个方法是执行n次迪杰斯特拉算法，这样就可以求出每一对顶点间的最短路径，执行的时间复杂度为O(n3)。 而另一种算法是由弗洛伊德提出的，时间复杂度同样是O(n3)，但算法的形式简单很多。 可以将弗洛伊德算法描述如下： 在本题中，读入一个有向图的带权邻接矩阵（即数组表示），建立有向...
第十三章 ALDS1_12_C:Single Source Shortest Path II 单源最短路径
小酷Miki的专栏
12-31 879
问题链接ALDS1_12_C:Single Source Shortest Path II问题内容 求出顶点0到各边的最短路径 思路 由于n比较大，所以需要用vector来处理数组，同时每条边都有权值，所以用vector代码#include <iostream> #include <cstdio> #include <cstring> #include <queue> #include <v
数据结构 -- 加权有向图
m0_46218511的博客
07-20 1181
一、概述 二、实现 2.1 加权有向图的边 2.1.1 API设计 类名 DirectedEdge 构造方法 DirectedEdge(int v,int w,double weight)：通过顶点v和w，以及权重weight值构造一个边对象 成员方法 1.public double weight():获取边的权重值2.public int from():获取有向边的起点3.public int to():获取有向边的终点 成员变量 1.private final int v：起点2
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值