动态规划类题目

/*问题 1 背包问题 
(需要花费的时间，幸福感)
比如  成都(1天, 10)   上海(3天, 20)   重庆(2天, 40)   武汉(4天, 50)  深圳(3天, 30)  北京 (3天, 20) 6个城市
问：如果你只有 n天的时间  怎么才能让幸福感最大
*/
struct city {
    string name;
    int cost;
    int weal;
    city() :name(""), cost(0), weal(0) {};
    city(const string& n, int c, int w) :name(n), cost(c), weal(w) {};
};
int solve(int n, vector<city>& city_arr) {
    
    if (n == 0) return 0;
    int len = city_arr.size();
    if (len == 0) return 0;

    vector<vector<int>> dp(len + 1, vector<int>(n + 1, 0));
    // dp[i][j]: 在i个城市中选择  花费j天 的最大幸福指数
    for (int i = 1; i <= len; ++i) {
        for (int j = 1; j <= n; ++j) {
            if (city_arr[i - 1].cost > j) dp[i][j] = dp[i - 1][j];
            else  
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - city_arr[i - 1].cost] +         city_arr[i - 1].weal);
        }
    }

    return dp[len][n];
}

/*问题2
给定一个由'0'和'1'组成的2维矩阵，返回该矩阵中最大的由'1'组成的正方形的面积，输入的矩阵是字符形式而非数字形式。
输入：
[1,0,1,0,0],
[1,0,1,1,1],
[1,1,1,1,1],
[1,0,0,1,0]
返回值：4
*/
int solve2(vector<vector<char>>& matrix) {
	// dp[i][j] 表示 以这个坐标为正方形左下角坐标，能形成的正方形边长大小
	// 画图可得出规律 dp[i][j] = min(dp[i-1][j-1],dp[i][j-1],dp[i-1][j]) + 1
	int rows = matrix.size();
	if (rows == 0) return 0;
	int cols = matrix[0].size();
	if (cols == 0) return 0;
	int maxLen = 0;


	vector<vector<int>> dp(rows + 1, vector<int>(cols + 1, 0));
	for (int i = 1; i <= rows; ++i) {
		for (int j = 1; j <= cols; ++j) {
			if (matrix[i-1][j-1] == '1') {
				dp[i][j] = min(dp[i - 1][j - 1], min(dp[i][j - 1], dp[i - 1][j])) + 1;
				if (dp[i][j] > maxLen) maxLen = dp[i][j];
			}
		}
	}
	return maxLen * maxLen;
}

/*问题3  最长公共子序列*/
string LCS2(string str1, string str2) {

	string ret;
	int len1 = str1.size();
	int len2 = str2.size();
	int max = 0; // 公共子串最大长度
	int index = 0;// 最后相等的一个下标
	vector<vector<int>> dp(len1+1, vector<int>(len2+1, 0));

	// dp[n][m] 的值表示 长度 n 和 m 的字符串 含有的最大公共子串长度 
	// dp[i][j] = dp[i-1][j-1] + 1

	for (int i = 1; i <= len1; ++i) {
		for (int j = 1; j <= len2; ++j) {
			if (str1[i-1] == str2[j-1]) {
				dp[i][j] = dp[i-1][j-1] + 1;
				if (max < dp[i][j]) {
					max = dp[i][j];
					index = i;
				}
			}
		}
	}

	return str1.substr(index-max, max);
}

/*问题4
* 输入一个长度为n的整型数组array，数组中的一个或连续多个整数组成一个子数组，
* 子数组最小长度为1。
* 求所有子数组的和的最大值。
*/

int max_sum(vector<int>& array) {
	int max = -(0x7fffffff) - 1;
	int len = array.size();
	
	if (len == 0) return 0;
	if (len == 1) return array[0];

	
	// 如果最大的是负数直接返回最大值
	// f[n] = max(f[n-1] + array[n], array[n])
	vector<int> dp(len, 0);
	dp[0] = array[0];
	for (int i = 1; i < len; ++i) {
		dp[i] = std::max(dp[i-1] + array[i], array[i]);
		if(max < dp[i]) max = dp[i];
	}

	return max;
}

/* 问题5
给一个整数n, 返回 1..n 能组成的 搜索二叉树 的 种类
1 2  3  
*/

int create_tree_num(int n) {
	vector<int> dp(n + 1);
	dp[0] = 1;
	for (int i = 1; i <= n; ++i) {
		for (int j = 1; j <= i; ++j) {// 以 j 为 root节点
			dp[i] += dp[j - 1] * dp[i - j]; // 只与长度有关
		}
	}
	return dp[n];
}

/*问题6
求数组最长的 波浪子序列长度（前后差值一正一负交错）  1    7      2      1     6    8  
										        6    -5    -1     5     2
											ret: 4
if(arr[i] < arr[i+1])   up = down + 1
if(arr[i] > arr[i+1])   down = up + 1
*/
int longest(const vector<int>& arr) {
	int len = arr.size();
	if (len == 0 || len == 1) return len;
	// vector<int> dp(len + 1, 0);
	int up = 0;
	int down = 0;

	for (int i = 0; i < len - 1; ++i) {
		if (arr[i] < arr[i + 1])  up = down + 1;
		else if (arr[i] > arr[i + 1])   down = up + 1;
	}
	
	return max(up, down);
}