动态规划02-线性 DP

yzd111

于 2024-08-24 19:49:07 发布

阅读量566

点赞数 12

分类专栏：算法动态规划文章标签：动态规划算法

本文链接：https://blog.csdn.net/yzd111/article/details/141503967

版权

算法同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

动态规划

8 篇文章 0 订阅

订阅专栏

数字三角形

给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
输入格式
第一行包含整数 $n$ ，表示数字三角形的层数。接下来 $n$ 行，每行包含若干整数，其中第 $i$ 行表示数字三角形第 $i$ 层包含的整数。
输出格式
输出一个整数，表示最大的路径数字和。
数据范围
$1 \leq n \leq 500$ , $- 10000 \leq 三角形中的整数 \leq 10000$
输入样例
5
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
输出样例
30

解决思路

这个题的解决思路比较简单，对于任意一个位置的数来讲，仅可以从左上方和右上方走到该位置，因此状态转移方程为 $d p [i] [j] = ma x (d p [i - 1] [j - 1], d p [i - 1] [j + 1]) + g [i] [j]$

代码实现

#include <iostream>
using namespace std;

const int N = 510, M = 1010;
int n;
int g[N][M];
bool st[N][M];
int dp[N][M];

int main()
{
    cin >> n;
    //使用双指针完成输入
    int l, r;
    l = r = n - 1;
    for(int i = 0; i < n; i++)
    {
        int x;
        for(int j = l; j <= r; j = j + 2)
        {
            cin >> x;
            g[i][j] = x;
            st[i][j] = true;
        }
        l--;
        r++;
    }
    int res = -1e9;
    l = r = n - 1;
    dp[0][n-1] = g[0][n-1];
    l--;
    r++;
    for(int i = 1; i < n; i++)
    {
        for(int j = l; j <= r; j = j + 2)
        {
            if(j != l && j != r)
            {
                dp[i][j] = max(dp[i-1][j-1],dp[i-1][j+1]) + g[i][j];
            }else if(j == l){
                dp[i][j] = dp[i - 1][j + 1] + g[i][j];
            }else if(j == r)
            {
                dp[i][j] = dp[i - 1][j - 1] + g[i][j];
            }
        }
        l--;
        r++;
    }
    for(int j = 0; j < 2*n -1; j = j + 2)
    {
        
        res = max(res,dp[n-1][j]);
    }
    cout << res << endl;
    return 0;
}

最长上升子序列 I

给定一个长度为 $N$ 的数列，求数值严格单调递增的子序列的长度最长是多少。
输入格式
第一行包含整数 $N$ 。第二行包含 $N$ 个整数，表示完整序列。
输出格式
输出一个整数，表示最大长度。
数据范围
$1 \leq N \leq 1000$ ，
$10^9≤数列中的数≤10^9$
输入样例
7
3 1 2 1 8 5 6
输出样例
4

解决思路

关于一个 $d p$ 问题我们首先要搞清楚当前的集合是几维，要满足可以解决该问题同时维数最小这一要求，对于本问题我们仅需要一个一维数组 $d p [i]$ ，接着我们需要知道当前的集合代表的意义，比如在背包问题中 $d p [i] [j]$ 往往代表的是在只从前 $i$ 个物品中选，且体积不大于 $j$ 的选法的集合，在三角形问题中 $d p [i] [j]$ 代表的是所有可以走到最底层的路径。而在本问题中 $d p [i]$ 代表的含义则是以第 $i$ 个数结尾的所有上升子序列。接着我们需要找到该集合的属性，对于本问题就是最大值 $ma x$ 。接下来确定了集合的状态表示之后我们需要对该集合进行计算，首先来进行集合划分，对于本问题因为所有的子序列的最后一个数都是第 $i$ 个数，那么可以使用最后一个数的前一个数进行表示，对 $j (0, 1, 2, ..., i - 1)$ 进行遍历，得到以第 $i$ 个数结尾的所有上升子序列长度的最大值。状态转换方程为 $d p [i] = ma x (d p [i], d p [j] + 1)$ ，最终从这 $i$ 个数中选择最大值得到答案。

代码实现

#include <iostream>
using namespace std;

const int N = 1010;
int dp[N], l[N];
int n;

