图算法

图算法

1.关于拓扑序( 207. Course Schedule)

a.题意

There are a total of n courses you have to take, labeled from 0 to n - 1.

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]

Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?

For example:

2, [[1,0]]
There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.

2, [[1,0],[0,1]]
There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.

大概的题意就是，有0到n-1的课程然后要判断是否存在一个拓扑序，存在返回true，不存在返回false

b.思路分析

这是道拓扑序的题目，我们可以用这样一个算法，每次从图中去掉入度为0的点然后重复这一过程，直到移除所有点，如果中途发现不存在入度为0的点则说明存在回边那么没有拓扑序。

c.代码实现

我们用一个二维数组来存这个图，然后用inDegree数组表示图中每个点的入度，把入度为0的点依次放入队列，每次去掉队列头的点直至队列为空，判断最后一共删除多少点，和原先的点数作比较就可以知道是否有拓扑序了

class Solution {
public:
    bool canFinish(int numCourses, vector< pair<int, int> >& prerequisites) {
        bool myGraph[numCourses][numCourses];
        int inDegree[numCourses];
        memset(inDegree,0,sizeof(inDegree));
        memset(myGraph,0,(numCourses) * numCourses);
        for (int i = 0;i < prerequisites.size();i++)
        {
            myGraph[prerequisites[i].second][prerequisites[i].first] = true;
            inDegree[prerequisites[i].first]++;
        }
        std::queue<int> toDelete;
        for (int i = 0;i < numCourses;i++)
        {
            if (inDegree[i] == 0)
            {
                toDelete.push(i);
            }
        }
        if (toDelete.empty())
        {
            return false;
        }
        int count = toDelete.size();
        while (!toDelete.empty())
        {
            int top = toDelete.front();
            toDelete.pop();
            for (int i = 0;i < numCourses;i++)
            {
                if (myGraph[top][i])
                {
                    inDegree[i]--;
                    if (inDegree[i] == 0)
                    {
                        toDelete.push(i);
                        count++;
                    }
                }
            }
        }
        return (count == numCourses);
    }
};

2.关于点与点之间的距离( 399. Evaluate Division)

a.题意

Equations are given in the format A / B = k, where A and B are variables represented as strings, and k is a real number (floating point number). Given some queries, return the answers. If the answer does not exist, return -1.0.

Example:
Given a / b = 2.0, b / c = 3.0.
queries are: a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ? .
return [6.0, 0.5, -1.0, 1.0, -1.0 ].

The input is: vector

b.思路分析

可以把这个问题看成图的距离问题，把字符当成点，把字符间的倍数关系当成一个点到另一个点之间的距离，例如a/b=2，就是a到b距离为2，b到a距离为0.5，这样就是求两个点之间距离问题了，我们用一个map来存图，然后使用深度优先算法来求距离即可

c.代码实现

首先我用map来存这个图，map的键是一个点a，值是一个map，这个map的键值分别是a能到达的点以及对应边的长度

unordered_map

class Solution {
public:
    vector<double> calcEquation(vector<pair<string, string>> equations, vector<double>& values, vector<pair<string, string>> queries) {
        unordered_map<string,unordered_map<string,double>> myMap;
        for (int i = 0;i < values.size();i++)
        {
            myMap[equations[i].first].insert(make_pair(equations[i].second,values[i]));
            if(values[i] != 0)
                myMap[equations[i].second].insert(make_pair(equations[i].first,1 / values[i]));
        }
        std::vector<double> ans;
        for (auto i : queries)
        {
            std::set<string> visited;
            double temp = DFS(i.first,i.second,myMap,visited);
            ans.push_back(temp);
        }
        return ans;

    }
    double DFS(string start,string end,unordered_map<string,unordered_map<string,double>> &myMap,set<string> &visited)
    {
        if (myMap[start].find(end) != myMap[start].end())
        {
            return myMap[start][end];
        }
        visited.insert(start);
        for (auto i : myMap[start])
        {
            if (visited.find(i.first) == visited.end())
            {
                visited.insert(i.first);
                double temp = DFS(i.first,end,myMap,visited);
                if (temp != (-1.0))
                {
                    return i.second * temp;
                }
            }
        }
        return -1.0;
    }
};