【算法】动态规划基础

最新推荐文章于 2024-09-03 18:29:17 发布

marti844

最新推荐文章于 2024-09-03 18:29:17 发布

阅读量79

点赞数

文章标签：算法动态规划

本文链接：https://blog.csdn.net/marti844/article/details/132028157

版权

背包问题

1. 01背包

求恰好装满，设为负无穷

只求最大值，设为0

for(int i=1;i<=n;i++){
    for(int j=0;j<=m;j++){
        f[i][j]=f[i-1][j];//若j<v[i]，则最大价值为在前j个物品中选总体积为j的最大价值
        if(j>=v[i]) f[i][j]=max(f[i][j],f[i-1][j-v[i]]+w[i]);
    }
}

一维01背包优化

for(int i=1;i<=n;i++){
    for(int j=m;j>=v[i];j--){//只枚举到v[i]可以节省时间
    	f[j]=max(f[j],f[j-v[i]]+w[i]);
    }
}

2. 完全背包

for(int i=1;i<=n;i++) // 枚举物品
        for(int j=0;j<=v;j++) // 枚举体积
            for(int k=0;k*c[i]<=j;k++) // 三重循环 枚举每种取用件数*c[i]不大于当前总体积j
                dp[i][j]=max(dp[i][j],dp[i-1][j-c[i]*k]+w[i]*k);

完全背包一级优化

for(int i=1;i<=n;i++) // 枚举物品
        for(int j=0;j<=v;j++){//参照01背包朴素 优化为二重循环 正序枚举体积
            dp[i][j]=dp[i-1][j];
            if(j>=c[i]) dp[i][j]=max(dp[i][j],dp[i][j-c[i]]+w[i]);
        }

二级

for(int i=1;i<=n;i++) // 枚举物品
        for(int j=c[i];j<=v;j++) // 正序枚举体积
            dp[j]=max(dp[j],dp[j-c[i]]+w[i]);

3. 多重背包

for(int i=1;i<=n;i++) // 枚举物品
        for(int j=0;j<=v;j++) // 枚举体积
            for(int k=0;k<=s[i]&&k*c[i]<=j;k++) // 枚举决策
                dp[i][j]=max(dp[i][j],dp[i-1][j-k*c[i]]+k*w[i]);

二进制优化

 int k=1; //相当于base(每组件数)：1 2 4 8 16 32 64 128 256...据此打包
        while(k<=s){
            cnt++;
            c[cnt]=k*a;
            w[cnt]=k*b;
            s-=k;
            k*=2;
        }
        if(s>0){ //若拆完之后还有零头
            cnt++; //再分一个包
            c[cnt]=a*s;
            w[cnt]=b*s;
        }
    }
    //相当于将多重背包转化为01背包
    n=cnt;//01物品总个数
    for(int i=1;i<=n;i++) 
        for(int j=v;j>=c[i];j--)//注意倒序遍历 
            dp[j]=max(dp[j],dp[j-c[i]]+w[i]);

单调队列优化

		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 ++ ;
                while (hh <= tt && g[q[tt]] - (q[tt] - j) / v * w <= g[k] - (k - j) / v * 					w) tt -- ;
                q[ ++ tt] = k;
                f[k] = g[q[hh]] + (k - q[hh]) / v * w;
            }
        }

4. 分组背包

for(int i=1;i<=n;i++)
        for(int j=v;j>=0;j--) //倒序遍历
            for(int k=1;k<=s[i];k++) //每组s[i]个
                if(c[i][k]<=j) //注意判断条件！！！！！！！！！！
                    dp[j]=max(dp[j],dp[j-c[i][k]]+w[i][k]); //选或不选

5. 混合背包

if(s==0) s=v/tc; // 完全背包
        if(s==-1) s=1; // 01背包
        // 二进制优化
        int k=1;
        while(k<=s){
            cnt++;
            c[cnt]=k*tc;
            w[cnt]=k*tw;
            s-=k;
            k*=2; 
        }
        if(s>0){
            cnt++;
            c[cnt]=s*tc;
            w[cnt]=s*tw;
        }
    }
    // 将01背包 完全背包 多重背包全部打包成cnt件
    n=cnt;// 接下来就是普通的01背包啦
    for(int i=1;i<=n;i++){
        for(int j=v;j>=c[i];j--){
            dp[j]=max(dp[j],dp[j-c[i]]+w[i]);
        }
    }

6. 二维费用的背包