int main()
{
    cin >> n;
    int res = 0;
    for(int i = 0; i < n; i++)
    {
        cin >> l[i];
    }
    //集合dp[i]:以第i个数结尾的所有的上升子序列
    //属性:最大值
    //状态转移方程dp[i] = max(dp[i],dp[j]+1);
    //j从0到i-1;
    for(int i = 0; i < n; i++)
    {
        //初始长度为 1
        dp[i] = 1;
        for(int j = 0; j < i; j++)
        {
            if(l[i] > l[j])
            {
                dp[i] = max(dp[i],dp[j] + 1);
            }
        }
        res = max(res,dp[i]);
    }
    cout << res << endl;
}

最长上升子序列 II

给定一个长度为 $N$ 的数列，求数值严格单调递增的子序列的长度最长是多少。
输入格式
第一行包含整数 $N$ 。第二行包含 $N$ 个整数，表示完整序列。
输出格式
输出一个整数，表示最大长度。
数据范围
$1 \leq N \leq 100000$ ，
$10^9≤数列中的数≤10^9$
输入样例
7
3 1 2 1 8 5 6
输出样例
4

解决思路

对于这个问题，我们的数据的数据范围成为十万，那么对于之前的 $n^2$ 的时间的复杂度的做法显然是会造成超时，因此我们需要去除一些冗余项。对于一定长度的上升子序列我们仅需要存储最后一位中最小的那个数，例如对于长度为 $1$ 的子序列，子序列 $3$ 和子序列 $1$ 相比显然在后面可以容纳的长度要小，因此我们就可以省略它。我们定义一个数组 $q$ 用来存储不同长度的子序列最后的一个数的最小值。

对于每个元素都要在 $q$ 数组中找到小于它的最大的一个元素，对于这个可以使用二分查找算法。然后将更新数组。以上图为例，由于小于 $a_i$ 的最大的数是 $q_4$ ，此时由于 $q_5$ 是大于等于 $a_i$ 的，因此只能让 $a_i$ 替换上 $q_5$ ，而不是从中间插入，需要舍弃原来的 $q_5$ 和 $q_6$ 。

代码实现

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

const int N = 1e5 + 10;
int a[N], q[N];
int n;

int main()
{
    cin >> n;
    int res = 0;
    for(int i = 1; i <= n; i++)
    {
        cin >> a[i];
    }
    
    int len = 0;
    q[0] = -2e9;
    for(int i = 1; i <= n; i++)
    {
        int l = 0, r = len;
        while(l < r)
        {
            int mid = (l + r + 1) >> 1;
            if(q[mid] < a[i])
            {
                l = mid;
            }else
            {
                r = mid - 1;
            }
        }
        len = max(len, r + 1);
        q[l + 1] = a[i];
    }
    
    cout << len << endl;
    return 0;
}

最长公共子序列

给定两个长度分别为 $N$ 和 $M$ 的字符串 $A$ 和 $B$ ，求既是 $A$ 的子序列又是 $B$ 的子序列的字符串长度最长是多少。
输入格式
第一行包含两个整数 $N$ 和 $M$ 。
第二行包含一个长度为 $N$ 的字符串，表示字符串 $A$ 。
第三行包含一个长度为 $M$ 的字符串，表示字符串 $B$ 。
字符串均由小写字母构成。
输出格式
输出一个整数，表示最大长度。
数据范围
$1 \leq N, M \leq 1000$
输入样例
4 5
acbd
abedc
输出样例
3

解决思路

集合表示:
第一个序列中前i个数和第二个序列中前j个数的公共子序列
集合属性:
max
集合划分:
以第i个数和第j个数是否被选择定为集合的划分条件，因此共有四种情况。
状态转移:

i和j都不选dp[i][j] = dp[i - 1][j - 1]
i和j都选dp[i][j] = dp[i-1][j-1] + 1
i和j选择其中一个，这个是这四种情况中最不好理解的类别，我们无法进行直接表示。以dp[i][j - 1]举例，它的含义是第一个序列中前i个数和第二个序列中前j-1个数中的所有公共子序列，但不是在dp[i - 1][j - 1]的基础上一定选择第i个数不选择第j个数的情况，但幸运的是，本题仅仅需要的是最大值，而我们需要的情况一定是在dp[i][j - 1]的情况中，而dp[i][j - 1]会包含在dp[i][j]之中，因此，我们不需要担心会超出，仅仅有一些重复，但是并不会对最终结果有影响。

