刷题之路（第二周）（暴力枚举）

按照洛谷题单，这周打算刷一个暴力枚举XD

虽说是暴力枚举，该超时还是照样超时（汗~）

首先暴力枚举的一个做法就是用深搜的方式解决重复的操作

就像下面这个组合数题目一样

组合的输出 - 洛谷

这道题在不知道要重复多少次的情况下，有两种做法，一种就是因为此题给的n不大，可以把全部情况列出来，第二个就是正常的深搜逻辑。标记操作，恢复操作等都是dfs很重要的步骤，这里就放上我的代码：

#include<iostream>
#include<iomanip>
#include<algorithm>
using namespace std;
int a[105],b[105];
void dfs(int k,int m,int n) {//k代表当前层数，n表示最大层数
	if (k > n) {//大于最大层数时输出数组
		for (int i = 1; i <= n; i++) {
			cout << setw(3) << a[i];
		}
		cout << endl;
		return;
	}
	for (int i = 1; i <= m; i++) {
		if (b[i] == 0 && i > a[k - 1]) {
			a[k] = i;
			b[i] = 1;
			dfs(k + 1, m, n);
			b[i] = 0;
		}
	}
}
int main() {
	int n, m;
	cin >> m >> n;
	dfs(1, m, n);
	return 0;
}

随后就是一道跟全排列有关的题目，掌握了STL可以马上写出来，但本小白还没有学过这个，所以还是用的dfs做的，不过这题理解起来确实不容易，首先要知道的是全排列从小到大的排法，是先从后往前查看能够增加的数，即找到一个比它后面一位的数要小的数，然后从后往前搜索能够增加的数字，即比这个数要大的第一个数，调换之后，再将前面的那个数字的后面全部逆序，这个过程就是全排列i到i+1的过程

这也正好是对应此类题型的另外两种做法，即暴力运算和利用函数进行高效计算

题目如下

 [NOIP2004 普及组] 火星人 - 洛谷

#include<iostream>
#include<stdio.h>
#include<iomanip>
#include<algorithm>
using namespace std;
int a[1000005];
int m, n;
void myincrease(int m) {
	while (m--) {
		int i, j;
		for (i = n - 1; i >= 1; i--) {
			if (a[i] < a[i + 1]) {
				break;
			}
		}
		for (j = n; j >= i; j--) {
			if (a[j] > a[i]) {
				break;
			}
		}
		int t = a[j];
		a[j] = a[i];
		a[i] = t;
		++i;
		j = n;
		while (i < j) {
			t = a[i];
			a[i] = a[j];
			a[j] = t;
			i = i + 1;
			j = j - 1;
		}
	}
}
int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
	}
	myincrease(m);
	for (int i = 1; i <= n-1; i++) {
		cout << a[i] << " ";
	}
	cout << a[n];
	return 0;
}

当然啦，后来也学了手STL的做法，就是上述的操作其实靠一段函数就可以实现，即

#include<iostream>
#include<stdio.h>
#include<iomanip>
#include<algorithm>
using namespace std;
int a[1000005];
int m, n;
int main() {
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
	}
	for (int i = 1; i <= m; i++) {
		next_permutation(a + 1, a + 1 + n);
	}
	for (int i = 1; i <= n-1; i++) {
		cout << a[i] << " ";
	}
	cout << a[n];
	return 0;
}

血亏好吧~

接下来是站队问题，这题不算难，很容易就能想到深搜的逻辑，但是！但是这题我一直有两个报错点也不知道为什么，弄了我好久才发现，当队伍里只有一人时要进行特殊处理，因为算了两遍方法。真的是醉了~

First Step (ファーストステップ) - 洛谷

#include<iostream>
#include<stdio.h>
#include<iomanip>
#include<algorithm>
using namespace std;
char a[500][500];
int m, n, z;
int sum = 0;
void dfs(int i, int j, int k, int w) {
	if (k >= z) {
		++sum;
		return;
	}
	if (i<1 || j<1 || i>m || j>n)return;
	if (a[i + 1][j] == '.' && w == 1)dfs(i + 1, j, k + 1, 1);
	if (a[i][j + 1] == '.' && w == 2)dfs(i, j + 1, k + 1, 2);
	return;
}
int main() {
	cin >> m >> n >> z;//m行n列
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= n; j++) {
			cin >> a[i][j];
		}
	}
	for (int i = 1; i <= m; i++) {
		for (int j = 1; j <= n; j++) {
			if (a[i][j] == '.') {
				dfs(i, j, 1, 1);
				dfs(i, j, 1, 2);
			}
		}
	}
	if (z == 1)sum = sum / 2;
	cout << sum;
	return 0;
}

