蓝桥杯C++ AB组辅导课第三讲数学与简单DP Acwing_1205. 买不到的数目题目提交记录讨论题解视频讲解小明开了一家糖果店。他-CSDN博客

本文链接：https://blog.csdn.net/m0_51448653/article/details/122787394

例题

AcWing 1205. 买不到的数目

小明开了一家糖果店。

他别出心裁：把水果糖包成4颗一包和7颗一包的两种。

糖果不能拆包卖。

小朋友来买糖的时候，他就用这两种包装来组合。

当然有些糖果数目是无法组合出来的，比如要买 10 颗糖。

你可以用计算机测试一下，在这种包装情况下，最大不能买到的数量是17。

大于17的任何数字都可以用4和7组合出来。

本题的要求就是在已知两个包装的数量时，求最大不能组合出的数字。

输入格式
两个正整数 n,m，表示每种包装中糖的颗数。

输出格式
一个正整数，表示最大不能买到的糖数。

数据范围

2≤n,m≤1000，

保证数据一定有解。

输入样例：

4 7

输出样例：

思路：

引理： $\forall a,b$ ，如果 $g c d (a, b) > 1$ ，那么不存在不能凑出的最大数
结论： $a, b$ 均为正整数且互质，那么由 $ax+by,x\geq0,y \geq0$ 不能凑出的最大数为 $a b - a - b$
证明 $a b - a - b$ 无法被 $\geq0,y \geq0$ 表示：反证法，假设 $a b - a - b = a x + b y$ ，那么 $a b = a (x + 1) + b (y + 1)$ ，由于 $a ∣ a b, a ∣ a (x + 1)$ ，因此 $a ∣ b (y + 1)$ ，由于a和b互质，因此， $a ∣ y + 1$ ，由于 $\geq0$ ，因此 $\geq a$ ，因此 $\geq ab$ ，同理， $\geq ab$ ，因此， $\geq 2ab \geq ab$ ，矛盾。
证明 $\geq1$ 一定可以表示成 $\geq0,y \geq 0$ 的形式：…

#include <iostream>
using namespace std;

int main()
{
    int a, b; cin >> a >> b;
    cout << a * b - a - b;
}

AcWing 1211. 蚂蚁感冒

长 100 厘米的细长直杆子上有 n 只蚂蚁。

它们的头有的朝左，有的朝右。

每只蚂蚁都只能沿着杆子向前爬，速度是 1 厘米/秒。

当两只蚂蚁碰面时，它们会同时掉头往相反的方向爬行。

这些蚂蚁中，有 1 只蚂蚁感冒了。

并且在和其它蚂蚁碰面时，会把感冒传染给碰到的蚂蚁。

请你计算，当所有蚂蚁都爬离杆子时，有多少只蚂蚁患上了感冒。

输入格式
第一行输入一个整数 n, 表示蚂蚁的总数。

接着的一行是 n 个用空格分开的整数 Xi, Xi 的绝对值表示蚂蚁离开杆子左边端点的距离。

正值表示头朝右，负值表示头朝左，数据中不会出现 0 值，也不会出现两只蚂蚁占用同一位置。

其中，第一个数据代表的蚂蚁感冒了。

输出格式
输出1个整数，表示最后感冒蚂蚁的数目。

数据范围

1<n<50,
0<|Xi|<100

输入样例1：

3
5 -2 8

输出样例1：

输入样例2：

5
-10 8 -20 12 25

输出样例2：

思路：

由于蚂蚁速度一致，且相撞都感冒，因此两只蚂蚁相撞后掉头可以理解为两只蚂蚁互相穿过了对方继续前进
因此，第一只蚂蚁如果向右前进，它右边所有向左的蚂蚁都会被感染，如果它右边有向左的蚂蚁，那么它左边所有向右的蚂蚁也会被感染；如果第一只蚂蚁向左前进，它左边所有向右的蚂蚁都会被感染，如果它左边有向右的蚂蚁，那么它右边所有向左的蚂蚁也会被感染
因此，无论第一只蚂蚁向左向右，都只要统计所有在它右边向左的 $r i g h t$ 和在它左边向右的 $l e f t$ ，然后 $a n s = r i g h t + l e f t + 1$

