NOIP专题复习——专题二：动态规划基础

最新推荐文章于 2022-10-10 13:58:30 发布
最新推荐文章于 2022-10-10 13:58:30 发布
阅读量1.1k 收藏 6
点赞数 1
分类专栏： OI学习笔记/题解报告/经验分享 文章标签： 动态规划 noip专题复习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhf_2015/article/details/52985187
版权

15个题，希望对大家有帮助，欢迎指出错误，交流算法。

数字三角形W

题目来源：【CodeVS 2189】
题意：

数字三角形，变为对100取模后的最大值。

思路：

当一种状态的影响不可忽略的时候，就加到动态规划当中，就是再加上一维。
设 dp[i][j][k] 表示，第i行的第j个，当余数是否能为k。
状态转移方程：
dp[i][j][k]=dp[i−1][j][(((k−v[i][j])%p)+p)%p] || dp[i−1][j−1][(((k−v[i][j])%p)+p)%p]

代码：
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int p = 100;
int n, mx;
int v[30][30];
bool f[30][30][110];
int main(){
    scanf("%d", &n);
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= i; j ++)
            scanf("%d", &v[i][j]);
    f[1][1][((v[1][1]%p)+p)%p] = 1;
    for(int i = 2; i <= n; i ++)
        for(int j = 1; j <= i; j ++)
            for(int k = 0; k <= 99; k ++)
                f[i][j][k] = f[i-1][j][((k-v[i][j])%p+p)%p] 
                || f[i-1][j-1][((k-v[i][j])%p+p)%p];
    for(int i = 1; i <= n; i ++)
        for(int j = 99; j >= 0; j --)
            if(f[n][i][j]){mx = max(mx, j);break;}
    printf("%d", mx);
    return 0;
}

花店橱窗布置

题目来源：【洛谷 1854】
题意：

给定一个 n∗m 的矩阵 A(n≤m) ，求一个序列 a1,a2,a3,...,an 满足 1≤a1<a2<a3<...<an≤m 使得 A[1][a1]+A[2][a2]+...+A[n][an] 最大。

思路：

考虑转换为背包问题。
设 dp[i][j] 表示现在处理到第i行，第i行选第j个，可以得到的最大值。
状态转移方程： dp[i][j]=max{dp[i−1][k]}+A[i][j](1≤k<j)
注意处理好边界条件，因为有负值，所以要把dp数组初始化为负无穷。

代码
#include <cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int inf = 1e9;
int v[110][110], f[110][110], pre[110][110], mx, mx_num;
int res[110], ct;
int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 0; i <= n; i ++)
        for(int j = 0; j <= m; j ++)
            f[i][j] = -inf;
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++)
            scanf("%d", &v[i][j]);
    for(int i = 1; i <= m; i ++) f[1][i] = max(v[1][i], f[1][i-1]);
    for(int i = 2; i <= n; i ++)
        for(int j = i; j <= m-n+i; j ++)
            for(int k = i-1; k < j; k ++)
                if(f[i][j] < f[i-1][k] + v[i][j])
                    f[i][j] = f[i-1][k] + v[i][j], pre[i][j] = k;
    for(int i = 1; i <= m; i ++)
        if(mx < f[n][i]) mx = f[n][i], mx_num = i;
    ct = n;
    printf("%d\n", mx);
    for(int i = mx_num; i; i = pre[ct--][i]) res[ct] = i;
    for(int i = 1; i <= n; i ++) printf("%d ", res[i]);
    return 0;
}

机器分配

题目来源：【洛谷 2066】
题意：

总公司拥有高效设备M台，准备分给下属的N个分公司。各分公司若获得这些设备，可以为国家提供一定的盈利。问：如何分配这M台设备才能使国家得到的盈利最大？求出最大盈利值。其中M≤15，N≤10。分配原则：每个公司有权获得任意数目的设备，但总台数不超过设备数M。

思路：

设 dp[i][j] 表示前i个店，总共购买j台的最大收益。
状态转移方程： dp[i][j]=min{dp[i−1][j−k]+a[i][k]}
洛谷的好像没有spj，所以要用 ≤ 更新才可以过。

