LeetCode题解之动态规划
Dynamic_programming
- 最长子序列
-
- 最长递增子序列
-
- 最长上升子序列
- 一组整数对能够构成的最长链
- 最长摆动子序列
- 最长公共子序列
- 0-1背包问题
-
- 目标和问题
- 一和零
最长子序列
已知一个序列 {S1, S2,…,Sn}，取出若干数组成新的序列 {Si1, Si2,…, Sim}，其中 i1、i2 … im 保持递增，即新序列中各个数仍然保持原数列中的先后顺序，称新序列为原序列的一个 子序列 。如果在子序列中，当下标 ix > iy 时，Six > Siy，称子序列为原序列的一个 递增子序列 。
最长递增子序列
定义一个数组 dp 存储最长递增子序列的长度，dp[n] 表示以 Sn 结尾的序列的最长递增子序列长度。对于一个递增子序列 {Si1, Si2,…,Sim}，如果 im < n 并且 Sim < Sn，此时 {Si1, Si2,…, Sim, Sn} 为一个递增子序列，递增子序列的长度增加 1。满足上述条件的递增子序列中，长度最长的那个递增子序列就是要找的，在长度最长的递增子序列上加上 Sn 就构成了以 Sn 为结尾的最长递增子序列。因此 dp[n] = max{ dp[i]+1 | Si < Sn && i < n} 。
因为在求 dp[n] 时可能无法找到一个满足条件的递增子序列，此时 {Sn} 就构成了递增子序列，需要对前面的求解方程做修改，令 dp[n] 最小为 1，即：对于一个长度为 N 的序列，最长递增子序列并不一定会以 SN 为结尾，因此 dp[N] 不是序列的最长递增子序列的长度，需要遍历 dp 数组找出最大值才是所要的结果，max{ dp[i] | 1 <= i <= N} 即为所求。
最长上升子序列
给定一个无序的整数数组，找到其中最长上升子序列的长度。
示例:
输入: [10,9,2,5,3,7,101,18]
输出: 4 解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。
public static int lengthOfLIS(int[] nums) {
if(nums==null||nums.length==0){
return 0;
}
int n=nums.length;
//保存以坐标i上的数结尾的最长递增子序列长度 所以需要跟nums[i]进行比较
int []dp=new int[n];
for(int i=0;i<n;i++){
int maxLen=1;//每次遍历重置最大长度
for(int j=0;j<i;j++){
if(nums[j]<nums[i]){
maxLen=Math.max(maxLen,dp[j]+1);//符合要求
}
}
dp[i]=maxLen;
}
int maxL=0;
for(int num:dp){
//因为不能保证以最后一个数字结尾的最长子字符串长度最大 所以要遍历找最大
maxL=Math.max(maxL,num);
}
return maxL;
}
降低时间复杂度
定义一个 tails 数组，其中 tails[i] 存储长度为 i + 1 的最长递增子序列的最后一个元素。对于一个元素 x，
- 如果它大于 tails 数组所有的值，那么把它添加到 tails 后面，表示最长递增子序列长度加 1；
- 如果 tails[i-1] < x <= tails[i]，那么更新 tails[i] = x。
例如对于数组[4,3,5,6]:
tails len num
[] 0 4
[4] 1 3
[3] 1 6
[3,6] 2 5
[3,5] 2 null
public int lengthOfLIS(int[] nums) {
int n = nums.length;
int[] tails = new int[n];
int len = 0;
for (int num : nums) {
int index = binarySearch(tails, len, num);
tails[index] = num;
if (index == len) {
len++;
}
}
return len;
}
private int binarySearch(int[] tails, int len, int key) {
int l = 0, h = len;
while (l < h) {
int mid = l + (h - l) / 2;
if (tails[mid] == key) {
return mid;
} else if (tails[mid] > key) {
h = mid;
} else {
l = mid + 1;
}
}
return l;
}
一组整数对能够构成的最长链
给出 n 个数对。 在每一个数对中，第一个数字总是比第二个数字小。当且仅当 b < c 时，数对(c, d) 才可以跟在 (a, b) 后面。我们用这种形式来构造一个数对链。给定一个对数集合，找出能够形成的最长数对链的长度。
输入: [[1,2], [2,3], [3,4]]
输出: 2
解释: 最长的数对链是 [1,2] -> [3,4]
public static int findLongestChain(int[][] pairs) {
if(pairs==null||pairs.length==0){
return 0;
}
Arrays.sort(pairs, new Comparator<int[]>() {
//根据二维数组的第一个元素进行排序
@Override
public int compare(int[] o1, int[] o2) {
return o1[0]-o2[0];
}
});
int []dp=new int[pairs.length];
for(int i=0;i<pairs.length;i++){
int maxLen=1;
for(int j=0;j<i;j++){
if(pairs[j][1]<pairs[i][0]){
maxLen=Math.max(maxLen,dp[j]+1);
}
}
dp[i]=maxLen;
}
int maxL=0;
for(int num:dp){
maxL=Math.max(maxL,num);
}
return maxL;
}
最长摆动子序列
如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。
输入: [1,17,5,10,13,15,10,5,16,8]
输出: 7
解释: 这个序列包含几个长度为 7 摆动序列，其中一个为[1,17,10,13,10,16,8]
输入: [1,7,4,9,2,5]
输出: 6
分析：
数组中的任何元素都对应下面三种可能状态中的一种：
上升的位置，意味着 nums[i] > nums[i - 1]
下降的位置，意味着 nums[i] < nums[i - 1]
相同的位置，意味着 nums[i] == nums[i - 1]
更新的过程如下：
- 如果 nums[i] > nums[i-1]，意味着这里在i处摆动上升，使用前一个位置下降的最大长度。所以 up[i] =down[i-1] + 1， down[i] 与 down[i−1] 保持相同
- 如果 nums[i] < nums[i-1]，意味着这里在摆动下降，使用前一个位置上升的最大长度。所以 down[i] = up[i-1] + 1，up[i]与 up[i−1] 保持不变
- 如果 nums[i] == nums[i-1]，意味着这个元素不会改变任何东西因为它没有摆动。所以 down[i] 与 up[i]与down[i−1] 和 up[i−1] 都分别保持不变。
- 最后，将 up[length-1]和 down[length−1] 中的较大值作为问题的答案
设置up 和down等于1是因为默认第一个元素是up或down点 假如它的后一个元素比他大 那么截止到该元素的up必然等于1+1=2 down同理
public class Solution {
public int wiggleMaxLength(int[] nums) {
if (nums.length < 2)
return nums.length;
int[] up = new int[nums.length];
int[] down = new int[nums.length];
up[0] = down[0] = 1;
for (int i = 1; i < nums.length; i++) {
if (nums[i] > nums[i - 1]) {
up[i] = down[i - 1] + 1;
down[i] = down[i - 1];
} else if (nums[i] < nums[i - 1]) {
down[i] = up[i - 1] + 1;
up[i] = up[i - 1];
} else {
down[i] = down[i - 1];
up[i] = up[i - 1];
}
}
return Math.max(down[nums.length - 1], up[nums.length - 1]);
}
}
空间优化的动态规划
public static int wiggleMaxLength(int[] nums) {
if(nums==null||nums.length==0){
return 0;
}
int n=nums.length;
if(n<=2){
return n;
}
int up=1,down=1;
for(int i=1;i<n;i++){
if(nums[i-1]<nums[i]){
up=down+1;
}else{
down=up+1;
}
}
return Math.max(up,down);
}
最长公共子序列
给定两个字符串 text1 和 text2，返回这两个字符串的最长公共子序列的长度。若这两个字符串没有公共子序列，则返回 0。一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。
输入：text1 = "abcde", text2 = "ace"
输出：3
解释：最长公共子序列是 "ace"，它的长度为 3。
输入：text1 = "abc", text2 = "abc"
输出：3
解释：最长公共子序列是 "abc"，它的长度为 3。
public int longestCommonSubsequence(String text1, String text2) {
int len1=text1.length();
int len2=text2.length();
int [][]dp=new int[len1+1][len2+1];
for(int i=1;i<=len1;i++){
for(int j=1;j<=len2;j++){
if(text1.charAt(i-1)==text2.charAt(j-1)){
dp[i][j]=dp[i-1][j-1]+1;
}else{
dp[i][j]=Math.max(dp[i][j-1],dp[i-1][j]);
}
}
}
return dp[len1][len2];
}
0-1背包问题
之所以叫做0-1背包问题，是由于对于每个物体而言只有选择和不选择两种情况。
题目
有N件物品和一个容量为V的背包。第i件物品的费用是w[i]，价值是v[i]，求将哪些物品装入背包可使价值总和最大。
基本思路
这是最基础的背包问题，特点是：每种物品仅有一件，可以选择放或不放。
用子问题定义状态：即f[i][j]表示前i件物品恰放入一个容量为j的背包可以获得的最大价值。则其状态转移方程便是：
f[i][j]=max(f[i−1][j],f[i−1][j−w[i]]+v[i])
优化问题：
for (int i = 1; i <= n; i++)
for (int j = V; j >= 0; j--)
f[j] = max(f[j], f[j - w[i]] + v[i]);
或
for (int i = 1; i <= n; i++)
for (int j = V; j >= w[i]; j--)
f[j] = max(f[j], f[j - w[i]] + v[i]);
初始化问题：
- 如果是第一种问法，要求恰好装满背包，那么在初始化时除了f[0]为0其它f[1…V]均设为−∞，这样就可以保证最终得到的f[N]是一种恰好装满背包的最优解。
- 如果并没有要求必须把背包装满，而是只希望价格尽量大，初始化时应该将f[0…V]全部设为0。
题目：
划分数组为和相等的两部分
Input: [1, 5, 11, 5]
Output: true
Explanation: The array can be partitioned as [1, 5, 5] and [11].
将数组划分为相同的部分 等价于 像一个背包中放数，保证所放的数和是所有数之和的一半
首先获取这个限制性的和,如果是奇数，那么题目无法满足
其次定义一个数组 dp[i]表示原数组是否可以取出若干个数字，其和为i
进行数组遍历,需要注意数组中的数只有小于目标时才有可能被添加进来
同时如果 dp[i - num]为true的话，说明现在已经可以组成 i-num 这个数字了，再加上num，就可以组成数字i了，那么dp[j]就一定为true。
如果之前dp[j]已经为true了，当然还要保持true，所以还要‘或’上自身
最后返回dp[target] 判断能否组成这个数字即可
public static boolean canPartition(int[] nums){
int sum = computeArraySum(nums);
if(sum%2!=0){
return false;
}
int target=sum/2;
boolean [] dp=new boolean[target+1];
dp[0]=true;
for(int num:nums){
for(int i=target;i>=1;i--){
if(i>=num){
dp[i]=dp[i]||dp[i-num];
}
}
}
return dp[target];
}
private static int computeArraySum(int [] nums){
int sum=0;
for (int num : nums) {
sum=sum+num;
}
return sum;
}
目标和问题
给定一个非负整数数组，a1, a2, …, an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。返回可以使最终数组和为目标数 S 的所有添加符号的方法数。
输入: nums: [1, 1, 1, 1, 1], S: 3
输出: 5
解释:
-1+1+1+1+1 = 3
+1-1+1+1+1 = 3
+1+1-1+1+1 = 3
+1+1+1-1+1 = 3
+1+1+1+1-1 = 3
一共有5种方法让最终目标和为3。
分析：
该问题可以转换为 Subset Sum 问题，从而使用 0-1 背包的方法来求解。可以将这组数看成两部分，P 和 N，其中 P 使用正号，N 使用负号，有以下推导：
sum(P) - sum(N) = target
sum(P) + sum(N) + sum(P) - sum(N) = target + sum(P) + sum(N)
2 * sum(P) = target + sum(nums)
因此只要找到一个子集，令它们都取正号，并且和等于 (target + sum(nums))/2，就证明存在解。
dp[i]表示在数组中选取正负数，最后之和等于i的排列方式个数
public static int findTargetSumWays(int[] nums, int S){
int sum=computeArraySum(nums);
if(sum<S||(S+sum)%2!=0){
return 0;
}
int target=(sum+S)/2;
int []dp=new int[target+1];
dp[0]=1;
for(int num:nums){
for(int i=target;i>=0;i--){
if(i>=num){
dp[i]=dp[i]+dp[i-num];
}
}
}
return dp[target];
}
private static int computeArraySum(int [] nums){
int sum=0;
for (int num : nums) {
sum=sum+num;
}
return sum;
}
一和零
现在，假设你分别支配着 m 个 0 和 n 个 1。另外，还有一个仅包含 0 和 1 字符串的数组。你的任务是使用给定的 m 个 0 和 n 个 1 ，找到能拼出存在于数组中的字符串的最大数量。每个 0 和 1 至多被使用一次。
Input: Array = {
"10", "0001", "111001", "1", "0"}, m = 5, n = 3
Output: 4
Explanation: There are totally 4 strings can be formed by the using of 5 0s and 3 1s, which are "10","0001","1","0"
分析：
这是一个多维费用的 0-1 背包问题，有两个背包大小，0 的数量和 1 的数量。
dp[i][j]是使用i个0 和j个i能组成的字符串数量的最大值
public static int findMaxForm(String[] strs, int m, int n){
if(strs==null||strs.length==0){
return 0;
}
int [][]dp=new int[m+1][n+1];
for(String str:strs){
//逐步遍历字符串数组
int ones=0,zeros=0;
char []chars=str.toCharArray();
//先获取资源数 也就是0和1的个数
for (char aChar : chars) {
if(aChar=='0'){
zeros++;
}else{
ones++;
}
}
for(int i=m;i>=0;i--){
for(int j=n;j>=0;j--){
if(i>=zeros&&j>=ones){
dp[i][j]=Math.max(dp[i][j],dp[i-zeros][j-ones]+1);
}
}
}
}
return dp[m][n];
}