[poj1160][IOI2000]Post Office【动态规划】

传送门

https://vjudge.net/problem/POJ-1160#author=SCU2018

题目描述

在一条水平的公路上建有n个小屋，两个小屋间的距离是它们的横坐标之差的绝对值。保证小屋的横坐标是整数，以及没有两个小屋建立在同一位置。现在需要建立m所加油站(m<=n)，加油站只能建立在小屋所在的位置。
现在需要你写个程序，给定了所有小屋的位置和加油站的数目，计算出每个小屋离最近的加油站的距离总和的最小值。
翻译来自vjudge

分析

是一道非常经典的题目，数据范围中给出了一点提示，n<=300，说明我们可以用时间复杂度\(O(n^3)\)的算法。
但是这个只是第一步，最重要的是状态和转移方程。
一眼就可以知道定义状态为\(f[i][j]\)为前\(i\)个小屋，建立\(j\)个加油站的最小距离。
那么转移方程需要决策退出，很经典的想法就是思考前一个加油站建在哪里，我们需要枚举一个\(k\)，也就是前一个状态时\(f[k][i-1]\)意思就是需要当前\(1~k\)的小屋建一个加油站，那么我们需要剩下来需要的部分就是区间\([k+1,i]\)，那么考虑一下，我们需要在O(1)的时间内求出在\([k+1,i]\)建一个加油站的最小距离和，这又是一个DP。状态定义就是\(g[i][j]\)表示在区间\([i,j]\)内只建立一个加油站的最小距离和。其实也不能这个不能严格算是一个DP，因为我们知道如果要距离之和最小，那么一定是在中间位置，那么我们只需要线性递推出距离就可以了。

---

当天晚上更新一下，因为我怕自己解释不清楚，所以就重新来解释一下\(g\)数组，也就是最短距离和数组是如何求解的。
非常清楚的是\(g[i][j]\)如果是暴力求解枚举两个端点，然后在枚举一个区间内的一个点，然后去最小值，但是明显常数太大。
但是很明显就可以得到一个类似于DP的递推式。考虑最后一个j对于答案的贡献，因为很明显我们答案一定是在中间的某一个点，那么建立加油站的点一定是在\((i+j)/2\)这个地方，那么这个距离就是\(g[i][j-1]+a[j]-a[(i+j)/2]\)。这样我们就把一个三维的转移降到了两维了。

---

那么考虑DP的边界，\(f[i][1]=g[1][i]\)，意思就是。。好像没有什么意思，两者的意义好像本身就是一样的。

---

总结一下：\(f[i][j]\)表示前i个小屋，建立j个加油站的最小距离。
用\(O(n^2)\)的时间预处理出\(g[i][j]\)表示第i个小屋到第j个小屋只建立一个加油站的最小距离和。
g数组的计算如上面所讲，那么对于f数组，转移方程式就是\(f[i][j]=min(f[i][j],f[k][j-1],g[k+1][i])\)

---

万恶的poj还是不能用万能头，吐槽吐槽吐槽（有生之年能看到poj能用bits吗？）

ac代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#define ll long long
#define ms(a, b) memset(a, b, sizeof(a))
#define inf 0x3f3f3f3f
#define N 305
using namespace std;
template <typename T>
inline void read(T &x) {
    x = 0; T fl = 1;
    char ch = 0;
    while (ch < '0' || ch > '9') {
        if (ch == '-') fl = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    x *= fl;
}
int n, m;
int f[N][N], dis[N][N];
int a[N];
int main() {
    while (scanf("%d%d", &n, &m) != EOF) {
        for (int i = 1; i <= n; i ++) read(a[i]);
        for (int i = 1; i <= n; i ++) 
            for (int j = i + 1; j <= n; j ++) 
                dis[i][j] = dis[i][j - 1] + a[j] - a[(i + j) / 2];
        ms(f, inf);
        for (int i = 1; i <= n; i ++) 
            f[i][1] = dis[1][i];
        for (int i = 2; i <= m; i ++) {
            for (int j = i; j <= n; j ++)
                for (int k = i - 1; k <= j - 1; k ++) {
                    f[j][i] = min(f[j][i], f[k][i - 1] + dis[k + 1][j]);
                }
        }
        printf("%d\n", f[n][m]);
    }
    return 0;
}

---

update/2019/3/24但是我把程序交到洛谷上去之后就T掉了，发现洛谷数据开大了10倍。
所以坑定是要考虑优化了。
回到原来的式子：
\[f[i][j]=min(f[i][j],f[k][j-1],g[k+1][i])\]
感觉长的非常像石子合并的方程。
打表发现（原谅我比较弱）：满足\(f[a][c]+f[b][d]<=f[a][d]+f[b][d]\)
而且决策单调。
那么我们就考虑四边形不等式优化。
那么就可以从\(f[i][j-1]\)和状态\(f[i+1][j]\)转移过来。

代码

#include <cstdio>
#include <cstring>
#include <algorithm>
#define ll long long
#define ms(a, b) memset(a, b, sizeof(a))
#define inf 0x3f3f3f3f
#define N 3005
using namespace std;
template <typename T>
inline void read(T &x) {
    x = 0; T fl = 1;
    char ch = 0;
    while (ch < '0' || ch > '9') {
        if (ch == '-') fl = -1;
        ch = getchar();
    }
    while (ch >= '0' && ch <= '9') {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    x *= fl;
}
int n, m;
int f[N][N], dis[N][N], s[N][N];
int a[N];
int main() {
    while (scanf("%d%d", &n, &m) != EOF) {
        for (int i = 1; i <= n; i ++) read(a[i]);
        for (int i = 1; i <= n; i ++) 
            for (int j = i + 1; j <= n; j ++) 
                dis[i][j] = dis[i][j - 1] + a[j] - a[(i + j) / 2];
        ms(f, inf);
        for (int i = 1; i <= n; i ++) 
            f[i][1] = dis[1][i];
        for (int i = 2; i <= m; i ++) {
            s[n + 1][i] = n;
            for (int j = n; j >= 1; j --) 
                for (int k = s[j][i - 1]; k <= s[j + 1][i]; k ++) 
                    if (f[k][i - 1] + dis[k + 1][j] < f[j][i]) {
                        f[j][i] = f[k][i - 1] + dis[k + 1][j];
                        s[j][i] = k;
                    }
        }
        printf("%d\n", f[n][m]);
    }
    return 0;
}

转载于:https://www.cnblogs.com/chhokmah/p/10574625.html