算法训练题解

（注：使用VS2022时，可以将main函数变成main1、main2等，这样源文件就不会执行该main函数，之后再通过“播放图标”统一进行注释）

A: 题目要求输入a、b、c三个数，进行5次挑选一个数自增的操作，得出5次操作后能得到的a*b*c的最大值

根据简单的数据示例运算（如1、2、3，1、2、2，1、5、9），当自增的数为其中的最小值时，得出的乘积结果最大，因此重复找到最小值并自增的操作5次，相乘后就是正确答案

#include<iostream>
using namespace std;

int main() {
	int a, b, c, t, index;
	cin >> t;
	while (t--)
	{
		cin >> a >> b >> c;
		int temp = 5;
		while (temp--) {
			//冒泡排序，给最前面的数字++(把最小的推到最前面就行，不用排完)
			if (b > c) { index = b; b = c; c = index; }
			if (a > b) { index = a; a = b; b = index; }
			a++;
		}
		cout << a * b * c << endl;
	}

	return 0;
}

B: 题目要求动态规划，让小孩在规定的容量大小（这里是时间）装入药材，使价值最高（不一定体积大就价格高、性价比高）。

因为考虑到体积的余量可能会比贪心多贪的比值要更加影响总价值，所以不用贪心。

这里的动态规划需要用到01背包的状态转移方程f[i][j] = max(f[i - 1][j], f[i - 1][j - w[i]] + v[j])

（注：max函数在包含iostream类时就能用）

i代表对i件物体做决策，有两种方式—放入背包和不放入背包。
j表示当前背包剩余的容量。

1. 也就是要开辟一个f[M][T]大小的二维数组 

2. 在容量符合要求时，对每一种容量进行数据的最大值更新

3. 依据公式，和填表的规律，将会在j = T处产生最大值

（因为更新f[i][j]的依据是 t[i] <= j , j和j-t[i] 代表从上一次数据的第几个更新下一行数据（也就是哪个位置存储的背包容量属于有空间））

以下是一个示范填表数据的代码

#include<iostream>
using namespace std;

int main()
{
	//数据导入，t[]和v[]存储单体时间和价值
	int T, M, t[105], v[105];
	cin >> T >> M;
	for (int i = 1; i <= M; i++) {
		cin >> t[i] >> v[i];
	}

	//动态规划，对f[i - 1]进行优化
	int f[101][1001] = {0}, i, j;
	for (i = 1; i <= M; i++) {

		//这是一个填表的过程
		for (j = T; j >= 0; j--) {
			if (t[i] <= j) {
				//更新每一种容量下的最大数据
				f[i][j] = max(f[i - 1][j], f[i - 1][j - t[i]] + v[i]);
			}
			else
			{
				f[i][j] = f[i - 1][j];
			}
		}

	}
	
	//题目要求输出最后得出的最大价值
	cout << f[M][T] << endl;
	for (i = 1; i <= M; i++) {
		cout << endl;
		for (j = 1; j <= T; j++) {
			cout << f[i][j] << " ";
		}
	}
	return 0;
}

C: 奶牛晒衣服

由于1≤wi​,a,b,n≤5×105的数据量，需要使用一些快速的算法，这里采用二分法来进行贪心求解。二分就是不断取中，贪心就是找出一个正确答案还不够，多次改变数值模拟直到最好。C++的sort函数将会根据传入的数据自动选择最快的排序方法进行排序。

错误示范1：

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

int n, a, b, w[50005]; //题目给出数据

bool bask(int ans) {
	int temp = ans * a;
	if (temp >= w[n]) return true;

	if ((w[n] - temp) <= ans * b) {
		return true;
	}

	return false;
}

int main()
{
	//输入题目要求的数据
	cin >> n >> a >> b;
	for (int i = 1; i <= n; i++) {
		cin >> w[i];
	}

	//进行一个排序
	sort(w + 1, w + n);

	//对排序后的数据进行二分
	int l = 1, r = w[n], ans;
	while (l <= r)
	{
		ans = (l + r) / 2;
		if (bask(ans))
			r = ans - 1;
		else
			r = ans + 1;
	}

	cout << ans;
	return 0;
}

//贪的方法
//1. 用假设的 ans 计算是否能自然烘干
//ans * a > w[n]    --->     return true
//2. 没有自然烘干，计算相同的天数能不能烘干剩下的
// (w[n] - ans * a) > ans * b//(a + b)
//3. 烘干了return ture继续贪，没有烘干return false不贪了

