活动安排问题的动态规划、贪心算法和树搜索算法求解

最新推荐文章于 2024-04-23 13:56:04 发布
最新推荐文章于 2024-04-23 13:56:04 发布
阅读量4.5k 收藏 63
点赞数 16
文章标签： 动态规划 贪心算法 树结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44753451/article/details/109551267
版权

活动安排问题的动态规划、贪心算法和树搜索算法求解

一、题目描述

1、题目

  给定一组活动的开始和结束时间，在其中选出最多活动，使它们不互相冲突。结果我们称之为最大相容活动集。

2、题目分析

  其实这个问题还是比较容易理解的，就是在一定时间内尽可能让更多的活动被举行。
  比如有一个多媒体教室，现在有四个待举办活动A、B、C、D。A是在8:00到10:00举行，简单记为[8, 10]；B是[12, 14]；C是[15, 17]；D是[11, 19]。为了让尽可能多的活动举行，很明显我们要选择A、B、C为最大相容活动集，因为D与B、C都冲突。

二、分析并解决问题

1、动态规划

  这里不再具体讲解动态规划的概念了，在我之前的博客里已经有了，如果不知道什么是动态规划的话，可以自行百度或者到我之前的博客简单了解一下：利用动态规划解决最长增长子序列问题。

（1）分析优化解的结构

  在分析之前，我们需要先对活动按照活动结束时间升序排序，这有利于我们之后的分析。
  首先，假设我们有已经按照活动结束时间升序排序的活动集[A, B, C, D, E]。如果我们想求[A, B, C, D, E]的最大相容活动集，其实就是[A, B, C, D]的最大相容活动集与活动E的相结合得出的最大相容活动集。但这样说可能比较难以理解，所以我们换种说法，假设A’、B’、C’、D’分别是以A、B、C、D活动结尾的最大相容活动集的个数，所以[A, B, C, D, E]的最大相容活动集的活动个数就是A’、B’、C’、D’与A’’、B’’、C’’、D’’(如果A与E相容，则A’‘就是A’+1)中的最大值。
  同样的，要求[A, B, C, D]的最大相容活动集，那该活动集的活动个数便是A’、B’、C’与A’’、B’’、C’'中的最大值。以此类推。
  用比较规范的语言来说就是：
在这里插入图片描述

  其实，这种方法也可以用来解决最大上升子序列的问题，与我之前博客里的方法不一样，大家可以思考一下如何用这种方法解决最大上升子序列问题。

（2）构造状态转换方程

  首先，我们使用数组actiArr[i]来记录以下标为i的活动结尾的最大相容活动个数；用preActiArr[i]来记录最大相容活动集中下标为i的活动的前一个活动的下标。
  状态转换方程为：
在这里插入图片描述

  当然这是最基本的转换方程，编程时我们可以添加别的变量使其变得更为简单。

（3）子问题重叠性

  由于每次计算预选活动集P时都要获取以之前活动为结尾的最大相容活动集，所以具有子问题重叠性。

2、贪心算法

  实际上，活动选择问题就是比较经典的可以用贪心算法解决的问题。
  同样的，在分析之前，我们需要先对活动按照活动结束时间升序排序，这有利于我们之后的分析。

（1）选择贪心策略

  这里的贪心策略非常简单，每次尽量选择结束时间最早的活动，这样就余下更多的时间，可能容纳更多的活动。

（2）优化子结构和贪心选择性的证明

  在这里就不证明了，其实思路和我之前的博客一样，要是感兴趣的话可以去利用贪心算法解决最小平铺路径问题看看。

3、树搜索算法

