该比赛已结束，您无法在比赛模式下递交该题目。您可以点击“在题库中打开”以普通模式查看和递交本题。

题目背景

有一天 CodingCow 准备训练一个 AI，于是 CodingCow 用 Requests 库写了一个爬虫，用来爬一个可怜的网站，不料 CodingCow 性能孱弱的 MacBook Air 2018 在爬虫的时候总是假死，这让 CodingCow 很是烦恼。但是，CodingCow 发现如果让爬虫单线程执行而不是多线程执行，那么这个该死的爬虫就不会假死。但是，这个爬虫单线程执行实在是太太太太太慢了。所以，CodingCow 就想找一个可以 $7 \times 24$ 不间断执行的地方，他转念一想，盯上了 MCOI 的服务器。

于是在一个夜黑风高夜，CodingCow 打开 Terminal ，登录服务器后台，然后开始运行脚本……

真是苍天有眼，即使 CodingCow 用 screen 将脚本隐藏在后台，站长WTX还是发现了 CodingCow 的脚本的输出文件，于是他决定刺杀 CodingCow。可 CodingCow 也不是傻的，他躲到了一个复杂的房间里，这个房间里面有许多机关，但由于WTX害怕被 CodingCow 陷害，所以他找到了你，来帮助他找到抓住 CodingCow 的最短路径

题目描述

有一个 $r \times c$，保证 $0<r, c \le 100$ 的地图，地图上有很多东西，其中 # 代表墙，T 代表传送门，C 表示 CodingCow，W 表示WTX，. 表示可走的路。注意，这里的传送门十分的 NB, 可以直接传送的 CodingCow 的身边，把他秒掉，WTX想知道抓住 CodingCow 的最短路径，由于路径有很多条，所以本题采用 SPOJ 的方式评测，注意，WTX只有四个方向可走，即上、下、左、右。

输入格式

第一行两个整数 $r$ 和 $c$

其后是一个 $r \times c$ 的字符矩阵，保证只包含描述中提及的字符

输出格式

输出一行，表示从起点到终点的一条路径，格式如下（其中 $x_1$， $y_1$ 等均为坐标），保证有解

($x_1$, $y_1$) -> ($x_2$, $y_2$)

样例

3 3
W..
#..
.C.

(1, 1) -> (1, 2) -> (2, 2) -> (3, 2)

提示

Checker.cpp :

#include "testlib.h"
#include <vector>
#include <sstream>

using namespace std;

// Storage points
struct point {
    int x, y;

    inline bool operator==(const point a) const {
        return a.x == x && a.y == y;
    }
};

int r, c;  // r and c from the problem
vector<point> user_output, std_output;  // output path from user and std code
char a[109][109];  // map from the data

int main(int argc, char *argv[]) {
	// init testlib
    registerTestlibCmd(argc,argv);
    // init stringstream
    stringstream ss;
	
	// read data
    r = inf.readInt();
    inf.readSpace();
	c = inf.readInt();
    inf.readEoln();
    for (int i = 1; i <= r; i++) {
        string str = inf.readLine();
        for (int j = 1; j <= c; j++) {
            a[i][j] = str[j - 1];
        }
    }
    
    // read std code output
    int last_bracket, last_comma;
    string std_output_line = ans.readLine();
    last_comma = last_bracket = -1;
    for (int i = 0; i < std_output_line.length(); i++) {
        if (std_output_line[i] == ',') {
            last_comma = i;
        }
        if (std_output_line[i] == '(') {
            last_bracket = i;
        }
        if (std_output_line[i] == ')') {
            int x, y;
            ss.clear();
            ss << std_output_line.substr(last_bracket + 1, last_comma - last_bracket - 1);
            ss >> x;
            ss.clear();
            ss << std_output_line.substr(last_comma + 1, i - last_comma - 1);
            ss >> y;
            std_output.push_back((point) {x, y});
        }
    }
	
	// read user output
    string user_output_line = ouf.readLine();
    last_comma = last_bracket = -1;
    for (int i = 0; i < user_output_line.length(); i++) {
        if (user_output_line[i] == ',') {
            last_comma = i;
        }
        if (user_output_line[i] == '(') {
            last_bracket = i;
        }
        if (user_output_line[i] == ')') {
            if (last_comma == -1 || last_bracket == -1) {
                quitf(_pe, "Wrong user output format");
        	}
            int x, y;
            ss.clear();
            ss << user_output_line.substr(last_bracket + 1, last_comma - last_bracket - 1);
            ss >> x;
            ss.clear();
            ss << user_output_line.substr(last_comma + 1, i - last_comma - 1);
            ss >> y;
            user_output.push_back((point) {x, y});
        }
    }

    // SPJ
    if (std_output.size() != user_output.size()) {
        if (user_output.size() < std_output.size()) {
            quitf(_wa, "User output shorter than stander answer");
        }
        if (user_output.size() > std_output.size()) {
            quitf(_wa, "User output longer than stander answer");
        }
    }
    if (!(std_output[0] == user_output[0])) {
        quitf(_wa, "Wrong starting point");
    }
    if (!(a[user_output[user_output.size() - 1].x][user_output[user_output.size() - 1].y] == 'T'
        || a[user_output[user_output.size() - 1].x][user_output[user_output.size() - 1].y] == 'C'
		|| (user_output[user_output.size() - 1].x == std_output[std_output.size() - 1].x
			&& user_output[user_output.size() - 1].y == std_output[std_output.size() - 1].y))) {
        quitf(_wa, "Wrong ending point");
    }
    for (int i = 0; i < user_output.size(); i++) {
        if (a[user_output[i].x][user_output[i].y] == '#' 
			&& !(user_output[i].x == std_output[i].x 
				&& user_output[i].y == std_output[i].y)) {
            quitf(_wa, "Wrong path");
        }
    }
    quitf(_ok, "Correct answer");
}