圆形牛棚

圆形牛棚

作为当代建筑的爱好者，农夫约翰建造了一个完美圆环形状的新牛棚。

牛棚内部有$n$个房间，围成一个环形，按顺时针编号为$1 \sim n$，所有相邻房间之间的距离均为$1$。

每个房间都既有通向相邻两个房间的门，也有通向牛棚外部的门。

约翰想让第$i$个房间内恰好有$r_{i}$头牛。

为了让奶牛们有序的进入牛棚，他计划打开一个外门，让牛从该门进入。

然后，每头牛顺时针(即当$i<n$时，第$i$个房间只能走到第$i+1$个房间；当$i=n$时，第$i$个房间只能走到第$1$个房间)穿过房间，直到到达合适的房间为止。

约翰希望通过合理选择打开的门，使得所有奶牛的行走距离之和尽可能小（这里只考虑每头牛进入牛棚以后的行走距离）。

请确定他的奶牛需要行走的最小总距离。

输入格式

第一行包含整数$n$。

接下来$n$行，包含$r_{1}$,...,$r_{n}$。

输出格式

输出所有奶牛需要行走的最小总距离。

数据范围

$3 \leq n \leq 1000$,

$1 \leq r_{i} \leq 100$

输入样例：

5
4
7
8
6
4

输出样例：

48

样例解释

最佳方案是让奶牛们从第二个房间进入。

 

解题思路

　　题意大概就是，选择一个房间作为入口，则代价就是每个房间牛的数量乘上该房间到入口房间的距离。

　　例如，如果我们选择$r_{0}$作为入口，则代价大小为$r_{0} \cdot 0 + r_{1} \cdot 1 + r_{2} \cdot 2 + ... + r_{n - 1} \cdot \left( {n - 1} \right)$。

　　如果我们选择$r_{1}$作为入口，则代价大小为$r_{1} \cdot 0 + r_{2} \cdot 1 + ... + r_{n - 1} \cdot \left( {n - 2} \right) + r_{0} \cdot \left( {n - 1} \right)$。以此类推。

　　所以我们有个最朴素的做法，就是枚举所有牛棚将其选择作为入口，然后总代价又可以通过$O\left( n \right)$的复杂度算出来，所以整个算法的时间复杂度为$O\left( n^{2} \right)$。

　　需要注意的是需要对每个牛棚的下标编号进行取模$n$。当枚举到下标$n - 1$时，因为顺时针走动，因此下一个牛棚的下标编号应该为$0$。

　　AC代码如下：

#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 1010;

int a[N];

int main() {
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%d", a + i);
    }

    int ans = 5e7;
    for (int i = 0; i < n; i++) {
        int ret = 0;
        for (int j = 1; j < n; j++) {
            ret += a[(i + j) % n] * j;
        }
        ans = min(ans, ret);
    }

    printf("%d", ans);

    return 0;
}

　　下面进行优化，讲讲时间复杂度为$O\left( n \right)$的算法思路和实现。

　　我们先把$n$个牛棚列出来，同时把每个牛棚到入口的距离列出来。

　　下面我们定义$P_{0}$为选择$r_{0}$为入口的总代价，即$P_{0} = r_{0} \cdot 0 + r_{1} \cdot 1 + ... + r_{n - 2} \cdot \left( {n - 2} \right) + r_{n - 1} \cdot \left( {n - 1} \right)$。

　　接下来我们考虑一下$P_{1}$怎么算，也就是怎么用$P_{0}$来表示。可以发现，在上图中，用第$2$行减去第$1$行就可以得到$P_{1} - P_{0}$的表达式，即 $$\begin{align*} P_{1} &= P_{0} + \left( {n - 1} \right) \cdot r_{0} - \left( {r_{1} + r_{2} + ... + r_{n - 1}} \right) \\ &= P_{0} + n \cdot r_{0} - \left( {r_{0} + r_{1} + r_{2} + ... + r_{n - 1}} \right) \\ &= P_{0} + n \cdot r_{0} - s \end{align*}$$ 这里定义$s = r_{0} + r_{1} + ... + r_{n - 1}$。

　　同理可得 $$\begin{align*} P_{2} &= P_{1} + n \cdot r_{1} - s \\ &= P_{0} + n \cdot \left( {r_{0} + r_{1}} \right) - 2s \end{align*}$$

　　以此类推，我们可以发现$P_{i}$有两种表达式， $$P_{i} = P_{i - 1} + n \cdot r_{i - 1} - s$$ $$P_{i} = P_{0} + n \cdot \left( {r_{0}{+ r}_{1}{+ ... + r}_{i - 1}} \right) - i \cdot s$$

　　其中对于第一种表达式，我们可以发现每一种状态都可以用上一种状态来表示，一共有$n$种状态（选择$n$个不同的牛棚作为入口），然后又因为一定存在其中一种代价最小的状态，因此我们把$n$种状态通过迭代的方式枚举一遍，就可以找到最小的那种状态，这个状态对应的值就是最小代价。

　　AC代码如下：

#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 1010;

int r[N];

int main() {
    int n;
    scanf("%d", &n);

    int sum = 0, p = 0;
    for (int i = 0; i < n; i++) {
        scanf("%d", r + i);
        sum += r[i];
        p += r[i] * i;
    }

    int ret = 2e9;
    for (int i = 0; i < n; i++) {
        p += n * r[i] - sum;
        ret = min(ret, p);
    }

    printf("%d", ret);

    return 0;
}

　　接下来我们对第二种表达式进行更深一步的挖掘。

　　首先在这个表达式中，我们是选择$r_{0}$作为入口的，也就是选择$P_{0}$作为初始状态，事实上我们可以选择任意一个$P_{i}$作为初始状态，因为这是一个环，每一个点的地位都是等同的。也就是说，无论我们选择的是$P_{0}$还是$P_{1}$还是其他作为初始状态，都是可以推出$P_{0} \sim P_{n - 1}$的。

