洛谷P1220 关路灯（DP或深搜）

最新推荐文章于 2022-08-11 16:47:40 发布

Berton2L

最新推荐文章于 2022-08-11 16:47:40 发布

阅读量586

点赞数

CC 4.0 BY-SA版权

分类专栏： DP DFS 文章标签： dp 深搜

本文链接：https://blog.csdn.net/earnMoney/article/details/78328178

DP 同时被 2 个专栏收录

13 篇文章

订阅专栏

DFS

8 篇文章

订阅专栏

本文详细解析洛谷P1220关路灯问题，介绍如何利用动态规划或深度优先搜索策略来确定最佳关灯顺序，以最小化功耗。

洛谷P1220 关路灯（DP或深搜）

题目描述

某一村庄在一条路线上安装了n盏路灯，每盏灯的功率有大有小（即同一段时间内消耗的电量有多有少）。老张就住在这条路中间某一路灯旁，他有一项工作就是每天早上天亮时一盏一盏地关掉这些路灯。
为了给村里节省电费，老张记录下了每盏路灯的位置和功率，他每次关灯时也都是尽快地去关，但是老张不知道怎样去关灯才能够最节省电。他每天都是在天亮时首先关掉自己所处位置的路灯，然后可以向左也可以向右去关灯。开始他以为先算一下左边路灯的总功率再算一下右边路灯的总功率，然后选择先关掉功率大的一边，再回过头来关掉另一边的路灯，而事实并非如此，因为在关的过程中适当地调头有可能会更省一些。
现在已知老张走的速度为1m/s，每个路灯的位置（是一个整数，即距路线起点的距离，单位：m）、功率（W），老张关灯所用的时间很短而可以忽略不计。
请你为老张编一程序来安排关灯的顺序，使从老张开始关灯时刻算起所有灯消耗电最少（灯关掉后便不再消耗电了）。

输入输出格式

输入格式：

文件第一行是两个数字n(0<n<50，表示路灯的总数)和c(1<＝c<=n老张所处位置的路灯号)；
接下来n行，每行两个数据，表示第1盏到第n盏路灯的位置和功率。

输出格式：

一个数据，即最少的功耗(单位：J，1J＝1W·s)。

输入输出样例

输入样例#1：

5 3
2 10
3 20
5 20
6 30
8 10

输出样例#1：

270

说明

输出解释：
{此时关灯顺序为3 4 2 1 5，不必输出这个关灯顺序}

解题分析

可以用动态规划或深搜解。

方法一动态规划

