hdu 3873 Invade the Mars（dij变体，带限制最短路）

Invade the Mars

Time Limit: 5000/2000 MS (Java/Others)    Memory Limit: 365768/165536 K (Java/Others)
Total Submission(s): 1232    Accepted Submission(s): 351

Problem Description

It's now the year 21XX,when the earth will explode soon.The evil U.S. decided to invade the Mars to save their lives.
But the childlike Marsmen never keeps any army,because war never take place on the Mars.So it's very convenient for the U.S. to act the action.
Luckily,the Marsmen find out the evil plan before the invadation,so they formed a defense system.The system provides enchantment for some citys,and the enchantment generator for city A maybe set in city B,and to make things worse,both city B and C and more will provide echantment for city A.
The satelite of U.S. has got the map of the Mars.And they knows that when they enter a city,they can destory all echantment generator in this city at once,and they can enter a city only if they has destoryed all enchantment generator for this city,but troops can stay at the outside of the city and can enter it at the moment its echantment is destoryed.Of course the U.S. army will face no resistance because the Mars keep no army,so troops can invade in many way at the same time.
Now the U.S. will invade the Mars,give you the map,your task is to calculate the minimium time to enter the capital of the Mars.

 

Input

The first line contains an integer T,which is the number of test cases.
For each testcase:
The first line contains two integers N and M,1<=N<=3000,1<=M<=70000,the cities is numbered from 1 to N and the U.S. landed on city 1 while the capital of the Mars is city N.
The next M lines describes M paths on the Mars.Each line contains three integers ai,bi and wi,indicates there is a unidirectional path form ai to bi lasts wi minutes(1<=wi<=10^8).
The next N lines describes N citys,the 1+M+i line starts with a integer li,followed with li integers, which is the number of cities has a echantment generator protects city i.
It's guaranteed that the city N will be always reachable.

 

Output

For each case,print a line with a number indicating the minimium time needed to enter the capital of the Mars.

 

Sample Input

  
  

   
   1
6 6
1 2 1
1 4 3
2 3 1
2 5 2
4 6 2
5 3 2
0
0
0
1 3
0
2 3 5
  
  

 

Sample Output

  
  

   
   5


   
   

    
    

     
     Hint
    
    
    
    The Map is like this:
We can follow these ways to achieve the fastest speed:
1->2->3,1->2->5,1->4->6.

    
    
     
     
    
    
    
     

   
   
   
    
  
  

 

题意：有n个城市，每个城市都受若干个或0个其他城市的保护，要攻占一个城市，首先要攻占保护这个城市的所有城市。
给出一个有向图，并给出每个城市受哪些城市保护。军队在城市1，求军队攻占到城市n所用的最短时间。
思路：设in[i]表示保护城市i的未被攻占的城市个数；
           mt[i]表示攻占保护城市i的城市所用的最长时间；
           dis[i]表示攻占城市i所需的最短时间，那么dis[i] = max(dis[i], mt[i])
           若攻占了一个城市，那么受这个城市保护的城市i的in[i]--，当in[i]=0时，把i入队。

AC代码：

#include <iostream>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <queue>
#include <stack>
#include <ctime>
#include <vector>
#include <algorithm>
#define ll __int64
#define L(rt) (rt<<1)
#define R(rt)  (rt<<1|1)

using namespace std;

const int INF = 1e9;
const int maxn = 3005;

struct Edge{
    int v, w, next;
}et[maxn * maxn];
int n, m, num;
int eh[maxn], dis[maxn], in[maxn], mt[maxn];
bool vis[maxn];
vector<int>pro[maxn];
typedef pair <int,int> pii;
void init(){
    memset(eh, -1, sizeof(eh));
    num = 0;
}
void add(int u, int v, int w){
    Edge e = {v, w, eh[u]};
    et[num] = e;
    eh[u] = num++;
}
int dij(int s){
    priority_queue<pii, vector<pii>, greater<pii> > Q;
    for(int i = 1; i <= n; i++)
    {
        dis[i] = INF;
        vis[i] =false;
        mt[i] = 0;
    }
    dis[s] = 0;
    Q.push(pii(dis[s], s));
    while(!Q.empty())
    {
        pii cur = Q.top();
        Q.pop();
        int u = cur.second;
        if(vis[u]) continue;
        vis[u] = true;
        for(int i = 0; i < (int)pro[u].size(); i++)
        {
            int v = pro[u][i];
            in[v]--;
            mt[v] = max(mt[v], dis[u]);
            if(dis[v] != INF && !in[v])
            {
                dis[v] = max(dis[v], mt[v]);
                Q.push(pii(dis[v], v));
            }
        }
        for(int i = eh[u]; i != -1; i = et[i].next)
        {
            int v = et[i].v, w = et[i].w;
            if(dis[v] > dis[u] + w)
            {
                dis[v] = max(dis[u] + w, mt[v]);
                if(!in[v]) Q.push(pii(dis[v], v));
            }
        }
    }
    return dis[n];
}
int main()
{
    int t, a, b, c;
    scanf("%d", &t);
    while(t--)
    {
        scanf("%d%d", &n, &m);
        init();
        while(m--)
        {
            scanf("%d%d%d", &a, &b, &c);
            add(a, b, c);
        }
        for(int i = 1; i <= n; i++) pro[i].clear();
        for(int i = 1; i <= n; i++)
        {
            scanf("%d", &in[i]);
            for(int j = 0; j < in[i]; j ++)
            {
                scanf("%d", &a);
                pro[a].push_back(i);
            }
        }
        printf("%d\n", dij(1));
    }
    return 0;
}