B1. The Strict Teacher (Easy Version)
传送门：https://codeforces.com/contest/2005/problem/B1

有两名老师和一名学生在一条长度为 n 的一维直线教室中。老师和学生初始位置不同，他们每次都可以移动到相邻的单元格或停留在原地。学生的目标是尽量延长被老师抓住的时间，而老师们的目标是尽快抓住学生。
你需要计算在每个测试用例中，老师们抓住学生所需的最少步数。
输入：
第一行是整数 t，表示测试用例数量。
对于每个测试用例，第一行给出三个整数 n（教室的长度）、m=2（老师的数量)，q=1（学生的查询次数）。
接下来一行包含 m 个整数，表示两名老师的位置。
最后一行包含 1 个整数，表示学生的位置。
输出：
对于每个测试用例，输出一个整数，表示老师抓住学生所需的最少步数。
样例：
输入：
3
10 2 1
1 4
2
8 2 1
3 6
1
8 2 1
3 6
8
输出：
1
2
2
样例解释：
第一个测试用例中，学生在位置 2，最靠近的老师在位置 1，老师只需移动一步就能抓住学生，答案是 1。
第二个测试用例中，学生在位置 1，最近的老师在位置 3，老师需要两步才能抓住学生，答案是 2。
第三个测试用例中，学生在位置 8，最近的老师在位置 6，老师需要两步才能抓住学生，答案是 2。

思路：我们很容易想到三种情况，那我们开始讨论。
(1)老师全在大卫的右边，那么好，我们很容易想到大卫往左边跑直到1为止，离大卫最近的老师追，追到为止，那么时间就是 min(x,y)-1;
(2) 老师全在大卫的左边，那么好，我们很容易想到大卫往右边跑直到n为止，离大卫最近的老师追，追到为止，那么时间就是 n-max(x,y);
(3) 最后我们讨论大卫在两名老师的中间，那么老师肯定会往中间追，大卫往离着最远老师的方向跑，在即将相遇的时候再往回跑，直到有一刻，两名老师同时抓到大卫，时间是(max(x,y)-min(x,y))/2

当时我打div2的时候脑子完全是抽了QVQ

#include
using namespace std;

typedef long long LL;
typedef pair PII;
typedef pair PLL;
typedef unordered_map HashII;
typedef unordered_map HashCI;
typedef priority_queue,greater> heap;
typedef unsigned long long ULL;
typedef unordered_map HashSI;
const int INF=0x3f3f3f3f;
const int N=1e5+10;
int dx[]={1,-1,0,0};
int dy[]={0,0,1,-1};
void solve()
{
    LL n,m,q;cin>>n>>m>>q;
    LL x,y;cin>>x>>y;
    LL a;cin>>a;
    LL ans = 0;
    if(x>y) swap(x,y);
    if(x>a) ans=x-1;//case 1
    else if(ya)
        ans = (y-x)>>1;//case 3
    cout<>t;
    while(t--)
    {
        solve();
    }
    return 0;
}

B2 https://codeforces.com/contest/2005/problem/B2
在这个问题中，有 m 名老师和 David（学生）在一个由 1 到 n 的一维线性教室中移动。所有老师和 David 初始位置不同，每次移动时，David 和老师都可以选择移动到相邻的格子或停留在原地。

David 的目标是尽量延长被抓的时间；
老师们 的目标是尽快抓住 David。
若有一位或多位老师与 David 位于同一个格子，David 就会被抓住。每个人都能看到对方的行动，都会采取最佳策略。你需要计算老师们在最优策略下，抓住 David 所需的最少步数。

输入：
第一行是一个整数 t，表示测试用例的数量。
对于每个测试用例，第一行包含三个整数：n（格子数）、m（老师数）、q（查询次数）。
接下来一行给出 m 个整数，表示老师的初始位置。
最后一行给出 q 个整数，表示每次查询中 David 的位置。
输出：
对于每个测试用例，输出 q 行，每行表示对应查询中老师抓住 David 所需的最少步数。
样例：
输入：
2
8 1 1
6
3
10 3 3
1 4 8
2 3 10
输出：
5
1
1
2
样例解释：
第一个测试用例中，老师位于 6 号格子，David 位于 3 号格子。David 最优策略是向左跑到 1 号格子，老师从 6 到 1 需要 5 步，答案是 5。
第二个测试用例：
David 在 2 号格子，老师距离最近的在 1 号格子，只需 1 步；
David 在 3 号格子，老师从 4 号格子到 3 号只需 1 步；
David 在 10 号格子，老师从 8 号格子到 10 号需要 2 步。

思路，和B1思路差不多，但是我们要找到离大卫最近的两个老师，我们可以通过排序找到b具有单调性，那么无疑就是二分了
我们可以用二分函数 lower_bound找到第一个大于的等于a的老师下标来判断是那种情况

#include 
using namespace std;

typedef long long LL;
typedef pair PII;
typedef pair PLL;
typedef unordered_map HashII;
typedef unordered_map HashCI;
typedef priority_queue, greater> heap;
typedef unsigned long long ULL;
typedef unordered_map HashSI;
const int INF = 0x3f3f3f3f;
const int N = 1e5 + 10;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
vector ans;
void check(vector& b, LL a) {
    sort(b.begin(), b.end());
    int n = b.size();
    int l = 0, r = n - 1;
    while (l < r) {
        int mid = (l + r) >> 1;
        if (b[mid] > a) r = mid;
        else l = mid + 1;
    }
    int x = r;
    l = 0;  
    r = n - 1;  
    while (l < r) {
        int mid = (l + r + 1) >> 1;
        if (b[mid] < a) l = mid;
        else r = mid - 1;
    }
    int y = l;
    ans.push_back({y, x});
}
void solve() {
    LL n, m, q;
    cin >> n >> m >> q;
    vector b(m);  
    vector c(m); 
    for (int i = 0; i < m; i++) {
        cin >> b[i];
    }
    sort(b.begin(),b.end());
    while (q--) {
        LL a;
        cin >> a;
        LL res = 0;
        int x = lower_bound(b.begin(),b.end(),a)-b.begin();
        if(x==0) res = b[0]-1;
        else if(x==b.size()) res = n-b[m-1];
        else
        {
            res = (b[x]-b[x-1])/2;
        }
        cout<> t;
    while (t--) {
        solve();
    }
    return 0;
}