　　现在我们考虑一下，我们应该怎么选择，使得初始状态就是对应最小代价的那个状态。

　　现在我们就假设$P_{0}$就是那个最小代价的状态。如果P_{0}是最小代价，那么对于任意一个的$P_{i}$，都应该满足$P_{i} - P_{0} \geq 0$（所有的状态都满足大于等于$0$）。

　　因为有$P_{i} = P_{0} + n \cdot \left( {r_{0}{+ r}_{1}{+ ... + r}_{i - 1}} \right) - i \cdot s$，这就等价于$n \cdot \left( {r_{0}{+ r}_{1}{+ ... + r}_{i - 1}} \right) - i \cdot s \geq 0$。

　　进行移项和化简 $$\begin{align*} n \cdot \left( {r_{0}{+ r}_{1}{+ ... + r}_{i - 1}} \right) &\geq i \cdot s \\ \frac{r_{0} + r_{1} + ... + r_{i - 1}}{i} &\geq \frac{s}{n} \\ \frac{r_{0} + r_{1} + ... + r_{i - 1}}{i} &\geq \overset{-}{r} \\ \frac{r_{0} + r_{1} + ... + r_{i - 1}}{i} - \overset{-}{r} &\geq 0 \\ \frac{r_{0} + r_{1} + ... + r_{i - 1} - i \cdot \overset{-}{r}}{i} &\geq 0 \\ \frac{\left( {r_{0} - \overset{-}{r}} \right) + \left( {r_{1} - \overset{-}{r}} \right) + ... + \left( {r_{i - 1} - \overset{-}{r}} \right)}{i} &\geq 0 \\ \left( {r_{0} - \overset{-}{r}} \right) + \left( {r_{1} - \overset{-}{r}} \right) + ... + \left( {r_{i - 1} - \overset{-}{r}} \right) &\geq 0 \end{align*}$$ 上式中，由于$i$大于$0$，所以可以消去。同时定义$\overset{-}{r} = \frac{s}{n}$，即平均值。

　　这里的初始状态为$P_{0}$，那么对于任意的$i$，上面的表达式中的每一项的和要满足大于等于$0$。更一般的情况，等价于我们要找的初始状态为$k$，满足$P_{k}$就是最小的代价，对于任意的$i$都要满足表达式$\left( {r_{k\% n} - \overset{-}{r}} \right) + \left( {r_{{({k + 1})}\% n} - \overset{-}{r}} \right) + ... + \left( {r_{{({k + i - 1})}\% n} - \overset{-}{r}} \right) \geq 0$。

　　我们把环变成一条链，线段的长度为环的两倍，也就是$2n$。环上从任意一点走长度为$n$的一段，等价于从线段中前一半长度的区间中找一个点，划出长度为$n$的一段。

　　对于表达式式$\left( {r_{k\% n} - \overset{-}{r}} \right) + \left( {r_{{({k + 1})}\% n} - \overset{-}{r}} \right) + ... + \left( {r_{{({k + i - 1})}\% n} - \overset{-}{r}} \right) \geq 0$要成立，相当于在这个长度为$n$的区间上，任意一个$r_{i} - \overset{-}{r}$的前缀和都要大于等于$0$。这里记$r_{i} - \overset{-}{r} = {r'}_{i}$，所以这就等价于在这个长度为$n$的区间上，任意一个${r'}_{i}$的前缀和都要大于等于$0$。需要注意的是，现在线段的长度为环的两倍，不需要再取模了。

　　所以可以在$2n$的区间定义前缀和${s'}_{i} = {r'}_{1} + {r'}_{2} + ... + {r'}_{i}$（前缀和的下标从$1$开始）。等价于在这个长度为$n$区间上任意一个点的前缀和满足${s'}_{i} - {s'}_{k - 1} \geq 0$。

　　其中，对于点$n$，${s'}_{n} = {r'}_{1} + {r'}_{2} + ... + {r'}_{n} = s - n \cdot \overset{-}{r} = s - s = 0$。

　　所以只要满足${s'}_{k - 1}$是最小值，那么就可以保证在长度为$n$的区间，${s'}_{i} - {s'}_{k - 1} \geq 0$恒成立。因为在一个集合里面，集合中的任意一个元素减去集合中最小的那个元素，得到的值一定是大于等于$0$的。

　　现在我们整理一下思路。

　　首先，我们先把这个环延长为长度为$2n$的线段，然后算一下${r'}_{i}$，接着算前缀和数组，在前缀和数组中找到一个$k-1$满足${s'}_{k-1}$是最小的那个值（$k-1$在区间$0 \sim n-1$中），那么我们从$k$开始的，长度为$n$的线段，即以$k$为入口的代价最小。代码思路同上。

　　AC代码如下：

#include <cstdio>
#include <algorithm>
using namespace std;

const int N = 2010;

int r[N];
double s[N];

int main() {
    int n;
    scanf("%d", &n);

    double sum;
    for (int i = 1; i <= n; i++) {
        scanf("%d", r + i);
        r[n + i] = r[i];
        sum += r[i];
    }

    double avg = sum / n;
    for (int i = 1; i <= 2 * n; i++) {
        s[i] = s[i - 1] + r[i] - avg;
    }

    int k = 0;
    for (int i = 0; i < n; i++) {
        if (s[i] < s[k]) k = i;
    }
    k++;

    int ret = 0;
    for (int i = 0; i < n; i++) {
        ret += i * r[k + i];
    }
    printf("%d", ret);

    return 0;
}

 

参考资料

　　AcWing 1843. 圆形牛棚（寒假每日一题2022）：https://www.acwing.com/video/3687/