五子棋迷【数组】

张兵和王武是五子棋迷，工作之余经常切磋棋艺。这不，这会儿又下起来了。走了一

会儿，轮张兵了，对着一条线思考起来了，这条线上的棋子分布如下 :

用数组表示 : -1 0 1 1 1 0 1 0 1 -1

棋子分布说明 :

1. -1 代表白子， 0 代表空位， 1 代表黑子

2. 数组长度 L, 满足 1 < L < 40, 且 L 为奇数 你得帮他写一个程序，算出最有利的出子位置。 最有利定义 :

1. 找到一个空位 (0) ，用棋子 (1/-1) 填充该位置，可以使得当前子的最大连续长度变大 ;

2. 如果存在多个位置，返回最靠近中间的较小的那个坐标 ;

3. 如果不存在可行位置，直接返回 -1;

4. 连续长度不能超过 5 个 ( 五字棋约束 );

输入描述：

第一行 : 当前出子颜色

第二行 : 当前的棋局状态

输出描述：

1 个整数，表示出子位置的数组下标

public class WZQ {
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int color=in.nextInt();
        in.nextLine();
        String num=in.nextLine();
        String[] nums=num.split(" ");
        int[] num1=new int[nums.length];
        for (int j=0;j<nums.length;j++){
            num1[j]=Integer.parseInt(nums[j]);
        }
        int best = getBest(num1, color);
        System.out.println(best);
    }

    public static int getBest(int[] nums,int color){
        //记录可以插入的下标
        List<Integer> index=new ArrayList<>();
        for (int i=0;i<nums.length;i++){
            if (nums[i]==0){
                index.add(i);
            }
        }
        if (index.size()==0)
            return -1;
        //记录获取的最大连续值
        int max=-1;
        //最佳索引
        int bestIndex;
        List<Integer> maxs=new ArrayList<>();
        Map<Integer,Integer> keyValue=new HashMap<>();
        //获取所有可以放入的下标以及放入后对应的连续最大值，同时按照下标记录下
        for (int id : index) {
            int[] copyNums=nums.clone();
            copyNums[id]=color;
            if (getMax(copyNums, color)<=5){
                max =getMax(copyNums, color);
                keyValue.put(id,max);
                maxs.add(max);
            }
        }
        Integer[] array = maxs.toArray(new Integer[0]);
        //将录入的满足条件的下标进行排序
        Arrays.sort(array);
        List<Integer> maxIndexs=new ArrayList<>();
        //获取等于最大值的所有下标
        List<Integer> bests=new ArrayList<>();
        for(int id : index){
            if (Objects.equals(keyValue.get(id), array[array.length - 1])){
                bests.add(id);
            }
        }
        if (bests.size()==1){
            return bests.get(0);
        }
        int bestId=bests.get(0);
        int staId=nums.length/2;
        //如果存在多个相同的值，获取距离中间值最近的下标
        for (Integer best : bests) {
            if (Math.abs(best - staId) <Math.abs( bestId - staId)) {
                bestId = best;
            }
            if (Math.abs(best - staId) == Math.abs(bestId - staId)) {
                bestId = Math.min(best, bestId);
            }
        }
        return bestId;
    }

    /**
     * 获取放入棋子后最大的连续数
     */
    public static int getMax(int[] nums,int color){
        int len=0;
        int maxLen=0;
        for (int num : nums) {
            if (num == color) {
                len++;
            }
            if (num != color) {
                maxLen = Math.max(len, maxLen);
                len = 0;
            }
        }
        return maxLen;
    }
}