网易有道第一道编程题

今天翻博客的时候，发现大家在网上讨论这道题目，很多人说没有思路，题主就默默的做了一下，给出的case是可以通过的，题主自己试了一些其他的case，也都没问题，但是没有在saima网上oj提交，所以题主也不敢保证百分百通过呀，给出题主的思路，欢迎大家一起来讨论~如果有问题，也欢迎大家交流指出。

题目如下：

/**
 查找矩形
 Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
 Problem Description:
 对于一组水平线段及垂直线段，共有n条，已知其中必定存在一个若干条线段组成的矩形，输出这个矩形的左下角和右上角点，
 定义左下角点有最小的x值和y值，右上角点有最大的x值和y值。
 线段可以重合，线段必须恰好能组成矩形，即线段不能头或尾部超出矩阵边界，如下图：


 输入
 第一行为线段数 n (4 <= n <= 25)
 接下来有n行，每行为一条线段的首尾点坐标： xi yi xj yj
 坐标值范围 -1e9 <= x, y <= 1e9
 输出
 在一行输出矩形的左下角点和右上角点坐标：
 xi yi xj yj
 根据定义有 xi < xj && yi < yj


 样例输入
 4
 0 0 0 1
 0 0 1 0
 0 1 1 1
 1 0 1 1
 样例输出
 ​0 0 1 1*/

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            int n = scanner.nextInt();
            XianDuan[] xianDuans = new XianDuan[n];//用数组存储n条线段
            XianDuan[] xianDuansShuiPing = new XianDuan[n];//存储水平的线段
            XianDuan[] xianDuansChuiZhi = new XianDuan[n];//存储垂直的线段
            int sh = 0;
            int ch = 0;
            for (int i = 0; i < n; i++) {
                xianDuans[i] = new XianDuan(new Point(scanner.nextInt(), scanner.nextInt()), new Point(scanner.nextInt(), scanner.nextInt()));
                if (xianDuans[i].shuiPing)
                    xianDuansShuiPing[sh++] = xianDuans[i];
                else
                    xianDuansChuiZhi[ch++] = xianDuans[i];
            }
            boolean flag = false;
            for (int i = 0; i < sh; i++) {
                for (int j = i + 1; j < sh; j++) {
                    for (int p = 0; p < ch; p++) {
                        for (int q = p + 1; q < ch; q++) {
                            Square square = new Square(xianDuansShuiPing[i], xianDuansShuiPing[j], xianDuansChuiZhi[p], xianDuansChuiZhi[q]);
                            flag = square.isTrue();
                            if (flag)
                                break;
                        }
                        if (flag)
                            break;
                    }
                    if (flag)
                        break;
                }
                if (flag)
                    break;
            }

        }
    }
}

class XianDuan {
    Point pi;
    Point pj;
    int length;
    boolean shuiPing = false;

    XianDuan(Point pi, Point pj) {
        this.pi = pi;
        this.pj = pj;
        if (pi.y == pj.y)
            shuiPing = true;
        if (shuiPing)
            length = Math.abs(pi.x - pj.x);
        else
            length = Math.abs(pi.y - pj.y);
    }
}

class Point {
    int x;
    int y;

    Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public boolean equal(Point p) {
        if (this.x == p.x && this.y == p.y)
            return true;
        else
            return false;
    }
}

class Square {
    XianDuan xianDuanShuiPing1;
    XianDuan xianDuanShuiPing2;
    XianDuan xianDuanChuiZhi1;
    XianDuan xianDuanChuiZhi2;

    Square(XianDuan x, XianDuan y, XianDuan p, XianDuan q) {
        xianDuanShuiPing1 = x;
        xianDuanShuiPing2 = y;
        xianDuanChuiZhi1 = p;
        xianDuanChuiZhi2 = q;
    }

    public Point getLeftDownPoint() {
        int x = Math.min(xianDuanShuiPing1.pi.x, xianDuanShuiPing1.pj.x);
        int y = Math.min(xianDuanChuiZhi1.pi.y, xianDuanChuiZhi1.pj.y);
        return new Point(x, y);
    }

    public Point getRightUpPoint() {
        int x = Math.max(xianDuanShuiPing1.pi.x, xianDuanShuiPing1.pj.x);
        int y = Math.max(xianDuanChuiZhi1.pi.y, xianDuanChuiZhi1.pj.y);
        return new Point(x, y);
    }

    public boolean isTrue() {
        Point[] points = new Point[4];
        points[0] = xianDuanShuiPing1.pi;
        points[1] = xianDuanShuiPing1.pj;
        points[2] = xianDuanShuiPing2.pi;
        points[3] = xianDuanShuiPing2.pj;
        int[] arr = new int[4];
        Point[] points1 = new Point[4];
        points1[0] = xianDuanChuiZhi1.pi;
        points1[1] = xianDuanChuiZhi1.pj;
        points1[2] = xianDuanChuiZhi2.pi;
        points1[3] = xianDuanChuiZhi2.pj;
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                if (points[i].equal(points1[j]))
                    arr[i]++;
            }
        }
        boolean result = true;
        for (int i = 0; i < 4; i++) {
            if (arr[i] != 1)
                result = false;
        }
        if (result) {
            Point ld = this.getLeftDownPoint();
            Point ru = this.getRightUpPoint();
            System.out.println(ld.x + " " + ld.y + " " + ru.x + " " + ru.y);
        }
        return result;
    }
}