Problem:
Problem E: Mirror Cave

双子の冒険者 Rin と Len は鏡の洞窟でお宝を探している．この洞窟には鏡の間という対になった 2 つの部屋があり，その部屋の扉の向こうには高価な宝が眠っているという．

便宜上，2 つの部屋はそれぞれ W × H のセルが格子状に並んだものとみなす．部屋の外側は壁で囲まれている．また，部屋の内側にもところどころ壁が設置されており，壁の配置されているセルには進入することができない．宝の部屋への扉を開くためには，2 人が左右対称の動きをして，同時に特定のセルに到達しなければならない．しかも，片方だけが先に到達した場合は，扉はロックされて開かなくなってしまう．

左右対称の動きとは，北と北，西と東，東と西，南と南にそれぞれ同時に動くことを意味する．ただし，片方が動こうとしている先に壁があり，もう一方の先に壁が無いといった状況下でも左右対称の動きであると認められる．この場合は壁がある方はその場にとどまり，壁が無い方は隣のセルに動くことになる．

入力として，双子の初期位置，目的地，障害物の配置が与えられる．あなたの仕事は，この双子が扉を開けることが可能であるか判定するプログラムを書くことである．

Input

入力は複数のデータセットからなる．各データセットは次の形式で与えられる．

W H

RoomL1 RoomR1

RoomL2 RoomR2

...

RoomLH RoomRH

最初の行では 2 つの正の整数 W, H (1 ≤ W, H ≤ 50) が 1 つの空白で区切られて与えられる．その後，H 行に渡って 2 つの部屋の情報が与えられる．RoomLi，RoomRi はそれぞれ左側，右側の部屋の i 番目の行に対応する．両者とも長さ W の文字列で，j 番目の文字が部屋の j 番目の列に対応する．それぞれの文字は以下のいずれかである．

. : 自由に移動できるセル

# : 壁のあるセル（進入できない）

% : 目的地

R : Rin の初期位置

L : Len の初期位置

各部屋とも 1 行目が部屋の北端，1 列目が部屋の西端に対応する．また，各部屋は必ずちょうど 1 つの目的地があり，左側の部屋には Len，右側の部屋には Rin の初期位置がちょうど 1 つ存在する．

入力の終わりは，空白で区切られた 2 つの 0 を含む行で示される．

Output

各データセットについて，双子が扉を開くことができるなら Yes，できなければ No をそれぞれ 1 行に出力せよ．

Sample Input

5 5
%#... ...#%
.#.#. .#.#.
.#.#. .#.#.
.#.#. .#.#.
...#L R#...
3 2
.L. .R#
%.. .%.
4 1
L.%. %..R
0 0

Output for the Sample Input

Yes
Yes
No

Solution in C# (judge verdict: Accepted)

using System;
using System.Collections.Generic;
using System.Linq;

namespace V2153{
    public class Program{
        public static void Main(string[] args){
            var sr = new StreamReader();
            //---------------------------------
            var dx = new[]{0, 1, 0, -1};
            var dy = new[]{1, 0, -1, 0};

            while(true){
                var W = sr.Next<int>();
                var H = sr.Next<int>();
                var C = sr.Next<string>(H * 2);
                if(W == 0 && H == 0) break;

                var lc = C.Where((_, i) => i % 2 == 0).ToArray();
                var rc = C.Where((_, i) => i % 2 == 1).Select(s => new string(s.Reverse().ToArray())).ToArray();

                var que = new Queue<int>();

                var glx = 0;
                var gly = 0;
                for(var i = 0; i < H; i++){
                    for(var j = 0; j < W; j++){
                        if(lc[i][j] == '%'){
                            glx = j;
                            gly = i;
                        }
                        if(lc[i][j] == 'L'){
                            que.Enqueue(j);
                            que.Enqueue(i);
                        }
                    }
                }

                var grx = 0;
                var gry = 0;
                for(var i = 0; i < H; i++){
                    for(var j = 0; j < W; j++){
                        if(rc[i][j] == '%'){
                            grx = j;
                            gry = i;
                        }
                        if(rc[i][j] == 'R'){
                            que.Enqueue(j);
                            que.Enqueue(i);
                        }
                    }
                }

                Func<int, int, bool> isInside = (x, y) => 0 <= x && x < W && 0 <= y && y < H;
                var dist = new bool[W, H, W, H];//lx, ly, rx, ry

                while(que.Count > 0){
                    var lx = que.Dequeue();
                    var ly = que.Dequeue();
                    var rx = que.Dequeue();
                    var ry = que.Dequeue();

                    for(var i = 0; i < 4; i++){
                        var nlx = lx + dx[i];
                        var nly = ly + dy[i];
                        var nrx = rx + dx[i];
                        var nry = ry + dy[i];

                        if(!isInside(nlx, nly) || lc[nly][nlx] == '#'){
                            nlx = lx;
                            nly = ly;
                        }
                        if(!isInside(nrx, nry) || rc[nry][nrx] == '#'){
                            nrx = rx;
                            nry = ry;
                        }

                        if(!dist[nlx, nly, nrx, nry] && !((nlx == glx && nly == gly) ^ (nrx == grx && nry == gry))){
                            dist[nlx, nly, nrx, nry] = true;
                            que.Enqueue(nlx);
                            que.Enqueue(nly);
                            que.Enqueue(nrx);
                            que.Enqueue(nry);
                        }
                    }
                }

                Console.WriteLine(dist[glx, gly, grx, gry] ? "Yes" : "No");
            }
            //---------------------------------
        }
    }

    public class StreamReader{
        private readonly char[] _c = {' '};
        private int _index = -1;
        private string[] _input = new string[0];
        private readonly System.IO.StreamReader _sr = new System.IO.StreamReader(Console.OpenStandardInput());

        public T Next<T>(){
            if(_index == _input.Length - 1){
                _index = -1;
                while(true){
                    string rl = _sr.ReadLine();
                    if(rl == null){
                        if(typeof(T).IsClass) return default(T);
                        return (T)typeof(T).GetField("MinValue").GetValue(null);
                    }
                    if(rl != ""){
                        _input = rl.Split(_c, StringSplitOptions.RemoveEmptyEntries);
                        break;
                    }
                }
            }
            return (T)Convert.ChangeType(_input[++_index], typeof(T), System.Globalization.CultureInfo.InvariantCulture);
        }

        public T[] Next<T>(int x){
            var ret = new T[x];
            for(var i = 0; i < x; ++i) ret[i] = Next<T>();
            return ret;
        }

        public T[][] Next<T>(int y, int x){
            var ret = new T[y][];
            for(var i = 0; i < y; ++i) ret[i] = Next<T>(x);
            return ret;
        }
    }
}