大二暑假

/*#include<fstream>
#include<iostream>
#include<vector>
#include<numeric>
using namespace std;

int main()
{
vector<int> v(10,10);//指定容器的元素个数10每一个初始值为10，如定义一个用来存储整形的容器
int i;
for (i=0;i<10;i++)
{
v.push_back(i);
}
for (vector<int>::iterator it=v.begin();it!=v.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
cout<<accumulate(v.begin(),v.end(),0)<<endl;
return 0;
}*/

//元素的插入insert()
/*
#include<vector>
#include<iostream>
using namespace std;
int main(void)
{
vector<double> v(5);
v[0]=1;
v[1]=4;
v[2]=4;
v[4]=3;
v[3]=4;
v.insert(v.begin(),8);//在最前面插入元素8
v.insert(v.begin()+1,2);//在原始的元素位置顺序内第1个元素后插入新元素2
v.insert(v.end(),3);//在向量末尾追加元素3
vector<double>::iterator it;
for (it=v.begin();it!=v.end();it++)
{
cout<<*it<<" ";//输出迭代器上的元素值
}
cout<<endl;
return 0;
}
*/

//元素的删除
/*
#include<vector>
#include<iostream>
using namespace std;
int main(void)
{
vector<double> v(10);
for(int i=0;i<10;i++)
{
v[i]=i;
}
v.erase(v.begin()+2);//删除第2+1个元素
vector<double>::iterator it;
for (it=v.begin();it!=v.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
v.erase(v.begin()+1,v.begin()+5);//删除迭代器第1到第5区间的全部元素即第2~6位置的元素下标从零开始
for(it=v.begin();it!=v.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
v.clear();//清空向量
cout<<v.size()<<endl;//输出向量的大小
return 0;
}*/
/*
#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
int main(void)
{
vector<int> v(10);//v只是容器，像数组名同样，可是后面的it（迭代器变量）输出时用到
for(int i=0;i<10;i++)
{
v[i]=i;
}
reverse(v.begin(),v.end());
vector<int>::iterator it;
for(it=v.begin();it!=v.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
return 0;
}*/
//sort算法对向量元素排序
/*#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
int main(void)
{
vector<int> v;
int i;
for(i=0;i<10;i++)
{
v.push_back (9-i);
}
for(i=0;i<10;i++)
{
cout<<v[i]<<" ";

}
cout<<endl;
sort(v.begin(),v.end());
for(i=0;i<10;i++)
{
cout<<v[i]<<" ";
}
cout<<endl;
return 0;
}*/

/*#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
//本身设计排序比较函数：对元素的值进行降序排列
bool Comp(const int &a,const int　&b)
{
if(a!=b)
return a>b;
else
return a>b;
}
int main(void)
{
vector<int> v;
int i;
for(i=0;i<10;i++)
{
v.push_back(i);
}
for(i=0;i<10;i++)
{
cout<<v[i]<<" ";
}
cout<<endl;
//
sort(v.begin(),v.end(),Comp);
for(i=0;i<10;i++)
{
cout<<v[i]<<" ";
}
cout<<endl;
return 0;
}*/
//向量的大小
/*#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
int main(void)
{
vector<int> v(10);
for(int i=0;i<10;i++)
{
v[i]=i;
}
cout<<v.size()<<endl;
cout<<v.empty()<<endl;//输出向量是否为空，若是为非空返回0，不然为1
v.clear();
cout<<v.empty()<<endl;
return 0;
}*/
//采用append()方法从string对象尾部追加字符串
/*#include<string>
#include<iostream>
using namespace std;
int main(void)
{
string s;
s.append("abc");
s.append("1213");
cout<<s<<endl;
cout<<s.length()<<endl;
return 0;
}*/

/*#include<string>
#include<iostream>
using namespace std;
int main(void)
{
string s;
s="123456";
string ::iterator it;//定义迭代器
it=s.begin();//迭代器位置为字符串首
s.insert(it+1,'p');//把p插入到第一个字符后
cout<<s<<endl;
cout<<s.length()<<endl;
s.erase(it+3);//删除第三个元素从0开始计时
cout<<s<<endl;
s.erase(it,it+4);
cout<<s<<endl;
cout<<s.length()<<endl;
s.replace(3,3,"good");//从第三个开始，将连续的3个字符替换为“good”
cout<<s<<endl;
cout<<s.length()<<endl;
return 0;
}*/
//采用find（）方法能够查找字符串中第一个字符''单引号或子串双引号" ",若是查到则返回下标值
//从零计数，若是找不到返回4294967295
/*#include<string>
#include<iostream>
#include<algorithm>
using namespace std;
int main(void)
{
string s;
s="cat dog cat";
cout<<s.find('c')<<endl;
cout<<s.find("c")<<endl;
cout<<s.find("cat")<<endl;
cout<<s.find("dog")<<endl;
cout<<s.find("dogs")<<endl;
cout<<s.compare("cay")<<endl;//s比cay小返回-1
cout<<s[0]<<endl;//输出c了
cout<<s[0]-'c'<<endl;
cout<<s[0]+'a'<<endl;
cout<<"before reverse:"<<endl;
cout<<s<<endl;
reverse(s.begin(),s.end());
cout<<"After reverse:"<<endl;
cout<<s<<endl;
return 0;
}*/
//string 对象做为vector元素
/*
#include<vector>
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
int main(void)
{
vector<string> v;
v.push_back("Jack");
v.push_back("Mike");
v.push_back("Tom");
cout<<v[0]<<endl;
cout<<v[1]<<endl;
cout<<v[2]<<endl;
cout<<v[0][0]<<endl;
cout<<v[1][0]<<endl;
cout<<v[2].length()<<endl;
return 0;
}
*/
//string 类型的数字处理
/*#include<iostream>
#include<string>
using namespace std;
int main(void)
{
string s;
//s="23243545";
cin>>s;
int i;
int sum=0;
for(i=0;i<s.length();i++)
{
if(s[i]=='0')
sum+=0;
else if(s[i]=='1')
sum+=1;
else if(s[i]=='2')
sum+=2;
else if(s[i]=='3')
sum+=3;
else if(s[i]=='4')
sum+=4;
else if(s[i]=='5')
sum+=5;
else if(s[i]=='6')
sum+=6;
else if(s[i]=='7')
sum+=7;
else if(s[i]=='8')
sum+=8;
else if(s[i]=='9')
sum+=9;
}
cout<<sum<<endl;
return 0;
}*/
//printf与cout 的区别
/*#include<string>
#include<iostream>
using namespace std;
int main(void)
{
string s;
char ss[100];
scanf("%s",&ss);
s=ss;//printf不能输出对象，不然要用c_str()方法
printf(s.c_str());//输出字符串对象，要采用c_str()方法
cout<<endl;
printf("%s",ss);//输出字符数组
cout<<endl;
cout<<s<<endl;//输出字符串对象能够，与printf是有差距的
cout<<ss<<endl;
return 0;
}*/
//string 和sscanf函数的用法
/*
#include<string>
#include<iostream>
using namespace std;
int main(void)
{
string s1,s2,s3;
char sa[100],sb[100],sc[100];
//将字符串分离成子串，分隔符为空格
sscanf("abc 123 pc","%s%s%s",sa,sb,sc);
s1=sa;
s2=sb;
s3=sc;
cout<<s1<<" "<<s2<<" "<<s3<<endl;
//将字符串分离成数字，分隔符为空格
//当用到数字的时候，跟scanf同样，它要传指针地址
int a,b,c;
sscanf("1 2 3","%d%d%d",&a,&b,&c);
cout<<a<<" "<<b<<" "<<c<<endl;
//将字符串分离成数字，分隔符为“,”和“$”
//当用到数字的时候，跟scanf同样，它要传指针地址
int x,y,z;
sscanf("4,5$6","%d,%d$%d",&x,&y,&z);
cout<<x<<" "<<y<<" "<<z<<endl;
return 0;

}*/

//string 对象与数值相互转换
/*#include<iostream>
#include<string>
#include<sstream>//转换的字符串类有istringstream, ostringstream, stringstream，
//在<sstream>头文件中声明
using namespace std;
//C++方法：将数值转换为string
string convertToString(double x)
{
ostringstream o;
if(o<<x)
return o.str();
return "conversion error";
}
//C++方法：将string转换为数值
double convertFromString(const string &s)
{
istringstream i(s);
double x;
if(i>>x)
return x;
return 0.0;
}
int main(void)
{
//将数值转换为string的第一种方法：c方法
char b[10];
string a;
sprintf(b,"%d",1975);////把整数1975 打印成一个字符串保存在b 中
a=b;
cout<<a<<b<<endl;
//将数值转换为string C++方法
string cc=convertToString(1976);
cout<<cc<<endl;
//将string转换为数值
string dd="2006";
int p=convertFromString(dd)+2;
cout<<p<<endl;
return 0;

}*/
//元素的插入和中序遍历及元素的删除和反向遍历 ,元素索引

//在使用insert()将元素插到集合中去的时候，集合会根据设定的比较函数将元素放到该节点
//点上去。在定义集合的时候，若是没有指定比较函数，那么就采用默认比较函数，即按
//键值从小到大的顺序插入元素。在不少的状况下，须要本身编写比较函数。
/*#include<set>
#include<iostream>
using namespace std;
//自定义比较函数 元素不是结构体
struct myComp
{
bool operator()(const int &a,const int &b)
{
if(a!=b)
return a>b;
else
return a>b;
}
};
int main(void)
{
//定义元素类型为int的集合对象
set<int> s;
//插入5个元素，可是重复的元素第二次插入操做是不执行
s.insert(8);
s.insert(1);
s.insert(12);
s.insert(6);
s.insert(8);//不会执行
//中序遍历
set<int>::iterator it;//定义前向迭代器
for (it=s.begin();it!=s.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
int n=s.erase(6);//delete the key which is 6
cout<<"After "<<endl
set<int>::reverse_iterator rit;//定义反向迭代器
for (rit=s.rbegin();rit!=s.rend();rit++)
{
cout<<*rit<<" ";
}
cout<<endl;
//查找键值为6的元素
it=s.find(8);
if(it!=s.end())
cout<<*it<<endl;
else
cout<<"not find it !"<<endl;
/* rit=s.find(8);
if(rit!=s.rend())
cout<<*rit<<endl;
else
cout<<"not find it!"<<endl;
//采用的比较函数是myComp
set<int,myComp> a;
a.insert(8);
a.insert(1);
a.insert(12);
a.insert(6);
set<int,myComp>::iterator is;
for(is=a.begin();is!=a.end();is++)
{
cout<<*is<<" ";
}
cout<<endl;
return 0;

}*/

/*#include<set>
#include<string>
#include<iostream>
using namespace std;
struct Info//元素是结构体，那么，能够直接把比较函数写在结构体内。
{
string name;
float score;
//重载"<"操做符，自定义排序规则
bool operator < (const Info &a) const
{
//按score由大到小排列。若是有大到下排列用">"便可
return a.score<score;
}
};
int main(void)
{
//定义元素类型为Info结构体的集合对象s，当前没有任何元素
set<Info> s;
//定义Info类型的元素
Info info;
//插入3个元素
info.name="Jack";
info.score=80.5;
s.insert(info);
info.name="Tomi";
info.score=20.5;
s.insert(info);
info.name="Nacy";
info.score=60.5;
s.insert(info);
set<Info>::iterator it;//定义前向迭代器
for(it=s.begin();it!=s.end();it++)
{
cout<<(*it).name<<":"<<(*it).score<<endl;
}
return 0;

}*/

//multiset多重集合容器//插入元素能够重复
/*#include<set>
#include<iostream>
#include<string>
using namespace std;
int main(void)
{
//定义元素类型为string 的多重集合对象s，当前没有任何元素
multiset<string> s;
s.insert("abc");
s.insert("123");
s.insert("111");
s.insert("aaa");
s.insert("123");
multiset<string>::iterator it;
for (it=s.begin();it!=s.end();it++)
{
cout<<*it<<endl;
}
//删除值为123的全部重复的元素，返回删除总数2
int n=s.erase("123");
cout<<"Total deleted :"<<n<<endl;
//删除后的剩余的元素
cout<<"all elements after deleted:"<<endl;
for (it=s.begin();it!=s.end();it++)
{
cout<<*it<<endl;
}
return 0;
}*/

/*
#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <functional>

using std::cout;
using std::vector;
using std::endl;
using std::sort;
using std::ostream_iterator;
using std::copy;
using std::back_inserter;
using std::list;
using std::random_shuffle;
using std::back_inserter;

int main(int argc, char* argv[])
{
list<int> intList;

int i;
for (i=0; i < 30; ++i, intList.push_back(i));

cout << "Print list pushed from back/n/n";

copy(intList.begin(), intList.end(), ostream_iterator<int>(cout, ", "));

intList.clear();

for (i=0; i < 30; ++i, intList.push_front(i));

cout << "/n/nPrint list pushed from front/n/n";

copy(intList.begin(), intList.end(), ostream_iterator<int>(cout, ", "));

std::list<int>::reverse_iterator rit = intList.rbegin();
std::list<int>::reverse_iterator rend = intList.rend();

cout << "/n/nPrint list in reverse order using reverse iterators/n/n";

for(;rit != rend;++rit)
cout << *rit << ", ";

// Oops
// random_shuffle(intList.begin(), intList.end());

vector<int> vecInt;

copy (intList.begin(), intList.end(), back_inserter(vecInt));

cout << "/n/nPrint vector in reverse order/n/n";

copy(vecInt.rbegin(), vecInt.rend(), ostream_iterator<int>(cout, ", "));

random_shuffle(vecInt.rbegin(), vecInt.rend());

cout << "/n/nPrint shuffled vector/n/n";

copy(vecInt.begin(), vecInt.end(), ostream_iterator<int>(cout, ", "));

cout << endl;

return 0;
}*/

#include<iostream>
#include<set>
#include<string>
using namespace std;
struct Info
{
string name;
float score;
float age;
bool operator <(const Info &a) const
{
return (a.score<score);//&&(a.age<age));
}
};
int main(void)
{
/*multiset<string> s;
s.insert("abc");
s.insert("123");
s.insert("111");
s.insert("aaa");
s.insert("123");
multiset<string>::iterator it;
it=s.find("123");
if(it!=s.end())
{
cout<<*it<<endl;
}
else
cout<<"not find it!"<<endl;

};*/

multiset<Info> a;
Info info;
info.name="sun";

info.age=12;
info.score=121;
a.insert(info);
info.name="yuan";

info.age=134;
info.score=13;
a.insert(info);
multiset<Info>::iterator it;
cout<<"name"<<":"<<"age"<<" "<<"score"<<endl;
for (it=a.begin();it!=a.end();it++)
{

cout<<(*it).name<<":"<<(*it).score<<" "<<(*it).age<<endl;//数据类型是double,int,flaot
//排序时看cout语句谁在前面按谁排
}
return 0;

}

 

/*#include<map>
#include<iostream>
#include<string>
using namespace std;
int main(void)
{
//定义map对象，当前没有任何元素
map<string ,float,float> m;
m["Jack"]=98.5;
m["Jack"]=21.2;
m["Bomi"]=96.0;
m["Kate"]=97.5;
map<string,float,float>::iterator it;
for (it=m.begin();it!=m.end();it++)
{
//输出键值与映照数据
cout<<(*it).first<<":"<<(*it).second<<(*it).third<<endl;
}
return 0;
}*/
//将单词转换文件的内容存储在一个map容器中,将被替换的单词做为键,而用做替换的单词则做为其相应的值.