（1）树搜索算法简介与分析

  其实很多问题的解可以表示成为树。解为树的节点或路径。求解这些问题可以转化为树搜索问题。比如深度表示活动的下标，如果在该深度的节点是左子节点，则表示包含该活动；如果是右子节点，则表示不包含该活动。这里我们便用这个思路来解决该问题。
  我个人感觉树搜索算法并不是那么常用，比如这个活动规划问题使用树搜索算法就不是特别合适。但树搜索算法中还是有很多方法分支的，如果感兴趣可以学习一下，但在这里就不详细说明了。
  在这里我们要使用Hill Climbing策略（爬山策略：首先利用贪心思想快速求出一个较优解。）进行分支界限搜索（分支界限搜索：快速找到一个可行解，并将该解作为阈值，在其他节点进行搜索的时候，预测该节点的极值解（可能是最大解或是最小解，要看问题是要求求最大值或最小值），与阈值相比较，如果不满足阈值的话，直接不再向下搜索，因为我们已经知道再往下搜索得出的解一定不是最终解，再往下搜索也没有意义了，我们也可以称这种方式为枝剪）。
  同样的，在分析之前，我们需要先对活动按照活动结束时间升序排序，这有利于我们之后的分析。而树的深度表示活动的下标。
  因为我们用了界限分支搜索，所以要确定一个预测解的函数。这里我们预测该节点向下搜索得出解（最大相容活动集）的个数 n 是(该活动之前选择的活动个数 + 该活动之后不与该活动冲突的活动个数)。如果 n 不大于爬山策略得出的解，该节点就不再向下搜索。
  当然树的节点也需要储存一些数据，这里我们设定节点的结构是：

1、parent -> 父节点；
2、leftChild -> 左子节点；
3、rightChild -> 右子节点；
4、border -> 当前边界值（即我们选择的活动集合中最晚结束时间）；
5、extra -> 被选择活动的数量（通过这个预测最大可能活动数）；
6、actiId -> 活动下标（用深度表示下标比较麻烦且不直观）；

  我们选择爬山策略的的贪心策略就是尽可能构建左子节点（说白了和上面的贪心算法的贪心策略一样，尽可能选结束时间早的活动，所以通过爬山策略取得的解已经是最优解，之后的搜索操作都是无意义的，因为这个问题本来就不适合用树搜索算法做，这里只是模拟树搜索算法的过程）。

三、算法实现

1、c语言

  首先我们需要几个头文件声明一些结构体、随机生成活动序列的函数以及排序函数。
  活动节点（node.h）：

#ifndef __NODE_H__
#define __NODE_H__

// node
typedef struct Node{
    int x;  // 活动开始时间
    int y;  // 活动结束时间
} Node;

#endif

  布尔类型（bool.h）：

#ifndef __BOOL_H__
#define __BOOL_H__

// bool type
typedef enum {
    false, true
} bool;

#endif

  获取随机活动集合（random_arr.c）：这里函数不是很严谨，可能存在(20, 20)的活动，但没什么影响。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include "bool.h"
#include "node.h"

//#define SIZE 10  // 活动数

#define random(min, max) (((min) + rand()%((max)-(min)))+1)  // 随机数组上下界

//#define RANGE_MIN 0  // 下界

//#define RANGE_MAX 20  // 上界

void randomArr(Node* S, int SIZE, int RANGE_MIN, int RANGE_MAX){
    srand((unsigned) time(NULL));
    for(int i = 0; i < SIZE; i++){
        Node node;
        node.x = random(RANGE_MIN, RANGE_MAX);
        node.y = random(RANGE_MIN, RANGE_MAX);
        while(node.x >= node.y){
            if(node.x == RANGE_MAX){
                node.y = RANGE_MAX;
                break;
            }
            if(node.x == RANGE_MAX - 1){
                node.y = RANGE_MAX;
            } else {
                node.y = node.y + random(node.x - node.y + 1, RANGE_MAX - node.y);
            }
        }
        S[i] = node;
    }
}

  归并排序（merge_sort.c）：

#include "bool.h"
#include "node.h"

// 归并排序（稳定的）
// x -> true : 对前界排序
// asc -> true : 升序排序
void mergeSort(Node* nodes, int size, bool x, bool asc){
    _mergeSort(nodes, 0, size - 1, x, asc);
}

// 归并排序
void _mergeSort(Node* nodes, int left, int right, bool x, bool asc){
    if(left < right){
        int mid = (left + right) / 2;
        _mergeSort(nodes, left, mid, x, asc);
        _mergeSort(nodes, mid + 1, right, x, asc);
        _merge(nodes, left, mid, right, x, asc);
    }
}

