数学与简单DP

---

买不到的数目

小明开了一家糖果店。

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

糖果不能拆包卖。

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

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

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

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

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

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

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

数据范围
2 ≤ n,m ≤ 1000，
保证数据一定有解。

输入样例：

4 7

输出样例：

17

打表找规律

结论：
如果 a,b 均是正整数且互质，那么由 ax + by, x ≥ 0,y ≥ 0 不能凑出的最大数是 ab−a−b。

下面给出证明：

首先证明 ab−a−b 不能被 ax+bx,x≥0,y≥0表示出。
反正法，假设 ab−a−b=ax+by，那么 ab=a(x+1)+b(y+1)，由于 a|ab,a|a(x+1)，所以 a|b(y+1)，由于 a,b 互质，所以 a|(y+1)，由于 y≥0，所以 a<=y+1，所以 b(y+1)≥ab。同理可得 a(x+1)≥ab，所以 a(x+1)+b(y+1)≥2ab>ab，矛盾。

证明 ab−a−b+d,d>0 一定可以表示成 ax+by,x,y≥0 的形式，可以参考这篇博客。

// 暴力搜索
#include <iostream>
using namespace std;
bool dfs(int m, int a, int b)
{
	if (m == 0) return true;
	if (m >= a && dfs(m - a, a, b)) return true;
	if (m >= b && dfs(m - b, a, b)) return true;
	return false;
}
int main()
{
	int n, m;
	cin >> n >> m;
	int res;
	for (int i = 2; i <= 10000; i ++ )
		if (!dfs(i, n, m))
			res = i;
	cout << res << endl; 
	return 0;
}

// 规律做法
#include <iostream>
#include <cmath>
using namespace std;
int main()
{
	int n, m;
	cin >> n >> m;
	cout << (n - 1) * (m - 1) - 1  << endl;
	return 0;
}

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

typedef long long LL;

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

    return 0;
}

笔记、代码学习：
作者：yxc
链接：https://www.acwing.com/solution/acwing/content/3165/
来源：AcWing

---

蚂蚁感冒

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

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

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

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

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

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

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

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

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

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

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

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

数据范围
1 < n < 50,
0 < |X_i| < 100

输入样例1：

3
5 -2 8

输出样例1：

1

输入样例2：

5
-10 8 -20 12 25

输出样例2：

3

1. 两只蚂蚁相撞掉头可以看作时一只蚂蚁穿过了另一只蚂蚁
2. left 表示左边蚂蚁向右走的数量，right 表示右边蚂蚁向左走的数量

以第一个蚂蚁向右走为例，向左走同理。

#include <iostream>
#include <cmath>
using namespace std;
const int N = 60;
int n;
int a[N];
int main()
{
	cin >> n;
	for (int i = 0; i < n; i ++ ) cin >> a[i];
	int left = 0, right = 0;
	for (int i = 0; i < n; i ++ ) 
		if (abs(a[i]) < abs(a[0]) && a[i] > 0) left ++ ;
		else if (abs(a[i]) > abs(a[0]) && a[i] < 0) right ++ ;
	if (a[0] > 0 && right > 0 || a[0] < 0 && left > 0) cout << left + right + 1 << endl;
	else cout << '1' << endl;
	return 0;
}

---

饮料换购

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

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

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

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

数据范围
0 < n < 10000

输入样例：

100

输出样例：

149

// 暴力搜索
#include <iostream>
using namespace std;
void dfs(int a, int b, int c) // a喝过的瓶子数量 b瓶盖数量 c未喝的数量/下一次需要喝的数量/上一次瓶盖对换的数量 
{
	if (b != 0 && c + b < 3) {
		cout << a + c << endl;
		return;	
	} 
	dfs(a + c, b % 3 + c, b / 3);
}
int main()
{
	int n;
	cin >> n;
	dfs(0, 0, n);
	return 0;
} 

#include <iostream>
using namespace std;
int main()
{
	int n, res = 0; // 盖 瓶 
	cin >> n;
	res = n;
	while (n >= 3) {
		res += n / 3;
		n = n / 3 + n % 3;
	}
	cout << res << endl;
	return 0;
}

