华为机试：最小传输时延

题目来源

• 华为机试：最小传输时延

题目描述

题目解析

思路：

• 要求最小时延，我的第一反应是迪克拉斯算法，但是它是一个矩阵，没必要
• 然后又想用动态规划来做，但是它有8个方向，不好处理
• 应该用DFS或者BFS，而求最小XXX，BFS更好一些
  • 如果BFS的话，需要计算每一个到达的终点时，需要多少时间，然后选出最小的那个

动态规划

class Solution{

public:
    int bfs(std::vector<std::vector<int>> &m){
        if(m.empty() || m[0].empty()){
            return 0;
        }

        int M = m.size(), N = m[0].size();
        std::vector<std::vector<int>> dp(M, std::vector<int>(N));
        dp[0][0] = m[0][0];
        // 初始化第0列（它只可能从上面转换而来）
        for (int i = 1; i < M; ++i) {
            if(m[i][0] != m[i-1][0]){    // 当前值和上一个值不一样
                dp[i][0] = m[i][0] +  dp[i - 1][0]; // 那么它需要在dp[i - 1][0]的基础上+自己的耗费
            }else{
                dp[i][0] = m[i][0] +  dp[i - 1][0] - 1;
            }
        }
        //初始化第1列（它只可能从左边转换而来）
        for (int j = 1; j < N; ++j) {
            if(m[0][j] != m[0][j - 1]){
                dp[0][j] = m[0][j] + dp[0][j - 1];
            }else{
                dp[0][j] = m[0][j] + dp[0][j - 1] - 1;
            }
        }

        for (int i = 1; i < M; ++i) {
            for (int j = 1; j < N; ++j) {
                int up = m[i][j] + dp[i - 1][j]; // 从上面走来
                if(m[i][j] == m[i - 1][j]){  
                    up = up - 1;  
                }
                int left = m[i][j] + dp[i][j - 1];  // 从左边来
                if(m[i][j] == m[i][j - 1]){
                    left = left - 1;
                }
                int tri = m[i][j] + dp[i - 1][j - 1]; // 从上斜边来
                if(m[i][j] == m[i][j - 1]){
                    tri = tri - 1;
                }
                dp[i][j] = std::min(left, std::min(up, tri));
            }
        }

        return dp[M - 1][N - 1];
    }
};

BFS

调试

int main(){
    vector<vector<int>> matrix1 = {{0, 2, 2},
                                   {1, 2, 1},
                                   {2, 2, 1}};
    vector<vector<int>> matrix2 = {{2, 2, 2},
                                   {2, 2, 2},
                                   {2, 2, 2}};
    Solution solo;
    cout << solo.bfs(matrix1) << endl;
    cout << solo.bfs(matrix2) << endl;
}