基础DP练习

最新推荐文章于 2022-01-23 22:17:17 发布

02PHC

最新推荐文章于 2022-01-23 22:17:17 发布

阅读量98

点赞数 1

分类专栏：笔记题解 ACM

本文链接：https://blog.csdn.net/weixin_46001550/article/details/118573192

版权

题解同时被 3 个专栏收录

33 篇文章 0 订阅

订阅专栏

ACM

8 篇文章 0 订阅

订阅专栏

笔记

6 篇文章 0 订阅

订阅专栏

HDU-1024
题意：把一个数组分成不相交的恰好m段，求最大子段和
$d p [i] [j]$ 将前 $i$ 个数分成 $j$ 段的最大值
2种情况
1）第i个数自成一组
2）第i个数和第i-1个数在同一组
$d p [i] [j] = m a x (d p [i - 1] [j], d p [k] [j - 1]) + a [i] (1 < = k < = i - 1)$
$m a x (d p [k] [j - 1]) (1 < = k < = i - 1)$ 可以用一个数组维护出来

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>

using namespace std;
typedef long long ll;
const int N = 1e6 + 10;
int m, n, a;
ll dp[N], Max[N];

int main() {
    while (~scanf("%d%d", &m, &n)) {
        ll res = -(1ll << 60);
        memset(dp, -0x3f, sizeof dp);
        memset(Max, -0x3f, sizeof Max);
        dp[0] = Max[0] = 0;
        for (int i = 1; i <= n; i++) {
            scanf("%d", &a);
            for (int j = m; j >= 1; j--) {
                dp[j] = max(dp[j], Max[j - 1]) + a;
                Max[j] = max(Max[j], dp[j]);
            }
            res = max(res, Max[m]);
        }
        printf("%lld\n", res);
    }
    return 0;
}

HDU-1257
题意：给定一个数组，求最少多少个非上升子序列能完全覆盖这个数组
等价于求这个数组的最长上升子序列长度

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>

using namespace std;
const int N = 1e5 + 10;
int n, a, q[N], len;

int main() {
    while (~scanf("%d", &n)) {
        len = 0;
        memset(q, 0, sizeof q);
        for (int i = 1; i <= n; i++) {
            scanf("%d", &a);
            int l = 0;
            if (len > 0)l = lower_bound(q + 1, q + 1 + len, a) - q - 1;
            len = max(len, l + 1);
            q[l + 1] = a;
        }
        cout << len << endl;
    }
    return 0;
}

HDU-1087

题意：给定数组，求最大上升子序列和

和求最长上升子序列长度一样，不过每次加的权值从1变为了 $a [i]$

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>

using namespace std;
typedef long long ll;
const int N = 1e3 + 10;
ll a[N], dp[N];
int n;

int main() {
    while (scanf("%d", &n), n) {
        ll res = 0;
        memset(dp, 0, sizeof dp);
        for (int i = 1; i <= n; i++) {
            scanf("%lld", &a[i]);
            dp[i] = a[i];
            for (int j = 1; j < i; j++)
                if (a[j] < a[i])
                    dp[i] = max(dp[i], dp[j] + a[i]);
            res = max(res, dp[i]);
        }
        printf("%lld\n", res);
    }
    return 0;
}

HDU-1069
题意：给定n个长方体，每个长方体可以使用无数次，把这些长方体堆起来，要求接触的2个长方体中的上长方体的长宽均严格大于下长方体的长宽，求最高高度

思路：类似求最长上升子序列和

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>

using namespace std;
typedef long long ll;
int n, cas;
ll a, b, c, dp[200];

struct node {
    ll x, y, z;

    bool operator<(const node &b) const {
        if (x == b.x)return y > b.y;
        return x > b.x;
    }
} s[200];

int main() {
    while (scanf("%d", &n), n) {
        ll res = 0;
        memset(dp, 0, sizeof dp);
        for (int i = 1; i <= n; i++) {
            scanf("%lld%lld%lld", &a, &b, &c);
            s[(i - 1) * 6 + 1] = {a, b, c};
            s[(i - 1) * 6 + 2] = {a, c, b};
            s[(i - 1) * 6 + 3] = {c, b, a};
            s[(i - 1) * 6 + 4] = {b, a, c};
            s[(i - 1) * 6 + 5] = {c, a, b};
            s[(i - 1) * 6 + 6] = {b, c, a};
        }
        sort(s + 1, s + 1 + 6 * n);
        for (int i = 1; i <= 6 * n; i++) {
            dp[i] = s[i].z;
            for (int j = 1; j < i; j++)
                if (s[i].x < s[j].x && s[i].y < s[j].y)
                    dp[i] = max(dp[i], dp[j] + s[i].z);
            res = max(res, dp[i]);
        }
        printf("Case %d: maximum height = %lld\n", ++cas, res);
    }
    return 0;
}

