// 基本框架
#include<iostream>
using namespace std;
int main(){
    return 0;
}

#pragma GCC target("avx,sse2,sse3,sse4,mmx")

// 一般只写这一句就会有很大的效果了
#pragma GCC optimize(2)

#pragma GCC target ("avx")
#pragma GCC optimize (2, 3, "Ofast", "inline", "-ffast-math")

// 输出指令：cout
// 输出运算符：<<   (两个小于)
// 换行指令：endl
cout<<"这是一个输出样例："<<endl;
cout<<"hello world!";

// C语言格式化输出: printf("<格式化字符串>", <参量表>)
// 常用：%d 整形、%lld 长整型、%c 字符型、%f 浮点型、%lf 高精度浮点、%.3f 保留三位小数
double pi = 3.1415926;
printf("保留小数位数：%.2lf %.3lf", pi, pi);

// 输入指令：cin
// 输入运算符：>>   (两个大于)
// 输入数据前，需要先定义变量来接收
int a;
cin>>a;

// C语言格式化输入: scanf("<格式化字符串>", &<参量表>)
// 使用时变量前面一定要加上取址符 &   对应的格式化字符串类型不能写错
// 常用：%d 整形、%lld 长整型、%c 字符型、%f 浮点型
double pi;
scanf("%lf", &pi);

// 从文件中读取输入，文件名C.in
freopen("C.in", "r", stdin);
// 将答案写入文件，文件名C.out
freopen("C.out", "w", stdout);

// 第一个if语句必须写，另外两个非必须，根据需求来写
if(){}
else if(){}
else{}

int a=10, b=10;
// 如果a>b为真，c=a，否则c=b
int c = a>b?a:b;

// 小括号只能传整形 和 字符类型。break必须写，不写就会合并多个情况
switch (1) {
    case 1:
        // 第一个选择
        break;
    case 2:
        // 第二个选择
        break;
    default:
        // 以上都没出现的选择
        break;
}

// 从0开始，到100结束
for(int i=0;i<=100;i++){
    cout<<i<<" ";
}

// 小括号为运行的条件，只要条件为真就会执行循环
while(1){}
// 当小括号里面为1，表示死循环，不会主动结束，需要使用break来结束循环
// continue语句：跳过本次循环

// 优先级t10086，学了就没用过，了解就行
do{
    // 代码，(和while没啥区别，这个是先循环一次，再去判断条件)
}while(1);

// 函数是一种固定的代码，可以让代码被重复利用，降低冗余
// 函数定义五个步骤
// 1、函数的返回值类型，即调用了这个函数后，你想要得到的数据类型(关联第5点)，没有返回值就是void
// 2、函数名，随便定义，只要满足变量命名规则即可
// 3、函数的参数，需要传给函数的变量(可有可无)
// 4、函数的功能(核心代码)
// 5、函数的返回值，函数处理完的结果(关键字：return)，只要第一点写的不是void，就必须要写return返回值

// 例：定义找两个整数最大值的函数
// 1、函数返回值类型：两个数的最大值，返回值为int类型
// 2、函数名：my_max
// 3、函数的参数：需要传入两个整数a,b
// 4、函数的功能：找两个整数的最大值：a>b?a:b
// 5、函数的返回值：直接返回最大的值即可
int my_max(int a, int b){
    return a>b?a:b;
}

// 结构体关键字：struct
struct xxx{       // 结构体名称：xxx
    string name;  // 结构体属性1
    int age;      // 结构体属性2
    int score;    // 结构体属性3
}a,b,c;  // 定义结构体的时候可以声明结构体变量，写不写都可以
// 使用结构体创建变量，和创建int变量一样:  数据类型  变量名;  
xxx aa;  // 创建了一个结构体变量aa 
struct xxx bb;  // 结构体专属写法，我的评价是不如上面那种。。
// 结构体变量赋值
// 1、在创建时赋值(列表化赋值)，必须严格按照结构体定义时的顺序来赋值
xxx aa = {"小明", 12, 250};
// 2、指定属性赋值，可以根据需求指定属性赋值，没有顺序要求
bb.age = 12;
bb.name = "小明";
bb.score = 250;
// 输出结构体时，要指明属性，不能直接输出结构体变量
cout<<aa.name<<" "<<aa.age<<" "<<aa.score;

