hdu3873 有约束条件的最短路

题目大意：美国佬打算入侵火星，火星上有n个城市，有些城市可能受其他城市保护，

如果i城市受j城市保护，那么你必须先攻占j城市才能再攻占i城市，问你攻占城市n的最短时间是多少。

数据解释：

给定t， 表示有t组数据

给定n，m 表示n个点，m条边

接下来m条有向边， a,b,c  表示从a到b，距离为c

接下来n行， 每行第一个整数d，然后接下来是d个整数，x1,x2,...xd， 表示第i个城市受d个城市保护，表示只有城市x1，x2...xd都被攻占，城市i才能被攻占

问从点1到达点n的最短时间（一定是可达的）

重要的一点是，因为是军队，所以可以同时进军多个点。

思路：

如果城市i受其他城市保护， 那么攻占城市i的最短时间是从1-->i和攻占城市i的保护城市  这两个时间中的最大值。

设dist[i] 为 攻占城市i的最短时间，  maxn[i] 为攻占所有保护i的城市中时间最长的那个

那么 dist[i] = max(dist[i],maxn[i])

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <math.h>
using namespace std;
#pragma warning(disable:4996)
typedef long long LL;
const int INF = 1 << 30;
/*

*/
struct Edge
{
    int to, dist;
    bool operator<(const Edge&rhs)const
    {
        return dist > rhs.dist;
    }
};
vector<Edge> g[3000 + 10];
vector<int> pro[3000 + 10];
bool vis[3000 + 10];
int protect[3000 + 10];
int dist[3000 + 10], maxn[3000 + 10], ans[3000 + 10];
void dij(int n)
{
    for (int i = 1; i <= n; ++i)
    {
        vis[i] = false;
        dist[i] = INF;
        maxn[i] = 0;
    }
    dist[1] = 0;
    priority_queue<Edge> q;
    Edge cur, tmp;
    cur.to = 1;
    cur.dist = 0;
    q.push(cur);
    while (!q.empty())
    {
        cur = q.top(); q.pop();
        int x = cur.to;
        if (vis[x]) continue;
        for (int i = 0; i < pro[x].size(); ++i)
        {
            int v = pro[x][i];
            maxn[v] = max(maxn[v], dist[x]);//求出到达保护城市v的城市最长的那一个
            protect[v]--;
        }
        vis[x] = true;
        for (int i = 0; i < g[x].size(); ++i)
        {
            int v = g[x][i].to;
            if (dist[v] > dist[x] + g[x][i].dist)
                dist[v] = dist[x] + g[x][i].dist;
        }
        for (int i = 1; i <= n; ++i)
        {
            if (vis[i]) continue;
            dist[i] = max(dist[i], maxn[i]);
            if (protect[i] == 0 && dist[i]!=INF)//在点i没有解除约束之前，我们不能让它去更新其它的点
            {
                tmp.to = i;
                tmp.dist = dist[i];
                q.push(tmp);
            }
            
        }
    }
}

void input(int &x)
{
    char ch = getchar();
    while (ch > '9' || ch < '0')
        ch = getchar();
    x = 0;
    while (ch >= '0' && ch <= '9')
    {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
}
int main()
{
    int t, n, m, i, a, b, c;
    Edge tmp;
    scanf("%d", &t);
    while (t--)
    {
        //scanf("%d%d", &n, &m);
        input(n); input(m);
        for (i = 1; i <= n; ++i)
        {
            g[i].clear();
            pro[i].clear();
        }
        for (i = 0; i < m; ++i)
        {
            //scanf("%d%d%d", &a, &b, &c);
            input(a); input(b); input(c);
            tmp.to = b;
            tmp.dist = c;
            g[a].push_back(tmp);
        }
        for (int i = 1; i <= n; ++i)
        {
            //scanf("%d", &a);
            input(a);
            protect[i] = a;
            for (int j = 0; j < a; ++j)
            {
                //scanf("%d", &b);
                input(b);
                pro[b].push_back(i);
            }
        }
        dij(n);
        printf("%d
", dist[n]);
    }
    return 0;
}