#include<cstdio>

#include<cstdlib>

struct PCB

{

    char name[];

    char state; //状态

    int super; //优先级

    int ntime; //预计运行时间

    int rtime; //实际运行时间

    PCB *link;

}*ready=NULL, *p;

void disp(PCB *pr) /*建立进程显示函数,用于显示当前进程 */

{

    printf("\n qname \t state \t super \t ntime \t rtime \n");

    printf("|%s \t ",pr->name);

    printf("|%c \t ",pr->state);

    printf("|%d \t ",pr->super);

    printf("|%d \t ",pr->ntime);

    printf("|%d \t ",pr->rtime);

    printf("\n");

}

void check() /* 建立进程查看函数 */

{

    printf("\n ******** 当前正在运行的进程是:%s",p->name); /* 显示当前运行进程 */

    disp(p);

    printf("\n ******** 当前就绪队列状态为:\n"); /* 显示就绪队列状态 */

    PCB *pr=ready;

    while(pr!=NULL) disp(pr), pr=pr->link;

}

void sort() /* 建立对进程进行优先级排列函数 */

{

    if(ready==NULL || (p->super)>(ready->super)) /* 优先级最大者,插入队首 */

    {

        p->link=ready;

        ready=p;

    }

    else /* 进程比较优先级,插入适当的位置中 */

    {

        PCB *first=ready, *second=first->link;

        while(second!=NULL)

        {

            if((p->super)>(second->super)) /* 若插入进程比当前进程优先数大,插入到当前进程前面 */

            {

                first->link=p;

                p->link=second;

                return;

            }

            first=first->link;

            second=second->link;

        }

        first->link=p;

    }

}

void input() /* 建立进程控制块函数 */

{

    system("cls");

    printf("\n 请输入进程数目?");

    int num; scanf("%d",&num);

    for(int i=;i<num;i++)

    {

        printf("\n 进程号 No.%d:\n",i);

        p=(PCB *)malloc(sizeof(PCB));

        printf("\n 输入进程名:");

        scanf("%s",p->name);

        printf("\n 输入进程优先数:");

        scanf("%d",&(p->super));

        printf("\n 输入进程运行时间:");

        scanf("%d",&(p->ntime));

        printf("\n");

        p->rtime=;

        p->state='w';

        p->link=NULL;

        sort(); /* 调用 sort 函数 */

    }

    system("cls");

    printf("\n ******** 进程创建如下:\n");

    PCB *pr=ready;

    while(pr!=NULL) disp(pr), pr=pr->link;

}

inline void destroy() /*建立进程撤消函数(进程运行结束,撤消进程) */

{

    printf("\n 进程 [%s] 已完成.\n",p->name), free(p);

}

inline void running() /* 建立进程就绪函数(进程运行时间到,置就绪状态) */

{

    (p->rtime)++;

    if(p->rtime==p->ntime)

        destroy(); /* 调用 destroy 函数 */

    else

        --(p->super), p->state='w', sort();

}

int main() /*主函数*/

{

    input();

    int h=;

    while(ready!=NULL)

    {

        getchar();

        printf("\n The execute number:%d \n",++h);

        p=ready;

        ready=p->link;

        p->link=NULL;

        p->state='r';

        check();

        running();

        printf("\n 按任意键继续......"), getchar();

    }

    printf("\n\n 进程已经全部完成.\n");

    getchar();

    return ;

}

/*

3

A

3

5

B

2

3

C

1

4

*/

#include<bits/stdc++.h>

using namespace std;

int cur_time;

int limit;

double turnover_time_sum, weighted_turnover_time_sum;

struct JCB

{

    int index; //作业序号

    string name; //作业名称

    string state; //状态

    int estimate_time; //预计运行时间

    int arrive_time; //到达时间

    int running_time; //实际运行时间

    int end_time; //结束时间

    inline int turnover_time()const //周转时间

    {

        return cur_time-arrive_time;

    }

    inline double weighted_turnover_time()const

    {

        return turnover_time()*1.0/running_time;

    }

    inline int waiting_time()const //等待时间

    {

        return turnover_time()-running_time;

    }

    void print()const

    {

        printf("作业 %d : \t",index);

        cout<<"|名称: "<<name<<" \t";

        cout<<"|状态: "<<state<<" \t";

        printf("|到达: %d \t",arrive_time);

        printf("|预计运行: %d \t",estimate_time);

        printf("|已运行: %d \t",running_time);

        printf("|已等待: %d \t",waiting_time());

        if(state=="destroy")

        {

            printf("|周转时间: %d \t",turnover_time());

            printf("|带权周转: %.2f",weighted_turnover_time());

        }

        printf("\n");

    }

};

