Leetcode: Convex Polygon

Given a list of points that form a polygon when joined sequentially, find if this polygon is convex (Convex polygon definition).

Note:

There are at least 3 and at most 10,000 points.
Coordinates are in the range -10,000 to 10,000.
You may assume the polygon formed by given points is always a simple polygon (Simple polygon definition). In other words, we ensure that exactly two edges intersect at each vertex, and that edges otherwise don't intersect each other.
Example 1:

[[0,0],[0,1],[1,1],[1,0]]

Answer: True

Explanation:

Example 2: [[0,0],[0,10],[10,10],[10,0],[5,5]] 

Answer: False 

Explanation:

https://discuss.leetcode.com/topic/70706/beyond-my-knowledge-java-solution-with-in-line-explanation

https://discuss.leetcode.com/topic/70664/c-7-line-o-n-solution-to-check-convexity-with-cross-product-of-adajcent-vectors-detailed-explanation

The key observation for convexity is that vector pi+1-pi always turns to the same direction to pi+2-pi formed by any 3 sequentially adjacent vertices, i.e., cross product (pi+1-pi) x (pi+2-pi) does not change sign when traversing sequentially along polygon vertices.

Note that for any 2D vectors v1, v2,

• v1 x v2 = det([v1, v2])

which is the determinant of 2x2 matrix [v1, v2]. And the sign of det([v1, v2]) represents the positive z-direction of right-hand system from v1 to v2. So det([v1, v2]) ≥ 0 if and only if v1 turns at most 180 degrees counterclockwise to v2.

 public class Solution {
     public boolean isConvex(List<List<Integer>> points) {
         // For each set of three adjacent points A, B, C, find the cross product AB · BC. If the sign of
         // all the cross products is the same, the angles are all positive or negative (depending on the
         // order in which we visit them) so the polygon is convex.
         boolean gotNegative = false;
         boolean gotPositive = false;
         int numPoints = points.size();
         int B, C;
         for (int A = 0; A < numPoints; A++) {
             // Trick to calc the last 3 points: n - 1, 0 and 1.
             B = (A + 1) % numPoints;
             C = (B + 1) % numPoints;

             int crossProduct =
                 crossProductLength(
                     points.get(A).get(0), points.get(A).get(1),
                     points.get(B).get(0), points.get(B).get(1),
                     points.get(C).get(0), points.get(C).get(1));
             if (crossProduct < 0) {
                 gotNegative = true;
             }
             else if (crossProduct > 0) {
                 gotPositive = true;
             }
             if (gotNegative && gotPositive) return false;
         }

         // If we got this far, the polygon is convex.
         return true;
     }

     // Return the cross product AB x BC.
     // The cross product is a vector perpendicular to AB and BC having length |AB| * |BC| * Sin(theta) and
     // with direction given by the right-hand rule. For two vectors in the X-Y plane, the result is a
     // vector with X and Y components 0 so the Z component gives the vector's length and direction.
     private int crossProductLength(int Ax, int Ay, int Bx, int By, int Cx, int Cy)
     {
         // Get the vectors' coordinates.
         int ABx = Bx - Ax;
         int ABy = By - Ay;
         int BCx = Cx - Bx;
         int BCy = Cy - By;

         // Calculate the Z coordinate of the cross product.
         return (ABx * BCy - ABy * BCx);
     }
 }