LeeSBMath

generator.py

from pprint import pprint

matrix = [[0] * 9 for _ in range(8)]

for row in range(8):
  for col in range(9):
    matrix[row][col] = col + row * 9

pprint(matrix)

graph = {}

for row in range(8):
  for col in range(9):
    current = col + row * 9
    neighbors = []
    try:
      neighbors.append(matrix[row][col + 1])
    except:
      pass
    # 서쪽 x
    # if (col - 1) >= 0:
    #   neighbors.append(matrix[row][col - 1])
    if (row - 1) >= 0:
      neighbors.append(matrix[row - 1][col])
    try:
      neighbors.append(matrix[row + 1][col])
    except:
      pass
    graph[current] = neighbors

pprint(graph)
for i in graph.keys():
  for j in graph[i]:
    print(f'g.addEdge({i}, {j});');
exit(0)

solution.cpp

// Modified https://www.geeksforgeeks.org/find-paths-given-source-destination/
#include <iostream>
#include <list>
using namespace std;

int count(0);

// A directed graph using adjacency list representation
class Graph
{
    int V;          // No. of vertices in graph
    list<int> *adj; // Pointer to an array containing adjacency lists

    // A recursive function used by printAllPaths()
    void printAllPathsUtil(int, int, bool[], int[], int &);

public:
    Graph(int V); // Constructor
    void addEdge(int u, int v);
    void printAllPaths(int s, int d);
};

Graph::Graph(int V)
{
    this->V = V;
    adj = new list<int>[V];
}

void Graph::addEdge(int u, int v)
{
    adj[u].push_back(v); // Add v to u’s list.
}

// Prints all paths from 's' to 'd'
void Graph::printAllPaths(int s, int d)
{
    // Mark all the vertices as not visited
    bool *visited = new bool[V];

    // Create an array to store paths
    int *path = new int[V];
    int path_index = 0; // Initialize path[] as empty

    // Initialize all vertices as not visited
    for (int i = 0; i < V; i++)
        visited[i] = false;

    // Call the recursive helper function to print all paths
    printAllPathsUtil(s, d, visited, path, path_index);
}

// A recursive function to print all paths from 'u' to 'd'.
// visited[] keeps track of vertices in current path.
// path[] stores actual vertices and path_index is current
// index in path[]
void Graph::printAllPathsUtil(int u, int d, bool visited[],
                              int path[], int &path_index)
{
    // Mark the current node and store it in path[]
    visited[u] = true;
    path[path_index] = u;
    path_index++;

    // If current vertex is same as destination, then print
    // current path[]
    if (u == d)
    {
        ::count += 1;
        cout << "[" << ::count << "] ";
        for (int i = 0; i < path_index; i++)
            cout << path[i] << " ";
        cout << endl;
    }
    else // If current vertex is not destination
    {
        // Recur for all the vertices adjacent to current vertex
        list<int>::iterator i;
        for (i = adj[u].begin(); i != adj[u].end(); ++i)
            if (!visited[*i])
                printAllPathsUtil(*i, d, visited, path, path_index);
    }

    // Remove current vertex from path[] and mark it as unvisited
    path_index--;
    visited[u] = false;
}

