【POJ1088】【动态规划】滑雪问题 思路解析和代码

滑雪问题

题目链接
POJ不能解析#include<bits/stdc++.h>

个人思路

题意

input:
3 3
4 5 6
3 10 7
2 9 8
output:9
此题的最长的滑坡指的是滑坡的个数,每个格子代表一个滑坡,即从10开始出发,最长可以经过9个格子
错误思路1:一开始以为的是滑坡长度(数值)之和最大,此时输出为54
错误思路2:后来以为的是滑坡的出发点,此时输出为10

思路

整个思路可以类比最长下降子序列,与最长下降子序列相比,这个是二维的,且边界值并非dp[0][0]或dp[1][1],个人采取结构体存储各节点值和节点坐标,并对结构体升序排序,则排序后的第一个节点即为整个dp数组的边界;在求解过程中是根据排序的顺序进行求解的。
dp[i][j]表示坐标为(i,j)的最长滑坡为dp[i][j]
自顶向下分析

  • 求最优解:求最长的滑坡
  • 最优子结构:当前位置的最长滑坡,依赖于前面已经求得的最长滑坡
  • 重叠子问题:想要求中间第i步(坐标是i,j)的最大值dp[i][j],需要从边界开始计算,直到求到当前位置;想要求终点的最大值dp[m-1][n-1],仍要从边界位置开始计算

自下而上解决问题

  • 边界:经过排序后,值最小的即为边界
  • 状态转移:
    探索上下左右四个位置,若当前节点数值小,才符合题意,此时在当前节点dp[i][j]和周围节点dp[x][y]+1中取最大值,即dp[i][j] = max(dp[i][j], dp[x][y] + 1);

注意

  • 数组在探索时不能越界访问
  • ans的初始值为1,当矩阵中所有数值均相等时,答案为1

个人思路代码

/*
 * @Author: LLX 
 * @Date: 2020-10-31 19:19:43 
 * @Last Modified by: SEUer
 * @Last Modified time: 2020-10-31 19:20:05
 */
#include<iostream>
#include<stdio.h>
#include<algorithm>
#include<vector>
using namespace std;
int dp[505][505];//dp[i][j]表示:坐标为i,j的最长滑坡长度为dp[i][j]
int matrix[500][500];
int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int m, n;
int ans;//记录答案
struct Node{
    int val;
    int x;
    int y;
    Node(){}
    Node(int vv, int xx, int yy){
        val = vv;
        x = xx;
        y = yy;
    }
};
vector<Node> nodes;
bool cmp(Node n1, Node n2){
    return n1.val < n2.val;
}
int main(){
    scanf("%d%d", &m, &n);
    for(int i = 0; i < m; ++i){
        for(int j = 0; j < n; ++j){
            scanf("%d", &matrix[i][j]);
            dp[i][j] = 1;
            nodes.push_back(Node(matrix[i][j], i, j));
        }
    }
    sort(nodes.begin(), nodes.end(), cmp);
    ans = dp[nodes[0].x][nodes[0].y] = 1;
    for(int i = 1; i < nodes.size(); ++i){
        int xx = nodes[i].x;
        int yy = nodes[i].y;
        int vv = nodes[i].val;
        for(int k = 0; k < 4; ++k){
            int tx = xx + dir[k][0];
            int ty = yy + dir[k][1];
            if(tx >= 0 && tx < m && ty >= 0 && ty < n){
                if(vv > matrix[tx][ty]){
                    dp[xx][yy] = max(dp[xx][yy], dp[tx][ty] + 1);
                    if(dp[xx][yy] > ans){
                        ans = dp[xx][yy];
                    }
                }
            }
        }
    }
    cout << ans << endl;
    /*for(int i = 0; i < m; ++i){
        for(int j = 0; j < n; ++j){
            cout << dp[i][j] << " ";
        }
        cout << endl;
    }
    system("pause");*/
    return 0;
}


