精华内容
下载资源
问答
  • 最短路径问题---Dijkstra算法详解

    万次阅读 多人点赞 2017-03-08 16:42:46
    前言 Nobody can go back and start a new beginning,but anyone ...1、最短路径问题介绍 问题解释: 从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径,称为最短路径 解决问题的算法:...

    前言
    Nobody can go back and start a new beginning,but anyone can start today and make a new ending.
    Name:Willam
    Time:2017/3/8

    1、最短路径问题介绍

    问题解释:
    从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径,称为最短路径

    解决问题的算法:

    这篇博客,我们就对Dijkstra算法来做一个详细的介绍

    2、Dijkstra算法介绍

    • 算法特点:

      迪科斯彻算法使用了广度优先搜索解决赋权有向图或者无向图的单源最短路径问题,算法最终得到一个最短路径树。该算法常用于路由算法或者作为其他图算法的一个子模块。

    • 算法的思路

      Dijkstra算法采用的是一种贪心的策略,声明一个数组dis来保存源点到各个顶点的最短距离和一个保存已经找到了最短路径的顶点的集合:T,初始时,原点 s 的路径权重被赋为 0 (dis[s] = 0)。若对于顶点 s 存在能直接到达的边(s,m),则把dis[m]设为w(s, m),同时把所有其他(s不能直接到达的)顶点的路径长度设为无穷大。初始时,集合T只有顶点s。
      然后,从dis数组选择最小值,则该值就是源点s到该值对应的顶点的最短路径,并且把该点加入到T中,OK,此时完成一个顶点,
      然后,我们需要看看新加入的顶点是否可以到达其他顶点并且看看通过该顶点到达其他点的路径长度是否比源点直接到达短,如果是,那么就替换这些顶点在dis中的值。
      然后,又从dis中找出最小值,重复上述动作,直到T中包含了图的所有顶点。

    3、Dijkstra算法示例演示

    下面我求下图,从顶点v1到其他各个顶点的最短路径

    这里写图片描述

    首先第一步,我们先声明一个dis数组,该数组初始化的值为:
    这里写图片描述

    我们的顶点集T的初始化为:T={v1}

    既然是求 v1顶点到其余各个顶点的最短路程,那就先找一个离 1 号顶点最近的顶点。通过数组 dis 可知当前离v1顶点最近是 v3顶点。当选择了 2 号顶点后,dis[2](下标从0开始)的值就已经从“估计值”变为了“确定值”,即 v1顶点到 v3顶点的最短路程就是当前 dis[2]值。将V3加入到T中。
    为什么呢?因为目前离 v1顶点最近的是 v3顶点,并且这个图所有的边都是正数,那么肯定不可能通过第三个顶点中转,使得 v1顶点到 v3顶点的路程进一步缩短了。因为 v1顶点到其它顶点的路程肯定没有 v1到 v3顶点短.

    OK,既然确定了一个顶点的最短路径,下面我们就要根据这个新入的顶点V3会有出度,发现以v3 为弧尾的有: < v3,v4 >,那么我们看看路径:v1–v3–v4的长度是否比v1–v4短,其实这个已经是很明显的了,因为dis[3]代表的就是v1–v4的长度为无穷大,而v1–v3–v4的长度为:10+50=60,所以更新dis[3]的值,得到如下结果:
    这里写图片描述

    因此 dis[3]要更新为 60。这个过程有个专业术语叫做“松弛”。即 v1顶点到 v4顶点的路程即 dis[3],通过 < v3,v4> 这条边松弛成功。这便是 Dijkstra 算法的主要思想:通过“边”来松弛v1顶点到其余各个顶点的路程。

    然后,我们又从除dis[2]和dis[0]外的其他值中寻找最小值,发现dis[4]的值最小,通过之前是解释的原理,可以知道v1到v5的最短距离就是dis[4]的值,然后,我们把v5加入到集合T中,然后,考虑v5的出度是否会影响我们的数组dis的值,v5有两条出度:< v5,v4>和 < v5,v6>,然后我们发现:v1–v5–v4的长度为:50,而dis[3]的值为60,所以我们要更新dis[3]的值.另外,v1-v5-v6的长度为:90,而dis[5]为100,所以我们需要更新dis[5]的值。更新后的dis数组如下图:
    这里写图片描述

    然后,继续从dis中选择未确定的顶点的值中选择一个最小的值,发现dis[3]的值是最小的,所以把v4加入到集合T中,此时集合T={v1,v3,v5,v4},然后,考虑v4的出度是否会影响我们的数组dis的值,v4有一条出度:< v4,v6>,然后我们发现:v1–v5–v4–v6的长度为:60,而dis[5]的值为90,所以我们要更新dis[5]的值,更新后的dis数组如下图:
    这里写图片描述

    然后,我们使用同样原理,分别确定了v6和v2的最短路径,最后dis的数组的值如下:
    这里写图片描述

    因此,从图中,我们可以发现v1-v2的值为:∞,代表没有路径从v1到达v2。所以我们得到的最后的结果为:

    起点  终点    最短路径    长度
    v1    v2     无          ∞    
          v3     {v1,v3}    10
          v4     {v1,v5,v4}  50
          v5     {v1,v5}    30
          v6     {v1,v5,v4,v6} 60
    

    4、Dijkstra算法的代码实现(c++)

    • Dijkstra.h文件的代码
    /************************************************************/
    /*                程序作者:Willam                          */
    /*                程序完成时间:2017/3/8                    */
    /*                有任何问题请联系:2930526477@qq.com       */
    /************************************************************/
    //@尽量写出完美的程序
    
    #pragma once
    //#pragma once是一个比较常用的C/C++杂注,
    //只要在头文件的最开始加入这条杂注,
    //就能够保证头文件只被编译一次。
    
    #include<iostream>
    #include<string>
    using namespace std;
    
    /*
    本程序是使用Dijkstra算法实现求解最短路径的问题
    采用的邻接矩阵来存储图
    */
    //记录起点到每个顶点的最短路径的信息
    struct Dis {
        string path;
        int value;
        bool visit;
        Dis() {
            visit = false;
            value = 0;
            path = "";
        }
    };
    
    class Graph_DG {
    private:
        int vexnum;   //图的顶点个数
        int edge;     //图的边数
        int **arc;   //邻接矩阵
        Dis * dis;   //记录各个顶点最短路径的信息
    public:
        //构造函数
        Graph_DG(int vexnum, int edge);
        //析构函数
        ~Graph_DG();
        // 判断我们每次输入的的边的信息是否合法
        //顶点从1开始编号
        bool check_edge_value(int start, int end, int weight);
        //创建图
        void createGraph();
        //打印邻接矩阵
        void print();
        //求最短路径
        void Dijkstra(int begin);
        //打印最短路径
        void print_path(int);
    };
    
    • Dijkstra.cpp文件的代码
    #include"Dijkstra.h"
    
    //构造函数
    Graph_DG::Graph_DG(int vexnum, int edge) {
        //初始化顶点数和边数
        this->vexnum = vexnum;
        this->edge = edge;
        //为邻接矩阵开辟空间和赋初值
        arc = new int*[this->vexnum];
        dis = new Dis[this->vexnum];
        for (int i = 0; i < this->vexnum; i++) {
            arc[i] = new int[this->vexnum];
            for (int k = 0; k < this->vexnum; k++) {
                //邻接矩阵初始化为无穷大
                    arc[i][k] = INT_MAX;
            }
        }
    }
    //析构函数
    Graph_DG::~Graph_DG() {
        delete[] dis;
        for (int i = 0; i < this->vexnum; i++) {
            delete this->arc[i];
        }
        delete arc;
    }
    
    // 判断我们每次输入的的边的信息是否合法
    //顶点从1开始编号
    bool Graph_DG::check_edge_value(int start, int end, int weight) {
        if (start<1 || end<1 || start>vexnum || end>vexnum || weight < 0) {
            return false;
        }
        return true;
    }
    
    void Graph_DG::createGraph() {
        cout << "请输入每条边的起点和终点(顶点编号从1开始)以及其权重" << endl;
        int start;
        int end;
        int weight;
        int count = 0;
        while (count != this->edge) {
            cin >> start >> end >> weight;
            //首先判断边的信息是否合法
            while (!this->check_edge_value(start, end, weight)) {
                cout << "输入的边的信息不合法,请重新输入" << endl;
                cin >> start >> end >> weight;
            }
            //对邻接矩阵对应上的点赋值
            arc[start - 1][end - 1] = weight;
            //无向图添加上这行代码
            //arc[end - 1][start - 1] = weight;
            ++count;
        }
    }
    
    void Graph_DG::print() {
        cout << "图的邻接矩阵为:" << endl;
        int count_row = 0; //打印行的标签
        int count_col = 0; //打印列的标签
        //开始打印
        while (count_row != this->vexnum) {
            count_col = 0;
            while (count_col != this->vexnum) {
                if (arc[count_row][count_col] == INT_MAX)
                    cout << "∞" << " ";
                else
                cout << arc[count_row][count_col] << " ";
                ++count_col;
            }
            cout << endl;
            ++count_row;
        }
    }
    void Graph_DG::Dijkstra(int begin){
        //首先初始化我们的dis数组
        int i;
        for (i = 0; i < this->vexnum; i++) {
            //设置当前的路径
            dis[i].path = "v" + to_string(begin) + "-->v" + to_string(i + 1);
            dis[i].value = arc[begin - 1][i];
        }
        //设置起点的到起点的路径为0
        dis[begin - 1].value = 0;
        dis[begin - 1].visit = true;
    
        int count = 1;
        //计算剩余的顶点的最短路径(剩余this->vexnum-1个顶点)
        while (count != this->vexnum) {
            //temp用于保存当前dis数组中最小的那个下标
            //min记录的当前的最小值
            int temp=0;
            int min = INT_MAX;
            for (i = 0; i < this->vexnum; i++) {
                if (!dis[i].visit && dis[i].value<min) {
                    min = dis[i].value;
                    temp = i;
                }
            }
            //cout << temp + 1 << "  "<<min << endl;
            //把temp对应的顶点加入到已经找到的最短路径的集合中
            dis[temp].visit = true;
            ++count;
            for (i = 0; i < this->vexnum; i++) {
                //注意这里的条件arc[temp][i]!=INT_MAX必须加,不然会出现溢出,从而造成程序异常
                if (!dis[i].visit && arc[temp][i]!=INT_MAX && (dis[temp].value + arc[temp][i]) < dis[i].value) {
                    //如果新得到的边可以影响其他为访问的顶点,那就就更新它的最短路径和长度
                    dis[i].value = dis[temp].value + arc[temp][i];
                    dis[i].path = dis[temp].path + "-->v" + to_string(i + 1);
                }
            }
        }
    
    }
    void Graph_DG::print_path(int begin) {
        string str;
        str = "v" + to_string(begin);
        cout << "以"<<str<<"为起点的图的最短路径为:" << endl;
        for (int i = 0; i != this->vexnum; i++) {
            if(dis[i].value!=INT_MAX)
            cout << dis[i].path << "=" << dis[i].value << endl;
            else {
                cout << dis[i].path << "是无最短路径的" << endl;
            }
        }
    }
    • main.cpp文件的代码
    #include"Dijkstra.h"
    
    
    //检验输入边数和顶点数的值是否有效,可以自己推算为啥:
    //顶点数和边数的关系是:((Vexnum*(Vexnum - 1)) / 2) < edge
    bool check(int Vexnum, int edge) {
        if (Vexnum <= 0 || edge <= 0 || ((Vexnum*(Vexnum - 1)) / 2) < edge)
            return false;
        return true;
    }
    int main() {
        int vexnum; int edge;
    
        cout << "输入图的顶点个数和边的条数:" << endl;
        cin >> vexnum >> edge;
        while (!check(vexnum, edge)) {
            cout << "输入的数值不合法,请重新输入" << endl;
            cin >> vexnum >> edge;
        }
        Graph_DG graph(vexnum, edge);
        graph.createGraph();
        graph.print();
        graph.Dijkstra(1);
        graph.print_path(1);
        system("pause");
        return 0;
    }

    输入:

    6 8
    1 3 10
    1 5 30
    1 6 100
    2 3 5
    3 4 50
    4 6 10
    5 6 60
    5 4 20

    输出:
    这里写图片描述

    从输出可以看出,程序的结果和我们之前手动计算的结果是一样的。

    展开全文
  • Python 相对路径问题:“No such file or directory

    万次阅读 多人点赞 2019-08-04 09:59:09
    如果你取相对路径不是在主文件里,可能就会有相对路径问题:"No such file or directory"。 因为 python 的相对路径,相对的都是主文件。 main.py 是主文件。 conf.py 里引用 config.txt 用相对路径。 如果用 . ...

    如果你取相对路径不是在主文件里,可能就会有相对路径问题:"No such file or directory"
    因为 python 的相对路径,相对的都是主文件
    如下目录结构:

    | -- main.py
         | -- conf.py
         | -- start.png
    | -- config.txt
    

    main.py 是主文件。
    conf.py 里引用 config.txt 用相对路径。
    如果用 .. . 相对的是 main.py,所以用 "./config.txt",相对于 main.py 是同一个目录下。
    . 指当前文件所在的文件夹,. . 指当前文件的上一级目录。
    喜欢的点个赞❤吧!

    展开全文
  • 最短路径问题---Floyd算法详解

    万次阅读 多人点赞 2017-03-11 17:01:37
    Time:2017/3/81、最短路径问题介绍问题解释: 从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径,称为最短路径解决问题的算法: 迪杰斯特拉算法(Dijkstra算法) 弗洛伊德算法(Floyd算法...

    前言
    Genius only means hard-working all one’s life.
    Name:Willam
    Time:2017/3/8

    1、最短路径问题介绍

    问题解释:
    从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径,称为最短路径

    解决问题的算法:

    之前已经对Dijkstra算法做了介绍(不懂的可以看这篇博客:Dijkstra算法详解),所以这篇博客打算对Floyd算法做详细的的介绍。

    2、Floyd算法的介绍

    • 算法的特点:
      弗洛伊德算法是解决任意两点间的最短路径的一种算法,可以正确处理有向图或有向图或负权(但不可存在负权回路)的最短路径问题,同时也被用于计算有向图的传递闭包。

    • 算法的思路

    通过Floyd计算图G=(V,E)中各个顶点的最短路径时,需要引入两个矩阵,矩阵S中的元素a[i][j]表示顶点i(第i个顶点)到顶点j(第j个顶点)的距离。矩阵P中的元素b[i][j],表示顶点i到顶点j经过了b[i][j]记录的值所表示的顶点。

    假设图G中顶点个数为N,则需要对矩阵D和矩阵P进行N次更新。初始时,矩阵D中顶点a[i][j]的距离为顶点i到顶点j的权值;如果i和j不相邻,则a[i][j]=∞,矩阵P的值为顶点b[i][j]的j的值。 接下来开始,对矩阵D进行N次更新。第1次更新时,如果”a[i][j]的距离” > “a[i][0]+a[0][j]”(a[i][0]+a[0][j]表示”i与j之间经过第1个顶点的距离”),则更新a[i][j]为”a[i][0]+a[0][j]”,更新b[i][j]=b[i][0]。 同理,第k次更新时,如果”a[i][j]的距离” > “a[i][k-1]+a[k-1][j]”,则更新a[i][j]为”a[i][k-1]+a[k-1][j]”,b[i][j]=b[i][k-1]。更新N次之后,操作完成!

    3、Floyd算法的实例过程

    上面,我们已经介绍了算法的思路,如果,你觉得还是不理解,那么通过一个实际的例子,把算法的过程过一遍,你就明白了,如下图,我们求下图的每个点对之间的最短路径的过程如下:

    这里写图片描述

    第一步,我们先初始化两个矩阵,得到下图两个矩阵:
    这里写图片描述

    这里写图片描述

    第二步,以v1为中阶,更新两个矩阵:
    发现,a[1][0]+a[0][6] < a[1][6] 和a[6][0]+a[0][1] < a[6][1],所以我们只需要矩阵D和矩阵P,结果如下:

    这里写图片描述

    这里写图片描述

    通过矩阵P,我发现v2–v7的最短路径是:v2–v1–v7

    第三步:以v2作为中介,来更新我们的两个矩阵,使用同样的原理,扫描整个矩阵,得到如下图的结果:

    这里写图片描述
    这里写图片描述

    OK,到这里我们也就应该明白Floyd算法是如何工作的了,他每次都会选择一个中介点,然后,遍历整个矩阵,查找需要更新的值,下面还剩下五步,就不继续演示下去了,理解了方法,我们就可以写代码了。

    4、Floyd算法的代码实现

    • Floyd.h文件代码
    /************************************************************/
    /*                程序作者:Willam                          */
    /*                程序完成时间:2017/3/11                   */
    /*                有任何问题请联系:2930526477@qq.com       */
    /************************************************************/
    //@尽量写出完美的程序
    
    #pragma once
    //#pragma once是一个比较常用的C/C++杂注,
    //只要在头文件的最开始加入这条杂注,
    //就能够保证头文件只被编译一次。
    
    /*
    本博客开始对Floyd算法的使用邻接矩阵实现的
    */
    
    #include<iostream>
    #include<string>
    using namespace std;
    
    class Graph_DG {
    private:
        int vexnum;   //图的顶点个数
        int edge;     //图的边数
        int **arc;   //邻接矩阵
        int ** dis;   //记录各个顶点最短路径的信息
        int ** path;  //记录各个最短路径的信息
    public:
        //构造函数
        Graph_DG(int vexnum, int edge);
        //析构函数
        ~Graph_DG();
        // 判断我们每次输入的的边的信息是否合法
        //顶点从1开始编号
        bool check_edge_value(int start, int end, int weight);
        //创建图
        void createGraph(int);
        //打印邻接矩阵
        void print();
        //求最短路径
        void Floyd();
        //打印最短路径
        void print_path();
    };
    
    
    • Floyd.cpp文件代码
    #include"Floyd.h"
    
    
    //构造函数
    Graph_DG::Graph_DG(int vexnum, int edge) {
        //初始化顶点数和边数
        this->vexnum = vexnum;
        this->edge = edge;
        //为邻接矩阵开辟空间和赋初值
        arc = new int*[this->vexnum];
        dis = new int*[this->vexnum];
        path = new int*[this->vexnum];
        for (int i = 0; i < this->vexnum; i++) {
            arc[i] = new int[this->vexnum];
            dis[i] = new int[this->vexnum];
            path[i] = new int[this->vexnum];
            for (int k = 0; k < this->vexnum; k++) {
                //邻接矩阵初始化为无穷大
                arc[i][k] = INT_MAX;
            }
        }
    }
    //析构函数
    Graph_DG::~Graph_DG() {
    
        for (int i = 0; i < this->vexnum; i++) {
            delete this->arc[i];
            delete this->dis[i];
            delete this->path[i];
    
        }
        delete dis;
        delete arc;
        delete path;
    }
    
    // 判断我们每次输入的的边的信息是否合法
    //顶点从1开始编号
    bool Graph_DG::check_edge_value(int start, int end, int weight) {
        if (start<1 || end<1 || start>vexnum || end>vexnum || weight < 0) {
            return false;
        }
        return true;
    }
    
    void Graph_DG::createGraph(int kind) {
        cout << "请输入每条边的起点和终点(顶点编号从1开始)以及其权重" << endl;
        int start;
        int end;
        int weight;
        int count = 0;
        while (count != this->edge) {
            cin >> start >> end >> weight;
            //首先判断边的信息是否合法
            while (!this->check_edge_value(start, end, weight)) {
                cout << "输入的边的信息不合法,请重新输入" << endl;
                cin >> start >> end >> weight;
            }
            //对邻接矩阵对应上的点赋值
            arc[start - 1][end - 1] = weight;
            //无向图添加上这行代码
            if(kind==2)
            arc[end - 1][start - 1] = weight;
            ++count;
        }
    }
    
    void Graph_DG::print() {
        cout << "图的邻接矩阵为:" << endl;
        int count_row = 0; //打印行的标签
        int count_col = 0; //打印列的标签
                           //开始打印
        while (count_row != this->vexnum) {
            count_col = 0;
            while (count_col != this->vexnum) {
                if (arc[count_row][count_col] == INT_MAX)
                    cout << "∞" << " ";
                else
                    cout << arc[count_row][count_col] << " ";
                ++count_col;
            }
            cout << endl;
            ++count_row;
        }
    }
    
    void Graph_DG::Floyd() {
        int row = 0;
        int col = 0;
        for (row = 0; row < this->vexnum; row++) {
            for (col = 0; col < this->vexnum; col++) {
                //把矩阵D初始化为邻接矩阵的值
                this->dis[row][col] = this->arc[row][col];
                //矩阵P的初值则为各个边的终点顶点的下标
                this->path[row][col] = col;
            }
        }
    
        //三重循环,用于计算每个点对的最短路径
        int temp = 0;
        int select = 0;
        for (temp = 0; temp < this->vexnum; temp++) {
            for (row = 0; row < this->vexnum; row++) {
                for (col = 0; col < this->vexnum; col++) {
                    //为了防止溢出,所以需要引入一个select值
                    select = (dis[row][temp] == INT_MAX || dis[temp][col] == INT_MAX) ? INT_MAX : (dis[row][temp] + dis[temp][col]);
                    if (this->dis[row][col] > select) {
                        //更新我们的D矩阵
                        this->dis[row][col] = select;
                        //更新我们的P矩阵
                        this->path[row][col] = this->path[row][temp];
                    }
                }
            }
        }
    }
    
    void Graph_DG::print_path() {
        cout << "各个顶点对的最短路径:" << endl;
        int row = 0;
        int col = 0;
        int temp = 0;
        for (row = 0; row < this->vexnum; row++) {
            for (col = row + 1; col < this->vexnum; col++) {
                cout << "v" << to_string(row + 1) << "---" << "v" << to_string(col+1) << " weight: "
                    << this->dis[row][col] << " path: " << " v" << to_string(row + 1);
                temp = path[row][col];
                //循环输出途径的每条路径。
                while (temp != col) {
                    cout << "-->" << "v" << to_string(temp + 1);
                    temp = path[temp][col];
                }
                cout << "-->" << "v" << to_string(col + 1) << endl;
            }
    
            cout << endl;
        }
    }
    
    • main.cpp文件的代码
    #include"Floyd.h"
    
    
    //检验输入边数和顶点数的值是否有效,可以自己推算为啥:
    //顶点数和边数的关系是:((Vexnum*(Vexnum - 1)) / 2) < edge
    bool check(int Vexnum, int edge) {
        if (Vexnum <= 0 || edge <= 0 || ((Vexnum*(Vexnum - 1)) / 2) < edge)
            return false;
        return true;
    }
    int main() {
        int vexnum; int edge;
        cout << "输入图的种类:1代表有向图,2代表无向图" << endl;
        int kind;
        cin >> kind;
        //判读输入的kind是否合法
        while (1) {
            if (kind == 1 || kind == 2) {
                break;
            }
            else {
                cout << "输入的图的种类编号不合法,请重新输入:1代表有向图,2代表无向图" << endl;
                cin >> kind;
            }
        }
    
        cout << "输入图的顶点个数和边的条数:" << endl;
        cin >> vexnum >> edge;
        while (!check(vexnum, edge)) {
            cout << "输入的数值不合法,请重新输入" << endl;
            cin >> vexnum >> edge;
        }
        Graph_DG graph(vexnum, edge);
        graph.createGraph(kind);
        graph.print();
        graph.Floyd();
        graph.print_path();
        system("pause");
        return 0;
    }

    输入:

    2
    7 12
    1 2 12
    1 6 16
    1 7 14
    2 3 10
    2 6 7
    3 4 3
    3 5 5
    3 6 6
    4 5 4
    5 6 2
    5 7 8
    6 7 9 

    输出:

    这里写图片描述

    展开全文
  • 【vue】npm run build打包路径问题

    万次阅读 2018-06-08 12:31:07
    直接插入主体 额不 主题 我的vue脚手架目录结构如下 有个config文件夹,在index.js中有两个方法一个开发dev,一个生产build。...一:Vue打包js,css等的路径问题 我们打包自然要设置build中的代码了。下...

    直接插入主 额不 主题

    我的vue脚手架目录结构如下
    这里写图片描述
    有个config文件夹,在index.js中有两个方法一个开发dev,一个生产build

    • dev: 是我们的开发环境,资源使用绝对路径,所以可以正常看到背景图片
    • build: 是我们的生产环境,资源使用相对路径,所以会报错

    一:Vue打包js,css等的路径问题

    我们打包自然要设置build中的代码了。下面是修改后的状态,箭头指向的地方之前是assetsPublicPath: '/'
    这里写图片描述

    二:Vue打包背景图片路径问题

    背景图片的路径需要找到Vue目录结构中的build文件夹,里面有个utils.js
    这里写图片描述
    这里我们要设置utils.js
    这里写图片描述
    这段代码是将css从打包中单独提取出来作为一个文件夹。

    箭头指向的publicPath:'../../' 是我手填上去的,开始这里是没有这一项的,可以看到这个if判断的上面有两个英文注释,翻译一下就是:在指定该选项时提取CSS(在生产过程中是这样的)。添加上这条地址路径之后,你在看看你的背景图有没有出来。

    三:Vue打包 路由设置mode:history,打包后页面空白

    想去掉地址的#,应该难看(挖坑中),最后打包的时候,页面一直是空白的,路径怎么看都没问题了,然后求助大佬,扫描出这个的问题,去掉之后问题就解决了(Amazing.gif)。

    **更新:VueCli 3 **

    由于 vue-cli 3 项目初始化后,没有了 build 目录,webpack.base.config.js、webpack.dev.config.js 、webpack.prod.config.js 等配置文件。而是需要自己在更目录下创建一个vue.config.js
    vue.config配置文档
    在这里插入图片描述
    修改路径同vue2.一样修改publicPath

    展开全文
  • idea中Java Web项目的访问路径问题

    万次阅读 多人点赞 2018-05-08 18:38:00
    这里只以 servlet 为例,没有涉及到框架,但其实路径的基本原理和框架的关系不大,所以学了框架的同学如果对路径有疑惑的也可以阅读此文 项目结构 在 idea 中新建一个 Java Web 项目,项目的初始结构如下 ( 不同版本...
  • matlab解决最短路径问题

    千次阅读 2019-08-23 10:04:55
    最短路径问题写在前面两种表示方法minpath的安装minpath的使用 写在前面 最短路径问题是图论研究中的一个经典算法问题。 它旨在寻找图(由结点和路径组成的)中两结点之间的最短路径。 这次主要是提供一个解决最短...
  • QT文件路径问题

    万次阅读 2018-12-09 15:57:04
     在项目中我们经常会遇到文件路径问题,如QFile file(“text.txt”)加载不成功、QPixmap(&quot;…/1.bmp&quot;) 加载图像不成功等问题。  在能成功加载文件、图像之前,我们必须要弄清楚两个概念:绝对...
  • 动态规划解决最短路径问题

    千次阅读 2020-08-15 16:00:30
    最短路径问题(Shortest path problem):再不回退的前提下,找到A到F的最短路径 3.6.2 算法思路 A到B1的最短路径为4,前序节点为A; A到B2的最短路径为5,前序节点为A; A到C1的最短路径,我们可以看出,只有B1可以...
  • Python 读取文件时的路径问题 .

    万次阅读 多人点赞 2017-05-28 10:32:40
    Python在读取文件内容时的路径问题,值得深究一下.我想讨论的重点还是在绝对路径上面.在这之前我们先看一下1:相对路径.这张图演示了在相对路径下寻找查找指定文件. open('相对路径演示'\'相对路径示例'.txt)打开...
  • 最短路径问题---SPFA算法详解

    万次阅读 多人点赞 2017-03-12 15:14:35
    1、最短路径问题介绍 问题解释: 从图中的某个顶点出发到达另外一个顶点的所经过的边的权重和最小的一条路径,称为最短路径 解决问题的算法: 迪杰斯特拉算法(Dijkstra算法) 弗洛伊德算法(Floyd算法) SPFA....
  • 上传文件时服务器路径问题

    千次阅读 2018-02-02 15:44:51
    在上传文件到服务器上时,上传到服务器的文件不能在指定目录下获取,主要是在java代码中设置的文件路径问题。 获取本地路径的几种方式 1.项目目录下建立excel文件夹存入上传文件 1.1得到当前的classpath的绝对...
  • pycharm导入路径问题

    千次阅读 2018-07-25 21:10:32
    pycharm导入路径问题 博主在导入自定义模块式出现模块下有红色波浪线,如下: 例如from conf import setting 导入时会从当前目录下找找到youkuClient就不会再往下找了,所以引入模块的路径不能夸路径,否则及就...
  • 理解上下文路径问题

    千次阅读 2019-09-02 09:37:31
    1,理解上下文路径问题。 在ssm架构时需要在JSP页面的资源请求路径写上下文路径,什么是上下文路径?因为项目部署到tomcat服务器的webapps文件夹下。项目的war包会被自动解压,解压后的文件夹名即项目名就是上下文...
  • 数据结构最短路径问题

    千次阅读 2019-05-27 09:53:35
    在带权有向图G中,给定一个源点v,求从v到G中的其余各顶点的最短路径问题,叫做单源点的最短路径问题。 在常用的单源点最短路径算法中,迪杰斯特拉算法是最为常用的一种,是一种按照路径长度递增的次序产生最短...
  • springboot文件上传保存路径问题

    千次阅读 2019-04-27 22:51:16
    springboot文件上传保存路径问题 最近使用springboot整合富文本编辑器wangeditor,在整合的时候,对于图片上传时候保存路径出现了一些问题,代码如下 @PostMapping("/upload") public Result upload...
  • 相对路径与绝对路径 这个是tomcat里面设置的路径:http://localhost:8080/stu/ ****只要是servlet里面的设置的urlPatterns路径,前面都要加上/,这个是必须的要求。 例如: @WebServlet(name = “StudentPageServlet...
  • webpack打包路径问题,生成相对路径

    万次阅读 2017-02-23 17:22:19
    webpack打包路径问题,生成相对路径 这里用我们用vue-cli脚手架生成项目举例,go=> 1,找到config文件夹下面的index.js 2, 3,把箭头所指的/去掉 —–搞定 对于所有webpack的同理,只要把打包输出路径的/...
  • Problem : 最短路径问题 欢迎各个大佬前来指教! 问题描述: 平面上有n个点(n&amp;amp;amp;lt;=100),每个点的坐标均在-10000~10000之间。其中的一些点之间有连线。若有连线,则表示可从一个点到达另一个点,...
  • Qt中路径问题小结

    万次阅读 多人点赞 2016-10-16 16:43:02
    在做Qt项目的时候,我们难免遇到到文件路径问题。如QFile file("text.txt")加载不成功、 QPixmap("../text.png") 加载图片不成功等等。今天就来做一个关于Qt路径问题的小结! 首先需要弄清楚两个概念:绝对路径与...
  • ckfinder+ckeditor 路径问题
  • 最短路径问题

    万次阅读 2014-04-30 10:08:22
    今天把老王的2011年课件又看了一遍,给大二的孩子们又讲了一遍,随手谷歌了N多资料,算是彻底搞懂了最短路径问题。请读者尽情享用……  我坚信:没有不好的学生,只有垃圾的教育。不过没有人理所当然的对你好,...
  • 关于springmvc中的controller里面的转发和重定向问题和路径问题
  • 工作中遇到路径问题的总结:一般来说,批处理文件处理相对路径的时候,起始位置是bat文件所在的目录,比如在D:\XX目录下执行bat文件,所有相对目录的操作都会以D:\XX下执行。 例如: 打开当前路径下的文件夹: .\...
  • Java 算法:最短路径问题

    千次阅读 2019-04-24 16:34:29
    最短路径问题适合于有向图与无向图: 应用: 路径规划:每个顶点就是城市,边就是道路。 工作任务:从一个点起始任务到另一个点任务完成,边就是完成任务的耗费。 例如无权图的广度优先遍历:结果就是求出了一...
  • 贪心算法之单源最短路径问题

    万次阅读 多人点赞 2018-08-19 21:19:17
    该问题称为单源最短路径问题。 基本思想:Dijkstra算法(迪杰斯特拉算法)是解单源最短路径问题的贪心算法。 Dijkstra算法特点:以起始点为中心向外层层扩展,直到扩展到终点为止,是一种广度优先搜索方法。 ...
  • 相对路径下 使用FileOutputStream写入文件(系统找不到路径问题) 标题java.io默认定位到当前用户目录 java.io默认定位到当前用户目录(“user.dir”)下,即:工程根目 录"D:\MyWork\ideaProjects\...
  • 使用Google colab 路径问题报错记录

    千次阅读 多人点赞 2020-07-27 20:08:43
    使用Google colab 路径问题报错记录 遇到问题 当使用colab训练yolov4代码时遇到了一个错误(其实以前也遇到过一样的错误,不过忘记怎么解决了) FileNotFoundError: [Errno 2] No such file or directory: '/content...
  • window上vs2017 opencv图片路径问题(附3种加载路径方法) 图片路径 问题 解决方式 去掉
  • thinkphp5 关于加载静态资源路径问题

    万次阅读 2017-10-11 16:23:44
    thinkphp5 关于加载静态资源路径问题 大于5.0.4版本可以直接使用 __ROOT__ 项目目录 __STATIC__ 项目目录下的static目录 __JS__ 项目目录下的static/js目录 __CSS__项目目录下的static/css目录

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,998,217
精华内容 799,286
关键字:

路径问题