动态规划

背包

*图片来自于《算法图解》，侵删

*图片来自于《算法图解》，侵删

#include 
#include 
#include 
using namespace std;

// 打印矩阵
int print_dp(vector<vector<int>> dp)
{
     
    for (int i = 0; i < dp.size(); i++)
    {
     
        for (int j = 0; j < dp[i].size(); j++)
        {
     
            cout << dp[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}

int main()
{
     
    // 物品价值
    vector<int> v = {
     1500, 3000, 2000, 2000};
    // 物品重量
    vector<double> w = {
     1, 4, 3, 1};
    // 背包递增步长 粒度
    double scale = 1;
    // 背包种类个数
    int m = 5;
    // dp二维矩阵
    vector<vector<int>> dp(v.size());
    for (int i = 0; i < v.size(); i++)
    {
     
        dp[i].resize(m);
    }

    // 实现规划
    for (int i = 1; i < dp[0].size(); i++)
    {
     
        dp[0][i] = v[0];
    }

    for (int i = 1; i < dp.size(); i++)
    {
     
        for (int j = 1; j < dp[i].size(); j++)
        {
     
            // 加入物品i的最大价值
            int add_v = 0;
            if (j * scale - w[i] >= 0) // 能放的下当前物品i
            {
     
                add_v = v[i] + dp[i - 1][(j * scale - w[i]) / scale];
            }

            // 更新dp
            dp[i][j] = max(dp[i - 1][j], add_v);
        }
    }
    print_dp(dp);

    return 0;
}

最大和子串

https://blog.csdn.net/qq_42034068/article/details/88212038

#include 
using namespace std;
const int SIZE = 10001;
int main()
{
     

    int k = 0;
    scanf("%d", &k);

    int v[SIZE];
    for (int i = 0; i < k; i++)
    {
     
        scanf("%d", &v[i]);
    }

    int dp[SIZE];
    int begin[SIZE];
    dp[0] = begin[0] = v[0];
    int max_sum = v[0];
    int max_begin = v[0];
    int max_end = v[0];
    for (int i = 1; i < k; i++)
    {
     
        if (dp[i - 1] + v[i] >= v[i])
        {
      // 前子串和为正
            dp[i] = dp[i - 1] + v[i];
            begin[i] = begin[i - 1];
        }
        else
        {
      // 前子串和为负,从当前位置开始
            dp[i] = v[i];
            begin[i] = v[i];
        }

        // 记录最大和子串情况
        if (dp[i] > max_sum)
        {
     
            max_sum = dp[i];
            max_begin = begin[i];
            max_end = v[i];
        }
    }
    if (max_sum >= 0)
    {
     
        printf("%d %d %d", max_sum, max_begin, max_end);
    }
    else
    {
     
        printf("%d %d %d", 0, v[0], v[k - 1]);
    }

    return 0;
}

最长公共子序列

*图片来自于《算法图解》，侵删

*图片来自于《算法图解》，侵删

#include 
#include 
using namespace std;
vector<vector<int>> dp(string str1, string str2)
{
     
    vector<vector<int>> dp(str1.length() + 1); // 注意留0行
    for (int i = 0; i < dp.size(); i++)
    {
     
        dp[i].resize(str2.length() + 1); // 注意留0列
    }

    for (int i = 1; i < dp.size(); i++)
    {
     
        for (int j = 1; j < dp[0].size(); j++)
        {
     
            if (str1[i - 1] == str2[j - 1]) // 注意dp矩阵下标转化为字符串下标
            {
     
                dp[i][j] = dp[i - 1][j - 1] + 1;
            }
            else
            {
     
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);
            }
        }
    }

    return dp;
}

// 打印矩阵
int print_dp(vector<vector<int>> dp)
{
     
    for (int i = 0; i < dp.size(); i++)
    {
     
        for (int j = 0; j < dp[i].size(); j++)
        {
     
            cout << dp[i][j] << " ";
        }
        cout << endl;
    }
    return 0;
}
int main()
{
     
    print_dp(dp("fort", "fosh"));
    cout << "-------------------" << endl;
    print_dp(dp("fish", "fosh"));
    return 0;
}