// 归并
void _merge(Node* nodes, int left, int mid, int right, bool x, bool asc){
    // 暂存结果
    Node temp[right - left + 1];
    // 左右索引
    int l_idx = left;
    int r_idx = mid + 1;
    int temp_idx = 0;
    // 归并
    while(l_idx <= mid && r_idx <= right){
        if(x && asc){
            if((nodes + l_idx)->x <= (nodes + r_idx)->x){  // 这个比较的等于号是稳定性的关键
                temp[temp_idx++] = *(nodes + l_idx);
                l_idx++;
            } else {
                temp[temp_idx++] = *(nodes + r_idx);
                r_idx++;
            }
        } else if(x && !asc){
            if((nodes + l_idx)->x >= (nodes + r_idx)->x){
                temp[temp_idx++] = *(nodes + l_idx);
                l_idx++;
            } else {
                temp[temp_idx++] = *(nodes + r_idx);
                r_idx++;
            }
        } else if(!x && asc){
            if((nodes + l_idx)->y <= (nodes + r_idx)->y){
                temp[temp_idx++] = *(nodes + l_idx);
                l_idx++;
            } else {
                temp[temp_idx++] = *(nodes + r_idx);
                r_idx++;
            }
        } else if(!x && !asc){
            if((nodes + l_idx)->y >= (nodes + r_idx)->y){
                temp[temp_idx++] = *(nodes + l_idx);
                l_idx++;
            } else {
                temp[temp_idx++] = *(nodes + r_idx);
                r_idx++;
            }
        }
    }
    // 将剩余的部分附在最后
    while(l_idx <= mid){
        temp[temp_idx++] = *(nodes + l_idx);
        l_idx++;
    }
    while(r_idx <= right){
        temp[temp_idx++] = *(nodes + r_idx);
        r_idx++;
    }
    // 将暂存的数据写回
    for(int i = 0; i < right - left + 1; i++){
        *(nodes + left + i) = temp[i];
    }
}

（1）动态规划

  为了减少状态转换方程那里的判断复杂程度以及最后求活动集合的难度。这里引进max_idx表示最大相容活动集的最后一个活动的下标和max_num表示最大相容活动集的活动个数。

#include <stdio.h>
#include <stdlib.h>
#include "node.h"
#include "bool.h"

#define SIZE 10  // 活动数

#define RANGE_MIN 0  // 下界

#define RANGE_MAX 20  // 上界

#define BORDER -1  // 边界

#define INIT 1  // 初始化值

int max_idx = 0;

int max_num = 0;

Node S[SIZE];  // 活动

int actiArr[SIZE];  // 以a(i)为结尾的最大活动数数组

int preActiArr[SIZE];  // 活动a(i)的前一个活动

void dynamic_progranmming(){
    printf("\nThis is dynamic programming\n");
    // 获取随机活动
    randomArr(S, SIZE, RANGE_MIN, RANGE_MAX);
    // 打印活动序列
    printf("random array:\n");
    _printActi();
    // 初始化活动矩阵
    _initActiArr();
    // 排序
    mergeSort(S, SIZE, false, true);
    // 打印活动序列
    printf("sorted array:\n");
    _printActi();
    // 求解
    _dynamic_progranmming();
    // 打印结果
    _dynamic_result();

    //printf("max idx : %d\n", max_idx);
    //printArr(preActiArr);
    //printf("max seq :\n");
    //printArr(actiArr);
}

// 求解
void _dynamic_progranmming(){
    // 遍历求解
    int max;
    for(int i = 1; i < SIZE; i++){
        // 回查
        max = 1;
        for(int j = i - 1; j >= 0; j--){
            if(S[i].x >= S[j].y && actiArr[j] + 1 > max){
                max = actiArr[j] + 1;
                preActiArr[i] = j;
            }
        }
        actiArr[i] = max;
        // 记录极值
        if(max_num < max){
            max_num = max;
            max_idx = i;
        }
    }
}

// 初始化活动数组
void _initActiArr(){
    for(int i = 0; i < SIZE; i++){
        actiArr[i] = INIT;
        preActiArr[i] = BORDER;
    }
}

// 打印随机生成的活动
void _printActi(){
    for(int i = 0; i < SIZE; i++){
        printf("no.%d -> (%d, %d)\n", i, S[i].x, S[i].y);
    }
}

// 打印数组
void printArr(int* a){
    for(int i = 0; i < SIZE; i++){
        printf("no.%d -> %d\n", i, *(a+i));
    }
}

