NYOJ10 dp+dfs(记忆化搜索)

题意:给一个n*m的矩阵,求一段连续的路径 ,路径上的数严格递增,求路径最长为多少

从dp的角度,容易想到定义状态:dp[i][j] :  以a[i][j]为最后一位的最长路径

那么怎么更新?LIS问题中,数组是自左向右的,可以直接由之前的已经确定的最优子结构得到dp,

但是这种二维的并不是,因为

例如:

16 17 18 19 6

15 24 25 20 7

14 23 22 21 8

13 12 11 10 9

数25的最优显然是由24得到,但是24由23得到,23更新24发生在24更新25之前,因此无法直接状态转移

由此我想到一种类似dijkstre的算法,反复更新,直到无法更新的时候,那么此时所有的点都是最优

大致可以用数学归纳法,反证的思想得到,因为如果一个已经最优,那么他无法被其他的再更新了,否则就不是最优,

因而,可以用这个最优的去更新别的

tip:不严谨的原理诠释：

先从最短路开始讲：

长度为2的最优路径必然会在一步之内被更新，也就是第一次遍历就必然会遍历所有len=2的最优路径

那么第二次遍历的时候，len=3的最优路径必然是由len=2的最优路径再走一步得来，那么此时

len=3的最优路径可以在此次遍历全部求出来，以此递推，最多n-1次遍历能得到到达所有点的最优路径

可以看出这里隐性用到dp，状态是到达a[i]的最短路,第j次遍历可以求出长度为j+1的到达某个a[i]的最短路

那么这个题目:

其实和上面的基本一样,就是松弛操作变了一下,依然是第j次遍历可以求出长度为j+1的到达某个a[i]为结尾的最长路径

另外

上面可知n-1次后必然全都是最优,那么到无法更新的时候(没有n-1次),一定是最优的吗

显然是的.
到第k次遍历时,此时若已经没有能更新的点,必然len=k+1的所有最优路已经被更新完,那么此时可以用len=k+1更新len+1的

路径,但是因为此时没有能更新的点,因此len+1最优,以此类推,所有达到最优

（背后的规律:一个回合，必然可以用已经达到最优的路径len,去更新没有达到最优的len+1,len+1由所有的len最优子结构得到）;

时间复杂度最不乐观是o（n^2*m^2）,差点超时吧..

但是时间复杂度应该很大,因为会走重复的步骤

code:

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
const int maxn=110;
const int inf=0x3f3f3f3f; 
int n,m;
int a[maxn][maxn],dp[maxn][maxn];
int dx[4]={0,0,1,-1},dy[4]={1,-1,0,0};

int main()
{
	
	scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			scanf("%d",&a[i][j]);
		}
	}
	int flag=1;
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			dp[i][j]=1;
		}
	}
	int cnt=0;
	while(flag){
		flag=0;
		cnt++;
		for(int i=0;i<n;i++){
			for(int j=0;j<m;j++){
				for(int k=0;k<4;k++){
					int x=i+dx[k],y=j+dy[k];
					if(x<0||x>=n||y<0||y>=m) continue;
					if(a[i][j]<a[x][y]&&dp[x][y]<dp[i][j]+1) {
						dp[x][y]=dp[i][j]+1;
						flag=1;
					}
				}
			}
		}
	}
//	cout<<cnt<<endl; 
	int ans=dp[0][0];
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			if(dp[i][j]>ans) ans=dp[i][j];
		}
	}
	printf("%d\n",ans);
	return 0;	
} 

很神奇得过了,数据太小太水了吧

然后搜题解发现都是用dfs+dp做的...(也可以说是记忆化搜索,不过用到了特殊的状态)

思路:对于每一个点,从这个点开始走,遇到可以更新dp的点就更新,并且进行dfs(用这个被更新的点更新其他点)

然后再到别的点,如果被更新,就回溯去再更新之前的已经更新的路线,做到反复更新.

这样确保每一步都能去更新,并且任意方向更新到无法更新为  止,少走了重复的路线

也可以说是把每个点纳入更新的体系,当所有点都纳入的时候就完成了所有的最优化更新

换而言之,如果有一个点x的最优dp路径中包含点y,那么以点y开始进行dfs必然能到达并更新x,之后又点z更新y时候

y会再dfs并去更新x;

讲得有一些混乱....也不知道怎么讲...过段时间再回过头来改一下这个做法的题解吧

#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
const int maxn=110;
const int inf=0x3f3f3f3f; 
int n,m;
int a[maxn][maxn],dp[maxn][maxn];
int dx[4]={0,0,1,-1},dy[4]={1,-1,0,0};

void dfs(int x,int y){
	for(int i=0;i<4;i++){
		int xx=x+dx[i],yy=y+dy[i];
		if(xx<0||xx>=n||yy<0||yy>=m) continue;
		if(a[xx][yy]>a[x][y]&&dp[xx][yy]<dp[x][y]+1){
			dp[xx][yy]=dp[x][y]+1;
			dfs(xx,yy);
		} 
	}
}

int main()
{
	
	scanf("%d%d",&n,&m);
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			scanf("%d",&a[i][j]);
		}
	}
	int flag=1;
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			dp[i][j]=1;
		}
	}
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			dfs(i,j);
		}
	}
	int ans=dp[0][0];
	for(int i=0;i<n;i++){
		for(int j=0;j<m;j++){
			if(dp[i][j]>ans) ans=dp[i][j];
		}
	}
	printf("%d\n",ans);
	return 0;	
}