贪心：推销员

参考文献：https://www.luogu.com.cn/blog/Rainy7/solution-p2672

题目链接：https://www.luogu.com.cn/problem/P2672

题目：

题目描述

阿明是一名推销员，他奉命到螺丝街推销他们公司的产品。螺丝街是一条死胡同，出口与入口是同一个，街道的一侧是围墙，另一侧是住户。螺丝街一共有N家住户，第ii家住户到入口的距离为Si​米。由于同一栋房子里可以有多家住户，所以可能有多家住户与入口的距离相等。阿明会从入口进入，依次向螺丝街的XX家住户推销产品，然后再原路走出去。

阿明每走1米就会积累1点疲劳值，向第ii家住户推销产品会积累Ai​点疲劳值。阿明是工作狂，他想知道，对于不同的X，在不走多余的路的前提下，他最多可以积累多少点疲劳值。

输入格式

第一行有一个正整数N，表示螺丝街住户的数量。

接下来的一行有N个正整数，其中第i个整数Si​表示第ii家住户到入口的距离。数据保证S1​≤S2​≤…≤Sn​<108。

接下来的一行有N个正整数，其中第ii个整数Ai​表示向第ii户住户推销产品会积累的疲劳值。数据保证Ai​<1000。

输出格式

输出N行，每行一个正整数，第i行整数表示当X=i时，阿明最多积累的疲劳值。

输入输出样例

输入 #1复制

5
1 2 3 4 5
1 2 3 4 5

输出 #1复制

15
19
22
24
25

输入 #2复制

5
1 2 2 4 5
5 4 3 4 1

输出 #2复制

12
17
21
24
27

说明/提示

【输入输出样例1说明】

X=1向住户5推销，往返走路的疲劳值为5+5，推销的疲劳值为5，总疲劳值为15。

X=2:向住户4,5推销，往返走路的疲劳值为5+5，推销的疲劳值为4+5，总疲劳值为5+5+4+5=19。

X=3:向住户3,4,5推销，往返走路的疲劳值为5+5，推销的疲劳值3+4+5，总疲劳值为5+5+3+4+5=22。

X=4：向住户2,3,4,5推销，往返走路的疲劳值为5+5，推销的疲劳值2+3+4+5，总疲劳值5+5+2+3+4+5=24。

X=5:向住户1,2,3,4,5推销，往返走路的疲劳值为5+5，推销的疲劳值1+2+3+4+5，总疲劳值5+5+1+2+3+4+5=25。

【输入输出样例2说明】

X=1：向住户4推销，往返走路的疲劳值为4+4，推销的疲劳值为4，总疲劳值4+4+4=12。

X=2：向住户1,4推销，往返走路的疲劳值为4+4，推销的疲劳值为5+4，总疲劳值4+4+5+4=17。

X=3：向住户1,2,4推销，往返走路的疲劳值为4+4，推销的疲劳值为5+4+4，总疲劳值4+4+5+4+4=21。

X=4：向住户1,2,3,4推销，往返走路的疲劳值为4+4，推销的疲劳值为5+4+3+4，总疲劳值4+4+5+4+3+4=24。或者向住户1,2,4,5推销，往返走路的疲劳值为5+5，推销的疲劳值为5+4+4+1，总疲劳值5+5+5+4+4+1=24。

X=5：向住户1,2,3,4,5推销，往返走路的疲劳值为5+5，推销的疲劳值为5+4+3+4+1，总疲劳值5+5+5+4+3+4+1=27。

【数据说明】

对于100%的数据，1≤N≤100000。

 分析:

最优解的情况分为两种，第一种就是需要x，则选择前x个推销耗费最多的情况，为往返路途 + 总的推销耗费。   第二种情况就是前x - 1 个推销耗费最多的情况  +  第x + 1~n中选择一个 往返路途 + 推销耗费总的最多的情况。两种情况取一个最大值

为什么只有这两种情况呢？

首先我们将其按照 推销耗费最多的情况进行排序，推销耗费相同距离大的在前。

1.如果1 ~ x的最大距离 大于等于 x + 1 ~ n的最大距离，则推销耗费又是最多的，最大距离也不会比 x+ 1 ~ n差，那么第一种不就是最优情况了嘛。