POJ-3616
题意，在一个数轴上有n条线段，告诉你每条线段的起点和终点，还有这条线段的权值，问在2条线段头尾距离大于等于r的情况下，求最大的总权值
思路：类似上升子序列和

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;

struct node {
    int l, r, v;

    bool operator<(const node &b) const {
        return l < b.l;
    }
} a[1010];

int n, m, s, dp[1010];

int main() {
    cin >> n >> m >> s;
    for (int i = 1; i <= m; i++) {
        scanf("%d%d%d", &a[i].l, &a[i].r, &a[i].v);
        a[i].r += s;
    }
    sort(a + 1, a + 1 + m);
    int res = 0;
    for (int i = 1; i <= m; i++) {
        dp[i] = a[i].v;
        for (int j = 1; j <= m; j++)
            if (a[j].r <= a[i].l) {
                dp[i] = max(dp[i], dp[j] + a[i].v);
                res = max(res, dp[i]);
            }
    }
    cout << res << endl;
    return 0;
}

POJ - 1458
题意：求最长公共子序列
dp[i][j]表示1~ i与1~ j的最长公共子序列

分为4种情况 00，01，10，11（1表示选，0表示不选）
而01和10均包含了00的情况
所以
$d p [i] [j] = m a x (d p [i - 1] [j], d p [i] [j - 1]);$
$i f (a [i] = = b [j]) d p [i] [j] = m a x (d p [i] [j], d p [i - 1] [j - 1] + 1);$

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>

using namespace std;
typedef long long ll;
const int N = 1010;
int n, m, dp[N][N];
char a[N], b[N];

int main() {
    while (cin >> a + 1 >> b + 1) {
        memset(dp, 0, sizeof dp);
        for (int i = 1; a[i]; i++) {
            for (int j = 1; b[j]; j++) {
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
                if (a[i] == b[j])dp[i][j] = max(dp[i][j], dp[i - 1][j - 1] + 1);
            }
        }
        cout << dp[strlen(a + 1)][strlen(b + 1)] << endl;
    }
    return 0;
}

关于背包dp的初始化去解决（大于，少于，恰好等于）问题

根据y总视频总结的：

体积不超过k 初始化全部为0，v>=0
体积恰好等于k 初始化为正无穷或负无穷（取决于求最大值还是最小值）f[0]=0(体积为0初始为0)
体积不少于k 初始化为正无穷或负无穷（取决于求最大值还是最小值）

HDU-1114
完全背包模板题，求最小值

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>

using namespace std;
int dp[10010], v[510], w[510];
int t, m, mm, n;

int main() {
    scanf("%d", &t);
    while (t--) {
        memset(dp, 0x3f, sizeof dp);
        dp[0] = 0;
        scanf("%d%d%d", &mm, &m, &n);
        m -= mm;
        for (int i = 1; i <= n; i++)scanf("%d%d", &w[i], &v[i]);
        for (int i = 1; i <= n; i++)
            for (int j = v[i]; j <= m; j++)
                dp[j] = min(dp[j], dp[j - v[i]] + w[i]);
        if (dp[m] == 0x3f3f3f3f)puts("This is impossible.");
        else printf("The minimum amount of money in the piggy-bank is %d.\n", dp[m]);
    }
    return 0;
}

CF1525D
题意：给定一个01数组，求使得每个1都不在原来位置的最小移动距离
$d p [i] [j]$ 表示将前i个1移动到前j个0中的最小移动距离
可以分为2种情况
1）将前 $i$ 个1移动到前 $j - 1$ 个0中去
2）将前 $i - 1$ 个1移动到前 $j - 1$ 个0中去，第 $i$ 个1移动到第 $j$ 个0上

$p s 1 [i]$ 表示第 $i$ 个1的下标
$p s 2 [i]$ 表示第 $i$ 个0的下标

状态转移方程

$d p [i] [j] = m a x (d p [i] [j - 1], d p [i - 1] [j - 1] + a b s (p s 1 [i] - p s 2 [j])$

#include<iostream>
#include<algorithm>
#include<vector>
#include<cstring>

using namespace std;
int n, a[5010];
int dp[2510][5010];
int ps1[5010], ps2[5010], cnt1, cnt2;

int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
        if (a[i] == 1)ps1[++cnt1] = i;
        else ps2[++cnt2] = i;
    }
    memset(dp, 0x3f, sizeof dp);
    for (int i = 0; i <= cnt2; i++)dp[0][i] = 0;
    for (int i = 1; i <= cnt1; i++)
        for (int j = i; j <= cnt2; j++)
            dp[i][j] = min(dp[i][j - 1], dp[i - 1][j - 1] + abs(ps1[i] - ps2[j]));
    cout << dp[cnt1][cnt2] << endl;
    return 0;
}

