一个图用邻接表表示，输出从顶点 s 到顶点 t 的所有简单路径

假设图用邻接表表示，设计一个算法，输出从顶点 i i i 到顶点 j j j 的所有简单路径

第一行包含三个整数 n n n ， m m m 和 k k k。

接下来 m m m 行，每行包含两个整数 x x x 和 y y y，表示存在一条从点 x x x 到点 y y y 的有向边 ( x x x, y y y)。

接下来 k k k 行，每行包含两个整数 s s s 和 t t t，表示要求输出顶点 s s s 到顶点 t t t 的所有简单路径。

6 8 3
1 2
1 3
2 4 
3 4
4 5
5 3
2 7
7 4
1 4
2 5
1 5

1 -> 4 的所有简单路径：
1 3 4 
1 2 7 4 
1 2 4 

2 -> 5 的所有简单路径：
2 7 4 5 
2 4 5 

1 -> 5 的所有简单路径：
1 3 4 5 
1 2 7 4 5 
1 2 4 5 

#include 
#include 
#include 

using namespace std;

const int N = 510;

int n, m, k;
bool st[N];
vector path;

struct Node
{
    int id; // 编号
    int w;  // 权值
    Node* next;
    Node(int _id) : id(_id), next(NULL){}
} *head[N];     // 邻接表

void add(int a, int b)
{
    Node* p = new Node(b);
    p->next = head[a];
    head[a] = p;
}

void dfs(int s, int t)
{
    if (s == t)
    {
        for (auto x : path) printf("%d ", x);
        puts("");
        return ;
    }
    
    for (auto p = head[s]; p; p = p->next)
    {
        int j = p->id;
        if (!st[j])
        {
            st[j] = true;
            path.push_back(j);
            dfs(j, t);
            path.pop_back();
            st[j] = false;
        }
    }
}


int main()
{
    cin >> n >> m >> k;
    while (m -- )
    {
        int a, b;
        cin >> a >> b;
        add(a, b);
    }
    
    while (k --)
    {
        int s, t;
        cin >> s >> t;
        printf("n%d -> %d 的所有简单路径：n", s, t);
        path.push_back(s);
        st[s] = true;
        dfs(s, t);  // 输出顶点s到顶点t的所有简单路径
        st[s] = false;
        path.pop_back();
    }
    
    return 0;
}