2015 Multi-University Training Contest 2 hdu 5303 Delicious Apples

Delicious Apples

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

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 ith tree is planted at position xi, clockwise from position 0. There are ai delicious apple(s) on the ith 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

 

Source

2015 Multi-University Training Contest 2

 

解题：核心思想是贪心，关键在于枚举最后剩下的K个苹果。

 

先把圆分成两半，用sum[i]算出到i最小需要多长路

 

 

为什么是sum[i] = sum[i-k] + L[i]呢？

 

这个其实是倒推!很明显，最后可能从前开始的不足K个，为什么不是从前面推呢？

 

很明显，无论是从前面推还是后面推，其包含的K长度的区间个数是一定的，

 

但是从后面推得到好处就是和会更少！

 

这里体现了传说中的贪心思想。

 

明显从后面推，前面部分的值更少

 

最后我们需要枚举K个长度的区间，横跨两个半圆

LL ret = (sum[Lsize][0] + sum[Rsize][1])<<1;

这句话表示纯粹的使用不环绕圆的方式取完所有苹果的最短路径，是的最短，因为前面贪心了嘛。

 

int a = Lsize - i; 表示的是什么呢？表示从左半圆选择i个 那么剩下的部分不跨圆，继续使用拿完原路返回策略
int b = max(0,Rsize - (K - i)); 剩下的 K- i个采用拿了原路返回的策略
ret = min(ret,((sum[a][0] + sum[b][1])<<1) + Len); 那么这K个，我们采用拿了 不原路返回，采用绕圆的方法

所以多了Len

 #include <bits/stdc++.h>
 using namespace std;
 typedef long long LL;
 const int maxn = ;
 LL d[maxn],tot,sum[maxn][];
 vector<LL>L,R;
 int main() {
     int kase,n,K,m,pos;
     LL Len;
     scanf("%d",&kase);
     while(kase--) {
         scanf("%d%d%d",&pos,&n,&K);
         L.clear();
         R.clear();
         Len = pos;
         for(int i = tot = ; i < n; ++i) {
             scanf("%d%d",&pos,&m);
             for(int j = ; j < m; ++j)
                 d[tot++] = pos;
         }
         for(int i = ; i < tot; ++i) {
             if(d[i]* < Len) L.push_back(d[i]);
             else R.push_back(Len - d[i]);
         }
         sort(L.begin(),L.end());
         sort(R.begin(),R.end());
         int Lsize = L.size(),Rsize = R.size();
         sum[][] = sum[][] = ;
         for(int i = ; i < Lsize; ++i)
             if(i +  <= K) sum[i + ][] = L[i];
             else sum[i + ][] = sum[i - K + ][] + L[i];
         for(int i = ; i < Rsize; ++i)
             if(i +  <= K) sum[i+][] = R[i];
             else sum[i+][] = sum[i-K+][] + R[i];
         LL ret = (sum[Lsize][] + sum[Rsize][])<<;
         for(int i = ; i <= Lsize && i <= K; ++i) {
             int a = Lsize - i;
             int b = max(,Rsize - (K - i));
             ret = min(ret,((sum[a][] + sum[b][])<<) + Len);
         }
         cout<<ret<<endl;
     }
     return ;
 }