for(int i=1;i<=n;i++){
        scanf("%d%d%d",&tv,&tm,&w);
        for(int j=v;j>=tv;j--){
            for(int k=m;k>=tm;k--){// 无非就是再加一维
                dp[j][k]=max(dp[j][k],dp[j-tv][k-tm]+w);
            }
        }
    }

7. 有依赖的背包问题

其实~~很简单~~ 就是把线性的01背包简单变形为一棵树
链式前向星+dfs

struct node{
    int to,next;
}e[maxm];
// 链式前向星 或者叫 邻接表
//加边操作
void add(int x,int y){
    cnt++;
    e[cnt].to=y;
    e[cnt].next=head[x];
    head[x]=cnt;
}

void dfs(int k){ //当前节点k
    for(int i=head[k];i;i=e[i].next){// 枚举物品
        int son=e[i].to; // 记录子节点
        dfs(son);// 向下递归到最末子树 在回溯的过程中从最末更新dp值 直到回到root
        // 由于当前节点k必选 因此体积j需要将c[k]空出来 01背包倒序枚举体积
        for(int j=v-c[k];j>=0;j--){ 
            for(int l=0;l<=j;l++){// 枚举决策
                dp[k][j]=max(dp[k][j],dp[k][j-l]+dp[son][l]);
            }//             不选son子树    选son子树
        }
    }
    for(int i=v;i>=c[k];i--) dp[k][i]=dp[k][i-c[k]]+w[k];
    for(int i=0;i<c[k];i++) dp[k][i]=0;
}

int main(){
    scanf("%d%d",&n,&v);
    for(int i=1;i<=n;i++){
        int p;
        scanf("%d%d%d",&c[i],&w[i],&p);
        if(p==-1) root=i; // 根节点
        add(p,i); // 加边加边 由父节点指向子节点
    }
    dfs(root); // 从根节点开始搜
    printf("%d",dp[root][v]);
}

8. 背包问题求方案数

求方案数类问题，我们需要调整一下dp数组的含义。以下以01背包为例：

$d p [i] [j]$ 表示的是从前 i 个物品中选，体积不超过 j 的选法的集合。而此处为了便于方案数的计算，令 $d p [i] [j]$ 表示为从前 i 个物品中选，体积恰好为 j 的选法的集合。注意dp数组含义改变后需要初始化，只有当体积恰好为零时，总价值才恰好为零，即 $d p [0] = 0$ ，其他情况均出于未更新的状态，因此需要全部初始化为 $- in f$ 。
dp数组的值等于此状态下的最大价值，另外我们还需要一个数组 $g [i] [j]$ ，表示此种状态下取最大值（即取 $d p [i] [j]$ ）的方案数。最后我们只需要遍历一下 $d p [n] [j]$ 得到最大价值（最优方案并不一定会把背包装满因此需要遍历），再将价值=最大价值的所有对应 $g [i] [j]$ 加起来，即为最优方案总数。

9. 背包问题求具体方案数

背包问题求具体方案的思路基本相同，重点在于判断每件物品到底选了还是没选，~~好像是废话~~，类似于最短路求最短路径。且由于要输出方案，所以我们不能使用空间优化后的转移方程。另外，要求输出字典序最小的方案时还须考虑选择顺序。

最长公共子序列

#include<bits/stdc++.h>
using namespace std;
int n;
int a1[100010],a2[100010];
int belong[100010];
int f[100010],b[100010],len;
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a1[i]);
        belong[a1[i]]=i;
    }
    for(int i=1;i<=n;i++)
    scanf("%d",&a2[i]);
    for(int i=1;i<=n;i++)
    {
        if(belong[a2[i]]>b[len])
        {
            b[++len]=belong[a2[i]];
            f[i]=len;
            continue;
        }
        int k=lower_bound(b+1,b+len+1,belong[a2[i]])-b;
        b[k]=belong[a2[i]];
        f[i]=k;
    }
    printf("%d\n",len);
    return 0;
}

二分+子序列进阶

