Problem:
真っ暗な部屋

目を覚ますと、A君は真っ暗な部屋の中にいた。
どうやらA君は N 個の部屋から構成されたダンジョンに迷い込んでしまったようだ。
あなたはA君がどの部屋に迷い込んだのかを知ることはできなかったが、幸いにもダンジョンのマップを手に入れることができた。
A君の進むべき道を示し明るい部屋に導こう。

N 個の部屋のうち M 個の部屋が真っ暗な部屋であり、それぞれ D_1, D_2, ..., D_M 番目の部屋が真っ暗な部屋であることが分かっている。
また、全ての部屋からちょうど K 本の一方通行の道が順に並んでおり、i 番目の部屋から出る道はそれぞれ
v_{i,1}, v_{i,2}, ..., v_{i,K} 番目の部屋に繋がっている。
あなたは、A君に対し今いる部屋から a_1, a_2, ..., a_l 番目の道を順に進ませることができる。
ただし、A君は明るい部屋に到達したらそれ以降の指示は無視する。
あなたは、指示の前後においてA君が今いる部屋の情報を知ることはできないため、A君がどの部屋にいたとしても明るい部屋に辿り着けるような指示列を伝えなければならない。

そのような指示のうち、最も短いものの長さを答えよ。

Constraints

2 ≤ N ≤ 100

1 ≤ M ≤ min(16, N − 1)

1 ≤ K ≤ N

1 ≤ D_i ≤ N

D_i は全て異なる

1 ≤ v_{i, j} ≤ N

全ての暗い部屋は少なくとも1つの明るい部屋に到達可能である

Input Format

入力は以下の形式で標準入力から与えられる。

N M K
D_1 D_2 ... D_M
v_{1,1} v_{1,2} ... v_{1,K}
v_{2,1} v_{2,2} ... v_{2,K}
...
v_{N,1} v_{N,2} ... v_{N,K}

Output Format

答えを一行に出力せよ。

Sample Input 1

4 2 2
1 2
2 4
3 1
4 2
1 3

Sample Output 1

2

1, 1 という指示を出すと

A君の初期位置が部屋1である場合、2つ目の移動で部屋3に到達する

A君の初期位置が部屋2である場合、1つ目の移動で部屋3に到達する

Sample Input 2

3 2 2
1 2
2 3
1 2
2 1

Sample Output 2

3

2, 1, 2 という指示を出すと

A君の初期位置が部屋1である場合、1つ目の移動で部屋3に到達する

A君の初期位置が部屋2である場合、3つ目の移動で部屋3に到達する

Sample Input 3

6 3 3
1 2 3
4 1 1
2 5 2
3 3 6
4 4 4
5 5 5
6 6 6

Sample Output 3

3

非連結であるケースや、自己辺、多重辺があるケースに気をつけよう

