动态规划题目和代码

合集下载

《信息学奥赛一本通》：第9章第2节动态规划背包问题(C++版)

f[n][m]即为最优解。
【参考程序】
#include<cstdio> using namespace std;
const int maxm = 201, maxn = 31;
int m, n;
int w[maxn], c[maxn];
int f[maxn][maxm];
int main()
{
scanf("%d%d",&m, &n);
for (int i=1; i <= n; i++)
//设f(v)表示重量不超过v公斤的最大价值
for (int v = m; v >= w[i]; v--)
if (f[v-w[i]]+c[i]>f[v])
f[v] = f[v-w[i]]+c[i];
printf("%d",f[m]);
// f(m)为最优解
【例9-12】、完全背包问题【问题描述】
设有n种物品，每种物品有一个重量及一个价值。但每种物品的数量是无限的，同时有一个背包，最大载重量为M，今从n种物品中选取若干件(同一种物品可以多次选取)，使其重量的和小于等于M，而价值的和为最大。
【输入格式】
第一行：两个整数，M(背包容量，M<=200)和N(物品数量，N<=30)；第2..N+1行：每行二个整数Wi,Ci，表示每个物品的重量和价值。【输出格式】
第九章动态规划
第二节背包问题
第二节背包问题
一、01背包问题问题：
有N件物品和一个容量为V的背包。第i件物品的费用（即体积，下同）是w[i]，价值是c[i]。求解将哪些物品装入背包可使这些物品的费用总和不超过背包容量，且价值总和最大。基本思路：

动态规划试题

动态规划试题动态规划装箱问题（01背包）：有⼀个箱⼦容量为VV（正整数，0≤V≤20000），同时有n个物品（024 68 3 12 7 9 7输出：0f[j]=max(f[j],f[j-w[i]]+w[i]);f[j] 为：当总容量为j 时，不放第i 件物品，所能装的最⼤体积。

f[j-w[i]]+w[i] 为：当总容量为j 时，放了第i 件物品后，所能装的最⼤体积。

（即j减去第i 件物品体积的容量能装的最⼤体积+第i 件物品的体积。

w[i] 为第i 件物品体积）背包的种类：背包分为01背包，多重背包以及完全背包这三种基本模型，其他的背包问题都是从这3种背包中延申出来的。

完全背包的模板题⾯是这样的：设有n种物品，每种物品有⼀个重量及⼀个价值。

但每种物品的数量是⽆限的，同时有⼀个背包，最⼤载重量为M，今从n种物品中选取若⼲件(同⼀种物品可以⽆限选取)，使其重量的和⼩于等于M，⽽价值的和为最⼤。

完全背包[⽆限量]的采摘药输⼊：70 371 10069 11 2输出：140每个数组在满⾜条件，可以遍历多次01背包实现代码：采药-传送门输⼊：70 371 10069 11 2输出：3每个数组遍历⼀遍题⽬描述⾦明今天很开⼼，家⾥购置的新房就要领钥匙了，新房⾥有⼀间他⾃⼰专⽤的很宽敞的房间。

更让他⾼兴的是，妈妈昨天对他说：“你的房间需要购买哪些物品，怎么布置，你说了算，只要不超过N元钱就⾏”。

今天⼀早⾦明就开始做预算，但是他想买的东西太多了，肯定会超过妈妈限定的N元。

于是，他把每件物品规定了⼀个重要度，分为5等：⽤整数1-5表⽰，第5等最重要。

他还从因特⽹上查到了每件物品的价格（都是整数元）。

他希望在不超过N元（可以等于N 元）的前提下，使每件物品的价格与重要度的乘积的总和最⼤。

设第jj件物品的价格为v_[j]，重要度为w_[j]，共选中了k件物品，编号依次为j_1,j_2,…,j_k，则所求的总和为：w_[j_k]v[j1]×w[j1]+v[j2]×w[j2]+…+v[jk]×w[jk]。

动态规划47题

动态规划练习【题目一览】总分【问题描述】学生在我们USACO的竞赛中的得分越多我们越高兴。

我们试着设计我们的竞赛以便人们能尽可能的多得分，这需要你的帮助。

我们可以从几个种类中选取竞赛的题目，这里的一个“种类”是指一个竞赛题目的集合，解决集合中的题目需要相同多的时间并且能得到相同的分数。

你的任务是写一个程序来告诉USACO的职员，应该从每一个种类中选取多少题目，使得解决题目的总耗时在竞赛规定的时间里并且总分最大。

输入包括竞赛的时间M（1<=M<=10000）（不要担心，你要到了训练营中才会有长时间的比赛）和“种类”的数目N（1<=N<=10000）。

后面的每一行将包括两个整数来描述一个“种类”：第一个整数说明解决这种题目能得的分数（1<=points<=10000），第二整数说明解决这种题目所需的时间（1<=minutes<=10000）。

你的程序应该确定我们应该从每个“种类”中选多少道题目使得能在竞赛的时间中得到最大的分数。

来自任意的“种类”的题目数目可能任何非负数（0或更多）。

计算可能得到的最大分数。

【输入格式】输入文件中的第1行：M，N--竞赛的时间和题目“种类”的数目。

第2～N+1行：两个整数：每个“种类”题目的分数和耗时。

【输出格式】输出文件中仅一行，包括那个在给定的限制里可能得到的最大的分数。

【输入输出样例】输入：300 4100 60250 120120 10035 20输出：605从第2个“种类”中选两题第4个“种类”中选三题。

邮票【问题描述】已知一个N枚邮票的面值集合（如，{1分，3分}）和一个上限K——表示信封上能够贴K张邮票。

计算从1到M的最大连续可贴出的邮资。

例如，假设有1分和3分的邮票；你最多可以贴5张邮票。

很容易贴出1到5分的邮资（用1分邮票贴就行了），接下来的邮资也不难：6 = 3 + 37 = 3 + 3 + 18 = 3 + 3 + 1 + 19 = 3 + 3 + 310 = 3 + 3 + 3 + 111 = 3 + 3 + 3 + 1 + 112 = 3 + 3 + 3 + 313 = 3 + 3 + 3 + 3 + 1然而，使用5枚1分或者3分的邮票根本不可能贴出14分的邮资。

DP入门（2）——DAG上的动态规划

DP⼊门（2）——DAG上的动态规划有向⽆环图（DAG,Directed Acyclic Graph）上的动态规划是学习动态规划的基础。

很多问题都可以转化为DAG上的最长路、最短路或路径计数问题。

⼀、DAG模型【嵌套矩形问题】问题：有n个矩形，每个矩形可以⽤两个整数a、b描述，表⽰它的长和宽。

矩形X(a , b)可以嵌套在矩形Y(c , d)中当且仅当a<c,b<d,或者b<c,a<d(相当于把矩形X旋转90°)。

例如(1,5)可以嵌套在(6, 2)内，但不能嵌套在(3, 4)内。

你的任务是选出尽可能多的矩形排成⼀⾏，使得除了最后⼀个之外，每个矩形都可以嵌套在下⼀个矩形内。

如果有多解，矩形编号的字典序应尽量⼩。

分析：矩形之间的“可嵌套”关系是⼀个典型的⼆元关系（我的理解是两个矩形之间存在关系），⼆元关系可以⽤图来建模。

如果矩形X可以嵌套在矩形Y⾥，就从X到Y连⼀条有向边。

这个有向图必然是⽆环的，因为⼀个矩形⽆法直接或间接地嵌套在⾃⼰内部。

换句话说，它是⼀个DAG。

这样，所要求的便是DAG上的最长路径。

【硬币问题】问题：有n种硬币，⾯值分别为V1, V2, ..., V n，每种都有⽆限多。

给定⾮负整数S，可以选⽤多少个硬币，使得⾯值之和恰好为S？输出硬币数⽬的最⼩值和最⼤值。

1 <= n <= 100, 0 <= S <= 10000, 1 <= V i <= S。

分析：此问题尽管看上去和嵌套矩形问题很不⼀样，但本题的本质也是DAG上的路径问题。

将每种⾯值看作⼀个点，表⽰“还需要凑⾜的⾯值”，则初始状态为S，⽬标状态为0。

若当前在状态 i，每使⽤⼀个硬币 j，状态便转移到i - V j。

补充：这个模型和上⼀题类似，但也有⼀些明显地不同之处：上题并没有确定路径的起点和终点（可以把任意矩形放在第⼀个和最后⼀个），⽽本题的起点必须为S，终点必须为0。

c++动态规划试题+分析

我们设机器人走到(i,j) 位置时拾到最多垃圾数为 f[i][j] ，由于机器人只能朝右和下走，只会跟机器人上一位置拾到最多的垃圾数有关，因此很容易写出状态转移方程。 F[i][j]=max{f[i-1][j],f[i][j-1]}+a[i][j],(1<=i<=n,1<=j<=m) 初始值：f[1][i]=f[1][i-1]+a[1][i] ，f[i][1]=f[i-1][1]+a[i][1] 时间复杂度为：O(nm) 我们再来看第二问：在最优解的情况下求方案总数，我们只要每次在最优解的情况下统计路径条数即可，见图 2：设 g[i][j] 表示在位置(i,j)达到拾到 f[i][j]垃圾时的路径总数，有如下ቤተ መጻሕፍቲ ባይዱ程： g[i][j]=g[i-1][j]*x+g[i][j-1]*y 当 f[i][j]=f[i-1][j]+a[i][j] 时，x=1，否则 x=0；当 f[i][j]=f[i][j-1]+a[i][j] 时，y=1，否则 y=0；
using namespace std; int n,m,a[200005],b[200005],f[200005]; void init() { int i,j=0; cin>>n>>m; for(i=1;i<=n;i++)cin>>a[i]; for(i=1;i<m;i++)if(a[i]<a[m])b[++j]=a[i];//去掉前面大于等于 a[m]的数 b[++j]=a[m]; for(i=m+1;i<=n;i++)if(a[i]>a[m])b[++j]=a[i];//去掉后面小于等于 a[m]的数 } int ERLIS()//上升子序列 { int i,L,r,mid,len=1; f[1]=b[1]; for(i=2;i<=n;i++) { L=1;r=len; if(f[len]<b[i]){len++;f[len]=b[i];continue;} while(L<=r) { mid=(L+r)/2; if(f[mid]<b[i])L=mid+1;else r=mid-1; } f[L]=b[i]; } return len; } int main() { init(); cout<<ERLIS()<<endl; } 3、采药 .cpp/c/pas) （medic medic.cpp/c/pas) 【问题描述】辰辰是个天资聪颖的孩子，他的梦想是成为世界上最伟大的医师。为此，他想拜附近最有威望的医师为师。医师为了判断他的资质，给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说：“孩子，这个山洞里有一些不同的草药，采每一株都需要一些时间，每一株也有它自身的价值。我会给你一段时间，在这段时间里，你可以采到一些草药。如果你是一个聪明的孩子，你应该可以让采到的草药的总价值最大。” 如果你是辰辰，你能完成这个任务吗？【输入格式】输入文件的第一行包含两个正整数 N,M。M 表示总共能够用来采药的时间，N 代表山洞里的草药的数目。接下来的 N 行每行包括两个的整数，分别表示采摘某株草药的时间 T i 和这株草药的价值 V i。【输出格式】输出文件仅包含一个整数表示规定时间内可以采到的草药的最大总价值。【样例输入输出】 medic .in medic .out medic.in medic.out 39 3 10 10 81 12 】【数据规模和约定数据规模和约定】 50%的数据中 N ，M≤1000；

动态规划总结经典题目(经典中的经典)

动态规划总结——经典问题总结本文着重讨论状态是如何表示，以及方程是怎样表示的。

当然，还附上关键的，有可能作为模板的代码段。

但有的代码的实现是优化版的。

经典问题总结最长上升子序列（LIS）问题描述如下:设L=<a1,a2,…,an>是n个不同的实数的序列，L的递增子序列是这样一个子序列Lin=<aK1,ak2,…,akm>，其中k1<k2<…<km且aK1<ak2<…<akm。

求最大的m值。

这里采用的是逆向思维的方法，从最后一个开始想起，即先从A[N]（A数组是存放数据的数组，下同）开始，则只有长度为1的子序列，到A[N-1]时就有两种情况，如果a[n-1] < a[n] 则存在长度为2的不下降子序列a[n-1],a[n]；如果a[n-1] > a[n] 则存在长度为1的不下降子序列a[n-1]或者a[n]。

有了以上的思想，DP方程就呼之欲出了（这里是顺序推的，不是逆序的）：DP[I]=MAX（1,DP[J]+1）J=0,1,...,I-1但这样的想法实现起来是）O(n^2)的。

本题还有更好的解法，就是O(n*logn)。

利用了长升子序列的性质来优化，以下是优化版的代码：//最长不降子序const int SIZE=500001;int data[SIZE];int dp[SIZE];//返回值是最长不降子序列的最大长度,复杂度O(N*logN)int LCS(int n) { //N是DATA数组的长度,下标从1开始int len(1),low,high,mid,i;dp[1]=data[1];for(i=1;i<=n;++i) {low=1;high=len;while( low<=high ) { //二分mid=(low+high)/2;if( data[i]>dp[mid] ) {low=mid+1;}else {high=mid-1;}}dp[low]=data[i];if( low>len ) {++len;}}return len;}最长公共子序列（LCS）给出两个字符串a, b，求它们的最长、连续的公共字串。

C语言动态规划之背包问题详解

C语⾔动态规划之背包问题详解01背包问题给定n种物品，和⼀个容量为C的背包，物品i的重量是w[i],其价值为v[i]。

问如何选择装⼊背包的物品，使得装⼊背包中的总价值最⼤？（⾯对每个武平，只能有选择拿取或者不拿两种选择，不能选择装⼊某物品的⼀部分，也不能装⼊物品多次）声明⼀个数组f[n][c]的⼆维数组，f[i][j]表⽰在⾯对第i件物品，且背包容量为j时所能获得的最⼤价值。

根据题⽬要求进⾏打表查找相关的边界和规律根据打表列写相关的状态转移⽅程⽤程序实现状态转移⽅程真题演练：⼀个旅⾏者有⼀个最多能装M公⽄的背包，现在有n件物品，它们的重量分别是W1、W2、W3、W4、…、Wn。

它们的价值分别是C1、C3、C2、…、Cn,求旅⾏者能获得最⼤价值。

输⼊描述：第⼀⾏：两个整数，M（背包容量，M<= 200)和N（物品数量，N<=30);第2…N+1⾏：每⾏两个整数Wi，Ci，表⽰每个物品的质量与价值。

