1、数字三角形(基础模型)
注:行列表示
集合
f [ i ] [ j ] f[i][j] f[i][j]:所有从起点 ( 1 , 1 ) (1,1) (1,1),走到 ( i , j ) (i,j) (i,j) 的路径上的数值和的最大值。
集合划分:
- 来自左上的最大值: f [ i ] [ j ] = f [ i − 1 ] [ j − 1 ] + a [ i ] [ j ] f[i][j] = f[i-1][j-1] + a[i][j] f[i][j]=f[i−1][j−1]+a[i][j]
- 来自右上的最大值: f [ i ] [ j ] = f [ i − 1 ] [ j ] + a [ i ] [ j ] f[i][j] = f[i-1][j] + a[i][j] f[i][j]=f[i−1][j]+a[i][j]
状态计算:
f
[
i
]
[
j
]
=
m
a
x
(
f
[
i
−
1
]
[
j
−
1
]
,
f
[
i
−
1
]
[
j
]
)
+
a
[
i
]
[
j
]
f[i][j]= max(f[i-1][j-1], f[i-1][j]) + a[i][j]
f[i][j]=max(f[i−1][j−1],f[i−1][j])+a[i][j]
注意: 矩阵
f
[
N
]
[
N
]
f[N][N]
f[N][N] 的初始化,由于状态方程的计算中存在
[
i
−
1
,
j
−
1
]
[i-1,j-1]
[i−1,j−1],故行要将多出来的第
0
0
0 行初始化为
−
I
N
F
-INF
−INF,列要将多出来的第
0
0
0 列和第
i
+
1
i+1
i+1 列初始化为
−
I
N
F
-INF
−INF,因为当取值从右上传过来的时候需要多出一列
−
I
N
F
-INF
−INF。
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 510, INF = 0x3f3f3f3f;
int n, w, f[N][N];
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i ++ )
for (int j = 0; j <= i + 1; j ++ )
f[i][j] = -INF;
int res = -INF;
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= i; j ++ ) {
scanf("%d", &w);
if (i == 1 && j == 1) f[i][j] = w;
else f[i][j] = max(f[i - 1][j - 1], f[i - 1][j]) + w;
if (i == n) res = max(res, f[n][j]);
}
printf("%d\n", res);
return 0;
}
2、摘花生
注: 算法题和传统数学题的坐标系是不一样的,下图是算法题中的坐标。
集合
f[i,j]
:所有从起点(1, 1)
,走到(i, j)
的路径上的花生数量最大值
集合划分:
状态计算:
f[i, j] = max(f[i - 1, j] + w[i, j], f[i, j - 1] + w[i, j])
注意区分:
这个题的代码和上个题的代码中f[1][1]
的初始化不同,因为上一个题中三角形的数据有可能是负数,所以最初f[i][j]
中的所有数据要初始为-INF
,然后将f[1][1]
初始化为a[1][1]
,如果过没有f[1][1] = a[1][1]
的初始化,那么结果将是比-INF
略大的数据。
而本题是所有花生的数量均为正数,所以f[i][j]
初始化为0
即可。
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 110;
int n, m;
int w, f[N][N];
int main() {
int T; scanf("%d", &T);
while (T--) {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &w);
f[i][j] = max(f[i - 1][j], f[i][j - 1]) + w;
}
printf("%d\n", f[n][m]);
}
return 0;
}
3、最低通行费
由条件商人必须在 (2N−1) 个单位时间穿越出去
且该图是一个正方形
,故可以得出结论:商人在走路的过程中不可以走回头路!
几点注意:
- 这个题求的是最小值,所以要对边界做初始化;
- 对于
f[1][1]
的初始化,理由同第一题,边界上有INF
都要注意初始化,如果不做特殊处理,因为它的值有两个方向决定,而这两个方向都带有INF
(很重要这一点!)。
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 110, INF = 0x3f3f3f3f;
int n;
int w, f[N][N];
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i++) f[i][0] = f[0][i] = INF;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
scanf("%d", &w);
if (i == 1 && j == 1) f[i][j] = w;
else f[i][j] = min(f[i - 1][j], f[i][j - 1]) + w;
}
printf("%d\n", f[n][n]);
return 0;
}
4、方格取数
算法思路:与摘花生类似
同时走,走两次:
f[i1, j1, i2, j2]
:表示所有从(1, 1)、(1, 1)
分别走到(i1, j1)、(i2, j2)
的路径的最大值;- 如何处理 ”同一个格子不能被重复选择” ?
- 什么时候它们会走到同一个格子呢?满足条件:
i1 + j1 = i2 + j2
并且它们的步数
相同的时候才会走到相同的格子,这里我们使用k
来到表它们的步数;
- 什么时候它们会走到同一个格子呢?满足条件:
- 状态优化(从四维降为三维):
f[k, i1, i2]
表示所有从(1, 1)、(1, 1)
分别走到(i1, k - i1)、(i2, k - i2)
的路径的最大值,其中k = i1 + j1 = i2 + j2
; - 集合划分(每条路径都是看最后一次怎么走):
- 第一类:第一条路径最后一次往
下
走,第二条路径最后一次往下
走; - 第二类:第一条路径最后一次往
下
走,第二条路径最后一次往右
走; - 第三类:第一条路径最后一次往
右
走,第二条路径最后一次往下
走; - 第四类:第一条路径最后一次往
右
走,第二条路径最后一次往右
走; - 如图:
- 第一类:第一条路径最后一次往
- 状态计算:
- 第一类:
- 第一条路径:
(1, 1) -> (i1 - 1, j1) -> (i1, j1)
- 第二条路径:
(1, 1) -> (i2 - 1, j2) -> (i2, j2)
- 对于两条路径前面一部分
(1, 1) -> (i1 - 1, j1) 和 (1, 1) -> (i2 - 1, j2)
的最大值即为max(f(k - 1, i1 - 1, i2 - 1))
- 对于后面一部分,要分情况考虑:
- 当两个结点重合的时候,
i1 = i2, j1 = j2
,就是它们之前上一个点走到的是同一个点,就只需要加上w(i1, j1)
; - 当两个结点不重合的时候,就需要加上:
w(i1, j1) + w(i2, j2)
;
- 当两个结点重合的时候,
- 第一条路径:
- 其他三类的最大值同理,最后结果为每一类的最大值再取一个最大值。
- 第一类:
注意:这个题不能分开走的原因
这样不能得到最大值。因为第一遍的最优解可能有非常多种方案,你并不能确定采用哪一种。第二遍的最大值依赖于第一遍选择哪种方案,而所有第一遍取最大值的方案数量可能是指数级别的。
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 15;
int n;
int w[N][N], f[N * 2][N][N];
int main() {
cin >> n;
int a, b, c;
while (cin >> a >> b >> c, a || b || c) w[a][b] = c;
for (int k = 2; k <= n + n; k++)
for (int i1 = 1; i1 <= n; i1++)
for (int i2 = 1; i2 <= n; i2++) {
int j1 = k - i1, j2 = k - i2;
if (j1 >= 1 && j1 <= n && j2 >= 1 && j2 <= n) {
int t = w[i1][j1];
if (i1 != i2) t += w[i2][j2];
int &x = f[k][i1][i2];
x = max(x, f[k - 1][i1 - 1][i2 - 1] + t);
x = max(x, f[k - 1][i1 - 1][i2] + t);
x = max(x, f[k - 1][i1][i2 - 1] + t);
x = max(x, f[k - 1][i1][i2] + t);
}
}
cout << f[n + n][n][n];
return 0;
}
更简洁的写法
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 15;
int n;
int w[N][N], f[N * 2][N][N];
int main() {
scanf("%d", &n);
int a, b, c;
while (scanf("%d%d%d", &a, &b, &c), a || b || c) w[a][b] = c;
for (int k = 2; k <= n + n; k++)
for (int i1 = 1; i1 <= n; i1++)
for (int i2 = 1; i2 <= n; i2++) {
int j1 = k - i1, j2 = k - i2;
if (j1 < 1 || j1 > n || j2 < 1 || j2 > n) continue;
int t = w[i1][j1];
if (j1 != j2) t += w[i2][j2];
for (int a = 0; a <= 1; a++)
for (int b = 0; b <= 1; b++)
f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][i1 - a][i2 - b] + t);
}
printf("%d\n", f[n + n][n][n]);
return 0;
}
5、传纸条
注:从右下角回传可以等价为从左上角同时传两次
集合
f[k,x1,x2]
:所有第一条线路从[1,1]
走到[x1,k-x1]
,第二条线路从[1,1]
走到[x2,k-x2]
的路线组合的最大值,其中k = x1 + y1 = x2 + y2
,k
代表步数。
集合划分
按两条路线最后一步走的方向来划分:
状态计算
第一类
- 第一条路线:
[1, 1] → [x1, k-1-x1] → [x1, k-x1]
; - 第二条路线:
[1, 1] → [x2, k-1-x2] → [x2, k-x2]
; - 两条路线前
k-1
步计算简单:max(f[k-1,x1,x2])
; - 最后一步:如果两条路线在这一步走到的点重合,就相加一次,否则加两次。
第二类
- 第一条路线:
[1, 1] → [x1, k-1-x1] → [x1, k-x1]
; - 第二条路线:
[1, 1] → [x2-1, k-x2] → [x2, k-x2]
; - 两条路线前
k-1
步计算简单:max(f[k-1,x1,x2-1])
; - 最后一步:如果两条路线在这一步走到的点重合,就相加一次,否则加两次。
其余两个状态分析类似。
注意
- 这个题和上一题的区别在于:如果重合就表示有一条路不让走了,但是上一题无此约束;
- 矩阵中所有值非负,所以矩阵可以初始化为
0
; - 对于
x1
的取值,因为有1 <= x1 <= n
且1 <= k-x1 <= m
,所以有max(1, k-m) <= x1 <= max(k-1, n)
,x2
的范围同理; - 不允许走同一个点的体现:除了起点和终点之外,只有
i != j
时,才能去更新其它状态,这样就保证了不走同一个格子。 关于这个证明看链接。
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 55;
int n, m;
int w[N][N], f[N * 2][N][N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
scanf("%d", &w[i][j]);
for (int k = 2; k <= n + m; k++)
for (int x1 = max(1, k - m); x1 <= min(k - 1, n); x1++)
for (int x2 = max(1, k - m); x2 <= min(k - 1, n); x2++) {
int t = w[x1][k - x1];
if (x2 != x1) t += w[x2][k - x2];
for (int a = 0; a <= 1; a++)
for (int b = 0; b <= 1; b++)
f[k][x1][x2] = max(f[k][x1][x2], f[k - 1][x1 - a][x2 - b] + t);
}
printf("%d\n", f[n + m][n][n]);
return 0;
}
下面是使用上一个题的写法,一样能过。
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 55;
int n, m;
int w[N][N], f[N * 2][N][N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
scanf("%d", &w[i][j]);
for (int k = 2; k <= n + m; k++)
for (int i1 = 1; i1 <= n; i1++)
for (int i2 = 1; i2 <= n; i2++) {
int j1 = k - i1, j2 = k - i2;
if (j1 < 1 || j1 > m || j2 < 1 || j2 > m) continue;
int t = w[i1][j1];
if (j1 != j2) t += w[i2][j2];
for (int a = 0; a <= 1; a++)
for (int b = 0; b <= 1; b++)
f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][i1 - a][i2 - b] + t);
}
printf("%d\n", f[n + m][n][n]);
return 0;
}
6、检查是否有合法括号字符串路径
对于一个括号序列,从左往右遍历每个字符,同时维护变量 n o w now now(初始值为 0 0 0)。遇到左括号时, n o w + = 1 now\ +=\, 1 now +=1,遇到右括号时, n o w − = 1 now\ -=\, 1 now −=1。如果过程中 n o w now now 始终非负,且最后 n o w now now 变成 0 0 0,则是合法序列。
对于本题,需要将
n
o
w
now
now 放进
d
p
dp
dp 状态里面,记
f
[
i
]
[
j
]
[
k
]
f[i][j][k]
f[i][j][k] 表示是否存在以格子
(
i
,
j
)
(i,j)
(i,j) 结尾,且
n
o
w
now
now 值为
k
k
k 的括号序列。由于只能往右或者往下走,存在如下状态转移方程:
f
(
i
,
j
,
k
)
←
{
f
(
i
−
1
,
j
,
k
−
c
)
i
f
(
i
>
0
)
从上面转移过来
f
(
i
,
j
−
1
,
k
−
c
)
i
f
(
j
>
0
)
从左边转移过来
f(i,j,k) \leftarrow \begin{cases} f(i-1, j, k - c) \ \ \ if(i>0) \ {从上面转移过来}\\ f(i, j - 1, k - c) \ \ \ if(j > 0) \ {从左边转移过来} \\ \end{cases}
f(i,j,k)←{f(i−1,j,k−c) if(i>0) 从上面转移过来f(i,j−1,k−c) if(j>0) 从左边转移过来
其中,若
g
r
i
d
[
i
]
[
j
]
=
′
(
′
grid[i][j] = \ '('
grid[i][j]= ′(′ ,则
c
=
1
c = 1
c=1,否则
c
=
−
1
c = -1
c=−1,并且
k
=
[
0
,
n
+
m
)
k = [0, n + m)
k=[0,n+m) (因为过程中
n
o
w
now
now 不能为负,且最长路径只有
n
+
m
−
1
n + m -1
n+m−1 这么长),初始值
f
[
0
]
[
0
]
[
1
]
=
t
r
u
e
f[0][0][1] = true
f[0][0][1]=true。时间复杂度为
O
(
n
m
(
n
+
m
)
)
O(nm(n + m))
O(nm(n+m))。
class Solution {
public:
bool hasValidPath(vector<vector<char>> &grid) {
if (grid[0][0] == ')') return false;
int n = grid.size(), m = grid[0].size();
vector<vector<vector<bool>>> f;
for (int i = 0; i < n; i++) {
f.push_back(vector<vector<bool>>());
for (int j = 0; j < m; j++) f.back().push_back(vector<bool>(n + m));
}
f[0][0][1] = true;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (i || j) {
int t = grid[i][j] == '(' ? 1 : -1;
for (int k = 0; k < n + m; k++) {
int kk = k - t;
if (kk < 0 || kk >= n + m) continue;
if (i) f[i][j][k] = f[i][j][k] || f[i - 1][j][kk];
if (j) f[i][j][k] = f[i][j][k] || f[i][j - 1][kk];
}
}
return f[n - 1][m - 1][0];
}
};