Educational Codeforces Round 169 (Rated for Div. 2) ABCD+E补

A题：Closest Point

题意

给定若干不同的点，问是否存在一个与这些点不同的点，使得其是对于它们之中的每一点最近

思路

A题不会有很大的难度，我们正常想，如果出现三个点的话，就无法再添加点使得它是全体最近的了。那么只有两个点的情况，然后我们又注意到了样例

2

5 6

做一个特判即可。

代码

inline void solve() {
     int n; cin >> n;
     vector<int> a(n + 1);
     for (int i = 1; i <= n; i ++ ) cin >> a[i];
     if (n == 2 && a[2] - a[1] > 1) cout << "YES" << endl;
     else cout << "NO" << endl;
	 return;
}

B题：Game with Doors

题意 

有100个房间和99道门，每道门连接相邻两个房间。两个人所在的位置区间为[l,r]和[L,R]，问至少要封上几道门才能使得两者无法相遇？

思路

当成线段来考虑，

一：如果两者不相交

那么只需封上一道门就无法相遇了

二：如果两者相交

首先对于重合的部分，必须相邻房间的门都要封上.

然后我们再看，这个重合的两端是否可能到另一个线段上即可。(只要端点不重合，就可以到另一个线段上）

代码

inline void solve() {
     int l, r, L, R; cin >> l >> r >> L >> R;
     if (r < L || R < l) cout << 1 << endl;
	 else cout << min(R, r) - max(l, L) + (r != R) + (l != L) << endl;
	 return;
}

C题：Splitting Items

题意

Alice和Bob轮流进行操作，每次从数组中取出一个元素，得分一开始为0，Alice会加上她所取的元素的值，而Bob会减去。现在Bob可以提前进行k次数组某一个元素+1的操作，问最后的得分最小是多少？

思路

题目难度不大，感觉是div3

如果不进行操作，Alice首先取最大的，然后Bob取次大的，这样一直进行操作下去。两者取的元素的相对大小一定是Alice大于等于Bob的。

而现在Bob可以加1，但是Bob不会改变相对大小，比如

3 5        +3

6 5 

并不会这么操作，只会让3变成5就停止操作了，因为再往上加，是给Alice做贡献，如果还要追平，自己还要再花费1次操作，属于浪费。

代码

inline void solve() {
     int n, k; cin >> n >> k;
     vector<int> a(n + 1);
	 for (int i = 1; i <= n; i ++ ) cin >> a[i];
	 sort(a.begin() + 1, a.end(), greater<>());
	 ll ans = 0;
	 for (int i = 1; i <= n; i ++ ) {
		if (i & 1) ans += a[i];
		else {
			int minv = min(k, a[i - 1] - a[i]);
			k -= minv, a[i] += minv;
			ans -= a[i];
		}
	 }
	 cout << ans << endl;
	 return;
}

D题：Colored Portals

题意

每个城市有两种颜色，你只能前往与你所在城市具有相同颜色的城市，花费的代价为abs(i-j)。给定q个询问起点和终点，问最小花费

思路

别多想，就两种情况

一：给定的两个城市具有相同的颜色

那么直接花费abs(i-j)前往即可，这就是最小的

二：需要借助其他城市前往

怎么借助呢

比如RG->BY

要么我们先去一个有B的城市，要么去一个有Y的城市，然后再去我们的终点，不用再转了，只会增加花费

那我们只需记录城市颜色的转变情况即可，

4 5

BR BR GY GR

我们规定一个顺序BRGY，总共就只要C43=6中情况

b - r         b - g         b - y

r - g         r - y          g - y

我们把这6中可以变换的位置开6个数组记录下来。

这样我们需要经过“中转”的时候，去各个数组二分出距离最近的中转点即可。

代码

string color = "BRGY";
int cal(char a, char b) {
    int x = color.find(a), y = color.find(b);
    if (x > y) swap(x, y);
    if (x == 0) {
        if (y == 1) return 0;
        else if (y == 2) return 1;
        else return 2;
    }else if (x == 1) {
        if (y == 2) return 3;
        else return 4;
    }else return 5;
}
inline void solve() {
     int n, q; cin >> n >> q;
     vector<vector<int>> pos(6);
     vector<string> a(n + 1);
     for (int i = 1; i <= n; i ++ ) {
        cin >> a[i];
        pos[cal(a[i][0], a[i][1])].push_back(i);
     }
     while (q -- ) {
        int x, y; cin >> x >> y;
        if (x == y) {
            cout << 0 << endl;
            continue;
        }
        if (x > y) swap(x, y);
        int ans = (int)MOD;
        for (int i = 0; i < 2; i ++ ) {
            for (int j = 0; j < 2; j ++ ) {
                if (a[x][i] == a[y][j]) {
                    ans = y - x;
                }
                int t = cal(a[x][i], a[y][j]);
                if (pos[t].empty()) continue;
                int m = pos[t].size();
                int id = lower_bound(pos[t].begin(), pos[t].end(), x) - pos[t].begin();
                if (id == m) {
                    int now = pos[t][m - 1];
                    ans = min(ans, x - now + y - now);
                }else {
                    int now = pos[t][id];
                    if (now > y) ans = min(ans, now - x + now - y);
                    else ans = y - x;
                    if (id > 0) now = pos[t][id - 1], ans = min(ans, x - now + y - now);         
                }
            }
        }
        if (ans == (int)MOD) ans = -1;
        cout << ans << endl;
     }
	 return;
}

E题：Not a Nim Problem

题意

Nim游戏，但是每次只能取小于每一堆数量的一个质数或者1

思路

打表+sg函数

打表发现sg函数为最小质因数所在的下标

质数用欧拉筛即可

特判2的情况，sg[2]应该都是0的，所以把它的所有倍数sg都要改成0（也很好理解，偶数么，Bob照着Alice一样取就行了）

代码

const int N = 1e7;
int sg[N + 1];
vector<int> primes;
void eulerSieve() {
    vector<bool> isPrime(N + 1, true);  
    for (int i = 2; i <= N; i++) {
        if (isPrime[i]) {
			primes.push_back(i);
			sg[i] = primes.size();
		}
        for (int j = 0; j < primes.size() && i * primes[j] <= N; j++) {
            isPrime[i * primes[j]] = false;
			sg[i * primes[j]] = sg[primes[j]];
            if (i % primes[j] == 0) break;
        }
    }
}
inline void solve() {
     int n; cin >> n;
	 int ans = 0;
	 for (int i = 1; i <= n; i ++ ) {
		int x; cin >> x;
		if (x % 2 == 0) x = 0;
		ans ^= sg[x];
	 }
	 cout << (ans ? "Alice" : "Bob") << endl;
	 return;
}

inline void pre_work() {
    sg[0] = 0, sg[1] = 1, sg[2] = 0;
	eulerSieve();
}