// Driver program
int main()
{
    // Create a graph given in the above diagram
    Graph g(72);
    g.addEdge(0, 1);
    g.addEdge(0, 9);
    g.addEdge(1, 2);
    g.addEdge(1, 10);
    g.addEdge(2, 3);
    g.addEdge(2, 11);
    g.addEdge(3, 4);
    g.addEdge(3, 12);
    g.addEdge(4, 5);
    g.addEdge(4, 13);
    g.addEdge(5, 6);
    g.addEdge(5, 14);
    g.addEdge(6, 7);
    g.addEdge(6, 15);
    g.addEdge(7, 8);
    g.addEdge(7, 16);
    g.addEdge(8, 17);
    g.addEdge(9, 10);
    g.addEdge(9, 0);
    g.addEdge(9, 18);
    g.addEdge(10, 11);
    g.addEdge(10, 1);
    g.addEdge(10, 19);
    g.addEdge(11, 12);
    g.addEdge(11, 2);
    g.addEdge(11, 20);
    g.addEdge(12, 13);
    g.addEdge(12, 3);
    g.addEdge(12, 21);
    g.addEdge(13, 14);
    g.addEdge(13, 4);
    g.addEdge(13, 22);
    g.addEdge(14, 15);
    g.addEdge(14, 5);
    g.addEdge(14, 23);
    g.addEdge(15, 16);
    g.addEdge(15, 6);
    g.addEdge(15, 24);
    g.addEdge(16, 17);
    g.addEdge(16, 7);
    g.addEdge(16, 25);
    g.addEdge(17, 8);
    g.addEdge(17, 26);
    g.addEdge(18, 19);
    g.addEdge(18, 9);
    g.addEdge(18, 27);
    g.addEdge(19, 20);
    g.addEdge(19, 10);
    g.addEdge(19, 28);
    g.addEdge(20, 21);
    g.addEdge(20, 11);
    g.addEdge(20, 29);
    g.addEdge(21, 22);
    g.addEdge(21, 12);
    g.addEdge(21, 30);
    g.addEdge(22, 23);
    g.addEdge(22, 13);
    g.addEdge(22, 31);
    g.addEdge(23, 24);
    g.addEdge(23, 14);
    g.addEdge(23, 32);
    g.addEdge(24, 25);
    g.addEdge(24, 15);
    g.addEdge(24, 33);
    g.addEdge(25, 26);
    g.addEdge(25, 16);
    g.addEdge(25, 34);
    g.addEdge(26, 17);
    g.addEdge(26, 35);
    g.addEdge(27, 28);
    g.addEdge(27, 18);
    g.addEdge(27, 36);
    g.addEdge(28, 29);
    g.addEdge(28, 19);
    g.addEdge(28, 37);
    g.addEdge(29, 30);
    g.addEdge(29, 20);
    g.addEdge(29, 38);
    g.addEdge(30, 31);
    g.addEdge(30, 21);
    g.addEdge(30, 39);
    g.addEdge(31, 32);
    g.addEdge(31, 22);
    g.addEdge(31, 40);
    g.addEdge(32, 33);
    g.addEdge(32, 23);
    g.addEdge(32, 41);
    g.addEdge(33, 34);
    g.addEdge(33, 24);
    g.addEdge(33, 42);
    g.addEdge(34, 35);
    g.addEdge(34, 25);
    g.addEdge(34, 43);
    g.addEdge(35, 26);
    g.addEdge(35, 44);
    g.addEdge(36, 37);
    g.addEdge(36, 27);
    g.addEdge(36, 45);
    g.addEdge(37, 38);
    g.addEdge(37, 28);
    g.addEdge(37, 46);
    g.addEdge(38, 39);
    g.addEdge(38, 29);
    g.addEdge(38, 47);
    g.addEdge(39, 40);
    g.addEdge(39, 30);
    g.addEdge(39, 48);
    g.addEdge(40, 41);
    g.addEdge(40, 31);
    g.addEdge(40, 49);
    g.addEdge(41, 42);
    g.addEdge(41, 32);
    g.addEdge(41, 50);
    g.addEdge(42, 43);
    g.addEdge(42, 33);
    g.addEdge(42, 51);
    g.addEdge(43, 44);
    g.addEdge(43, 34);
    g.addEdge(43, 52);
    g.addEdge(44, 35);
    g.addEdge(44, 53);
    g.addEdge(45, 46);
    g.addEdge(45, 36);
    g.addEdge(45, 54);
    g.addEdge(46, 47);
    g.addEdge(46, 37);
    g.addEdge(46, 55);
    g.addEdge(47, 48);
    g.addEdge(47, 38);
    g.addEdge(47, 56);
    g.addEdge(48, 49);
    g.addEdge(48, 39);
    g.addEdge(48, 57);
    g.addEdge(49, 50);
    g.addEdge(49, 40);
    g.addEdge(49, 58);
    g.addEdge(50, 51);
    g.addEdge(50, 41);
    g.addEdge(50, 59);
    g.addEdge(51, 52);
    g.addEdge(51, 42);
    g.addEdge(51, 60);
    g.addEdge(52, 53);
    g.addEdge(52, 43);
    g.addEdge(52, 61);
    g.addEdge(53, 44);
    g.addEdge(53, 62);
    g.addEdge(54, 55);
    g.addEdge(54, 45);
    g.addEdge(54, 63);
    g.addEdge(55, 56);
    g.addEdge(55, 46);
    g.addEdge(55, 64);
    g.addEdge(56, 57);
    g.addEdge(56, 47);
    g.addEdge(56, 65);
    g.addEdge(57, 58);
    g.addEdge(57, 48);
    g.addEdge(57, 66);
    g.addEdge(58, 59);
    g.addEdge(58, 49);
    g.addEdge(58, 67);
    g.addEdge(59, 60);
    g.addEdge(59, 50);
    g.addEdge(59, 68);
    g.addEdge(60, 61);
    g.addEdge(60, 51);
    g.addEdge(60, 69);
    g.addEdge(61, 62);
    g.addEdge(61, 52);
    g.addEdge(61, 70);
    g.addEdge(62, 53);
    g.addEdge(62, 71);
    g.addEdge(63, 64);
    g.addEdge(63, 54);
    g.addEdge(64, 65);
    g.addEdge(64, 55);
    g.addEdge(65, 66);
    g.addEdge(65, 56);
    g.addEdge(66, 67);
    g.addEdge(66, 57);
    g.addEdge(67, 68);
    g.addEdge(67, 58);
    g.addEdge(68, 69);
    g.addEdge(68, 59);
    g.addEdge(69, 70);
    g.addEdge(69, 60);
    g.addEdge(70, 71);
    g.addEdge(70, 61);
    g.addEdge(71, 62);

    int s = 63, d = 71;
    cout << "Following are all different paths from " << s
         << " to " << d << endl;
    g.printAllPaths(s, d);

    return 0;
}