#include <iostream>
#include <math.h>
using namespace std;

int main()
{
    int n; cin >> n;
    
    int first, ans = 0, left = 0, right = 0;
    
    for (int i = 0, x; i < n && cin >> x; i ++ )
    {
        if (!i) first = x;
        if (abs(first) < abs(x) && x < 0) right ++ ;
        if (abs(first) > abs(x) && x > 0) left ++ ;
    }
    
    if (!(first > 0 && right) && !(first < 0 && left)) cout << 1;
    else cout << right + left + 1;
}

下列附上另一种模拟的做法
由于题目保证第0秒时没有两个蚂蚁在同一个位置，前进速度为1s，因此我们以0.5s为最小单位

#include <iostream>
#include <cstring>
using namespace std;
#define the_smallest_unit 0.5
int main()
{
    int ant_count;
    int i, j, k;
    double d[100] = { 0 };
    bool cold[100] = { 0,1 };
    int finish = 0, ans=1;
    cin >> ant_count;
    for (i = 1; i <= ant_count; i++)
    {
        cin >> d[i];
    }
    while (1)//不断循环直至结束
    {
        //不断遍历，要是蚂蚁全不在这个杆上，就说明已经结束了，要输出答案了
        finish = 0;
        for (i = 1; i <= ant_count; i++)//逐个遍历
            if (abs(d[i]) <= 0 || abs(d[i]) >= 100)//绝对值判断是否正在杆上
                finish++;//在就加一
        if (finish == ant_count)//达到目标退出
            break;
        //接下来挨个蚂蚁走路，以0.5为单位，达到0或是100就不必再走
        for (i = 1; i <= ant_count; i++)//走一单位
        {
            if (d[i] != 0 && d[i] != 100)
                d[i] += 0.5;
        }
        for (i = 1; i <= ant_count; i++)//进行相遇判断，每次选两个都在杆上的蚂蚁判定绝对值是否相等
        {
            if(d[i]!=0&&d[i]!=100)
                for (j = i + 1; j <= ant_count; j++)
                {
                    if (d[j] != 0 && d[j] != 100)
                    {
                        if (abs(d[j]) == abs(d[i]))//相遇就掉头，并且判断二者是否有一只蚂蚁得病，有就让另一只也病
                        {
                            d[j] = -d[j];
                            d[i] = -d[i];
                            if (cold[i] && !cold[j])
                            {
                                ans++;
                                cold[j] = 1;
                            }
                            if (cold[j] && !cold[i])
                            {
                                ans++;
                                cold[i] = 1;
                            }
                        }
                    }
                }
        }
    }
    cout << ans << endl;
    return 0;
}

AcWing 1216. 饮料换购

乐羊羊饮料厂正在举办一次促销优惠活动。乐羊羊C型饮料，凭3个瓶盖可以再换一瓶C型饮料，并且可以一直循环下去(但不允许暂借或赊账)。

请你计算一下，如果小明不浪费瓶盖，尽量地参加活动，那么，对于他初始买入的 n 瓶饮料，最后他一共能喝到多少瓶饮料。

输入格式
输入一个整数 n,表示初始买入的饮料数量。

输出格式
输出一个整数，表示一共能够喝到的饮料数量。

数据范围

0<n<10000

输入样例：

输出样例：

思路：

共喝饮料数 $r e s$ ，当前瓶盖数 $n$
赋值给n，且res=n
一直循环直到瓶盖n<3，每次res += n / 3，n变成了新的饮料/3加上剩下的n%3

#include <iostream>
#include <math.h>
using namespace std;

int main()
{
    int n; cin >> n;
    
    int res = n;
    
    while (n >= 3)
    {
        res += n / 3;
        n = n / 3 + n % 3;
    }
    
    cout << res;
}