---

01背包问题

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

第 i 件物品的体积是 v_i，价值是 w_i。

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

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

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

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

数据范围
0 < N,V ≤ 1000
0 < v_i,w_i ≤ 1000

输入样例

4 5
1 2
2 4
3 4
4 5

输出样例：

8

来自深蓝大佬的优质题解

#include <iostream>
using namespace std;
const int N = 1010;
int n, m;
int v[N], w[N];
int f[N][N]; 
int main()
{
	cin >> n >> m;
	for (int i = 1; i <= n; i ++ ) cin >> v[i] >> w[i];
	for (int i = 1; i <= n; i ++ )
		for (int j = 1; j <= m; j ++ ) 
		{
//			f[i][j] = f[i - 1][j];
//			if (j >= v[i]) f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]] + w[i]);
			if (j < v[i]) f[i][j] = f[i - 1][j];
			else f[i][j] = max(f[i - 1][j], f[i - 1][j - v[i]] + w[i]);	
		}
	cout << f[n][m];
	return 0;
}

---

摘花生

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

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

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

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

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

输入格式
第一行是一个整数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

空间压缩
f[i][j]只需要用到这一层和上一层的f元素，所以可以压缩成滚动数组。在此之上，还可以直接压缩成一维数组。

#include <iostream>
using namespace std;
const int N = 110;
int n[N][N];
int main()
{
	int t;
	cin >> t;
	while (t -- )
	{
		int a, b;
		cin >> a >> b;
		for (int i = 1; i <= a; i ++ )
			for (int j = 1; j <= b; j ++ )
			{
				cin >> n[i][j];
				n[i][j] += max(n[i - 1][j], n[i][j - 1]);
			}
		cout << n[a][b] << endl;
	}
	return 0;
} 

算法1：DP 空间复杂度O(n²)

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 110;

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

int main()
{
    int T;
    cin >> T;
    while (T -- )
    {
        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;
    }

    return 0;
}

算法2：DP + 滚动数组 空间复杂度O(n)

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

const int N = 105;
int a[2][N], f[2][N], q, n, m;

int main()
{
    cin >> q;
    while(q--){
        cin >> n >> m;

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

        memset(f, 0, sizeof f);
    }
}

算法3：DP 一维版 空间复杂度O(n)

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

const int N = 105;
int a[N][N], f[N], q, n, m;

int main()
{
    cin >> q;
    while(q--){
        cin >> n >> m;

        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                cin >> a[i][j];
            }
        }

        for(int i = 1; i <= n; i++){
            for(int j = 1; j <= m; j++){
                f[j] = max(f[j], f[j-1]) + a[i][j];
            }
        }
        cout << f[m] << endl;

        // 由于多组样例，而二维数组解法由于f[0][...]和f[...][0]都为0，所以没有问题。对于一维数组，上一样例的f数组需要清零，否则影响结果
        memset(f, 0, sizeof f);
    }
}

算法4：DP 记忆化搜索

#include <iostream>
#include <cstring>

using namespace std;

const int N = 110, INF = 0x3f3f3f3f;

int T;
int n, m;
int w[N][N];
int f[N][N];

int dp(int x, int y)
{
    if (f[x][y] >= 0) return f[x][y];
    if (x < 1 || x > n || y < 1 || y > m) return f[x][y] = -INF;
    if (x == 1 && y == 1) return f[x][y] = w[x][y];

    int t = 0;
    t = max(t, dp(x - 1, y) + w[x][y]);
    t = max(t, dp(x, y - 1) + w[x][y]);
    return f[x][y] = t;
}
int main()
{
    cin >> T;
    while (T -- )
    {
        memset(w, 0, sizeof w);
        memset(f, -1, sizeof f);
        cin >> n >> m;

        for (int i = 1; i <= n; ++ i)
        {
            for (int j = 1; j <= m; ++ j)
            {
                cin >> w[i][j];
            }
        }
        cout << dp(n, m) << endl;
    }
    return 0;
}

笔记、代码学习：
作者：dasongshu
链接：https://www.acwing.com/solution/content/8422/
来源：AcWing
作者：彩色铅笔
链接：https://www.acwing.com/solution/content/49332/
来源：AcWing

