Algoritm

1.Алгоритм обхода в глубину - https://habrahabr.ru/post/200074/
2.Алгоритм обхода в ширину - https://habrahabr.ru/post/200252/
3.Алгоритм Дейкстры - https://habrahabr.ru/post/111361/
4.Алгоритм Флойда — Уоршелла - https://habrahabr.ru/post/105825/
5.Алгоритм Джонсона - https://ru.wikipedia.org/wiki/Алгоритм_Джонсона
6.Алгоритм Ли(волновой алгоритм) - https://ru.wikipedia.org/wiki/Алгоритм_Ли
7.Алгоритм Беллмана — Форда - https://habrahabr.ru/post/201588/

1.https://sites.google.com/site/pythontutorarticles/obhod-v-glubinu 
  n = 10
  adj_list = [[2, 4, 6],
              [9],
              [0, 3],
              [2, 4],
              [0, 3],
              [],
              [0, 7, 8],
              [6],
              [6],
              [1]]
  s = 0

  visited = [False] * n  # массив "посещена ли вершина?"

  def dfs(v):
      visited[v] = True
      for w in adj_list[v]:
          if visited[w] == False:  # посещён ли текущий сосед?
              dfs(w)

  dfs(s)
  
2.https://codedump.io/share/B93FoSNifDL1/1/bfs-algorithm-in-python
    graph={ 0:[1,3,4], 1:[0,2,4], 2:[1,6], 3:[0,4,6], 4:[0,1,3,5], 5:[4], 6:[2,3] }
    def bfs(graph, start):
        path = []
        queue = [start]
        while queue:
          vertex = queue.pop(0)
          if vertex not in path:
            path.append(vertex)
            queue.extend(graph[vertex])
        return path
  print bfs(graph, 0) 

3.https://gist.github.com/ivan1911/5963571
  #!/usr/bin/env python
  # -*- coding: utf-8 -*-

  # Алгоритм Дейкстры
  #   Находит кратчайшее расстояние от одной из вершин графа до всех остальных. 
  #   Алгоритм работает только для графов без рёбер отрицательного веса.
  #   Матрица задается как список словарей смежности вершин
  # Описание алгоритма http://goo.gl/KsqC


  def dijkstra_shortest_path(graph, start, p={}, u=[], d={}):
      if len(p) == 0: p[start] = 0 # инициализация начального пути
      # print "start V: %d, " % (start)
      for x in graph[start]:
          if (x not in u and x != start):
              if (x not in p.keys() or (graph[start][x] + p[start]) < p[x]):
                  p[x] = graph[start][x] + p[start]

      u.append(start)

      min_v = 0
      min_x = None
      for x in p:
          # print "x: %d, p[x]: %d, mv %d" % (x, p[x], min_v)
          if (p[x] < min_v or min_v == 0) and x not in u:
                  min_x = x
                  min_v = p[x]

      if(len(u) < len(graph) and min_x):
          return dijkstra_shortest_path(graph, min_x, p, u)
      else:
          return p

  if __name__ == '__main__':
      # инициализация графа с помощью словаря смежности
      a, b, c, d, e, f, g, h = range(8)
      N = [
          {b: 7, c: 9, f: 14},
          {a: 7, c: 10, d: 15},
          {a: 9, b: 10, d: 11, f: 2},
          {b: 15, c: 11, e: 6},
          {d: 6, f: 9},
          {a: 14, c: 2, e: 9},
          {h: 2},
          {g: 2},
      ]
      for i in range(1):
          print dijkstra_shortest_path(N, a)
  # b in N[a] - смежность
  # len(N[f]) - степень
  # N[a][b] - вес (a,b)
  # print N[a][b]
  
 4.https://mindhalls.ru/floyd-warshall-algorithm/
  #include <iostream>
#include <algorithm>
#include <fstream>
 
//Максимальное значение веса = 100
#define INF 101
 
using namespace std;
 
void printMatrix(int** matrix, int numberOfVert) {
    for(int i = 0; i < numberOfVert; i++) {
        for(int j = 0; j < numberOfVert; j++) {
            if(matrix[i][j] == INF) {
                cout << "INF" << " ";
            }
            else {
                cout << matrix[i][j] << " ";
            }
        }
        cout << endl;
    }
}
 
//matrix - матрица смежности
void originalFloydWarshall(int **matrix, int numberOfVert) {
    //Пробегаемся по всем вершинам и ищем более короткий путь
    //через вершину k
    for(int k = 0; k < numberOfVert; k++) {
        for(int i = 0; i < numberOfVert; i++) {
            for(int j = 0; j < numberOfVert; j++) {
                //Новое значение ребра равно минимальному между старым
                //и суммой ребер i <-> k + k <-> j (если через k пройти быстрее)
                matrix[i][j] = min(matrix[i][j], matrix[i][k] + matrix[k][j]);
            }
        }
    }
     
    return;
}
 