代码的错误应该在于理所当然的进行全部衣服一起的烘干，而且错误的将w[n]认为是总和。

另外这里对l的操作写成了对r的操作

错误模型2 

int check(int ans)//ans代表此时我们预测的天数
{
	int sum = 0;//烘干机所用的天数
	for (int i = 1; i <= n; i++)
	{
		if (w[i] > ans * a)//衣服没能自己风干
		{
			sum += ceil((w[i] - ans * a) * 1.0 / b);//烘干机所用天数（向上取整）	
		}
	}
	if (sum > ans) return 0;//此方案不行，回去汇报吧，十天搞不完，宽限些十二天咋样
	return 1;
}

// 如何模拟烘干（并计算天数是否符合要求）
// 1. 计算出是否能自然烘干
// if (ans * a > w[i]) coutinue;
// 2. 将w[i]不能自然风干的湿度减出来，看看要用几秒烘衣机
// else { sum += w[i]/b , if(w[i]%b) sum+=1;} 
// ( 注：不一定整除，而且0.00001就算1秒) 

最后计算出的数值ans总是会大1； 

(注：是排序sort(w + 1, w + n +1)，不是是排序sort(w + 1, w + n))

这是依据模型2所写出的代码

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

int n, a, b, w[50005]; //题目给出数据,n是衣服数量,a是自然风干

bool bask(int ans) {
	int sum = 0;
	for (int i = 1; i <= n; i++) { //进行一个烘干的模拟
		if (ans * a >= w[i]) continue;
		else {
			sum += w[i] / b;
			if (w[i] % b) sum += 1;
		}
	}
	if (sum <= ans) return true;
	return false;
}

int main()
{
	//输入题目要求的数据
	cin >> n >> a >> b;
	for (int i = 1; i <= n; i++) {
		cin >> w[i];
	}

	//进行一个排序
	sort(w + 1, w + n + 1);

	//对排序后的数据进行二分（二分+贪心的基本模型）
	int l = 1, r = w[n], ans = 99, mid, res = 0;
	while (l <= r)
	{
		ans = (l + r) >> 1;
		if (bask(ans)) {
			//if (check(ans)) {
			r = ans - 1;
			res = ans;
		}
		else
			l = ans + 1;
	}

	cout << res - 1;
	return 0;
}

// 如何模拟烘干（并计算天数是否符合要求）
// 1. 计算出是否能自然烘干
// if (ans * a > w[i]) coutinue;
// 2. 将w[i]不能自然风干的湿度减出来，看看要用几秒烘衣机
// else { sum += w[i]/b , if(w[i]%b) sum+=1;} 
// ( 注：不一定整除，而且0.00001就算1秒) 

当正确答案到93，数据量为1000时，它的结果是 99。所以误差尽量还是不要有。

根据检验，是如下两行代码出了问题

//sum += w[i] / b;
//if (w[i] % b) sum += 1;

 应该改为

sum += (w[i] - ans*a) / b;
if (w[i] % b) sum += 1;

或

	//sum += ceil((w[i] - ans * a) * 1.0 / b);

 总之错误原因为没有减去已经被自然风干的湿度，导致重复计算

最终代码（因为数组开小了又错了1次...）

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

int n, a, b, w[500005]; //题目给出数据,n是衣服数量,a是自然风干

bool bask(int ans) {
	int sum = 0;
	for (int i = 1; i <= n; i++) { //进行一个烘干的模拟
		if (ans * a >= w[i]) continue;
		else {
			//sum += (w[i] - ans*a) / b;
			//if (w[i] % b) sum += 1;
			sum += ceil((w[i] - ans * a) * 1.0 / b);
		}
	}
	if (sum <= ans) return true;
	return false;
}

int main()
{
	//输入题目要求的数据
	cin >> n >> a >> b;
	for (int i = 1; i <= n; i++) {
		cin >> w[i];
	}

	//进行一个排序
	sort(w + 1, w + n + 1);

	//对排序后的数据进行二分（二分+贪心的基本模型）
	int l = 1, r = w[n], ans = 99, mid, res = 0;
	while (l <= r)
	{
		ans = (l + r) >> 1;
		if (bask(ans)) {
			r = ans - 1;
			res = ans;
		}
		else
			l = ans + 1;
	}

	cout << res;
	return 0;
}

E: 题目的要求是多段不等长木棍，取最大值l，要求满足最后截取的段数要大于k