---

最长上升子序列

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

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

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

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

数据范围
1 ≤ N ≤ 1000，
−10⁹ ≤ 数列中的数 ≤ 10⁹

输入样例：

7
3 1 2 1 8 5 6

输出样例：

4

#include <iostream>
using namespace std;
const int N = 1010;
int n, res = 0;
int a[N];
int f[N]; // 以第i个数字结尾的最长上升子序列的最大长度 
int main()
{
	cin >> n;
	for (int i = 1; i <= n; i ++ ) cin >> a[i];	
	for (int i = 1; i <= n; i ++ ) // 结尾数字 
	{
		f[i] = 1;
		for (int j = 1; j < i; j ++ ) // 最后一个不同点：倒数第二个数字 
			if (a[j] < a[i]) 
				f[i] = max(f[i], f[j] + 1);
		res = max(f[i], res);	
	}	
	cout << res << endl;
	return 0;
}

---

地宫取宝

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

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

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

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

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

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

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

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

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

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

数据范围
1 ≤ n,m ≤ 50,
1 ≤ k ≤ 12,
0 ≤ C_i ≤ 12

输入样例1：

2 2 2
1 2
2 1

输出样例1：

2

输入样例2：

2 3 2
1 2 3
2 1 5

输出样例2：

14

#include <iostream>
using namespace std;
const int N = 55, M = 13, MOD = 1000000007; 
int n, m, k;
int a[N][N];
int f[N][N][M][14]; // 走到(i,j)，拿了k个物品，最后一个最大价值 的方案数 
 
int main()
{
	cin >> n >> m >> k;
	for (int i = 1; i <= n; i ++ )
		for (int j = 1; j <= m; j ++ )
		{
			cin >> a[i][j];
			// 物品价值可能为0 原价值范围(-1~12) 但在数组中不选物品价值为0 导致不可以选择价值为0的物品 
			a[i][j] ++ ;  
			// 物品价值全部加1 范围变为(0~13) 最小价值变为1 0变为边界条件，表示没有选择物品 
		}	
	f[1][1][1][a[1][1]] = 1;
	f[1][1][0][0] = 1;
	for (int i = 1; i <= n; i ++ )
		for (int j = 1; j <= m; j ++ ) 
		{
			if (i == 1 && j == 1) continue;
			for (int cnt = 0; cnt <= k; cnt ++ )
				for (int v = 0; v <= M; v ++ )
				{
					int &val = f[i][j][cnt][v];
					// 不选当前物品 
					val = (val + f[i - 1][j][cnt][v]) % MOD;
					val = (val + f[i][j - 1][cnt][v]) % MOD;
					// 选当前物品 
					if (cnt > 0 && v == a[i][j])
					{
						for (int c = 0; c < v; c ++ )
						{
							val = (val + f[i - 1][j][cnt - 1][c]) % MOD;
							val = (val + f[i][j - 1][cnt - 1][c]) % MOD;
						}
					}
				}
		}
	int res = 0;
	for (int i = 0; i <= M; i ++ ) res = (res + f[n][m][k][i]) % MOD;
	cout << res << endl;
	return 0;
} 

---

波动数列

观察这个数列：

1 3 0 2 -1 1 -2 …

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

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

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

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

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

数据范围
1 ≤ n ≤ 1000,
−10⁹ ≤ s ≤ 10⁹,
1 ≤ a,b ≤ 10⁶

输入样例：

4 10 2 3

输出样例：

2

样例解释
两个满足条件的数列分别是2 4 1 3和7 4 1 -2。

没懂

#include <iostream>
using namespace std;
const int N = 1010, M = 100000007; 
int n, s, a, b;
int f[N][N]; // 前i个数 余数为j 的方案数 
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; i ++ )
		for (int j = 0; j < n; j ++ )
			f[i][j] = (f[i - 1][get_mod(j - a * (n - i), n)] + f[i - 1][get_mod(j + b * (n - i), n)]) % MOD;
	cout << f[n - 1][get_mod(s, n)] << endl;
	return 0;
} 

---