翻译：

莱斯利和利昂进入了一个迷宫。迷宫由𝑛大厅和𝑚大厅之间的单向通道组成。大厅编号从1到𝑛。

莱斯利和利昂在大厅开始了他们的旅程𝑠。他们立刻争吵起来，决定各自去探索迷宫。然而，他们希望在旅程结束时再次见面。

为了帮助Leslie和Leon，你的任务是找到两条不同的路径，从给定的大厅𝑠到另一个大厅𝑡，这样这两条路径除了开始的大厅𝑠和结束的大厅𝑡之外不共用大厅。大厅𝑡还没有确定，所以你可以选择任何一个迷宫的大厅𝑡除了𝑠。

莱斯利和利昂的路不一定是最短的，但他们的路必须很简单，最多一次去任何一个大厅。此外，除了𝑠和𝑡之外，他们在旅途中不能参观任何公共大厅，即使是在不同的时间。

输入
第一行包含三个整数𝑛、𝑚𝑠,哪里𝑛(2≤𝑛≤2⋅105)是顶点的数目,𝑚(0≤𝑚≤2⋅105)是迷宫,边的数量和𝑠(1≤𝑠≤𝑛)开始大厅。

然后是𝑚带有段落描述的行。每个描述都包含两个整数𝑢𝑖,𝑣𝑖(1≤𝑢𝑖,𝑣𝑖≤𝑛;𝑢𝑖≠𝑣𝑖)，表示从𝑢𝑖厅到𝑣𝑖厅的通道。这些通道是单向的。每个元组(𝑢𝑖，𝑣𝑖)在输入中最多出现一次。迷宫可以包含循环，并且不一定以任何方式连接。

输出
如果有可能找到所需的两条路径，则输出“possible”，否则输出“Impossible”。

如果答案存在，输出两个路径描述。每个描述占用两行。描述的第一行包含整数ℎ(2≤ℎ≤𝑛)—路径中的厅数，第二行包含不同的整数𝑤1，𝑤2，…，𝑤ℎ(𝑤1=𝑠;1≤𝑤𝑗≤𝑛;𝑤ℎ=𝑡)——按照经过的顺序排列在道路上的大厅。两条路径必须在同一个顶点𝑡结束。这些路径必须是不同的，这些路径中的所有中间大厅必须是不同的。

例子
inputCopy
5 5 1
1 2
2 3
1 - 4
4个3
3个5
outputCopy
可能的
3.
1 2 3
3.
1 4 3
inputCopy
5 5 1
1 2
2 3
3 4
2个5
5个4
outputCopy
不可能的
inputCopy
3 3 2
1 2
2 3
3个1
outputCopy
不可能的

思路：看有没有完全不同路径，从相同的起点出发，到一个可以到达的点。所以我们可以先看，没有解的情况，当起点只有一个点相连，这时候必不可能有解。之后我们对起点相连的点，轮流进行的方式，然后标记，如果有能搜到的点，已经被之前的搜到过了就是有解，我们用数组来记录路径，然后记录最后的两个点。然后回溯存点，输出。细节比较复杂，思路比较简单。

代码：

#include <iostream>
#include <algorithm>
#include <string.h>
#include <string>
#include <math.h>
#include <stdio.h>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<tuple>
#include<numeric>
using namespace::std;
typedef long long  ll;
inline __int128 read(){
    __int128 x = 0, f = 1;
    char ch = getchar();
    while(ch < '0' || ch > '9'){
        if(ch == '-')
            f = -1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9'){
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    return x * f;
}
inline void print(__int128 x){
    if(x < 0){
        putchar('-');
        x = -x;
    }
    if(x > 9)
        print(x / 10);
    putchar(x % 10 + '0');
}
int n ,m,s;
int f,ff;
vector<int>q[200005];
int ffla[200005];
int back[200005];
bool flag=false;
int ss,ssr;
void dfs(int x,int kl){
    ffla[x]=kl;
    for (auto next:q[x]) {
        if (ffla[next]&&ffla[next]!=kl) {
            if(next!=s){
                ss=next;ssr=x;
                flag=true;
                return;
            }
        }
        if (!ffla[next]) {
            back[next]=x;
            dfs(next, kl);
            if (flag) {
                return;
            }
        }
    }
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(); cout.tie();
    cin>>n>>m>>s;
    for (int i =0; i<m; i++) {
        cin>>f>>ff;
        q[f].push_back(ff);
    }
    if (q[s].size()<2) {
        printf("Impossible\n");return 0;
    }
    int rs=1;
    ffla[s]=1e7;
    for (auto k:q[s]) {
        if (flag) {
            break;
        }
        if (ffla[k]&&k!=s) {
            
            ss=k;
            ssr=s;
            flag=1;
            break;
        }
        back[k]=s;
        ffla[k]=rs;
        dfs(k, rs);
        rs++;
    }
    if (!flag) {
        printf("Impossible\n");return 0;
    }
    printf("Possible\n");
    vector<int>an1;
    vector<int>an2;
    an2.push_back(ss);
//    printf("%d %d",ss,ssr);
    while (ss!=s) {
        an1.push_back(ss);
        ss=back[ss];
    }
    while (ssr!=s) {
        an2.push_back(ssr);
        ssr=back[ssr];
    }
    
    printf("%d\n%d ",an1.size()+1,s);
    for (int i =an1.size()-1; i>=0; i--) {
        printf("%d ",an1[i]);
    }printf("\n");
    printf("%d\n%d ",an2.size()+1,s);
    for (int i=an2.size()-1; i>=0; i--) {
        printf("%d ",an2[i]);
    }printf("\n");
    return 0;
}