算法导论 第22章 图的基本算法（二） 深度优先搜索

深度优先搜索（DFS）

    本篇博客主要讨论有向图的深度优先搜索，包括递归形式以及非递归形式，遍历中对图的各边进行分类，同时解决该节书后习题。

     DFS与BFS的异同：当扫描顶点u的邻接链表发现v时，就将u置为v的祖先，这一点与BFS相同；与此不同的是，在BFS中，先辈子图形成一棵树，而DFS的先辈子图可以有几棵树组成，即成为一个森林，因为搜索可以从多个不同的源顶点开始。

     除了可能创建一个深度优先森林外，对于各顶点的访问，我们都加上时间戳并标上合适的颜色。刚开始时对于所有顶点，颜色均为白色，表示均未被访问；搜索中，对于顶点u，当第一次访问时将其置为灰色，并打上时间戳d[u]，在后续搜索结束对u的访问时将其置为黑色，并打上时间戳f[u]。显然时间戳将会是1~2|V|之间的一个数，因为对于每个顶点都会有一个开始访问时刻和结束访问时刻，且有：d[u] < f[u]。

     顶点在d[u]之前，为白色；在d[u]和f[u]之间将会是灰色;在f[u]之后将一直为黑色。因此可以看出，灰色顶点带式整个搜索的分界线，是正在被访问的顶点，在此之前，是已经访问完毕的黑色顶点，在此之后，是未被访问的白色顶点。

   

约定：

    1、边节点结构

struct edgeNode
{//边节点
	size_t adjvertex;//该边的关联的顶点
	edge e;//边类型
	int weight;//边权重
	edgeNode *nextEdge;//下一条边
	edgeNode(size_t adj, int w) :adjvertex(adj), weight(w),e(GRAPH),nextEdge(nullptr){}
};

    2、顶点结构

struct vertex
{
	size_t c;//颜色
	size_t d, f;//访问开始和结束时间
	size_t p;//父亲
	vertex() :c(WHITE), p(NOPARENT), d(0), f(0){}
};

    3、有向图数据成员

class AGraph
{//图
private:
	vector<edgeNode*> E;
	vector<vertex> V;
	size_t nodenum;
};

    4、关于顶点编号。所有顶点将用数字1,2,3...编号，按图的顺时间方向标注；对于图的两个vector成员均从索引1开始存入数据，且索引i对应地是顶点i的相关信息，一是为了便于后续算法实现，二是0可以用作它途，比如表示没有祖先NOPARENT。

边类型的分类

    根据访问过程中遇到的顶点的颜色以及时间戳可以将边分为四类，如下：

对于边(u,v)，我么将根据v的颜色以及两者的时间戳将其分为四类，

1、树边(tree edge)：v是白色，则边(u,v)是树边；

2、反向边(back edge):v是灰色，因为v是灰色表明正在搜索v的后裔，而现在由u又能搜索到v，说明存在环，且边(u,v)指向了u的祖先v，因而是反向边；

3、正向边(forward edge)：v是黑色且d[u] < d[v],黑色表明v已经搜索完毕，d[u] < d[v]表明在搜索u过程中v已经被搜索完毕，那么v必是u的某个后裔的后裔，同时在图中又是u的直接后裔，u是其祖先。

4、交叉边(cross edge)：v是黑色且d[u] > d[v],v比u先搜索完毕，而且没有通过v搜索到u,表明在图中v不是u的祖先，现在通过u搜索到v，却已经为黑色，则(u,v)不可能为树边，那么在深度优先树中u也不可能是v的祖先，即在DFS树中，一个顶点不会是另一个顶点的祖先。另外，交叉边也可能存在于不同的优先树之间。

递归DFS完整代码

#include<iostream>
#include<fstream>
#include<vector>
#include<stack>

#define NOPARENT 0
using namespace std;
enum color{ WHITE, GRAY, BLACK };
enum edge{GRAPH, TREE, BACK, FORWARD, CROSS };