顺便一提，不需要还原操作的深搜真舒服，哈哈~

暴力枚举最大的问题还是在于像暴力枚举的题不能暴力枚举

例如[USACO1.5]回文质数 Prime Palindromes - 洛谷

本人自豪的暴力枚举结果只拿了66分，呜呜

原因是最后三个超时了

所以说，此方法慎用！慎用！

当然啦，如果你像我这样也没其他思路的话，自然还是要用这种方法搏一搏的啦~

此题用暴力枚举好像也是能做的，根据其他大佬的说法，在这个区间里符合条件的最大数为9989899

然后好像就不会超时了耶

总而言之，有其他方法还是用其他方法呀XD

接下来就是要一道很典型的技巧型枚举题

妖梦拼木棒 - 洛谷

然后呢，我最开始吧，花了五分钟写了个最为暴力的枚举

	sort(a + 1, a + 1 + n);
	for (int i = 1; i <= n - 1; i++) {
		if (a[i] == a[i + 1]) {
			for (int j = 1; j <= i; j++) {
				for (int k = 1; k <= i; k++) {
					if (a[j] + a[k] == a[i]) {
						sum++;
					}
				}
			}
		}
	}

 哈哈，果不其然

不出所料了可以说是

所以自然是要想怎么优化的，最明显的优化思路肯定是要减少循环的次数，那这时候用一个数组进行标记就要好得多。 而且不能用数组下标进行遍览，这样时间复杂度太高了。

#include<iostream>
#include<stdio.h>
#include<iomanip>
#include<algorithm>
#include<math.h>
using namespace std;
int m, n;
int a[1000000], b[1000000];
int mymin = 1e9, mymax = -1;
int k = 1e9 + 7;
int main() {
	int n;
	cin >> n;
	long long sum = 0;
	for (int i = 1; i <= n; i++) {
		cin >> a[i];
		mymin = min(mymin, a[i]);
		mymax = max(mymax, a[i]);
		b[a[i]]++;//这个长度出现的次数
	}
	for (int i = mymin + 1; i <= mymax; i++) {
		if (b[i] > 1) {//这个长度出现了两次及以上
			for (int j = mymin; j <= i / 2; j++) {
				if (b[i - j] >= 1 && b[j] >= 1) {//有这两个长度的木棍
					if (j == i - j && b[j] > 1) {
						sum = sum + ((b[i] * (b[i] - 1) >> 1) % k * (b[j] * (b[j] - 1) >> 1) % k) % k;
					}
					else if (j != i - j) {
						sum = sum + ((b[i] * (b[i] - 1) >> 1) % k * b[j] * b[i - j]) % k;
					}
					sum = sum % k;
				}
			}
		}
	}
	cout << sum;
	return 0;
}

这就是最后的代码啦，仅供参考XD

总结一下，暴力枚举的主要思路有深搜，打表，巧用枚举，STL等方法。那么，下次再见咯~

刷题记录

“蓝桥杯”练习系统

问题描述

　　给定一个1～N的排列a[i]，每次将相邻两个数相加，得到新序列，再对新序列重复这样的操作，显然每次得到的序列都比上一次的序列长度少1，最终只剩一个数字。
　　例如:
　　3 1 2 4
　　4 3 6
　　7 9
　　16
　　现在如果知道N和最后得到的数字sum，请求出最初序列a[i]，为1～N的一个排列。若有多种答案，则输出字典序最小的那一个。数据保证有解。

题目说n<10所以最多也只有10*9*8*7*6*5*4*3*2*1=3628800种排序，因此可以暴力枚举

#include<iostream>
#include<algorithm>
#include<queue>
#include<vector>
#include<string.h>
using namespace std;
typedef long long ll;
ll n,sum;
int main(){
	scanf("%lld %lld",&n,&sum);
	vector<int>a(n);
	for(int i=0;i<n;i++){
		a[i]=i+1;
	}
	do{
		vector<int>b=a;
		for(int i=1;i<=n-1;i++){
			for(int j=0;j<n-1-i+1;j++){
				b[j]=b[j]+b[j+1];
			}
		}
		if(b[0]==sum){
			for(int i=0;i<n;i++){
				printf("%d ",a[i]);
			}
			break;
		}
	}while(next_permutation(a.begin(),a.end()));
	return 0;
}