考虑区间[i, j]内的路灯全部关闭，其他路灯都没有关闭时所消耗的功率。
对于每一个区间，所消耗的功率不仅与区间长度（所包含的路灯的数量）有关，而且与老张当前所处的位置有关，当然，老张只能处于区间的两个端点处，因此构造状态如下：
f[i][j][2]，表示在区间[i, j]中所消耗的功率数，具体说，就是当区间[i, j]中的所有等都已经关闭，且其他灯都没有关闭时所消耗的总功率，这里的总功率是指所有路灯消耗的功率总和。f[i][j][0]表示当前老张在i处，f[i][j][1]表示老张在j处。
对于f[i][j][0]，该状态可以由区间[i+1, j]的状态获得，如果老张在[i+1, j]状态时在i+1处，则只需要向左走一步就能到达f[i][j][0]，且增加的功率为所走的距离dis[i][i+1]与除区间[i+1, j]之外的其他路灯的总功率的乘积；同样，如果老张在[i+1, j]的j处，则走到i出需要走的距离为dis[i][j]，增加的总功率为dis[i][j]与除区间[i+1, j]之外的其他路灯的总功率的乘积。f[i][j][0]为上述两者中的较小者，即：
f[i][j][0] = min(f[i+1][j][0] + dis[i][i+1]*get_remain(i+1, j), f[i+1][j][1] + dis[i][j]*get_remain(i+1, j)
其中，get_remain(i+1, j)为除区间[i+1, j]的其他所有路灯的功率之和。
同样可以得到：
f[i][j][1] = min(f[i][j-1][0] + dis[i][j]*get_remain(i, j-1), f[i][j-1][1] + dis[j-1][j]*get_remain(i, j-1)
可以从区间长度gap（所包含的路灯数量）为2开始计算每一个状态的值。gap最多为n。
初始值：对于gap为1的情形需要给定初始值，对于出发点c，可设f[c][c][0]和f[c][c][1]都为0（因为关灯不需要耗费时间），而对于其他位置，都设置f[i][i][0]和f[i][i][1]为一个较大的值。
最终结果为f[1][n][0]和f[1][n][1]中较小者。

方法二深搜

从每一个位置出发，都有两个方向可走：向左和向右，因此形成一个搜索树，对该搜索树进行深搜即可。
在深搜过程中，需要记录如下几个数据：
1、当前的位置，即老张当前处于什么位置now。
2、当前已关灯的区间的左端点le和右端点re，则从当前位置可以有两个选择，向左走到le-1或向右走到re+1。
3、未关灯的功率总和all_w，则当从now走到下一个位置next(其值为le-1或re+1)时，所增加的功耗为dis[now][next]*all_w，当关闭一个灯时，all_w需要减去该灯的功率。
4、关闭等的数量step，当所有等全部关闭时，本轮搜索结束。

剪枝：当所得到的结果已大于已有的结果时，结束本轮搜索。

#include 
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
#define MIN(a, b) ((a)<(b)?(a):(b))
int n, c,
    f[52][52][2],   // f[i][j][0]：区间[i, j]内的路灯关闭时消耗的总功率，且当前老张在i处
    // f[i][j][0]：区间[i, j]内的路灯关闭时消耗的总功率，且当前老张在j处
    dis[52][52], sum[52]= {0};

struct node {
    int d;
    int w;
    void set(int d1, int w1) {
        d = d1;
        w = w1;
    }
} light[52];

void get_i(int &x) {
    char ch = getchar();
    x = 0;
    while(!isdigit(ch)) ch = getchar();
    while(isdigit(ch)) {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
}
// 闭区间[x, y]之外的路灯的功率总和
int get_remain(int x, int y) {
    return sum[n] - (sum[y] - sum[x-1]);
}

void resolve() {
    int gap, i, j;
    for(gap=2; gap<=n; gap++) { // 区间的间距
        for(i=1; j=i+gap-1, j<=n; i++) { // i:区间的左端点 j:区间的右端点
            f[i][j][0] = MIN(f[i+1][j][0] + dis[i+1][i]*get_remain(i+1, j),
                             f[i+1][j][1] + dis[i][j]*get_remain(i+1, j));
            f[i][j][1] = MIN(f[i][j-1][0] + dis[i][j]*get_remain(i, j-1),
                             f[i][j-1][1] + dis[j][j-1]*get_remain(i, j-1));
        }
    }
    cout<
#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
int n, c, ans = 0x7fffffff, dis[52][52];
struct node {
    int d;
    int w;
    void set(int d1, int w1) {
        d = d1;
        w = w1;
    }
} light[52];

void get_i(int &x) {
    char ch = getchar();
    x = 0;
    while(!isdigit(ch)) ch = getchar();
    while(isdigit(ch)) {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
}

int le, ri, tot, t, all_w;
void dfs(int now, int step) {
    if(ans < tot) // 剪枝
        return;
    if(step == n) {
        if(ans > tot)
            ans = tot;
        return;
    }
    if(le - 1 > 0) {
        le--;
        tot += all_w * dis[le][now];
        all_w -= light[le].w;
        dfs(le, step+1);
        all_w += light[le].w;
        tot -= all_w * dis[le][now];
        le++;
    }

    if(ri+1<=n) {
        ri++;
        tot += all_w * dis[ri][now];
        all_w -= light[ri].w;
        dfs(ri, step+1);
        all_w += light[ri].w;
        tot -= all_w * dis[ri][now];
        ri--;
    }
}

int main() {
    ios::sync_with_stdio(false);
    int i, j, d, w;
    get_i(n), get_i(c);
    for(i=1; i<=n; i++) {
        get_i(d), get_i(w);
        light[i].set(d, w);
        all_w += w;
    }
    all_w -= light[c].w;
    for(i=1; i