LeetCode题练习与总结：直线上最多的点数--149

一、题目描述

给你一个数组 points ，其中 points[i] = [xi, yi] 表示 X-Y 平面上的一个点。求最多有多少个点在同一条直线上。

示例 1：

输入：points = [[1,1],[2,2],[3,3]]
输出：3

示例 2：

输入：points = [[1,1],[3,2],[5,3],[4,1],[2,3],[1,4]]
输出：4

提示：

• 1 <= points.length <= 300
• points[i].length == 2
• -10^4 <= xi, yi <= 10^4
• points 中的所有点 互不相同

二、解题思路

首先，我们需要明确两个点可以确定一条直线。因此，我们可以遍历所有点对，计算它们之间的斜率，如果斜率相同，则这两个点在同一条直线上。

为了计算斜率，我们可以使用数学中的公式：

斜率 k = (y2 - y1) / (x2 - x1)

为了避免除以0的情况，我们可以使用最大公约数（GCD）来简化分数。

算法步骤：

1. 初始化一个HashMap，用于存储斜率和对应的点数。
2. 遍历所有点对，计算它们之间的斜率。
3. 如果斜率已经在HashMap中，则将对应的点数加1；否则，将斜率添加到HashMap中，并设置点数为1。
4. 遍历HashMap，找到最大的点数，即为答案。

三、具体代码

import java.util.HashMap;

public class Solution {
    public int maxPoints(int[][] points) {
        int n = points.length;
        if (n <= 2) {
            return n;
        }
        
        int result = 0;
        for (int i = 0; i < n; i++) {
            HashMap<String, Integer> map = new HashMap<>();
            int duplicate = 0;
            int max = 0;
            for (int j = i + 1; j < n; j++) {
                int x = points[j][0] - points[i][0];
                int y = points[j][1] - points[i][1];
                
                if (x == 0 && y == 0) {
                    duplicate++;
                    continue;
                }
                
                int gcd = generateGCD(x, y);
                x /= gcd;
                y /= gcd;
                
                String key = x + "," + y;
                map.put(key, map.getOrDefault(key, 0) + 1);
                max = Math.max(max, map.get(key));
            }
            
            result = Math.max(result, max + duplicate + 1);
        }
        
        return result;
    }
    
    private int generateGCD(int a, int b) {
        if (b == 0) {
            return a;
        }
        return generateGCD(b, a % b);
    }
}

四、时间复杂度和空间复杂度

1. 时间复杂度

• 外层循环遍历所有的点，共有n个点，因此外层循环的时间复杂度为O(n)。
• 内层循环遍历除了当前点之外的所有点，因此内层循环的时间复杂度也为O(n)。
• 在内层循环中，对于每一对点，我们需要计算它们的斜率，并简化为最简分数形式。计算最大公约数（GCD）的时间复杂度为O(log(m))，其中m是坐标值的最大差值。
• 因此，内层循环中每一对点的处理时间复杂度为O(log(m))。
• 综合以上分析，总的时间复杂度为O(n^2 * log(m))。

2. 空间复杂度

• 我们使用了一个HashMap来存储斜率和对应的点数。在最坏的情况下，所有的点都在同一条直线上，此时HashMap中只有一个键值对。因此，空间复杂度为O(1)。
• 但是，在计算过程中，我们使用了递归函数来计算最大公约数（GCD）。在最坏的情况下，递归的深度为O(log(m))，因此递归栈的空间复杂度为O(log(m))。
• 综合以上分析，总的空间复杂度为O(log(m))。

综上所述，该算法的时间复杂度为O(n^2 * log(m))，空间复杂度为O(log(m))。

五、总结知识点

1. 数组操作：使用二维数组points来存储点的坐标，其中points[i][0]和points[i][1]分别表示第i个点的x坐标和y坐标。

2. 循环结构：使用了两层循环来遍历所有点对，外层循环用于选取参考点，内层循环用于选取其他点。

3. 散列表（HashMap）：使用HashMap来存储直线的斜率（用字符串表示）和该斜率对应的点数。HashMap是一种关联数组，它允许我们以键值对的形式存储数据，并且可以快速检索数据。

4. 最大公约数（GCD）：使用了一个辅助函数generateGCD来计算两个整数的最大公约数。最大公约数是数学中的一个概念，用于简化分数。

5. 斜率计算：计算两点之间的斜率，公式为(y2 - y1) / (x2 - x1)。为了避免除以0的情况，代码中使用了最大公约数来简化分数。

6. 字符串操作：使用字符串来表示斜率，将x和y坐标的比值转换为字符串形式，作为HashMap的键。

7. 逻辑判断：使用条件语句（if）来判断两点是否重合，以及如何处理重合点。

8. 数学运算：进行了整数除法、取余等基本数学运算。

9. 递归：在计算最大公约数时，使用了递归函数。递归是一种常见的编程技巧，它允许函数调用自身。

10. 函数默认值：在HashMap的getOrDefault方法中，如果键不存在，则返回一个默认值。

11. 最大值追踪：使用变量max来追踪当前最大的点数，使用Math.max函数来更新最大值。

12. 结果更新：使用变量result来存储最终的结果，并在每次内层循环结束后更新它。

以上就是解决这个问题的详细步骤，希望能够为各位提供启发和帮助。