代码
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
int v[20][20], f[20][20], pre[20][20], res[20];
int n, m, mx, ct, mx_num;
int main(){
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++)
            scanf("%d", &v[i][j]);
    for(int i = 1; i <= n; i ++){
        for(int j = 1; j <= m; j ++){
            for(int k = 0; j >= k && k <= m; k ++){
                if(f[i][j] <= f[i-1][j-k] + v[i][k]){
                    f[i][j] = f[i-1][j-k] + v[i][k];
                    pre[i][j] = j-k;
                }
            } 
        } 
    }
    for(int i = 1; i <= n; i ++)
        if(mx < f[i][m]) mx = f[i][m];
    printf("%d\n", mx);
    ct = n;
    for(int i = m; i; i = pre[ct--][i]) res[ct] = i; 
    for(int i = 1; i <= n; i ++) printf("%d %d\n", i, res[i]-res[i-1]);
    return 0;
}

烽火传递

题目来源：【Smart OJ 1475】
题意：

给定n个非负整数，选择其中若干个数字，使得每连续k个数中至少有一个被选出。要求选择的数字之和尽可能小。

思路：

设 dp[i] 表示选第i个数，且满足条件的最小值。
状态转移方程： dp[i]=min{dp[j]}+a[i](i−j+1≤k)
可用单调队列优化。

代码
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
int v[1000010], f[1000010];
int q[1000010], mn = 1e9;
int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i ++) scanf("%d", &v[i]);
    int l = 1, r = 0;
    f[0] = 0;
    for(int i = 1; i <= n; i ++){
        while(l <= r && f[q[r]] >= f[i-1]) r --;
        q[++r] = i-1;
        while(l <= r && i-q[l] > m) l ++;
        f[i] = f[q[l]] + v[i];
        if(n-i < m) mn = min(f[i], mn);
    }
    printf("%d", mn);
    return 0;
}

传球游戏

题目来源：【洛谷 1057】
题意：

n个人站成一个圈传球，从1号开始传，每次等机率向左或向右传，问传m次以后，传到1号的方案数。

思路：

设 dp[i][j] 表示第 i 个人，传了j次的方案数。
转移方程：
dp[i][j]=dp[i−1][j−1]+dp[i+1][j−1]
注意特判一下 1 和n的情况。

代码
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
int f[50][50];
int main(){
    int n, m;
    scanf("%d%d", &n, &m);
    f[1][0] = 1;
    for(int i = 1; i <= m; i ++){
        for(int j = 1; j <= n; j ++){
            if(j == 1){
                f[1][i] = f[2][i-1] + f[n][i-1];
            }else if(j == n){
                f[n][i] = f[n-1][i-1] + f[1][i-1];
            }else{
                f[j][i] = f[j-1][i-1] + f[j+1][i-1];
            }
        }
    }
    printf("%d", f[1][m]);
    return 0;
}

尼克的任务

题目来源：【洛谷 1280】
题意：

尼克的一个工作日为N分钟，从第一分钟开始到第N分钟结束。当尼克到达单位后他就开始干活。如果在同一时刻有多个任务需要完戍，尼克可以任选其中的一个来做，而其余的则由他的同事完成，反之如果只有一个任务，则该任务必需由尼克去完成，假如某些任务开始时刻尼克正在工作，则这些任务也由尼克的同事完成。如果某任务于第P分钟开始，持续时间为T分钟，则该任务将在第P+T-1分钟结束。计算最大的闲暇时间。

思路：

设 dp[i] 表示前 i 个分钟的最大闲暇时间。
转移时考虑两种情况：
1. 这一时刻没有任务，则dp[i]=max(dp[i−1],dp[i])
2. 这一时刻有任务，则可以推出以后的闲暇时间，设任务持续到的时间是 t ，那么dp[t]=max(dp[t],dp[i−1])
因为任务是必须有就要做的，所以只有当一个状态只能由任务已经完成的状态推得，休息的条件是这个时间点不在执行任务，即把dp数组初始化为 −inf ， dp[0]=1 。

