HDU5303 Delicious Apples（贪心）

题意：一个长为L的环，环上有n棵树，每棵树上有xi个苹果，有一个容量为k的篮子，装完之后要回到出发点0，给定每棵树的顺时针位置，求摘完所有苹果所需的最短路径。

思路：因为是个环，取苹果的策略可以有三种：

1.取左半边的苹果左边出发原路返回，此时的路径长度是最远苹果树的二倍；

2.取右半边的苹果右边出发原路返回，路径长同上；

3.转一圈后回去，路径长是L。

 可以想出来，对于第三种情况，只有左边和右边的树都离起点较远且两边的苹果总数不大于k，否则都可以通过方法一或二使结果更小。因此每组数据最多只会使用一次方法三。

对于方法一和二，贪心的策略是：1.可以一次拿完，此时的路径长是最远的苹果树的距离的二倍；2.不能一次拿完，优先取最远的。由于最远处的苹果树不确定，因此不一定每次都需要装k个苹果，这点很重要，因此将苹果离散化，分两边按每个苹果到起点的距离l[i]排序。

由此可以得到递推公式：

dis[i]=l[i](i<=k)或者(l[i]+dis[i-k+1])(i>k)

其中dis[i]表示摘到第i个苹果所需要的路径长。

处理完两边后直接枚举转一圈取苹果的情况，要注意确定左边再计算右边的时候有可能得到负数。

#include<bits/stdc++.h>
using namespace std;
#define N 100005
typedef long long LL;
int x[N];
LL disl[N],disr[N];
vector<int>l,r;
int main(){
    int n,k,L,t,cnt,tmp,dis;
    LL ans;
    scanf("%d",&t);
    while(t--){
        scanf("%d%d%d",&L,&n,&k);
        cnt=0;
        for(int i=0;i<n;++i){
            scanf("%d%d",&dis,&tmp);
            if(dis&&(L-dis)){//终点处的树不用走
                while(tmp--){
                    x[cnt++]=dis;
                }
            }
        }
        l.clear();
        r.clear();
        int d=L/2;
        for(int i=0;i<cnt;++i){
            if(x[i]<=d)l.push_back(x[i]);
            else r.push_back(L-x[i]);
        }
        sort(l.begin(),l.end());
        sort(r.begin(),r.end());
        memset(disl,0,sizeof(disl));
        memset(disr,0,sizeof(disr));
        int cl=l.size(),cr=r.size();
        for(int i=0;i<cl;++i){
            disl[i+1]=(LL)((i+1)<=k?l[i]:(l[i]+disl[i+1-k]));
        }
        for(int i=0;i<cr;++i){
            disr[i+1]=(LL)((i+1)<=k?r[i]:(r[i]+disr[i+1-k]));
        }//很关键，dis[i]保存每半边取到第i个苹果的最短路径，递推思想很重要
        ans=(disl[cl]+disr[cr])*2;
        for(int i=0;i<=cl&&i<=k;++i){//i<=cl
            int p1=cl-i;
            int p2=max(0,cr-(k-i));//注意可能会出现负数
            ans=min(ans,(disl[p1]+disr[p2])*2+L);
        }//枚举最后走一圈的情况，找出最小值
        printf("%lld\n",ans);
    }
}