习题7-15 最大的数 UVa11882

1.题目描述：点击打开链接

2.解题思路：本题利用“DFS+剪枝”解决。本题要求在一个矩阵中找到一条数字链，使得它尽量大。不难想象，如果只是单纯地用dfs进行盲目的搜索，那么时间复杂度将是N!级别的，这里的N代表矩阵中所有数字的个数。时间上开销太大，难以承受。需要优化。

那么本题该怎么优化呢？通过观察易知，本题有两处可以进行优化，假设已经找到的答案数组是b，目前尝试的数组是c，当前要填的位置是cur。答案的长度是maxd，如果b,c两数组在cur之前的所有数字均相等，但当前要填的值val<b[cur]，那么可想而知，c的结果一定小于b，此时再往下寻找结果也不会更优，直接剪枝！

另外，通过maxd和当前位置cur可以知道还需要寻找的数字个数是res。如果当前填入的值val对应的坐标是(x,y)，用一个find(x,y)函数表示它后面最多还能找到的数字个数。可想而知，当find(x,y)<res时，即往下能够找到的最多的数字个数还达不到最低要求时，需要剪枝。而find函数还可以通过递归来实现，详细细节见代码。

这样，通过这样的两次剪枝，就可以实现时间复杂度的巨大优化！只有在矩阵中没有障碍格且所有数字都相同时才会达到最坏的情况，此时复杂度是O(N!)，但大多数情况下复杂度是远远小于这个值的。

本题值得学习的地方有以下几点：（1）学会适当的剪枝，“预测”从某一个结点出发能否找到更优解。（2）矩阵中的数字是否用过，除了可以用数组标记以外，也可以直接将它设置为一个特殊的数字，比如0，最后再恢复即可。不过这要保证输入的数字中绝对不含0。

3.代码：

#define _CRT_SECURE_NO_WARNINGS 
#include<iostream>
#include<algorithm>
#include<string>
#include<sstream>
#include<set>
#include<vector>
#include<stack>
#include<map>
#include<queue>
#include<deque>
#include<cstdlib>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<ctime>
#include<functional>
using namespace std;

struct Node
{
	int val, x, y;
	bool operator<(const Node&r)const
	{
		return val>r.val;
	}
};
int cnt;
int n, m, maxd;//maxd表示答案的长度
#define N 35
#define For(i,n) for(int i=0;i<(n);i++)
int b[N], c[N];//b数组存放答案，c数组是当前待尝试的结果
int vis[N][N];
int a[N][N];//存放输入的数字，'#'均用0表示
const int dx[] = { 0, 0, -1, 1 };
const int dy[] = { -1, 1, 0, 0 };
int find(int x, int y)//寻找(x,y)后面最多还有多少个数
{
	int ret = 0;
	vis[x][y] = cnt;
	For(k, 4){
		int i = x + dx[k], j = y + dy[k];
		if (!a[i][j] || vis[i][j] == cnt)continue;
		ret += find(i, j) + 1;//递归寻找
	}
	return ret;
}

bool dfs(int cur, int val, int x, int y, bool same)//当前位置为cur,待填入的值为val,坐标为(x,y)，same表示cur之前的数字和目前的答案是否完全一致,返回是否更新过答案
{
	if (same&&val < b[cur])return 0;//如果cur之前所有位都相等 且 当前cur位置的数<以往找到的数，剪枝（1）
	if (val>b[cur])same = 0;//如果大于，说明不相等
	c[cur] = val;
	if (cur == maxd){
		for (int i = 1; i <= maxd; i++)
			b[i] = c[i]; 
		return 1;//找到了一个答案，返回1，表示更新过答案
	}
	int res = maxd - cur; cnt++;//res表示还需要找的数字个数，cnt表示查找的次数，也作为标记数
	if (find(x, y) < res)return 0;//如果剩余的数字个数<需要的数字个数，剪枝（2）
	vector<Node>L;
	For(k, 4){
		int i = x + dx[k], j = y + dy[k];
		if (!a[i][j])continue;
		L.push_back(Node{ a[i][j], i, j });//后继结点都放入L中
	}
	sort(L.begin(), L.end());//排序，从较大的后继结点开始搜索
	bool o = 0;
	For(i, L.size()){
		int&t = a[L[i].x][L[i].y];
		int tmp = t; t = 0;
		o |= dfs(cur + 1, L[i].val, L[i].x, L[i].y, same);
		if (o)same = 1;
		t = tmp;
	}
	return o;
}
char st[100];
void solve()
{
	vector<Node>L;
	memset(a, 0, sizeof(a));
	memset(vis, 0, sizeof(vis));
	memset(b, 0, sizeof(b)); cnt = 0;
	maxd = 0;
	for (int i = 1; i <= n; i++)
	{
		scanf("%s", st + 1);
		for (int j = 1; j <= m; j++)
		{
			if (st[j] != '#'){
				a[i][j] = st[j] - '0';
				L.push_back(Node{ a[i][j], i, j });
				maxd++;
			}
		}
	}
	sort(L.begin(), L.end());//将数值较大的结点放到前面
	for (; maxd >= 1; maxd--)//从长度最大的开始尝试，如果无解，换为小一点的，这样的一个好处是容易比较大小，可以进行剪枝
	{
		bool o = 0;
		for (int i = 0; i < L.size(); i++){
			int&t = a[L[i].x][L[i].y];
			int tmp = t; t = 0;//暂时让(x,y)处的值消失，递归结束后恢复
			o |= dfs(1, L[i].val, L[i].x, L[i].y, 1);//默认same初始值为1
			t = tmp;//恢复该位置的值
		}
		if (o)break;//当前答案长度的限制下找到了解，直接break
	}
	for (int i = 1; i <= maxd; i++)
		printf("%d", b[i]);
	puts("");
}
int main()
{
	freopen("t.txt", "r", stdin);
	while (~scanf("%d%d", &n, &m) && (n || m))
		solve();
	return 0;
}