[POI2009]WIE-Hexer

题目描述

Byteasar has become a hexer - a conqueror of monsters.

Currently he is to return to his hometown Byteburg. The way home, alas, leads through a land full of beasts. Fortunately the habitants, forced to fight the monsters for centuries, have mastered the art of blacksmithery - they are now capable of making special swords that are very efficient against the beasts.

The land Byteasar wanders through is quite vast: many towns lie there, and many roads connect them.

These roads do not cross outside the towns (mostly because some of them are underground passages).

Byteasar has gathered all practical information about the land (all hexers like to know these things).

He knows what kind of monsters he may come across each of the roads and how much time he needs to walk it down.

He also knows in which villages there are blacksmiths and against what kinds of monsters the swords that they make work.

Byteasar wants to get back to Byteburg as soon as possible.

As a hexer he is quite ashamed that he does not know the best route, and that he has no sword on him at the moment.

Help him find the shortest path to Byteburg such that whenever he could meet some king of monster, previously he would have a chance to get an appropriate sword to fight the beast.

You need not worry about the number or weight of the swords - every hexer is as strong as an ox, so he can carry (virtually) unlimited number of equipment, swords in particular.

大陆上有n个村庄，m条双向道路，p种怪物，k个铁匠，每个铁匠会居住在一个村庄里，你到了那个村庄后可以让他给你打造剑，每个铁匠打造的剑都可以对付一些特定种类的怪物，每条道路上都可能出现一些特定种类的怪物，每条道路都有一个通过所需要的时间，现在要从1走到n，初始的时候你没有剑，要求在经过一条道路的时候，对于任意一种可能出现在这条道路上的的怪物，你都有已经有至少一把剑可以对付他，求从1走到n的最短时间（打造剑不需要时间）

输入输出格式

输入格式：

 

The first line of the standard input holds four integers: n,m,p,kn,m,p,k (1\le n\le 200,0\le m\le 3000,1\le p\le 13,0\le k\le n1≤n≤200,0≤m≤3000,1≤p≤13,0≤k≤n),separated by single spaces, that denote respectively:

the number of towns, the number of roads connecting them,the number of different kinds of monsters and the number of blacksmiths.

The towns are numbered from 11 to nn in such a way that nn is Byteburg's number and 11 is the number of the village which Byteasar starts in. The monster kinds are numbered from 11 to pp.

In the following kk lines the profiles of successive blacksmiths are given,one per line. The (i+1)(i+1)-st line holds the integers w_i,q_i,r_{i,1}wi​,qi​,ri,1​<ri,2​<...<ri,qi​​(1\le w_i\le n,1\le q_i\le p,1\le r_{i,j}\le p1≤wi​≤n,1≤qi​≤p,1≤ri,j​≤p),separated by single spaces, that denote respectively: the number of town in which the blacksmith lives, the number of different kinds of monsters against which his swords are efficient, and the kinds of monsters themselves (in increasing order). Note that a town may have more than one blacksmith.

Then mm lines with roads' descriptions follow.The (k+i+1)(k+i+1)-th line holds the integersv_i,w_i,t_i,s_i,u_{i,1}vi​,wi​,ti​,si​,ui,1​<ui,2​<...<ui,si​​(1\le v_i1≤vi​<wi​≤n,1≤ti​≤500,0≤si​≤p,1≤ui,j​≤p)separated by single spaces, that denote respectively: the towns that the road connects, the time needed to walk down the road (same in both directions), the number of different kinds of monsters that may appear on that road, and finally the kinds of monsters themselves (in increasing order). No two roads connect the same pair of towns.

 

输出格式：

 

Your programme is to print out one integer to the standard output - the minimum summary time required to reach Byteburg.

Should reaching Byteburg be impossible, the number should be -1−1.

 

输入输出样例

输入样例#1：  复制

6 7 4 2
2 1 2
3 2 1 3
1 2 2 0
2 3 9 0
1 4 2 1 2
2 5 3 0
4 5 5 2 2 3
4 6 18 0
5 6 3 2 1 2

输出样例#1：  复制

24

说明

大陆上有n个村庄，m条双向道路，p种怪物，k个铁匠，每个铁匠会居住在一个村庄里，你到了那个村庄后可以让他给你打造剑，每个铁匠打造的剑都可以对付一些特定种类的怪物，每条道路上都可能出现一些特定种类的怪物，每条道路都有一个通过所需要的时间，现在要从1走到n，初始的时候你没有剑，要求在经过一条道路的时候，对于任意一种可能出现在这条道路上的的怪物，你都有已经有至少一把剑可以对付他，求从1走到n的最短时间（打造剑不需要时间）

 

分析：

可怜的洛谷就一道dijkstra题目，于是我只能做这题了。。。

根据某题解大佬的讲法：“观察数据，发现p<=13,n<=200，所有我们很明显可以将状态保存下来。”

WOC!那么“根据dijkstra的性质，n第一次被取出时就是答案。”

于是我就会做了。。。

 

CODE（还是看大佬的代码吧，我的代码。。。不忍直视。。。）:

 1 #include
 2 #include
 3 #include
 4 #include<string>
 5 #include
 6 #include
 7 #include
 8 using namespace std;
 9 const int N=2e2+10,M=3e3+10,inf=1e9;
10 int n,m,k,p,tot,a[N],d[N][N*50],vis[N][N*50];
11 int head[N],next[M*2],ver[M*2],edge[M*2],cost[M*2];
12 priority_queueint,int>,int> >q;
13 inline int read(){
14     int x=0,f=1;char ch=getchar();
15     while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
16     while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
17     return x*f;
18 }
19 inline void add(int x,int y,int z,int c){
20     ver[++tot]=y;edge[tot]=z;cost[tot]=c;next[tot]=head[x];head[x]=tot;
21 }
22 inline int dijkstra(){
23     for(int i=1;i<=n;i++){
24         for(int j=0;j<(1<inf;
25     }
26     d[1][0]=0;q.push(make_pair(make_pair(0,1),0));
27     while(q.size()){
28         int t=-q.top().first.first,x=q.top().first.second,s=q.top().second;q.pop();
29         if(x==n) return t; 
30         if(vis[x][s]) continue;
31         vis[x][s]=1;s|=a[x];
32         for(int i=head[x];i;i=next[i]){
33             int y=ver[i],z=edge[i],c=cost[i];
34             if((s|c)!=s) continue;
35             if(d[y][s]>t+edge[i]){
36                 d[y][s]=t+edge[i];
37                 q.push(make_pair(make_pair(-d[y][s],y),s));
38             }
39         }
40     }
41     return -1;
42 }
43 int main(){
44     n=read();m=read();p=read();k=read();
45     for(int i=1;i<=k;i++){
46         int w=read(),q=read();
47         for(int j=1;j<=q;j++){
48             int x=read();a[w]|=1<<(x-1);
49         }
50     }
51     for(int i=1;i<=m;i++){
52         int x=read(),y=read(),z=read(),s=read(),c=0;
53         for(int j=1;j<=s;j++){
54             int v=read();c|=1<<(v-1);
55         }
56         add(x,y,z,c);add(y,x,z,c);
57     }
58     printf("%d\n",dijkstra());
59     return 0;
60 }

 

转载于:https://www.cnblogs.com/kanchuang/p/11150350.html