hdu 4412 2012杭州赛区网络赛 期望

虽然dp方程很好写，就是这个期望不知道怎么求，昨晚的BC也是

题目问题抽象之后为：在一个x坐标轴上有N个点，每个点上有一个概率值，可以修M个工作站，

                     求怎样安排这M个工作站的位置，使得这N个点都走到工作站的距离期望值最小？

解题报告人：SpringWater(GHQ)

解题思路：状态方程：dp[i][j]  =  min{ dp[i - 1][k - 1]  + cost[k][j]   }dp[i][j]表示在1到j修i个站，的最小期望值，

                   cost【k】【j】是我预处理的k到j这段区间修一个工作站的期望值 ，因为在求cost【k】【j】具

                有单调性，所以可以在O（n^2）复杂度算出

#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<map>
#define INF ((1<<23)-1)
using namespace std;
map<int ,double> mp;
double f[1010][60];
typedef struct
{
    int x; double p;
}Point;
Point pt[1010];
int kk,m;

void initial()
{
    for(int i=0;i<=1000;i++)
        for(int j=0;j<=50;j++)
            f[i][j]=INF;
    for(int i=0;i<=m;i++)
        for(int j=i;j<=m;j++)
            f[i][j]=0.0;
}

int main()
{
    int k,i,j,l,x; double p;
    while( scanf("%d%d",&kk,&m),kk+m )
    {
        mp.clear();
        initial();
        for(i=1;i<=kk;i++)
        {
            scanf("%d",&l);
            for(j=1;j<=l;j++)
            {
                scanf("%d%lf",&x,&p);
                mp[x]+=p;
            }
        }
        map<int,double>::iterator it;
        j=1;
        for( it=mp.begin(); it!=mp.end();it++,j++)
        {
            pt[j].x=(it->first);
            pt[j].p=(it->second);
        }
        int n=j-1;
        for( i=1;i<=n;i++ )
        {
            for(j=1;j<=m && j<=i; j++ )
            {
                f[i][j]=INF;
                double pre=0.000,suf=0.000;
                int cur=i; double add=0.000;
                for(k=i-1;k>=j-1;k--)
                {
                    if( k+1 != i )
                    {
                        pre+=pt[k+1].p;
                        add+=pt[k+1].p*(pt[cur].x-pt[k+1].x);
                    }
                    while( pt[cur].p+suf < pre )
                    {
                        suf+=pt[cur].p;
                        cur--;
                        pre-=pt[cur].p;
                        add-=pt[cur].p*(pt[cur+1].x-pt[cur].x);
                        add+=pt[cur+1].p*(pt[cur+1].x-pt[cur].x);
                        add-=pre*(pt[cur+1].x-pt[cur].x);
                        add+=(suf-pt[cur+1].p)*(pt[cur+1].x-pt[cur].x);
                    }
                    f[i][j]=min(f[i][j],f[k][j-1]+add);
                }
            }
        }
        printf("%.2lf
",f[n][m]);
    }
    return 0;
}