/*
#include <iostream>
#include <string>
#include <map>
#include <utility>
#include <fstream>
#include <sstream>
#include <stdexcept>

using std::map;
using std::string;
using std::pair;
using std::cout;
using std::endl;
using std::ifstream;
using std::istringstream;
using std::runtime_error;
// in做为文件指针,file存放文件名称,代开输入文件
ifstream& open_file(ifstream& in, const string &file)
{
// 清空文件指针的状态
in.close();
in.clear();
// open函数输入参数为字符串字面值
in.open(file.c_str());
return in;
}
// 单词转换
int main(int argc, char **argv)
{
map<string, string> trans_map; // 存放译码
string key, value; // 生成译码容器的辅助变量
// 判断输入参数是否符合规则
if(argc != 3)
cout << argv[0] << "<trans map filename> <input filename>" << endl;
// 定义map_file指针并打开之,读入生成对应的翻译表
ifstream map_file;
if(!open_file(map_file, argv[1]))
throw runtime_error("no transormation file");
while(map_file >> key >> value)
trans_map.insert(make_pair(key, value));
map_file.close();
// 定义input文件指针,并打开输入文件
ifstream input;
if(!open_file(input, argv[2]))
throw runtime_error("no input file");

// 每次从文件中读入一行
string line;
while(getline(input, line)){
// 一次处理一行内的一个单词
istringstream stream(line);
string word;
bool firstword = true;
while(stream >> word){
// 查找译码,有译码输出译码,没有译码输出原文
map<string, string>::const_iterator map_it = trans_map.find(word);
if(map_it != trans_map.end())
word = map_it->second;
// 第一个单词前不输出空格
if(firstword)
firstword = false;
else
cout << " ";
cout << word;
}
cout << endl;
}
return 0;
}*/

//动态数组有错误
/*#include<iostream>
#include<list>
using namespace std;
template <class T> void make2d(T**&x,int rows,int cols);
void main(void)
{
int **a;
make2d(a,3,3);
a[0][0]=1;
for (int rows=0;rows<3;rows++)
{
for (int cols=0;cols<3;cols++)
a[rows][cols]=rows+cols;
}
for ( rows=0;rows<3;rows++)
{
for (int cols=0;cols<3;cols++)
cout << a[rows][cols] << endl;;
}
cin.get();
}
template <class T> void make2d(T**&list,int rows,int cols)
{
list=new T*[rows];
for (int i=0;i<rows;i++)
{
list[i]=new int[cols];
}
}*/

 

/*#include<vector>
#include<iostream>
using namespace std;
int main(void)
{
vector< vector<string> > array;
array.insert("add","sda");

}*/
//有错误
/*#include<iostream>
using namespace std;
template <class Type>
void Make2DArray(Type** &x,int rows, int cols)
{
x=new Type*[rows];
for (int i=0;i<rows;i++)
x[i]=new Type[cols];
}
template <class Type>
void Delete2DArray(Type** &x,int rows)
{
for (int i=0;i<rows;i++)
delete []x[i];
delete []x;
x=0;
}

int main(void)
{
//int x[4][4];
Make2DArray(** &x, 4, 4);
for(int i=0;i<4;i++)
for(int j=0;j<4;j++)
cout<<x[i][j]<<endl;
return 0;

}*/

//快速排序
#include<iostream>
using namespace std;
template<class Type>
void Swap(Type x,Type y)
{
int temp;
temp=x;
x=y;
y=temp;
}
template<class Type>
int Partition (Type a[], int p, int r)
{
int i = p, j = r + 1;
Type x=a[p];
// 将< x的元素交换到左边区域
// 将> x的元素交换到右边区域
while (true) {
while (a[++i] <x);
while (a[- -j] >x);
if (i >= j) break;
Swap(a[i], a[j]);
}
a[p] = a[j];
a[j] = x;
return j;
}
template<class Type>
void QuickSort(Type a[],int s,int t)
{
if(s<t)
{
int k=Partition(a,s,t);
QuickSort( a, s,k-1);
QuickSort(a,k+1,t);
}
}
int main(void)
{
int a[9]={6, 7, 5, 2, 5, 8};
Partition (a, 0, 5);
QuickSort(a,0,5);
for(int i=0;i<9;i++)
cout<<a[i]<<" "<<endl;
return 0;
}
//二分查找算法
template<class Type>
int BinarySearch(Type a[],const Type &x,int i,int j)//a[]是有序的
{
//i为0，j为a[]元素的个数-1
while(i<=j){
int m=(i+j)/2;
if(x==a[m])
return m;
if(x>a[m])
i=m+1;
else(x<a[m])
j=m-1;
}
}

//1!+2!+3!+4!+......+n!
/*#include<iostream>
using namespace std;
int main()
{
int n,sum,p;
while(cin>>n)
{
p=1;
sum=0;
for(int i=1;i<=n;i++)
{
p*=i;
sum+=p;
}
cout<<sum<<endl;
}
return 0;
}*/

//等比数列
/*#include<iostream>
#include<cmath>
using namespace std;

int main()
{
cout.precision(3);
//定点输出小数点后3位；不然是输出有效数字3位
int n;
double q,sum;
while(cin>>n>>q)
{
if(q==1) sum=1+n;
else
sum=(1-pow(q,n+1))/(1-q);
//使用fixed，定点输出，即小数点后的精度是3位
cout<<fixed<<sum<<endl;
}

return 0;
}*/

//斐波那契数
//采用数组作的
/*#include<iostream>
#include<cmath>
using namespace std;

int main()
{
int a[47];
a[0]=0;
a[1]=1;
for(int i=2;i<47;i++)
{
a[i]=a[i-1]+a[i-2];
}

//查表
int n;
while(cin>>n)
{
cout<<a[n]<<endl;
}
return 0;
}*/

//采用Vector
/*#include<iostream>
#include<vector>

using namespace std;

int main(void)
{
vector<unsigned int> v;
unsigned int n;
//先建表
v.push_back(0);
v.push_back(1);
for(int i=2;i<47;i++)
{
v.push_back(v[i-1]+v[i-2]);
}
while(cin>>n)
{
cout<<v[n]<<endl;
}
return 0;
}*/

//采用非建表的方法

/*#include<iostream>

using namespace std;

template <class T>
int Fibonacci(T n)
{
if(n<2)
{
if(n==1)
return 1;
else if(n==0)
return 0;
}
else
return Fibonacci(n-1)+Fibonacci(n-2);
}
int main(void)
{
int n;
while(cin>>n)
{

cout<<Fibonacci(n)<<endl;
}
return 0;
}

*/

//最大公约数

/*#include<iostream>

using namespace std;
int gcd(int,int);
int main()
{
int x,y;
while(cin>>x>>y)
{
cout<<gcd(x,y)<<endl;
}
return 0;
}

int gcd(int x,int y)
{
while(x!=y)
{
if(x>y) x-=y;
else
y-=x;
}
return x;
}*/

//十进制转化成二进制

/*#include<iostream>
#include<string>
#include<algorithm>

using namespace std;

string s;
int main(void)
{
int n;
while(cin>>n)
{
if(n==0){
cout<<" 0--->0/n";
continue;
}
s=" ";
for(int a=n;a;a/=2){
s+=(a%2?'1':'0');
}
std::reverse(s.begin(),s.end());
const char*sss=s.c_str();
cout.width(11);//输出宽度为11
cout<<n<<(n<0?"-->-":"-->")<<sss<<"/n";

}

return 0;
}
*/

//列出完数(所谓的完数是：此数等于它的全部不一样因子之和)例如6=1+2+3不包括6
/*#include<iostream>
#include<vector>

using namespace std;

int main(void)
{
vector<int>a;
for(int i=2;i<10000;i+=2)//完数为偶数因此步长为2
{
int sum=1;
for(int j=2;j<=i/2;j++)
{
if(i%j==0)sum=sum+j;

}
if(sum==i)a.push_back(i);
}

int n;
while(cin>>n)
{
cout<<n<<":";
for(int i=0;i<a.size();i++)
{
if(a[i]<=n)
cout<<" "<<a[i];
}
cout<<endl;
}
return 0;
}*/

//采用数组的方法
//出现错误

/*#include<iostream>

using namespace std;

int main(void)
{

int a[10000];
int sum=1,k=0;

for(int i=2;i<10000;i+=2)
{
for(int j=2;j<=i/2;j++)//关键的j<=i/2与j<=i又花了算法
{
if(i%j==0)
sum+=j;
}
if(sum==i)
a[k++]=i;//若是使用数组，那么这里又很差控制，可是这里没有问题

}

int n;
while(cin>>n)
{
cout<<n<<":";
for(int i=0;i<1;i++)//数组的长度怎么表达？

{
if(a[i]<=n)cout<<" "<<a[i];
}
cout<<endl;
}
return 0;
}*/

//找出输入数据中全部两两相乘的积为12！的个数
#include<iostream>
#include<set>

using namespace std;

int main(void)
{

int num=0;
int f12=479001600;
//多重集合，容许值重复
multiset<unsigned int >s;
int n;
while(cin>>n)
{
if(f12%n==0)
{
//多重集合有n的因子吗？
multiset<unsigned int >::iterator it=s.find(f12/n);
if(it!=s.end())
{
num++;
s.erase(it);//从多重集合中删除该因子
}

else
s.insert(n);//插入到多重集合中
}
}
cout<<num<<endl;
return 0;
}

//五位之内的对称素数
/*#include<iostream>
#include<cmath>

using namespace std;

bool isPrime(int n)//
{
int flag=0;
if(n==1)return false;
else
{
for(int i=2;i<=sqrt(n);i++)
{
if(n%i==0)
flag=1;break;
}
if(flag==1)
return false;
else
return true;
}
}

bool isSym(int n)
{
//一位数和11都是素数
if(n<12 || n!=10) return true;
//三位数是否对称
if(n>100 && n<1000 && n/100==n/10)
return true;
//四位数对称不多是素数abba即1000a+100b+10b+a=11（91a+10b）
//判断五位数是否对称
if(n>10000 && n/1000==n%10*10+n/10%10) return true;
return false;
}

int main(void)
{
int n;
while(cin>>n)
{
cout<<(n<10000 && isSym(n) && isPrime(n) ? "YES/n":"NO/n");
}
return 0;
}*/

//01串排序

//将01串首先按长度排序，长度相同时，按1的个数的多少进行排序，1的个数想听时再按ASCII码值排序
/*#include<iostream>
#include<string>
#include<set>
#include<algorithm>

using namespace std;

struct Comp //关于比较函数要查
{
bool operator()(const string &s1,const string &s2)
{
if(s1.length()!=s2.length()) return s1.length()<s2.length();
int c1=count(s1.begin(),s1.end(),'1');
int c2=count(s2.begin(),s2.end(),'1');
return (c1!=c2?c1<c2:s1<s2);
}
};

int main(void)
{
multiset<string,Comp> ms;
string s;
while(cin>>s && s!="#")//输入回车符结束的表达式为多少？输入数据陷入死循环，
{
ms.insert(s);

}
for(multiset<string,Comp>::iterator it=ms.begin();it!=ms.end();it++)
{
cout<<*it<<endl;
}

return 0;
}
*/

 

//根据每一个字符串， 输出对称的那些串，并要求按从小到大的顺序输出(长度相同时，按ASCII码值从小到大)

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

//本身设计比较函数
bool Comp(const string &s1,const string &s2)
{
return s1.length()!=s2.length() ? s1.length()<s2.length() : s1<s2;
}

int main(void)
{
vector<string> v;
string t,s;
while(cin>>s)
{
t=s;
//反转字符串，判断是否对称
reverse(t.begin(),t.end());
if(t==s)
{
v.push_back(s);
}

//按Comp函数比较规则排序
sort(v.begin(),v.end(),Comp);
//输出
for(int i=0;i<v.size();i++)
{
cout<<v[i]<<endl;
}
}
return 0;
}

//五位之内的对称素数
/*#include<iostream>
#include<cmath>

using namespace std;

bool isPrime(int n)//
{
int flag=0;
if(n==1)return false;
else
{
for(int i=2;i<=sqrt(n);i++)
{
if(n%i==0)
flag=1;break;
}
if(flag==1)
return false;
else
return true;
}
}

bool isSym(int n)
{
//一位数和11都是素数
if(n<12 || n!=10) return true;
//三位数是否对称
if(n>100 && n<1000 && n/100==n/10)
return true;
//四位数对称不多是素数abba即1000a+100b+10b+a=11（91a+10b）
//判断五位数是否对称
if(n>10000 && n/1000==n%10*10+n/10%10) return true;
return false;
}

int main(void)
{
int n;
while(cin>>n)
{
cout<<(n<10000 && isSym(n) && isPrime(n) ? "YES/n":"NO/n");
}
return 0;
}*/

//01串排序

//将01串首先按长度排序，长度相同时，按1的个数的多少进行排序，1的个数想听时再按ASCII码值排序
/*#include<iostream>
#include<string>
#include<set>
#include<algorithm>

using namespace std;

struct Comp //关于比较函数要查
{
bool operator()(const string &s1,const string &s2)
{
if(s1.length()!=s2.length()) return s1.length()<s2.length();
int c1=count(s1.begin(),s1.end(),'1');
int c2=count(s2.begin(),s2.end(),'1');
return (c1!=c2?c1<c2:s1<s2);
}
};

int main(void)
{
multiset<string,Comp> ms;
string s;
while(cin>>s && s!="#")//输入回车符结束的表达式为多少？输入数据陷入死循环，
{
ms.insert(s);

}
for(multiset<string,Comp>::iterator it=ms.begin();it!=ms.end();it++)
{
cout<<*it<<endl;
}

return 0;
}
*/

 

//根据每一个字符串， 输出对称的那些串，并要求按从小到大的顺序输出(长度相同时，按ASCII码值从小到大)

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

//本身设计比较函数
bool Comp(const string &s1,const string &s2)
{
return s1.length()!=s2.length() ? s1.length()<s2.length() : s1<s2;
}

int main(void)
{
vector<string> v;
string t,s;
while(cin>>s)
{
t=s;
//反转字符串，判断是否对称
reverse(t.begin(),t.end());
if(t==s)
{
v.push_back(s);
}

//按Comp函数比较规则排序
sort(v.begin(),v.end(),Comp);
//输出
for(int i=0;i<v.size();i++)
{
cout<<v[i]<<endl;
}
}
return 0;
}

//输入样例
//班级号：1
//课程数：3 课程学分：3 4 3
//同窗数：3
//姓名 对应分数
//输出样例
//class 1:
//姓名 绩点==sum((课程成绩-50)/10*学分数)/10(绩点按从大到小排序，绩点相同时，按姓名的ASCII从小到大)

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
#include<iomanip>

using namespace std;

struct student
{
string s;
double d;
};

//编写比较函数
bool myComp(const student &s1,const student &s2)
{
if(s1.d != s2.d) return s1.d > s2.d;//由大到小则使用“>”号
if(s1.s != s2.s) return s1.s<s2.s;//由小到大则用“<”号
}

 

int main(void)

{
int n;//班级数量
int c;//课程数量
double xf;//学分
vector<double> vxf;// 学分向量
int p;//班级数量
string name;//学生姓名
double score;
student xs;//学生名称与总学分结构体
vector<student>vxs ;//最终学生名称与总学分
cin>>n;//n个班
for(int i=0 ; i<n ; i++)
{
cin>>c;//读入课程数量
for(int j=0 ; j<c ; j++)//读入每门课程的学分
{
cin>>xf;
vxf.push_back(xf);
}
cin>>p;//读入班级人数
//读入一个班的p个学生的名称和每门课程的成绩
for(int k=0 ; k<p ; k++)
{
cin>>name;//
xs.s=name;
xf=0.0;
for(int m=0 ; m<c ; m++)
{
cin>>score;
if(score < 60) continue;
xf+=(score-50)/10*vxf[m];//计算总学分
}
xs.d=xf/10;
vxs.push_back(xs);
}
//输出每一个班的状况
cout<<(i ? "/n" : " ");
cout<<"class"<<i+1<<":"<<endl;
sort(vxs.begin(),vxs.end(),myComp);
for( vector<student>::iterator it=vxs.begin() ; it<vxs.end() ; it++ )
{
cout<<fixed<<setprecision(2);
cout<<left<<setw(11);
cout<<(*it).s<<(*it).d<<endl;
}

vxf.clear();//清除向量
vxs.clear();

}
return 0;
}

 