// 打印结果
void _dynamic_result(){
    printf("max acti num -> %d, they are:\n", max_num);
    _dynamic_node_result(max_idx);
}

// 打印节点
void _dynamic_node_result(int pos){
    if(preActiArr[pos] == BORDER){
        printf("(%d, %d)\n", S[pos].x, S[pos].y);
        return;
    }
    _dynamic_node_result(preActiArr[pos]);
    printf("(%d, %d)\n", S[pos].x, S[pos].y);
}

（2）贪心算法

  贪心算法比较简单，没什么好说的。

#include <stdio.h>
#include <stdlib.h>
#include "node.h"
#include "bool.h"

#define SIZE 10  // 活动数

#define RANGE_MIN 0  // 下界

#define RANGE_MAX 20  // 上界

Node S[SIZE];  // 活动

int idx[SIZE];  // 结果集合

int top = 0;  // 结果集合顶部下标

void greedy(){
    printf("\nThis is greedy\n");
    // 获取随机活动
    randomArr(S, SIZE, RANGE_MIN, RANGE_MAX);
    // 打印活动序列
    printf("random array:\n");
    _printActi();
    // 排序
    mergeSort(S, SIZE, false, true);
    // 打印活动序列
    printf("sorted array:\n");
    _printActi();
    // 贪心算取结果
    _greedy();
    // 打印结果
    _greedy_result();
}

// 贪心获取结果
void _greedy(){
    idx[top++] = 0;
    for(int i = 1; i < SIZE; i++){
        if(S[i].x >= S[idx[top - 1]].y){
            idx[top++] = i;
        }
    }
}

// 打印结果
void _greedy_result(){
    printf("max acti num -> %d, they are:\n", top);
    for(int i = 0; i < top; i++){
        printf("(%d, %d)\n", S[idx[i]].x, S[idx[i]].y);
    }
}

（3）树搜索算法

  这里我们需要引进树节点的结构体头文件(tree.h)：

#ifndef __TREE_H__
#define __TREE_H__

// Tree node
typedef struct TreeNode{
    struct TreeNode* parent;
    struct TreeNode* leftChild;
    struct TreeNode* rightChild;
    int border;  // 当前边界值
    int extra;  // 记录当前活动数
    int actiId;  // 活动序号
} TreeNode;

#endif

  核心代码：

#include <stdio.h>
#include <stdlib.h>
#include "bool.h"
#include "node.h"
#include "tree.h"

#define SIZE 10  // 活动数

#define RANGE_MIN 0  // 下界

#define RANGE_MAX 20  // 上界

Node S[SIZE];  // 活动

TreeNode *root;  // 根节点

TreeNode *lastActi;  // 最大相容活动数对应的叶节点

int treeNodeNum = 0;  // 树节点总数

void tree_search(){
    printf("\nThis is tree search\n");
    // 获取随机活动
    randomArr(S, SIZE, RANGE_MIN, RANGE_MAX);
    // 打印活动序列
    printf("random array:\n");
    _printActi();
    // 排序
    mergeSort(S, SIZE, false, true);
    // 打印活动序列
    printf("sorted array:\n");
    _printActi();
    // 初始化根节点
    _initRoot();
    // 界限法获取第一个结果
    _treeFirstResult();
    // 枝剪
    _treeSearchPre(root);
    // 打印结果
    _treePrintResult();
}

// 初始化根节点
void _initRoot(){
    root = (TreeNode*)malloc(sizeof(TreeNode));
    root->border = 0;
    root->extra = 0;
    root->actiId = -1;
    root->parent = NULL;
    root->leftChild = NULL;
    root->rightChild = NULL;
}

// 构造节点
TreeNode* _createTreeNode(TreeNode* parent, int border, int extra, int actiId, bool leftChild){
    TreeNode* node;
    if(leftChild){
        parent->leftChild = (TreeNode*)malloc(sizeof(TreeNode));
        node = parent->leftChild;
    } else {
        parent->rightChild = (TreeNode*)malloc(sizeof(TreeNode));
        node = parent->rightChild;
    }
    node->border = border;
    node->extra = extra;
    node->actiId = actiId;
    node->parent = parent;
    node->rightChild = NULL;
    node->leftChild = NULL;
    return node;
}

