/**
     * 燒腦版
     * 就是在一條長L釐米的 繩索上,螞蟻每秒走一釐米,走到兩端都會立刻掉下去,且螞蟻互相不會交叉過繩索,也就是說碰到時都掉頭走,問最後一隻螞蟻掉下繩索的 最長和最短時間
     * @param L 繩索的長度
     * @param data  每一隻螞蟻距離繩索最左邊的初始距離
     * @return
     */
    public static int[] t2(int L, int data[]) {
        //螞蟻數量
        int count = data.length;
        
        //最長時間 ,注意除以2
        int max = 0;
        
        //最短時間
        int min = 0;
        
        //中間值
        int half = L / 2;

        //輔助 陣列,用於儲存每一個螞蟻在特定位置的 標誌,說明該位置有幾隻螞蟻,-1 是特殊情況,是發生相遇事件的處理
        int ruler[] = new int[2 * L + 1];
        int result[] = new int[2];

        for (int i = 0; i < count; i++) {
            min = Math.max(min, Math.min(L - data[i], data[i]));
        }


        //下面的處理是 修改 每一隻螞蟻距離最左邊的 初始距離,向左是負方向,向右是正方向前進,且0-L是正,L+1-2L 是負方向前進
        for (int i = 0; i < data.length; i++) {
            if (data[i] > half) {
                data[i] *= -2;
                ruler[(-1) * data[i]] = 1;
            } else {
                data[i] *= 2;
                ruler[data[i]] = 1;
            }
        }
        while (true) {
            max++;
            for (int i = 0; i < data.length; i++) {
                if (data[i] > 0) {
                    switch (ruler[data[i]]) {
                        case 2://螞蟻相遇,其中一隻率先處理衝突
                            ruler[data[i]] = -1;
                            data[i] = -1 * (data[i] - 1);
                            ruler[-1 * data[i]] = 1;
                            break;
                        case -1://螞蟻相遇,它不是首先處理衝突的.記住,螞蟻相遇一定是針對兩隻螞蟻而言的
                            ruler[data[i]] = 0;
                            ruler[data[i] - 1] = 1;
                            data[i] = -1 * (data[i] - 1);
                            break;
                        case 1://預設情況
                        default:
                            ruler[data[i]] = 0;
                            //加一 , 說明螞蟻前進了一釐米,但是這裡的加一意味著 標誌位更新
                            ruler[data[i] + 1] += 1;
                            //這裡的加一才是真正的距離更新,因為data儲存著距離資訊
                            data[i] = data[i] + 1;
                            if (data[i] == 2 * L) {
                                data[i] = 0;
                                count--;
                                if (count == 0) {
                                    break;//直接退出迴圈,然後在下面判斷是否全部的螞蟻掉下繩索,如果是,則程式終止
                                }
                            }
                    }
                } else if (data[i] < 0) {
                    switch (ruler[-1 * data[i]]) {
                        case 2:
                            ruler[-1 * data[i]] = -1;
                            data[i] = -1 * data[i] + 1;
                            ruler[data[i]] = 1;
                            break;
                        case -1:
                            ruler[-1 * data[i]] = 0;
                            data[i] = -1 * data[i] + 1;
                            ruler[data[i]] = 1;
                            break;
                        case 1:
                        default:
                            ruler[-1 * data[i]] = 0;
                            data[i] = data[i] + 1;
                            ruler[-1 * data[i]] += 1;
                            if (data[i] == 0) {
                                count--;
                                if (count == 0) {
                                    break;
                                }
                            }
                            break;
                    }
                }
            }

            if (count == 0) {
                result[0] = min;
                result[1] = max / 2;
                return result;
            }


        }
    }
 

吐血版

int Max(int a, int b) {
    return a > b ? a : b;
}

int Min(int a, int b) {
    return a > b ? b : a;
}

void Fun(int L, int count, int *data, int *result) {
    int max = 0;
    int min = 0;
    for (int i = 0; i < count; ++i) {
        min = Max(min, Min(data[i], L - data[i]));
    }

    for (int i = 0; i < count; ++i) {
        max = Max(max, Max(data[i], L - data[i]));
    }
    result[0] = min;
    result[1] = max;
}

void testFun() {
    int testCase = 1000;
    int poleLength = 1000;
    int antsCount = 1000;
    scanf("%d", &testCase);
    int result[testCase][2];
    for (int i = 0; i < testCase; i++) {
        scanf("%d %d", &poleLength, &antsCount);
        int index = 0;
        int antsArray[antsCount];
        while (index < antsCount) {
            scanf("%d", &antsArray[index++]);
        }
        Fun(poleLength, antsCount, antsArray, result[i]);
    }

    for (int j = 0; j < testCase; ++j) {
        printf("%d %d\n", result[j][0], result[j][1]);

    }
}