Hetao P1178 冒险者 题解 [ 绿 ][ 最短路 ][ 线性 dp ]
题解
本蒟蒻采用的和大部分人解法不同，是根据当前标记值的总和跑最短路的一种解法。
思路 30min ,调代码 2h 的我太蒻了
首先观察题面可以发现本题求的是最少操作数，由于要求最小且有变化的过程，所以可以使用 dp 求解，也可以使用 最短路算法 求解，本篇先介绍最短路的算法。
其实作为图论来解还挺需要思维的。
最短路做法
建图
可以把本题抽象为以下的问题：
以编号为 \(\sum_{i = 1}^{n} a_i\) 的节点为起点，每次可以减去任何一个 \(a_i\) 并到达编号为这个数的节点，每个 \(a_i\) 最多可以减去一次；每次也可以加上一个 \(1\) 并到达编号为这个数的节点，有无限次数，任何边的权值都为 \(1\) ，求到达编号为 \(x\) 的倍数的节点的最短路。
实现
写题解的时候突然发现由于边权为 1 ，所以本题可以使用 bfs 用 \(O(n)\) 的时间进行求解，数据甚至可以更大一些。
但考试的时候没想那么多，就使用了 Dijkstra 算法，时间为 \(O(m \log m)\)，由于边数可能比较多，因此不提前建出边来，而是对每个节点临时建边。看似复杂度很大，实际上有效边数并没有这么多，最大的数据也只跑了 13ms ，若用 bfs 可能会更少。
同时注意到每个数只能被减去一次，由于堆优化 dijkstra 的堆中每个情况是相对独立的，所以每个情况都要开额外的一个数组来存储每个数是否使用过，为了节省空间防止 MLE ，这里采用 bitset 来压缩空间。就是这里写错下标导致我调了 2h。
然后其他的就按照正常的最短路跑就行了。
代码
直接贺了赛时的 dijkstra 上去，什么时候有时间再来写 bfs 版和 dp 版的吧。
#include <bits/stdc++.h>
using namespace std;
int n,x;
int a[1005],start=0;
int dis[1001005];
bool vis[1001005];
struct node{
bitset<1005>bs;
int f,s;
}tmp,tmp2;
struct cmp{
bool operator()(node b,node c)
{
return c.f<b.f;
}
};
int dijkstra()
{
memset(dis,0x3f,sizeof(dis));
priority_queue<node,vector<node>,cmp> q;
tmp.f=0,tmp.s=start;
q.push(tmp);
dis[start]=0;
while(!q.empty())
{
tmp=q.top();
q.pop();
int oridis=tmp.f,u=tmp.s;
if(u%x==0)
{
return dis[u];
}
if(vis[u])continue;
vis[u]=1;
for(int i=1;i<=n;i++)
{
if(tmp.bs[i]==0)
{
int v=u-a[i];
if(dis[v]>oridis+1)
{
dis[v]=oridis+1;
tmp2.f=dis[v],tmp2.s=v;
tmp2.bs=tmp.bs;
tmp2.bs[i]=1;//就是这个下标坑我2h
q.push(tmp2);
}
}
}
int v=u+1;
if(v<=start+1000 && dis[v]>oridis+1)//最多操作次数为1000次
{
dis[v]=oridis+1;
tmp2.f=dis[v],tmp2.s=v;
tmp2.bs=tmp.bs;
q.push(tmp2);
}
}
return n;
}
int main()
{
freopen("player.in","r",stdin);
freopen("player.out","w",stdout);
cin>>n>>x;
for(int i=1;i<=n;i++)
{
cin>>a[i];
start+=a[i];
}
int res=dijkstra();
cout<<res;
return 0;
}
dp 做法
没有想到这个做法的原因主要还是最近 dp 有点生疏，一直往利用元素的条件来想，而忽视了靠元素的数值来解决问题。
这是典型的以数字设计 dp ，而不是用元素设计的一道题，从 \(a_i\le 1000\) 就可以看出。
同时，对于一个数删不删除，对应着 2 种状态，并且一旦知道删了哪些数，就可以推出这时要加多少个 1 。所以，就此设计转移方程式即可。
第一维是一个常见的 dp 设计思路：对于前 \(i\) 个数进行选择的结果，第二维是当前的数的总和 $sum \mod x $ 的结果。
于是，定义 \(f[i][j]\) 表示在前 \(i\) 个数中，使存在的数的总和 \(\mod x\) 为 \(j\) 时，最少删去的数的数量。
转移方程式为：\(f[i][j]=\min(f[i-1][j]+1,f[i-1][(j-a[i]+x)\mod x])\) ，其中 $ 1\le i\le n , 0\le j <x $。
最后计算答案时，直接输出 $\min(f[n][j]+(x-j)\mod x) , 0\le j <x $ 即可。
然后还要注意一点：初始化 \(f[0][0]=0\) 。
时间 \(O(nx)\) 。
未优化代码如下：
#include <bits/stdc++.h>
using namespace std;
int a[1005],n,f[1005][1005],x;
int main()
{
freopen("player.in","r",stdin);
freopen("player.out","w",stdout);
memset(f,0x3f,sizeof(f));
f[0][0]=0;
cin>>n>>x;
for(int i=1;i<=n;i++)
{
cin>>a[i];
a[i]%=x;
}
for(int i=1;i<=n;i++)
{
for(int j=0;j<x;j++)
{
f[i][j]=min(f[i-1][j]+1,f[i-1][(j-a[i]+x)%x]);
}
}
int ans=0x3f3f3f3f;
for(int i=0;i<x;i++)
{
ans=min(ans,f[n][i]+(x-i)%x);
}
cout<<ans;
return 0;
}
优化
注意到动态转移方程式的第一维只会用到 \(i-1\) 的值，所以可以强行进行滚动数组优化，虽然不这样做也可以过就是了。
滚动数组优化代码：
#include <bits/stdc++.h>
using namespace std;
int a[1005],n,f[2][1005],x;
int main()
{
freopen("player.in","r",stdin);
freopen("player.out","w",stdout);
memset(f,0x3f,sizeof(f));
f[0][0]=0;
cin>>n>>x;
for(int i=1;i<=n;i++)
{
cin>>a[i];
a[i]%=x;
}
for(int i=1;i<=n;i++)
{
for(int j=0;j<x;j++)
{
f[i&1][j]=min(f[(i&1)^1][j]+1,f[(i&1)^1][(j-a[i]+x)%x]);//i&1=i%2,(i&1)^1=(i+1)%2
}
}
int ans=0x3f3f3f3f;
for(int i=0;i<x;i++)
{
ans=min(ans,f[n&1][i]+(x-i)%x);
}
cout<<ans;
return 0;
}
