「LOJ2267」「SDOI2017Round2」龙与地下城

本文介绍了一种游戏战斗模拟中的概率计算方法,利用中心极限定理和正态分布近似求解角色攻击命中和伤害值的概率问题。针对不同情况采用精确计算与近似计算两种策略。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

题目描述

小 Q 同学是一个热爱学习的人,但是他最近沉迷于各种游戏,龙与地下城就是其中之一。 在这个游戏中,很多场合需要通过掷骰子来产生随机数,并由此决定角色未来的命运,因此骰子堪称该游戏的标志性道具。

骰子也分为许多种类,比如 4 面骰、6 面骰、8 面骰、12 面骰、20 面骰,其中 20 面骰用到的机会非常多。当然,现在科技发达,可以用一个随机数生成器来取代真实的骰子,所以这里认为骰子就是一个随机数生成器。

在战斗中,骰子主要用来决定角色的攻击是否命中,以及命中后造成的伤害值。举个例子,假设现在已经确定能够命中敌人,那么 YdXYdX(也就是掷出 YYX 面骰子之后所有骰子显示的数字之和)就是对敌人的基础伤害。在敌人没有防御的情况下,这个基础伤害就是真实伤害。

众所周知,骰子显示每个数的概率应该是相等的,也就是说,对于一个 XX 面骰子,显示
0,1,2X1 中每一个数字的概率都是 1X1X​​ 。

更形式地说,这个骰子显示的数 WW 满足离散的均匀分布,其分布列为

W
00 122 X1X−1
PP 1X1X1X1X1X1X1X

除此之外还有一些性质

WW 的一阶原点矩(期望)为

v1(W)=E(W)=i=0X1iP(W=i)=X12

​​
WW 的二阶中心矩(方差)为

μ2(W)=E((WE(W))2)=i=0X1(iE(W))2P(W=i)=X2112

​​
言归正传,现在小 Q 同学面对着一个生命值为 AA 的没有防御的敌人,能够发动一次必中的 YdX 攻击,显然只有造成的伤害不少于敌人的生命值才能打倒敌人。但是另一方面,小 Q 同学作为强迫症患者,不希望出现 overkill,也就是造成的伤害大于 BB 的情况,因此只有在打倒敌人并且不发生 overkill 的情况下小 Q 同学才会认为取得了属于他的胜利。
因为小 Q 同学非常谨慎,他会进行 10 次模拟战,每次给出敌人的生命值 A 以及 overkill 的标准 BB,他想知道此时取得属于他的胜利的概率是多少,你能帮帮他吗?

输入格式

第一行是一个正整数 T ,表示测试数据的组数。
对于每组测试数据,第一行是两个整数 XXY,分别表示骰子的面数以及骰子的个数。
接下来 1010 行,每行包含两个整数 AAB,分别表示敌人的生命值 AA 以及 overkill 的标准 B

输出格式

对于每组测试数据,输出 1010 行,对每个询问输出一个实数,要求绝对误差不超过 0.0135790.013579,也就是说,记输出为 aa,答案为 b,若满足 |ab|0.013579|a−b|≤0.013579 ,则认为输出是正确的。

样例

样例输入
1
2 19
0 0
0 1
0 2
0 3
0 4
0 5
0 6
0 7
0 8
0 9
样例输出
0.000002
0.000038
0.000364
0.002213
0.009605
0.031784
0.083534
0.179642
0.323803
0.500000

数据范围与提示

对于 100%100% 的数据,T10T≤102X202≤X≤201Y2000001≤Y≤2000000AB(X1)Y0≤A≤B≤(X−1)Y ,保证满足 Y>800Y>800 的数据不超过 22 组。

题解

应用中心极限定理 。中心极限定理 - 维基百科

设随机变量 X1,X2,,Xn 独立同分布, 且具有有限的数学期望和方差 E(Xi)=μE(Xi)=μD(Xi)=σ20(i=1,2,,n)D(Xi)=σ2≠0(i=1,2,⋯,n) 。记
X¯=1nni=1XiX¯=1n∑i=1nXiζn=X¯μσ/nζn=X¯−μσ/n ,则 limnP(ζnz)=Φ(z)limn→∞P(ζn≤z)=Φ(z)
其中 Φ(z)Φ(z) 是标准正态分布的分布函数。

这个定理的含义是:nn 个独立同分布,且具有有限的数学期望 μ 和方差 σ2σ2 的随机变量,他们的平均值的分布函数在 nn→∞ 时无限近似于期望为 μμ ,方差为σ2nσ2n 的正态分布。

考虑到题目要求的精度误差十分宽松,我们考虑在 YY 比较大的时候用正态分布函数的积分来近似答案。

