C++面向对象程序设计 第九周 string类

一、Week9_01 Set

描述
现有一整数集（允许有重复元素），初始为空。我们定义如下操作：
add x 把x加入集合
del x 把集合中所有与x相等的元素删除
ask x 对集合中元素x的情况询问
对每种操作，我们要求进行如下输出。
add 输出操作后集合中x的个数
del 输出操作前集合中x的个数
ask 先输出0或1表示x是否曾被加入集合（0表示不曾加入），再输出当前集合中x的个数，中间用空格格开。
输入
第一行是一个整数n，表示命令数。0<=n<=100000。
后面n行命令，如Description中所述。
输出
共n行，每行按要求输出。
样例输入
7
add 1
add 1
ask 1
ask 2
del 2
del 1
ask 1
样例输出
1
2
1 2
0 0
0
2
1 0
提示
Please use STL’s set and multiset to finish the task

#include "stdafx.h"
#include<set>
#include<iostream>
using namespace std;

int main()
{
        multiset<int>sets;
        char cmd[20];//不可以写成 char* 类型
        int n,tmp;
        int flag = 0;
        cin >> n;
        while (n--)
        {
               cin >> cmd;
               switch (cmd[1])
               {
               case'd'://add
                       cin >> tmp;
                       sets.insert(tmp);
                       cout << sets.count(tmp) << endl;
                       break;
               case's'://ask
                       cin >> tmp;
                       flag = 0;
                       if ( sets.find(tmp)!=sets.end() )
                       {
                              flag = 1;
                       }
                       cout << flag <<" " ;
                       cout << sets.count(tmp) << endl;
                       break;
               case'e'://del
                       //multiset<int>::iterator i=sets.find(tmp);
                       cin >> tmp;
                       cout << sets.count(tmp) << endl;
                       while ( sets.find(tmp) !=  sets.end() )
                       {
                              sets.erase(tmp);
                       }
                       break;
               default:
                       break;
               }
        }
    return 0;
}

二、Week9_02 热血格斗场

描述
为了迎接08年的奥运会，让大家更加了解各种格斗运动，facer新开了一家热血格斗场。
格斗场实行会员制，但是新来的会员不需要交入会费，而只要同一名老会员打一场表演赛，证明自己的实力。
我们假设格斗的实力可以用一个正整数表示，成为实力值。
另外，每个人都有一个唯一的id，也是一个正整数。
为了使得比赛更好看，每一个新队员都会选择与他实力最为接近的人比赛，即比赛双方的实力值之差的绝对值越小越好，
如果有两个人的实力值与他差别相同，则他会选择比他弱的那个（显然，虐人必被虐好）。
不幸的是，Facer一不小心把比赛记录弄丢了，但是他还保留着会员的注册记录。
现在请你帮facer恢复比赛纪录，按照时间顺序依次输出每场比赛双方的id。
输入
第一行一个数n(0 < n <=100000)，表示格斗场新来的会员数（不包括facer）。
以后n行每一行两个数，按照入会的时间给出会员的id和实力值。
一开始，facer就算是会员，id为1，实力值1000000000。输入保证两人的实力值不同。
输出
N行，每行两个数，为每场比赛双方的id，新手的id写在前面。
样例输入
3
2 1
3 3
4 2
样例输出
2 1
3 2
4 2

#include "stdafx.h"
#include<map>
#include<iostream>
using namespace std;

int main()
{
        multimap<int, int> member;
        int n,id,power;
        member.insert(make_pair(1000000, 1));
        cin >> n;
        while (n--)
        {
               multimap<int, int>::iterator sp, tmp;//当新成员实力处于会员中两极时
               multimap<int, int>::iterator p1, p2;//普通新成员需要选择的前后两个对手
               cin >> id >> power;
               sp = member.insert(make_pair(power, id));//新成员的所在的迭代器位置
               if (sp == member.begin())//新成员实力最弱，只能选择之后的对手
               {
                       tmp = member.begin();
                       ++tmp;
                       cout << sp->second << " " << tmp->second << endl;
               }
               else if (sp == (-- member.end())) { //新成员实力最强，只能选择之前的对手
                       tmp = sp;
                       --tmp;
                       cout << sp->second << " " << tmp->second << endl;
               }
               else
               {
                       p1 = sp; --p1;//比新成员弱的那个
                       p2 = sp; ++p2;//比新成员强的那个
                       if ((sp->first - p1->first) > (p2->first - sp->first ))// 只有当比新手强的那个选手的实力差值小于弱的选手和新手的差值,才输出后者
                       //这个判断很神奇
                              cout << sp->second<<" " << p2->second << endl;
                       else
                              cout << sp->second << " " << p1->second << endl;
               }
        }
    return 0;
}

三、Week9_03 冷血格斗场1

