2019 浙江省赛 A B C

A Vertices in the Pocket

     DSU + 权值线段树 + 二分

     $tot$ 表示当前不减少连通块的最大加边数
     叶子结点表示连通块的大小，线段树维护：
     $cnt$    维护连通块个数
     $sum$    维护连点数和
     $pfh$    维护连点数的平方和

     最小值就是当前连通块个数 $-1$
     对于最大值，则增加 $k-tot$ 条边，贪心加在第一大连通块和第二大连通块之间，也就是不断地找右子树，如果可加边数仍小于 $k-tot$，则往左子树寻找，
     对于最后返回值，因为维护的是连通块个数，所以对个数进行二分出答案，返回即可

     太太考验码力了。。。

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 2e5 + 10;

#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
int n, t, q, op, cont, f[maxn];
ll tot, num[maxn];
ll cnt[maxn<<2], sum[maxn<<2], pfh[maxn<<2];

int find(int v) {
	return f[v] == v ? v : f[v] = find(f[v]);
}

void pushup(int rt){
	cnt[rt] = cnt[rt<<1] + cnt[rt<<1|1];
	sum[rt] = sum[rt<<1] + sum[rt<<1|1];
	pfh[rt] = pfh[rt<<1] + pfh[rt<<1|1];
}

void build(int l,int r,int rt){
	if(l==r){
		cnt[rt] = sum[rt] = pfh[rt] = (l==1 ? n : 0);
		return;
	}
	int m = (l+r)>>1;
	build(lson);
	build(rson);
	pushup(rt);
}

void update(ll pos,ll c,int l,int r,int rt){
	if(l==r){
		cnt[rt] += c;
		sum[rt] += c*pos;
		pfh[rt] += c*pos*pos;
		return ;
	}
	int m = (l+r)>>1;
	if(pos<=m) update(pos,c,lson);
	else update(pos,c,rson);
	pushup(rt);
}

ll query(ll k,int l,int r,int rt,int all){
	if(l==r){
		ll l1 = 1, r1 = cnt[rt], mid;
		while(l1<r1){
			mid = (l1+r1)>>1;
			if(mid*(mid-1)/2*l*l+mid*l*all >= k)
				r1 = mid;
			else l1 = mid + 1;
		}
		return l1;
	}
	int m = (l+r)>>1;
	// 贪心：计算当前右子树的可连边数 
	ll tmp = (sum[rt<<1|1]*sum[rt<<1|1]-pfh[rt<<1|1]) / 2;
	tmp += all * sum[rt<<1|1];
	if(tmp<k) return cnt[rt<<1|1] + query(k-tmp,lson,all+sum[rt<<1|1]);
	else return query(k,rson,all);
}

ll solve(ll k){
	if(k<=tot) return cont;
	k -= tot;
	ll ret = query(k,1,n,1,0);
	return cont-ret+1;
}

int main() {
	scanf("%d", &t);
	while(t--) {
		scanf("%d%d", &n, &q);
		tot = 0, cont = n;
		for(int i=1; i<=n; i++) {
			f[i] = i;
			num[i] = 1;
		}
		build(1,n,1);
		while(q--) {
			scanf("%d", &op);
			if(op==1) {
				int u, v;
				scanf("%d%d", &u, &v);
				u = find(u), v = find(v);
				if(u==v) {
					tot--;
					continue;
				}
				if(num[u]>num[v]) swap(u,v);	// 合并到 v
				update(num[u],-1,1,n,1);
				update(num[v],-1,1,n,1);
				cont--;
				f[u] = v;
				tot += num[u]*num[v] - 1;
				num[v] += num[u];
				num[u] = 0;
				update(num[v],1,1,n,1);
			}
			else {
				ll k;
				scanf("%lld", &k);
				ll ans1 = max(1LL, cont-k);
				ll ans2 = solve(k);
				printf("%lld %lld\n", ans1, ans2);
			}
		}
	}
}

---

B Element Swapping

     数学

     可求出 $a[i]+a[j]$的值，继而求出 $i$ 和 $j$ 的关系
     $On$ 枚举 $i$ ，$O1$ 验证 $j$

#include<bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair <int,int> pii;
const ll mod = 1e9 + 7;
const int maxn = 3e5 + 10;
int n, t;
ll x, y, x2, y2, ans, a[maxn];
map <ll,ll> mp;

