ACM - DP - 基础（背包 + 线性 + 区间 + 计数类 + 数位 + 状压 + 树形 + 记忆化搜索）

肆呀

已于 2023-05-10 15:45:25 修改

阅读量483

点赞数 1

分类专栏： dp 文章标签： c++ acm竞赛动态规划算法

于 2021-07-20 18:14:52 首次发布

本文链接：https://blog.csdn.net/CSDNWudanna/article/details/118664173

版权

dp 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

动态规划 - AcWing 基础课

一、背包问题
二、线性 DP
三、区间DP
- AcWing 282. 石子合并
四、计数类DP
- AcWing 900. 整数划分
五、数位统计DP
- AcWing 338. 计数问题
六、状态压缩DP
- AcWing 291. 蒙德里安的梦想
- AcWing 91. 最短Hamilton路径
七、树形DP
- AcWing 285. 没有上司的舞会
八、记忆化搜索
- 1、AcWing 901. 滑雪
- 2、AcWing 3828. 行走路径：滑雪的加深版+dfs判环

【本文主要来自对AcWing基础算法课DP（背包 / 线性 / 区间 / 计数 / 数位统计 / 状压 / 树形 / 记忆化 DP）的整理，基本是母题】

一、背包问题

1、01背包：每件物品最多只能选一次

AcWing 2. 01背包问题

原题链接：https://www.acwing.com/problem/content/2/
在这里插入图片描述
思路

#include <bits/stdc++.h> 

using namespace std;

#define getlen(array) {return (sizeof(array) / sizeof(array[0]));}
#define ll long long 
#define ull unsigned long long
#define PII pair<int, int>
#define PLL pair<ll, ll>
#define MEM(x, y) memset(x, y, sizeof x)
#define rin int n; scanf("%d", &n)
#define rln ll n; scanf("%lld", &n)
#define rim int m; scanf("%d", &m)
#define rit int t; scanf("%d", &t)
#define ria int a; scanf("%d", &a)
#define sc scanf
#define pr printf

const int INF = 0x3f3f3f3f;
const int N = 1010; 
int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};

int v[N], w[N];
int dp[N];  //优化空间

int main() {
	//freopen("D:\\in.txt", "r", stdin); 
	rin;
	rim;
	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) {
			dp[j] = dp[j];
			dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
		}
	}
	cout << dp[m];
	return 0;
}

2、完全背包 : 每件物品可以选任意次

AcWing 3. 完全背包问题
原题链接：https://www.acwing.com/problem/content/3/
在这里插入图片描述

思路

因为背包的体积不是无限大，所以设每一件物品最多只能放 k 件进背包。
在这里插入图片描述
如果 k 较大，可能会TLE，所以还可以再优化一下：

#include <bits/stdc++.h> 

using namespace std;

#define getlen(array) {return (sizeof(array) / sizeof(array[0]));}
#define ll long long 
#define ull unsigned long long
#define PII pair<int, int>
#define PLL pair<ll, ll>
#define MEM(x, y) memset(x, y, sizeof x)
#define rin int n; scanf("%d", &n)
#define rln ll n; scanf("%lld", &n)
#define rim int m; scanf("%d", &m)
#define rit int t; scanf("%d", &t)
#define ria int a; scanf("%d", &a)
#define sc scanf
#define pr printf

const int INF = 0x3f3f3f3f;
const int N = 1010; 
int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};

int v[N], w[N];
int dp[N][N];

int main() {
	//freopen("D:\\in.txt", "r", stdin); 
	rin;
	rim;
	for (int i = 1; i <= n; ++ i) cin >> v[i] >> w[i];
	for (int i = 1; i <= n; ++ i) {
		for (int j = 1; j <= m; ++ j) {
			dp[i][j] = dp[i - 1][j];
			if (v[i] <= j) dp[i][j] = max(dp[i][j], dp[i][j - v[i]] + w[i]);
		}
	}
	cout << dp[n][m];
	return 0;
}