代码：
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <vector> 
using namespace std;
const int inf = 1e9;
vector <int> p[10010];
int f[10010], mx;
int main(){
    int n, k;
    scanf("%d%d", &n, &k);
    for(int i = 1; i <= n; i ++) f[i] = -inf;
    for(int i = 1; i <= k; i ++){
        int a, b;
        scanf("%d%d", &a, &b);
        p[a].push_back(a+b-1);
    }
    for(int i = 1; i <= n; i ++){
        if(!p[i].size()) f[i] = max(f[i-1] + 1, f[i]);
        for(int j = 0; j < p[i].size(); j ++){
            f[p[i][j]] = max(f[p[i][j]], f[i-1]);
        }
    }
    printf("%d", f[n]);
    return 0;
}

下面就不写题意了，都是中文题。
感觉难点都不在dp，而是在模型的抽象化，收获颇多。

低价购买

题目来源：【洛谷 1108】
思路：

最长下降子序列+方案数。至于第二问求方案数，相同的数字只从靠后面的转移方案。

代码：
#include <cstring>
#include <iostream>
#include <cstdio>
#include <map>
using namespace std;
const int maxn = 5010;
int n, a1[maxn], num[maxn], dp[maxn];
map <int, bool> map1;
int main(){
    scanf("%d", &n);
    for(int i = 1; i <= n; i ++){
        scanf("%d", &a1[i]);
    }
    for(int i = 1, mx1, mx2; i <= n; i ++){
        dp[i] = 1;
        mx1 = 0; mx2 = 0, map1.clear();
        for(int j = i-1; j > 0; j --){
            if(a1[j] > a1[i]){
                if(dp[j] >= mx1){
                    if(dp[j] == mx1){
                        if(map1[a1[j]] == 1) continue;
                        else map1[a1[j]] = 1, mx2 += num[j];
                    }else mx1 = dp[j], mx2 = num[j], map1.clear(), map1[a1[j]] = 1;
                }
            }
        }
        dp[i] = mx1+1;
        num[i] = mx2==0?1:mx2;
    }
    int max1 = 0, max2 = 0;
    map1.clear();
    for(int i = n; i >= 1; i --){
        if(max1 < dp[i])
            max1 = dp[i], max2 = num[i], map1.clear(), map1[a1[i]] = 1;
        if(max1 == dp[i]){
            if(map1[a1[i]] == 1) continue;
            else max2 += num[i], map1[a1[i]] = 1;
        }
    }
    printf("%d %d", max1, max2);
    return 0;
}

多米诺骨牌

题目来源：【洛谷 1282】
思路：

设 dp[i][j] 表示前 i 张骨牌，上下之差为j的最小翻转次数，设 Ai,Bi 分别表示第 i 张骨牌上值和下值
状态转移方程：
dp[i][j+(Ai−Bi)]=min(dp[i][j+(Ai−Bi)],dp[i][j])
dp[i][j−(Ai−Bi)]=min(dp[i][j−(Ai−Bi)],dp[i][j]+1)
要加上一个数，让下标都是正的。

代码：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int p = 7000;
int f[1010][14010], ans = 1e9;
int main(){
    int n; scanf("%d", &n);
    memset(f, 63, sizeof f);
    f[0][p] = 0;
    for(int i = 0; i < n; i ++){
        int a, b, t;
        scanf("%d%d", &a, &b);
        t = a-b;
        for(int j = -6000; j <= 6000; j ++){
            f[i+1][j+t+p] = min(f[i+1][j+t+p], f[i][j+p]);
            f[i+1][j-t+p] = min(f[i+1][j-t+p], f[i][j+p]+1);
        }
    }
    for(int i = 0; i <= 6000; i ++){
        if(f[n][i+p] <= 1000 || f[n][p-i] <= 1000){
            ans = min(f[n][i+p], f[n][p-i]);
            break;
        } 
    }
    printf("%d", ans);
    return 0;
}

烹调方案

题目来源：【洛谷 1417】
思路：

