精华内容
下载资源
问答
  • AE+C#最短路径程序

    2013-03-10 15:22:24
    AE和C#开发的最短路径程序,解压后可直接运行,自带数据,选择目标点后,在地图上高亮显示最短路径.
  • AE+C# 最短路径程序

    2013-03-10 15:17:40
    AE和C#开发的最短路径程序,解压后可直接运行,自带数据,选择目标点后,在地图上高亮显示最短路径
  • 数据结构的树和图章节的最短路径源代码 可以运行
  • 用栈求解迷宫问题的所有路径及最短路径程序

    千次阅读 多人点赞 2018-11-03 18:40:21
    内容:编写一个程序,输出迷宫的所有路径,并求第一条最短路径长度及最短路径。 代码如下: #include <iostream> #include <cstdio> #include <stack> #include &...

    目的:掌握栈在求解迷宫问题中的应用。

    内容:编写一个程序,输出迷宫的所有路径,并求第一条最短路径长度及最短路径。

    代码如下:

    #include <iostream>
    #include <cstdio>
    #include <stack>
    #include <cstdlib>
    using namespace std;
    #define inf 0x3f3f3f
    const int MaxSize=1000;
    int M=4,N=4;
    int mg[6][6]={{1,1,1,1,1,1},{1,0,0,0,1,1},
                      {1,0,1,0,0,1},{1,0,0,0,1,1},
                      {1,1,0,0,0,1},{1,1,1,1,1,1}};
    int vis[6][6];
    typedef struct
    {
        int i;//当前方块的行号
        int j;//当前方的列号
        int di;
    }Box;
    typedef struct
    {
        Box data[MaxSize];
        int top;//栈顶指针
    }SqStack;//顺序栈类型
    void InitStack(SqStack *&s)//初始化栈
    {
        s=(SqStack *)malloc(sizeof(SqStack));
        s->top=-1;
    }
    bool Push(SqStack *&s,Box e)//进栈
    {
        if(s->top==MaxSize-1)
            return false;
        s->top++;
        s->data[s->top]=e;
    }
    bool StackEmpty(SqStack *s)//判断栈是否为空
    {
        return (s->top==-1);
    }
    bool Pop(SqStack *&s,Box &e)//出栈
    {
        if(s->top==-1)
            return false;
        e=s->data[s->top];
        s->top--;
        return true;
    }
    bool GetTop(SqStack *s,Box &e)//取出栈顶元素
    {
        if(s->top==-1)
            return false;
        e=s->data[s->top];
        return true;
    }
    bool mgpath(int xi,int yi,int xe,int ye)
    {
        int minn=inf,minum;
        int cont=1;
        int f=0;
        int i,j,di,i1,j1,k;
        bool _find=false;
        SqStack *st;//定义栈st
        InitStack(st);//初始化栈st
        Box e1,e;
        e1.i=xi;
        e1.j=yi;
        e1.di=-1;
        Push(st,e1);//方块e进栈
        vis[xi][yi]=-1;//将入口的迷宫值置为-1,避免重复走到该方块
        while(!StackEmpty(st))//栈不为空时循环
        {
            GetTop(st,e);
            //cout<<e.i<<" "<<e.j<<" "<<e.di<<endl;
            i=e.i;
            j=e.j;
            di=e.di;
            if(i==xe&&j==ye)//找到了出口,输出该路径
            {
                f=1;
                if(st->top<minn)
                {
                    minn=st->top;
                    minum=cont;
                }
                printf("迷宫路径%d为:\n",cont++);
                for(k=0;k<=st->top;k++)
                    printf("(%d,%d)\t",st->data[k].i,st->data[k].j);
                printf("\n");
            }
            _find=false;
            while(di<4&&!_find)
            {
                di++;
                switch(di)
                {
                    case 0:i1=i-1;j1=j;break;
                    case 1:i1=i;j1=j+1;break;
                    case 2:i1=i+1;j1=j;break;
                    case 3:i1=i;j1=j-1;break;
                }
                if(vis[i1][j1]==0&&mg[i1][j1]==0) _find=true;
            }
            if(_find)
            {
                st->data[st->top].di=di;
                e.i=i1;
                e.j=j1;
                e.di=-1;
                Push(st,e);
                vis[i1][j1]=-1;
            }
            else
            {
                Pop(st,e);
                vis[e.i][e.j]=0;
            }
        }
        if(f==1)
        {
            printf("最短路径为路径%d\n",minum);
            printf("最短路径长度为%d\n",minn);
            return true;
        }
        return false;
    }
    int main()
    {
        if(!mgpath(1,1,4,4))
            printf("该迷宫问题没有解!\n");
        return 0;
    }

    运行结果:

    展开全文
  • 通过使用python实现图的可视化,以及广度优先的最短距离,深度优先的最短路径,dijkstra的最短路径 dijkstra最短路径 深度优先最短路径 深度优先忘记标路径的边及方向 广度优先最短路径 这个广度优先可能有点BUG...

    简要说明

    通过使用python实现图的可视化,以及广度优先的最短距离,深度优先的最短路径,dijkstra的最短路径

    dijkstra最短路径

    在这里插入图片描述

    深度优先最短路径

    在这里插入图片描述
    深度优先忘记标路径的边及方向

    广度优先最短路径

    在这里插入图片描述
    这个广度优先可能有点BUG,有时候是对的有时候有错,因为刚检查完,忙着复习期末考试,没时间调了

    操作说明

    1.需要安装graphviz,这是可视化的库

    2.需要安装opencv,因为要读写图片

    3.当开始运行程序时,首先要点击“初始化画图”然后再点击“画图”才显示出图片

    这是初始化图后的显示
    在这里插入图片描述

    4.当你每次要操作其他功能的时候,都要先“清空”然后“初始化画图”,及画图,这样一轮循环。比如你先填如初始节点“a”,目的节点“v”,点击“dijkstra最短路径”(dijkstra是我最后加的文本)

    在这里插入图片描述

    然后当你要再要选择广度优先或者深度优先填入节点时,首先要点击“清空”,然后再“初始化画图”,再“画图”,就是重新初始化,然后就可以进行其他的操作,每次都要循环这个操作

    点击“清空”

    跟原来一样,没变化

    在这里插入图片描述

    然后“初始化画图”,以及画图

    在这里插入图片描述

    这样就重新初始化成功了。可以进行别的操作

    可以进行节点的添加,和边的添加,但没有删除功能

    5.添加节点“yyy”,然后点击“添加节点”,然后“画图”

    在这里插入图片描述

    图中出现“yyy”的节点,这是可视化graphviz自动分配的位置,下一步添加边和权值,输入要连接的节点名称和权值,然后点击“添加边”,以及“画图”

    在这里插入图片描述

    如果想删除或恢复原来的状态就进行重新初始化操作,跟上面提到的一样

    代码

    #好像没什么注释,有时间再补吧

    import cv2
    import copy
    import time
    import graphviz as gv
    import tkinter
    from tkinter import *
    tk=tkinter.Tk()
    
    g = gv.Graph('1',format='png',edge_attr ={},node_attr={"fixedsize":"shape"},engine='neato')
    
    g1=gv.Graph("2",format='pdf',engine='neato')
    tk.geometry("1500x800")
    
    e=tkinter.Entry(tk)
    e.place(x=0,y=0)
    edge=tkinter.Entry(tk)
    edge1=tkinter.Entry(tk)
    edge2=tkinter.Entry(tk)
    breath=tkinter.Entry(tk,width=10)
    breath1=tkinter.Entry(tk,width=10)
    breath2=tkinter.Entry(tk,width=10)
    depth=tkinter.Entry(tk,width=10)
    depth1=tkinter.Entry(tk,width=10)
    depth2=tkinter.Entry(tk,width=10)
    djstla=tkinter.Entry(tk,width=10)
    djstla1=tkinter.Entry(tk,width=10)
    edge.place(x=0,y=60)
    edge1.place(x=150,y=60)
    edge2.place(x=300,y=60)
    breath2.place(x=100,y=290)
    breath.place(x=0,y=190)
    breath1.place(x=100,y=190)
    
    depth.place(x=0,y=340)
    depth1.place(x=100,y=340)
    depth2.place(x=100,y=240)
    djstla.place(x=200,y=90)
    djstla1.place(x=300,y=90)
    menu0=Menu(tk)#参数是父级控件
    list1=['a','b','c','d','e','f','g','h','l','m','n','o','p','q','r','s','t','u','v','w','x','a1','b1','c1','d1','e1','f1','g1','a2','b2']
    length=30
    adrect=[[0,25,-1,60,-1,-1,-1,20,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [25,0,50,30,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,50,0,-1,12,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [60,30,-1,0,30,10,50,-1,-1,-1,-1,-1,-1,-1,45,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,12,30,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,10,-1,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,50,-1,-1,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [20,25,-1,60,-1,-1,-1,0,25,-1,60,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,25,0,50,30,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,50,0,-1,12,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,60,30,-1,0,12,10,50,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,12,12,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,20,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,10,-1,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,50,-1,-1,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,45,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,25,-1,60,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,25,0,50,30,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,50,0,-1,12,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,60,30,-1,0,12,10,50,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,12,12,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,5,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,10,-1,0,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,50,-1,-1,0,-1,-1,-1,-1,-1,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,20,-1,-1,-1,-1,-1,-1,-1,-1,-1,0,25,-1,60,-1,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,25,0,50,30,-1,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,50,0,-1,12,-1,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,60,30,-1,0,12,10,50,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,12,12,0,-1,-1,-1,10],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,10,-1,0,-1,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,50,-1,-1,0,-1,-1],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,5,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,2],
            [-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,10,-1,-1,2,-1],
            ]#初始化邻近矩阵
    list2={}
    
    j=0
    for i in list1:
        list2[i]=j
        j=j+1
    print(list2)
    
    global minshu
    minshu=9999999
    def lab():
        print("1")
    for x in ['文件','编辑','视图']:
        menu0.add_command(label=x,command=lab)#添加3个一级菜单
    tk['menu'] = menu0
    def addpoint():
         a=e.get()
         if(a not in list1):
            g.node(name=a)
    
            list1.append(a)
            list3 = []
            for i in range(len(list1)-1):
                adrect[i].append(-1)
            for j in range(len(list1)-1):
                list3.append(-1)
            list3.append(0)
            adrect.append(list3)
            list2.update({a:len(list1)-1})
         print(list1)
         print(adrect)
         print(list2)
    
    button=tkinter.Button(tk,text="添加节点",command=addpoint)
    button.place(x=200,y=0)
    def addedge():
        a=edge.get()
        b=edge1.get()
        c=edge2.get()
        if( adrect[list2[a]][list2[b]]==-1):
            adrect[list2[a]][list2[b]]=int(c)
            adrect[list2[b]][list2[a]]=int(c)
        g.edge(a,b,c)
    
        print(adrect)
    lab1=tkinter.Label(tk,text="边的权值")
    lab1.place(x=350,y=30)
    lab2=tkinter.Label(tk,text="第一个点")
    lab2.place(x=200,y=30)
    lab3=tkinter.Label(tk,text="第二个点")
    lab3.place(x=50,y=30)
    button2=tkinter.Button(tk,text="  添加边  ",command=addedge)
    button2.place(x=500,y=50)
    
    def drawpicture():
        # g.view()
        g.render("1.gv",view=False)
        img = cv2.imread("1.gv.png")
        #h = cv2.resize(img, (600, 750))
        cv2.imwrite("img1.png", img)
        render=tkinter.PhotoImage(file="./img1.png")
        la=tkinter.Label(tk,image=render,width=800,height=800)
        la.place(x=700,y=0)
        tk.mainloop()
    button1=tkinter.Button(tk,text="  画图  ",command=drawpicture)
    button1.place(x=620,y=50)
    def firstdrawpicture():
        #g.attr('graph',{"size": "7,7", "ratio ": "expand"})
        g.attr(size='7,7')
        #g.attr('graph',mindist="0.2")
        g.attr('node', fontsize='10',style='filled')
        g.attr('node',width='0.4',height='0.4')
    
        g.attr('node',fixedsize='shape', fontsize = '16')
        #g.attr('edge',len="5", fontsize = '10')
        g.node(name='a')
        g.node(name='b')
        g.node(name='a2')
        g.node(name='b2')
        g.node(name='c')
        g.node(name='d')
        g.node(name='e')
        g.node(name='f')
        g.node(name='g')
        g.node(name='a1')
        g.node(name='b1')
        g.node(name='c1')
        g.node(name='d1')
        g.node(name='e1')
        g.node(name='f1')
        g.node(name='g1')
        g.node(name='h')
        g.node(name='l')
        g.node(name='m')
        g.node(name='n')
        g.node(name='o')
        g.node(name='p')
        g.node(name='q')
        g.node(name='r')
        g.node(name='s')
        g.node(name='t')
        g.node(name='u')
        g.node(name='v')
        g.node(name='w')
        g.node(name='x')
        g.edge('a','b',label='25')
        g.edge('b','c',label='50')
        g.edge('b', 'd',label='30')
        g.edge('a', 'd',label='60')
        g.edge('d', 'g',label='50')
        g.edge('d', 'e',label='30')
        g.edge('d', 'f',label='10')
        g.edge('c', 'e', label='12')
        g.edge('a1', 'b1', label='25')
        g.edge('b1', 'c1', label='50')
        g.edge('b1', 'd1', label='30')
        g.edge('a1', 'd1', label='60')
        g.edge('d1', 'g1', label='50')
        g.edge('d1', 'e1', label='12')
        g.edge('d1', 'f1', label='10')
        g.edge('c1', 'e1', label='12')
        g.edge('h', 'l', label='25')
        g.edge('l', 'm', label='50')
        g.edge('l', 'n', label='30')
        g.edge('h', 'n', label='60')
        g.edge('n', 'q', label='50')
        g.edge('n', 'o', label='12')
        g.edge('n', 'p', label='10')
        g.edge('m', 'o', label='12')
        g.edge('a', 'h', label='20')
    
        g.edge('r', 's', label='25')
        g.edge('s', 't', label='50')
        g.edge('s', 'u', label='30')
        g.edge('r', 'u', label='60')
        g.edge('u', 'x', label='50')
        g.edge('u', 'v', label='12')
        g.edge('u', 'w', label='10')
        g.edge('t', 'v', label='12')
        g.edge('d','r',label='45')
        g.edge('a2', 'b2', label='2')
        g.edge('o', 'a1', label='20')
        g.edge('b2', 'e1', label='10')
        g.edge('a2', 'v', label='5')
    
        g.render("1.gv", view=False)
    
    button3=tkinter.Button(tk,text="初始化画图",command=firstdrawpicture)
    button3.place(x=620,y=0)
    #queue=[]
    #res=[]
    #visited=[False]*(len(list1))
    def bfs(queue,res,visited,dis,b,res1):
        global  minp
        global ggh,path11
        ggh={}
        ggh[queue[0]]=0
        minp=9999999
        path11={}
        #gr=queue
        while len(queue) > 0:
            key= queue.pop(0)
            res1.append(key)
            #print("ffff",queue)
            #gr.append(key)
            if(key==b):
                print(dis)
                break
            print(key)
            i=list2[key]
            for j in range(len(list1)):
                if adrect[i][j]> 0 and visited[j] == False:
                    res.append(list1[j])
                    ggh[list1[j]]=adrect[i][j]
                    visited[j] = True
                    for jj in range(len(list1)):
                        if (adrect[list2[list1[j]]][jj] > 0 and visited[jj] == True):
                            ggh[list1[j]] = adrect[list2[list1[j]]][jj] + ggh[list1[jj]]
                            path11[list1[j]]=list1[jj]
                    for ii in range(len(list1)):
                        if(adrect[list2[list1[j]]][ii]>0 and visited[ii]==True):
                            if(adrect[list2[list1[j]]][ii]+ggh[list1[ii]]<ggh[list1[j]]):
                                ggh[list1[j]]=adrect[list2[list1[j]]][ii]+ggh[list1[ii]]
                                path11[list1[j]] = list1[ii]
                    dis=dis+adrect[i][j]
                    queue.append(list1[j])
                    print(queue)
    
    
    def breath_serach():
        queue = []
        res = []
        res1=[]
        visited = [False] * (len(list1))
        start = time.time()
        a=breath.get()
        b=breath1.get()
        if len(list1) <= 0:
            return res
        else:
            queue.append(a)  # 节点名称
            visited[list2[a]] = True#节点所在的位置号
            res.append(a)
            bfs(queue,res,visited,0,b,res1)
        print(res)
        print(res1)
        print(ggh)
        print(path11)
        rr=[]
        def router(b):
            if(b!=a):
                for ji in path11:
                    if(b==ji):
                        rr.append(b)
                        router(path11[b])
        router(b)
        rr.append(a)
        rr.reverse()
        print(rr)
        end=time.time()
        zuiduanluji=ggh[b]
        print(zuiduanluji)
        label10 = tkinter.Label(tk, text="最短路径:"+str(zuiduanluji))
        label10.place(x=0, y=220)
        label11 = tkinter.Label(tk, text="运行时间" + str(end-start))
        label11.place(x=100, y=220)
        '''
        str1=''
        for jk in res:
            j=0
            str1=str(str1)+jk
            j=j+1
        #   if(j>=len(res)-2):
                break
            else:
                str1 = str1 + '->'
            print(str1)
        label1=tkinter.Label(tk, text=str1)
        label1.place(x=0,y=270)'''
        '''list4 = {}
        j = 0
        for ii in res:
            list4[j] = ii
            j = j + 1'''
    
        for i in range(len(rr) - 1):
            g.attr('edge', dir='forward')
            g.edge(rr[i], rr[i + 1], color='red')
            g.attr('edge', dir='forward')
            g.node(rr[i], shape='doublecircle', style='filled', color='red')
        g.node(rr[len(rr) - 1], shape='doublecircle', style='filled', color='red')
        g.render("2.gv", view=False)
        #img = cv2.imread("2.gv.png")
        #h = cv2.resize(img, (300, 565))
        # cv2.imwrite("img.png", h)
        #render = tkinter.PhotoImage(file="./img.png")
        render = tkinter.PhotoImage(file="./2.gv.png")
        la = tkinter.Label(tk, image=render, width=800, height=800)
        la.place(x=700, y=0)
        tk.mainloop()
    
    button4=tkinter.Button(tk,text="广度优先搜素最短路径",command=breath_serach)
    button4.place(x=200,y=190)
    def bfs2(queue,res,visited):
        while len(queue) > 0:
            key= queue.pop(0)
            i=list2[key]
            for j in range(len(list1)):
                if adrect[i][j]> 0 and visited[j] == False:
                    res.append(list1[j])
                    visited[j] = True
                    queue.append(list1[j])
    def breath_serach1():
        queue = []
        res = []
        visited = [False] * (len(list1))
        a=breath2.get()
        if len(list1) <= 0:
            return res
        else:
            queue.append(a)  # 节点名称
            visited[list2[a]] = True#节点所在的位置号
            res.append(a)
            bfs2(queue,res,visited)
        print(res)
        str1=''
        for jk in res:
            j=0
            str1=str(str1)+jk
            j=j+1
            if(j>=len(res)-2):
                break
            else:
                str1 = str1 + '->'
            print(str1)
        label1=tkinter.Label(tk, text=str1)
        label1.place(x=0,y=320)
        list4 = {}
        j = 0
        for ii in res:
            list4[j] = ii
            j = j + 1
    
        for i in range(len(res) - 1):
            g.attr('edge', dir='forward')
            g.edge(list4[i], list4[i + 1], color='red')
    
            g.attr('edge', dir='forward')
        g.node(list4[0], shape='doublecircle', style='filled', color='red')
        g.render("2.gv", view=False)
        # img = cv2.imread("2.gv.png")
        # h = cv2.resize(img, (300, 565))
        # cv2.imwrite("img.png", h)
        # render = tkinter.PhotoImage(file="./img.png")
        render = tkinter.PhotoImage(file="./2.gv.png")
        la = tkinter.Label(tk, image=render, width=800, height=800)
        la.place(x=700, y=0)
        tk.mainloop()
    
    button41=tkinter.Button(tk,text="广度优先搜索",command=breath_serach1)
    button41.place(x=200,y=290)
    global book,path,min,minn,hhh,pp,dis,aaa,yyy,pk
    minn=[]
    hhh=[]
    aaa=[]
    min1 = 9999999
    def dfss(cur,dis,aim,book,path,pk):
        global min1,pp,yyy
    
        if(aim==cur):
            #for i in range(list2['a'],len(list1)):
                #if( path[i]):
            #print(path)
            #print(dis)
            if min1>dis:
                min1=dis
                print(path)
                print(pk)
                pp=copy.copy(path)
    
                #print(pp)
                #print(path)
    
                minn.append(min1)
                jp=sorted(minn)
                yyy=jp[0]
                while len(minn)>0:
                    minn.pop()
                #print(minn)
    
        global flag
        tt = 0
        for h  in range(list2['a'],len(list1)):
    
            if(adrect[list2[cur]][h]>0  and book[h]==0):
                book[h]=1
                path[h]=list1[h]
                #print(tt)
                pk[tt]=list1[h]
                '''for hk in range(len(pk)):
                    if(pk[hk]==list1[h]):
                        flag=hk
                        print(flag)'''
                #print(pk)
                #print(book)
                #print(path)
                dfss(list1[h],dis+adrect[list2[cur]][h],aim,book,path,pk)
                book[h]=0
                path[h]=0
                pk[tt]=0
            tt=tt+1
    
        #print(book)
        #print(path)
    
    def dfs1():
        global book,path,pp,pk
    
        pk= [0] * len(list1)
        book = [0] * len(list1)
        path = [0] * len(list1)
        a=depth.get()
        book[list2[a]]=1
        pk[list2[a]]=1
        b=depth1.get()
        path[list2[a]]=a
        start=time.time()
    
        dfss(a,0,b,book,path,pk)
        #aaa=sorted(minn)
        #print(minn)
        print(yyy)
        hp=yyy
        end=time.time()
        #while len(aaa)>0:
         #   aaa.pop()
        #for ii in minn:
        #    aaa.append(ii)
        #print(sorted(aaa))
        #hp=aaa[0]
        str1="最短路径"
        #print(minn[aaa[0]])
        label1 = tkinter.Label(tk, text=str1+str(hp)+"  ")
        label1.place(x=0, y=370)
        label12 = tkinter.Label(tk, text="运行时间:" + str(end-start))
        label12.place(x=100, y=370)
        #print(pp)
    
        while len(hhh)>0:
            hhh.pop()
            #print(hhh)
    
        for jj in pp:
            if(jj!=0):
                hhh.append(jj)
        print(hhh)
        ght = {}
        ghtt=[]
        jkp=0
        for ty in hhh:
            ght[ty] = jkp
            ghtt.append(ty)
            jkp = jkp + 1
        print(ght)
        print(ghtt)
        qw={}
        qw1={}
        gr={}
        for ih in hhh:
            qw1[ih]=0
        qw[a]=0
        global ghq
        ghq=copy.deepcopy(hhh)
        def gy(a):
            visted=[False]*len(hhh)
            while(len(ghq)>0):
                key = ghq.pop(0)
                visted[ght[key]]=True
                for ij in range(len(hhh)):
                    if(adrect[list2[key]][list2[hhh[ij]]]>0 and visted[ij]==False):
                        if(qw1[hhh[ij]]>0):
                            qw1[hhh[ij]]=qw1[hhh[ij]]
                        else:
                            qw1[hhh[ij]]=adrect[list2[key]][list2[hhh[ij]]]
                    if(qw1[hhh[ij]]>qw1[key]+adrect[list2[key]][list2[hhh[ij]]] and visted[ij]==False):
                        qw1[hhh[ij]]=qw1[key]+adrect[list2[key]][list2[hhh[ij]]]
                        gr[hhh[ij]]=key
                    if(adrect[list2[key]][list2[hhh[ij]]]>0 and visted[ij]==False):
                        qw1[hhh[ij]]=qw1[key]+adrect[list2[key]][list2[hhh[ij]]]
                        gr[hhh[ij]] = key
    
        gy(a)
        print(qw1)
        print(gr)
        routlist=[]
        if(b in gr.keys()):
            def rout(b):
                if(b!=a):
                    for key in gr:
                        if(b==key):
                            print(gr[key])
                            routlist.append(gr[key])
                    rout(gr[b])
            rout(b)
            routlist.insert(0,b)
            routlist.reverse()
            print(routlist)
        else:
            def rout(a):
                if(b!=a):
                    for key in gr:
                        if(a==key):
                            print(gr[key])
                            routlist.append(gr[key])
                    rout(gr[a])
            rout(a)
            routlist.insert(0,a)
            print(routlist)
    
        # print(pk)
        #for i in hhh:
           # for j in hhh:
              #  if(adrect[list2[i]][list2[j]]>0):
                #    g.edge(list1[list2[i]], list1[list2[j]], color='red')
        for i in range(len(hhh) - 1):
            #g.attr('edge', dir='forward')
           # g.edge(routlist[i], routlist[i + 1], color='red')
            #g.attr('edge', dir='forward')
            g.node(hhh[i], shape='doublecircle',style='filled',color='red')
        g.node(hhh[len(hhh)-1],shape='doublecircle',style='filled',color='red')
        g.render("2.gv", view=False)
        render = tkinter.PhotoImage(file="./2.gv.png")
        la = tkinter.Label(tk, image=render, width=800, height=800)
        la.place(x=700, y=0)
        tk.mainloop()
    
    def dfs(res,visited,a,juli,temp):
    
        res.append(a)
        juli[a]=temp
        visited[list2[a]] = True
        for j in range(len(list1)):
            if adrect[list2[a]][j] > 0 and visited[j] == False:
                temp1=temp+adrect[list2[a]][j]
                dfs(res,visited,list1[j],juli,temp1)
    def depth_serach():
        res=[]
        juli={}
        temp=0
        visited=[False]*len(list1)
        a=depth2.get()
    
        dfs(res,visited,a,juli,temp)
        print(juli)
    
        print(res)
        str1 = ''
        for jk in res:
            j = 0
            str1 = str(str1) + jk
            j = j + 1
            if (j >= len(res) - 2):
                break
            else:
                str1 = str1 + '->'
            print(str1)
        label1 = tkinter.Label(tk, text=str1)
        label1.place(x=0, y=270)
        list4 = {}
        j = 0
        for ii in res:
            list4[j] = ii
            j = j + 1
    
        for i in range(len(res)-1):
            g.attr('edge', dir='forward')
            g.edge(list4[i],list4[i+1],color='red')
    
            g.attr('edge', dir='forward')
        g.node(list4[0],shape='doublecircle',style='filled',color='red')
        g.render("2.gv", view=False)
        #img = cv2.imread("2.gv.png")
        #h = cv2.resize(img, (300, 565))
        #cv2.imwrite("img.png", h)
        #render = tkinter.PhotoImage(file="./img.png")
        render = tkinter.PhotoImage(file="./2.gv.png")
        la = tkinter.Label(tk, image=render, width=800, height=800)
        la.place(x=700, y=0)
        tk.mainloop()
    
    button5=tkinter.Button(tk,text="深度度优先搜索最短路径",command=dfs1)
    button5.place(x=200,y=340)
    
    button7=tkinter.Button(tk,text="深度度优先搜索",command=depth_serach)
    button7.place(x=200,y=240)
    def clear():
        global min1,dis
        min1=9999999
        dis=0
        #book=[0]*len(list1)
        #path=[0]*len(list1)
        g.clear(keep_attrs = False )
    
        del adrect[length:len(list1)]
        for i in range(len(adrect)):
            del adrect[i][length:len(list1)]
        x=len(list1)
        a=[]
        for j in range(length,x):
            a.append(list1[j])
        for i in a:
            list2.pop(i)
        del list1[length:x]
        print(adrect)
        print(list1)
        print(list2)
    
    button6=tkinter.Button(tk,text="清空",command=clear)
    button6.place(x=620,y=100)
    def min_distance():
        start = time.time()
        a=djstla.get()
        b=djstla1.get()
        hh=adrect
        distances={}
        for i in range(len(list1)):
            distances[list1[i]]={}
        print(distances)
        for i in range(len(list1)):
            for j in range(len(list1)):
                if(hh[i][j]>0):
                    distances[list1[i]][list1[j]]=hh[i][j]
        print(distances)
        nodes=list1
        unvisited={node:9999999 for node in nodes}
        current=a
        currentdistance=0
        visited={}
        router={}
        routlist=[]
        while True:
            key_tos={}
            for neighbor,distance in distances[current].items():
                if(neighbor not in unvisited):
                    continue
                newdistance=currentdistance+distance
                if(unvisited[neighbor]==9999999 or unvisited[neighbor]>newdistance):
                    unvisited[neighbor]=newdistance
                    key_tos [neighbor]=current
            print(key_tos)
            for key in key_tos:
                router[key]=key_tos[key]
            print(router)
            visited[current]=currentdistance
            del unvisited[current]
            if not unvisited:
                break
            after=[node for node in unvisited.items() ]#将unvisited转为列表元祖
            current,currentdistance=sorted(after,key=lambda x:x[1])[0]#选路径最短的
        print(visited)
        print(router)
        def rout(b):
            if(b!=a):
                for key in router:
                    if(b==key):
                         print(router[key])
                         routlist.append(router[key])
                rout(router[b])
        rout(b)
        routlist.insert(0,b)
        routlist.reverse()
        print(routlist)
    
        for i in visited:
            if(i==b):
                print(visited[i])
        end = time.time()
        print(str(end-start))
        label5 = tkinter.Label(tk, text="dijkstra最短距离为:"+str(visited[b])+"   ")
        label5.place(x=200, y=120)
        label6 = tkinter.Label(tk, text="运行时间:" + str(end-start)+ "   ")
        label6.place(x=200, y=150)
        list4 = {}
        j = 0
        for ii in routlist:
            list4[j] = ii
            j = j + 1
        for i in range(len(routlist) - 1):
            g.attr('edge', dir='forward')
            g.edge(list4[i], list4[i + 1], color='red')
            g.attr('edge', dir='forward')
            g.node(list4[i], shape='doublecircle',style='filled',color='red')
        g.node(list4[len(routlist)-1],shape='doublecircle',style='filled',color='red')
        g.render("2.gv", view=False)
        #img = cv2.imread("2.gv.png")
        # img = cv2.imread("2.gv.png")
       # h = cv2.resize(img, (550, 750))
        #cv2.imwrite("img.png", h,[int(cv2.IMWRITE_PNG_COMPRESSION), 0])
        #cv2.imwrite("123.png", img, [int(cv2.IMWRITE_PNG_COMPRESSION), 0])
        #render = tkinter.PhotoImage(file="./img.png")
        render = tkinter.PhotoImage(file="./2.gv.png")
        la = tkinter.Label(tk, image=render, width=800, height=800)
        la.place(x=700, y=0)
        tk.mainloop()
    button7=tkinter.Button(tk,text="dijkstra最短路径",command=min_distance)
    button7.place(x=500,y=90)
    tkinter.mainloop()
    
    
    
    
    
    
    
    展开全文
  • 最短路径问题(python实现)解决最短路径问题:(如下三种算法)(1)迪杰斯特拉算法(dijkstra算法)(2)弗洛伊德算法(floyd算法) (3)spfa算法第一种算法:dijkstra算法广度优先搜索解决赋权有向图或者无向图...

    o55g08d9dv.jpg广告关闭

    腾讯云11.11云上盛惠 ,精选热门产品助力上云,云服务器首年88元起,买的越多返的越多,最高返5000元!

    最短路径问题(python实现)解决最短路径问题:(如下三种算法)(1)迪杰斯特拉算法(dijkstra算法)(2)弗洛伊德算法(floyd算法) (3)spfa算法第一种算法:dijkstra算法广度优先搜索解决赋权有向图或者无向图的单源最短路径问题. 是一种贪心的策略算法的思路声明一个数组dis来保存源点到各个顶点的最短距离和一...

    71mcdd307c.png

    一心想学习算法,很少去真正静下心来去研究,前几天趁着周末去了解了最短路径的资料,用python写了一个最短路径算法。 算法是基于带权无向图去寻找两个点之间的最短路径,数据存储用邻接矩阵记录。 首先画出一幅无向图如下,标出各个节点之间的权值。? 其中对应索引:a ——> 0b ——> 1c ——> 2d ——>3e ——> 4f ...

    1ybpl28vd2.jpeg

    一心想学习算法,很少去真正静下心来去研究,前几天趁着周末去了解了最短路径的资料,用python写了一个最短路径算法。 算法是基于带权无向图去寻找两个点之间的最短路径,数据存储用邻接矩阵记录。 首先画出一幅无向图如下,标出各个节点之间的权值。? 其中对应索引:a ——> 0b——> 1c——> 2d——>3e——> 4f——>...

    定义:起始位置:a终止位置:f持久集合:permanent = set()暂时集合:temporary = set()? 首先将起始位置a加入永久集合,并将a的距离设为0, 此时遍历a的邻接节点,找到其距离a最短的节点b,将b插入到永久集合中,并更新b的距离为10,b的前驱节点为a。 没有写完。。 先放这,自己有点懵...

    你可以按照下面的规则在平面上移动:每一秒沿水平或者竖直方向移动一个单位长度,或者跨过对角线(可以看作在一秒内向水平和竖直方向各移动一个单位长度)。 必须按照数组中出现的顺序来访问这些点。 示例 1:输入:points = ,]输出:7解决方案 首先我们需要知道在坐标轴上进行移动的话,一点到对角线路径为二...

    该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。 -来自百度百科 前一篇文章:(https:study.sqdxwz.comindex.phparchives13)我们已经学习过了单源最短路径求解方法,这次我们来学习所有顶点间(任意两点间)的最短路径求解方法-floyd算法。 对于求解任意两点最短路径...

    hfgkmqsaar.png

    迪杰斯特拉算法(dijkstra)是由荷兰计算机科学家狄克斯特拉于1959 年提出的,因此又叫狄克斯特拉算法。 是从一个顶点到其余各顶点的最短路径算法,解决的是有权图中最短路径问题。 迪杰斯特拉算法主要特点是以起始点为中心向外层层扩展,直到扩展到终点为止。 -来自百度百科一. 最短路径问题的求解1、单源最短路径用...

    txz59ziqtp.jpeg

    最短路径实现图.jpeg 代码实现 def __init__(self, alifecount=100, ):self.initcitys() self.lifecount = alifecount self.ga =ga(acrossrate=0.7, amutationrage=0.02, alifecount=self.lifecount,agenelenght=len(self.citys), amatchfun=self.matchfun()) self.bestcityorder = ,order city1, city2 = self.citys...

    因此,值函数表示到达目标单元格的最短路径的长度。 更准确地说,让d(s,s )d(s,s )表示从状态ss到目标的最短路径。 然后,对于s≠s s≠s ,vπ(s)...所提供的python实现 gettransitionprobability并不像数学公式那样明确 :def gettransitionprobability(self, oldstate, newstate, action, gridworld)...

    因此,值函数表示到达目标单元格的最短路径的长度。 更准确地说,让d(s,s )d(s,s )表示从状态ss到目标的最短路径。 然后,对于s≠s s≠s ,vπ(s)...所提供的python实现 gettransitionprobability并不像数学公式那样明确 :def gettransitionprobability(self, oldstate, newstate, action, gridworld)...

    比如最短路径寻址,n度关系查找等很多时候需要对整个图做计算才能得出需要的信息,而且这种结构不太好做分布式的集群方案对于nosql并没有一个明确的范围和...redis的出现,很大程度补偿了memcached这类keyvalue存储的不足,在部 分场合可以对关系数据库起到很好的补充作用。 它提供了python,ruby,erlang,php...

    得到的可能是近似最优解,但也可能便是最优解(区间调度问题,最短路径问题(广度优先、狄克斯特拉))3. 对于完全np问题,目前并没有快速得到最优解的解决方案4. 面临np完全问题,最佳的做法就是使用近似算法5. 贪婪算法(近似算法)在大部分情况下易于实现,并且效率不错举个简单的例子,比如给定某个数字的金额(如 250...

    c7o3qs3phv.jpeg

    缺少合理的学习路径,上来 python、html 各种学,极其容易放弃; 3.python有很多包、框架可以选择,不知道哪个更友好; 4.遇到问题找不到解决办法,学习...电影时长最短为45分钟,最长238分,平均时长121.61分钟,第一四分位书为99.25分钟,看来绝多数电影时长还是大于90分钟的。 总排名、按评分排名、按评价...

    本文将介绍笔者在学习过程中开发的网络感知模块和基于网络感知模块提供的网络信息,实现的基于跳数、时延和带宽三种最优路径转发应用。 基于跳数的最短路径转发基于跳数的最短路径转发是最简单的最优路径转发应用。 我们通过network_awareness应用来实现网络拓扑资源的感知并计算最短路径。 首先控制器通过下发lldp...

    在本次演讲中,我想告诉大家我是如何“调试”这个问题的,以及如何使用几个运行在 micropython 的微控制器来改善供暖方式,而这些都没有对不属于我的这座房子进行任何物理修改。 dijkstra 最短路径算法链接:https:t.coqnbi3m7s1z从 gps 导航到网络层链路状态路由,dijkstra 算法为一些备受关注的现代服务提供了理论...

    都是为了方便走好人生路,用最短的路程走到成功的终点。 内置模块就像亲属,生来即有; 自定义模块就像自己走过一次的路,吃一堑长一智做好了攻略,下次按攻略来就可以; 第三方模块就像之后接触到的朋友,他们成功的经验借鉴给你,自己选择,规避坑陷。 模块调用的方法 import 模块名 from 模块名 import 方法名emmm ...

    广度优先搜索属于图算法的一种,擅长找出两者最短距离,解决最短路径问题 步骤:1、使用图来建立问题模型 2、使用广度优先搜索解决问题查找到f的路径...前言最近看完《算法图解》对python的算法有点了解,特记录下来算法概括二分查找的速度比简单查找快得多算法运行时间用大o表示法来表示。 从起增速的角度...

    这是一种在图形平面上,有多个节点的路径,求出最低通过成本的算法。 常用于游戏中的npc(non-player-controlledcharacter)的移动计算,或线上游戏的bot(robot)的移动计算上。 该算法像dijkstra算法一样,可以找到一条最短路径; 也像bfs一样,进行启发式的搜索。 a算法是一种启发式搜索算法,启发式搜索就是在...

    file_object =open(fiel_name, access_mode=’r’, buffering=-1)file_name是要打开的文件名字的字符串,可以使相对路径或者绝对路径,默认文件保存在运行python的起始路径,access_mode可选参数,表示文件打开的模式,’r’,’w’,’a’ 分别代表读取,写入和追加。 还有个’u’模式,代表通用换行符支持。 ‘r’或者’u...

    当前处理的异常详细信息 executable:python解释程序路径 exit(n):退出程序,正常退出时exit(0) getwindowsversion():获取windows的版本 hexversion:获取...返回一个对象的类型 zip(seq1,...):将若干个元组进行合并,长度以元组中的最短的为准 4.time模块这个模块定义的都是和时间、时钟、计时相关的内容: clock...

    展开全文
  • 求K条最短路径的必要性最短路径问题分为:单源最短路径所有顶点对间的最短路径共同的缺陷:这里的最短路径指两点间最短的那一条路径,不包括次短、再次短等路径。这样的最短路径问题比较狭义。在实际情况中,例如:...

    一、问题介绍

    1.求K条最短路径的必要性

    最短路径问题分为:

    单源最短路径

    所有顶点对间的最短路径

    共同的缺陷:

    这里的最短路径指两点间最短的那一条路径,不包括次短、再次短等路径。这样的最短路径问题比较狭义。

    在实际情况中,例如:用户在使用咨询系统或决策支持系统时,希望得到最优的决策参考外,还希望得到次优、再次优等决策参考,这同样反映在最短路径问题上。因此有必要将最短路径问题予以扩展和延伸,称为K条最短路径问题,即不但要求得最短路径,还要求得次短、再次短等路径。

    2.KSP问题定义

    KSP问题是对最短路径问题的推广,它除了要确定最短路径之外,还要确定次短路径、第三短路径,...,知道找到第K短路径。用Pi表示从起点s到终点t的第i短路径,KSP问题是确定路径集合Pk={p1,p2,p3,...,pk},使得满足以下3个条件:

    1)K条路径是按次序产生的,即对于所有的i(i=1,2,...,K-1),pi是在pi+1之前确定;

    2)K条路径是按长度从小到大排列的,即对于所有的i(i=1,2,...,K-1),都有c(pi)

    3)这K条路径是最短的,即对于所有的p∈Pst-PK,都有c(pk)

    ea0e6894259b

    3.相关概念

    ea0e6894259b

    用于说明偏离概念的图

    设起点为 1 ,终点为 5 。p1、p2、p3 分别表示起点到终点间最短路径、第二短路径、第三短路径。

    1)偏离点

    p3相对于p1的偏离节点为节点 2

    2)偏离边

    p3相对于p1的偏离边为(2,4)

    3)偏离路径

    p3相对于p1的(2,4,5)

    4.KSP算法分类

    1) 一般KSP问题

    对路径没有任何限制

    2) 限定无环KSP问题

    要求所有路径都是简单路径,不能有环

    当路径中所有节点都不同时,称为无环路径

    两类KSP问题具有不同的特征,分别提出了不同的求解算法,分别称之为

    一般的KSP算法

    限定无环KSP算法

    ea0e6894259b

    K最短路径算法分类

    二、思路

    下面列出用Yen's算法求KSP的代码。该算法是Yen在1971年提出的以其名字命名的Yen算法。算法采用了递推法中的偏离路径算法思想,适用于非负权边的有向无环图。

    1.流程图

    ea0e6894259b

    Q:将什么样的点做为偏离点

    在pk的基础上求pk+1时,将pk的路径上除终点d之外的节点分别作为偏离点

    Q:求Vi到终点d的最短路径

    设起点为s,终点为t,偏离点为Vi。求偏离点到终点的最短路径时要注意两个问题

    防止从起点到终点的整体路径有环

    从Vi到t的最短路径不能包含s到Vi的路径上的任何节点

    避免与已经在结果列表中的路径重复

    从Vi发出的边不能与结果列表中的路径p1,p2,...pk,上从Vi发出边的相同

    这个体现在代码上就是:在用Dijkstra算法算最短路径时对数组的初始化要进行特别处理

    // 不能走的边

    if (unavailableEdges != null && unavailableEdges.size() != 0) {

    for (MyPath p: unavailableEdges) {

    int index = p.path.indexOf(startIndex);

    if (index >= 0 && (index + 1) >= 0) {

    dist[index + 1] = Double.MAX_VALUE;

    path[index + 1] = -1;

    }

    }

    }

    // 不能走的点

    if (unavailableNodeIndexs != null && unavailableNodeIndexs.size() != 0) {

    for (Integer point: unavailableNodeIndexs) {

    set[point] = 1;

    }

    }

    Q:每次找到新的最短路径时,需将该路径从候选链列表中移除,并加入到结果列表中

    Q:候选列表中的路径不能重复

    所以选择用Set来存储候选路径,去重

    Q:如何从候选列表中选出合适的路径

    如果只有一条路径权值和最小的路:将该路径返回;

    如果路径权值和最小的路有多条:从其中选出节点数最少的路径。

    2.手工模拟求K最短路径流程

    求C到H的10条最短路径

    ea0e6894259b

    节点加载内存后存储在Node[] nodes数组中,各个节点在数组中的存储位置如下,下面用各个点的数组下标进行说明。表格中括号中备注为路径权重。

    ea0e6894259b

    1)通过最短路径算法Dijkstra得到C到H的最短路径

    p1=C-E-F-H,即0-2-3-5

    2)在p1的基础上求p2

    ea0e6894259b

    遍历完各个偏离点后的情况:

    ea0e6894259b

    从集合B中选出路径0->2->4->5(7)移除,并加入到集合A中,作为p2

    ea0e6894259b

    3)在p2的基础上求p3

    ea0e6894259b

    遍历完各个偏离点后的情况:

    ea0e6894259b

    从集合B中选出路径0->1->3->5(8)移除,并加入到集合A中,作为p3

    ea0e6894259b

    4)在p3的基础上求p4

    ea0e6894259b

    遍历完各个偏离点后的情况:

    ea0e6894259b

    从集合B中选出路径0->1->3->5(8)移除,并加入到集合A中,作为p4

    ea0e6894259b

    5)在p4的基础上求p5

    ea0e6894259b

    遍历完各个偏离点后的情况:

    ea0e6894259b

    从集合B中选出路径0->2->3->4->5(8)移除,并加入到集合A中,作为p5`

    ea0e6894259b

    6)在p5的基础上求p6

    ea0e6894259b

    遍历完各个偏离点后,没有新的候选路径加入集合B中

    ea0e6894259b

    从集合B中选出路径0->1->3->4->5(11)移除,并加入到集合A中,作为p6

    ea0e6894259b

    7)在p6的基础上求p7

    遍历各个偏离点时求最短路径均不存在,故遍历完各个偏离点后,没有新的候选路径加入集合B中,从集合B中选出路径0->2->1->3->4->5(11)移除,并加入到集合A中,作为p7

    ea0e6894259b

    8)在p7的基础上求p8

    遍历各个偏离点时求最短路径均不存在,故遍历完各个偏离点后,没有新的候选路径加入集合B中,候选集合为空,不能再继续向下寻找。故从C到H共有7条路径。

    三、代码

    1.输入上述图

    6 9

    11 C

    12 D

    13 E

    14 F

    15 G

    16 H

    11 12 3

    11 13 2

    12 14 4

    13 12 1

    13 14 2

    13 15 3

    14 15 2

    14 16 1

    15 16 2

    11 16 10

    2.代码

    package road;

    import util.NavigationUtil;

    import java.util.*;

    /**

    *

    * author : 杨丽金

    * time : 2018/11/14

    * desc : 有关于图的最短路径

    * version: 1.0

    *

    */

    public class ShortestPath {

    public static class MyPath {

    // 路径上的各个节点对应的数组下标(从起点到终点)

    public List < Integer > path;

    // 路径总权值

    public double weight;

    // 路径上节点个数:通过path.size()得到

    public MyPath() {}

    public MyPath(List < Integer > path, double weight) {

    this.path = path;

    this.weight = weight;

    }

    @Override

    public String toString() {

    return "MyPath{" +

    "path=" + path +

    ", weight=" + weight +

    '}';

    }

    @Override

    public boolean equals(Object o) {

    if (this == o) return true;

    if (o == null || getClass() != o.getClass()) return false;

    MyPath path1 = (MyPath) o;

    return path != null ? path.equals(path1.path) : path1.path == null;

    }

    @Override

    public int hashCode() {

    int result;

    long temp;

    result = path != null ? path.hashCode() : 0;

    temp = Double.doubleToLongBits(weight);

    result = 31 * result + (int)(temp ^ (temp >>> 32));

    return result;

    }

    }

    /**

    * 用Yen's KSP算法从图中找出从startIndex到endIndex的K条最短路径

    *

    * @param g

    * @param startIndex:起始节点的数组下标

    * @param endIndex:终止节点的数组下标

    * @param K:要求的最短路径数目

    * @return

    */

    public List < MyPath > KSP_Yen(MyGraph g, int startIndex, int endIndex, int K) {

    // 结果列表

    List < MyPath > result = new ArrayList < > ();

    // 候选路径列表

    Set < MyPath > candidatePaths = new HashSet < > ();

    // 候选路径列表中权值最小的路径,及其对应的节点个数

    // 第一条最短路径

    MyPath p1 = getSingleShortestPath_dijkstra(g, startIndex, endIndex, null, null);

    result.add(p1);

    int k = 1;

    List < Integer > pk = p1.path;

    while (k < K) {

    /*

    求第k+1条最短路径

    */

    // 遍历每一个偏离点

    for (int i = 0; i <= pk.size() - 2; i++) {

    // 1,pk路径中起点到偏离点Vi的路径权值

    double w1 = 0;

    for (int j = 0; j <= i - 1; j++) {

    w1 += NavigationUtil.getEdgeWight(g, pk.get(j), pk.get(j + 1));

    }

    // 2,偏离点到终点的最短路径

    MyPath viToDestinationSP = getSingleShortestPath_dijkstra(g,

    pk.get(i), endIndex, pk.subList(0, i), result);

    if (viToDestinationSP != null) {

    // 说明从这个偏离点可以到达终点

    MyPath temp = new MyPath();

    List < Integer > tempPath = new ArrayList < > (pk.subList(0, i));

    tempPath.addAll(viToDestinationSP.path);

    temp.path = tempPath;

    temp.weight = w1 + viToDestinationSP.weight;

    // 加入候选列表

    if (!candidatePaths.contains(temp)) {

    candidatePaths.add(temp);

    }

    }

    }

    if (candidatePaths == null || candidatePaths.size() == 0) {

    // 没有候选路径,则无需再继续向下求解

    break;

    } else {

    // 从候选路径中选出最合适的一条,移除并加入到结果列表

    MyPath fitPath = getFitPathFromCandidate(candidatePaths);

    candidatePaths.remove(fitPath);

    result.add(fitPath);

    k++;

    pk = fitPath.path;

    }

    }

    return result;

    }

    /**

    * 从候选列表中得到一条路径作为pk+1

    * 要求:1)该路径的权值和最小;2)路径经过节点数最少

    * @param candidatePaths:候选列表

    * @return

    */

    private MyPath getFitPathFromCandidate(Set < MyPath > candidatePaths) {

    MyPath result = new MyPath(null, Double.MAX_VALUE);

    for (MyPath p: candidatePaths) {

    // 对于每一条路径

    if (p.weight < result.weight) {

    result = p;

    }

    if (p.weight == result.weight && p.path.size() < result.path.size()) {

    result = p;

    }

    }

    return result;

    }

    /**

    * 用Dijkstra算法得到从startIndex到endIndex的一条最短路径

    *

    * @param g

    * @param startIndex 起始节点的数组下标

    * @param endIndex 终止节点的数组下标

    * @param unavailableNodeIndexs:求最短路径时不可用的节点(数组下标)

    * @param unavailableEdges:求最短路径时不可用的边

    * @return

    */

    public MyPath getSingleShortestPath_dijkstra(MyGraph g, int startIndex, int endIndex,

    List < Integer > unavailableNodeIndexs, List < MyPath > unavailableEdges) {

    if (startIndex == -1) {

    // throw new Exception("getSingleShortestPath_dijkstra()起始点编号输入错误");

    }

    if (endIndex == -1) {

    // throw new Exception("getSingleShortestPath_dijkstra()终止点编号输入错误");

    }

    int[] set = new int[g.n]; // 是否已并入集合,该点是否已找到最短路径

    // s到i的最短路径长度

    double[] dist = new double[g.n];

    // s到i的最短路径上i的前一个节点编号

    int[] path = new int[g.n];

    // 初始化数组

    set[startIndex] = 1;

    for (int i = 0; i < g.n; i++) {

    if (i == startIndex) { // 源点

    dist[i] = 0;

    path[i] = -1;

    } else {

    if (NavigationUtil.isConnected(g, startIndex, i)) {

    dist[i] = NavigationUtil.getEdgeWight(g, startIndex, i);

    path[i] = startIndex;

    } else {

    dist[i] = Double.MAX_VALUE;

    path[i] = -1;

    }

    }

    }

    // 不能走的边

    if (unavailableEdges != null && unavailableEdges.size() != 0) {

    for (MyPath p: unavailableEdges) {

    int index = p.path.indexOf(startIndex);

    if (index >= 0 && (index + 1) >= 0) {

    dist[p.path.get(index + 1)] = Double.MAX_VALUE;

    path[p.path.get(index + 1)] = -1;

    }

    }

    }

    // 不能走的点

    if (unavailableNodeIndexs != null && unavailableNodeIndexs.size() != 0) {

    for (Integer point: unavailableNodeIndexs) {

    set[point] = 1;

    }

    }

    // 需进行n-2轮循环

    for (int i = 0; i < g.n - 2; i++) {

    int k = -1;

    double min = Double.MAX_VALUE;

    // 找出dist[]中最小的(太贪心了)

    for (int j = 0; j < g.n; j++) {

    if (set[j] == 1) {

    continue;

    }

    if (dist[j] < min) {

    min = dist[j];

    k = j;

    }

    }

    if (k == -1) {

    // 说明从源点出发与其余节点不连通,无法再向下进行扩展

    break;

    }

    set[k] = 1; // 把节点k并入

    // 修改dist[]、path[]

    for (int j = 0; j < g.n; j++) {

    if (set[j] == 1) {

    continue;

    }

    if (NavigationUtil.isConnected(g, k, j)) {

    double temp = dist[k] + NavigationUtil.getEdgeWight(g, k, j);

    if (temp < dist[j]) {

    dist[j] = temp;

    path[j] = k;

    }

    }

    }

    }

    System.out.println("运行Dijkstra算法后的数组情况为:");

    System.out.print("set[]:");

    for (int i = 0; i < g.n; i++) {

    System.out.print(set[i] + "\t");

    }

    System.out.println();

    System.out.print("dist[]:");

    for (int i = 0; i < g.n; i++) {

    System.out.print(dist[i] + "\t");

    }

    System.out.println();

    System.out.print("path[]:");

    for (int i = 0; i < g.n; i++) {

    System.out.print(path[i] + "\t");

    }

    System.out.println();

    // 输出

    if (dist[endIndex] == Double.MAX_VALUE) {

    // 说明没有最短路径,两点不连通

    System.out.println("两点之间不连通");

    return null;

    } else {

    System.out.println("节点" + g.nodes[startIndex].nodeId + "到节点" +

    g.nodes[endIndex].nodeId + "的最短路径长度为:" + dist[endIndex] + ",具体路径是:");

    MyPath result = new MyPath();

    result.path = getMinimumPath(g, startIndex, endIndex, path);

    result.weight = dist[endIndex];

    return result;

    }

    }

    /**

    * 输出从节点S到节点T的最短路径

    *

    * @param sIndex:起始节点在数组中下标

    * @param tIndex:终止节点在数组中下标

    */

    private List < Integer > getMinimumPath(MyGraph g, int sIndex, int tIndex, int[] path) {

    List < Integer > result = new ArrayList < > ();

    Stack < Integer > stack = new Stack < > ();

    stack.push(tIndex);

    int i = path[tIndex];

    while (i != -1) {

    stack.push(i);

    i = path[i];

    }

    while (!stack.isEmpty()) {

    System.out.print(g.nodes[stack.peek()].nodeId + ":" + g.nodes[stack.peek()].nodeName + "-->");

    result.add(NavigationUtil.getIndex(g, g.nodes[stack.pop()].nodeId));

    }

    System.out.println();

    return result;

    }

    }

    3.输出

    sps: [MyPath {

    path = [0, 2, 3, 5], weight = 5.0

    }, MyPath {

    path = [0, 2, 4, 5], weight = 7.0

    }, MyPath {

    path = [0, 1, 3, 5], weight = 8.0

    }, MyPath {

    path = [0, 2, 1, 3, 5], weight = 8.0

    }, MyPath {

    path = [0, 2, 3, 4, 5], weight = 8.0

    }, MyPath {

    path = [0, 1, 3, 4, 5], weight = 11.0

    }, MyPath {

    path = [0, 2, 1, 3, 4, 5], weight = 11.0

    }]

    参考文献

    [1]K条最短路径问题综述

    [2]韩海玲. 基于城市路网的最短路径算法研究与应用[D]. 中北大学, 2017.

    [3]徐涛, 丁晓璐, 李建伏. K最短路径算法综述[J]. 计算机工程与设计, 2013, 34(11):3900-3906.

    [4]K条最短路径算法(KSP, k-shortest pathes):Yen's Algorithm

    展开全文
  • 内包含QT程序运行出来是一个60*60的迷宫,算法包括迷宫的自动生成,利用深度优先搜索、广度优先搜索两种方法遍历最短路径,并能在界面上动态显示。
  • C语言实现图的最短路径Floyd算法发布时间:2020-10-07 10:51:10来源:脚本之家阅读:64作者:KittyGirllllFloyd算法直接使用二维...以下程序在DEV C++中调试运行通过。#include #define INFINITY 65535typedef in...
  • 用gtk+2.0开发的一个小程序,用来显示最短路径,前台界面用gtk+2.0开发,后台用flody算法,支持手工画图,动态修改图的结构,包括修改顶点、边长等等,可以在界面上显示任意两点之间的最短路径,可以在图上画出来,...
  • 要求:求带权有向图中某一结点到其他结点的最短路径。 用迪杰斯特拉算法求解,迪杰斯特拉算法书上的描述如下: 对于图G=(V,{E}),将图中的顶点归为两组: 第一组S:已求出的最短路径的终点集合(开始为{v0}) 第...
  • 得到无权最短路径 代码实现 问题描述 现有一个有向无权图。如下图所示: 问题:使用某个顶点s作为输入参数,找出从s到所有其他顶点的最短路径。 说明:因为是无权图,因此我们可以为每台边赋值为1。这里选择...
  • 文件中详细介绍了最短路径算法实现方案,在VC环境下调试运行可行。
  • 注意:这里需要求解的最短路径指的是两个城市之间的最短距离,而不是所有城市之间最短总距离。 1.最短路径算法 //最短路径算法 static void distMin(GraphMatrix GM,int vend){ //vend为结束...
  • 问题:使用某个顶点s作为输入参数,找出从s到所有其他顶点的最短路径。 说明:因为是无权图,因此我们可以为每台边赋值为1。这里选择v3为s作为起点。 问题分析 此时立刻可以说,从s到v3的最短路径是长为0的路径...
  • 最短路径问题

    2020-05-26 09:28:42
    最短路径(Shortest Path) 在网络中,求两个不同顶点之间的所有路径中,边权重值之和最小的那一条路径 源点(Source) 第一个顶点 终点 最后一个顶点(Destination) 单源最短路径问题 从固定源点出发到其他所有...
  • 最短路径

    2015-08-15 11:03:47
    最短路径问题 对于如下的图来说,每一个“∙\bullet”代表一个节点,节点与节点之间是他们之间相应的边权,由于这个图类似于矩阵的形式,所以当给定坐标(x1,y1)和(x2,y2)(x_1, y_1)和(x_2, y_2)时,求这两个节点之间...
  • matlab最短路径的输出问题,用了递归,但程序出错了,请大虾指点 程序如下function shortestpath(w,p,q)c='->';l='';f='';t=size(w);m=t(1,1);a=zeros(m,m);v=w;for k=1:mfor i=1:mfor j=1:mb=[w(i,j),w(i,k)+w(k,j)...
  • 本文实例讲述了Python数据结构与算法之图的最短路径(Dijkstra算法)。分享给大家供大家参考,具体如下:# coding:utf-8# Dijkstra算法——通过边实现松弛# 指定一个点到其他各顶点的路径——单源最短路径# 初始化图...
  • 本文实例讲述了Python数据结构与算法之图的最短路径(Dijkstra算法)。分享给大家供大家参考,具体如下:# coding:utf-8# Dijkstra算法——通过边实现松弛# 指定一个点到其他各顶点的路径——单源最短路径# 初始化图...
  • 单源最短路径问题

    2018-07-11 18:01:00
    1.最短路径给定一个带权有向图G=(V,E),其中每条边的权都是非负实数。另外再给定V中的一个顶点,称为源。现要计算从源到其他各顶点的最短路长度。这里路的长度是指路上各边权之和。这个问题通常称为最短路径问题...
  • 图的四种最短路径算法

    万次阅读 多人点赞 2017-12-27 12:03:57
    本文总结了图的几种最短路径算法的实现:深度或广度优先搜索算法,弗洛伊德算法,迪杰斯特拉算法,Bellman-Ford算法1),深度或广度优先搜索算法(解决单源最短路径)从起始结点开始访问所有的深度遍历路径或广度...
  • 此应用程序可让您从 Cytoscape 中的给定图形创建生成树和所有配对最短路径。 去做 自述文件 此自述文件通常会记录启动和运行应用程序所需的任何步骤。 这个存储库是做什么用的? 快速总结 版本 我
  • 并行最短路径算法Dijkstra。 为实现并行最短路径计算,我们必须要解决如下问题: (1)数据获取:利用随机函数生成大约2000个节点及其节点之间的距离。本程序使用邻接矩阵来存储带权有向图的信息。矩阵大小2000*2000...
  • 最短路径算法

    2018-06-29 18:06:24
    本文总结了图的几种最短路径算法的实现:深度或广度优先搜索算法,弗洛伊德算法,迪杰斯特拉算法,Bellman-Ford算法1),深度或广度优先搜索算法(解决单源最短路径)从起始结点开始访问所有的深度遍历路径或广度...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,760
精华内容 13,504
关键字:

最短路径程序运行