详细讨论 IC26 四川省赛 C 题
详细讨论 IC26 四川省赛 C 题
链接
题意
C. 精灵对战
time limit per test: 3 seconds
memory limit per test: 1024 megabytes
小 \(z\) 爱玩洛克王国,尤其喜欢和别的玩家进行精灵对战。
现在有 \(n\) 种精灵,编号为 \(1\) 到 \(n\)。精灵之间存在克制关系。对于每种精灵,它最多被 \(k\) 种精灵克制。
当小 \(z\) 的精灵 \(A\) 与对手的精灵 \(B\) 对战时,结果如下:
- 若 \(A\) 克制 \(B\),且 \(B\) 不克制 \(A\),则 \(B\) 被击倒,\(A\) 继续战斗;
- 若 \(B\) 克制 \(A\),且 \(A\) 不克制 \(B\),则 \(A\) 被击倒,\(B\) 继续战斗;
- 若 \(A\) 与 \(B\) 之间不存在任何克制关系,则二者同归于尽;
- 若 \(A\) 与 \(B\) 互相克制,则小 \(z\) 可以通过高超的博弈技巧击败对手的精灵,即 \(B\) 被击倒,\(A\) 继续战斗。
小 \(z\) 已经提前知道了对手的精灵出战顺序,这是一个长度为 \(m\) 的序列,序列中可以出现重复的精灵。
小 \(z\) 需要合理安排自己的精灵出战顺序来击败对手的所有精灵。对战过程中,当前精灵没有被击倒时,不能更换精灵;只有当前精灵被击倒或同归于尽后,小 \(z\) 才能派出新的精灵。小 \(z\) 可以多次派出同一种精灵。
派出一只精灵需要花费 \(1\) 的代价。请你求出小 \(z\) 击败对手所有精灵所需的最小总花费。
Input
第一行包含三个整数 \(n,m,k\)(\(1 \le n,m \le 10^5, 1 \le k \le 30\)),分别表示精灵种类数、对手精灵出战序列长度,以及每种精灵最多被克制的精灵种类数。
接下来 \(n\) 行,第 \(i\) 行首先包含一个整数 \(s_i\)(\(0 \le s_i \le k\)),表示克制第 \(i\) 种精灵的精灵种类数;随后包含 \(s_i\) 个整数 \(x_{i,1},x_{i,2},\ldots,x_{i,s_i}\)(\(1 \le x_{i,j} \le n,x_{i,j} \neq i\)),表示克制第 \(i\) 种精灵的精灵编号。
最后一行包含 \(m\) 个整数 \(a_1,a_2,\ldots,a_m\)(\(1 \le a_i \le n\)),表示对手的精灵出战序列。
输入保证每一行克制关系中的精灵编号互不相同,且不会出现自克制关系。
Output
输出一行一个整数,表示小 \(z\) 击败对手所有精灵所需的最小总花费。
Example
Input
3 4 2
1 2
2 3 1
1 1
2 2 2 1
Output
1
最朴素做法
看完题意后其实易知:可以从最开始的第一个对手遍历 \(1\to n\) 个我可以选择的精灵,那么每个精灵都可能会走到后面不同的位置,对于这 \(n\) 种情况的每一个情况让 \(1 \to n\) 个精灵再遍历一遍,直到每一个情况都到了最后一个位置,然后选这些情况中的最小代价。那么其实这就是一个搜索树的算法,复杂度是 \(O(n\text{ 的指数})\),非常大。
记忆化搜索(DP)
在此基础上我们优化以减少复杂度:可以发现其实搜索树有很多重复计算的地方,我们可以使用记忆化搜索,使用一个数组 \(dp[i][x]\) 记录对于位置 \(i\) 且 \(x\) 精灵存活的情况下的最少代价。
为什么可以这样使用记忆化:
记忆化的本质和 DP 其实一样,只是不同的表达方式。也可以说记忆化搜索就是 DP,记忆化搜索的本质是记录一些状态,合并相同状态并保留最优情况,而不用继续计算非最优的情况。
那多余计算的部分是什么呢?是到达同一个状态后的非最优历史继续往后搜索的部分。那有没有可能非最优到后面会超过当前最优呢?这其实也是 DP 的本质:DP 只用存下当前真正能影响未来的信息,未来只与当前状态有关,与到达该状态的历史无关。即对于一个状态 \((i,x)\),未来只与当前位置和当前精灵有关,与具体是通过哪一条历史到达这里的无关。因此,如果两个历史到达了同一个 \((i,x)\),它们面对的未来一定相同,区别只在已经花掉的代价。我们保留代价更小的那个即可。在这种情况下我只需要算最优的就可以了,而不用去算非最优的,属于多余计算。
这并不是说 DP 在每一步直接选局部最优。DP 仍然会保留所有不同状态,只是对同一个状态保留最小值;贪心如果要跳过其他状态,还需要额外证明当前选择不会破坏未来最优性。
举个例子:设两个不同的历史 \(H_1\) 和 \(H_2\) 都到达状态 \((i,x)\) ,第 \(i\) 只对手已经消灭,当前精灵 \(x\) 活着,那么下一步:
- 如果
x=0,两者都可以选择相同的精灵y; - 如果
x>0,两者都必须让x和同一只对手战斗。
因为当前精灵相同、当前对手相同、规则相同,所以战斗结果相同,下一状态也相同。
可以形象的说就是一颗搜索树的两条不同的路径 \(H_1\) 和 \(H_2\),到达了同一个状态 \((i,x)\) 那这两个节点下的子树其实一模一样,只是 cost 因为到达它的历史不同,因此已有代价不同,那直接选最优的就可以了。
那么其实可以得到 DP 的本质就是找到未来所需要的所有信息,就可以达到说某个节点选最优的操作(类似贪心了),之前我也是总是不知道 DP 和贪心的区别,觉得为什么 DP 也是每一步选最优就可以是全局最优解,而贪心选最优就是局部最优解,因为 DP 保留所有不同状态,对每个状态选择最小转移值;贪心则直接丢弃其他局部选择。这也是源于 DP 选取一些信息后所达到的无后效性(未来与过去无关),而贪心就是当前选择(过去)与未来强耦合,如果当前不选最优可能未来达到了最优。
但是使用 DP 或者记忆化搜索还是 \(O(mn)\) 的复杂度,还是过不了。
我们想想还有什么优化技巧或者有什么可以不用算的步骤。
优化 DP
其实我们可以先把记忆化 DP 写出来,看看有什么可以优化的。
定义:
(i, x)
- \(i\):前 \(i\) 只对手已经消灭;
- \(x\):当前精灵是谁;
- \(x=0\):场上无人。
\(i\) 有 \(m+1\) 种,\(x\) 有 \(n+1\) 种,所以总状态数是 \(O(mn)\)。
考虑每个状态要做什么:
对于状态 \((i,0)\),场上无人,可以派任意一只新精灵。最朴素的做法是枚举所有 \(n\) 种精灵,因此每个空场状态的决策数是 \(O(n)\)。
对于状态 \((i,x)\),其中 \(x>0\),当前精灵必须和下一只对手战斗,不能主动更换。
所以只需要判断:
- \(x\) 是否击败下一只对手;
- 下一只对手是否击败 \(x\);
- 双方是否都没有克制关系。
每个存活状态只需要做一次判断,复杂度为 \(O(1)\)。
总复杂度是:
- 空场状态:\(m \times n\);
- 存活状态:\(m \times n\)。
这是不可接受的。
令 \(C[v]\) 表示能克制精灵 \(v\) 的精灵集合,也就是输入中第 \(v\) 行给出的列表。
那么仔细想想,在空场状态时,我们需要枚举每一个精灵吗?假设当前对手是 \(b\),场上无人。朴素地派出精灵 \(y\),分三种情况:
- 情况 1: \(y \in C[b]\),精灵 \(y\) 击败 \(b\),存活下来;
- 情况 2: \(y\) 与 \(b\) 没有克制关系,双方同归于尽,进入下一只对手,场上无人。对于这种情况,其实无论选什么,下一个状态都是
(next position, 0)。既然结果完全相同,那直接保留最小的代价就好了。由于没有自克制关系,直接选 \(y=b\) 就好了。 - 情况 3: \(b\) 击败 \(y\),\(y\) 刚派出来就死亡,\(b\) 仍然活着。白多花 \(1\) 个代价,所以这个永远不可能是最优解,直接删除。
所以总结来看,从空场状态出发,最多只有:
k 个击败当前对手的精灵 + 1 个同归于尽的选择 = k + 1
在存活状态时,需要区分时间点。进入当前第 \(i\) 只对手的战斗前,如果 \(x\) 还活着,说明它在上一次战斗中击败了上一只对手,因此 \(x\) 属于上一只对手的克制者集合。当前战斗结束后,新存活的 \(x\) 一定击败了当前对手 \(a_i\),因此 $$x \in C[a_i]$$ 而题目保证 $$|C[a_i]| \le k$$ 。
所以第 \(i\) 层真正可能存活的精灵最多只有 \(k\) 个。因此当前层的状态最多是:
空场 + 上一只对手的至多 k 个克制者 = k + 1
当前战斗结束后,新的存活状态又只会来自当前对手的 \(C[a_i]\),数量同样不超过 \(k\)。
所以最终对于每个对手 \(b\),只需要处理:
- 上一层的至多 \(k\) 个存活状态;
- 当前 \(C[b]\) 中的至多 \(k\) 个精灵;
- 一个空场状态。
总共 \(O(mk)\)。关系判断如果使用有序数组二分查找,会变成 \(O(mk\log k)\);加上对输入排序,总体复杂度是 \(O((n+m)k\log k)\)。
为什么能看到用 \(k\le 30\) 来优化,并不仅仅是因为 \(k\) 很小,最主要的是从搜索树的推导中发现了:存活身份和空场决策都被 \(C\) 集合限制。
这样才是这题一个逻辑比较顺的解题思路。
实现代码
#include<bits/stdc++.h>
#define int long long
#define endl "\n"
using namespace std;
const int N=1e5+5;
const int INF=1e18;
int n,m,k;
vector<int> c[N];
int a[N];
void solve(){
cin>>n>>m>>k;
int s;
for(int i=1;i<=n;++i){
cin>>s;
int x;
for(int j=1;j<=s;++j){
cin>>x;
c[i].push_back(x);
}
sort(c[i].begin(),c[i].end());
}
for(int i=1;i<=m;++i){
cin>>a[i];
}
vector<int> dp(n+5,INF);
vector<int> temp(n+5,INF);
dp[0]=0;
vector<int> alive;
vector<int> nalive;
for(int i=1;i<=m;++i){
nalive.clear();
int fresh=dp[0];
dp[0]=INF;
auto addAlive=[&](int x,int cost){
if(temp[x]==INF){
nalive.push_back(x);
}
temp[x] = min(temp[x], cost);
};
for(int x:alive){
if(binary_search(c[a[i]].begin(),c[a[i]].end(),x)){
addAlive(x,dp[x]);
}
else if(binary_search(c[x].begin(),c[x].end(),a[i])){
fresh=min(fresh,dp[x]);
}
else{
temp[0]=min(temp[0],dp[x]);
}
dp[x]=INF;
}
for(int x:c[a[i]]){
addAlive(x,fresh+1);
}
temp[0]=min(temp[0],fresh+1);
dp.swap(temp);
alive.swap(nalive);
}
int ans=dp[0];
for(int x:alive){
ans=min(ans,dp[x]);
}
cout<<ans<<endl;
}
signed main()
{
ios::sync_with_stdio(false);
cin.tie(0);
int T=1;
//cin>>T;
while(T--){
solve();
}
return 0;
}
前向 DP 实现补充
循环开始时:
dp[0]表示当前场上无人时的最小花费;dp[x]表示精灵 \(x\) 存活时的最小花费;alive保存当前真正可能存活的精灵,并且每个精灵只出现一次;fresh表示当前对手仍然存活、场上无人、可以立即派精灵时的最小花费。
判断关系时:
binary_search(c[b], x)表示 \(x\in C[b]\),即 \(x\) 击败当前对手 \(b\);binary_search(c[x], b)表示 \(b\in C[x]\),即当前对手击败 \(x\)。
必须优先判断“\(x\) 击败 \(b\)”,因为双方互相克制时要按题目规则判我方获胜。
temp 和 dp 分别保存下一层和当前层。处理旧状态时先读取 dp[x],随后立即把 dp[x] 清成 INF。因此交换之后,原来的 dp 已经全部清空,可以作为下一轮的 temp 使用,不需要每轮重新初始化长度为 \(n\) 的数组。
addAlive 利用 temp[x]==INF 判断 \(x\) 是否第一次进入下一层,从而同时完成去重和取最小花费。若不从空场枚举所有精灵,而是只枚举 \(C[b]\) 和同归于尽选择,那么每轮最多处理 \(O(k)\) 个存活状态和 \(O(k)\) 个新精灵,转移复杂度为 \(O(mk\log k)\)。
其实还有一种贪心做法
这个是我在 CF 上看到的。
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
#define all(x) (x).begin(), (x).end()
int main()
{
ios::sync_with_stdio(0);
cin.tie(0);
int n, m, q, i, j, k;
cin >> n >> m >> q;
vector a(n, vector<int>());
for (auto &v : a)
{
int sz;
cin >> sz;
v.resize(sz);
for (int &x : v) cin >> x, --x;
}
vector<int> b(m);
for (int &x : b) cin >> x, --x;
int ans = 0;
for (i = 0; i < m;)
{
j = i + 1;
for (int x : a[b[i]])
{
k = i + 1;
while (k < m && count(all(a[b[k]]), x))
++k;
if (k < m && !count(all(a[x]), b[k])) ++k;
j = max(j, k);
// cerr << x + 1 << ' ' << k << endl;
}
i = j;
++ans;
}
cout << ans << endl;
}
区间贪心补充
一次派出后,精灵会连续战斗到死亡,因此一次派出可以看成消灭一段连续区间:
并回到下一个空场位置 \(j\)。派出代价固定为 \(1\)。
代码中的端点计算方式如下:
j=i+1表示派出精灵 \(b[i]\) 自己,与当前对手同归于尽;- 对每个 \(x\in C[b[i]]\),先让它连续击败后面的对手;
- 遇到第一只不能击败的对手时,如果双方互不克制,则双方同归于尽,位置再前进一位;
- 如果对手反过来克制 \(x\),则 \(x\) 死亡、对手仍存活,位置不前进;
- 取所有选择中下一次空场位置最靠后的那个。
为什么选择最远位置是正确的:设最优策略的空场位置依次为
贪心策略为
假设已经有 \(g_\ell\ge e_\ell\)。如果 \(g_\ell\ge e_{\ell+1}\),贪心已经超过最优策略的下一次终点;否则有
最优策略从 \(e_\ell\) 到 \(e_{\ell+1}\) 使用的是同一只精灵,它击败了这个连续区间内的所有对手。因此从 \(g_\ell\) 重新派出同一只精灵,仍然至少能打到 \(e_{\ell+1}\)。所以贪心下一次不会落后于最优策略。归纳可得,贪心每次派出后都不会落在最优策略的同次数位置之前。
这个结论依赖于“一次派出覆盖连续区间”和“精灵可以重复使用”,一般的每次跳最远并不一定正确。
每个 \(C[b]\) 最多有 \(k\) 个精灵,count 线性判断关系又是 \(O(k)\),因此时间复杂度约为 \(O(mk^2)\),空间复杂度为 \(O(nk+m)\)。
还有一种是从后往前的写法
#include<bits/stdc++.h>
using namespace std;
const int N=1e5+5,K=31;
int n,m,k,id[N][K],s[N],a[N],dp[N][K];
int read()
{
int x=0,f=1;char ch=getchar();
while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
return x*f;
}
int check(int u,int v)//u 是否克制 v
{
for(int i=1;i<=s[v];i++) if(id[v][i]==u) return i;
return 0;
}
int main()
{
n=read(),m=read(),k=read();
for(int i=1;i<=n;i++)
{
s[i]=read();
for(int j=1;j<=s[i];j++) id[i][j]=read();
}
for(int i=1;i<=m;i++)
{
a[i]=read();
for(int j=0;j<=k;j++) dp[i][j]=1e9;
}
for(int i=m;i>=1;i--)
{
dp[i][0]=min(dp[i][0],dp[i+1][0]+1);
for(int j=1;j<=s[a[i]];j++)
{
int w=check(id[a[i]][j],a[i+1]);
if(w) dp[i][j]=min(dp[i][j],dp[i+1][w]);
else
{
if(check(a[i+1],id[a[i]][j])) dp[i][j]=min(dp[i][j],dp[i+1][0]+1);
else dp[i][j]=min(dp[i][j],dp[i+2][0]+1);
}
dp[i][0]=min(dp[i][0],dp[i][j]);
}
}
printf("%d\n",dp[1][0]);
return 0;
}
倒序 DP 补充
设:
- \(g[i]=dp[i][0]\):从第 \(i\) 只对手开始,场上无人,消灭 \(i..m\) 的最小花费;
- \(h[i][j]\):第 \(j\) 个能击败 \(a[i]\) 的精灵已经派出,并且由它击败 \(a[i]\) 时,之后还需要多少花费。
代码中实际保存的是
也就是把当前精灵的派出费用合并进状态。
设 \(x=\operatorname{id}[a[i]][j]\),则有三类转移:
-
如果 \(x\) 也击败 \(a[i+1]\),则 \(x\) 继续存活:
\[dp[i][j]=dp[i+1][w] \]其中 \(w\) 是 \(x\) 在 \(C[a[i+1]]\) 中的下标。
-
如果 \(a[i+1]\) 击败 \(x\),则需要重新派精灵:
\[dp[i][j]=dp[i+1][0]+1 \] -
如果双方互不克制,则下一只对手也死亡,从 \(i+2\) 开始:
\[dp[i][j]=dp[i+2][0]+1 \]
场上无人时的转移为
第一项表示派出一只与当前对手同归于尽的精灵,第二项表示直接选择一只克制当前对手的精灵。
代码在 \(i=m\) 时会访问 a[m+1]、dp[m+1][0] 和 dp[m+2][0]。由于这些全局数组的默认值为 \(0\),恰好形成了结尾哨兵。为了提高可读性,可以在循环前显式写上:
a[m + 1] = 0;
dp[m + 1][0] = 0;
dp[m + 2][0] = 0;
check 最多线性扫描 \(k\) 个元素,每个位置最多枚举 \(k\) 个克制者,因此时间复杂度约为 \(O(mk^2)\),空间复杂度为 \(O(nk+mk)\)。
三种写法之间的关系
- 前向 DP 维护“当前位置和当前存活精灵”,直接利用 \(k\le 30\) 压缩状态数;
- 区间贪心进一步把一段连续存活过程压缩成一次区间跳跃,并依赖交换论证;
- 倒序 DP 改为计算后缀答案,把当前精灵的派出费用直接并入状态。
三种写法的核心思想相同:只保留真正能够影响未来的信息,并利用每种精灵最多被 \(k\) 种精灵克制这一性质。

浙公网安备 33010602011771号