cdoj 482 优先队列+bfs

Charitable Exchange

Time Limit: 4000/2000MS (Java/Others)     Memory Limit: 65535/65535KB (Java/Others)

Submit Status

Have you ever heard a star charity show called Charitable Exchange? In this show, a famous star starts with a small item which values 11 yuan. Then, through the efforts of repeatedly exchanges which continuously increase the value of item in hand, he (she) finally brings back a valuable item and donates it to the needy.

In each exchange, one can exchange for an item of Vi yuan if he (she) has an item values more than or equal to RiRi yuan, with a time cost of TiTi minutes.

Now, you task is help the star to exchange for an item which values more than or equal to MM yuan with the minimum time.

Input

The first line of the input is TT (no more than 2020), which stands for the number of test cases you need to solve.

For each case, two integers NN, MM (1≤N≤1051≤N≤105, 1≤M≤1091≤M≤109) in the first line indicates the number of available exchanges and the expected value of final item. Then NN lines follow, each line describes an exchange with 33 integers ViVi, RiRi, TiTi (1≤Ri≤Vi≤1091≤Ri≤Vi≤109, 1≤Ti≤1091≤Ti≤109).

Output

For every test case, you should output Case #k: first, where kk indicates the case number and counts from 11. Then output the minimum time. Output −1−1 if no solution can be found.

Sample input and output

Sample Input	Sample Output
3 3 10 5 1 3 8 2 5 10 9 2 4 5 2 1 1 3 2 1 4 3 1 8 4 1 5 9 5 1 1 10 4 10 8 1 10 11 6 1 7 3 8	Case #1: -1 Case #2: 4 Case #3: 10

Source

Sichuan State Programming Contest 2011

 

题意：给你n个物品交换，每个交换用r,v,t描述，代表需要用r元的东西花费t时间交换得v元的东西。
一开始只有1元的东西，让你求出交换到价值至少为m的最少时间代价。

 

题解：相当于每个交换是一条边，时间为边权，求走到价值大于等于m的点的最短路径。bfs的时候，用优先队列来储存状态，

每次取出花费总时间最小的状态。将边按照r来排序，遍历更新得到新的边加入到队列，注意剪枝，当前拥有r无法做任何交换时 break；

 

爆内存点  i=l  不需要每次遍历都从i=1开始 因为已经进行过排序处理,已经遍历过的 为了确保时间代价最小 一定不满足之后取出的状态

T点  r无法做任何交换时 break；

注意开long long

 

 

 /******************************
 code by drizzle
 blog: www.cnblogs.com/hsd-/
 ^ ^    ^ ^
  O      O
 ******************************/
 //#include<bits/stdc++.h>
 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<map>
 #include<algorithm>
 #include<queue>
 #include<cmath>
 #define ll long long
 #define PI acos(-1.0)
 #define mod 1000000007
 using namespace std;
 struct node
 {
     int to;
     ll we;
     int pre;
     friend bool operator < (node a, node b)
     {
         return  a.we > b.we;
     }
 }N[];
 priority_queue<node> pq;
 int t;
 int n,m;
 bool cmp(struct node aa,struct  node bb)
 {
     return aa.pre<bb.pre;
 }
 ll bfs()
 {
     struct node exm,now;
     while(!pq.empty()) pq.pop();
     exm.pre=;
     exm.to=;
     exm.we=;
     pq.push(exm);
     int l=;
     int i;
     while(!pq.empty())
     {
         now=pq.top();
         pq.pop();
         if(now.to>=m)
         {
             return now.we;
         }
         for(i=l; i<=n; i++)
         {
             if(now.to>=N[i].pre&&now.to<N[i].to)//遍历可以用的边
             {
                 exm.pre=now.to;
                 exm.to=N[i].to;
                 exm.we=now.we+N[i].we;
                 pq.push(exm);
                 l=i;//爆内存点
             }
             if(now.to<N[i].pre)//T点
                 break;
         }
     }
     return -;
 }
 int main()
 {
     scanf("%d",&t);
     {
         for(int i=; i<=t; i++)
         {
             scanf("%d %d",&n,&m);
             for(int j=; j<=n; j++)
                 scanf("%d %d %lld",&N[j].to,&N[j].pre,&N[j].we);
             sort(N+,N++n,cmp);
             ll ans=bfs();
             printf("Case #%d: %lld\n",i,ans);
         }
     }
     return ;
 }