2.如果 1 ~ x 的 最大距离  小于 x + 1 ~ n 的最大距离， 则可能x + 1 ~ n 的推销耗费没有 1 ~ x 耗费大，但是可以通过距离进行弥补，而这个弥补选择的一定是x + 1 ~ n中距离 大于  1~x的最大距离的情况，所以2 * 距离的话,用的是x + 1 ~ n 中选择的新的那个。

可能存在 x + 1 ~ n 中推销耗费 + 2 * 距离 > 第一种的情况。

也就是第二种情况可能最优。

那么，为什么不会出现第三种情况呢？那就是只选择前 x - 2 的推销耗费最大，x + 1 ~ n中选择两个的情况呢？ 这是因为，我们选择的这两个物品，要么这两个的距离相等，要么这两个的距离不等，而不管距离相等还是不等，2 * 距离的计算，都是用的这两个中距离最大的乘以 2, 然后 + 1 ~ x - 2的推销消费， + 选中的两个推销消费。

即然如此，那还不如只选择那个距离最大的情况，

变为 2 * 距离最大（与上面标红的距离最大值一样） + 1 ~ x - 1的推销消费（前x - 1个推销消费最大的情况） + 这个距离最大的推销消费。

所以，这第三种情况要么 与 第二种情况值相等，要么小于第二种情况。

以此类推，只选择前x - 3 , x- 4个推销耗费最大也是一样的道理。

因此，最大值只有最上面的两种情况。

而这两种情况，最后可以用一个公式进行合并。

printf("%d\n",max(ss[i] + 2 * lentemp , ss[i - 1] + sum[i + 1]));

当选择前i个的时候，就用前i的前缀和 + 2 * 最大的长度。

当选择前i - 1个的时候，就用前i - 1 的前缀和  + (i + 1 ~ n) 中的最大值。

最后求一个max即可。 

代码实现：

# include <iostream>
# include <algorithm>
using namespace std;

const int N = 100010;

struct People
{
    int dist; // 距离
    int waste; // 推销时消耗
}people[N];

int n;

bool cmp(struct People a , struct People b)
{
    if(a.waste == b.waste) // 如果推销的消耗相同的时候，距离越大的排在前面
    {
        return a.dist > b.dist;
    }
    return a.waste > b.waste; // 推销消耗越大的排前面

}

//实际上这个len[]的求解是多余的。最后发现虽然在思路上会对长度进行比较，但是在最后求max的时候，不需要用到len[],直接max()求解，将1~x 与 x + 1 ~ n 的所有最大长度之间的关系都包括进去了.

int len[N]; // len[i]:就是i到n中最大距离的那个点。


int sum[N]; // sum[i]:就是i到n中的 距离 * 2 + 疲劳值得到的值 的最大值
int ss[N]; // 前1~i的waste的前缀和

int main()
{
    scanf("%d",&n);
    for(int i = 1 ; i <= n ; i++)
    {
        scanf("%d",&people[i].dist);
    }
    for(int i = 1 ; i <= n ; i++)
    {
        scanf("%d",&people[i].waste);
    }

    sort(people + 1 , people + 1 + n , cmp);


    len[n + 1] = -0x3f3f3f3f;

    for(int i = n ; i >= 1 ; i--)
    {
        len[i] = max(people[i].dist,len[i + 1]);
    }

    sum[n + 1] = -0x3f3f3f3f;
    for(int i = n ; i >= 1 ; i--)
    {
        sum[i] = max(sum[i + 1],people[i].dist * 2 + people[i].waste);
    }

    for(int i = 1 ; i <= n ; i++)
    {
        ss[i] = ss[i - 1] + people[i].waste;
    }

    int lentemp = -0x3f3f3f3f;

    for(int i = 1 ; i <= n ; i++) //i就是x 的含义,前i - 1与 i ~n进行比较
    {
        lentemp = max(lentemp,people[i].dist);
        printf("%d\n",max(ss[i] + 2 * lentemp , ss[i - 1] + sum[i + 1])); // 如果选择了第i个，或者选择第 i + 1 ~ n中的一个
    }
    /*
    如果 前 i个的最大长度   大于 后 i + 1 ~ n中所有节点的长度，
    则ss[i] + 2 * lentemp必为最大值，因为ss[i]是所有耗费中最大的情况， 2 * lentemp中lentemp也为最大的长度，所以不会被后面的ss[i - 1] + sum[i + 1]影响

    如果后面的 (i + 1) ~ n 中存在比它长度大的结果 ，那么就有可能是后面的情况。
    */
    return 0;
}