3、多重背包（朴素版）：限定每件物品选择次数的上限

AcWing 4. 多重背包问题 I

原题链接：https://www.acwing.com/problem/content/4/
在这里插入图片描述

思路

由于 dp[ i ] [ j - v] 展开后会多出额外的一项（因为有上限 s[ i ]），所以不能和完全背包一样用以前的状态替换掉。
在这里插入图片描述

#include <bits/stdc++.h> 

using namespace std;

#define getlen(array) {return (sizeof(array) / sizeof(array[0]));}
#define ll long long 
#define ull unsigned long long
#define PII pair<int, int>
#define PLL pair<ll, ll>
#define MEM(x, y) memset(x, y, sizeof x)
#define rin int n; scanf("%d", &n)
#define rln ll n; scanf("%lld", &n)
#define rim int m; scanf("%d", &m)
#define rit int t; scanf("%d", &t)
#define ria int a; scanf("%d", &a)
#define sc scanf
#define pr printf

const int INF = 0x3f3f3f3f;
const int N = 110; 
int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};

int v[N], w[N], s[N];
int dp[N][N];

int main() {
	rin;
	rim;
	for (int i = 1; i <= n; ++ i) cin >> v[i] >> w[i] >> s[i];
	for (int i = 1; i <= n; ++ i) {
		for (int j = 1; j <= m; ++ j) {
			for (int k = 0; k <= s[i] && k * v[i] <= j; ++ k) {
				dp[i][j] = max(dp[i][j], dp[i - 1][j - k * v[i]] + k * w[i]);
			}
			
		}
	}
	cout << dp[n][m];
	return 0;
}

4、多重背包（二进制优化版）：限定每件物品选择次数的上限，但是上限较大

AcWing 5. 多重背包问题 II

原题链接：https://www.acwing.com/problem/content/5/
在这里插入图片描述
思路

首先明确一点，用1、2、4、8、……、64 等数可以拼凑起 0 到 127 之间的任意一个数，假如想要拼凑 0 到 200 之间的任意一个数，那么至少需要 1、2、4、8、……、64、73 这些数。

因为题目中 s [ i ] 的范围较大，不可能再开一重循环，所以就考虑将 s [ i ] 拆开为 1、2、4、……，由此可以保证每一种组合都会被涉及到。

最后合成的全新的 v 和 w 数组，再用一次 01 背包即可求得最终解。

#include <bits/stdc++.h> 

using namespace std;

#define getlen(array) {return (sizeof(array) / sizeof(array[0]));}
#define ll long long 
#define ull unsigned long long
#define PII pair<int, int>
#define PLL pair<ll, ll>
#define MEM(x, y) memset(x, y, sizeof x)
#define rin int n; scanf("%d", &n)
#define rln ll n; scanf("%lld", &n)
#define rim int m; scanf("%d", &m)
#define rit int t; scanf("%d", &t)
#define ria int a; scanf("%d", &a)
#define sc scanf
#define pr printf

const int INF = 0x3f3f3f3f;
const int N = 30000; 
int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};

int v[N], w[N];
int dp[N];

int main() {
	//freopen("D:\\in.txt", "r", stdin); 
	int n, m;
	cin >> n >> m;
	int cnt = 1;
	
	for (int i = 0; i < n; ++ i) {
		int a, b, c;
		cin >> a >> b >> c;
		int num = 1;  // num ：1、2、4、8、……
		while (num <= c) {
			v[cnt] = num * a;
			w[cnt] = num * b;
			++ cnt;
			c -= num;
			num *= 2;
		}
		if (c > 0) {
			v[cnt] = c * a;
			w[cnt] = c * b;
			++ cnt;
		}
	}
	for (int i = 1; i < cnt; ++ i) {
		for (int j = m; j >= v[i]; -- j) {	
			 dp[j] = max(dp[j], dp[j - v[i]] + w[i]);
		}
	}
	cout << dp[m];
	return 0;
}

5、分组背包：分为 x 组，每一组最多只能选择其中的一件

