#include <stdio.h>
#include <stdlib.h>
#include<iostream>
#include<fstream>
#include<assert.h>
#include<time.h>

using namespace std;


int righe = -1;
int colonne = -1;
int pacX = -1;
int pacY = -1;

char *campo = NULL;
int *campoCalcolo = NULL;
int *campoCalcoloFantasma = NULL;

int *fantasmi = NULL; int nFantasmi = 0;
int *pillolozzi = NULL; int nPillol = 0;

int MAX_FANT_PILLOL = 100;

int inline getIndex(int x, int y) { return x*colonne+y; }
char inline get(int x, int y) { return campo[x*colonne+y]; }
void inline set(int x, int y, char l) { campo[x*colonne+y] = l; }

void readInput() {
   ifstream fin( "input.txt" ); assert( fin );
   fin >> righe;
   fin >> colonne;

   campo = (char*)(malloc(sizeof(char)*righe*colonne));
   campoCalcolo = (int*)(malloc(sizeof(int)*righe*colonne));
   campoCalcoloFantasma = (int*)(malloc(sizeof(int)*righe*colonne));
   fantasmi = (int*)(malloc(sizeof(int)*MAX_FANT_PILLOL));
   pillolozzi = (int*)(malloc(sizeof(int)*MAX_FANT_PILLOL));

   char tmp;
   for(int i=0; i < righe; i++) {
	for(int j=0; j < colonne; j++) {
		fin >> tmp;
		if (tmp == 'M') { pacX = i; pacY = j; };
		//memorizzo posizione fantasmi
		if (tmp == 'F') { fantasmi[nFantasmi++] = i; fantasmi[nFantasmi++] = j;}
		//memorizzo posizione pillolozzi
		if (tmp == 'P') { pillolozzi[nPillol++] = i; pillolozzi[nPillol++] = j; pillolozzi[nPillol++]=1;}
		set(i,j,tmp);
	}
   }

   fin.close();
}

void initCampoCalcoloPacman() {
	for(int i=0; i < righe; i++) {
		for(int j=0; j < colonne; j++) {
			char tmp = get(i,j);
			campoCalcolo[getIndex(i,j)] = (tmp!='W')?0:-1;
		}
	}
}

void initCampoCalcoloFantasma() {
	for(int i=0; i < righe; i++) {
		for(int j=0; j < colonne; j++) {
			char tmp = get(i,j);
			campoCalcoloFantasma[getIndex(i,j)] = (tmp!='W')?0:-1;
		}
	}
}

void contaPassiSudEstPacman(int x, int y, int passo) {
	if (x==righe || y==colonne) return;
	else {
		campoCalcolo[getIndex(x,y)] = passo;

		if (y+1 < colonne && campoCalcolo[getIndex(x,y+1)] != -1)
			contaPassiSudEstPacman(x, y+1, passo+1);
		if (x+1 < righe && campoCalcolo[getIndex(x+1,y)] != -1)
			contaPassiSudEstPacman(x+1, y, passo+1);	
	}
}

void contaPassiSudOvestPacman(int x, int y, int passo) {
	if (x==righe || y==-1) return;
	else {
		campoCalcolo[getIndex(x,y)] = passo;

		if (y-1 >= 0 && campoCalcoloFantasma[getIndex(x,y-1)] != -1)
			contaPassiSudOvestPacman(x, y-1, passo+1);
		if (x+1 < righe && campoCalcoloFantasma[getIndex(x+1,y)] != -1)
			contaPassiSudOvestPacman(x+1, y, passo+1);	
	}
}

void contaPassiNordEstPacman(int x, int y, int passo) {
	if (x==-1 || y==colonne) return;
	else {
		campoCalcolo[getIndex(x,y)] = passo;

		if (y+1 < colonne && campoCalcoloFantasma[getIndex(x,y+1)] != -1)
			contaPassiNordEstPacman(x, y+1, passo+1);
		if (x-1 >= 0 && campoCalcoloFantasma[getIndex(x-1,y)] != -1)
			contaPassiNordEstPacman(x-1, y, passo+1);	
	}
}

void contaPassiNordOvestPacman(int x, int y, int passo) {
	if (x==-1 || y==-1) return;
	else {
		campoCalcolo[getIndex(x,y)] = passo;

		if (y-1 >= 0 && campoCalcoloFantasma[getIndex(x,y-1)] != -1)
			contaPassiNordOvestPacman(x, y-1, passo+1);
		if (x-1 >= 0 && campoCalcoloFantasma[getIndex(x-1,y)] != -1)
			contaPassiNordOvestPacman(x-1, y, passo+1);	
	}
}

void contaPassiSudEstFantasma(int x, int y, int passo) {
	if (x==righe || y==colonne) return;
	else {
		campoCalcoloFantasma[getIndex(x,y)] = passo;

		if (y+1 < colonne && campoCalcoloFantasma[getIndex(x,y+1)] != -1)
			contaPassiSudEstFantasma(x, y+1, passo+1);
		if (x+1 < righe && campoCalcoloFantasma[getIndex(x+1,y)] != -1)
			contaPassiSudEstFantasma(x+1, y, passo+1);	
	}
}

void contaPassiSudOvestFantasma(int x, int y, int passo) {
	if (x==righe || y==-1) return;
	else {
		campoCalcoloFantasma[getIndex(x,y)] = passo;

		if (y-1 >= 0 && campoCalcoloFantasma[getIndex(x,y-1)] != -1)
			contaPassiSudOvestFantasma(x, y-1, passo+1);
		if (x+1 < righe && campoCalcoloFantasma[getIndex(x+1,y)] != -1)
			contaPassiSudOvestFantasma(x+1, y, passo+1);	
	}
}