// 界限法，先获取一个结果
void _treeFirstResult(){
    TreeNode* node = root;
    for(int i = 0; i < SIZE; i++){
        if(node->parent != NULL){
            //printf("%d, %d\n",node->parent->actiId, node->parent->border);
        }
        if(S[i].x >= node->border){
            node = _createTreeNode(node, S[i].y, node->extra + 1, i, true);
        } else {
            node = _createTreeNode(node, node->border, node->extra, i, false);
        }
    }
    // 第一个结果
    lastActi = node;
}

// 获取可能的最大值(这里是与目标下标对应的活动之后与该活动相容的活动数)
int _getPossibleMaxActiNum(int actiId){
    int max = 0;
    for(int i = actiId + 1; i < SIZE; i++){
        if(S[i].x >= S[actiId].y){
            max++;
        }
    }
    return max;
}

// 前序遍历进行枝剪
void _treeSearchPre(TreeNode* node){
    treeNodeNum++;
    if(node == NULL){
        return;
    } else {
        // 树的深度不能超过活动数量上限
        if(node->actiId >= SIZE - 1){
            return;
        }
        // 判断是否有打到最大相容活动数的可能性
        if(lastActi->extra < node->extra + _getPossibleMaxActiNum(node->actiId)){
            // 不管怎么样，右子节点一定是可以有的
            if(node->rightChild == NULL){  // 该子节点已经有了的话就不创建了
                _createTreeNode(node, node->border, node->extra, node->actiId + 1, false);
            }
            // 尝试创建左子节点
            if(node->leftChild == NULL && S[node->actiId + 1].x >= node->border){  // 该子节点已经有了的话就不创建了
                _createTreeNode(node, S[node->actiId + 1].y, node->extra + 1, node->actiId + 1, true);
                // 如果最大相容活动数更新的话，更新最大叶子节点
                // 但这里实际上不是叶子节点，应该是最后一个被包含的活动对应的节点，可以减少操作
                // 只有创建完左子节点（新包含了一个活动），才可能更新最大相容活动数，所以这里判断该节点新建的左子节点记录的extra（最大相容活动数）是否超过了之前记录的节点记录的extra，刷新了最大相容活动数上限
                if(node->leftChild->extra > lastActi->extra){
                    lastActi = node->leftChild;
                }
            }
            // 继续遍历
            _treeSearchPre(node->leftChild);
            _treeSearchPre(node->rightChild);
        } else {
            // 没有的话直接结束（枝剪）
            return;
        }
    }
}

// 打印最大相容活动集合
void _treePrintResult(){
    printf("there are %d tree nodes, max acti num -> %d, they are:\n", treeNodeNum, lastActi->extra);
    _treePrintActis(lastActi);
}

// 递归获取每个活动
void _treePrintActis(TreeNode* node){
    // 如果是根节点，停止递归
    if(node->parent == NULL){
        return;
    }
    // 递归
    _treePrintActis(node->parent);
    // 如果是左节点，说明该活动在结果集中
    if(node == node->parent->leftChild){
        printf("(%d, %d)\n", S[node->actiId].x, S[node->actiId].y);
    }
}

（4）测试代码

#include <stdio.h>
#include <stdlib.h>

int main()
{
    // dynamic
    dynamic_progranmming();
    // greedy
    greedy();
    // tree search
    tree_search();
    return 0;
}

（5）测试结果

在这里插入图片描述

四、后记

  这次写的也比较仓促，有很多地方讲解的不够清楚，但我希望这个博客只是个引导，要想学到真东西，只看这篇博客是远远不够的，希望这些思路和代码能带给大家启发，帮助到大家。代码我会上传到空间，可以自取。如果有什么问题，可以在评论区提出。谢谢观看！

