VP Codeforces Round 905 (Div. 2)

---

A. Chemistry

题意：一个字符串，能不能删除不超过$k$字符和重排后是回文。

记录每个字符的数量，如果是奇数则我们可能需要删除，最多留一个不能删的放在中间。

点击查看代码

void solve() {
    int n, k;
    std::cin >> n >> k;
    std::string s;
    std::cin >> s;
    std::vector<int> cnt(26);
    for (auto & c : s) {
    	++ cnt[c - 'a'];
    }

    int tot = 0;
    for (int i = 0; i < 26; ++ i) {
    	tot += cnt[i] & 1;
    }

    if (k - tot >= -1) {
    	std::cout << "YES\n";
    } else {
    	std::cout << "NO\n";
    }
}

---

B. Raspberries

题意：给你一个数组，每次可以给一个数加一，使得这些数的乘积是$k$的倍数，问最少加几次。$k\in [2,5]$。

发现除了$k$等于$4$的时候，都是质数，只需要求每个数变成$k$的倍数需要加的最小值。如果是$4$，则还要看选两个数变成$2$的倍数需要加多少。

点击查看代码

void solve() {
    int n, k;
    std::cin >> n >> k;
    std::vector<int> a(n);
    for (int i = 0; i < n; ++ i) {
    	std::cin >> a[i];
    }

    int ans = 1e9;
    for (int i = 0; i < n; ++ i) {
    	ans = std::min(ans, (a[i] + k - 1) / k * k - a[i]);
    }

    if (k == 4) {
    	int min1 = 1e9, min2 = 1e9;
    	for (int i = 0; i < n; ++ i) {
    		int x = (a[i] + 1) / 2 * 2 - a[i];
    		if (x < min1) {
    			min2 = min1;
    			min1 = x;
    		} else if (x < min2) {
    			min2 = x;
    		}
    	}

    	std::cout << std::min(ans, min1 + min2) << "\n";
    } else {
    	std::cout << ans << "\n";
    }
}

---

C. You Are So Beautiful

题意：求数组有多少子数组在所有子序列里只出现过一次。

预处理每个数前面有没有出现过，和在后面有没有出现过。那么所选的子数组的第一个数和最后一个数在前后各自不能出现。从前往后枚举右端点，如果右端点合法则加上前面合法的左端点的个数。

点击查看代码

void solve() {
    int n;
    std::cin >> n;
    std::vector<int> a(n);
    for (int i = 0; i < n; ++ i) {
    	std::cin >> a[i];
    }

    std::vector<int> pre(n), suf(n);
    std::set<int> s;
    for (int i = 0; i < n; ++ i) {
    	if (s.count(a[i])) {
    		pre[i] = 1;
    	}

    	s.insert(a[i]);
    }

    s.clear();
    for (int i = n - 1; i >= 0; -- i) {
    	if (s.count(a[i])) {
    		suf[i] = 1;
    	}

    	s.insert(a[i]);
    }

    i64 ans = 1;
    int sum = 0;
    for (int i = 0; i < n; ++ i) {
    	sum += !pre[i];
    	if (!suf[i]) {
    		ans += i == n - 1 ? sum - 1 : sum;
    	}
    }

    std::cout << ans << "\n";
}

---

D1. Dances (Easy version) && D2. Dances (Hard Version)

题意：给你两个数组$a,b$其中$a$的第一个数待定。求$a_1\in [1,m]$的每种情况的最小操作数。两个数组满足条件使得两个数组各自删除同样个数的数，然后重排后使得$a_i<b_i$。

因为可以重排，我们自然是让两个数组都从小到大排。然后$a$删去前面一些数，$b$删去后面一些数。那么对于$D1$，$m=1$，我们只需要二分出最小操作数。
对于$D2$，我们先看$m$作为$a_1$的取值范围为$[1,a_2]$，那么$[1,b_1-1]$的操作数是相同的，我们二分求出后面第一个和它操作数相同的数，对于$m$作为$a_i$取值范围为$[a_{i-1},a_i]$，那么$[a_{i-1},b_i-1]$的操作数是相同的，同样可以二分求。于是我们从$m=1$开始，每次二分求与它操作数相等的数$j$，然后$i=j+1$这样一直跳即可。发现最多跳$lo{g}_{2}m$次。

点击查看代码

