【九十四】【算法分析与设计】练习四蛮力法练习,排列问题和组合问题,求解最大连续子序列和问题,求解幂集问题,求解0/1背包问题,求解任务分配问题

求解最大连续子序列和问题

给定一个有n（n≥1）个整数的序列，要求求出其中最大连续子序列的和。

例如：

序列（-2，11，-4，13，-5，-2）的最大子序列和为20

序列（-6，2，4，-7，5，3，2，-1，6，-9，10，-2）的最大子序列和为16。

规定一个序列最大连续子序列和至少是0（看成0个元素构成的子序列），如果小于0，其结果为0。

1.

子数组累加和最大值问题,如何划分问题,子数组应该如何划分?

可以划分为以某一个位置结尾的子数组,以i位置结尾的子数组.

所有的子数组被划分成以0下标结尾的子数组,以1下标结尾的子数组.......

我们只需要解决每一个划分出来的子数组集合对应的问题即可.

也就是解决以某一个位置结尾的子数组累加和最大值是多少.

2.

以i位置结尾的子数组可以划分成两种,第一种是只包含i位置元素,第二种是不只包含i位置元素.

只包含i位置元素的累加和最大值为arr[i],不只包含i位置元素的累加和最大值为arr[i]+(以i-1位置结尾的子数组累加和最大值).

我们要求最大值,所以以i位置结尾的子数组累加和最大值为max(arr[i],arr[i]+(以i-1位置结尾的子数组累加和最大值)).

3.

动态规划,自底向上的动态规划和自顶向下的动态规划.

自底向上的动态规划写法

#include<bits/stdc++.h> // 导入标准库头文件
using namespace std; // 使用标准命名空间
#define int long long // 将int类型定义为long long类型，便于处理大数
#define endl '\n' // 将endl定义为换行符

// 定义两个测试用的数组
vector<int>arr1 = { -2,11,-4,13,-5,-2 };
vector<int>arr2 = { -6,2,4,-7,5,3,2,-1,6,-9,10,-2 };

// 定义一个动态规划数组和一个存储当前数组的变量
vector<int>dp;
vector<int>arr;
// 定义存储最大子数组和的变量
int ret;

// 初始化函数
void init() {
        dp.assign(arr.size(), 0); // 将dp数组初始化为和当前数组相同大小，并赋初值为0
        ret = 0; // 将ret初始化为0
}

// 求解最大子数组和的函数
void solve() {
        for (int i = 0; i < arr.size(); i++) { // 遍历数组中的每一个元素
                dp[i] = max((i - 1 >= 0 ? dp[i - 1] : 0) + arr[i], arr[i]); // 计算以当前位置结尾的最大子数组和
                ret = max(ret, dp[i]); // 更新最大子数组和
        }
        cout << ret << endl; // 输出结果
}

// 测试函数
void f() {
        arr = arr1; // 将数组设置为arr1
        init(); // 初始化
        solve(); // 求解

        arr = arr2; // 将数组设置为arr2
        init(); // 初始化
        solve(); // 求解
}

// 主函数
signed main() {
        ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); // 提高输入输出效率
        f(); // 调用测试函数
}

自顶向下的动态规划写法(记忆化递归)

#include<bits/stdc++.h> // 导入标准库头文件
using namespace std; // 使用标准命名空间
#define int long long // 将int类型定义为long long类型，便于处理大数
#define endl '\n' // 将endl定义为换行符

// 定义两个测试用的数组
vector<int>arr1 = { -2,11,-4,13,-5,-2 };
vector<int>arr2 = { -6,2,4,-7,5,3,2,-1,6,-9,10,-2 };

// 定义一个当前数组的变量和一个存储最大子数组和的变量
vector<int>arr;
int ret;

// 定义一个动态规划数组
vector<int>dp;

// 记忆化递归函数，求以位置i结尾的最大子数组和
int dfs(int i) {
        if (dp[i] != -1) return dp[i]; // 如果dp[i]已被计算，则直接返回dp[i]
        if (i - 1 < 0) { // 如果i是第一个元素
                dp[i] = arr[i]; // 直接返回arr[i]
                return dp[i]; // 返回dp[i]
        }
        dp[i] = max(dfs(i - 1) + arr[i], arr[i]); // 计算dp[i]，取包含i的子数组和与仅包含i元素的子数组和的最大值
        ret = max(ret, dp[i]); // 更新最大子数组和
        return dp[i]; // 返回dp[i]
}

// 初始化函数
void init() {
        ret = 0; // 将ret初始化为0
        dp.assign(arr.size(), -1); // 将dp数组初始化为和当前数组相同大小，并赋初值为-1
}

// 求解最大子数组和的函数
void solve() {
        for (int i = 0; i < dp.size(); i++) dfs(i); // 遍历数组中的每一个元素，调用dfs函数
        cout << ret << endl; // 输出结果
}

// 测试函数
void f() {
        arr = arr1; // 将数组设置为arr1
        init(); // 初始化
        solve(); // 求解

        arr = arr2; // 将数组设置为arr2
        init(); // 初始化
        solve(); // 求解
}