冲鸭hhh
关注
  • 16
    点赞
  • 踩
  • 63
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
活动安排问题的动态规划、贪心算法和树搜索算法求解（更新）
11-09
活动安排问题的动态规划、贪心算法和树搜索算法求解。 比如有一个多媒体教室，现在有四个待举办活动A、B、C、D。A是在8:00到10:00举行，简单记为[8, 10]；B是[12, 14]；C是[15, 17]；D是[11, 19]。为了让尽可能多的活动举行，很明显我们要选择A、B、C为最大相容活动集，因为D与B、C都冲突。
活动选择问题-最大场次和最大收益（贪心和动态规划求解）
weixin_53461714的博客
11-24 632
已证明优先选择最早结束的活动时举办活动的场次最多，证明略。：假如每个活动都有收益，收益各不相同，问怎样使收益最大呢？对于第i个活动，我们的选择有 选 与 不选。使用二分法查找第i个活动前最后结束的活动。快速排序：O(nlogn)二分查找：O(nlogn)
动态规划-带权活动选择问题
KARLGong的博客
11-02 196
介绍了使用贪心思想和动态规划方法求解的带权活动选择问题，并讨论了贪心算法和动态规划的比较。
活动选择问题（动态规划和贪心算法）
m0_72431373的博客
12-04 509
有一个由n个活动组成的集合S = {a1, ..., an} 1. 这些活动使用同一个资源，而这个资源在某一时刻只供一个活动使用 2. 每个活动都有一个开始和结束时间si/fi；如果被选中，则任务ai发生在半开时间区间[si, fi) 3. 如果两个活动ai和aj不重叠，则称两个活动兼容 活动选择问题，希望选出一个最大兼容活动集 假设活动已经按结束时间递增排好序最优子结构 Sij表示在ai结束之后，aj开始之前结束之前的活动集合；Aij表示Sij的一个最大兼容活动集
从 活动选择问题 看动态规划和贪心算法的区别与联系
weixin_34320724的博客
06-10 1170
这篇文章主要用来记录我对《算法导论》 贪心算法一章中的“活动选择问题”的动态规划求解和贪心算法求解 的思路和理解。 主要涉及到以下几个方面的内容： ①什么是活动选择问题---粗略提下，详细请参考《算法导论》 ②活动选择问题的DP(Dynamic programming)求解--DP求解问题的思路 ③活动选择问题的贪心算法求解 ④为什么这个问题可以用贪心算法求解？ ⑤动态规划与贪心算法的...
活动安排问题 动态规划、贪心算法C语言实现
如果没有躺赢的命，那就站起来奔跑，你的努力一定会对得起这一路的颠沛流离。
04-24 3668
问题描述   设有n个活动的集合E={1,2,…,n}，其中每个活动都要求使用同一资源，如演讲会场等，而在同一时间内只有一个活动能使用这一资源。每个活动i都有一个要求使用该资源的起始时间si和一个结束时间fi,且si <fi 。如果选择了活动i，则它在半开时间区间[si, fi)内占用资源。   若区间[si, fi)与区间[sj, fj)不相交，则称活动i与活动j是相容的。也就是说，当si≥fj或sj≥fi时，活动i与活动j相容。活动安排问题就是要在所给的活动集合中选出最大的相容活动子集合。 思路
【算法设计与分析】活动安排问题（动态规划和贪心算法）
one or only的博客
03-05 6410
活动选择问题描述 假设我们存在这样一个活动集合S={a1,a2,a3,a4,...,an}，其中每一个活动ai都有一个开始时间si和结束时间fi保证(0≤si<fi)，fi保证(0≤si<fi),活动aiai进行时，那么它占用的时间为[si,fi)[si,fi).现在这些活动占用一个共同的资源，就是这些活动会在某一时间段里面进行安排，如果两个活动aiai和ajaj的占用时间[si,f...
算法分析与实践-作业10-相容问题
green_hand2333的博客
05-04 255
#include<stdio.h> #define MAX 100 int a[MAX]; void GreedyApproach(int x[][2],int n){ a[1] = 1;//最优解必含有活动1 int m=2,j = 0; //m存储有多少个活动，j存储最优解中最后一个的序号 for (int i = 1; i < n; i++) { if (x[i]...
【LeetCode】会议调度问题 （动态规划）
myaijarvis notebook
05-15 1327
【参考：会议室调度算法集锦_阿飞算法的博客-CSDN博客】 1751. 最多可以参加的会议数目 II hard 【参考：1751. 最多可以参加的会议数目 II - 力扣（LeetCode）】 【参考：【阿飞算法】畅游面试中的动态规划套路-最多可以参加的会议数目 II - 最多可以参加的会议数目 II - 力扣（LeetCode）】 循序渐进 自顶向下记忆化递归 memo[curr][k] ： 表示处理到编号curr这个会议，还剩余k次参加会议机会所能获取的价值的最大值 class Solution {
会议安排（贪心算法和动态规划） 贪心算法和动态规划.pdf
04-08
会议安排（贪心算法和动态规划） 贪心算法和动态规划.pdf
用贪心算法解单源最短路径问题
05-02
用贪心算法解单源最短路径问题 明确单源最短路径问题的概念；利用贪心算法解决单源最短路径问题；并通过本例熟悉贪心算法在程序设计中的应用方法。
精选_毕业设计_基于贪心策略直接搜索算法和极大极小博弈树算法的智能人机博弈五子棋游戏_完整源码
03-05
基于贪心策略直接搜索算法和极大极小博弈树算法的智能人机博弈五子棋游戏
学习数据结构和算法分析的一些实例，包括排序算法、搜索算法、递归、二叉树等等实例.zip
01-15
算法分类：排序算法（如冒泡排序、快速排序、归并排序），查找算法（如顺序查找、二分查找、哈希查找），图论算法（如Dijkstra最短路径算法、Floyd-Warshall算法、Prim最小生成树算法），动态规划，贪心算法，回溯法...
计算机大赛-团体程序设计天梯赛算法范围.docx
04-21
6.贪心算法：贪心算法是求解最优问题的有效方法之一，需要掌握贪 心的基本思想和具体的实现思路。 7.数学算法：包括快速幂、欧几里得算法、 素数筛法等 8.数据结构：包括树、 堆、图等数据结构，需要熟练掌握其基本...
贪心算法-活动安排问题和背包问题
m0_74867870的博客
04-19 1188
贪心算法-活动安排问题和背包问题
DAY31-贪心算法| 455.分发饼干,376.摆动序列,53. 最大子序和
qq_40988139的博客
04-20 296
455.分发饼干,376.摆动序列,53. 最大子序和
代码随想录训练营26day-贪心算法4
goodBoy
04-23 192
首先需要消耗10元，因为5元可以兑换零钱方式更多，先把兑换方式少的减掉。2 排序k（人数）因为身高已经排序成功，所以需要考虑的是k值，把k插入对应的位置，这样people身高是排序的，只需要考虑k的位置，就满足了两个条件。2 如果是10元，那么需要five--，ten++，但是如果five本身就小于0，那么不可能找零成功，返回false；题目解析：注意一开始是没有零钱，也只会取5 10 20三类数字，因此从这3类数字出发，去判断。1 先考虑身高，从高到低，如果身高相同，那么k（人数）少的排前面。
【贪心算法】Leetcode 55. 跳跃游戏【中等】
FLGB
04-23 235
给你一个非负整数数组 nums ，你最初位于数组的 第一个下标。数组中的每个元素代表你在该位置可以跳跃的最大长度。：可以先跳 1 步，从下标 0 到达下标 1, 然后再从下标 1 跳 3 步到达最后一个下标。判断你是否能够到达最后一个下标，如果可以，返回 true；否则，返回 false。时间复杂度：遍历一次数组，时间复杂度为O(n)，其中n为数组nums的长度。空间复杂度：仅使用了常数级的额外空间，空间复杂度为O(1)。
贪心算法在单位时间任务调度问题中的应用
最新发布
笔者从事电信媒体开发多年，愿意将多年的开发经验分享给同行
04-23 521
单位时间任务调度问题是一类经典的优化问题，旨在分配任务到不同的时间槽中，使得某种性能指标达到最优。在16.5节中，我们讨论了一种带截止时间和惩罚的单位时间任务调度问题，其中每个任务有一个截止时间以及错过截止时间后的惩罚值。这个问题要求我们找到一个任务调度方案，能够最小化超过截止时间导致的惩罚总和。 本文将介绍一种贪心算法来解决这个问题，并通过证明和伪代码分析来说明该算法的正确性和效率。同时，我们还将探讨如何利用21.3节提出的快速不相交集合森林来高效实现该算法，并分析其运行时间。
详细讲解一下动态规划算法、回溯算法和贪心算法
07-15
动态规划算法通常适用于具有重叠子问题和最优子结构的问题，回溯算法适用于穷尽搜索所有可能解的问题，而贪心算法适用于局部最优解构成整体最优解的问题。在选择算法时，需要根据问题的特点和约束进行综合考虑。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值