Problem:
Problem I: 盗まれた宝石

パル王国の国宝である宝石が盗賊たちに盗まれた。 冒険者のあなたはその噂を聞きつけて盗賊のアジトに向かい、なんとか宝石を取り戻すことが出来た。

ところが、宝石をパル王国の城へ返しに出向いたところ、城の守衛兵から、 「我が王はまだあなたを完全に信用していない。その宝石が本物かどうか怪しいし、そもそも宝石を取り戻したというのがウソで、王の命を狙う盗賊の仲間なのではないか？と疑っておられる。」 といわれた。

あなたは、守衛兵から本当に信頼できる人物かどうか試すための試練を与えられた。試練の内容は、 「城の地下倉庫へ行き指定された場所に宝石を置け。そこに宝石が本物だったときに反応する魔法陣が書かれてある。ただしあなたが怪しい行動を起こさないようにするため、地下倉庫の入り口から指定された場所に向かうまで、守衛兵が言った移動パターンをとってはならない。」 というものだった。

例えば、下図にある地下倉庫の形状、禁止パターンに対し、図にかかれてあるような移動パターンを取ってはならない。移動パターンの一部(赤くハイライトされている)が、禁止パターンの中に含まれるからである。(また、この移動パターンの中の2,3番目の動き「↓↓」も禁止パターンの中に含まれる)

一方、 下図のような移動パターンは、移動パターンのどの部分も禁止パターンの中に含まれないので許される。

入力として、地下倉庫の形状、禁止パターンが与えられる。禁止パターンを取らずに、入り口から魔法陣へ移動するのに最低限必要な移動回数を求めよ。

Input

入力には、地下倉庫の形状と禁止パターンが含まれる。

地下倉庫の形状は、以下のように表される。 まず、二つの整数 N,M が与えられる。それぞれ地下倉庫の行数と列数を意味する。(1 ≤ N,M ≤ 50)

続いて、それぞれM個の文字からなる文字列がN行与えられる。 含まれる文字とその意味は以下の通りである。

文字

意味

S

地下倉庫の入り口。一つの地下倉庫につき必ず一つだけ含まれる。

G

魔法陣。一つの地下倉庫につき必ず一つだけ含まれる。

.

通路。(禁止パターンをとらなければ)通ることが出来る。

#

壁。壁の中を通ることはできない。

次に、禁止パターンが与えられる。禁止パターンは以下のように表される。 まず、一つの整数 P が与えられる。禁止パターンの数を意味する。(0 ≤ P ≤ 10)

続いて、禁止パターンを意味する文字列がP行にわたって与えられる。 禁止パターンに含まれる文字とその意味は以下の通りである。

文字

意味

U

↑の移動。

R

→の移動。

D

↓の移動。

L

←の移動。

禁止パターンの長さは1以上、10以下である。 ある禁止パターンが、別の禁止パターンの部分文字列となっていることもある。また、同一の禁止パターンが含まれることもある。

Output

最低限必要な移動回数を意味する整数を出力せよ。魔法陣へ辿りつけない場合は -1 を出力せよ。

Notes on Test Cases

上記入力形式で複数のデータセットが与えられます。各データセットに対して上記出力形式で出力を行うプログラムを作成して下さい。

n, m が 0 のとき入力の終わりを示します。

Sample Input

7 6
......
.####.
.####.
...S#.
...##.
...##.
.....G
3
LD
DD
LLL
7 8
S#......
.#.####.
.#.#G.#.
.#.##.#.
.#....#.
.######.
........
8
DDDD
DDDU
UUUU
UUUD
RRRR
RRRL
LLLL
LLLR
3 8
########
S......G
########
2
U
D
6 10
..........
.S........
..........
..........
........G.
..........
0
6 7
.......
...#...
...#.S.
...###.
.G.....
.......
2
LL
DD
0 0

Output for Sample Input

13
60
7
10
-1

Solution in Rust (judge verdict: Accepted)

// ---------- begin Aho-Corasick ----------
const F: usize = 4;

fn convert(s: Vec<char>) -> Vec<usize> {
    let mut a = Vec::with_capacity(s.len());
    for c in s {
        let k = match c {
            'L' => 0,
            'R' => 1,
            'U' => 2,
            'D' => 3,
            _ => unreachable!(),
        };
        a.push(k);
    }
    a
}

