算法练习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
