博弈论
博弈论
记住：能转移到先手必败态的是先手必胜，只能转移到先手必胜的是先手必败
很多时候，它是与 DP/打表找规律相结合的
\(SG\) 函数也常见
常见模型
-
Nim 游戏：多堆石子，每次取一堆中任意个，无法行动者输，先手必败当且仅当 \(a_1\operatorname{xor}a_2\dots\operatorname{xor}a_n=0\)
同时如果 \(a_i\ge s\)，\(s\) 为当前除 \(a_i\) 外的异或和，则先手下一步可从 \(a_i\) 中取
-
NimK：多堆石子，每次可从最多 \(k\) 堆中各取走任意个石子，无法行动者输，当且仅当石子数的二进制表示中每一位上 \(1\) 的个数和 \(\equiv0\pmod{k+1}\) ，即 \(\forall t\in[1,w],\sum_{i=1}^n a_i\operatorname{and} 2^t\equiv0\pmod{k+1}\)
Nim 游戏其实就是 NimK 游戏 \(k=1\) 的特殊形式
-
Bash 博弈：一堆石子共 \(n\) 个，每次只能取 \(1\sim m\) 个，无法行动者输，当且仅当 \(n \equiv0\pmod {m+1}\) 时先手必败
此时后手只要和先手对称着取就必胜
-
Fibonacci Nim：一堆石子共 \(n\) 个，先手第一次取不能不取也不能取完，以后每次取的石子数不超过之前的 \(2\) 倍，无法行动者输，则当且仅当石子数为斐波那契数时先手必败
-
Wythoff’s game：\(2\) 堆石子个数为 \(a,b(a<b)\)，每次只取一堆中任意个或两堆都取相同个，无法行动者输，则当且仅当 \(a=\lfloor \frac{\sqrt 5+1} {2}k\rfloor,b=a+k\) 时先手必胜，这种局势为奇异局势
-
Staircase Nim：\(n\) 级阶梯，每次可以把 \(1\sim n\) 级上的某一级上任意个石子挪到下一级，第 \(0\) 级阶梯上石子无法移动，无法行动者输，则先手必败当前仅当奇数级阶梯上的石子数异或和为 \(0\)
偶数级阶梯上石子个数不影响结果，可以通过调整保持必败必胜态的转移
-
Anti Nim：Nim 游戏，定义为取到最后一棵石子的输，则当且仅当所有石子数为 \(1\) 且 \(SG\) 为 \(0\) 或至少一堆石子数大于 \(1\) 且 \(SG\) 不为 \(0\) 时先手必胜
如果拓展至不同游戏的组合，则需 \(SJ\) 定理，必须满足所有 \(SG=0\) 的状态都无后继状态或有一个后继状态 \(SG=1\)
SG 函数
一个局面的 SG 值：它后继状态的 SG 值的 \(\operatorname{mex}\)
一个游戏的 SG 值：它所有子游戏的 SG 值的异或和
注意区分 ”局面“ 和 ”游戏“
通常可以暴搜一下 SG 值，找找规律或 DP
博弈 DP
这是比较常见的考察形式
一般博弈双方都绝顶聪明，能预见未来，所以 DP 有后效性无前效性，从后往前 DP
CF1628D2 Game on Sum (Hard Version)
注意取实数，设 \(f(n,m)\) 表示当前还剩 \(n\) 次，其中有 \(m\) 次后手必须选加的 \(x\) 值
那么先手假设选 \(t\)，有两种情况：
- 后手选择减，\(f(n,m)\gets f(n-1,m)-t\)
- 后手选择加，\(f(n,m)\gets f(n-1,m-1)+t\)
此时后手一定会选让 \(x\) 小的那个，而先手想让最小值最大
因此先手要让 \(f(n-1,m)-t=f(n-1,m-1)+t\)，即 \(f(n,m)=\frac{f(n-1,m)+f(n-1,m-1)}{2}\)
边界是 \(f(i,0)=0,f(i,i)=ik\)
发现决策完全与 \(k\) 无关，可以直接当作 \(k=1\) 预处理出 \(k\) 的系数，最后答案为 \(f(n,m)\times k\)
\(O(nm)\) 的 DP 可以通过 Easy Version
由于初始只有 \(f(i,i)\) 有值，考虑每个 \(f(i,i)\) 对答案的贡献
看作每次 \((x,y)\) 只能走到 \((x+1,y+1)\) 或 \((x+1,y)\)，求 \((i,i)\) 走到 \((n,m)\) 的路径数，注意第一次只能走到 \((i+1,i)\)
所以方案数为 \(n-i-1\choose m-i\)
由于每走一步系数除以 \(2\)，总答案为 \(\sum_{i=1}^m {n-i-1\choose m-i}\times \frac{i\cdot k}{2^{n-i}}\)
注意特判 \(n=m\)
int main()
{
fact[0] = invf[0] = 1;
for(ll i = 1; i <= V; ++i) fact[i] = fact[i - 1] * i % mod;
invf[V] = qmi(fact[V], mod - 2), inv2[V] = qmi(qmi(2ll, V), mod - 2);
for(ll i = V - 1; i > 0; --i) invf[i] = invf[i + 1] * (i + 1) % mod, inv2[i] = inv2[i + 1] * 2ll % mod;
read(t);
while(t--)
{
read(n, m, k), ans = 0;
if(n == m) {print(k * m % mod), putchar('\n'); continue;}
for(ll i = 1; i <= m; ++i) ans = (ans + c(n - i - 1, m - i) * i % mod * k % mod * inv2[n - i] % mod) % mod;
print(ans), putchar('\n');
}
return 0;
}
预处理出 \(s,t\) 到每个点的距离，然后分别从小到大排序，距离相同的放在一起，则两人当前取的点一定是某个前缀
所以状态就方便表示了：设 \(f(i,j)\) 表示先手已经选了前 \(i\) 个，后手已选前 \(j\) 个时先手还能获得的最大分数
枚举先手下一步选到 \(k\)，后手一定会选 \(l\) 使 \(f(k,l)\) 最小
因此 \(f(i,j)=\max_{k=st_{i,j}}\{cost(i+1,k,j)+\min_{l=st2_{i,j}} f(k,l)\}\)，其中 \(cost(i,k,j)\) 为后手选到 \(j\) 时先手选 \(i\sim k\) 获得的收益
\(st_{i,j}\) 为已选 \(i,j\)，先手下一步能选的最近位置（保证有新点加入），同理 \(st2_{i,j}\) 为后手下一步能选的最近位置
可以预处理出 \(s(i,j)\) 表示后手选到 \(j\) 时先手从 \(1\sim i\) 的收益，由于先手选的内部不重复，因此 \(cost(i+1,k,j)=s(k,j)-s(i,j)\)
然后边 DP 边记录后缀最小值 \(mn(i,j)=\min\{mn(i,j+1),f(i,j)\}\)，更新最大值 \(mx(i,j)=\max\{mx(i+1,j),s(i,j)+mn(i,st2_{i,j})\}\)
最终转移为 \(f(i,j)=mx(st(i,j),j)-s(i,j)\)，边界为覆盖了所有点的 \(f(i,j)=0\)
这样就能 \(O(n^2)\) 完成转移，细节有一点多
ll n, m, S, T, u, v, d, p[N], dis[2][N], f[N][N], ful[N][N], vis[N][N], st[N][N], st2[N][N], cnt[2], mx[N][N], mn[N][N], s[N][N], tot;
map<ll, vector<ll> > dist[2];
vector<ll> lin[2][N];
vector<pll> edge[N]; bitset<N> book;
void dij(ll id, ll st)
{
priority_queue<pll, vector<pll>, greater<pll> > heap;
memset(dis[id], 0x3f, sizeof(dis[id])), book.reset();
dis[id][st] = 0, heap.push(mp(0, st));
while(!heap.empty())
{
ll x = heap.top().se; heap.pop();
if(book[x]) continue;
book[x] = 1;
for(pll y : edge[x])
if(dis[id][y.fi] > dis[id][x] + y.se)
{
dis[id][y.fi] = dis[id][x] + y.se;
heap.push(mp(dis[id][y.fi], y.fi));
}
}
for(ll i = 1; i <= n; ++i) dist[id][dis[id][i]].pb(i);
}
int main()
{
read(n, m, S, T);
for(ll i = 1; i <= n; ++i) read(p[i]), tot += p[i];
for(ll i = 1; i <= m; ++i)
{
read(u, v, d);
edge[u].pb(mp(v, d)), edge[v].pb(mp(u, d));
}
dij(0, S), dij(1, T);
for(iter it = dist[0].begin(); it != dist[0].end(); ++it) lin[0][++cnt[0]] = it -> se;
for(iter it = dist[1].begin(); it != dist[1].end(); ++it) lin[1][++cnt[1]] = it -> se;
for(ll j = 0; j <= cnt[1]; ++j)
{
book.set();
for(ll k = 1; k <= j; ++k)
for(ll u : lin[1][k]) book[u] = 0;
for(ll i = 1; i <= cnt[0]; ++i)
{
ll flag = 0;
for(ll k : lin[0][i])
if(book[k]) s[i][j] += p[k], flag = 1;
s[i][j] += s[i - 1][j], vis[i][j] = flag;
}
for(ll i = cnt[0], k = cnt[0] + 1; i >= 0; --i)
{
st[i][j] = k;
if(vis[i][j]) k = i;
}
}
memset(vis, 0, sizeof(vis));
for(ll i = 0; i <= cnt[0]; ++i)
{
book.set();
for(ll j = 1; j <= i; ++j)
for(ll k : lin[0][j]) book[k] = 0;
for(ll j = 0; j <= cnt[1]; ++j)
{
ll flag = 0;
for(ll k : lin[1][j])
if(book[k]) {flag = 1; break;}
vis[i][j] = flag;
}
for(ll j = cnt[1], k = cnt[1] + 1; j >= 0; --j)
{
st2[i][j] = k;
if(vis[i][j])
{
if(k == cnt[1] + 1)
for(ll u = j; u <= cnt[1]; ++u) ful[i][u] = 1;
k = j;
}
}
}
if(tot > 0) // 先手全选即胜利
{
printf("Break a heart");
return 0;
} // 注意初始化，mx[cnt[0]][j] 看作先手直接全部取完
memset(f, -0x3f, sizeof(f)), memset(mx, -0x3f, sizeof(mx)), memset(mn, 0x3f, sizeof(mn));
for(int j = 0; j <= cnt[1]; ++j) f[cnt[0]][j] = 0, mx[cnt[0]][j] = s[cnt[0]][j], ful[cnt[0]][j] = 1;
for(int i = 0; i <= cnt[0]; ++i) f[i][cnt[1]] = mn[i][cnt[1]] = 0, mx[i][cnt[1]] = s[i][cnt[1]], ful[i][cnt[1]] = 1;
for(int i = cnt[0] - 1; i >= 0; --i)
for(int j = cnt[1] - 1; j >= 0; --j)
{
if(ful[i][j]) f[i][j] = 0;
else f[i][j] = mx[st[i][j]][j] - s[i][j];
mn[i][j] = min(mn[i][j + 1], f[i][j]);
if(mn[i][st2[i][j]] < inf) mx[i][j] = max(mx[i + 1][j], s[i][j] + mn[i][st2[i][j]]);
else mx[i][j] = max(mx[i + 1][j], s[i][j]); // 注意存在 f 才用它更新，否则为后手直接取完全部
}
if(f[0][0] == tot - f[0][0]) printf("Flowers");
else if(f[0][0] < tot - f[0][0]) printf("Cry");
else printf("Break a heart");
return 0;
}
二分图博弈
定义：有一张二分图，起始节点为左部点 \(S\)，先后手交替移动，每条边只能经过一次，不能移动的一方输掉游戏
先说结论，当 \(S\) 在图上的每一组最大匹配中时，先手必胜
证明：
若 \(S\) 在每一组最大匹配中，则先手先走一条匹配边到 \(x\)，后手从 \(x\) 走到 \(y\) 后 \(y\) 一定有匹配边，否则 \((S,x)\) 所在匹配中把它换成 \((x,y)\) 最大匹配不会变而 \(S\) 不在匹配中，同理之后若后手走到的点无匹配边，则相当于找到了增广路，能调整使得 \(S\) 不在最大匹配中，矛盾
因此先手每次能沿着匹配边走，先手必胜
若存在最大匹配使得 \(S\) 不在其中，则先手走到 \(x\) 后，之后后手每次肯定能走一条匹配边 \((x,y)\)，因为如果某次后手走了非匹配边 \((z,w)\)，之前先手走了 \((y,z)\)，则可以调整，将 \((x,y)\) 所在匹配中它换成 \((S,x),(y,z)\) 加入最大匹配，使得最大匹配增加，矛盾
因此后手每次能沿着匹配边走，后手必胜
那么如果只对一个点求，可以直接去掉这个点重跑最大匹配
找出所有的非必经点，则从每个非匹配点 \(x\)，找到 \(z\) 使得 \((x,y)\) 为非匹配边，\((y,z)\) 为匹配边，将 \(x,z\) 连边后遍历新图，被遍历到的都是非必经点