void solve() {
    int n, m;
    std::cin >> n >> m;
    std::vector<int> a(n), b(n);
    for (int i = 1; i < n; ++ i) {
    	std::cin >> a[i];
    }

    for (int i = 0; i < n; ++ i) {
    	std::cin >> b[i];
    }

    std::sort(b.begin(), b.end());

    auto get = [&](int x) -> int {
        auto aa = a;
        aa[0] = x;
        std::sort(aa.begin(), aa.end());
        auto check = [&](int x) -> bool {
        	for (int i = 0; i < n - x; ++ i) {
        		if (aa[i] >= b[i + x]) {
        			return false;
        		}
        	}

        	return true;
        };

        int l = 0, r = n;
        while (l < r) {
        	int mid = l + r >> 1;
        	if (check(mid)) {
        		r = mid;
        	} else {
        		l = mid + 1;
        	}
        }

        return l;
    };

    i64 ans = 0;
    for (int i = 1; i <= m;) {
        int l = i, r = m;
        int t = get(i);
        while (l < r) {
            int mid = l + r + 1 >> 1;
            if (t == get(mid)) {
                l = mid;
            } else {
                r = mid - 1;
            }
        }

        ans += (i64)(l - i + 1) * get(i);
        // std::cout << get(i) << " " << i << " " << l << "\n";
        i = l + 1;
    }

    std::cout << ans << "\n";
}   

---

E. Time Travel

题意：有$t$个图，每个图有$n$个点，$m_i$条边。同时给出一个序列，每次你会在第$a_i$个图上操作，你每次可以选择走一条边或者不动。你一开始在第$a_1$个图的$1$号点，你要到第$n$号点，求最少几次操作后能到。

对于第$i$个图的边$(u,v)$，连上$(u,v,i)$的边，代表这条边是第几个图上的。那么我们可以$dijkstra$，记录$dis{t}_u$为到$u$时的最少操作数。那么我们给每个图在序列里出现的位置存下来，那么对于一条边$(u,v,i)$，我们二分第$i$张图大于等于$dis{t}_u$这个位置的最小的位置，就可以转移。

点击查看代码

void solve() {
    int n, t;
    std::cin >> n >> t;
    std::vector<std::vector<std::pair<int, int>>> adj(n);
    for (int i = 0; i < t; ++ i) {
    	int m;
    	std::cin >> m;
    	while (m -- ) {
    		int u, v;
    		std::cin >> u >> v;
    		-- u, -- v;
    		adj[u].push_back({v, i});
    		adj[v].push_back({u, i});
    	}
    }

    int k;
    std::cin >> k;
    std::vector<std::vector<int>> pos(t);
    for (int i = 0; i < k; ++ i) {
    	int x;
    	std::cin >> x;
    	-- x;
    	pos[x].push_back(i);
    }

    const int inf = 1e9;
    using PII = std::pair<int, int>;
    std::vector<int> dist(n, inf);
    dist[0] = 0;
    std::priority_queue<PII, std::vector<PII>, std::greater<PII>> heap;
    heap.push({dist[0], 0});
    while (heap.size()) {
    	auto [d, u] = heap.top(); heap.pop();
    	if (d != dist[u]) {
    		continue;
    	}

    	for (auto & [v, t] : adj[u]) {
    		auto it = std::lower_bound(pos[t].begin(), pos[t].end(), d);
    		if (it == pos[t].end()) {
    			continue;
    		}

    		if (dist[v] > *it + 1) {
    			dist[v] = *it + 1;
    			heap.push({dist[v], v});
    		}
    	}
    }

    int ans = dist[n - 1] == inf ? -1 : dist[n - 1];
    std::cout << ans << "\n";
}

---

F. Minimum Array

题意：一个数组，$m$次区间加操作，求第几次操作后的数组在所有数组里字典序最小。

区间加可以联想到差分操作。我们用$map$存$d$数组，那么每次操作后，先把最前面的加$0$的位置删掉，然后看第一个不为$0$的位置是不是加的负数，如果加的负数，意味着数组的字典序变小了，记录操作到了第几个，然后清空$map$，继续操作，这样下一个字典序小的就是相当于当前字典序最小的数组而言的，就是前$i$个数组字典序最小的。

点击查看代码

void solve() {
    int n;
    std::cin >> n;
    std::vector<i64> a(n + 1);
    for (int i = 1; i <= n; ++ i) {
    	std::cin >> a[i];
    }

    int m;
    std::cin >> m;
    std::vector<int> l(m + 1), r(m + 1), x(m + 1);
    int p = 0;
    std::map<int, i64> d;
    for (int i = 1; i <= m; ++ i) {
    	std::cin >> l[i] >> r[i] >> x[i];
    	d[l[i]] += x[i], d[r[i] + 1] -= x[i];
   		while (!d.empty() && d.begin()->second == 0) {
   			d.erase(d.begin());
   		} 

   		if (!d.empty() && d.begin()->second < 0) {
   			p = i;
   			d.clear();
   		}
    }

    std::vector<i64> b(n + 2);
    for (int i = 1; i <= p; ++ i) {
    	b[l[i]] += x[i]; b[r[i] + 1] -= x[i];
    }

    for (int i = 1; i <= n; ++ i) {
    	b[i] += b[i - 1];
    	a[i] += b[i];
    }

    for (int i = 1; i <= n; ++ i) {
    	std::cout << a[i] << " \n"[i == n];
    }
}