dfs 判重Sequence one——hdu 2610

努力算法的小明

已于 2024-10-05 12:05:34 修改

阅读量480

点赞数 16

文章标签：深度优先算法

于 2024-10-05 12:04:10 首次发布

本文链接：https://blog.csdn.net/2301_80093604/article/details/142712221

版权

前言

搜索算法判重

搜索算法判重有很多种方法，常见的有两种，map判重和set判重

#include<set>
#include<map>
using namespace std;

map判重

	string s;
	//map判重
	map<string, bool>mp;
	if (!mp[s]) {
		mp[s] = true;
		//dfs or bfs
	}

set判重

	string s;
	//set判重
	set<string>vis;
	if (vis.count(s) == 0) {
		vis.insert(s);
		//dfs or bfs
	}

但本题这两种判重都不是最佳

Sequence one

问题描述

给定一个序列，要求该序列前p个不递减的子序列，如果不足p个则输出所有

输入

有多个测试，每个测试第一行输入两个整数n,p,分别代表序列元素个数，以及要求输出个数，第二行输入n个整数

输出

对于每个测试输出前p个不递减的序列

数据范围

1<n<=1000 1<p<=10000 每个整数不大于 $2^{31}$

样例

问题分析

本题完全可以看作一个加了很多限制的全排列问题，先附上全排列代码

//默认大家都会哈，这个应该是最简单的dfs了
void dfs(int s, int t) {
	if (s == t) {
		for (int i = 0; i < t; i++) {
			cout << b[i] << " ";	
		}
		cout << endl;
		return;
	}
	for (int i = 0; i < t; i++) {
		if (!vis[i]) {
			vis[i] = true;
			b[s] = a[i];
			dfs(s + 1, t);
			vis[i] = false;
		}
	}
}

之后我们要做的就是对这段代码加上各种剪枝，使得它符合题目要求

重构dfs参数

我们先考虑如何选择dfs函数参数问题，本题要求输出的是子序列，那么输出长度就是需要变化的，我吗命名为sublen，那么至少还需要一个参数代表我们当前递归层已经拼好的子序列长度为多少，我们命名为now_len,之后就是题目要求求不递减的子序列，那么每拼好一个整数，应该是从下一个数字开始拼，那么我们还需要一个参数，表示当前位置，命名为now_pos。到此我们就已经搭建好了基本的代码框架

void dfs(int sublen, int now_len, int now_pos){

    return;
}


int main(){
    for (int i = 1; i <= n; i++) {
		dfs(i, 0, 1);
	}
}

递减，不重复

题目说到要求递减的序列，那么就可以再每层递归前加上限制条件，而且需要使得每次生成的序列不再重复（重复的原因是因为序列中有重复的元素），那么就可以在输出序列之前判重，完整代码长这样：

//先写个单次输入的
#include<map>
#include<iostream>
using namespace std;
int n, p;
int cnt = 0;
int a[1010];
int b[1010];
map<string, bool>mp;
bool vis[1010];

void dfs(int sublen,int now_len,int now_pos) {
	if (cnt == p) {
		return;
	}
	if (now_len == sublen) {
		string s;
		for (int i = 0; i < sublen; i++) {
			s += b[i];
		}
		//map判重
		if (!mp[s]) {
			for (int i = 0; i < sublen-1; i++) {
				cout << b[i] << " ";
			}
			if (sublen - 1 >= 0) {
				cout << b[sublen - 1] << endl;
			}
			cnt++;
			mp[s] = true;
		}
		return;
	}
	for (int i = now_pos; i <= n; i++) {
		if (!vis[i] &&  (now_len == 0 || b[now_len - 1] <=a[i])) {  //保证序列递增
			vis[i] = true;
			b[now_len] = a[i];
			dfs(sublen, now_len+1,i+1);
			//回溯
			vis[i] = false;
		}
	}
}


int main() {
	cin >> n >> p;
	for (int i = 1; i <=n; i++) {
		cin >> a[i];
	}
	for (int i = 1; i <= n; i++) {
		dfs(i,0,1);
	}
	return 0;
}

去重的优化

当时我也想着就这样就可以结束了，但还是超时，服了，之后才知道，这里的去重其实是可以优化的，仔细看过dfs原理图的伙伴就知道，其实dfs原理是以一个元素为首，然后不断递归去找子序列，本题导致重复的原因就是两次使用了同一个数值的元素为首进行dfs（注意我说的是同一个数值，不是同一个数）

画的有点丑，忽略

那就只需要对每层dfs的队首做一次判断即可（注意每层dfs队首都会更新），这样如果序列中有重复的元素就可以去重

f代表front——队首

最终代码

#include<iostream>
#include<set>
#include<map>
using namespace std;
int n, p;
int cnt = 0;
int a[1010];
int b[1010];
bool vis[1010];

bool check(int a_ed, int a_i) {
	for (int i = a_ed; i < a_i; i++) {
		if (a[i] == a[a_i]) return false;
	}
	return true;
}

void dfs(int sublen, int now_len, int now_pos) {
	if (cnt == p) {
		return;
	}
	if (now_len == sublen) {
		for (int i = 0; i < sublen-1; i++) {
			cout << b[i] << " ";
		}
		if (sublen - 1 >= 0) {
			cout << b[sublen - 1] << endl;
		}
		cnt++;
		
		return;
	}
	for (int i = now_pos; i <= n; i++) {
		if (!vis[i] && (now_len == 0 || b[now_len - 1] <= a[i])) {
			if (now_len == 0) {
				if (!check(1, i)) continue;
			}
			if (now_len != 0) {
				if (!check(now_pos, i))continue;
			}
			vis[i] = true;
			b[now_len] = a[i];
			dfs(sublen, now_len + 1, i + 1);
			vis[i] = false;
		}
	}
}

int main() {
	while (~scanf_s("%d %d", &n, &p)) {
		for (int i = 1; i <= n; i++) {
			cin >> a[i];
		}
		cnt = 0;
		for (int i = 1; i <= n; i++) {
			dfs(i, 0, 1);
		}
		cout << endl;
	}
	return 0;
}