DP相关
作者：互联网
背包问题
1.01背包问题
一件物品只能选一次
on^2复杂度
f[i][j]表示只看前i个物品，总体积为j的情况下，总价值最大
f[i][j]:
不选第i件物品
f[i][j]=f[i-1][j]
选第i件物品
f[i][j]=f[i-1][j-v[i]](在前i-1件物品中选择重量为j-v[i]的物品的价值)+w[i](第i件物品的价值)
f[i][j]=max(f[i-1][j],f[i-1][j-v[i]]+w[i])
初始状态 f[0][0]不选物品的最大价值是0
#include<iostream>
#include<algorithm>
using namespace std;
int w[1001],v[1001];
int dp[1001][1001];
int main()
{
int n,W;
cin>>n>>W;
for(int i=1;i<=n;i++)cin>>v[i]>>w[i];
for(int i=1;i<=n;i++){
for(int j=1;j<=W;j++){
dp[i][j]=dp[i-1][j];
if(j>=v[i]){
dp[i][j]=max(dp[i][j],dp[i-1][j-v[i]]+w[i]);
}
}
}
cout<<dp[n][W]<<endl;
}
一维数组
如果只想求W时的最大值
那么设f[0]=0，f[i]=-INF,其他值都从0转移过去
#include<iostream>
#include<algorithm>
using namespace std;
int w[1001],v[1001];
int dp[1001];
int main()
{
int n,W;
cin>>n>>W;
for(int i=1;i<=n;i++)cin>>v[i]>>w[i];
for(int i=1;i<=n;i++){
for(int j=W;j>=v[i];j--){
//必须从最大值开始
dp[j]=max(dp[j],dp[j-v[i]]+w[i]);
}
}
cout<<dp[W]<<endl;
}
当背包容量很大时
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
int w[101],v[101];
//把价值看作背包容量，将问题转化为求价值恰好为i时的最小重量d[i]，
//求满足要求的最大重量 对应的价值是最大价值
int dp[10001];
const int INF =1e9+1;
int main()
{
int n,W;
//cout<<INF;
cin>>n>>W;
dp[0]=0;
int sum=0;//最大重量
//初始化为最大值
//cout<<dp[2];
for(int i=1;i<=n;i++){
cin>>v[i]>>w[i];
sum+=v[i];
}
for(int i=1;i<=sum;i++)dp[i]=INF;
for(int i=1;i<=n;i++){
for(int j=sum;j>=v[i];j--){
dp[j]=min(dp[j],dp[j-v[i]]+w[i]);
}
}
//从最大值遍历，找到的第一个满足条件的重量即为答案
for(int i=sum;i>=0;i--){
if(dp[i]<=W){
cout<<i<<endl;
return 0;
}
}
}
2.完全背包问题
一件物品可以选很多次
3.多重背包问题
每个物品选择上限不同
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N=100;
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;
for(int j=m;j>=0;j--){
for(int k=1;k<=s&&k*v[i]<=j;k++)
f[j]=max(f[j],f[j=k*v[i]+k*w[i]]);
}
}
cout<<f[m]<<endl;
}
4.混合背包问题
背包有很多种
5.二维费用的背包问题
体积，重量
6.分组背包问题
所有物品分成若干组，每组选一件
7.背包问题求方案数
8.求背包问题的方案
9.有依赖的背包问题
选一个物品必须选它的依赖物品
线性DP
最长上升子序列（LIS）
例：由6个数，分别是： 1 7 6 2 3 4，求最长上升子序列。
评析：首先，我们要理解什么叫做最长上升子序列：1、最长上升子序列的元素不一定相邻 2、最长上升子序列一定是原序列的子集。所以这个例子中的LIS就是：1 2 3 4，共4个
1、n^2做法
首先我们要知道，对于每一个元素来说，最长上升子序列就是其本身。那我们便可以维护一个dp数组，使得
dp[i]表示以第i元素为结尾的最长上升子序列长度，那么对于每一个dp[i]而言，初始值即为1；
那么dp数组怎么求呢？我们可以对于每一个i，枚举在i之前的每一个元素j，然后对于每一个dp[j],如果元素i大于元素j，那么就可以考虑继承，而最优解的得出则是依靠对于每一个继承而来的dp值，取max.
int dp[i]//以第i个元素为结尾的最长上升子序列长度
int data[i]//存储元素
for(int i=1;i<=n;i++)
{
dp[i]=1;//初始化
for(int j=1;j<i;j++)//枚举i之前的每一个j
if(data[j]<data[i] && dp[i]<dp[j]+1)
//用if判断是否可以拼凑成上升子序列，
//并且判断当前状态是否优于之前枚举
//过的所有状态,如果是，则↓
dp[i]=dp[j]+1;//更新最优状态
}
dp[i]=dp[j]+1:i的值更新为 比第i个元素小的第一个元素j的最长子序列+1
最后，因为我们对于dp数组的定义是到i为止的最长上升子序列长度，所以我们最后对于整个序列，只需要输出dpn即可。
从这个题我们也不难看出，状态转移方程可以如此定义：
下一状态最优值=最优比较函数（已经记录的最优值，可以由先前状态得出的最优值）
2、nlogn 做法
我们其实不难看出，对于n2做法而言，其实就是暴力枚举：将每个状态都分别比较一遍。但其实有些没有必要的状态的枚举，导致浪费许多时间，当元素个数到了104-10^5以上时，就已经超时了。而此时，我们可以通过另一种动态规划的方式来降低时间复杂度：
将原来的dp数组的存储由数值换成该序列中，长度为i的上升子序列 的最小末尾数值
这其实就是一种几近贪心的思想：我们当前的上升子序列长度如果已经确定，那么如果这种长度的子序列的结尾元素越小，后面的元素就可以更方便地加入到这条我们臆测的、可作为结果、的上升子序列中。
int n;
cin>>n;
for(int i=1;i<=n;i++)
{
cin>>a[i];
f[i]=0x7fffffff;
//初始值要设为INF
/*原因很简单，每遇到一个新的元素时，就跟已经记录的f数组当前所记录的最长
上升子序列的末尾元素相比较：如果小于此元素，那么就不断向前找，直到找到
一个刚好比它大的元素，替换；反之如果大于，么填到末尾元素的下一个q，INF
就是为了方便向后替换*/
}
f[1]=a[1];
int len=1;//通过记录f数组的有效位数，求得个数
/*因为上文中所提到我们有可能要不断向前寻找，
所以可以采用二分查找的策略，这便是将时间复杂
度降成nlogn级别的关键因素。*/
for(int i=2;i<=n;i++)
{
int l=0,r=len,mid;
if(a[i]>f[len])f[++len]=a[i];
//如果刚好大于末尾，暂时向后顺次填充
else
{
//当某个元素比f[]中最后一个元素小
while(l<r)
{
//二分查找，更新长度为len的最长上升子序列的最后一个元素的值
mid=(l+r)/2;
if(f[mid]>a[i])r=mid;
//如果仍然小于之前所记录的最小末尾，那么不断
//向前寻找(因为是最长上升子序列，所以f数组必然满足单调)
else l=mid+1;
}
f[l]=min(a[i],f[l]);//更新最小末尾
}
}
cout<<len;
```
## 区间DP
## 计数类DP
## 数位统计DP标签：背包,int,元素,DP,序列,相关,include,dp 来源： https://www.cnblogs.com/Jyming/p/16544804.html