poj 3700 二分套dfs

先看第一个tle的思路，就是直接暴力的搜索，但是如果搜索的深度非常大，就会tle

int n, a[55], ans;
int nn[2][55][55], l[2][55], vis[55];//0为降序，1为升序

void dfs(int x, int dir, int now, int sum) {
	if (now == n) {
		ans = min(ans, sum);
		return;
	}
	if (sum + 1 >= ans)return;
	if (l[dir][x] == 0) {
		for (int i = 0; i < n; i++)
			if (!vis[i]) {
				vis[i] = 1;
				dfs(i, 0, now + 1, sum + 1);
				dfs(i, 1, now + 1, sum + 1);
				vis[i] = 0;
				break;
			}
		return;
	}
	for (int i = 0; i < l[dir][x]; i++) {
		if (vis[nn[dir][x][i]]) continue;
		vis[nn[dir][x][i]] = 1;
		dfs(nn[dir][x][i], dir, now + 1, sum);
		vis[nn[dir][x][i]] = 0;
	}
}

int main() {
	while (scanf("%d", &n), n) {
		for (int i = 0; i < n; i++)
			scanf("%d", a + i);
		memset(l, 0, sizeof(l));
		memset(vis, 0, sizeof(vis));
		for (int i = 0; i < n; i++)
			for (int j = i + 1; j < n; j++)
				if (a[i] > a[j]) nn[0][i][l[0][i]++] = j;
				else if (a[i] < a[j]) nn[1][i][l[1][i]++] = j;
		ans = 50;
		dfs(0, 0, 0, 0);
		dfs(0, 1, 0, 0);

		printf("%d\n", ans);
	}

	return 0;
}

看第二种ac的思路迭代加深。核心思路在于对于某一个点，能把他加在已经有的序列后面就一定要加，因为这个点你最后是一定要算进序列的。如果不能加，就新开序列

假设一个长度，超过就直接退出，这样就容易过。

#include <cstdio>
#include <iostream>
#include <iomanip>
#include <string>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <set>
#include <vector>
#include <map>
#include <algorithm>
#include <cmath>
#include <stack>

#define INF 0x3f3f3f3f
#define IMAX 2147483646
#define LINF 0x3f3f3f3f3f3f3f3f
#define ll long long
#define c unsigned long long
#define uint unsigned int

using namespace std;

int n, a[55],as[55],ds[55],len;

bool dfs(int x, int aa, int dd) {
	if (aa + dd > len)return false;
	if (x == n)return true;

	int s = -1, j = -1;
	for (int i = 0; i < aa; i++)
		if ((s == -1 || as[i] > as[s]) && as[i] < a[x])
			s = i;
	for (int i = 0; i < dd; i++)
		if ((j == -1 || ds[i] < ds[j]) && ds[i] > a[x])
			j = i;

	if (s != -1) {
		int tt = as[s]; as[s] = a[x];
		if (dfs(x + 1, aa, dd))return true;
		as[s] = tt;
	}
	else {
		as[aa] = a[x];
		if (dfs(x + 1, aa + 1, dd))return true;
	}

	if (j != -1) {
		int tt = ds[j]; ds[j] = a[x];
		if (dfs(x + 1, aa, dd))return true;
		ds[j] = tt;
	}
	else {
		ds[dd] = a[x];
		if (dfs(x + 1, aa, dd + 1))return true;
	}

	return false;
}

int main() {
	while (scanf("%d", &n), n) {
		for (int i = 0; i < n; i++)
			scanf("%d", a + i);

		for (int i = 1;; i++) {
			len = i;
			if (dfs(0, 0, 0)) {
				printf("%d\n", i);
				break;
			}
		}	
	}
	

	return 0;
}

善于二分的老YB可能已经发现了，迭代加深和二分有异曲同工之妙，所以二分也能过，但是对于这道题来说，不同的mid测试的复杂度是幂次方上升的，二分容易去测一些很大的数据导致过不了，上下界把握好了就能过，把握不好就tle，这种题还是迭代加深最稳妥。

#include <cstdio>
#include <iostream>
#include <iomanip>
#include <string>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <set>
#include <vector>
#include <map>
#include <algorithm>
#include <cmath>
#include <stack>

#define INF 0x3f3f3f3f
#define IMAX 2147483646
#define LINF 0x3f3f3f3f3f3f3f3f
#define ll long long
#define c unsigned long long
#define uint unsigned int

using namespace std;

int n, a[55],as[55],ds[55],len;

bool dfs(int x, int aa, int dd) {
	if (aa + dd > len)return false;
	if (x == n)return true;

	int s = -1, j = -1;
	for (int i = 0; i < aa; i++)
		if ((s == -1 || as[i] > as[s]) && as[i] < a[x])
			s = i;
	for (int i = 0; i < dd; i++)
		if ((j == -1 || ds[i] < ds[j]) && ds[i] > a[x])
			j = i;

	if (s != -1) {
		int tt = as[s]; as[s] = a[x];
		if (dfs(x + 1, aa, dd))return true;
		as[s] = tt;
	}
	else {
		as[aa] = a[x];
		if (dfs(x + 1, aa + 1, dd))return true;
	}

	if (j != -1) {
		int tt = ds[j]; ds[j] = a[x];
		if (dfs(x + 1, aa, dd))return true;
		ds[j] = tt;
	}
	else {
		ds[dd] = a[x];
		if (dfs(x + 1, aa, dd + 1))return true;
	}

	return false;
}

int main() {
	while (scanf("%d", &n), n) {
		for (int i = 0; i < n; i++)
			scanf("%d", a + i);

		int l = 1, r = 50, mid;
		while (l < r) {
			mid = (l + r) >> 1;
			len = mid;
			if (dfs(0, 0, 0))r = mid;
			else l = mid + 1;
		}
		printf("%d\n", l);
	}
	

	return 0;
}