【JZOJ4231】寻找神格

在神秘的神界,一位勇士被赋予了挑战神格的任务。他必须通过解决难题来展示自己的智慧和运气,同时,他还需理解并掌握部落人口管理的精髓,以确保各部落之间的和平与稳定。部落间的人口差距由方差衡量,神必须适时干预以避免战争。本文详细介绍了如何使用线段树数据结构来高效处理部落人数的变化和方差计算。

description

淬炼完神体,王仙女被传送到了遥远处一座没有神雷的浮岛上,发现浮岛上除了一扇门以外什么都没有。他来到门前,发现上面写着这样一段话:
一个神出了拥有强大的神体外,还需要一枚神格。然而,想要获得神格没那么简单,除了有实力外还需要有运气。曾经有一个人叫金(jin)字(zi)塔(da),他的神体很强,很壮,可是他根本没有运气,所以最后神格拒绝了他。打开这扇门,你将会进入一个神格创造的空间,在那里,神格将会问你一些问题来测试你解决问题的能力,当然,它的问题将会很难,在你答不出来的时候你可以选择随便猜一个答案,以此来展现你的运气。
王仙女二话不说打开了那扇门,一阵眩晕过后,他来到了一个灰蒙蒙的空间。一个苍老的声音在四周响起:小娃娃,我是一枚存在亿万年的神格,我的上一任主人已经死去百万余年了,我也已经在这里等待了百万年了。能否成为我的主人,让我重现百万年前的风采,就看你的能力和运气了。再问问题之前,我要先跟你讲一件事。成为一个神后,最大的责任便是保护神界的人民,他们都出生在神界,但并不都具有神的实力。当然,神界人族的内部也有战争,他们一共分为N个部落,每两个部落之间都有可能发生战争。为了不然神界人族因为战争而损失惨重,神界的诸神将这些部落编号为1 ~ N,当这些部落的人数差距太大时,诸神便会降临,将一些部落的人带走,并放一些在别的部落中。而衡量所有部落人数差距的数值便是方差。接下来,我会告诉你一些部落的人数增加或减少的信息,并会不时的询问你编号为L~R的部落的总人数或是他们部落人数的方差。


analysis

  • 线段树瞎搞维护权值和与平方和

  • 一段数的s2=1n∑i=xy(a[i]−ave)2s^2={1\over n}\sum_{i=x}^y(a[i]-ave)^2s2=n1i=xy(a[i]ave)2,而ave=∑i=xya[i]y−x+1ave={\sum^y_{i=x}a[i]\over{y-x+1}}ave=yx+1i=xya[i],平均数直接由权值和算

  • 那么s2=1n∑i=xya[i]2−2⋅a[i]⋅ave+ave2=∑i=xya[i]2−2⋅ave⋅∑i=xya[i]+(y−x+1)⋅ave2ns^2={1\over n}\sum^y_{i=x}a[i]^2-2·a[i]·ave+ave^2={\sum_{i=x}^ya[i]^2-2·ave·\sum_{i=x}^ya[i]+(y-x+1)·ave^2\over n}s2=n1i=xya[i]22a[i]ave+ave2=ni=xya[i]22avei=xya[i]+(yx+1)ave2

  • 中间的权值和与平方和用线段树维护就好了

  • 不长但是细节麻烦,注意标记下传 (我被坑了好久)

  • 这题题面说好保留三位小数,但要保留十位才能过数据怕不是傻逼

  • 时间复杂度O(nlog⁡2n)O(n\log_2n)O(nlog2n)


code

#pragma GCC optimize("O3")
#pragma G++ optimize("O3")
#include<stdio.h>
#include<string.h>
#include<algorithm>
#define MAXN 100005
#define ld double
#define ll long long
#define reg register ll
#define fo(i,a,b) for (reg i=a;i<=b;++i)
#define fd(i,a,b) for (reg i=a;i>=b;--i)
#define O3 __attribute__((optimize("-O3")))

using namespace std;

ll n,q;

struct node
{
	ll sum,sqrsum,lazy;
}tr[MAXN*4];

