矩阵连乘
题目描述
解题代码
void printOptimalParens(vector<vector<int>>& partition, int i, int j) {
if (i == j) cout << "A" << i; // 单个矩阵，无需划分
else {
cout << "(";
printOptimalParens(partition, i, partition[i][j]);
printOptimalParens(partition, partition[i][j] + 1, j);
cout << ")";
}
}
// nums[i]: nums[0]为矩阵A1的行数，nums[i](i >= 1)表示矩阵Ai的列数
// 如输入为 nums = { 30,35,15,5,10,20,25 }，代表矩阵行列数如下：
// A1: 30 * 35, A2: 35 * 15, A3: 15 * 5, A4: 5 * 10, A5: 10 * 20, A6: 20 * 25
int matrixChainOrder(vector<int>& nums) {
int n = nums.size() - 1;
// dp[i][j]表示矩阵链A[i～j]的最优解
vector<vector<int>> dp(n + 1, vector<int>(n + 1, INT32_MAX));
// partition[i][j]表示矩阵链A[i～j]最优解对应的划分k
vector<vector<int>> partition(n + 1, vector<int>(n + 1));
for (int i = 1; i <= n; ++i) {
dp[i][i] = 0; // 矩阵链长度为1时，最优解为0
}
for (int len = 2; len <= n; ++len) { // len为矩阵链长度
for (int i = 1; i + len - 1 <= n; ++i) { // 矩阵链左端点i
int j = i + len - 1; // 矩阵链右端点j
for (int k = i; k <= j - 1; ++k) { // 划分点k
int sum = dp[i][k] + dp[k + 1][j] + nums[i - 1] * nums[k] * nums[j];
if (sum < dp[i][j]) { // 更新最优解
dp[i][j] = sum;
partition[i][j] = k;
}
}
}
}
printOptimalParens(partition, 1, n); // 打印最优方案
return dp[1][n];
}
最长公共子序列
题目描述
解题代码
void printLCS(const string& text1, vector<vector<char>>& dir, int i, int j) {
if (i == 0 || j == 0) return;
if (dir[i][j] == 'S') { // 向左上移动
printLCS(text1, dir, i - 1, j - 1);
cout << text1[i - 1]; // 递归后再输出字符，以实现反向
}
else if (dir[i][j] == 'U') { // 向上移动
printLCS(text1, dir, i - 1, j);
}
else { // 向左移动
printLCS(text1, dir, i, j - 1);
}
}
int longestCommonSubsequence(string text1, string text2) {
int m = text1.size(), n = text2.size();
// dp[i][j]表示text1[0～i-1]和text2[0～i-1]的LCS
vector<vector<int>> dp(m + 1, vector<int>(n + 1, 0));
// dir[i][j]记录得到LCS的移动方向，以便构造最优解
vector<vector<char>> dir(m + 1, vector<char>(n + 1, '*'));
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
if (text1[i - 1] == text2[j - 1]) {
dp[i][j] = dp[i - 1][j - 1] + 1;
dir[i][j] = 'S';
}
else if (dp[i - 1][j] >= dp[i][j - 1]) {
dp[i][j] = dp[i - 1][j];
dir[i][j] = 'U';
}
else {
dp[i][j] = dp[i][j - 1];
dir[i][j] = 'L';
}
}
}
printLCS(text1, dir, m, n); // 构造最优解
return dp[m][n];
}
最大子段和
题目描述
解题代码
分治法
int dividedMaxSubSum(vector<int>& nums, int left, int right) {
if (left == right) return nums[left]; // 单个元素最大子段和为该元素的值
int mid = left + (right - left) / 2;
int lSum = dividedMaxSubSum(nums, left, mid); // 划分左端子数组的最大子段和
int rSum = dividedMaxSubSum(nums, mid + 1, right); // 划分右端子数组的最大子段和
// 计算穿过划分点的子数组左端的最大子段和
int midL = 0, maxMidL = INT32_MIN;
for (int i = mid; i >= left; --i) {
midL += nums[i];
maxMidL = max(maxMidL, midL);
}
// 计算穿过划分点的子数组右端的最大子段和
int midR = 0, maxMidR = INT32_MIN;
for (int i = mid + 1; i <= right; ++i) {
midR += nums[i];
maxMidR = max(maxMidR, midR);
}
// 子数组的最大子段和为三者之间最大的一个
return max(maxMidL + maxMidR, max(lSum, rSum));
}
int maxSubSum(vector<int>& nums) {
int n = nums.size();
return dividedMaxSubSum(nums, 0, n - 1);
}
动态规划
int maxSubSum(vector<int>& nums) {
int res = 0, sum = 0;
for (int i = 0; i < nums.size(); ++i) {
if (sum > 0) {
sum += nums[i];
}
// 当前累计总和小于零，则包含该部分的子段必不可能为最大子段，可根据反证法证明：
// 假设子段S为最大子段，且其包含总和为负的前缀子段s1，则将该前缀子段删去后得到的新子段S'的子段和必定大于S，与假设矛盾
else {
sum = nums[i];
}
res = max(res, sum);
}
return res;
}
凸多边形最优三角剖分
题目描述
解题代码
int minScoreTriangulation(vector<int>& values) {
int n = values.size();
vector<vector<int>> dp(n, vector<int>(n, 0));
for (int len = 3; len <= n; ++len) { // 多边形顶点序列长度len
for (int i = 0; i + len - 1 < n; ++i) { // 顶点序列左端点i
int j = i + len - 1; // 顶点序列右端点j
dp[i][j] = INT32_MAX;
for (int k = i + 1; k < j; ++k) { // 划分点k
int cost = dp[i][k] + dp[k][j] + values[i] * values[j] * values[k];
dp[i][j] = min(dp[i][j], cost);
}
}
}
return dp[0][n - 1];
}
0-1背包问题
题目描述
解题代码
int knapsack01(vector<int>& weights, vector<int>& values, int c) {
int n = weights.size();
// dp[i][j]表示可选商品为0～i，背包容量为j情况下的最优解
vector<vector<int>> dp(n, vector<int>(c + 1, 0));
for (int j = weights[0]; j <= c; ++j) {
// 若i=0，即可选商品只有0，此时最优解为：能否装下商品0 ? values[0] : 0
dp[0][j] = values[0];
}
for (int i = 1; i < n; ++i) { // 可选商品0～i
for (int j = 1; j <= c; ++j) { // 背包容量j
dp[i][j] = dp[i - 1][j]; // 不选择商品i
if (j >= weights[i]) { // 若j >= weight[i]，则可选择商品i
// 取两种情况（选择或不选择商品i）下的最优解
dp[i][j] = max(dp[i][j], dp[i - 1][j - weights[i]] + values[i]);
}
}
}
return dp[n - 1][c];
}
最优二叉搜索树
题目描述
解题代码
// pNonLeaves[i](i >= 1)表示非叶结点i的搜索概率，pLeaves[i](i >= 0)表示叶子结点i的搜索概率
// 如输入为 pNonLeaves = { 0.0,0.15,0.10,0.05,0.10,0.20 }
// 表示非叶结点i的搜索概率p[1～5] = [ 0.15,0.10,0.05,0.10,0.20 ]（原数组首个0为占位用，无实际含义）
// 如输入为 pLeaves = { 0.05,0.10,0.05,0.05,0.05,0.10 }
// 表示非叶结点i的搜索概率q[0～5] = [ 0.05,0.10,0.05,0.05,0.05,0.10 ]
double optimalBST(vector<double>& pNonLeaves, vector<double>& pLeaves) {
int n = pNonLeaves.size() - 1; // 非叶节点的个数n
// dp[i][j]表示根据结点序列pNonLeaves[i～j]和pLeaves[i～j]构成的最优解（子树）
// dp[i][i-1]代表只含有叶结点i-1的子树（不含非叶节点）
vector<vector<double>> dp(n + 2, vector<double>(n + 1, DBL_MAX));
// root[i][j]表示dp[i][j]对应的子树的根节点，可根据其构造最优二叉搜索树
vector<vector<int>> root(n + 1, vector<int>(n + 1));
// pSum[i][j]表示结点序列pNonLeaves[i～j]和pLeaves[i～j]的概率总和
vector<vector<double>> pSum(n + 2, vector<double>(n + 1));
for (int i = 1; i <= n + 1; ++i) { // 初始化dp和pSum
dp[i][i - 1] = pLeaves[i - 1];
pSum[i][i - 1] = pLeaves[i - 1];
}
for (int len = 1; len <= n; ++len) { // 结点序列长度len
for (int i = 1; i + len - 1 <= n; ++i) { // 序列左端点i
int j = i + len - 1; // 序列右端点j
pSum[i][j] = pSum[i][j - 1] + pNonLeaves[j] + pLeaves[j]; // 递推计算结点序列区间概率和
for (int r = i; r <= j; ++r) { // 将非叶结点r选作根节点
double cost = dp[i][r - 1] + dp[r + 1][j] + pSum[i][j]; // 该情况下的搜索代价
if (cost < dp[i][j]) { // 更新最优解
dp[i][j] = cost;
root[i][j] = r;
}
}
}
}
return dp[1][n];
}
扫一扫
1604
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
