LeetCode动态规划（中等难度）

这两题是求二叉树数目的

package com.coding.leetcode;

import java.util.List;
import java.util.ArrayList;
import com.coding.adt.*;

public class LeetCodeSolution{

    /**
    * 不同的二叉树1:
    * 思路：假设n个结点存在二叉排序树的个数死G(n)，1-n都可以作为根结点，1为根结点，左子树结点数为0,右子树结点数为n-1,2为根结点，左子树个数为1，右子树为n-2，
    * 以此类推可得G(n)=G(0)*G(n-1)+G(1)*G(N-2)+...+G(n-1)*G(0)
    */
    public int numTrees(int n){
      int[] result=new int[n+1];
      result[0]=1;
      result[1]=1;
      for(int i=2;i<n+1;++i){
        int sum=0;
        for(int j=1;j<i+1;++j){
          sum+=result[j-1]*result[i-j];
        }
        result[i]=sum;
      }
      return result[n];
    }

    public List<TreeNode> generateTrees(int n){
      List <TreeNode> res = new ArrayList<TreeNode>();
      if(n<1){
        return res;
      }else {
        return this.generateBST(1,n);
      }
    }

    private List<TreeNode> generateBST(int start,int end){
      List <TreeNode> res = new ArrayList<TreeNode>();
      if(start>end){
        res.add(null);
        return res;
      }else {
        for(int i=start;i<end+1;i++){
                List<TreeNode> leftChild=this.generateBST(start,i-1);
                List<TreeNode> rightChild=this.generateBST(i+1,end);
                for(TreeNode left:leftChild){
                    for(TreeNode right:rightChild){
                        TreeNode root=new TreeNode(i);
                        root.left=left;
                        root.right=right;
                        res.add(root);
                    }
                }
        return res;
      }
    }
} 
}

不同路径

    /**
    * 一个m*n的矩阵，从左上角到右下角共有多少种路径
    *
    **/
    public int uniquePaths(int m, int n) {
        int dp[][]=new int[m][n];
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                if(i==0||j==0)
                    dp[i][j]=1;
                else
                    dp[i][j]=dp[i-1][j]+dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }

264 丑数问题

编写一个程序，找出第 n 个丑数。

丑数就是只包含质因数 2, 3, 5 的正整数。

示例:

输入: n = 10
输出: 12
解释: 1, 2, 3, 4, 5, 6, 8, 9, 10, 12 是前 10 个丑数。
说明:  

1 是丑数。
n 不超过1690。

我看到的比较好的方法是使用了3指针结合动态规划

    public int nthUglyNumber(int n) {
        int[] dp=new int[n];
        dp[0]=1;
        int i2=0,i3=0,i5=0;
        for(int i=1;i<n;i++){
            int min=Math.min(dp[i2]*2,Math.min(dp[i3]*3,dp[i5]*5));
            if(min==dp[i2]*2)
                i2++;
            if(min==dp[i3]*3)
                i3++;
            if(min==dp[i5]*5)
                i5++;
            dp[i]=min;
        }
        return dp[n-1];
    }

还有个十分暴力的

/**
   * 丑数求解过程：首先除2，直到不能整除为止，然后除5到不能整除为止，然后除3直到不能整除为止。 最终判断剩余的数字是否为1，如果是1则为丑数，否则不是丑数
   * 
   * 解题思路： 从1开始遍历，按丑数求解过程找出满足条件的第n个丑数（提交超时） 思路优化（如何利用之前的计算）
   *
   * @param n
   * @return
   */
  public int nthUglyNumber2(int n) {
    map.put(1, true);
    int uglyCount = 1;
    int retVal = 1;
    for (int i = 2; i < Integer.MAX_VALUE; i++) {
      if (uglyCount > n) {
        break;
      }
      boolean isUgly = isUglyNumber(i);
      if (isUgly) {
        map.put(i, true);
        uglyCount++;
        retVal = i;
      }
    }
    return retVal;
  }

  private Map<Integer, Boolean> map = new HashMap<>();

  private boolean isUglyNumber(int num) {
    while (num % 2 == 0) {
      num /= 2;
      if (map.containsKey(num))
        return true;
    }
    while (num % 5 == 0) {
      num /= 5;
      if (map.containsKey(num))
        return true;
    }
    while (num % 3 == 0) {
      num /= 3;
      if (map.containsKey(num))
        return true;
    }
    return num == 1;
  }

5. 最长回文子串

package dp;

public class Palindromic {
	/**时间复杂度：两层 for 循环 O(n²）O(n²），for 循环里边判断是否为回文 O(n）O(n），所以时间复杂度为 O(n³）			O(n³）。

	空间复杂度：O(1）O(1），常数个变量。*/
    public String longestPalindrome(String s) {
        String ans = "";
        int max = 0;
        int len = s.length();
        for (int i = 0; i < len; i++) {
            for (int j = i + 1; j < len; j++) {
                String test = s.substring(i, j);
                if (isPadlindromic(test) && test.length() > max) {
                    ans = test;
                    max = Math.max(max, test.length());
                }
            }
        }
        return ans;
    }

    public boolean isPadlindromic(String test) {
        int len = test.length();
        boolean flag = true;
        for (int i = 0; i < len / 2; i++) {
            if (test.charAt(i) != test.charAt(len - i - 1)) {
                return false;
            }
        }
        return flag;
    }
}

338.比特位计数
任意输入一个整数num，要求输出从0到num之间所有这些数如果用二进制表示时，二进制数中的1，结果以数组形式输出。

class Solution {
	/**
	* 复习一个常识，奇数二进制表示，它的1的个数是比它小1的偶数的1的个数+1；如果是偶数，则1的个数和它的1/2的1的个数一样。
	*/
    public int[] countBits(int num) {
        int[] dp = new int[num+1];
        for(int i=0;i<=num;i++){
            if(i%2==1){
                dp[i]=dp[i-1]+1;
            }else{
                dp[i]=dp[i/2];
            }
        }
        return dp;
    }
}

413.等差数列划分
给定一个数组，数组长度至少为3。求其中包含的等差数列的个数，每个等差数列元素至少有三个。

class Solution {
    public int numberOfArithmeticSlices(int[] A) {
        if(A.length<3){
            return 0;
        }
        int[] dp = new int[A.length];
        dp[1]=0;
        dp[2]=0;
        if(A.length==3&&A[2]-A[1]==A[1]-A[0]){
            dp[2]=1;
        }
        int sum = 0;
        for(int i=2;i<A.length;i++){
            if(A[i]-A[i-1]==A[i-1]-A[i-2]){
                dp[i]=dp[i-1]+1;
                sum +=dp[i];
            }
        }
        return sum;
    }
}