【动态规划+数论】包子凑数|完全背包变形

小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有N种蒸笼，其中第i种蒸笼恰好能放Ai个包子。每种蒸笼都有非常多笼，可以认为是无限笼。

　　每当有顾客想买X个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有X个包子。比如一共有3种蒸笼，分别能放3、4和5个包子。当顾客想买11个包子时，大叔就会选2笼3个的再加1笼5个的（也可能选出1笼3个的再加2笼4个的）。

　　当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有3种蒸笼，分别能放4、5和6个包子。而顾客想买7个包子时，大叔就凑不出来了。

　　小明想知道一共有多少种数目是包子大叔凑不出来的。

输入说明：

第一行包含一个整数N。(1 <= N <= 100)
　　以下N行每行包含一个整数Ai。(1 <= Ai <= 100)

输出说明:

一个整数代表答案。如果凑不出的数目有无限多个，输出INF。

比如：

输入

2
4
5

输出

说明：

　　凑不出的数目包括：1, 2, 3, 6, 7, 11。

输入

2
4
6

输出

INF

说明：

　　所有奇数都凑不出来，所以有无限多个。

测试用例:

输入：

2
4
5

输出：

题解：

问题分析：

一个笼子可以用无数次，所以应该是完全背包类的变形问题。

数学分析：

先分析凑的出来的包子数，先从两个数字开始分析：两个数字只能凑出其最大公约数的倍数。这个结论可以推广到多个数字，也只能凑出其最大公约数的倍数。所以几个数字最大公约数如果！=1 则必有INF种组合凑不出来。

而最大公约数，我们利用辗转相除法来求。而多个数的最大公约数可以用这个逻辑来计算:求a b c的最大公约数先求 a 和 b的最大公约数 x 再求 x和 c的最大公约数 y 则 y就是a b c的最大公约数。也就是可以每遇到一个新的数就求一次最大公约数并保存与下一个数继续算最大公约数。

辗转相除法求最大公约数参考我的【数论】辗转相除法

DP分析：

由于是可不可以组合的出则DP数组为一个BOOL数字 1代表可以0代表不可以。

类似于完全背包则DP数组为一个二维数组，DP[i][j] i代表用前i种笼子 j代表可以凑得出的包子数量

目标确定:

求凑不出的数目则dp[n][j] 等于0的数量即为ans n代表所有种类笼子都用上还凑不出来的包子数

j从1遍历到MAX MAX也就是最多可能的包子数为10000

上界确定：

10000如何确定的是一个难点因为笼子大小最大为100 而100以内互质的数最大为99 98 则最大凑不出来的包子数为99*98-99-98<100*100=10000 所以上界定为这个而数字越多凑出来的可能越大所以上界越小所以考虑只有两中笼子的情况

为什么最大凑不出来数是这个呢参考我的：

【数论】A B互质最大不能表示出来的数是 A*B-A-B

DP数组初始化：

DP[0][0]=1 0种笼子肯定能凑出0个包子

DP数组遍历方式:

类似于完全背包的遍历方式外层遍历笼子种类内层遍历可能的包子和

状态转移方程：

dp[i][j]=dp[i-1][j]||(j>=arr[i]?dp[i][j-arr[i]]:false)

两种可能如果前i-1种笼子已经可以凑出j种包子了就直接转移如果不行再看j j如果>=第i种笼子内的包子数则就看i种笼子能不能凑出j-arr[i]种包子可以的话就从这个状态上加上i笼包子数转移如果j于包子数就默认为false 我们用一个三目运算符来实现上面的逻辑

题解代码：

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<algorithm>
#include<set>
#include<sstream>
#include<map>
using namespace std;
#define INF 0x3f3f3f3f
const int maxn=1e2+5;
int gcd(int a,int b){//最大公约数
    return b?gcd(b,a%b):a;
}
bool dp[maxn][10000]={0};//i代表笼子的种类 j代表包子数量 0代表不能装 1代表可以装 用的是布尔数组
int arr[maxn];//笼子容量
int n;
int main(){
    cin>>n;
    int d=0;//用来记录最大公约数 初始化为0 0和任何数的最大公约数都为那个数
    for(int i=1;i<=n;++i){
        cin>>arr[i];
        d=gcd(d,arr[i]);//每次都计算一次最大公约数 就可以得到所有数字的最大公约数
    }
    if(d!=1){//由于包子数只能是最大公约数的倍数 所有gcd！=1的话 一定有无数个包子不能完成
        cout<<"INF";
        return 0;
    }
    dp[0][0]=1;//初始化 包子为空的时候一定可以
    for(int i=1;i<=n;++i)//外层遍历物品
    {
        for(int j=0;j<=10000;++j){//j从0开始 先更新到dp[1][0]=dp[0][0] 然后放一个东西就可以从dp[1][0]开始更新 dp[1][arr[1]]=dp[1][arr[0]]
            dp[i][j]=dp[i-1][j]||(j>=arr[i]?dp[i][j-arr[i]]:false);//要保证j`arr[i]有意义
        }
    }
    int ans=0;
    for(int i=1;i<=10000;++i){
        if(!dp[n][i])
            ans++;//n种笼都用上 包子数完不成 则dp=0 统计 ans加1
    }
    cout<<ans;
    
    return 0;
}

代码具体说明：

变量

INF 是一个很大的数，表示无穷大。
maxn 定义了笼子种类的最大值为 105。
dp[i][j] 表示前 i 种笼子能否组成恰好 j 个包子。
arr[i] 存储第 i 种笼子的容量。
n 表示笼子的总数。
主函数
输入笼子的数量 n 和每种笼子的容量 arr[i]。
计算所有笼子容量的最大公约数 d。
如果 d != 1，则说明无法凑出所有数量的包子，因为包子的数量必须是最大公约数的倍数，此时输出 "INF"。
否则，使用动态规划填充 dp 数组：
- dp[0][0] = true：初始状态，零个包子是可以组成的。
- 对于每个笼子 i，更新 dp[i][j]：如果不用当前笼子，则继承 dp[i-1][j]；如果用当前笼子，则检查 dp[i][j-arr[i]] 是否成立。
最后统计不能组成的包子数量 ans 并输出。
总结
这段代码的核心在于利用动态规划来判断哪些包子数量可以通过给定的笼子组合得到，并计算出无法组合得到的包子数量。关键点在于先通过 GCD 判断是否有可能存在无法组合的情况，然后再进行动态规划求解。