从左上角到右下角的带有阈值的最大值

题目描述：

现在有一个8*8的棋盘，上面放着64个价值不等的礼物，每个小的棋盘上面放置一个礼物（礼物的价值大于0小于1000），一个人的初始位置在棋盘的左上角，每次他只能向下或向右移动一步，并拿走对应棋盘上的礼物，结束位置在棋盘的右下角，请设计一个算法使其能够获得最大价值的礼物。

输入：

输入包含多个测试用例，每个测试用例共有8行8列，第i行的第j列的数字代表了该处棋盘上的礼物的价值，每两个数之间用空格隔开。

输出：

对于每组测试用例，请输出你能够获得最大价值的礼物。

样例输入：

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

样例输出：

194

这是典型的动态规划就可以求解的题，首先用sum[][]数组复制测试数组，然后利用公式sum[i][j] = max(sum[i][j-1], sum[i-1][j])求得右下角的值。

具体代码：

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

int Max_sum(int A[][8], int m, int n)
{
	vector<vector<int> > sum(m, vector<int>(n));
	for (int i = 0; i < m; ++i)
	{
		for (int j = 0; j < n; ++j)
		{
			sum[i][j] = A[i][j];
		}
	}
	for (int i = 0; i < m; ++i)
	{
		for (int j = 0; j < n; ++j)
		{
			if (i == 0 && j == 0)
			{
				sum[i][j] = A[i][j];
			}
			else
				if (i == 0 && j > 0)
			    {
				    sum[i][j] += sum[i][j-1];
			    }
			else
				if (i > 0 && j == 0)
			    {
				    sum[i][j] += sum[i-1][j];
			    }
			else
				if (i > 0 && j > 0)
			    {
				    sum[i][j] += (sum[i-1][j] > sum[i][j-1])?sum[i-1][j]:sum[i][j-1];
			    }
		}
	}
	return sum[m-1][n-1];
}

拓展：

   
   

    
    

     
     
现在有一个8*8的棋盘，上面放着64个不同价值的礼物，每个小的棋盘上面放置一个礼物（礼物的价值大于0小于100），一个人初始位置在棋盘的左上角，每次他只能向下或向右移动一步，并拿走对应棋盘上的礼物，结束位置在棋盘的右下角。从棋盘的左上角移动到右下角的时候的，每次他只能向下或向右移动一步，并拿走对应棋盘上的礼物，但是拿到的所有的礼物的价值之和不大于一个限定值limit，请设计一个算法请实现，使其能够获得不超过限制值limit的最大价值的礼物。
     
     

    
    
   
   
   
   

    
    
     
     输入：
    
    
    
    

     
     
输入包含多个测试用例，每个测试用例共有9行，第一行是一个限制值limit<=1000，下面还有8行8列，第i行的第j列的数字代表了该处棋盘上的礼物的价值，每两个数之间用空格隔开。
     
     

    
    
   
   
   
   

    
    
     
     输出：
    
    
    
    

     
     
对于每组测试用例，请输出你能够获得不超过限制值limit的最大价值的礼物。若没有符合条件的线路则输出-1。
     
     

    
    
   
   
   
   

    
    
     
     样例输入：
    
    
    
    

     
     
90
4 2 5 1 3 8 9 7
4 5 2 3 7 1 8 6
7 2 1 8 5 9 3 6
2 8 9 5 6 3 1 7
1 2 4 5 3 7 9 6
3 5 7 8 9 6 2 4
10 8 1 4 7 5 3 9
7 4 6 2 1 3 9 8
    
    
   
   
   
   

    
    
     
     样例输出：
    
    
    
    

     
     
90
    
    
   
   

对测试数组arr来说，给定了右下角，即arr[7][7]的limit值，而从左上角到右下角要么通过arr[6][7]到右下角，要么通过arr[7][6]到右下角，而要求从左上角到右下角的limit下的最大值，那么我们只需求出从左上角到arr[6][7] 在limit-arr[7][7]限定值得情况下的 最大值，和从左上角到arr[7][6] 在limit-arr[7][7]限定值下的 最大值后，取其中的较大值就是结果。以此类推。

具体代码：

int max_limit_sum(int A[][8], int i, int j, int limit, int sum)
{
	if (i <0 || j < 0 || sum < 0)
	{
		return -1;
	}
	if (i == 0 && j == 0)
	{
		if (sum >= A[i][j])
		{
			return A[i][j];
		}
		else
			return -1;//-1表示从这条路找到的值会大于limit
	}
	int sum1 = -1, sum2 = -1;
	sum1 = max_limit_sum(A,i - 1,j, limit, sum - A[i][j]);
	sum2 = max_limit_sum(A,i, j - 1, limit, sum - A[i][j]);
	if (sum1 == -1 && sum2 == -1)
	{
		return -1;//两条路都不通
	}
	else
		if (sum1 != -1 && sum2 == -1)
		{
			return sum1 + A[i][j];//表示可以从左上角找到一条满足A[i][j]limit限制的到A[i][j]的路。
		}
		else
			if (sum1 == -1 && sum2 != -1)
			{
				return sum2 + A[i][j];
			}
			else
				return A[i][j] + (sum1 > sum2 ?sum1:sum2);
}

测试代码：

int main()
{
	//int A[8][8] = {2 ,8 ,15 ,1, 10, 5, 19, 19,
	//	3, 5, 6, 6, 2, 8, 2, 12,
	//	16, 3, 8, 17, 12, 5, 3, 14,
	//	13, 3, 2, 17, 19, 16, 8, 7,
	//	12, 19, 10, 13, 8, 20, 16, 15,
	//	4, 12, 3, 14, 14, 5, 2, 12,
	//	14, 9, 8, 5, 3, 18, 18, 20,
	//	4, 2, 10, 19, 17, 16, 11, 3};
	//cout << Max_sum(A, 8, 8) << endl;//输出正确
	int A[8][8] = {
		4, 2, 5, 1, 3, 8, 9, 7,
		4 ,5 ,2 ,3 ,7 ,1, 8 ,6,
		7, 2, 1, 8, 5, 9, 3, 6,
		2, 8, 9, 5, 6, 3, 1, 7,
		1, 2, 4, 5, 3, 7, 9, 6,
		3, 5, 7, 8, 9, 6, 2, 4,
		10, 8, 1, 4, 7, 5, 3, 9,
		7, 4, 6, 2, 1, 3, 9, 8
	};
	cout << max_limit_sum(A,7,7,90,90) << endl;//输出正确
	system("pause");
	return 1;
}