一、深度优先搜索
把\(m\)个机器分配给\(n\)个公司，暴力遍历所有方案
记录分配方案，如果能更新最优解，顺便更新一下最优解的分配方案
#include <bits/stdc++.h>
using namespace std;
const int N = 11; //最多N个公司
const int M = 16; //最多M个设备
int n; //n个公司
int m; //m个设备
int path[N]; //记录每一次尝试时的路径记录数组，但不一定是最优的，在达到最优时复制到path里
int w[N][M]; //第i个公司拿j个机器时获取到的价值
int Max; //价值的最大值
int res[N]; //最佳的取法数组,一直记录到目前为止最优的方案
/**
* 功能：深度优先搜索求最大值及方案
* @param step 第x个公司
* @param sum 总价值
* @param r 剩余设备数量
*/
void dfs(int step, int sum, int r) {
//如果走完了所有公司，就可以回头统计结果了
if (step == n + 1) {
//更新最大值
if (sum > Max) {
Max = sum;
//复制保留当前最优路径
memcpy(res, path, sizeof path);
}
return;
}
//从0到r(剩余机器数量),分别尝试分给第x个公司
for (int i = 0; i <= r; i++) {
path[step] = i; //给第x个公司i个设备
//开始尝试x+1个公司,此时价值增加了w[x][i],剩余机器数量减少了i
dfs(step + 1, sum + w[step][i], r - i);
}
}
int main() {
cin >> n >> m;
//读入第i个公司，拿j个设备时的价值是多少
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
cin >> w[i][j];
//爆搜
dfs(1, 0, m);//站在第1个公司面前，爆搜，目前的总价值是0，剩余的机器数量是m
//输出最大价值
printf("%d\n", Max);
//输出最大价值时的选择方法
for (int i = 1; i <= n; i++)
printf("%d %d\n", i, res[i]);
return 0;
}
二、分组背包
本题乍一看很像是 背包DP，为了转换成 背包DP问题，我们需要对里面的一些叙述做出 等价变换
每家公司 我们可以看一个 物品组，又因为 每家公司 最终能够被分配的 机器数量 是固定的
因此对于分给第 \(i\) 个 公司 的不同 机器数量 可以分别看作是一个 物品组 内的 物品
该 物品 \(k\) 的含义：分给第 \(i\) 个 公司 \(k\) 台机器
该 物品 \(k\) 的体积：\(k\)
该 物品 \(k\) 的价值：\(w_{ik}\)
于是，本题就转换成了一个 分组背包问题
直接上 分组背包 的 闫氏DP分析法
初始状态 ：\(f[0][0]\)
目标状态 ：\(f[N][M]\)
#include <bits/stdc++.h>
using namespace std;
const int N = 30;
int n, m; //n个公司，m个机器
int w[N][N]; //第i个公司，拿j个机器时可以得到的价值
int f[N][N]; //dp结果，第一维：前i个公司，第二维：在j个机器的情况下的最优解
int path[N]; //最优解的路径
int main() {
//读入
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
cin >> w[i][j];//读入第i个公司，拿j个机器时能获取到的价值
//二维分组背包模板
for (int i = 1; i <= n; i++) // 枚举组
for (int j = 0; j <= m; j++) { // 枚举体积
f[i][j] = f[i - 1][j]; // 一个都不选的情况
for (int k = 1; k <= j; k++)// 枚举物品,数量和价值在此统一到一起表示
f[i][j] = max(f[i][j], f[i - 1][j - k] + w[i][k]);
}
//输出最大值
printf("%d\n", f[n][m]);
//求方案路径的套路
int j = m; //j代表空间大小
for (int i = n; i >= 1; i--) //倒序遍历每组，注意求解方案时需要从下向上
for (int k = 0; k <= j; k++) //看看f[i][j]是从哪个前序状态转化而来
if (f[i][j] == f[i - 1][j - k] + w[i][k]) {
path[i] = k;//记录下来
j -= k; //体积减小
break; //找到一组即可
}
//输出路径
for (int i = 1; i <= n; i++) printf("%d %d\n", i, path[i]);
return 0;
}
三、动态规划求状态转移路径
这里我介绍一个从 图论 角度思考的方法
动态规划 本质是在一个 拓扑图 内找最短路
我们可以把每个 状态\(f[i][j]\)看作一个 点，状态的转移 看作一条 边，把 状态的值 理解为 最短路径长
具体如下图所示：
对于 点 \(f[i][j]\) 来说，他的 最短路径长 是通过所有到他的 边 更新出来的
更新 最短路 的 规则 因题而已，本题的 更新规则 是 \(f(i,j)=max\{f(i−1,j−v_i)+w_i\}\)
最终，我们会把从 初始状态（起点）到 目标状态 （终点）的 最短路径长 更新出来
随着这个更新的过程，也就在整个 图 中生成了一颗 最短路径树
该 **最短路径树 **上 起点 到 终点 的 路径 就是我们要求的 动态规划的状态转移路径
如下图所示：
可以直接沿用 最短路 输出路径的方法就可以找出 状态的转移
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int n, m;
int w[N][N];
int f[N][N];
int path[N], cnt;
//i,j这个状态是从哪个状态转化而来，记录一下路径
void dfs(int i, int j) {
if (i == 0) return;//递归出口
//寻找当前状态f[i][j]是从上述哪一个f[i-1][k]状态转移过来的
for (int k = 0; k <= j; k++) { //遍历每个可能的转移体积
if (f[i - 1][j - k] + w[i][k] == f[i][j]) {
path[cnt++] = k;//记录从哪里来~
dfs(i - 1, j - k);//沿着这条路线继续吧
return;//找到一个合理解就不再探讨其它的体积
}
}
}
int main() {
//input
cin >> n >> m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
cin >> w[i][j];
//dp
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
for (int k = 0; k <= j; ++k)
f[i][j] = max(f[i][j], f[i - 1][j - k] + w[i][k]);
cout << f[n][m] << endl;
//find path
dfs(n, m);
for (int i = cnt - 1, id = 1; i >= 0; i--, id++)
cout << id << " " << path[i] << endl;
return 0;
}