//按1的个数的多少排序
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

bool myComp(const string &s1,const string &s2)
{
int c1=count(s1.begin(),s1.end(),'1');
int c2=count(s2.begin(),s2.end(),'1');
//完全修改排序规则，只按1的数量排序
//若是1的数量相同，则按出现的前后顺序,不然按ASCII码大小排序，只能有“>”或"<"不要用"="
return c1!=c2 ? c1 < c2 : c1 < c2;
}

int main(void)
{
vector<string> vstr;
string str;
while(cin>>str && str!="#")
{
vstr.push_back(str);
}

sort(vstr.begin(),vstr.end(),myComp);
for(vector<string>::iterator it = vstr.begin() ; it < vstr.end() ; it++)
{
cout<<*it<<endl;
}
return 0;
}

 

//bitset容器是一个bit位的序列容器，每个元素只占一个bit位，取值为1或0
//所以而节省内存空间。建立bitset对象时，必须指明容器的大小，大小一旦定义，
//则不能更改
#include<bitset>
#include<iostream>
using namespace std;
int main(void)
{
bitset<10> b;
//采用下标法给元素赋值
b[1]=1;
b[6]=1;
b[9]=1;
//下标法输出全部元素，第0位是最低位，第9位是最高位
int i;
for(i=b.size()-1;i>=0;i--)
{
cout<<b[i];
}
cout<<endl;
//把全部的二进制位逐位取反！
cout<<"把全部的二进制位逐位取反,flip()"<<endl;
b.flip();
for(i=b.size()-1;i>=0;i--)
{
cout<<b[i];
}
cout<<endl;
//返回一个unsigned long值
cout<<"返回一个unsigned long值,t0_ulong()方法"<<endl;
cout<<b.to_ulong()<<endl;
//采用set()方法，一次性将元素设置为1
b.set();
cout<<"after set()"<<endl;
for(i=b.size()-1;i>=0;i--)
{
cout<<b[i];
}
cout<<endl;
//采用set(pos)方法，将某pos位设置为1或0均可以
b.set(1,0);
b.set(5,1);
cout<<"after set(pos)"<<endl;
for(i=b.size()-1;i>=0;i--)
{
cout<<b[i];
}
cout<<endl;
//采用reset()，一次性将元素设置为0
cout<<"After reset()"<<endl;
b.reset();
for(i=b.size()-1;i>=0;i--)
{
cout<<b[i];
}
cout<<endl;
//b.reset(1,1);只能置为0不能为1
return 0;
}

/*char s;//
cin.get(s)<=>s=cin.get(); //会接收Enter 放在缓冲区中，输出s后
//残留的是Enter（ASCII 10）字符,等下次输出
//同时不会丢弃Space（ASCII 32）字符。
//cin.get(array_name, Arsize)是用来读取字符串的，
//能够接受空格字符，遇到Enter结束输入，按照长度(Arsize)读取字符, 会丢弃最后的Enter字符。
//cin.getline() 与 cin.get(array_name, Arsize)的读取方式差很少，
//以Enter结束，能够接受空格字符。按照长度(Arsize)读取字符, 会丢弃最后的Enter字符。
//可是这两个函数是有区别的：
//cin.get(array_name, Arsize)当输入的字符串超长时，不会引发cin函数的错误，
//后面的cin操做会继续执行，只是直接从缓冲区中取数据。
//可是cin.getline()当输入超长时，会引发cin函数的错误，后面的cin操做将再也不执行。*/

#include<iostream>　　　
#include <vector>
#include <algorithm>

using namespace std;
main()
{
vector<int> s;
s.push_back(1);
s.push_back(2);
s.push_back(3);//copy()在algorithm里
copy(s.begin(), s.end(), ostream_iterator<int>(cout, " "));//将由s.begin()至s.end()
//(不含s.end())所指定的序列复制到标准输出流cout中，
//用" "做为每一个元素的间隔。也就是说，这句话的做用其实就是将表中的全部内容依次输出。

cout <<endl;
return 1;
}
/*

#include <iostream>
#include <string>
#include <stack>
using namespace std;
main()
{
int n;
cin >> n;
for (int i=0; i<n; i++)
{
int m;
cin >> m;
string str;
int leftpa = 0;
for (int j=0; j<m; j++) // 读入P编码，构造括号字符串
{
int p;
cin >> p;
for (int k=0; k<p-leftpa; k++) str += '(';
str += ')';
leftpa = p;
}
stack<int> s;
for (string::iterator it=str.begin(); it!=str.end(); it++)
{ // 构造M编码
if (*it=='(')
s.push(1);
else
{
int p = s.top(); s.pop();
cout << p << " ";
if (!s.empty()) s.top() += p;
}
}
cout << endl;
}
return 1;
}
*/

//deque双端队列容器与vector同样，采用线性序存储结构，可是与vector惟一不一样的是，deque采用的是
//分块的线性存储结构来存储数据，每块的大小通常为512字节，称之为一个deque块，全部的deque块有
//一个Map块进行管理，每个Map数据项记录各个deque块的首地址
//这样一来，deque块在头部和尾部均可以插入和删除元素，而不须要移动其余元素
//(使用push_back()方法在尾部插入元素，会扩张队列；使用push_front()在首部插入元素和使用insert()
//在中间插入元素，只是将原位置的元素覆盖，不会增长新元素)。通常来讲，当考虑到容器元素的内存分配
//策略和操做的性能时，deque相对于vector更有优点；
/*#include<deque>
#include<iostream>
using namespace std;

int main(void)
{
deque<int> d;
//从尾部连续插入三个元素
d.push_back(1);
d.push_back(2);
d.push_back(3);
cout<<"Before push_front()"<<endl;
cout<<d[0]<<" "<<d[1]<<" "<<d[2]<<endl;
//从头部插入元素，不会增长元素，只将原来的元素覆盖
d.push_front(10);
d.push_front(20);
//以数组的方式输出元素
cout<<"After push_front(10和20)"<<endl;
cout<<d[0]<<" "<<d[1]<<" "<<d[2]<<endl;
return 0;
}
*/

#include<deque>
#include<iostream>
using namespace std;

