动态规划_有一个行数n和列数m的矩阵,它每个格子有一个权值

1.走方格问题

有一个矩阵map，它每个格子有一个权值。从左上角的格子开始每次只能向右或者向下走，最后到达右下角的位置，路径上所有的数字累加起来就是路径和，返回所有的路径中最小的路径和。给定一个矩阵map及它的行数n和列数m，请返回最小路径和。保证行列数均小于等于100.

第一行，输入n,m表示这个矩阵的行数和列数，接下来的n行，输入每行的m个数字，也即每个格子的权值。最后输出最小路径和。

到某个特定各格子的最小路径和只取决于走到它左边和上边的最小路径和，再加上这个格子的权值。

而对于第一行和第一列的格子，它们的最小路径和就是顺着走下来。

int get_min(const int(*map)[100],int row,int col) {
    int dp[100][100]={0};
    int i,j;

    dp[0][0]=map[0][0];
    for(i=1;i<col;i++) {
        dp[0][i]=map[0][i]+dp[0][i-1];  //算出每一行的dp初始值
    }
    for(i=1;i<row;i++) {
        dp[i][0]=map[i][0]+dp[i-1][0];  //算出每一列的dp初始值
    }

    for(i=1;i<row;i++) {
        for(j=1;j<col;j++) {
            dp[i][j]=map[i][j]+Min(dp[i-1][j],dp[i][j-1]);
        }
    }

    return dp[row-1][col-1];
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

类似，还有数字三角形：

在数字三角形中寻找一条从顶部到底边的路径，使得路径上所经过的数字之和最大。路径上的每一步都只能往左下或 右下走。只需要求出这个最大和即可，不必给出具体路径。 三角形的行数大于1小于等于100，数字为 0 - 99。

这种题型不过是变形而已，但是因为到达最后一条边最大，所以需要比较一下最后每一行的数返回最大的数。

#include<stdio.h>

void get_triangle(int(*triangle)[100],int row);

int get_max(const int(*triangle)[100],int row);
int Max(int num1,int num2);
int Max_result(int*last,int row);

int main() {
    int triangle[100][100]={0};
    int row;
    int maxsum;

    scanf("%d",&row);
    get_triangle(triangle,row);

    maxsum=get_max(triangle,row);

    printf("%d\n",maxsum);

    return 0;
}

void get_triangle(int(*triangle)[100],int row) {
    int i,j;

    for(i=0;i<row;i++) {
        for(j=0;j<=i;j++) {
            scanf("%d",&triangle[i][j]);
        }
    }
}

int get_max(const int(*triangle)[100],int row) {
    int dp[100][100]={0};
    int i,j;

    dp[0][0]=triangle[0][0];
    for(i=1;i<row;i++) {
        dp[i][0]=dp[i-1][0]+triangle[i][0];
    }
    for(i=1;i<row;i++) {
        dp[i][i]=dp[i-1][i-1]+triangle[i][i];
    }

    for(i=2;i<row;i++) {
        for(j=1;j<i;j++) {
            dp[i][j]=Max(dp[i-1][j-1],dp[i-1][j])+triangle[i][j];
        }
    }

    return Max_result(dp[row-1],row);

}

int Max(int num1,int num2) {
    if(num1<num2) {
        return num2;
    }

    return num1;
}

int Max_result(int*last,int row) {
    int i;
    int max=last[0];

    for(i=0;i<row;i++) {
        if(last[i]>max) {
            max=last[i];
        }
    }

    return max;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

后来发现可以倒着往前算，这样最后算得的结果就是最终的最大值，不需要再进行一次比较了。