struct edgeNode
{//边节点
	size_t adjvertex;//该边的关联的顶点
	edge e;//边类型
	int weight;//边权重
	edgeNode *nextEdge;//下一条边
	edgeNode(size_t adj, int w) :adjvertex(adj), weight(w),e(GRAPH),nextEdge(nullptr){}
};

struct vertex
{
	size_t c;//颜色
	size_t d, f;//访问开始和结束时间
	size_t p;//父亲
	vertex() :c(WHITE), p(NOPARENT), d(0), f(0){}
};

class AGraph
{//图
private:
	vector<edgeNode*> E;
	vector<vertex> V;
	size_t nodenum;
	void DFS_aux(size_t u,size_t &time);
	void DFS_aux_Not_recursive(size_t u, size_t &time);
	void printEdge();//打印图的边类型
	void printVertex();//打印顶点信息
public:
	AGraph(size_t n) :nodenum(n)
	{
		E.resize(n + 1);
		V.resize(n + 1);
	}
	void initGraph();//初始化有向图
	void clearVertex()
	{//用于清除顶点状态
		for (size_t i = 1; i <= nodenum; ++i)
		{
			V[i].c = WHITE;
			V[i].p = NOPARENT;
			V[i].d = 0;
			V[i].f = 0;
		}
	}
	edgeNode* search(size_t, size_t);//查找边
	void addEdge(size_t, size_t, int);//有向图中添加边
	void DFS();
	void print();
	~AGraph();
};


void AGraph::initGraph()
{
	size_t start, end;
	ifstream infile("F:\\dfs.txt");
	while (infile >> start >> end)
		addEdge(start, end, 1);
}

edgeNode* AGraph::search(size_t start, size_t end)
{
	edgeNode *curr = E[start];
	while (curr != nullptr && curr->adjvertex != end)
		curr = curr->nextEdge;
	return curr;
}

void AGraph::addEdge(size_t start, size_t end, int weight = 1)
{
	edgeNode *curr = search(start, end);
	if (curr == nullptr)
	{
		edgeNode *p = new edgeNode(end, weight);
		p->nextEdge = E[start];
		E[start] = p;
	}
}

inline void AGraph::print()
{
	for (size_t i = 1; i != E.size(); ++i)
	{
		edgeNode *curr = E[i];
		cout << i;
		if (curr == nullptr) cout << " --> null";
		else
			while (curr != nullptr)
			{
				cout << " --> " << curr->adjvertex;
				curr = curr->nextEdge;
			}
		cout << endl;
	}
}

void AGraph::printEdge()
{
	for (size_t i = 1; i != E.size(); ++i)
	{
		edgeNode *curr = E[i];
		while (curr != nullptr)
		{
			cout << i << " --> " << curr->adjvertex;
			switch (curr->e)
			{
			case TREE:
				cout << " : TREE" << endl;
				break;
			case BACK:
				cout << " : BACK" << endl;
				break;
			case FORWARD:
				cout << " : FORWARD" << endl;
				break;
			case CROSS:
				cout << " : CROSS" << endl;
				break;
			}
			curr = curr->nextEdge;
		}
	}
}

void AGraph::printVertex()
{
	cout << "parent vector" << endl;
	for (size_t i = 1; i != E.size(); ++i)
		cout << V[i].p << ' ';
	cout << endl << "start time vector" << endl;
	for (size_t i = 1; i != E.size(); ++i)
		cout << V[i].d << ' ';
	cout << endl << "finish time vector" << endl;
	for (size_t i = 1; i != E.size(); ++i)
		cout << V[i].f << ' ';
	cout << endl;
}

