【HackerRank】Sherlock and MiniMax

题目连接：Sherlock and MiniMax

Watson gives Sherlock an array A1,A2...AN. 
He asks him to find an integer M between P and Q(both inclusive), such that, min {|Ai-M|, 1 ≤ i ≤ N} is maximised. If there are multiple solutions, print the smallest one.

Input Format 
The first line contains N. The next line contains space separated N integers, and denote the array A. The third line contains two space separated integers denoting P and Q.

Output Format 
In one line, print the required answer.

Constraints 
1 ≤ N ≤ 10²
1 ≤ Ai ≤ 10⁹ 
1 ≤ P ≤ Q ≤ 10⁹

Sample Input

3
5 8 14
4 9

Sample Output

4

---

题解：难度为Diffcult的一道题，真的好难=。=

首先题目理解：给定一个数组a和两个整数P和Q，在区间[P,Q]中找到一个数M，使得min{a[i] - M}最大，即对于每一个[P,Q]之间的数m，将数组中的每个数和m求差的绝对值，那么这些绝对值里面就有一个最小值(比如题目中的例子，选择m=4，那么对应的3个差的绝对值是1，4，10，最小值就是1)。现在要做的就是选出这个m，使得这个最小值最大(比如如果选定m=5，那么对应的3个差的绝对值是0，3，9，最小值是0，就比刚才选4的时候得到的最小值小，所以m选4不选5）。

首先对原数组排序，那么对于[P,Q]之间的任意一个m，对应的差的绝对值如下图两种情况所示：

                      图一

在第一种情况中，最小值在端点处达到；在第二种情况中，最小值在转折点处达到，这都是由a数组有序以后得到的性质。那么我们想想在哪些地方可以达到最大的最小值。如小图所示，对于任意两个数，当且仅当取m为它们的中点(a[i]+a[i+1])/2的时候，得到的最小绝对值最大。所以就可以遍历所有的(a[i],a[i+1])，然后找出使得最小值最大的m作为M。

            图二

在这个过程中，有一种情况就是(a[i],a[i+1])的中点不在[P,Q]内，那么最小值或者在[P,Q]中最靠近中点处取得（区间[P,Q]和区间[a[i],a[i+1]]有交集时候，在P或者Q取到最小值）；或者[P,Q]和[a[i],a[i+1]]没有交集，即图一中第一种情况，最小值也在P或者Q处达到。那么我们为单独用O(n)的时间考察P和Q，遍历数组，找到最小值，然后查看是否可能成为最大的最小值。

总结一下算法：

• 首先对数组a排序
• 对于P和Q，利用O(N)的时间遍历数组，找到最小值，看能够成为最大的最小值；
• 对于任意(a[i],a[i+1])，考察(a[i]+a[i+1])/2是否在[P,Q]内，如果在，考察此处得到的最小值是否能够成为最大的最小值，注意a[i]+a[i+1]为奇数时，要考察两个中点，它们都可能取得最小值。
• 算法排序时间复杂度O(NlogN)，单独处理P,Q及中点复杂度O(N)，所以最终的算法时间复杂度为O(NlogN）。

代码如下：

import java.io.*;
import java.util.*;
import java.math.*;


public class Solution {
    static int miniMax = 0;
    static int miniMax_index = 0;
    private static int mini_first_last(int[] a,int first_last){
        //check for p
        int mini = Integer.MAX_VALUE;
        
        for(int i = 0;i < a.length;i++){
            mini = Math.min(mini,Math.abs(a[i]-first_last));
        }
        
        return mini;
    }
    private static void middle(int index,int[] a,int p,int q){
        int mini = Integer.MAX_VALUE;
        int mini_index = 0;
        int mid = (a[index]+a[index+1])/2;
        if(mid >= p && mid <= q){
            int m = Math.abs(a[index]-mid);
            int n = Math.abs(a[index+1]-mid);
            if(mini > Math.min(m, n)){
                mini = Math.min(m, n);
                mini_index = mid;
            }
            if(mid+1<=q && mid*2 != a[index] + a[index+1]){
                m = Math.abs(a[index]-mid-1);
                n = Math.abs(a[index+1]-mid-1);
                if(mini > Math.min(m, n)){
                    mini = Math.min(m, n);
                    mini_index = mid+1;
                }
            }
            if(mini != Integer.MAX_VALUE && miniMax < mini){
                miniMax = mini;
                miniMax_index = mini_index;
            }
        }    
        
    }
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] a = new int[n];
        for(int i = 0;i < n;i++)
            a[i] = in.nextInt();
        int p = in.nextInt();
        int q = in.nextInt();
        Arrays.sort(a);
        
        miniMax = mini_first_last(a, p);
        miniMax_index = p;
        
        int temp = mini_first_last(a, q);
        if(miniMax < temp){
            miniMax = temp;
            miniMax_index = q;
        }
        
        for(int i = 0;i < n-1;i++){
            middle(i, a, p, q);
        }
        System.out.println(miniMax_index);
      }
}