动态规划 4/09

1 爬楼梯问题，爬一阶与两阶

/**
 *  爬楼梯问题，爬一阶与两阶
 */

int getNFloor(int n) {
	std::vector<int> dp(101,0);
	dp[0] = 0;
	dp[1] = 1;
	dp[2] = 2;
	for (int i = 3; i <= n; i++) {	
		dp[i] = dp[i-1] + dp[i-2];
	}
	return dp[n];
}

2 打家劫舍，求不连续的房间里如何获取财宝最多，主要是考虑取该元素还是不取该元素

/**
 * 打家劫舍，求不连续的房间里如何获取财宝最多，主要是考虑取该元素还是不取该元素 [3,1,6,2,8]间隔拿
 */
int getMony(std::vector<int> &nums) {
	if (!nums.size()) return 0;
	std::vector<int> dp(1001, 0);
	dp[0] = nums[0];
	dp[1] = max(nums[0], nums[1]);

	for (int i = 2; i < nums.size(); i++) {
		//DP[I]的值其实就是看当前房间取不取的问题，取的话，nums[i-1]就不能拿，要dp[i-2]与当前值相加才行
		//不取的话，则DP[I]其实就是DP[I-1]的值，看前面的最大值即可
		//因为两个相邻的房间不能同时拿
		dp[i] = max(dp[i-1], dp[i-2]+ nums[i]);
	}
	return dp[nums.size() - 1];
}

3 最大连续子段和

/**
 * 最大连续子段和,动态规划思想，临时和大于0就加，小于0就等于当前nums[i]
 */

int getMaxSub(std::vector<int> &nums) {
	int res = 0;
	std::vector<int> dp(nums.size(), 0);
	dp[0] = nums[0];
	for (int i = 1; i < nums.size(); i++) {
		//主要就是看当前 DP[I-1]+NUMS[I]与 NUMS[I]谁大，因为DP[I-1]+NUMS[I]可能是个负值
		dp[i] = max(dp[i-1]+nums[i], nums[i]);
		res = max(res, dp[i]);
	}
	return res;
}

4 找零钱，给定金额，获取最少的钞票数量
5 求最长递增子序列（非连续）

5  求最长递增子序列长度（非连续）

int getLongSub(std::vector<int> nums) {
	//普通 DP 方式，只需要看 DP[I]前面的哪个 DP 最大，且 NUMS[I]大于最大的队尾，则追加上就是dp[i]

	int res = 1;
	std::vector<int> dp(nums.size(), 0);
	dp[0] = nums[0];
	for (int i = 1; i < nums.size(); i++) {
		do[i] = 1;
		for (int j = 0; j < i; j++) {
			if (nums[i] > nums[j] && dp[i] < dp[j] + 1) {
				dp[i] = dp[j] +1;
			}
			res = max(res, dp[i]);
		}
	}
	return res;

	//用 vector 的栈来解决，比栈尾巴大就进去，否则就从栈底遍历到栈顶，找到第一个比当前元素大的，就替换掉后break；
	std::vector<int> stack; 
	stack.push_back(nums[0]);
	for (int i = 1; i < nums.size(); i++) {
		if (nums[i] > stack.back()) {
			stack.push_back(nums[i]);
		} else {
			for (int j = 0; j < stack.size(); j++) {
				if (stack[j] > nums[i]) {
					stack[j] = nums[i];
					break;
				}
			}
		}

	}
	//stack就是最长递增子序列
	return stack.size();
}

6给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

int minPathSum(vector<vector<int>>& grid) {
        if (grid.size() ==0)return 0;
        int row = grid.size();
        int column = grid[0].size();
        vector<vector<int>> dp(row, vector<int> (column, 0));

        dp[0][0] = grid[0][0];
        for(int i=1;i< column;i++) {
            dp[0][i] = dp[0][i-1] + grid[0][i];
        }
        for(int i=1;i<row;i++) {
            dp[i][0] = dp[i-1][0]+grid[i][0];
            for(int j=1;j<column;j++) {
                dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j];
            }
        }
        return dp[row-1][column-1];
    }