1. La representación básica del gráfico:
G (V, E) representa el gráfico, V es el nodo del vector y E es el borde.
La lista de adyacencia se usa a menudo para representar gráficos dispersos, y la matriz de adyacencia a menudo representa gráficos densos, Donde la matriz de adyacencia se usa a menudo cuando la escala del gráfico es pequeña, porque la matriz es simple.
La suma de las longitudes de las listas vinculadas adyacentes de 2|E|gráficos no dirigidos es, y la suma de las longitudes de las listas vinculadas adyacentes de gráficos dirigidos es |E|.
2. BFS de búsqueda en amplitud primero:
BFS es el algoritmo más básico para resolver la ruta más corta sin gráfico de peso .
El problema de ruta más corta de fuente única basado en él es el problema de resolución de ruta más corta de gráficos ponderados , y la solución es el algoritmo Dijkstra (basado en la mejora de BFS).
Una vez que el algoritmo encuentra todos los nodos cuya distancia desde el nodo fuente s es k, encontrará otros nodos cuya distancia desde el nodo fuente s es k + 1.
Nota: La primera búsqueda de amplitud es unaBúsqueda jerárquicaEn el proceso, cada paso hacia adelante puede visitar un lote de vértices, a diferencia de la búsqueda en profundidad, no hay retroceso, por lo que no es un algoritmo recursivo. Para lograr el acceso capa por capa,El algoritmo debe usar una cola auxiliar para registrar la siguiente capa de vértices que se visitan。
Al mismo tiempo, es necesario guardar el estado del acceso al nodo (para evitar accesos repetidos), Si está en forma de matriz de adyacencia, use una matriz para guardar el estado de acceso al nodo; si está en forma de lista vinculada de adyacencia, aumente los atributos de nodo en la lista vinculada node.accessed = true.
2.1. Código C ++ de búsqueda primero en amplitud representado por matriz de adyacencia:
use una matriz para guardar el estado de acceso al nodo
const int MaxNum = 10; // 图的大小10X10
int G[MaxNum ][MaxNum ]; // 表示图 ,顶点为数字0-9，此部分要随题变化
int visited[MaxNum ] = {
0}; // 保存访问状态
int route[MaxNum ] ={
-1}; //记录路径
queue<int> q; // 记录待访问节点
void BFS(int* G,int start) // 输入图与搜索起点，起点类型随题目而变
{
visited[start] = 1;
route[start] = -1; //源头，-1表示已经没有路了
q.push(start);
while(!q.empty()){
int tmpnode = q.front();
q.pop();
for(int i = 0;i<MaxNum;i++){
if(G[tmpnode][i] = 1 && visited[i] == 0){
//1代表连接（有路）
//当两节点间连接且没访问过则进行处理：加入待放问列表
route[i] = tmpnode; //路的来源
q.push(i);
visited[i] = 1;
}
}
}
}
//输出起点start到任一点的路径：
void route(int start, int end)
{
vector<int> route_start_end;
while( end !=-1){
route_start_end.push_back(end);
end = route[end];
}
for(int i = route_start_end.size()-1;i>=0;i--){
std::cout<<route_start_end[i];
}
}
2.2. El código C ++ de búsqueda primero en amplitud representado por la lista vinculada de adyacencia:
también puede agregar el atributo visitado al nodo en lugar de la matriz visitada
struct ListNode {
int val;
struct ListNode *next;
ListNode(int x) : val(x), next(NULL) {
}
}
const int MaxNum = 10; // 图的大小10X10
ListNode* G[MaxNum]; // 图,假设已经构造好了
void BFS(ListNode* G,int start) // 输入图与搜索起点，起点类型随题目而变
{
int visited[MaxNum ] = {
0}; // 保存访问状态
int route[MaxNum ] ={
-1}; //记录路径
queue<ListNode*> q; // 记录待访问节点
q.push(G[start]); //起点入队
visited[start] = 1; //标识起点已经访问
while(!q.empty()){
ListNode* tmp = q.front();
q.pop();
while(tmp->next != null){
if(visited[tmp->next->val]!=1){
q.push(tmp->next);
visited[tmp->next->val] = 1;
route[tmp->next->val] =tmp->val; //记录路径
}
tmp = tmp->next;
}
}
}
2.3. Búsqueda en amplitud primero para mapas que no son unicom:
void BFSall(ListNode* G)
{
for(int i = 0；i<MaxNum;i++){
if(visited[i]!=1){
BFS(G,i); // 若这个节点未访问过说明与其他节点不连通，从此节点开始再调用BFS
}
}
}
Materiales de referencia:
bueno: análisis de algoritmo de primera búsqueda en amplitud (BFS) y búsqueda en profundidad (DFS) de gráficos,
implementación de C ++ en amplitud primero
3. Búsqueda en
profundidad : la búsqueda en profundidad es similar al recorrido de un árbol por pedido anticipado.Necesita una matriz para registrar los nodos visitados y, al mismo tiempo, utilizar la recursividad para volver al nodo predecesor cuando se hayan visitado todos los nodos.
3.1. Código C ++ de búsqueda en profundidad primero representado por matriz de adyacencia:
int visited[MaxNum] = {
0}; // 保存访问状态
void DFS(int* G,int start)
{
visit(start); // 可以是输出、记录父节点等任何操作
visited[start] = 1;
for(int i = 0;i<MaxNum;i++){
if(G[start][i]!=0 && visited[i]!=1){
DFS(G,i);
}
}
}
3.2. Código C ++ de búsqueda en profundidad primero representado por una lista vinculada por adyacencia:
int visited[MaxNum] = {
0}; // 保存访问状态
void DFS(ListNode* G,int start) //start为访问起点
{
visit(start); // 可以是输出、记录前驱节点等任何操作
visited[start] = 1;
ListNode* head = G[start];
while(head){
ListNode* tmp = head->next;
if(tmp && visited[tmp->val]!=1){
//若节点存在且未访问，则递归进入
DFS(G,tmp->val);
}
head = tmp; //否则就退回源节点，转到链表其余节点
}
}
Material de referencia: análisis de algoritmos de gráficos de primera búsqueda en amplitud (BFS) y búsqueda en profundidad primero (DFS)
para resumir:
1. La búsqueda en amplitud es similar al recorrido de secuencia. Se necesita una cola para almacenar los nodos que se visitarán y un atributo para identificar el estado de acceso del nodo. Para guardar la ruta del nodo, también se requiere una matriz de ruta.
2. La búsqueda en profundidad es similar al recorrido de preorden, implementado por recursividad.
3. El punto de partida de la búsqueda BFS y DFS es incierto, por lo que generalmente es necesario encontrar el punto de partida primero al resolver problemas.
4. Se puede utilizar el algoritmo de búsqueda de amplitudEncuentra el camino más corto.