线性Dp题目

最新推荐文章于 2024-10-05 19:23:25 发布

zwj@yj

最新推荐文章于 2024-10-05 19:23:25 发布

阅读量74

点赞数

文章标签：算法数据结构 Powered by 金山文档

本文链接：https://blog.csdn.net/m0_69306938/article/details/129168618

版权

U279551 数字三角形

题目描述

给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。

        7
      3   8
    8   1   0
  2   7   4   4
4   5   2   6   5

输入格式

第一行包含整数 n ，表示数字三角形的层数

接下来 n 行，每行包含若干整数，其中第 i 行表示数字三角形第 i 层包含的整数。

输出格式

输出一个整数，表示最大的路径数字和。

输入输出样例

输入 #1复制

3 8

8 1 0

2 7 4 4

4 5 2 6 5

输出 #1复制

说明/提示

1 ≤ n ≤ 500

−10000 ≤ 三角形中的整数 ≤ 10000

题解

动态规划 Dp

f[i][j] 用一个数代表某个集合

f[][] 考虑一下这个数组有几维

1. 这个数组代表的集合是什么？

（1）数组是存的是一个数, 存的这个数代表

集合中的什么属性(Max, min, cnt)

2. 这个集合怎么算

3 8

8 1 -100 0

2 7 4 4

4 5 2 6 5

f[3, 2] 表示所有从[1, 1] 开始走, 走到 [3, 2] 这个位置的所有走法

f[3, 2] = 16

f[i][j]

1. 集合：所有从(1, 1) 开始走, 走到(i, j) 这个位置的所有走法的集合

数(属性) ： Max

2. 集合计算：

f[i, j] = max(f[i - 1, j], f[i - 1, j - 1]) + g[i, j];

f[1, 1] = g[1, 1]

3. 初始化（边界）

4. 时间复杂度 O(n^2)

0，1，1，

f[x] = f[x - 1] + f[x - 2];

代码

#include <iostream>
#include <stdlib.h>

using namespace std;

const int N = 510, INF = 1e9;

int n;
int g[N][N], f[N][N];

int main()
{
//    system("color f1");
    cin >> n;
    
    for (int i = 0; i <= n; i ++ )
        for (int j = 0; j <= n; j ++ )
            f[i][j] = -INF;
    
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= i; j ++ )
            cin >> g[i][j];
    
    f[1][1] = g[1][1];        
    for (int i = 2; i <= n; i ++ )
        for (int j = 1; j <= i; j ++ )
            f[i][j] = max(f[i - 1][j - 1], f[i - 1][j]) + g[i][j];
    
        
    int res = -INF;
    
    for (int i = 1; i <= n; i ++ ) 
        res = max(res, f[n][i]);
    
    
    cout << res << endl;
    
    return 0;
}

U279552 最长上升子序列

题目描述

给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。

输入格式

第一行包含整数 N 。

第二行包含 N 个整数，表示完整序列。

输出格式

输出一个整数，表示最大长度。

输入输出样例

输入 #1复制

3 1 2 1 8 5 6

输出 #1复制

说明/提示

1≤N≤1000

−1000≤数列中的数≤1000

题解

f[i]

1. 集合：所有以 a[i] 结尾的上升子序列的集合

数(属性) ： max

2. 计算集合：

f[i] = max(f[1], f[2], ... f[i - 1]) + 1;

3. 边界(初始化) f[0] = 0, f[i] = 1; i >= 1

5 3 2

、

4. 时间复杂度 O(n^2)

3 1 2 1 8 5 6

代码

#include <iostream>

using namespace std;

const int N = 1010;

int a[N];
int f[N];

int main()
{
    int n;
    cin >> n;
    for (int i = 1; i <= n; i ++ ) cin >> a[i];
    
    for (int i = 1; i <= n; i ++ )
    {
        f[i] = 1;   // 算f[i] 只会用到 f[1 ~ i - 1]; 
                    // f[1] 的时候 f[0] 已经算过
                    // f[2] 的时候 f[1] 已经算过
                    // f[3] 的时候 f[1 ~ 2] 已经算过
                    // f[4] 的时候 f[1 ~ 3] 已经算过 
        for (int k = 1; k < i; k ++ )
            if (a[k] < a[i]) f[i] = max(f[i], f[k] + 1);
    }
    
    
    int res = 0;
    for (int i = 1; i <= n; i ++ ) res = max(res, f[i]);
    
    cout << res << endl;
    
    return 0;
    
}

