POJ 3666. Making the Grade 数学证明及动态规划解法

POJ 3666. Making the Grade

题目链接

Description

A straight dirt road connects two fields on FJ’s farm, but it changes elevation more than FJ would like. His cows do not mind climbing up or down a single slope, but they are not fond of an alternating succession of hills and valleys. FJ would like to add and remove dirt from the road so that it becomes one monotonic slope (either sloping up or down).

You are given N integers $A_1^{},...,A_N^{}(1\le N\le 2,000)$ describing the elevation $(0\le A_i^{}\le 1,000,000,000)$ at each of N equally-spaced positions along the road, starting at the first field and ending at the other. FJ would like to adjust these elevations to a new sequence $B_1^{},....,B_N^{}$ that is either nonincreasing or nondecreasing. Since it costs the same amount of money to add or remove dirt at any position along the road, the total cost of modifying the road is

$$|A_1^{}-B_1^{}|+|A_2^{}-B_2^{}|+...+|A_N^{}-B_N^{}|$$

Please compute the minimum cost of grading his road so it becomes a continuous slope. FJ happily informs you that signed 32-bit integers can certainly be used to compute the answer.

Input

• Line 1: A single integer: N
• Lines $2…N+1: Line i+1 contains a single integer elevation: $A_i^{}$

Output

• Line 1: A single integer that is the minimum cost for FJ to grade his dirt road so it becomes nonincreasing or nondecreasing in elevation.

Sample Input

7
1
3
2
4
5
3
9

Sample Output

3

\newline
\newline
\newline

思路

首先把这题的模型抽象出来，就是给定一个数组，你通过调整数组 $A$ 的值使数组变成单调不减或者单调不增，求数组每个数字的变化绝对值之和最小是多少。记调整完以后的符合要求的数组为 $A^{\prime }$。我们可以先考虑单调不减的情况，单调不增同理。

我们考虑两个相邻的 $A[i-1]$ 和 $A[i]$，如果 $A[i-1]$ > $A[i]$，那么我们只需要提高 $A[i]$ 的值到 $A^{\prime }[i]=A[i-1]$ 就行，而不需要提高到$A[i-1]+1,A[i-1]+2....$，因为提高到 $A[i-1]$ 已经满足要求。同理我们也可以降低 $A[i-1]$ 的值到 $A^{\prime }[i-1]=A[i]$。这里有一个直觉，那就是：
\newline
\newline

猜想

最终的数组 $A^{\prime }$ 的值都是属于原数组 $A$ 的值的集合。

\newline
\newline

证明

我们把原数组连同 $-\infty$ 和 $+\infty$ 从小到大排序，得到新数组 $a$，有

$$a_0^{}\le a_1^{}\le ......\le a_{N+1}^{}$$
其中$a_0^{}$ = $-\infty$，$a_{N+1}^{}$ = $+\infty$

\newline
\newline

记调整后的数组为 $c$，我们要证明相邻的$a_i^{}$ 和 $a_{i+1}^{}$ 之间不存在任何数组 $c$ 中的值。即不存在任何 $c_j^{}$ … $c_k^{}$ 使得

$$a_i^{}<c_j^{}\le c_{j+1}^{}\le ....\le c_k^{}<a_{i+1}^{}$$

假设存在这样的 $c_j^{}$ … $c_k^{}$，记 $c_t^{}$ 对应的原数组中的值为 $x，j\le t\le k$。

如果 $c_t^{}$ $\le x$，那么有

$$a_i^{}<c_j^{}\le c_{j+1}^{}\le ....\le c_k^{}<a_{i+1}^{}\le x$$
如果我们把 $c_t^{}$ 变到 $a_{i+1}^{}$，那么总的目标和会降低 $a_{i+1}^{}$ - $c_t^{}$，如果我们把 $c_t^{}$ 变到 $a_i^{}$，总的目标和会提高 $c_t^{}$ - $a_i^{}$。
\newline
同理，如果有 $c_t^{}$ $\ge x$，则
$$x\le a_i^{}<c_j^{}\le c_{j+1}^{}\le ....\le c_k^{}<a_{i+1}^{}$$
如果我们把 $c_t^{}$ 变到 $a_{i+1}^{}$，那么总的目标和会提高 $a_{i+1}^{}$ - $c_t^{}$，如果我们把 $c_t^{}$ 变到 $a_i^{}$，总的目标和会降低 $c_t^{}$ - $a_i^{}$。
\newline
\newline
现在我们记 $c_j^{}$ … $c_k^{}$ 当中有 $m_1^{}$ 个数小于对应的原数组中的数字，有 $m_2^{}$ 个数大于对应的原数组中的数字。
\newline
如果 $m_1^{}\le m_2^{}$，那么我们把 $c_j^{}$ … $c_k^{}$ 中所有的数字降低 $c_j^{}$ - $a_i^{}$，那么新的数组 $c$ 变成

