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