输出描述：仅⼀⾏，⼀个数，表⽰最⼤总价值样例：输⼊：10 42 13 34 57 9输出：12解题步骤定义⼀个数组dp[i][j]表⽰容量为j时，拿第i个物品时所能获取的最⼤价值。

按照题⽬要求进⾏打表，列出对应的dp表。

W[i]（质量）V[i]（价值）01234567891000000000000210011111111133001334444444500135568899790013556991012对于⼀个动态规划问题设置下标时最好从0开始，因为动态规划经常会和上⼀个状态有关系！从上⾯的dp表可以看出来对于⼀个物品我们拿还是不难需要进⾏两步来判断。

第⼀步：判断背包当前的容量j是否⼤于物品当前的质量，如果物品的质量⼤于背包的容量那么就舍弃。

第⼆步：如果背包可以装下这个物品，就需要判断装下该物品获取的最⼤价值是不是⼤于不装下这个物品所获取的最⼤价值，如果⼤于那么就把东西装下！根据这样的思想我们可以得到状态转移⽅程：如果单签背包的容量可以装下物品:dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);如果当前背包的容量装不下该物品:dp[i][j]=dp[i-1][j];#include <stdio.h>int max(const int a,const int b){return a>b ? a:b;}int main(){int w[35]={0},v[35]={0},dp[35][210]={0};int n,m;scanf("%d %d",&m,&n);int i,j;for(i=1;i<=n;i++){scanf("%d %d",&w[i],&v[i]);}for(i=1;i<=n;i++){for(j=1;j<=m;j++){if(j>=w[i])//如果当前背包的容量⼤于商品的质量{dp[i][j]=max(dp[i-1][j],dp[i-1][j-w[i]]+v[i]);//判断是否应该拿下}else//⼤于背包的当前容量{dp[i][j]=dp[i-1][j];}}}for(int k=0;k<=n;k++){for(int l=0;l<=m;l++){printf("%d ",dp[k][l]);}printf("\n");}printf("%d\n",dp[n][m]);}通过运⾏以上程序可以看到最终的输出dp表和我们的预期是相符合的！但是并没有结束，动态规划有⼀个后⽆效性原则(当前状态只与前⼀个状态有关)。

