查找笛卡尔平面上每个给定多边形内的多边形数量

给定N 个不相交的嵌套多边形，以及成对的二维数组arr[][] ，其中数组的每个单元格表示多边形顶点的坐标。任务是找到位于每个多边形内的多边形数。

例子：

Input: N = 3, arr[][][] = {{{-2, 2}, {-1, 1}, {2, 2}, {2, -1}, {1, -2}, {-2, -2}}, {{-1, -1}, {1, -1}, {1, 1}}, {{3, 3}, {-3, 3}, {-3, -3}, {3, -3}}}
Output: 1 0 2
Explanation:

1. The polygon represented at index 0, is the green-colored polygon shown in the picture above.
2. The polygon represented at index 1, is the blue-colored polygon shown in the picture above.
3. The polygon represented at index 2, is the yellow-colored polygon shown in the picture above.

Therefore, there is 1 polygon inside the polygon at index 0, and 0 polygons inside the polygon at index 1, and 2 polygons inside the polygon at index 2.
 

方法：以上问题可以基于以下观察来解决：

1. 可以观察到，位于外面的多边形将具有最大的X 坐标。多边形的最大 X 坐标将减小，因为它会向内移动，因为多边形是嵌套且不相交的。
2. 因此，按最大X 坐标对多边形进行排序将给出多边形的正确排列顺序。

请按照以下步骤解决问题：

• 初始化一个大小为N*2的2D 数组： maximumX[][]来存储多边形的最大X 坐标对和多边形的索引值。
• 使用变量遍历数组arr[][] ，我执行以下步骤：
  • 初始化一个变量，比如maxX，以存储当前多边形的最大X 坐标。
  • 使用变量j迭代数组arr[i] ，并在每次迭代中将maxX更新为maxX = max(maxX, arr[i][j][0])。
  • 将{maxX, i}对分配给maximumX[i]。
• 使用自定义比较器按第一个元素对数组进行降序排序。
• 初始化一个数组，例如res[]，以存储位于当前多边形内的多边形数。
• 使用变量i在范围[0, N-1] 上迭代，并在每次迭代中将Ni-1分配给res[maximumX[i][1]]，因为在maximumX[i][内有Ni-1多边形1] ^th多边形。
• 最后，完成上述步骤后，打印数组res[]作为答案。

下面是上述方法的实现：

Java

// Java program for above approach
import java.util.*;
  
class GFG {
  
    // Function to sort a 2D
    // array using custom a comparator
    public static void sort2d(int[][] arr)
    {
        Arrays.sort(arr, new Comparator() {
            public int compare(final int[] a,
                               final int[] b)
            {
                if (a[0] < b[0])
                    return 1;
                else
                    return -1;
            }
        });
    }
  
    // Function to calculate maximum sum
    static void findAllPolygons(int N,
                                int[][][] arr)
    {
        // Stores the maximum X co-
        // ordinate of every polygon
        int[][] maximumX = new int[N][2];
  
        // Traverse the array arr[][]
        for (int i = 0; i < N; i++) {
  
            // Stores the max X co-
            // ordinate of current
            // polygon
            int maxX = Integer.MIN_VALUE;
  
            // Traverse over the vertices
            // of the current polygon
  
            for (int j = 0; j < arr[i].length; j++) {
                // Update maxX
                maxX = Math.max(maxX, arr[i][j][0]);
            }
  
            // Assign maxX to maximumX[i][0]
            maximumX[i][0] = maxX;
  
            // Assign i to maximumX[i][1]
            maximumX[i][1] = i;
        }
  
        // Sort the array of pairs
        // maximumX in descending
        // order by first element
        sort2d(maximumX);
  
        // Stores the count of
        // polygons lying inside
        // a polygon
        int[] res = new int[N];
  
        // Travers the maximumX array
        for (int i = 0; i < N; i++) {
            // Update value at
            // maximumX[i][1] in
            // res
            res[maximumX[i][1]] = N - 1 - i;
        }
  
        // Print the array array res
        for (int i = 0; i < N; i++) {
            System.out.print(res[i] + " ");
        }
    }
  
    // Driver Code
    public static void main(String[] args)
    {
  
        int N = 3;
        int[][][] arr = {
            { { -2, 2 }, { -1, 1 }, { 2, 2 }, { 2, -1 }, { 1, -2 }, { -2, -2 } },
            { { -1, -1 }, { 1, -1 }, { 1, 1 } },
            { { 3, 3 }, { -3, 3 }, { -3, -3 }, { 3, -3 } }
        };
  
        findAllPolygons(N, arr);
    }
}

输出

1 0 2 

时间复杂度： O(M + N log N)，其中 M 多边形的最大尺寸
辅助空间： O(N)

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