poj 1088 记忆化搜索||动态规划

全栈程序员-站长 • 2022年7月26日上午7:36 • 未分类 • 阅读 5

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE使用 1年只要46元售后保障童叟无欺

poj 1088

记忆化搜索也也是采用递归深搜的对数据进行搜索，但不同于直接深搜的方式，记忆化搜索是在每次搜索时将得到的结果保存下来，避免了重复计算，这就是所谓的记忆化。记忆化应该是属于动态规划。

举个例子，比如我们搜索最长最长连续增子序列， 1 2 3 4 5 6 7，当然这个例子比较特殊，但足以说明情况。

对于这种问题，我们可以先搜索以1开始的，定义一个函数dfs（1），然后在dfs（1）中将第二个与一个数比较，如果大的话返回1+dfs（2）。。。。依次递归，然后我们搜索分别以1 2 …………开头的子序列，当我们dfs（3）时，实际上我们在dfs（2）和dfs（1）的时候早就把它计算过了，如果数据量大的话我们会重复计算多次，但如果我们在计算过程中保存结果，我们就会消除好多重复的计算，这也是动态规划的思想。

代码：

#include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;

int h[101][101];
int ans[101][101];
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};

int dfs(int x, int y)
{
    if (ans[x][y] > 0)
        return ans[x][y];
    int f = 1;
    for (int i = 0; i < 4; i++)
    {
        int tx = x + dx[i];
        int ty = y + dy[i];
        if (h[tx][ty] < h[x][y])
        {
            f = 0;
            ans[x][y] =max(ans[x][y], 1+dfs(tx, ty));
        }
    }
    if (f)
        return 1;
    return ans[x][y];
}

int main()
{
    int r, c;
    while (scanf("%d %d",&r, &c) != EOF)
    {
        int mans = 0;
        memset(h, 0x3f, sizeof(h));
        memset(ans, 0, sizeof(ans));
        for (int i = 1; i <= r; i++)
        {
            for (int j = 1; j <= c; j++)
            {
                scanf("%d",&h[i][j]);
            }
        }
        for (int i = 1; i <= r; i++)
        {
            for (int j = 1; j <= c; j++)
            {
                mans = max(mans, dfs(i, j));
            }
        }
        printf("%d\n",mans);
    }
    return 0;
}

动态规划解题方法：

动态规划是先求出子问题的最优解，然后用已求得的子问题的最优解，然后逐步扩大求解范围，最终获得整体最优解。

#include<iostream>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<algorithm>
using namespace std;
struct dot//创建一个结构体存储每个点的信息
{
    int x;
    int y;
    int h;
};
dot line[20000]; //将每个点存入该结构体数组
int height[120][120]; //用于存储input
int len[120][120];  //dp数组，存储每个点的最优解
int cmp( const void *a ,const void *b) //快速排序的参考函数
{
    if((*(dot *)a).h>(*(dot *)b).h)
        return 1;
    else return -1;
}
int main ()
{
    int m,n;
    cin>>m>>n;
    int i,j;
    int flag=-1;
    int max=0;
    for(i=1;i<=m;i++)
    {
        for(j=1;j<=n;j++)
        {
            flag++;
            scanf("%d",&height[i][j]);
            line[flag].x=i;
            line[flag].y=j;
            line[flag].h=height[i][j];
        }
    } //这个双层循环用来完成数据收集的工作
    qsort(line,m*n,sizeof(line[0]),cmp); //对结构体的h参数进行排序
    for(i=0;i<m*n;i++)
    {
        if(height[line[i].x][line[i].y]<height[line[i].x][line[i].y+1]&&len[line[i].x][line[i].y]>=len[line[i].x][line[i].y+1])
        {
            len[line[i].x][line[i].y+1]=len[line[i].x][line[i].y]+1;
        }
        if(height[line[i].x][line[i].y]<height[line[i].x+1][line[i].y]&&len[line[i].x][line[i].y]>=len[line[i].x+1][line[i].y])
        {
            len[line[i].x+1][line[i].y]=len[line[i].x][line[i].y]+1;
        }
        if(height[line[i].x][line[i].y]<height[line[i].x][line[i].y-1]&&len[line[i].x][line[i].y]>=len[line[i].x][line[i].y-1])
        {
            len[line[i].x][line[i].y-1]=len[line[i].x][line[i].y]+1;
        }
        if (height[line[i].x][line[i].y]<height[line[i].x-1][line[i].y]&&len[line[i].x][line[i].y]>=len[line[i].x-1][line[i].y])
        {
            len[line[i].x-1][line[i].y]=len[line[i].x][line[i].y]+1;
        }
    } //动态规划过程
    for(i=1;i<=m;i++)
    {
        for(j=1;j<=n;j++)
        {
            if(len[i][j]>max)
                max=len[i][j];
        }
    } //遍历len数组，求出最大值
    cout<<max+1<<endl;// 因为初始值是0,所以最后要加一
    return 0;

}

发布者：全栈程序员-站长，转载请注明出处：https://javaforall.net/164453.html原文链接：https://javaforall.net