1. The key that names a direction

Fix one point, the anchor $(x_1, y_1)$. Any other point $(x_2, y_2)$ lies in some direction from it. Write that direction as the step from the anchor to the point:

$dx = x_2 - x_1 \qquad dy = y_2 - y_1$

Two points lie on the same line through the anchor when their steps point the same way or exactly opposite ways. The steps $(2, 1)$ and $(4, 2)$ and $(-2, -1)$ all describe the same line. The code needs one canonical key for each line: a single value that every point of that line produces, and no point of another line produces.

2. Building the key for one pair

The code builds the key in two steps.

First it divides both parts by $g = \gcd(dx, dy)$, the greatest common divisor. Python's math.gcd always returns a non-negative number, and $g > 0$ here because all points are different. After the division, the two parts have no common factor left. So $(4, 2)$ and $(2, 1)$ both become $(2, 1)$. The key stores $dy$ first, as (dy // g, dx // g). The division is exact, because $g$ divides both parts.

Then it fixes the sign, because $(2, 1)$ and $(-2, -1)$ are still different pairs. The rule makes the first part positive, or, when the first part is 0, makes the second part positive:

A vertical line has $dx = 0$, so $g = |dy|$ and the key is $(1, 0)$ or $(-1, 0)$. The sign fix makes it $(1, 0)$. No division by zero ever happens.

3. Why equal keys mean one line

Two points with the same key have steps from the anchor that are whole multiples of the same reduced pair. So both lie on the one line through the anchor in that direction. Two points on different lines through the anchor have directions that are not multiples of each other. After dividing by the gcd and fixing the sign, their keys differ. A line through the anchor is fully fixed by one point and its direction, so counting equal keys counts the points on each line.

For each anchor, slopes[key] counts the other points on the line with that key. The line also holds the anchor itself, so it has slopes[key] + 1 points.

4. Why later points are enough, and the small inputs

The inner loop only looks at points with index $j > i$. That is enough. Take the line with the most points, and let $i$ be the smallest index among them. When the anchor is point $i$, all the other points of that line have larger indices, so they are all counted.

With one or two points, every point is on one line, so the code returns len(points) at once. The loops would return 0 for a single point, because they never run a pair.

5. Example 2 by hand

points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]].

The picture shows the six points, labelled by index. Points 1, 3, 4 and 5 are $(3, 2)$, $(4, 1)$, $(2, 3)$ and $(1, 4)$. They lie on the line $x + y = 5$, which falls by 1 for every step of 1 to the right.

The smallest index on that line is 1, so the anchor $(3, 2)$ finds it:

Row j = 3 shows why the sign fix is needed. Before it, $(4, 1)$ gives $(-1, 1)$ and $(2, 3)$ gives $(1, -1)$. Both points are on the same line, but their pairs differ. After the fix, both keys are $(1, -1)$. Row j = 5 shows why the gcd is needed. Its step $(-2, 2)$ is twice the step of row j = 4, and dividing by $g = 2$ gives the same key.

After row j = 5, the key $(1, -1)$ has count 3, so this line holds $3 + 1 = 4$ points. No anchor finds a larger count, so the code returns 4, the expected output.

6. Example 1 by hand

points = [[1,1],[2,2],[3,3]]. With the anchor $(1, 1)$, the point $(2, 2)$ has step $(1, 1)$ and key $(1, 1)$. The point $(3, 3)$ has step $(2, 2)$. Its gcd is 2, so its key is also $(1, 1)$. The count for $(1, 1)$ reaches 2, so the line holds $2 + 1 = 3$ points. The code returns 3, the expected output.

7. From the math to the code

The two loops look at every pair once, and each key takes one gcd. Under LeetCode's limits every coordinate difference is at most $2 \cdot 10^4$, so one gcd takes a bounded number of steps. So the code takes $O(n^2)$ time. The map for one anchor holds at most $n - 1$ keys, so it uses $O(n)$ space.