g = [(1, [1, 2, 3]),
     (2, [1, 3, 4]),
     (3, [5]),
     (4, [3, 4]),
     (5, [5, 2])
    ]

find n gr = case lookup n gr of
            Nothing -> []
            Just b  -> b

{-
queue
graph
node = root

queue.push(node);
bfs(queue);

fn bfs(queue, str){
    while( !queue ){
        node = queue.pop();
        str += node;
        foreach(node.childs as c){
            queue.push(c);
        }
    }
}
-}

{-
h :: [(Int, [Int])] -> Int -> [[Int]]
h g n = h' g n []
        where
            h' _ 0 s = s
            h' g@((a,b):xs) n s = h' g (n-1) $ f a b

            -- [a , [a1, a2]] -> [[a a1], [a a2]]
            f a = map (\x -> a ++ x)
-}

{-

    g = [(b, [b1, b2, b]),
         (b1, [b2, b]),
         (b2, [b])
        ]
    f b g n =
        -- найдём в графе пару с b и сконкатинируем её, отнимем от n 1.
        l1 = map (\x-> b : x : []) (find b g)
        -- l1 = [[b b1], [b b2], [b b]]
        n = n - 1
        -- потом для получившегося списка сделаем map для каждого
        -- элемента из пары, в котором найдём список дуг
        -- и сконкатинируем каждый элемент список дуг с l1 и вычтем из n 1
        l2 = map (\x -> zipWith (++) l1 $ (find x g) ) $ snd (b, [b1, b2, b])
        -- l2 = [[], [], []]
-}

l1 :: Eq a => a -> [(a, [a])] -> [[a]]
l1 a g = map (\x -> [a, x]) $ find a g

l2 gr = map (\x -> l1 (last x) gr)