第三周作业（图论--BFS与DFS相关）

第三周作业（图论–BFS与DFS相关）

目录：

• 本周完成题目
• 主要过程思路
• 相关代码
• 感想与总结

一、本周完成题目

本周共完成2道题目，2道Medium。针对于本周所学的知识选择了Graph分类下的题目。 Graph

具体完成题目及难度如下表：

#	Title	Difficulty
207	Course Schedule	Medium
399	Evaluate Division	Medium

题目内容

1、Course Schedule　
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.

题目大意：有n门可选课程，从0到n-1编号。其中课程之间存在先后顺序关系，问满足先后顺序的情况下课程是否都能上完。

2、Evaluate Division
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 ].

题目大意：给定几组除法关系，如A/B=k。根据所给关系计算出所问除法关系的答案。（无法计算则输出-1）

二、主要过程思路

这两道题都是图论相关的题目，可以使用BFS（广度优先搜索）或者DFS（深度优先搜索）算法进行处理。

BFS：

其英文全称是Breadth First Search，对于某个顶点s，算法会首先搜索和s距离为k的所有顶点，然后再去搜索和S距离为k+l的其他顶点。类似于逐层搜索的情况。以下图为例，如从A开始。则会继续搜索B、C。然后再下一层，搜索F、D、E。

DFS：

其英文全称为Depth First Search，图的深度遍历原则：访问一个邻接的未访问的节点，标记它，并把它放入栈中。当不能再访问时，如果栈不为空，则从栈中弹出一个元素。直到所有元素都被访问到，遍历结束。
以下图为例，如从A开始，首先访问B、F，之后访问C、D。最后访问E。

Course Schedule

本题的问题可以进行转化，实质上是求有向图是否有环存在，若存在则返回false，不存在则返回true。在读入数字之后建立一个邻接表，之后对于从0开始的每个元素进行逐次判断，看以该数字起始的子元素中是否存在环。
本题在这一部分使用的是DFS，对于每个数字进行遍历。
首先对于数字状态进行设定。
（1）visit[i]=0，说明i未被遍历过；
（2）visit[i]=-1，说明i正在遍历中，即i为当前元素的前置元素；
（3）visit[i]=1，说明i已经遍历完成且没有出现环。
遍历具体规则如下：

    1.当前数字没有子元素，visit[i]标记为1，return true。
    2.当前数字有子元素，对于每个子元素，判断该元素的visit值是否为-1，若为-1，说明产生了环，return false。
    若为0，说明子元素未被访问过，标记为-1，对该元素继续进行DFS。若为1，跳过该元素。
    3.遍历完所有子元素则标记该元素为1，代表已经完成子元素的遍历且不存在环。

Evaluate Division

首先，使用map存储每个元素和剩余其他元素之间的商。之后对于要求的式子进行判断，两个元素有不存在的元素，返回-1；两个元素存在且相同，返回1；否则，需要进行遍历判断两个元素是否存在递进的商的关系。
本题使用的是BFS算法。假设最后要求的式子是s1/s2。以s1作为搜索起点，进行广度优先遍历，每次将所有的子元素都压到队列中，同时更新每个子元素的商，遍历完一个节点的子元素后该节点商置为-1。
逐层遍历，若找到s2则返回相乘结果。若没有找到则返回-1。

三、相关代码

Course Schedule

class Solution {
public:
    bool canFinish(int numCourses, vector<pair<int, int> >& prerequisites) {
       vector<vector<int> > graph(numCourses);  //保存邻接表
       for(int i = 0; i < prerequisites.size(); ++ i){
           int s1=prerequisites[i].first,s2=prerequisites[i].second;
           graph[s1].push_back(s2);
       }
        int visit[numCourses] = { 0 };
        for (int i=0;i<numCourses;i++) {
            if(visit[i]!=1){
               if(!DFS(graph,i,visit)){
                return false;
                }
            }
        }
        return true;
    }
    //DFS部分，递归遍历
    bool DFS(vector<vector<int> > &graph, int current, int *visit) {
        if (graph[current].size() == 0) {  
            visit[current] = 1; //当前数字没有子元素，标记为1
            return true;
        }
        visit[current] = -1;   //表示正在遍历中
        //遍历子元素
        for (int i = 0; i < graph[current].size(); i++) {
            int index = graph[current][i];
            if (visit[index] == -1) {
                return false;    //遍历到正在遍历的元素中，环出现
            } else if (visit[index] == 0) {
                visit[index] = -1;
                if (!DFS(graph, graph[current][i], visit)) {
                    return false;
                }
            } else {
                continue;
            }

        }
        visit[current] = 1;  //遍历完成
        return true;
    }
};

Evaluate Division

class Solution {
public:
    vector<double> calcEquation(vector<pair<string, string> > equations, vector<double>& values, vector<pair<string, string> > queries) {
        vector<double> result;
        //使用map存储每个元素和剩余其他元素之间的商
        map<string,map<string,double> > graph;
        for(int i=0;i<values.size();i++){
            string s1 = equations[i].first, s2 = equations[i].second;
            graph[s1].insert(map<string,double>::value_type(s2,values[i]));
            graph[s2].insert(map<string,double>::value_type(s1,1/values[i]));
        }
        for(int i=0;i<queries.size();i++){
            string s1 = queries[i].first, s2 = queries[i].second;
            if(graph.find(s1)==graph.end()||graph.find(s2)==graph.end()){
                result.push_back(-1.0);    //两个元素有不存在的元素，返回-1
            }else if(s1==s2){
                result.push_back(1.0);  //两个元素存在且相同，返回1
            }else{
                result.push_back(BFS(s1,s2,graph)); //利用BFS计算结果
            }
        }
        return result;
    }
    double BFS(string s1,string s2,map<string,map<string,double> > graph){
        int len=graph.size();
        map<string,double> visit;  //用于保存从s1到其他元素的商
        queue<string> q;
        q.push(s1);
        visit.insert(map<string,double>::value_type(s1,1));
        while(!q.empty()){
            string str=q.front();
            q.pop();
            double num=visit[str];
            if(num==-1){
                continue;
            }
            map<string,double>::iterator   my_Itr;
            if(graph[str].find(s2)!=graph[str].end()){
                return graph[str][s2]*num;    
            }
            //将当前元素的子元素压入队列，计算到子元素的总共的商
            for(my_Itr=graph[str].begin();   my_Itr!=graph[str].end();   ++my_Itr)   {
                q.push(my_Itr->first);
                visit.insert(map<string,double>::value_type(my_Itr->first,my_Itr->second*num));
            }
            visit[str]=-1;   //标记已遍历过的元素
        }
        return -1;
    }
};

四、感想与总结

本周主要进行了图论中BFS和DFS的练习，通过具体的题目对于这两种遍历算法都进行了复习。在弄懂了题目之后相对而言还是比较简单的。但是在做第一题的时候出现了Memory Limited的问题。这是由于开始的时候使用了map形式且没有进行引用调用，空间损耗比较大。