pku1088 dfs+dp memory search

ski

Time Limit: 1000MS		Memory Limit: 65536K
Total Submissions: 88861		Accepted: 33344

Description

It's no surprise that Michael loves skiing, because skiing is really exciting. But to gain speed, the slippery area has to slope down, and when you get to the bottom of the slope, you have to walk uphill again or wait for the lift to pick you up. Michael wants to know the longest landslide in an area. The area is given by a two-dimensional array. Each number of the array represents the height of the point. Below is an example

 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

A person can slide from a point up, down, left and right to one of the four adjacent points if and only if the height decreases. In the example above, a slideable landslide is 24-17-16-1. Of course 25-24-23-...-3-2-1 is longer. In fact, this is the longest one.

Input

The first line of input represents the row number R and column number C of the region (1 <= R, C <= 100). Below are R lines, each with C integers representing height h, 0<=h<=10000.

Output

Output the length of the longest region.

Sample Input

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

Sample Output

Very simple question, go through it all over again, because the question requires a path from large to small, so there is no need to mark the visited nodes with vist. This path itself has its own directed attribute.

#include <iostream>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <string>
#include <queue>
#include <stack>
#include <algorithm>

const int inf = (1<<31)-1;
const int MAXN = 1e2+10;
using namespace std;

int dp[MAXN][MAXN];
int vist[MAXN][MAXN];
int a[MAXN][MAXN];
int n,m;

int mov[4][2]={-1,0,1,0,0,1,0,-1};

int check(int x,int y){
    if(x<1||y<1||x>n||y>m)return 0;
   // if(vist[x][y]==1)return 0;
    else return 1;
}

void dfs(int x,int y){
    int nx,ny;
   // cout<<"haha"<<endl;
    for(int i=0;i<4;i++){
        nx = x+mov[i][0];
        ny = y+mov[i][1];
        if(check(nx,ny)&&a[x][y]>a[nx][ny]){
            if(dp[nx][ny]==1){
               // vist[nx][ny] = 1;
                dfs(nx,ny);
                dp[x][y] = max(dp[x][y],dp[nx][ny]+1);
                //vist[nx][ny] = 0;
            }
            else{
                dp[x][y] = max(dp[x][y],dp[nx][ny]+1);
            }
        }
    }
}

intmain ()
{
    while(scanf("%d%d",&n,&m)!=EOF){
        int mmax = -inf;
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                scanf("%d",&a[i][j]);
                dp[i][j] = 1;
                shown [i] [j] = 0 ;
            }
        }
        for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                if(dp[i][j]!=1||vist[i][j]==0){
                    //if()
                    vist[i][j] = 1;
                    dfs(i,j);
                }
                mmax = max(mmax,dp[i][j]);
            }
        }
        /*for(int i=1;i<=n;i++){
            for(int j=1;j<=m;j++){
                printf("%d ",dp[i][j]);
            }
            cout<<endl;
        }*/
        cout<<mmax<<endl;
    }
    //cout << "Hello world!" << endl;
    return 0;
}

View Code

Reprinted in: https://www.cnblogs.com/EdsonLin/p/5441033.html

pku1088 dfs+dp memory search

Guess you like