一个很好的贪心性质：当制作A食材的时间 × B食材的单位损耗 < <script type="math/tex" id="MathJax-Element-36"><</script>制作B食材的时间 × A食材的单位损耗时，我们一定是优先选择A食材，我们可以把第一项看做先制作A食材对B的影响，第二项看做先制作B食材对A的影响，我们当然先做影响相对较小的，所以先按上面的运算排序，再做背包，选出最优的组合。
典型背包，方程没有什么好说的。

代码：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
struct node{
    ll num, a, b;
    bool operator < (const node &t)const{
        return a*t.b > b*t.a;
    }
};
node p[110];
ll f[100010], mx;
int main(){
    int T, n;
    scanf("%d%d", &T, &n);
    for(int i = 1; i <= n; i ++) scanf("%lld", &p[i].num);
    for(int i = 1; i <= n; i ++) scanf("%lld", &p[i].a);
    for(int i = 1; i <= n; i ++) scanf("%lld", &p[i].b);
    sort(p+1, p+1+n);
    for(int i = 1; i <= n; i ++){
        for(int j = T; j >= p[i].b; j --){
            f[j] = max(f[j], f[j-p[i].b] + max((ll)0, p[i].num-p[i].a*j));
        }
    }
    for(int i = 0; i <= T; i ++) mx = max(mx, f[i]);
    printf("%lld", mx);
    return 0;
}

创意吃鱼法

题目来源：【洛谷 1736】
思路：

题目也就是问最长的只有对角线的正方形最大的对角线长度。
设 f[i][j] 表示以 i 行j列结尾的最长的对角线长度， f[i][j] 转移左上的， g[i][j] 转移右上的。
转移的时候要验证新添加的一行或者一列的一部分是否只有 i,j 位置上的一个1，这个可以用二维的前缀和O(NM)预处理，O(1)询问。
每次向前面转移的长度要尽量长，但是有的时候全选上又不满足条件，所以只能选一部分，这里可以二分枚举选多少。

代码：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
int n, m, mx;
int f[2510][2510], g[2510][2510];
int v[2510][2510], sum[2510][2510];
int calc(int x1, int y1, int x2, int y2){
    return sum[x2][y2] - sum[x1-1][y2] - sum[x2][y1-1] + sum[x1-1][y1-1];
}
int main(){
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++)
            scanf("%d", &v[i][j]);
    for(int i = 1; i <= n; i ++)
        for(int j = 1; j <= m; j ++)
            sum[i][j] = sum[i-1][j] + sum[i][j-1] 
            - sum[i-1][j-1] + v[i][j];
    for(int i = 1; i <= n; i ++){
        for(int j = 1; j <= m; j ++){
            if(!v[i][j]) continue;
            if(f[i-1][j-1]){
                int l = 1, r = f[i-1][j-1] + 1, ans = 0;
                while(l <= r){
                    int mid = (l+r) >> 1;
                    if(calc(i,j-mid+1,i,j) == 1 
                    && calc(i-mid+1,j,i,j) == 1) ans = mid, l = mid + 1;
                    else r = mid - 1;
                } 
                f[i][j] = ans;
            }
            f[i][j] = max(f[i][j], 1);
            if(g[i-1][j+1]){
                int l = 1, r = g[i-1][j+1] + 1, ans = 0;
                while(l <= r){
                    int mid = (l+r) >> 1;
                    if(calc(i,j,i,j+mid-1) == 1 
                    && calc(i-mid+1,j,i,j) == 1) ans = mid, l = mid + 1;
                    else r = mid - 1;
                } 
                g[i][j] = ans;
            }
            g[i][j] = max(g[i][j], 1);
            mx = max(mx, max(f[i][j], g[i][j]));
        }
    }
    printf("%d", mx);
    return 0;
}

统计单词个数

题目来源：【洛谷 1026】
思路：

分析题意可以知道，同一个开头的字母只能有一个对应的单词相对应，所以我们可以先进行一次动态规划。设 v[i][j] 表示从第 i 号字符到第j号字符的单词个数。
转移：
v[i][j]=v[i+1][j]+1 （存在以 i 开头的单词）
v[i][j]=v[i+1][j]（不存在以 i 开头的单词）
得到v数组以后，下一步的就很方便了，设 f[i][j] 表示前 i 个字符，分为j段的最大单词数。
转移：
f[i][j]=max(f[k][j−1]+v[j+1][i],f[i][j])  j≤k≤i−1
所有的 f[i][1] 都可以提前初始化，转移时不再转移。