AcWing 2. 01背包问题

有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。

第 i 件物品的体积是 vi，价值是 wi。

求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出最大价值。

输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。

接下来有 N 行，每行两个整数 vi,wi，用空格隔开，分别表示第 i 件物品的体积和价值。

输出格式
输出一个整数，表示最大价值。

数据范围
0<N,V≤1000
0<vi,wi≤1000
输入样例
4 5
1 2
2 4
3 4
4 5
输出样例：
8

#include <iostream>
using namespace std;

const int N = 1010;

int f[N];

int main()
{
    int n, m; cin >> n >> m;
    
    for (int i = 1; i <= n; i ++ )
    {
        int v, w; cin >> v >> w;
        for (int j = m; j >= v; j -- )
            f[j] = max(f[j], f[j - v] + w);
    }
    
    cout << f[m];
}

AcWing 1015. 摘花生

Hello Kitty想摘点花生送给她喜欢的米老鼠。

她来到一片有网格状道路的矩形花生地(如下图)，从西北角进去，东南角出来。

地里每个道路的交叉点上都有种着一株花生苗，上面有若干颗花生，经过一株花生苗就能摘走该它上面所有的花生。

Hello Kitty只能向东或向南走，不能向西或向北走。

问Hello Kitty最多能够摘到多少颗花生。

1.gif

输入格式
第一行是一个整数T，代表一共有多少组数据。

接下来是T组数据。

每组数据的第一行是两个整数，分别代表花生苗的行数R和列数 C。

每组数据的接下来R行数据，从北向南依次描述每行花生苗的情况。每行数据有C个整数，按从西向东的顺序描述了该行每株花生苗上的花生数目M。

输出格式
对每组输入数据，输出一行，内容为Hello Kitty能摘到得最多的花生颗数。

数据范围
1≤T≤100,
1≤R,C≤100,
0≤M≤1000
输入样例：
2
2 2
1 1
3 4
2 3
2 3 4
1 6 5
输出样例：
8
16

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

const int N = 110;

int w[N][N], f[N][N];

int main()
{
    int _; cin >> _;
    while (_ -- )
    {
        int n, m; cin >> n >> m;
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= m; j ++ )
                cin >> w[i][j];
        
        memset(f, 0, sizeof f);
        
        for (int i = 1; i <= n; i ++ )
            for (int j = 1; j <= m; j ++ )
                f[i][j] = max(f[i - 1][j], f[i][j - 1]) + w[i][j];
        
        cout << f[n][m] << endl;
    }
}

AcWing 895. 最长上升子序列

给定一个长度为 N 的数列，求数值严格单调递增的子序列的长度最长是多少。

输入格式
第一行包含整数 N。

第二行包含 N 个整数，表示完整序列。

输出格式
输出一个整数，表示最大长度。

数据范围
1≤N≤1000，
−109≤数列中的数≤109
输入样例：
7
3 1 2 1 8 5 6
输出样例：
4

#include <iostream>
using namespace std;

const int N = 1010;

int a[N], f[N];

int main()
{
    int n; cin >> n;
    
    for (int i = 1; i <= n && cin >> a[i]; i ++ );
    
    int res = 0;
    for (int i = 1; i <= n; i ++ )
    {
        f[i] = 1;
        for (int j = 1; j < i; j ++ )
            if (a[i] > a[j])
                f[i] = max(f[i], f[j] + 1);
        res = max(res, f[i]);
    }
    cout << res;
}

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

const int N = 1010;

int a[N], f[N];

int main()
{
    int n; cin >> n;
    for (int i = 1; i <= n && cin >> a[i]; i ++ );
    
//    memset(f, 1, sizeof f);   -> wrong
    for (int i = 1; i <= n; i ++ ) f[i] = 1;
    
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j < i; j ++ )
            if (a[i] > a[j])
                f[i] = max(f[i], f[j] + 1);
    
    int res = 0;
    for (int i = 1; i <= n; i ++ )
        res = max(res, f[i]);
    cout << res;
}

