Welcome to Subscribe On Youtube

335. Self Crossing

Description

You are given an array of integers distance.

You start at the point (0, 0) on an X-Y plane, and you move distance[0] meters to the north, then distance[1] meters to the west, distance[2] meters to the south, distance[3] meters to the east, and so on. In other words, after each move, your direction changes counter-clockwise.

Return true if your path crosses itself or false if it does not.

 

Example 1:

Input: distance = [2,1,1,2]
Output: true
Explanation: The path crosses itself at the point (0, 1).

Example 2:

Input: distance = [1,2,3,4]
Output: false
Explanation: The path does not cross itself at any point.

Example 3:

Input: distance = [1,1,1,2,1]
Output: true
Explanation: The path crosses itself at the point (0, 0).

 

Constraints:

• 1 <= distance.length <= 105
• 1 <= distance[i] <= 105

Solutions

                i-2
    case 1 : i-1┌─┐
                └─┼─>i
                 i-3

                   i-2
    case 2 : i-1 ┌────┐
                 └─══>┘i-3
                 i  i-4

    case 3 :    i-4
               ┌──┐
               │i<┼─┐
            i-3│ i-5│i-1
               └────┘
                i-2

• Java
• C++
• Python
• Go
• C#

• class Solution {
      public boolean isSelfCrossing(int[] distance) {
          int[] d = distance;
          for (int i = 3; i < d.length; ++i) {
              if (d[i] >= d[i - 2] && d[i - 1] <= d[i - 3]) {
                  return true;
              }
              if (i >= 4 && d[i - 1] == d[i - 3] && d[i] + d[i - 4] >= d[i - 2]) {
                  return true;
              }
              if (i >= 5 && d[i - 2] >= d[i - 4] && d[i - 1] <= d[i - 3]
                  && d[i] >= d[i - 2] - d[i - 4] && d[i - 1] + d[i - 5] >= d[i - 3]) {
                  return true;
              }
          }
          return false;
      }
  }
  

• class Solution {
  public:
      bool isSelfCrossing(vector<int>& distance) {
          vector<int> d = distance;
          for (int i = 3; i < d.size(); ++i) {
              if (d[i] >= d[i - 2] && d[i - 1] <= d[i - 3]) return true;
              if (i >= 4 && d[i - 1] == d[i - 3] && d[i] + d[i - 4] >= d[i - 2]) return true;
              if (i >= 5 && d[i - 2] >= d[i - 4] && d[i - 1] <= d[i - 3] && d[i] >= d[i - 2] - d[i - 4] && d[i - 1] + d[i - 5] >= d[i - 3]) return true;
          }
          return false;
      }
  };
  

• class Solution:
      def isSelfCrossing(self, distance: List[int]) -> bool:
          d = distance
          for i in range(3, len(d)):
              if d[i] >= d[i - 2] and d[i - 1] <= d[i - 3]:
                  return True
              if i >= 4 and d[i - 1] == d[i - 3] and d[i] + d[i - 4] >= d[i - 2]:
                  return True
              if (
                  i >= 5
                  and d[i - 2] >= d[i - 4]
                  and d[i - 1] <= d[i - 3]
                  and d[i] >= d[i - 2] - d[i - 4]
                  and d[i - 1] + d[i - 5] >= d[i - 3]
              ):
                  return True
          return False
  
  

• func isSelfCrossing(distance []int) bool {
  	d := distance
  	for i := 3; i < len(d); i++ {
  		if d[i] >= d[i-2] && d[i-1] <= d[i-3] {
  			return true
  		}
  		if i >= 4 && d[i-1] == d[i-3] && d[i]+d[i-4] >= d[i-2] {
  			return true
  		}
  		if i >= 5 && d[i-2] >= d[i-4] && d[i-1] <= d[i-3] && d[i] >= d[i-2]-d[i-4] && d[i-1]+d[i-5] >= d[i-3] {
  			return true
  		}
  	}
  	return false
  }
  

• public class Solution {
      public bool IsSelfCrossing(int[] x) {
          for (var i = 3; i < x.Length; ++i)
          {
              if (x[i] >= x[i - 2] && x[i - 1] <= x[i - 3]) return true;
              if (i > 3 && x[i] + x[i - 4] >= x[i - 2])
              {
                  if (x[i - 1] == x[i - 3]) return true;
                  if (i > 4 && x[i - 2] >= x[i - 4] && x[i - 1] <= x[i - 3] && x[i - 1] + x[i - 5] >= x[i - 3]) return true;
              }
          }
          return false;
      }
  }
  

All Problems

All Solutions