// 相同数据类型的元素按一定顺序排列的集合，就是把有限个类型相同的变量用一个名字命名
// 数据类型  数组名[元素个数];
int a[100];  // 100个元素的int数组，也可以理解为100个变量
a[0] = 999;  // 通过索引访问元素
cout<<a[0];

#include<stack>  // 使用时需要导入头文件
// 创建栈
stack<int> st;   // 创建了一个名为st的栈，里面只能存放int类型的数据
stack<Node> st1; // 创建了一个名为st1的栈，里面只能存放Node类型的数据 Node：自己的定义的结构体类型
// 栈的常用操作
st.push(1);    // 往st栈顶添加一个元素1
st.pop();      // 把st栈顶元素弹出(删除、出栈)
st.top():      // 获取st栈顶元素
st.size();     // 获取st栈的元素个数
st.empty();    // 判断st栈是否为空，为空则返回1

#include<queue>  // 使用时需要导入头文件
// 创建栈
queue<int> st;   // 创建了一个名为st的队列，里面只能存放int类型的数据
queue<Node> st1; // 创建了一个名为st1的队列，里面只能存放Node类型的数据 Node：是自己的定义的结构体类型
// 队列的常用操作
st.push(1);    // 往队尾添加一个元素
st.pop();      // 把队首元素出队(删除)
st.front():    // 获取队首元素
st.back();     // 获取对尾元素
st.size();     // 获取队列中的元素个数
st.empty();    // 判断队列是否为空，为空则返回1

struct Node{
	int val;    // 链表的值
	Node *next; // 下一个节点的地址
};

struct Node{
	int val;     // 链表的值
	Node *left;  // 上一个节点的地址
	Node *right; // 下一个节点的地址
};

#include<map>    // 使用时需要导入头文件
// 创建，前一个类型是键的类型，后一个是值的类型
map<int, int> p;     // 创建了一个哈希表变量，键的类型是int，值的类型也是int
map<char, int> p2;   // 创建了一个哈希表变量，键的类型是char，值的类型是int
map<string, int> p3; // 创建了一个哈希表变量，键的类型是string，值的类型是int，可以用来统计字符串出现的数量(比结构体好用)
// 使用
// 1、键不存在：
p2['A'] = 100; // 添加一个数据，键为'A'，值为100
// 2、键存在：正常调用即可
cout<<p2['A'];

// 排序n个元素，只需要冒泡n-1次即可
for(int i=1;i<=n-1;i++){
	// 每完成一次冒泡排序，就可以少比较一次(排好序的元素越来越多)
	for(int j=1;j<=n-i;j++){
		// 把较大的元素排序到末尾
		if(a[j]>a[j+1]) swap(a[j], a[j+1]);
	}
}

// 每次选择一个最小(最大)的元素，放到待排序数组前面
for(int i=1;i<=n-1;i++){
	// 找待排序数组中的最小值
	int k = i, minn = a[i]; // 初始化最小值的信息
	for(int j=i;j<=n;j++){
		if(a[j] < minn){  // 比较找最小值
			k = j;        // 更新最小值索引
			minn = a[j];  // 更新最小值
		}
	}
	swap(a[i], a[k]);  // 把当前的最小值和待排序数组第一个元素交换
}

// 初始化桶，数据中的最大值是99，所以桶的容量必须大于99
// 类型根据是否要去重来选择，去重就用bool数组标记，不去重就int数组统计
int tong[100] = {0};  
int t;
for(int i=1;i<=n;i++){
	cin>>t;
	tong[t]++;  // 每获取一个数据，t的次数+1
}
// 桶的索引就是题目输入的数据
// 最后根据桶的索引输出排序后的数组即可
for(int i=0;i<=100;i++){  // 升序
	// 不去重的排序，根据统计出现的次数来输出
	for(int j=1;j<=tong[i];j++){
		cout<<i<<" ";
	}
	// 要去重的话，桶数组就用bool类型，标记元素是否出现
	// 每个元素出现了，就输出一次即可
	// if(tong[i] == 1) cout<<i<<" ";
}

