给定N点的线数不平行于X或Y轴

在2D平面上给定N个不同的整数点。任务是计算由给定的N个点形成的，不平行于X轴或Y轴的线的数量

例子：

Input: points[][] = {{1, 2}, {1, 5}, {1, 15}, {2, 10}}
Output: 3
Choosen pairs are {(1, 2), (2, 10)}, {(1, 5), (2, 10)}, {(1, 15), (2, 10)}.

Input: points[][] = {{1, 2}, {2, 5}, {3, 15}}
Output: 3
Choose any pair of points.

方法：

1. 我们知道
   • 通过连接任意两点形成的线，如果它们具有相同的Y坐标，则它们将平行于X轴
   • 如果它们具有相同的X坐标，则它将平行于Y轴。
2. 可以由N个点形成的线段总数= $\binom{N}{2}= \frac{N*(N-1)}{2}$
3. 现在，我们将排除那些平行于X轴或Y轴的线段。
4. 对于每个X坐标和Y坐标，计算点数并在末端排除那些线段。

下面是上述方法的实现：

C++

// C++ program to find the number
// of lines which are formed from
// given N points and not parallel
// to X or Y axis
  
#include 
using namespace std;
  
// Function to find the number of lines
// which are formed from given N points
// and not parallel to X or Y axis
int NotParallel(int p[][2], int n)
{
    // This will store the number of points has
    // same x or y coordinates using the map as
    // the value of coordinate can be very large
    map x_axis, y_axis;
  
    for (int i = 0; i < n; i++) {
  
        // Counting frequency of each x and y
        // coordinates
        x_axis[p[i][0]]++;
        y_axis[p[i][1]]++;
    }
  
    // Total number of pairs can be formed
    int total = (n * (n - 1)) / 2;
  
    for (auto i : x_axis) {
        int c = i.second;
  
        // We can not choose pairs from these as
        // they have same x coordinatethus they
        // will result line segment
        // parallel to y axis
        total -= (c * (c - 1)) / 2;
    }
  
    for (auto i : y_axis) {
        int c = i.second;
  
        // we can not choose pairs from these as
        // they have same y coordinate thus they
        // will result line segment
        // parallel to x-axis
        total -= (c * (c - 1)) / 2;
    }
  
    // Return the required answer
    return total;
}
  
// Driver Code
int main()
{
  
    int p[][2] = { { 1, 2 },
                   { 1, 5 },
                   { 1, 15 },
                   { 2, 10 } };
  
    int n = sizeof(p) / sizeof(p[0]);
  
    // Function call
    cout << NotParallel(p, n);
  
    return 0;
}

Java

// Java program to find the number
// of lines which are formed from
// given N points and not parallel
// to X or Y axis
import java.util.*;
  
class GFG{
   
// Function to find the number of lines
// which are formed from given N points
// and not parallel to X or Y axis
static int NotParallel(int p[][], int n)
{
    // This will store the number of points has
    // same x or y coordinates using the map as
    // the value of coordinate can be very large
    HashMap x_axis = new HashMap();
    HashMap y_axis = new HashMap();
   
    for (int i = 0; i < n; i++) {
   
        // Counting frequency of each x and y
        // coordinates
        if(x_axis.containsKey(p[i][0]))
            x_axis.put(p[i][0], x_axis.get(p[i][0])+1);
        else
            x_axis.put(p[i][0], 1);
        if(y_axis.containsKey(p[i][1]))
            y_axis.put(p[i][1], y_axis.get(p[i][1])+1);
        else
            y_axis.put(p[i][1], 1);
    }
   
    // Total number of pairs can be formed
    int total = (n * (n - 1)) / 2;
   
    for (Map.Entry i : x_axis.entrySet()) {
        int c = i.getValue();
   
        // We can not choose pairs from these as
        // they have same x coordinatethus they
        // will result line segment
        // parallel to y axis
        total -= (c * (c - 1)) / 2;
    }
   
    for (Map.Entry i : y_axis.entrySet()) {
        int c = i.getValue();
   
        // we can not choose pairs from these as
        // they have same y coordinate thus they
        // will result line segment
        // parallel to x-axis
        total -= (c * (c - 1)) / 2;
    }
   
    // Return the required answer
    return total;
}
   
// Driver Code
public static void main(String[] args)
{
   
    int p[][] = { { 1, 2 },
                   { 1, 5 },
                   { 1, 15 },
                   { 2, 10 } };
   
    int n = p.length;
   
    // Function call
    System.out.print(NotParallel(p, n));
   
}
}
  
