【 DP | 记忆化搜索】【Uva10258 | poj 1088】滑雪

最新推荐文章于 2019-05-14 14:23:06 发布

原创最新推荐文章于 2019-05-14 14:23:06 发布 · 322 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

dp 同时被 2 个专栏收录

12 篇文章

订阅专栏

dfs/bfs 搜索

12 篇文章

订阅专栏

本文探讨了滑雪问题的两种解决方案——记忆化搜索和动态规划（DP）。通过对比这两种方法在滑雪问题上的应用，展示了如何利用记忆化搜索优化搜索过程，以及如何通过动态规划解决该问题。代码示例提供了清晰的实现步骤。

题目链接：poj1088

题意：

这个题目就是滑雪呗，就是给定n行m列，从高到低进行滑雪，然后问最长路是多少

题解：

浪子回头金不换

这个题目是以DAG为背景的，所有应该有两个解法：

以前总觉得DP快一点，但是这个题目实测是记忆化搜索比较快。

记忆化搜索：

首先存值，然后进行看哪一个可以延伸下去，一直延伸下去知道没有的话就返回值，用到就是基本的记忆化搜索的基本套路。

贴上代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=110;
int dp[N][N],a[N][N],n,m;
int dir[4][2]={
        {-1,0},
    {0,-1},{0,1},
        {1,0}
};
bool check(int x,int y){
    return (1<=x&&x<=n&&1<=y&&y<=m) ? true : false;
}
int dfs(int x,int y){
    int &ans=dp[x][y],tx,ty;
    if(~dp[x][y]) return ans;
    ans=1;
    for(int i=0;i<4;i++){
        tx=x+dir[i][0];
        ty=y+dir[i][1];
        if( check(tx,ty) && a[x][y] > a[tx][ty]){
            ans=max(ans,dfs(tx,ty)+1);
        }
    }
    return ans;
}
int main()
{
    int T;
    for(scanf("%d",&T);T;T--){
        memset(dp,-1,sizeof(dp));
        char name[N];
        scanf("%s",name);
        scanf("%d%d",&n,&m);
        int ans=-1;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                scanf("%d",&a[i][j]);
        for(int i=1;i<=n;i++)
            for(int j=1;j<=m;j++)
                ans=max(ans,dfs(i,j));
        printf("%s: %d\n",name,ans);
    }
}

/*
2

Feldberg 10 5
56 14 51 58 88
26 94 24 39 41
24 16 8 51 51
76 72 77 43 10
38 50 59 84 81
5 23 37 71 77
96 10 93 53 82
94 15 96 69 9
74 0 62 38 96
37 54 55 82 38

Spiral 5 5
1 2 3 4 5
16 17 18 19 6
15 24 25 20 7
14 23 22 21 8
13 12 11 10 9

Feldberg: 7
Spiral: 25
*/

DP:

其实这个dp，需要排序一下，因为大家想：滑雪一定是从高到底，我们”刷表法“需要知道哪里开始刷表，根据题目可以从高到低一直刷，然后我的写法是，从小到大开始，从小的方格四周开始更新，最后更新最大值。

【小提示】：ans初始化为1，可能出现不进入if判断，导致答案就是1。这个是多次WA的教训。

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N=105;
typedef struct Node {
    int x,y,num;
    Node (int X=0,int Y=0,int Num=0):x(X),y(Y),num(Num){}
    bool operator < (const Node &t) const {
        return num<t.num;
    }
} Node ;
int n,m,cnt,a[N][N],dp[N][N],dir[4][2]={
        {-1,0},
    {0,-1},{0,1},
        {1,0}
};
inline bool check(int x,int y){
    return ( 1<=x&&x<=n && 1<=y&&y<=m ) ? true : false;
}
Node b[N*N];
int main()
{
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++){
            scanf("%d",&a[i][j]);
            b[cnt]=Node(i,j,a[i][j]);
            dp[i][j]=1;
            cnt++;
        }
    sort(b,b+cnt);
    int ans=1;
    for(int i=0;i<cnt;i++){
        int x=b[i].x;
        int y=b[i].y;
        int t=b[i].num;
        //printf("t : %d\n",t);
        for(int j=0;j<4;j++){
            int tx=x+dir[j][0];
            int ty=y+dir[j][1];
            if( check(tx,ty) && t > a[tx][ty] ){
                dp[x][y]=max(dp[x][y],dp[tx][ty]+1);
                ans = max(ans,dp[x][y]);
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}
/*
10 5
56 14 51 58 88
26 94 24 39 41
24 16 8 51 51
76 72 77 43 10
38 50 59 84 81
5 23 37 71 77
96 10 93 53 82
94 15 96 69 9
74 0 62 38 96
37 54 55 82 38

*/