精华内容
下载资源
问答
  • 算法设计与分析实验报告,附已通过源码,供学习参考,共勉♪ 目录摘要如下: 1.问题描述 2.实验目的 3.实验原理 4.实验设计 (包括输入格式、算法、输出格式) 5.实验结果与分析 (除了截图外,实验结果还用...
  • 单源最短路径 贪心算法》由会员分享,可在线阅读,更多相关《单源最短路径 贪心算法(3页珍藏版)》请在人人文库网上搜索。1、实验三 单源最短路径一、实验目的及要求掌握贪心算法的基本思想用c程序实现单源最短路径...

    《单源最短路径 贪心算法》由会员分享,可在线阅读,更多相关《单源最短路径 贪心算法(3页珍藏版)》请在人人文库网上搜索。

    1、实验三 单源最短路径一、实验目的及要求掌握贪心算法的基本思想用c程序实现单源最短路径的算法二、实验环境Window下的vc2010三、实验内容1、有向图与单源点最短路径2、按路径长度非降的次序依次求各节点到源点的最短路径3、Dijkstra算法四、算法描述及实验步骤设给定源点为Vs,S为已求得最短路径的终点集,开始时令S=Vs。当求得第一条最短路径(Vs,Vi)后,S为Vs,Vi。根据以下结论可求下一条最短路径。设下一条最短路径终点为Vj,则Vj只有:源点到终点有直接的弧;从Vs出发到Vj的这条最短路径所经过的所有中间顶点必定在S中。即只有这条最短路径的最后一条弧才是从S内某个顶点连接到S外的。

    2、顶点Vj。若定义一个数组distn,其每个disti分量保存从Vs出发中间只经过集合S中的顶点而到达Vi的所有路径中长度最小的路径长度值,则下一条最短路径的终点Vj必定是不在S中且值最小的顶点,即:disti=Mindistk|VkV-S利用公式就可以依次找出下一条最短路径。在程序中c表示带权邻接矩阵,dist表示顶点到源点的最短路径,p记录顶点到源点最短路径的前驱节点,u源点,函数Way是递归的构造出最短路径的次序。五、实验结果程序执行的结果:六、源代码#include #includeusing namespace std;#define MAX 999void getdata(int *。

    3、c,int n)int i,j;int begin,end,weight;for (i=1;ibegin;if(begin=-1) break;cinendweight;cbeginend=weight; while(begin!=-1);void Dijkstra(int n,int v ,int *dist,int *prev,int *c)bool sMAX;int i,j;for (i=1;i1;i-)pathi=prevpathi+1;/构造路径m-;for (i=m;i;/输出路径coutn;int *dist=new int n+1;int *prev=new int n+1;int *c;c=new int *n+1;for (i=0;ibeginend;v=begin;Dijkstra(n,v,dist,prev,c);/计算路径PrintPath(prev,n,begin,end);/输出路径system(pause。

    展开全文
  • 单源最短路径算法贪心思想: 单源最短路径即是寻找一个点到各各点的距离,首先需要去用一个数组dis去保持起始点到最近点的路劲(即权),由出发点去找最近点的最短路径,再由这个找到的最近点去找和他连的路径,如果...

    单源最短路径算法贪心思想:

    单源最短路径即是寻找一个点到各各点的距离,首先需要去用一个数组dis去保持起始点到最近点的路劲(即权),由出发点去找最近点的最短路径,再由这个找到的最近点去找和他连的路径,如果这个点的到最近点的距离小于已经在dis数组中保持的,就去更改dis数组,下面是图演示:
    在这里插入图片描述
    这是保存在e[][]这个二维数组里的值:
    在这里插入图片描述
    在这里插入图片描述

    #include"stdafx.h"
    #include <stdio.h>
    #include<iostream>
    using namespace std;
    int main()
    {
    	int e[10][10], dis[10], book[10], i, j, n, m, t1, t2, t3, u, v, min;
    	int inf = 99999999; //用inf(infinity的缩写)存储一个我们认为的正无穷值
    	//读入n和m,n表示顶点个数,m表示边的条数
    	scanf("%d %d", &n, &m);
    
    	//初始化
    	for (i = 1; i <= n; i++)
    	for (j = 1; j <= n; j++)
    	if (i == j) e[i][j] = 0;
    	else e[i][j] = inf;
    
    	//读入边
    	for (i = 1; i <= m; i++)
    	{
    		scanf("%d %d %d", &t1, &t2, &t3);
    		e[t1][t2] = t3;
    	}
    	//初始化dis数组,这里是1号顶点到其余各个顶点的初始路程
    	for (i = 1; i <= n; i++)
    		dis[i] = e[1][i];
    	//book数组初始化
    	for (i = 1; i <= n; i++)
    		book[i] = 0;
    	book[1] = 1;
    
    	//Dijkstra算法核心语句
    	for (i = 1; i <= n - 1; i++)
    	{
    		//找到离1号顶点最近的顶点
    		min = inf;
    		for (j = 1; j <= n; j++)
    		{
    			if (book[j] == 0 && dis[j]<min)
    			{
    				min = dis[j];
    				u = j;
    			}
    		}
    		book[u] = 1;
    		for (v = 1; v <= n; v++)
    		{
    			if (e[u][v]<inf)
    			{
    				if (dis[v]>dis[u] + e[u][v])
    					dis[v] = dis[u] + e[u][v];
    			}
    		}
    	}
    
    	//输出最终的结果
    	for (i = 1; i <= n; i++)
    		printf("%d ", dis[i]);
    
    	system("pause");
    	return 0;
    }
    
    展开全文
  • java单源最短路径贪心算法) public class TheShortestWay { static int MAX_SIZE = 6; public static void dijkstra(int v, float[][] a, float[] dist, int[] prev) { int n = dist.length - 1; if (v ||...
  • - -可编辑修改 - 单源最短路径 计科 1 班 朱润华 2012040732 方法 1 贪心算法贪心算法解决单源最短路径问题描述 单源最短路径描述 给定带权有向图 G=(V,E, 其中每条边的权是非负实数 另外还给 定 V 中的一个顶点...
  • 用C++实现的贪心算法 Dijkstra 单源最短路径,并包含大量的注释,对理解程序很有帮助
  • NULL 博文链接:https://128kj.iteye.com/blog/1678532
  • 关于单源最短路径的问题非常典型,这里没有给出分析与证明,仅仅给出了实现。 需要指出的是,许多实现仅给出了最短路径的长度,而没有给出“最短路径”,这里用给出了实现。 如程序中那样,定义一个数组p[N],其中...
  • public class TheShortestWay { static int MAX_SIZE=6; public static void dijkstra(int v,float... } } 运行结果: 从1出发到2、3、4、5的最短路径依次是: 10.0 50.0 30.0 60.0 从1到5最短路径经过的点为: 1 4 3 5

    public class TheShortestWay

    {

    static int MAX_SIZE=6;

    public static void dijkstra(int v,float[][]a,float[]dist,int[]prev)

    {

    int n=dist.length-1;

    if(v<1||v>n)return;

    boolean []s=new boolean[n+1];

    for(int i=1;i<=n;i++)

    {

    dist[i]=a[v][i];

    s[i]=false;

    if(dist[i]==Float.MAX_VALUE)

    prev[i]=0;

    else

    prev[i]=v;

    }

    dist[v]=0;s[v]=true;

    for(int i=1;i

    {

    float temp=Float.MAX_VALUE;

    int u=v;

    for(int j=1;j<=n;j++)

    if((!s[j])&&(dist[j]

    {

    u=j;

    temp=dist[j];

    }

    s[u]=true;

    for(int j=1;j<=n;j++)

    if((!s[j])&&(a[u][j]

    {

    float newdist=dist[u]+a[u][j];

    if(newdist

    {

    dist[j]=newdist;

    prev[j]=u;

    }

    }

    }

    }

    public static void main(String args[])

    {

    float a[][]=new float[MAX_SIZE][MAX_SIZE];float[]dist=new float[MAX_SIZE];int []prev=new int[MAX_SIZE];

    for(int i=0;i<6;i++)

    for(int j=0;j<6;j++)

    a[i][j]=Float.MAX_VALUE;

    a[1][2]=10;

    a[1][4]=30;

    a[1][5]=100;

    a[2][3]=50;

    a[3][5]=10;

    a[4][3]=20;

    a[4][5]=60;

    int v=1;//假设从顶点1处出发

    dijkstra(v,a,dist,prev);

    System.out.println("从1出发到2、3、4、5的最短路径依次是:");

    for(int j=2;j<6;j++)

    {

    System.out.println(dist[j]);

    }

    int z=prev[5],y=prev[z],x=prev[y];

    System.out.println("从1到5最短路径经过的点为:");

    System.out.print(x+" "+y+" "+z+" "+"5");

    }

    }

    运行结果:

    从1出发到2、3、4、5的最短路径依次是:

    10.0

    50.0

    30.0

    60.0

    从1到5最短路径经过的点为:

    1 4 3 5

    展开全文
  • 【问题描述】Dijkstra算法解决的是带权重的有向图上单源最短路径问题。所有边的权重都为非负值。设置顶点集合S并不断地作贪心选择来扩充这个集合。使用最小堆数据结构构造优先队列。第1个顶点为源。 【输入形式】在...

    【问题描述】Dijkstra算法解决的是带权重的有向图上单源最短路径问题。所有边的权重都为非负值。设置顶点集合S并不断地作贪心选择来扩充这个集合。使用最小堆数据结构构造优先队列。第1个顶点为源。
    【输入形式】在屏幕上输入顶点个数和连接顶点间的边的权矩阵。
    【输出形式】从源到各个顶点的最短距离及路径。
    【样例输入】
    5
    0 10 0 30 100
    0 0 50 0 0
    0 0 0 0 10
    0 0 20 0 60
    0 0 0 0 0
    【样例输出】
    10: 1->2
    50: 1->4->3
    30: 1->4
    60: 1->4->3->5
    【样例说明】
    输入:顶点个数为5。连接顶点间边的权矩阵大小为5行5列,位置[i,j]上元素值表示第i个顶点到第j个顶点的距离,0表示两个顶点间没有边连接。
    输出:每行表示源1到其余各顶点的最短距离及路径,冒号后有一空格。如果源1到该顶点没有路,则输出:“inf: 1->u”,其中u为该顶点编号。
    【评分标准】根据输入得到准确的输出。

    #include <iostream>
    #include <cstdio>
    #include <queue>
    #include <stack>
    
    using namespace std;
    
    struct Edge{
        int u = 0,v = 0,w = 0;
        friend bool operator < (Edge a, Edge b) {
            return a.w > b.w;
        }
    };
    
    const int maxn = 1005;
    const int INF = 0x3f3f3f3f;
    
    int n = 0, cnt = 0;
    int mp[maxn][maxn] = {0};
    int dis[maxn] = {0};
    int bac[maxn] = {0};
    bool vis[maxn] = {0};
    
    void BackTrace() {
        stack<int> sta;
        for(int i = 2; i <= n; ++i) {
            while(!sta.empty()) sta.pop();
            int t = i;
            while(bac[t] != t) {
                sta.push(t);
                t = bac[t];
            }
            cout << dis[i] << ": 1";
            while(!sta.empty()) {cout << "->" << sta.top(); sta.pop();}
            cout << endl; 
        }
    }
    
    int main() {
        cin >> n;
        for(int i = 1; i <= n; ++i) {
            for(int j = 1; j <= n; ++j) {
                cin >> mp[i][j];
                if(mp[i][j] == 0) mp[i][j] = INF; 
            }
        }
        priority_queue<Edge> q;
        vis[1] = 1; bac[1] = 1;
        for(int i = 2; i <= n; ++i) {
            dis[i] = mp[1][i];
            q.push({1,i,mp[1][i]});
        }
        while(!q.empty()) {
            Edge et = q.top(); q.pop();
            if(vis[et.v]) continue;
            vis[et.v] = 1; cnt++;
            if(cnt == n-1) break;
            int u_ = et.v;
            for(int v_ = 2; v_ <= n; ++v_)
                if(!vis[v_] && mp[u_][v_] + dis[u_] < dis[v_]) {
                    dis[v_] = mp[u_][v_] + dis[u_];
                    bac[v_] = u_;
                    q.push({u_, v_, mp[u_][v_] + dis[u_]});
                }
        }
        BackTrace();
        return 0;
    }
    
    展开全文
  • 单源最短路径 Dijkstra 算法(Java代码实现)
  • 1.问题分析给定有向带权图G = (V, E),其中每条边的权是非负实数。此外,给定V中的一个顶点u,...2.算法设计Dijkstra是解决单源最短路径贪心算法。算法的基本思想首先假定源点为u,顶点集合V被划分为两部分:集合S...
  • Dijsktra: #include using namespace std; const int INF = 0x3f3f3f3f; //表示无穷大 const int N = 5;... i++) { cout 源点1到点" 的最短路径长度为:" [i] ; traceback(i, prev); cout ; } return 0; }
  • 【算法设计与分析】 单源最短路径贪心算法) Dijkstra 【问题描述】 Dijkstra算法解决的是带权重的有向图上单源最短路径问题。所有边的权重都为非负值。设置顶点集合S并不断地作贪心选择来扩充这个集合。使用最小...
  • 问题描述给定一个带权有向图 G=(V,E) ,其中...算法基本思想Dijkstra算法是解单源最短路径问题的一个贪心算法。其基本思想是,设置一个基点集合 S ,并不断地作贪心选择来扩充这个集合。一个项点属于集合 S 当且仅当...
  • 给定一个带权有向图 G=(V,E) ,其中每条边的权是一个整数。另外,还给定 V 中的一个顶点,称为源。现在我们要计算从源到所有其他各顶点的最短路径长度。这里的长度是指路上各边权...这个问题通常称为单源最短路径问题。
  • 贪心思想和案例(活动安排问题,0-1背包问题,最优装载,哈夫曼编码,单源最短路径,最小生成树(Prim,Kruskal),汽车加油问题)。算法课使用的ppt,可结合我的博客算法专栏一起看。有详细代码。
  • Dijkstra算法:是解单源最短路径问题的贪心算法。 基本思想: 一个顶点属于集合S,当且仅当从源到该顶点的最短路径长度已知。 设置顶点集合S,并不断地作贪心选择来扩充这个集合。 贪心策略:每次都从V-S中找...
  • 单源最短路径

    2012-11-02 17:47:43
    单源最短路径C语言实现,简单易懂,适合算法学习
  • 贪心算法 贪心算法是指,在对问题求解时,总是做出在当前看来是最好的选择。也就 是说,不从整体最优上加以考虑,他所做出的是在某种意义上的局部最优解。 贪心算法思路: 建立数学模型来描述问题; 把求解的问题...
  • 输入 用邻接矩阵存储,并以文件的形式读入。 代码 #include <iostream> #include <fstream> #include <sstream>... // 某节点是否已被选择加入最短路径 std::vector<bool&
  • 算法思想:贪心算法实际问题:单源最短路径编程语言:Java问题描述单源最短路径算法,又称迪杰斯特拉算法。其目的是寻找从一个顶点到其余各顶点的最短路径算法,解决的是有权图中最短路径问题。算法构造相关解释观测...
  • 贪心算法单源最短路径问题 明确单源最短路径问题的概念;利用贪心算法解决单源最短路径问题;并通过本例熟悉贪心算法在程序设计中的应用方法。
  • Dijkstra算法是最具代表性的解单源最短路径问题的贪心算法
  • 选择算法: 单源最短路径 ???? 算法概述: 贪心算法,又称贪婪算法,是一种在每一步选择中都采取在当前状态下最好或最优的选择,从而希望导致结果是最好或最优的算法。 单源最短路径,迪杰斯特拉(Dijkstra)的算法...
  • 基于贪心法求解单源最短路径问题 完整实验报告,结尾有实验代码
  • 单元最短路径,为广大计算机专业学生算法所需实验报告而准备
  • 单源最短路径算法

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,232
精华内容 1,692
关键字:

单源最短路径贪心算法