poj dp题目列表

[1]POJ 动态规划题目列表容易：1018, 1050, 1083, 1088, 1125, 1143, 1157, 1163, 1178, 1179, 1189, 1208, 1276, 1322, 1414, 1456, 1458, 1609, 1644, 1664, 1690, 1699, 1740(博弈), 1742, 1887, 1926(马尔科夫矩阵，求平衡）, 1936, 1952, 1953, 1958, 1959, 1962, 1975, 1989, 2018, 2029, 2039, 2063, 2081, 2082, 2181, 2184, 2192, 2231, 2279, 2329, 2336, 2346, 2353, 2355, 2356, 2385, 2392, 2424,不易：1019, 1037, 1080, 1112, 1141, 1170, 1192, 1239, 1655, 1695, 1707, 1733(区间减法加并查集), 1737, 1837, 1850, 1920(加强版汉罗塔), 1934(全部最长公共子序列), 1937(计算几何), 1964(最大矩形面积，O(n)算法), 2138, 2151, 2161, 2178,推荐：1015, 1635, 1636(挺好的), 1671, 1682, 1692(优化), 1704, 1717, 1722, 1726, 1732, 1770, 1821, 1853, 1949, 2019, 2127, 2176, 2228, 2287, 2342, 2374, 2378, 2384, 24111015 Jury Compromise1029 False coin1036 Gangsters1037 A decorative fence1038 Bugs Integrated, Inc.1042 Gone Fishing1050 To the Max1062 昂贵的聘礼1074 Parallel Expectations1080 Human Gene Functions1088 滑雪1093 Formatting Text1112 Team Them Up!1141 Brackets Sequence1143 Number Game1157 LITTLE SHOP OF FLOWERS1159 Palindrome1160 Post Office1163 The Triangle1170 Shopping Offers1178 Camelot1179 Polygon1180 Batch Scheduling1185 炮兵阵地1187 陨石的秘密1189 钉子和小球1191 棋盘分割1192 最优连通子集1208 The Blocks Problem1239 Increasing Sequences1240 Pre-Post-erous!1276 Cash Machine1293 Duty Free Shop1322 Chocolate1323 Game Prediction1338 Ugly Numbers1390 Blocks1414 Life Line1432 Decoding Morse Sequences 1456 Supermarket1458 Common Subsequence1475 Pushing Boxes1485 Fast Food1505 Copying Books1513 Scheduling Lectures1579 Function Run Fun1609 Tiling Up Blocks1631 Bridging signals 2分+DP NLOGN 1633 Gladiators1635 Subway tree systems1636 Prison rearrangement1644 To Bet or Not To Bet1649 Market Place1651 Multiplication Puzzle1655 Balancing Act1661 Help Jimmy1664 放苹果1671 Rhyme Schemes1682 Clans on the Three Gorges 1690 (Your)((Term)((Project)))1691 Painting A Board1692 Crossed Matchings1695 Magazine Delivery1699 Best Sequence1704 Georgia and Bob1707 Sum of powers1712 Flying Stars1714 The Cave1717 Dominoes1718 River Crossing1722 SUBTRACT1726 Tango Tango Insurrection 1732 Phone numbers1733 Parity game1737 Connected Graph1740 A New Stone Game1742 Coins P1745 Divisibility1770 Special Experiment1771 Elevator Stopping Plan 1776 Task Sequences1821 Fence1837 Balance1848 Tree1850 Code1853 Cat1874 Trade on Verweggistan 1887 Testing the CATCHER 1889 Package Pricing1920 Towers of Hanoi1926 Pollution1934 Trip1936 All in All1937 Balanced Food1946 Cow Cycling1947 Rebuilding Roads1949 Chores1952 BUY LOW, BUY LOWER 1953 World Cup Noise1958 Strange Towers of Hanoi 1959 Darts1962 Corporative Network 1964 City Game1975 Median Weight Bead 1989 The Cow Lineup2018 Best Cow Fences2019 Cornfields2029 Get Many Persimmon Trees 2033 Alphacode2039 To and Fro2047 Concert Hall Scheduling 2063 Investment2081 Recaman's Sequence 2082 Terrible Sets2084 Game of Connections2127 Greatest Common Increasing Subsequence 2138 Travel Games2151 Check the difficulty of problems2152 Fire2161 Chandelier2176 Folding2178 Heroes Of Might And Magic2181 Jumping Cows2184 Cow Exhibition2192 Zipper2193 Lenny's Lucky Lotto Lists2228 Naptime2231 Moo Volume2279 Mr. Young's Picture Permutations2287 TianJi -- The Horse Racing2288 Islands and Bridges2292 Optimal Keypad2329 Nearest number - 22336 Ferry Loading II2342 Anniversary party2346 Lucky tickets2353 Ministry2355 Railway tickets2356 Find a multiple2374 Fence Obstacle Course2378 Tree Cutting2384 Harder Sokoban Problem2385 Apple Catching2386 Lake Counting2392 Space Elevator2397 Spiderman2411 Mondriaan's Dream2414 Phylogenetic Trees Inherited2424 Flo's Restaurant2430 Lazy Cows2915 Zuma3017 Cut the Sequence3028 Shoot-out3124 The Bookcase3133 Manhattan Wiring3345 Bribing FIPA3375 Network Connection3420 Quad Tiling ?/?cat=5[2]动态规划方法总结1. 按状态类型分写在前面：从状态类型分，并不表示一题只从属于一类。

动态规划问题（斐波那契数列）

动态规划问题（斐波那契数列）算法1. 动态规划题⽬1：写⼀个函数，输⼊ n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。

斐波那契数列的定义如下：F(0) = 0, F(1)= 1F(N) = F(N - 1) + F(N - 2), 其中 N > 1.斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加⽽得出。

答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。

⽰例 1：输⼊：n = 2思路：1. ⾸先想到的是递归，后⾯的函数需要调⽤前⾯的函数，并且有明显的停⽌条件。

2. 然后是动态规划，要计算第三个数，只需要知道前⾯两个数即可，⽽最开始的两个很容易得出。

再下⼀次计算中舍弃第⼀个，保留第⼆三个数。

作为下⼀轮的第⼀⼆位。

如此重复操作即可。

（就是⼀个循环的问题）代码：public class Fib {//测试public static void main(String[] args) {System.out.println(fib(22));System.out.println(fib01(1000));}//思路1public static int fib(int n) {if (n == 0 || n == 1) {return n;}return fib(n - 1) + fib(n - 2);}//思路2public static int fib01(int n) {if (n < 2) {return n;}final int MOD = 1000000007;int a = 0;int b = 1;int c = 0;for (int i = 1; i < n; i++) {c = (a + b) % MOD;a = b;b = c;}return c;}}题⽬2：⼀只青蛙⼀次可以跳上1级台阶，也可以跳上2级台阶。

Poj动态规划

[1]POJ 动态规划题目列表容易：1018, 1050, 1083, 1088, 1125, 1143, 1157, 1163, 1178, 1179, 1189, 1208, 1276, 1322, 1414, 1456, 1458, 1609, 1644, 1664, 1690, 1699, 1740(博弈), 1742, 1887, 1926(马尔科夫矩阵，求平衡）, 1936,1952, 1953, 1958, 1959, 1962, 1975, 1989, 2018, 2029,2039, 2063, 2081, 2082,2181, 2184, 2192, 2231, 2279, 2329, 2336, 2346, 2353,2355, 2356, 2385, 2392, 2424,不易：1019,1037, 1080, 1112, 1141, 1170, 1192, 1239, 1655, 1695, 1707,1733(区间减法加并查集), 1737, 1837, 1850, 1920(加强版汉罗塔), 1934(全部最长公共子序列), 1937(计算几何), 1964(最大矩形面积，O(n)算法), 2138, 2151, 2161(烦，没写), 2178,推荐：1015, 1635, 1636(挺好的), 1671, 1682, 1692(优化), 1704, 1717, 1722, 1726, 1732, 1770, 1821, 1853, 1949, 2019, 2127, 2176, 2228, 2287, 2342, 2374, 2378, 2384, 2411状态DP树DP构造最优解四边形不等式单调队列1015 Jury Compromise1029 False coin1036 Gangsters1037 A decorative fence1038 Bugs Integrated, Inc.1042 Gone Fishing1050 To the Max1062 昂贵的聘礼1074 Parallel Expectations1080 Human Gene Functions1088 滑雪1093 Formatting Text1112 Team Them Up!1141 Brackets Sequence1143 Number Game1157 LITTLE SHOP OF FLOWERS1159 Palindrome1160 Post Office1163 The Triangle1170 Shopping Offers1178 Camelot1179 Polygon1180 Batch Scheduling1185 炮兵阵地1187 陨石的秘密1189 钉子和小球1191 棋盘分割1192 最优连通子集1208 The Blocks Problem1239 Increasing Sequences1240 Pre-Post-erous!1276 Cash Machine1293 Duty Free Shop1322 Chocolate1323 Game Prediction1338 Ugly Numbers1390 Blocks1414 Life Line1432 Decoding Morse Sequences 1456 Supermarket1458 Common Subsequence1475 Pushing Boxes1485 Fast Food1505 Copying Books1513 Scheduling Lectures1579 Function Run Fun1609 Tiling Up Blocks1631 Bridging signals 2分+DP NLOGN 1633 Gladiators1635 Subway tree systems1636 Prison rearrangement1644 To Bet or Not To Bet1649 Market Place1651 Multiplication Puzzle1655 Balancing Act1661 Help Jimmy1664 放苹果1671 Rhyme Schemes1682 Clans on the Three Gorges 1690 (Your)((Term)((Project)))1691 Painting A Board1692 Crossed Matchings 1695 Magazine Delivery 1699 Best Sequence1704 Georgia and Bob1707 Sum of powers1712 Flying Stars1714 The Cave1717 Dominoes1718 River Crossing1722 SUBTRACT1726 Tango Tango Insurrection 1732 Phone numbers1733 Parity game1737 Connected Graph1740 A New Stone Game 1742 Coins P1745 Divisibility1770 Special Experiment 1771 Elevator Stopping Plan 1776 Task Sequences1821 Fence1837 Balance1848 Tree1850 Code1853 Cat1874 Trade on Verweggistan 1887 Testing the CATCHER 1889 Package Pricing1920 Towers of Hanoi1926 Pollution1934 Trip1936 All in All1937 Balanced Food1946 Cow Cycling1947 Rebuilding Roads1949 Chores1952 BUY LOW, BUY LOWER 1953 World Cup Noise1958 Strange Towers of Hanoi 1959 Darts1962 Corporative Network 1964 City Game1975 Median Weight Bead 1989 The Cow Lineup2018 Best Cow Fences2019 Cornfields2029 Get Many Persimmon Trees2033 Alphacode2039 To and Fro2047 Concert Hall Scheduling2063 Investment2081 Recaman's Sequence2082 Terrible Sets2084 Game of Connections2127 Greatest Common Increasing Subsequence 2138 Travel Games2151 Check the difficulty of problems2152 Fire2161 Chandelier2176 Folding2178 Heroes Of Might And Magic2181 Jumping Cows2184 Cow Exhibition2192 Zipper2193 Lenny's Lucky Lotto Lists2228 Naptime2231 Moo Volume2279 Mr. Young's Picture Permutations2287 TianJi -- The Horse Racing2288 Islands and Bridges2292 Optimal Keypad2329 Nearest number - 22336 Ferry Loading II2342 Anniversary party2346 Lucky tickets2353 Ministry2355 Railway tickets2356 Find a multiple2374 Fence Obstacle Course2378 Tree Cutting2384 Harder Sokoban Problem2385 Apple Catching2386 Lake Counting2392 Space Elevator2397 Spiderman2411 Mondriaan's Dream2414 Phylogenetic Trees Inherited2424 Flo's Restaurant2430 Lazy Cows2915 Zuma3017 Cut the Sequence3028 Shoot-out3124 The Bookcase3133 Manhattan Wiring3345 Bribing FIPA3375 Network Connection3420 Quad Tiling ?/?cat=5[2]动态规划方法总结1. 按状态类型分写在前面：从状态类型分，并不表示一题只从属于一类。

常见动态规划题目详解

常见动态规划题⽬详解1.爬楼梯题⽬描述：假设你正在爬楼梯。

需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。

你有多少种不同的⽅法可以爬到楼顶呢？注意：给定 n 是⼀个正整数。

⽰例 1：输⼊： 2输出： 2解释：有两种⽅法可以爬到楼顶。

1. 1 阶 + 1 阶2. 2 阶⽰例 2：输⼊： 3输出： 3解释：有三种⽅法可以爬到楼顶。

1. 1 阶 + 1 阶 + 1 阶2. 1 阶 + 2 阶3. 2 阶 + 1 阶实现代码：class Solution {public:int climbStairs(int n) {vector<int> a(n);a[0] = 1;a[1] = 2;if(n == 1){return 1;}if(n == 2){return 2;}for(int i = 2; i < n;i++){a[i] = a[i - 1] + a[i - 2];}return a[n - 1];}};2.变态跳台阶题⽬描述：⼀只青蛙⼀次可以跳上1级台阶，也可以跳上2级……它也可以跳上n级。

求该青蛙跳上⼀个n级的台阶总共有多少种跳法。

实现代码：class Solution {public:int jumpFloorII(int number) {if(number == 0){return 0;}int total = 1;for(int i = 1; i < number; i++){total *= 2;}return total;}};3.n年后⽜的数量题⽬描述：假设农场中的母⽜每年会产⽣⼀头⼩母⽜，并且永远不会死。

第⼀年农场中只有⼀头成熟的母⽜，第⼆年开始，母⽜开始⽣⼩母⽜，每只⼩母⽜三年之后成熟⼜可以⽣⼩母⽜，给定整数N，求N年后母⽜的数量。

实现代码：class solution{　public: int f(int n){ if(n < 1){ return 0; } if(n == 1|| n== 2||n == 3){ return n; } int res = 3; int pre = 2; int prepre = 1; int tmp1=0; int tmp2 = 0; for(int i = 4;i < n;i++){ tmp1 = res; tmp2 = pre; res = pre + prepre; pre = tmp1; prepre = tmp2; } return res; }};4.矩形覆盖题⽬描述：我们可以⽤2*1的⼩矩形横着或者竖着去覆盖更⼤的矩形。

动态规划算法题（5题）

动态规划算法题（5题）1、题⽬描述（⽹易）有 n 个学⽣站成⼀排，每个学⽣有⼀个能⼒值，⽜⽜想从这 n 个学⽣中按照顺序选取 k 名学⽣，要求相邻两个学⽣的位置编号的差不超过d，使得这 k 个学⽣的能⼒值的乘积最⼤，你能返回最⼤的乘积吗？输⼊描述:每个输⼊包含 1 个测试⽤例。

每个测试数据的第⼀⾏包含⼀个整数 n (1 <= n <= 50)，表⽰学⽣的个数，接下来的⼀⾏，包含 n 个整数，按顺序表⽰每个学⽣的能⼒值 ai（-50 <= ai <= 50）。

接下来的⼀⾏包含两个整数，k 和 d (1 <= k <= 10, 1 <= d <= 50)。

输出描述:输出⼀⾏表⽰最⼤的乘积。

试题分析：本题要使⽤动态规划来解，动态规划的特点：1.求解的是最优化问题；2.可以分解为最优⼦结构本题可以先求解在第i个学⽣的位置下，j（j<K）个学⽣的能⼒值的最⼤值，得到所有学⽣位置下j个学⽣的能⼒值的最⼤值；在j个学⽣的情况下，得到j+1个学⽣的最⼤值，样例输出： 10 8 7 2 -7 9 5 4 10 -7 1 3 3输出： 630如上，第⼀步先计算k=2的情况：7:在d=3的情况下，最⼤最⼩值都为562:在d=3的情况下，最⼤值为16，最⼩值为14-7:在d=3的情况下，最⼤值为-14，最⼩值为-56......得到第⼀趟的结果k=3的情况下（这⾥以第⼀趟的结果为基础，只有这样就不需要考虑第⼀趟中d=3的限制）：2:在d=3的情况下，最⼤最⼩值都为112（56*2）-7:在d=3的情况下，最⼤值为-98（14*-7）最⼩值为-392（56*-7）9:在d=3的情况下，最⼤值为504（56*9）最⼩值为-504（-56*9）......得到第⼆趟的结果返回最⼤值就是最后的结果#-*- coding:utf-8 -*-n=input()array=[int(i) for i in raw_input().split()]k,d=[int(i) for i in raw_input().split()]# n=36array_max=array_min=array#轮询k-1趟即可for i in range(0,k-1):_max=[-float('inf')]*n#将最⼤值的数组赋值⽆穷⼩_min=[float('inf')]*n#将最⼩值的数组赋值⽆穷⼤for j in range(i+1,n):if j<=d+i:#下⾯对应的min、max都是考虑到array[j]为负值的情况下temp_max = max(max(ii*array[j] for ii in array_max[i:j]),max(ii*array[j] for ii in array_min[i:j]))temp_min = min(min(ii*array[j] for ii in array_max[i:j]),min(ii*array[j] for ii in array_min[i:j]))else:temp_max = max(max(ii*array[j] for ii in array_max[j-d:j]),max(ii*array[j] for ii in array_min[j-d:j]))temp_min = min(min(ii*array[j] for ii in array_max[j-d:j]),min(ii*array[j] for ii in array_min[j-d:j]))_max[j]=temp_max_min[j]=temp_minarray_max=_maxarray_min=_minprint array_maxprint array_minprint max(array_max)2、题⽬描述（腾讯）：腾讯⼤厦有39层，你⼿⾥有两颗⼀抹⼀眼的玻璃珠。

动态规划讲解大全(含例题及答案)

动态规划算法的应用
一、动态规划的概念
近年来，涉及动态规划的各种竞赛题越来越多，每一年的 NOI 几乎都至少有一道题目需要用动态规划的方法来解决；而竞赛对选手运用动态规划知识的要求也越来越高，已经不再停留于简单的递推和建模上了。
要了解动态规划的概念，首先要知道什么是多阶段决策问题。 1. 多阶段决策问题如果一类活动过程可以分为若干个互相联系的阶段，在每一个阶段都需作出决策(采取措施)，一个阶段的决策确定以后，常常影响到下一个阶段的决策，从而就完全确定了一个过程的活动路线，则称它为多阶段决策问题。各个阶段的决策构成一个决策序列，称为一个策略。每一个阶段都有若干个决策可供选择，因而就有许多策略供我们选取，对应于一个策略可以确定活动的效果，这个效果可以用数量来确定。策略不同，效果也不同，多阶段决策问题，就是要在可以选择的那些策略中间，选取一个最优策略，使在预定的标准下达到最好的效果. 2．动态规划问题中的术语阶段：把所给求解问题的过程恰当地分成若干个相互联系的阶段，以便于求解，过程不同，阶段数就可能不同．描述阶段的变量称为阶段变量。在多数情况下，阶段变量是离散的，用 k 表示。此外，也有阶段变量是连续的情形。如果过程可以在任何时刻作出决策，且在任意两个不同的时刻之间允许有无穷多个决策时，阶段变量就是连续的。
解决方法：
我们尝试从正面的思路去分析问题，如上例，不难得出一个非常简单的递归过程 : f1:=f(i-1,j+1); f2:=f(i-1,j); if f1>f2 then f:=f1+a[i,j] else f:=f2+a[i,j]; 显而易见，这个算法就是最简单的搜索算法。时间复杂度为 2n，明显是会超时的。分析一下搜索的过程，实际上，很多调用都是不必要的，也就是把产生过的最优状态，又产生了一次。为了避免浪费，很显然，我们存放一个 opt 数组：Opt[i, j] - 每产生一个 f(i, j)，将 f(i, j)的值放入 opt 中，以后再次调用到 f(i, j)的时候，直接从 opt[i, j]来取就可以了。于是动态规划的状态转移方程被直观地表示出来了，这样节省了思维的难度，减少了编程的技巧，而运行时间只是相差常数的复杂度，避免了动态规划状态转移先后的问题，而且在相当多的情况下，递归算法能更好地避免浪费，在比赛中是非常实用的.

动态规划（DynamicProgramming）LeetCode经典题目

动态规划（DynamicProgramming）LeetCode经典题⽬
动态规划（DP）概述：
动态规划是运筹学的⼀个分⽀。

（运筹学，是现代管理学的⼀门重要专业基础课。

该学科利⽤统计学、数学模型和算法等⽅法，去寻找复杂问题中的最佳或近似最佳的解答。

）
以局部最优解最终求得全局最优解。

在设计动态规划算法时，需要确认原问题与⼦问题、动态规划状态、边界状态结值、状态转移⽅程等关键要素。

在算法⾯试中，动态规划是最常考察的题型之⼀，⼤多数⾯试官都以是否可较好地解决动态规划相关问题来区分候选者是否“聪明”。

下⾯就让我们开始8道经典的动态规划相关题⽬吧！！
1、LeetCode70 爬楼梯
2、LeetCode198 打家劫舍
3、LeetCode53 最⼤⼦序和
4、LeetCode322 找零钱
5、LeetCode120 三⾓形
6、LeetCode300 最长上升⼦序列
7、LeetCode64 最⼩路径和
8、LeetCode174 地下城游戏
（题解稍后会在博客随笔分类“动态规划”中⼀⼀给出，耐⼼等待哦！！）
欢迎评论，共同进步！！。

【转载】各种背包问题模板讲解

【转载】各种背包问题模板讲解背包问题集合⼀般来说，动态规划（DP）。

都是初学者最难闯过的⼀关，⽽在这⾥详细解说动态规划的⼀种经典题型：背包问题。

这⾥介绍的背包分为以下⼏种：01背包，完全背包，多重背包，混合背包，⼆维费⽤的背包。

（以后会持续更新）【⼀：01背包】⾸先放上例题：01背包问题【题⽬描述】：⼀个旅⾏者有⼀个最多能装M公⽄的背包，现在有n件物品，他们的重量分别是W1，W2…Wn，它们的价值分别是C1，C2……Cn，求旅⾏者能够获得的最⼤总价值。

【输⼊格式】：第⼀⾏：两个整数，M，（背包容量，M<=200）和N（物品数量N<=30）第2⾄N+1⾏，每⾏两个整数，Wi,Ci,表⽰每个物品的重量和价值。

【输出格式】：仅⼀⾏，⼀个数，表⽰最⼤总价值。

【输⼊样例#1】：10 42 13 34 57 9【输出样例#1】：1201背包问题可以说是最简单的背包问题，简单之处就在：他的每⼀个物品都只有⼀个。

⾸先定义⼀个f[MAXN][MAXN]数组，⽤来记录最⼤价值。

即：f[i][v]表⽰的就是当前i件物品放⼊⼀个容量为v的背包的时候可以获得的最⼤价值。

01背包的状态转移⽅程式便是：f[i][v]=max(f[i-1][v],f[i-1][v-w[i]]+c[i])。

众所周知DP问题最重要的便是状态转移⽅程式了，那么这个状态转移⽅程式究竟是怎么来的呢？？详解来啦“既然说了是“将第i件物品放⼊背包”，那么如果只考虑第i件物品的⽅式策略，那么就只和第i-1件物品有关了，如果是放第i件物品，那么问题就转化为：“前i-1件物品放⼊容量为v的背包中”，此时能够获得的最⼤价值就是f[i-1][v-w[i]]，也就是第i-1件物品放⼊容量为v（原来的总容量）减去w[i]（第i件物品的占容）产⽣的最优价值，再加上放通过⼊第i件物品增加的价值c[i]。

那么放⼊第i件物品产⽣的最⼤价值就是要在”放“，或者是”不放“中选择了，”不放“的话，产⽣的价值就是f[i-1] [v]，”放“的话，产⽣的最⼤价值就是,f[i-1][v-w[i]]+c[i])。

动态规划题目选讲

例题二：加分二叉树
• 设一个n个节点的二叉树tree的中序遍历为（ l,2,3,…,n），其中数字1,2,3,…,n为节点编号。每个节点都有一个分数（均为正整数），记第 i个节点的分数为di，tree及它的每个子树都有一个加分，任一棵子树(也包含tree本身的分数 • 若某个子树为主，规定其加分为1，叶子的加分就是叶节点本身的分数。不考虑它的空子树。 • 试求一棵符合中序遍历为（1,2,3,…,n）且加分最高的二叉树tree。
思考
例题六
• 对于 k=0 的情况： • 我们发现遍历一棵树最后回到原点，那么对于所有的边，我们都是走过去，再走回来。 • 答案 (n-1)*2
例题六
• 对于 k=1 的情况 • 设每条边长度为1，然后树上找最长链，然后这条链走过去就不再一步步往回了，直接从链底连一条边去链顶，然后链中间连的那些点，直接走过去再走回来，它们那些边的答案是不变的。 • 答案 (n−1)*2−(最长链长度)+1 • 可以证明不能减得更多啦。
• 资源和含有工厂的星球个数都不超过4 • n≤200
想法
暴力枚举匹配方案，求最短路？
想法
暴力枚举匹配方案，求最短路？两条路径公用边怎么办？
思考
• 特殊的星球数量很少，可以枚举状态28=256
思考
• 特殊的星球数量很少，可以枚举状态28=256 • 如何表示状态?
• 设F[i][s]表示现在路径包含第i个星球，已经连接上的特殊星球选择方案是s的最少代价。 • 如何转移？
• 对于s的合并操作，枚举！
void Spfa(int s,int k){ int u,v,d,t; for(int top=1;top<=bot;top++){ u=Q[top]; for(int j=E[u].size()-1;j>=0;j--){ v=E[u][j];d=D[u][j];t=s|S[v]; if(F[u][s]+d*k<F[v][t]){ F[v][t]=F[u][s]+d*k; if(t==s&&V[v][s]){ V[v][s]=false;Q[++bot]=v; } } } V[u][s]=true; } }

动态规划套路详解

动态规划套路详解读完本⽂，你可以去⼒扣拿下如下题⽬：-----------这篇⽂章是我们号半年前⼀篇 200 多赞赏的成名之作「动态规划详解」的进阶版。

由于账号迁移的原因，旧⽂⽆法被搜索到，所以我润⾊了本⽂，并添加了更多⼲货内容，希望本⽂成为解决动态规划的⼀部「指导⽅针」。

动态规划问题（Dynamic Programming）应该是很多读者头疼的，不过这类问题也是最具有技巧性，最有意思的。

本书使⽤了整整⼀个章节专门来写这个算法，动态规划的重要性也可见⼀斑。

刷题刷多了就会发现，算法技巧就那⼏个套路，我们后续的动态规划系列章节，都在使⽤本⽂的解题框架思维，如果你⼼⾥有数，就会轻松很多。

所以本⽂放在第⼀章，来扒⼀扒动态规划的裤⼦，形成⼀套解决这类问题的思维框架，希望能够成为解决动态规划问题的⼀部指导⽅针。

本⽂就来讲解该算法的基本套路框架，下⾯上⼲货。

⾸先，动态规划问题的⼀般形式就是求最值。

动态规划其实是运筹学的⼀种最优化⽅法，只不过在计算机问题上应⽤⽐较多，⽐如说让你求最长递增⼦序列呀，最⼩编辑距离呀等等。

既然是要求最值，核⼼问题是什么呢？求解动态规划的核⼼问题是穷举。

因为要求最值，肯定要把所有可⾏的答案穷举出来，然后在其中找最值呗。

动态规划这么简单，就是穷举就完事了？我看到的动态规划问题都很难啊！⾸先，动态规划的穷举有点特别，因为这类问题存在「重叠⼦问题」，如果暴⼒穷举的话效率会极其低下，所以需要「备忘录」或者「DP table」来优化穷举过程，避免不必要的计算。

⽽且，动态规划问题⼀定会具备「最优⼦结构」，才能通过⼦问题的最值得到原问题的最值。

另外，虽然动态规划的核⼼思想就是穷举求最值，但是问题可以千变万化，穷举所有可⾏解其实并不是⼀件容易的事，只有列出正确的「状态转移⽅程」才能正确地穷举。

以上提到的重叠⼦问题、最优⼦结构、状态转移⽅程就是动态规划三要素。

具体什么意思等会会举例详解，但是在实际的算法问题中，写出状态转移⽅程是最困难的，这也就是为什么很多朋友觉得动态规划问题困难的原因，我来提供我研究出来的⼀个思维框架，辅助你思考状态转移⽅程：明确 base case -> 明确「状态」-> 明确「选择」 -> 定义 dp 数组/函数的含义。

力扣优秀题解

力扣优秀题解——动态规划动态规划（Dynamic programming，简称DP）是一种常见的求解优化问题的方法。

它与分治算法类似，都是通过将大问题分解成若干个小问题来求解的。

不同的是，DP解决的问题通常是有重叠子问题和最优子结构特征的，即在求解过程中会反复计算相同的子问题，并且每个子问题都具有最优解，可以通过这些最优解推导出全局最优解。

力扣中的很多题目都可以使用动态规划来解决，比如最长公共子序列、股票买卖、打家劫舍等等。

下面针对这些题目进行详细解析。

一、最长公共子序列题目描述：给定两个字符串text1 和text2，返回它们的最长公共子序列。

如果不存在公共子序列，返回0。

示例：输入：text1 = "abcde", text2 = "ace" 输出：3 解释：最长公共子序列是 "ace"，它的长度为 3。

解题思路：最长公共子序列问题是比较经典的DP问题。

设字符串text1和text2的长度分别为m 和n，令dp[i][j]表示text1[0:i]和text2[0:j]的最长公共子序列长度，为方便起见，text1和text2的下标从1开始。

当text1[i-1] == text2[j-1]时，dp[i][j] = dp[i-1][j-1] + 1，即text1[0:i-1]和text2[0:j-1]的最长公共子序列长度加上1。

当text1[i-1] != text2[j-1]时，dp[i][j] = max(dp[i-1][j], dp[i][j-1])，即考虑text1[0:i-1]和text2[0:j]的最长公共子序列长度与text1[0:i]和text2[0:j-1]的最长公共子序列长度，两者取最大值。

最终的答案即为dp[m][n]。

代码实现：class Solution: def longestCommonSubsequence(self, text1: str, text2: str) -> int: m, n = len(text1), len(text2) dp = [[0] * (n + 1) for _ in range(m + 1)] for i in range(1, m + 1): for j in range(1, n + 1): if text1[i - 1] == text2[j - 1]: dp[i][j] = dp[i - 1][j - 1] + 1 else: dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]) return dp[m][n]二、股票买卖题目描述：给定一个数组prices，其中prices[i]是一支给定股票第i天的价格。

买木头编程题

买木头编程题这是一道经典的动态规划问题，称为“买木头”或“卖木头”。

题目通常描述如下：你有一些木头，每根木头的长度是不同的。

你每次只能买一根木头，而你的目标是使得你拥有的木头总长度最大。

每次你只能选择买一根木头或者不买。

你会如何选择？假设木头的长度为数组 lengths，长度为 n。

一种直观的解法是使用贪心算法，即每次都选择当前最长的木头。

但是这种解法并不总是能得到最优解。

动态规划的解法如下：初始化一个长度为 n+1 的数组 dp，其中 dp[i] 表示在考虑前 i 根木头时能得到的最大总长度。

对于第一根木头，显然应该买，所以 dp[1] = lengths[0]。

对于第 i 根木头（i > 1）：如果买第 i 根木头，则 dp[i] = max(dp[i-1] + lengths[i-1], lengths[i-1])。

如果不买第 i 根木头，则 dp[i] = dp[i-1]。

返回 dp[n]，即在考虑所有木头时能得到的最大总长度。

下面是 Python 代码实现：pythondef max_length(lengths):n = len(lengths)dp = [0] * (n + 1)dp[1] = lengths[0]for i in range(2, n + 1):if lengths[i - 1] > dp[i - 1]:dp[i] = dp[i - 1] + lengths[i - 1]else:dp[i] = lengths[i - 1]return dp[n]这个算法的时间复杂度是 O(n)，空间复杂度也是 O(n)。