hdu 4114 Disney's FastPass（最短路+状态压缩）

Disney's FastPass

Time Limit: 20000/10000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 2336    Accepted Submission(s):
644

Problem Description

Disney's FastPass is a virtual queuing system
created by the Walt Disney Company. First introduced in 1999 (thugh the idea of
a ride reservation system was first introduced in world fairs), Fast-Pass allows
guests to avoid long lines at the attractions on which the system is installed,
freeing them to enjoy other attractions during their wait. The service is
available at no additional charge to all park guests.
---
wikipedia

Disneyland is a large theme park
with plenties of entertainment facilities, also with a large number of tourists.
Normally, you need to wait for a long time before geting the chance to enjoy any
of the attractions. The FastPass is a system allowing you to pick up
FastPass-tickets in some specific position, and use them at the corresponding
facility to avoid long lines. With the help of the FastPass System, one can
arrange his/her trip more efficiently.
You are given the map of the whole
park, and there are some attractions that you are interested in. How to visit
all the interested attractions within the shortest time?

 

Input

The first line contains an integer T(1<=T<=25),
indicating the number of test cases.
Each test case contains several
lines.
The first line contains three integers N,M,K(1 <= N <= 50; 0
<= M <= N(N - 1)/2; 0 <= K <= 8), indicating the number of
locations(starting with 1, and 1 is the only gate of the park where the trip
must be started and ended), the number of roads and the number of interested
attractions.
The following M lines each contains three integers A,B,D(1 <=
A,B <= N; 0 <= D <= 10^4) which means it takes D minutes to travel
between location A and location B.
The following K lines each contains
several integers P_i, T_i, FT_i,N_i,
F_i,1, F_i,2 ... F_i,Ni-1, F_iNi ,(1
<= P_i,N_i, F_i,j <=N, 0 <=
FT_i <= T_i <= 10^4), which means the ith interested
araction is placed at location Pi and there are Ni locations F_i,1;
F_i,2 ... F_i,N_i where you can get the FastPass
for the ith attraction. If you come to the ith attraction with its FastPass, you
need to wait for only FTi minutes, otherwise you need to wait for Ti
minutes.
You can assume that all the locations are connected and there is at
most one road between any two locations.
Note that there might be several
attrractions at one location.

 

Output

For each test case in the input, print one line: "Case
#X: Y", where X is the test case number (starting with 1) and Y is the minimum
time of the trip.

 

Sample Input

2

4 5 2

1 2 8

2 3 4

3 4 19

4 1 6

2 4 7

2 25 18 1 3

4 12 6 1 3

4 6 2

1 2 5

1 4 4

3 1 1

3 2 1

3 4 1

2 4 10

2 8 3 1 4

4 8 3 1 2

 

Sample Output

Case #1: 53

Case #2: 14

 

题意：游戏园里有N个区域，有M条边连接这N个区域，有K个要访问的景点。对于每个景点告诉你这个景点所在的区域，要访问这个景点需要等待一定时间，如果没有FastPass，等待时间有Ti，否则等待时间为FTi，接下来的Ni，表示有Ni个区域可以得到这个景点的FastPass，问从区域1出发，再回到区域1所需要的最少时间。

 

第一次写状态压缩，参照别人的代码。首先是floyd预处理出任意两点之间的最短距离。dp[state1][state2][u]表示在该状态state1(已经访问过的景点)、state2(手中有的景点的票)、目前所在的位置时所花费的时间的最小值，于是答案就是dp[(1<<k)-1][state][1]了（0<=state<(1<<n))。

 

附上代码：

 

 #include <iostream>
 #include <cstdio>
 #include <cstring>
 #include <queue>
 #include <cmath>
 #define INF 0x3f3f3f3f
 #define M
 #define N 60
 using namespace std;
 int n,m,k,ans;
 int map[N][N];
 int p[N],t[N],ft[N],pass[N];
 int dp[<<][<<][N];

 void floyd()
 {
     int i,j,k;
     for(k=; k<=n; k++)
         for(i=; i<=n; i++)
             for(j=; j<=n; j++)
                 if(map[i][j]>map[i][k]+map[k][j])
                     map[i][j]=map[i][k]+map[k][j];
 }

 void Get_Dp()
 {
     int i,j,u,v;
     for(i=; i<=(<<k); i++)
         for(j=; j<=(<<k); j++)
             for(u=; u<=n; u++)
                 dp[i][j][u]=INF;
     dp[][][]=;
     for(int state1=; state1<(<<k); state1++)
     {
         for(int state2=; state2<(<<k); state2++)
         {
             for(u=; u<=n; u++)
             {
                 if(dp[state1][state2][u]<INF)
                 {
                     for(i=; i<k; i++)
                     {
                         if(!(state1&(<<i))) ///单独取state1的每一位数字
                         {
                             int cost=map[u][p[i]];
                             if((state2&(<<i))) cost+=ft[i];
                             else cost+=t[i];
                             dp[state1|(<<i)][state2|pass[p[i]]][p[i]]=min(dp[state1|(<<i)][state2|pass[p[i]]][p[i]],dp[state1][state2][u]+cost);
                         }
                     }
                     for(v=; v<=n; v++)
                     {
                         dp[state1][state2|pass[v]][v]=min(dp[state1][state2|pass[v]][v],dp[state1][state2][u]+map[u][v]);
                     }
                 }
             }
         }
     }
     ans=INF;
     for(i=; i<(<<k); i++)
         ans=min(ans,dp[(<<k)-][i][]);
 }

 int main()
 {
     int i,j,T,cas,num,v;
     scanf("%d",&T);
     for(cas=; cas<=T; cas++)
     {
         scanf("%d%d%d",&n,&m,&k);
         for(i=; i<=n; i++)
             for(j=; j<=n; j++)
                 if(i==j) map[i][j]=;
                 else     map[i][j]=INF;
         int a,b,c;
         while(m--)
         {
             scanf("%d%d%d",&a,&b,&c);
             if(map[a][b]>c)
                 map[a][b]=c,map[b][a]=c;
         }
         floyd();
         memset(pass,,sizeof(pass));
         for(i=; i<k; i++)
         {
             scanf("%d%d%d%d",&p[i],&t[i],&ft[i],&num);
             while(num--)
             {
                 scanf("%d",&v);
                 pass[v]|=(<<i); ///没有进位的加法
             }
         }
         Get_Dp();
         printf("Case #%d: %d\n",cas,ans);
     }
     return ;
 }