day1-周雨扬

T2 CF467G

• 给定一个长度为 n 的序列和一个整数p。
• 有 m个操作，操作要么是区间赋值，要么是询问区间内出现次数至少占 p% 的数。
• 输出询问的答案时，可以包含错的数，也可以重复输出，但对的数一定要在答案中，且输出的数的个数不超过 \(\lfloor \frac{100}{p}\rfloor\)。
• \(n,m \le 1.5 \times 10^5，20 \le p \le 100\)。

若p >= 51时 等价于求区间绝对众数

在考虑若 \(20 \le p \le 50\) 则维护至多5个出现次数最多的数即可。

#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
using namespace std;
typedef long long LL;
const int N = 1.5e5+10;
inline int read()
{
	register int x = 0 , f = 0; register char c = getchar();
	while(c < '0' || c > '9') f |= c == '-' , c = getchar();
	while(c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0' , c = getchar();
	return f ? -x : x;
}
int n , m , p;
struct node
{
	int siz , tag , a[6] , b[6]; // siz 数量 ， a 出现次数最多的数 ， b 出现次数 
	node() { memset(a , 0 , sizeof a); memset(b , 0 , sizeof b); siz = tag = 0; }
	inline node operator = (const node &o)
	{
		siz = o.siz; tag = 0; // tag 清0 ， 好像是防止叶子的tag被瞎用。。。。 
		memcpy(a , o.a , sizeof a);
		memcpy(b , o.b , sizeof b);
		return *this;
	}
	node operator + (const node &A) const 
	{
		node res = A;
		for(int i = 1 ; i <= siz ; ++i)
		{
			int flag = 0;
			for(int j = 1 ; j <= res.siz ; ++j)
				if(a[i] == res.a[j]) { res.b[j] += b[i]; flag = 1; break; }
			if(flag) continue;
			if(res.siz < p) { res.siz++; res.a[res.siz] = a[i]; res.b[res.siz] = b[i]; continue; }
			
			int k = 1;
			for(int j = 2 ; j <= res.siz ; ++j) if(res.b[k] > res.b[j]) k = j;
			if(b[i] < res.b[k])
				for(int j = 1 ; j <= res.siz ; ++j) res.b[j] -= b[i];
			else
			{
				int tmp = res.b[k];
				res.a[k] = a[i]; res.b[k] = b[i];
				for(int j = 1 ; j <= res.siz ; ++j) res.b[j] -= tmp;
			}
		}
		return res;
	}
}tr[N << 2];

#define lson k << 1 , l , mid
#define rson k << 1 | 1 , mid + 1 , r

inline void update(int k) { tr[k] = tr[k << 1] + tr[k << 1 | 1]; return ; }

void build(int k , int l , int r)
{
	if(l == r) { tr[k].a[1] = read(); tr[k].b[1] = tr[k].siz = 1; return ; }
	int mid = (l + r) >> 1;
	build(lson); build(rson); return update(k);
}

inline void Tag(int k , int l , int r , int val)
{
	tr[k].a[1] = val; tr[k].b[1] = r - l + 1; tr[k].siz = 1; tr[k].tag = val; return ;
}

inline void down(int k , int l , int r)
{
	if(tr[k].tag)
	{
		int mid = (l + r) >> 1;
		Tag(lson , tr[k].tag); Tag(rson , tr[k].tag);
		tr[k].tag = 0;
	}
	return ; 
}

void modify(int k , int l , int r , int x , int y , int val)
{
	if(x <= l && r <= y) return Tag(k , l , r , val);
	int mid = (l + r) >> 1; down(k , l , r);
	if(x <= mid) modify(lson , x , y , val);
	if(y  > mid) modify(rson , x , y , val);
	return update(k);
}

node Ask(int k , int l , int r , int x , int y)
{
	if(x <= l && r <= y) return tr[k];
	int mid = (l + r) >> 1; down(k , l , r);
	if(y <= mid) return Ask(lson , x , y);
	if(x  > mid) return Ask(rson , x , y);
	return Ask(lson , x , y) + Ask(rson , x , y);
}

int main()
{
	n = read(); m = read(); p = 100 / read();
	build(1 , 1 , n);
	int op , l , r , x;
	while(m--)
	{
		op = read(); l = read(); r = read();
		if(op == 1) x = read() , modify(1 , 1 , n , l , r , x);
		if(op == 2)
		{
			node s = Ask(1 , 1 , n , l , r); cout << s.siz;
			for(int i = 1 ; i <= s.siz ; ++i) cout << ' ' << s.a[i]; cout << '\n';
		}
	}
	return 0;
}

T3

有n个点的树，边权为1，给出你每个点到其他点的距离和\(D_i\)，构建出这个树.

\(n \le 1e5 , D_i \ le 1e12\)

构造，到其他点距离最大的一定是叶子，若叶子是x，那么fa就是 x + siz[son] - (n - siz[son]) = x - n + 2 * siz[son]

从下往上构建，即可，最后再检查一遍。

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<vector>
#include<cmath>
#include<map>
using namespace std;
typedef long long LL;
const int N = 1e5+10;
inline LL read()
{
	register LL x = 0 , f = 0; register char c = getchar();
	while(c < '0' || c > '9') f |= c == '-' , c = getchar();
	while(c >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0' , c = getchar();
	return f ? -x : x;
}
int n;
LL d[N];
int eu[N] , ev[N] , siz[N];
vector<int> G[N];
map<LL , int> mp;
struct node
{
	LL d;
	int id;
}p[N];

inline bool cmp(const node &A , const node &B) { return A.d > B.d; }

void dfs1(int x , int dep , int rot)
{
	siz[x] = 1; d[rot] += dep;
	for(int i = 0 ; i < G[x].size() ; ++i) dfs1(G[x][i] , dep + 1 , rot) , siz[x] += siz[G[x][i]];
	return ;
}

void dfs2(int x)
{
	for(int i = 0 ; i < G[x].size() ; ++i)
	{
		d[G[x][i]] = d[x] + n - 2 * siz[G[x][i]];
		dfs2(G[x][i]);
	}
	return ;
}

int main()
{
	n = read();
	for(int i = 1 ; i <= n ; ++i) p[i].d = read() , p[i].id = i , mp[p[i].d] = i;
	LL sum = 0;
	for(int i = 1 ; i <= n ; ++i) sum += p[i].d;
	if(sum & 1) { puts("-1"); return 0; }
	sort(p + 1 , p + 1 + n , cmp);
	for(int i = 1 ; i <= n ; ++i) siz[i] = 1;
	for(int i = 1 ; i <  n ; ++i)
	{
		LL fa_d = p[i].d - n + 2 * siz[p[i].id];
		if(!mp.count(fa_d)) { puts("-1"); return 0; }
		ev[i] = p[i].id; eu[i] = mp[fa_d]; siz[eu[i]] += siz[ev[i]];
	}
	for(int i = 1 ; i <  n ; ++i) G[eu[i]].push_back(ev[i]);
	dfs1(p[n].id , 0 , p[n].id); dfs2(p[n].id);
	for(int i = 1 ; i <= n ; ++i) if(d[p[i].id] != p[i].d) { puts("-1"); return 0; }
	for(int i = 1 ; i <  n ; ++i) cout << eu[i] << ' ' << ev[i] << '\n';
	return 0;
}