POJ-3635 Full Tank? （记忆化广搜）

Description

After going through the receipts from your car trip through Europe this summer, you realised that the gas prices varied between the cities you visited. Maybe you could have saved some money if you were a bit more clever about where you filled your fuel?

To help other tourists (and save money yourself next time), you want to write a program for finding the cheapest way to travel between cities, filling your tank on the way. We assume that all cars use one unit of fuel per unit of distance, and start with an empty gas tank.

Input

The first line of input gives 1 ≤ n ≤ 1000 and 0 ≤ m ≤ 10000, the number of cities and roads. Then follows a line with n integers 1 ≤ p_i ≤ 100, where p_i is the fuel price in the ith city. Then follow m lines with three integers 0 ≤ u, v < n and 1 ≤ d ≤ 100, telling that there is a road between u and v with length d. Then comes a line with the number 1 ≤ q ≤ 100, giving the number of queries, and q lines with three integers 1 ≤ c ≤ 100, s and e, where c is the fuel capacity of the vehicle, s is the starting city, and e is the goal.

Output

For each query, output the price of the cheapest trip from s to e using a car with the given capacity, or "impossible" if there is no way of getting from s to e with the given car.

Sample Input

5 5
10 10 20 12 13
0 1 9
0 2 8
1 2 1
1 3 11
2 3 7
2
10 0 3
20 1 4

Sample Output

170
impossible

题目大意：n个城市，m条公路构成了一张n个顶点，m条无向边的图。现在要从一个城市驾车到另一个城市，每单位油能走1公里路，已知每个城市的油价（元/单位）和车的油箱容量，问到达目的地的最小花费是多少。
题目分析：以当前的所在城市和油箱剩余油量作为状态参数，最多有 城市数x油箱容量=10^5 个状态，暴力是可以接受的，又让求最小花费，就敲定用广搜了。现在考虑状态转移，当到达一个城市时，无非面临了两种选择：1.当油量足够能通过下条路时，直接扩展；2.加一个单位油（加一个单位油没问题，如果加多的话，会重复，造成不必要的时间浪费）。问题看似已经解决，但如果仅仅是这样的话，会TLE。
　　解决办法就是将广搜的过程记忆化，当达到某个状态时解比已经得到的解更优时，搜索才继续进行下去，并更新最优解。要开辟新的数组来记录状态的最优解。

代码如下：

 # include<iostream>
 # include<cstdio>
 # include<queue>
 # include<cstring>
 # include<algorithm>
 using namespace std;
 const int INF=<<;
 struct node
 {
     int pos,tank,m;
     bool operator < (const node &a) const {
         return m>a.m;
     }
 };
 struct edge
 {
     int to,w,nxt;
 };
 edge e[];
 int n,vis[][],dp[][],head[],price[],cnt;
 void add(int u,int v,int w)
 {
     e[cnt].to=v;
     e[cnt].w=w;
     e[cnt].nxt=head[u];
     head[u]=cnt++;
 }
 void bfs(int v,int s,int t)
 {
     priority_queue<node>q;
     for(int i=;i<=n;++i)
         for(int j=;j<=v;++j)
             dp[i][j]=INF;
     memset(vis,,sizeof(vis));
     dp[s][]=;
     node sta;
     sta.m=,sta.pos=s,sta.tank=;
     q.push(sta);
     while(!q.empty()){
         node u=q.top();
         q.pop();
         int pos=u.pos;
         vis[pos][u.tank]=;
         if(pos==t){
             printf("%d\n",u.m);
             return ;
         }
         for(int i=head[pos];i!=-;i=e[i].nxt){
             if(u.tank>=e[i].w&&!vis[e[i].to][u.tank-e[i].w]&&dp[e[i].to][u.tank-e[i].w]>u.m){
                 dp[e[i].to][u.tank-e[i].w]=u.m;
                 node nxt;
                 nxt.pos=e[i].to,nxt.tank=u.tank-e[i].w,nxt.m=u.m;
                 q.push(nxt);
             }
         }
         if(u.tank+<=v&&!vis[pos][u.tank+]&&dp[pos][u.tank+]>dp[pos][u.tank]+price[pos]){
             dp[pos][u.tank+]=dp[pos][u.tank]+price[pos];
             node nxt;
             nxt.pos=pos,nxt.m=dp[pos][u.tank+],nxt.tank=u.tank+;
             q.push(nxt);
         }
     }
     printf("impossible\n");
 }
 int main()
 {
     int m,q,a,b,c;
     while(scanf("%d%d",&n,&m)!=EOF)
     {
         cnt=;
         for(int i=;i<n;++i)
             scanf("%d",price+i);
         memset(head,-,sizeof(head));
         while(m--){
             scanf("%d%d%d",&a,&b,&c);
             add(a,b,c);
             add(b,a,c);
         }
         scanf("%d",&q);
         while(q--){
             scanf("%d%d%d",&c,&a,&b);
             bfs(c,a,b);
         }
     }
     return ;
 }