解題思路

• 重複的點沒有必要去增加時間複雜度，
  先把point點簡化成沒有重複的新陣列norepeatvalues以及記錄每個新陣列的成員point對應的重複次數repeatcounts陣列；
• 兩個點可以確定一條直線，假設有一個起始點Point[i]和Point[j],它們倆相連的斜率為k,其它只要和它們相連的點必定與它們在同一條直線上；當然，斜率不存在的極端情況也是要考慮在內的，斜率不存在的點，它們點X座標必定一樣；
• 由於norepeatvalues的長度和對應的點重複的個數陣列repeatcounts長度不定，所以採用ArrayList陣列；

import java.util.ArrayList;
import java.util.Scanner;

public
 
 class Main {
    static class Point {
        int x;
        int y;
        Point(int a, int b) {
            x = a;
            y = b;
        }
    }
    public static int maxPoints(Point[] points) {
        // Write your code here
        if (points == null) {
            return 0;
        }
        int
 
 maxcount = 0;
        int len = points.length;
        if (len < 2) {
            return len;
        }
        ArrayList<Point> norepeatvalues = new ArrayList<Point>();// 簡化陣列，記錄不重複的陣列
        ArrayList<Integer> repeatcounts = new ArrayList<Integer>();// 簡化陣列，記錄norepeatvalues.get[i]的元素對應的在Point數組裡面擁有的元素的重複個數
 

        for (int i = 0; i < len; i++) {
            int repeatcount = 0;
            boolean isrepeatnum = false;
            for (int m = 0; m < norepeatvalues.size(); m++) {
                // 判斷這個Point是否是記錄已經存在的
                if (norepeatvalues.get(m).x == points[i].x && points[i].y == norepeatvalues.get(m).y) {
                    isrepeatnum = true;
                    break;
                }
            }
            if (!isrepeatnum) {
                // 這個Point不是norepeatvalues記錄已經存在的，則繼續
                for (int j = i + 1; j < len; j++) {
                    if (points[i].x == points[j].x && points[i].y == points[j].y) {
                        // repeatcounts陣列記錄有多少個和points[i]相同的點
                        repeatcount++;
                    }
                }
                norepeatvalues.add(points[i]);
                repeatcounts.add(repeatcount);
            }
        }
        len = norepeatvalues.size();
        if (len == 1) {
            // 如果只有一個非重複元素
            return len + repeatcounts.get(0);
        }

        for (int i = 0; i < len - 1; i++) {
            for (int j = i + 1; j < len; j++) {
                int tempcount = 2 + repeatcounts.get(i) + repeatcounts.get(j);
                float k = 0f;
                boolean hasK = true;// 判斷斜率是否存在
                if (norepeatvalues.get(i).x == norepeatvalues.get(j).x) {
                    hasK = false;
                } else {
                    k = (float) (norepeatvalues.get(i).y - norepeatvalues.get(j).y)
                            / (norepeatvalues.get(i).x - norepeatvalues.get(j).x);
                }
                float b = norepeatvalues.get(i).y - k * norepeatvalues.get(i).x;
                for (int m = j + 1; m < len; m++) {
                    if (hasK) {
                        // 斜率存在
                        float curk = (float) (norepeatvalues.get(i).y - norepeatvalues.get(m).y)
                                / (norepeatvalues.get(i).x - norepeatvalues.get(m).x);
                        if (curk == k) {
                            tempcount = tempcount + repeatcounts.get(m) + 1;
                        }
                    } else {
                        // 斜率不存在
                        if (norepeatvalues.get(i).x == norepeatvalues.get(m).x) {
                            tempcount = tempcount + repeatcounts.get(m) + 1;
                        }
                    }
                }
                if (tempcount > maxcount) {
                    maxcount = tempcount;
                }
            }
        }
        return maxcount;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Point[] data = new Point[n];
        for (int i = 0; i < n; i++) {
            data[i] = new Point(sc.nextInt(), sc.nextInt());
        }
        System.out.println(maxPoints(data));
    }
}