分析过后你就会发现这是典型的**

拿到手发现还真不好走，

我们发现随着我们走，后边的路径长度可能会影响之前我们选好的路径

因此我们想了想，还是保存一下当前的路径长度，再每次遇到下一条路的话，比较一下，选取前两条中最短的一条，这不就保证每次都是最短的吗？？

所以典型的动态规划！！！

//考虑： 原地出发还真不好出发，天知道后边的路怎么样
// 写完代码发现其实都一样，也可以从原点出发
//那么 我们从目的地出发，因为必须要到达目的地
//我们每走一步都保存一下当前的最优解

class Solution {
public:
    int minPathSum(vector<vector<int>>& grid) {
    //考虑： 原地出发还真不好出发，天知道后边的路怎么样
    int length = grid.size();
    int width  = grid[0].size();
    if(length < 1 || width < 1)
        return 0;
    vector<vector <int>>vv;
    vv.resize(length);
    for(int i =0; i<length; ++i )
        vv[i].resize(width);
    vv[length-1][width -1 ] = grid[length-1][width-1];
    //动态统计
    //既然我们反着走，所以只能从右边或下边来
    //1  处理下边界  下边界只能从 右边来
    int j = width -1; 
    for(int i = length-2; i >= 0; --i)
        vv[i][j] = grid[i][j] + vv[i+1][j]; 
        //if(length == 1)
          //  return vv[0][0];
    //2  处理右边界  右边界只能从下边界来
    int i = length-1;
    for(int j = width-2; j >= 0; --j)
        vv[i][j] = grid[i][j] + vv[i][j+1];
    //统计非边界  
    for(int i=length - 2; i >= 0; --i)
        for(int j=width-2; j >= 0; --j)
                vv[i][j] = grid[i][j] + 
                        min(vv[i+1][j], vv[i][j+1] );
    return vv[0][0];
                    题目描述：给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。说明：每次只能向下或者向右移动一步。示例:输入:[[1,3,1],[1,5,1],[4,2,1]]输出: 7解释: 因为路径 1→3→1→1→1 的总和最小。来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/...
				
提供的二维数字矩阵地图，从左上角出发，每次可以向下或向右走，直到到达右下角，途中经过的路径上的数字加起来，得到的数应该是一个最大的数1.输出路径及累计值2.提供二维数组的输入（文本文件导入或JS文件导入）3.输出每次搜索花的时间，比如：输入二维数组 输出结果 和 搜索用的时间4.最大二维数组为：200x200,最小二维数组为2x2;
【题目描述】1.例如，文本文件中内容如下：(如果采用JS编写，...
				
题目 给定一个矩阵m，从左上角开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，返回所有路径中最小的路径和。 例子： 给定m如下： 1 3 5 9 8 1 3 4 5 0 6 1 8 8 4 0 路径1,3,1,0,6,1,0是所有路径中路径和最小的，所以返回12。
使用动态规划，定义 dp[M][N] , M ,N 分别代表矩阵的行和列数...
				
迪杰斯特拉（Dijkstra）算法主要是针对没有负值的有向图，求解其中的单一起点到其他顶点的最短路径算法。
1 算法原理
迪杰斯特拉（Dijkstra）算法是一个按照路径长度递增的次序产生的最短路径算法。下图为带权值的有向图，作为程序中的实验数据。
其中，带权值的有向图采用邻接矩阵graph来进行存储，在计算中就是采用n*n的二维数组来进行存储，v0-v5表示数组的索引编号0-5，二维数组的值表示节点之间的权值，若两个节点不能通行，比如，v0->v1不能通行，那么graph[0,1]=+∞ （采用计算机中最大正整数来进行表示）。那如何求解从v0每个v节点的最短路径长度呢?
首先，引进一个
				
**题目：**首先输入一个（n,k）的值，其中n构成一个n*n的二维数字，而二维数字具体的参数则是1-k某一具体的值。问题是要找到遍历1…k这些所有值经过的最短路径。但是如果输入的二维数组缺少从0-k的某个值时，那么就没有最短路径。路径的求法是：比如aij和bij的路径是|ai-bi|+|aj-bj|。
1、输入部分就不多说了，做好之后建议输入输出测试一下，方便只有的调试。
2、关于找出最短路径的问题，刚开始想可以用回溯用递归，加上没有最短路径的问题，结果思路就很乱。于是就选择最简单最直接的这种方法
输入一个正整数组成的数组和一个正整数k，请问数组中和大于等于k的连续子数组的最短长度是多少，如果不存在所有数字之和大于或等于k的子数组，则返回0,。例如，输入数组[5,1,4,3],k的值为7，和大于等于7的最短连续子数组是[4,3],因此输出它的长度2。
这道题求连续子数组和大于等于7，需要两个指针，分别指向这个子数组首尾，最开始令两个数组指针指向数组第一个位置，比较这个子数组是否小于7，如果小于7移动右指针p2,直到两个指针之间的子数组数字之和为大于k,否则右移指针p1，直到两个指针之间
定义一个二维数组： int maze[n][m]; 它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角到右下角的最短路线。
输入描述：
一个5 × 5的二维数组，表示一个迷宫。数据保证有唯一解。
int maze[5][5] = {
0, 1, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 0, 0,
0, 1, 1, 1, 0,
0, 0, 0, 1, 0,
样式输出：
(0,0)
给定一个二维数组map[4][4] ={{1,3,5,9},{8,1,3,4},{5,0,6,1},{8,8,4,0}}。求从左上角到右下角的最短路径和。即从左上到右下二维数组中元素之和最小的组合。
应用场景：
导航地图中从规划起点位置到终点位置的最短路程。
该问题为一个经典的动态规划问题，所以先分析它...
看到这道题是不是感觉无从下手，这就对了，还是让我们一起分析分析吧。
根据题目我们首先要确定的是最短路径是那一条，根据我们在图上比划来比划去，最后我们发现只是向右或者向下走到出口的位置，这个就一定是最短路径,而且最短路径就是等于 m+n。
把刚刚的.
				
Floyd算法是一种动态规划算法，用于求解所有点对之间的最短路径。其基本思想是利用动态规划的思想，对于图中的任意两个顶点，如果它们之间有边相连，则它们之间的最短路径就是这条边的权值；如果它们之间没有边相连，则可以通过一个中间顶点来连接它们，这时需要计算它们通过这个中间顶点的路径长度，并取其中的最小值作为它们之间的最短路径长度。
具体实现时，可以使用一个二维数组来存储任意两个顶点之间的最短路径长度，初始时，这个数组的值就是图中各个边的权值。然后，对于每个中间顶点，依次计算它与其他顶点之间的路径长度，并更新最短路径数组的值。最终，这个数组中存储的就是所有点对之间的最短路径长度。
以下是Floyd算法的示例代码：
```python
def floyd(graph):
    n = len(graph)
    dist = graph.copy()
    for k in range(n):
        for i in range(n):
            for j in range(n):
                if dist[i][j] > dist[i][k] + dist[k][j]:
                    dist[i][j] = dist[i][k] + dist[k][j]
    return dist
其中，graph是一个邻接矩阵，表示图中各个边的权值；dist是一个二维数组，表示任意两个顶点之间的最短路径长度。