代码：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <string>
using namespace std;
string s, t, dic[10];
int v[210][210], f[210][210];
int n, m, k;
void init(){
    for(int i = 1; i <= n; i ++){
        t = s[i];
        for(int j = 1; j <= m; j ++)
            if(t == dic[j]){v[i][i] = 1;break;}
    }
    for(int i = 2; i <= n; i ++)
        for(int j = 1; i+j-1 <= n; j ++){
            bool ok = 0;
            string c = "";
            for(int p = j; !ok && p <= j+i-1; p ++){
                c += s[p];
                for(int k = 1; k <= m; k ++)
                    if(c == dic[k]){ok = 1;break;}
            }
            if(ok) v[j][j+i-1] = v[j+1][j+i-1] + 1;
            else v[j][j+i-1] = v[j+1][j+i-1];
        }
    return;
}
int main(){
    s = " ";
    scanf("%d%d", &n, &k);
    for(int i = 1; i <= n; i ++) cin >> t, s += t;
    scanf("%d", &m);
    for(int i = 1; i <= m; i ++) cin >> dic[i];
    n *= 20, init();
    for(int i = 1; i <= n; i ++){
        f[i][1] = v[1][i];
        for(int l = 2; l <= i && l <= k; l ++){
            for(int j = l; j < i; j ++){
                f[i][l] = max(f[i][l], f[j][l-1] + v[j+1][i]);
            }
        }
    }
    printf("%d", f[n][k]);
    return 0;
}

垃圾陷阱

题目来源：【洛谷 1156】
思路：

设 f[i][j] 表示已经处理了前 i 个垃圾，现在放的高度是j的最长存活时间。
递推转移：
f[i+1][j]=max(f[i+1][j],f[i][j]−t+p[i+1].b);
f[i+1][min(j+p[i+1].c,H)]=max(f[i+1][min(j+p[i+1].c,H)],f[i][j]−t);
显然，以上的方程需要满足条件 (f[i][j]−t>=0) 。
如果没有解，可以重新贪心求出最长的存活时间。

代码：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int inf = 1e9;
struct node{
    int a, b, c;
    bool operator < (const node &t)const{
        return a < t.a;
    }
};
node p[110];
int f[110][110], res;
int H, n;
int main(){
    scanf("%d%d", &H, &n);
    for(int i = 0; i <= n; i ++)
        for(int j = 0; j <= H; j ++)
            f[i][j] = -inf;
    for(int i = 1; i <= n; i ++) scanf("%d%d%d", &p[i].a, &p[i].b, &p[i].c);
    f[0][0] = 10;
    sort(p+1,p+1+n);
    for(int i = 0; i < n; i ++){
        for(int j = 0; j <= H; j ++){
            int t = p[i+1].a - p[i].a;
            if(f[i][j] - t >= 0){
                f[i+1][j] = max(f[i+1][j], f[i][j] - t + p[i+1].b);
                f[i+1][min(j+p[i+1].c, H)] = max(f[i+1][min(j+p[i+1].c, H)], f[i][j] - t);
            } 
        }
    }
    for(int i = 1; i <= n; i ++){
        if(f[i][H] >= 0){
            printf("%d", p[i].a);
            return 0;
        }
    }
    int left = 10;
    for(int i = 1; i <= n; i ++){
        if(p[i].a - p[i-1].a <= left) left = left - (p[i].a - p[i-1].a) + p[i].b;
        else{
            res = max(p[i-1].a + left, res);
            break;
        }
        res = max(left+p[i].a, res);
    }
    printf("%d", res);
    return 0;
}

过河

题目来源：【洛谷 1052】
思路：

非常裸的背包问题，可以说对一个数取模来缩小范围是不对的做法，可是数据比较水。
直接压缩会被卡在最大值与最小值相等的情况上，所以加上特判，水过，以后有机会一定改正。
正解使用裴蜀定理，解出一个式子，然后就可以求出中间没有用的部分，将其去除。