// 主函数
signed main() {
        ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); // 提高输入输出效率
        f(); // 调用测试函数
}

求解幂集问题

对于给定的正整数3，求1～3构成的集合的所有子集（幂集）。

{}

{1}

{2}

{1,2}

{3}

{1,3}

{2,3}

{1,2,3}

1.

组合问题,有3个整数,选出其中的部分整数作为一个集合,所有不同的情况都列出来.

对于任意的整数,在选出来的集合中,都可以选择或者不选择两种方案.

所以一共有2^3种方案.对于数字1可以选择或者不选择,对于数字2可以选择或者不选择,对于数字3可以选择或者不选择.

一共有2*2*2=2^3种方案数.

2.

在每一种方案中对于每一个数字,都有对应的选择,选择或者不选择,因此可以用1表示选择0表示不选择.

例如空集对应000,{1}对应100,{2}对应010,{1,2}对应110....{1,2,3}对应111.

如果000~111全部是二进制数,那么对应的十进制数是0~2^3-1.

每一个数的二进制都对应一种方案.

3.

对于每一种方案,只需要提取对于二进制数所有位置的1就知道选择了哪些元素.

#include<bits/stdc++.h> // 导入标准库头文件
using namespace std; // 使用标准命名空间
#define int long long // 将int类型定义为long long类型，便于处理大数
#define endl '\n' // 将endl定义为换行符

// 定义一个包含1,2,3的数组
vector<int> arr = { 1,2,3 };
// 定义一个变量n来存储幂集的大小
int n;

// 初始化函数
void init() {
        n = pow(2, arr.size()); // 计算幂集的大小，即2的arr.size()次幂
}

// 求解幂集的函数
void solve() {
        for (int i = 0; i < n; i++) { // 遍历从0到2^arr.size() - 1的所有整数
                cout << "{ "; // 输出子集的左花括号
                for (int j = 0; j < arr.size(); j++) { // 遍历数组中的每一个元素
                        if (i & (1 << j)) { // 检查整数i的第j位是否为1
                                cout << arr[j] << " "; // 如果是，则输出对应的数组元素
                        }
                }
                cout << "}" << endl; // 输出子集的右花括号和换行符
        }
}

// 主函数
signed main() {
        ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); // 提高输入输出效率
        init(); // 初始化
        solve(); // 求解幂集
}

求解0/1背包问题

有n个重量分别为{w1，w2，…，wn}的物品，它们的价值分别为{v1，v2，…，vn}，给定一个容量为W的背包。设计从这些物品中选取一部分物品放入该背包的方案，每个物品要么选中要么不选中，要求选中的物品不仅能够放到背包中，而且具有最大的价值。

并对下表所示的4个物品求出W=6时的所有解和最佳解。

物品编号	重量	价值
1	5	4
2	3	4
3	2	3
4	1	1

1.

0/1背包问题也是组合问题.有n个物品,选择一部分物品出来放到一个集合里面.

2.

一共有4个物品,每一个物品对应一个二进制数,一共是四个位置的二进制数,0~2^4-1.

每一个数对应一种选择方案,要么选择要么不选择.

一共有2^4种方案数.

3.

printf输入格式很方便,但是要注意string转化为c_str().

#include<bits/stdc++.h> // 导入标准库头文件
using namespace std; // 使用标准命名空间
#define int long long // 将int类型定义为long long类型，便于处理大数
#define endl '\n' // 将endl定义为换行符

// 定义一个结构体node，用来存储物品的重量和价值
struct node {
        int weight; // 物品重量
        int value; // 物品价值
};

// 定义变量n表示物品数量，nsize表示所有可能选择方案的数量，maxWeight表示背包的最大承重
int n = 0;
int nsize = 0;
int maxWeight = 6; // 背包最大承重为6

// 定义一个包含4个物品的数组，每个物品包含重量和价值
vector<node> arr = { {5,4},{3,4},{2,3},{1,1} };

// 定义一个结构体node1，用来存储选择方案的字符串表示、总重量和总价值
struct node1 {
        string str = ""; // 选择方案的字符串表示
        int weight = 0; // 选择方案的总重量
        int value = 0; // 选择方案的总价值
};

// 定义一个变量ret，用来存储最佳选择方案
node1 ret;

// 初始化函数
void init() {
        n = 4; // 物品数量为4
        nsize = pow(2, n); // 所有可能选择方案的数量为2^4=16
}

