AcWing动态规划
1.背包问题
01背包问题
有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 i 件物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。
接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
int v[N], w[N];
int f[N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i ++ ) {
cin >> v[i] >> w[i];
}
for (int i = 1; i <= n; i ++ ) {
for (int j = m; j >= v[i]; j -- ) {
f[j] = max(f[j], f[j - v[i]] + w[i]);
}
}
cout << f[m] << endl;
return 0;
}
完全背包问题
有 N 种物品和一个容量是 V的背包，每种物品都有无限件可用。
第 i 种物品的体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。
接下来有 N行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 种物品的体积和价值。
输出格式
输出一个整数，表示最大价值。
int n, m;
int v[N], w[N];
int f[N];
int main() {
cin >> n >> m;
for(int i = 1; i <= n; i ++ ) cin >> v[i] >> w[i];
for (int i = 1; i <= n; i ++ ) {
for(int j = v[i]; j <= m; j ++ ) {
f[j] = max(f[j], f[j - v[i]] + w[i]);
}
}
cout << f[m] << endl;
return 0;
}
多重背包问题 I
有 N 种物品和一个容量是 V 的背包。
第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。
接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。
输出格式
输出一个整数，表示最大价值。
int n, m;
int v[N], w[N], s[N];
int f[N][N];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i ++) cin >> v[i] >> w[i] >> s[i];
for (int i = 1; i <= n; i ++ ) {
for(int j = 0; j <= m; j ++ ) {
for(int k = 0; k <= s[i] && k * v[i] <= j; k ++) {
f[i][j] = max(f[i][j], f[i - 1][j - v[i] * k] + w[i] * k);
}
}
}
cout << f[n][m] << endl;
return 0;
}
多重背包问题 II
有 N 种物品和一个容量是 V 的背包。
第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。
接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。
输出格式
输出一个整数，表示最大价值。
int n, m;
int v[N], w[N];
int f[N];
int main() {
cin >> n >> m;
int cnt = 0;
for (int i = 1; i <= n; i ++ ) {
int a, b, s;
cin >> a >> b >> s;
int k = 1;
while (k <= s) {
cnt ++;
v[cnt] = a * k;
w[cnt] = b * k;
s -= k;
k *= 2;
}
if (s > 0) {
cnt ++ ;//剩下的
v[cnt] = a * s;
w[cnt] = b * s;
}
}
n = cnt;
for (int i = 1; i <= n; i ++ ) {
for(int j = m; j >= v[i]; j -- ) {
f[j] = max(f[j], f[j - v[i]] + w[i]);
}
}
cout << f[m] << endl;
return 0;
}
多重背包问题 III
有 N 种物品和一个容量是 V 的背包。
第 i 种物品最多有 si 件，每件体积是 vi，价值是 wi。
求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。
输出最大价值。
输入格式
第一行两个整数，N，V(0 接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。 输出一个整数，表示最大价值。 有 N 种物品和一个容量是 V 的背包。 物品一共有三类： 每种体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使物品体积总和不超过背包容量，且价值总和最大。 第一行两个整数，N，V，用空格隔开，分别表示物品种数和背包容积。 接下来有 N 行，每行三个整数 vi,wi,si，用空格隔开，分别表示第 i 种物品的体积、价值和数量。 输出一个整数，表示最大价值。 有 N 件物品和一个容量是 V 的背包，背包能承受的最大重量是 M。 每件物品只能用一次。体积是 vi，重量是 mi，价值是 wi。 求解将哪些物品装入背包，可使物品总体积不超过背包容量，总重量不超过背包可承受的最大重量，且价值总和最大。 第一行三个整数，N,V,M，用空格隔开，分别表示物品件数、背包容积和背包可承受的最大重量。 接下来有 N 行，每行三个整数 vi,mi,wi，用空格隔开，分别表示第 i 件物品的体积、重量和价值。 输出一个整数，表示最大价值。 有 N 组物品和一个容量是 V 的背包。 每组物品有若干个，同一组内的物品最多只能选一个。 求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。 输出最大价值。 第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。 接下来有 N 组数据： 有 N 个物品和一个容量是 V 的背包。 物品之间具有依赖关系，且依赖关系组成一棵树的形状。如果选择一个物品，则必须选择它的父节点。 如下图所示： 如果选择物品5，则必须选择物品1和2。这是因为2是5的父节点，1是2的父节点。 每件物品的编号是 i，体积是 vi，价值是 wi，依赖的父节点编号是 pi。物品的下标范围是 1…N。 求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。 输出最大价值。 第一行有两个整数 N，V，用空格隔开，分别表示物品个数和背包容量。 接下来有 N 行数据，每行数据表示一个物品。 输出一个整数，表示最大价值。 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出 最优选法的方案数。注意答案可能很大，请输出答案模 109+7109+7 的结果。 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。 输出一个整数，表示 方案数 模 10^9+7 的结果。 有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。 第 i 件物品的体积是 vi，价值是 wi。 求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。 输出 字典序最小的方案。这里的字典序是指：所选物品的编号所构成的序列。物品的编号范围是 1…N。 第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。 接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。 输出一行，包含若干个用空格隔开的整数，表示最优解中所选物品的编号序列，且该编号序列的字典序最小。 物品编号范围是 1…N。 辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。 为此，他想拜附近最有威望的医师为师。 医师为了判断他的资质，给他出了一个难题。 医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。” 如果你是辰辰，你能完成这个任务吗？ 输入文件的第一行有两个整数 T 和 M，用一个空格隔开，T 代表总共能够用来采药的时间，M 代表山洞里的草药的数目。 接下来的 M 行每行包括两个在 1 到 100 之间（包括 1 和 100）的整数，分别表示采摘某株草药的时间和这株草药的价值。 输出文件包括一行，这一行只包含一个整数，表示在规定的时间内，可以采到的草药的最大总价值。 有一个箱子容量为 V，同时有 n 个物品，每个物品有一个体积（正整数）。 要求 n 个物品中，任取若干个装入箱内，使箱子的剩余空间为最小。 第一行是一个整数 V，表示箱子容量。 第二行是一个整数 n，表示物品数。 接下来 n 行，每行一个正整数（不超过10000），分别表示这 n 个物品的各自体积。 一个整数，表示箱子剩余空间。 宠物小精灵是一部讲述小智和他的搭档皮卡丘一起冒险的故事。 一天，小智和皮卡丘来到了小精灵狩猎场，里面有很多珍贵的野生宠物小精灵。 小智也想收服其中的一些小精灵。 然而，野生的小精灵并不那么容易被收服。 对于每一个野生小精灵而言，小智可能需要使用很多个精灵球才能收服它，而在收服过程中，野生小精灵也会对皮卡丘造成一定的伤害（从而减少皮卡丘的体力）。 当皮卡丘的体力小于等于0时，小智就必须结束狩猎（因为他需要给皮卡丘疗伤），而使得皮卡丘体力小于等于0的野生小精灵也不会被小智收服。 当小智的精灵球用完时，狩猎也宣告结束。 我们假设小智遇到野生小精灵时有两个选择：收服它，或者离开它。 如果小智选择了收服，那么一定会扔出能够收服该小精灵的精灵球，而皮卡丘也一定会受到相应的伤害；如果选择离开它，那么小智不会损失精灵球，皮卡丘也不会损失体力。 小智的目标有两个：主要目标是收服尽可能多的野生小精灵；如果可以收服的小精灵数量一样，小智希望皮卡丘受到的伤害越小（剩余体力越大），因为他们还要继续冒险。 现在已知小智的精灵球数量和皮卡丘的初始体力，已知每一个小精灵需要的用于收服的精灵球数目和它在被收服过程中会对皮卡丘造成的伤害数目。 请问，小智该如何选择收服哪些小精灵以达到他的目标呢？ 输入数据的第一行包含三个整数：N，M，K，分别代表小智的精灵球数量、皮卡丘初始的体力值、野生小精灵的数量。 之后的K行，每一行代表一个野生小精灵，包括两个整数：收服该小精灵需要的精灵球的数量，以及收服过程中对皮卡丘造成的伤害。 输出为一行，包含两个整数：C，R，分别表示最多收服C个小精灵，以及收服C个小精灵时皮卡丘的剩余体力值最多为R。 给定 N 个正整数 A1,A2,…,AN，从中选出若干个数，使它们的和为 M，求有多少种选择方案。 第一行包含两个整数 N 和 M。 第二行包含 N 个整数，表示 A1,A2,…,AN。 包含一个整数，表示可选方案数。 小明手里有n元钱全部用来买书，书的价格为10元，20元，50元，100元。 问小明有多少种买书方案？（每种书可购买多本） 一个整数 n，代表总共钱数。 一个整数，代表选择方案种数。 为了庆贺班级在校运动会上取得全校第一名成绩，班主任决定开一场庆功会，为此拨款购买奖品犒劳运动员。 期望拨款金额能购买最大价值的奖品，可以补充他们的精力和体力。 第一行二个数n，m，其中n代表希望购买的奖品的种数，m表示拨款金额。 接下来n行，每行3个数，v、w、s，分别表示第I种奖品的价格、价值（价格与价值是不同的概念）和能购买的最大数量（买0件到s件均可）。 一行：一个数，表示此次购买能获得的最大的价值（注意！不是价格）。 潜水员为了潜水要使用特殊的装备。 他有一个带2种气体的气缸：一个为氧气，一个为氮气。 让潜水员下潜的深度需要各种数量的氧和氮。 潜水员有一定数量的气缸。 每个气缸都有重量和气体容量。 潜水员为了完成他的工作需要特定数量的氧和氮。 他完成工作所需气缸的总重的最低限度的是多少？ 例如：潜水员有5个气缸。每行三个数字为：氧，氮的（升）量和气缸的重量： 如果潜水员需要5升的氧和60升的氮则总重最小为249（1，2或者4，5号气缸）。 你的任务就是计算潜水员为了完成他的工作需要的气缸的重量的最低值。 第一行有2个整数 m，n。它们表示氧，氮各自需要的量。 第二行为整数 k 表示气缸的个数。 此后的 k 行，每行包括ai，bi，ci，3个整数。这些各自是：第 i 个气缸里的氧和氮的容量及气缸重量。 仅一行包含一个整数，为潜水员完成工作所需的气缸的重量总和的最低值。 给定一个如下图所示的数字三角形，从顶部出发，在每一结点可以选择移动至其左下方的结点或移动至其右下方的结点，一直走到底层，要求找出一条路径，使路径上的数字的和最大。 第一行包含整数 n，表示数字三角形的层数。 接下来 n 行，每行包含若干整数，其中第 i 行表示数字三角形第 i 层包含的整数。 输出一个整数，表示最大的路径数字和。 Hello Kitty想摘点花生送给她喜欢的米老鼠。 她来到一片有网格状道路的矩形花生地(如下图)，从西北角进去，东南角出来。 地里每个道路的交叉点上都有种着一株花生苗，上面有若干颗花生，经过一株花生苗就能摘走该它上面所有的花生。 Hello Kitty只能向东或向南走，不能向西或向北走。 问Hello Kitty最多能够摘到多少颗花生。 第一行是一个整数T，代表一共有多少组数据。 接下来是T组数据。 每组数据的第一行是两个整数，分别代表花生苗的行数R和列数 C。 每组数据的接下来R行数据，从北向南依次描述每行花生苗的情况。每行数据有C个整数，按从西向东的顺序描述了该行每株花生苗上的花生数目M。 对每组输入数据，输出一行，内容为Hello Kitty能摘到得最多的花生颗数。 一个商人穿过一个 N×N 的正方形的网格，去参加一个非常重要的商务活动。 他要从网格的左上角进，右下角出。 每穿越中间 11 个小方格，都要花费 11 个单位时间。 商人必须在 (2N−1) 个单位时间穿越出去。 而在经过中间的每个小方格时，都需要缴纳一定的费用。 这个商人期望在规定时间内用最少费用穿越出去。 请问至少需要多少费用？ 注意：不能对角穿越各个小方格（即，只能向上下左右四个方向移动且不能离开网格）。 第一行是一个整数，表示正方形的宽度 N。 后面 N 行，每行 N 个不大于 100的正整数，为网格上每个小方格的费用。 输出一个整数，表示至少需要的费用。 设有 N×N 的方格图，我们在其中的某些方格中填入正整数，而其它的方格中则放入数字0。如下图所示： 某人从图中的左上角 A 出发，可以向下行走，也可以向右行走，直到到达右下角的 B 点。 在走过的路上，他可以取走方格中的数（取走后的方格中将变为数字0）。 此人从 A 点到 B 点共走了两次，试找出两条这样的路径，使得取得的数字和为最大。 第一行为一个整数N，表示 N×N 的方格图。 接下来的每行有三个整数，第一个为行号数，第二个为列号数，第三个为在该行、该列上所放的数。 行和列编号从 1 开始。 一行“0 0 0”表示结束。 输出一个整数，表示两条路径上取得的最大的和。 小渊和小轩是好朋友也是同班同学，他们在一起总有谈不完的话题。 一次素质拓展活动中，班上同学安排坐成一个 m 行 n 列的矩阵，而小渊和小轩被安排在矩阵对角线的两端，因此，他们就无法直接交谈了。 幸运的是，他们可以通过传纸条来进行交流。 纸条要经由许多同学传到对方手里，小渊坐在矩阵的左上角，坐标 (1,1)(1,1)，小轩坐在矩阵的右下角，坐标 (m,n)。 从小渊传到小轩的纸条只可以向下或者向右传递，从小轩传给小渊的纸条只可以向上或者向左传递。 在活动进行中，小渊希望给小轩传递一张纸条，同时希望小轩给他回复。 班里每个同学都可以帮他们传递，但只会帮他们一次，也就是说如果此人在小渊递给小轩纸条的时候帮忙，那么在小轩递给小渊的时候就不会再帮忙，反之亦然。 还有一件事情需要注意，全班每个同学愿意帮忙的好感度有高有低（注意：小渊和小轩的好心程度没有定义，输入时用 00 表示），可以用一个 0∼100 的自然数来表示，数越大表示越好心。 小渊和小轩希望尽可能找好心程度高的同学来帮忙传纸条，即找到来回两条传递路径，使得这两条路径上同学的好心程度之和最大。 现在，请你帮助小渊和小轩找到这样的两条路径。 第一行有 22 个用空格隔开的整数 m 和 n，表示学生矩阵有 m 行 n 列。 接下来的 m 行是一个 m×n 的矩阵，矩阵中第 i 行 j 列的整数表示坐在第 i 行 j 列的学生的好心程度，每行的 n 个整数之间用空格隔开。 输出一个整数，表示来回两条路上参与传递纸条的学生的好心程度之和的最大值。 给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。 第一行包含整数 N。 第二行包含 N 个整数，表示完整序列。 输出一个整数，表示最大长度。 给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。 第一行包含整数 N。 第二行包含 N 个整数，表示完整序列。 输出一个整数，表示最大长度。 给定两个长度分别为 N 和 M 的字符串 A 和 B，求既是 A 的子序列又是 B 的子序列的字符串长度最长是多少。 第一行包含两个整数 N 和 M。 第二行包含一个长度为 N 的字符串，表示字符串 A。 第三行包含一个长度为 M 的字符串，表示字符串 B。 字符串均由小写字母构成。 输出一个整数，表示最大长度。 给定两个字符串 A 和 B，现在要将 A 经过若干操作变为 B，可进行的操作有： 现在请你求出，将 A 变为 B 至少需要进行多少次操作。 第一行包含整数 n，表示字符串 A 的长度。 第二行包含一个长度为 n 的字符串 A。 第三行包含整数 m，表示字符串 B 的长度。 第四行包含一个长度为 m 的字符串 B。 字符串中均只包含大小写字母。 输出一个整数，表示最少操作次数。 给定 n个长度不超过 1010 的字符串以及 m 次询问，每次询问给出一个字符串和一个操作次数上限。 对于每次询问，请你求出给定的 n 个字符串中有多少个字符串可以在上限操作次数内经过操作变成询问给出的字符串。 每个对字符串进行的单个字符的插入、删除或替换算作一次操作。 第一行包含两个整数 n 和 m。 接下来 n 行，每行包含一个字符串，表示给定的字符串。 再接下来 m 行，每行包含一个字符串和一个整数，表示一次询问。 字符串中只包含小写字母，且长度均不超过 1010。 输出共 m 行，每行输出一个整数作为结果，表示一次询问中满足条件的字符串个数。 怪盗基德是一个充满传奇色彩的怪盗，专门以珠宝为目标的超级盗窃犯。 而他最为突出的地方，就是他每次都能逃脱中村警部的重重围堵，而这也很大程度上是多亏了他随身携带的便于操作的滑翔翼。 有一天，怪盗基德像往常一样偷走了一颗珍贵的钻石，不料却被柯南小朋友识破了伪装，而他的滑翔翼的动力装置也被柯南踢出的足球破坏了。 不得已，怪盗基德只能操作受损的滑翔翼逃脱。 假设城市中一共有N幢建筑排成一条线，每幢建筑的高度各不相同。 初始时，怪盗基德可以在任何一幢建筑的顶端。 他可以选择一个方向逃跑，但是不能中途改变方向（因为中森警部会在后面追击）。 因为滑翔翼动力装置受损，他只能往下滑行（即：只能从较高的建筑滑翔到较低的建筑）。 他希望尽可能多地经过不同建筑的顶部，这样可以减缓下降时的冲击力，减少受伤的可能性。 请问，他最多可以经过多少幢不同建筑的顶部(包含初始时的建筑)？ 输入数据第一行是一个整数K，代表有K组测试数据。 每组测试数据包含两行：第一行是一个整数N，代表有N幢建筑。第二行包含N个不同的整数，每一个对应一幢建筑的高度h，按照建筑的排列顺序给出。 对于每一组测试数据，输出一行，包含一个整数，代表怪盗基德最多可以经过的建筑数量。 五一到了，ACM队组织大家去登山观光，队员们发现山上一共有N个景点，并且决定按照顺序来浏览这些景点，即每次所浏览景点的编号都要大于前一个浏览景点的编号。 同时队员们还有另一个登山习惯，就是不连续浏览海拔相同的两个景点，并且一旦开始下山，就不再向上走了。 队员们希望在满足上面条件的同时，尽可能多的浏览景点，你能帮他们找出最多可能浏览的景点数么？ 第一行包含整数N，表示景点数量。 第二行包含N个整数，表示每个景点的海拔。 输出一个整数，表示最多能浏览的景点数。 N 位同学站成一排，音乐老师要请其中的 (N−K) 位同学出列，使得剩下的 K 位同学排成合唱队形。 合唱队形是指这样的一种队形：设 K 位同学从左到右依次编号为 1，2…，K，他们的身高分别为 T1，T2，…，TK,则他们的身高满足 T1<…< Ti > Ti+1>…>TK (1≤i≤K)。 你的任务是，已知所有 N 位同学的身高，计算最少需要几位同学出列，可以使得剩下的同学排成合唱队形。 输入的第一行是一个整数 N，表示同学的总数。 第二行有 N 个整数，用空格分隔，第 i 个整数 Ti 是第 i 位同学的身高(厘米)。 输出包括一行，这一行只包含一个整数，就是最少需要几位同学出列。 Palmia国有一条横贯东西的大河，河有笔直的南北两岸，岸上各有位置各不相同的N个城市。 北岸的每个城市有且仅有一个友好城市在南岸，而且不同城市的友好城市不相同。 每对友好城市都向政府申请在河上开辟一条直线航道连接两个城市，但是由于河上雾太大，政府决定避免任意两条航道交叉，以避免事故。 编程帮助政府做出一些批准和拒绝申请的决定，使得在保证任意两条航线不相交的情况下，被批准的申请尽量多。 第1行，一个整数N，表示城市数。 第2行到第n+1行，每行两个整数，中间用1个空格隔开，分别表示南岸和北岸的一对友好城市的坐标。 仅一行，输出一个整数，表示政府所能批准的最多申请数。 一个数的序列 bi，当 b1 对于给定的一个序列(a1,a2,…,aN)，我们可以得到一些上升的子序列(ai1,ai2,…,aiK)，这里1≤i1 比如，对于序列(1,7,3,5,9,4,8)，有它的一些上升子序列，如(1,7),(3,4,8)等等。 这些子序列中和最大为18，为子序列(1,3,5,9)的和。 你的任务，就是对于给定的序列，求出最大上升子序列和。 注意，最长的上升子序列的和不一定是最大的，比如序列(100,1,2,3)的最大上升子序列和为100，而最长上升子序列为(1,2,3)。 输入的第一行是序列的长度N。 第二行给出序列中的N个整数，这些整数的取值范围都在0到10000(可能重复)。 输出一个整数，表示最大上升子序列和。 某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。 但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达任意的高度，但是以后每一发炮弹都不能高于前一发的高度。 某天，雷达捕捉到敌国的导弹来袭。 由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。 输入导弹依次飞来的高度（雷达给出的高度数据是不大于30000的正整数，导弹数不超过1000），计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。 共一行，输入导弹依次飞来的高度。 第一行包含一个整数，表示最多能拦截的导弹数。 第二行包含一个整数，表示要拦截所有导弹最少要配备的系统数。 阿福是一名经验丰富的大盗。趁着月黑风高，阿福打算今晚洗劫一条街上的店铺。 这条街上一共有 N 家店铺，每家店中都有一些现金。 阿福事先调查得知，只有当他同时洗劫了两家相邻的店铺时，街上的报警系统才会启动，然后警察就会蜂拥而至。 作为一向谨慎作案的大盗，阿福不愿意冒着被警察追捕的风险行窃。 他想知道，在不惊动警察的情况下，他今晚最多可以得到多少现金？ 输入的第一行是一个整数 T，表示一共有 T 组数据。 接下来的每组数据，第一行是一个整数 N ，表示一共有 N 家店铺。 第二行是 N 个被空格分开的正整数，表示每一家店铺中的现金数量。 每家店铺中的现金数量均不超过1000。 对于每组数据，输出一行。 该行包含一个整数，表示阿福在不惊动警察的情况下可以得到的现金数量。 给定一个长度为 N 的数组，数组中的第 i 个数字表示一个给定股票在第 i 天的价格。 设计一个算法来计算你所能获取的最大利润，你最多可以完成 k 笔交易。 注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。一次买入卖出合为一笔交易。 第一行包含整数 N 和 k，表示数组的长度以及你可以完成的最大交易笔数。 第二行包含 N 个不超过 10000 的正整数，表示完整的数组。 输出一个整数，表示最大利润。 给定一个长度为 N 的数组，数组中的第 i 个数字表示一个给定股票在第 i 天的价格。 设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）: 第一行包含整数 N，表示数组长度。 第二行包含 N 个不超过 10000 的正整数，表示完整的数组。 输出一个整数，表示最大利润。 设有 N 堆石子排成一排，其编号为 1,2,3,…,N。 每堆石子有一定的质量，可以用一个整数来描述，现在要将这 N 堆石子合并成为一堆。 每次只能合并相邻的两堆，合并的代价为这两堆石子的质量之和，合并后与这两堆石子相邻的石子将和新堆相邻，合并时由于选择的顺序不同，合并的总代价也不相同。 例如有 44 堆石子分别为 如果第二步是先合并 2、32、3 堆，则代价为 77，得到 问题是：找出一种合理的方法，使总的代价最小，输出最小代价。 第一行一个数 N 表示石子的堆数 N。 第二行 N 个数，表示每堆石子的质量(均不超过 1000)。 输出一个整数，表示最小代价。 一个正整数 n 可以表示成若干个正整数之和，形如：n=n1+n2+…+nk，其中 n1≥n2≥…≥nk,k≥1。 我们将这样的一种表示称为正整数 n 的一种划分。 现在给定一个正整数 n，请你求出 n 共有多少种不同的划分方法。 共一行，包含一个整数 n。 共一行，包含一个整数，表示总划分数量。 由于答案可能很大，输出结果请对 10^9+7 取模。 给定两个整数 a 和 b，求 a 和 b 之间的所有数字中 0∼9 的出现次数。 例如，a=1024，b=1032，则 a 和 b 之间共有 99 个数如下： 其中 输入包含多组测试数据。 每组测试数据占一行，包含两个整数 a 和 b。 当读入一行为 每组数据输出一个结果，每个结果占一行。 每个结果包含十个用空格隔开的数字，第一个数字表示 求把 N×M 的棋盘分割成若干个 1×21×2 的长方形，有多少种方案。 例如当 N=2，M=4 时，共有 5 种方案。当 N=2，M=3时，共有 3 种方案。 如下图所示： 输入包含多组测试用例。 每组测试用例占一行，包含两个整数 N 和 M。 当输入用例 N=0，M=0 时，表示输入终止，且该用例无需处理。 每个测试用例输出一个结果，每个结果占一行。 给定一张 n 个点的带权无向图，点从 0∼n−1 标号，求起点 0 到终点 n−1 的最短 Hamilton 路径。 Hamilton 路径的定义是从 0 到 n−1 不重不漏地经过每个点恰好一次。 第一行输入整数 n。 接下来 n 行每行 n 个整数，其中第 i 行第 j 个整数表示点 i 到 j 的距离（记为 a[i,j]）。 对于任意的 x,y,z，数据保证 a[x,x]=0，a[x,y]=a[y,x] 并且 a[x,y]+a[y,z]≥a[x,z]。 输出一个整数，表示最短 Hamilton 路径的长度。 Ural 大学有 N 名职员，编号为 1∼N。 他们的关系就像一棵以校长为根的树，父节点就是子节点的直接上司。 每个职员有一个快乐指数，用整数 Hi 给出，其中 1≤i≤N。 现在要召开一场周年庆宴会，不过，没有职员愿意和直接上司一起参会。 在满足这个条件的前提下，主办方希望邀请一部分职员参会，使得所有参会职员的快乐指数总和最大，求这个最大值。 第一行一个整数 N。 接下来 N 行，第 i 行表示 i 号职员的快乐指数 Hi。 接下来 N−1 行，每行输入一对整数 L,K，表示 K 是 L 的直接上司。 输出最大的快乐指数。 给定一个 R 行 C 列的矩阵，表示一个矩形网格滑雪场。 矩阵中第 i 行第 j 列的点表示滑雪场的第 i 行第 j 列区域的高度。 一个人从滑雪场中的某个区域内出发，每次可以向上下左右任意一个方向滑动一个单位距离。 当然，一个人能够滑动到某相邻区域的前提是该区域的高度低于自己目前所在区域的高度。 下面给出一个矩阵作为例子： 在给定矩阵中，一条可行的滑行轨迹为 24−17−2−1。 在给定矩阵中，最长的滑行轨迹为 25−24−23−…−3−2−1，沿途共经过 25 个区域。 现在给定你一个二维矩阵表示滑雪场各区域的高度，请你找出在该滑雪场中能够完成的最长滑雪轨迹，并输出其长度(可经过最大区域数)。 第一行包含两个整数 R 和 C。 接下来 R 行，每行包含 C 个整数，表示完整的二维矩阵。 输出一个整数，表示可完成的最长滑雪长度。 大致意思就是说给一串字符串，然后问其中abcd顺序的字符串有多少个，模板代码：输出格式
int n, m;
int f[N], g[N], q[N];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i ++ ) {
int v, w, s;
cin >> v >> w >> s;
memcpy(g, f, sizeof f); // 滚动数组存上一次的状态
for (int j = 0; j < v; j ++ ) { // 枚举余数
// 余数固定，从前往后枚举每一个值是多少
int hh = 0, tt = -1; // 单调队列的定义
for (int k = j; k <= m; k += v) {
if (hh <= tt && q[hh] < k - s * v) { // 队列不空并且划出窗口
hh ++ ; // 对头出列
}
if (hh <= tt) { // 队列不空，更新最大值
f[k] = max(f[k], g[q[hh]] + (k - q[hh]) / v * w); // 算中间空余了多少个物品的体积
}
while (hh <= tt && g[q[tt]] - (q[tt] - j) / v * w <= g[k] - (k - j) / v * w) { // 把没用的元素弹出
tt -- ;
}
q[ ++ tt] = k; // 把当前元素插进来
}
}
}
cout << f[m] << endl;
return 0;
}
混合背包问题
输出最大价值。输入格式
输出格式
int n, m;
int f[N];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i ++ ) {
int v, w, s;
cin >> v >> w >> s;
if (!s) {
for (int j = v; j <= m; j ++ )
f[j] = max(f[j], f[j - v] + w);
} else {
if (s == -1) s = 1;
for (int k = 1; k <= s; k *= 2) {
for (int j = m; j >= k * v; j -- )
f[j] = max(f[j], f[j - k * v] + k * w);
s -= k;
}
if (s) {
for (int j = m; j >= s * v; j -- )
f[j] = max(f[j], f[j - s * v] + s * w);
}
}
}
cout << f[m] << endl;
return 0;
}
二维费用的背包问题
输出最大价值。输入格式
输出格式
int n, V, M;
int f[N][N];
int main() {
cin >> n >> V >> M;
for (int i = 0; i < n; i ++ ) {
int v, m, w;
cin >> v >> m >> w;
for (int j = V; j >= v; j -- )
for (int k = M; k >= m; k -- )
f[j][k] = max(f[j][k], f[j - v][k - m] + w);
}
cout << f[V][M] << endl;
return 0;
}
分组背包问题
每件物品的体积是 vij，价值是 wij，其中 i 是组号，j 是组内编号。输入格式
int n, m;
int v[N][N], w[N][N], s[N];
int f[N];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i ++ ) {
cin >> s[i];
for (int j = 0; j < s[i]; j ++ ) {
cin >> v[i][j] >> w[i][j];
}
}
for (int i = 1; i <= n; i ++ ) {
for (int j = m; j >= 0; j -- ) {
for (int k = 0; k < s[i]; k ++ ) { //枚举所有选择
if (v[i][k] <= j) {
f[j] = max(f[j], f[j - v[i][k]] + w[i][k]);
}
}
}
}
cout << f[m] << endl;
return 0;
}
有依赖的背包问题
输入格式
第 i 行有三个整数 vi,wi,pi，用空格隔开，分别表示物品的体积、价值和依赖的物品编号。
如果 pi=−1，表示根节点。 数据保证所有物品构成一棵树。输出格式
int n, m;
int v[N], w[N];
int h[N], e[N], ne[N], idx;
int f[N][N];
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
void dfs(int u) {
for (int i = h[u]; ~i; i = ne[i]) { // 循环物品组
int son = e[i];
dfs(e[i]);
// 分组背包
for (int j = m - v[u]; j >= 0; j -- ) // 循环体积
for (int k = 0; k <= j; k ++ ) // 循环决策
f[u][j] = max(f[u][j], f[u][j - k] + f[son][k]);
}
// 将物品u加进去
for (int i = m; i >= v[u]; i -- ) f[u][i] = f[u][i - v[u]] + w[u];
for (int i = 0; i < v[u]; i ++ ) f[u][i] = 0;
}
int main() {
cin >> n >> m;
memset(h, -1, sizeof h);
int root;
for (int i = 1; i <= n; i ++ ) {
int p;
cin >> v[i] >> w[i] >> p;
if (p == -1) root = i;
else add(p, i);
}
dfs(root);
cout << f[root][m] << endl;
return 0;
}
背包问题求方案数
输入格式
输出格式
int n, m;
int f[N], g[N];
int main() {
cin >> n >> m;
memset(f, -0x3f, sizeof f);
f[0] = 0;
g[0] = 1;
for (int i = 0; i < n; i ++ ) {
int v, w;
cin >> v >> w;
for (int j = m; j >= v; j -- ) {
int maxv = max(f[j], f[j - v] + w);
int s = 0;
if (f[j] == maxv) s = g[j];
if (f[j - v] + w == maxv) s = (s + g[j - v]) % mod;
f[j] = maxv, g[j] = s;
}
}
int res = 0;
for (int i = 1; i <= m; i ++ )
if (f[i] > f[res])
res = i;
int sum = 0;
for (int i = 0; i <= m; i ++ )
if (f[i] == f[res])
sum = (sum + g[i]) % mod;
cout << sum << endl;
return 0;
}
背包问题求具体方案
输入格式
输出格式
int n, m;
int v[N], w[N];
int f[N][N];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i ++ ) cin >> v[i] >> w[i];
for (int i = n; i >= 1; i -- )
for (int j = 0; j <= m; j ++ ) {
f[i][j] = f[i + 1][j];
if (j >= v[i]) f[i][j] = max(f[i][j], f[i + 1][j - v[i]] + w[i]);
}
int j = m;
for (int i = 1; i <= n; i ++ )
if (j >= v[i] && f[i][j] == f[i + 1][j - v[i]] + w[i]) {
cout << i << ' ';
j -= v[i];
}
return 0;
}
输入格式
输出格式
int v[N], w[N];
int f[N];
int main() {
int V, n;
cin >> V >> n;
for (int i = 1; i <= n; i ++ ) {
cin >> v[i] >> w[i];
}
for (int i = 1; i <= n; i ++ ) {
for (int j = V; j >= v[i]; j -- ) {
f[j] = max(f[j], f[j - v[i]] + w[i]);
}
}
cout << f[V] << endl;
return 0;
}
输入格式
输出格式
int v[N], f[N];
int main() {
int V, n;
cin >> V >> n;
for (int i = 1; i <= n; i ++ ) {
cin >> v[i];
}
for (int i = 1; i <= n; i ++ ) {
for (int j = V; j >= v[i]; j -- ) {
f[j] = max(f[j], f[j - v[i]] + v[i]);
}
}
cout << V - f[V] << endl;
return 0;
}
输入格式
输出格式
int n, V1, V2;
int f[N][M];
int main() {
cin >> V1 >> V2 >> n;
for (int i = 0; i < n; i ++ ) {
int v1, v2;
cin >> v1 >> v2;
for (int j = V1; j >= v1; j -- ) {
for (int k = V2; k >= v2; k -- ) {
f[j][k] = max(f[j][k], f[j - v1][k - v2] + 1);
}
}
}
cout << f[V1][V2 - 1] << " "; // 体力最小是1
int k = V2 - 1;
while (k > 0 && f[V1][k - 1] == f[V1][V2 - 1]) {
k -- ;
}
cout << V2 - k << endl;
return 0;
}
输入格式
输出格式
int f[N];
int main() {
int n, m;
cin >> n >> m;
f[0] = 1;
for (int i = 0; i < n; i ++ ) {
int v;
cin >> v;
for (int j = m; j >= v; j -- ) {
f[j] += f[j - v];
}
}
cout << f[m] << endl;
return 0;
}
输入格式
输出格式
int f[N];
int v[4] = {10, 20, 50, 100};
int main() {
int n;
cin >> n;
f[0] = 1;
for (int i = 0; i < 4; i ++ ) {
for (int j = 0; j <= n; j ++ ) {
// f[i][j] += f[i - 1][j]; 等价
// f[j] += f[j];
if (j >= v[i]) {
// f[i][j] += f[i][j - v[i]];等价
f[j] += f[j - v[i]];
}
}
}
cout << f[n] << endl;
return 0;
}
输入格式
输出格式
int f[N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i ++ ) {
int v, w, s;
cin >> v >> w >> s;
for (int j = m; j >= 0; j -- ) {
for (int k = 0; k <= s && k * v <= j; k ++ ) {
f[j] = max(f[j], f[j - k * v] + k * w);
}
}
}
cout << f[m] << endl;
return 0;
}
3 36 120
10 25 129
5 50 250
1 45 130
4 20 119
输入格式
输出格式
int f[N][M];
int n, m, K;
int main() {
cin >> n >> m >> K;
memset(f, 0x3f, sizeof f);
f[0][0] = 0;
while (K -- ) {
int v1, v2, w;
cin >> v1 >> v2 >> w;
for (int i = N - 1; i >= 0; i -- ) {
for (int j = M - 1; j >= 0; j -- ) {
f[i][j] = min(f[i][j], f[max(0, i - v1)][max(0, j - v2)] + w);
}
}
}
int res = 1e9;
for (int i = n; i < N; i ++ ) {
for (int j = m; j < M; j ++ ) {
res = min(res, f[i][j]);
}
}
cout << res << endl;
return 0;
}
2.数字三角形模型
7
3 8
8 1 0
2 7 4 4
4 5 2 6 5
输入格式
输出格式
int n;
int a[N][N];
int f[N][N];
int main() {
scanf("%d", &n);
for(int i = 1; i <= n; i ++) {
for(int j = 1; j <= i; j ++) {
scanf("%d", &a[i][j]);
}
}
for(int i = 0; i <= n; i ++) {
for(int j = 0; j <= i + 1; j ++) {
f[i][j] = -INF;
}
}
f[1][1] = a[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] + a[i][j], f[i - 1][j] + a[i][j]);
}
}
int res = -INF;
for(int i = 1; i <= n; i ++) res = max(res, f[n][i]);
printf("%d\n", res);
return 0;
}
输入格式
输出格式
int a[N][N], f[N][N];
void solve() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i ++ ) {
for (int j = 0; j < m; j ++ ) {
cin >> a[i][j];
}
}
f[0][0] = a[0][0];
for (int i = 0; i < n; i ++ ) {
for (int j = 0; j < m; j ++ ) {
if (i == 0 && j != 0) {
f[i][j] = f[i][j - 1] + a[i][j];
} else if (i != 0 && j == 0) {
f[i][j] = f[i - 1][j] + a[i][j];
} else {
f[i][j] = max(f[i - 1][j], f[i][j - 1]) + a[i][j];
}
}
}
cout << f[n - 1][m - 1] << endl;
}
int main() {
int t;
cin >> t;
while (t -- ) {
solve();
}
return 0;
}
输入格式
输出格式
int w[N][N];
int f[N][N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i ++ ) {
for (int j = 1; j <= n; j ++ ) {
cin >> w[i][j];
}
}
for (int i = 1; i <= n; i ++ ) {
for (int j = 1; j <= n; j ++ ) {
if (i == 1 && j == 1) { // 特判第一行第一列，不特判的话从边上为0的点走过来一定更小
f[i][j] = w[i][j];
} else {
f[i][j] = INF;
if (i > 1) {
f[i][j] = min(f[i][j], f[i - 1][j] + w[i][j]);
}
if (j > 1) {
f[i][j] = min(f[i][j], f[i][j - 1] + w[i][j]);
}
}
}
}
cout << f[n][n] << endl;
return 0;
}
输入格式
输出格式
int w[N][N];
int f[N * N][N][N];
int 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];
}
// f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][i1 - 1][i2 - 1] + t);
// f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][i1 - 1][i2] + t);
// f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][i1][i2 - 1] + t);
// f[k][i1][i2] = max(f[k][i1][i2], f[k - 1][i1][i2] + t);
// 简化：
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] << endl;
return 0;
}
输入格式
输出格式
int w[N][N];
int f[N * 2][N][N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i ++ ) {
for (int j = 1; j <= m; j ++ ) {
cin >> w[i][j];
}
}
for (int k = 2; k <= n + m; k ++ ) {
for (int i = max(1, k - m); i <= n && i < k; i ++ ) {
for (int j = max(1, k - m); j <= n && j < k; j ++ ) {
for (int a = 0; a <= 1; a ++ ) {
for (int b = 0; b <= 1; b ++ ) {
int t = w[i][k - i];
if (i != j || k == 2 || k == n + m) { // 除了起点和终点之外，其余每个格子只能走一次
t += w[j][k - j];
f[k][i][j] = max(f[k][i][j], f[k - 1][i - a][j - b] + t);
}
}
}
}
}
}
cout << f[n + m][n][n] << endl;
return 0;
}
3.最长上升子序列模型
输入格式
输出格式
int a[N], 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;
for (int j = 1; j <= n; j ++ ) {
if (a[j] < a[i]) {
f[i] = max(f[i], f[j] + 1);
}
}
}
sort(f + 1, f + n + 1);
cout << f[n] << endl;
return 0;
}
输入格式
输出格式
int n;
int a[N]; // 存储每个数
int q[N]; // 存储所有不同长度下上升子序列结尾的最小值
int main() {
scanf("%d", &n);
for(int i = 0; i < n; i ++) scanf("%d", &a[i]);
int len = 0; // q[]数组的元素个数
q[0] = -2e9; // 保证数组中小于某个数的数一定存在
for(int i = 0; i < n; i ++) { // 枚举每个数
// 二分出来小于某个数的最大的数
int l = 0, r = len;
while(l < r) {
int mid = l + r + 1 >> 1;
if(q[mid] < a[i]) { //要找的答案在mid或者mid右边
l = mid;
} else {
r = mid - 1;
}
}
len = max(len, r + 1); // 更新最大值 r找的是可以接到某个长度的后面
q[r + 1] = a[i]; // r是小于a[i]的最后一个数,r+1一定大于等于a[i]
}
printf("%d\n", len);
return 0;
}
输入格式
输出格式
int n, m;
char a[N], b[N];
int f[N][N];
int main() {
scanf("%d%d", &n, &m);
scanf("%s%s", a + 1, b + 1);//用到i-1和j-1，下标从1开始
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]); //01和10一定存在，11只有同时包含a[i]和b[j]并且a[i]和b[j]相等
if(a[i] == b[j]) f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);
}
}
printf("%d\n", f[n][m]);
return 0;
}
输入格式
输出格式
int n, m;
char a[N], b[N];
int f[N][N];
int main() {
scanf("%d%s", &n, a + 1);
scanf("%d%s", &m, b + 1);
//a用0个字母想匹配b的前x个字母，只能用添加操作，操作次数和b的长度有关
for(int i = 0; i <= m; i ++) f[0][i] = i;
//b用0个字母想匹配a的前x个字母，只能用删除操作，操作次数和a的长度有关
for(int i = 0; i <= n; i ++) f[i][0] = i;
//dp
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][j], f[i - 1][j - 1]);
} else {
f[i][j] = min(f[i][j], f[i - 1][j - 1] + 1);
}
}
}
printf("%d\n", f[n][m]); // 最后答案是把a的前n个字母变成b的前m个字母
return 0;
}
输入格式
输出格式
int n, m;
int f[N][N];
char str[M][N];
int edit_distance(char a[], char b[]) {
int la = strlen(a + 1), lb = strlen(b + 1);
//初始化
for(int i = 0; i <= lb; i ++) {
f[0][i] = i;
}
for(int i = 0; i <= la; i ++) {
f[i][0] = i;
}
//dp
for(int i = 1; i <= la; i ++) {
for(int j = 1; j <= lb; j ++) {
f[i][j] = min(f[i - 1][j] + 1, f[i][j - 1] + 1);
f[i][j] = min(f[i][j], f[i - 1][j - 1] + (a[i] != b[j]));
}
}
return f[la][lb];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i ++ ) {
scanf("%s", str[i] + 1);
}
while (m -- ) {
char s[N];
int limit;
scanf("%s%d", s + 1, &limit);
int res = 0;
for(int i = 0; i < n; i ++) {
if(edit_distance(str[i], s) <= limit) {
res ++ ;
}
}
printf("%d\n", res);
}
return 0;
}
输入格式
输出格式
int a[N], f[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i ++ ) {
cin >> a[i];
}
int res = 0;
// 正向求解最长上升子序列
for (int i = 1; i <= n; i ++ ) {
f[i] = 1;
for (int j = 1; j < i; j ++ ) {
if (a[i] > a[j]) {
f[i] = max(f[i], f[j] + 1);
}
}
res = max(res, f[i]);
}
// 反向求解最长上升子序列
for (int i = n; i >= 1; i -- ) {
f[i] = 1;
for (int j = n; j > i; j -- ) {
if (a[i] > a[j]) {
f[i] = max(f[i], f[j] + 1);
}
}
res = max(res, f[i]);
}
cout << res << endl;
return 0;
}
输入格式
输出格式
int a[N], f[N], g[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;
for (int j = 1; j < i; j ++ ) {
if (a[j] < a[i]) {
f[i] = max(f[i], f[j] + 1);
}
}
}
for (int i = n; i; i -- ) {
g[i] = 1;
for (int j = n; j > i; j -- ) {
if (a[j] < a[i]) {
g[i] = max(g[i], g[j] + 1);
}
}
}
int res = 0;
for (int i = 1; i <= n; i ++ ) {
res = max(res, f[i] + g[i] - 1);
}
cout << res << endl;
return 0;
}
输入格式
输出格式
int a[N];
int f[N], g[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i ++ ) {
cin >> a[i];
}
int res = 0;
for (int i = 1; i <= n; i ++ ) {
f[i] = 1;
for (int j = 1; j < i; j ++ ) {
if (a[j] < a[i]) {
f[i] = max(f[i], f[j] + 1);
}
}
}
for (int i = n; i; i -- ) {
g[i] = 1;
for (int j = n; j > i; j -- ) {
if (a[j] < a[i]) {
g[i] = max(g[i], g[j] + 1);
}
}
}
for (int i = 1; i <= n; i ++ ) {
res = max(f[i] + g[i] - 1, res);
}
cout << n - res << endl;
return 0;
}
输入格式
输出格式
PII p[N];
int f[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i ++ ) {
cin >> p[i].first >> p[i].second;
}
sort(p + 1, p + 1 + n);
int res = 0;
for (int i = 1; i <= n; i ++ ) {
f[i] = 1;
for (int j = 1; j < i; j ++ ) {
if (p[j].second < p[i].second) {
f[i] = max(f[i], f[j] + 1);
}
}
res = max(res, f[i]);
}
cout << res << endl;
return 0;
}
输入格式
输出格式
int a[N], f[N];
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i ++ ) {
cin >> a[i];
}
int res = 0;
for (int i = 1; i <= n; i ++ ) {
f[i] = a[i];
for (int j = 1; j < i; j ++ ) {
if (a[j] < a[i]) {
f[i] = max(f[i], f[j] + a[i]);
}
}
res = max(res, f[i]);
}
cout << res << endl;
return 0;
}
输入格式
输出格式
int a[N];
int f[N], g[N];
int find1(int l, int r, int x) {
while (l < r) {
int mid = l + r >> 1;
if (f[mid] < x) {
r = mid;
} else {
l = mid + 1;
}
}
return r;
}
int find2(int l, int r, int x) {
while (l < r) {
int mid = l + r >> 1;
if (g[mid] >= x) {
r = mid;
} else {
l = mid + 1;
}
}
return r;
}
int main() {
int n = 1;
while (cin >> a[n]) {
n ++ ;
}
int len = 1;
f[len] = a[1];
for (int i = 2; i < n; i ++ ) {
if (a[i] <= f[len]) {
f[ ++ len] = a[i];
} else {
f[find1(1, len, a[i])] = a[i];
}
}
cout << len << endl;
int cnt = 0;
for (int i = 1; i < n; i ++ ) {
if (a[i] > g[cnt]) {
g[ ++ cnt] = a[i];
} else {
g[find2(1, cnt, a[i])] = a[i];
}
}
cout << cnt << endl;
return 0;
}
4.状态机模型
输入格式
输出格式
int w[N], f[N][2];
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n; i ++ ) {
cin >> w[i];
}
f[0][0] = 0, f[0][1] = -INF;
for (int i = 1; i <= n; i ++ ) {
f[i][0] = max(f[i - 1][0], f[i - 1][1]);
f[i][1] = f[i - 1][0] + w[i];
}
cout << max(f[n][0], f[n][1]) << endl;
}
int main() {
int t;
cin >> t;
while (t -- ) {
solve();
}
return 0;
}
输入格式
输出格式
int w[N], f[N][M][2];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i ++ ) {
cin >> w[i];
}
memset(f, -0x3f, sizeof f);
for (int i = 0; i <= n; i ++ ) {
f[i][0][0] = 0; // 初始化
}
for (int i = 1; i <= n; i ++ ) {
for (int j = 1; j <= m; j ++ ) {
f[i][j][0] = max(f[i - 1][j][0], f[i - 1][j][1] + w[i]);
f[i][j][1] = max(f[i - 1][j][1], f[i - 1][j - 1][0] - w[i]);
}
}
int res = 0;
for (int i = 0; i <= m; i ++ ) {
res = max(res, f[n][i][0]);
}
cout << res << endl;
return 0;
}
输入格式
输出格式
int n;
int w[N], f[N][3];
int main() {
cin >> n;
for (int i = 1; i <= n; i ++ ) {
cin >> w[i];
}
f[0][2] = 0, f[0][1] = -0x3f3f3f3f, f[0][0] = -0x3f3f3f3f;
for (int i = 1; i <= n; i ++ ) {
f[i][0] = max(f[i - 1][0], f[i - 1][2] - w[i]);
f[i][1] = f[i - 1][0] + w[i];
f[i][2] = max(f[i - 1][1], f[i - 1][2]);
}
cout << max(f[n][1], f[n][2]) << endl;
return 0;
}
5.区间DP
1 3 5 2， 我们可以先合并 1、21、2 堆，代价为 44，得到 4 5 2， 又合并 1、21、2 堆，代价为 99，得到 9 2 ，再合并得到 1111，总代价为 4+9+11=244+9+11=24；4 7，最后一次合并代价为 1111，总代价为 4+7+11=224+7+11=22。输入格式
输出格式
int n;
int s[N];
int f[N][N];
int main() {
scanf("%d", &n);
for(int i = 1; i <= n; i ++) scanf("%d", &s[i]);
// 处理前缀和
for(int i = 1; i <= n; i ++) {
s[i] += s[i - 1];
}
// 枚举所有状态 (按长度从小到大枚举状态)
// 处理边界问题：区间长度为1，合并不需要代价，所以len从2开始枚举
for(int len = 2; len <= n; len ++) { // 枚举长度
for(int i = 1; i + len - 1 <= n; i ++) { // 枚举起点
int l = i, r = i + len - 1; // 左右端点
f[l][r] = 1e8;
for(int k = l; k < r; k ++) { // 枚举分界点
f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + s[r] - s[l - 1]);
}
}
}
printf("%d\n", f[1][n]); // 将第一堆到第n堆合并的最小代价
return 0;
}
6.计数类DP
输入格式
输出格式
int n;
int f[N][N];
int main() {
cin >> n;
f[0][0] = 1;
for(int i = 1; i <= n; i ++) {
for(int j = 1; j <= i; j ++) {
f[i][j] = (f[i - 1][j - 1] + f[i - j][j]) % mod;
}
}
int res = 0;
for (int i = 1; i <= n; i ++ ) res = (res + f[n][i]) % mod;
cout << res << endl;
return 0;
}
7.数位统计DP
1024 1025 1026 1027 1028 1029 1030 1031 1032
0 出现 1010 次，1 出现 1010 次，2 出现 77 次，3 出现 33 次等等…输入格式
0 0 时，表示输入终止，且该行不作处理。输出格式
0 出现的次数，第二个数字表示 1 出现的次数，以此类推。LL f[10];
int T[9] = {1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000};
//T[i]-->10^i
/* 求0~n中k出现的次数 */
LL get(int n, int k) {
LL res = 0;
//当k为0时由于不能存在前导0为方便起见就分开讨论了
if (k) {
LL a, b, c;
//n从最后一位到第一位逐个看
//b表示当前看到的哪一位对应的值，a表示b前面的值，c表示b后面的值
/* xxxabcyyy */
for (int i = 1, j = 0; n / i; i *= 10, j ++ ) {
a = n / i / 10;
b = n / i % 10;
c = n % i;
//先考虑b前面从0~a-1
res += a * T[j];
//在考虑b前面为a时
if (k < b) {
res += T[j];
} else if (k == b) {
res += c + 1;
}
//cout << i << ' ' << j << '.'<< endl;
}
} else {
//与前面不同的是第一次绝对不能为0因此不用管第一位
LL a, b, c;
for (int i = 1, j = 0; n / i / 10; i *= 10, j ++ ) {
a = n / i / 10;
b = n / i % 10;
c = n % i;
//与前面不同的是这儿要考虑的是：b前面从1~a-1
res += (a - 1) * T[j];
if (k < b) {
res += T[j];
} else if (k == b) {
res += c + 1;
}
}
}
return res;
}
void solve(int a, int b) {
for (int i = 0; i < 10; i ++ ) {
//1~b中i出现次数 - 1~a-1中i出现的次数为a~b中i出现的次数
f[i] = get(b, i) - get(a - 1, i);
}
}
int main() {
int a, b;
/* 读入数据 */
/* 多组数据读入加~ */
while (~scanf("%d%d", &a, &b) && (a || b)) {
/* 如果a比b大，交换，方便比较 */
if (a > b) {
swap(a, b);
}
/* 每次操作清空数组f */
memset(f, 0, sizeof f);
/* 求a, b之间所有0~9出现的次数 */
solve(a, b);
/* 输出 */
for (int i = 0; i < 10; i ++ ) {
printf("%lld ", f[i]);
}
puts("");
}
return 0;
}
8.状态压缩DP
输入格式
输出格式
int n, m;
long long f[N][M];
bool st[M];
int main() {
while (cin >> n >> m, n || m) {
for (int i = 0; i < 1 << n; i ++ ) {
int cnt = 0;
st[i] = true;
for (int j = 0; j < n; j ++ )
if (i >> j & 1) {
if (cnt & 1) st[i] = false;
cnt = 0;
}
else cnt ++ ;
if (cnt & 1) st[i] = false;
}
memset(f, 0, sizeof f);
f[0][0] = 1;
for (int i = 1; i <= m; i ++ )
for (int j = 0; j < 1 << n; j ++ )
for (int k = 0; k < 1 << n; k ++ )
if ((j & k) == 0 && st[j | k])
f[i][j] += f[i - 1][k];
cout << f[m][0] << endl;
}
return 0;
}
输入格式
输出格式
int n;
int w[N][N];
int f[M][N];
int main() {
cin >> n;
for (int i = 0; i < n; i ++ )
for (int j = 0; j < n; j ++ )
cin >> w[i][j];
memset(f, 0x3f, sizeof f);
f[1][0] = 0;
for (int i = 0; i < 1 << n; i ++ )
for (int j = 0; j < n; j ++ )
if (i >> j & 1)
for (int k = 0; k < n; k ++ )
if (i >> k & 1)
f[i][j] = min(f[i][j], f[i - (1 << j)][k] + w[k][j]);
cout << f[(1 << n) - 1][n - 1];
return 0;
}
9.树形DP
输入格式
输出格式
int n;
int h[N], e[N], ne[N], idx;
int happy[N];
int f[N][2];
bool has_fa[N];
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
void dfs(int u) {
f[u][1] = happy[u];
for (int i = h[u]; ~i; i = ne[i]) {
int j = e[i];
dfs(j);
f[u][1] += f[j][0];
f[u][0] += max(f[j][0], f[j][1]);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i ++ ) scanf("%d", &happy[i]);
memset(h, -1, sizeof h);
for (int i = 0; i < n - 1; i ++ ) {
int a, b;
scanf("%d%d", &a, &b);
add(b, a);
has_fa[a] = true;
}
int root = 1;
while (has_fa[root]) root ++ ;
dfs(root);
printf("%d\n", max(f[root][0], f[root][1]));
return 0;
}
10.记忆化搜索
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9
输入格式
输出格式
int n, m;
int h[N][N];
int f[N][N];
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
int dp(int x, int y) {
if (f[x][y] != -1) { // 计算过
return f[x][y];
}
f[x][y] = 1;
for (int i = 0; i < 4; i ++ ) {
int nx = x + dx[i], ny = y + dy[i];
if (nx >= 1 && nx <= n && ny >= 1 && ny <= m && h[nx][ny] < h[x][y]) {
f[x][y] = max(f[x][y], dp(nx, ny) + 1);
}
}
return f[x][y];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i ++ ) {
for (int j = 1; j <= m; j ++ ) {
scanf("%d", &h[i][j]);
}
}
// 递归算每个状态
memset(f, -1, sizeof f);
int res = 0;
for (int i = 1; i <= n; i ++ ) {
for (int j = 1; j <= m; j ++ ) {
res = max(res, dp(i, j));
}
}
printf("%d\n", res);
return 0;
}
11.不知道叫啥但是很常见的一个dp
#include
#include