O3 inline ll read()
{
	ll x=0,f=1;char ch=getchar();
	while (ch<'0' || '9'<ch){if (ch=='-')f=-1;ch=getchar();}
	while ('0'<=ch && ch<='9')x=x*10+ch-'0',ch=getchar();
	return x*f;
}
O3 inline ll sqr(ll x)
{
	return x*x;
}
O3 inline void maketree(ll t,ll l,ll r)
{
	if (l==r)
	{
		tr[t].sum=read();
		tr[t].sqrsum=sqr(tr[t].sum);
		tr[t].lazy=0;
		return;
	}
	ll mid=(l+r)>>1;
	maketree(t<<1,l,mid),maketree((t<<1)+1,mid+1,r);
	tr[t].sum=tr[t<<1].sum+tr[(t<<1)+1].sum;
	tr[t].sqrsum=tr[t<<1].sqrsum+tr[(t<<1)+1].sqrsum;
}
O3 inline void downdata(ll t,ll l,ll r)
{
	if (tr[t].lazy)
	{
		tr[t*2].lazy+=tr[t].lazy,tr[t*2+1].lazy+=tr[t].lazy;
		ll mid=(l+r)>>1;
		tr[t*2].sqrsum+=((mid-l+1)*tr[t].lazy*tr[t].lazy+2*tr[t].lazy*tr[t*2].sum);
		tr[t*2+1].sqrsum+=((r-mid)*tr[t].lazy*tr[t].lazy+2*tr[t].lazy*tr[t*2+1].sum);
		tr[t*2].sum+=(mid-l+1)*tr[t].lazy,tr[t*2+1].sum+=(r-mid)*tr[t].lazy;
		tr[t].lazy=0;	
	}
}
O3 inline void change(ll t,ll l,ll r,ll x,ll y,ll z)
{
	downdata(t,l,r);
	if (l==x && y==r)
	{
		tr[t].sqrsum+=((r-l+1)*sqr(z)+2*z*tr[t].sum);
		tr[t].sum+=(r-l+1)*z;
		tr[t].lazy+=z;
		downdata(t,l,r);
		return;
	}
	ll mid=(l+r)>>1;
	if (y<=mid)change(t<<1,l,mid,x,y,z);
	else if (x>mid)change((t<<1)+1,mid+1,r,x,y,z);
	else change(t<<1,l,mid,x,mid,z),change((t<<1)+1,mid+1,r,mid+1,y,z);
	tr[t].sum=tr[t<<1].sum+tr[(t<<1)+1].sum;
	tr[t].sqrsum=tr[t<<1].sqrsum+tr[(t<<1)+1].sqrsum;
}
O3 inline ll query_sum(ll t,ll l,ll r,ll x,ll y)
{
	downdata(t,l,r);
	if (l==x && y==r)return tr[t].sum;
	ll mid=(l+r)>>1;
	if (y<=mid)return query_sum(t<<1,l,mid,x,y);
	else if (x>mid)return query_sum((t<<1)+1,mid+1,r,x,y);
	else return query_sum(t<<1,l,mid,x,mid)+query_sum((t<<1)+1,mid+1,r,mid+1,y);
}
O3 inline ll query_sqrsum(ll t,ll l,ll r,ll x,ll y)
{
	downdata(t,l,r);
	if (l==x && y==r)return tr[t].sqrsum;
	ll mid=(l+r)>>1;
	if (y<=mid)return query_sqrsum(t<<1,l,mid,x,y);
	else if (x>mid)return query_sqrsum((t<<1)+1,mid+1,r,x,y);
	else return query_sqrsum(t<<1,l,mid,x,mid)+query_sqrsum((t<<1)+1,mid+1,r,mid+1,y);
}
O3 int main()
{
	//freopen("T1.in","r",stdin);
	n=read(),q=read();
	maketree(1,1,n);
	while (q--)
	{
		ll t=read(),x=read(),y=read(),z;
		if (t==0)change(1,1,n,x,x,y);
		else if (t==1)z=read(),change(1,1,n,x,y,z);
		else if (t==2)printf("%lld\n",query_sum(1,1,n,x,y));
		else
		{
			ll num=y-x+1,sum=query_sum(1,1,n,x,y);
			ld ave=1.0*sum/num;
			ld ans=1.0*query_sqrsum(1,1,n,x,y)-2.0*ave*sum+ave*ave*num;
			printf("%.10lf\n",1.0*ans/num);
		}
	}
	return 0;
}
### 解题思路 题目要求解决的是一个与图相关的最小覆盖问题,通常在特定条件下可以通过状态压缩动态规划(State Compression Dynamic Programming, SCDP)来高效求解。由于状态压缩的适用条件是状态维度较小(例如K≤10),因此可以利用二进制表示状态集合,从而优化计算过程。 #### 1. 状态表示 - 使用一个整数 `mask` 表示当前选择的点集,其中第 `i` 位为 `1` 表示第 `i` 个节点被选中。 - 定义 `dp[mask]` 表示在选中 `mask` 所代表的点集后,能够覆盖的节点集合。 - 可以通过预处理每个点的邻域信息(包括自身和所有直接连接的点),快速更新状态。 #### 2. 预处理邻域 对于每个节点 `u`,预先计算其邻域范围 `neighbor[u]`,即从该节点出发一步能到达的所有节点集合。这样,在后续的状态转移过程中,可以直接使用这些信息进行合并操作。 #### 3. 状态转移 - 初始化:对每个单独节点 `u`,设置初始状态 `dp[1 << u] = neighbor[u]`。 - 转移规则:对于任意两个状态 `mask1` 和 `mask2`,如果它们没有交集,则可以通过合并这两个状态得到新的状态 `mask = mask1 | mask2`,并更新对应的覆盖范围为 `dp[mask1] ∪ dp[mask2]`。 - 在所有状态生成之后,检查是否某个状态的覆盖范围等于全集(即覆盖了所有节点)。如果是,则记录此时使用的最少节点数量。 #### 4. 最优解提取 遍历所有可能的状态,找出能够覆盖整个图的最小节点数目。 --- ### 时间复杂度分析 - 状态总数为 $ O(2^K) $,其中 `K` 是关键点的数量。 - 每次状态转移需要枚举所有可能的子集组合,复杂度为 $ O(2^K \cdot K^2) $。 - 整体时间复杂度控制在可接受范围内,适用于 `K ≤ 10~20` 的情况。 --- ### 代码实现(状态压缩 DP) ```cpp #include <bits/stdc++.h> using namespace std; const int MAXN = 25; int neighbor[MAXN]; // 每个节点的邻域 int dp[1 << 20]; // dp[mask] 表示选中的点集合为 mask 时所能覆盖的点集合 int min_nodes; // 最小覆盖点数 void solve(int n, vector<vector<int>>& graph) { // 预处理每个节点的邻域 for (int i = 0; i < n; ++i) { neighbor[i] = (1 << i); // 包括自己 for (int j : graph[i]) { neighbor[i] |= (1 << j); } } // 初始化 dp 数组 memset(dp, 0x3f, sizeof(dp)); for (int i = 0; i < n; ++i) { dp[1 << i] = neighbor[i]; } // 状态转移 for (int mask = 1; mask < (1 << n); ++mask) { if (__builtin_popcount(mask) >= min_nodes) continue; // 剪枝 for (int sub = mask & (mask - 1); sub; sub = (sub - 1) & mask) { int comp = mask ^ sub; if (comp == 0) continue; int new_mask = mask; int covered = dp[sub] | dp[comp]; if (covered == (1 << n) - 1) { min_nodes = min(min_nodes, __builtin_popcount(new_mask)); } dp[new_mask] = min(dp[new_mask], covered); } } } int main() { int n, m; cin >> n >> m; vector<vector<int>> graph(n); for (int i = 0; i < m; ++i) { int u, v; cin >> u >> v; graph[u].push_back(v); graph[v].push_back(u); // 无向图 } min_nodes = n; solve(n, graph); cout << "Minimum nodes required: " << min_nodes << endl; return 0; } ``` --- ### 优化策略 - **剪枝**:当当前状态所用节点数已经超过已知最优解时,跳过后续计算。 - **提前终止**:一旦发现某个状态覆盖了全部节点,并且节点数达到理论下限,即可提前结束程序。 - **空间优化**:可以仅保存当前轮次的状态,减少内存占用。 --- ### 总结 本题通过状态压缩动态规划的方法,将原本指数级复杂度的问题压缩到可接受范围内。结合位运算技巧和预处理机制,能够高效地完成状态转移和覆盖判断操作。 ---
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值