首先是模拟的思路，由大到小，取出l，直到合适为止。

取的思路就是首先sum / k，获得一个可能的最大l，截取观察是否满足段数达到k。

没有达到则找到余数最大的那一段，将它多取一段的值用来更新l，即 l = L[i]/（thisk+1）

#include<iostream>
using namespace std;

int main()
{
	int n, k, l, * array, sum = 0;  //n是木棍数，k是要切割的段数, l是一次或多次更新获得的结果
	cin >> n >> k;          
	array = new int[n + 1];

	for (int i = 1; i <= n; i++) {
		cin >> array[i];    //记录n个数据
		sum += array[i];
	}
	l = sum / k; //这样给出的是特殊情况，也是最大情况

	int resk, numk, numl, num;
	while (true)
	{
		if (sum < k) {
			cout << 0;
			break;
		}
		int temp, tempk;
		resk = 0, num = -1;
		for (int i = 1; i <= n; i++) {
			tempk = array[i] / l;
			resk += tempk;


			temp = array[i] % l;

			if (temp >= num ) {//&& tempk > 0) {
				numk = tempk;
				numl = array[i];
				num = temp;
			}
		}

		if (resk >= k) {
			cout << l;
			break;
		}
		else {
			l = numl / (numk + 1);
		}
	}
}

如果这样写的话，l < 1需要作为特殊的情况写出来，也就是木头长度总和还没有k大时，需要直接输出0。而且在最后数据量非常大时，虽然不爆栈也不超时但是结果依旧不正确。

接下来是正确的解法，二分法，从l = 0 开始往上找

#include<iostream>
using namespace std;

int main()
{
	int n, k, L[100001];
	cin >> n >> k;
	for (int i = 0; i < n; i++){
		cin >> L[i];
	}

	int l = 0, high = 100000001, temp;

	while (l + 1 < high)
	{
		int mid = (l + high) / 2;
		
		temp = 0;
		for (int i = 0; i < n; i++) {
			temp += L[i] / mid;
		}
		if (temp >= k) l = mid;
		else high = mid;
	}

	cout << l;

	return 0;
}

首先写一个最简单的二分模型，找出l = mid，由于二分查找跨度大，非常可能 l = mid取的太小了，所以扔回循环再取，直到刚刚好。

该题采用从下(0)往上(100000001)找的思路，因此将 l 作为 low = 0 使用，设 high = 100000001，设 mid 作为中点更新 l 和 high 。

———————————————————————————————————————————

———————————————————————————————————————————

D: 进击的奶牛

叕是贪心+二分，二分模型只要是正确的就行，l 和 r 的初始化只需要 l --- r 概括所有可能结果。

while (l <= r) {
	mid = (l + r) / 2;
	if (test(mid))
		l = mid + 1, ans = mid;
	else
		r = mid - 1;
}

然后在test里判断正不正确，正确了就再贪点，不正确就少贪点，直到 r < l 退出循环，一般就是正确答案，就是test(很多人都写check)函数里的判断模拟容易错，非常容易错。

以下是数据代码示例

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

int N, C, x[100005];

bool test(int res) {
	int sum = 1, last = x[1], temp;
	for (int i = 2; i <= N; i++) {
		temp = x[i] - last;

		if (temp >= res) {
			last = x[i];
			sum++;
		}
	}
	if (sum >= C) return true;
	return false;
}

int main()
{
	cin >> N >> C;
	for (int i = 1; i <= N; i++) {
		cin >> x[i];
	}
	sort(x + 1, x + N + 1);//排序方便贪心模拟

	int l = 1, r = x[N] - x[1], mid, ans = 0;
	while (l <= r) {
		mid = (l + r) / 2;
		if (test(mid))
			l = mid + 1, ans = mid;
		else
			r = mid - 1;
	}

	cout << l << " " << ans << " " << r << endl;
	//cout << l;
	//cout << ans;
	//cout << r;

	return 0;
}
//数组最好还是开全局变量，传来传去麻烦
//如果需要用到不改变的地方就用局部

F: 砍树

请看错误代码

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

int N, M, x[100005];

bool test(int H) {
	int res = 0;
	for (int i = 1; i <= N; i++) {
		res += x[i] - H;
	}
	if (res >= M) return true;
	return false;
}

