设有 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]，需要跳过。