代码：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
using namespace std;
const int inf = 1e9;
int v[110], cnt;
int L, S, T, n, p, pp;
int f[2000010];
int main(){
    scanf("%d%d%d%d", &L, &S, &T, &n);
    for(int i = 1; i <= n; i ++) scanf("%d", &v[i]);
    sort(v+1, v+1+n);
    if(S == T){
        int ans = 0;
        for(int i = 1; i <= n; i ++)
            if(v[i] % S == 0) ans ++;
        printf("%d", ans);
        return 0;
    }
    int left = 0;
    for(int i = 1; i <= n; i ++){
        v[i] -= left;
        int t = (v[i] - v[i-1]) / 1009 * 1009;
        left += t;
        v[i] -= t;
    }
    L -= left;
    int t = (L - v[n]) / 1009 * 1009;
    L -= t;
    for(int i = 1; i <= L; i ++) f[i] = inf;
    if(v[++p] == 0) f[0] = 1, p ++;
    else f[0] = 0;
    for(int i = 0; i <= L; i ++){
        while(v[p] < i) p ++;
        if(v[p] == i) pp = 1;
        else pp = 0;
        for(int j = S; j <= T; j ++)
            f[i+j] = min(f[i+j], f[i] + pp);
    }
    printf("%d", f[L]);
    return 0;
}

加分二叉树

题目来源：【洛谷 1040】
思路：

树的中序遍历可以看做是一个区间dp的模型，每次枚举根节点的位置，根据题目中给出的式子，特判树的根在左端点和右端点的情况。
设 f[i][j] 表示 i 到j这一段区间中，最大的得分是多少， g[i][j] 表示 i 到j这一段区间中，选择那个节点为根。
在维护 f 数组的时候，顺便记录g。
转移：
f[j][j+i−1]=max(f[j][k−1]×f[k+1][j+i−1]+f[k][k],f[j][j+i−1])

代码：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <string>
using namespace std;
typedef long long ll;
ll n, v[50], f[50][50], g[50][50];
void dfs(ll l, ll r){
    if(l == r){cout << l << " ";return;} 
    cout << g[l][r] << " ";
    if(l <= g[l][r]-1) dfs(l,g[l][r]-1);
    if(g[l][r]+1 <= r) dfs(g[l][r]+1,r);
    return;
}
int main(){
    cin >> n;
    for(int i = 1; i <= n; i ++) cin >> v[i];
    for(int i = 1; i <= n; i ++) f[i][i] = v[i], g[i][i] = i;
    for(int i = 2; i <= n; i ++){
        for(int j = 1; j+i-1 <= n; j ++){
            for(int k = j; k <= j+i-1; k ++){
                if(k == j){
                    if(f[j][j+i-1] < v[j] + f[j+1][j+i-1]){
                        f[j][j+i-1] = v[j] + f[j+1][j+i-1];
                        g[j][j+i-1] = k;
                    }
                }   
                else if(k == j+i-1){
                    if(f[j][j+i-1] < v[j+i-1] + f[j][j+i-2]){
                        f[j][j+i-1] = v[j+i-1] + f[j][j+i-2];
                        g[j][j+i-1] = k;
                    }
                }
                else{
                    if(f[j][j+i-1] < f[j][k-1] * f[k+1][j+i-1] + v[k]){
                        f[j][j+i-1] = f[j][k-1] * f[k+1][j+i-1] + v[k];
                        g[j][j+i-1] = k;
                    }
                }
            }
        }
    }
    cout << f[1][n] << endl;
    dfs(1,n);
    return 0;
}

双塔

题目来源：【洛谷 2423】
思路：

设 f[i][j] 表示前 i 个水晶，高度差为j的相对较高的塔的高度。
转移时考虑每个水晶放的位置：

  • 不放这一块水晶： f[i+1][j]=max(f[i+1][j],f[i][j]);
  • 放在高塔上面： f[i+1][j+v[i+1]]=max(f[i+1][j+v[i+1]],f[i][j]+v[i+1]);
  • 放在低塔上面（注意判断新的高度是否超过高塔）：
    f[i+1][abs(j−v[i+1])]=max(f[i+1][abs(j−v[i+1])],(j−v[i+1]>0?f[i][j]:f[i][j]+v[i+1]−j));
