电话号码（C++实训题）

写在前面：仅为个人代码/总结，未必标准，仅供参考！如有错误，还望指出交流，共同进步！

电话号码

【问题描述】

Vasya有几本电话簿，记录了他的朋友们的电话号码，每一个朋友都可以有一或几个电话号码。

Vasya决定整理关于朋友电话号码的信息。给定n个字符串，来自于Vasya的电话簿中的条目。每一条都以朋友的姓名开头，然后跟着当前条目中的电话号码个数，然后是本人的电话号码。有可能几个相同的电话被记录在同一个记录中。

Vasya还认为，如果电话号码a是电话号码b的后缀（也就是说，号码b以a结尾），这两个号码被当作同一个电话号码，那么a被认为是无城市代码，它不应该被考虑。

输出整理后Vasya朋友的电话号码信息。有可能两个不同的人有相同的号码。如果一个人有两个电话号码x和y，x是y的后缀（即y以x结尾），则不输出x。

如果Vasya的电话簿中的某些朋友记录了几次，那么只需要记录一次。

【输入形式】

输入第一行一个整数n(1<=n<=20)，Vasya的电话簿上的条目数。

以下n行后面是描述中的格式记录。 朋友的姓名中不包含空字符，长度不超过10位，由小写英文字母组成。电话号码个数在1_{10之间。每个电话号码的长度范围在1}10之间，可以包含前导0。

【输出形式】

输出Vasya的朋友的电话号码的有序信息。首先输出电话簿中的朋友数目m。

接下来的m行，包含以格式“姓名 电话号码个数 电话号码1 … 电话号码k"的条目，号码间以空格分隔。每个记录包含当前朋友的所有电话号码。

每个条目输出按照姓名字母序进行排序，电话号码按照从小到大的顺序排列（注意电话号码：“1”<“01”、“12”<“012”，依此类推）

【样例输入】

4
ivan 3 123 123 456
ivan 2 456 456
ivan 8 789 3 23 6 56 9 89 2
dasha 2 23 789

【样例输出】

2
dasha 2 23 789
ivan 4 2 123 456 789

【示例代码】
主要运用了结构体的sort排序和字符串查找的方法

#include <bits/stdc++.h>
using namespace std;
struct Friend
{
    string name;
    vector <string> PN;
};
bool cmp(Friend p,Friend q)//实现名字字典序排序
{
    return p.name<q.name;
}
bool cmp1(string p,string q)//实现电话号码由短到长、由小到大排序
{
    if(p.length()!=q.length()) return p.length()<q.length();
    else
    {
        return p<q;
    }
}
int main()
{
    int n;
    cin>>n;
    Friend F[20];//也可使用vector容器
    int t=0;
    string s;
    while(n--)
    {
        string s;
        int num,pos=0;
        cin>>s>>num;
        if(t!=0)
        {
            bool b=false;
            for(int i=0;i<t;i++)
            {
                if(s==F[i].name)
                {
                    pos=i;
                    b=true;
                    break;
                }
            }
            if(b==false)
            {
                F[t].name=s;
                pos=t;
                t++;
            }
        }
        else
        {
            F[t].name=s;
            pos=t;
            t++;
        }
        string pn;
        while(num--)//数据输入，同一朋友的电话号码存在同一结构体的vector容器中
        {
            cin>>pn;
            F[pos].PN.push_back(pn);
        }
    }
    for(int i=0;i<t;i++)
    {
        bool flag=false,b=false;
        for(vector<string>::iterator it=F[i].PN.begin();it!=F[i].PN.end();it++)
        {
        	//注意下面的使用erase函数前后it指针的指向变化
            if(b==true)
            {
                if(flag==true) {it=F[i].PN.begin();}
                else
                {
                    it--;
                }
            }
            string s1=*it;
            vector<string>::iterator it1=it;
            it1++;
            for(vector<string>::iterator its=it1;its!=F[i].PN.end();its++)
            {
                flag=false;b=false;
                string s2=*its;
                if(s1==s2)
                {
                    if(its==F[i].PN.end()-1)
                    {
                        F[i].PN.pop_back();//思考此情况下用pop_back而不用erase的原因
                        break;
                    }
                    else {F[i].PN.erase(its);its--;continue;}
                }
                int len1=s1.length(),len2=s2.length();
                if(len2>len1)
                {
                    int po=s2.find(s1,len2-len1);//从第len2-len1个位置开始寻找，使寻找效率更高、查找更准确，下同
                    if(len2-len1==po)
                    {
                        if(it==F[i].PN.begin()) {flag=true;}
                        F[i].PN.erase(it);
                        b=true;
                        break;
                    }
                }
                else//同上
                {
                    int po=s1.find(s2,len1-len2);
                    if(len1-len2==po)
                    {
                        if(its==F[i].PN.end()-1)
                        {
                            F[i].PN.pop_back();
                            break;
                        }
                        else {F[i].PN.erase(its);its--;continue;}
                    }
                }
            }
        }
    }
    sort(F,F+t,cmp);//字典序排序
    cout<<t<<endl;
    for(int i=0;i<t;i++)
    {
        sort(F[i].PN.begin(),F[i].PN.end(),cmp1);//注意vector容器使用sort排序的用法
        cout<<F[i].name<<' '<<F[i].PN.size();
        for(vector<string>::iterator it=F[i].PN.begin();it!=F[i].PN.end();it++)
        {
            cout<<' '<<*it;
        }
        cout<<endl;
    }
    return 0;
}