两道DP，四年修一次路

第十一届：山区修路

题目描述

SNJ位于HB省西部一片群峰耸立的高大山地，横亘于A江、B水之间，方圆数千平方公里，相传上古的神医在此搭架上山采药而得名。景区山峰均在海拔3000米以上，堪称"华中屋脊"。SNJ是以秀绿的亚高山自然风光，多样的动植物种，人与自然和谐共存为主题的森林生态区。
SNJ处于中国地势第二阶梯的东部边缘，由大巴山脉东延的余脉组成中高山地貌，区内山体高大，高低不平。 交通十分不便。
最近，HB省决定修一条从YC市通往SNJ风景区的高速公路。经过勘测分析，途中需要经过高度分别为H1，H2，……,Hn的N个山区。由于高低不平，除正常的修路开支外，每段还要多出高度差|Hi - Hi-1|*X万元的斜坡费用。Dr. Kong 决定通过填高一些区域的高度来降低总的费用。当然填高也是需要一些费用的。每填高Y单位，需要付出Y2万元费用。
你能否帮Dr. Kong做出一个规划，通过部分填高工程改造，使得总的费用降下来。

第一行： T 表示以下有T组测试数据（ 1≤ T ≤8 ）
对每组测试数据，
第一行：N  X（2 ≤ N ≤100，000   1≤ X ≤100）
第二行：N个整数，分别表示N个区域的高度Hi( 1<=Hi<=100 , i=1…. n)

对每组测试数据，输出占一行，一个整数，即经过部分填高工程改造后的最少费用。

dp[i][j]表示 第i个山区 在第j高度下时，所需要的最少费用

状态转移方程：dp[i][j] = min( dp[i-1][k] + 第i个山区填高的费用 + 第i-1和第i个山区斜坡的花费)

为什么可以这样转移？

因为 题目给出的数据 区域最大高度不过100，而山区最大由100000个，借助数据特点。

#include<bits/stdc++.h>
using namespace std;

const int maxn = 100005;
int t;
int a[maxn];
int dp[maxn][210];
int n,x;
const int inf = 0x3f3f3f3f;

int main(){
	cin>>t;
	while(t--){
		cin>>n>>x;
		for(int i=1;i<=n;i++){
			cin>>a[i];
		}
		memset(dp,inf,sizeof(dp));
		for(int i=a[1];i<=100;i++){
			dp[1][i] = (a[1] - i)*(a[1] - i);
		}

		for(int i=2;i<=n;i++){
			for(int j=a[i];j<=100;j++){ //第i个山区 在第j米高度时
				int cost = (j-a[i])*(j-a[i]);
				for(int k=a[i-1];k<=100;k++){ //第i-1个山区 在第k米时
					dp[i][j] = min(dp[i][j], dp[i-1][k] +  abs(j - k)*x + cost);
				}
			}
		}
		int ans = inf;
		for(int i=1;i<=100;i++){
			ans = min(ans,dp[n][i]);
		}
		cout<<ans<<endl;
	}
	return 0;
}

第七届：山区修路

题目描述

某山区的孩子们上学必须经过一条凹凸不平的土路，每当下雨天，孩子们非常艰难。现在村里走出来的Dr. Kong决定募捐资金重新修建着条路。由于资金有限，为了降低成本，对修好后的路面高度只能做到单调上升或单调下降。

为了便于修路，我们将整个土路分成了N段，每段路面的高度分别A1，A2,….,An。由于将每一段路垫高或挖低一个单位的花费成本相同，修路的总费用与路面的高低成正比。

现在Dr. Kong希望找到一个恰好含N个元素的不上升或不下降序列B1，B2,….,Bn，作为修过的路路段的高度。要求：
 | A1-B1| + | A2–B2| + ... + | An-Bn|------>最小

O(n^2)

参考博客：https://blog.csdn.net/m0_37579232/article/details/80426543

这道题和第十一届的类似，只不过dp转移需要改变；

因为ai 最大 有1e9，我们不能再用dp[i]j，这里j最大有1e9，这种方法不可行

而题目给出的数据 ai 虽然大，但是 n小啊。

这道题的正确做法：dp[i][j] 表示第i段在第a[j]高度下的最小费用，前i-1段已经修好了，为什么可以这样？因为题目要求最小花费，我们最大也只能修到和 a[j]数组的最大值相等的高度，也就是a[j]

也就是 dp[i][j]:= 把第i段路修成b[j]高度，所需要的最小花费（这时，前i-1段路都已经搞定啦）

