HDU-1024
题意:把一个数组分成不相交的恰好m段,求最大子段和
d
p
[
i
]
[
j
]
dp[i][j]
dp[i][j]将前
i
i
i个数分成
j
j
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
)
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)
m
a
x
(
d
p
[
k
]
[
j
−
1
]
)
(
1
<
=
k
<
=
i
−
1
)
max(dp[k][j-1])(1<=k<=i-1)
max(dp[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;
}
题意:给定数组,求最大上升子序列和
和求最长上升子序列长度一样,不过每次加的权值从1变为了 a [ i ] a[i] 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
]
)
;
dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
dp[i][j]=max(dp[i−1][j],dp[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
)
;
if(a[i]==b[j])dp[i][j]=max(dp[i][j],dp[i-1][j-1]+1);
if(a[i]==b[j])dp[i][j]=max(dp[i][j],dp[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
]
dp[i][j]
dp[i][j]表示将前i个1移动到前j个0中的最小移动距离
可以分为2种情况
1)将前
i
i
i个1移动到前
j
−
1
j-1
j−1个0中去
2)将前
i
−
1
i-1
i−1个1移动到前
j
−
1
j-1
j−1个0中去,第
i
i
i个1移动到第
j
j
j个0上
p
s
1
[
i
]
ps1[i]
ps1[i]表示第
i
i
i个1的下标
p
s
2
[
i
]
ps2[i]
ps2[i]表示第
i
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 ] ) dp[i][j]=max(dp[i][j-1],dp[i-1][j-1]+abs(ps1[i]-ps2[j]) dp[i][j]=max(dp[i][j−1],dp[i−1][j−1]+abs(ps1[i]−ps2[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;
}
题意:假设在接下来的一段时间里,馅饼都掉落在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;
}
题意:有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
)
)
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))
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))
#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
n*n
n∗n的字符矩阵,求其中最大的对称矩阵
对称矩阵:关于
y
=
x
y=x
y=x直线对称
d
p
[
i
]
[
j
]
dp[i][j]
dp[i][j]表示以点(i,j)为左下角的最大对称矩阵
那么
d
p
[
i
]
[
j
]
dp[i][j]
dp[i][j]可以由
d
p
[
i
−
1
]
[
j
+
1
]
dp[i-1][j+1]
dp[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
]
dp[i][0]
dp[i][0]表示第i个平台往左走到地面的最少时间
d
p
[
i
]
[
1
]
dp[i][1]
dp[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
]
dp[i][j]
dp[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
)
dp[i][j]=abs(j-w[i])+min(dp[i-1][k])(k<=j)
dp[i][j]=abs(j−w[i])+min(dp[i−1][k])(k<=j)
而
d
p
[
i
−
1
]
[
k
]
dp[i-1][k]
dp[i−1][k]可以用一个变量m来维护
由于a[i]<=1e9所以第二维存不下
由于不是求严格单调序列,所以可以发现,这个j啊,他为a[i]中的某一个时才是最优的
那么就不需要遍历全部的了,只需遍历
j
−
>
(
a
[
1
]
j->(a[1]
j−>(a[1] ~
a
[
n
]
)
a[n])
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;
}