Cross the Wall HDU3669 斜率优化DP

纠结了近一个星期,泪奔~~

题意:

给你n个矩形,长宽已知,求用不超过k个大矩形包含所有给定矩形,使得大矩形总面积和最小.

题解:

  首先DP显然,有状态转移方程:dp[i][k]=min(dp[j][k-1]+w[j+1].y*w[i].x) (k-1<=j<=i-1)
     令w[j+1].y=y,dp[j][k-1]=x,w[i].x=k;
      yy=x+ky,求min yy
      y=-(1/k)x+yy即斜率为k,过点(x,y)(有好多对(x,y))的直线的最小纵坐标截距
   所以可以斜率优化,用单调队列维护类似U左半部分的一个凸包,每个状态最多进出1次,所以总时间复杂度O(nk).

总结一下凸包维护规律:

   斜率为负,从小到大,维护U左半部分凸包,求最小y截距

   斜率为负,从大到小,维护倒U右半部分凸包,求最大y截距

   斜率为正,从小到大,维护U右半部分凸包,求最小y截距

   斜率为正,从大到小,维护倒U左半部分凸包,求最大y截距

/*
 * File:   main.cpp
 * Author: swordholy
 *
 * Created on 2011年3月13日, 下午5:54
 */


#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<memory.h>
using namespace std;
#define N 50005
#define K 105
const long long INF = 1LL<<60;
struct WALL
{
  long long x,y;
  bool operator <(const WALL & rhs) const
  {
    if (x<rhs.x) return true;
    else if (x>rhs.x) return false;
         else return (y<rhs.y);
  }
};
WALL a[N],w[N];
long long dp[N][2];
long long head,tail;
struct pt
{
  long long x,y;
};
pt q[N];
int pre,now;
bool judge(int head,int i)
{
   if ((q[head].y-q[head+1].y)*w[i].x>q[head+1].x-q[head].x) return true;
    else return false;
}
int main()
{
  int n,m,i,j,ln,k;
  long long ans,nowx,nowy;
  while(scanf("%d%d",&n,&m)!=EOF)
  {
     for(i=1;i<=n;i++)
      {
        scanf("%lld%lld",&a[i].x,&a[i].y);
         //cin>>a[i].x>>a[i].y;
      }
    sort(a+1,a+1+n);
     ln=1;
     w[1]=a[1];
     for(i=2;i<=n;i++)
      {
       while(ln>=1&&w[ln].y<=a[i].y) ln--;
       w[++ln]=a[i];
      }
     n=ln;now=0;pre=1;ans=INF;
     //dp[i][k]=min(dp[j][k-1]+w[j+1].y*w[i].x) k-1<=j<=i-1
     //令w[j+1].y=y,dp[j][k-1]=x,w[i].x=k;
     //yy=x+ky,求min yy
     //y=-(1/k)x+yy即斜率为k,过点(x,y)(有好多对(x,y))的直线的最小纵坐标截距
     //memset(dp,-1,sizeof(dp));
     //维护类似U左半部分的一个凸包
     for(i=0;i<=n;i++)
       {
         dp[i][now]=INF;
         dp[i][pre]=INF;
       }
    dp[0][pre]=0;
     for(k=1;k<=m;k++)
      {

         head=1;tail=0;
       tail++;
       q[tail].x=dp[k-1][pre];
       q[tail].y=w[k].y;
       for(i=k;i<=n;i++)
        {

           while(head+1<=tail && judge(head,i) ) head++;
          //dp[i][now]=y+kx;
           dp[i][now]=q[head].x+q[head].y*w[i].x;
           nowx=dp[i][pre];nowy=w[i+1].y;
          while(head+1<=tail && (q[tail].x-nowx)*(q[tail-1].y-nowy)-(q[tail-1].x-nowx)*(q[tail].y-nowy)>=0 ) tail--;
          q[++tail].x=nowx;q[tail].y=nowy;
        }
       ans=min(ans,dp[n][now]);
       now=1-now;
       pre=1-pre;
      }
     cout<<ans<<endl;
  }
}