代码：
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int inf = 1e9;
int v[110], sm, ans;
int f[110][4010];
int main(){
    int n;
    scanf("%d", &n);
    for(int i = 1; i <= n; i ++) scanf("%d", &v[i]), sm += v[i];
    for(int i = 0; i <= n; i ++)
        for(int j = 0; j <= sm; j ++)
            f[i][j] = -inf;
    f[0][0] = 0;
    for(int i = 0; i < n; i ++){
        for(int j = 0; j <= sm; j ++){
            if(f[i][j] >= 0){
                f[i+1][j+v[i+1]] = max(f[i+1][j+v[i+1]], f[i][j] + v[i+1]);
                f[i+1][abs(j-v[i+1])] = max(f[i+1][abs(j-v[i+1])], (j-v[i+1] > 0 ? f[i][j] : f[i][j]+v[i+1]-j));
                f[i+1][j] = max(f[i+1][j], f[i][j]);
            }
        }
    }
    for(int i = n; i >= 1; i --)
        if(f[i][0] >= 0) ans = max(ans, f[i][0]);
    if(ans == 0) printf("Impossible");
    else printf("%d", ans);
    return 0;
}
yhf_2015
关注
专栏目录
NOIP复赛复习（十五）动态规划巩固与提高
dqcsm1964的博客
11-05 1039
经典例题：数字金字塔（Luogu 1216）  写一个程序来查找从最高点到底部任意处结束的路径，使路径经过数字的和最大。每一步可以走到左下方的点也可以到达右下方的点。 我们现在这里讨论搜索如何实现：  状态：目前在第x行第y列  行动：向左走，向右走  例如：一个底边为4的三角形共有八种状态： 我们按照一般的搜索思路，进行深度优先搜索
浅析NOIP中的动态规划
盛楠的博客
11-15 2831
收录并解析近十年NOIP提高组的DP题，分为背包类dp，线性dp，状压dp，树形dp，区间dp 五个部分
NOIP动态规划大合集
weixin_33724046的博客
08-02 203
1、前言 NOIP2003-2014动态规划题目大合集，有简单的也有难的（对于我这种动态规划盲当然存在难的），今天就把这些东西归纳一下，做一个比较全面的总结，方便对动态规划有一个更深的理解。 2、NOIP2003 加分二叉树 树形DP入门题，根据题意，一个树的加分=左子树*右子树+根节点，由此可以设f[i][j]为子树i到j的加分，则有方程：f[i][j...
NOIP复习篇———动态规划
MPS的博客
11-05 3016
NOIP复习篇———动态规划
NOIP2016专题 ——动态规划 by kqp
07-17
NOIP2016专题 ——动态规划 by kqp 本ppt为归纳总结性ppt
noip复习手册
12-16
### NOIP复习手册知识点解析 #### 一、Pascal语言基础知识 ##### 1. 基本数据类型 Pascal语言提供了多种基本数据类型来满足不同的编程需求： - **整型**： - `byte`：范围从0到255，占用1字节。 - `shortint`...
NOIP基础算法——贪心和分治.ppt
10-07
在NOIP（全国青少年信息学奥林匹克竞赛）这样的编程竞赛中，掌握这两种算法是提高解题能力的基础。 1. **贪心算法**： - **定义**：贪心算法是一种在每一步选择中都采取在当前状态下最好或最优（即最有利）的选择...
NOIP基础算法——贪心和分治pasal.ppt
03-19
NOIP基础算法——贪心和分治pasal.ppt
NOIP基础算法——贪心和分治_图文.ppt.ppt
05-29
NOIP基础算法——贪心和分治_图文.ppt.ppt
noip2019——动态规划刷题历程
weixin_30550271的博客
04-12 177
加粗的是值得总结的 从洛谷的普及题开始刷题； 背包式dp（有些技巧的） 1.p2639[USACO09OCT]Bessie的体重问题 -p1049取模意义下01背包 技巧：重量=价值 2.金明的预算问题——很经典了 P1064 金明的预算方案 技巧：树形背包 3.P1131[ZJOI2007]时态同步 技巧：单一表达式树上dp； DAG式dp P1608 路径统计 ...
NOIP复健计划——动态规划
最新发布
Edward The Bunny 的博客
10-10 365
dp
noip动态规划总结
...
11-09 878
难点：模型的建立和理解。 要求：对于每道题，都能在很短的时间里把思路完整地整理一遍，可以快速而无误的写出程序。 (一) 两种动机 a) 利用重叠子问题，进行记忆化求解，即利用递归。 例1、 括号序列 分析：d[I,j]:=min 也可以用记忆化搜索。 需要的只有方程和边界。 例2、 棋盘分割[noi99] 目标式变形： 因为不变，所以要使每个矩阵的平方和
NOIP竞赛学习整理--动态规划算法举例P1264
qq_21291397的博客
02-14 730
动态规划 什么是动态规划？ 动态规划是解决多阶段决策最优化问题的一种思想方法。所谓“动态”，指的是在问题的多阶段决策中，按某一顺序，根据每一步所选决策的不同，将随即引起状态的转移，最终在变化的状态中产生一个决策序列。动态规划就是为了使产生的决策序列在符合某种条件下达到最优。 一、动态规划中的主要概念，名词术语 1 阶段：把问题分成几个相互联系的有顺序的几个环节，这些环节即称为阶段。 2 状态：某一...
2540. 【NOIP动态规划专题】采药2 (Standard IO)
学习成神之路
08-11 740
2540. 【NOIP动态规划专题】采药2 (StandardIO) Description 　　辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可
[NOIP复习]第三章：动态规划
weixin_30687811的博客
06-16 315
一、背包问题 最基础的一类动规问题。相似之处在于给n个物品或无穷多物品或不同种类的物品，每种物品仅仅有一个或若干个，给一个背包装入这些物品，要求在不超出背包容量的范围内，使得获得的价值或占用体积尽可能大，这一类题的动规方程f[i]一般表示剩余容量为i时取得的最大价值或最大占用体积。或者有多维状态，分别表示不同种物品的剩余量 1、Wikioi 1014 装箱问题 题目描写叙述 De...
noip提高组写题心得——动态规划4例
maxtir的博客
08-19 1568
题目1：Luogu P1970花匠： 最简单的一道题目。本题的重点在于如何理解 条件 A：对于所有g(2i)>g(2i-1),g(2i)>g(2i+1) 条件 B：对于所有g(2i) 这两个东东。 看上去很深奥，实际上细想，就是从一个有序整数集合Q中顺序取出几个数组成一个数列，使得：这个数列一大一小就得了。要求这个数列最长。理解了一大一小这个东西，动态方程不难列出来，有两个，而因为每个f
NOIP大纲整理：（十）动态规划巩固与提高3：各种DP（有机会再细分类别）
liusu201601的博客
08-06 1054
、路径行走问题   经典例题：方格取数（Luogu 1004）  设有 N*N 的方格图 (N&lt;=9)，我们将其中的某些方格中填入正整数，而其他的方格中则放入数字 0。 *某人从图的左上角的 A 点出发，可以向下行走，也可以向右走，直到到达右下角的 B 点。在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字 0）。 *此人从 A点到 B 点共走两次，试找出 2 条这样的路...
【经典】Noip动态规划
weixin_30809173的博客
11-08 103
一、线性动态规划 最长严格上升子序列 #include<iostream> #include<cstdio> using namespace std; int n,ans; int a[5004],dp[5004]; int main() { scanf("%d",&n); for(int i=1;i<=n;i++)...
NOIP基础算法解析：动态规划DP与枚举法
"这篇资料主要介绍了动态规划(DP)的基础知识，特别是如何在O(n)的时间复杂度下解决特定问题，以及枚举法在解决问题中的应用。内容包括NOIP、ACM、OI、CTSC等竞赛相关的算法学习。" 文章详细讲解了动态规划(DP)在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值