习题

AcWing 1212. 地宫取宝

X 国王有一个地宫宝库，是 n×m 个格子的矩阵，每个格子放一件宝贝，每个宝贝贴着价值标签。

地宫的入口在左上角，出口在右下角。

小明被带到地宫的入口，国王要求他只能向右或向下行走。

走过某个格子时，如果那个格子中的宝贝价值比小明手中任意宝贝价值都大，小明就可以拿起它（当然，也可以不拿）。

当小明走到出口时，如果他手中的宝贝恰好是 k 件，则这些宝贝就可以送给小明。

请你帮小明算一算，在给定的局面下，他有多少种不同的行动方案能获得这 k 件宝贝。

输入格式
第一行 3 个整数，n,m,k，含义见题目描述。

接下来 n 行，每行有 m 个整数 Ci 用来描述宝库矩阵每个格子的宝贝价值。

输出格式
输出一个整数，表示正好取 k 个宝贝的行动方案数。

该数字可能很大，输出它对 1000000007 取模的结果。

数据范围
1≤n,m≤50,
1≤k≤12,
0≤Ci≤12
输入样例1：
2 2 2
1 2
2 1
输出样例1：
2
输入样例2：
2 3 2
1 2 3
2 1 5
输出样例2：
14

思路：

由“如果那个格子中的宝贝价值比小明手中任意宝贝价值都大，小明就可以拿起它“得出性质：后面拿的价值比前面拿的大，严格单调递增，因此只需要记录当前拿的最大值

在这里插入图片描述

采用集合的思想考虑dp问题
$f [i] [j] [c n t] [k]$ 表示当前在(i,j)这个点，已经拿了cnt个物品，且这些物品中最大的价值为k 的方案数
容易想到将其划分为两个集合，一个是在(i,j)选了，一个是在(i,j)没有选
对于没有选， $f [i] [j] [c n t] [k] + = f [i - 1] [j] [c n t] [k] + f [i] [j - 1] [c n t] [k]$
对于选了，这种方案不一定存在，必须满足 $k = = a [i] [j]$ ，若满足则有 $f [i] [j] [c n t] [k] + = f [i - 1] [j] [c n t - 1] [1 - (k - 1)] + f [i] [j - 1] [c n t - 1] [1 - (k - 1)]$
以上两个式子在计算时先不考虑%，后面加上
最后将在终点处所有拿了所需个数的方案累加
注意初始化两种可行为1
这道题还有一个特殊的地方，那就是 物品的价值可能为0，但这不代表没有取这个物品！因此我们给每个物品价值偏移量加一，由于这道题是求方案数，且物品间相互大小没有变化，页不影响取的个数，因此不影响结果

#include <iostream>
using namespace std;

const int N = 55, M = 15;
const int mod = 1000000007;

int w[N][N];
int f[N][N][M][M];

int main()
{
    int n, m, k; cin >> n >> m >> k;
    
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
        {
            cin >> w[i][j];
            w[i][j] ++ ;
        }
    
    f[1][1][0][0] = 1;
    f[1][1][1][w[1][1]] = 1;
    
    for (int i = 1; i <= n; i ++ )
        for (int j = 1; j <= m; j ++ )
        {
            for (int cnt = 0; cnt <= k; cnt ++ )
            {
                for (int mx = 0; mx <= 13; mx ++ )
                {
                    f[i][j][cnt][mx] = (f[i][j][cnt][mx] + f[i - 1][j][cnt][mx]) % mod;
                    f[i][j][cnt][mx] = (f[i][j][cnt][mx] + f[i][j - 1][cnt][mx]) % mod;
                    
                    if (cnt >= 1 && mx == w[i][j])
                    {
                        for (int mxx = 0; mxx < mx; mxx ++ )
                        {
                            f[i][j][cnt][mx] = (f[i][j][cnt][mx] + f[i - 1][j][cnt - 1][mxx]) % mod;
                            f[i][j][cnt][mx] = (f[i][j][cnt][mx] + f[i][j - 1][cnt - 1][mxx]) % mod;
                        }
                    }
                }
            }
        }
    
    int res = 0;
    for (int mx = 0; mx <= 13; mx ++ )
        res = (res + f[n][m][k][mx]) % mod;
    cout << res;
}

