用c++设有n种不同面值的硬币，各硬币的面值存于数组T[1:n]中。现要用这些面值的硬币来找钱，可以实用的各种面值的硬币个数不限。当只用硬币面值T[1],T[2],…,T[i]时，可找出钱数j的最少硬币个数记为C(i,j)。若只用这些硬币面值，找不出钱数j时，记C(i,j)=∞。

这个问题属于算法问题，我可以回答。这是一道动态规划题目，求解C(i,j)的最小值可以用以下公式：
C(i,j) = min{C(i-1,j), C(i,j-T[i])+1}
其中，C(i-1,j)表示只使用T[1]~T[i-1]面值的硬币找j元钱的最小硬币数，C(i,j-T[i])+1表示使用T[1]~T[i]面值的硬币找j-T[i]元钱的最小硬币数再加1个面值为T[i]的硬币。初始条件为C(i,0)=0。请注意，这仅是一种可能的解法，还有其他方式可以解决这个问题。

相关问题

设有n 种不同面值的硬币，各硬币的面值存于数组T［1:n］中。现要用这些面值的硬币来找钱。可以使用的各种面值的硬币个数存于数组Coins［1:n］中。 对任意钱数0≤m≤20001，设计一个用最少硬币找钱m的方法。

这个问题可以用动态规划来解决。设f(i)表示找i元钱所需的最少硬币数量，则有状态转移方程：

f(i) = min{f(i-T[j])+1}，其中T[j]表示第j种硬币的面值，且T[j]<=i且Coins[j]>0。

初始状态：f(0)=0，即找0元钱不需要任何硬币。

最终答案为f(m)。

下面是C++代码实现：

const int INF = 0x3f3f3f3f; // 定义无穷大
int f[20005]; // f[i]表示找i元钱所需的最少硬币数量
int T[105], Coins[105]; // T数组存储硬币面值，Coins数组存储硬币个数

int solve(int m, int n) {
    memset(f, INF, sizeof(f)); // 初始化为无穷大
    f[0] = 0; // 找0元钱不需要任何硬币
    for (int i = 1; i <= m; i++) {
        for (int j = 1; j <= n; j++) {
            if (T[j] <= i && Coins[j] > 0) {
                f[i] = min(f[i], f[i-T[j]]+1);
                Coins[j]--; // 使用了第j种硬币
            }
        }
        for (int j = 1; j <= n; j++) {
            if (T[j] <= i) {
                Coins[j]++; // 恢复第j种硬币的个数
            }
        }
    }
    if (f[m] == INF) return -1; // 无解的情况
    else return f[m];
}

其中m表示需要找的钱数，n表示硬币的种类数。函数返回值为最少硬币数量，若无解则返回-1。

设有 n 种不同面值的硬币，各硬币的面值存于数组 T［1:n］中。现要用这些 面值的硬币来找钱。可以使用的各种面值的硬币个数存于数组 Coins［1:n］中。 对任意钱数 0≤m≤20001，设计一个用最少硬币找钱 m 的方法。

这是一个典型的动态规划问题，可以使用动态规划算法来解决。

定义状态 dp[i] 表示找钱金额为 i 时所需的最少硬币数。则对于每个 i，都可以枚举使用哪种面值的硬币 Coin[j]，来更新状态 dp[i]。

具体来说，对于每个 i，遍历数组 Coins，如果当前硬币面值为 Coin[j]，并且 i-Coin[j] 可以被找零（即 dp[i-Coin[j]] 不为无穷大），则可以更新状态 dp[i]：

dp[i] = min(dp[i], dp[i-Coin[j]] + 1)

其中，dp[i-Coin[j]] + 1 表示使用当前硬币 Coin[j]，再加上找钱金额为 i-Coin[j] 时所需的最少硬币数。

最终，dp[m] 就是所需的最少硬币数。

下面是 C++ 代码实现：

const int INF = 0x3f3f3f3f;
const int MAXN = 20010;

int T[MAXN], Coins[MAXN], dp[MAXN];

int main() {
    int n, m;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &T[i]);
    }
    for (int i = 1; i <= n; i++) {
        scanf("%d", &Coins[i]);
    }

    memset(dp, INF, sizeof(dp));
    dp[0] = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = m; j >= T[i]; j--) {
            for (int k = 0; k <= Coins[i] && k * T[i] <= j; k++) {
                if (dp[j - k * T[i]] != INF) {
                    dp[j] = min(dp[j], dp[j - k * T[i]] + k);
                }
            }
        }
    }

    printf("%d\n", dp[m] == INF ? -1 : dp[m]);
    return 0;
}

其中，第一个循环枚举硬币面值，第二个循环枚举钱数，第三个循环枚举使用当前硬币的个数。在第三个循环中，需要判断 dp[j-k\*T[i]] 是否为 INF，如果是，则说明无法使用当前硬币找零 j-k\*T[i]，需要跳过。