int main()
{
	cin >> N >> M;
	for (int i = 1; i <= N; i++) {
		cin >> x[i];
	}
	sort(x + 1, x + N + 1);//排序方便贪心模拟

	int l = 1, r = x[N], mid, H = 0;
	while (l <= r) {
		mid = (l + r) / 2;
		if (test(mid))
			l = mid + 1, H = mid;
		else
			r = mid - 1;
	}

	cout << H;

	return 0;
}

错误原因就是test模拟部分，当H大于树高时，会出现负数，导致结果变小

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

int N, M, x[100005];

bool test(int H) {
	int res = 0;
	for (int i = 1; i <= N; i++) {
		if (x[i] > H)
		{
			res += x[i] - H;
		}
	}
	if (res >= M) return true;
	return false;
}

int main()
{
	cin >> N >> M;
	for (int i = 1; i <= N; i++) {
		cin >> x[i];
	}
	sort(x + 1, x + N + 1);//排序方便贪心模拟

	int l = 1, r = x[N], mid, H = 0;
	while (l <= r) {
		mid = (l + r) / 2;
		if (test(mid))
			l = mid + 1, H = mid;
		else
			r = mid - 1;
	}

	cout << H;

	return 0;
}

换上限制条件就对了!......60分。。。。。。

数据范围不对，加大数值大小到了70

最后发现还是是数据范围不对，全部变成long long到了100.。。。。。

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

long long N, M, x[1000005];

bool test(int H) {
	long long res = 0;
	for (int i = 1; i <= N; i++) {
		if (x[i] > H)
		{
			res += x[i] - H;
		}
	}
	if (res >= M) return true;
	return false;
}

int main()
{
	cin >> N >> M;
	for (int i = 1; i <= N; i++) {
		cin >> x[i];
	}
	sort(x + 1, x + N + 1);//排序方便贪心模拟

	long long l = 1, r = x[N], mid, H = 0;
	while (l <= r) {
		mid = (l + r) / 2;
		if (test(mid))
			l = mid + 1, H = mid;
		else
			r = mid - 1;
	}

	cout << H;

	return 0;
}

G: 查并集

刚刚接触时，我认为它可能是链表、数组、树，或者几乎万用的图，然后

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

int N, M, a[10005][10005], flag[10005][10005];

void read() {
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			cout << a[i][j] << " ";
		}
		cout << endl;
	}
}

void method1(int x, int y) {
	a[x][y] = 1;
	a[y][x] = a[x][y];
}

//bool method2(int x, int y) {
//	//广度优先搜索
//	queue<int> q;
//	q.push(x);
//	flag[x][x] = 1;
//	while (!q.empty()) {
//		int temp = q.front();
//		q.pop();
//		for (int i = 1; i <= N; i++) {
//			if (flag[temp][i] == 0 && a[temp][i] == 1) {
//				if (i == y) {
//					return true;
//				}
//				flag[temp][i] = 1;
//				q.push(i);
//			}
//		}
//	}
//	return false;
//}

bool method2(int x, int y) {
	//广度优先搜索
	queue<int> q;
	q.push(x);
	flag[x][x] = 1;
	while (!q.empty()) {
		int temp = q.front();
		q.pop();
		for (int i = 1; i <= N; i++) {
			if (flag[temp][i] == 0 && a[temp][i] == 1) {
				if (i == y) {
					return true;
				}
				flag[temp][i] = 1;
				q.push(i);
			}
		}
	}
	return false;
}

void clear() {
	for (int i = 1; i <= N; i++) {
		for (int j = 1; j <= N; j++) {
			flag[i][j] = 0;
		}
	}
}

int main()
{
	cin >> N >> M;
	for (int i = 1; i <= N; i++) {
		a[i][i] = 1;
	}

	//read();

	int z, x, y;
	while (M--) 
	{
		cin >> z >> x >> y;
		if (z == 1) method1(x, y);
		else if (z == 2) {
			if (method2(x, y))cout << "Y" << endl;
			else cout << "N" << endl;
			clear();
		}
	}

	return 0;
}
//用tu的方法实现并查集
//如：
/*1 2 3 4  
1 1 0 0 0
2 0 1 0 0
3 0 0 1 0
4 0 0 0 1
----------
4 7
2 1 2
1 1 2
2 1 2
1 3 4
2 1 4
1 2 3
2 1 4
---------
/~1 2 3 4
1 1 1 0 0
2 1 1 1 0
3 0 1 1 1
4 0 0 1 1
*/
//错误原因在于flag数组没有及时清除

 

我还是第一次见MLE