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 C++14 (judge verdict: Accepted)

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <bitset>
#include <map>
#include <unordered_map>
#include <list>
#include <numeric>
#include <utility>
#include <iterator>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <ctime>
#include <cassert>

#define INF 1000000000
#define LINF 9000000000000000000
#define mod 1000000007

#define rep(i,n) for(int i=0;i<int(n);i++)
#define rrep(i,n) for(int i=n-1;i>=0;i--)
#define REP(i,a,b) for(int i=(a);i<int(b);i++)
#define all(x) (x).begin(),x.end()
#define pb push_back
#define mp make_pair

using namespace std;

/*
   cin.tie(0);
   ios::sync_with_stdio(false);
*/

typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<long long>vll;
typedef pair<int,int> pi;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
int ddx[8]={-1,-1,0,1,1,1,0,-1};
int ddy[8]={0,1,1,1,0,-1,-1,-1};
bool debug=false;

/*---------------------------------------------------*/

int main(){
  int N, M, K;
  cin >> N >> M >> K;
  vector<int> D(M);
  for(int i=0;i<M;i++){
    cin>>D[i];
    D[i]--;
  }

  vector<int> darkness(N,-1);
  for(int i=0;i<M;i++){
    darkness[D[i]]=i;
  }
  
  vector<vector<int> > v(N,vector<int>(K));
  for(int i=0;i<N;i++){
    for(int j=0;j<K;j++){
      cin>>v[i][j];
      v[i][j]--;
    }
  }

  vector<int> d(1<<M, INF);
  queue<int> que;
  que.push((1<<M)-1);
  d[(1<<M)-1]=0;
  while(que.size()){
    int now=que.front();que.pop();
    for(int k=0;k<K;k++){
      int next_mask=0;
      for(int m=0;m<M;m++){
	if(now & (1<<m)){
	  int next= v[D[m]][k];
	  if(darkness[next]<0)continue;
	  next_mask |= (1 << darkness[next]);
	  // cout<<next_mask<<endl;
	}
      }

      if(d[next_mask]>d[now]+1){
	d[next_mask]=d[now]+1;
	que.push(next_mask);
      }
      if(next_mask==0){
	cout<<d[0]<<endl;
	return 0;
      }
    }
  }
  cout<<d[0]<<endl;
  return 0;
}