percolation

public class Percolation{

    private int arrDim;
    private char[][] state;
    private MyWeightedQuickUnionUF qu;
    private int top = 0;
    private int bottom;
    final long constructionTime;

    Percolation(int N){
        arrDim = N;
        qu = new MyWeightedQuickUnionUF((N*N)+2); // +2 is for the virtual top n bottom site
        state = new char[N][N];
//      System.out.print("\n state : " + state.length + " elements : ");
        for(int i = 0; i< N; i++){
            for(int j = 0; j < N ; j++){
//              'b' = blocked
//              'o' = open
//              'f' = full
                state[i][j]='b';
//              System.out.print(" " + state[i][j]);
            }
        }
        bottom = N*N + 1; // (N*N + 2) - 1;
        for(int i = 1; i<= N; i++){
            qu.union(top, i); // creating virual connection of top row to Top site
            qu.union(bottom,bottom - i); // connecting bottom row sites to Bottom
        }
//      System.out.println("done constructing\n\n\n");
        constructionTime = System.nanoTime();

    }

    public int convertTo1D(int row, int col){
        return ((row*arrDim + col) + 1); // the conversion is needed as union find has 1D array, and return value will give the index of that array
                                        // but, since the initial(0) and final(N*N+1) positions of the (N*N + 2) array are reserved for TOP n BOTTOM virtual sites
                                        // the array index range for use is from 1 to N*N
    }
    public void open(int row,int col){
//      System.out.print("in open(): passed value: " + row+ " " + col);
        if (row < 1 || row > arrDim || col < 1 || col > arrDim)
            throw new IndexOutOfBoundsException("Illegal parameter value.");

        // passed values are in 1:N convetion , here, sice 2D to 1D conversion is involded, row convention changed to 0:(N-1)
        row = row - 1;
        col = col - 1;

        if(calledBefore(row,col)){
            // if the site is already  opened, do nothing
            System.out.println("called before");
        }
        else{

            int myIndex = convertTo1D(row,col);

//          System.out.println(" myIndex : " + myIndex);

            if(row == 0){
                state[row][col] = 'f';
            }
            else if(row == (arrDim - 1)){
                state[row][col] = 'o';
            }
            else{
                // if neither in top or bottom row just mark state as open n check for open neigbors, and connect them.
                state[row][col] = 'o';
            }
            // opening a site means connecting the newly opened site with its neighboring sites
            if(row < (arrDim - 1)){
                // do row + 1
                int neighborIndex = convertTo1D(row+1,col);
                if(isOpen(row+1,col)){ // ||
                    qu.union(myIndex, neighborIndex);
//                  System.out.print(" open connect row + 1 ");
                    state[row + 1][col] = state[row][col]; //  isOpen returns true, so state[row + 1][col] is open. thus it can only change to full if state[row][col] = 'f'
                                                            // state[row][col] is either full or open, so state[row + 1][col] has nothing to lose, only it can gain.

                }else if(isFull(row+1,col)){
                    qu.union(myIndex, neighborIndex);
//                  System.out.print(" full connect row + 1 ");
                    state[row][col] = 'f';
                }
            }
            if(row > 0){
                // do row - 1

                int neighborIndex = convertTo1D(row-1,col);
                if(isOpen(row-1,col)){// ||
                    qu.union(myIndex, neighborIndex);
//                  System.out.print(" open connect row - 1");
                    state[row - 1][col] = state[row][col];

                }else if(isFull(row-1,col)){
                    qu.union(myIndex, neighborIndex);
//                  System.out.print(" full connect row - 1 ");
                    state[row][col] = 'f';
                }
            }
            if(col < (arrDim - 1)){
                // do col + 1

                int neighborIndex = convertTo1D(row,col+1);
                if(isOpen(row,col + 1)){ // ||
                    qu.union(myIndex, neighborIndex);
//                  System.out.print(" open connect col + 1");
                    state[row][col + 1] = state[row][col];

                }else if(isFull(row,col + 1)){
                    qu.union(myIndex, neighborIndex);
//                  System.out.print(" full connect col + 1 ");
                    state[row][col] = 'f';
                }
            }
            if(col > 0){
                // do col - 1

                int neighborIndex = convertTo1D(row,col-1);
                if(isOpen(row,col - 1)){ //
                    qu.union(myIndex, neighborIndex);
//                  System.out.print(" open connect col - 1\n");
                    state[row][col - 1] = state[row][col];

                }else if(isFull(row,col - 1)){
                    qu.union(myIndex, neighborIndex);
//                  System.out.print(" full connect col - 1 ");
                    state[row][col] = 'f';
                }
            }
        }


    }
    public boolean isOpen(int row, int col){
        return (state[row][col] == 'o');
    }
    public boolean isFull(int row, int col){
        return (state[row][col] == 'f');
        //return (qu.rootOf(convertTo1D(row,col)) == 0);
    }
    public boolean calledBefore(int row, int col){
        return (state[row][col] == '0' || state[row][col] == 'f');
    }
    public boolean percolates(){
//      System.out.println("in percolates: returning: ");
        if(qu.connected(top, bottom)){
            System.out.println("\n\n percolates: true");
            return true;
        }
        else{
//          System.out.println("false");
            return false;
        }
    }

    public static void main(String[] args){
        final long startTime = System.nanoTime();
//      System.out.println("enter size: ");
//      int size = StdIn.readInt() ;
        int size=200;
        Percolation perC = new Percolation(size);
//      System.out.println("enter number of iterations: ");
//      int numOfRuns = StdIn.readInt();

        for(;;){
            int row = (int)(Math.random()*size + 1);
            int column = (int)(Math.random()*size + 1);
//          System.out.format("\n row n column: %d %d",row,column);
//          int row = StdIn.readInt();
//          int column = StdIn.readInt();
            if((row<1 || row>size) || (column < 1 || column > size )) throw new java.lang.IndexOutOfBoundsException("entered value is not valid \n");

            perC.open(row,column);
            if(perC.percolates()){
                System.out.println("percolates");
                break;
            }

        }

        final long endTime = System.nanoTime();
        final long constructionDuration = perC.constructionTime - startTime;
        final long runningDuration = endTime - perC.constructionTime;
        final long totalDuration = System.nanoTime() - startTime;
        System.out.println("\n\n construction time: " + constructionDuration + "\n running duration: " + runningDuration);
        System.out.println(" total running time: " + totalDuration);
    }


}