// This code is contributed by PrinciRaj1992

C#

// C# program to find the number
// of lines which are formed from
// given N points and not parallel
// to X or Y axis
using System;
using System.Collections.Generic;
  
class GFG{
    
// Function to find the number of lines
// which are formed from given N points
// and not parallel to X or Y axis
static int NotParallel(int [,]p, int n)
{
    // This will store the number of points has
    // same x or y coordinates using the map as
    // the value of coordinate can be very large
    Dictionary x_axis = new Dictionary();
    Dictionary y_axis = new Dictionary();
    
    for (int i = 0; i < n; i++) {
    
        // Counting frequency of each x and y
        // coordinates
        if(x_axis.ContainsKey(p[i, 0]))
            x_axis[p[i, 0]] = x_axis[p[i, 0]] + 1;
        else
            x_axis.Add(p[i, 0], 1);
        if(y_axis.ContainsKey(p[i, 1]))
            y_axis[p[i, 1]] = y_axis[p[i, 1]] + 1;
        else
            y_axis.Add(p[i, 1], 1);
    }
    
    // Total number of pairs can be formed
    int total = (n * (n - 1)) / 2;
    
    foreach (KeyValuePair i in x_axis) {
        int c = i.Value;
    
        // We can not choose pairs from these as
        // they have same x coordinatethus they
        // will result line segment
        // parallel to y axis
        total -= (c * (c - 1)) / 2;
    }
    
    foreach (KeyValuePair i in y_axis) {
        int c = i.Value;
    
        // we can not choose pairs from these as
        // they have same y coordinate thus they
        // will result line segment
        // parallel to x-axis
        total -= (c * (c - 1)) / 2;
    }
    
    // Return the required answer
    return total;
}
    
// Driver Code
public static void Main(String[] args)
{
    
    int [,]p = { { 1, 2 },
                   { 1, 5 },
                   { 1, 15 },
                   { 2, 10 } };
    
    int n = p.GetLength(0);
    
    // Function call
    Console.Write(NotParallel(p, n));  
}
}
  
// This code is contributed by Princi Singh

Python3

# Python3 program to find the number 
# of lines which are formed from 
# given N points and not parallel 
# to X or Y axis 
  
# Function to find the number of lines 
# which are formed from given N points 
# and not parallel to X or Y axis 
def NotParallel(p, n) : 
  
    # This will store the number of points has 
    # same x or y coordinates using the map as 
    # the value of coordinate can be very large 
    x_axis  = {}; y_axis = {}; 
  
    for i in range(n) :
  
        # Counting frequency of each x and y 
        # coordinates 
        if p[i][0] not in x_axis :
            x_axis[p[i][0]] = 0;
              
        x_axis[p[i][0]] += 1; 
  
        if p[i][1] not in y_axis :
            y_axis[p[i][1]] = 0;
          
        y_axis[p[i][1]] += 1; 
  
    # Total number of pairs can be formed 
    total = (n * (n - 1)) // 2; 
  
    for i in x_axis :
        c =  x_axis[i]; 
  
        # We can not choose pairs from these as 
        # they have same x coordinatethus they 
        # will result line segment 
        # parallel to y axis 
        total -= (c * (c - 1)) // 2; 
  
    for i in y_axis : 
        c = y_axis[i]; 
  
        # we can not choose pairs from these as 
        # they have same y coordinate thus they 
        # will result line segment 
        # parallel to x-axis 
        total -= (c * (c - 1)) // 2; 
      
    # Return the required answer 
    return total; 
  
  
# Driver Code 
if __name__ == "__main__" : 
  
    p = [ [ 1, 2 ], 
            [1, 5 ], 
            [1, 15 ], 
            [ 2, 10 ] ]; 
  
    n = len(p); 
  
    # Function call 
    print(NotParallel(p, n)); 
  
    # This code is contributed by AnkitRai01

输出：

3

时间复杂度： O(N)