int main(int argc, char** argv) {
    ifstream file("matrix");
    int numberOfVert;
    file >> numberOfVert;
    cout << numberOfVert << endl;
     
    //Матрица смежности с весами ребер графа(101 - ребра нет, 0 ребро в себя)
    int **matrix = (int**)malloc(sizeof(int)*numberOfVert);
    for(int i = 0; i < numberOfVert; i++) {
        matrix[i] = (int *) malloc(sizeof(int) * numberOfVert);
    }
     
    //Считываем матрицу весов ребер
    for(int i = 0; i < numberOfVert; i++) {
        for(int j = 0; j < numberOfVert; j++) { file >> matrix[i][j];
        }
    }
     
    file.close();
     
    cout << "Old matrix" << endl;
    printMatrix(matrix, numberOfVert);
     
    originalFloydWarshall(matrix, numberOfVert);
     
    cout << "New matrix" << endl;
     
    printMatrix(matrix, numberOfVert);
     
    return 0;
}

5.https://github.com/coryplusplus/Johnsons-Algorithm/blob/master/Johnson's%20Algorithm.py

6.https://cpp.mazurok.com/tag/волновой-алгоритм/
#include <iostream>
#include <queue>
using namespace std;
 
/* нахождение пути*/
void find_path(int n, int row, int col, char** lab, int** visited, int** path, queue<int>& plan){
    if(!visited[row][col]){
        /* проверяем не вышли ли мы за границы лабиринта, есть ли клетка 
        в массиве посещенных и можно ли через нее пройти*/
        if ((row+1) < n && (row+1) >= 0 && !visited[row+1][col] &&
            (lab[row+1][col] == '.' || lab[row+1][col] == 'X')) {
                path[row+1][col] = path[row][col] + 1;
                plan.push(row+1);
                plan.push(col);
        }
        if((row-1) < n && (row-1) >= 0 && !visited[row-1][col] && 
            (lab[row-1][col] == '.' || lab[row-1][col] == 'X')) {
                path[row-1][col] = path[row][col] + 1;
                plan.push(row-1);
                plan.push(col);
        }
        if((col + 1) < n && (col + 1) >= 0 && !visited[row][col+1] && 
            (lab[row][col+1] == '.' || lab[row][col+1] == 'X')) {
                path[row][col+1] = path[row][col] + 1;
                plan.push(row);
                plan.push(col+1);
        }
        if((col - 1) < n && (col - 1) >= 0 && !visited[row][col-1] && 
            (lab[row][col-1] == '.' || lab[row][col-1] == 'X')) {
                path[row][col-1] = path[row][col] + 1;
                plan.push(row);
                plan.push(col-1);
        }
        visited[row][col] = 1; /* отмечаем клетку в которой побывали */
    }
}
 
int main() {
    int n, x_start, y_start, x_end, y_end, x, y;
    queue <int> plan; 
    cin >> n;
    char** lab = new char* [n];
    int** visited = new int * [n];
    int** path = new int * [n];
    for(int i=0; i<n; i++){
        lab[i] = new char [n];   /* массив для хранения лабиринта */
        visited[i] = new int [n]; /* массив для хранения информации о посещении клеток*/
        path[i] = new int [n];  /* массив для хранения найденных путей */
        for(int j=0; j<n; j++){
            visited[i][j] = 0;  
            path[i][j] = -1;   
            cin >> lab[i][j]; 
            if (lab[i][j] == '@') { /* находим начало пути*/
                x_start = i;
                y_start = j;
                plan.push(i);  /* заносим начальную клетку */
                plan.push(j);  /* в план посещения */
                path[i][j] = 1;
            }
            else if (lab[i][j] == 'X') { /* находим конечную точку */
                x_end = i;
                y_end = j;
            }
        }
    }
    while(!plan.empty()){ /* пока очередь посещения клеток непустая*/
        x=plan.front();
        plan.pop();
        y=plan.front();
        plan.pop();
        find_path(n, x, y, lab, visited, path, plan); /* продолжаем поиск пути*/
    }
    if(!visited[x_end][y_end]){
        cout << "N" << endl;
    }
    else {
        cout << "Y" << endl;
            x = x_end;
            y = y_end;
            lab[x][y] = '+';
            while (path[x][y] != 2) { /* восстановление пути*/
                if ((x-1) >= 0 && (x-1) < n && (path[x-1][y] == path[x][y] - 1)) {
                    x = x-1;
                    lab[x][y] = '+';
                }
                else if ((x+1) >= 0 && (x+1) < n && (path[x+1][y] == path[x][y] - 1)) {
                    x = x+1;
                    lab[x][y] = '+';
                }
                else if ((y-1) >= 0 && (y-1) < n && (path[x][y-1] == path[x][y] - 1)) {
                    y = y-1;
                    lab[x][y] = '+';
                }
                else if ((y+1) >= 0 && (y+1) < n && (path[x][y+1] == path[x][y] - 1)) {
                    y = y+1;
                    lab[x][y] = '+';
                }
            }
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < n; j++) {
                    cout << lab[i][j];
                }
                cout << endl;
            }
        }
    return 0;
}

7.https://foxford.ru/wiki/informatika/algoritm-forda-bellmana