博客

1.最小延迟调度问题描述

f(i) 表示某任务 开始的时间。

ti  表示 某任务 加工的时间

di  表示 某任务 要求完成的时间

延迟：  f(i)+ti-di

• 如果 实际完成的时间 小于 规定完成时间，那么，就没有 延迟。延迟就是拖延，如果你在规定时间内（<=规定时间），那么，就说明没有延迟，没有拖延。
• 由于有很多用户，所以，会有很多不同的拖延值，我们的目标是，求得所有拖延值中的最大值，并使得这个最大的拖延值 最小。Min(Max拖延值）

2.举例理解调度问题

f1(1)为什么为0 ，因为 f(1)=0，t1=5，而 d=10，就是说，用户一在规定时间内完成了任务，当然没有延迟。

用户二的延迟：13-12=1

用户三的延迟： 17-15=2 

用户四的延迟： 27-11=16

用户五的延迟： 30-20=10

 所以，在这个调度的条件下，最大的延迟是 第四个用户：16.

按照规定的截止时间安排，这里D的顺序是： {10,11,12,15,20}

对应客户需要加工的时间排序就变成了:{5,10,8,4,3}

 用户一的延迟为： 因为 5<10，所以，延迟为0

 用户二的延迟为： 23-12=11

 用户三的延迟为： 27-15=12

 用户四的延迟为： 15-11=4

 用户五的延迟为： 30-20=10

 在这种情况下，最大的延迟是 12.

可见，不同的调度策略，得到的最小调度延迟值是不一样的。

对于贪心算法，如果要验证策略的正确性，可以通过举反例的方式。

• 对于策略1，按照 加工时间的长短 安排，肯定是 用户一 先安排，此时，用户一的 需要1个时间单位完成，用户二在 第11个时间单位 完成，
  
  用户一没有时间延迟，用户二的时间延迟为 1 。
• 但是，如果我们先加工第二个任务，任务二在 第10个时间单位结束， 规定结束时间为10 ，此时的延迟为0。第一个任务的加工时间为1，结束时间是 11，此时， 11<100，延迟也为 0 。
• 对于策略 2： 根据 d-t 的大小，我们应该优先安排 用户二，此时用户一的时间延迟是 11-2=9. 用户二的时间延迟为0。
  
  但是，我们如果优先安排用户一，此时用户一的时间延迟是0，用户二的时间延迟是1. 1<9

对于策略 3，是正确的，我们看看伪码

正确性证明：

code

/*
最小延迟调度问题
越前浩波
*/

#include<iostream>
using namespace std;
#define N 100

//也可以用sort()
struct Mission
{
    int num;
    int last;
    int end;
};

//
void QuickSort(Mission *mi,int f,int t)
{
    if(f<t)
    {
        int i=f-1,j=f;
        Mission m=mi[t];
        while(j<t)
        {
            if(mi[j].end<=m.end)
            {
                i++;
                Mission tmp=mi[i];
                mi[i]=mi[j];
                mi[j]=tmp;
            }
            j++;
        }
        Mission tmp1=mi[t];
        mi[t]=mi[i+1];
        mi[i+1]=tmp1;
        QuickSort(mi,f,i);
        QuickSort(mi,i+2,t);
    }
}
int main()
{
    int n;
    cout<<"请输入任务总数:"<<endl;
    cin>>n;
    Mission mi[N];//Mission[0]~Mission[n-1]
    int start[N+1];//排好序的任务的开始时间，start[1]~start[n]
    int i;
    for(i=0;i<n;i++)
    {
        mi[i].num=i+1;
        cout<<"任务"<<i+1<<"的持续时间为:";
        cin>>mi[i].last;
        cout<<"任务"<<i+1<<"的截止时间为:";
        cin>>mi[i].end;
    }
    QuickSort(mi,0,n-1);
    int delay=0,m=0;
    start[1]=0;
    if(start[1]+mi[0].last>mi[0].end)
    {
        delay=start[1]+mi[0].last-mi[0].end;//如果开始时间+持续时间>截止时间，累计延迟
    }

    for(i=1;i<n;i++)
    {
        start[i+1]=start[i]+mi[i-1].last;
        if(start[i+1]+mi[i].last>mi[i].end)
        {
            m=start[i+1]+mi[i].last-mi[i].end;
            if(delay < m)
                delay = m;
        }
    }
    cout<<"最大延迟为:"<<delay<<endl;
    for(i=0;i<n;i++)
    {
        cout<<"任务"<<mi[i].num<<"的执行时间:["<<start[i+1]<<","<<mi[i].last+start[i+1]<<"]"<<endl;
    }
    system("pause");
}