Uva-1336-Fixing the Great Wall

这个题大意是给你一些需要修复位置的坐标，以及修复他们的费用和等待单位时间所产生的费用，让你求出最少的费用将所有位置修复。

 思路：

首先应该对X进行离散化并进行排序，然后每次修复的时候肯定是以区间进行修复的，所以用dp[i][j][k]表示修复区间i->j，并且当前位置在k所产生的最少费用

代码：

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
using namespace std;
const int inf=1<<29;
const int maxn=1100;
struct Node
{
    int x;
    int c;
    int d;
    bool operator < (const Node &a)const{
        return x<a.x;
    }
}a[maxn];
int n,v,x,X[maxn],cntx,sum[maxn];
double dp[maxn][maxn][2];
void Init()
{
    for(int i=1;i<=n;i++)
        sum[i]=sum[i-1]+a[i].d;
    for(int i=0;i<=n;i++)
        for(int j=i;j<=n;j++)
            dp[i][j][0]=dp[i][j][1]=inf;
}
void solve()
{
    Init();
    for(int i=1;i<=n;i++)
    {
        double t=abs(X[a[i].x]-x)*1.0/v;
        dp[i][i][0]=dp[i][i][1]=(sum[i]-sum[0])*t+(sum[n]-sum[i])*t+a[i].c;
    }
    for(int j=1;j<=n;j++)
        for(int i=1;i+j<=n;i++)
        {
            dp[i][i+j][0]=min(dp[i+1][i+j][0]+(abs(X[a[i].x]-X[a[i+1].x])*1.0/v)*(sum[i]-sum[0]+sum[n]-sum[i+j])+a[i].c,
                    dp[i+1][i+j][1]+(abs(X[a[i+j].x]-X[a[i].x])*1.0/v)*(sum[i]-sum[0]+sum[n]-sum[i+j])+a[i].c);
            dp[i][i+j][1]=min(dp[i][i+j-1][1]+(abs(X[a[i+j].x]-X[a[i+j-1].x])*1.0/v)*(sum[i-1]-sum[0]+sum[n]-sum[i+j-1])+a[i+j].c,
                    dp[i][i+j-1][0]+(abs(X[a[i].x]-X[a[i+j].x])*1.0/v)*(sum[i-1]-sum[0]+sum[n]-sum[i+j-1])+a[i+j].c);
        }
    int ans=min(dp[1][n][0],dp[1][n][1]);
    printf("%d\n",ans);
}
int main()
{
    while(scanf("%d%d%d",&n,&v,&x)!=EOF)
    {
        if(n+v+x==0)
            break;
        cntx=0;
        X[cntx++]=x;
        for(int i=1;i<=n;i++)
        {
            scanf("%d%d%d",&a[i].x,&a[i].c,&a[i].d);
            X[cntx++]=a[i].x;
        }
        sort(X,X+cntx);
        cntx=unique(X,X+cntx)-X;
        for(int i=1;i<=n;i++)
            a[i].x=lower_bound(X,X+cntx,a[i].x)-X;
        sort(a+1,a+n+1);
        solve();
    }
    return 0;
}