这部分题建立dp数组时，dp[i]表明的是使用第i个数值时候的情况。
1、300.最长递增子序列（不会，有个扩展优化答案没写）
dp[i]表示i之前包括i的以nums[i]结尾的最长递增子序列的长度
本题最关键的是要想到dp[i]由哪些状态可以推出来，并取最大值，那么很自然就能想到递推公式：dp[i] = max(dp[i], dp[j] + 1);
自己总结的重点：dp[i]表示第i个绝对会有。所以i后面的只要比较是否比i大就可以+1了，前面的都遍历一下取个最大，初始数值为1
答案：
class Solution {
public int lengthOfLIS(int[] nums) {
int[] dp = new int[nums.length];
int res = 0;
Arrays.fill(dp, 1);
for (int i = 1; i < dp.length; i++) {
for (int j = 0; j < i; j++) {
if (nums[i] > nums[j]) {
dp[i] = Math.max(dp[i], dp[j] + 1);
}
res = Math.max(res, dp[i]);
}
}
return res;
}
}2、最长连续递增序列（简单题）
跟上面的题一模一样，没什么好说的
class Solution {
public int findLengthOfLCIS(int[] nums) {
int[] dp = new int[nums.length];
Arrays.fill(dp , 1);
int res = 1;
for(int i=1;i<dp.length;i++){
if(nums[i] > nums[i-1]){
dp[i] = dp[i-1] + 1;
res = Math.max(res , dp[i]);
}
}
return res;
}
}3、718. 最长重复子数组（顺利）
有个优化注意一下。
class Solution {
public int findLength(int[] nums1, int[] nums2) {
int[][] dp = new int[nums1.length][nums2.length];
int res = 0;
for(int i=0;i<nums2.length;i++)
if(nums2[i] == nums1[0]){
dp[0][i] = 1;
res = 1;
}
for(int i=0;i<nums1.length;i++)
if(nums1[i] == nums2[0]){
dp[i][0] = 1;
res = 1;
}
for(int i=1;i<nums1.length;i++){
for(int j=1;j<nums2.length;j++){
if(nums1[i] == nums2[j]){
dp[i][j] = dp[i-1][j-1] + 1;
res = Math.max(res, dp[i][j]);
}
}
}
return res;
}
}答案建立数组有+1，这样之后就不用初始化了。
4、最长公共子序列（有一点卡）
这题写的时候有些混乱。没有做成累计的，想的是相等情况下，遍历前面的+1。如果二维没优化的话，就是On4复杂度了。
这次加了+1长度，省了初始化。
后来改回来了。
class Solution {
public int longestCommonSubsequence(String text1, String text2) {
int[][] dp = new int[text1.length()+1][text2.length()+1];
int res = 0;
for(int i=1;i<=text1.length();i++){
for(int j=1;j<=text2.length();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-1][j] , dp[i][j-1]);
}
}
return dp[text1.length()][text2.length()];
}
}标答也是之前那样。
5、1035.不相交的线（问题转化难）
这个题跟上面的题一模一样，有些背题的感觉了。
这题难数学转换上，线就像是找公共子序列相同的那个数值，不交叉就是要按顺序。所以跟上面的题目一样
class Solution {
public int maxUncrossedLines(int[] nums1, int[] nums2) {
int[][] dp = new int[nums1.length+1][nums2.length+1];
for(int i=1;i<=nums1.length;i++){
for(int j=1;j<=nums2.length;j++){
if(nums1[i-1] == nums2[j-1]){
dp[i][j] = dp[i-1][j-1] + 1;
}else
dp[i][j] = Math.max(dp[i-1][j] , dp[i][j-1]);
}
}
return dp[nums1.length][nums2.length];
}
}6、53. 最大子数组和（二分拓展没做）
这个题目之前做过，但用滑动窗口会比较复杂，拓展里还有二分的做法，之后做一下
class Solution {
public int maxSubArray(int[] nums) {
int[] dp = new int[nums.length];
dp[0] = nums[0];
int res = dp[0];
for(int i=1;i<nums.length;i++){
if(dp[i-1]<0)
dp[i] = nums[i];
else
dp[i] = dp[i-1] + nums[i];
res = Math.max(res , dp[i]);
}
return res;
}
}7、392. 判断子序列
如果在dp存储true/false比较麻烦，做的判断会比较多，所以还是用数量。这也是子序列动态规划最常用的。
写成一维的难度会大很多，不好优化，答案也没优化。
class Solution {
public boolean isSubsequence(String s, String t) {
int[][] dp = new int[s.length()+1][t.length()+1];
for(int i=1;i<=s.length();i++){
for(int j=1;j<=t.length();j++){
if(s.charAt(i-1) == t.charAt(j-1)){
dp[i][j] = dp[i-1][j-1] +1;
}else{
dp[i][j] = Math.max(dp[i-1][j] , dp[i][j-1]);
}
}
}
return dp[s.length()][t.length()] == s.length() ? true :false ;
}
}8、115. 不同的子序列（不会）
dp[i][j]：以i-1为结尾的s子序列中出现以j-1为结尾的t的个数为dp[i][j]。
当s[i - 1] 与 t[j - 1]相等时，dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
当s[i - 1] 与 t[j - 1]不相等时，dp[i][j]只有一部分组成，不用s[i - 1]来匹配（就是模拟在s中删除这个元素），即：dp[i - 1][j]
这里跟之前的差别是是否要一一对应，之前的题目是不考虑是否有重复性，只要有就直接加上去，而这里会考虑到有多少种情况。
初始化的时候dp[0][i]初始化为1，因为第一列中t字符串为空，可以直接匹配上，因为是空对空，所以都是1。
class Solution {
public int numDistinct(String s, String t) {
int[][] dp = new int[s.length() + 1][t.length() + 1];
for (int i = 0; i < s.length() + 1; i++) {
dp[i][0] = 1;
}
for (int i = 1; i < s.length() + 1; i++) {
for (int j = 1; j < t.length() + 1; j++) {
if (s.charAt(i - 1) == t.charAt(j - 1)) {
dp[i][j] = dp[i - 1][j - 1] + dp[i - 1][j];
}else{
dp[i][j] = dp[i - 1][j];
}
}
}
return dp[s.length()][t.length()];
}
}9、583. 两个字符串的删除操作
固定思路，不难。
需要注意的是初始化，和取左和上的min+1.
这俩字符串是对称的，谁一维二维差别不大。
class Solution {
public int minDistance(String word1, String word2) {
int[][] dp = new int[word1.length()+1][word2.length()+1];
for(int i = 1; i<= word2.length() ; i++){
dp[0][i] = i;
}
for(int i=1;i<=word1.length() ;i++)
dp[i][0] = i;
for(int i=1;i<=word1.length();i++){
for(int j=1;j<=word2.length();j++){
if(word1.charAt(i-1) == word2.charAt(j-1)){
dp[i][j] = dp[i-1][j-1];
}else
dp[i][j] = Math.min(dp[i-1][j] , dp[i][j-1]) + 1;
}
}
return dp[word1.length()][word2.length()];
}
}10、72.编辑距离
跟上面的题相比，多了一个改的情况。所以就多了dp[i-1][j-1] +1的情况。另外两个dp[i-1][j]和dp[i][j-1]这两种对应的是两个字符串的删。
一开始想把两个删除的情况给省了，但当出现一个字符串多一个字符串少的情况时候，删是最快的。
class Solution {
public int minDistance(String word1, String word2) {
int[][] dp = new int[word1.length()+1][word2.length()+1];
for(int i = 1; i<= word2.length() ; i++){
dp[0][i] = i;
}
for(int i=1;i<=word1.length() ;i++)
dp[i][0] = i;
for(int i=1;i<=word1.length();i++){
for(int j=1;j<=word2.length();j++){
if(word1.charAt(i-1) == word2.charAt(j-1)){
dp[i][j] = dp[i-1][j-1];
}else
dp[i][j] = Math.min(dp[i][j-1], Math.min(dp[i-1][j-1] , dp[i-1][j])) + 1;
}
}
return dp[word1.length()][word2.length()];
}
}但迭代
11、647. 回文子串
这个得定义一个起始点和终止点。Dp的作用可能就是为了判断是否为回文串方便一些，不用一个一个判断了，之前的dp记录了结果。
除了dp记录之前结果节约了判断回文串的复杂度，dp做法跟回溯的区别就是顺序问题了吧（也是为了dp能记录结果）
class Solution {
public int countSubstrings(String s) {
char[] chars = s.toCharArray();
int len = chars.length;
boolean[][] dp = new boolean[len][len];
int result = 0;
for (int i = len - 1; i >= 0; i--) {
for (int j = i; j < len; j++) {
if (chars[i] == chars[j]) {
if (j - i <= 1) { // 情况一 和 情况二
result++;
dp[i][j] = true;
} else if (dp[i + 1][j - 1]) { //情况三
result++;
dp[i][j] = true;
}
}
}
}
return result;
}
}12、516. 最长回文子序列
dp[i][j]：字符串s在[i, j]范围内最长的回文子序列的长度为dp[i][j]。
如果s[i]与s[j]相同，那么dp[i][j] = dp[i + 1][j - 1] + 2;
对于回文串来说都是些45度线，从下往上。之所以这样是因为按照递推公式来的，先得到的要先便利，这样一轮就都能得到结果。
另外递推公式，都是表示当前点用上的情况，这里用上指的是范围用上，而前面的问题用上是指位置i参与进去这种意思。
public class Solution {
public int longestPalindromeSubseq(String s) {
int len = s.length();
int[][] dp = new int[len + 1][len + 1];
for (int i = len - 1; i >= 0; i--) { // 从后往前遍历 保证情况不漏
dp[i][i] = 1; // 初始化
for (int j = i + 1; j < len; j++) {
if (s.charAt(i) == s.charAt(j)) {
dp[i][j] = dp[i + 1][j - 1] + 2;
} else {
dp[i][j] = Math.max(dp[i + 1][j], Math.max(dp[i][j], dp[i][j - 1]));
}
}
}
return dp[0][len - 1];
}
}
199
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