AcWing 9. 分组背包问题

原题链接：https://www.acwing.com/problem/content/9/
在这里插入图片描述

思路

#include <bits/stdc++.h> 

using namespace std;

#define getlen(array) {return (sizeof(array) / sizeof(array[0]));}
#define ll long long 
#define ull unsigned long long
#define PII pair<int, int>
#define PLL pair<ll, ll>
#define MEM(x, y) memset(x, y, sizeof x)
#define rin int n; scanf("%d", &n)
#define rln ll n; scanf("%lld", &n)
#define rim int m; scanf("%d", &m)
#define rit int t; scanf("%d", &t)
#define ria int a; scanf("%d", &a)
#define sc scanf
#define pr printf

const int INF = 0x3f3f3f3f;
const int N = 110; 
int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};

int v[N], w[N], dp[N][N];

int main() {
	//freopen("D:\\in.txt", "r", stdin);
	rin;
	rim;
	for (int i = 1; i <= n; ++ i) {
		int s;
		cin >> s;
		for (int j = 1; j <= s; ++ j) {
			cin >> v[j] >> w[j];
		}
		for (int j = 1; j <= m; ++ j) {
			dp[i][j] = dp[i - 1][j];
			for (int k = 1; k <= s; ++ k) {
				if (v[k] <= j) dp[i][j] = max(dp[i][j], dp[i - 1][j - v[k]] + w[k]);
			}
		}
	} 
	cout << dp[n][m];
	return 0;
}

二、线性 DP

AcWing 898. 数字三角形

原题链接：https://www.acwing.com/problem/content/900/
在这里插入图片描述
思路

代码

#include<bits/stdc++.h>

using namespace std;

const int N = 510;

int dp[N][N];

int main() {
    int n;
    cin >> n;
    memset(dp, -0x3f3f3f3f, sizeof dp);
    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= i; ++ j) {
            cin >> dp[i][j];
        }
    }
    for (int i = 2; i <= n; ++ i) {
        for (int j = 1; j <= i; ++ j) {
            dp[i][j] += max(dp[i - 1][j - 1], dp[i - 1][j]);
        }
    }
    int ans = -0x3f3f3f3f;
    for (int i = 1; i <= n; ++ i) ans = max(ans, dp[n][i]);
    cout << ans;
    return 0;
}

AcWing 895. 最长上升子序列

原题链接：https://www.acwing.com/problem/content/897/
在这里插入图片描述
思路

代码

#include<bits/stdc++.h>

using namespace std;

const int N = 1010;

int nums[N], dp[N];

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++ i) {
        cin >> nums[i];
        // 以nums[i]为结尾的递增子序列，则该序列的倒数第二个数必须严格小于nums[i]
        dp[i] = 1;
        for (int j = 1; j < i; ++ j) {
            if (nums[j] < nums[i]) dp[i] = max(dp[i], dp[j] + 1);
        }
    }
    int ans = 0;
    for (int i = 1; i <= n; ++ i) ans = max(ans, dp[i]);
    cout << ans;
    return 0;
}

AcWing 896. 最长上升子序列 II（n = 10^5 nlogn的做法）

原题链接：https://www.acwing.com/problem/content/898/
在这里插入图片描述
思路

很显然，该数据范围需要至少在 nlogn 复杂度范围内解决，这里其实已经有点点不像 DP ，更像贪心一点？

我们设有这么一个数组 last [ i ] 表示：在所有长度为 i 的子序列中，最小以 last [ i ] 结尾。
很显然，长度为 a 的子序列，可以看成是长度为 a - 1 的子序列加上 nums [ i ] 而得到的，而能在子序列后面加上 nums [ i ] 的最低标准是，nums [ i ] 必须比所有长度为 a - 1 的子序列的尾数中最小的那个尾数大。

所以综上，二分找出 nums [ i ] 能放在哪一个长度的子序列后面，然后更新 last。

#include<bits/stdc++.h>

using namespace std;

const int N = 100010;
const int INF = 0x3f3f3f3f;

