最强大脑
时间限制：C/C++语言 1000MS；其他语言 3000MS
内存限制：C/C++语言 65536KB；其他语言 589824KB
题目描述：
小B乘火车和朋友们一起在N市到M市之间旅行。她在路途中时睡时醒。当她醒来观看窗外的风景时，注意到每个火车站都有一种特别颜色的旗帜，但是她看到的旗
帜仅仅是经过的一小部分。小B在乘车过程中有两次清醒的时间，她到达旅程终点时处于睡梦中。出站时，她和朋友们谈论着一路的见闻，朋友们觉得很有意思。
他们把N到和M之间经过车站的旗帜颜色依次列出来，然后告诉你小B记得的旗帜颜色序列，让你判断小B究竟是从N和M之间哪些方向才能看到所说颜色的旗帜，还是根本就不可能看到？颜色用字母代表，相同的字母代表相同的颜色，不同的字母则表示不同的颜色。
输入
输入中有多组测试数据。每组测试数据包含三行，第一行为一个由小写拉丁字母构成的非空字符串，长度不超过10^5，表示N到M之间车站的颜色。火车从M向
N运行时，经过的车站相同，只是方向相反。第二行为小B在第一次睡醒时看到的颜色序列，第三行为小B在第二次睡醒时看到的颜色序列。两个序列都是小写的拉
丁字母构成的字符串，长度不超过100个字母。每个序列的颜色顺序排列按小B看到的时间顺序排列。
输出
对每组测试数据，在单独的行中输出小B的旅行方向。
forward – 由N到M方向；
backward – 由M到N方向；
both – 两种方向都有可能；
invalid – 不可能看到这样的颜色序列；
样例输入
atob
a
b
aaacaaa
aca
aa
样例输出
forward
both
Hint
火车假定时刻处于运动状态，不会两次看到同一个旗帜。N市和M市的车站没有旗帜。
当时的代码：
#include <iostream>
#include<string>
#include <vector>
using namespace std;
string reverse(string s1)
{
for(int i=0;i<s1.length()/2;i++)
{
char tmp=s1[i];
s1[i]=s1[s1.length()-i-1];
s1[s1.length()-i-1]=tmp;
}
return s1;
}
bool isSubSeq(string s1,string s2)
{
int i=0,j=0;
for(i=0;i<s1.length();i++)
{
for(;j<s2.length();j++)
{
if(s1[i]==s2[j])
{
j++;
break;
}
}
if(i!=s1.length()-1 && j==s2.length())
return false;
}
if(i==s1.length()&&s2[j-1]==s1[i-1])
return true;
else
return false;
}
int main()
{
string cols;
string see1;
string see2;
while(cin>>cols)
{
cin>>see1>>see2;
int res=0;
char s[200];
int i=0;
for(i=0;i<see1.length();i++)
s[i]=see1[i];
for(i=0;i<see2.length();i++)
s[i+see1.length()]=see2[i];
s[see1.length()+see2.length()]='\0';
string s2=reverse(s);
if(isSubSeq(s,cols)&&isSubSeq(s2,cols))
cout<<"both"<<endl;
else if(isSubSeq(s,cols))
cout<<"forward"<<endl;
else if(isSubSeq(s2,cols))
cout<<"backward"<<endl;
else
cout<<"invalid"<<endl;
}
return 0;
}
上面的代码只A了70%，现在才发现题目理解错了，忽略了每次醒来看到的旗帜应该是连续的，应该是判断是否是子串的问题，而我理解成了判断子序列。另外string有现成的reverse函数，不需要自己实现。。。修正后的代码：
#include <iostream>
#include<string>
#include <vector>
using namespace std;
int main()
{
string cols;
string see1;
string see2;
while(cin>>cols)
{
cin>>see1>>see2;
string cols2=cols;
reverse(cols2.begin(),cols2.end());
int forw=0;
int backw=0;
if(cols.find(see1)!=cols.npos)
{
int pos=cols.find(see1);
string t=cols.substr(pos+see1.length());
if(t.find(see2)!=t.npos)
forw=1;
}
if(cols2.find(see1)!=cols2.npos)
{
int pos=cols2.find(see1);
string t=cols2.substr(pos+see1.length());
if(t.find(see2)!=t.npos)
backw=1;
}
if(forw&&backw)
cout<<"both"<<endl;
else if(forw)
cout<<"forward"<<endl;
else if(backw)
cout<<"backward"<<endl;
else
cout<<"invalid"<<endl;
}
return 0;
}
内存管理
时间限制：C/C++语言 1000MS；其他语言 3000MS
内存限制：C/C++语言 65536KB；其他语言 589824KB
题目描述：
物联网技术的蓬勃发展，各种传感器纷纷出现。小B所在的项目组正在开发一个物联网项目，她们在研究设计一种新的传感器。这种传感器有自己的基本处理单元，
具有一定的自主性，能够进行简单的数据收集、处理、存储和传输。为降低系统功耗并保证系统可靠性和可控性，他们要对内存进行基本的管理。研究小组计划开发
一个实验性内存管理器，实现对内存的分配、释放和整理。对应的接口为new、del和def，使用语法为：
new size：分配size字节大小的内存块，返回该内存块的句柄handle，size为正整数；
del handle：释放句柄handle指向的内存块；
def：整理内存碎片，将所有已分配内存块按地址从低到高的顺序迁移，使空闲内存碎片在高地址端拼接在一起；
初始内存为 initSize 字节大小的整片空闲内存，编号为 1 到 initSize 。
new size操作中，若存在不小于size的连续空闲内存，则按照小地址优先的原则从空闲内存区域中分配size大小的内存块，标记该内存块状态为已分配，并返回指向该内存块的句柄。若无法分配，则返回空（NULL）。
del handle操作释放由handle标记的内存块，标记被释放的内存状态为空闲。若handle为无效句柄，则返回ILLEGAL_OPERATION。
def 完成内存整理工作，无返回值。
根据设计，每次成功内存分配返回的句柄为一个正整数，从1开始，依次计数。失败的存储分配操作不影响计数。
项目小组将此项任务分配给小B，小B向你求助，你能帮她吗？
输入
输入中有多组测试数据。每组测试数据的第一行为两个正整数T和MaxMem（1<=T<=10000, 1<=MaxMem<=10000），其中T为操作次数，MaxMem为初始内存大小，随后有T行操作指令。
输出
对每组测试数据，按操作顺序输出操作结果。对每个new操作，在单独行中输出结果，成功时输出其返回句柄值，失败则输出NULL。若del操作失败，输出ILLEGAL_OPERATION。def不产生输出。
样例输入
6 10
new 5
new 3
del 1
new 6
def
new 6
样例输出
1
2
NULL
3
当时考虑用map来存储内存结构，因为它可以自动排序，key中存储内存块的开始位置，value存储结束位置，维护两个map，一个表示空的内存块，一个表示已分配内存块。但由于map的迭代器返回类型的问题，出现了编译错误，同时存在handle无法存储的问题。现在考虑使用链表list存储。上面的例子可以正确通过，但是其他就不知道了。
#include <iostream>
#include <string>
#include <vector>
#include <list>
using namespace std;
struct memNode{
int start; //内存块起始位置
int end; //内存块终止位置（包含）
int hand; //句柄号
bool operator<(memNode &b)
{
return start<b.start;
}
};
list<memNode> empty;//空的内存块链表
list<memNode> used; //已分配内存链表
int MaxMem;
int handle=0;
int mynew(int maxsize,int size)
{//在空闲链表中寻找可用内存块
for(list<memNode>::iterator i=empty.begin();i!=empty.end();i++)
{
if(i->end-i->start+1>size)//若该空闲块大于所需内存，将该块分割，被分配的部分加入used，更新该块剩下空闲的起始位置
{
handle++;
memNode m;
m.start=i->start;
m.end=i->start+size-1;
m.hand=handle;
used.push_back(m);
i->start=i->start+size;
return handle;
}
else if(i->end-i->start+1==size)//若该空闲块等于所需内存，将该块加入used，从empty中删去该块
{
handle++;
memNode m;
m.start=i->start;
m.end=i->end;
m.hand=handle;
used.push_back(m);
empty.erase(i);
return handle;
}
}
return false; //找不到合适的空闲块则分配失败
}
bool del(int handle)//释放内存块
{
bool res=false;
for(list<memNode>::iterator i=used.begin();i!=used.end();i++) //根据句柄在used中查找内存
{
if(i->hand==handle)
{
res=true;
for(list<memNode>::iterator ie=empty.begin();ie!=empty.end();ie++)//因为要将该块返回到空闲内存链表中，同时每次分配空闲块时需要小地址优先，所以要寻找合适的插入位置，并在used中删除该块
{ //若该块正好可以与empty中的某个空闲块首尾相连，则更新empty中该空闲块的起始或终止位置
if(ie->end+1==i->start)
{
ie->end=i->end;
used.erase(i);
return true;
}
if(i->end+1==ie->start)
{
ie->start=i->start;
used.erase(i);
return true;
} //找到第一个起始地址大于该释放内存块的终止地址的空闲块，将该块插入到其前面。
if(i->end+1<ie->start)
{
memNode m;
m.start=i->start;
m.end=i->end;
m.hand=0;
used.erase(i);
empty.insert(ie,m);
return true;
}
} //若不符合上面情况，直接在empty末尾插入
memNode m;
m.start=i->start;
m.end=i->end;
m.hand=0;
empty.push_back(m);
used.erase(i);
return true;
}
}
return res;
}
void def()
{
used.sort();//需要从低地址开始迁移，所以先对used进行排序
int count=1;//记录当前used已使用到的位置
for(list<memNode>::iterator i=used.begin();i!=used.end();i++)//更新used中内存块的地址，即向低地址端迁移
{
i->end=i->end-i->start+count;
i->start=count;
count=i->end+1;
} //empty中所有空闲块合并，所以将其清空，插入count到最大内存地址的地址块
empty.clear();
memNode m;
m.start=count;
m.end=MaxMem;
m.hand=0;
empty.push_back(m);
}
int main()
{
int T;
cin>>T>>MaxMem;
memNode m;
m.start=1;
m.end=MaxMem;
empty.push_back(m);
for(int i=0;i<T;i++)
{
string order;
int size;
cin>>order;
if(order.compare("new")==0)
{
cin>>size;
int res=mynew(MaxMem,size);
if(res==0)
cout<<"NULL"<<endl;
else
cout<<res<<endl;
}
else if(order.compare("del")==0)
{
cin>>size;
bool res=del(size);
if(!res)
cout<<"ILLEGAL_OPERATION"<<endl;
}
else if(order.compare("def")==0)
def();
}
return 0;
}
来源：https://www.cnblogs.com/luchenxu/p/5861307.html