Question

可能重复：
Algorithm to find the total number of connected sets in a matrix

问题：

https://amazonindia.interviewstreet.com/challenges/dashboard/#problem/4fd6570bd51e1

我的解决方案并未通过所有测试用例。但我无法指出其中的方案我的代码会失败。任何人都可以指出我的代码有什么问题吗？

我的算法很简单，当你发现1时，该位置的值等于一个名为set的变量，增加1.最初设置为1。然后检查该位置的邻居，如果其中任何一个为1，则使其等于设置+ 1。

重复相同的步骤，直至到达矩阵的右下角。现在递增set并重复该过程，直到矩阵中剩下任何1（我使用boolean left决定这个）。

我的解决方案

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]);


        }



    }

}

Answer 1

以下是您的代码失败的一个测试用例：

这里只有一个组件。

此外，您的算法很慢。当j未连接到前一行时，您会在每一行重置1。尝试填充填充算法：http://en.wikipedia.org/wiki/Flood_fill

Interviewstreet拼图连接集

1 个答案: