百度2017暑期实习编程题

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

输入包含多组测试数据。

  对于每组测试数据，第一行为一个正整数n，代表有n个单词。

  然后有n个字符串，代表n个单词。

  保证：

  2<=n<=200,每个单词长度大于1且小于等于10,且所有单词都是由小写字母组成。

  

输出描述:

对于每组数据，输出"Yes"或"No"

输入例子:

  3

  abc

  cdefg

  ghijkl

  4

  abc

  cdef

  fghijk

  xyz

  

输出例子:

  Yes

  No

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

int main()
{
int n(0);
while (cin >> n)
{
string str;
vector<string>ss;
map<char, vector<int>>g;
for (int i = 0; i < n; i++)
{
cin >> str;
ss.push_back(str);
g[str[0]].push_back(i);
}
int k = 0;
bool flag = false;
while (!flag&&k<ss.size())
{
vector<int>path;
g[ss[k][0]].erase(find(g[ss[k][0]].begin(), g[ss[k][0]].end(), k));
if (g[ss[k][0]].empty())
g.erase(g.find(ss[k][0]));
path.push_back(k);
map<char, int>st;
for (map<char, vector<int>>::iterator it = g.begin(); it != g.end(); it++)
st[it->first] = 0;
while (!flag&&!path.empty())
{
while (st[ss[path.back()].back()] < g[ss[path.back()].back()].size())
{
int b = g[ss[path.back()].back()][st[ss[path.back()].back()]];
st[ss[path.back()].back()] += 1;
path.push_back(b);
if (path.size() == ss.size())
{
flag = true;
break;
}
}
if (!flag)path.pop_back();
}
k++;
}
if (flag)cout << "Yes" << endl;
else cout << "No" << endl;
}
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个页面请求，请算出缺页数。


输入描述:

输入包含多组测试数据。

对于每组测试数据，第一行是整数n，第二行是整数m。

然后有m个整数，代表请求页编号。

保证：

2<=n<=20,1<=m<=100，1<=页编号<=200.


输出描述:

对于每组数据，输出一个整数，代表缺页数


输入例子:

2
5
2
1
2
3
1

输出例子:

3

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main()
{
int n(0),m(0);
while(cin>>n>>m)
{
int cnt(0);
vector<int>cache;
for(int i=0;i<m;i++)
{
int a;cin>>a;
bool f=false;
for(int i=0;i<cache.size();i++)
if(cache[i]==a)
{
f=true;break;
}
if(!f)
{
cnt++;
if(cache.size()==n)
{
cache.erase(cache.begin());
cache.push_back(a);
}
else
cache.push_back(a);
}
}
cout<<cnt<<endl;
}
return 0;
}

短作业优先（SJF, Shortest Job First）又称为“短进程优先”SPN(Shortest Process Next)；是对FCFS算法的改进，其目标是减少平均周转时间。

短作业优先调度算法基于这样一种思想：

运行时间短的优先调度；

如果运行时间相同则调度最先发起请求的进程。

等待时间：一个进程从发起请求到开始执行的时间间隔。

现在有n个进程请求cpu，每个进程用一个二元组表示：(p,q),p代表该进程发起请求的时间，p代表需要占用cpu的时间。

请计算n个进程的平均等待时间。


输入描述:

输入包含多组测试数据。

对于每组测试数据，第一行为一个整数n。

然后有n行，每行两个整数，代表上述的二元组(p,q).

保证:

2<=n<=2000,1<=p<=300,1<=q<=100.


输出描述:

对于每组数据，输出一个浮点数，代表平均等待时间，请保留4位有效数字


输入例子:

4
1 4
1 3
1 5
2 1

输出例子:

5.2500