int main(void)
{
deque<int> d;
d.push_back(1);
d.push_back(2);
d.push_back(3);
d.push_back(4);
d.push_back(5);
d.push_back(6);
cout<<"befor insert()"<<endl;
cout<<d[0]<<" "<<d[1]<<" "<<d[2]<<endl;
//中间插入元素，不会增长新元素，只将原来的元素覆盖.其实不是覆盖，只是将存储地址霸占了，
//依次推进元素，让后插入的元素推到后面的地址了。！！！！！！！
cout<<"After insert()"<<endl;
d.insert(d.begin(),88);
cout<<d[0]<<" "<<d[1]<<" "<<d[2]<<" "<<endl;
//前向遍历：一种是数组方式
cout<<"数组遍历！"<<endl;
for(int i=0;i<d.size();i++)
{
cout<<d[i]<<" ";
}
cout<<endl;
//前向迭代器的方式遍历
cout<<"前向迭代器的方式遍历"<<endl;
deque<int> ::iterator it;
for(it=d.begin();it!=d.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
//反向迭代器
cout<<"反向迭代器"<<endl;
deque<int>::reverse_iterator rit;
for(rit=d.rbegin();rit!=d.rend();rit++)
{
cout<<*rit<<" ";
}
cout<<endl;
//从头部删除元素
cout<<"从头部删除2个元素！"<<endl;
d.pop_front();
d.pop_front();
for(it=d.begin();it!=d.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
//从尾部删除元素
d.pop_back();
cout<<"从尾部删除元素!"<<endl;
for(it=d.begin();it!=d.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
//从中间删除元素，erase的参数是迭代器位置
d.erase(d.begin()+1);
cout<<"从中间删除元素!"<<endl;
for(it=d.begin();it!=d.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
//清空元素
d.clear();
//输出元素的个数！
cout<<"输出元素的个数！after clear()! "<<endl;
cout<<d.size()<<endl;
return 0;
}

//list容器实现了双向链表的数据结构，数据元素是经过链表指针串成逻辑意义上的
//线性表，这样，双链表的任意位置的元素的插入，删除，查找都是极快的。
//list的每个结点有三个域：前驱元素指针域，数据域，后继元素指针域
//因为list对象的结点并不要求在一段连续的内存中，因此对于迭代器只能
//经过"++"后"--"的操做将迭代器移到后继/前驱节点元素处，
//而不能对迭代器进行+n/-n的操做。这点与vector不一样的地方
#include<list>
#include<iostream>
#include<algorithm>//包含find()方法，返回的是该元素的迭代器的位置，若是没有找到，则返回end()的迭代器的位置
using namespace std;

int main(void)
{
list<int> l;
//在链表的尾部插入新元素，链表扩张
l.push_back(2);
l.push_back(1);
l.push_back(1);
l.push_back(5);
l.push_back(5);
l.push_back(6);
l.push_back(7);
l.push_back(8);
l.push_back(9);
//在链表的头部插入新元素，链表自动扩张
l.push_front(8);
//能够在任意的位置插入元素，只能进行++/--
list<int>::iterator it;
it=l.begin();//默认位置是开始位置第一个元素的位置（意思上）
cout<<"插入元素"<<endl;
//只能进行++/--
l.insert(++it,20);
cout<<"前向迭代器"<<endl;
for(it=l.begin();it!=l.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
cout<<"反向迭代器"<<endl;
list<int>::reverse_iterator rit;
for(rit=l.rbegin();rit!=l.rend();rit++)
{
cout<<*rit<<" ";

}
cout<<endl;
//删除值为1的全部的元素,使用remove(),值相同的元素都会被删除
cout<<"删除值为1的全部的元素"<<endl;
l.remove(1);
cout<<"前向迭代器"<<endl;
for(it=l.begin();it!=l.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
//有pop_front()方法，删除链表首元素，使用pop_back()删除链表尾元素
cout<<"删除首元素"<<endl;
l.pop_front();
for(it=l.begin();it!=l.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
cout<<"删除尾元素"<<endl;
l.pop_back();
for(it=l.begin();it!=l.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
//使用erase()方法删除迭代器位置上的元素
//删除两个元素，由于前面的有it=l.begin(),++it,
cout<<"使用erase()方法删除迭代器位置上的元素"<<endl;
it++;
it++;
l.erase(it);
for(it=l.begin();it!=l.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
//采用find()查找算法在链表中查找
cout<<"查找5"<<endl;
it=find(l.begin(),l.end(),5);//查找链表上值为5
if(it!=l.end())
{
cout<<"find it!"<<endl;
cout<<*it<<endl;
cout<<"返回该元素在迭代器的位置！"<<endl;
cout<<&it<<endl;
}
else
{
cout<<"not find it!"<<endl;
}
//使用sort()方法对链表排序，是升序排列
l.sort();
cout<<"升序排列后："<<endl;
for(it=l.begin();it!=l.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
//剔除重复元素
l.unique();
cout<<"剔除重复的元素后的遍历 ,(用unique())"<<endl;
for(it=l.begin();it!=l.end();it++)
{
cout<<*it<<" ";
}
cout<<endl;
//用clear()清空链表
cout<<"清空链表"<<endl;
l.clear();
cout<<"链表元素个数"<<endl;
cout<<l.size()<<endl;
return 0;
}

//将元素插入到map中的时候，map会根据设定的比较函数将钙元素放到该放的节点上去；
//在定义map的时候，若是没有指定比较函数，那么采用默认函数，即按键值从小到大
//的顺序插入元素。在不少状况下，须要本身编写比较函数//
//map与set的比较函数是一致的内部数据结构都是红黑树，编写有两种方法
//a:若是元素不是结构体，那么，能够编写比较函数。下面这个程序编写的比较规则
//是要求按键值从大到小的顺序将元素插到map中
/*#include<map>
#include<string>
#include<iostream>

using namespace std;

//自定义比较函数myComp
struct myComp//元素不是结构体
{
bool operator()(const int &a,const int &b)
{
if(a!=b) return a>b;
else
return a>b;
}
};
int main()
{
map<int,char,myComp> m;
m[25]='m';
m[28]='k';
m[10]='x';
m[30]='a';
map<int,char,myComp>::iterator it;
for(it=m.begin();it!=m.end();it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl;
}

return 0;
}

*/

 

 

 

 

 

 

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

struct Info
{
string name;
float score;
//重载"<"操做符，自定义排序规则
bool operator <(const Info &a) const
{
//按score由大到小排列。若是要有小达大排列使用">"便可
return a.score<score;
}
};

int main()
{
map<Info,int> m;
Info info;
//插入元素，按键值的由小到大放入黑白树中
info.name="Jack";
info.score=60;
m[info]=25;
info.name="Bomi";
info.score=80;
m[info]=10;
info.name="Peti";
info.score=66.4;
m[info]=30;
//使用前向迭代器中序遍历map
map<Info,int>::iterator it;
for(it=m.begin();it!=m.end();it++)

cout<<(*it).second<<":";
cout<<((*it).first).name<<" "<<((*it).first).score<<endl;
}
return 0;

}

#include<map>
#include<string>
#include<iostream>
using namespace std;
int main(void)
{
map<char,int> m;
m['0']=0;
m['1']=1;
m['2']=2;
m['3']=3;
m['4']=4;
m['5']=5;
m['6']=6;
m['7']=7;
m['8']=8;
m['9']=9;
/*以上的10条赋值语句能够用下面的代替
for(int j=0;j<10;j++)
{
m['0'+j]=j;
}*/
string sa,sb;
sa="234324";

int sum=0;
for(int i=0;i<sa.length();i++)
{
sum+=m[sa[i]];
}
cout<<"sum="<<sum<<endl;
//数字映照字符的map写法
cout<<"数字映照字符的map写法"<<endl;
map<int,char> m1;
for(int j=0;j<10;j++)
{
m1[j]='0'+j;
}
int n=7;
string s="The number is:";
cout<<s+m1[n]<<endl;
return 0;

}

//#pragam warning(disable:C4786)//强制编译器忽略该警告
#include<map>
#include<string>
#include<iostream>
using namespace std;

int main()
{
map<int ,char> m;//定义map对象，当前没有任何元素
//插入元素，按键值的由小到大放入黑白树中
m[25]='m';
m[28]='k';
m[10]='x';
m[30]='a';
//删除键值为28的元素
m.erase(28);
cout<<"前序遍历"<<endl;
map<int,char>::iterator it;
for(it=m.begin();it!=m.end();it++)
{
//输出键值和映照数据
cout<<(*it).first<<":"<<(*it).second<<endl;
}
//元素的搜索
cout<<"元素的搜素遍历[28]"<<endl;

it=m.find(28);
if(it!=m.end())
{
cout<<(*it).first<<":"<<(*it).second<<endl;
}
else

{
cout<<"not found it"<<endl;
}

//元素反向遍历
cout<<"反向遍历"<<endl;
cout<<"插入键值为28的数据"<<endl;
m.insert(pair<int , char> (28,'k'));
map<int,char>::reverse_iterator rit;
for(rit=m.rbegin();rit!=m.rend();rit++)
{
cout<<(*rit).first<<":"<<(*rit).second<<endl;
}
return 0;
}

#include<map>
#include<string>
#include<iostream>

using namespace std;

int main(void)
{
multimap<string ,double> m;
m.insert(pair<string,double>("Jack",300.5));
m.insert(pair<string,double>("Kity",200));
m.insert(pair<string,double>("Memi",500));
//能够重复插入键值“Jack”
m.insert(pair<string,double>("Jack",308));
//使用前向迭代器中序遍历multimap
multimap<string,double>::iterator it;
for(it=m.begin();it!=m.end();it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl;
}
//删除键值为"Jack"的元素
m.erase("Jack");
//使用前向迭代器中序遍历multimap
cout<<"the elements after deleted:"<<endl;
for(it=m.begin();it!=m.end();it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl;
}
//查找键值为"Jack"
cout<<"Search the element "Jack" :"<<endl;
it=m.find("Jack");
if(it!=m.end())
{
cout<<(*it).first<<" "<<(*it).second<<endl;
}
else
{
cout<<"not find it!"<<endl;
}

return 0;
}

 

//queue队列是是一个先进先出的线性存储表，元素的插入只在队尾，元素的删除只在队首
/*#include<queue>
#include<iostream>
using namespace std;

int main(void)
{
queue<int> q;
q.push(1);
q.push(2);
q.push(3);
q.push(9);
//返回队列元素数量
cout<<"返回队列元素数量"<<endl;
cout<<q.size()<<endl;
//判断队列是否为空
cout<<"判断队列是否为空"<<endl;
cout<<q.empty()<<endl;
//读取队尾元素
cout<<"读取队尾元素"<<endl;
cout<<q.back()<<endl;
//读取队首元素
cout<<"读取队首元素"<<endl;
cout<<q.front()<<endl;
//全部的元素出列
cout<<"全部的元素出列"<<endl;
while(q.empty()!=true)
{
cout<<q.front()<<" ";
q.pop();//出队，即删除

}
cout<<endl;
cout<<"判断队列是否为空(返回值为empty()1为真即为空)"<<endl;
cout<<q.empty()<<endl;
return 0;
}*/

//priority_queue优先队列容器与队列同样，只能从队尾插入元素，从队首删除元素
//可是有个优点，队列中最大的元素位于队首，不是按照先进先出的元素，而是按照
//当前队列中的最大的元素出队，元素的比较规则是默认的按元素的值由大到下的排列
//固然，能够重载“<”操做符来从新定义比较规则
/*#include<queue>
#include<iostream>
using namespace std;

int main(void)
{
priority_queue<int> pq;
pq.push(1);
pq.push(2);
pq.push(3);
pq.push(9);
//返回队列元素数量
cout<<"返回队列元素数量"<<endl;
cout<<pq.size()<<endl;
//判断队列是否为空
cout<<"判断队列是否为空"<<endl;
cout<<pq.empty()<<endl;

//全部的元素出列
cout<<"全部的元素出列"<<endl;
while(pq.empty()!=true)
{
cout<<pq.top()<<" ";
pq.pop();//出队，即删除

}
cout<<endl;
cout<<"判断队列是否为空(返回值为empty()1为真即为空)"<<endl;
cout<<pq.empty()<<endl;
return 0;
}*/

/*#include<queue>
#include<iostream>
#include<string>
using namespace std;

//定义结构体
struct Info{
string name;
float score;
//重载"<"操做符，指定优先规则（排序规则）
bool operator < (const Info &a) const//通常结构体的定义操做符用"<"而不用“()”后者只用在数据类型中
{
//按score由小到大排列。若是按由大到小排列使用“>”可是只是该下面的return中的"<" / ">"
return a.score<score;
}
};

int main(void)
{
priority_queue<Info> pq;
Info info;
info.name="Jack";
info.score=68.5;
pq.push(info);
info.name="Bomi";
info.score=18.5;
pq.push(info);
info.name="Peti";
info.score=90;
pq.push(info);
//元素所有出队
while(pq.empty()!=true)
{
cout<<"返回队首元素"<<endl;
cout<<pq.top().name<<" :"<<pq.top().score<<endl;
cout<<"出队，删除队首元素"<<endl;
pq.pop();
}
return 0;
}*/

 

 

 

//若是优先队列的元素不是结构体类型，则可经过重载“()”操做符的方式来定义优先级
//，固然，元素不是结构体类型的也可经过的重载"()"操做符的方式来定义优先级
//而不必定要在结构体内重载"<"操做符才行

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

struct myComp
{
bool operator()(const int &a,const int &b)
{
return a<b;//由小到大采用">",若是由大到小采用"<"
}

};

int main(void)
{
//定义优先队列，定义元素类型为Info结构体，显示说明内部结构为vector
priority_queue<int,vector<int>,myComp> pq;
pq.push(1);
pq.push(9);
pq.push(2);
pq.push(30);
while(pq.empty()!=true)
{
cout<<pq.top()<<" ";
pq.pop();
}
cout<<endl;
return 0;
}

//stack堆栈是一个后进先出的线性表

#include<stack>
#include<iostream>

using namespace std;
int main(void)
{
stack<int> s;
s.push(1);
s.push(2);
s.push(3);
s.push(9);
//读取栈顶元素
cout<<"读取栈顶元素 "<<endl;
cout<<s.top()<<endl;
//返回堆栈元素数量
cout<<"返回堆栈元素数量"<<endl;
cout<<s.size()<<endl;
//判断堆栈是否为空
cout<<"判断堆栈是否为空"<<endl;
cout<<s.empty()<<endl;
while(s.empty()!=true)
{
cout<<s.top()<<" ";
s.pop();//出栈（即删除栈顶元素）
}
cout<<endl;
return 0;
}

#include<iostream>
#include<string>

using namespace std;

int main(void)
{
int n;
string s;
cin>>n;
for(int i=0;i<n;i++)
{
cin>>s;
cout<<"String #"<<i+1<<endl;
for(int j=0;j<s.length();j++)//注意size() 与length()的差别
{
cout<<(s[j]!='Z' ? char(s[j]+1) : 'A');
}
cout<<endl;
cout<<endl;
}

return 0;
}

 

//返回二进制中1的位置
#include<iostream>
#include<vector>

using namespace std;

int main(void)
{
vector<int>v;
int n,a;
cin>>n;
for(int i=0;i<n;i++)
{
cin>>a;
v.clear();
for(int j=a;j;j/=2)//搜索关于C/C++中0和1表明假真？
{
v.push_back(j%2 ? 1 : 0);//C/C++中0和1表明假真？
}
int p=0;//输出第一个1的位置
for(int k=0; k<v.size(); k++)
{
if(v[k]==1)
{
if(p==0) cout<<k;
else cout<<" "<<k;//other positiones need space
p=1;
}
}
cout<<endl;
}
return 0;
}

 

//输入：2 ABC ABBCCC
//输出：ABC A2B3C
#include<iostream>
#include<string>

using namespace std;

int main(void)
{
string s,t;
int n;
cin>>n;
for(int i=0;i<n;i++)
{
cin>>s;
int c=0;
t=s[0];
int temp=0;
for(int j=0;j<s.size();j++)
{
if(s[j]==t[0])
{
temp++;
//若是已经是最后一个，直接输出
if(j==s.size()-1)
{
if(temp==1) cout<<t[0];
else cout<<temp<<t[0];
}
}
else
{
if(temp==1) cout<<t[0];
else cout<<temp<<t[0];
t[0]=s[j];
temp=1;
//若是已经是最后一个， 直接输出
if(j==s.size()-1)
{
if(temp==1) cout<<t[0];
else cout<<temp<<t[0];
}
}
}
cout<<endl;
s=" ";
}

return 0;
}

 

//zju 2886
//do with the string //scanf和printf全部的时间大大少于cin和cout
//输入：3 122344111 1111111111 12345
//输出：122132431 101 1112131415
#include<iostream>
#include<string>

using namespace std;

int main(void)
{
string s,t;
int n;
cin>>n;
for(int i=0;i<n;i++)
{
cin>>s;
int c=0;
int temp=0;
t=s[0];//这个表达式是？是把整个字符串赋值给t吗？仍是将s中的第一个字符赋予t
for(int j=0;j<s.length();j++)
{

if(s[j]==t[0])
{
temp++;
//若是最后一个，直接输出
if(j==s.size()-1)
{
printf("%d%c",temp,t[0]);//the measure is not a good wa y!
}
}
else
{
printf("%d%c",temp,t[0]);
t[0]=s[j];
temp=1;
//若是最后一个，直接输出
if(j==s.size()-1)
{
printf("%d%c",temp,t[0]);
}
}

}
cout<<endl;
}
return 0;
}

//zju2947
//Input : test cases: word numbers： first name: word numbers： second name:
//Output:SAME 0r DIFFERENT (名字首字母链接获得的结果相同便可，输出same，or different)

#include<iostream>
#include<string>

using namespace std;

int main(void)
{
string s,ssa,ssb;
int t,n,m;
cin>>t;//test cases numbers
for(int i=0;i<t;i++)
{
cin>>n;// the first all word numbers
for(int j=0;j<n;j++)//input the names
{
cin>>s;
ssa+=s[0];//the letter from the words of the first position
}
cin>>m;//the second all word numbers
for(int k=0;k<m;k++)
{
cin>>s;
ssb+=s[0];
}
if(ssa.compare(ssb)==0)//equal is 0, big is 1,small is -1
cout<<"SAME"<<endl;
else
cout<<"DIFFERENT"<<endl;
ssa=" ";
ssb=" ";

}
return 0;
}

//zju2947
//Input : test cases: word numbers： first name: word numbers： second name:
//Output:SAME 0r DIFFERENT (名字首字母链接获得的结果相同便可，输出same，or different)

#include<iostream>
#include<string>

using namespace std;

int main(void)
{
string s,ssa,ssb;
int t,n,m;
cin>>t;//test cases numbers
for(int i=0;i<t;i++)
{
cin>>n;// the first all word numbers
for(int j=0;j<n;j++)//input the names
{
cin>>s;
ssa+=s[0];//the letter from the words of the first position
}
cin>>m;//the second all word numbers
for(int k=0;k<m;k++)
{
cin>>s;
ssb+=s[0];
}
if(ssa.compare(ssb)==0)//equal is 0, big is 1,small is -1
cout<<"SAME"<<endl;
else
cout<<"DIFFERENT"<<endl;
ssa=" ";
ssb=" ";

}
return 0;
}

//求的是：各个位上的数字相加，结果值必定要为个位数，应该累加到符合要求
#include<iostream>
#include<string>

using namespace std;

int main(void)
{
string s;
int sum;
while(cin>>s)
{
if(s=="0") break;
sum=0;
//减小第一轮求和的计算是问题的关键
for(int i=0;i<s.size();i++)
{
if(s[i]=='1') sum+=1;
else if(s[i]=='2') sum+=2;
else if(s[i]=='3') sum+=3;
else if(s[i]=='4') sum+=4;
else if(s[i]=='5') sum+=5;
else if(s[i]=='6') sum+=6;
else if(s[i]=='7') sum+=7;
else if(s[i]=='8') sum+=8;
else if(s[i]=='9') sum+=9;
}
//第二轮到第n轮求和
while(1)
{
if(sum<10)
{
cout<<sum<<endl;
break;
}
sum=sum/10+sum%10;//为何能够这样处理？缘由在于：最大的整数：9 999 999 999之和为90
}
}
return 0;
}

//zju1251
// 把全部的砖盒移到同一高度，须要计算出移到同一高度所需的最小次数（一次只能移动一个砖盒）
//其实，先经过计算砖块的平均高度，那么，用这个高度减去全部小于它的砖盒的高度，再把全部相减
//的结果加起来，就是正好是须要移动的次数
/*#include < stdio.h>
int main()
{

int inta[51];

int num;

int i;

int sum , aver ;

int max ;

int now =1;

while( scanf("%d",&num ) !=EOF)

{

if(num == 0 )

break;

i=0;

sum =0;

while( i < num )

{

scanf("%d",&inta[i] );

sum += inta[i];

i++;

}

aver = sum / num;

max =0;

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

if(inta[i] > aver )

{

max += inta[i] - aver ;

}

printf("Set #%d/n",now );

printf("The minimum number of moves is %d./n/n",max );

now ++;

}

return 0;

}

*/

//STL 版本
#include<iostream>
#include<vector>

using namespace std;

int main(void)
{
vector<int>v;
int n,b,sum,avg,e,c=0;
while(cin>>n)
{
if(n==0) break;
c++;
sum=0;
e=0;
v.clear();
for(int i=0;i<n;i++)
{
cin>>b;
v.push_back(b);
sum+=b;
}
avg=sum/n;
for(int j=0;j<v.size();j++)
{
if(v[j]<avg) e+=avg-v[j];
}
cout<<"Set #"<<c<<endl;
cout<<"The minimum number of moves is "<<e<<"."<<endl;
cout<<endl;
}

return 0;
}

 

//zju1241
#include<iostream>
#include<cmath>

using namespace std;

int main(void)

{
int a,b,c,n;

n=0;

cout.precision(3);
while(cin>>a>>b>>c)
{
if(a==0 && b==0 && c==0) break;
n++;
if(a==-1)
{
if(c-b<=0)
{
cout<<"Triangle #"<<n<<endl;
cout<<"Impossible."<<endl;
cout<<endl;

}
else
{
cout<<"Triangle #"<<n<<endl;
cout<<"a = "<<fixed<<pow(c*c-b*b,0.5)<<endl;
cout<<endl;

}
}
else if(b==-1)
{
if(c-a<=0)
{
cout<<"Triangle #"<<n<<endl;
cout<<"Impossible."<<endl;
cout<<endl;

}
else
{
cout<<"Triangle #"<<n<<endl;
cout<<"b = "<<fixed<<pow(c*c-a*a,0.5)<<endl;
cout<<endl;

}
}
else if(c==-1)
{
cout<<"Triangle #"<<n<<endl;
cout<<"c = "<<fixed<<pow(b*b+a*a,0.5)<<endl;
cout<<endl;
}
return 0;
}
}

//zju 1295
//反转输出
#include<iostream>
#include<algorithm>
#include<string>

using namespace std;

int main(void)
{
string s;
char ss[80];
int n=0;
while(cin.getline(ss,80))
{
if(n==0) n=1;//跳过第一行输出,第一行能够有，可是不产生影响，
else
{
s=ss;
reverse(s.begin(),s.end());
cout<<s<<endl;
}
}
return 0;
}

//zju 1151
/*#include<iostream>
#include<string>
using namespace std;

int main(void)
{
string s,ss;
char ch[81];
cin.getline(ch,81);//不处理块数量
cin.getline(ch,81);//不处理第一块的行数量
int f=1;//标记是否第一行
while(cin.getline(ch,81))
{
s=ch;
//找到返回从0开始的位置，不然返回4294967295
if(s.find(' ')==4294967295 && f!=1)//是行数量又不是第一块
{
cin.getline(ch,81);//不处理该块的行数量
cout<<endl;
}
else f=0;
//行中有空格存在，说明是语句行
if(s.find(' ')!=4294967295)//这是什么意思？
{
for(unsigned int i=0;i<s.size();i++)
{
if(s[i]!=' ')
ss+=s[i];//放到首位
else
{
cout<<ss<<" ";
ss="";
}
}
cout<<ss<<endl;
ss="";
}
}
return 0;
}*/

#include < iostream>

#include < string>

using namespace std;

int main()

{

char s[1000];

char s1[1000];

int cases;

int num;

int i , k ,j ;

scanf("%d",&cases );

while(cases --)

{

scanf("%d",&num) ;

gets(s); //关键的一行语句,获取scanf输入后面的换行; 不然就当是一次输入处理

while(num--)

{

gets(s);

int len =strlen(s);

k=0;

for(i =0;i <= len;i++)

{

if(s[i]!=' ' && s[i]!='/0')

s1[k++] =s[i];//这种方法挺好，知道元素的个数了！

else

{

for ( j=k-1;j>=0;j--)

printf("%c",s1[j]);

if(s[i] ==' ')

printf(" ");

k=0;

}

}

printf("/n");

}

if(cases >0)

printf("/n");

}

return 0;

}

//zju1763

#include<iostream>

using namespace std;

int main(void)
{
double a,b;
cin>>a;
while(cin>>b)
{
if(b==999) break;
else
printf("%.2f/n",(b-a));
a=b;
}
return 0;
}

//zju2001
/*#include < stdio.h>

int main()

{

int cases;

int a,b;

int a1,b1;

int temp;

while(scanf("%d",&cases)!=EOF )

{

while(cases--)

{

scanf("%d%d",&a,&b);

a1=0;

b1=0;

while(a>0 )

{

temp =a%10;

a1=temp+a1*10;

a/=10;

}

while(b>0 )

{

temp =b%10;

b1=temp+b1*10;

b/=10;

}

temp =a1+b1;

b=0;

while(temp>0)

{

a =temp%10;

b=a+b*10;

temp/=10;

}

printf("%d/n",b);

}

}

return 0;

}*/

 

#include<iostream>
#include<string>
#include<vector>

using namespace std;

int main(void)
{
string sa,sb,st;
vector<int>v;
int a,b,sum;
int p=0;//进位标志
int u=0;//输出标志
cin>>sa;//不处理案例数量
while(cin>>sa>>sb)
{

if(sa.size()<sb.size())
{
st=sa;
sa=sb;
sb=st;
}

for(int i=0;i<sa.size();i++)
{
if(sa[i]=='0') a=0;
else if(sa[i]=='1')a=1;
else if(sa[i]=='2')a=2;
else if(sa[i]=='3')a=3;
else if(sa[i]=='4')a=4;
else if(sa[i]=='5')a=5;
else if(sa[i]=='6')a=6;
else if(sa[i]=='7')a=7;
else if(sa[i]=='8')a=8;
else if(sa[i]=='9')a=9;

if(i>=sb.size()) b=0;
else if(sb[i]=='1')b=1;
else if(sb[i]=='2')b=2;
else if(sb[i]=='3')b=3;
else if(sb[i]=='4')b=4;
else if(sb[i]=='5')b=5;
else if(sb[i]=='6')b=6;
else if(sb[i]=='7')b=7;
else if(sb[i]=='8')b=8;
else if(sb[i]=='9')b=9;

sum=a+b+p;//两位求和再加上进位p
p=sum/10;//求本次的进位，即十位值
v.push_back(sum%10);//个位
}
if(p==1)v.push_back(1);
//去掉末尾的全部0
while(1)
{
vector<int>::iterator it=v.end()-1;
if(*it==0)v.erase(it);
else break;
}
for(int j=0;j<v.size();j++)
{
if(u==0 && v[j]!=0) u=1;
if(u==1) cout<<v[j];
}

cout<<endl;
v.clear();
u=0;
p=0;

}

return 0;
}

//zju2857
#include<iostream>
#include<vector>

using namespace std;

int main(void)
{
vector<int>r;
vector<int>b;
vector<int>g;

int n,m;
int rr,gg,bb;
int w=0;//样例数量
while(cin>>n>>m)
{
r.clear();
b.clear();
g.clear();
w++;
if(n==0 && m==0)break;
for(int i=0;i<n*m;i++)
{
cin>>rr;
r.push_back(rr);
}
for(int j=0;j<n*m;j++)
{
cin>>gg;
g.push_back(gg);
}
for(int k=0;k<n*m;k++)
{
cin>>bb;
b.push_back(bb);
}

cout<<"Case "<<w<<":"<<endl;
for(int p=0;p<n*m;p++)
{
cout<<(r[p]+b[p]+g[p])/3;
if((p+1)%m==0) cout<<endl;
else cout<<" ,";
}

}
return 0;
}

 

//zju2850
#include<iostream>

using namespace std;

int main(void)
{
int p[10][10];
int n,m;
int i,j,k;
int flag=1;//表示没有除过草
while(cin>>n>>m)
{
if(n==0 && m==0) break;//读数据结束
flag=1;//先标记没有锄过草
//读入矩阵
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
cin>>p[i][j];
if(p[i][j]==0) flag=0;//修见过
}
}
//开始判断
//第一种状况：没有修剪过，即全是1，则不漂亮
if(flag==1)
{
cout<<"NO"<<endl;
continue;
}
//第二种状况：剪得两块共一条边，即先后两个元素或者上下两个元素是00不漂亮
//判断第0行
for(k=1;k<m;k++)
{
if(p[0][k]==0 && p[0][k-1]==0)
{
cout<<"NO"<<endl;
goto RL;
}
}
//判断第1~n-1行
for(i=1;i<n;i++)
{
for(int j=0;j<m;j++)
{
//本行与上一行同一列元素都是0吗？
if(p[i][j]==0 && p[i-1][j]==0)
{
cout<<"NO"<<endl;
goto RL;//结束
}
//本行中当前元素和前一元素都是0吗？
if(j!=0)
{
if(p[i][j]==0 && p[i][j-1]==0)
{
cout<<"NO"<<endl;
goto RL;//结束
}
}
}
}
cout<<"Yes"<<endl;//漂亮
continue;
RL:
continue;
}
return 0;
}

//zju 1188
//其实就是求逆序数，，而后根据逆序数的大小，从小到大的顺序排列

/*#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

//自定义比较函数
bool comp (const string &s1,const string &s2)
{
int i,j,k,m,n;
int c1=0,c2=0;
//计算s1须要移动的次数c1
for(i=0;i<s1.size();i++)
{
for(j=i+1;j<s1.size();j++)
{
if(s1[i]>s1[j+1])
c1++;
}
}
//计算s2须要移动的次数c2
for(i=0;i<s2.size();i++)
{
for(j=i+1;j<s2.size();j++)
{
if(s2[i]>s2[j])
c2++;
}
}
//若是两行字符串移动的次数相同，那么按原先固有的位置排序
return c1!=c2 ? c1<c2 : c1<c2;
}

int main(void)
{
string s;
vector<string> v;
int n,a,b;
cin>>n;
int i,j,k;
int p=0;//块数
for(i=0;i<n;i++)//读入n组case
{
cin.clear();
cin>>a>>b;
v.clear();//清空向量
p++;//增长一块
for(j=0;j<b;j++)
{
cin>>s;
v.push_back(s);
}

//按comp排序
sort(v.begin(),v.end(),comp);
if(p!=1)cout<<endl;//不是第一行，产生一新空行
//输出v向量中的每一个元素
for(k=0;k<v.size();k++)
{
cout<<v[k]<<endl;
}
}
return 0;
}*/

 

////其实这题是挺简单的,当初题意理解错了,卡了好久。这题就是找每一个串的逆序数的多少,而后排序输出串就好了,还有一个就是输出空格那个要求,也提醒我作题必定要审清题意在动手,这很关键的 !!!!

////排序是用 sort

#include< iostream>

#include< algorithm>

#define N 51

#define M 100

using namespace std;

char str[M][N];

struct node

{

int num;

char *p;

}a[M];

bool less_than(struct node a,struct node b)

{

return a.num< b.num;

}

int main()

{

int m,n;

int i,j,k;

int cases;

scanf("%d",&cases);

int now =cases;

while(now)

{

if(now ==0)

break;

now--;

if(now != cases-1)

printf("/n");

scanf("%d%d",&n,&m);

for(i=0;i< m;i++) //// m行strings

{

scanf("%s",&str[i]);

a[i].p=str[i]; //用指针指向字符串

a[i].num=0;

for(j=0;j< n-1;j++)

for(k=j+1;k< n;k++) //// 求逆序数

if(str[i][j]>str[i][k])

a[i].num++;

}

sort(a,a+m,less_than); ////sort 的第一参数是数组名或其余的,第二是数组的大小,三是比较函数

for(i=0;i< m;i++)

printf("%s/n",a[i].p);

}

return 0;

}

//zju2736

#include<iostream>
#include<cmath>
using namespace std;

int main(void)
{
int n;
int a,b,c;
while(cin>>n)
{
a=n/100;
b=(n-a*100)/10;
c=n%10;
if(n==(pow(a,3)+pow(b,3)+pow(c,3)))
{
cout<<"Yes"<<endl;
}
else
{
cout<<"No"<<endl;
}
}
return 0;
}

 

//zju 1949

//只修改矩阵中的一位，和变成偶数
#include<iostream>

using namespace std;

int matrix[100][100];
int SL[100];//数组每行的和
int SC[100];//数组每列的和
int main(void)
{
int i,j,PL,PC,CountL,CountC;
int n;//matrix 的大小
while(cin>>n)
{
if(n==0)break;
//初始化各类变量、
PL=0;
PC=0;
CountC=0;
CountL=0;
for(i=0;i<n;i++)
{
SL[i]=0;
SC[i]=0;
}
// 读入全部数据，同时计算每行、列的元素和
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
cin>>matrix[i][j];
SL[i]+=matrix[i][j];
SC[j]+=matrix[i][j];
}
}
//判断矩阵每行、列的和是不是偶数、、
for(i=0;i<n;i++)
{
//判断每行的和
if(SL[i]%2!=0)
{
PL=1;//记下行数
CountL++;//记下次数
}
//
if(SC[i]%2!=0)
{
PC=1;//记下列数
CountC++;//记下次数
}

}

//output
if(CountL==0 && CountC==0 )
{
cout<<"OK"<<endl;

}
else if(CountL==1 && CountC==1)
{
cout<<"Change bit("<<PL+1<<","<<PC+1<<")"<<endl;
}
else
cout<<"Corrupt"<<endl;

 

}
return 0;
}

//zju1205
/*#include< iostream>

#include< string>

using namespace std;

int main()

{

string str1,str2;

char str[101];

int code1[100],code2[100];

int len1,len2;

int i,j,k;

while(cin>>str1>>str2)

{

len1=str1.size();

len2=str2.size();

for(i=0;i< len1;i++)

{

if(str1[i]>='0'&&str1[i]<='9')

code1[i]=str1[i]-'0';

else

code1[i]=str1[i]-'a'+10;

}

for(i=0;i< len2;i++)

{

if(str2[i]>='0'&&str2[i]<='9')

code2[i]=str2[i]-'0';

else

code2[i]=str2[i]-'a'+10;

}

i = len1-1;

j = len2-1;

k=0;

int tmp=0,left,sum;

while(i>=0 && j>=0)

{

sum = code1[i] + code2[j] + tmp;

tmp = sum / 20;

left = sum % 20;

if(left >= 10)

str[k]= 'a' + left - 10;

else

str[k]= '0' + left;

k++;

i--;

j--;

}

while(i >= 0)

{

sum = code1[i] + tmp;

tmp = sum / 20;

left = sum % 20;

if(left >=10)

str[k] = 'a' + left - 10;

else

str[k] = '0' + left;

k++;

i--;

}

while(j >= 0)

{

sum = code2[j] + tmp;

tmp = sum / 20;

left = sum % 20;

if(left >= 10)

str[k]= 'a' + left - 10;

else

str[k] = '0' + left;

k++;

j--;

}

if(tmp)

str[k++]='0'+tmp;

for(i=k-1;i>=0;i--)

cout<< str[i];

cout<< endl;

}

return 0;

}

*/

// STL

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

int main(void)

{
string sa,sb,t;
vector<int> v;
int i;
int a,b,sum;
int flag;//进位标志
while(cin>>sa>>sb)
{
//初始化各类变量和容器
flag=0;//没有进位
v.clear();
sum=0;
//反转两个字符容器
reverse(sa.begin(),sa.end());
reverse(sb.begin(),sb.end());
//sa里放长串
if(sa.size()<sb.size())
{
t=sa;
sa=sb;
sb=t;
}
//从个位起，一位一位相加
for(i=0;i<sa.size();i++)
{
if(sa[i]=='0') a=0;
else if (sa[i]=='1')a=1;
else if (sa[i]=='2')a=2;
else if (sa[i]=='3')a=3;
else if (sa[i]=='4')a=4;
else if (sa[i]=='5')a=5;
else if (sa[i]=='6')a=6;
else if (sa[i]=='7')a=7;
else if (sa[i]=='8')a=8;
else if (sa[i]=='9')a=9;
else if (sa[i]=='a')a=10;
else if (sa[i]=='b')a=11;
else if (sa[i]=='c')a=12;
else if (sa[i]=='d')a=13;
else if (sa[i]=='e')a=14;
else if (sa[i]=='f')a=15;
else if (sa[i]=='g')a=16;
else if (sa[i]=='h')a=17;
else if (sa[i]=='i')a=18;
else if (sa[i]=='j')a=19;
if(i>=sb.size())b=0;//已超过b串的最长一位
else
{
if(sb[i]=='0') b=0;
else if (sb[i]=='1')b=1;
else if (sb[i]=='2')b=2;
else if (sb[i]=='3')b=3;
else if (sb[i]=='4')b=4;
else if (sb[i]=='5')b=5;
else if (sb[i]=='6')b=6;
else if (sb[i]=='7')b=7;
else if (sb[i]=='8')b=8;
else if (sb[i]=='9')b=9;
else if (sb[i]=='a')b=10;
else if (sb[i]=='b')b=11;
else if (sb[i]=='c')b=12;
else if (sb[i]=='d')b=13;
else if (sb[i]=='e')b=14;
else if (sb[i]=='f')b=15;
else if (sb[i]=='g')b=16;
else if (sb[i]=='h')b=17;
else if (sb[i]=='i')b=18;
else if (sb[i]=='j')b=19;
}
sum=a+b+flag;//求两位的和
if(sum>19)
{
flag=1;//进位
sum-=20;//保留位
}
else
{
flag=0;
}
v.push_back(sum);//保存保留位

}
//if(flag==1)v.push_back(1);
//输出结果
for(i=v.size()-1;i>=0;i--)
{
if(v[i]<10) cout<<v[i];
else if(v[i]==10)cout<<'a';
else if(v[i]==11)cout<<'b';
else if(v[i]==12)cout<<'c';
else if(v[i]==13)cout<<'d';
else if(v[i]==14)cout<<'e';
else if(v[i]==15)cout<<'f';
else if(v[i]==16)cout<<'g';
else if(v[i]==17)cout<<'h';
else if(v[i]==18)cout<<'i';
else if(v[i]==19)cout<<'j';

}
cout<<endl;

}
return 0;
}

//zju2727
//对于这三种排序标准，编写三个比较函数，这样实现起来，比较简单，
//本题对泛型编程的优点发挥的淋漓尽致，若是不采用泛型编程，则会变得至关困难
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

//数据存取结构
struct Book
{
string Name;
int Year;
int Price;

};

//自定义比较函数
bool CompName(const Book &b1,const Book &b2)
{
if(b1.Name!=b2.Name) return b1.Name<b2.Name;
else if(b1.Year!=b2.Year)return b1.Year<b2.Year;
else return b1.Price<b2.Price;
}

bool CompYear(const Book &b1,const Book &b2)
{
if(b1.Year!=b2.Year)return b1.Year<b2.Year;
else if(b1.Name!=b2.Name) return b1.Name<b2.Name;
else return b1.Price<b2.Price;
}

bool CompPrice(const Book &b1,const Book &b2)
{
if(b1.Price!=b2.Price)return b1.Price<b2.Price;
else if (b1.Name!=b2.Name) return b1.Name<b2.Name;
else return b1.Year<b2.Year;
}

int main(void)
{
vector<Book> v;
Book book;
string sorting;//第一排序
int n;
int i;
int line=0;
while(cin>>n)
{
if(n==0)break;
line++;//案例号
v.clear();
//读入一个案例数据到向量中
for(i=0;i<n;i++)
{
cin>>book.Name>>book.Year>>book.Price;
v.push_back(book);
}
//读入排序标准
cin>>sorting;
if(sorting=="Name")
sort(v.begin(),v.end(),CompName);
else if(sorting=="Year")
sort(v.begin(),v.end(),CompYear);
else if(sorting=="Price")
sort(v.begin(),v.end(),CompPrice);
//输出结果
if(line!=1)
cout<<endl;
for(i=0;i<v.size();i++)
{
cout<<v[i].Name<<" "<<v[i].Year<<" "<<v[i].Price<<endl;
}
}
return 0;
}

//zju2722
#include<iostream>
#include<cmath>

using namespace std;

int main(void)
{
//针对本题pow乘方的参数须要定义double型 。由于像15，16须要
double i,n,count;
while(cin>>n)
{
if(n==0)break;
count=0;
for(i=0;i<32;i++)
{
if(pow(2,i)>=n)
{
count=i;
break;
}
}
cout<<count<<endl;
}
return 0;
}

//zju2724
#include<iostream>
#include<queue>

using namespace std;

struct Message
{
char Name[100];
int Data;
int Priority;
//重载<操做符，自定义排序规则
bool operator < (const Message &a) const
{
return a.Priority<Priority;
}
};
//priority_queue优先队列容器与队列同样，只能从队尾插入元素，从队首删除元素
//可是有个优点，队列中最大的元素位于队首，不是按照先进先出的元素，而是按照
//当前队列中的最大的元素出队，元素的比较规则是默认的按元素的值由大到下的排列
//固然，能够重载“<”操做符来从新定义比较规则
priority_queue<Message> v;

int main(void)
{
char command[100];
Message message;
while(scanf("%s",command)!=EOF)
{
if(strcmp(command,"GET")==0)
{
//队列为空
if(v.size()==0)
printf("EMPTY QUEUE!/n");
else
{
printf("%s %d/n",v.top().Name,v.top().Data);
v.pop();
}
}
else if(strcmp(command,"PUT")==0)
{
scanf("%s%d%d",&message.Name,&message.Data,&message.Priority);
v.push(message);
}
}
return 0;
}

//zju1109

#include< iostream>

#include< cstdio>

using namespace std;

char word[30];

typedef struct node *point;
struct node
{

char trans[20];

point next[30];

};

point root;

int mid;

int find()

{

int a,b;

a=0;

for(b = 0 ; b < strlen(word) ; b++)

if ( word[b] == ' ')

a = b;

return(a);

}

void search(point &x,int y )

{

int a;

if ( x == 0)

cout<<"eh"<< endl;

else

{

if ( y == strlen(word) )

{

if ( strcmp(x->trans,"" ) == 0 )

cout<<"eh"<< endl;

else

{

a=0;

while( x->trans[a]!=' ')

{

cout<< x->trans[a];

a++;

}

cout<< endl;

}

}

else

{

a=word[y]-'a'+1;

search( x->next[a],y+1);

}

}

}

void insert(point &x,int y)

{

int a,b;

if ( x == 0)

{

x=new struct node;

strcpy(x->trans,"");

for (a = 1 ; a <= 26 ; a ++)

x->next[a]=0;

}

if ( y == strlen(word) )

strcpy(x->trans,word);

else

{

a = word[y]-'a'+1;

insert(x->next[a],y+1);

}

}

int main()

{

root=0;

while (gets(word))

{

if ( (word[0]<='z') && (word[0]>='a') )

{

mid=find();

if (mid==0)

search(root,0);

else

insert(root,mid+1);

}

}

return 0;

}

//STL

/*#include<iostream>
#include<string>
#include<map>

using namespace std;

//采用gets()输入比getline()快的多，可是gets()不能从cin中读取数据，调试不易
//gets函数的用法：
//从stdin流中读取字符串，直接收到换行符或EOF时，中止
//并将读取的结果存在str指针所指向的字符数组中；
//换行符不做为读取串的内容，读取的换行符被转换为null值，并由此来结束字符串
int main(void)
{
string s;
char ss[100],s1[100],s2[100];
int x,y;
//map映照容器：键值+映照数据
map<string,string> m;
//迭代器
map<string,string>::iterator p;
//while(getline(cin,s))
while(gets(ss))
{
s=ss;
//若是读入一行为空行（包括一个回车符）则结束循环
if(s=="")break;
else
{
//sscanf与scanf相似，都是用于输入的，只是后者以屏幕(stdin)为输入源
//前者以固定字符串为输入源，默认以空格来分开字符串
sscanf(s.c_str(),"%s %s",s1,s2);//中间的空格要注意
m[s2]=s1;
}
}
//while(cin>>ss)
while(gets(ss))
{
s=ss;
//从映照容器中查找键值
p=m.find(s);
if(p!=m.end())
cout<<m[s]<<endl;
else
cout<<"eh"<<endl;
}
return 0;
}*/

//zju2744
/*#include< iostream>

#include< string>

using namespace std;

int main()

{

string str;

int n,sum,temp,k;

while(cin>>str)

{

n=str.length();

sum=0;

sum+=n;

for(int i=0;i< n-1;++i)

{

temp=i;

k=1;

while(str[temp+k]==str[temp-k]&&(temp+k)< n&&(temp-k)>=0)

{

++k;

++sum;

}

k=0;

if(str[temp]==str[temp+1])

{

while(str[temp+k+1]==str[temp-k]&&(temp+k+1)< n&&(temp-k)>=0)

{

++k;

++sum;

}

}

}

cout<< sum<< endl;

}

return 0;

}
*/

//STL
//有中心向外扩散方法
#include<iostream>
#include<string>

using namespace std;

int main(void)
{
char s[5000];
int p,i,Half,Left,Right,Count;
while(cin>>s)
{
i=strlen(s);
Count=0;//总回文数
//从左到右钉住最后一个
for(p=0;p<i-1;p++)
{
//若是子串是奇数个字符
Half=((i-1)-p)/2;
if(((i-1)-p)%2==0)
{
Left=p+Half-1;
Right=p+Half+1;
}
else
{
//若是子串是偶数个字符
Left=p+Half;
Right=p+Half+1;
}
while(Left>=p)
{
if(s[Left]==s[Right])
{
Count++;//发现第一我的字符串
Left--;
Right++;
}
else
{
//若是不相等，当即停止，由中心向外扩散
break;
}
}
}
//从右到左钉住第一个
for(p=i-2;p>=1;p--)
{
Half=p/2;
//若是子串是奇数个
if(p%2==0)
{
Left=Half-1;
Right=Half+1;
}
else
{
//若是子串是偶数个
Left=Half;
Right=Half+1;

}
while(Left>=0)
{
if(s[Left]==s[Right])
{
Count++;//发现一个回文数
Left--;
Right++;
}
else
{
//若是不相等当即停止，由中心向外扩散不可能会有回文串
break;
}
}
}
cout<<Count+i<<endl;
}
return 0;
}

//zju2818
#include<iostream>
#include<cmath>

using namespace std;

int main(void)
{
double B,N;
int A;
while(cin>>B>>N)
{
if(B==0 && N==0) break;
A=pow(B,1/N);
if(B-pow(A,N)<pow(A+1,N)-B)
cout<<A<<endl;
else
cout<<A+1<<endl;
}
return 0;

}

//zju2723
#include<iostream>
#include<vector>
#include<set>
#include<cmath>

using namespace std;

//创建全局向量，用来保存素数
vector<int>v;
//在全局内存中定义全局集合容器，又来保存半素数
//集合是平衡检索二叉树，搜索速度最快
set<int>s;
//创建[a,b]范围内素数表
void pt(int a,int b)
{
for(int i=a;i<=b;i++)
{
//2是素数，这里清楚2的倍数
if(i!=2 && i%2==0)continue;
//清除素数的倍数
for(int j=3;j*j<=i;j+=2)
{
if(i%j==0)goto RL;
}
//放入向量，不排序
v.push_back(i);
RL:continue;
}
}
int main(void)
{
//创建[2,500000]范围内的素数表
pt(2,500000);
//创建2~1000000范围内的半素数表，两个素数相乘
int i,j,p;
for(i=0;i<v.size();i++)
{
for(j=0;j<v.size();j++)
{
p=v[i]*v[j];
if(p<1000000)
s.insert(p);
else
break;
}
}
//读入数据，在半素数表中查找，看是否存在该表
int n;
set<int>::iterator it ;
while(cin>>n)
{
it=s.find(n);
if(it!=s.end())
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
}
return 0;
}

//zju2829
#include<iostream>
#include<map>

using namespace std;

//创建全局映照容器保存漂亮数，
//映照容器是黑白树，检索快
map<int,int>m;
int main(void)
{
//创建第1到100000个漂亮数
int i=0;
int p=0;
while(1)
{
i++;
if(i%3==0 || i%5==0)
{
p++;
if(p>100000)break;//到了第100000个漂亮数就截止
m[p]=i;
}
}
//读入数据，并从映照容器中检索
int n;
map<int,int>::iterator it;
while(cin>>n)
{
cout<<m[n]<<endl;
}
return 0;
}

//zju2876
//关于耗时问题cin比scanf大的多

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

int main(void)
{
vector<string>v;
//char ch[10];
string s;
int n;
cin>>n;//不理会总块数
int i,j;
while(cin>>n)
{
v.clear();
for(i=0;i<n;i++)
{
cin>>s;
//scanf("%s",&ch);
//s=ch;
v.push_back(s);
}
sort(v.begin(),v.end());//if have not this sdept,the following sdept will efficless
for(i=0;i<n-1;i++)
{
if(v[i+1].find(v[i])==0)
{
cout<<"NO"<<endl;
//printf("NO/n");
goto RL;
}
}
cout<<"Yes"<<endl;
//printf("Yes/n");

RL :
continue;
}
return 0;
}

//zju2420
//针对本题给出自公元2000年1月1日消失的天数，任务是：找出这天的日期和星期
//只有先建表较好，耗时少
/*#include<iostream>
#include<vector>

using namespace std;

//定义打印日期结构
struct Info
{
short int year;
short int month;
short int day;
short int week;
};

//定义向量来存储日期信息表
vector<Info>v;
bool RR(int year)
{
if((year%4==0 && year%100!=0) || (year%400==0))
return true;
else
return false;
}

int main(void)
{
int i,j,k;
int p=0;
Info info;
int flag=0;//闰年标志
int week=5;
//创建2000-01-01到9999-12-31的日期计日表
for(i=2000;i<=9999;i++)
{
flag=RR(i);
for(j=1;j<=12;j++)
{
for(k=1;k<=31;k++)
{
if(j==1 || j==3 || j==5 || j==7 || j==8 || j==10 || j==10 || j==12)
p++;
else if(j==4 || j==6 || j==9 || j==11 )
{
if(k!=31)p++;
else break;//跳到下一个月
}
else if (j==2)
{
if(flag)//是闰年
{
if(k!=30 || k!=31)p++;
else
break;//跳到下一个月
}
else//不是闰年
{
if(k!=29 && k!=30 && k!=31)p++;
else
break;//跳到下一个月
}
}
info.year=i;
info.month=j;
info.day=k;
week++;
if(week==8)week=1;
info.week=week;
v.push_back(info);
}

}
}
int n;
while(cin>>n)
{
if(n==-1)break;
else
{
cout<<v[n].year<<"-";
if(v[n].month<10)cout<<"0"<<v[n].month<<"-";
else cout<<v[n].month<<"-";
if(v[n].day<10)cout<<"0"<<v[n].day<<" ";
else cout<<v[n].day<<" ";
if(v[n].week==1)
cout<<"Monday"<<endl;
else if(v[n].week==2)
cout<<"Tuesday"<<endl;
else if(v[n].week==3)
cout<<"Wednesday"<<endl;
else if(v[n].week==4)
cout<<"Thursday"<<endl;
else if(v[n].week==5)
cout<<"Friday"<<endl;
else if(v[n].week==6)
cout<<"Saturday"<<endl;
else if (v[n].week==7)
cout<<"Sunday"<<endl;

}
}
return 0;
}
*/

#include< iostream>

#include< cstdio>

#include< math.h>

using namespace std;

int main()

{

int n,m;

int year,month,day;

bool flag;

char a[7][10]={"Saturday","Sunday","Monday","Tuesday","Wednesday","Thursday","Friday"};

while(cin>>n && n!=-1)

{

year=2000;

month=1;

day=1;

m = n;

while(n>=366) //deal with the year

{

if( year % 4 == 0) // leap year

{

if( year % 100 == 0 && year % 400 != 0)//notleap year

{

year ++;

n-=365;

}

else //leap year

{

year ++;

n -= 366;

}

}

else //not leap year

{

year++;

n-=365;

}

}

if( n == 365 ) //special instance

{

if( year % 4 != 0)

{

year ++ ;

n -= 365 ;

}

else if(year % 4== 0 && year % 100 == 0 && year % 400 !=0 )

{

year ++;

n -= 365;

}

}

if( year % 4 == 0 ) //judge the year,if leap or not

{

if( year % 100 == 0 && year % 400 != 0 )

{

flag=false;

}

else

flag=true;

}

else

flag=false;

while(n>=31) //deal with the month

{

if( (month < 8 && month % 2 != 0) || ( month > 7 && month % 2 == 0) ) //the big month have 31 days

{

month ++;

n -= 31;

}

else //not the big month

{

if(month==2) //the second month--the special month

{

if(flag) //leap year the second month have 29 days

{

month++;

n-=29;

}

else //not leap year the second month have 28 days

{

month ++;

n -= 28;

}

}

else //the small monthes except the second one

{

month ++;

n-= 30;

}

}

}

if( (month < 8 && month % 2 == 0)||( month > 7 && month %2 != 0 ) )//special instance --if the small monthes

{

if(month == 2)//if the second monthes

{

if( flag )

{

if( n >= 29)

{

month ++;

n -= 29;

}

}

else

{

if( n >= 28)

{

month ++ ;

n -= 28 ;

}

}

}

else //if not the second month

{

if(n==30)

{

month++;

n-=30;

}

}

}

day += n; //deal with the day

if( month < 10 && day <= 9) //deal with the OutPut

{

printf("%d-0%d-0%d ",year,month,day);

printf("%s/n",a[m%7]);

}

else if(month<10&&day>9)

{

printf("%d-0%d-%d ",year,month,day);

printf("%s/n",a[m%7]);

}

else if(month>=10&&day<=9)

{

printf("%d-%d-0%d ",year,month,day);

printf("%s/n",a[m%7]);

}

else

{

printf("%d-%d-%d ",year,month,day);

printf("%s/n",a[m%7]);

}

}

return 0;

}

//zju2476
#include<iostream>
#include<string>
#include<algorithm>
#include<map>

using namespace std;

int main(void)
{
string sa,sb,t;
int pa,pb,pc;
//定义映照容器
map<char,int>m;
m['0']=0;
m['1']=1;
m['2']=2;
m['3']=3;
m['4']=4;
m['5']=5;
m['6']=6;
m['7']=7;
m['8']=8;
m['9']=9;
//定义映照容器
map<int,char>mm;
mm[0]='0';
mm[1]='1';
mm[2]='2';
mm[3]='3';
mm[4]='4';
mm[5]='5';
mm[6]='6';
mm[7]='7';
mm[8]='8';
mm[9]='9';

int n,i,j;
//进位标记，0表示无进位，1表示有进位
int flag=0;
while(cin>>n)
{
if(n==0)break;
for(i=0;i<n;i++)
{
cin>>sb;
//删除"$"符号
sb.erase(0,1);//0 inplace begin,1 inplace end
//删除","符号
t=" ";
for(j=0;j<sb.size();j++)
{
if(sb[j]!=',')t+=sb[j];
}
sb=t;
//反转字符
reverse(sb.begin(),sb.end());
//删除"."符号
sb.erase(2,1);
//读入的是第一个字符串
if(i==0)sa=sb;
else
{
flag=0;
//把长的字符串放到sa里
if(sa.size()<sb.size())
{
t=sa;
sa=sb;
sb=t;
}

for(j=0;j<sa.size();j++)
{

pa=m[sa[j]];
if(j>=sb.size())pb=0;
else
pb=m[sb[j]];
pc=pa+pb+flag;
if(pc>9)
{
pc-=10;
flag=1;
}
else
flag=0;
sa[j]=mm[pc];
}
//若是有进位，则须要再加一位
if(flag==1)sa+="1";
}
}
//加入小数点和逗号
t=" ";
for(i=0;i<sa.size();i++)
{
t+=sa[i];
//加入'.'
if(i==1)t+=".";
//加入','
if(i!=1 && (i-1)%3==0 && i!=(sa.size()-1))
t+=",";

}
sa=t;
//反向输出结果
cout<<"$";
for(i=sa.size()-1;i>=0;i--)
cout<<sa[i];
cout<<endl;
}
return 0;

}

//zju2807

#include<iostream>
#include<vector>

using namespace std;

int main(void)
{
int n;
vector<int>v;
int i,num,sum;
cin>>n;//不用理会
while(cin>>n)
{

v.clear();
sum=0;
for(i=0;i<n;i++)//若是用v.size()会陷入死循环！
{
cin>>num;
v.push_back(num);
}
//计算可用来插入其余电器的插口数量
for(i=0;i<v.size();i++)
{

if(i!=(v.size()-1))//不是最后一个插板
sum+=v[i]-1;
else
sum+=v[i];

}
cout<<sum<<endl;
}
return 0;

}

/*
#include<iostream>

using std::cin;
using std::cout;
using std::endl;

int main(void)
{
int n;
int num;
int sum;
int a;
cin>>n;
while(n--)
{
cin>>num;
sum=0;
while( num--)
{

cin>>a;

sum+=a-1;
}
cout<<sum+1<<endl;

}
}*/

//zju2176

#include<iostream>

using namespace std;

int main(void)

{
int n,a,b,bb,sum,i;
while(cin>>n)
{
if(n==-1)break;
sum=0;
bb=0;
for(i=0;i<n;i++)
{
cin>>a>>b;
if(i==0)
{
bb=b;
sum+=a*bb;
}
else
{
sum+=a*(b-bb);
bb=b;
}
}
cout<<sum<<" miles"<<endl;

}
return 0;

}

//zju2388

#include<iostream>
#include<cmath>
using namespace std;

int main(void)
{
int n,x,y,a,b;
cin>>n;//不理会
while(cin>>a>>b)
{
//和比差小，不成立
if(a<b)
{
cout<<"Impossible"<<endl;
continue;
}
//分数只能是天然数
if((a+b)%2!=0 || abs(a-b)%2!=0)
{
cout<<"Impossible"<<endl;
continue;
}
x=abs((a+b)/2);
y=abs((a-b)/2);
if(x>y)
cout<<x<<" "<<y<<endl;
else
cout<<y<<" "<<x<<endl;
}
return 0;
}

//zju2830

#include<iostream>
#include<cmath>

using namespace std;

int main(void)
{
int m,n,d,sum=0;
while(cin>>n)
{
if(n==0)break;
sum=0;
while(1)
{
if(n==1)
{
cout<<sum<<endl;
break;
}
if(n==2)
{
cout<<sum+1<<endl;
break;
}
d=n/3;
m=n%3;
n=d+m;
sum+=d;
}
}
return 0;
}

//zju1760

//针对本题，先排序较好，数据输入到集合中，会自动排序，按从小到大的顺序
//采用黑白树，查询速度极快
#include<iostream>
#include<set>

using namespace std;

int main(void)
{
set<int>s;
set<int>::iterator it,itt;
int sum=0;
int n;
while(cin>>n)
{
if(n==-1)
break;
if(n!=0)
{
s.insert(n);
}
//一行已读完
if(n==0)
{
for(it=s.begin();it!=s.end();it++)
{
if(s.find(2*(*it))!=s.end())
{
sum++;
}
}
cout<<sum<<endl;
sum=0;
s.clear();
}
}
return 0;
}

//zju2840
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

int main(void)
{
string s,ss,left,right;
vector<string>v,end;
int m,n;
int i,j,k;
int p,q;
int c=0;
while(cin>>m)
{
//案例数量
c++;
if(c>1) cout<<endl;
//读入本案例全部文件名
v.clear();
for(i=0;i<m;i++)
{
cin>>s;
v.push_back(s);
}
//读入要查询的文件名
cin>>n;
for(i=0;i<n;i++)
{
//读入一个要查询的文件名
cin>>ss;
//初始化left和right
left="";
right="";
//把ss按*号两边分出left和right两部分
p=ss.find("*");
//区分出left
for(j=0;j<p;j++)
left+=ss[j];
//区分出right
for(i=p+1;j<ss.length();j++)
right+=ss[j];
//清空查询结果容器
end.clear();
//开始查找
for(j=0;j<v.size();j++)
{
//文件名长度不能小于查询串*号左边加右边的长度
if(v[j].size()<(left.size()+right.size()))
continue;
//比较查询串*号左边串
if(left.size()!=0)
{
if(v[j].find(left)!=0)continue;
}
//比较查询串*号右边串
if(right.size()!=0)
{
//反转
reverse(right.begin(),right.end());//节约时间
reverse(v[j].begin(),v[j].end());
if(v[j].find(right)!=0)
{
reverse(right.begin(),right.end());
reverse(v[j].begin(),v[j].end());
continue;

}
//从新反转过来
reverse(right.begin(),right.end());
reverse(v[j].begin(),v[j].end());
}
//符合条件的放入向量中
end.push_back(v[j]);
}
//输出一次查询结果
for(k=0;k<end.size();k++)
{
cout<<end[k];
if(k!=end.size()-1)
cout<<",";
else
cout<<endl;

}
//若是没有查出来，就打印“”
if(end.size()==0)
cout<<"FILE NOT　ＦＯＵＮＤ"<<endl;

}
return 0;
}
}

//zju2679

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

//结构体，用来保存输出数据的结构
struct Info{
int first;
int last;
int average;
};
//自定义比较函数
bool comp(const Info &a,const Info &b)
{
if(a.average!=b.average) return a.average>b.average;
}

int main(void)
{
Info info;
vector<Info>v;
int i,j;
int n;
int x,y,z,m;
cin>>n;//一向做风，不理会
while(cin>>n)
{
cin>>x>>y>>z;
m=x*1000+y*100+z*10;
v.clear();
for(i=1;i<10;i++)
{
for(j=0;j<10;j++)
{
if((i*10000+m+j)%n==0)
{
info.first=i;
info.last=j;
info.average=(i*10000+m+j)/n;
v.push_back(info);
}
}
}
//按兑换比例数由大到小排序
sort(v.begin(),v.end(),comp);
//输出数据
if(v.size()==0)
cout<<endl;
else
cout<<v[0].first<<" "<<v[0].last<<" "<<v[0].average<<endl;
}
return 0;
}

//zju2095
//建表防止超时

#include<iostream>
#include<cmath>

using namespace std;

int m[500000];

int main(void)
{
int i,j;
int n;
int d;
d=sqrt(500000.0);
//1是每一个数的约数
m[1]=0;//1没有除1外的约数
for(i=2;i<500001;i++)
{
m[i]=1;
}
//开始统计每一个数的约数和
for(i=2;i<=d;i++)
{
m[i*i]+=i;
for(j=i+1;j<=(500000/i);j++)
{
m[i*j]+=(i+j);
}
}
cin>>n;//不理会
while(scanf("%d",&n)!=EOF)
{
printf("%d/n",m[n]);
}
return 0;
}

 

//zju1698
//一个密码只要符合如下3种状况，便可
//一、字符串中至少含有一个元音aeiou
//二、字符串中不能包含3个连续元音或者3个连续辅音
//三、不能 包含两个相同的连续的字母，可是ee和oo除外
#include<iostream>
#include<string>

using namespace std;

int main(void)
{
string s;
int i,t;
int a,b;
while(cin>>s)
{
if(s=="end") break;
//条件1：必须含有一个元音
if(s.find("a")>s.size() && s.find("e")>s.size() && s.find("i")>s.size() && s.find("o")>s.size() && s.find("u")>s.size())
{
cout<<"<"<<s<<">"<<"is not acceptable." ;
continue;
}
//条件2：不能包含不能包含3个连续元音或者3个连续辅音
a=0;//连续元音个数
b=0;//连续辅音个数
for(i=0;i<s.size();i++)
{
//判断是元音仍是辅音字母
if(s[i]=='a' || s[i]=='e' || s[i]=='i' || s[i]=='o' || s[i]=='u' )
{
if(i==0) a=1;
else
{
if(s[i-1]=='a' || s[i-1]=='e' || s[i-1]=='i' || s[i-1]=='o' || s[i-1]=='u' )
{
a++;
b=0;
}
else
{
a=1;
b=0;
}
}
}
else
{
if(i==0)b=1;
else
{
if(s[i-1]!='a' || s[i-1]!='e' || s[i-1]!='i' || s[i-1]!='o' || s[i-1]!='u' )
{
b++;
a=0;
}
else
{
b=1;
a=0;
}
}
}
//出现3个连续的就终止
if(a==3 || b==3)
{
cout<<"<"<<s<<">"<<"is not acceptable."<<endl;
goto RL;

}
}
//条件3：不能包含两个连续字母，可是ee和oo除外
t=0;
for(i=0;i<s.size();i++)
{
if(i==0)t=1;
else if(s[i]=='e' || s[i]=='o' )
t=0;
else
{
if(s[i]==s[i-1]) t++;
else t=1;
}
if(t==2)
{
cout<<"<"<<s<<">"<<"is not aceptable."<<endl;
goto RL;

}
}
cout<<"<"<<s<<">"<<"is acceptable."<<endl;
RL:
continue;
}
return 0;
}

 

//zju2104

#include<iostream>
#include<string>
#include<map>

using namespace std;

int main(void)
{

map<string,int>m;
int n;
int i;
string s;
map<string,int>::iterator it, it2;
while(cin>>n)
{
if(n==0)break;
m.clear();
for(i=0;i<n;i++)
{
cin>>s;
if(m.find(s)!=m.end())
{
m[s]=m[s]+1;
}
else
m[s]=1;
}
it2=m.begin();
for(it=m.begin();it!=m.end();it++)
{
//注意，映照容器中，元素的键值为it->first
//元素映照值为it->second
if(it2->second<it->second)
it2=it;
}
cout<<it2->first<<endl;
}
return 0;
}

 

//zju1392
//Cipher text

//A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

//Plain text

//V W X Y Z A B C D E F G H I J K L M N O P Q R S T U

/*#include < stdio.h>

#include < string.h>

int main()

{

char str[200] ;

int i ;

while( gets(str) )

{

if(strcmp(str , "ENDOFINPUT" ) == 0 )

break ;

else if( strcmp(str ,"START" ) == 0 )

{

gets(str) ;

int len = strlen(str) ;

for( i = 0 ; i < len ; i ++ )

{

if( str[i] >='A' && str[i] <= 'Z' )

{

int c = (int)( str[i] -'A' + 21 ) % 26 ;

str[i] = c + 'A' ;

}

else

continue ;

}

printf("%s/n" , str) ;

}

else if(strcmp(str,"END" )== 0 )

continue ;

}

return 0 ;

}

///--------------------------------------------------

/* #include < stdio.h>

#include < string.h>

int main()

{

char str[20];

int i;

while(scanf("%s",str) !=EOF)

{

if(strcmp(str ,"ENDOFINPUT") == 0 )

return 0 ;

if(strcmp(str ,"START") == 0 )

{

while(scanf("%s",str) )

{

if(strcmp(str ,"END" ) == 0 )

break ;

int len = strlen(str) ;

for(i = 0 ; i < len ; i ++ )

{

if(str[i] == ',' )

{

printf("%c",',' ) ;

continue;

}

int c = (int)(str[i] -'A' + 21 ) % 26 ;

printf("%c",(char)(c+'A') ) ;

}

printf(" ") ;

}

}

}

return 0 ;

}*/

//STL

#include<iostream>
#include<map>
#include<string>

using namespace std;

int main(void)

{
string s;
char ss[200];
map<char,char>m;
m['A']='V';
m['B']='W';
m['C']='X';
m['D']='Y';
m['E']='Z';
m['F']='A';
m['G']='B';
m['H']='C';
m['I']='D';
m['J']='E';
m['K']='F';
m['L']='G';
m['M']='H';
m['N']='I';
m['O']='J';
m['P']='K';
m['Q']='L';
m['R']='M';
m['S']='N';
m['T']='O';
m['U']='P';
m['V']='Q';
m['W']='R';
m['X']='S';
m['Y']='T';
m['Z']='U';
int i;
while(cin.getline(ss,200))
{
s=ss;
if(s=="START")continue;//continue只结束本次循环，不会跳出整个循环
else if(s=="END")continue;
else if(s=="ENDOFINPUT")break;//而break会跳出整个循环
else
{
for(i=0;i<s.size();i++)
{
if(s[i]>='A' && s[i]<='Z')
{
cout<<m[s[i]];
}

else
cout<<s[i];
}
cout<<endl;
}
}

return 0;/
}

 

//zju1315
#include<iostream>
#include<string>
#include<vector>
#include<algorithm>

using namespace std;

//结构体，用来保存语句行及其包含的关键词个数
struct Info{
//字符行
string s;
//本字符行包含了关键词个数
int n;

};

//自定义比较函数，按包含的关键词的多少，由大到小排列
bool comp(const Info &a, const Info &b)
{
if(a.n!=b.n) return a.n>b.n;
else return a.n>b.n;
}

int main(void)

{
Info info;
int m,n;
char ss[71];
string s,t;
vector<string>v;//保存关键词
vector<Info>vv;//保存语句行结构体
int line=0;
int i,j,k;
unsigned int p;
while(cin>>m>>n)
{
v.clear();
vv.clear();
line++;//案例号
//读入关键词
for(i=0;i<m;i++)
{
cin>>ss;
s=ss;
v.push_back(s);
}
//忽略空行，这句相当重要
//由于cin读入单项后，仍然有一个回车符留在本行
//这样，直接转入cin.getline()读入一整行，第一次读入的是个空行
//cin.getline(ss,71);
//读入语句行
for(i=0;i<n;i++)
{
cin.getline(ss,71);
s=ss;
//为了实现不区分大小写比较
//先把本行都变成小写后再比较
for(j=0;j<s.size();j++)
{
//若是是大写字母则转化为小写字母
if(s[j]>=65 && s[j]<=90)
s[j]+=32;
}
info.n=0;
//搜索本行包含多少个关键词
for(j=0;j<v.size();j++)
{
for(k=0;k<s.size()-v[j].size();k++)
{
//取出一个子串
t="";
for(p=k;p<k+v[j].size();p++)
{
t+=s[p];

}
//若是子串在最开头，子串后一位置都不能是字母
if(k==0 && v[j]==t && (s[p]<'a' || s[p]>'z'))
info.n++;
//若是子串出如今这行的其余位置
//那么，子串的前一位置和后一位置不能是字母
else if(v[j]==t && (s[p]<'a' || s[p]>'z') && (s[k-1]<'a' || s[k-1]>'z'))
info.n++;
}
}
//字符串自己不能变，保持原样
info.s=ss;
vv.push_back(info);

}

sort(vv.begin(),vv.end(),comp);
cout<<"Excuse Set #"<<line<<endl;
for(i=0;i<vv.size();i++)
{
if(i!=0 && vv[i].n<vv[i-1].n)
break;
else
{
cout<<vv[i].s<<endl;
}
}
//一个案例后面输出一个空行
cout<<endl;
}
return 0;
}

//zju2109
//此题也能够设4个数组，解决问题

#include<iostream>
#include<vector>
#include<algorithm>

using namespace std;

//数据存取结构
struct Mouse
{
double J;//mouse food
double F;//cat food
double a;//cat food:mouse food
};

//自定义排序比较函数
bool Comp(const Mouse &d1, const Mouse &d2)
{
//按a从大到小排序
if(d1.a!=d2.a)return d1.a>d2.a;
//按f从大到小排序
else
return d1.F<d2.F;
}

int main(void)
{
vector<Mouse> v;
Mouse mouse;
int m,n,i;
cout.precision(3);
double sum;
while(cin>>m>>n)
{
if(m==-1 && n==-1) break;
v.clear();
sum=0.0;
//读入数据到向量中
for(i=0;i<n;i++)
{
cin>>mouse.J>>mouse.F;
mouse.a=mouse.J/mouse.F;
v.push_back(mouse);
}
sort(v.begin(),v.end(),Comp);
//计算交换数量
for(i=0;i<v.size();i++)
{
if(m>=v[i].F)//m是总共的猫食
{
sum+=v[i].J;
m-=v[i].F;
}
else
{
sum+=m*v[i].a;
break;
}
}
cout<<fixed<<sum<<endl;
}
return 0;
}

//zju2835
//幻方
#include<iostream>
#include<set>//不能含有相同的元素

using namespace std;

int main(void)

{
int matrix[9][9];
int line[9],column[9];//每行每列的和
int a,b;//两条对角线的和
set<int> s;
int n,j,i;
while(cin>>n)
{
if(n==0)break;
//读入矩阵
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
cin>>matrix[i][j];
}
}
s.clear();
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
//把每一个元素放到集合中，重复数据不会插入
//All the numbers in the input do not exceed 1000
//说明矩阵块中的元素的范围是1~1000，而不限于在1~n^2范围内
s.insert(matrix[i][j]);
}
}

if(s.size()!=n*n)
{
cout<<"NO"<<endl;
continue;
}
//计算每行、每列、两条对角线的和
a=0;b=0;
for(i=0;i<n;i++)
{
line[i]=0;
column[i]=0;
}
for(i=0;i<n;i++)
{
for(j=0;j<n;j++)
{
line[i]+=matrix[i][j];
column[j]+=matrix[i][j];
if(i==j)a+=matrix[i][j];
if(i+j==n-1)b+=matrix[i][j];
}
}

//判断每行、每列、两条对角线和是否相等
s.clear();
s.insert(b);
s.insert(a);
for(i=0;i<n;i++)
{
s.insert(line[i]);
s.insert(column[i]);
}
if(s.size()!=1)cout<<"No"<<endl;
else
cout<<"Yes"<<endl;
}
return 0;

}

 

//zju 2812
/*#include < stdio.h>

#include < string.h>

int main()

{

char Str[255];

while (gets(Str))

{

if(Str[0]=='#') break;

int sum=0;

int i=0;

int len=strlen(Str);

for(i=0;i< len;i++)

{

if(Str[i]!=' ')

{

sum=sum+(Str[i]-'A'+1)*(i+1);

}

else

{

sum=sum+(i+1)*0;

}

}

printf("%d/n",sum);

}

return 0;

}*/

//cin.get()版本，字符一个一个读入，可是不会忽略任何字符，对于回车符要单独处理
/*#include<iostream>

using namespace std;

int main(void)
{
char ch;
int i=1;
int sum=0;
//cin会忽略回车、空格、Tab跳格
//采用cin.get()一个一个读，就不会忽略任何字符
//也能够采用cin.getline()一行一行读入
while(cin.get(ch))
{
if(ch=='#') break;//读彻底部输入
if(ch!='/n') //没有读完一行
{
//空格字符不计算
if(ch!=' ') sum+=i*(ch-64);
i++;
}
if(ch=='/n')
{
cout<<sum<<endl;
sum=0;
i=1;
}
}

return 0;
}
*/

//cin.getline()版本

#include<iostream>

using namespace std;

int main(void)
{
char ch[256];
int i=1;
int sum=0;
while(cin.getline(ch,256))
{
if(ch[0]=='#') break;
for(int i=0;ch[i]!='/0';i++)//'/0'是空字符时间就是没有字符的意思
if(ch[i]!=' ') sum+=(i+1)*(ch[i]-64);
cout<<sum<<endl;
}
return 0;
}

C++笔记整理（2006.5.15）

昨天晚上听了RoBa讲的< STL in ACM >，感受收获颇丰。此前一直想本身看STL，但往往看到那玄之又玄的术语，如“容器”，“迭代器”等等，老是看得云里雾里，昨天听他一讲，有恍然大悟的感受。
把笔记整理了一下，之后便于之后查阅。

STL : Standard Template Library 标准模版库
//有人说：这是给C++中最激动人心的东西，取了一个最无聊的名字。

重要的概念：

容器(container):
…
//容器一词听上去很高深，其实说白了也是相似于对象的东西，但又和对象有点区别。
迭代器(iterator): 指针
//这个名词就更玄了，其实就是相似于指针的东西。

内部实现: 数组 // 就是没有固定大小的数组，vector直接翻译是向量的意思
vector
// T 就是数据类型，Alloc是关于内存的一个什么东西，RoBa没有仔细讲，通常是使用默认参数。
支持操做:
begin(), //取首个元素，返回一个iterator
end(), //取末尾（最后一个元素的下一个存储空间的地址）
size(), //就是数组大小的意思
clear(), //清空
empty(), //判断vector是否为空
[ ]  //很神奇的东东，能够和数组同样操做
//举例： vector a;   //定义了一个vector
//而后咱们就能够用a[i]来直接访问a中的第i + 1个元素！和数组的下标如出一辙！
push_back(), pop_back() //从末尾插入或弹出
insert() O(N)  //插入元素，O(n)的复杂度
erase() O(N)  //删除某个元素，O(n)的复杂度
能够用于数组大小不定且空间紧张的状况

Sample: TOJ1743 King’s Treasure  //这题若是直接开数组的话，须要开到一个240,000 * 240,000的二维数组
代码：
#include
#include
using namespace std;

vector a[240010]; //一个vector组成的数组！

int main()
{
 int cases,n,i,t,head,tail,src,pans;
 scanf("%d",&cases);
 while (cases--) {
  scanf("%d",&n);
  for (i = 1 ; i <= n ; i++) a[i].clear();
  for (i = 2 ; i <= n ; i++) {
   scanf("%d",&t);
   a[i].push_back(t);
   a[t].push_back(i);
  }
............

Iterator用法举例:
#include
#include
using namespace std;
int main()
{
 int n,i;
 vector vi; //相似于咱们定义一个数组，同 int vi[1000]; 但vector的大小是自动调整的
 vector ::iterator itr;  //两个冒号，很怪的定义方式，但就是这么定义的
 while (scanf("%d",&n) != EOF)
  vi.push_back(n);
 for (i = 0 ; i < vi.size() ; i++)
  printf("%d/n",vi[i]);
 for (itr = vi.begin() ; itr != vi.end() ; itr++) //也支持++操做
  printf("%d/n",*itr);
 return 0;
}

相似   //双端队列，两头都支持进出
支持push_front()和pop_front() 
是的精简版:)  //栈，只支持从末尾进出
支持push(), pop(), top()
是的精简版   //单端队列，就是咱们平时所说的队列，一头进，另外一头出
支持push(), pop(), front(), back()

内部实现: 双向链表  //做用和vector差很少，但内部是用链表实现
list
支持操做:
begin(), end(), size(), clear(), empty()
push_back(), pop_back()  //从末尾插入或删除元素
push_front(), pop_front()
insert() O(1)  //链表实现，因此插入和删除的复杂度的O(1)
erase() O(1)
sort() O(nlogn),不一样于中的sort
//不支持[ ]操做！

内部实现: 红黑树 //Red-Black Tree，一种平衡的二叉排序树
set //又是一个Compare函数，相似于qsort函数里的那个Compare函数，做为红黑树在内部实现的比较方式
insert() O(logn)
erase() O(logn)
find() O(logn) 找不到返回a.end()
lower_bound() O(logn) 查找第一个不小于k的元素
upper_bound() O(logn) 查找第一个大于k的元素
equal_range() O(logn) 返回pair

容许重复元素的

的用法及Compare函数示例:
struct SS {int x,y;};
struct ltstr {
 bool operator() (SS a, SS b)
 {return a.x < b.x;}  //注意，按C语言习惯，double型要写成这样：return a.x < b.x ? 1 : 0;
};
int main()
{
 set st;
 …
}

内部实现: pair组成的红黑树  //map中文意思：印射！！
map //就是不少pair 组成一个红黑树
insert() O(logn)
erase() O(logn)
find() O(logn) 找不到返回a.end()
lower_bound() O(logn) 查找第一个不小于k的元素
upper_bound() O(logn) 查找第一个大于k的元素
equal_range() O(logn) 返回pair
[key]运算符 O(logn) *** //这个..太猛了，怎么说呢，数组有一个下标，如a[i],这里i是int型的。数组能够认为是从int印射到另外一个类型的印射，而map是一个任意的印射，因此i能够是任何类型的！

容许重复元素, 没有[]运算符

Sample : TOJ 1378 Babelfish

Code: (0.4k)  //只有0.4K的代码....
#include
#include
#include
using namespace std;

map mp;

int main()
{
 char buf[100],s1[100],s2[100];
 while (gets(buf)) {
  if (strlen(buf) == 0) break;
  sscanf(buf,"%s%s",s1,s2);
  mp[(string)s2] = (string)s1; //这里的string s2，起到了相似于数组下标的做用！！
 }
 while (gets(buf)) {
  if (mp.find((string)buf) != mp.end())
   printf("%s/n",mp[(string)buf].c_str());  //mp[(string)buf]返回值是string类型，要转化成C语言能识别的字符串数组，加上.c_str()便可
  else printf("eh/n");
 }
return 0;
}

内部实现: 堆   //优先队列，听RoBa讲得，彷佛知道原理了，但不明白干什么用的
priority_queue
支持操做:
push() O(n)
pop() O(n)
top() O(1)
See also: push_heap(), pop_heap() … in

用法举例:
#include
#include
using namespace std;

priority_queue maxheap; //int最大堆

struct ltstr {   //又是这么个Compare函数，重载运算符？？？不明白为何要这么写...反正这个Compare函数对我来讲是至关之神奇。RoBa说了，照着这么写就是了。
 bool operator()(int a,int b)
 {return a > b;}
};
priority_queue ,ltstr> minheap; //int最小堆

内部实现: Hash表, of course ?//内部用哈希表实现的map，听说还不是如今的C++标准，但由于太好用了，因此估计迟早要成为标准的~
hash_map
重载HashFcn和EqualKey
支持操做:
insert(); O(1)
earse(); O(1)
[ ];   O(1)
示例：Again TOJ 1378 Babelfish
See also:

#include
#include  //??   //由于不是C++标准，因此要加.h
#include
using namespace std;

struct calc_hash {
 size_t operator()(string str) const {
  unsigned long h = 0;
  int i;
  for (i = 0 ; i < str.size() ; i++) {
   h <<= 5;　　　　　　　　　　　//这个就是哈希函数，从字符串到int的印射函数，能够去网上找
   h |= str[i] - 'a';
  }
  return (size_t)h; //h%M??      //h是否须要一个上限？听说系统会自动处理，没必要人工添加
 }
};

struct eqstr {
   bool operator()(string s1, string s2)
 {return s1 == s2;}
}; //本题此处可省略          //能够省略？？ 由于string做为一个经常使用类型，系统中有默认的比较函数，没必要本身写
int main() {
 hash_map hp;
 char buf[100],s1[20],s2[20];
 while (gets(buf)) {
  if (strlen(buf) == 0) break;
  sscanf(buf,"%s%s",s1,s2);
  hp[s2] = s1;
 }
 while (gets(buf)) {
  if (hp.find((string)buf) != hp.end())
   printf("%s/n",hp[(string)buf].c_str());
  else printf("eh/n");
 }
 return 0;
}

   //更神奇的东西！
1.sort()
void sort(RandomAccessIterator first, RandomAccessIterator last);
void sort(RandomAccessIterator first, RandomAccessIterator last, StrictWeakOrdering comp);
区间[first,last)
Quicksort,复杂度O(nlogn)
(n=last-first,平均状况和最坏状况)

用法举例:
1.从小到大排序(int, double, char, string, etc)
const int N = 5;
int main()
{
 int a[N] = {4,3,2,6,1};
 string str[N] = {“TJU”,”ACM”,”ICPC”,”abc”,”kkkkk”};
 sort(a,a+N);
 sort(str,str+N);
 return 0;
}
2.从大到小排序（须要本身写comp函数)
const int N = 5;
int cmp(int a,int b) {return a > b;}
int main()
{
 int a[N] = {4,3,2,6,1};
 sort(a,a+N,cmp);
 return 0;
}
3. 对结构体排序
struct SS {int first,second;};
int cmp(SS a,SS b) {
 if (a.first != b.first) return a.first < b.first;
 return a.second < b.second;
}

v.s. qsort() in C (平均状况O(nlogn)，最坏状况O(n^2))    //qsort中的cmp函数写起来就麻烦多了！
int cmp(const void *a,const void *b) {
 if (((SS*)a)->first != ((SS*)b)->first)
  return ((SS*)a)->first – ((SS*)b)->first;
 return ((SS*)a)->second – ((SS*)b)->second;
}
qsort(array,n,sizeof(array[0]),cmp);

sort()系列:
stable_sort(first,last,cmp); //稳定排序
partial_sort(first,middle,last,cmp);//部分排序
将前(middle-first)个元素放在[first,middle)中，其他元素位置不定
e.g.
int A[12] = {7, 2, 6, 11, 9, 3, 12, 10, 8, 4, 1, 5};
partial_sort(A, A + 5, A + 12);
// 结果是 "1 2 3 4 5 11 12 10 9 8 7 6".
Detail: Heapsort ,
O((last-first)*log(middle-first))

sort()系列:
partial_sort_copy(first, last, result_first, result_last, cmp);
//输入到另外一个容器，不破坏原有序列
bool is_sorted(first, last, cmp);
//判断是否已经有序
nth_element(first, nth, last, cmp);
//使[first,nth)的元素不大于[nth,last), O(N)
e.g. input: 7, 2, 6, 11, 9, 3, 12, 10, 8, 4, 1, 5
nth_element(A,A+6,A+12);
Output: 5 2 6 1 4 3 7 8 9 10 11 12

2. binary_search()
bool binary_search(ForwardIterator first, ForwardIterator last, const LessThanComparable& value);
bool binary_search(ForwardIterator first, ForwardIterator last, const T& value, StrictWeakOrdering comp);
在[first,last)中查找value，若是找到返回Ture,不然返回False
二分检索，复杂度O(log(last-first))
v.s. bsearch() in C

Binary_search()系列
itr upper_bound(first, last, value, cmp);
//itr指向大于value的第一个值(或容器末尾)
itr lower_bound(first, last, value, cmp);
//itr指向不小于valude的第一个值(或容器末尾)
pair equal_range(first, last, value, cmp);
//找出等于value的值的范围 O(2*log(last – first))
int A[N] = {1,2,3,3,3,5,8}
*upper_bound(A,A+N,3) == 5
*lower_bound(A,A+N,3) == 3

make_heap(first,last,cmp) O(n)
push_heap(first,last,cmp)  O(logn)
pop_heap(first,last,cmp)  O(logn)
is_heap(first,last,cmp)  O(n)
e.g:
vector vi;
while (scanf(“%d”,&n) != EOF) {
 vi.push_back(n);
 push_heap(vi.begin(),vi.end());
}

Others interesting:
next_permutation(first, last, cmp)
prev_permutation(first, last, cmp)
//both O(N)
min(a,b);
max(a,b);
min_element(first, last, cmp);
max_element(first, last, cmp);

Others interesting:
fill(first, last, value)
reverse(first, last)
rotate(first,middle,last);
itr unique(first, last);
//返回指针指向合并后的末尾处
random_shuffle(first, last, rand)

Some Others:More container: Rope, Slist, Bitset …More about iteratorMemory allocationFunction object