Java InterviewStreetPuzzle连通集

可能重复：

问题：

我的解决方案不是通过所有测试用例，但我无法指出其中的场景 我的代码将失败。 有人能指出我的代码有什么问题吗

我的算法很简单，当你找到一个1时，使这个位置的值等于一个叫做set的变量加1。初始设置为1。 然后检查该位置的相邻位置，如果其中任何一个为1，则使其等于set+1

重复同样的步骤，直到你到达矩阵的右下角。现在，递增集合并重复该过程，直到矩阵中剩下任何1（我使用布尔左键确定）

我的解决方案

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class Solution {


    public static void main(String[] args) throws IOException {


               String no_of_tc;

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        no_of_tc=br.readLine();
        int[] result=new int[Integer.parseInt(no_of_tc)];
        int mdim=0,maxset=0;
        boolean left=false;
        int i=0;
        boolean first=true;
        //boolean anyneighbour=false;
        for(i=0;i<Integer.parseInt(no_of_tc);i++)
        {
            maxset=0;
            left=false;
            first=true;
            mdim=Integer.parseInt(br.readLine());

            int[][] matrix=new int[mdim][mdim];
            String[] values=new String[mdim];
            int valuecount=0,counter=0,countchar=0;

            for(valuecount=0;valuecount<mdim;valuecount++)
            {
                countchar=0;
                values[valuecount]=br.readLine();
                for(counter=0;counter<mdim;counter++)
                {
                    char temp=(values[valuecount].charAt(countchar));
                    countchar=countchar+2;
                    matrix[valuecount]counter]=Character.getNumericValue(temp);
                }

            }


            int j=0,k=0,set=1;
            while(j<mdim)
            {

                while(k<mdim)
                {
                if(first)
                {
                    if(matrix[j][k]==1)
                    {
                        matrix[j][k]=set+1;
                        first=false;
                        maxset=set;
                    }
                }
                if(matrix[j][k]==set+1)
                {
                    if((j-1>=0)&&(k+1<mdim)&&(matrix[j-1][k+1]==1))
                    {
                        matrix[j-1][k+1]=set+1;
                        //anyneighbour=true;
                        //proceedwhole=proceedwhole+1;
                    }
                    if((j-1>=0)&&matrix[j-1][k]==1)
                    {
                        matrix[j-1][k]=set+1;
                        //anyneighbour=true;
                        //proceedwhole=proceedwhole+1;
                    }
                    if((j-1>=0)&&(k-1>=0)&&matrix[j-1][k-1]==1)
                    {
                        matrix[j-1][k-1]=set+1;
                        //anyneighbour=true;
                        //proceedwhole=proceedwhole+1;
                    }
                    if((k+1<mdim)&&matrix[j][k+1]==1)
                    {
                        matrix[j][k+1]=set+1;
                        //anyneighbour=true;
                        //proceedwhole=proceedwhole+1;
                    }

                    if((k-1>=0)&&matrix[j][k-1]==1)
                    {
                        matrix[j][k-1]=set+1;
                        //anyneighbour=true;
                        //proceedwhole=proceedwhole+1;

                    }

                    if((j+1<mdim)&& (k+1<mdim) && matrix[j+1][k+1]==1)
                    {
                        matrix[j+1][k+1]=set+1;
                        //anyneighbour=true;
                        //proceedwhole=proceedwhole+1;

                    }
                    if((j+1<mdim)&&matrix[j+1][k]==1)
                    {
                        matrix[j+1][k]=set+1;
                        //anyneighbour=true;
                        //proceedwhole=proceedwhole+1;

                    }
                    if((j+1<mdim)&&(k-1>=0)&&matrix[j+1][k-1]==1)
                    {
                        matrix[j+1][k-1]=set+1;
                        //anyneighbour=true;
                        //proceedwhole=proceedwhole+1;

                    }

//                  if(anyneighbour==false&&proceedwhole==1)
//                  {
//                      first=true;
//                      set=set+1;
//              
//                      result[i]=result[i]+1;
//                      break;
//                  }
//                  


                }
                else
                {

                    if(matrix[j][k]==1)
                    {

                        left=true;

                    }

                }

                k++;

            }
                k=0;
                j++;


                if(j==mdim)
                {
                    if(left==true)
                    {
                        j=0;
                    first=true;
                        left=false;

                        set=set+1;

                    }
                    else
                    {
                        result[i]=maxset;
                    }


                }
//              if(anyneighbour==false&&left==true)
//              {
//                  j=0;
//                  left=false;
//                  
//              }
            }



        }
        int counter2=0;

        for(counter2=0;counter2<Integer.parseInt(no_of_tc);counter2++)
        {
            System.out.println(result[counter2]);


        }



    }

}

导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStreamReader；
公共类解决方案{
公共静态void main（字符串[]args）引发IOException{
_tc的字符串no_；
BufferedReader br=新的BufferedReader（新的InputStreamReader（System.in））；
no_of_tc=br.readLine（）；
int[]result=new int[Integer.parseInt（不包含任何字符）]；
int mdim=0，maxset=0；
布尔左=假；
int i=0；
布尔值优先=真；
//布尔值=假；
对于（i=0；i，这里有一个您的代码失败的测试用例：

1
3
1 0 1
1 0 1
1 1 1

这里只有一个组件

此外，您的算法也很慢。当有一个
1
未连接到上一行时，您在每一行重置
j
。请尝试泛洪填充算法：