bool cmp(const JCB &a,const JCB &b)

{

    return a.arrive_time<b.arrive_time;

}

vector<JCB> memory; //内存

queue<JCB> fifo; //FIFO队列

vector<JCB> destroy; //待销毁

JCB createJob(int index) //创建

{

    JCB res;

    printf("\n\n作业序号: %d\n",res.index=index);

    res.state="reserve";

    printf("请输入作业名称:\n");

    cin>>res.name;

    printf("请输入预计运行时间:\n");

    cin>>res.estimate_time;

    printf("请输入到达时间:\n");

    cin>>res.arrive_time;

    res.running_time=;

    return res;

}

void printJobs() //输出各个作业情况

{

    printf("\n************************************************************\n");

    printf("目前时间: %d\n",cur_time);

    printf("\n内存中存在 %d 个作业:\n",memory.size());

    for(auto job:memory) job.print();

    queue<JCB> tmp=fifo;

    printf("\n后备队列中存在 %d 个作业:\n",tmp.size());

    while(tmp.size()) tmp.front().print(), tmp.pop();

    printf("\n待销毁 %d 个作业:\n",destroy.size());

    for(auto job:destroy) job.print();

    cout<<endl<<endl<<endl<<endl;

}

void runJobs() //运行内存中的作业

{

    for(unsigned int i=;i<memory.size();i++)

    {

        memory[i].running_time++;

        if(memory[i].running_time==memory[i].estimate_time)

        {

            memory[i].state="destroy";

            memory[i].end_time=cur_time;

            destroy.push_back(memory[i]);

            memory.erase(memory.begin()+i);

            i--;

        }

    }

}

void destroyJobs() //销毁待销毁的作业

{

    for(unsigned int i=;i<destroy.size();i++)

    {

        turnover_time_sum+=destroy[i].turnover_time();

        weighted_turnover_time_sum+=destroy[i].weighted_turnover_time();

    }

    destroy.clear();

}

int main()

{

    printf("请输入内存允许的最多作业数目:\n");

    cin>>limit;

    printf("请输入作业总数目:\n");

    int num; cin>>num;

    vector<JCB> tmp;

    for(int i=;i<num;i++) tmp.push_back(createJob(i));

    sort(tmp.begin(),tmp.end(),cmp);

    cur_time=;

    turnover_time_sum=weighted_turnover_time_sum=0.0;

    while(tmp.size()> || fifo.size()> || memory.size()>)

    {

        while(memory.size()<limit && fifo.size()>)

        {

            JCB tmp=fifo.front();

            fifo.pop();

            tmp.state="running";

            memory.push_back(tmp);

        }

        for(unsigned int i=;i<tmp.size();i++)

        {

            if(tmp[i].arrive_time==cur_time)

            {

                fifo.push(tmp[i]);

                tmp.erase(tmp.begin()+i);

                i--;

            }

        }

        runJobs();

        printJobs();

        destroyJobs();

        cur_time++;

    }

    printf("\n\n该组作业平均周转时间 %.2f, 平均带权周转时间 %.2f.\n",turnover_time_sum/num,weighted_turnover_time_sum/num);

}

/*

2

7

YJC

5

3

HBG

3

1

WYY

10

5

QQQ

2

7

ZVD

8

1

WCY

10

10

YJLGXC

7

5

*/

#include<bits/stdc++.h>

using namespace std;

int cur_time;

int limit;

double turnover_time_sum, weighted_turnover_time_sum;

struct JCB

{

    int index; //作业序号

    string name; //作业名称

    string state; //状态

    int estimate_time; //预计运行时间

    int arrive_time; //到达时间

    int running_time; //实际运行时间

    int end_time; //结束时间

    inline int turnover_time()const //周转时间

    {

        return cur_time-arrive_time;

    }

    inline double weighted_turnover_time()const

    {

        return turnover_time()*1.0/running_time;

    }

    inline int waiting_time()const //等待时间

    {

        return turnover_time()-running_time;

    }

    void print()const

