算法练习LeetCode初级算法之动态规划

• 爬楼梯：斐波那契数列

  假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

  每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

  注意：给定 n 是一个正整数。

• 非递归解法

  class Solution {

  public int climbStairs(int n) {

  if (n==1) {

  return 1;

  }

  if (n==2) {

  return 2;

  }

  int n1=1,n2=2;

  for (int i = 0; i <n-2; i++) {

  int m=n1+n2;

  n1=n2;

  n2=m;

  }

  return n2;

  }

  }

• 递归解法

  class Solution {

  int[] result=null;

  public int climbStairs(int n) {

  result=new int[n+1];

  Arrays.fill(result, -1);

  f(n);

  return result[n];

  }

  private void f(int X) {

  if (result[X]!=-1) {

  return;

  }

  if (X==0||X==1) {

  result[X]=1;

  return;

  }

  f(X-1);

  f(X-2);

  result[X]=result[X-1]+result[X-2];

  }

  }

• 买卖股票的最佳时机

  重点是要设置一个最小值和一个最大值，并且不断替换！

  class Solution {

  public int maxProfit(int[] prices) {

  if (prices.length==0||prices.length==1) {

  return 0;

  }

  int minPrice=prices[0];

  int maxPrice=0;

  for (int i = 0; i < prices.length; i++) {

  if (prices[i]<=minPrice) {

  minPrice=prices[i];

  }else if ((prices[i]-minPrice)>maxPrice) {

  maxPrice=prices[i]-minPrice;

  }

  }

  return maxPrice;

  }

  }

• 最大子序和

• 超出时间限制的解法

  class Solution {

  public int maxSubArray(int[] nums) {

  if (nums.length==0) {

  return 0;

  }

  if (nums.length==1) {

  return nums[0];

  }

  int sum=0;

  Set<Integer> list=new TreeSet<>();

  int n=1;

  while (n<=nums.length) {

  for (int i = 0; i < nums.length-n+1; i++) {

  int m=0;

  for (int j = 0; j < n; j++) {

  m+=nums[i+j];

  }

  list.add(m);

  }

  n++;

  }

  int res=0;

  for (Iterator iterator = list.iterator(); iterator.hasNext();) {

  res= (Integer) iterator.next();

  }

  return res;

  }

  }

• 优化解法

没想到可以这样解，厉害！找个例子试一试就懂了

class Solution {

public int maxSubArray(int[] nums)

{

if (nums.length==0) {

return 0;

}

if (nums.length==1) {

return nums[0];

}

int max=nums[0];

int sum=0;

for (int i = 0; i < nums.length; i++) {

if (sum>0) {

sum+=nums[i];

}else {

sum=nums[i];

}

max=Math.max(max, sum);

}

return max;

}

}

• 更简单的解法：找最大子序列，最重要的要分清正负！！！

  class Solution {

  public int maxSubArray(int[] nums)

  {

  int max=nums[0];

  int sum=nums[0];

  for (int i = 1; i < nums.length; i++) {

  sum=Math.max(sum+nums[i], nums[i]);

  max=Math.max(max, sum);

  }

  return max;

  }

  }

• 打家劫舍

挺难的，参考别人的解法，先记住

• 递归法

  class Solution {

  //测试2,1,1,2

  private int[] memo;

  public int rob(int[] nums) {

  memo=new int[nums.length];

  Arrays.fill(memo, -1);

  return tryRob(nums, 0);

  }

  private int tryRob(int[] nums,int index) {

  if (index>=nums.length) {

  return 0;

  }

  if (memo[index]!=-1) {

  return memo[index];

  }

  int res=0;

  for (int i = index; i < nums.length; i++) {//循环每次后移，即可以跳过（相隔）两个或多个

  res=Math.max(res, nums[i]+tryRob(nums,i+2));

  }

  memo[index]=res;

  return res;

  }

  }

• 动态规划

  class Solution {

  //测试2,1,1,2

  public int rob(int[] nums) {

  int n = nums.length;

  if (n == 0) {

  return 0;

  }

  if (n==1) {

  return nums[0];

  }

  if (n==2) {

  return Math.max(nums[0], nums[1]);

  }

  int[] f = new int[n];

  f[0]=nums[0];

  f[1]=Math.max(nums[0], nums[1]);//典型动态规划问题，先将子问题记录，然后

  for (int i = 2; i < f.length; i++) {

  f[i]=Math.max(f[i-2]+nums[i], f[i-1]);//这里利用子问题来解决问题

  }

  return f[n-1];

  }

  }

  参考：https://blog.csdn.net/likunkun__/article/details/80724683