由于是不递减，所以第i段路修成b[j]，那么第i-1段路就只能修成b[1]-b[j]，要求第i段路的最优解，则求:

dp[i][j]=min(dp[i-1][1],dp[i-1][2]……dp[i-1][j]）+abs(a[i]-b[j])

第i-1段路修成b[1],b[2]…b[j]的最小值，加上第i段路修成b[j]所需要的消费

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int a[505],b[505],n,dp[505][505];
const int INF=0x3f3f3f3f;
int cmp(int a,int b){
    return a>b;
}
int solve(){
    int tmp;
    for(int i=1;i<=n;i++){
        dp[1][i]=abs(a[1]-b[i]);
    }
    for(int i=2;i<=n;i++){
        tmp=INF;
        for(int j=1;j<=n;j++){
            tmp=min(tmp,dp[i-1][j]);//tmp求出了把第i-1段路修成不超过b[j]的最小花费
            dp[i][j]=abs(a[i]-b[j]) + tmp;//状态转移方程: 第i段路修成不超过b[j]的最小花费 等于  i-1段路修成不超过b[j]的最小花费 + 第i短路从a[i]修成b[i]的花费
        }
    }

    int ans=INF;
    for(int i=1;i<=n;i++){
        ans=min(ans,dp[n][i]);
    }
    return ans;
}

int main(){
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d",&n);
        for(int i=1;i<=n;i++){
            scanf("%d",&a[i]);
            b[i]=a[i];
        }
        sort(b+1,b+1+n);
        int ans1=solve();
        sort(b+1,b+1+n,cmp);
        int ans2=solve();
        printf("%d\n",min(ans1,ans2));
    }
}

O(n^3)

O(n^3)的做法 更为直观，但是运行了1700ms会超时。

dp[i][j]表示 第i个点 在高度为b[j]下的最小花费

状态转移方程：第i个点 在第b[j]高度 = min(第i-1个点，在第b[k]高度)

所以三层循环直接递推。

#include<bits/stdc++.h>
using namespace std;

const int maxn = 510;
int t;
int n;
int dp[maxn][maxn][2];
int a[maxn];
int b[maxn];
const int inf = 0x3f3f3f3f;

int main(){
    cin>>t;
    while(t--){
        cin>>n;
        for(int i=1;i<=n;i++){
            cin>>a[i];
            b[i] = a[i];
        }
        sort(b+1,b+n+1);
        memset(dp,inf,sizeof(dp));
        for(int i=1;i<=n;i++){
            dp[1][i][0] = abs(a[1] - b[i]);
        }

        //第一次dp 正序
        for(int i=2;i<=n;i++){
            for(int j=1;j<=n;j++){ //第i个点 在第b[j]高度
                for(int k=1;k<=j;k++){ //第i-1个点 在第b[k]高度
                    dp[i][j][0] = min(dp[i][j][0],dp[i-1][k][0] + abs(a[i] - b[j])); //状态转移递推
                }
            }
        }

        //第二次  这里超时 k从j~n 最坏时间复杂度O(n^3)
/*        for(int i=2;i<=n;i++){
            for(int j=1;j<=n;j++){
                for(int k=j;k<=n;k++){
                    dp[i][j][1] = min(dp[i][j][1],dp[i-1][k][1] + abs(a[i] - b[j]));
                }
            }
        }
*/
        reverse(a+1,a+n+1);
        for(int i=1;i<=n;i++){
            dp[1][i][1] = abs(a[1] - b[i]);
        }
        //把数组反转重新 再进行一次第一次dp
        for(int i=2;i<=n;i++){
            for(int j=1;j<=n;j++){
                for(int k=1;k<=j;k++){
                    dp[i][j][1] = min(dp[i][j][1],dp[i-1][k][1] + abs(a[i] - b[j]));
                }
            }
        }

        int ans = inf;
        for(int i=0;i<=n;i++){
            if(dp[n][i][1] < ans) ans = dp[n][i][1];
            if(dp[n][i][0] < ans) ans = dp[n][i][0];
        }
        cout<<ans<<endl;
    }

    return 0;
}

本题小结与想法：

从O(n^3) 优化到O(n^2)的一些理解：

O(n^2)利用单调不减性质：tmp求出了 把第i-1段路修成不超过b[j]的最小花费，tmp找出的是(i-1段路修成不超过b[j]的最小花费)的最优解，边推(i从2~n的过程中)边更新这个最优解，以用来求第i段路修成不超过b[j]的最小花费

O(n^{3)：每次j变化时，都从0开始到j结束找一遍i-1段路修成不超过b[j]的最小花费，可以优化成O(n}2)边推边更新。