精华内容
下载资源
问答
  • 多段图的最短路径问题问题:设图G=(V,E)是一个带权有向图,如果把顶点集合V划分成k个互不相交的子集Vi(2<=k<=n,1<=i<=k),使得E中的任何一条边,必有u∈Vi,v∈Vi+m(1<=it∈Vk为终点。多段图的最短路径...

    多段图的最短路径问题

    问题:设图G=(V,E)是一个带权有向图,如果把顶点集合V划分成k个互不相交的子集Vi(2<=k<=n,1<=i<=k),

    使得E中的任何一条边,必有u∈Vi, v∈Vi+m(1<=i

    t∈Vk为终点。

    多段图的最短路径问题为从源点到终点的最小代价路径。

    11709da35245b5ce98945857f0df7c5c.png

    子问题:设Cuv表示多段图的有向边上的权值,将从源点s到终点t的最短路径长度即为d(s,t),

    考虑原问题的部分解d(s,v),显然有下式成立

    d(s,v)=Csu   (∈E)

    d(s,v)=min(d(s,u)+Cuv)            (∈E)

    算法:多段图的最短路径问题

    输入:多段图的代价矩阵

    输出:最短长度及路径c[n][n]

    1.循环变量j从1~n-1重复下述操作,执行填表工作

    1.1考察顶点j的所有入边,对于边∈E,执行下述操作

    1.1.1cost[j]=min{cost[i]+c[i][j]};

    1.1.2path[j]=使cost[i]+c[i][j]最小的i;

    1.2 j++;

    2.输出最短路径长度cost[n-1];

    3.循环变量i=path[n-1].循环直到path[i]=0,输出最短路径经过的顶点;

    3.1 输出path[i];

    3.2 i=path[i]

    #include#include#include

    #define Max 0xffff

    using namespacestd;//动态规划求最短路径

    void dp_path(int c[][100], int *cost, int *path) {intm, n;

    cout<< "输入顶点个数和边个数" <

    cin>> n >>m;//初始化代价矩阵

    for (int i = 0; i < n; i++)for (int j = 0; j < n; j++)

    c[i][j]=Max;//输入代价矩阵

    intu, v, s;for (int i = 0; i < m; i++) {

    cin>> u >> v >>s;//cout<

    c[u][v] =s;

    }for(int i=0;i

    cost[i]=Max;

    path[0] = -1;

    cost[0] = 0;for (int j = 1; j < n; j++) {for (int i = j-1; i >=0; i--) {if (cost[j] > cost[i] +c[i][j]) {

    path[j]=i;

    cost[j]= cost[i] +c[i][j];

    }

    }

    }

    cout<

    cout<=0){

    cout<

    i=path[i];

    }

    }intmain()

    {int c[100][100], cost[100], path[100];

    dp_path(c, cost, path);

    getchar();return 0;

    }

    展开全文
  • 代码: #include&lt;bits/stdc++.h&gt; using namespace std; int arc[20][20];... // 假定边上权值均不超过1000 int CreateGraph() { int i,j,k; int weight; int vnum,arcnum; cout&l...

    代码:

    #include<bits/stdc++.h>
    using namespace std;
    int arc[20][20];
    const int MAX = 1000;    // 假定边上的权值均不超过1000
    int CreateGraph()
    {
        int i,j,k;
        int weight;
        int vnum,arcnum;
        cout<<"请输入顶点的个数和边的个数:";
        cin>>vnum>>arcnum;
        //  初始化图的代价矩阵
        for(i=0; i<vnum; i++)
            for(j=0; j<vnum; j++)
                arc[i][j]=MAX;
        //  建立图的代价矩阵
        for(k=0; k<arcnum; k++)
        {
            cout<<"请输入边的两个顶点和权值:"<<endl;
            cin>>i>>j>>weight;
            arc[i][j]=weight;
        }
        return vnum;    // 返回顶点个数
    }
    //  求n个顶点长度多段图的最短路径
    int BackPath(int n)
    {
        int i,j;
        int cost[n],path[n];    // 存储路径长度和路径
        for(i=1; i<n; i++)
        {
            cost[i]=MAX;    // 初始化路径长度为MAX
            path[i]=-1;
        }
        cost[0]=0;  // 顶点0为源点
        path[0]=-1;
        //  执行填表工作
        for(j=1; j<n; j++)
        {
            //  考察所有入边
            for(i=j-1; i>=0; i--)
            {
                if(arc[i][j]+cost[i]<cost[j])
                {
                    cost[j]=arc[i][j]+cost[i];
                    path[j]=i;
                }
            }
        }
        cout<<n-1;  // 输出终点
        i=n-1;
        while(path[i]>=0)   // 依次输出path[i]
        {
            cout<<"<-"<<path[i];
            i=path[i];      // 求得路径上顶点i的前一个顶点
        }
        cout<<endl;
        return cost[n-1];   // 返回最短路径长度
    }
    
    int main()
    {
        int n,m;
        n=CreateGraph();
        m=BackPath(n);
        cout<<m<<endl;
        return 0;
    }

    测试数据:

    10 18
    0 1 4
    0 2 2
    0 3 3
    1 4 9
    1 5 8
    2 4 6
    2 5 7
    2 6 8
    3 5 4
    3 6 7
    4 7 5
    4 8 6
    5 7 8
    5 8 6
    6 7 6
    6 8 5
    7 9 7
    8 9 3

    输出:

    展开全文
  • 多段图的最短路径问题 问题:设图G=(V,E)是一个带权有向图,如果把顶点集合V划分成k个互不相交的子集Vi(2<=k<=n,1<=i<=k), 使得E中的任何一条边<u,v>,必有u∈Vi,v∈Vi+m(1<=i<k,1&...

    多段图的最短路径问题

    问题:设图G=(V,E)是一个带权有向图,如果把顶点集合V划分成k个互不相交的子集Vi(2<=k<=n,1<=i<=k),

              使得E中的任何一条边<u,v>,必有u∈Vi, v∈Vi+m(1<=i<k,1<i+m<=k),则称图G为多段图,称s∈V1为源点,

             t∈Vk为终点。

             多段图的最短路径问题为从源点到终点的最小代价路径。

    子问题:设Cuv表示多段图的有向边<u,v>上的权值,将从源点s到终点t的最短路径长度即为d(s,t),

                  考虑原问题的部分解d(s,v),显然有下式成立

                 d(s,v)=Csu                                  (<s,v>∈E)

                 d(s,v)=min(d(s,u)+Cuv)            (<u,v>∈E)

    算法:多段图的最短路径问题

    输入:多段图的代价矩阵

    输出:最短长度及路径c[n][n]

    1.循环变量j从1~n-1重复下述操作,执行填表工作

       1.1考察顶点j的所有入边,对于边<i,j>∈E,执行下述操作

           1.1.1cost[j]=min{cost[i]+c[i][j]};

           1.1.2path[j]=使cost[i]+c[i][j]最小的i;

         1.2 j++;

    2.输出最短路径长度cost[n-1];

    3.循环变量i=path[n-1].循环直到path[i]=0,输出最短路径经过的顶点;

       3.1 输出path[i];

       3.2 i=path[i]

    #include<iostream>
    #include<algorithm>
    #include<stdio.h>
    #define Max 0xffff
    using namespace std;
    //动态规划求最短路径
    void dp_path(int c[][100], int *cost, int *path) {
        int m, n;
        cout << "输入顶点个数和边个数" << endl;
        cin >> n >> m;
        //初始化代价矩阵
        for (int i = 0; i < n; i++)
            for (int j = 0; j < n; j++)
                c[i][j] = Max;
        //输入代价矩阵
        int u, v, s;
        for (int i = 0; i < m; i++) {
            cin >> u >> v >> s;
            //cout<<u<<v<<s<<endl;
            c[u][v] = s;
        }
        for(int i=0;i<n;i++)
            cost[i]=Max;
        path[0] = -1;
        cost[0] = 0;
        for (int j = 1; j < n; j++) {
            for (int i = j-1; i >=0; i--) {
                if (cost[j] > cost[i] + c[i][j]) {
                    path[j] = i;
                    cost[j] = cost[i] + c[i][j];
                }
            }
        }
        cout<<cost[n-1]<<endl;
        int i=path[n-1];
        cout<<path[n-1]<<endl;
        while(path[i]>=0){
            cout<<path[i]<<endl;
            i=path[i];
        }
    }
    int main()
    {
        int c[100][100], cost[100], path[100];
        dp_path(c, cost, path);
        getchar();
        return 0;
    }

     

    转载于:https://www.cnblogs.com/zuoyou151/p/9028675.html

    展开全文
  • 课程随堂作业,C语言,用dev就能运行,萌新代码,勿喷,仅仅帮助不想写作业朋友方便一下,反正老师也不会仔细检查
  • 多段图的最短路径问题: 定义: 给定有向带权图G(V,E,W),如果把顶点集合V划分成 k个不相交的子集V i ,1≤i ≤k,k≥2,使得E中的任何一条边 (u,v),必有uЄ V i, v ∈ V i+m ,m≥1,则称这样的图为多段图。 决策...
    /*
    多段图的最短路径问题:
    定义: 给定有向带权图G(V,E,W),如果把顶点集合V划分成
    k个不相交的子集V i ,1≤i ≤k,k≥2,使得E中的任何一条边
    (u,v),必有uЄ V i, v ∈ V i+m  ,m≥1,则称这样的图为多段图。
    
    决策的第一阶段:确定图中第k-1段的所有顶点到达收点t的花费最小的通路。把这些信息保存
    起来,在最后形成最优决策时使用。用数组cost[i]存放顶点i到达手电t的最小花费,用数组path[i]
    存放顶点i到达收点t的最小花费通路上的前方顶点编号
    
    决策第二阶段:确定途中第k-2段的所有顶点到收点t的花费最小的通路。这时,利用第一阶段形成的信息来进行
    决策,并把决策的结果存放在数组cost和path的相应元素中,依次进行,直到最后确定源点s到收点t的花费最小的
    通络。
    源点s的path数组中就是最优决策序列
    
    思想:
    1设cost[i]表示顶点i到收点t的最短花费
    2动态规划方程:cost[i] =  min{c[i][j] + cost[j]},1<= j <= n ,并且j != i中
     path[i] = j,j是使得c[i][j] + cost[j]最小的j
    3 边界条件:cost[n-1] = 0
    4 目标状态:cost[0]
    
    算法步骤:
    用route[n]存放从源点s出发到达收点t的最短通路上的顶点编号
    1)对所有的i,0<=i<n,把cost[i]初始化为最大值,path[i]初始化为-1,cost[n-1]初始化为0
    2)令i = n - 2;
    3)根据状态迁移方程计算cost[i]和path[i]
    4)另i = i -1 ;若i > = 0,转步骤(3),否则转到步骤(5)
    5)另i = 0 ,route[i] = 0
    6)若route[i] = n-1,算法结束,否则转步骤(7)
    7)i = i + 1,route[i] = path[route[i-1],转步骤(6)
    
    输入说明:
    首行:顶点个数,顶点从0开始
    接下来:每一行分别是:起始结点编号 终止结点编号 权值
    
    输入:
    10(顶点个数) 19(边的条数)
    0 1 4
    0 2 1
    0 3 3
    
    1 4 9
    1 5 8
    2 3 1
    2 4 6
    2 5 7
    2 6 8
    3 5 4
    3 6 7
    
    4 7 5
    4 8 6
    5 7 8
    5 8 6
    6 7 6
    6 8 5
    
    7 9 7
    8 9 3
    
    输出:
    15
    0 2 3 5 8 9
    */
    
    /*
    关键:
    1 逆序方式 递推	//二重循环,循环n-1次,每次,求出当前结点的最短花费,外层循环:逆序
    	for(int i = n-2 ; i >= 0 ; i--)
    	{
    		//内层循环递增求解
    		int iMin = MAX;
    		for(int j = i+1 ; j <= n-1 ; j++)
    		{
    			//剪枝
    			if(g_iCost[j] != MAX && g_iMatrix[i][j] != -1)
    			{
    				iRet = g_iCost[j] + g_iMatrix[i][j];
    				if(iMin > iRet)
    				{
    					iMin = iRet;
    					g_iCost[i] = iMin;
    					//如何记录最短路径
    					g_iPath[i] = j;
    
    2 顺序方式,递归
    	//记忆化搜索,也是递归基
    	if(g_iCost[iEnd] != MAX)
    	{
    		return g_iCost[iEnd];
    	}
    	//自底向上开始动态规划
    	int iMin = MAX;
    	int iRet;
    	for(int i = 0 ; i <= n-1 ; i++)
    	{
    		//计算其他状态值,剪枝,cost[i] = min { cost[j] + c[i][j])
    		if(i > iEnd && g_iMatrix[iEnd][i] != -1)
    		{
    			iRet = dp(i,n) + g_iMatrix[iEnd][i];
    			if(iMin > iRet)
    			{
    				iMin = iRet;
    
    3设定path[i] = j;j是使cost[i]取得最小值的j
    //如何记录最短路径
    g_iPath[i] = j;
    
    4 1设cost[i]表示顶点i到收点t的最短花费
    2动态规划方程:cost[i] =  min{c[i][j] + cost[j]},1<= j <= n ,并且j != i中
     path[i] = j,j是使得c[i][j] + cost[j]最小的j
    */
    
    #include <iostream>
    #include <string.h>
    #include <string>
    #include <fstream>
    #include <vector>
    
    using namespace std;
    
    const int MAXSIZE = 100;
    int g_iMatrix[MAXSIZE][MAXSIZE];
    int g_iCost[MAXSIZE];
    int g_iPath[MAXSIZE];
    int g_iRoute[MAXSIZE];
    
    const int MAX = 1000000000;
    
    int max(int a,int b)
    {
    	return a > b ?  a : b;
    }
    
    //采用递推的方式做
    int dp2(int n)
    {
    	//自底向上开始动态规划
    
    	int iRet;
    	int iCnt = 0;
    	//二重循环,循环n-1次,每次,求出当前结点的最短花费,外层循环:逆序
    	for(int i = n-2 ; i >= 0 ; i--)
    	{
    		//内层循环递增求解
    		int iMin = MAX;
    		for(int j = i+1 ; j <= n-1 ; j++)
    		{
    			//剪枝
    			if(g_iCost[j] != MAX && g_iMatrix[i][j] != -1)
    			{
    				iRet = g_iCost[j] + g_iMatrix[i][j];
    				if(iMin > iRet)
    				{
    					iMin = iRet;
    					g_iCost[i] = iMin;
    					//如何记录最短路径
    					g_iPath[i] = j;
    				}
    			}
    		}
    	}
    	return g_iCost[0];
    }
    
    //因为存在多个阶段,只能用递归做
    int dp(int iEnd,int n)
    {
    	//记忆化搜索,也是递归基
    	if(g_iCost[iEnd] != MAX)
    	{
    		return g_iCost[iEnd];
    	}
    	//自底向上开始动态规划
    	int iMin = MAX;
    	int iRet;
    	for(int i = 0 ; i <= n-1 ; i++)
    	{
    		//计算其他状态值,剪枝,cost[i] = min { cost[j] + c[i][j])
    		if(i > iEnd && g_iMatrix[iEnd][i] != -1)
    		{
    			iRet = dp(i,n) + g_iMatrix[iEnd][i];
    			if(iMin > iRet)
    			{
    				iMin = iRet;
    			}
    		}
    	}
    	return g_iCost[iEnd] = iMin;
    }
    
    /*读取文件中的数据*/
    bool readData(const string& sFileName)
    {
    	if(sFileName.empty())
    	{
    		return false;
    	}
    	ifstream infile;
    	infile.open(sFileName,ios::in);
    	if(infile.bad())
    	{
    		cout << "打开文件:" << sFileName << ",发生错误" << endl;
    		return false;
    	}
    	string sLine;
    	vector<string> vecTemp;
    	int iBeg,iEnd,iWeight;
    	string sBeg,sEnd,sWeight;
    	while(getline(infile,sLine))
    	{
    		//if(boost::starts_with(sLine,"***") ||  sLine.empty())
    		if(string::npos != sLine.find("*") || sLine.empty())
    		{
    			continue;
    		}
    		else
    		{
    			vecTemp.clear();
    			int iFirstBlank = sLine.find_first_of(" ");
    			int iLastBlank = sLine.find_last_of(" ");
    			int iLen = iLastBlank - iFirstBlank - 1;
    			sBeg = sLine.substr(0,iFirstBlank);
    			sEnd = sLine.substr(iFirstBlank + 1, iLen);
    			sWeight = sLine.substr(iLastBlank + 1,sLine.size() - iLastBlank - 1);
    			vecTemp.push_back(sBeg);
    			vecTemp.push_back(sEnd);
    			vecTemp.push_back(sWeight);
    			if(vecTemp.size() != 3)
    			{
    				cout << "读取的文件格式不对,请检查" << endl;
    				return false;
    			}
    			else
    			{
    				iBeg = atoi(vecTemp.at(0).c_str());
    				iEnd =	atoi(vecTemp.at(1).c_str());
    				iWeight = atoi(vecTemp.at(2).c_str());
    				cout << "边<" << iBeg << "," << iEnd << ">,权值:" << iWeight << endl; 
    				//易错,这里是无向图的邻接矩阵,所以要设置两个无相边的连接值
    				g_iMatrix[iBeg][iEnd] = iWeight;
    			}
    		}
    	}
    	return true;
    }
    
    /*打印最短路径,path[8] = 9,path[6] = 8,path[5] = 6,path[0] = 2,path[1] = 5,g_iPath[],0,2,3,5,8,9,从Path[0]出发,*/
    void printPath(int n)
    {
    	for(int i = 0 ; i!= n -1  ; i = g_iPath[i] )
    	{
    		cout << i << " ";
    	}
    	cout << n-1 << endl;
    }
    
    void process1()
    {
    	memset(g_iMatrix,-1,sizeof(g_iMatrix));
    	readData("./data.txt");
    	int iEdgeNum = 19;
    	int n = 10;
    	//初始化最大距离
    	for(int i = 0 ; i <= n - 1 ; i++)
    	{
    		g_iCost[i] = MAX;
    	}
    	//初始化动态规划数组初始状态
    	g_iCost[n-1] = 0;
    	memset(g_iPath,-1,sizeof(g_iPath));
    	cout << dp2(10) << endl;
    	printPath(n);
    }
    
    void process()
    {
    	int n;
    	while(cin >> n)
    	{
    		int iBeg,iEnd,iDis;
    		memset(g_iMatrix,-1,sizeof(g_iMatrix));
    		int iEdgeNum ;
    		cin >> iEdgeNum;
    		for(int k = 0 ; k < iEdgeNum ; k++)
    		{
    			cin >> iBeg >> iEnd >> iDis;
    			g_iMatrix[iBeg][iEnd] = iDis;
    		}
    		//初始化最大距离
    		for(int i = 0 ; i <= n - 1 ; i++)
    		{
    			g_iCost[i] = MAX;
    		}
    		//初始化动态规划数组初始状态
    		g_iCost[n-1] = 0;
    		memset(g_iPath,-1,sizeof(g_iPath));
    		dp(0,n);
    		cout << g_iCost[0] << endl;
    	}
    }
    
    int main(int argc,char* argv[])
    {
    	process1();
    	getchar();
    	return 0;
    }

    展开全文
  • 时间复杂度为O(m+k):m为边数目,k为段的数目。 #include<iostream> using namespace std; #define INF 999 int arc[100][100]; // 最多100个点 int CreateGraph() { int vnum,arcnum; cout<<"请...
  • 要求经过整数之和最小,整个矩形是环形,即第一行上一行是最后一行,最后一行下一行是第一行,输出路径上每列行号,解时输出字典序最小。 分析:  每一列就是一个状态,这个状态是由前一列右上,...
  • 多段图的最短路径问题-----动态规划法

    万次阅读 多人点赞 2013-06-06 22:27:01
    多段图,求最短路径,如图: 对其使用动态规划法: 阶段:将图中顶点划分5个阶段,k 状态:每个阶段有几种供选择点s 决策:当前状态应在前一个状态基础上获得。决策需要满足规划方程 规划方程:f(k)...
  • 多段图的最短路径

    2018-04-04 14:18:23
    多段图是一个有向的无环图。求解从起始点v0到终止点的最短路径的长度,首先看一下这个问题是否具有最优子结构的性质。对于每一点来说,从v0到它的最短路径有两种可能,分别是从v0直接到该点或者是从最短的前驱节点...
  • 多段图的最短路径问题是求原点到终点的最小代价路径 分支限界法求解步骤: 1.确定合理的限界函数,根据限界函数确定目标函数的界[down,up] 2.从起点开始,按照广度优先策略搜索问题的解空间树,将在界范围内的节点...
  • 问题描述 源码 #include<stdio.h> #include<stdlib.h> const int INF = 1000; const int N = 100;//图的最大结点数为100 int arc[N][N];//图的代价矩阵 int cost[N];//存储路径长度 int path[N];//...
  • 应用示例: ...在位置与目的地,路径规划会...从起始点到达目的地的最佳行车路线的过程,它是多段图最短路径问题的典型应用。 对以下多段图,求出从原点1到终点10的最短路径。 分析: 源代码: #include <iostr...
  • [图算法]多段图最短路径 多段图最短路径问题是应用动态规划经典问题之一,许多优化问题都能转化为多段图最短路径问题进而求解。多段图最短...
  • 建立一个从源点S到终点T的多段图,设计一个动态规划算法求出从S到T的最短路径值,并输出相应的最短路径。 解 1 package org.xiu68.exp.exp4; 2 3 public class Exp4_1 { 4 //建立一个从源点S...
  • 多段图的最短路径问题 建立一个从源点S到终点T的多段图,设计一个动态规划算法求出从S到T的最短路径值,并输出相应的最短路径。 思路 首先确定能分段,即每一层的各个结点互不连通,后驱结点均在同一层。 通过...
  • 多段图最短路径

    2019-11-03 20:27:48
    设是一个赋权有向,其顶点集V被划分为个不相交子集,其中,V1和Vk分别只有一个顶点s(称为源)和一个顶点t(称为汇),所有边(u,v)始点和终点都在相邻两个子集Vi和Vi+1中:, 且边(u,v)有一个正权重,记为....
  • 对于一般加权图,Bellman-Ford计算单源点最短路径时间复杂度为O(VE),斐波那契堆优化后Dijkstrs为O(E+VLogV) ...同样这个方法可以解决多段图问题多段图属于DAG。 初始化dist[]={INF,INF,...} and
  • 现实场景也非常的多,比如,你想从A地到D地,但有很条路径可以到达,中间要经过中转,每一路花费时间都不一样,那么找到一条路径,让从A到D花费时间最短,就是一个最短路径问题。抽象一下就是一个有权...
  • 动态规划--多段图最短路径

    千次阅读 2017-10-29 12:50:17
    问题描述:设是一个赋权有向,其顶点集V被划分为个不相交子集,其中,V1和Vk分别只有一个顶点s(称为源)和一个顶点t(称为汇),所有边(u,v)始点和终点都在相邻两个子集Vi和Vi+1中:, 且边(u,v)有一个正...
  • 多段图的最小成本问题 实验要求 设G=(V,E)是一个赋权有向图,其顶点集V被划分成k>2个不相交的子集Vi: 1ik,其中,V1和Vk分别只有一个顶点s(称为源)和一个顶点t(称为汇),图中所有的边(u,v)的始点和终点都在相邻的两...
  • 一个图G=(V,E)是多段图,是指顶点集V划分成k个互不相交子集Vi,使得E中任意一条边(u,v)必有u,v属于两个不同子集。A是源点,E是终点。 1 动态规划 1.1 动态规划逆序解法 从后向前,E->A。next数组储存路径上...
  • 最短路径 Floyd算法 王道考研/ Robert WFloyd Floyd算法Floyd-Warshall算法 堆排序算法 罗伯特弗洛伊德 1936 2001Robert WFloyd 1978年图灵奖得主 王道考研/ Floyd算法 Floyd算法求出每对顶点之间的最短路径 ...
  • 时间在做寻路算法,发现网上有关Floyd教程虽然很详细,但是结果却有误差,搜了很帖子,核心算法都是这样一行代码: for(k=0;k  for(i=0;i  for(j=0;j  if(A[i][j]>(A[i][k]+A[k][j])){  A[i][j]=...
  • 1、路由表 ...SPF路由:最短路径路由,每个路由器都维护有自己的网路,以便计算自身与其他节点之间的最短路径来更新其路由表。//paths最短路径生成的数,每个节点包含d 和父节点信息;destination:
  • 即就是类似于百度地图路径规划问题,小编研究了一时间,并参考了相关资料,基于postgresql+postgis+pgrouting实现了简单路径规划,计算结果是组成最短路径的所有线路集合,话不说,直接上主要存储过程...
  • 关于几何最值问题研究老师很,本人以前也有文章论述,本文在此基础上再次进行归纳总结,把各种知识、方法、思想、策略进行融合提炼、追本溯源、认祖归宗,以使解决此类问题时更加简单明晰。一、基本图形所有问题...

空空如也

空空如也

1 2 3 4 5 6
收藏数 103
精华内容 41
关键字:

多段图的最短路径问题