题目大意:
输入一个n行m列的字符型矩阵，其中S代表起点 T代表终点，"*"代表墙，"."代表路，问能否从S走到T，并且转弯不超过两次（初始方向可以是任意的）?
..S..
****.
T.....
****.
......
比如上图可以走到，需要转弯两次。

想问一下判断转弯超不超过两次应该怎么实现?

仿照之前的帖子写了一个程序，但是运行被终止，可以帮忙看一下怎么回事么？

#include<stdio.h>
#include<stdlib.h>
char a[1000][1000];
int f(char a[][1000],int i,int j,int n,int m,int dir,int k){
    int n1=0,n2=0,n3=0,n4=0;
    if(k<=3 && a[i][j]=='T') return 1;  /*最开始不知道方向，k设为零（不等于1，2，3，4），默认为开始的时候转了一次弯，所以最后k<=3就行 */
    if(k>3) return 0;                           
    else{
        a[i][j]='*';       /*要研究的点一定是通路，把它置成断路的，防止倒车，影响下面运算 */
        if(i+1<n && a[i+1][j]!='*'){
            if(dir==1) n1=f(a,i+1,j,n,m,1,k);   /* 向上走，方向标记为1 */
            else n1=f(a,i+1,j,n,m,1,k+1);       /*如果这次选择走的方向和上一次不一样，转弯次数k加1 */
        }
        if(i-1<=0 && a[i-1][j]!='*'){
            if(dir==2) n2=f(a,i-1,j,n,m,2,k);   /*向下走，方向标记为2 */
            else n2=f(a,i-1,j,n,m,2,k+1);
        }
        if(j+1<m && a[i][j+1]!='*'){         
            if(dir==3) n3=f(a,i,j+1,n,m,3,k);   /*向右走，方向标记为3 */
            else n3=f(a,i,j+1,n,m,3,k+1);
        }
        if(j-1>=0 && a[i][j-1]!='*'){
            if(dir==4) n4=f(a,i,j-1,n,m,4,k);   /*向左走，方向标记为4 */
            else n4=f(a,i,j-1,n,m,4,k+1);
        }
        printf("n1=%d,n2=%d,n3=%d,n4=%d\n",n1,n2,n3,n4);
        
        if((n1||n2||n3||n4)==0){                /*如果有一种路线能走到终点，函数就返回1 */
            a[i][j]='.';
            return 0;
        }
        else{
          return 1;
    }
}
}
   
        
int main(void){
  int n,m,i,j,i0,j0,i1,j1,dir,k;
  while((scanf("%d %d",&n,&m))!=EOF){
      for(i=0;i<n;i++) scanf("%s",a[i]);
      for(i=0;i<n;i++){
          for(j=0;j<n;j++){
              printf("%c ",a[i][j]);
              if(j==n-1) printf("\n");
              if(a[i][j]=='S'){
                  i0=i;
                  j0=j;
              }
          }
      }
      printf("%d %d\n",i0,j0);
      dir=0;
      k=0;
      if(f(a,i0,j0,n,m,dir,k)) printf("YES\n");
      else printf("NO\n");
  }
  return 0;
}

我用的深度优先搜索，可能复杂度太高了？