左神算法学习日记——动态规划进阶

给定一个数组，通过给数组中每一个数一个整数倍的值，求和为aim的所有可能性。
int recMonnum(vector<int>& arr, int index, int aim)
{
	if (index == arr.size())//当aim被减为0时，说明当前策略符合要求
		return (aim == 0 ? 1 : 0);
	int res = 0;
	for (int i = 0; i*arr[index] <= aim; i++)
	{
		res+=recMonnum(arr, index + 1, aim - i*arr[index]);//arr.size()个数字，每个数字都有aim/arr[i]种可能，所有可能中和为aim的数量就是结果
	}
	return res;
}

int dpMonnum(vector<int> arr, int aim)
{
	vector<vector<int>> dp(arr.size() + 1, vector<int>(aim + 1,0));//递归过程中curindex和curaim，有重复出现的状况，且后面的结果都是一种操作。
	dp[arr.size()][0] = 1;
	for (int i = arr.size()-1; i >= 0; i--)
		for (int rest = 0; rest<= aim; rest++)
			for (int j = 0; rest - j*arr[i] >= 0; j++)
			{
				dp[i][rest] += dp[i + 1][rest - j*arr[i]];//当前dp值可以优化为它下面的数和他之前一个累加和的数的和，因为之前一个累加和就相当于dp[i + 1][j - j*arr[i]]的和
			}
	return dp[0][aim];
}

int dpMonnum2(vector<int> arr, int aim)
{
	vector<vector<int>> dp(arr.size() + 1, vector<int>(aim + 1, 0));
	for (int i = 0; i <= arr.size();i++)
		dp[i][0] = 1;
	for (int i = arr.size() - 1; i >= 0; i--)
		for (int j = 0; j <= aim; j++)
		{
			dp[i][j] += j - arr[i] >= 0 ? dp[i][j - arr[i]] + dp[i + 1][j] : dp[i + 1][j];
		}
	return dp[0][aim];
}
给定一个整型数组arr, 代表数值不同的纸牌排成一条线 玩家A和玩家B依次拿走 每张纸牌, 规定玩家A先拿,
 玩家B后拿, 但是每个玩家每次只能拿走最左或最右 的纸牌, 玩家A和玩家B都绝顶聪明 请返回最后获胜者的
分数
int behget(vector<int>& arr, int l, int r);

int preget(vector<int>& arr, int l, int r)
{
	if (l == r)
		return arr[l];
	return max(arr[l] + behget(arr, l + 1, r), (arr[r]+behget(arr,l,r-1)));
}

int behget(vector<int>& arr, int l, int r)
{
	if (l == r)
		return 0;
	return min(preget(arr, l + 1, r), preget(arr, l, r - 1));
}

int recget(vector<int> arr)
{
	vector<vector<int>> behdp(arr.size(), vector<int>(arr.size(), 0));
	vector<vector<int>> predp(arr.size(), vector<int>(arr.size(), 0));
	for (int i = 0; i < arr.size(); i++)
	{
		predp[i][i] = arr[i];
	}
	for (int j = 1; j < arr.size(); j++)
	{
		for (int i = j - 1; i>=0;i--)
		{
			behdp[i][j] = min(predp[i][j - 1], predp[i + 1][j]);
			predp[i][j] = max((arr[j] + behdp[i][j - 1]), (arr[i] + behdp[i + 1][j]));
		}
	}
	return max(behdp[0][arr.size() - 1], predp[0][arr.size() - 1]);
}

int ways(int N, int objpos, int curpos, int restep)
{
	if (N<2 || objpos>N || objpos<1 || curpos>N || curpos < 1 || restep < 0)
		return 0;
	if (restep == 0)
		return curpos == objpos ? 1 : 0;
	if (curpos == N)
		return ways(N, objpos, curpos - 1, restep - 1);
	if (curpos == 1)
		return ways(N, objpos, curpos + 1, restep - 1);
	return ways(N, objpos, curpos - 1, restep - 1) + ways(N, objpos, curpos + 1, restep - 1);
}

int recways(int N, int objpos, int curpos, int step)
{
	vector<vector<int>> dp(step+1, vector<int>(N, 0));
	dp[0][objpos - 1] = 1;
	for (int i = 1; i <= step;i++)
	for (int j = 0; j < N; j++)
	{
		if (j == N - 1)
			dp[i][j] = dp[i - 1][j - 1];
		else if (j == 0)
			dp[i][j] = dp[i - 1][j + 1];
		else
			dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j + 1];
	}
	return dp[step][curpos - 1];
}