struct TrieNode {
    elem: bool,
    fail: usize,
    depth: usize,
    next: [usize; F],
}

impl TrieNode {
    fn new() -> TrieNode {
        TrieNode {
            elem: false,
            fail: 0,
            depth: 0,
            next: [0; F],
        }
    }
}

struct AhoCorasick {
    node: Vec<TrieNode>,
}

#[allow(dead_code)]
impl AhoCorasick {
    fn new() -> Self {
        let root = TrieNode::new();
        AhoCorasick {
            node: vec![root],
        }
    }
    fn insert(&mut self, s: &Vec<usize>) {
        let node = &mut self.node;
        let mut v = 0;
        for &k in s {
            if node[v].next[k] == 0 {
                node[v].next[k] = node.len();
                let mut t = TrieNode::new();
                t.depth = node[v].depth + 1;
                node.push(t);
            }
            v = node[v].next[k];
        }
        node[v].elem = true;
    }
    fn build(&mut self) {
        let mut q = std::collections::VecDeque::new();
        let node = &mut self.node;
        for i in 0..F {
            if node[0].next[i] != 0 {
                q.push_back(node[0].next[i]);
            }
        }
        while let Some(v) = q.pop_front() {
            for i in 0..F {
                let u = node[v].next[i];
                if u == 0 {
                    continue;
                }
                let mut fail = node[v].fail;
                while fail > 0 && node[fail].next[i] == 0 {
                    fail = node[fail].fail;
                }
                let f = node[fail].next[i];
                node[u].fail = f;
                node[u].elem |= node[v].elem || node[f].elem;
                q.push_back(u);
            }
        }
    }
    fn next(&self, v: usize, k: usize) -> usize {
        self.node[v].next[k]
    }
    fn trans(&self, mut v: usize, k: usize) -> usize {
        let node = &self.node;
        while v > 0 && node[v].next[k] == 0 {
            v = node[v].fail;
        }
        node[v].next[k]
    }
    fn elem(&self, k: usize) -> bool {
        self.node[k].elem
    }
    fn fail(&self, k: usize) -> usize {
        self.node[k].fail
    }
    fn depth(&self, k: usize) -> usize {
        self.node[k].depth
    }
    fn get_size(&self) -> usize {
        self.node.len()
    }
}
// ---------- end Aho-Corasick ----------
use std::io::Read;
use std::io::Write;

fn run() {
    let out = std::io::stdout();
    let mut out = std::io::BufWriter::new(out.lock());
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();
    let mut it = s.trim().split_whitespace();
    loop {
        let h: usize = it.next().unwrap().parse().unwrap();
        let w: usize = it.next().unwrap().parse().unwrap();
        if h == 0 {
            break;
        }
        let s: Vec<Vec<char>> = (0..h).map(|_| it.next().unwrap().chars().collect()).collect();
        let q: usize = it.next().unwrap().parse().unwrap();
        let mut aho = AhoCorasick::new();
        for _ in 0..q {
            aho.insert(&convert(it.next().unwrap().chars().collect()));
        }
        aho.build();
        let size = aho.get_size();
        let inf = 1_000_000_000;
        let mut dp = vec![vec![vec![inf; size]; w]; h];
        let mut q = std::collections::VecDeque::new();
        for i in 0..h {
            for j in 0..w {
                if s[i][j] == 'S' {
                    q.push_back((i, j, 0));
                    dp[i][j][0] = 0;
                }
            }
        }
        while let Some((r, c, v)) = q.pop_front() {
            for (k, &(x, y)) in [(r, c - 1), (r, c + 1), (r - 1, c), (r + 1, c)].iter().enumerate() {
                let u = aho.trans(v, k);
                if !(x < h && y < w && s[x][y] != '#' && !aho.elem(u)) {
                    continue;
                }
                if dp[x][y][u] > dp[r][c][v] + 1 {
                    dp[x][y][u] = dp[r][c][v] + 1;
                    q.push_back((x, y, u));
                }
            }
        }
        let mut ans = inf;
        for i in 0..h {
            for j in 0..w {
                if s[i][j] == 'G' {
                    ans = *dp[i][j].iter().min().unwrap();
                }
            }
        }
        if ans < inf {
            writeln!(out, "{}", ans).ok();
        } else {
            writeln!(out, "-1").ok();
        }
    }
}

fn main() {
    run();
}