覆盖所有点的最小线

给定二维空间中的 N 个点，我们需要打印穿过所有这些 N 个点并也穿过特定 (xO, yO) 点的最小行数。
例子：

If given points are (-1, 3), (4, 3), (2, 1), (-1, -2), 
(3, -3) and (xO, yO) point is (1, 0) i.e. every line
must go through this point. 
Then we have to draw at least two lines to cover all
these points going through (xO, yO) as shown in below
diagram.

我们可以通过考虑所有点的斜率（xO，yO）来解决这个问题。如果两个不同的点与 (xO, yO) 具有相同的斜率，那么它们只能被同一条线覆盖，这样我们就可以跟踪每个点的斜率，并且每当我们获得新的斜率时，我们都会将我们的线数增加 1。
在下面的代码中，斜率被存储为一对整数以摆脱精度问题，并使用一组来跟踪发生的斜率。
请参阅下面的代码以更好地理解。

CPP

// C++ program to get minimum lines to cover
// all the points
#include 
using namespace std;
 
//    Utility method to get gcd of a and b
int gcd(int a, int b)
{
    if (b == 0)
        return a;
    return gcd(b, a % b);
}
 
//    method returns reduced form of dy/dx as a pair
pair getReducedForm(int dy, int dx)
{
    int g = gcd(abs(dy), abs(dx));
 
    //    get sign of result
    bool sign = (dy < 0) ^ (dx < 0);
 
    if (sign)
        return make_pair(-abs(dy) / g, abs(dx) / g);
    else
        return make_pair(abs(dy) / g, abs(dx) / g);
}
 
/*    method returns minimum number of lines to
    cover all points where all lines goes
    through (xO, yO) */
int minLinesToCoverPoints(int points[][2], int N,
                                   int xO, int yO)
{
    //    set to store slope as a pair
    set< pair > st;
    pair temp;
    int minLines = 0;
 
    //    loop over all points once
    for (int i = 0; i < N; i++)
    {
        //    get x and y co-ordinate of current point
        int curX = points[i][0];
        int curY = points[i][1];
 
        temp = getReducedForm(curY - yO, curX - xO);
 
        // if this slope is not there in set,
        // increase ans by 1 and insert in set
        if (st.find(temp) == st.end())
        {
            st.insert(temp);
            minLines++;
        }
    }
 
    return minLines;
}
 
// Driver code to test above methods
int main()
{
    int xO, yO;
    xO = 1;
    yO = 0;
 
    int points[][2] =
    {
        {-1, 3},
        {4, 3},
        {2, 1},
        {-1, -2},
        {3, -3}
    };
 
    int N = sizeof(points) / sizeof(points[0]);
    cout << minLinesToCoverPoints(points, N, xO, yO);
    return 0;
}

Python3

# Python3 program to get minimum lines to cover
# all the points
 
# Utility method to get gcd of a and b
def gcd(a, b):
    if (b == 0):
        return a
    return gcd(b, a % b)
 
# method returns reduced form of dy/dx as a pair
def getReducedForm(dy, dx):
    g = gcd(abs(dy), abs(dx))
 
    # get sign of result
    sign = (dy < 0) ^ (dx < 0)
 
    if (sign):
        return (-abs(dy) // g, abs(dx) // g)
    else:
        return (abs(dy) // g, abs(dx) // g)
 
# /* method returns minimum number of lines to
#     cover all points where all lines goes
#     through (xO, yO) */
def minLinesToCoverPoints(points, N, xO, yO):
     
    # set to store slope as a pair
    st = dict()
    minLines = 0
 
    # loop over all points once
    for i in range(N):
         
        # get x and y co-ordinate of current point
        curX = points[i][0]
        curY = points[i][1]
 
        temp = getReducedForm(curY - yO, curX - xO)
 
        # if this slope is not there in set,
        # increase ans by 1 and insert in set
        if (temp not in st):
            st[temp] = 1
            minLines += 1
 
    return minLines
 
# Driver code
xO = 1
yO = 0
 
points =[[-1, 3],
         [4, 3],
         [2, 1],
         [-1, -2],
         [3, -3]]
 
N = len(points)
print(minLinesToCoverPoints(points, N, xO, yO))
 
# This code is contributed by mohit kumar 29

Javascript

// Javascript program to get minimum lines to cover
// all the points
 
    //    Utility method to get gcd of a and b
    function gcd(a,b)
    {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
     
    // method returns reduced form of dy/dx as a pair
    function getReducedForm(dy,dx)
    {
        let g = gcd(Math.abs(dy), Math.abs(dx));
   
    // get sign of result
    let sign = (dy < 0) ^ (dx < 0);
       
    if (sign)
    {  
        return [Math.floor(-Math.abs(dy) / g), Math.floor(Math.abs(dx) / g)];
             
    }
    else
        return [Math.floor(Math.abs(dy) / g), Math.floor(Math.abs(dx) / g)];
    }
     
    /*    method returns minimum number of lines to
    cover all points where all lines goes
    through (xO, yO) */
    function minLinesToCoverPoints(points,N,x0,y0)
    {
        let st=new Set();
        let temp;
        let minLines = 0;
         
        // loop over all points once
    for (let i = 0; i < N; i++)
    {
        // get x and y co-ordinate of current point
        let curX = points[i][0];
        let curY = points[i][1];
   
        temp = getReducedForm(curY - yO, curX - xO);
           
        // if this slope is not there in set,
        // increase ans by 1 and insert in set
        if (!st.has(temp.join("")))
        {
             
            st.add(temp.join(""));
            minLines++;
        }
    }
   
    return minLines;
    }
     
    // Driver code to test above methods
    let xO, yO;
    xO = 1;
    yO = 0;
     
    let points =[[-1, 3],
         [4, 3],
         [2, 1],
         [-1, -2],
         [3, -3]];
    let N = points.length;
    document.write(minLinesToCoverPoints(points, N, xO, yO))
    
// This code is contributed by unknown2108

输出：

2

如果您希望与专家一起参加现场课程，请参阅DSA 现场工作专业课程和学生竞争性编程现场课程。