NOIP2015 T4 推销员 贪心+堆优化

前几天在学堆，这个数据结构貌似挺简单的，但是我看了很久啊QAQ...

今天算是搞懂了吧...于是想到了这道题...（当初悄悄咪咪看题解记得一点）

点我看题

放洛谷的题...

题意的话，大概就是有n个房子在一条直线上，每个房子有一个离起点的距离，还有一个价值。

然后n个询问，第 i 个表示选 i 个房子能得到的最大总价值。总价值指 最远距离*2+每一个推销房子的价值。

有一个前提，不多走路，也就是说这个最远距离必须是某个要推销的房子。

思路：我萌可以考虑一下贪心，对于第i个询问，是否可以从第 i-1 个询问的基础上来得到捏？

当然可以辣！（然而不会证明QAQ）

辣我萌就假装证明完了的样子，

所以第 i 个询问的答案只需要在第 i-1 的询问答案加上一个最优值，也就是选择一个地方进行推销。

我萌可以这样考虑，假设在第 i-1 个询问的答案为lastans，这个最优解当前的最远房子为max

然后分类讨论，对于一个房子 x ，如果在max左边（x<max），辣么这个房子对答案的影响为  a[x]。

 　　　　　　　　　　　　　　   如果在max右边（x>max），辣么这个房子对答案的影响为 s[x]*2+a[x]-s[max]*2。

所以我萌每次都在去枚举一重 x 找到影响最大的，然后输出 lastans+影响值。

并更新 lastans和max。

但对于100%的数据O(n^2)是要tle的，辣就想想优化。

找最大值！会想到很多数据结构都可以维护。这里我选了刚学的堆。当然有很大原因是因为之前看的题解是堆

如何去优化捏。这样考虑，对于 x<max 的情况建一个堆heap0，对于 x>max 的情况建一个堆heap1。

刚开始的时候把heap1这个堆初始为全部 s[i]*2+a[i]  (1≤i≤n) heap0这个堆初始为空。

然后每次查询前，如果heap1的堆首是<=max的就都删掉。

比较一下heap1的堆首和heap0的堆首，更新。

如果heap1的堆首更优，就把所有  没在heap0堆的且小于新max的都加入到heap0堆里。

这题我觉得题灰常的好啊QAQ，毕竟花了好久才搞出来...不过必须吐槽官方数据太弱了...

type
  node=record
      num:longint;
      id:longint;
  end;
var n,i,j:longint;
    num,lastans:longint;
    max,x:longint;
    s,a:array[0..100000]of longint;
    v:array[0..100000]of boolean;
    heap:array[0..100000,0..1]of node;

    tot,tot0:longint;
procedure swap(var a,b:node);
var t:node;
begin
  t:=a;a:=b;b:=t;
end;
procedure down(x,b:longint);
begin
  while x*2<=n do
  begin
    if heap[x*2,b].num>heap[x*2+1,b].num then
    begin
      if heap[x,b].num<heap[x*2,b].num then
      begin
        swap(heap[x,b],heap[x*2,b]);
        x:=x*2;
      end else break;
    end else
    begin
      if heap[x,b].num<heap[x*2+1,b].num then
      begin
        swap(heap[x,b],heap[x*2+1,b]);
        x:=x*2+1;
      end else break;
    end;
  end;
end;
procedure up(x:longint);
begin
  while x>1 do
  begin
    if heap[x div 2,0].num<heap[x,0].num then
    begin
      swap(heap[x div 2,0],heap[x,0]);
      x:=x div 2;
    end else break;
  end;
end;
procedure build(n:longint);
var i:longint;
begin
  for i:=n div 2 downto 1 do
  down(i,1);
end;
begin
  read(n);
  for i:=1 to n do
  read(s[i]);
  for i:=1 to n do
  read(a[i]);
  for i:=1 to n do
  begin
    heap[i,1].num:=s[i]*2+a[i];
    heap[i,1].id:=i;
  end;
  tot:=n;
  build(n);
  for i:=1 to n do
  begin
    while (heap[1,1].id<=max)and(tot>0) do
    begin
      heap[1,1].num:=0;
      swap(heap[1,1],heap[tot,1]);
      down(1,1);
      dec(tot);
    end;
    if (heap[1,0].num+lastans>num) then
    begin
      num:=lastans+heap[1,0].num;
      x:=heap[1,0].id;
    end;
    if heap[1,1].num+lastans-s[max]*2>num then
    begin
      num:=heap[1,1].num+lastans-s[max]*2;
      x:=heap[1,1].id;
      for j:=1 to x-1 do
      if not v[j] then
      begin
        v[j]:=true;
        inc(tot0);
        heap[tot0,0].num:=a[j];
        heap[tot0,0].id:=j;
        up(tot0);
      end;
      max:=x;
    end;
    writeln(num);
    lastans:=num;
    if x<max then
    begin
      heap[1,0].num:=0;
      swap(heap[1,0],heap[tot0,0]);
      down(1,0);
      dec(tot0);
    end;
  end;
end.

//堆的维护都是自己写的，很丑啊QAQ