// 求解0/1背包问题的函数
void solve() {
        cout << "0/1背包求解方案" << endl; // 输出标题
        // 输出表头
        printf("%-10s%-20s%-10s%-10s%-10s\n", "序号", "选中物品", "总重量", "总价值", "能否装入");
        for (int i = 0; i < nsize; i++) { // 遍历所有可能的选择方案
                node1 temp; // 定义一个临时变量temp来存储当前选择方案
                temp.str.push_back('{'); // 添加左花括号
                temp.str.push_back(' ');
                for (int j = 0; j < n; j++) { // 遍历所有物品
                        if (i & (1 << j)) { // 检查当前选择方案是否选择了第j个物品
                                temp.str.push_back(j + '1'); // 如果选择了，则将物品编号添加到字符串中
                                temp.str.push_back(' ');
                                temp.weight += arr[j].weight; // 将物品的重量加到总重量中
                                temp.value += arr[j].value; // 将物品的价值加到总价值中
                        }
                }
                temp.str.push_back('}'); // 添加右花括号

                // 如果当前选择方案的总重量小于等于背包的最大承重且总价值大于当前最佳选择方案的总价值，则更新最佳选择方案
                if (temp.weight <= maxWeight && temp.value > ret.value) ret = temp;
                // 输出当前选择方案的序号、字符串表示、总重量、总价值和是否能装入背包
                printf("%-10lld%-20s%-10lld%-10lld%-10s\n", i + 1, temp.str.c_str(), temp.weight, temp.value, temp.weight <= maxWeight ? "能" : "否");
        }

        // 输出最佳选择方案的字符串表示、总重量和总价值
        printf("最佳方案为 选中物品:%s,总重量:%lld,总价值:%lld", ret.str.c_str(), ret.weight, ret.value);
}

// 主函数
signed main() {
        ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); // 提高输入输出效率
        init(); // 初始化
        solve(); // 求解0/1背包问题
}

求解任务分配问题

有n（n≥1）个任务需要分配给n个人执行，每个任务只能分配给一个人，每个人只能执行一个任务。

第i个人执行第j个任务的成本是c[i][j]（1≤i，j≤n）。求出总成本最小的分配方案。

【问题求解】所谓一种分配方案就是由第i个人执行第j个任务，用（a1，a2，…，an）表示，即第1个人执行第a1个任务，第2个人执行第a2个任务，以此类推。全部的分配方案恰好是1～n的全排列。

这里采用穷举法求出所有的分配方案ps（全排列），再计算出每种方案的成本，比较求出最小成本的方案，即最优方案。以n=4，成本如下表所示为例讨论。

1.

排列问题,将4个任务进行全排列,列出所有的情况.

用内置函数next_premutation函数找到所有的全排序序列.

模板:

        vector<int> arr = { 1,2,3,4 };
        do {
                // 输出当前的排列
                for (int num : arr) {
                        cout << num << " ";
                }
                cout << endl;
        } while (next_permutation(arr.begin(), arr.end()));

2.

用内置函数next_premutation找到所有的全排序序列的前提是需要arr排序完毕.

//内置函数求全排序模板
#if 0

#include<bits/stdc++.h>
using namespace std;
#define int long long 
#define endl '\n'
void init() {}
void solve() {}

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


        vector<int> arr = { 1,2,3,4 };
        do {
                // 输出当前的排列
                for (int num : arr) {
                        cout << num << " ";
                }
                cout << endl;
        } while (next_permutation(arr.begin(), arr.end()));

}

#endif // 1

#if 1

#include<bits/stdc++.h> // 导入标准库头文件
using namespace std; // 使用标准命名空间
#define int long long // 将int类型定义为long long类型，便于处理大数
#define endl '\n' // 将endl定义为换行符

// 定义一个结构体node，用来存储一个分配方案及其总成本
struct node {
        vector<int>people = { 0,0,0,0 }; // 分配方案
        int total = 0; // 总成本
};

// 定义成本矩阵
vector<vector<int>> cost = {
        {9,2,7,8},
        {6,4,3,7},
        {5,8,1,8},
        {7,6,9,4}
};

// 定义一个包含任务序号的数组
vector<int>arr = { 1,2,3,4 };
// 定义一个变量ret，用来存储最优方案
node ret;

// 初始化函数
void init() {
        ret.total = INT_MAX; // 将最优方案的总成本初始化为最大值
}

// 求解任务分配问题的函数
void solve() {

        do {
                node temp; // 定义一个临时变量temp来存储当前分配方案
                for (int i = 0; i < arr.size(); i++) { // 遍历所有任务
                        temp.total += cost[i][arr[i] - 1]; // 累加当前分配方案的总成本
                }
                temp.people = arr; // 将当前分配方案赋值给temp的people字段
                if (ret.total > temp.total) ret = temp; // 如果当前分配方案的总成本小于最优方案的总成本，则更新最优方案

        } while (next_permutation(arr.begin(), arr.end())); // 生成下一个排列

        printf("最优方案:\n"); // 输出最优方案
        for (int i = 0; i < 4; i++) { // 遍历所有人
                printf("第%lld个人安排任务%lld\n", i + 1, ret.people[i]); // 输出每个人对应的任务
        }
        printf("总成本=%lld\n", ret.total); // 输出总成本
}

// 主函数
signed main() {
        ios::sync_with_stdio(0), cin.tie(0), cout.tie(0); // 提高输入输出效率
        init(); // 初始化
        solve(); // 求解任务分配问题
}

#endif // 1

结尾

最后，感谢您阅读我的文章，希望这些内容能够对您有所启发和帮助。如果您有任何问题或想要分享您的观点，请随时在评论区留言。

同时，不要忘记订阅我的博客以获取更多有趣的内容。在未来的文章中，我将继续探讨这个话题的不同方面，为您呈现更多深度和见解。

谢谢您的支持，期待与您在下一篇文章中再次相遇！