HDU-1176
在这里插入图片描述

题意：假设在接下来的一段时间里，馅饼都掉落在0-10这11个位置。开始时gameboy站在5这个位置，因此在第一秒，他只能接到4,5,6这三个位置中其中一个位置上的馅饼。问gameboy最多可能接到多少个馅饼？
思路：转化为二维矩阵表
在这里插入图片描述

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>

using namespace std;
typedef long long ll;
const int N = 1e5 + 10;
int x, t, n, dp[N][11];

int main() {
    while (scanf("%d", &n), n) {
        memset(dp, 0, sizeof dp);
        int m = 0;
        for (int i = 1; i <= n; i++) {
            scanf("%d%d", &x, &t);
            dp[t][x]++;
            m = max(m, t);
        }
        for (int i = m - 1; i >= 0; i--)
            for (int j = 0; j < 11; j++)
                dp[i][j] += max(dp[i + 1][j], max(dp[i + 1][min(10, j + 1)], dp[i + 1][max(0, j - 1)]));
        cout << dp[0][5] << endl;
    }
    return 0;
}

HDU-1074

题意：有n门作业，每门作业有3个属性，作业名字，截止时间，完成这个作业需要的时间
按照作业名字的字典序输入，每门作业每晚一天完成就扣一分，找到一个完成作业的顺序，按照字典序依次输出完成作业名字，使扣的分数最小（1<=n<=15）
思路：明显状压dp，具体细节见代码注释

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
const int N = 1 << 16;
int t, n, d[20], c[20], dp[N], f[N], pre[N];
// dp[i]表示到达i这个状态需要的时间
//f[i]表示到达i这个状态扣的最少分
//pre[i]表示到达了状态i的最后一步是选择了哪个作业，用于输出顺序
string s[20];
void out(int x) {//递归输出
    if (!x)return;
    out(x ^ (1 << pre[x]));
    cout << s[pre[x]] << endl;
}
int main() {
    cin >> t;
    while (t--) {
        cin >> n;
        memset(f, 0x3f, sizeof f);
        f[0] = 0;
        for (int i = 0; i < n; i++)cin >> s[i] >> d[i] >> c[i];
        for (int i = 1; i < 1 << n; i++)
            for (int j = 0; j < n; j++) {
                if (!(i >> j & 1))continue;
                dp[i] = dp[i ^ (1 << j)] + c[j];
                int x = max(0, dp[i] - d[j]);//完成这门作业要扣多少分
                if (f[i] >= f[i ^ (1 << j)] + x) {
                //这里用的是 >= 因为 pre[i]表示到达了状态i的最后一步是选择了哪个作业
                //题目要求字典序最小，那么要让j尽可能大
                    f[i] = f[i ^ (1 << j)] + x;
                    pre[i] = j;
                }
            }
        int x = (1 << n) - 1;
        cout << f[x] << endl;
        out(x);
    }
    return 0;
}

POJ-3186
题意：有一个双向队列，可以从中取数，取出的第k个数乘以k就是这个数的价值，然后求所有数的最大价值。

区间dp
dp[i][j]表示还剩下i~j的数的最大值
转移方程：
$d p [i] [j] = m a x (d p [i - 1] [j] + a [i - 1] * (n - j + i - 1), d p [i] [j + 1] + a [j + 1] * (n - j + i - 1))$

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

using namespace std;
int n, a[2010], dp[2010][2010];

int main() {
    cin >> n;
    int res = 0;
    for (int i = 1; i <= n; i++)scanf("%d", &a[i]);
    for (int i = 1; i <= n; i++)
        for (int j = n; j >= i - 1; j--) {
            dp[i][j] = max(dp[i - 1][j] + a[i - 1] * (n - j + i - 1), 
            		   dp[i][j + 1] + a[j + 1] * (n - j + i - 1));
            res = max(res, dp[i][j]);
        }
    cout << res << endl;
    return 0;
}

HDU-2859
题意：给定 $n * n$ 的字符矩阵，求其中最大的对称矩阵
对称矩阵：关于 $y = x$ 直线对称
$d p [i] [j]$ 表示以点(i,j)为左下角的最大对称矩阵
那么 $d p [i] [j]$ 可以由 $d p [i - 1] [j + 1]$ 转移来

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>

using namespace std;
typedef long long ll;
int n, dp[1010][1010];
char s[1010][1010];