代码实现

#include <iostream>
using namespace std;

const int N = 1010;
int n, m;
char A[N], B[N];
int dp[N][N];

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; i++)
    {
        cin >> A[i];
    }
    for(int i = 1; i <= m; i++)
    {
        cin >> B[i];
    }
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            dp[i][j] = max(dp[i - 1][j],dp[i][j - 1]);
            if(A[i] == B[j])
            {
                dp[i][j] = max(dp[i - 1][j - 1] + 1, dp[i][j]);
            }
        }
    }
    cout << dp[n][m] << endl;
    return 0;
}

最短编辑距离

给定两个字符串 $A$ 和 $B$ ，现在要将 $A$ 经过若干操作变为 $B$ ，可进行的操作有：

删除–将字符串 $A$ 中的某个字符删除。
插入–在字符串 $A$ 的某个位置插入某个字符。
替换–将字符串 $A$ 中的某个字符替换为另一个字符。

现在请你求出，将 $A$ 变为 $B$ 至少需要进行多少次操作。
输入格式
第一行包含整数 $n$ ，表示字符串 $A$ 的长度。
第二行包含一个长度为 $n$ 的字符串 $A$ 。
第三行包含整数 $m$ ，表示字符串 $B$ 的长度。
第四行包含一个长度为 $m$ 的字符串 $B$ 。
字符串中均只包含大小写字母。
输出格式
输出一个整数，表示最少操作次数。
数据范围
$1 \leq n, m \leq 1000$
输入样例
10
AGTCTGACGC
11
AGTAAGTAGGC
输出样例
4

解决思路

集合状态

使用 $d p [i] [j]$ 表示将字符串 $A$ 的前 $i$ 个字符转换为字符串 $B$ 前 $j$ 个字符的转换方式

集合属性

转换方式的最小值

集合划分

分为插入操作，删除操作，替换操作
插入操作：
我们在分析时都以最后状态的前一个状态进行分析，如果当前字符串 $A$ 仅需要插入操作可以使得相同，那么也就代表字符串 $A$ 的前 $i$ 个字符和字符串 $B$ 的前 $j - 1$ 个字符是相等的。
$d p [i] [j] = d p [i] [j - 1] + 1$
删除操作：
字符串 $A$ 的前 $i - 1$ 个字符和字符串 $B$ 的前 $j$ 个字符是相等的。
$d p [i] [j] = d p [i - 1] [j] + 1$
替换操作：
字符串 $A$ 的前 $i - 1$ 个字符和字符串 $B$ 的前 $j - 1$ 个字符是相等的。同时根据第 $i$ 个和第 $j$ 个字符是否相同进行判断是否进行操作。
$d p [i] [j] = d p [i - 1] [j - 1] + 1/0$

状态转移

$d p [i] [j] = min (d p [i] [j - 1] + 1, d p [i - 1] [j] + 1, d p [i - 1] [j - 1] + 1/0)$

代码实现

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

const int N = 1010;
char A[N], B[N];
int dp[N][N];
int n, m;

int main()
{
    cin >> n;
    for(int i = 1; i <= n; i++)
    {
        cin >> A[i];
    }
    cin >> m;
    for(int i = 1; i <= m; i++)
    {
        cin >> B[i];
    }
    //分别对于i为0和j为0的情况进行处理
    //初始化首行首列
    for(int i = 0; i <= m; i++)
    {
        dp[0][i] = i;
    }
    for(int i = 0; i <= n; i++)
    {
        dp[i][0] = i;
    }
    for(int i = 1; i <= n; i++)
    {
        for(int j = 1; j <= m; j++)
        {
            int c;
            if(A[i] != B[j])
            {
                c = dp[i - 1][j - 1] + 1;;
            }else
            {
                c = dp[i - 1][j - 1];
            }
            dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1);
            dp[i][j] = min(dp[i][j], c);
        }
    }
    cout << dp[n][m] << endl;
    return 0;
}