int n;
int nums[N], last[N];  //last[i]：长度为i的子序列中，最小以last[i]结尾

//二分找到last里面第一个大于等于a的位置
int find(int a) {
    int l = 0, r = n;
    while (l <= r) {
        int mid = l + (r - l) / 2;
        if (last[mid] >= a) r = mid - 1;
        else l = mid + 1;
    }
    while (last[l] >= a) -- l;  //此时找到的是小于a中最大的那一个
    return l + 1;
}

int main() {
    cin >> n;
    for (int i = 1; i <= n; ++ i) cin >> nums[i];
    //初始化
    memset(last, INF, sizeof last);
    last[0] = -INF;
    
    for (int i = 1; i <= n; ++ i) {
        int a = find(nums[i]);
        last[a] = min(last[a], nums[i]);
    }
    int ans = n;
    while (last[ans] == INF) -- ans;
    cout << ans;
    return 0;
}

AcWing 897. 最长公共子序列

在这里插入图片描述
思路

代码

#include<bits/stdc++.h>

using namespace std;

const int N = 1010;

char a[N], b[N];
int dp[N][N];

int main() {
    int n, m;
    cin >> n >> m;
    cin >> a + 1 >> b + 1;
    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= m; ++ 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[n][m];
    return 0;
}

AcWing 902. 最短编辑距离

原题链接：https://www.acwing.com/problem/content/description/904/
在这里插入图片描述

思路

代码

#include<bits/stdc++.h>

using namespace std;

const int N = 1010;

char a[N], b[N];
int dp[N][N];

int main() {
    int n, m;
    cin >> n >> a + 1;
    cin >> m >> b + 1;
    //初始化
    for (int i = 1; i < N; ++ i) {
        dp[i][0] = i;
        dp[0][i] = i;
    }
    
    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= m; ++ j) {
            dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + 1;  //min(删，增加)
            if (a[i] == b[j]) dp[i][j] = min(dp[i][j], dp[i - 1][j - 1]);
            //只有不一样的时候才需要替换，因为替换的定义是换成另一个字符
            else dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] + 1);   
        }
    }
    cout << dp[n][m];
    return 0;
}

AcWing 899. 编辑距离

原题链接：https://www.acwing.com/problem/content/901/
在这里插入图片描述

思路

和上一题一样的，只是改了形式。

#include<bits/stdc++.h>

using namespace std;

const int N = 1010;

int n, m;
char arr[N][13], str[15];
int dp[15][15], num;

//初始化dp数组的边界
void init() {
    for (int i = 1; i < 15; ++ i) {
        dp[i][0] = i;
        dp[0][i] = i;
    }
}

int get_ans() {
    int cnt = 0;
    for (int k = 1; k <= n; ++ k) {  //枚举n个字符串
        int len1 = strlen(arr[k] + 1), len2 = strlen(str + 1);
        for (int i = 1; i <= len1; ++ i) { 
            for (int j = 1; j <= len2; ++ j) {
                dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + 1;  //min(删，增)
                if (arr[k][i] == str[j]) dp[i][j] = min(dp[i][j], dp[i - 1][j - 1]); //相同
                else dp[i][j] = min(dp[i][j], dp[i - 1][j - 1] + 1); //替换
            }
        }
        if (dp[len1][len2] <= num) ++ cnt;
    }
    return cnt;
}

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; ++ i) {
        cin >> arr[i] + 1;
        // cout << arr[i] + 1 << endl;
    }
    init();
    while (m --) {
        cin >> str + 1 >> num;
        cout << get_ans() << endl;
    }
    return 0;
}

三、区间DP

AcWing 282. 石子合并

原题链接：https://www.acwing.com/problem/content/284/
在这里插入图片描述

思路

代码

#include<bits/stdc++.h>

using namespace std;

const int N = 310;