inline ll read(){
    ll x=0;
    char ch=getchar();
    while(ch>'9' || ch<'0') ch=getchar();
    while(ch>='0' && ch<='9') x=x*10+ch-'0',ch=getchar();
    return x;
}

int main() {
	t = read();
	while(t--) {
		n = read(); x = read(); y = read();
		x2 = y2 = ans = 0;
		mp.clear();
		for(int i=1; i<=n; i++) {
			a[i] = read();
			x2 += 1ll*i*a[i];
			y2 += 1ll*i*a[i]*a[i];
			mp[a[i]]++;
		}
		if(x2==x) {
			if(y2!=y) {
				puts("0");
				continue;
			} else {
				for(auto i:mp) {
					ll tmp = i.second;
					ans += tmp*(tmp-1)/2;
				}
				printf("%lld\n",ans);
				continue;
			}
		} else if(abs(y-y2)%abs(x-x2)!=0) {
			puts("0");
			continue;
		} else {
			ll he = (y-y2)/(x-x2);
			for(int i=1; i<=n; i++){
				ll aj = he - a[i];
				if(a[i]==aj) continue;
				if(abs(x-x2)%abs(a[i]-aj)!=0) continue;
				
				int j = i + (x-x2)/(a[i]-aj);
				if(j<=i) continue;
				if(aj==a[j] && x2+1ll*(j-i)*(a[i]-a[j]) == x)
					if(y2+1ll*(j-i)*(a[i]*a[i]-a[j]*a[j]) == y)
						ans++;
			}
		}
		printf("%lld\n", ans);
	}
}

---

C Array in the Pocket

     $set$ 或者 线段树

     从前往后贪心取最小
     维护当前剩余所有元素的个数 + 当前位置后面所有元素的个数
     若上述和 $\le n-i$，即为可行值，否则往下取次小
     这里用 $set$ 和优先队列瞎搞出来了

---

2020 / 6/ 20 更新：
判断当前的值能否选取的条件是：后面所有的值有一种合理选法使得满足题意
判断剩余的值存不存在合法答案，也就是对于剩余的每一个值，还需要选取 $x$ 次 $+$ A数组里还出现了 $y$ 次 $\le$ 剩余的位置数量
满足上述不等式说明存在合法答案，因此只需要找出最大的 $x+y$ 看是否满足即可
因为最大的满足了，其他的也肯定可以满足

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair <int,int> pii;
const ll mod = 1e9 + 7;
const int maxn = 1e5 + 10;
int n, t, a[maxn], b[maxn], p[maxn];
int num[maxn], vis[maxn];
set <int> s;
set <int>::iterator it;

struct Node{
	int sum, val;
	Node(){}
	Node(int Sum, int Val){
		sum = Sum, val = Val;
	}
	bool friend operator <(Node A, Node B){
		return A.sum < B.sum;
	}
};
priority_queue <Node> q;

void init(){
	s.clear();
	memset(p,0,sizeof(p));
	memset(num,0,sizeof(num));
	memset(vis,0,sizeof(vis));
	while(!q.empty()) q.pop();
}

int main(){
	scanf("%d", &t);
	while(t--){
		init();
		scanf("%d", &n);
		for(int i=0; i<n; i++){
			scanf("%d", a+i);
			num[a[i]]++;
			s.insert(a[i]);
		}
		for(int i=0; i<n; i++){
			if(!vis[a[i]]) q.push(Node(num[a[i]]*2, a[i]));
			vis[a[i]] = 1;
		}
		
		int f = 0, flag = 1;
		for(int i=0; i<n; i++){
			f = 0;
			for(it=s.begin(); it!=s.end(); it++){
				if(*it != a[i]){
					while(!q.empty()){
						Node now = q.top();
						if(p[now.val]){
							now.sum -= p[now.val];
							p[now.val] = 0;
							q.pop(); q.push(now);
							continue;
						}
						int ok = now.sum;
						if(now.val==a[i] || now.val==*it) ok--;
						if(ok <= n-i-1) f = 1;
						else f = 0;
						break;
					}
					if(f==1){
						b[i] = *it;
						p[b[i]]++; num[b[i]]--;
						if(num[b[i]]==0) s.erase(it);
					}
				}
				
				if(f == 1) break;
			}
			
			p[a[i]]++;
			if(f == 0) { flag = 0; break; }
		}
		
		if(!flag) puts("Impossible");
		else for(int i=0; i<n; i++)
			printf("%d%c", b[i], i==n-1 ? '\n' : ' ');
	}
}