关于DP的一些解题总结

总结一道提交了无数遍的DP问题：

5. 最长回文子串，这是学习DP的一道提交了很长时间的题目：

这道题目用O(n3)O(n^3)O(n3) 的时间复杂度是比较容易的，显而易见会超时。用之前学的滑动窗口方法也是能做的，但是我的超时了、哭～，最后选择DP，下面是我提交的代码：

class Solution {public String longestPalindrome(String s) {int len = s.length();if(len <= 1) return s;boolean dp[][] = new boolean[len][len];for(int i = 0; i<len; i++)dp[i][i] = true;// ----------上面是初始化过程-----------------------int max = 0;String ret = "";for(int i = len-1; i>=0; i--){for(int j = i; j < len; j++){dp[i][j] = (s.charAt(i) == s.charAt(j))&& (j-i <= 2 || dp[i+1][j-1]);if(dp[i][j] && j-i+1>max){max = j-i+1;ret = s.substring(i,j+1);}}}return ret;}
}

其中dp[i][j]数组是index 的i到j是否是回文子串，这里我判断是根据如果s[i]和s[j] 是否相等，如果不相等那么dp[i][j]直接false，否则接着判断 dp[i+1][j-1]是否相等呢，如果继续相等，那就是回文子串，这里j-i 表示这么一类情况，比如 asa 这种我们只要判断两端相等了，就不用管中间那个单独的字母，这里最重要的是选择for循环的，for循环对解题取得关键作用，之前一直提交失败原因是for循环区间选错了，导致dp[i][j]先于dp[i+1][j-1] 出来，就默认 dp[i+1][j-1]为false，怎么都会失败。

下面还是一个DP问题，这是一道easy题目，但是我为了用DP做出来还是想了很久：

121. 买卖股票的最佳时机

很明显，用暴力两层循环也是能过的，但是没啥意思，暴力做了551ms，DP只要3ms

这里我的思路是不断找最小解之间的关系，我定义的DP[i]表示第i天卖出，最大利润，代码如下：

class Solution {public int maxProfit(int[] prices) {// 尝试用DP解决 dp[i]表示第i天最大的利润int len = prices.length;if(len == 0) return 0;Integer [] dp = new Integer[len];int max = 0;dp[0] = 0;int lastdp0 = prices[0];for(int i = 1; i<len; i++){dp[i] = prices[i] - lastdp0;if(dp[i] <= 0){dp[i] = 0;lastdp0 = prices[i];}else{if(dp[i] > max)max = dp[i];}}return max;}
}

首先明确初始解 dp[0] = 0 ，表示第0天卖出，没利润。dp[1]和dp[0]之间的关系：如果prices[1] < price[0]，表示股价跌了，还是没挣钱dp[1] = 0，如果 prices[1] > price[0] ，表示挣了dp[1] = price[1]-price[0]，推广开来，第i天最大利润是 prices[i] - (最后一个dp[j] = 0所对应的prices[j])，代码中，我用lastdp0记录下来。

139. 单词拆分，这是一道tag为DP的题目，但是我最终是用 DFS算出来的，每个失眠的夜晚脑袋都是这种题目~~

先上code：

class Solution {boolean res = false;public boolean wordBreak(String s, List<String> wordDict) {if(s.length() == 0) return true;Map<String,Integer> map = new HashMap();for(int i = 0; i<wordDict.size(); i++)map.put(wordDict.get(i),0);Boolean []mark = new Boolean[s.length()+1];return splits(s,0,s.length(),map,mark);}public boolean splits(String s, int start, int end, Map<String,Integer> map, Boolean []mark){for(int i = start; i<end; i++){String patern = s.substring(start,i+1);if(map.get(patern) != null && i+1 != end){boolean res1 = false;if(mark[i] != null)res1 = mark[i];else{res1 =  splits(s,i+1,end,map,mark);mark[i] = res1;}res = res || res1;}if(map.get(patern) != null && i+1 == end){return true;}}return false || res;}
}

不得不说，我的代码着实写的非常丑，我还是很有必要看一下代码简洁之美。大致解释一下我的代码：

首先，我把所有的wordDict放到map中，这里我后来发现没啥必要了，List有个contains方法就直接解决了这个问题。但是这不重要了，这里我重点还是想总结一下解题思路。这里递归终止的条件是 start到达了字符串最后的同时，最后一个字符串也匹配到了，此时是返回true。不然的话，就对除了匹配到的字符串，剩下的的字串接着匹配，同时为了剪枝，还要记录start位置，所对应的递归字串结果，如果之前已经记录下来了就不用再次递归了。重点是下面的代码：

if(map.get(patern) != null && i+1 != end){boolean res1 = false;if(mark[i] != null)res1 = mark[i];else{res1 =  splits(s,i+1,end,map,mark); //这里不立即返回的原因是还要对下面这种情况判断
// cantsrt   {"can","cant","srt"} 找到can还不能返回，还要接着找cant，最后汇总除can递归字串和除cant递归字串的结果 res = res || res1mark[i] = res1;}res = res || res1;  // 只要有一个递归最后完美结束了，就算找到了}

最后剪枝之后AC了，不剪枝是AC不了，碰到aaaaaaaaaaaa这种，时间复杂度就爆炸了( O(nn)O(n^n)O(nn) )。

下面是一道记忆化搜索问题（这种题目一般可以转DP）：

这道题和那道整数拆分一样的套路，也是记忆化搜索来进行剪枝。

class Solution {HashMap<Integer,Integer> map = new HashMap();public int numSquares(int n) {int val = (int)Math.sqrt(n);if(val*val == n) return 1;if(map.get(n) != null) return map.get(n);int res = Integer.MAX_VALUE;  //每次都要初始化这个结果值for(int i = 1; i*i<n;i++)res = Math.min(res,1+numSquares(n-i*i));map.put(n,res);return res;}
}

下面怎么转DP，这是个问题