0

重複の可能性:
行列内の接続されたセットの総数を見つけるアルゴリズム

質問:

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

私のソリューションはすべてのテストケースに合格しているわけではありませんが、コードが失敗するシナリオを指摘することはできません。誰かが私のコードの何が悪いのか指摘できますか?

私のアルゴリズムは単純です。1を見つけたら、その位置の値を1ずつインクリメントされたsetという変数に等しくします。最初にsetは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]);


        }



    }

}
4

1 に答える 1

1

コードが失敗する 1 つのテスト ケースを次に示します。

1
3
1 0 1
1 0 1
1 1 1

ここには 1 つのコンポーネントしかありません。

また、アルゴリズムが遅いです。前の行に接続されていない行がjある場合、すべての行でリセットします。1フラッド フィル アルゴリズムを試す: http://en.wikipedia.org/wiki/Flood_fill

于 2012-06-30T04:48:39.540 に答える