// 1、函数定义：sum(n)表示1~n的全部整数之和，sum(5)=15
// 2、递归表达式：sum(n) = sum(n-1)+n，把要解决的问题拆成了范围更小的问题
// 3、递归边界：当n=1时，可以直接得出sum(1)=1，不需要继续递归了
int sum(int n){
	if(n == 1) return 1;
	return sum(n-1) + n;
}

#include <iostream> 
using namespace std;

// 从n个数中选k个数全排(组合)
int n,k;
int res[15];  // 答案数字
bool vis[15]; // 标记数组，0表示没被选过，1表示被选

// 函数作用：表示当前选的是第几个数(总共要选k个数)
void dfs(int x){
	// 当前选的数超过k个，就结束搜索(x等于k，即dfs(k)表示选第k个数)
	if(x>k){
		// 输出答案，有k个数字所以要用循环
		for(int i=1;i<=k;i++){
			cout<<res[i]<<" ";
		}
		cout<<endl;
		return;
	}
	// 从1~n个数中选
	for(int i=1;i<=n;i++){
		// 全排列：没有数字大小限制，只有一个条件：数字没被选过即可
		// if(vis[i] != 1){
		
		// 组合：数字没被选过 && 当前选的数字不能小于前一个数字
                // 也就是说，1 2 3 和 2 3 1是一种方案
		if(vis[i] != 1 && res[x-1]<i){

			res[x] = i;  // 把这个数字记录到答案数组中
			vis[i] = 1;  // 标记这个数字，后面的搜索中不能再选了
			dfs(x+1);    // 递归搜索下一个数字
			vis[i] = 0;  // 回溯，本次搜索完后，后续的其他搜索中也可能有这个数字
		}
	}
}

int main(){
	cin>>n>>k;
	dfs(1);
	return 0; 
}

#include <iostream>
#include<queue>  // 队列头文件
using namespace std;

// 迷宫格结构体，当前格子的坐标(x,y)，以及从起点到当前格子的最少步数step
struct pos{
	int x,y,step;
};


queue<pos> q;        // 广搜队列
char map[105][105];  // 地图数组
int vis[105][105];   // 标记数组，用于标记已经被走过的点
int dx[4] = {0,1,0,-1};  // x方向位移数组：右、下、左、上
int dy[4] = {1,0,-1,0};  // y方向位移数组：右、下、左、上
// 地图大小
int n,m,ans=0;
int sx,sy; // 起点坐标
int ex,ey; // 终点坐标

// 广搜
void bfs(){
        // 起点格子
	pos t = {sx,sy,0};
	vis[sx][sy] = 1; // 标记起点
	q.push(t);       // 起点入队，开始广搜
	while(!q.empty()){
		t = q.front();  // 队首元素出队
		q.pop();        // 队首已经在下面被访问，所以可以先删掉
		// 走到终点结束
		if(t.x == ex && t.y == ey){
			ans = t.step;
			return;
		}
                // 从当前队首的格子能走到的四个方向上的格子
		for(int i=0;i<4;i++){
			int xx = dx[i] + t.x;
			int yy = dy[i] + t.y;
			// 不能超过迷宫边界   遇到墙不能走  走过的不能走
			if(xx>=1&&xx<=n&&yy>=1&&yy<=m&&map[xx][yy]!='#'&&vis[xx][yy]!=1){
				q.push({xx,yy,t.step+1});  // 上下左右能走的入队，并更新最少步数step
				vis[xx][yy] = 1; // 下个格子被走过了，标记
			}
		}
	}
}

int main() {
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		for(int j=1;j<=m;j++){
			cin>>map[i][j];
			if(map[i][j] == 'S') sx = i, sy = j; 
			if(map[i][j] == 'T') ex = i, ey = j;
		}
	}
	bfs();  // 调用广搜
	cout<<ans;
	return 0;
}