华为od机试-最小传输时延Ⅱ

题目描述

有 M*N 的节点短阵，每个节点可以向 8 个方向(上、下、左、右及四个斜线方向)转发数据包，每个节点转发时会消耗固定时延，连续两个相同时延可以减少一个时延值(即当有K 个相同时延的节点连续转发时可以减少 K-1 个时延值)，求左上角 (0，0)开始转发数据包到右下角 (M-1，N- 1)并转发出的最短时延

输入描述

第一行两个数字，M、N，接下来有 M 行，每行有 N 个数据，表示 M* N 的矩阵。

输出描述

最短时延值。

用例

输入处理

m, n = map(int, input().split())
arr = [list(map(int, input().split())) for i in range(m)]
print(m, n, arr)

输出看看

3 3 [[0, 2, 2], [1, 2, 1], [2, 2, 1]]

算法解析

这是一个寻找最短路径的问题，可以使用 Dijkstra 算法或 A* 算法来解决。对于每个节点，它的周围八个方向都可以作为下一个节点进行转发，每次选择时延最小的节点进行转发，并更新其周围节点的时延值。需要注意的是，连续相同时延会减少时延值，因此需要记录当前连续相同时延的个数。最终到达右下角节点时的时延即为所求的最短时延。

代码

java

import java.util.*;

public class Main {
    private static final int[][] DIRECTIONS = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}, {-1, -1}, {-1, 1}, {1, -1}, {1, 1}};
    private static final Comparator<Node> COMPARATOR = Comparator.comparingInt(a -> a.delay);

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int m = scanner.nextInt();
        int n = scanner.nextInt();
        int[][] arr = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                arr[i][j] = scanner.nextInt();
            }
        }
        int res = shortestDelay(arr, m, n);
        System.out.println(res);
    }

    private static int shortestDelay(int[][] arr, int m, int n) {
        int[][] delay = new int[m][n]; // 记录每个节点的最短时延值
        PriorityQueue<Node> pq = new PriorityQueue<>(COMPARATOR); // 用小根堆存储待遍历的节点

        // 初始化起点
        delay[0][0] = arr[0][0];
        pq.offer(new Node(0, 0, arr[0][0]));

        while (!pq.isEmpty()) {
            Node cur = pq.poll();
            if (delay[cur.x][cur.y] == -1) continue; // 跳过已经访问过的节点

            // 遍历周围八个方向的节点
            for (int[] dir : DIRECTIONS) {
                int nx = cur.x + dir[0];
                int ny = cur.y + dir[1];
                if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue; // 越界判断
                int ndelay = cur.delay + calcDelay(arr, cur.x, cur.y, nx, ny);
                if (delay[nx][ny] == 0 || ndelay < delay[nx][ny]) { // 更新节点的最短时延值
                    delay[nx][ny] = ndelay;
                    pq.offer(new Node(nx, ny, ndelay));
                }
            }

            delay[cur.x][cur.y] = -1; // 标记当前节点已经访问过
        }

        return delay[m - 1][n - 1];
    }

    private static int calcDelay(int[][] arr, int x1, int y1, int x2, int y2) {
        if (x1 == x2 || y1 == y2) { // 直线移动
            return arr[x2][y2];
        } else { // 斜向移动
            if (arr[x1][y1] == arr[x2][y2]) { // 连续相同时延
                return arr[x2][y2];
            } else {
                return arr[x2][y2] + 1;
            }
        }
    }

    static class Node {
        int x;
        int y;
        int delay;

        public Node(int x, int y, int delay) {
            this.x = x;
            this.y = y;
            this.delay = delay;
        }
    }
}

python

import heapq

def shortest_delay(arr, m, n):
    DIRECTIONS = [(-1, 0), (0, -1), (1, 0), (0, 1), (-1, -1), (-1, 1), (1, -1), (1, 1)]

    def calc_delay(x1, y1, x2, y2):
        if x1 == x2 or y1 == y2: # 直线移动
            return arr[x2][y2]
        else: # 斜向移动
            if arr[x1][y1] == arr[x2][y2]: # 连续相同时延
                return arr[x2][y2]
            else:
                return arr[x2][y2] + 1

    delay = [[0] * n for _ in range(m)] # 记录每个节点的最短时延值
    pq = [(arr[0][0], 0, 0)] # 用小根堆存储待遍历的节点

    while pq:
        cur_delay, cur_x, cur_y = heapq.heappop(pq)
        if delay[cur_x][cur_y] == -1: continue # 跳过已经访问过的节点

        # 遍历周围八个方向的节点
        for dx, dy in DIRECTIONS:
            nx, ny = cur_x + dx, cur_y + dy
            if nx < 0 or nx >= m or ny < 0 or ny >= n: continue # 越界判断
            ndelay = cur_delay + calc_delay(cur_x, cur_y, nx, ny)
            if delay[nx][ny] == 0 or ndelay < delay[nx][ny]: # 更新节点的最短时延值
                delay[nx][ny] = ndelay
                heapq.heappush(pq, (ndelay, nx, ny))

        delay[cur_x][cur_y] = -1 # 标记当前节点已经访问过

    return delay[m - 1][n - 1]

