[SDOI2010]大陆争霸 带限制最短路

首先明确最短路是DP 带继承的DP 是有转移的

bellman没有顺序的松弛 复杂度很高 dijk维护一个正解点集 很快

这道题给最短路加了限制：同时走若干条路，当走过某些点后才能走该点

原转移为：d[x] = min {d[y] + w | y -> x}

新加的转移为：d[x] = max {d[y] | y protect x}

可以知道 依然可以维护一个正解点集 当没有protect才可以加入点集

我犯的错误：

longlong

莫名TLE的原因很可能是数组开小 相信复杂度计算

可能会补充手写堆dijk

我TM显然是不会补了！！！！wtf lazyboy！  -State 010913

#include <cstdio>
#include <vector>
#include <cstring>
using namespace std;
int n, m;
typedef __int64 ll;
const int N = 10000, M = 200000;
const ll INF = 1LL << 60;
int key[M], head[N], next[M], len[M], cnt, in[N];
ll d[N];
vector<int> vc[N];
vector<int>::iterator it;
inline void add (int x, int y, int w)
{
    key[cnt] = y;
    next[cnt] = head[x];
    len[cnt] = w;
    head[x] = cnt ++;
}
inline void dijk ()
{
    bool v[N] = {};
    for (int i = 0; i <= n; i ++)
        d[i] = INF;
    d[1] = 0;
    for (int i = 1; i <= n; i ++)
    {
        int k = 0;
        for (int j = 1; j <= n; j ++)
            if (!v[j] && in[j] == 0 && d[j] < d[k])
                k = j;
        v[k] = true;
        if (k == n) break;
        for (int j = head[k]; ~ j; j = next[j])
            d[key[j]] = min (d[key[j]], d[k] + len[j]);
        for (it = vc[k].begin (); it != vc[k].end (); it ++)
        {
            in[*it] --;
            d[*it] = max (d[*it], d[k]);
        }
    }
}
int main ()
{
    memset (head, -1, sizeof head);
    scanf ("%d%d", &n, &m);
    for (int i = 1, a, b, c; i <= m; i ++)
        scanf ("%d%d%d", &a, &b, &c), add (a, b, c);
    for (int i = 1, x, y; i <= n; i ++)
    {
        scanf ("%d", &x);
        in[i] = x;
        while (x --) scanf ("%d", &y), vc[y].push_back (i);
    }
    dijk ();
    printf ("%I64d", d[n]);
    return 0;
}