Leetcode-贪心算法

55-跳跃游戏

给定一个非负整数数组 nums ,你最初位于数组的 第一个下标 。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
判断你是否能够到达最后一个下标。

在这里插入图片描述

class Solution {
public:
    bool canJump(vector<int>& nums) {
        int n=nums.size();
        int farthest=0;
        if(n==1)
            return true;
        for(int i=0;i<n-1;++i)
        {
            farthest=max(farthest,i+nums[i]);
            if(farthest<=i)
                return false;
        }
        return farthest>=n-1;
    }
};

45跳跃游戏‖

给你一个非负整数数组 nums ,你最初位于数组的第一个位置。
数组中的每个元素代表你在该位置可以跳跃的最大长度。
你的目标是使用最少的跳跃次数到达数组的最后一个位置。
假设你总是可以到达数组的最后一个位置。

在这里插入图片描述

解题思路

可采用动态规划和贪心思想两种方法进行

方法一:动态规划

暴力穷举所有可能的跳法,通过备忘录 memo 消除重叠子问题,取其中的最小值最为最终答案:

class Solution {
public:
    int jump(vector<int>& nums) {
        //备忘录初始化为n,相当于INT_MAX
        //因为从0跳到n-1最多n-1步
        vector<int>memo(nums.size()-1,nums.size());
        return dp(nums,0,memo);
    }
    int dp(vector<int>&nums,int p,vector<int>&memo)
    {
        int n=nums.size();
        //base  case
        if(p>=n-1)
            return 0;
        //子问题已经计算过
        if(memo[p]!=n)
            return memo[p];
        int steps=nums[p];
        //你可以选择跳1步,跳2步
        for(int i=1;i<=steps;++i)
        {
            //穷举每一个选择
            //计算每一个子问题的结果
            int subProblem=dp(nums,p+i,memo);
            memo[p]=min(memo[p],subProblem+1);
        }
        return memo[p];
    }
};
  1. 时间复杂度:O(n^2)
  2. 空间复杂度:O(n)

方法二:贪心思想

我们不需要「递归地」计算出所有选择的具体结果然后比较求最值,而只需要做出那个最有「潜力」,看起来最优的选择即可。

class Solution {
	public:
	    int jump(vector<int>& nums) {
	    int n = nums.size();
	    int end = 0, farthest = 0;
	    int jumps = 0;
	    for (int i = 0; i < n - 1; ++i) {
	        farthest =max(nums[i] + i, farthest);
	        if (end == i) {
	            ++jumps;
	            end = farthest;
	        }
	    }
	    return jumps;
	    }
};

  1. 时间复杂度:O(n)
  2. 空间复杂度:O(1)

494- 目标和

给你一个整数数组 nums 和一个整数 target 。

向数组中的每个整数前添加 ‘+’ 或 ‘-’ ,然后串联起所有整数,可以构造一个 表达式 :
例如,nums = [2, 1] ,可以在 2 之前添加 ‘+’ ,在 1 之前添加 ‘-’ ,然后串联起来得到表达式 “+2-1” 。
返回可以通过上述方法构造的、运算结果等于 target 的不同 表达式 的数目。

在这里插入图片描述

解题思路

方法一:回溯算法

C++实现

class Solution1
{
public:
	int result = 0;
	/* 主函数 */
	int findTargetSumWays(vector<int>& nums, int target) 
	{
		if (nums.size() == 0) return 0;
		backtrack(nums, 0, target);
		return result;
	}
	/* 回溯算法模板 */
	void backtrack(vector<int>& nums, int i, int rest) 
	{
		// base case
		if (i == nums.size()) {
			if (rest == 0) {
				// 说明恰好凑出 target
				result++;
			}
			return;
		}
		// 给 nums[i] 选择 - 号
		rest += nums[i];
		// 穷举 nums[i + 1]
		backtrack(nums, i + 1, rest);
		// 撤销选择
		rest -= nums[i];

		// 给 nums[i] 选择 + 号
		rest -= nums[i];
		// 穷举 nums[i + 1]
		backtrack(nums, i + 1, rest);
		// 撤销选择
		rest += nums[i];
	}
};
  1. 时间复杂度:O(2^n),回溯需要遍历所有不同的表达式,共有 2^n种不同的表达式,每种表达式计算结果需要 O(1) 的时间,因此总时间复杂度是 O(2^n)。
  2. 空间复杂度:O(1),其中 n 是数组 nums 的长度。空间复杂度主要取决于递归调用的栈空间,栈的深度不超过 n。

方法二:动态规划

其实,这个问题可以转化为一个子集划分问题,而子集划分问题又是一个典型的背包问题。
首先,如果我们把 nums 划分成两个子集 A 和 B,分别代表分配 + 的数和分配 - 的数,那么他们和 target 存在如下关系:

sum(A) - sum(B) = target sum(A) = target + sum(B) sum(A) + sum(A) =
target + sum(B) + sum(A) 2 * sum(A) = target + sum(nums)

综上,可以推出 sum(A) = (target + sum(nums)) / 2,也就是把原问题转化成:nums 中存在几个子集 A,使得 A 中元素的和为 (target + sum(nums)) / 2?
我们可以运用动态规划的常规套路:

C++实现

class Solution {
public:
	int findTargetSumWays(vector<int>& nums, int target) {
		int sum=0;
		for(auto&num:nums)
			sum+=num;
		if(sum < -target || (sum + target) % 2 == 1)
			return 0;
		sum=(sum+target)/2;
		int n=(int)nums.size();
		vector<int>dp(sum+1,0);
		dp[0]=1;
		for(int i=1;i<=n;++i)
		{
			for(int j=sum;j>=0;--j)
			{
				if(j>=nums[i-1])
					dp[j]=dp[j]+dp[j-nums[i-1]];
				else
					dp[j]=dp[j];
			}
		}
		return dp[sum];
	}
};
  1. 时间复杂度:O(n×m),双层循环,n为数组大小,m为数组的(sum(nums)+target)/2。
  2. 空间复杂度:O(m)
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值