    {

        printf("作业 %d : \t",index);

        cout<<"|名称: "<<name<<" \t";

        cout<<"|状态: "<<state<<" \t";

        printf("|到达: %d \t",arrive_time);

        printf("|预计运行: %d \t",estimate_time);

        printf("|已运行: %d \t",running_time);

        printf("|已等待: %d \t",waiting_time());

        if(state=="destroy")

        {

            printf("|周转时间: %d \t",turnover_time());

            printf("|带权周转: %.2f",weighted_turnover_time());

        }

        printf("\n");

    }

    bool operator<(const JCB &o)const

    {

        return o.estimate_time<estimate_time;

    }

};

bool cmp(const JCB &a,const JCB &b)

{

    return a.arrive_time<b.arrive_time;

}

vector<JCB> memory; //内存

priority_queue<JCB> heap; //优先队列

vector<JCB> destroy; //待销毁

JCB createJob(int index) //创建

{

    JCB res;

    printf("\n\n作业序号: %d\n",res.index=index);

    res.state="reserve";

    printf("请输入作业名称:\n");

    cin>>res.name;

    printf("请输入预计运行时间:\n");

    cin>>res.estimate_time;

    printf("请输入到达时间:\n");

    cin>>res.arrive_time;

    res.running_time=;

    return res;

}

void printJobs() //输出各个作业情况

{

    printf("\n************************************************************\n");

    printf("目前时间: %d\n",cur_time);

    printf("\n内存中存在 %d 个作业:\n",memory.size());

    for(auto job:memory) job.print();

    priority_queue<JCB> tmp=heap;

    printf("\n后备队列中存在 %d 个作业:\n",tmp.size());

    while(tmp.size()) tmp.top().print(), tmp.pop();

    printf("\n待销毁 %d 个作业:\n",destroy.size());

    for(auto job:destroy) job.print();

    cout<<endl<<endl<<endl<<endl;

}

void runJobs() //运行内存中的作业

{

    for(unsigned int i=;i<memory.size();i++)

    {

        memory[i].running_time++;

        if(memory[i].running_time==memory[i].estimate_time)

        {

            memory[i].state="destroy";

            memory[i].end_time=cur_time;

            destroy.push_back(memory[i]);

            memory.erase(memory.begin()+i);

            i--;

        }

    }

}

void destroyJobs() //销毁待销毁的作业

{

    for(unsigned int i=;i<destroy.size();i++)

    {

        turnover_time_sum+=destroy[i].turnover_time();

        weighted_turnover_time_sum+=destroy[i].weighted_turnover_time();

    }

    destroy.clear();

}

int main()

{

    printf("请输入内存允许的最多作业数目:\n");

    cin>>limit;

    printf("请输入作业总数目:\n");

    int num; cin>>num;

    vector<JCB> tmp;

    for(int i=;i<num;i++) tmp.push_back(createJob(i));

    sort(tmp.begin(),tmp.end(),cmp);

    cur_time=;

    turnover_time_sum=weighted_turnover_time_sum=0.0;

    while(tmp.size()> || heap.size()> || memory.size()>)

    {

        //将若干作业调度运行

        while(memory.size()<limit && heap.size()>)

        {

            JCB tmp=heap.top(); heap.pop();

            tmp.state="running";

            memory.push_back(tmp);

        }

        //当前时间点到达的作业进入后备队列

        for(unsigned int i=;i<tmp.size();i++)

        {

            if(tmp[i].arrive_time==cur_time)

            {

                heap.push(tmp[i]);

                tmp.erase(tmp.begin()+i);

                i--;

            }

        }

        runJobs();

        printJobs();

        destroyJobs();

        cur_time++;

    }

    printf("\n\n该组作业平均周转时间 %.2f, 平均带权周转时间 %.2f.\n",turnover_time_sum/num,weighted_turnover_time_sum/num);

}

/*

2

7

YJC

5

3

HBG

3

1

WYY

10

5

QQQ

2

7

ZVD

8

1

WCY

10

10

YJLGXC

7

5

*/

#include<bits/stdc++.h>

using namespace std;

int cur_time;

int limit;

double turnover_time_sum, weighted_turnover_time_sum;

struct JCB

{

    int index; //作业序号

    string name; //作业名称

    string state; //状态

    int estimate_time; //预计运行时间

    int arrive_time; //到达时间

    int running_time; //实际运行时间

    int end_time; //结束时间

    inline int turnover_time()const //周转时间

    {

        return cur_time-arrive_time;

    }

    inline double weighted_turnover_time()const

    {

        return turnover_time()*1.0/running_time;

    }

    inline int waiting_time()const //等待时间

    {

        return turnover_time()-running_time;

    }

    inline double response_ratio()const //响应比