void AGraph::DFS_aux(size_t u, size_t &time)
{
	V[u].c = GRAY;
	V[u].d = ++time;
	edgeNode *curr = E[u];
	while (curr != nullptr)
	{
		if (V[curr->adjvertex].c == WHITE)
		{
			curr->e = TREE;
			V[curr->adjvertex].p = u;
			DFS_aux(curr->adjvertex, time);
		}
		else if (V[curr->adjvertex].c == GRAY)
			curr->e = BACK;
		else
		{
			if (V[u].d < V[curr->adjvertex].d) curr->e = FORWARD;
			else curr->e = CROSS;
		}
		curr = curr->nextEdge;
	}
	V[u].c = BLACK;
	V[u].f = ++time;
}

void AGraph::DFS()
{
	size_t time = 0;
	for (size_t i = 1; i != E.size(); ++i)
		if (V[i].c == WHITE)
			DFS_aux(i, time);
	printVertex();
	printEdge();
}

AGraph::~AGraph()
{
	for (size_t i = 1; i != E.size(); ++i)
	{
		edgeNode *curr = E[i], *pre;
		while (curr != nullptr)
		{
			pre = curr;
			curr = curr->nextEdge;
			delete pre;
		}
	}
}

const int nodenum = 8;

int main()
{
	AGraph G(nodenum);
	G.initGraph();
	G.print();
	G.DFS();
	getchar();
	return 0;
}

对书中22-5的图从源点s开始顺时针标号，运行上述程序，得到下述结果

习题22.3-6 非递归的深度优先搜索（DFS）

    要消除递归，就需要引入一个栈。对于顶点u，在DFS完毕它的第一个邻接顶点之后，回来的时候应当能够记住该访问哪条边了，不能又从头开始搜寻，因此另外一个关键是引入一个数组vector，专门存储每个顶点下一次将要被访问的边，在程序代码中成为access_edge。

void AGraph::DFS_aux_Not_recursive(size_t u, size_t &time)
{
	stack<size_t> S;
	vector<edgeNode*> access_edge(E);//记下每个顶点下一条将被访问的边，初始时就等于E
	V[u].c = GRAY;
	V[u].d = ++time;
	S.push(u);
	while (!S.empty())
	{//只要栈不空，不断搜索
		size_t i = S.top();
		edgeNode *curr = access_edge[i];//得到顶点i当前将要被访问的边
		while (curr != nullptr)
		{//不断循环，直到访问到一个白节点，或者顶点i的所有邻接点已被访问
			if (V[curr->adjvertex].d == WHITE)
			{//与i相邻的是白节点，即未被访问过
				V[curr->adjvertex].c = GRAY;
				V[curr->adjvertex].p = i;
				V[curr->adjvertex].d = ++time;
				S.push(curr->adjvertex);//访问后入栈
				access_edge[i] = curr->nextEdge;//记下顶点i下一条将要被访问的边，开始DFS该邻接顶点
				break;
			}
			else curr = curr->nextEdge;
		}
		if (curr == nullptr)
		{//顶点i的所有邻接点已被访问，则出栈
			V[i].c = BLACK;
			V[i].f = ++time;
			S.pop();
		}
		//不要while循环的形式，用while是为了减少不必要的出栈和入栈
		/*if (curr != nullptr)
		{
			if (c[curr->adjvertex] == WHITE)
			{
				V[curr->adjvertex].c = GRAY;
				V[curr->adjvertex].p = i;
				V[curr->adjvertex].d = ++time;
				S.push(curr->adjvertex);
			}
			access_edge[i] = curr->nextEdge;
		}
		else
		{
			V[i].c = BLACK;
			V[i].f = ++time;
			S.pop();
		}*/
	}
}

习题22.3-9

    递归形式的DFS有修改，非递归的没有。

习题22.3-11

    给顶点数据结构加一个域cc，在DFS的每次for循环开始前，给予该源点一个k值，表明是第几个连通分支，在DFS_aux中，对于边(u,v)，若v是白色，则说明v和u处于同一分支，即cc[u] = cc[v]。

习题22.3-12

    判断是否存在正向边，若存在则说明非半联通，因为对于某个顶点v,存在某个顶点u到达它的路径不止一条，若没有正向边，则是半联通的。