int main() {
    while (cin >> n, n) {
        int res = 1;
        for (int i = 1; i <= n; i++)scanf("%s", s[i] + 1);
        for (int i = 1; i <= n; i++) {
            for (int j = n; j >= 1; j--) {
                if (i == 1 || j == n)dp[i][j] = 1;
                else {
                    int x = i - 1, y = j + 1;
                    while (x >= 1 && y <= n && s[x][j] == s[i][y])x--, y++;
                    dp[i][j] = min(dp[i - 1][j + 1] + 1, i - x);
                }
                res = max(res, dp[i][j]);
            }
        }
        cout << res << endl;
    }
    return 0;
}

POJ-1661
先按高度从小到大排
$d p [i] [0]$ 表示第i个平台往左走到地面的最少时间
$d p [i] [1]$ 表示第i个平台往右走到地面的最少时间

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>

using namespace std;
typedef long long ll;

struct node {
    int h, l, r;

    bool operator<(const node &b) const {
        return h < b.h;
    }
} s[1010];

int t, n, x, y, m, dp[1010][2];

int main() {
    scanf("%d", &t);
    while (t--) {
        memset(dp, 0, sizeof dp);
        scanf("%d%d%d%d", &n, &x, &y, &m);
        s[0].l = s[0].r = x, s[0].h = y;
        for (int i = 1; i <= n; i++)scanf("%d%d%d", &s[i].l, &s[i].r, &s[i].h);
        sort(s, s + n + 1);
        for (int i = 0; i <= n; i++) {
            int j;
            for (j = i - 1; j >= 0; j--) {
                if (s[i].h - s[j].h <= m && s[i].l <= s[j].r && s[i].l >= s[j].l) {
                    dp[i][0] = s[i].h - s[j].h + min(dp[j][0] + s[i].l - s[j].l, dp[j][1] + s[j].r - s[i].l);
                    break;
                }
            }
            if (j < 0) {
                if (s[i].h > m)dp[i][0] = 0x3f3f3f3f;
                else dp[i][0] = s[i].h;
            }
            for (j = i - 1; j >= 0; j--) {
                if (s[i].h - s[j].h <= m && s[i].r <= s[j].r && s[i].r >= s[j].l) {
                    dp[i][1] = s[i].h - s[j].h + min(dp[j][1] + s[j].r - s[i].r, dp[j][0] + s[i].r - s[j].l);
                    break;
                }
            }
            if (j < 0) {
                if (s[i].h > m)dp[i][1] = 0x3f3f3f3f;
                else dp[i][1] = s[i].h;
            }
        }
        cout << min(dp[n][0], dp[n][1]) << endl;
    }
    return 0;
}

POJ-3666
题意：给定一个数组，求将这个数组变成非降或非升序列的最小花费
$d p [i] [j]$ 表示将前i个数变成上升序列，且第i个数为j的最小花费
$d p [i] [j] = a b s (j - w [i]) + m i n (d p [i - 1] [k]) (k < = j)$
而 $d p [i - 1] [k]$ 可以用一个变量m来维护
由于a[i]<=1e9所以第二维存不下
由于不是求严格单调序列，所以可以发现，这个j啊，他为a[i]中的某一个时才是最优的
那么就不需要遍历全部的了，只需遍历 $j - > (a [1]$ ~ $a [n])$

#include<iostream>
#include<cstdio>
#include<algorithm>

using namespace std;
const int N = 2010;
int n, a[N], b[N], dp[N];

int main() {
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)scanf("%d", &a[i]), b[i] = a[i];
    sort(b + 1, b + 1 + n);
    for (int i = 1; i <= n; i++) {
        int m = 0x3f3f3f3f;
        for (int j = 1; j <= n; j++) {
            m = min(m, dp[j]);
            dp[j] = abs(b[j] - a[i]) + m;
        }
    }
    int res = 0x3f3f3f3f;
    for (int i = 1; i <= n; i++)res = min(res, dp[i]), dp[i] = 0;
    for (int i = n; i >= 1; i--) {
        int m = 0x3f3f3f3f;
        for (int j = n; j >= 1; j--) {
            m = min(m, dp[j]);
            dp[j] = abs(b[j] - a[i]) + m;
        }
    }
    for (int i = 1; i <= n; i++)res = min(res, dp[i]);
    cout << res << endl;
    return 0;
}

02PHC

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
基础DP练习

HDU-1024题意：把一个数组分成不相交的恰好m段，求最大字段和dp[i][j]dp[i][j]dp[i][j]将前iii个数分成jjj段的最大值2种情况1）第i个数自成一组2）第i个数和第i-1个数在同一组dp[i][j]=max(dp[i−1][j],dp[k][j−1])+a[i](1<=k<=i−1)dp[i][j]=max(dp[i-1][j],dp[k][j-1])+a[i](1<=k<=i-1)dp[i][j]=max(dp[i−1][j],dp[k][j
复制链接

扫一扫