由于正态分布函数的概率密度函数

Φ(x)=1σ2πe(xμ)22σ2

的不定积分不是初等函数,所以考虑自适应辛普森积分。函数是光滑的,所以误差很小。

有一点需要注意:由于峰比较窄,积分区间比较大的时候可能出现 l,3l+r4,l+r2,l+3r4,rl,3l+r4,l+r2,l+3r4,r五处的函数值都几乎为零,但是峰在积分区间内的情况,这会导致答案错误。一种方法是分成若干个小的区间分别进行辛普森积分,第二种方式是只计算 [A,B][μ3σ,μ+3σ][A,B]∩[μ−3σ,μ+3σ] 的积分(因为正态分布函数在[μ3σ,μ+3σ][μ−3σ,μ+3σ] 外的比率只占不到 0.3%0.3% ,可以忽略不计), 还有一种方法是直接使用误差函数 erf(x)=2πx0et2dterf(x)=2π∫0xe−t2dt 直接计算(需要C++11)。

My Code

#include <bits/stdc++.h>
#define pi acos(-1)
#define eps 1e-15

using namespace std;
int n, m;
double f[2][32005], g[2][32005];
void solve1(){
    int p = 0, q = 1;
    f[p][0] = 1; g[p][0] = 1;
    for(int i = 1; i <= n; i ++){
        for(int j = 0; j <= (m - 1) * i; j ++){
            double tmp = g[p][min(j, (m - 1) * (i - 1))]; if(j >= m) tmp -= g[p][j - m];
            f[q][j] = tmp / m; g[q][j] = f[q][j]; if(j > 0) g[q][j] += g[q][j - 1];
        //  printf("%d %d %.6lf\n", i, j, f[q][j]);
        }
        swap(p, q);
    }
    for(int i = 1; i <= 10; i ++){
        int a, b;
        scanf("%d%d", &a, &b);
        double ans = g[p][b]; if(a != 0) ans -= g[p][a - 1];
        printf("%.6lf\n", ans); 
    }
}
double mu, sigma, pi2;
inline double sqr(double x) {return x * x;}
inline double F(double x){
//  printf("%.10lf %.10lf\n", x, exp(-sqr(x - mu) / 2 / sqr(sigma)) / pi2 / sigma);
    return exp(-sqr(x - mu) / 2 / sqr(sigma)) / pi2 / sigma;
}
double cal(double l, double r){
    double mid = (l + r) / 2;
    return (r - l) / 6 * (F(l) + 4 * F(mid) + F(r));
}
double simpson(double l, double r, double cur){
    double mid = (l + r) / 2;
    double cl = cal(l, mid);
    double cr = cal(mid, r);
//  printf("%.11lf %.11lf %.11lf %.11lf %.11lf %.11lf\n", l, r, cl, cr, cur, fabs(cur - cl - cr));
    if(fabs(cur - cl - cr) < eps) return cur;
    return simpson(l, mid, cl) + simpson(mid, r, cr);
}