void contaPassiNordEstFantasma(int x, int y, int passo) {
	if (x==-1 || y==colonne) return;
	else {
		campoCalcoloFantasma[getIndex(x,y)] = passo;

		if (y+1 < colonne && campoCalcoloFantasma[getIndex(x,y+1)] != -1)
			contaPassiNordEstFantasma(x, y+1, passo+1);
		if (x-1 >= 0 && campoCalcoloFantasma[getIndex(x-1,y)] != -1)
			contaPassiNordEstFantasma(x-1, y, passo+1);	
	}
}

void contaPassiNordOvestFantasma(int x, int y, int passo) {
	if (x==-1 || y==-1) return;
	else {
		campoCalcoloFantasma[getIndex(x,y)] = passo;

		if (y-1 >= 0 && campoCalcoloFantasma[getIndex(x,y-1)] != -1)
			contaPassiNordOvestFantasma(x, y-1, passo+1);
		if (x-1 >= 0 && campoCalcoloFantasma[getIndex(x-1,y)] != -1)
			contaPassiNordOvestFantasma(x-1, y, passo+1);	
	}
}

//solo contare percorsi direzione sud est
//da scrivere i metodi per le altre tre direzioni
void contaPercorsi(int x, int y) {
	if (x==righe || y == colonne ) {
		return;
	}
	else {
		if ((y==colonne-1 && x < righe-1) && campoCalcolo[getIndex(x+1,y)] != -1) {
			contaPercorsi(x+1, y);
			campoCalcolo[getIndex(x,y)] = campoCalcolo[getIndex(x+1,y)];	
		} else {
			if ((x==righe -1 && y < colonne-1) && campoCalcolo[getIndex(x,y+1)] != -1) {
				contaPercorsi(x, y+1);
				campoCalcolo[getIndex(x,y)] = campoCalcolo[getIndex(x,y+1)];	
			} else {
				bool done = false;
				if (campoCalcolo[getIndex(x,y+1)] != -1) {
					contaPercorsi(x, y+1);
					done = true;
					campoCalcolo[getIndex(x,y)] = campoCalcolo[getIndex(x,y+1)];			
				}
				if (campoCalcolo[getIndex(x+1,y)] != -1) {
					contaPercorsi(x+1, y);
					done = true;
					campoCalcolo[getIndex(x,y)] += campoCalcolo[getIndex(x+1,y)];
				}

				if (!done && campoCalcolo[getIndex(x,y)] == 0) campoCalcolo[getIndex(x,y)] = 1;
			}
		}
	}
}


/*
void writeOutput() {
   ofstream fout( "output.txt" ); assert( fout );
   fout << best << endl;
   fout.close();
}
*/



void stampa () {
	for(int i=0; i < righe; i++) {
		for(int j=0; j < colonne; j++)
			printf("%c\t", get(i,j));
		printf("\n");
	}
}

void stampaCC () {
	for(int i=0; i < righe; i++) {
		for(int j=0; j < colonne; j++)
			printf("%d\t", campoCalcolo[getIndex(i,j)] );
		printf("\n");
	}
}


int main (void) {

	readInput();

	initCampoCalcoloPacman();


	// esploro in tutte le direzioni per Pacman
	contaPassiSudEstPacman(pacX, pacY, 1);
	contaPassiSudOvestPacman(pacX, pacY, 1);
	contaPassiNordEstPacman(pacX, pacY, 1);
	contaPassiNordEstPacman(pacX, pacY, 1);

	stampa(); 

	//per ogni fantasma
	for (int i = 0; i < nFantasmi; i=i+2) {
		initCampoCalcoloFantasma();
		int fantasmaX = fantasmi[i];
		int fantasmaY = fantasmi[i+1];
		//espora il campo in ogni direzione
		contaPassiSudEstFantasma(fantasmaX, fantasmaY, 1);
		contaPassiSudOvestFantasma(fantasmaX, fantasmaY, 1);
		contaPassiNordEstFantasma(fantasmaX, fantasmaY, 1);
		contaPassiNordOvestFantasma(fantasmaX, fantasmaY, 1);

		//per ogni pillolozzo
		for (int i = 0; i < nPillol; i=i+3) {
			int pillolozziX = pillolozzi[i];
			int pillolozziY = pillolozzi[i+1];
			
			if (campoCalcolo[getIndex(pillolozziX, pillolozziY)] > campoCalcoloFantasma[getIndex(pillolozziX, pillolozziY)])
				pillolozzi[i+2] = 0;	//un fantasma arriva prima di me su questo pillolizzo
		}
			
	}

	initCampoCalcoloPacman();
	//stampaCC();

	//controllo se raggiungo qualche pillolozzo prima di qualsiasi fantasma
	for (int i = 0; i < nPillol; i=i+3) {
		// questo pillolozzo si e' salvato		
		if (pillolozzi[i+2] == 1) {
			int pillolozziX = pillolozzi[i];
			int pillolozziY = pillolozzi[i+1];
			//conto le strade per raggiungere questo pillolozzo
			printf("salvo pillolozzo %d %d\n", pillolozziX, pillolozziY);
			//contaPercorsi(pacX, pacY);
			//stampaCC();
			//printf("%d \n", campoCalcolo[getIndex(pillolozziX, pillolozziY)]);
			exit(0);
		}
	}

   return 0;
}