杂题小记（2023.02.25）
杂题小记（2023.02.25）
目录
更好的阅读体验戳此进入
PJudge-21739 A. 【NOIP Round #5】青鱼和序列
题面
给定初始序列，存在两种操作，将序列复制并接在前面，将序列复制并翻转并接在前面，需要在 $ m $ 次操作后最大化：
\[\sum_{i = 1}^n \sum_{j = 1}^i a_j \bmod{(1\times 10^9 + 7)}
\]
Solution
“容易” 发现翻转多次与翻转一次等效，“容易” 发现一次的翻转在任意位置都等效，于是模拟跑一下即可。
复杂度最优可以优化到 $ O(n + \log m) $，本题限制十分宽松故写的很丑也没事。
Code
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define PI M_PI
#define E M_E
#define npt nullptr
#define SON i->to
#define OPNEW void* operator new(size_t)
#define ROPNEW void* Edge::operator new(size_t){static Edge* P = ed; return P++;}
#define ROPNEW_NODE void* Node::operator new(size_t){static Node* P = nd; return P++;}
using namespace std;
mt19937 rnd(random_device{}());
int rndd(int l, int r){return rnd() % (r - l + 1) + l;}
bool rnddd(int x){return rndd(1, 100) <= x;}
typedef unsigned int uint;
typedef unsigned long long unll;
typedef long long ll;
typedef long double ld;
#define MOD (ll)(1e9 + 7)
template < typename T = int >
inline T read(void);
int N, M;
ll A[110000];
ll sum[110000], rsum[110000], ssum, srsum;
ll pow2s[110000], pow2[110000];
ll spow2s[110000];
int main(){
N = read(), M = read();
for(int i = 1; i <= N; ++i)A[i] = read();
for(int i = 1; i <= N; ++i)sum[i] = (sum[i - 1] + A[i]) % MOD;
for(int i = N; i >= 1; --i)rsum[i] = (rsum[i + 1] + A[i]) % MOD;
for(int i = 1; i <= N; ++i)(ssum += sum[i]) %= MOD, (srsum += rsum[i]) %= MOD;
ll base(N);
for(int i = 1; i <= M - 1; ++i){
ssum = (ssum + ssum + sum[N] * base % MOD) % MOD;
srsum = (srsum + srsum + sum[N] * base % MOD) % MOD;
(sum[N] *= 2) %= MOD;
(base <<= 1) %= MOD;
}
printf("%lld\n", max((ssum + ssum + sum[N] * base % MOD) % MOD, (ssum + srsum + sum[N] * base % MOD) % MOD));
// pow2s[0] = sum[N] * N % MOD, pow2[0] = 1;
// for(int i = 1; i <= M; ++i)pow2s[i] = pow2s[i - 1] * 4 % MOD, pow2[i] = pow2[i - 1] * 2 % MOD;
// for(int i = 0; i <= M; ++i)spow2s[i] = ((i - 1 >= 0 ? spow2s[i - 1] : 0) + pow2s[i]) % MOD;
// ll ans((ssum * pow2[M] % MOD + spow2s[M - 1]) % MOD);
// ssum = (ssum * pow2[M - 1] % MOD + (M - 2 >= 0 ? spow2s[M - 2] : 0)) % MOD;
// srsum = (srsum * pow2[M - 1] % MOD + (M - 2 >= 0 ? spow2s[M - 2] : 0)) % MOD;
// ll tmp = ssum;
// ssum = ((ssum + srsum) % MOD + pow2s[M - 1]) % MOD;
// ans = max(ans, ssum);
// //unreverse todo
// ll origin_ssum = ssum, origin_srsum = srsum;
// for(int rev = 1; rev <= M; ++rev){
// ssum = origin_ssum, srsum = origin_srsum;
// int d = rev - 1;
// ssum = (ssum * pow2[d] % MOD + (rev - 2 >= 0 ? spow2s[rev - 1] : 0)) % MOD;
// srsum = (srsum * pow2[d] % MOD + (rev - 2 >= 0 ? spow2s[rev - 1] : 0)) % MOD;
// ll tmp = ssum;
// (ssum += (srsum + pow2s[rev]) % MOD) %= MOD;
// (srsum += (tmp + pow2s[rev]) % MOD) %= MOD;
// d = M - rev;
// ssum = (ssum * pow2[d] % MOD + (spow2s[M] - spow2s[rev] + MOD) % MOD) % MOD;
// ans = max(ans, ssum);
// printf("rev = %d, ssum = %lld\n", rev, ssum);
// }
// printf("%lld\n", ans);
fprintf(stderr, "Time: %.6lf\n", (double)clock() / CLOCKS_PER_SEC);
return 0;
}
template < typename T >
inline T read(void){
T ret(0);
int flag(1);
char c = getchar();
while(c != '-' && !isdigit(c))c = getchar();
if(c == '-')flag = -1, c = getchar();
while(isdigit(c)){
ret *= 10;
ret += int(c - '0');
c = getchar();
}
ret *= flag;
return ret;
}
Pjudge-21743 B. 【NOIP Round #5】青鱼和怪兽
题面
存在怪兽，你有 $ n $ 点血怪兽有 $ m $，每次可以选择攻击，会有 $ p $ 的概率使怪兽掉一滴血，反之则有 $ 1 - p $ 的概率使自己掉一滴血吗，会消耗 $ 1 $ 单位时间，也可以选择 remake，不消耗时间但会使你和怪兽恢复为初始的血量，求击杀怪兽的期望时间。
Solution
考虑一个朴素的 DP，令 $ dp(i, j) $ 表示你剩 $ i $ 怪兽剩 $ j $ 的状态时击杀的期望时间，不考虑 remake 的转移为 $ dp(i, j) = dp(i - 1, j) \times (1 - p) + dp(i, j - 1) \times p $，然后考虑到 remake，不难想到二分答案 $ tim $，也就是二分一个 $ dp(n, m) $，此时我们不难发现边界，对于 $ dp(i, 0) $，此时已经结束，赋值为 $ 0 $，对于 $ dp(0, j) $ 则只能重开，赋值为 $ tim $，然后转移过程中在朴素转移的基础上对 $ tim $ 取 $ \min $，即如果正常的期望不如重开，那么就直接重开。然后最终判断求得得 $ dp(n, m) $ 与我们二分出来的 $ tim $ 是否相同，相同则说明不合法，可以上调下界，反之一定有更优的低于 $ tim $ 的时间，下调上界。
Code
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#include<climits>
#define PI M_PI
#define E M_E
#define npt nullptr
#define SON i->to
#define OPNEW void* operator new(size_t)
#define ROPNEW void* Edge::operator new(size_t){static Edge* P = ed; return P++;}
#define ROPNEW_NODE void* Node::operator new(size_t){static Node* P = nd; return P++;}
using namespace std;
mt19937 rnd(random_device{}());
int rndd(int l, int r){return rnd() % (r - l + 1) + l;}
bool rnddd(int x){return rndd(1, 100) <= x;}
typedef unsigned int uint;
typedef unsigned long long unll;
typedef long long ll;
typedef long double ld;
#define EPS (1e-9)
template < typename T = int >
inline T read(void);
int N, M, C;
ld P;
ld dp[1100][1100];
bool Check(ld tim){
for(int i = 0; i <= N + 10; ++i)
dp[i][0] = 0.0;
for(int j = 0; j <= M + 10; ++j)
dp[0][j] = tim;
for(int i = 1; i <= N; ++i)
for(int j = 1; j <= M; ++j)
dp[i][j] = min(tim, (dp[i - 1][j] + 1) * (1.0 - P) + (dp[i][j - 1] + 1) * P);
return dp[N][M] < tim;
}
int main(){
N = read(), M = read(), C = read();
P = (ld)C / 100.0;
ld l = EPS, r = 1e9, ans(-1.0);
while(fabs(l - r) > EPS){
ld mid = (l + r) / 2.0;
ans = mid;
if(Check(mid))r = mid - EPS;
else l = mid + EPS;
}printf("%.8Lf\n", ans);
fprintf(stderr, "Time: %.6lf\n", (double)clock() / CLOCKS_PER_SEC);
return 0;
}
template < typename T >
inline T read(void){
T ret(0);
int flag(1);
char c = getchar();
while(c != '-' && !isdigit(c))c = getchar();
if(c == '-')flag = -1, c = getchar();
while(isdigit(c)){
ret *= 10;
ret += int(c - '0');
c = getchar();
}
ret *= flag;
return ret;
}
LG-P4097 [HEOI2013]Segment
题面
插线段，求点对应最大值且序号最小的线段。
Solution
李超线段树模板解决。
Code
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define PI M_PI
#define E M_E
#define npt nullptr
#define SON i->to
#define OPNEW void* operator new(size_t)
#define ROPNEW void* Edge::operator new(size_t){static Edge* P = ed; return P++;}
#define ROPNEW_NODE void* Node::operator new(size_t){static Node* P = nd; return P++;}
using namespace std;
mt19937 rnd(random_device{}());
int rndd(int l, int r){return rnd() % (r - l + 1) + l;}
bool rnddd(int x){return rndd(1, 100) <= x;}
typedef unsigned int uint;
typedef unsigned long long unll;
typedef long long ll;
typedef long double ld;
#define EPS (1e-6)
#define LIM (41000)
template < typename T = int >
inline T read(void);
struct Interval{
bool flag;
int idx;
double k, b;
double CalVal(int x){
return k * x + b;
}
};
class LCSegTree{
private:
Interval tr[LIM << 2];
#define LS (p << 1)
#define RS (LS | 1)
#define MID ((gl + gr) >> 1)
public:
void Update(Interval line, int p, int gl, int gr){
if(!tr[p].flag)return tr[p] = line, void();
if(fabs(line.CalVal(MID) - tr[p].CalVal(MID)) < EPS){
if(line.idx < tr[p].idx)swap(tr[p], line);
}else if(line.CalVal(MID) > tr[p].CalVal(MID))swap(tr[p], line);
if(gl != gr && (fabs(line.CalVal(gl) - tr[p].CalVal(gl)) < EPS || line.CalVal(gl) > tr[p].CalVal(gl)))Update(line, LS, gl, MID);
if(gl != gr && (fabs(line.CalVal(gr) - tr[p].CalVal(gr)) < EPS || line.CalVal(gr) > tr[p].CalVal(gr)))Update(line, RS, MID + 1, gr);
}
void UpdatePoint(int pos, int val, int idx, int p = 1, int gl = 1, int gr = LIM){
if(gl == gr){
if(!tr[p].flag)tr[p] = Interval{true, idx, 0.0, (double)val};
else if(fabs(tr[p].CalVal(pos) - (double)val) < EPS)tr[p].idx = min(tr[p].idx, idx);
else if(tr[p].CalVal(pos) < (double)val)tr[p] = Interval{true, idx, 0.0, (double)val};
return;
}
if(pos <= MID)UpdatePoint(pos, val, idx, LS, gl, MID);
else UpdatePoint(pos, val, idx, RS, MID + 1, gr);
}
void Insert(Interval line, int l, int r, int p = 1, int gl = 1, int gr = LIM){
if(l <= gl && gr <= r)return Update(line, p, gl, gr);
if(l <= MID)Insert(line, l, r, LS, gl, MID);
if(r >= MID + 1)Insert(line, l, r, RS, MID + 1, gr);
}
pair < int, double > Query(int pos, int p = 1, int gl = 1, int gr = LIM){
auto ret = tr[p].idx; auto mxv = tr[p].CalVal(pos);
if(gl != gr){
auto vals = pos <= MID ? Query(pos, LS, gl, MID) : Query(pos, RS, MID + 1, gr);
if(fabs(vals.second - mxv) < EPS)ret = min(ret, vals.first);
else if(vals.second > mxv)ret = vals.first, mxv = vals.second;
}return {ret, mxv};
}
}lcst;
int N;
int cnt(0);
int lst(0);
int main(){
N = read();
for(int i = 1; i <= N; ++i){
int opt = read();
if(opt == 0){
int ans = lcst.Query((read() + lst - 1) % 39989 + 1).first;
lst = ans;
printf("%d\n", ans);
continue;
}
int sx = (read() + lst - 1) % 39989 + 1, sy = (read() + lst - 1) % (int)(1e9) + 1;
int tx = (read() + lst - 1) % 39989 + 1, ty = (read() + lst - 1) % (int)(1e9) + 1;
if(sx == tx)lcst.UpdatePoint(sx = tx, max(sy, ty), ++cnt);
else lcst.Insert(Interval{true, ++cnt, (double)(ty - sy) / (tx - sx), (double)ty - (double)(ty - sy) / (tx - sx) * tx}, min(sx, tx), max(sx, tx));
}
fprintf(stderr, "Time: %.6lf\n", (double)clock() / CLOCKS_PER_SEC);
return 0;
}
template < typename T >
inline T read(void){
T ret(0);
int flag(1);
char c = getchar();
while(c != '-' && !isdigit(c))c = getchar();
if(c == '-')flag = -1, c = getchar();
while(isdigit(c)){
ret *= 10;
ret += int(c - '0');
c = getchar();
}
ret *= flag;
return ret;
}
LG-P5249 [LnOI2019]加特林轮盘赌
题面
存在加特林，存在 $ n $ 个人围城一圈轮流使用加特林并每次均有 $ P $ 的概率被打死，求第 $ k $ 个人是最终唯一的幸存者的概率。
Solution
很有意思的一道题，和一般的朴素概率 DP 不尽相同。
前面的思路和其它题解差不多，主要细说一下最后推式子的步骤。
对于 $ n = 1 $ 平凡解决，对于 $ n = 2 $ 考虑，发现不能用一般的线性递推的思路，不难想到对于处于第一位的人，若其没有被打死，那么下一次的时候枪指向下一个人，局面与初始时原来处于第一位的人处于第二位等效，那么不难想到我们令 $ dp(2, i) $ 表示 $ 2 $ 个人时处于第 $ i $ 位的人幸存的概率，不难发现转移：
\[dp(2, 1) = P \times 0 + (1 - P) \times dp(2, 2)
\]
也就是说考虑其原本处于第 $ 1 $ 位，被打死则无贡献，没有被打死并且在下一次被移动到 $ 2 $ 位置后仍然幸存即为答案。
写到这就不难发现这东西是存在后效性的，或者说不存在初值，但是仍然存在显然的 $ dp(2, 1) + dp(2, 2) = 1 $，所以也可以计算。
于是考虑扩展到 $ dp(n, i) $，不难想到最朴素地：
\[dp(n, 1) = (1 - P) \times dp(n, n)
\]
\[\sum_{i = 1}^n dp(n, i) = 1
\]
此时我们仔细想一下刚才的过程，不难发现意义就是我们每次只崩首位的人，崩完之后不移动枪，而是将整个圆排列对应旋转。
然后我们考虑对于中间的转移，不难想到对于 $ dp(n, k) $，我们如果 $ P $ 的概率崩掉首位了，则 $ k \leftarrow k - 1, n \leftarrow n - 1 $，即 $ P \times dp(n - 1, k - 1) $，如果 $ 1 - P $ 地没崩掉，那么人虽然没有减少但是圆排列仍然需要转一下 $ k \leftarrow k - 1 $，也就是 $ (1 - P) \times dp(n, k - 1) $，于是转移即为：
\[dp(n, k) = P \times dp(n - 1, k - 1) + (1 - P) \times dp(n, k - 1)
\]
当然我们这东西是没有初值的，不能直接递推，但是共存在 $ n $ 个方程，可以直接解 $ n $ 元 $ 1 $ 次方程组，用高斯消元即可，但是这个是 $ O(n^4) $ 的，考虑优化。
考虑对于 $ P \times dp(n - 1, k - 1) $ 此时已经为常量了，令其为 $ \xi $，则有：
\[dp(n, k) = (1 - P) \times dp(n, k - 1) + \xi
\]
令 $ f(k) = dp(n, k) $，令 $ \xi(k) $ 表示 $ dp(n - 1, k - 1) \times P \times (1 - P)^{k - 1} $，则有：
\[f(k) = (1 - P)^{k - 1}f(1) + \sum_{i = 1}^{k - 1}\xi(i)
\]
这样我们可以用 $ f(1) $ 表示出所有 $ f(k) $，然后带入 $ \sum f(k) = 1 $ 求出 $ f(1) $，再 $ O(n) $ 求出所有的 $ f(k) $。
注意需要特判 $ P = 0 $ 的情况，且注意需要滚动数组优化空间。
最终时间复杂度 $ O(n^2) $，空间复杂度 $ O(n) $。
Code
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define PI M_PI
#define E M_E
#define npt nullptr
#define SON i->to
#define OPNEW void* operator new(size_t)
#define ROPNEW void* Edge::operator new(size_t){static Edge* P = ed; return P++;}
#define ROPNEW_NODE void* Node::operator new(size_t){static Node* P = nd; return P++;}
using namespace std;
mt19937 rnd(random_device{}());
int rndd(int l, int r){return rnd() % (r - l + 1) + l;}
bool rnddd(int x){return rndd(1, 100) <= x;}
typedef unsigned int uint;
typedef unsigned long long unll;
typedef long long ll;
typedef long double ld;
#define EPS (1e-10)
template < typename T = int >
inline T read(void);
ld P;
int N, K;
ld dp[2][11000];
int main(){
scanf("%Lf", &P), N = read(), K = read();
if(P < EPS)printf("%.10Lf\n", N == 1 ? (ld)1 : (ld)0), exit(0);
dp[1][1] = 1.0;
bool cur(false);
for(int i = 2; i <= N; ++i){
ld K(1.0), B(0.0), base1(1.0), base2(0.0);
for(int j = 2; j <= i; ++j)
base1 *= (1 - P), base2 = base2 * (1 - P) + P * dp[cur ^ 1][j - 1],
K += base1, B += base2;
dp[cur][1] = (1 - B) / K;
for(int j = 2; j <= i; ++j)
dp[cur][j] = (1 - P) * dp[cur][j - 1] + P * dp[cur ^ 1][j - 1];
cur ^= 1;
}printf("%.10Lf\n", dp[cur ^ 1][K]);
fprintf(stderr, "Time: %.6lf\n", (double)clock() / CLOCKS_PER_SEC);
return 0;
}
template < typename T >
inline T read(void){
T ret(0);
int flag(1);
char c = getchar();
while(c != '-' && !isdigit(c))c = getchar();
if(c == '-')flag = -1, c = getchar();
while(isdigit(c)){
ret *= 10;
ret += int(c - '0');
c = getchar();
}
ret *= flag;
return ret;
}
UPD
update-2023_02_25 初稿