描述
为了迎接08年的奥运会，让大家更加了解各种格斗运动，facer新开了一家冷血格斗场。
格斗场实行会员制，但是新来的会员不需要交入会费，而只要同一名老会员打一场表演赛，证明自己的实力。
我们假设格斗的实力可以用一个正整数表示，成为实力值，两人的实力值可以相同。
另外，每个人都有一个唯一的id，也是一个正整数。
为了使得比赛更好看，每一个新队员都会选择与他实力最为接近的人比赛，即比赛双方的实力值之差的绝对值越小越好，
如果有多个人的实力值与他差别相同，则他会选择id最小的那个
不幸的是，Facer一不小心把比赛记录弄丢了，但是他还保留着会员的注册记录。
现在请你帮facer恢复比赛纪录，按照时间顺序依次输出每场比赛双方的id。
输入
第一行一个数n(0 < n <=100000)，表示格斗场新来的会员数（不包括facer）。
以后n行每一行两个数，按照入会的时间给出会员的id和实力值。
一开始，facer就算是会员，id为1，实力值1000000000。
输出
N行，每行两个数，为每场比赛双方的id，新手的id写在前面。
样例输入
3
2 3
3 1
4 2
样例输出
2 1
3 2
4 2

#include "stdafx.h"
#include<map>
#include<cmath>
#include<iostream>
using namespace std;
multimap<int, int> member;
void toErase(multimap<int, int>::iterator p1, multimap<int, int>::iterator p2) {  //为了不判断id,大小，将相同power但id大的成员删去
        if (p1->first == p2->first)
        {
               if (p1->second > p2->second)
                       member.erase(p1);
               else
                       member.erase(p2);
        }
        
}
int main()
{

        int n, id, power;
        member.insert(make_pair(1000000, 1));
        cin >> n;
        while (n--)
        {
               cin >> id >> power;
               multimap<int, int>::iterator sp = member.insert(make_pair(power,id));//当新成员
               multimap<int, int>::iterator Lp = sp; --Lp;//普通新成员需要选择的前后两个对手
               multimap<int, int>::iterator Hp = sp; ++Hp;
               if (sp == member.begin())
               {
                       cout << id << " " << Hp->second;
                       toErase(sp,Hp);
               }
               else if(sp == member.end())
               {
                       cout << id << " " << Lp->second;
                       toErase(sp, Lp);
               }
               else //由于之前都把相同的power成员删除，所以与其power相同的只有一个
               {
                       int dL = abs(sp->first - Lp->first);
                       int dH = abs(Hp->first - sp->first);
                       if (dL < dH || dL == dH && Lp->second < Hp->second) //距离相等时，id小的输出
                              cout << id << " " << Lp->second;
                       else if (dL > dH || dL == dH && Lp->second > Hp->second)
                              cout << id << " " << Hp->second;
               }

        }
        return 0;
}

四、Week9_03 冷血格斗场2

不同于前一种的是：这种方法并没有删除相同的power的成员，而是将相同power的成员的id放入set里，最小id的用begin()来获得

#include "stdafx.h"
#include<iostream>
#include<map>
#include<set>
#include<algorithm>
#include<cmath>

using namespace std;
map<int,set<int> > member; //写类型名
int main()
{
        int n;
        int id, power;
        set<int> mid;
        mid.insert(1);
        member.insert(make_pair(10000000, mid));//这样实例化，每个member里的set都是独立的。
        cin >> n;
        while ( n --)
        {
               cin >> id >> power;
               map<int, set<int>>::iterator Lp=member.lower_bound(power);
               if (Lp == member.end()) //所有的成员都比power小：新成员的power最大
               {
                       cout << id << " " << *(member.rbegin()->second.begin());//second就是set,相同power中id最小的那个。注意是指针

               }
               else if (Lp == member.begin())//所有的成员都比power大：新成员的power最小
               {
                       cout << id << " " << *(member.begin()->second.begin());
               }
               else {
                       if (Lp ->first == power) //lower_bound 放回 [begin,it) 其中 it是大于等于 power的.
                       {
                              cout << id << " " << *(Lp->second.begin());
                       }
                       else {
                              map<int, set<int>>::iterator p = Lp;
                              --p;//lower_bound 放回 [begin,it) 其中 it是大于等于 power的
                              int dL = abs(power- p->first);
                              int dH = abs(Lp->first - power);
                              if (dL > dH)
                              {
                                      cout << id << " " << *(p->second.begin());
                              }
                              else if (dH < dL)
                              {
                                      cout << id << " " << *(Lp->second.begin());
                              }
                              else {
                                      cout << id << " " << min(*(p->second.begin()), *(Lp->second.begin())); //当距离相同时，比较两者中id最小的那个
                              }
                       }
               }

               member[power].insert(id);//map里的 []返回的是 second的引用，也就是等同于 set.insert
        }
    return 0;
}

五、Week9_04 编程填空：数据库内的学生信息

