poj3666

一道不错的dp题

就是最小修改代价，使序列变为一个非下降序或非上升（由于数据较弱直接求非下降即可，当然非上升非下降本质是一样的）

观察可得到，修改后得到的数列中的元素最后一定都在原序列中；

由此我们可以将原数列排序离散化；

在dp[i,j]表示新序列到第i个元素修改成原序列第j小的数所用的代价

易得dp[i,j]=min(dp[i-1,k])+abs(p[i]-a[j]) (1<=k<=j)； a是原数列，p是排序后的

由于n<=1000 看起来这样的方程式O(n^3)会超时；

实际上，我们在处理的时候，完全可以优化成O(n^2);

由于abs(p[i]-a[j])是一个定值，不受k影响，所以我们可以先用dp[i,j]表示min(dp[i-1,k]) (1<=k<=j)

则dp[i,j+1]=min(d[i,j],d[i-1,j]);

最后再集体加上abs(p[i]-a[j])即可实现O(n^2)

var f:array[0..1,0..2010] of longint;
    a,p:array[0..2010] of longint;
    n,i,k1,k2,j,ans:longint;

procedure swap(var a,b:longint);
  var c:longint;
  begin
    c:=a;
    a:=b;
    b:=c;
  end;

function min(a,b:longint):longint;
  begin
    if a>b then exit(b) else exit(a);
  end;

procedure sort(l,r: longint);
  var i,j,x: longint;
  begin
    i:=l;
    j:=r;
    x:=a[(l+r) div 2];
    repeat
      while a[i]<x do inc(i);
      while x<a[j] do dec(j);
      if not(i>j) then
      begin
        swap(a[i],a[j]);
        inc(i);
        j:=j-1;
      end;
    until i>j;
    if l<j then sort(l,j);
    if i<r then sort(i,r);
  end;

begin
  readln(n);
  for i:=1 to n do
  begin
    readln(a[i]);
    p[i]:=a[i];
  end;
  sort(1,n);
  k1:=1;
  k2:=0;
  for i:=1 to n do
  begin
    k1:=k1 xor 1;
    k2:=k2 xor 1;
    f[k2,1]:=f[k1,1];
    for j:=2 to n do
      f[k2,j]:=min(f[k2,j-1],f[k1,j]);
    for j:=1 to n do
      f[k2,j]:=f[k2,j]+abs(p[i]-a[j]);
  end;
  ans:=2147483647;
  for i:=1 to n do
    ans:=min(f[k2,i],ans);
  writeln(ans);
end.