int arr[N], dp[N][N], sum[N];

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++ i) {
        cin >> arr[i];;
        sum[i] = sum[i - 1] + arr[i];
    }
    for (int len = 2; len <= n; ++ len) {   //枚举区间长度
        for (int i = 1; i + len - 1 <= n; ++ i) {  //枚举区间起点
            int l = i, r = i + len - 1;
            //记得初始化，但是不能直接memset(dp, 0x3f3f3f3f, sizeof dp);
            //因为dp[a][a]是0
            dp[l][r] = 0x3f3f3f3f;  
            for (int mid = l; mid < r; ++ mid) {  //枚举最后一次合并的位置
                dp[l][r] = min(dp[l][r], dp[l][mid] + dp[mid + 1][r] + sum[r] - sum[l - 1]);
            }
        }
    }
    cout << dp[1][n];
    return 0;
}

四、计数类DP

AcWing 900. 整数划分

原题链接：https://www.acwing.com/problem/content/902/
在这里插入图片描述
【解法一：完全背包思维】

可以看成现在有无限个从 1 到 n 之间的数，问把容量为 n 的背包恰好装满，有多少种装法。
dp[ i ][ j ]：用 1 到 i 之间的数凑出 j 的方案数
dp[ i ][ j ] = dp[ i - 1][ j ] + [ i ][ j - i ] = 不用 i 这个数凑出 j + 用至少一个 i 凑出 j
其中，初始化 dp[ a ][ a ] = 1。

#include<bits/stdc++.h>

using namespace std;

const int N = 1010;
#define ll long long

ll dp[N][N];
int mod = 1e9 + 7;

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= n; ++ j) {
            dp[i][j] = dp[i - 1][j];  //不用当前这个数
            if (i < j) dp[i][j] += dp[i][j - i];  //用当前这个数
            else if (i == j) dp[i][j] ++;
            dp[i][j] %= mod;
        }
    }
    cout << dp[n][n];
    return 0;
}

【解法二】

在这里插入图片描述

#include<bits/stdc++.h>

using namespace std;

const int N = 1010, mod = 1e9 + 7;

long long dp[N][N];

int main() {
    int n;
    cin >> n;
    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= n; ++ j) {
            if (j == 1) dp[i][j] = 1;  //初始化
            else {
            	//假设至少有一个1
                dp[i][j] = dp[i - 1][j - 1];  
                //假设没有1，那么把所有数-1依旧合法
                if (i >= j) dp[i][j] += dp[i - j][j];  
            }
            dp[i][j] %= mod;
        }
    }
    long long ans = 0;
    for (int i = 1; i <= n; ++ i) ans = (ans + dp[n][i]) % mod;
    cout << ans;
    return 0;
}

五、数位统计DP

AcWing 338. 计数问题

原题链接：https://www.acwing.com/problem/content/340/
在这里插入图片描述

思路

在这里插入图片描述
看着好像很简单……但其实边界多的一批……

① 假如 1 在最高位，不需要计算上图第一种情况。
② 假如 1 在最低位，如果 1 <= d，那么++ cnt；反之不需要对 cnt 进行操作。
③ 剔除前导零的情况：假如 x = 0，那么上图第一种情况是（abc - 1）* 1000，x 前面需要从非零开始考虑。

代码

#include<bits/stdc++.h>

using namespace std;

//将v中从l到r之间的数字合成一个数
int get_value(vector<int> v, int l, int r) {
    int num = 0;
    while (l >= r) {
        num = num * 10 + v[l];
        -- l;
    }
    return num;
}

