Question

在阵列A [n]矩形中找到2个矩形A [i]和A [j]，使得A [i] .width＆gt; A [j] .width和A [i] .length - A [j] .length是最长的。

有没有办法将复杂度降低到O（nlogn）？我找不到一种方法来获得第二个矩形的O（logn）搜索。由于两个标准彼此完全相反的可能性，排序在这里似乎没有帮助。也许我只是错了？请指引我走正确的道路。谢谢。

注意：家庭作业使用不同的对象并使用2个标准而不是3个，但上下文是相同的。

Answer 1

由于这是作业，这里是一个高级答案，实施留下作为OP的问题：

按宽度递增对数组元素进行排序。然后向下扫描数组，从目前为止遇到的最高长度中减去当前长度。跟踪到目前为止遇到的最大差异（以及相应的i和j）。完成后，您将获得最大长度差A [i] .length-A [j] .length其中A [i] .width＆gt; A [j]的.WIDTH

分析：对元素进行排序需要O(n*Log(n))，所有其他步骤需要O(n)。

Answer 2

这是一些实现相同的java代码::

  import java.util.Arrays;
  import java.util.Comparator;
  import java.util.Random;

  public class RequiredRectangle {

    public static void main(String[] args) {
        // test the method
        int n=10;
        Rectangle[] input = new Rectangle[n];
        Random r = new Random();
        for(int i=0;i<n;i++){
            input[i] = new Rectangle(r.nextInt(100)+1,r.nextInt(100)+1);
        }

        System.out.println("INPUT:: "+Arrays.deepToString(input));

        Rectangle[] output = getMaxLengthDiffAndGreaterBreadthPair(input);
        System.out.println("OUTPUT:: "+Arrays.deepToString(output));

    }

    public static Rectangle[] getMaxLengthDiffAndGreaterBreadthPair(Rectangle[] input){
        Rectangle[] output = new Rectangle[2];

        Arrays.sort(input, new Comparator<Rectangle>() {
            public int compare(Rectangle rc1,Rectangle rc2){
                return rc1.getBreadth()-rc2.getBreadth();
            }
        });

        int len=0;
        Rectangle obj1,obj2;
        for(int i=0;i<input.length;i++){
            obj2=input[i];
            for(int j=i+1;j<input.length;j++){
                obj1=input[j];
                int temp=obj1.getLength() - obj2.getLength();

                if(temp>len && obj1.getBreadth() > obj2.getBreadth()){
                    len=temp;
                    output[0]=obj1;
                    output[1]=obj2;
                }
            }
        }
        return output;
    }
  }

  class Rectangle{
    private int length;
    private int breadth;

    public int getLength(){
        return length;
    }

    public int getBreadth(){
        return breadth;
    }

    public Rectangle(int length,int breadth){
        this.length=length;
        this.breadth=breadth;
    }

    @Override
    public boolean equals(Object obj){
        Rectangle rect = (Rectangle)obj;

        if(this.length==rect.length && this.breadth==rect.breadth)
            return true;

        return false;
    }

    @Override
    public String toString(){
        return "["+length+","+breadth+"]";
    }
  }

`

示例输出：

INPUT:: [[8,19], [68,29], [92,14], [1,27], [87,24], [57,42], [45,5], [66,27], [45,28], [29,11]]
OUTPUT:: [[87,24], [8,19]]

算法如何处理多个标准

2 个答案: