题解👀️ ，记得点赞！！！

1. 首先从输入中读取两个整数 t 和 m，分别表示背包的总容量和物品的个数。
2. 接下来使用循环读取 m 个物品的重量和价值，并将它们分别存储在 w 数组和 val 数组中。
3. 然后开始进行动态规划的计算。dp 数组用于记录每个背包容量下所能获得的最大价值。
4. 外层循环遍历每个物品，内层循环遍历从背包容量 t 开始到 0 的所有可能容量。
5. 在内层循环中，判断当前容量是否能放下当前物品。如果能放下，则尝试将该物品放入背包中，并更新 dp 数组的值为放入该物品后的最大价值。
6. 最后输出 dp[t] 的值，即为背包容量为 t 时所能获得的最大价值。

复杂度是 O(t*m)，其中 t 是背包的总容量，m 是物品的个数。

PY:

t, m = map(int, input().split())
w = [0] * (m+1)
val = [0] * (m+1)
dp = [0] * (t+1)

for i in range(1, m+1):
    w[i], val[i] = map(int, input().split())

for i in range(1, m+1):
    for j in range(t, 0, -1):
        if j >= w[i]:
            dp[j] = max(dp[j-w[i]] + val[i], dp[j])

print(dp[t])

C++:

#include <iostream>
#include <algorithm>
using namespace std;

const int MAXN = 1005;
int w[MAXN], val[MAXN], dp[MAXN];

int main() {
    int t, m;
    cin >> t >> m;
    for (int i = 1; i <= m; i++) {
        cin >> w[i] >> val[i];
    }
    for (int i = 1; i <= m; i++) {
        for (int j = t; j >= 0; j--) {
            if (j >= w[i]) {
                dp[j] = max(dp[j - w[i]] + val[i], dp[j]);
            }
        }
    }
    cout << dp[t] << endl;
    return 0;
}

点个赞吧❤️ ~

这个问题可以使用动态规划来解决。下面是编写代码的思路：

1. 首先，我们需要定义一个二维数组dp[M+1][T+1]，其中dp[i][j]表示在前i株草药中，在时间不超过j的情况下能够采到的草药的最大总价值。
2. 然后，我们需要遍历每一株草药，并计算出dp[i][j]的值。具体的计算方法如下：
   • 如果当前的时间可以采摘这株草药（times[i-1] <= j），则有两种选择：采摘这株草药和不采摘这株草药。
     • 采摘这株草药时，总价值为dp[i-1][j-times[i-1]] + values[i-1]，其中dp[i-1][j-times[i-1]]表示在前i-1株草药中，在剩余时间为j-times[i-1]的情况下能够采到的最大总价值，values[i-1]表示当前草药的价值。
     • 不采摘这株草药时，总价值为dp[i-1][j]，即在前i-1株草药中，在当前时间下能够采到的最大总价值。
     • 我们需要选择上述两种选择中价值最大的方案作为dp[i][j]的值。
   • 如果当前时间不足以采摘这株草药（times[i-1] > j），则只能选择不采摘这株草药，即dp[i][j] = dp[i-1][j]。
3. 最后，我们需要返回dp[M][T]作为结果，表示在总共能够用来采药的时间为T的情况下，能够采到的草药的最大总价值。

以上就是解决这个问题的主要思路。通过动态规划的方式，我们可以利用已经计算好的子问题的结果来求解更大规模的问题，从而得到最优解。

AC代码，放心食用😄 ：

#include <iostream>
#include <vector>
using namespace std;

int maxValue(int T, int M, vector<int>& times, vector<int>& values) {
    // 创建一个二维数组dp来记录每个时间点对应的最大价值
    vector<vector<int>> dp(M+1, vector<int>(T+1, 0));

    // 动态规划的过程，从第一株草药开始计算
    for (int i = 1; i <= M; i++) {
        for (int j = 1; j <= T; j++) {
            // 如果当前的时间可以采摘这株草药
            if (times[i-1] <= j) {
                // 判断不采摘这株草药和采摘这株草药哪种选择获得的价值更大
                dp[i][j] = max(dp[i-1][j], dp[i-1][j-times[i-1]] + values[i-1]);
            } else {
                // 当前时间不足以采摘这株草药，则选择不采摘
                dp[i][j] = dp[i-1][j];
            }
        }
    }

    return dp[M][T]; // 返回最大总价值
}

int main() {
    int T, M;
    cin >> T >> M; // 输入总共能够用来采药的时间和山洞里的草药的数目

    vector<int> times(M), values(M);
    for (int i = 0; i < M; i++) {
        cin >> times[i] >> values[i]; // 输入每株草药的采摘时间和价值
    }

    int maxVal = maxValue(T, M, times, values); // 调用函数计算最大总价值
    cout << maxVal << endl; // 输出结果

    return 0;
}

采药总时间相当于背包容量，每一株药相当于一件物品，采药时间相当于该物品的体积，草药的价值相当于物品价值。

for (int j = m; j >= v; j--)
    f[j] = max(f[j], f[j - v] + w);

😄 👀️ 麻烦大家伙给俺也点个小赞赞吧👍

复杂度是 O(t*m)不算太特别大~

采药总时间 = 背包容量， 每一株药 = 一件物品， 采药时间 = 物品的体积， 草药的价值 = 物品价值。

转换一下，用常量做题😄

首先从输入t 和 m，分别表示背包的总容量和物品的个数。接下来循环 m 个物品的重量和价值，并把它们分别存储在 x 和 y 数组中。然后用动态规划计算背包最大价值。 最后，我们需要返回z[M][T]作为结果，就OK了。

#include <bits/stdc++.h>
using namespace std;
int x[1005],y[1005], z[1005];
int main() 
{
   int t, m;
   cin >> t >> m;
   for (int i = 1; i <= m; i++) 
   {
      cin >> x[i] >> y[i];
   }
   for (int i = 1; i <= m; i++) 
   {
      for (int j = t; j >= 0; j--) 
      {
         if (j >= x[i]) 
         {
            z[j] = max(z[j - x[i]] + y[i], z[j]);
         }
      }
   }
   cout << z[t] << endl;
   return 0;
}