n 条线有多少个交点？

Question

问题是，给定 n 行，给出 x0, y0, x1, y1。 获取集合点的数量。 三条或更多条线相交是没有意义的。 线通过 (x0, y0), (x1, y1)。 不会有相同的线路。 我有一个想法是先声明一个HashMap，当有新的线路来的时候，得到它的slop。 如果斜率值不在 HashMap 中，则结果 = 结果 + 我们现在有多少行。 如果斜坡位于 HashMap 中，则结果 = 结果 +（我们现在有多少行 - 这个斜坡有多少行）。 这是我的主要代码部分。

public static void main(String[] args){
    Scanner in = new Scanner(System.in);
    int[][] lines = new int[in.nextInt()][4];
    Map<Double, Integer> map = new HashMap<>();
    int cross = 0;
    for(int i = 0; i< lines.length; i++){
        for(int j = 0; j< 4; j++)
            lines[i][j] = in.nextInt();
        double slop;
        if(lines[i][2] - lines[i][0] == 0)
            slop = Double.POSITIVE_INFINITY;
        else
            slop = (double)(lines[i][3] - lines[i][1]) / (lines[i][2] - lines[i][0]);
        if(!map.containsKey(slop)) {
            cross = cross + i;
            map.put(slop, 1);
        }else{
            cross = cross + (i - map.get(slop));
            map.put(slop, map.get(slop) + 1);
        }
    }
    System.out.print(cross + "\n");
}

但测试结果表明这是错误的。 有人可以帮我解决我没有注意到的情况，或者我的代码有什么问题吗？

Answer 1

任何一对不平行的线都会相交。

因此，交点数是唯一斜率数的多项式 function。

直线的斜率以Rise/Run形式给出，但直接使用此除法很危险，因为在浮点数学中4.2/2.2和8.4/4.4可能不会给出相同的结果。 同样，减去x0-x1可能会引入浮点怪异。

由于看起来好像您正在将坐标读取为整数，因此请考虑将斜率存储为(Rise,Run)对。 但请注意-Rise/Run和Rise/-Run看起来不同； 因此，制定一个约定，如果斜率为负，则该符号应存储在Rise中。 现在，简化您的分数，也许通过使用GCD 算法。

现在你有了一个独特而精确的斜率（比你以前的要好得多）。

现在，像以前一样继续：如果斜率是唯一的，那么斜率的数量会随着哈希集中已经存在的条目数的增加而增加。

Answer 2

这是一个不错的小问题。 由于我们正在处理线，并且我们知道同一条线不会出现两次，并且我们知道相同的交点不会出现两次，因此解决方案几乎就像每对线计算一个交点一样简单，即n * (n-1) / 2 。 但是，这假设每对线都有一个交点，如果任何线平行，则不成立； 所以我们需要计算每个斜率有多少条线共享相同的斜率。 看起来你已经想通了。

但是，从您的代码中不清楚您是否正确使用这些斜率计数来计算交叉点的数量。 在你的循环中有一些加法和减法，这很难解释。 如果您分两个不同的阶段执行此算法，则该算法会更简洁。

如果存在具有相同斜率的r线，则n * (n-1) / 2公式假设它们将使r * (r-1) / 2交点，但由于线是平行的，它们实际上使 0 个交点它们之间。 所以我们需要减去r * (r-1) / 2来修正计数。 我们需要为每个斜率独立地执行此操作。

所以算法可以如下工作：

• 构建一个 Map 的斜坡来计数。
• 将total初始化为n * (n-1) / 2 ，其中n是行数。
• 对于地图值中的每个计数r ，从总数中减去r * (r-1) / 2 。

这是一个实现：

import java.util.Map;
import java.util.HashMap;
import java.util.Scanner;

public class CountIntersections {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        long n = in.nextInt();

        Map<Double, Integer> slopeCounts = new HashMap<>();
        for(int i = 0; i < n; i++) {
            int x0 = in.nextInt(), y0 = in.nextInt(),
                x1 = in.nextInt(), y1 = in.nextInt();

            double slope;
            if(x0 == x1) {
                slope = Double.POSITIVE_INFINITY;
            } else {
                slope = (double) (y1 - y0) / (x1 - x0);
            }

            slopeCounts.put(slope, slopeCounts.getOrDefault(slope, 0) + 1);
        }

        long total = n * (n-1) / 2;
        for(long r : slopeCounts.values()) {
            total -= r * (r-1) / 2;
        }
        System.out.println(total);
    }
}

变量n 、 total和r被声明为long而不是int类型，这样乘法n * (n-1)就不会溢出。 这是n值和/或r大于约 46,000 的问题。

请注意，在这里将斜率计算为double没有问题。 从 Scanner 读取的数字是int s，所有这些都可以精确地表示为double s。 减法将是精确的，并且IEEE 754 规范保证浮点数的除法将被正确舍入。 因此，由于浮点运算，数值不精确不会导致计算两个相等的斜率略有不同。