$$a_i^{}=c_j^{\prime }\le c_{j+1}^{\prime }\le ....\le c_k^{\prime }<a_{i+1}^{}$$
新的目标和
$$S^{\prime }=S+m_1^{}\ast (c_j^{}-a_i^{})-m_2^{}\ast (c_j^{}-a_i^{})\le S$$

如果 $m_1^{}\ge m_2^{}$，那么我们把 $c_j^{}$ … $c_k^{}$ 中所有的数字提高 $a_{i+1}^{}$ - $c_k^{}$，那么新的数组 $c$ 变成

$$a_i^{}<c_j^{\prime }\le c_{j+1}^{\prime }\le ....\le c_k^{\prime }=a_{i+1}^{}$$
新的目标和
$$S^{\prime }=S-m_1^{}\ast (a_{i+1}^{}-c_k^{})+m_2^{}\ast (a_{i+1}^{}-c_k^{})\le S$$

\newline
\newline
综上，我们总可以通过调整 $c_j^{\prime }=a_i^{}$ 或者 $c_k^{\prime }=a_{i+1}^{}$，来使新的目标和 $S^{\prime }$ 不增，这样我们可以重复上述的步骤使得所有的 $c_j^{}$ … $c_k^{}$ 都变成 $a_i^{}$ 或者 $a_{i+1}^{}$。故而猜想得证。

\newline
\newline
\newline

最初的动态规划想法

上面证明了调整后的新数组的值必然都处于原数组内，那么这个问题就有点像完全背包问题了。记原数组中的值的集合为 $B$, 每一个 $A^{\prime }[i]$ 都可以从 $B$ 中取一个数字，而且同一个数字可以重复取。

我们定义状态 $dp[i][j]$ 为 $A^{\prime }$中的第 $i$ 个数字 $A^{\prime }[i]=B[j]$ 时，最小的目标和。状态转移方程为：
$$dp[i][j]=mi{n}_{B[k]\le B[j]}(|A[i]-B[j]|+dp[i-1][k])$$
我们可以自定义一个 $B$ 数组的顺序，不妨把 $B$ 从小到大排序，那么状态转移方程可以写成：
$$dp[i][j]=mi{n}_{0\le k\le j}(|A[i]-B[j]|+dp[i-1][k])$$
这个算法时间复杂度为 $O(n^3)$，对于 $n\le 2000$ 的数据来说太慢了，需要优化。
\newline
\newline
\newline
\newline

优化的动态规划

上面的状态转移方程需要比较所有的 $k,0\le k\le j$，但是这些 $k$ 都是连续的，所以我们可以考虑像数组前缀和那样，定义一个前缀累积的状态

我们重新定义状态 $dp[i][j]$ 为 $A^{\prime }$中的第 $i$ 个数字 $A^{\prime }[i]$ 在 $B[0],B[1],B[2],...B[j]$ 中时，最小的目标和

1. 如果 $A^{\prime }[i]\ne B[j]$，结果为 $dp[i][j-1]$
2. 如果$A^{\prime }[i]=B[j]$，结果为 $dp[i-1][j]+|A[i]-B[j]|$

此时状态转移方程为：
$$dp[i][j]=min(dp[i][j-1],dp[i-1][j]+|A[i]-B[j]|)$$

时间复杂度为 $O(n^2)$。另外因为 $dp[i][j]$ 只和 $i,i-1$ 相关，可以优化到一维数组。
\newline
\newline

import java.util.Arrays;
import java.util.Scanner;

public class Main {
    private int solve(int[] A) {
        int[] B = Arrays.copyOf(A, A.length);
        Arrays.sort(B);
        // Reverse value array so we can calculate non-increasing result.
        int ans = helper(A, B);
        int i = 0;
        int j = A.length - 1;
        while (i < j) {
            int tmp = B[i];
            B[i] = B[j];
            B[j] = tmp;
            i++;
            j--;
        }
        ans = Math.min(ans, helper(A, B));
        return ans;
    }

    private int helper(int[] A, int[] B) {
        int N = A.length;
        int[] dp = new int[N];
        for (int i = 0; i < N; ++i) {
            for (int j = 0; j < N; ++j) {
                int val = dp[j] + Math.abs(A[i] - B[j]);
                if (j > 0) {
                    val = Math.min(dp[j - 1], val);
                }
                dp[j] = val;
            }
        }
        return dp[N - 1];
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        int[] A = new int[N];
        for (int i = 0; i < N; ++i) {
            A[i] = scanner.nextInt();
        }
        Main main = new Main();
        System.out.println(main.solve(A));
    }
}