nyoj 304 节能 【区间dp】

点击打开链接

节能

时间限制： 1000 ms  |  内存限制： 65535 KB

难度： 5

描述

Dr.Kong设计的机器人卡多越来越聪明。最近市政公司交给卡多一项任务，每天早晨5：00开始，它负责关掉ZK大道右侧上所有的路灯。

卡多每到早晨5：00准会在ZK大道上某盏路灯的旁边，然后他开始关灯。每盏灯都有一定的功率，机器人卡多有着自觉的节能意识，它希望在关灯期间，ZK大道右侧上所有路灯的耗电量总数是最少的。

机器人卡多以1m/s的速度行走。假设关灯动作不需要花费额外的时间，因为当它通过某盏路灯时就顺手将灯关掉。

请你编写程序，计算在给定路灯设置，灯泡功率以及机器人卡多的起始位置的情况下，卡多关灯期间，ZK大道上所有灯耗费的最小能量。

输入

有多组测试数据，以EOF为输入结束的标志
每组测试数据第一行： N 表示ZK大道右侧路灯的数量 （2≤ N ≤ 1000） 
第二行： V 表示机器人卡多开始关灯的路灯号码。 （1≤V≤N）
接下来的N行中，每行包含两个用空格隔开的整数D和W，用来描述每盏灯的参数

D表示该路灯与ZK大道起点的距离 (用米为单位来表示)，
W表示灯泡的功率，即每秒该灯泡所消耗的能量数。路灯是按顺序给定的。
（ 0≤D≤1000， 0≤W≤1000 ）

输出

输出一个整数，即消耗能量之和的最小值。注意结果小于200，000，000

样例输入

4 
3
2 2
5 8
6 1
8 7

样例输出

56

来源

第四届河南省程序设计大赛

思路，无非在关过灯的路径来回选择去哪边关灯。

我就左右枚举，但是wa了，还没找到错，想放起来，等有思路再写。

我写的暴力贪心。 

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int inf=0xfffffff;
const int maxn=1111;
int n,st;
struct node{
    int x,y;
}a[maxn];
int main(){
    while(~scanf("%d",&n)){
        ll ans=0,x=0;st=0;
        scanf("%d",&st);
        for(int i=1;i<=n;++i) scanf("%d %d",&a[i].x,&a[i].y);
        ll l=0,r=0,i=st-1,j=st+1;
        a[st].y=0;st=a[st].x;
        while(1<=i||j<=n){
            if(1<=i&&j<=n){
                l=(st-a[i].x)*a[i].y+(a[j].x-2*a[i].x+st)*a[j].y;
                r=(a[j].x-st)*a[j].y+(2*a[j].x-a[i].x-st)*a[i].y;
                if(l<=r){
                     x+=st-a[i].x;
                     ans+=x*a[i].y;
                     st=a[i].x;i--;
                }else{
                     x+=a[j].x-st;
                     ans+=x*a[j].y;
                     st=a[j].x;j++;
                }
            }else if(i<1&&j<=n){
                for(int k=j;k<=n;++k){
                    x+=a[k].x-st;
                    st=a[k].x;
                    ans+=x*a[k].y;
                }break;
            }else if(i>=1&&j>n){
                for(int k=i;k>=1;--k){
                    x+=st-a[k].x;
                    st=a[k].x;
                    ans+=x*a[k].y;
                }break;
            }
        }
        printf("%lld\n",ans);
    }
    return 0;
}

我好像知道那错了。 待我想想怎么写。

之前写的贪心， 从起点开始左右两个方向贪心。基本上已经很接近答案了。谁让我不会区间dp ，，

为此专门先跑去刷了一道区间dp入门试试水。

后来看了大神代码知道了把二维dp再开一维，dp[i][j][2]   dp[i][j][0]表示在区间【i，j】中关掉所有灯站在i端的总耗能。同理得dp[i][j][1]；

引入这个思想就思路明晰了。

区间合并，只用分成两部分，求最小值就行了。

#include<bits/stdc++.h>
#define ll long long
using namespace std;
const int inf=0xfffffff;
const int maxn=1111;
int n,st;
int dp[maxn][maxn][2];
int s[maxn],sum[maxn][maxn],sw;
int d[maxn],w[maxn];
int main(){
    while(~scanf("%d",&n)){
        scanf("%d",&st);sw=0;
        for(int i=1;i<=n;++i){
            scanf("%d %d",&d[i],&w[i]);
            s[i]=s[i-1]+w[i];
            sw+=w[i];
        }
        for(int i=1;i<=n;++i) for(int j=i;j<=n;++j) sum[i][j]=s[j]-s[i-1];
        for(int i=st-1;i>0;--i){
            dp[i][st][0]=dp[i+1][st][0]+(sw-sum[i+1][st])*(d[i+1]-d[i]);
            dp[i][st][1]=dp[i][st][0]+(sw-sum[i][st])*(d[st]-d[i]);
        }
        for(int j=st+1;j<=n;++j){
            dp[st][j][1]=dp[st][j-1][1]+(sw-sum[st][j-1])*(d[j]-d[j-1]);
            dp[st][j][0]=dp[st][j][1]+(sw-sum[st][j])*(d[j]-d[st]);
        }
        for(int i=st-1;i>=1;i--){
            for(int j=st+1;j<=n;++j){
                dp[i][j][0]=min(dp[i+1][j][0]+(d[i+1]-d[i])*(sw-sum[i+1][j]),dp[i+1][j][1]+(d[j]-d[i])*(sw-sum[i+1][j]));
                dp[i][j][1]=min(dp[i][j-1][1]+(d[j]-d[i])*(sw-sum[i][j-1]),dp[i][j-1][1]+(d[j]-d[j-1])*(sw-sum[i][j-1]));
            }
        }
        printf("%d\n",min(dp[1][n][1],dp[1][n][0]));
    }
    return 0;
}