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;
}
}
}
}
};