// 0612.cpp : Defines the entry point for the console application.
//

短作业优先（SJF, Shortest Job First）又称为“短进程优先”SPN(Shortest Process
Next)；是对FCFS算法的改进，其目标是减少平均周转时间。 短作业优先调度算法基于这样一种思想： 运行时间短的优先调度；
如果运行时间相同则调度最先发起请求的进程。 等待时间：一个进程从发起请求到开始执行的时间间隔。
现在有n个进程请求cpu，每个进程用一个二元组表示：(p,q),p代表该进程发起请求的时间，p代表需要占用cpu的时间。
请计算n个进程的平均等待时间。

//短作业优先（SJF）调度是FIFO的改进，减少了平均周转时间
    #include<iostream>
using namespace std;
#include<vector>

struct Job
{
    int start;
    int need;
};

int compareJob(Job j1, Job j2)
{
    if (j1.start == j2.start)
        return j1.need - j2.need;
    return j1.start - j2.start;
}

int main()
{
    int n;
    while (cin >> n)
    {
        vector<Job> wait;
        int  st, nd, sum_w = 0;
        for (int i = 0; i < n; ++i)
        {
            cin >> st >> nd;
            wait.push_back({ st, nd });
        }
        for (int i = wait.size() - 1; i > 0; --i)
        {
            bool change = false;
            for (int j = 0; j < i; ++j)
            {
                if (compareJob(wait[j], wait[j + 1])>0)
                {
                    Job t = wait[j];
                    wait[j] = wait[j + 1];
                    wait[j + 1] = t;
                    change = true;
                }
            }
            if (change == false)
                break;
        }
        int thisTime = wait[0].start + wait[0].need;
        for (int i = 1; i < wait.size(); ++i)
        {
            if (thisTime < wait[i].start)
                thisTime = wait[i].start;
            sum_w += (thisTime - wait[i].start);
            thisTime += wait[i].need;
        }
        printf("%.4f\n", sum_w / (double)n);
    }
    return 0;
}

在计算机中，页式虚拟存储器实现的一个难点是设计页面调度（置换）算法。其中一种实现方式是FIFO算法。 FIFO算法根据页面进入内存的时间先后选择淘汰页面，先进入内存的页面先淘汰，后进入内存的后淘汰。 假设Cache的大小为2,有5个页面请求，分别为 2 1 2 3 1，则Cache的状态转换为：(2)->(2,1)->(2,1)->(1,3)->(1,3)，其中第1,2,4次缺页，总缺页次数为3。 现在给出Cache的大小n和m个页面请求，请算出缺页数。

#include <iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
bool findd(vector<int>q,int n){
    bool flag=false;
    for(int i=0;i<q.size();i++)
    {
        if(q[i]==n)
            flag=true;

    }
    return flag;
}

int main(){
    int n,m;
    while(cin>>n>>m)
    {

        vector<int> v;
        for(int i=0;i<m;i++)
        {
            int temp;
            cin>>temp;
            v.push_back(temp);
        }
        vector<int> q;
        int countt=0;
        for(int j=0;j<m;j++)
        {
           if(!findd(q,v[j]))
           {
                if(q.size()<n)
                    q.push_back(v[j]);
                else
                    {
                        q.erase(q.begin());
                        q.push_back(v[j]);
                    }
               countt++;
           }
           else
                continue;
        }
       cout<<countt<<endl;

    }
    return 0;
}

    拉姆刚开始学习英文单词，对单词排序很感兴趣。
如果给拉姆一组单词，他能够迅速确定是否可以将这些单词排列在一个列表中，使得该列表中任何单词的首字母与前一单词的为字母相同。
你能编写一个程序来帮助拉姆进行判断吗？

#include <iostream>
using namespace std;
#include <vector>
#include <string>

int main()
{
    int n;
    while (cin>>n)
    {
        vector<string> vc(n);
        for (int i = 0; i < n;i++)
        {
            cin >> vc[i];
        }
        bool flag = true;
        for (int i = 0; i < n-1;i++)   //提出为bool的函数
        {
            int size = vc[i].size();
            if (vc[i][size-1]==vc[i+1][0])
            {
                continue;
            }
            else{
                flag = false;           
                break;
            }

        }
        if (flag)
        {
            cout << "Yes" << endl;
        }
        else
        {
            cout << "No" << endl;
        }
    }
    return 0;
}