贪心算法多机调度问题c程序
贪心法 多机调度问题
//多机调度问题/*贪心法求解多级调度问题的贪心策略师最长处理时间的作业优先，即把处理时间最长的作业分配给最先空闲的机器，这样就可以保证处理时间长的作业优先处理，从而在整体上获得尽可能短的时间。
按照最长处理时间作业优先的贪心测落，当m>n,时，只要将机器ide [0,ti)时间去见分配给作业j即可，当m<n时，首先将n个作业从大到小排序，然后依次顺序将作业分配给空闲的处理机算法伪代码将数组t[n]从大到小排序，对应的作业序号存储在数组p[n]中；将数组d[m]初始化为零3：for（i0;i<=m;i++)3.1:s[i]={p[i]}:将m个作业分配给m个机器3.2 d[i]=t[i];for(i=m+1;i<=n;i++)4.1 j=数组d[m]中最小值对应的下标；//j为最先空闲的机器序号4.2 s[j]=s[j]+{p[i]};//将作业分配给最先空闲的的机器j4.3 d[j]=d[j]+d[t];//机器j将在d[j]后空闲*/#include<iostream>using namespace std;void lowsort(int *t,int *p,int n)//将数组t[n]按从小到大的顺序排序，相应的任务编号数组p[n]也要随之改变{int index;for(int i=0;i<n;i++){index=i;for(int j=i+1;j<n;j++){if(t[index]<t[j])index=j;}if(index!=i){int temp;temp=t[index];t[index]=t[i];t[i]=temp;temp=p[i];p[i]=p[index];p[index]=temp;}}int find(int *d,int m){int min=d[0];int k;for(int i=0;i<m;i++){if(d[i]<min){min=d[i];k=i;}}return k;}void ajust(int *t,int *d,int *p,int *s,int n,int m){lowsort(t,p,n);for(int i=0;i<m;i++){d[m]=0;}for(i=0;i<m;i++){s[i]=p[i];cout<<"机器"<<i+1<<"做了任务"<<p[i]<<endl;d[i]=t[i];}for(i=m;i<n;i++){int j=find(d,m);//查找数组d[m]中最小值对应的下标s[j]=s[j]+p[i];cout<<"机器"<<j+1<<"做了任务"<<p[i]<<endl;d[j]=d[j]+t[i];}}void main()int n,m;cout<<"输入任务数量"<<endl;cin>>n;cout<<"输入机器个数"<<endl;cin>>m;int *t=new int [n];int *s=new int [n];int *d=new int [m];int *p=new int[n];cout<<"输入任务编号"<<endl;for(int k=0;k<n;k++)cin>>p[k];cout<<"每件任务所花费的时间"<<endl;for(int i=0;i<n;i++)cin>>t[i];ajust(t,d,p,s,n,m);}。
算法之多机调度问题
}
for(i=m+1;i<=n;i++)
{
for(int k=1;k<m;k++)
{
int o=d[k];
if (o>d[k+1])
{
o=d[k+1];
j=k+1;
}
}
s[j]|=(1<<(p[i]-1));
d[j]=d[j]+t[i];
}
}
void Output(int *p,int n,int *s,int *d,int m) //阅读并理解这个函数
Dsc_Order_By_t(t,p,n); //对作业根据运行时间t进行降序排列
Processing(p,t,n,s,d,m); //用最长运行时间优先算法处理作业
Output(p,n,s,d,m); //输出结果
_getch();
return 0;
}
运行结果图：
t[]={0,2,14,4,16,6,5,3}, //对应作业时间，t[0]不用
s[]={0,0,0,0}, //机器处理的作业集合，如：s[1]存放机器处理过的作业号，s[0]不用
d[]={0,0,0,0}; //机器处理作业的总时间，如：d[2]存放机器处理过的作业的总时间，d[0]不用
int n=sizeof(p)/sizeof(int)-1,m=sizeof(s)/sizeof(int)-1; //n--作业总数，m--机器台数
算法之多机调度问题
用贪心法解决多机调度问题
（1）问题的描述
设有n个独立的作业{1, 2,…, n}，由m台相同的机器{M1, M2,…, Mm}进行加工处理，作业i所需的处理时间为ti（1≤i≤n），每个作业均可在任何一台机器上加工处理，但不可间断、拆分。多机调度问题要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。
贪心算法---例题5.多机调度问题
cout<<"("<<x.first<<","<<x.second<<")"<<endl; } int timeTotal = 0; vector<int> timeOfMachine(n, 0); int pos = 0; //表示Job数组的下标 while(m--) {
int minPosition = min_element(timeOfMachine.begin(), timeOfMachine.end()) - timeOfMachine.begin(); timeOfMachine[minPosition] += Job[pos].second; cout<<"将作业"<<Job[pos].first<<"分配给机器"<<minPosition+1<<",用时"<<Job[pos].second; cout<<"机器"<<minPosition+1<<"目前总用时为"<<timeOfMachine[minPosition]<<endl; pos++; } return *max_element(timeOfMachine.begin(), timeOfMachine.end()); } int main() { cout<<"一共m个作业,请输入m: "; int m; cin>>m; cout<<"请输入每个作业的时间: "<<endl; vector<pair<int, int>> Job; int time; for(int i=0; i<m; i++) { cin>>time; Job.push_back(pair<int, int>(i+1, time)); } cout<<"指定n台机器,请输入n: "<<endl; int n; cin>>n; int timeTotal = JobSort(Job, n); cout<<"总用时为: "<<timeTotal<<endl; system("pause"); return 0; }
贪心算法程序设计
贪心算法程序设计贪心算法程序设计1. 什么是贪心算法贪心算法（Greedy Algorithm）是一种常见的算法思想，它在每一步选择中都采取当前状态下的最优选择，从而希望最终达到全局最优解。
贪心算法的核心思想是局部最优解能导致全局最优解。
2. 贪心算法的基本步骤贪心算法的基本步骤如下：1. 定义问题的优化目标。
2. 将问题分解成子问题。
3. 选择当前最优的子问题解，将子问题的解合并成原问题的解。
4. 检查是否达到了问题的优化目标，如果没有达到，则回到第二步，继续寻找下一个最优子问题解。
5. 在所有子问题解合并成原问题解后，得到问题的最优解。
3. 贪心算法的应用场景贪心算法的应用非常广泛，几乎可以用于解决各种优化问题。
以下几个常见的应用场景：1. 零钱找零问题：给定一定面额的纸币和硬币，如何找零使得所需纸币和硬币的数量最小？2. 区间调度问题：给定一些活动的开始时间和结束时间，如何安排活动使得可以办理的活动数量最大？3. 背包问题：给定一些具有重量和价值的物品，如何选择物品使得背包的总价值最大？4. 最小树问题：给定一个带权无向图，如何找到一棵树，使得它的边权之和最小？5. 哈夫曼编码问题：给定一组字符和相应的频率，如何构造一个满足最低编码长度限制的二进制编码？4. 贪心算法的优缺点贪心算法的优点是简单、高效，可以快速得到一个近似最优解。
而且对于一些问题，贪心算法能够得到全局最优解。
贪心算法的缺点在于它不一定能够得到全局最优解，因为在每一步只考虑局部最优解，无法回溯到之前的选择。
5. 贪心算法的程序设计在使用贪心算法进行程序设计时，通常需要以下几个步骤：1. 定义问题的优化目标。
2. 将问题分解成子问题，并设计子问题的解决方案。
3. 设计贪心选择策略，选择局部最优解。
4. 设计贪心算法的递推或迭代公式。
5. 判断贪心算法是否能够得到全局最优解。
6. 编写程序实现贪心算法。
6.贪心算法是一种常见的算法思想，它在每一步选择中都采取当前状态下的最优选择，从而希望最终达到全局最优解。
贪心算法几个经典例子c语言
贪心算法几个经典例子c语言1. 零钱兑换问题题目描述：给定一些面额不同的硬币和一个总金额，编写一个函数来计算可以凑成总金额所需的最少的硬币个数。
如果没有任何一种硬币组合能够凑出总金额，返回 -1。
贪心策略：每次选择面额最大的硬币，直到凑出总金额或者无法再选择硬币为止。
C语言代码：int coinChange(int* coins, int coinsSize, int amount){int count = 0;for(int i = coinsSize - 1; i >= 0; i--){while(amount >= coins[i]){amount -= coins[i];count++;}}return amount == 0 ? count : -1;}2. 活动选择问题题目描述：有 n 个活动，每个活动都有一个开始时间和结束时间，选择一些活动使得它们不冲突，且能够参加的活动数最多。
贪心策略：每次选择结束时间最早的活动，直到所有活动都被选择或者无法再选择为止。
C语言代码：typedef struct{int start;int end;}Activity;int cmp(const void* a, const void* b){return ((Activity*)a)->end - ((Activity*)b)->end;}int maxActivities(Activity* activities, int n){qsort(activities, n, sizeof(Activity), cmp);int count = 1;int end = activities[0].end;for(int i = 1; i < n; i++){if(activities[i].start >= end){count++;end = activities[i].end;}}return count;}3. 跳跃游戏题目描述：给定一个非负整数数组，你最初位于数组的第一个位置。
多机调度问题贪心算法c语言
多机调度问题贪心算法c语言一、引言多机调度问题是指将一组作业分配给多台机器，使得完成所有作业的时间最短。
在实际生产中，多机调度问题是一个常见的优化问题。
贪心算法是解决多机调度问题的一种有效方法。
本文将介绍贪心算法在C语言中的应用。
二、问题描述假设有n个作业需要分配给m台机器进行加工处理，每个作业需要的时间不同，每台机器的处理速度也不同。
现在需要设计一个算法，将这些作业分配给这些机器进行加工处理，并使得完成所有作业所需时间最短。
三、贪心算法思路贪心算法是一种基于局部最优解来构造全局最优解的思想。
对于多机调度问题，我们可以采用以下贪心策略：1. 将所有作业按照所需时间从大到小排序；2. 将第一个作业分配给第一台机器；3. 对于剩余的作业，选择当前处理时间最短的那台机器进行分配；4. 重复步骤3直到所有作业都被分配完毕。
四、C语言实现下面是C语言实现多机调度问题贪心算法的代码：#include <stdio.h>#include <stdlib.h>#define MAX_JOB 1000#define MAX_MACHINE 1000int cmp(const void *a, const void *b) {return *(int *)b - *(int *)a;}int main() {int n, m, job[MAX_JOB], machine[MAX_MACHINE] = {0}; scanf("%d%d", &n, &m);for (int i = 0; i < n; i++) {scanf("%d", &job[i]);}qsort(job, n, sizeof(int), cmp);for (int i = 0; i < n; i++) {int min_time = machine[0], min_index = 0;for (int j = 1; j < m; j++) {if (machine[j] < min_time) { min_time = machine[j]; min_index = j;}}machine[min_index] += job[i]; }int max_time = machine[0];for (int i = 1; i < m; i++) {if (machine[i] > max_time) { max_time = machine[i];}}printf("%d\n", max_time);return 0;}五、代码解析1. 宏定义和头文件引入：```#define MAX_JOB 1000#define MAX_MACHINE 1000#include <stdio.h>#include <stdlib.h>```定义了最大作业数和最大机器数，并引入了标准输入输出库和标准库。
贪心算法—多机调度
贪心算法-多机调度一、问题描述设有n个独立的作业，由m台机器进行加工处理，作业i所需的处理时间为t（i）。
约定，任何作业可以在任何机器上加工处理，但未完成前不允许中断处理。
任何作业不能拆分成更小的子作业。
多机调度问题要求给出一种作业调度方案，使n个作业在尽可能短的时间内完成。
二、算法分析1当n<=m时，将机器i的【0~t(i)】时间分配给作业i即可。
2当n>m时，首先将n个作业按照时间从大到小排列。
然后照此顺序将作业分配给空闲的处理机即可。
3创建3个类:JobNode类,MachineNode类, MinHeap类分别用于作业信息，机器信息，对机器类型的堆处理三、代码#include<iostream>using namespace std;#define Max 15template <class Type>class MinHeap{public:MinHeap(int ms);~MinHeap();void Insert(const Type& x);void DeleteMin(Type& x);protected:void FilterDown();//自顶向下构造堆void FilterUp();//自底向上构造堆private:Type *heap;int length;};////////////////////////////////////////template <class Type>MinHeap<Type>::MinHeap(int m){heap=new Type[m+1];length=0;}////////////////////////////////////////template <class Type>void MinHeap<Type>::Insert(const Type& x) {heap[++length]=x;FilterUp();}////////////////////////////////////////template <class Type> template <class Type>void MinHeap<Type>::FilterUp(){//自底向上进行调整int i=length,j=i/2;//父节点的编号Type temp=heap[i];while(i>1){if(temp>=heap[j])break;//找到了相应的位置else{heap[i]=heap[j];i=j;j=i/2;}}heap[i]=temp;}////////////////////////////////////////template <class Type>void MinHeap<Type>::DeleteMin(Type &x){x=heap[1];heap[1]=heap[length];length--;FilterDown();}////////////////////////////////////////template <class Type>void MinHeap<Type>::FilterDown(){int i=1,j=i*2;Type temp=heap[i];while(j<=length){if(j<length && heap[j]>heap[j+1])j++;//如果左右子树都存在,找出最小者,用j标记if(temp<heap[j])break;//找到了相应的位置else{heap[i]=heap[j];i=j;j=2*i;}}heap[i]=temp;}////////////////////////////////////////template <class Type>MinHeap<Type>::~MinHeap(){delete[] heap;}////////////////////////////////////////class JobNode{friend void Greedy(JobNode *,int ,int);friend void main(void);public:operator int() const {return time;}int ID,time;};class MachineNode{friend void Greedy(JobNode *,int ,int); public:operator int() const {return avail;}int ID,avail;};void Sort(JobNode a[],int n){int i,j,k;JobNode tmp;for(i=1;i<n;i++){k=i;for(j=i+1;j<=n;j++){if(a[j].time<a[k].time) k=j;}if(k!=i){tmp=a[i];a[i]=a[k];a[k]=tmp;}}}void Greedy(JobNode a[],int n,int m){if(n<=m){cout<<"为每个作业分配一台机器."<<endl;return;}Sort(a,n);MinHeap<MachineNode>H(m);MachineNode x;for(int i=1;i<=m;i++){x.avail=0;x.ID=i;H.Insert(x);}for(i=n;i>=1;i--){H.DeleteMin(x);cout<<"\n将机器"<<x.ID<<"从"<<x.avail<<"到"<<(x.avail+a[i].time)<<"的时间段分配给作业"<<a[i].ID<<endl;x.avail+=a[i].time;H.Insert(x);}}void main(){int i;int job_cnt; //作业的数目float machine_cnt;//机器数目int Time_of_all=0;JobNode a[Max];//作业所需要的时间// MachineNode b[Max];cout<<"==========多机调度问题===========\n";cout<<"输入机器个数：";cin>>machine_cnt;cout<<"输入作业个数(小于15)：";cin>>job_cnt;for(i=1;i<=job_cnt;i++){cout<<"\n请输入第"<<i<<"个作业处理时间:";cin>>a[i].time;a[i].ID=i;}Greedy(a,job_cnt,machine_cnt);}四、结果截图五．实验总结多机调度问题是生活中比较典型的例子，根据经验我们很好确定贪心算法的贪心标准，但是落实到编程，还是有点不够得心应手，还需要加强自己的编程能力。
最小生成树例题贪心算法c语言算法与设计
最小生成树例题贪心算法c语言算法与设计题目：最小生成树例题——贪心算法在C语言算法与设计中的应用引言:在算法和数据结构的学习过程中，贪心算法是一种常见且重要的思想。
它通过每一步局部最优的选择来构建整体最优解。
最小生成树问题是贪心算法的经典例题之一，而在C语言算法与设计中，理解并应用贪心算法是非常必要的。
本文将围绕最小生成树例题展开，探讨贪心算法在C语言算法与设计中的应用。
一、最小生成树（Minimum Spanning Tree）的定义与理解1.1 概念解析最小生成树是图论中的一个概念，它指的是在连通图中找到一棵树，使得这棵树的所有边的权值之和最小。
最小生成树常应用于优化问题，如电缆布线以及城市间道路建设等。
1.2 算法应用最小生成树常用于解决具有边权的连通图问题。
在实际应用中，我们通常使用Kruskal算法或Prim算法来求解最小生成树。
二、Kruskal算法详解2.1 思想描述Kruskal算法是一种基于贪心思想的算法，其主要思路是依次选择边权最小且不形成回路的边，直到生成最小生成树。
2.2 具体步骤（1）将图中的所有边按照权值从小到大进行排序；（2）从权值最小的边开始，如果该边的两个端点不在同一个连通分量中，则将其加入最小生成树，并合并两个连通分量；（3）重复步骤（2），直到最小生成树包含图中的所有节点。
2.3 例子分析以以下图为例说明Kruskal算法的应用过程：```（图1）```（1）将图中的边按照权值从小到大排序得到如下顺序：```A-B: 1E-F: 1B-C: 2E-G: 2C-D: 3D-F: 3F-G: 4```（2）选取权值最小的边A-B，并将A和B加入最小生成树。
此时连通分量为{A}和{B}。
```（图2）```（3）选取权值次小的边E-F，可以将其加入最小生成树，同时连通分量中加入F。
此时连通分量为{A}，{B}和{F}。
```（图3）```（4）依次选择权值较小的边，直到最小生成树中包含图中的所有节点。
多机调度问题的贪心算法实现(使用C语言)
多机调度问题的贪心算法实现（使用C语言）标题：多机调度问题的贪心算法实现（使用C语言）简介：多机调度问题是一个经典的组合优化问题，旨在将一组待处理的任务分配给多台计算机，使得任务完成时间最小化。
贪心算法是一种常用的解决该问题的方法，本文将介绍如何使用C语言实现贪心算法来解决多机调度问题。
引言：随着计算机技术的不断进步，我们面临的任务越来越多，如何有效地将任务分配给多台计算机成为一个重要的问题。
多机调度问题涉及到任务的分配、计算机资源的利用率以及任务完成时间的优化。
本文将通过贪心算法来解决这一问题，贪心算法通过每次选择局部最优解，最终得到一个全局最优解。
1. 多机调度问题的贪心算法概述1.1 贪心算法的基本思想1.2 多机调度问题的贪心策略选择1.3 贪心算法实现的步骤2. 多机调度问题的输入与输出2.1 输入：任务集合和计算机集合2.2 输出：任务分配结果和任务完成时间3. 多机调度问题的贪心算法实现3.1 任务排序3.2 计算机选择3.3 任务分配3.4 计算任务完成时间4. 多机调度问题的贪心算法代码实现（使用C语言） 4.1 数据结构定义4.2 输入模块4.3 贪心算法实现函数4.4 输出模块5. 算法性能分析和改进5.1 算法的时间复杂度分析5.2 算法的空间复杂度分析5.3 改进思路：局部搜索算法的引入6. 总结与展望6.1 对多机调度问题贪心算法的观点和理解6.2 对未来算法改进的展望结论：本文详细介绍了如何使用C语言实现贪心算法来解决多机调度问题。
贪心算法通过选择局部最优解，使得任务完成时间最小化。
此外，我们还讨论了算法的性能分析和改进方向，展望了未来对算法的进一步优化。
通过本文的学习，读者能够更加全面深刻地理解多机调度问题及贪心算法的应用。
参考文献：[1] 文献1[2] 文献2[3] 文献3。
贪心算法最短路径问题c语言代码
贪心算法最短路径问题c语言代码贪心算法最短路径问题C语言代码在计算机算法的领域中，贪心算法是一种常见的解决问题的方法。
贪心算法是一种寻找最优解的方法，就是在每个步骤中都采取最优的选择，这样每一步的最优解最终就可以得到整体的最优解。
在实际应用中，贪心算法通常被用于NP问题的解决，例如最短路径问题。
本文将介绍如何用C语言实现贪心算法解决最短路径问题。
1. 最短路径问题概述最短路径问题是一种图论问题，是指在一个有权重的有向图或无向图中，从一个指定的起点节点到达一个指定终点节点的最短路径问题。
在实际应用中，最短路径问题的应用非常广泛，例如地图导航、网络寻路、信息传递等等。
2. 贪心算法的原理贪心算法是一种自顶向下的设计方法，它主要依赖与一种贪心的选择方法。
在每个步骤中，都会选择能够最优化当前直接的步骤的答案。
因此，当遇到问题难以确定最优解时，可以使用贪心算法。
一般来说，贪心算法的优点是简单易懂，并且在特定情况下能够得到准确的答案。
3. C语言代码实现快速查找从起点到所有节点的距离是这个问题的关键，可以使用某种最短路算法，例如Dijkstra算法或贪心算法。
在这里，我们使用贪心算法解决最短路径问题。
以下是C语言代码示例：#include <stdio.h> #include <stdlib.h> #include <string.h>#define V 6int min_distance(int distance[], int visited[]) { int min_index, min_distance = INT_MAX;for (int i = 0; i < V; i++) { if (visited[i] == 0 && distance[i] <= min_distance){ min_distance = distance[i]; min_index = i; } }return min_index; }int dijkstra(int graph[V][V], int source, int destination) { int distance[V], visited[V], count; memset(distance, 0, sizeof(distance)); memset(visited, 0, sizeof(visited));for (int i = 0; i < V; i++){ distance[i] = INT_MAX; }distance[source] = 0;for (count = 0; count < V - 1; count++){ int u = min_distance(distance, visited);visited[u] = 1;for (int v = 0; v < V; v++){ if (!visited[v] && graph[u][v] &&distance[u] != INT_MAX && distance[u] + graph[u][v]< distance[v]) { distance[v] =distance[u] +graph[u][v]; } } }return distance[destination]; }int main() { int graph[V][V] = { { 0, 1, 0,0, 0, 0 }, { 0, 0, 9, 0, 0,0 }, { 2, 0, 0, 3, 0, 1 }, { 0, 0, 0, 0, 2, 0 }, { 4,6, 0, 2, 0, 0 }, { 0, 0, 0,0, 1, 0 } };int source = 0, destination = 5;int distance = dijkstra(graph, source,destination);printf("The shortest distance from node %dto %d is: %d\n", source, destination, distance);return 0; }4. 结尾在本文中，我们介绍了贪心算法解决最短路径问题的原理和C语言代码实现。
第三章 贪心算法
2021/2/22
5
如果问题改成：砝码的种类分别为11克、5克和1克， 待称的物体是15克。用贪婪算法应先选一个11克的，然 后选四个1克的，共用五个砝码。这不是最优结果，只 要用三个5克的砝码就够了。
贪婪算法虽不能保证得到最优结果，但对于一些除
了“穷举”方法外没有有效算法的问题，用贪婪算法往
往能很快地得出较好的结果，如果此较好结果与最优结 果相差不是很多的话，此方法还是很实用的。
2021/2/22
9
当n不太大时，适当的取k值，此改进方法常常可以得到 最优解，但不能因此就说一般背包问题有多项式算法。 当n增大时，k不能随着n不断的加大，如k随n增大而同 时加大，其复杂性就是指数型而不是多项式型的了，而 如k取值较小，又不能保证得出最优解。
c++贪心算法经典例题
c++贪心算法经典例题和详解贪心算法（Greedy Algorithm）是一种优化问题解决方法，其基本思想是每一步都选择当前状态下的最优解，以期望达到全局最优解。
贪心算法的特点是每一步都要做出一个局部最优的选择，而这些局部最优选择最终构成了全局最优解。
下面是一个经典的贪心算法例题以及详解：例题：活动选择问题（Activity Selection Problem）假设有一个需要在同一时段使用同一个资源的活动集合，每个活动都有一个开始时间和结束时间。
设计一个算法，使得能够安排最多数量的互不相交的活动。
# 输入：-活动的开始时间数组`start[]`。
-活动的结束时间数组`end[]`。
# 输出：-选择的互不相交的活动的最大数量。
# 算法详解：1. 首先，将活动按照结束时间从小到大排序。
2. 选择第一个活动，并将其加入最终选择的集合中。
3. 对于剩下的活动，选择下一个结束时间最早且与前一个活动不冲突的活动。
4. 重复步骤3，直到所有活动都被选择。
```cpp#include <iostream>#include <algorithm>#include <vector>using namespace std;// 定义活动结构体struct Activity {int start, end;};// 比较函数，用于排序bool compareActivities(Activity a, Activity b) {return a.end < b.end;}// 贪心算法解决活动选择问题void activitySelection(vector<Activity>& activities) {// 按照结束时间排序sort(activities.begin(), activities.end(), compareActivities);// 第一个活动总是被选中cout << "Selected activity: (" << activities[0].start << ", " << activities[0].end << ")" << endl;// 选择其余活动int lastSelected = 0;for (int i = 1; i < activities.size(); i++) {// 如果当前活动的开始时间大于等于上一个选择的活动的结束时间，则选择该活动if (activities[i].start >= activities[lastSelected].end) {cout << "Selected activity: (" << activities[i].start << ", " << activities[i].end << ")" << endl;lastSelected = i;}}}int main() {vector<Activity> activities = {{1, 2}, {3, 4}, {0, 6}, {5, 7}, {8, 9}, {5, 9}};cout << "Activities before sorting:" << endl;for (const Activity& activity : activities) {cout << "(" << activity.start << ", " << activity.end << ") ";}cout << endl;activitySelection(activities);return 0;}```在这个例子中，我们首先定义了一个活动的结构体`Activity`，然后编写了一个比较函数`compareActivities` 用于排序。
贪心算法实验报告(C语言)
实验2、《贪心算法实验》一、实验目的1. 了解贪心算法思想2. 掌握贪心法典型问题，如背包问题、作业调度问题等。
二、实验内容1. 编写一个简单的程序，实现单源最短路径问题。
2. 编写一段程序，实现找零。
【问题描述】当前有面值分别为2角5分，1角，5分，1分的硬币，请给出找n分钱的最佳方案（要求找出的硬币数目最少）。
3. 编写程序实现多机调度问题【问题描述】要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m 台机器加工处理完成。
约定，每个作业均可在任何一台机器上加工处理，但未完工前不允许中断处理。
作业不能拆分成更小的子作业。
三、算法思想分析1.初始化将源点设计为红点集，其余点设计为蓝点，重复选择蓝点集中与源点路径最短的点加入红点集，更新剩余的蓝点集路径，直至蓝点集为空或者只剩下没有连通的点，那么源点到其余所有点的最短路径就出来了。
2.找零问题是典型的贪心问题，但是并不代表所有的找零都能用贪心算法找到最优解。
只有满足贪心选择性质的找零才能找到最优解，本题满足贪心选择性质，直接先一直选面值最大的硬币，再一次减小即可。
3.先对作业按时长进行重排序，再依次找目前用时最短的机器安排工作并加上对应时长，最后总时长为机器中用时最长的那个时长。
四、实验过程分析1.单源最短路径的算法思想并不难，但是在实际编码过程中还是有很多小问题需要注意，首先，一定要新建数组存储路径变化，因为后面计算路径时会用到原数组，如果直接在原数组上更改后面就找不到原数据了，那么就会出现偏差。
其次就是建议先写个伪代码，判断的if-else语句比较多，容易搞混，在代码中一定要及时备注，某些代码的功能是什么，不然再次看代码时需要思考很久甚至忘记。
2.找零问题直接用while循环或者不断取余取模即可解决。
3.作业调度问题大致分为三步，一是排序，二是不断找最短时长的机器安排作业，三是找最长时间为作业完成时间。
五、算法源代码及用户屏幕1.（1）算法源码/**********************单源最短路径问题。
贪心算法求解多机调度问题
多机调度问题一、 问题描述设有n个独立的作业{1,2,…,n}，由m台相同的机器进行加工处理。
作业i所需的处理时间为t i。
现约定，任何作业可以在任何一台机器上加工处理，但未完工前不允许中断处理，任何作业不能拆分成更小的子作业。
要求给出一种作业调度方案，使所给的n个作业在尽可能短的时间内由m台机器加工处理完成。
二、 问题分析这是一个NP完全问题，到目前为止还没有有效的解法。
本报告根据教材指导及实践经验，采用贪心算法进行分析求解，并进行简单评估。
使用贪心算法，能避免许多复杂的子问题分析，便于直观地剖析主要问题。
在选择贪心算法的基础上，进一步地，我们采用最长处理时间作业优先的贪心选择策略，以求设计出解多机调度问题的较好的近似算法。
预期效果：根据最长处理时间作业优先的原则，理应能够得出直观下比较高效的输出结果。
三、算法设计与分析1．算法输入和输出输入：作业数n，机器数m，作业i对应的处理时间t i（t i在测试时用一个一维数组time表示）输出：总耗费时间2．算法说明最长处理时间作业优先的贪心算法，顾名思义，就是将目前还未被处理的且需要处理时间最长的作业，分配给最先空闲的机器，直到分配完所有的作业为止。
3．算法描述（1）（处理1）：当n≤m时，只要将机器i的[0,t i]时间区间分配给作业i即可。
（2）（处理2）：当n＞m时：i.先将耗时最长的m个作业依次分配给m个机器ii.沿着时间轴，寻找最先得到空闲的机器。
将还未被处理且需要处理时间最长的那个作业分配给此机器iii.重复上一步直到所有作业都被处理完毕4．算法分析当n≤m时，算法需要O(1)时间。
当n＞m时，算法需要O(nlogn)时间。
四、算法流程图输入是否n≤m处理1 处理2输出图4-1 多机调度算法流程图五、测试数据及其结果分析1．测试数据当输入n=7, m=3, time={2,14,4,16,6,5,3}时（教材示例），经历处理2，输出结果为17 当输入n=7, m=3, time={4,5,13,9,4,11,2}时，经历处理2，输出结果为20当输入n=18, m=3, time={1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9}时，经历处理2，输出结果为33当输入n=3, m=3, time={2,3,5}时，经历处理1，输出结果为52．结果分析观察可知，贪心算法解此问题，比直观感受要更高效。
约翰逊算法例题
约翰逊算法例题约翰逊算法（Johnson's Algorithm）是一种用于解决两台机器上的作业调度问题的贪心算法。
该算法可以将作业按照最优顺序安排在两台机器上，使得完成所有作业的时间最短。
以下是一个约翰逊算法的例题：假设有4个作业（A、B、C、D）需要在两台机器上完成。
每个作业在两台机器上的处理时间如下表所示：作业| 机器1处理时间| 机器2处理时间--- | --- | ---A | 3 | 6B | 2 | 5C | 4 | 3D | 2 | 2按照约翰逊算法的步骤来解决这个问题：步骤1：计算作业在机器1上的处理时间和在机器2上的处理时间之和，并按照总时间从小到大排序。
作业| 机器1处理时间| 机器2处理时间| 总时间--- | --- | --- | ---B | 2 | 5 | 7D | 2 | 2 | 4C | 4 | 3 | 7A | 3 | 6 | 9按照总时间的大小顺序重新排列作业：D、B、C、A步骤2：从总时间最小的作业开始，依次将作业分配给机器1和机器2，直到所有作业都被分配完毕。
初始情况下，机器1和机器2都没有被分配作业。
首先，将作业D分配给机器1，将作业D分配给机器2。
此时，机器1的处理时间为2，机器2的处理时间为2。
作业| 分配机器--- | ---D | 1D | 2接下来，将作业B分配给机器1，将作业C分配给机器2。
此时，机器1的处理时间为4，机器2的处理时间为5。
作业| 分配机器--- | ---D | 1D | 2B | 1C | 2最后，将作业A分配给机器1，将作业A分配给机器2。
此时，机器1的处理时间为7，机器2的处理时间为11。
作业| 分配机器--- | ---D | 1D | 2B | 1C | 2A | 1A | 2步骤3：按照作业的分配顺序得到最终的作业调度顺序。
最终的作业调度顺序为：D、B、C、A、A。
因此，按照约翰逊算法，最优的作业调度顺序为：D、B、C、A、A，完成所有作业的总时间为11个单位。
贪心算法：任务调度问题
数据结构课程设计报告贪心算法：任务调度问题专业计算机科学与技术（软件工程）学生姓名陈亮班级BM计算机091学号**********指导教师吴素芹起止日期2011.1.10-2011.1.14***********目录1简介 (1)2算法说明 (2)3测试结果 (2)4分析与探讨 (8)5小结 (11)参考文献 (11)附录 (12)附录1 源程序清单 (12)贪心算法1 简介贪心算法通过一系列的选择来得到一个问题的解。
它所做的每一个选择都是当前状态下某种意义的最好选择，即贪心选择。
希望通过每次所做的贪心选择导致最终结果是问题的一个最优解。
这种启发式的策略并不总奏效，然而许多情况下确能达到预期的目的。
下面来看一个找硬币的例子。
假设有四种面值的硬币：一分、两分、五分和一角。
现在要找给某顾客四角八分钱。
这时，一般都会拿出四个一角、一个五分、一个两分和一个一分的硬币递给顾客。
这种找硬币的方法与其他的方法相比，它所给出的硬币个数是最少的。
在这里，就是下意思的使用了贪心算法（即尽可能地先考虑大币值的硬币）。
贪心算法并不是从整体最优加以考虑，它所做出的选择只是局部最优选择。
一些问题中，使用贪心算法得到的最后结果并不是整体的最优解，这时算法得到的是一次最优解（Suboptimal Solution）。
在上述的问题中，使用贪心算法得到的结果恰好就是问题整体的最优解。
对于一个具体的问题，怎么知道是否可用贪心算法来解此问题，以及能否得到问题的一个最优解呢？这个问题很难给予肯定的回答。
但是，许多可以用贪心算法求解的问题中一般具有两个重要的性质：贪心选择性质和最优子结构性质。
所谓贪心选择性质是指所求问题的整体最优解可以通过一系列局部最优的选择即贪心选择来达到，这是贪心算法可行的第一个基本要素。
对于一个具体问题，要确定它是否具有贪心选择性质，必须证明每一步所做的贪心选择最终将会得到问题的一个整体最优解。
首先考察问题的一个整体最优解，并证明可修改这个最优解，使其以贪心选择开始。
多机调度问题贪心算法python代码
多机调度问题贪心算法python代码多机调度问题是一种经典的优化问题，它的目标是在多台机器上完成一组任务，使得任务完成时间最短。
贪心算法是求解这个问题的一种有效方法。
贪心算法的基本思想是每次选择当前最优的解决方案，直到达到全局最优解。
在多机调度问题中，我们可以采用以下贪心策略来求解：1. 将所有任务按照完成时间从小到大排序。
2. 将第一个任务分配给第一台机器。
3. 对于剩余的任务，将其分配给当前完成时间最早的机器。
4. 重复步骤3直到所有任务都被分配完毕。
下面是使用Python实现多机调度问题贪心算法的代码：```pythondef schedule(tasks, m):# 按照完成时间从小到大排序tasks.sort(key=lambda x: x[1])# 初始化每台机器的完成时间为0machines = [0] * m# 分配任务for task in tasks:# 找到当前完成时间最早的机器min_time = machines[0]min_machine = 0for i in range(1, m):if machines[i] < min_time:min_time = machines[i]min_machine = i# 将任务分配给该机器并更新其完成时间machines[min_machine] += task[0]# 返回完成时间最晚的机器的完成时间return max(machines)```该代码中，tasks是一个元素为元组的列表，每个元组表示一个任务，第一个元素为任务的处理时间，第二个元素为任务的完成时间。
m表示机器的数量。
我们可以使用以下代码来测试该函数：```pythontasks = [(2, 6), (3, 7), (4, 8), (4, 9), (5, 10)]m = 3print(schedule(tasks, m))```输出结果为：```12```这表示将这些任务分配给3台机器后，完成所有任务需要的最短时间为12。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
实验内容：多机调度问题
设有n项独立的作业{1,2,…, n},由m台相同的机器加工处理。
作业i所需要的处理时间为台相同的机器加工处理。
设有n项独立的作业由ti。
约定：任何一项作业可在任何一台机器上处理，但未完工前不准中断处理；任何作业不能拆分成更小的子作业。
多机调度问题要求给出一种调度方案，能拆分成更小的子作业。
多机调度问题要求给出一种调度方案，使所给的n个作业在尽可台机器处理完。
利用贪心策略，设计贪心算法解决多机调度问题，能短的时间内由m台机器处理完。
利用贪心策略，设计贪心算法解决多机调度问题，并计算其时间复杂度。
多机调度问题的一个实例：
多机调度问题的一个实例：项独立的作业{1,2,3,4,5,6,7}，要由三台机器M1, M2 ,M3处理。
各个作业所需处理。
各个作业所需例如设有7项独立的作业，要的处理时间分别为{2,14,4,16,6,5,3}。
利用你设计的贪心算法，要的处理时间分别为。
利用你设计的贪心算法，安排作业的处理顺序使得机器处理作业的时间最短。
器处理作业的时间最短。
#include <iostream>
using namespace std;
void Greedy(int t[],int n,int m);
int main() {
int n=7,m=3,t[]={2,14,4,16,6,5,3};//待分配的工作
Greedy(t,n,m);
return 0; }
void Greedy(int t[],int n,int m)
{ int flagn,flagm; int M[]={0,0,0,0,0,0,0,0};
for(int i=0;i<n;i++)
{ int max=0,min=10000;
flagn=0;
flagm=0;
for(int j=0;j<n;j++)//选择时间最多的工作
{ if(max<t[j]) { max=t[j]; flagn=j; } }
for(j=0;j<m;j++)//选择工作量最小的机器
{
if(M[flagm]>M[j])
{flagm=j;}
}
M[flagm]=M[flagm]+t[flagn]; t[flagn]=0; //被选择过的机器时间调为0cout<<flagn<<"work "<<flagm<<"machine"<<endl; } }。