洛谷 P1220 关路灯 （Java 动态规划）

题目描述

某一村庄在一条路线上安装了 n 盏路灯，每盏灯的功率有大有小（即同一段时间内消耗的电量有多有少）。老张就住在这条路中间某一路灯旁，他有一项工作就是每天早上天亮时一盏一盏地关掉这些路灯。

为了给村里节省电费，老张记录下了每盏路灯的位置和功率，他每次关灯时也都是尽快地去关，但是老张不知道怎样去关灯才能够最节省电。他每天都是在天亮时首先关掉自己所处位置的路灯，然后可以向左也可以向右去关灯。开始他以为先算一下左边路灯的总功率再算一下右边路灯的总功率，然后选择先关掉功率大的一边，再回过头来关掉另一边的路灯，而事实并非如此，因为在关的过程中适当地调头有可能会更省一些。

现在已知老张走的速度为 1m/s，每个路灯的位置（是一个整数，即距路线起点的距离，单位：m）、功率（W），老张关灯所用的时间很短而可以忽略不计。

请你为老张编一程序来安排关灯的顺序，使从老张开始关灯时刻算起所有灯消耗电最少（灯关掉后便不再消耗电了）。

输入格式

第一行是两个数字 n（表示路灯的总数）和 c（老张所处位置的路灯号）；

接下来 n 行，每行两个数据，表示第 1 盏到第 n 盏路灯的位置和功率。数据保证路灯位置单调递增。

输出格式

一个数据，即最少的功耗（单位：J，1J =1W × s）。

题目链接：关路灯

思路：

从题中关灯时间不计可知只要路过某个路灯就表示它关了，假设用dp[i][j]表示关闭第 i 到第 j 个路灯的最小耗能。这道题类似区间dp问题，先上模板：（模板例题：石子合并）

for (int len = 2; len <= n; len++) {         // 区间长度
    for (int i = 1; i + len - 1 <= n; i++) { // 区间起点
        int j = i + len - 1;                 // 区间终点

        for (int k = i; k < j; k++) {        // 枚举分割点，构造状态转移方程
            dp[i][j] = min(dp[i][j], dp[i][k] + dp[k + 1][j] + 合并区间的消耗);
        }
    }
}

然后它又可能是沿着上一次的的方向走下去，或者是选择了掉头，为记录掉头和沿着走，我们可以增加一维空间，存储上一次状态老张在 i 点还是 j 点。这里dp[i][j][0]表示关完 i 到 j 个路灯老张站在最左边，即 i 点，dp[i][j][1]则代表老张站在最右边，即 j 点。

因此dp[i][j][0]表示上个状态往左走的，所以一定是dp[i+1][j][0]沿着走或者dp[i+1][j][1]掉头来的，那么dp[i][j][1]一定是dp[i][j-1][0]掉头或者dp[i][j-1][1]沿着走转移来的，它的区间分割状态只有两种，所以我们这里不需要区间分割点k，这是和模板的不同点，即变为：

for (int len = 2; len <= n; len++) {         // 区间长度
    for (int i = 1; i + len - 1 <= n; i++) { // 区间起点
        int j = i + len - 1;                 // 区间终点

        f[i][j][0]=min(f[i+1][j][0]+对应消耗,f[i+1][j][1]+对应消耗);
        f[i][j][1]=min(f[i][j-1][0]+对应消耗,f[i][j-1][1]+对应消耗);
    }
}

每次关完 i 到 j 后我们还要计算其他未关的路灯耗能多少，加上已关完路灯消耗的总耗能就是本次的耗能，对于未关路灯的总耗能，我们可以用前缀和来计算，sum[i]表示第一个到第i个路灯的总功率。这里我们可以用一个函数count()来计算总耗能。

    public static int count(int x, int y, int l, int r, int n) {
		return (po[y]-po[x]) * (sum[n]-sum[r]+sum[l-1]);
	}

其中 x 和 y 是从第 y 个路灯走到第 x 个路灯，po数组是各自距起点的距离，po[y]-po[x]就是走的距离，速度1m/s，所以它又可以代表消耗的时间，l 和 r 表示第 l 个到第 r 个路灯是关闭的，n 是路灯总数，sum[n]-sum[r]代表已关区间右边未关的灯的总功率sum[l-1]就是左边未关的灯的总功率，再乘以时间就是未关的灯消耗的总功率

所以得到状态转移方程：

dp[i][j][0] = min(dp[i+1][j][0] + count(i, i+1, i+1, j, n),  dp[i+1][j][1] + count(i, j, i+1, j, n));

dp[i][j][1] = min(dp[i][j-1][0] + count(i, j, i, j-1, n), dp[i][j-1][1] + count(j-1, j, i, j-1, n));

设置初态dp[c][c][0] = dp[c][c][1] = 0，因为起点可以直接关灯，不消耗时间和功率。

代入模板：

for (int len = 2; len <= n; len++) {
	for (int i = 1; i+len-1 <= n; i++) {
		int j = i+len-1;
		dp[i][j][0] = Math.min(dp[i+1][j][0] + count(i, i+1, i+1, j, n), 
				dp[i+1][j][1] + count(i, j, i+1, j, n));
		dp[i][j][1] = Math.min(dp[i][j-1][0] + count(i, j, i, j-1, n),
				dp[i][j-1][1] + count(j-1, j, i, j-1, n));
	}
}

最后输出dp[1][n][0] 和dp[1][n][1] 的较大值即可。

完整代码：

import java.util.Scanner;
public class Main {
	static int[][][] dp = new int[51][51][2];
	static int[] po = new int[51];
	static int[] sum = new int[51];
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt(), c = sc.nextInt();
		for (int i = 1; i <= n; i++) {
			po[i] = sc.nextInt();
			sum[i] = sum[i-1] + sc.nextInt();//计算前缀和
		}
		for (int i = 1; i <= n; i++) 
			for (int j = 1; j <= n; j++) 	//将dp数组都初始化为一个超大的值，因为我们求的是最小功耗
				dp[i][j][0]=dp[i][j][1] = Integer.MAX_VALUE/3;
		dp[c][c][0] = dp[c][c][1] = 0;	//初始位置的功耗为0
		for (int len = 2; len <= n; len++) {
			for (int i = 1; i+len-1 <= n; i++) {
				int j = i+len-1;
				dp[i][j][0] = Math.min(dp[i+1][j][0] + count(i, i+1, i+1, j, n), 
						dp[i+1][j][1] + count(i, j, i+1, j, n));
				dp[i][j][1] = Math.min(dp[i][j-1][0] + count(i, j, i, j-1, n),
						dp[i][j-1][1] + count(j-1, j, i, j-1, n));
			}
		}
		System.out.println(Math.min(dp[1][n][0], dp[1][n][1]));
	}
	public static int count(int x, int y, int l, int r, int n) {
		return (po[y]-po[x]) * (sum[n]-sum[r]+sum[l-1]);
	}
}