跃动的题解

题目描述

小蓝在一个 nm 列的方格图中玩一个游戏。

开始时,小蓝站在方格图的左上角,即第 11 行第 11 列。

小蓝可以在方格图上走动,走动时,如果当前在第 r 行第 c 列,他不能走到行号比 r 小的行,也不能走到列号比 c 小的列。同时,他一步走的直线距离不超过 33。

例如,如果当前小蓝在第 33 行第 55 列,他下一步可以走到第 33 行第 66 列、第 33 行第 77 列、第 33 行第 88 列、第 44 行第 55 列、第 44 行第 66 列、第 44 行第 77 列、第 55 行第 55 列、第 55 行第 66 列、第 66 行第 55 列之一。

小蓝最终要走到第 n 行第 m 列。

在图中,有的位置有奖励,走上去即可获得,有的位置有惩罚,走上去就要接受惩罚。奖励和惩罚最终抽象成一个权值,奖励为正,惩罚为负。

小蓝希望,从第 11 行第 11 列走到第 n 行第 m 列后,总的权值和最大。请问最大是多少?

输入描述

输入的第一行包含两个整数 n,m,表示图的大小。

接下来 n 行,每行 m 个整数,表示方格图中每个点的权值。

其中,1≤n≤100,−104≤权值≤1041≤n≤100,−104≤权值≤104

输出描述

输出一个整数,表示最大权值和。


解题思路:先定义一个二维数组,用于代表行与列。

然后根据游戏规则编写规则代码,但初始并无任何思绪,耽搁了好长时间,最终我就开始扒别人的代码,勉强可以理解,

它将行和列可以挪动的长度定义成了两个数组,且在规则上相关联;

static int dx[] = {0,0,0,1,2,3,1,2,1};
static int dy[] = {1,2,3,0,0,0,1,1,2};

利用这两个有关联的数组,递归(得出一个完整的路线)与循环(决定从第一步走到最后一步的各种路线)输出最后的权重,再将这几个权值进行比较,找出最大的。

正确代码:

import java.util.Scanner;

public class Main {
    static Scanner sr = new Scanner(System.in);
    static int n = sr.nextInt();
    static int m = sr.nextInt();
    static int[][] map = new int[n][m];
    static int dx[] = {0,0,0,1,2,3,1,2,1};
    static int dy[] = {1,2,3,0,0,0,1,1,2};
    static int max_length = Integer.MIN_VALUE;
    public static void main(String[] args) {
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                map[i][j] = sr.nextInt();
            }
        }
        dfs(0,0, map[0][0]);
        System.out.println(max_length);
    }
    private static void dfs(int i, int j, int length) {
        // TODO Auto-generated method stub
        if(i==n-1 && j== m-1)
            max_length = Math.max(length, max_length);//更新最长长度
        for (int k = 0; k < dx.length; k++) {
            int nx = i + dx[k];
            int ny = j + dy[k];
            //根据范围内坐标进行递归
            if (nx >= 0 && ny >= 0 && nx < n && ny < m ) {
                dfs(nx,ny,length+map[nx][ny]);//进行递归
            }
        }
    }
}

收获:锻炼了一下思维的开阔性,以及复习了一下递归的知识和了解了一下Integer.MIN_VALUE;

递归的特点

1,函数内部自己调用自己

2,必须有出口

Integer.MAX_VALUE表示:int 数据类型的最大值,即:2147483647。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
06-01
这道题是一道典型的费用限制最短路题目,可以使用 Dijkstra 算法或者 SPFA 算法来解决。 具体思路如下: 1. 首先,我们需要读入输入数据。输入数据中包含了道路的数量、起点和终点,以及每条道路的起点、终点、长度和限制费用。 2. 接着,我们需要使用邻接表或邻接矩阵来存储图的信息。对于每条道路,我们可以将其起点和终点作为一个有向边的起点和终点,长度作为边权,限制费用作为边权的上界。 3. 然后,我们可以使用 Dijkstra 算法或 SPFA 算法求解从起点到终点的最短路径。在这个过程中,我们需要记录到每个点的最小费用和最小长度,以及更新每条边的最小费用和最小长度。 4. 最后,我们输出从起点到终点的最短路径长度即可。 需要注意的是,在使用 Dijkstra 算法或 SPFA 算法时,需要对每个点的最小费用和最小长度进行松弛操作。具体来说,当我们从一个点 u 经过一条边 (u,v) 到达另一个点 v 时,如果新的费用和长度比原来的小,则需要更新到达 v 的最小费用和最小长度,并将 v 加入到优先队列(Dijkstra 算法)或队列(SPFA 算法)中。 此外,还需要注意处理边权为 0 或负数的情况,以及处理无法到达终点的情况。 代码实现可以参考以下样例代码: ```c++ #include <cstdio> #include <cstring> #include <queue> #include <vector> using namespace std; const int MAXN = 1005, MAXM = 20005, INF = 0x3f3f3f3f; int n, m, s, t, cnt; int head[MAXN], dis[MAXN], vis[MAXN]; struct Edge { int v, w, c, nxt; } e[MAXM]; void addEdge(int u, int v, int w, int c) { e[++cnt].v = v, e[cnt].w = w, e[cnt].c = c, e[cnt].nxt = head[u], head[u] = cnt; } void dijkstra() { priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q; memset(dis, 0x3f, sizeof(dis)); memset(vis, 0, sizeof(vis)); dis[s] = 0; q.push(make_pair(0, s)); while (!q.empty()) { int u = q.top().second; q.pop(); if (vis[u]) continue; vis[u] = 1; for (int i = head[u]; i != -1; i = e[i].nxt) { int v = e[i].v, w = e[i].w, c = e[i].c; if (dis[u] + w < dis[v] && c >= dis[u] + w) { dis[v] = dis[u] + w; q.push(make_pair(dis[v], v)); } } } } int main() { memset(head, -1, sizeof(head)); scanf("%d %d %d %d", &n, &m, &s, &t); for (int i = 1; i <= m; i++) { int u, v, w, c; scanf("%d %d %d %d", &u, &v, &w, &c); addEdge(u, v, w, c); addEdge(v, u, w, c); } dijkstra(); if (dis[t] == INF) printf("-1\n"); else printf("%d\n", dis[t]); return 0; } ```

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值