NOIP2015普及组T4salesman题解

4.推销员
(salesman.cpp/c/pas)
【问题描述】
阿明是一名推销员，他奉命到螺丝街推销他们公司的产品。螺丝街是一条死胡同，出口与入
口是同一个，街道的一侧是围墙，另一侧是住户。螺丝街一共有N家住户，第i家住户到入口
的距离为Si米。由于同一栋房子里可以有多家住户，所以可能有多家住户与入口的距离相等。 阿明会从入口进入，依次向螺丝街的X家住户推销产品，然后再原路走出去。 阿明每走1米就会积累1点疲劳值，向第i家住户推销产品会积累Ai点疲劳值。阿明是工作狂， 他想知道，对于不同的X，在不走多余的路的前提下，他最多可以积累多少点疲劳值。
【输入格式】 输入文件名为salesman.in。 第一行有一个正整数N，表示螺丝街住户的数量。
接下来的一行有N个正整数，其中第i个整数Si表示第i家住户到入口的距离。数据保证 S1≤S2≤…≤Sn<108。 接下来的一行有N个正整数，其中第i个整数Ai表示向第i户住户推销产品会积累的疲劳值。
数据保证Ai<103。
【输出格式】 输出文件名为salesman.out。
输出 N 行，每行一个正整数，第 i 行整数表示当 X=i 时，阿明最多积累的疲劳值。
【样例输入 1】
5
1 2 3 4 5
1 2 3 4 5
【样例输出 1】
15
19
22
24
25
【输入输出样例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】
5
1 2 2 4 5
5 4 3 4 1
【样例输出 2】
12
17
21
24
27
【输入输出样例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。
【样例输入输出3】
见选手目录下的salesman/salesman3.in和salesman/salesman3.ans。
【数据说明】 对于20%的数据，1≤N≤20； 对于40%的数据，1≤N≤100； 对于60%的数据，1≤N≤1000；
对于 100%的数据，1≤N≤100000。

【题解】
这道题目距离 Si 是保证严格不降的，对于前 60 分，只需要 O(N^2)的算法 O(N^2)的算法的关键是要发现找最大疲劳值，要么是在距离点内找疲劳值最大的点，要么是 增加距离范围找到一个（疲劳值+增加的往返距离值最大）的点。
如果要拿到剩下的 40 分，需要优化选择下一个最优点的时间复杂度，有很多种方式， 这里采用了树状数组维护区间最值的方法，建立两个树状数组，分别表示当前距离范围内的最大疲劳值、超过距离范围的（疲劳值+增加的往返距离值）最大值。

#include "stdio.h"
#include "string.h"
#include "algorithm"
#include "stdlib.h"
#include "iostream"
#include "queue"
#include "vector"
#include "stack"
#include "math.h"

using namespace std;

struct node{
    int x;
    int y;
    int name;
}house[100005],cpy[100005];

int right;

bool operator >(node a,node b){
    if(a.y==b.y) return (a.x-b.x>0)?1:0;
    return (a.y-b.y>0)?0:1;
}
int cmp(const void *p,const void *q){
    node *a=(node *)p;
    node *b=(node *)q;
    int t1=a->x*2+a->y;
    int t2=b->x*2+b->y;
    if(t1==t2) return a->x-b->x;
    return t2-t1;
}

int cmp2(const void *p,const void *q){
    node *a=(node *)p;
    node *b=(node *)q;
    if(a->x==b->x) return a->y-b->y;
    return a->x-b->x;
}

int x,r;
int ans[100005];

priority_queue < node , vector <node> ,greater <node> > q; 

int main(){
    freopen("salesman.in","r",stdin);
    freopen("salesman.out","w",stdout);
    int n,i,j=1,k=1;
    cin>>n;
    for(i=1;i<=n;i++){
        scanf("%d",&house[i].x);
    }
    for(i=1;i<=n;i++){
        scanf("%d",&house[i].y);
        house[i].name=i;
        cpy[i].x=house[i].x;
        cpy[i].y=house[i].y;
        cpy[i].name=i;
    }
    qsort(house+1,n,sizeof(house[0]),cmp);
    qsort(cpy+1,n,sizeof(cpy[0]),cmp2);
    for(i=1;i<=n;i++){
        if(q.empty()||q.top().y<(house[j].x-x)*2+house[j].y){
            ans[i]=ans[i-1]+(house[j].x-x)*2+house[j].y;
            r=house[j].x;
            j++;
            while(cpy[k].x<r&&k<=n){
                q.push(cpy[k]);
                k++;
            }
            x=r;
        }else{
            ans[i]=ans[i-1]+q.top().y;
            q.pop();
        }
        while(house[j].x<x&&j<=n){
            j++;
        }
    }
    for(i=1;i<=n;i++)
        printf("%d\n",ans[i]);
    return 0;
}