格子取数3

给定m*n的矩阵，每个位置是一个整数，从左上角开始，每次只能朝右、上和下走，并且不允许两次进入同一个格子，走到右上角，最小和。

#include <iostream>
using namespace std;

#define M 4
#define N 4

int dp[M][N];

void initDp() {
	for (int i = 0; i < M; ++i) {
		for (int j = 0; j < N; ++j) {
			dp[i][j] = INT_MAX;
		}
	}
}

//找出列中的最小值,返回对应行
int findMinInCol(int matrix[M][N], int col) {
	int row = 0;
	for (int i = 1; i < M; ++i) {
		if (matrix[i][col] < matrix[row][col]) {
			row = i;
		}
	}
	return row;
}

bool isVaild(int x, int y, int n) {
	if (x >= 0 && x < n && y >= 0 && y < n) {
		return true;
	}
	return false;
}

int getNum(int x, int y, int n) {
	return isVaild(x, y, n) ? dp[x][y] : INT_MAX;
}

int findMinCellPath(int matrix[M][N], int m, int n) {
	initDp();

//	第一列只能从(0,0)开始走,即dp[i][0]只有向下一个方向
	dp[0][0] = matrix[0][0];
	for (int i = 1; i < m; ++i) {
		dp[i][0] = dp[i - 1][0] + matrix[i][0];
	}

//枚举列,不往回走
	for (int i = 0; i < m; ++i) {
//枚举行
		for (int j = 1; j < n; ++j) {
			/*对行中的每一格(x,y),从(x,0)朝右走到(x,y),然后再从(x,y)朝上走到(0,y),
			 * 再从(x,y)朝下走到(n-1,y),然后记录走到这一格所需最小dp值*/
			dp[i][j] = min(dp[i][j], matrix[i][j] + dp[i][j - 1]);
			for (int k = i; k > 0; --k) {
				dp[k - 1][j] = min(dp[k - 1][j], dp[k][j] + matrix[k - 1][j]);
			}
			for (int k = i; k < n - 1; ++k) {
				dp[k + 1][j] = min(dp[k + 1][j], dp[k][j] + matrix[k + 1][j]);
			}
		}
	}

	/*找出最后一列最小dp值,即末列入口
	 * 再往回找,
	 * 一个格子的上一状态,即上下左3种(存在时),往对应最小dp走*/
	int minx = findMinInCol(dp, n - 1);
	int result = 0;
	for (int i = 0; i <= minx; ++i) {
		result += matrix[i][n - 1];
	}

	int miny = n - 1;
	int tmp1, tmp2;
	while (1) {
		int curx = minx - 1, cury = miny;
		if ((tmp1 = getNum(minx - 1, miny, n)
				> (tmp2 = getNum(minx, miny - 1, n)))) {
			tmp1 = tmp2;
			curx = minx;
			cury = miny - 1;
		}
		if (tmp1 > (tmp2 = getNum(minx + 1, miny, n))) {
			tmp1 = tmp2;
			curx = minx + 1;
			cury = miny;
		}

		minx = curx;
		miny = cury;
		if (!cury) {	//第一列
			for (int j = 0; j <= minx; ++j) {
				result += matrix[j][0];
			}
			return result;
		}

		result += matrix[curx][cury];
	}
	return result;
}