# include <iostream>
# include <cstdio>
# include <cstring>
# include <algorithm>
using namespace std;
int a[100005],t[100005],A[100005],B[100005],f[100005];
bool cmp(int a,int b)
{
    return a<b;
}
int solve(int l,int r,int x)
{
    int mid=(l+r)/2;;
    if (l==r) return l; 
    if (a[mid]>x) return solve(l,mid,x);
    if (a[mid]<=x) return solve(mid+1,r,x);
}
int main()
{
    int n;
    scanf("%d",&n);
    for (int i=1;i<=n;i++) scanf("%d",&A[i]);
    for (int i=1;i<=n;i++) scanf("%d",&B[i]);
    for (int i=1;i<=n;i++) f[A[i]]=i;
    for (int i=1;i<=n;i++) t[i]=f[B[i]];
    memset(a,0,sizeof(a));
    for (int i=1;i<=n;i++) {
        if ((i==0)||(t[i]>a[a[0]])) a[++a[0]]=t[i];
        else if (t[i]<a[a[0]]) a[solve(1,a[0],t[i])]=t[i];
//a[lower_bound(a+1,a+a[0]+1,t[i])-a]=t[i];(替换a[solve(1,a[0],t[i])]=t[i];也行但是会稍微慢一点。。)
    }
    printf("%d\n",a[0]); 
    return 0;
}

最长公共子序列(LCS)

#include<bits/stdc++.h>
using namespace std;
int n;
int a1[100010],a2[100010];
int belong[100010];
int f[100010],b[100010],len;
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&a1[i]);
        belong[a1[i]]=i;
    }
    for(int i=1;i<=n;i++)
    scanf("%d",&a2[i]);
    for(int i=1;i<=n;i++)
    {
        if(belong[a2[i]]>b[len])
        {
            b[++len]=belong[a2[i]];
            f[i]=len;
            continue;
        }
        int k=lower_bound(b+1,b+len+1,belong[a2[i]])-b;
        b[k]=belong[a2[i]];
        f[i]=k;
    }
    printf("%d\n",len);
    return 0;
}

状压dp

状态压缩动态规划，就是我们俗称的状压DP，是利用计算机二进制的性质来描述状态的一种DP方式。

例题：luogu P1896 [SCOI2005] 互不侵犯
简述：给一个 $\times n$ 的矩阵放置棋子，每个棋子周围的八个空间不能有棋子，询问有多少种放置方法
状态定义： $dp_{i,j,k}$ 表示在第 $i$ 行，棋子状态是 $j$ 时，放置了 $k$ 个棋子的最多情况
状态转移： $d p [i] [s i t] [j] + = d p [i - 1] [s i t 2] [j - c (s i t)];$
时间复杂度： $O(n^4)$

#include<bits/stdc++.h>
#define int long long
using namespace std;
const int N = 15;
int n, k;
int dp[N][1 << 9][N * N];

inline int c(int sit) {
    return __builtin_popcount(sit);
}

//  检查是否符合放置要求
bool check(int sit, int sit2) {
    for(int i = 0; i < n - 1; ++i) {
        if((sit & (1 << i)) && (sit & (1 << (i + 1)))) return false;
    }
    if((sit & (sit2 << 1)) || (sit & (sit2 >> 1)) || (sit & sit2)) return false;
    return true;
}



inline void solve() {
    std::cin >> n >> k;
    for(int i = 0; i < n; ++i) {
        for(int sit = 0; sit < (1 << n); ++sit) {
		// sit表示每一行的状态，状压dp核心
            if(!check(sit, 0)) continue;
            if(i == 0) dp[i][sit][c(sit)] = 1;
            else {
                for(int j = c(sit); j <= k; ++j) {
                    for(int sit2 = 0; sit2 < (1 << n); ++sit2) {
                        if(!check(sit2, 0) || !check(sit, sit2)) continue;
                        dp[i][sit][j] += dp[i - 1][sit2][j - c(sit)];
                    }
                }
            }
        }
    }
    int ans = 0;
    for(int sit = 0; sit < (1 << n); ++sit) {
        ans += dp[n - 1][sit][k];
    }
    std::cout << ans << endl;
    return;
}


signed main() {
    ios::sync_with_stdio(0);
    cin.tie(0), cout.tie(0);

    int T;
    T = 1;
    while(T --) {
        solve();
    }
}

区间DP

例题：luogu P1880 [NOI1995] 石子合并
简述：N堆石子摆成一条线。现要将石子有次序地合并成一堆。规定每次只能选相邻的2堆石子合并成新的一堆，并将新的一堆石子数记为该次合并的代价。计算将N堆石子合并成一堆的最大/小代价。
状态定义： $dp_{i,j}$ 表示区间 $[i, j]$ 合并所能得到的最大/小代价
状态转移： $d p [j] [e n d s] = min (d p [j] [e n d s], d p [j] [i] + d p [i + 1] [e n d s] + w e i g t h [i] [e n d s]);$