//num在1~end之间一共出现多少次 
int count(int end, int num) {
    if (end == 0) return 0;
	int cnt = 0;
	vector<int> nums;
	while (end) {
	    nums.push_back(end % 10);
	    end /= 10;
	}
	int len = nums.size();
	//枚举每一位
	for (int i = len - 1; i >= 0; -- i) {
	    int front, later; //以 i 为分界线区分前后两部分
	    // 0 ~ abc - 1
	    if (i == len - 1) front = 0;  //数头不需要计算该部分
	    else {
	        front = get_value(nums, len - 1, i + 1);
	        //不能有前导零，所以需要减一，又因为front-1可能为负数，所以和0取max
	        if (num == 0) front = max(0, front - 1);  
	    }
	    later = pow(10, i);
	    cnt += front * later;
	    //abc
	    front = 1;
	    if (i == len - 1 && num == 0) continue;  //不能有前导零
	    if (i == 0) {
	        later = 1;
	        if (nums[i] < num) later = 0;
	    }
	    else {
	        if (nums[i] == num) later = get_value(nums, i - 1, 0) + 1;
	        else if (nums[i] > num) later = pow(10, i);
	        else later = 0;  //这一步不能漏，否则later会是上一步的later
	    }
	    cnt += front * later;
	}
	return cnt;
}

int main() {
	int l, r;
	while (cin >> l >> r, l | r) {
		if (l > r) swap(l, r);
		//获得从 0 ~ 9 的个数
		for (int i = 0; i < 10; ++ i) {
			cout << count(r, i) - count(l - 1, i) << " ";
		}
		cout << endl;
	}
	return 0;
}

y总的简约版，但属实太优雅，我不配：

#include <iostream>
#include <algorithm>
#include <vector>

using namespace std;

const int N = 10;

/*

001~abc-1, 999

abc
    1. num[i] < x, 0
    2. num[i] == x, 0~efg
    3. num[i] > x, 0~999

*/

int get(vector<int> num, int l, int r)
{
    int res = 0;
    for (int i = l; i >= r; i -- ) res = res * 10 + num[i];
    return res;
}

int power10(int x)
{
    int res = 1;
    while (x -- ) res *= 10;
    return res;
}

int count(int n, int x)
{
    if (!n) return 0;

    vector<int> num;
    while (n)
    {
        num.push_back(n % 10);
        n /= 10;
    }
    n = num.size();

    int res = 0;
    for (int i = n - 1 - !x; i >= 0; i -- )
    {
        if (i < n - 1)
        {
            res += get(num, n - 1, i + 1) * power10(i);
            if (!x) res -= power10(i);
        }

        if (num[i] == x) res += get(num, i - 1, 0) + 1;
        else if (num[i] > x) res += power10(i);
    }

    return res;
}

int main()
{
    int a, b;
    while (cin >> a >> b , a)
    {
        if (a > b) swap(a, b);

        for (int i = 0; i <= 9; i ++ )
            cout << count(b, i) - count(a - 1, i) << ' ';
        cout << endl;
    }

    return 0;
}

六、状态压缩DP

AcWing 291. 蒙德里安的梦想

原题链接：https://www.acwing.com/problem/content/293/
在这里插入图片描述

思路
在这里插入图片描述
代码

#include<bits/stdc++.h>

using namespace std;

const int N = 12, M = 1 << N;

long long dp[N][M];  //不开long long见祖宗
//st[i]: 判断i的二进制表示中是否可以合法存放竖着的小方格，即是否所有连着的0都是偶数个
bool st[M];   

int main() {
	int n, m;
	while (cin >> n >> m, n | m) {  //n|m为假时跳出循环
	    memset(dp, 0, sizeof dp);  //记得初始化……
		int length = 1 << n;
		for (int i = 0; i < length; ++ i) {
			st[i] = true;
			int cnt = 0;  //统计连续0的个数
			for (int j = 0; j < n; ++ j) {
				int num = (i >> j) & 1;  //获得i的二进制数从右往左数第j位是0还是1
				if (num == 1) {
					if (cnt % 2 == 1) {  //连着的是奇数个0
						st[i] = false;
						break;
					}
					else cnt = 0;  //重置（其实不重置也可以，偶数加偶数还是偶数）
				}
				else ++ cnt;
			}
			if (cnt % 2 == 1) st[i] = false;
		}
		
		dp[0][0] = 1;  //不操作也是一种方案
		for (int i = 1; i <= m; ++ i) {  //枚举从1到m列
			for (int j = 0; j < length; ++ j) { //当前列本身的添加的小方格
				for (int k = 0; k < length; ++ k) {  //上一列伸出来的小方格
				    //if(两种方案是否会重叠冲突&&摆放后竖着的小方格能不能合理摆放)
					if ((j & k) == 0 && st[j | k]) {  
						dp[i][j] += dp[i - 1][k];
					}
				}
			}
		}
		cout << dp[m][0] << endl;  //最后一列本身不能有操作
	}
	return 0;
}

