邮局选址问题

邮局选址问题

题目描述

一条直线上有居民点，邮局只能建在居民点上。给定一个有序整形数组arr，每个值表示居民点的一维坐标，再给定一个正数num，表示邮局数量。

选择num个居民点建立num个邮局，使所有的居民点到邮局的总距离最短，返回最短的总距离。

输入描述：

第一行有两个整数N,num。分别表示居民点的数量，要建的邮局数量。
接下来一行N个整数表示邮局的坐标。保证坐标递增

输出描述：

输出一个整数表示答案

示例1

输入

6 2
1 2 3 4 5 1000

输出

6

说明

第一个邮局建立在3位置，第二个邮局建立在1000位置。那么1位置到邮局的距离为2,2位置到邮局距离为1,3位置到邮局的距离为0，4位置到邮局的距离为1,5位置到邮局的距离为2,1000位置到邮局的距离为0.
这种方案下的总距离为6。

备注：

$1⩽N⩽3000$
$1⩽num⩽N$

$1⩽\text{邮局坐标}⩽10000$

---

题解：

动态规划。首先从简单的模型开始：

若我们需要在 n 个点中选一个位置安放邮局，怎么放呢？坐标的中位数即可，奇数为中间位置，偶数任意两个中间位置之一即可。

回到这题上来，本质是对 n 个地址进行划分，划分成 num 段，每段一个邮局，求最小的距离。

那么 dp 方程就很明显了：设 $f[i][j]$ 表示 a[0…j] 安放 i+1 个邮局的最小距离，转移方程为：

f [ i ] [ j ] = m i n { f [ i − 1 ] [ k ] + c o s t [ k + 1 ] [ j ] ( 0 ⩽ k < n ) } f[i][j] = min \{ f[i-1][k] + cost[k + 1][j] (0 \leqslant k < n) \} f[i][j]=min{f[i−1][k]+cost[k+1][j](0⩽k<n)}

其中 $cost[k+1][j]$ 表示在 $a[k+1...j]$ 之中安放一个邮局的距离。

#include <cstdio>
#include <algorithm>

using namespace std;

const int N = 3001;

int n, num;
int w[N][N];
int x[N];
int f[N][N];

int main(void) {
    scanf("%d%d", &n, &num);
    for ( int i = 0; i < n; ++i )
        scanf("%d", x + i);
    for ( int i = 0; i < n; ++i ) {
        for ( int j = i + 1; j < n; ++j )
            w[i][j] = w[i][j - 1] + x[j] - x[i + j >> 1];
        f[0][i] = w[0][i];
    }
    for ( int i = 1; i < num; ++i ) {
        for ( int j = i + 1; j < n; ++j ) {
            f[i][j] = 1 << 30;
            for ( int k = 0; k <= j; ++k )
                f[i][j] = min( f[i][j], f[i - 1][k] + w[k + 1][j]);
        }
    }
    printf("%d\n", f[num - 1][n - 1]);
    return 0;
}

这样的话，对于该动态规划方程，时间复杂度为 $O(n^2\ast num)$，在本题上是无法通过的。。。

优化：

我们发现在求解 $f[i][j]$ 时，几乎枚举了所有的 $f[i-1][0...j]$ ，这个过程是可以使用四边形不等式优化的。

• 当邮局为 i-1 个，区间为 a[0…j] 时，如果在其最优划分方案中发现，邮局 $1\sim i-2$ 负责 a[0…l] ，邮局 i-1 负责 a[l+1…j] 。那么当邮局为 i 个，区间为 a[0…j] 时，如果想得到最优方案，邮局 $1\sim i-1$ 负责的区域不必尝试比 a[0…l] 小的区域，只需要尝试 $a[0...k](k⩾l)$。
• 当邮局为 i 个，区间为 a[0…j+1] 时，如果在其最优划分方案中发现，邮局 $1\sim i-1$ 负责 a[0…m] ，邮局 i 负责 a[m+1…j+1] 。那么当邮局为 i 个，区间为 a[0…j] 时，如果想得到最优方案，邮局 $1\sim i-1$ 负责的区域不必尝试比 a[0…m] 大的区域，只尝试 $a[0...k](k⩽m)$。

时间复杂度为 $O(n^2)$。

目前对四边形不等式优化大概有一个认识：通过确定枚举的上下界，优化动态规划中无用的重复枚举过程。

代码：

#include <cstdio>
#include <algorithm>

using namespace std;

const int N = 3001;

int n, num;
int w[N][N];
int x[N];
int f[N];
int s[N];

int main(void) {
    scanf("%d%d", &n, &num);
    for ( int i = 0; i < n; ++i )
        scanf("%d", x + i);
    for ( int i = 0; i < n; ++i ) {
        for ( int j = i + 1; j < n; ++j )
            w[i][j] = w[i][j - 1] + x[j] - x[i + j >> 1];
        f[i] = w[0][i];
    }
    
    int minK = 0, maxK = 0, cur = 0, t;
    for ( int i = 1; i < num; ++i ) {
        for ( int j = n - 1; j >= i; --j ) {
            cur = 1 << 30;
            minK = s[j];
            maxK = j == n - 1 ? n - 1 : s[j + 1];
            for ( int k = minK; k <= maxK; ++k ) {
                t = f[k] + w[k + 1][j];
                if ( t <= cur ) {
                    cur = t;
                    s[j] = k;
                }
            }
            f[j] = cur;
        }
    }
    printf("%d\n", f[n - 1]);
    return 0;
}