吐血（1）无厘头烧脑

    /**
     * 烧脑版
     * 就是在一条长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]);

    }
}