Solution in Rust (judge verdict: Accepted)

    extern crate core;
     
    use std::fmt;
    use std::cmp::{Ordering, min, max};
    use std::f32::MAX;
    use std::ops::{Add, Sub, Mul, Div, Neg, Index, IndexMut, SubAssign, Range};
    use std::collections::{BTreeMap, VecDeque, BinaryHeap, BTreeSet, HashMap};
    use std::fmt::Display;
     
    fn show<T: Display>(vec: &Vec<T>) {
        if vec.is_empty() {
            println!("[]");
        }else {
            print!("[{}", vec[0]);
            for i in 1 .. vec.len() {
                print!(", {}", vec[i]);
            }
            println!("]");
        }
    }
    fn show2<T: Display>(vec: &Vec<Vec<T>>) {
        if vec.is_empty() {
            println!("[]");
        }else {
            for l in vec {
                show(l);
            }
        }
    }
     
    macro_rules! read_line{
        () => {{
            let mut line = String::new();
            std::io::stdin().read_line(&mut line).ok();
            line
        }};
        (delimiter: ' ') => {
            read_line!().split_whitespace().map(|x|x.to_string()).collect::<Vec<_>>()
        };
        (delimiter: $p:expr) => {
            read_line!().split($p).map(|x|x.to_string()).collect::<Vec<_>>()
        };
        (' ') => {
            read_line!(delimiter: ' ')
        };
        ($delimiter:expr) => {
            read_line!(delimiter: $delimiter)
        };
        (' '; $ty:ty) => {
            read_line!().split_whitespace().map(|x|x.parse::<$ty>().ok().unwrap()).collect::<Vec<$ty>>()
        };
        ($delimiter:expr; $ty:ty) => {
            read_line!($delimiter).into_iter().map(|x|x.parse::<$ty>().ok().unwrap()).collect::<Vec<$ty>>()
        };
    }
    macro_rules! read_value{
        () => {
            read_line!().trim().parse().ok().unwrap()
        }
    }
    macro_rules! let_all {
        ($($n:ident:$t:ty),*) => {
            let line = read_line!(delimiter: ' ');
            let mut iter = line.iter();
            $(let $n:$t = iter.next().unwrap().parse().ok().unwrap();)*
        };
    }
     
    macro_rules! let_mut_all {
        ($($n:ident:$t:ty),*) => {
            let line = read_line!(delimiter: ' ');
            let mut iter = line.iter();
            $(let mut $n:$t = iter.next().unwrap().parse().ok().unwrap();)*
        };
    }
    #[derive(Copy, Clone, Default)]
    struct BitSet {
        state: i32
    }
    impl BitSet {
        fn added(&self, position: usize) -> BitSet {
            BitSet{state: self.state | (1 << position as i32)}
        }
        fn removed(&self, position: usize) -> BitSet {
            BitSet{state: self.state & !(1 << position as i32)}
        }
        fn is_added(&self, position: usize) -> bool {
            self.state & (1 << position as i32) != 0
        }
        fn is_empty(&self) -> bool {
            self.state == 0
        }
        fn empty() -> BitSet {
            BitSet{state: 0}
        }
    }
    impl IntoIterator for BitSet {
        type Item = usize;
        type IntoIter = BitSetIterator;
        fn into_iter(self) -> Self::IntoIter {
            BitSetIterator{state: self.state, position: 0}
        }
    }
    struct BitSetIterator {
        state: i32, position: i32
    }
    impl Iterator for BitSetIterator {
        type Item = usize;
        fn next(&mut self) -> Option<Self::Item> {
            if self.state == 0 {
                None
            }else if self.state % 2 == 0 {
                self.state /= 2;
                self.position += 1;
                self.next()
            }else {
                let position = self.position as usize;
                self.state /= 2;
                self.position += 1;
                Some(position)
            }
        }
    }
    fn main() {
        let_all!(n: usize, m: usize, k: usize);
        let mut dark_room = read_line!(' '; usize);
        let mut rooms = vec![n; n];
        for i in 0 .. dark_room.len() {
            dark_room[i] -= 1;
            rooms[dark_room[i]] = i;
        }
        let mut path = Vec::with_capacity(n);
        for _ in 0 .. n {
            let mut p: Vec<usize> = read_line!(' '; usize);
            for mut r in &mut p {
                *r -= 1;
            }
            path.push(p);
        }
        let mut queue = VecDeque::new();
        queue.push_back(BitSet{state: (1 << m as i32) - 1});
        let mut count = 0;
        let mut is_added = vec![false; 1 << m];
        while !queue.is_empty() {
            count += 1;
            for _ in 0 .. queue.len() {
                if let Some(set) = queue.pop_front() {
                    for i in 0 .. k {
                        let mut next = BitSet::empty();
                        for c in set {
                            if rooms[path[dark_room[c]][i]] != n {
                                next = next.added(rooms[path[dark_room[c]][i]]);
                            }
                        }
                        if next.is_empty() {
                            println!("{}", count);
                            return
                        }
                        if !is_added[next.state as usize] {
                            is_added[next.state as usize] = true;
                            queue.push_back(next);
                        }
                    }
                }
            }
        }
    }