AcWing 91. 最短Hamilton路径

原题链接：https://www.acwing.com/problem/content/description/93/
在这里插入图片描述
思路

自己的理解

#include<bits/stdc++.h>

using namespace std;

const int N = 21, M = 1 << N;

int g[N][N];
int dp[M][N];

int main() {
	int n;
	cin >> n;
	memset(dp, 0x3f, sizeof dp);
	for (int i = 0; i < n; ++ i) {
		for (int j = 0; j < n; ++ j) {
			cin >> g[i][j];
			dp[(1 << i )| (1 << j)][j] = g[i][j];  //初始化，将单边和点加载在dp数组里
		}
	}
	int length = 1 << n;
	for (int i = 0; i < length; ++ i) {
		for (int j = 0; j < n; ++ j) {
			if (i >> j & 1) {  //判断合法性：当前路径i包含点j
				int num = i - (1 << j);  //获得除去最后到达的j的路径为num
				//枚举num路径下的其他点，因为0必须是起点，不能成为中间点，所以k从1开始
				//对于诸如从0走到1这样的路径在初始化的时候已经赋予，所以并没有遗漏
				for (int k = 1; k < n; ++ k) {  
					if ((num >> k) & 1) {  //判断num路径确实有k这个点
						dp[i][j] = min(dp[i][j], dp[num][k] + g[k][j]);
					}
					
				}
			}
		}
	}
	cout << dp[length - 1][n - 1];
	return 0;
}

y 总的解法：

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 20, M = 1 << N;

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);
    //因为必须从0出发，所以只初始化这个点，就能保证路径一点从0开始
    //因为若从1~n-1开始，dp[1<<j][j]是无穷大
    f[1][0] = 0;  // 等价于 ：f[0][0] = 0;该式可推出f[0][0] + w[0][0] = 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;
}

七、树形DP

AcWing 285. 没有上司的舞会

原题链接：https://www.acwing.com/problem/content/287/
在这里插入图片描述

思路

#include<bits/stdc++.h>

using namespace std;

const int N = 6010;

//happy-快乐指数  father-是否有父节点 st-dfs的时候是否已经访问过
int happy[N], dp[N][2];
int h[N], e[N], ne[N], idx = 1;
bool father[N], st[N];

void insert(int a, int b) {
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx ++;
}

void dfs(int a) {
    st[a] = true;   //标记已访问
    dp[a][1] = happy[a];  //初始化
    for (int i = h[a]; i != -1; i = ne[i]) {
        int j = e[i];
        if (!st[j]) dfs(j);
        //直接上司必定参加，那么直接下属必定不能参加
        dp[a][1] += dp[j][0];  
        //直接上司必定不参加，那么直接下属可以选择参不参加
        dp[a][0] += max(dp[j][0], dp[j][1]); 
    }   
}

int main() {
    int n;
    cin >> n;
    memset(h, -1, sizeof h);
    for (int i = 1; i <= n; ++ i) cin >> happy[i];
    for (int i = 1; i < n; ++ i) {
        int a, b;
        cin >> a >> b;
        insert(b, a);
        father[a] = true; 
    }
    //找到根节点
    int root = 1;
    while (father[root]) ++ root;
    dfs(root);
    cout << max(dp[root][0], dp[root][1]);
    
    return 0;
}

八、记忆化搜索

1、AcWing 901. 滑雪

原题链接：https://www.acwing.com/problem/content/903/
在这里插入图片描述

思路

说白了就是不要走重复的路，把已经确定的状态都记录下来。

#include<bits/stdc++.h>

