导弹拦截（Java实现）

经过11年的韬光养晦，某国研发出了一种新的导弹拦截系统，凡是与它的距离不超过其工作半径的导弹都能够被它成功拦截。当工作半径为0时，则能够拦截与它位置恰好相同的导弹。但该导弹拦截系统也存在这样的缺陷：每套系统每天只能设定一次工作半径。而当天的使用代价，就是所有系统工作半径的平方和。

某天，雷达捕捉到敌国的导弹来袭。由于该系统尚处于试验阶段，所以只有两套系统投入工作。如果现在的要求是拦截所有的导弹，请计算这一天的最小使用代价。

输入描述:

第一行包含4个整数x1、y1、x2、y2，每两个整数之间用一个空格隔开，表示这两套导弹拦截系统的坐标分别为(x1, y1)、(x2, y2)。

第二行包含1个整数N，表示有N颗导弹。接下来N行，每行两个整数x、y，中间用一个空格隔开，表示一颗导弹的坐标(x, y)。不同导弹的坐标可能相同。

输出描述:

输出只有一行，包含一个整数，即当天的最小使用代价。

示例1

输入

复制0 0 10 0 2 -3 3 10 0

0 0 10 0
2
-3 3
10 0

输出

复制18

18

说明

要拦截所有导弹，在满足最小使用代价的前提下，两套系统工作半径的平方分别为18和0。

示例2

输入

复制0 0 6 0 5 -4 -2 -2 3 4 0 6 -2 9 1

0 0 6 0 
5 
-4 -2 
-2 3 
4 0 
6 -2 
9 1

输出

复制30

30

说明

样例中的导弹拦截系统和导弹所在的位置如下图所示。要拦截所有导弹，在满足最小使用代价的前提下，两套系统工作半径的平方分别为20和10。

备注:

两个点(x1, y1)、(x2, y2)之间距离的平方是(x1−x2)2+(y1−y2)2。

两套系统工作半径r1、r2的平方和，是指r1、r2分别取平方后再求和，即r12+r22。

对于10%的数据，N=1

对于20%的数据，1≤N≤2

对于40%的数据，1≤N≤100

对于70%的数据，1≤N≤1000

对于100%的数据，1≤N≤100000，且所有坐标分量的绝对值都不超过1000。

 对于每个导弹都有两种情况，他们要么在一导弹防御系统内，要么在二导弹防御系统内。

对：

导弹一  0	导弹二 0
r1	r2
r1	r2
r1	r2
r1	r2

此时已经按r1做降序排序：

错误思路：每次找r1和r2的最小值，然后找挑选过之后整个r1组内和r2组内的最大值，这样并不每次都是全优解，举个例子：

r1 =500	r2=300
r1=700	r2=800
r1=100	r2=200

按照错误思路，应该为1000，可是选择r1 700 r2 0 也能满足此题解，所以应该按照思路2，将每个导弹第一次归为一系统，后面将其一直归为二系统，如果能使系统半径和减小，说明他归为二系统更好，否则说明他在一系统更好。

思路解析：

导弹一  0

导弹二 0

这个为初始状态，没有导弹，然后将r1归为一系统，然后不断加入导弹，当前导弹归为一系统，已经考虑过的系统归给二系统，每次找r2的最大值，然后和当前r1相加，得到此时的局部最优解，然后所有局部最优解求最优得到全局最优解。

代码：

// 不易理解思路，请结合代码和debug和草稿纸推算

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner input = new Scanner(System.in);
        int x1 = input.nextInt();
        int y1 = input.nextInt();
        int x2 = input.nextInt();
        int y2 = input.nextInt();
        Bomb[] array = new Bomb[100005];
        int n = input.nextInt();
        for(int i = 1; i <= n; i++){
            int x = input.nextInt();
            int y = input.nextInt();
            array[i] = new Bomb(x,y);
            array[i].r1 = (int) (Math.pow(x - x1, 2) + Math.pow(y - y1, 2));
            array[i].r2 = (int) (Math.pow(x - x2, 2) + Math.pow(y - y2, 2));
        }
        Arrays.sort(array, 1, n+1, new BombComparator()); // 将array以r1降序的方式进行排序
        int ars = 0;
        int ans = Integer.MAX_VALUE;
        array[0] = new Bomb(0,0);
        for (int i = 1; i <= n; i++) {
            ars = Math.max(ars, array[i-1].r2); // 寻找r2的最大值
            ans = Math.min(ans, array[i].r1 + ars); // 寻找r1 + r2 的最小值
            
        }
        System.out.println(ans);
    }

    public static class Bomb{
        int x;
        int y;
        int r1;
        int r2;

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

    }
    public static class BombComparator implements Comparator<Bomb>{
        @Override
        public int compare(Bomb o1, Bomb o2) {
            return o2.r1 - o1.r1;
        }
    }
}