Delicious Apples（贪心+枚举）

Delicious Apples

Time Limit: 5000/3000 MS (Java/Others)    Memory Limit: 524288/524288 K (Java/Others)
Total Submission(s): 587    Accepted Submission(s): 188

Problem Description

There are  n  apple trees planted along a cyclic road, which is  L  metres long. Your storehouse is built at position  0  on that cyclic road.
The  i th tree is planted at position  xi , clockwise from position  0 . There are  ai  delicious apple(s) on the  i th tree.

You only have a basket which can contain at most  K  apple(s). You are to start from your storehouse, pick all the apples and carry them back to your storehouse using your basket. What is your minimum distance travelled?

1≤n,k≤105,ai≥1,a1+a2+...+an≤105
1≤L≤109
0≤x[i]≤L

There are less than 20 huge testcases, and less than 500 small testcases.

 

Input

First line:  t , the number of testcases.
Then  t  testcases follow. In each testcase:
First line contains three integers,  L,n,K .
Next  n  lines, each line contains  xi,ai .

 

Output

Output total distance in a line for each testcase.

 

Sample Input

  
  

   
   2
10 3 2
2 2
8 2
5 1
10 4 1
2 2
8 2
5 1
0 10000
  
  

 

Sample Output

  
  

   
   18
26
  
  
  
  


  
  

题目大意：有一个圈，圈的长度是l，在正上方是0点，在圈上有n棵苹果树，给出每棵苹果树的位置和苹果的数量，现在一个人在0点的农场里，有一个小篮子，一次可以装k个苹果，问最少走多少距离可以把苹果收回农场。

赛中一看就是贪心的题目，然后就是各种不会啊，当时想了各种办法，又想了各种反例，，，，最终还是不会，，，

赛后补题，结论：表示一定要注意给出的范围的条件呀，尤其是比较特别的，一定有用。

对于摘苹果有几种情况：

1、正向去摘，然后按原路返回

2、反向去摘，然后按原路返回

3、还有就是直接走一圈

这三种方式，前面两个是比较容易解决的，直接去摘就好，特别的是去直接走一圈，如果两侧都有很多，那么直接走一圈一定是浪费的，那么会在什么情况下会变成节省路程的呢？

结果就是如果在圈上只剩下了k个苹果，可以一次摘走，如果这k个在一侧，或者在接近0点的两侧，那么走半圆是优的；如果在两侧并且比较靠下方，那么直接走一圈就是优的。而且走一圈只可能出现一次，否则就可以用半圈来代替了。

题目中给出了所有的苹果不会超过10^5个，让a[i]表示第i个苹果的位置，disr[i]表示正向摘完第i个需要的距离，disl[i]表示反向摘完第i个需要的距离，然后通过它们找出如果没走过整圈需要的最小值，和走一个整圈需要的最小值，其中小的那个是结果。

注意：如果k大于所有的苹果数，那么len的距离一定可以摘完，要特判一下最小值。

[cpp]  view plain  copy

1. #include <cstdio>  
2. #include <cstring>  
3. #include <algorithm>  
4. using namespace std ;  
5. #define LL __int64  
6. struct node{  
7.     int x , a ;  
8. }p[100010];  
9. int a[100010] , cnt ;  
10. LL disl[100010] , disr[100010] ;  
11. int cmp(node t1,node t2) {  
12.     return t1.x < t2.x ;  
13. }  
14. int main() {  
15.     int t , n , k ;  
16.     int i , j ;  
17.     LL len , ans ;  
18.     scanf("%d", &t) ;  
19.     while( t-- ) {  
20.         scanf("%d %d %d", &len, &n, &k) ;  
21.         for(i = 0 ; i < n ; i++) {  
22.             scanf("%d %d", &p[i].x, &p[i].a) ;  
23.         }  
24.         sort(p,p+n,cmp) ;  
25.         cnt = 1 ;  
26.         for(i = 0 ; i < n ; i++) {  
27.             for(j = 0 ; j < p[i].a ; j++)  
28.                 a[cnt++] = p[i].x ;  
29.         }  
30.         memset(disl,0,sizeof(disl)) ;  
31.         memset(disr,0,sizeof(disr)) ;  
32.         for(i = 1 ; i < cnt ; i++) {  
33.             j = max(i-k,0) ;  
34.             disr[i] = disr[j] + 2*a[i] ;  
35.         }  
36.         for(i = cnt-1 ; i > 0 ; i--) {  
37.             j = min(i+k,cnt) ;  
38.             disl[i] = disl[j] + 2*(len-a[i]) ;  
39.         }  
40.         ans = 0 ;  
41.         for(i = 0 ; i < cnt ; i++) {  
42.             if( ans == 0 ) ans = disr[i] + disl[i+1] ;  
43.             else ans = min(ans,disr[i]+disl[i+1]) ;  
44.         }  
45.         for(i = 0 ; i+k+1 <= cnt ; i++)  
46.             ans = min(ans,disr[i]+disl[i+k+1]+len) ;  
47.         if( k >= cnt ) ans = min(ans,len) ;  
48.         printf("%I64d\n", ans) ;  
49.     }  
50.     return 0 ;  
51. }