JAVA题解：

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

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        
        // 读取第一行，路口基站接入人数
        String[] parts = reader.readLine().trim().split("\\s+");
        int[] crossroads = new int[parts.length];
        for (int i = 0; i < parts.length; i++) {
            crossroads[i] = Integer.parseInt(parts[i]);
        }
        
        // 读取第二行，基站覆盖范围
        int k;
        try {
            k = Integer.parseInt(reader.readLine().trim());
        } catch (Exception e) {
            System.out.println(-1);
            return;
        }
        
        // 计算最佳基站
        int[] result = bestStation(crossroads, k);
        
        // 输出结果
        if (result == null) {
            System.out.println(-1);
        } else {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < result.length; i++) {
                sb.append(result[i]);
                if (i < result.length - 1) {
                    sb.append(" ");
                }
            }
            System.out.println(sb.toString());
        }
    }
    
    /**
     * 计算每个路段的最佳通信基站
     * @param crossroads 每个路口基站的接入人数
     * @param k 基站覆盖范围
     * @return 每个路段的最佳基站编号数组，非法输入返回null
     */
    public static int[] bestStation(int[] crossroads, int k) {
        int n = crossroads.length;
        
        // 检查输入合法性
        if (n < 2 || k < 1 || k > n) {
            return null;  // 非法输入
        }
        
        int[] result = new int[n - 1];  // 路段数量比路口数量少1
        Deque<Integer> deque = new LinkedList<>();  // 单调队列，存储基站索引
        
        // 初始化第0号路段
        int r0 = Math.min(n - 1, k);
        for (int i = 0; i <= r0; i++) {
            // 维护单调队列，队列中的基站接入人数从小到大排列
            while (!deque.isEmpty() && crossroads[i] <= crossroads[deque.peekLast()]) {
                deque.pollLast();
            }
            deque.offerLast(i);
        }
        result[0] = deque.peekFirst();  // 第0号路段的最佳基站
        
        // 处理剩余路段
        for (int i = 1; i < n - 1; i++) {
            // 确定窗口左右边界
            int left = Math.max(0, i + 1 - k);
            int right = Math.min(n - 1, i + k);
            
            // 如果右边界扩大，添加新基站
            if (right > r0) {
                int idx = right;
                while (!deque.isEmpty() && crossroads[idx] <= crossroads[deque.peekLast()]) {
                    deque.pollLast();
                }
                deque.offerLast(idx);
                r0 = right;
            }
            
            // 移除窗口左边界外的基站
            while (!deque.isEmpty() && deque.peekFirst() < left) {
                deque.pollFirst();
            }
            
            // 当前路段的最佳基站是队列头部
            result[i] = deque.peekFirst();
        }
        
        return result;
    }
}