if __name__ == '__main__':
    m, n = map(int, input().split())
    arr = [list(map(int, input().split())) for _ in range(m)]
    res = shortest_delay(arr, m, n)
    print(res)

C++

#include <iostream>
#include <vector>
#include <queue>
#include <functional>
using namespace std;

struct Node {
    int x, y, delay;
    bool operator>(const Node& other) const {
        return delay > other.delay;
    }
};

int shortestDelay(vector<vector<int>>& arr, int m, int n) {
    vector<vector<int>> delay(m, vector<int>(n)); // 记录每个节点的最短时延值
    priority_queue<Node, vector<Node>, greater<Node>> pq; // 用小根堆存储待遍历的节点

    // 初始化起点
    delay[0][0] = arr[0][0];
    pq.push({0, 0, arr[0][0]});

    while (!pq.empty()) {
        auto [cur_x, cur_y, cur_delay] = pq.top();
        pq.pop();
        if (delay[cur_x][cur_y] == -1) continue; // 跳过已经访问过的节点

        // 遍历周围八个方向的节点
        for (int i = -1; i <= 1; i++) {
            for (int j = -1; j <= 1; j++) {
                if (i == 0 && j == 0) continue; // 跳过当前节点
                int nx = cur_x + i;
                int ny = cur_y + j;
                if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue; // 越界判断
                int ndelay = cur_delay + ((i == 0 || j == 0) ? arr[nx][ny] : ((arr[cur_x][cur_y] == arr[nx][ny]) ? arr[nx][ny] : arr[nx][ny] + 1));
                if (delay[nx][ny] == 0 || ndelay < delay[nx][ny]) { // 更新节点的最短时延值
                    delay[nx][ny] = ndelay;
                    pq.push({nx, ny, ndelay});
                }
            }
        }

        delay[cur_x][cur_y] = -1; // 标记当前节点已经访问过
    }

    return delay[m - 1][n - 1];
}

int main() {
    int m, n;
    cin >> m >> n;
    vector<vector<int>> arr(m, vector<int>(n));
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
            cin >> arr[i][j];
        }
    }
    int res = shortestDelay(arr, m, n);
    cout << res << endl;
    return 0;
}

Java Script

function shortestDelay(arr, m, n) {
    const DIRECTIONS = [[-1, 0], [0, -1], [1, 0], [0, 1], [-1, -1], [-1, 1], [1, -1], [1, 1]];

    function calcDelay(x1, y1, x2, y2) {
        if (x1 === x2 || y1 === y2) { // 直线移动
            return arr[x2][y2];
        } else { // 斜向移动
            if (arr[x1][y1] === arr[x2][y2]) { // 连续相同时延
                return arr[x2][y2];
            } else {
                return arr[x2][y2] + 1;
            }
        }
    }

    let delay = Array.from({ length: m }, () => Array.from({ length: n }).fill(0)); // 记录每个节点的最短时延值
    let pq = [[arr[0][0], 0, 0]]; // 用小根堆存储待遍历的节点

    while (pq.length > 0) {
        let [cur_delay, cur_x, cur_y] = pq.shift();
        if (delay[cur_x][cur_y] === -1) continue; // 跳过已经访问过的节点

        // 遍历周围八个方向的节点
        for (let [dx, dy] of DIRECTIONS) {
            let nx = cur_x + dx;
            let ny = cur_y + dy;
            if (nx < 0 || nx >= m || ny < 0 || ny >= n) continue; // 越界判断
            let ndelay = cur_delay + calcDelay(cur_x, cur_y, nx, ny);
            if (delay[nx][ny] === 0 || ndelay < delay[nx][ny]) { // 更新节点的最短时延值
                delay[nx][ny] = ndelay;
                pq.push([ndelay, nx, ny]);
            }
        }

        delay[cur_x][cur_y] = -1; // 标记当前节点已经访问过
    }

    return delay[m - 1][n - 1];
}

const readline = require('readline');
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

let m, n, arr;
rl.on('line', line => {
    if (!m) {
        [m, n] = line.trim().split(' ').map(Number);
        arr = Array.from({ length: m }, () => []);
    } else {
        arr[m - 1] = line.trim().split(' ').map(Number);
        m--;
        if (m === 0) {
            let res = shortestDelay(arr, n, n);
            console.log(res);
            rl.close();
        }
    }
});