广度优先搜索与深度优先搜索

   广度优先搜索使用的是步步为营的策略，每执行一步循环就会把所有可能的情况加入队列，直到调出循环。适用于求最短的问题。

   深度优先搜索则是依次遍历每一种情况，直至找到问题的解。

   深度优先搜索和广度优先搜索都属于穷竭法。在运行内存空间上面，广度优先搜索与情况数成正比，而深度优先搜索与递归深度成正比。

   

#include <iostream>
#include <queue>
using namespace std;
int G[100][100];
int D[100];
int P[100];
bool M[100];
void BFS(int G[][],int D[],int P[],int M[],int s)
{
int n;//n个点
for(int i=1;i<n;i++)
{
M[i]=true;
}

D[s]=0;
M[s]=false;
queue<int> Q;
Q.push(s);

while(!Q.empty())
{
int u=Q.front();
Q.pop();

for(int v=1;v<=n;v++)
if(G[u][v]>0&&M[v])
{
Q.push(v);
M[v]=false;
P[v]=u;
D[v]=D[u]+1;
}
}
}

void print_path(int P[],int s,int v)
{
if(s==v)
{
cout<<s;
return;
}
else
{
print_path(P,s,P[v]);
cout<<v;
}
}

#include <iostream>
using namespace std;
int G[100][100];
bool M[100];
int D[100];
int F[100];
int P[100];
int time=0;
void DFS(int G[][],int M[])
{
for(int i=1;i<=100;i++)
M[i]=true;

for(int u=1;u<=100;u++)
if(M[u]) dfs_visit(G,u);
}
void dfs_visit(int G[][],int u)
{
time+=1;
D[u]=time;
M[u]=false;

for(int v=1;v<=100;v++)
{
if(M[v]&&G[u][v]>0)
{
P[v]=u;
dfs_visit(G,v);
}
}

time+=1;
F[u]=time;
}

队列：#include<queue>

申请队列：queue<type>q;

判队空：q.empty();

获取队头元素：q.front()；

入队：q.push();

出出队：q.pop();

a  

 

  栈：#include<stack>

  申请栈：stack<type>s;

  入栈：s.push();

  出栈：s.pop();

  获取栈顶元素：s.top();

  判栈空：s.empty();