BZOJ 3875

本题的DP思路很好想：设f[i]为第i个怪兽被消灭所需要的最小代价，那么，

f[i]=min{spl[i],ori[i]+∑j∈App[i]f[j]}

然而，由于f[j]有可能也要依赖f[i]，所以这个DP会带环。啊，那该怎么办呢？遇到这类问题，我们常常用SPFA来处理。怎么处理呢？我们需要更新过f[j]的时候，就把所有依赖于它的f[i]入队，用类似于松弛操作的方法搞一搞。由于“边权”非负，最后是不会困在里面出不来的，因为就像图上的最短路，总得有个尽头。由于所有的怪兽都可能被更新，所以一开始需要将所有怪兽都入队。最后的答案就是f[1]。

// 代码之后有彩蛋窝会跟泥说？
// BZOJ 3875

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;

 typedef unsigned long long uLL;
 const int N=200000+5, M=1000000+5; 

 #define rep(i,a,b) for (int i=a; i<=b; i++)
 #define dep(i,a,b) for (int i=a; i>=b; i--)
 #define read(x) scanf("%d", &x)
 #define fill(a,x) memset(a, x, sizeof(a))

 uLL ori[N], d[N];
 int n, m, num;
 bool inq[N];

  struct Graph {
    int s, from[M], to[M], pre[M], last[N];
    void init() { s=-1; rep(i,1,n) last[i]=-1; }
    void ine(int a, int b) {
        s++;
        from[s]=a, to[s]=b, pre[s]=last[a];
        last[a]=s;
    }
 } G, B;
 #define reg(i,G,u) for (int i=G.last[u]; i!=-1; i=G.pre[i])

 int Q[M+5];
 void SPFA() {
    int head=1, tail=0;
    rep(i,1,n) Q[++tail]=i, inq[i]=true;
    while (head<=tail) {
        int x=Q[head++]; head%=M;
        uLL sum=ori[x];
        inq[x]=false;
        if (sum>=d[x]) continue; 
        reg(i,G,x) sum+=d[G.to[i]]; 
        if (sum<d[x]) {
            d[x]=sum;
            reg(i,B,x) {
                int y=B.to[i];
                if (!inq[y]) Q[(++tail)%M]=y, inq[y]=true;
            }
        }
    }
 }

int main()
{
    read(n);
    G.init(); B.init();
    rep(i,1,n) {
        scanf("%llu%llu%d", &ori[i], &d[i], &num); // original, dis
        rep(j,1,num) read(m), G.ine(i,m), B.ine(m,i); // Graph Belong
    }
    SPFA();
    printf("%llu
", d[1]);

    return 0;
}

啊，本题其实还可以强行用Dijkstra做！——武神
因为本题可以找到当前最优状态。法术攻击值最小的怪兽的f值就是它的法术攻击值，不会再被更新。然后，再用它更新它的所有前驱，然后再取出当前最小的f，以此类推。感觉有点虚，而且比较难实现，要记录一大堆东西，就懒得写了……