dp[j][ends] = min(dp[j][ends],dp[j][i]+dp[i+1][ends]+weigth[i][ends]);

时间复杂度： $O(n^3)$

#include<bits/stdc++.h>
#define int long long
#define inf 0x3f3f3f3f
using namespace std;

const int N = 3e2 + 10;
const int M = 1e6 + 10;

int n, m;
int a[N];
int dpmax[N][N], dpmin[N][N];
int sum[N];

inline void solve() {
    scanf("%lld", &n);
    for(int i = 1; i <= n; ++i) {
        scanf("%lld", &a[i]);
        a[i + n] = a[i];

    }
    for(int i = 1; i <= 2 * n; ++i) {
        sum[i] = sum[i - 1] + a[i];
    }

    for(int len = 2; len <= n; ++len) {
        for(int i = 1; i <= 2 * n - len + 1; ++i) {
            int j = len + i - 1;
            dpmax[i][j] = -1, dpmin[i][j] = inf;
            for(int k = i; k < j; ++k) {
                dpmax[i][j] = max(dpmax[i][j], dpmax[i][k] + dpmax[k + 1][j] + sum[j] - sum[i - 1]);
                dpmin[i][j] = min(dpmin[i][j], dpmin[i][k] + dpmin[k + 1][j] + sum[j] - sum[i - 1]);
            }
        }
    }
    int maxx = -1;
    int minn = inf;
    for(int i = 1; i < n; ++i) {
        maxx = max(maxx, dpmax[i][i + n - 1]);
        minn = min(minn, dpmin[i][i + n - 1]);
    }
    printf("%lld\n%lld\n", minn, maxx);
}

signed main() {
    // ios::sync_with_stdio(0);
    // cin.tie(0), cout.tie(0);

    int T;
    T = 1;
    while(T--) {
        solve();
    }
    return 0;
}

数位DP

#include<iostream>
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define maxn 15
int num;
int* a = new int[maxn];
int f[15];
//int a[maxn];
int b[maxn];//b保存第p为存的是那个数
int ten[maxn];
int L, R;
int t;
int dfs(int p, bool limit) {//p表示在第p位，limite表示此时是否处于限制位
	if (p < 0) {
		//for (int i = 2; i >= 0; i--)cout << b[i];//无限递归,记得加结束return
		//cout << endl;
		return 0;//搜索结束，返回
	}
	if (!limit && f[p] != -1) {//记忆化搜索，不处于限制位，并且f[p]被算过了
		return f[p];
	}
	int up = limit ? a[p] : 9;//判断是否处于限制位，如果是就只能取到a[p]为，否则最高位能取到9
 
	int ans = 0;
 
	for (int i = 0; i <= up; i++) {
		//b[p] = i;
		if (i == 3) {
			if (limit && i == up) {
				ans += 1;
				for (int j = p - 1; j >= 0; j--)//处于限制条件就把限制数下面全算上
					ans += a[j] * ten[j];
			}
			else//如果不处于限制条件直接加上10的p次方
				ans += ten[p];
		}
		else ans += dfs(p - 1, limit && i == up);//这里填a[p]可以填up也行，在处于限制的时候up等于a[p]
 
	}
	if (!limit)//记忆化搜索，如果没有处于限制条件就可以直接那算过一次的数直接用，能节省很多时间
		f[p] = ans;
	return ans;
}
 
int handle(int num) {
	int p = 0;
	while (num) {//把num中的每一位放入数组
		a[p++] = num % 10;
		num /= 10;
	}
	//说明a数组写进去了，但是读取无效数据是什么意思勒，之前好像不是这样的，解决办法，动态创建数组
	/*for (int i = 0; i < p; i++) {
		cout << a[i];
	}*/
	return dfs(p - 1, true);//对应的最高位为p-1位，为True表示没有处于限制位
}
 
void init() {
	ten[0] = 1;
	for (int i = 1; i < 15; i++) {
		ten[i] = ten[i - 1] * 10;
	}
	memset(f, -1, sizeof(f));
}
int32_t  main() {
	cin>>t;
    while(t--){
        cin>>L>>R;
        //handle(23);
	    init();//一定要记得初始化，TM的我在这卡了半个月
	    cout << handle(R)-handle(L) << endl;
	    delete[]a;
    }
    return 0;
}