包含至少一半给定坐标的正方形的最小长度

给定二维平面中的一组 N 个点。任务是找到 M 的最小值，使得以原点为中心、边为 2*M 的正方形在其内部或上面至少包含 floor(N/2) 个点。

例子：

Input : N = 4 
Points are: {(1, 2), (-3, 4), (1, 78), (-3, -7)} 
Output : 4 
The square with end point (4, 4), (-4, -4), (4, -4), (-4, 4) will contain the points (1, 2) and (-3, 4). 
Smallest Possible value of M such that the square has at least 2 points is 4.
Input : N = 3 
Points are: {(1, 2), (-3, 4), (1, 78)} 
Output : 2 
Square contains the point (1, 2). {floor(3/2) = 1}  

方法：

1. 对任何点 (x, y) 的一个主要观察结果，该点所在的最小 M 是 max(abs(x), abs(y))。
2. 使用点1。我们可以找到所有点的M的最小值并将它们存储在一个数组中。
3. 对数组进行排序。
4. 现在，array[i] 表示最小 M，这样如果边 2*M 的正方形中需要 i 个点。 （因为 i 以下的所有点都有 M 的最小值小于或等于 i）。
5. 打印数组[floor(n/2)] 的值。

下面是上述方法的实现：

C++

// C++ implementation of the above approach
 
#include 
using namespace std;
 
// Function to Calculate Absolute Value
int mod(int x)
{
    if (x >= 0)
        return x;
    return -x;
}
 
// Function to Calculate the Minimum value of M
void findSquare(int n)
{
    int points[n][2] = { { 1, 2 }, { -3, 4 },
                       { 1, 78 }, { -3, -7 } };
    int a[n];
 
    // To store the minimum M for each
    // point in array
    for (int i = 0; i < n; i++) {
        int x, y;
        x = points[i][0];
        y = points[i][1];
        a[i] = max(mod(x), mod(y));
    }
 
    // Sort the array
    sort(a, a + n);
 
    // Index at which atleast required point are
    // inside square of length 2*M
    int index = floor(n / 2) - 1;
    cout << "Minimum M required is: " << a[index] << endl;
}
 
// Driver Code
int main()
{
    int N;
    N = 4;
    findSquare(N);
 
    return 0;
}

Java

import java.util.*;
 
// Java program to find next identical year
class GFG
{
 
// Function to Calculate Absolute Value
static int mod(int x)
{
    if (x >= 0)
        return x;
    return -x;
}
 
// Function to Calculate the Minimum value of M
static void findSquare(int n)
{
    int points[][] = { { 1, 2 }, { -3, 4 },
                    { 1, 78 }, { -3, -7 } };
    int []a = new int[n];
 
    // To store the minimum M for each
    // point in array
    for (int i = 0; i < n; i++)
    {
        int x, y;
        x = points[i][0];
        y = points[i][1];
        a[i] = Math.max(mod(x), mod(y));
    }
 
    // Sort the array
    Arrays.sort(a);
 
    // Index at which atleast required point are
    // inside square of length 2*M
    int index = (int) (Math.floor(n / 2) - 1);
    System.out.println("Minimum M required is: " + a[index]);
}
 
// Driver Code
public static void main(String[] args)
{
    int N;
    N = 4;
    findSquare(N);
}
}
 
// This code contributed by Rajput-Ji

Python3

# Python3 implementation of the
# above approach
 
# Function to Calculate the
# Minimum value of M
def findSquare(n):
 
    points = [[1, 2], [-3, 4],
              [1, 78], [-3, -7]]
    a = [None] * n
 
    # To store the minimum M
    # for each point in array
    for i in range(0, n):
        x = points[i][0]
        y = points[i][1]
        a[i] = max(abs(x), abs(y))
     
    # Sort the array
    a.sort()
 
    # Index at which atleast required
    # point are inside square of length 2*M
    index = n // 2 - 1
    print("Minimum M required is:", a[index])
 
# Driver Code
if __name__ == "__main__":
 
    N = 4
    findSquare(N)
     
# This code is contributed
# by Rituraj Jain

C#

// C# program to find next identical year
using System;
 
class GFG
{
 
// Function to Calculate Absolute Value
static int mod(int x)
{
    if (x >= 0)
        return x;
    return -x;
}
 
// Function to Calculate the Minimum value of M
static void findSquare(int n)
{
    int [,]points = new int[4,2]{ { 1, 2 }, { -3, 4 },
                    { 1, 78 }, { -3, -7 } };
    int []a = new int[n];
 
    // To store the minimum M for each
    // point in array
    for (int i = 0; i < n; i++)
    {
        int x, y;
        x = points[i,0];
        y = points[i,1];
        a[i] = Math.Max(mod(x), mod(y));
    }
 
    // Sort the array
    Array.Sort(a);
 
    // Index at which atleast required point are
    // inside square of length 2*M
    int index = (int) (n / 2 - 1);
    Console.WriteLine("Minimum M required is: " + a[index]);
}
 
// Driver Code
public static void Main(String []args)
{
    int N;
    N = 4;
    findSquare(N);
}
}
 
// This code contributed by Arnab Kundu

PHP

= 0)
        return $x;
    return -$x;
}
 
// Function to Calculate the
// Minimum value of M
function findSquare($n)
{
    $points = array(array( 1, 2 ),
                    array( -3, 4 ),
                    array( 1, 78 ),
                    array( -3, -7 ));
    $a[$n] = array();
 
    // To store the minimum M for each
    // point in array
    for ($i = 0; $i < $n; $i++)
    {
        $x; $y;
        $x = $points[$i][0];
        $y = $points[$i][1];
        $a[$i] = max(mod($x), mod($y));
    }
 
    // Sort the array
    sort($a);
 
    // Index at which atleast required point
    // are inside square of length 2*M
    $index = floor($n / 2) - 1;
    echo "Minimum M required is: ",
                  $a[$index], "\n";
}
 
// Driver Code
$N = 4;
findSquare($N);
 
// This code is contributed by ajit.
?>

Javascript

    // Javascript program to find next identical year
     
    // Function to Calculate Absolute Value
    function mod(x)
    {
        if (x >= 0)
            return x;
        return -x;
    }
 
    // Function to Calculate the Minimum value of M
    function findSquare(n)
    {
        let points = [ [ 1, 2 ], [ -3, 4 ],
                        [ 1, 78 ], [ -3, -7 ] ];
        let a = new Array(n);
 
        // To store the minimum M for each
        // point in array
        for (let i = 0; i < n; i++)
        {
            let x, y;
            x = points[i][0];
            y = points[i][1];
            a[i] = Math.max(mod(x), mod(y));
        }
 
        // Sort the array
        a.sort(function(a, b){return a - b});
 
        // Index at which atleast required point are
        // inside square of length 2*M
        let index = (Math.floor(n / 2) - 1);
        document.write("Minimum M required is: " + a[index]);
    }
     
    let N;
    N = 4;
    findSquare(N);
 
         

输出：

Minimum M required is: 4

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