BZOJ 3875: [Ahoi2014&Jsoi2014]骑士游戏

首先正着搜是错的。。因为搜索的顺序会影响结果。。
那么就把所有点按法术攻击的大小都加入小根堆，每次取出最小的，那么解决它就只需要用法术攻击了。因为肯定存在解决它的儿子用法术攻击的情况，而且需要的花费比解决它的法术攻击还大，那必然用一次法术攻击解决它，不过存在当它没有儿子时，就把法术攻击和普通攻击取个min就对了。
这样就相当于在一个DAG上跑dijkstra了，当它们的父亲度数也为 \(0\) 了就可以更新。
复杂度 \(O(n \log n)\)

#include <bits/stdc++.h>
#define ll long long

namespace IO {
    const int MAXSIZE = 1 << 20;
    char buf[MAXSIZE], *p1, *p2;
    #define gc() (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, MAXSIZE, stdin), p1 == p2) ? EOF : *p1++)
    void read() {}
    template<typename T, typename ... T2>
    inline void read(T &x, T2 &... oth) {
        x = 0; T f = 1; char ch = gc();
        while (ch < '0' || ch > '9') { if (ch == '-') f = -1; ch = gc(); }
        while (ch >= '0' && ch <= '9') { x = x * 10 + ch - 48; ch = gc(); }
        x *= f;
        read(oth...);
    }
}

const int N = 2e5 + 7;
const int M = 1e6 + 7;
int head1[N], head2[N], cnt = 1, n, deg[N];
ll dis[N], a[N];
struct E {
    int v, ne;
} e[M << 1];

void add(int u, int v, int *head) {
    e[++cnt].v = v; e[cnt].ne = head[u]; head[u] = cnt;
}

struct Node {
    int u;
    ll d;
    Node(int _u = 0, ll _d = 0): u(_u), d(_d) {}
    bool operator < (const Node &p) const {
        return d > p.d;
    }
};
std::priority_queue<Node> que;
bool done[N];

int main() {
    IO::read(n);
    for (int i = 1, x; i <= n; i++) {
        IO::read(a[i], dis[i], deg[i]);
        for (int j = 1; j <= deg[i]; j++) {
            int x;
            IO::read(x);
            add(i, x, head1);
            add(x, i, head2);
        }
        if (!deg[i]) dis[i] = std::min(dis[i], a[i]);
        que.push(Node(i, dis[i]));
    }
    while (!que.empty()) {
        Node p = que.top(); que.pop();
        int u = p.u;
        if (u == 1) break;
        if (done[u]) continue;
        done[u] = 1;
        for (int i = head2[u]; i; i = e[i].ne) {
            int fa = e[i].v;
            deg[fa]--;
            if (!deg[fa] && !done[fa]) {
                ll temp = a[fa];
                for (int j = head1[fa]; j; j = e[j].ne)
                    temp += dis[e[j].v];
                if (temp < dis[fa]) {
                    dis[fa] = temp;
                    que.push(Node(fa, dis[fa]));
                }
            }
        }
    }
    printf("%lld\n", dis[1]);
    return 0;
}