图的路径问题

图的路径

• 路径问题
• Dijkstra算法

路径问题

在图的相关问题当中,我们经常会遇到路径问题,即在图中某两个节点之间的距离.
这个距离也许并不仅仅是相隔的节点数,也有可能代表一些其他的值,比如距离,时间.

此时广度优先搜索(BFS)是一种不错的选择.广度优先搜索按照层次逐层处理节点,这为我们计算顶点到某一节点的距离提供了便利.
我给出一个简单的实现方案:

class BFSTest {
public:
    map<string, vector<string>> pointList;
    map<string, bool> pointVisitted;

    //有向图
    void initPointList(vector<pair<string,string>> path) {
        pointList.clear();
        for (size_t i = 0; i < path.size(); i++) {
            if(pointList[path[i].first] == pointList.end()){
                vector<string> temp;
                pointList[path[i].first] = temp;
            }
            pointList[path[i].first].push_back(path[i].second);
        }
    }

    void initVisitted() {
        for(auto it = pointVisitted.begin(); it != pointVisitted.end(); it++) {
            it->second = false;
        }
    }

    int graphBFS(string begin, string end) {
        queue<pair<string,int>> findQueue;
        pair<string,int> node;
        findQueue.push(pair<string,int>(begin,0));

        while(!findQueue.empty()) {
            node = findQueue.front();
            findQueue.pop();
            pointVisitted[node.first] = true;
            for (size_t i = 0; i < pointList[node.first].size(); i++) {
                if(pointVisitted[pointList[node.first][i]] == false){
                    if(pointList[node.first][i] == end) {
                        return node.second + 1;
                    }
                    findQueue.push(pair<string,int>(pointList[node.first][i],node.second+1));
                }
            }
        }

        return -1;
    }

    int calcDistance(vector<pair<string,string>> path, vector<pair<string, string>> queries) {
        vector<int> results;
        initPointList(path);
        for (size_t i = 0; i < queries.size(); i++) {
            results.push_back(graphBFS(queries[i].first,queries[i].second));
        }
    }
}

Dijkstra算法

• 在实际应用中,我们遇到的问题可能比上面提到的要复杂的多.最直观的一个例子,节点之间的'距离'可能并不是我们在上文代码中实现的单位长度(也就是1).此时我们拥有的则是一个加权图.那么这种图的最短路径问题应该怎么解决呢?
• 让我们来想象这样一种情况,我们首先给出一道题.小明从A地出发,要去到D地.A到D之间的路径关系如下:

    A->B = 5
    A->C = 10
    B->D = 5
    C->D = 1

我们应该如何站在计算机的角度去考虑这个问题?闹钟算法是这么解决的,小米和朋友同时从A出发,去往可达的B,C.当小明到达B时,小明的朋友距离C还有5个单位距离.此时小明已经发现了D并向D走去.过了5个单位时间后小明已到达终点D,此时小明的朋友到达C点.

• 如果我们将题目中的距离关系改成这样呢?

    A->B = 5
    A->C = 8
    B->D = 10
    C->D = 2

按照刚才的思路,小明在从A到达B的时候,小明的朋友距离C还有3个单位距离.此时小明从B出发去往D.在3个单位距离的时间后,小明的朋友到达C,此时他从C出发去往D.在2个单位距离后小明的朋友到达D.此时小明距离D还有5个单位距离.

• 让我们概括一下刚才的思路:我们以时间为单位,在相同时间内我们沿每条路径移动相同的距离.每次到达新的节点的时候,我们都会停下来更新整个路径图.已经在走的路径长度被更新为剩余路径的长度,而新发现的路径则被加入到路径图中去.直到某一条路径到达终点为止.
  代码实现:

bool compare(const cityAndDistance a,const cityAndDistance b) {
    return a->second < b->second;
}

class shortestPath{
public:
    typedef pair<string, int> cityAndDistance;
    map<string, vector<cityAndDistance>> graph;
    map<string, cityAndDistance> prev;
    map<string, bool> visited;

    void initGraph(vector<pair<string, pair<string,int>>> path) {
        for (size_t i = 0; i < path.size(); i++) {
            if(graph.find(path[i].first) != graph.end()) {
                vector<cityAndDistance> temp;
                graph[path[i].first] = temp;
            }
            graph[path[i].first].push_back(cityAndDistance(path[i].second));
        }
    }

    //基于闹钟算法,每次到达一个新的节点就将已发现的节点距离更新.
    void update(map<string,int>& queuePri) {
        visited[first.first] = true;
        auto first = queuePri.begin();
        for(auto i = first+1;i != queuePri.end();i++){
            i->second -= first->second;
        }
    }

    //通过回溯找到最短路径
    vector<string> backtrack(string begin, string end) {
        vector<string> temp;
        temp.push_back(end);
        string nodeNow = end;
        while(nodeNow != begin) {
            nodeNow = prev[nodeNow].first;
            temp.insert(temp.begin(), nodeNow);
        }
        return backtrack;
    }

    vector<string> dijkstra(string begin, string end) {
        map<string,int> queuePri;
        queuePri[begin] = 0;
        while(!queuePri.empty()) {
            //到达最短的点.
            auto it = queuePri.begin();

            //更新所有节点距离信息
            update(queuePri);

            //找到最终节点
            if(it->first == end) {
                return backtrack(begin,end);
            }

            //更新可达节点信息
            for (size_t i = 0; i < graph[it->first].size(); i++) {
                //如果节点被访问过则去除这一节点.
                if(visited.find(graph[it->first][i].first)){
                    continue;
                }

                //发现新节点或者更短的路径
                if(queuePri.find(graph[it->first][i].first) != queuePri.end() || queuePri[graph[it->first][i].first] > graph[it->first][i].second) {
                    //更新新节点或者最短路径
                    queuePri[graph[it->first][i].first] = graph[it->first][i].second;
                    //绑定该节点与前驱节点,
                    prev[graph[it->first][i].first] = cityAndDistance(it->first, graph[it->first][i].second);
                }
            }

            //擦除已到达节点.
            queuePri.erase(it);
            //排序,使得每次最短的节点都在begin位置.
            sort(queuePri.begin(),queuePri.end(),compare);
        }
        return vector<string>();
    }

    vector<string> findShortestPath(vector<pair<string, string, int>> path) {
        initPointList(path);
        return dijkstra(begin, end);
    }
}