Leecode335

You are given an array x of n positive numbers. You start at point x[0] metres to the north, then 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)
这个问题一开始真是想的太简单了，以为每四个一组之后重置相对原点坐标来算就可以，而忽略了很多情况，比如：完全可能前四个没相遇，但在第五步的时候去和之前的轨迹相交！
所以看了一下hint，提示要用binary tree。怎么处理呢？
这里参考了下Marshall专栏的解法，分x.size()<4,=4,>4的情况来讨论。【感觉没有用到二叉树的内容】找规律的时候发现，只需要看每一步x[n]是否比它之前两步x[n-2]的距离长,如果长则交不上，
而比其短则有可能相交，再继续判断。

    class Solution {  
    public:  
        bool isSelfCrossing(vector<int>& x) {  
            if(x.size()<4)  
                return false;  
            if(x.size()==4)  
            {  
                if(x[2]>x[0])  
                    return false;  
                else if(x[3]>=x[1])  
                    return true;  
                else  
                    return false;  
            }  
            int k=2;  
            while(k<x.size()&&x[k]>x[k-2])  
            {  
                k++;  
            }  
            if(k==x.size())  
                return false;  
            else if(x[k]<x[k-2]-x[k-4])  
            {  
                k++;  
                while(k<x.size()&&x[k]<x[k-2])  
                    k++;  
                if(k==x.size())  
                    return false;  
                else  
                    return true;  
            }  
            else  
            {  
                k++;  
                if(k==x.size())  
                    return false;  
                else   
                {  
                    if(x[k]>=x[k-2]-x[k-4])  
                        return true;  
                    else  
                    {  
                        k++;  
                        while(k<x.size()&&x[k]<x[k-2])  
                            k++;  
                        if(k==x.size())  
                            return false;  
                        else  
                            return true;  
                    }  
                }  
            }  
        }  
    };