请各位朋友来看看，帮帮小弟的忙。先表感谢！

程序要求如下：
一、
定义1：矩阵 [aij ] 中的元素称作点。
求以aij为始点的路的算法：
1．取矩阵A=[aij]，(i =1，2，…，19，j =1，2，…，19) ，其中aij =19(i－1)+j；
2．对于A中的某个元素aij，取L=φ，Lm=φ，m=0，n=１；
3．若j+n≤19，记Lm=(aij，ai(j+1)，ai(j+2)，…，ai(j+n))，n=n+1, m=m+1，否则，记n=1，到第5步；
4．记L=L∪Lm，再回到第3步；
5．若j－n≥1，记Lm=(aij，ai(j－1)，ai(j－2)，…，ai(j－n))，n=n+1, m=m+1，否则，记n=1，到第7步；
6．记L=L∪Lm，再回到第5步；
7．若i－n≥1，记Lm=(aij，a(i－1)j，a(i－2)j，…，a(i－n)j)，n=n+1, m=m+1，否则，记n=1，到第9步；
8．记L=L∪Lm，再回到第7步；
9．若i+n≤19，记Lm=(aij，a(i+1)j，a(i+2)j，…，a(i+n)j)，n=n+1, m=m+1，否则到第11步；
10．记L=L∪Lm，再回到第9步；
11．集合L=（L1，L2，…，Lm）为以aij为始点的路的集合，停止。
二、
定义2：一条路以ags为始点，以akt为终点，如果g=k，s≠t，称该路为横向路，如果 g≠k，s=t，称该路为纵向路。
定义3：不同始点的两条路Lm、Pr，Pr的始点为Lm的终点，Lm为横(纵)向路，Pr为纵(横)向路，称Lm∪Pr为一条曲线路，称Pr为曲线路Lm∪Pr的尾部路段。
定义4：对于矩阵[aij ]中的元素 aij，元素ai(j+1)、ai(j－1)、a(i+1)j、a(i－1)j称作aij邻接的元素。
求含aij的闭合圈的算法：
1．对于矩阵A=[aij]内某个元素aij，计算aij的路的集合L=（L1，L2，…，Lm）；
2．取L内任一条路Lm，令Lm的终点为akt，如果Lm的尾部路段为横(纵)向路，计算以akt为始点的纵(横)向路的集合P1，P2，…，Pr ,得到曲线路的集合Lm∪P1，Lm∪P2，…，Lm∪Pr ；
3．以得到的曲线路为基础如上进行反复运算。如果每次运算，尾部路段中有一点与曲线路上除aij外的一点重合或者邻接于曲线路上一点，舍去；
4．如此反复，如果某条路所含点的个数大于32，舍去，如果某条路的终点为aij，记该路为Z1；
5．直至L中的元素全部计算完，得到的集合Z1，Z2，…，Zh，即为含aij的闭合圈的集合，停止。我编写的第两问代码如下，可是运行时间很长、很长。请朋友们指点一下修改的方向。谢谢！如果还有什么不清楚的地方，我长期在线。
//求含aij点的闭合圈
  public int[][] aijBHQ(int i,int j){
    int[][][] Temp;
    int[][] L,Z;
    int[] Lm;
    int z=0;
    L=aijL(i,j);//获取以aij点为起点的路(第一问的结果)
    Temp= new int[L.length][][];
    for(int k=1;k<=L.length-1;k++){
      Lm=L[k];
      Temp[k]=LBHQ(Lm);
    }
    for(int k=1;k<Temp.length-1;k++)
      z+=Temp[k].length-1;
    Z=new int[z+1][];
    z=0;
    for(int k=1;k<Temp.length;k++)
      for(int t=1;t<Temp[k].length;t++)
        Z[++z]=Temp[k][t];
    return Z;
  }
//求以Lm为曲线路段的闭合圈
  public int[][] LBHQ(int[] Lm){
    int[][][] Temp3;
    int[][] Z,P=new int[20][],Temp1=new int[20][],Temp2;
    int[] Pr;
    int m=0,n=1,ags,akt,x,y,temp1=0,temp2=0,temp3=0,z=0;
    Dimension point;
    ags=Lm[Lm.length-2];
    akt=Lm[Lm.length-1];
    point=reArray(akt);
    x=(int)point.getWidth();
    y=(int)point.getHeight();
    //尾路段纵（横）向判断
    if(ZXL(ags,akt)){
      while(true){
        if(y+n<=19){
          Pr=new int[n+1];
          for(int k=1;k<=n;k++)
            Pr[k]=a[x][y+k];
          if(SQBHQ(Pr,Lm)){
            P[++m]=Pr;
            n++;
          }else{
            n++;
            continue;
          }
        }else{
          n=1;
          break;
        }
      }
      while(true){
        if(y-n>=1){
          Pr=new int[n+1];
          for(int k=1;k<=n;k++)
            Pr[k]=a[x][y-k];
          if(SQBHQ(Pr,Lm))//尾部路段的正确性{
            P[++m]=Pr;
            n++;
          }else{
            n++;
            continue;
          }
        }else{
          n=1;
          break;
        }
      }
    }else{
      while(true){
        if(x+n<=19){
          Pr=new int[n+1];
          for(int k=1;k<=n;k++)
            Pr[k]=a[x+k][y];
          if(SQBHQ(Pr,Lm)){
            P[++m]=Pr;
            n++;
          }else{
            n++;
            continue;
          }
        }else{
          n=1;
          break;
        }
      }
      while(true){
        if(x-n>=1){
          Pr=new int[n+1];
          for(int k=1;k<=n;k++)
            Pr[k]=a[x-k][y];
          if(SQBHQ(Pr,Lm)){
            P[++m]=Pr;
            n++;
          }else{
            n++;
            continue;
          }
        }else{
         n=1;
         break;
        }
      }
    }
    for(int k=1;k<=m;k++)
      Temp1[++temp1]=addJH(Lm,P[k]);
    Temp2=new int[temp1+1][];
    Temp3=new int[temp1+1][][];
    for(int k=1;k<=temp1;k++){
      if(Temp1[k][1]==Temp1[k][Temp1[k].length-1]){
        Temp2[++temp2]=Temp1[k];
      }else{
        Temp3[++temp3]=LBHQ(Temp1[k]);
      }
    }
    z=temp2;
    for(int k=1;k<=temp3;k++)
      z+=Temp3[k].length-1;
    Z=new int[z+1][];
    z=0;
    for(int k=1;k<=temp2;k++)
      Z[++z]=Temp2[k];
    for(int k=1;k<=temp3;k++)
      for(int t=1;t<Temp3[k].length;t++)
        Z[++z]=Temp3[k][t];
    return Z;
  }