洛谷P1434 [SHOI2002]滑雪

题目描述

Michael喜欢滑雪。这并不奇怪，因为滑雪的确很刺激。可是为了获得速度，滑的区域必须向下倾斜，而且当你滑到坡底，你不得不再次走上坡或者等待升降机来载你。Michael想知道在一个区域中最长的滑坡。区域由一个二维数组给出。数组的每个数字代表点的高度。下面是一个例子：

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

一个人可以从某个点滑向上下左右相邻四个点之一，当且仅当高度减小。在上面的例子中，一条可行的滑坡为24－17－16－1（从24开始，在1结束）。当然25－24－23―┅―3―2―1更长。事实上，这是最长的一条。

输入输出格式

输入格式：

 

输入的第一行为表示区域的二维数组的行数R和列数C（1≤R，C≤100）。下面是R行，每行有C个数，代表高度(两个数字之间用1个空格间隔)。

 

输出格式：

 

输出区域中最长滑坡的长度。

 

输入输出样例

输入样例#1： 复制

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

输出样例#1： 复制

25

解法：记忆化搜索 || dp

首先想到的肯定是搜索，dfs每个点最长可以滑的长度。但这样会超时，所以考虑记忆化。

由于每个点只能往比其高度低的点移动。所以每一点如果被计算出来了，则后续就不必再计算一次了。

令maxlen[i][j]为坐标为i,j的点所能构成的最长长度。

最后在所有的maxlen值中的最大值即为答案。

法1:记忆化搜索

#include 
#include 
#define pii pair
#define ll long long
#define eps 1e-5
using namespace std;
const int maxn = 2e5 + 10;
int loc[200][200];
int r, c;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int ans = 1;
int maxlen[200][200];
void dfs(int a, int b, int len)
{
    for(int i = 0; i < 4; i++)
    {
        int x = dx[i] + a, y = dy[i] + b;
        if(x >= 0 && x < r && y >= 0 && y < c)
            if(loc[x][y] < loc[a][b])
            {
                if(maxlen[x][y] > 1)//如果已经被计算出来了
                {
                    ans = max(ans, maxlen[x][y] + len);//直接更新值
                    continue;
                }
                dfs(x, y, len + 1);
            }
    }
    ans = max(ans, len);//每次计算完后更新最大值
}
int main()
{
    // freopen("/Users/vector/Desktop/testdata.in", "r", stdin);
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> r >> c;
    for(int i = 0; i < r; i++)
        for(int j = 0; j < c; j++)
        {
            cin >> loc[i][j];
            maxlen[i][j] = 1;
        }
    for(int i = 0; i < r; i++)
        for(int j = 0; j < c; j++)
        {
            ans = 1;//置零
            dfs(i, j, 1);
            maxlen[i][j] = ans;//每次dfs后的ans即为当前值的答案
        }
    for(int i = 0; i < r; i++)
        for(int j = 0; j < c; j++)
            ans = max(ans, maxlen[i][j]);
    cout << ans << endl;
    return 0;
}

法2:dp

由于状态很好找，

maxlen[i][j]为坐标为i,j的点所能构成的最长长度。具有无后效性。

先考虑排序，将所有点按高度从低到高进行排序。

然后转移方向为上下左右四个点比自己低的点，由于已经排序，比自己低的点的值已经被计算出来了。

一遍扫描就可以了。

#include 
#include 
#define pii pair
#define ll long long
using namespace std;
const int maxn = 2e5 + 10;
int r, c;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int ans = 1;
int maxlen[200][200];
int loc[200][200];
struct node{
    int x, y, h;
}a[maxn];
bool cmp(const node& a, const node& b)
{
    return a.h < b.h;
}
int main()
{
    // freopen("/Users/vector/Desktop/testdata.in", "r", stdin);
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin >> r >> c;
    for(int i = 0; i < r; i++)
        for(int j = 0; j < c; j++)
        {
            maxlen[i][j] = 1;
            int h; cin >> h;
            loc[i][j] = h;
            a[i * c + j].x = i;
            a[i * c + j].y = j;
            a[i * c + j].h = h;
        }
    sort(a, a + r * c, cmp);
    for(int i = 0; i < r * c; i++)
    {
        int x = a[i].x, y = a[i].y;
        for(int j = 0; j < 4; j++)
        {
            int a = x + dx[j], b = y + dy[j];
            if(a >= 0 && a < r && b >= 0 && b < c)
                if(loc[a][b] < loc[x][y])
                    maxlen[x][y] = max(maxlen[x][y], maxlen[a][b] + 1);
        }
        ans = max(ans, maxlen[x][y]);
    }
    cout << ans << endl;
    return 0;
}