描述
程序填空，使得下面的程序,先输出
(Tom,80),(Tom,70),(Jone,90),(Jack,70),(Alice,100),
(Tom,78),(Tom,78),(Jone,90),(Jack,70),(Alice,100),
(70,Jack),(70,Tom),(80,Tom),(90,Jone),(100,Alice),
(70,Error),(70,Error),(80,Tom),(90,Jone),(100,Alice),

---

然后，再根据输入数据按要求产生输出数据
输入
输入数据的每一行，格式为以下之一：
A name score
Q name score
name是个不带个空格的字符串，长度小于 20
score是个整数，能用int表示
A name score 表示往数据库中新增一个姓名为name的学生，其分数为score。开始时数据库中一个学生也没有。
Q name 表示在数据库中查询姓名为name的学生的分数
数据保证学生不重名。
输入数据少于200,000行。
输出
对于每个查询，输出学生的分数。如果查不到，则输出 “Not Found”
样例输入
A Tom1 30
A Tom2 40
Q Tom3
A Tom4 89
Q Tom1
Q Tom2
样例输出
(Tom,80),(Tom,70),(Jone,90),(Jack,70),(Alice,100),
(Tom,78),(Tom,78),(Jone,90),(Jack,70),(Alice,100),
(70,Jack),(70,Tom),(80,Tom),(90,Jone),(100,Alice),
(70,Error),(70,Error),(80,Tom),(90,Jone),(100,Alice),

---

Not Found
30
40
提示

1. 编写模板的时候，连续的两个 “>”最好要用空格分开，以免被编译器看作是 ">>"运算符。VS可能无此问题，但是Dev C++和服务器上的编译环境会有这个问题。
   比如 vector<vector> 有可能出错，要改成 vector<vector >
2. 在模板中写迭代器时，最好在前面加上 typename关键字，否则可能会编译错。VS可能无此问题，但是Dev C++和服务器上的编译环境会有这个问题。

//轮子不用自己造，继承就好
#include "stdafx.h"
#include <iostream>
#include <string>
#include <map>
#include <iterator>
#include<functional>  //VS 里调用 greater需要包含。
#include <algorithm> //定义了 less
using namespace std;
// 在此处补充你的代码
template <typename Key,typename T,typename Pred = greater<Key> >
class MyMultimap :public multimap<Key,T,Pred>{ //神一样的继承！！！！！
public:      //虽然不起眼，还是很重要的public
        void Set(Key k, T v) {
               typename multimap<Key, T, Pred>::iterator l = multimap<Key, T, Pred>::lower_bound(k);//调用基类的lower_bound 函数 需要加上基类的名字.基类名：multimap<Key, T, Pred>
               //在模板中写迭代器时，最好在前面加上 typename关键字，否则可能会编译错。VS可能无此问题，但是Dev C++和服务器上的编译环境会有这个问题。
               typename multimap<Key, T, Pred>::iterator u = multimap<Key, T, Pred>::upper_bound(k);
               for ( ;l!=u ;++l )
                       l->second = v;
        }
};
template <class Key,class T>  //需要重载输出pair类
ostream & operator <<( ostream & o, const pair<Key, T> & p) {
        o << "("<<p.first << "," << p.second << ")" ;
        return o;
}
// 在此处补充你的代码
struct Student
{
        string name;
        int score;
};
template <class T>
void Print(T first, T last) {
        for (; first != last; ++first)
               cout << *first << ",";
        cout << endl;
}
int main()
{

        Student s[] = { { "Tom",80 },{ "Jack",70 },
        { "Jone",90 },{ "Tom",70 },{ "Alice",100 } };
        MyMultimap<string, int> mp;
        for (int i = 0; i<5; ++i)
               mp.insert(make_pair(s[i].name, s[i].score));
        Print(mp.begin(), mp.end()); //按姓名从大到小输出
        mp.Set("Tom", 78); //把所有名为"Tom"的学生的成绩都设置为78
        Print(mp.begin(), mp.end());
        MyMultimap<int, string, less<int> > mp2;
        for (int i = 0; i<5; ++i)
               mp2.insert(make_pair(s[i].score, s[i].name));
        Print(mp2.begin(), mp2.end()); //按成绩从小到大输出
        mp2.Set(70, "Error");          //把所有成绩为70的学生，名字都改为"Error"
        Print(mp2.begin(), mp2.end());
        cout << "******" << endl;
        mp.clear();
        string name;
        string cmd;
        int score;
        while (cin >> cmd) {
               if (cmd == "A") {
                       cin >> name >> score;
                       if (mp.find(name) != mp.end()) {
                              cout << "erroe" << endl;
                       }
                       mp.insert(make_pair(name, score));
               }
               else if (cmd == "Q") {
                       cin >> name;
                       MyMultimap<string, int>::iterator p = mp.find(name);
                       if (p != mp.end()) {
                              cout << p->second << endl;
                       }
                       else {
                              cout << "Not Found" << endl;
                       }
               }
        }
        return 0;
}