/*
测试数据
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
1 1
1
1 2
1 2
1 3 
1 3 2
2 2
1 2 
4 3
2 2 
1 2 
3 4
4 7
7 6 5 4 3 2 1
1 5 1 1 1 1 1
1 4 3 1 1 1 1
1 5 6 7 8 1 1
3 3
9 1 2
5 6 7
8 4 3
3 4
1 2 3 4
8 7 6 5
9 10 11 12
3 3
0 0 0
0 5 0
0 0 0
12 13
1   1 30  4  800  6  7  8  99 10 1223 1
20 30 30 4 16 15 14 13 12 11 1
21 22 99 444444 88 9926 27 9928 9929 3000 456 1
40 39 1 90 36 35 34 33 3992 30001 789  1
41 42 4000 44  88 46 47 48 49 50 897  1
1 59 1 57 56  85 54 53 52 51 908 1
61 77 56 64 444 66 67 68 69 70 1234 1
80 79 78 77 76 75 74 73 72 71 12345 1
81 82 2  2 4 86 5 88 8 90 3456  1
100 99 98 97 96 95 94 93 92 91 567 1
890 654 623 154 683 15414 86549 633 123 456 123456  1
9517 45632 643164 3478643 43 16 431 64453132 689431 746546 15643 1
64543 13146543 13474 314789 4352154 65431 631 654324 65132 89547  34567312 1 1
13 12
1   1 30  4  800  6  7  8  99 10 1223 1
20 30 30 4 16 15 14 13 12 11 1
21 22 99 444444 88 9926 27 9928 9929 3000 456 1
40 39 1 90 36 35 34 33 3992 30001 789  1
41 42 4000 44  88 46 47 48 49 50 897  1
1 59 1 57 56  85 54 53 52 51 908 1
61 77 56 64 444 66 67 68 69 70 1234 1
80 79 78 77 76 75 74 73 72 71 12345 1
81 82 2  2 4 86 5 88 8 90 3456  1
100 99 98 97 96 95 94 93 92 91 567 1
890 654 623 154 683 15414 86549 633 123 456 123456  1
9517 45632 643164 3478643 43 16 431 64453132 689431 746546 15643 1
64543 13146543 13474 314789 4352154 65431 631 654324 65132 89547  34567312 1 1
3 3
0 1 2
1 0 1
2 1 0
3 3
0 0 0
0 0 0
0 0 0
1 1
0
10 10
1 2 300 4 5 6 7 8 9 10
20 19 18 17 16 15 14 13 12 11
21 22 23 24 25 26 27 28 29 30
40 39 38 37 36 35 34 33 32 31
41 42 43 44 45 46 47 48 49 50
60 59 58 57 56 55 54 53 52 51
61 62 63 64 65 66 67 68 69 70
80 79 78 77 76 75 74 73 72 71
81 82 83 84 85 86 87 88 89 90
100 99 98 97 96 95 94 93 92 91
4 4
1 2 3 4
1 2 3 4
1 2 3 4
1 2 3 4
4 4
1 2 2 1
1 4 4 1
1 3 3 1
1 2 2 1
3 3
9 1 2
5 6 7
8 4 3
Sample Output
25
1
2
2
4
3
7
4
12
2
27
37
3
1
1
97
4
4

*/
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
POJ1753的题目描述为:有一个4×4的棋盘,棋盘中有16个棋子,其中有14个棋子是黑色的,用B表示;另外两个棋子是白色的,用W表示。现在要求移动棋子,将两个白色棋子移到一起,移动棋子方式是把与白色棋子相邻(上下左右,而非斜向相邻)的棋子移到空位上。现在,请你求出最少需要移动多少次。 题目看起来很简单,但是要考虑各种情况,一般在处理类似的搜索问题时,我们使用Breath First Search (BFS)来解决问题。 BFS 是一种优秀的遍历搜索算法,广泛应用于许多问题,特别是计算机科学和人工智能。BFS 只需要进行一次完整的搜索即可找到问题的最短路径或解决方案。 在这道题目中,我们可以使用 BFS 来解决问题。 我们首先需要定义状态的表示方式,可以这么表示: 1. 4*4的数组board表示状态。 2. 一个结构体Node,代表搜索树的每个节点。其中状态的表示形式为board。还有一些列信息,包括横,纵坐标,深度depth,以及方向dir。 我们使用 queue 来存储每一层需要遍历的结点,对于每个结点,我们枚举它可以到达的状态,并将这些状态添加到队列中,继续进行下一层的遍历。直到达到目标状态。 因此,我们的搜索过程主要包括以下的步骤: 1. 判断当前状态是否是目标状态 2. 枚举当前状态可能到达的所有状态,并判断是否合法 3. 如果该状态未被访问过,添加该状态,进行遍历。 知道了上面的步骤,我们就可以使用 bfs 来解决问题了。 具体实现可以参考以下代码

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

九筒-

你的鼓励将是我创作的最大动力

¥2 ¥4 ¥6 ¥10 ¥20
输入1-500的整数
余额支付 (余额:-- )
扫码支付
扫码支付:¥2
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值