    {

        return (waiting_time()+estimate_time)*1.0/estimate_time;

    }

    void print()const

    {

        printf("作业 %d : \t",index);

        cout<<"|名称: "<<name<<" \t";

        cout<<"|状态: "<<state<<" \t";

        printf("|到达: %d \t",arrive_time);

        printf("|预计运行: %d \t",estimate_time);

        printf("|已运行: %d \t",running_time);

        printf("|已等待: %d \t",waiting_time());

        if(state=="reserve")

        {

            printf("|响应比: %.2f",response_ratio());

        }

        if(state=="destroy")

        {

            printf("|周转时间: %d \t",turnover_time());

            printf("|带权周转: %.2f",weighted_turnover_time());

        }

        printf("\n");

    }

    bool operator>(const JCB &o)const

    {

        return response_ratio()>o.response_ratio();

    }

};

bool cmp(const JCB &a,const JCB &b)

{

    return a.arrive_time<b.arrive_time;

}

vector<JCB> memory; //内存

vector<JCB> rq; //后备队列

vector<JCB> destroy; //待销毁

JCB createJob(int index) //创建

{

    JCB res;

    printf("\n\n作业序号: %d\n",res.index=index);

    res.state="reserve";

    printf("请输入作业名称:\n");

    cin>>res.name;

    printf("请输入预计运行时间:\n");

    cin>>res.estimate_time;

    printf("请输入到达时间:\n");

    cin>>res.arrive_time;

    res.running_time=;

    return res;

}

void printJobs() //输出各个作业情况

{

    printf("\n************************************************************\n");

    printf("目前时间: %d\n",cur_time);

    printf("\n内存中存在 %d 个作业:\n",memory.size());

    for(auto job:memory) job.print();

    printf("\n后备队列中存在 %d 个作业:\n",rq.size());

    for(auto job:rq) job.print();

    printf("\n待销毁 %d 个作业:\n",destroy.size());

    for(auto job:destroy) job.print();

    cout<<endl<<endl<<endl<<endl;

}

void runJobs() //运行内存中的作业

{

    for(unsigned int i=;i<memory.size();i++)

    {

        memory[i].running_time++;

        if(memory[i].running_time==memory[i].estimate_time)

        {

            memory[i].state="destroy";

            memory[i].end_time=cur_time;

            destroy.push_back(memory[i]);

            memory.erase(memory.begin()+i);

            i--;

        }

    }

}

JCB findJobs() //在后备队列查找作业

{

    unsigned int idx=;

    for(unsigned int i=;i<rq.size();i++)

    {

        if(rq[i]>rq[idx]) idx=i;

    }

    printf("调度该作业进入内存:\n");

    rq[idx].print();

    JCB res=rq[idx];

    res.state="running";

    rq.erase(rq.begin()+idx);

    return res;

}

void destroyJobs() //销毁待销毁的作业

{

    for(unsigned int i=;i<destroy.size();i++)

    {

        turnover_time_sum+=destroy[i].turnover_time();

        weighted_turnover_time_sum+=destroy[i].weighted_turnover_time();

    }

    destroy.clear();

}

int main()

{

    printf("请输入内存允许的最多作业数目:\n");

    cin>>limit;

    printf("请输入作业总数目:\n");

    int num; cin>>num;

    vector<JCB> tmp;

    for(int i=;i<num;i++) tmp.push_back(createJob(i));

    sort(tmp.begin(),tmp.end(),cmp);

    cur_time=;

    turnover_time_sum=weighted_turnover_time_sum=0.0;

    while(tmp.size()> || rq.size()> || memory.size()>)

    {

        //将若干作业调度运行

        while(memory.size()<limit && rq.size()>)

            memory.push_back(findJobs());

        //当前时间点到达的作业进入后备队列

        for(unsigned int i=;i<tmp.size();i++)

        {

            if(tmp[i].arrive_time==cur_time)

            {

                rq.push_back(tmp[i]);

                tmp.erase(tmp.begin()+i);

                i--;

            }

        }

        runJobs();

        printJobs();

        destroyJobs();

        cur_time++;

    }

    printf("\n\n该组作业平均周转时间 %.2f, 平均带权周转时间 %.2f.\n",turnover_time_sum/num,weighted_turnover_time_sum/num);

}

/*

2

7

YJC

5

3

HBG

3

1

WYY

10

5

QQQ

2

7

ZVD

8

1

WCY

10

10

YJLGXC

7

5

*/