SkipStones

/*Problem Statement

When a stone is thrown across water, sometimes it will land on the water and bounce rather than falling in right away.

Suppose that a stone is thrown a distance of n. On each successive bounce it will travel half the distance as the previous bounce (rounded down to the nearest integer).

When it can not travel any further, it falls into the water.

If, at any point, the stone lands on an obstruction rather than water, it will not bounce, but will simply deflect and fall into the water.

Please look at the figure for further clarification (with black, red and green cells representing banks, obstructions and free water respectively).

So, if the stone is thrown a distance 7, it will bounce and travel a distance of 3, then finally a distance of 1,

having travelled a total distance of 11 (the green path in the figure).

If a stone is thrown a distance of 8, it will reach the opposite bank, and if thrown at distances of 2 or 6 it will hit an obstruction during its travel.

These are the three red paths in the figure.

You are given a String water. An ‘X’ represents an obstruction, while a ‘.’represents water free from obstruction.

You are to return an int representing the maximum distance a stone can travel and finally fall in the water, without hitting any obstructions,

and without reaching the opposite bank (going beyond the end of the string). You may choose any initial distance for the throw,

which starts from the left side of the string. A distance of 1 is the first character of the string, etc. If no initial throw will result in the stone

landing in the water without hitting an obstruction, return 0.


Definition：

Class:            SkipStones
Method:            maxDistance
Parameters:        String
Returns:        int
Method signature:    int maxDistance(String water)*/

package skipStones;

public class SkipStones {

    public static int maxDistance(String water) {
        int dis = initDistance(water.length());
       
        int[] distances = new int[dis];
        for(int i = 0; i < dis; i++) {
            distances[i] = i + 1;
        }
       
        int result = removeStone(distances, water);
       
        int temp = result;
        while((temp = temp/2) != 0) {
            result = result + temp;
        }
       
        return result;
    }
   
    private static int initDistance(int length) {
       
        int[] possibleTree = new int[length];
        int path = length - 1;
       
        for(int i=0; i < length; i++) {
            if(i == 0) {
                possibleTree[i] = path;
            } else {
                possibleTree[i] = possibleTree[i/2] - i - 1;
                if(possibleTree[i] == 0) return i + 1;
                else if(possibleTree[i] < 0) return i;
               
                if (i + 1 < length) {
                    possibleTree[i + 1] = possibleTree[i / 2] - i - 2;
                    if (possibleTree[i + 1] == 0) return i + 2;
                    else if (possibleTree[i + 1] < 0) return i + 1;

                    i++;
                }
            }
        }
        return 0;
    }
   
    private static int removeStone(int[] distances, String water) {
        char[] stones = water.toCharArray();
       
        for (int i = 0; i < stones.length; i++) {
            if (stones[i] == 'X') {
                if (i < distances.length) {
                    distances[i] = 0;
                }
                possibleDistance(distances, i + 1);
            }
        }
       
        for(int k = distances.length - 1; k >= 0; k--) {
            if(distances[k] != 0) return distances[k];
        }
       
        return 0;
    }
   
    private static void possibleDistance(int[] distances, int length) {
       
        int counter = 0;

        for(int i=0; i < distances.length; i++) {
            int temp = distances[i];
            if(temp == length) {
                distances[i] = 0;
            } else {
                int value = distances[i];
                while((temp = temp/2) != 0) {
                    value = value + temp;
                    if(value == length) {
                        distances[i] = 0;
                        break;
                    }
                }
            }
        }
    }
}