Distinct Routes

import sys
from collections import deque, defaultdict, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product, accumulate, groupby
from functools import lru_cache, cmp_to_key, reduce
from math import gcd, isqrt, comb, inf, pi, sqrt, atan2, hypot
sys.setrecursionlimit(10**9)


def main():
    data = sys.stdin.buffer.read().split(); idx = 0
    if len(data) < 2:
        return
    # n = int(data[idx]); idx += 1
    n, m = map(int, data[idx:idx + 2]); idx += 2
    # a = list(map(int, data[idx:idx + n])); idx += n
    # s = data[idx].decode(); idx += 1                  # strings

    adj = [[] for i in range(n+1)]
    for i in range(m):
        a, b = map(int, data[idx:idx + 2]); idx += 2
        adj[a].append((b,i))


    # working_paths_node =  [[] for i in range(n+1)]
    all_paths = []

    used = set()
    on_path = set()

    
    taken_path = []
    def dfs(node):

        taken_path.append(node)
        on_path.add(node)
        # print(f"{node=}. {taken_path=}")
        if node == n:
            all_paths.append((taken_path.copy(), used.copy()))
            on_path.remove(node)
            taken_path.pop()
            return

        neighbours = adj[node]
        for newnode, path in neighbours:
            if path in used or newnode in on_path: continue
            used.add(path)
            dfs(newnode)
            used.remove(path)

        on_path.remove(node)
        taken_path.pop()

    dfs(1)
    out = []
    # print(all_paths)


    # for combi in combinations():

    #     bool(set() & set(b))
    for i in range(len(all_paths), -1, -1):
        found = False
        for combo in combinations(all_paths, i):
            # sets = [a[1] for a in combo]
            used = set()
            valid = True
            for lst, sett in combo:
                if bool(used & sett):
                    valid = False
                    break
                else:
                    used = used | sett
            if valid:
                found = True
                for lst, sett in combo:
                    out.append(lst)
                break
        if found: break



    # g = [data[idx + i].decode() for i in range(n)]; idx += n  # grid of n rows, no spaces, strings

    # input = sys.stdin.readline
    # n, m = map(int, input().split())
    # s = input().strip()  # strip removes the trailing newline
    # for line in sys.stdin:  # read until EOF



    print(len(out))
    for paths in out:
        print(len(paths))
        print(" ".join(map(str, paths)))
    # sys.stdout.write("\n".join(map(str, out)) + "\n")  # one value per line
    # print(*out)                                      # space separated on one line
    # print(f"{ans:.6f}")                              # float with 6 decimals
    # print("\n".join("".join(row) for row in g))      # grid of chars


main()

Test 1

Verdict: ACCEPTED

Test 2

Verdict: ACCEPTED

Test 3

Verdict: ACCEPTED

Test 4

Verdict: ACCEPTED

Test 5

Verdict: ACCEPTED

Test 6

Verdict: TIME LIMIT EXCEEDED

Test 7

Verdict: TIME LIMIT EXCEEDED

Test 8

Verdict: TIME LIMIT EXCEEDED

Test 9

Verdict: ACCEPTED

Test 10

Verdict: ACCEPTED

Test 11

Verdict: ACCEPTED

Test 12

Verdict: ACCEPTED

Test 13

Verdict: ACCEPTED

Test 14

Verdict: ACCEPTED

Test 15

Verdict: TIME LIMIT EXCEEDED