using namespace std;

const int N = 310;

int n, m;
int g[N][N], dp[N][N];
bool st[N][N];
int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};

int get_dp(int i, int j) {
	if (st[i][j]) return dp[i][j];
	st[i][j] = true;
	dp[i][j] = 1;
	for (int k = 0; k < 4; ++ k) {
		int x = dx[k] + i, y = dy[k] + j;
		//只由在它上下左右且比它高的地方去考虑
		if (x >= 1 && x <= n && y >= 1 && y <= m && g[x][y] > g[i][j])  {
			dp[i][j] = max(dp[i][j], get_dp(x, y) + 1);  //必须get_dp
		}
	}
	return dp[i][j];
}

int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; ++ i) {
		for (int j = 1; j <= m; ++ j) {
			cin >> g[i][j];
		}
	}
	
	int ans = 0;
	for (int i = 1; i <= n; ++ i) {
		for (int j = 1; j <= m; ++ j) {
			dp[i][j] = get_dp(i, j);
			ans = max(ans, dp[i][j]);
		}
	}
	cout << ans;
	return 0;
}

2、AcWing 3828. 行走路径：滑雪的加深版+dfs判环

原题链接：https://www.acwing.com/problem/content/3831/
在这里插入图片描述

/*
我悟了……
一开始只想着只从Q开始走怎么剪枝……
原来这是滑雪的加深版
在dfs过程判环就好了……
*/
#include<iostream>
#include<cstring>

using namespace std;

const int N = 1010;
int dx[] = {-1, 1, 0, 0}, dy[] = {0, 0, -1, 1};
int n, m;
int g[N][N];
bool st[N][N];
int dp[N][N];
bool is_inf = false;  //是否有环

void find(int a, int b) {
    if (st[a][b]) {
        is_inf = true;
        return;
    }
    if (dp[a][b] != -1) return;
    st[a][b] = true;
    dp[a][b] = 1;  //初始化
    for (int i = 0; i < 4; ++ i) {
        int x = a + dx[i], y = b + dy[i];
        if (x >= 1 && x <= n && y >= 1 && y <= m) {
            if (g[x][y] == (g[a][b] + 1) % 4) {
                find(x, y);
                dp[a][b] = max(dp[a][b], 1 + dp[x][y]);
            }
        }
    }
    st[a][b] = false;  //恢复现场
}

int main() {
    cin >> n >> m;
    memset(dp, -1, sizeof dp);
    getchar();
    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= m; ++ j) {
            char c;
            cin >> c;
            
            int &a = g[i][j];
            if (c == 'Q') a = 0;
            else if (c == 'W') a = 1;
            else if (c == 'E') a = 2;
            else a = 3;
        }
    }
    int ans = -1;
    for (int i = 1; i <= n; ++ i) {
        for (int j = 1; j <= m; ++ j) {
            // memset(st, false, sizeof st); //因为需要恢复现场，所以就没必要memset
            find(i, j);
            int a = dp[i][j];
            a -= (4 - g[i][j]) % 4;
            a /= 4;
            if (a > 0) ans = max(ans, a);
        }
    }
    if (is_inf) cout << "infinity";
    else if (ans == -1) cout << "none";
    else cout << ans;
}

肆呀

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
ACM - DP - 基础（背包 + 线性 + 区间 + 计数类 + 数位 + 状压 + 树形 + 记忆化搜索）

动态规划AcWing 基础课1、背包问题01背包：每件物品最多只能选一次完全背包 : 每件物品可以选任意次多重背包（朴素版）：限定每件物品选择次数的上限多重背包（二进制优化版）：限定每件物品选择次数的上限，但是上限较大分组背包：分为 x 组，每一组最多只能选择其中的一件2、线性 DPAcWing 898. 数字三角形AcWing 895. 最长上升子序列AcWing 896. 最长上升子序列 II（n = 10^5 nlogn的做法）AcWing 897. 最长公共子序列AcWing 902. 最短
复制链接

扫一扫