建图与搜索(代码补充)

栈
• Tarjan算法需要用到的结构：栈 • 栈是一种“先入后出”的结构 • 有以下几种操作： #include<stack> using namespace std; stack<int> s; s.push(x);//将元素x加入栈中 s.top();//读取栈顶元素 s.pop();//删除栈顶元素 s.size();//返回栈中元素个数 s.empty()//判断栈是否为空，若为空，返回true,否 则，返回false
割点
• 同样用tarjan算法进行标记，但是low(u)的含义为： u或者u的子树中能够通过非父子边追溯到的最早 的节点的DFS开始时间。（非父子边是为了防止 由子节点回搜到父节点） • 判定是否是割点的条件是看它是否存在这样的子 节点：子节点的low值大于等于它本身的dfn值。 新增加的强连通分量等于存在这样节点的个数。 不过要注意，起始点的这个值需要-1。子节点还 需要满足一个性质，就是它与父亲节点的那条边 必须是标号的时候搜索过的
• • • • • • • • • • • • • • • • • • • • •
bool vst[35][35]; char a[35][35]; int dir[4][2]={0,1,0,-1,1,0,-1,0}; //定义方向向量 int cont;//记录个数 bool CheckEdge(int x,int y){//判断是否满足条件 if(!vst[x][y] && a[x][y]=='.') return 1; else return 0; } void dfs(int x,int y){ vst[x][y]=1;//标记是否进行过访问 if(a[x][y]=='.'){ cont++; } for(int i=0;i<4;i++){//对周围四个方向进行深度优先搜索 if(CheckEdge(x+dir[i][0],y+dir[i][1])) dfs(x+dir[i][0],y+dir[i][1]); } return; }
Kosaraju算法： 1.深度优先遍历G，算出每个结 点u的结束时间f[u],起点如何选 择无所谓。 2.深度优先遍历G的转置图GT （转置图的定义：将有向图G中 的每一条边反向形成的图称为G 的转置GT。注意到原图和GT的 强连通分支是一样的），选择 遍历的起点时，按照结点的结 束时间从大到小进行。遍历的 过程中，一边遍历，一边给结 点做分类标记，每找到一个新 的起点，分类标记值就加1。 3.第2步中产生的标记值相同的 结点构成深度优先森林中的一 棵树，也即一个强连通分量。
• 深度优先搜索 • 由根节点开始，向子 节点进行搜索，直到 没有子节点为止，回 溯到上一层节点，如 果上一层节点的子节 点都搜索完了，继续 回溯。 • 搜索顺序： E,F,J,G,H,K,I
院赛题目B:学园都市
输入由“.”,“@”,“*”组成n行m列的地图，问从 @出发，每次可以向周围四个方向移动， 最多可以经过几个“.”？ 典型的深度优先搜索的题目，n，m<=30的小 数据可以进行搜索。
2.用邻接矩阵建图 用a[i][j]表示从点i到点j的路程长度（权值等） 好处：可以很容易的表示出每两个节点之间 的路径，也可以记录权值。 缺点：遍历的时候很费时间，空间占用量非 常大。 int a[20vector不但和数组一样可以对元素进行随机访问， 还能在尾部插入元素。完全可以替代数组。 • vector具有内存自动管理的功能，对于元素的插 入和删除，可以动态调整所占内存空间。 • vector需要头文件包含申明include<vector>。 • vector同数组一样，也是从下标0开始计数的。 • vector容器有两个重要的方法，begin（）和end （）。begin（）返回的是首元素位置的迭代器； end（）返回的是最后一个元素的下一元素位置 的迭代器。
• Vector支持下标访问方式且从0开始计数， 例如：v={1,4,5,7}，则v[0]=1,v[3]=7。 • 遍历vector中的元素： • for（i=0;i<v.size();i++）（注意这个位置不 能加等号，否则会越界） if(v[i]==……)…… 还可以使用迭代器来遍历vector中的元素， vector<int>:: iterator it,定义it为迭代器。 for(it=v.begin();it!=v.end();it++) if(*it==……)……
Vector存图代码
• for(i=1;i<=n;i++){//输入n条边 • scanf(“%d %d”,&a,&b);//输入每条边的起 点和终点 • v[a].push_back(b);//将b存入v[a]中 • } • 经过n次此操作，v[i]里面的元素即表示点i 可以连接的点
• • • • •
搜索
• 分为广度优先搜索（BFS）和深度优先搜索 （DFS）。 • 广度优先搜索利于求最短路，它是一种先 生成的节点先扩展的策略。 • 深度优先搜索需求空间少，能进则进，进 不了则换，换不了则退，回溯的一种策略。
队列
• 广度优先搜索需要用到一个结构：队列。 • 队列是一种“先入先出”的存储结构。 • 有以下几种操作： #include<queue> using namespace std; queue<int> d; d.push(x)(插入元素x)； d.pop()(删除队首元素); d.front()(读取队首元素)； d.empty()(判断队列是否为空，是，返回true，否， 返回false)；
first 1 2 5 -1
next -1 -1
3
4 5
-1
4 -1
2
1 3
• 存图 scanf(“%d%d”,&b[i].start,&b[i].end); next[i]=first[b[i].start]; first[b[i].start]=i; • 遍历 k=first[i]; While(k!=-1){ ……(相关操作); k=next[k]; }
Tarjan算法代码实现 • void Tarjan(u) { • dfn[u]=low[u]=++index;//对于未访问的点做赋初值处理 • stack.push(u);//将元素u加入栈中 • for each (u, v) in E {//对于u的每一个子节点进行遍历（伪代码），不同的存图方式， 采用不同的遍历方式 • if (v is not visted) {//如果该子节点未访问 • tarjan(v) ;//对子节点访问 • low[u] = min(low[u], low[v]);//更新low值 • } • else if (v in stack) {//如果该节点被访问过且在栈中 • low[u] = min(low[u], dfn[v]) //更新low值 • } • } • if (dfn[u] == low[u]) { //u是一个强连通分量的根 • number++;//新的强连通分量 • } • do{ • v = stack.top(); //取出栈顶元素 • stack.pop();//删除栈顶元素 • v[number].push_back(v);//将元素v加入第number个强连通分量中 • }while(u!= v); //直到取到u为止（包括u） • } //复杂度是O(E+V)的
问题： (0,2) (0,3) 求从左上角(0,0)到 右下角(3,3)的最短 (1,2) (1,3) 距离，红色坐标点 为不可到达的点。
(2,2) (2,3) (3,2) (3,3)
14
BFS的遍历方式
(0,0) 0 (1,0) 1 (2,0) 2 (3,0) 3 (0,1) 1 (1,1) 2 (2,1) 3 (3,1) 4 (0,2) (0,3) 5 Queue (1,2) 3 (1,3) 4 (1,3,4) (1,0,1) (3,0,3) (1,1,2) (2,0,2) (0,1,1) (1,2,3) (0,3,5) (3,1,4) (2,1,3) (2,3,5) (2,2) (2,3) 5 (3,2) (3,3) 6
15
(3,3,6) (0,0,0)
(0,0)
(0,1)
(1,1)
(1,0)
(2,0)
0 1 2
…
16
这个性质非常重要! 保证了最先被搜索到的解一定 是最优解!
…
对于点(1,1)而言，为 什么不再从点(1,2)得 到(1,1)的新状态(1,1,4) 并重新入队?
17
剪枝
即去掉已被证明不可能某些状态， 不再对其进行扩展搜索，节省时间 若判断得到此分支是不存在解 和空闲。 的分支，则不对其进行搜索。
Tarjan算法
• DFN(u)为节点u搜索的次序编号(时间戳). • Low(u)为u或u的子树能够追溯到的最早的 栈中节点的次序号。 • low(u) = min(low(u),low(v)),v为u的子节点。 • 回溯时，若low(u)=dfn(u),则将栈中u以前的 元素全部取出，这些元素构成一个强连通 分量
Vector的基本操作
• #include<vector>（头文件） • using namespace std;（c++） • vector<（vector中存的变量类型）> v （vector的名称）; • 增加一个元素：v.push_back(x);将x增加到 v中。 • 清空：v.clear(); v.begin()和v.end()会分别返回开始和结束的 地址，v.size()会返回里面元素的个数。
图的基础与搜索