【算法】贪心算法

贪心算法

通过使用局部解来找到全局最优解,不同题型采用不同的贪心策略。

1.题目

给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。
每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说,如果你在 nums[i] 处,你可以跳转到任意 nums[i + j] 处:

  • 0 <= j <= nums[i]
  • i + j < n

返回到达 nums[n - 1] 的最小跳跃次数。生成的测试用例可以到达 nums[n - 1]。

示例1:

输入:nums = [2,3,1,1,4]
输出:2

解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置,跳 1 步,然后跳 3 步到达数组的最后一个位置。

示例2:

输入:nums = [2,3,0,1,4]
输出:2

2.解析:

在这里插入图片描述

从正向查找

下标为0出发,可以跳到下标1或者2,可以看出,下标1跳得更远,所以选择下标1

下标1出发,可以选择下标2,下标3,下标4,很明显下标4可以跳得更远。

所以最终步数为2

3.代码
    public int jump(int []arr){
        int end = 0;
        int position = 0;
        int step = 0;
        for(int i=0;i< arr.length-1;i++){
            //记录能够跳到最远位置
            position = Math.max(position, i+arr[i]);
            //限制在每次跳最远的区间范围计算
            //当i到达边界
            if(i==end){       
                //重新记录能够跳到最远处为新的区间边界
                end=position;
                //步数加1    
                step++;
            }
        }
        //返回步数
        return step;
    }

在遍历数组的时候,不访问最后一个元素,因为边界值一定是大于或者等于最后一个元素的位置。如果访问了最后一个元素,那么存在一种可能就是刚好跳到最后一个元素的位置,代码中会增加一次没必要的次数。

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Prim算法是一种求解加权无向连通图的最小生成树的算法。其基本思想是从一个点开始,每次选择一个与当前生成树相邻且权值最小的边,直到生成一棵包含所有节点的树为止。具体步骤如下: 1. 任选一个起始点,将其加入生成树中。 2. 找到与生成树相邻的所有边中权值最小的那条边,将其加入生成树中。 3. 重复第二步,直到生成一棵包含所有节点的树为止。 下面是一个使用Prim算法求解最小生成树的Python代码示例: ```python def prim(graph): # 初始化 nodes = list(graph.keys()) visited = [nodes[0]] edges = [] # 循环直到所有节点都被访问 while len(visited) < len(nodes): min_edge = None # 找到与已访问节点相邻的所有边中权值最小的那条边 for node in visited: for neighbor, weight in graph[node].items(): if neighbor not in visited: if min_edge is None or weight < min_edge[2]: min_edge = (node, neighbor, weight) # 将该边加入生成树中 edges.append(min_edge) visited.append(min_edge[1]) return edges ``` 贪心算法是一种在求解最优解问题时采用贪心策略的算法。其基本思想是每次选择当前看来最优的解决方案,直到达到全局最优解。贪心算法通常适用于满足最优子结构性质的问题,即问题的最优解可以通过子问题的最优解推导得到。具体步骤如下: 1. 将问题分解为若干个子问题。 2. 对每个子问题求解,得到子问题的最优解。 3. 将所有子问题的最优解合并成原问题的解。 下面是一个使用贪心算法求解背包问题的Python代码示例: ```python def knapsack(items, capacity): # 按照单位价值排序 items = sorted(items, key=lambda x: x[1]/x[0], reverse=True) # 初始化 total_value = 0 knapsack = [] # 循环直到背包装满 for item in items: if capacity >= item[0]: knapsack.append(item) capacity -= item[0] total_value += item[1] else: knapsack.append((capacity, item[1]/item[0]*capacity)) total_value += item[1]/item[0]*capacity break return knapsack, total_value ```

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值