AcWing 1214. 波动数列

观察这个数列：

1 3 0 2 -1 1 -2 …

这个数列中后一项总是比前一项增加2或者减少3，且每一项都为整数。

栋栋对这种数列很好奇，他想知道长度为 n 和为 s 而且后一项总是比前一项增加 a 或者减少 b 的整数数列可能有多少种呢？

输入格式
共一行，包含四个整数 n,s,a,b，含义如前面所述。

输出格式
共一行，包含一个整数，表示满足条件的方案数。

由于这个数很大，请输出方案数除以 100000007 的余数。

数据范围
1≤n≤1000,
−109≤s≤109,
1≤a,b≤106
输入样例：
4 10 2 3
输出样例：
2
样例解释
两个满足条件的数列分别是2 4 1 3和7 4 1 -2。

思路：

假设第一个数为x，那么第二个数为 $x+d_1$ ，第三个数为 $x+d_1+d_2$ ，第四个数为 $x+d_1+d_2+d_3,...,x+d_1+...+d_{n-1}$ ，这里 $d_1,d_2$ 为 a 或者 -b
则数列之和 $x+(x+d_1)+(x+d_1+d_2)+...=nx+(n-1)d_1+(n-2)d_2+...+d_{n-1}=s$
则有 $x=\frac{s-((n-1)d_1+(n-2)d_2+...+d_{n-1})}{n}$ ，由于x为整数，所以分母%n一定为零，可以推出 $s$ %n== $n-1)d_1+(n-2)d_2+...+d_{n-1})$ %n，又由于s是确定的，求这个式子的方案数是多少，
状态表示： $f [i] [j]$ 表示所有只考虑前i项，且当前的d总和除以n的余数是j的方案数
明确目标：最后求得的是 $f [n - 1] [s$ % $n]$ 的值
递推关系：第i次选择时可以选+a也可以选-b；如果选+a，前i个数的和为 $n-1)d_1+(n-2)d_2+...+(n-i+1)d_{i-1}+(n-i)a] \mod n=j \mod n$ ，也就是 $[(n-1)d_1+(n-2)d_2+...+(n-i+1)d_{i-1} \equiv j - (n-i)a$ ，因为 $f [i] [j]$ 表示的是方案数，其中 $j - (n - i) a$ 是确定值，所以 $f [i] [j] = f [i - 1] [j - (n - i) a]$ ；同理，如果选-b， $f [i] [j] = f [i - 1] [j + (n - i) b]$ ，因此， $f [i] [j] = f [i - 1] [j - (n - i) a] + f [i - 1] [j + (n - i) b]$
易错点1:这里是1e8+7不是1e9+7
易错点2:使用get_mod函数，因为有涉及到模的运算且可能出现负数
易错点3:这里dp函数状态表示的第二维表示 余数，因此仍然要取余！且由于易错点2，因此用get_mod函数

#include <iostream>
using namespace std;

const int N = 1010, MOD = 1e8 + 7;

int n, s, a, b;
int f[N][N];

int get_mod(int a, int b)
{
    return (a % b + b) % b;
}

int main()
{
    cin >> n >> s >> a >> b;
    
    f[0][0] = 1;
    
    for (int i = 1; i <= n - 1; i ++ )
        for (int j = 0; j < n; j ++ )
        {
            f[i][j] = (f[i - 1][get_mod(j - (n - i) * a, n)] + f[i - 1][get_mod(j + (n - i) * b, n)]) % MOD;
        }
    
    cout << f[n - 1][get_mod(s, n)];
}