void solve2(){
    mu = 1.0 * (m - 1) / 2.0 * n;
    sigma = sqrt(n * 1.0 * (m * m - 1.0) / 12.0);
    //printf("%.6lf %.6lf\n", mu, sigma);
    pi2 = sqrt(2.0 * pi);
        for(int i = 1; i <= 10; i ++){
        int a, b;
        scanf("%d%d", &a, &b);
        double l = max((double)a, mu - 3 * sigma);
        double r = min((double)b, mu + 3 * sigma); 
        double ans = 0;
        if(l < r) ans = simpson(l, r, cal(l, r));
        printf("%.6lf\n", ans);
    }
}
int main(){
    int T;
    scanf("%d", &T);
    while(T--){
        scanf("%d%d", &m, &n);
        if(n <= 1600){
            solve1();
        }else{
            solve2();
        } 
    }   
    return 0;
} 
<think>我们正在查询LOJ6279相关的编程题目或解决方案。LOJ(LibreOJ)是一个在线的评测系统,主要收录算法竞赛题目。根据题号6279,我们需要确定该题目的具体内容。由于我无法直接访问网络,我将基于已知信息进行推理。在算法竞赛中,LOJ的题目编号通常特定的题目对应。题号6279可能对应一个特定的问题。根据常见的题目类型,我们可以推测它可能涉及数据结构或算法。然而,为了准确回答,我们可以尝试回忆或推断常见的LOJ题目。例如,LOJ6000系列题目多为数据结构题,如线段树、树状数组等。实际上,通过搜索记忆,我回想起LOJ6279是“数列分块入门3”(BlockArray3)题目。这是“分块”系列题目中的一题。题目描述:给出一个长为n的数列,以及n个操作,操作涉及区间加法,询问区间内小于某个值x的前驱(即最大的小于x的数)。因此,用户需要的是关于LOJ6279题目的描述和解决方案。解决方案:由于题目要求分块处理,我们将数列分成若干块,每块大小为sqrt(n)。对于每个块,我们维护一个有序的数组(用于二分查找)以及一个加法标记(记录整个块被加了多少)。操作:1.区间加法:对于整块,直接更新加法标记;对于不完整的块,暴力更新元素值,然后重新排序该块(或者重新构建有序数组)。2.查询区间内小于x的前驱:遍历区间内的所有块。对于整块,在块的有序数组中二分查找小于(x-加法标记)的最大值;对于不完整的块,暴力遍历每个元素,判断是否小于x(注意加上加法标记)并更新最大值。代码实现(C++)示例:```cpp#include<iostream>#include<vector>#include<cmath>#include<algorithm>#include<climits>usingnamespacestd;constintMAXN=100010;constintBLOCK_SIZE=320;//约sqrt(MAXN)intn;vector<int>a;vector<int>block_add;//每块的加法标记vector<vector<int>>sorted_blocks;//每块的有序数组voidinit(){intblock_num=(n+BLOCK_SIZE-1)/BLOCK_SIZE;block_add.assign(block_num,0);sorted_blocks.resize(block_num);for(inti=0;i<n;i++){sorted_blocks[i/BLOCK_SIZE].push_back(a[i]);}for(inti=0;i<block_num;i++){sort(sorted_blocks[i].begin(),sorted_blocks[i].end());}}voidupdate_block(intblock_id){sorted_blocks[block_id].clear();intstart=block_id*BLOCK_SIZE;intend=min((block_id+1)*BLOCK_SIZE,n);for(inti=start;i<end;i++){sorted_blocks[block_id].push_back(a[i]);}sort(sorted_blocks[block_id].begin(),sorted_blocks[block_id].end());}voidadd(intl,intr,intc){intblock_l=l/BLOCK_SIZE,block_r=r/BLOCK_SIZE;if(block_l==block_r){for(inti=l;i<=r;i++){a[i]+=c;}update_block(block_l);}else{for(inti=l;i<(block_l+1)*BLOCK_SIZE;i++){a[i]+=c;}update_block(block_l);for(inti=block_l+1;i<block_r;i++){block_add[i]+=c;}for(inti=block_r*BLOCK_SIZE;i<=r;i++){a[i]+=c;}update_block(block_r);}}intquery(intl,intr,intc){intblock_l=l/BLOCK_SIZE,block_r=r/BLOCK_SIZE;intans=-1;if(block_l==block_r){for(inti=l;i<=r;i++){intval=a[i]+block_add[block_l];if(val<c){if(val>ans)ans=val;}}}else{for(inti=l;i<(block_l+1)*BLOCK_SIZE;i++){intval=a[i]+block_add[block_l];if(val<c){if(val>ans)ans=val;}}for(inti=block_l+1;i<block_r;i++){//在块i的有序数组中二分查找小于c-block_add[i]的最大值inttarget=c-block_add[i];autoit=lower_bound(sorted_blocks[i].begin(),sorted_blocks[i].end(),target);if(it!=sorted_blocks[i].begin()){it--;intval=*it+block_add[i];if(val>ans)ans=val;}}for(inti=block_r*BLOCK_SIZE;i<=r;i++){intval=a[i]+block_add[block_r];if(val<c){if(val>ans)ans=val;}}}returnans;}intmain(){cin>>n;a.resize(n);for(inti=0;i<n;i++){cin>>a[i];}init();for(inti=0;i<n;i++){intop,l,r,c;cin>>op>>l>>r>>c;l--;r--;//如果题目输入是1-indexed,则转换为0-indexedif(op==0){add(l,r,c);}else{cout<<query(l,r,c)<<endl;}}return0;}```注意:上述代码是示例代码,可能需要根据题目具体输入要求进行调整。§§相关问题§§1.LOJ6279题目的具体描述是什么?2.分块算法的时间复杂度是多少?3.除了分块,还有哪些方法可以解决LOJ6279?4.如何优化分块算法的常数?5.分块算法适用于哪些场景?</think>### LOJ 6279 题目分析解决方案 **题目描述**:LOJ 6279 是 LibreOJ 上的 **"数列分块入门 3"**,属于分块算法的经典练习题。核心要求如下: - **操作 1**:区间 $[l, r]$ 内每个数加上值 $c$ - **操作 2**:查询区间 $[l, r]$ 内小于 $c$ 的**最大元素值**(即前驱),不存在时返回 $-1$ #### 分块算法设计 分块的核心思想是将数列划分为 $\sqrt{n}$ 大小的块,平衡暴力操作批量处理。 ##### 关键数据结构 1. **块内有序数组**: - 每块维护一个排序后的数组,用于二分查找前驱。 - 示例:块 $B_i$ 的排序数组为 $S_i$。 2. **加法懒标记**: - 记录整块被加的总值 $add_i$(不影响块内有序性)。 ##### 操作实现 1. **区间加法($[l, r] + c$)**: - **整块**:直接更新懒标记 $add_i \gets add_i + c$,时间复杂度 $O(1)$。 - **碎块**:暴力修改元素值,并**重构有序数组**(排序),时间复杂度 $O(\sqrt{n} \log \sqrt{n})$。 2. **查询前驱($[l, r]$ 内 $< c$ 的最大值)**: - **整块**:在有序数组 $S_i$ 中二分查找 $c - add_i$ 的前驱,时间复杂度 $O(\log \sqrt{n})$。 - **碎块**:暴力遍历元素,检查 $a_j + add_i < c$ 并更新最大值,时间复杂度 $O(\sqrt{n})$。 #### 代码实现(C++) ```cpp #include <iostream> #include <vector> #include <cmath> #include <algorithm> #include <climits> using namespace std; const int MAXN = 100010; int n, block_size; vector<int> a; vector<int> add_tag; // 块的加法标记 vector<vector<int>> blocks; // 每块的有序数组 void init() { block_size = sqrt(n); int block_num = (n + block_size - 1) / block_size; add_tag.assign(block_num, 0); blocks.resize(block_num); for (int i = 0; i < n; i++) blocks[i / block_size].push_back(a[i]); for (int i = 0; i < block_num; i++) sort(blocks[i].begin(), blocks[i].end()); } void rebuild_block(int block_id) { blocks[block_id].clear(); int start = block_id * block_size; int end = min(start + block_size, n); for (int i = start; i < end; i++) blocks[block_id].push_back(a[i]); sort(blocks[block_id].begin(), blocks[block_id].end()); } void range_add(int l, int r, int c) { int block_l = l / block_size, block_r = r / block_size; if (block_l == block_r) { // 同一块内 for (int i = l; i <= r; i++) a[i] += c; rebuild_block(block_l); } else { // 左侧碎块 for (int i = l; i < (block_l + 1) * block_size; i++) a[i] += c; rebuild_block(block_l); // 中间整块 for (int i = block_l + 1; i < block_r; i++) add_tag[i] += c; // 右侧碎块 for (int i = block_r * block_size; i <= r; i++) a[i] += c; rebuild_block(block_r); } } int query_predecessor(int l, int r, int c) { int ans = -1; int block_l = l / block_size, block_r = r / block_size; // 左侧碎块暴力查询 for (int i = l; i < min(r + 1, (block_l + 1) * block_size); i++) { int val = a[i] + add_tag[block_l]; if (val < c && val > ans) ans = val; } // 中间整块二分查找 for (int i = block_l + 1; i < block_r; i++) { int target = c - add_tag[i]; auto it = lower_bound(blocks[i].begin(), blocks[i].end(), target); if (it != blocks[i].begin()) { it--; int val = *it + add_tag[i]; if (val < c && val > ans) ans = val; } } // 右侧碎块暴力查询 if (block_l != block_r) { for (int i = block_r * block_size; i <= r; i++) { int val = a[i] + add_tag[block_r]; if (val < c && val > ans) ans = val; } } return ans; } int main() { cin >> n; a.resize(n); for (int i = 0; i < n; i++) cin >> a[i]; init(); for (int i = 0; i < n; i++) { int op, l, r, c; cin >> op >> l >> r >> c; l--; r--; // 转为0-indexed if (op == 0) range_add(l, r, c); else cout << query_predecessor(l, r, c) << endl; } return 0; } ``` #### 算法分析 - **时间复杂度**: - 单次修改/查询:$O(\sqrt{n} \log \sqrt{n})$(碎块排序主导)。 - 总操作 $m$ 次:$O(m \sqrt{n} \log n)$。 - **空间复杂度**:$O(n)$。 #### 优化技巧 1. **减少排序次数**: - 碎块修改时只重构受影响块的有序数组。 2. **块大小调整**: - 实测调整块大小为 $n^{0.6}$ 可能更快(需测试)。 #### 应用场景 分块算法适用于**强制在线**的区间问题(如 LOJ 的数列分块系列题),在 $O(\sqrt{n})$ 复杂度下平衡修改查询[^1]。
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值