U279548 最长公共子序列

题目描述

给定两个长度分别为 N 和 M 的字符串 A 和 B ，求既是 A 的子序列又是 B 的子序列的字符串长度最长是多少。

输入格式

第一行包含两个整数 N 和 M 。

第二行包含一个长度为 N 的字符串，表示字符串 A 。

第三行包含一个长度为 M 的字符串，表示字符串 B 。

字符串均由小写字母构成。

输出格式

输出一个整数，表示最大长度。

输入输出样例

输入 #1复制

4 5

acbd

abedc

输出 #1复制

说明/提示

1 ≤ N, M ≤1 000

题解

f[i, j]

1. 集合：

所有在a 的前 i 个字母出现，在 b 的前 j 个字母出现的公共子序列的集合

集合的 Max

2. 计算集合：

f[i, j] 一定是一下其中一种情况

1. a[i] 不在公共子序列中, b[j] 不在公共子序列中

f[i, j] = f[i - 1, j - 1];

2. a[i] 不在公共子序列, b[j] 在

f[i, j] = f[i - 1, j]

3. a[i] 在， b[j] 不在

f[i, j] = f[i, j - 1];

4. a[i] 在, b[j] 在

if (a[i] == b[j])

f[i, j] = f[i - 1, j - 1] + 1;

初始化(边界)

3. f[0, i] = 0, f[i, 0] = 0;

4. O(n^2)

代码

#include <iostream>

using namespace std;

const int N = 1010;

int n, m;
int f[N][N]; 
char a[N], b[N];

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

U279553 最短编辑距离

题目描述

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

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

现在请你求出，将 A 变为 B 至少需要进行多少次操作。

输入格式

第一行包含整数 n ，表示字符串 A 的长度。

第二行包含一个长度为 n 的字符串 A 。

第三行包含整数 m ，表示字符串 B 的长度。

第四行包含一个长度为 m 的字符串 B 。

字符串中均只包含大小写字母。

输出格式

输出一个整数，表示最少操作次数。

输入输出样例

输入 #1复制

AGTCTGACGC

AGTAAGTAGGC

输出 #1复制

说明/提示

1≤n,m≤1000

说明/提示

1 ≤ N, M ≤1 000

题解

AGTaaGtAgGC

AGTAAGTAGGC

4 次

f[i, j]

1. 集合：将 a[1 ~ i] 这个字符串变成 b[1 ~ j] 的所有操作方法的集合

数(属性)： min

2. 计算集合：

f[i, j] 一定是从一下三种方法变成的, 我们只需求出这三种取Min

看第 a的 i 个字母

1. 删 a[i]

f[i, j] = f[i - 1, j] + 1;

2. 增 a[i + 1]

f[i, j] = f[i, j - 1] + 1;

3. 改

(1) a[i] == b[j] 不用改

(2) a[i] != b[j] 改

f[i, j] = f[i - 1, j - 1] + 0 / 1;

3. 边界

f[i][0] = i, f[0, i] = i;

4. 时间

O(n^2)

代码

#include <iostream>
using namespace std;
const int N = 1010;
int n, m;
int f[N][N];
char a[N], b[N];
int main()
{
cin >> n >> a + 1 >> m >> b + 1;
for (int i = 0; i <= n; i ++ ) f[i][0] = i;
for (int i = 0; i <= m; i ++ ) f[0][i] = i;
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= m; j ++ )
{
f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);
if (a[i] == b[j]) f[i][j] = min(f[i - 1][j - 1], f[i][j]);
else f[i][j] = min(f[i - 1][j - 1] + 1, f[i][j]);
}
cout << f[n][m] << endl;
return 0;
}