2017虹软校招算法题

本文为转载，原博客地址：http://blog.csdn.net/sgzqc/article/details/52593262

前段时间参加了虹软的校招笔试，遇到了一道算法题，现摘录下来做个备份。

题目： 给定一个mXn的矩阵，如下图所示，里面所有元素都非负，试找出一条从左上角到右下角的一条路径，要求路径上的数字之和最小。注：在某一个位置只有两种选择，向下或者向右。

1	4	8	2	9
1	4	6	7	8
1	1	1	1	1

在以上矩阵中，其中数字之和最小的路径为1-1-1-1-1-1-1，其最小和为7.

请给出你的解题思路，并完成int min_sum_path(int *mat, int row, int col)。其中函数返回值为路径和的最小值，最后给出你算法的时间复杂度。

思路一： 可直接用回溯算法，每次从当前位置有2种选择，要么向右，要么向下，示例代码如下：

[cpp]  view plain  copy

1. //===============================================================  
2. //Author :   
3. //                    Andrew  
4. //Date   :  
5. //                2016/09/20 10:32:32  
6. //Mail   :  
7. //               andrewzhao1020@gmail.com  
8. //===============================================================  
9.   
10. #include <iostream>  
11. #include<string>  
12. #include<vector>  
13. using namespace std;  
14.   
15. //存放位置  
16. int POSX[10];  
17. int POSY[10];  
18.   
19. void DFS(int depth, int i, int j, int *mat, int m, int n, int &cursum, int &minsum)  
20. {  
21.     //记录位置  
22.     POSX[depth] = i;  
23.     POSY[depth] = j;  
24.     //迭代结束  
25.     if (depth == n + m - 1)  
26.     {  
27.         return;  
28.     }  
29.     //更新最小值  
30.     if (i == m - 1 && j == n - 1 && cursum < minsum)  
31.         minsum = cursum;  
32.     //右  
33.     if (i<m && j + 1<n)  
34.     {  
35.         cursum += mat[i*n + (j + 1)];  
36.         DFS(depth + 1, i, j + 1, mat, m, n, cursum, minsum);  
37.         cursum -= mat[i*n + (j + 1)];  
38.     }  
39.     //下  
40.     if (i + 1<m && j<n)  
41.     {  
42.         cursum += mat[(i + 1)*n + j];  
43.         DFS(depth + 1, i + 1, j, mat, m, n, cursum, minsum);  
44.         cursum -= mat[(i + 1)*n + j];  
45.     }  
46.   
47. }  
48.   
49. int min_sum_path(int *mat, int row, int col)  
50. {  
51.     int cursum = mat[0];  
52.     int minsum = 10000;  
53.     //求最值  
54.     DFS(0, 0, 0, mat, row, col, cursum, minsum);  
55.   
56.     return minsum;  
57. }  
58.   
59. int main()  
60. {  
61.     int mat[] = { 1, 4, 8, 2, 9, 1, 4, 6, 7, 8, 1, 1, 1, 1, 1 };  
62.     int row = 3;  
63.     int col = 5;  
64.       
65.     int answer = min_sum_path(mat,  row,  col);  
66.     cout << "answer = " << answer << endl;  
67.       
68.     //输出位置  
69.     for (int i = 0; i<row + col - 1; i++)  
70.     {  
71.         cout << mat[POSX[i]* col + POSY[i]] << " ";  
72.     }  
73.     cout << endl;  
74.   
75.     return 0;  
76. }  

思路二： 动态规划，将该一维数组视为二维数组，由于每个位置只能往右或者往下走，不妨记F(i,j)表示从起点到位置（i，j）处的路径和的最小值，则状态转移方程为:

F(i+1,j+1) = min(F(i,j+1), F(i+1,j)) + mat[i+1][j+1]   其中 0< i + 1<row   0< j+1<col

初始条件为，对于第一行的位置，因为只能向右到达 ，所以 F(0,j) = sum(0,j)    j=0...col; 对于第一列的位置，只能从起点向下到达，所以 F(i,0) = sum(i,0)  i = 0...row

据此，可得代码如下：

[cpp]  view plain  copy

1. //===============================================================  
2. //Author :   
3. //                    Andrew  
4. //Date   :  
5. //                2016/09/20 10:32:32  
6. //Mail   :  
7. //               andrewzhao1020@gmail.com  
8. //===============================================================  
9.   
10. #include <iostream>  
11. #include<string>  
12. #include<vector>  
13. #include<algorithm>  
14. using namespace std;  
15.   
16. int min_sum_path(int *mat, int row, int col)  
17. {  
18.     int i, j;  
19.     int dp[100][100] = { 0 };  
20.     dp[0][0] = mat[0];  
21.     //第一行  
22.     for ( j = 1; j < col; j++)  
23.         dp[0][j] = dp[0][j - 1] + mat[j];  
24.     //第一列  
25.     for ( i = 1; i < row; i++)  
26.         dp[i][0] = dp[i - 1][0] + mat[i*col];  
27.     //其他位置  
28.     for ( i = 1; i < row;i++)  
29.         for (j = 1; j < col; j++)  
30.             dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + mat[i*col + j];  
31.     return dp[row-1][col-1];  
32. }  
33. int main()  
34. {  
35.     int mat[] = { 1, 4, 8, 2, 9, 1, 4, 6, 7, 8, 1, 1, 1, 1, 1 };  
36.     int row = 3;  
37.     int col = 5;  
38.       
39.     int answer = min_sum_path(mat,  row,  col);  
40.     cout << "answer = " << answer << endl;  
41.       
42.     return 0;  
43. }