LeetCode-Self Crossing

You are given an array x of n positive numbers. You start at point (0,0) and moves x[0] metres to the north, then x[1] metres to the west, x[2] metres to the south, x[3] metres to the east and so on. In other words, after each move your direction changes counter-clockwise.

Write a one-pass algorithm with O(1) extra space to determine, if your path crosses itself, or not.

Example 1:

Given x = [2, 1, 1, 2],
┌───┐
│   │
└───┼──>
    │

Return true (self crossing)

Example 2:

Given x = [1, 2, 3, 4],
┌──────┐
│      │
│
│
└────────────>

Return false (not self crossing)

Example 3:

Given x = [1, 1, 1, 1],
┌───┐
│   │
└───┼>

Return true (self crossing)

Analysis:
　　There are two possible modes: 1. Area is expanding, and 2. Area is shrinking. We need to identify the current mode.

　　For shrinking mode, let current index be i, then if x[i] < x[i-2], x[i] is safe.
　　For expanding mode, it is more complicated. For index i, there are 3 possible situations:
　　　　1. x[i] > x[i-2]: still expanding mode, safe
　　　　2. x[i] < x[i-2] - x[i-4]: switch to shrink mode, but safe
　　　　3. x[i] >= x[i-2] - x[i-4]: switch to shrink mode, but possibly not safe, we need further determine, see the code. 

Solution:

public class Solution {
    public boolean isSelfCrossingExpand(int[] x, int start){
        for (int i=start;i<x.length;i++){
            if (x[i] > x[i-2]){
                continue;
            } else {
                // becomes shrink mode
                int bar = (i>=4) ? x[i-4] : 0;
                if (x[i] <= x[i-2] && x[i] >= (x[i-2] - bar)){
                    if ( i+1 == x.length){
                        return false;
                    }
                    if (x[i+1] >= (x[i-1] - x[i-3])){
                        return true;
                    }
                    return isSelfCrossingShrink(x,i+2);
                } else {
                    return isSelfCrossingShrink(x,i+1);
                }
            }        
        }
        return false;
    }

    public boolean isSelfCrossingShrink(int[] x, int start){
        for (int i=start; i<x.length;i++){
            if (x[i] >= x[i-2])
                return true;
        }
        return false;
    }
    public boolean isSelfCrossing(int[] x) {
        if (x.length<=3) return false;

        if (x[2] <= x[0]) return isSelfCrossingShrink(x,3);        
        return isSelfCrossingExpand(x,3);
        
    }
}