C++博客-心如止水-随笔分类-题目分类：排序

UVa 10152 ShellSort

lee1r — Tue, 06 Sep 2011 12:27:00 GMT

代码第23行本意是r[j]=i，不小心写成了r[i]=j，输出一个序列，找到了规律：从后向前找升序的第一个值，把它及其它之前的全部输出……
比如对于第二个样例得到1，6，3，2，4，5，7，8，9。从后向前第一个升序是3，所以输出3，6，1。
以下是我的代码（囧）：

1 #include <iostream>
2 #include <string>
3 #include <cstdio>
4 using namespace std;
5
6 const int kMaxn = 1007;
7
8 int n, r[kMaxn];
9 string init[kMaxn], aim[kMaxn];
10
11 void Input ()
12 {
13     scanf ( "%d", &n );
14     getchar();
15     for ( int i = 1; i <= n; i++ )
16         getline ( cin, init[i] );
17     for ( int i = 1; i <= n; i++ )
18     {
19         getline ( cin, aim[i] );
20         for ( int j = 1; j <= n; j++ )
21             if ( aim[i] == init[j] )
22             {
23                 r[i] = j;
24                 break;
25             }
26     }
27     for ( int i = 1; i <= n; i++ )
28         printf ( "%d ", r[i] );
29     puts ( "" );
30 }
31
32 void Solve ()
33 {
34     int pos = -1;
35     for ( int i = n; i >= 2; i-- )
36         if ( r[i-1] > r[i] )
37         {
38             pos = i-1;
39             break;
40         }
41     if ( pos != -1)
42     {
43         for ( int i = pos; i >= 1; i-- )
44             printf ( "%s\n", aim[i].c_str() );
45     }
46 }
47
48 int main ()
49 {
50 #ifndef ONLINE_JUDGE
51     freopen ( "data.in", "r", stdin );
52 #endif
53
54     int T;
55     scanf ( "%d", &T );
56     while ( T-- )
57     {
58         Input ();
59
60         Solve ();
61
62         printf ( "\n" );
63     }
64
65     return 0;
66 }
67

lee1r 2011-09-06 20:27 发表评论

POJ 2388 Who's in the Middle

lee1r — Thu, 04 Aug 2011 12:36:00 GMT

本来想做DP专题，队长让我去补基础知识，我就来做POJ分类了……
排序。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/4 20:20:15
* File Name: poj2388.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
const double kEps(1e-11);
typedef long long int64;
typedef unsigned long long uint64;

int n,r[10007];

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d",&n)==1)
    {
        for(int i=1;i<=n;i++)
            scanf("%d",&r[i]);
        sort(r+1,r+n+1);
        printf("%d\n",r[Half(n+1)]);
    }

    return 0;
}

lee1r 2011-08-04 20:36 发表评论

UVa 10057 A mid-summer night's dream.

lee1r — Fri, 20 May 2011 08:30:00 GMT

题目名字很好听，仲夏夜之梦。

#include<vector>
#include<algorithm>
#include<cstdio>
using namespace std;

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif

    int n;
    while(scanf("%d",&n)==1)
    {
        vector<int> r;
        for(int i=0;i<n;i++)
        {
            int t;
            scanf("%d",&t);
            r.push_back(t);
        }

        sort(r.begin(),r.end());

        int ansa,ansb,ansc;
        if(n&1)
        {
            ansa=r[n>>1];
            ansb=upper_bound(r.begin(),r.end(),r[n>>1])-lower_bound(r.begin(),r.end(),r[n>>1]);
            ansc=1;
        }
        else
        {
            ansa=r[(n>>1)-1];
            ansb=upper_bound(r.begin(),r.end(),r[(n>>1)-1])-lower_bound(r.begin(),r.end(),r[(n>>1)-1]);
            if(r[(n>>1)-1]!=r[n>>1])
                ansb+=upper_bound(r.begin(),r.end(),r[(n>>1)])-lower_bound(r.begin(),r.end(),r[(n>>1)]);
            ansc=r[n>>1]-r[(n>>1)-1]+1;
        }

        printf("%d %d %d\n",ansa,ansb,ansc);
    }

    return 0;
}

这道题目重点在于中位数～中位数一定可以使得最终结果最小。
以下是我的代码：

lee1r 2011-05-20 16:30 发表评论

UVa 10132 File Fragmentation

lee1r — Fri, 20 May 2011 07:44:00 GMT

题目大意：一些相同的01串被打碎成两半，现在给出这些打碎了之后的串，要求求出原串。
首先，原串的长度一定是打碎了之后的串中最长的长度加上最短的长度。设打碎之后的串中最长串组成集合S，最短串组成集合T，那么原串肯定为ST或TS中的某种。由于S、T中元素个数必定小于等于2，所以可能的结果最多只有8种。枚举这8种结果，然后检测是否符合要求即可。
检测的时候，对于某个长度为L的串，要快速检索到长度为（maxlength+minlength-L）的串，使用multimap可以很方便地做到。
以下是我的代码：

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

bool cmp(const string &a,const string &b)
{
    return (a.size()<b.size() ||(a.size()==b.size() && a<b));
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif

    int T;
    cin>>T;
    cin.get();
    cin.get();
    bool first(true);
    while(T--)
    {
        int minl(0x7f7f7f7f),maxl(0);
        vector<string> a;
        string t;
        while(getline(cin,t) && !t.empty())
        {
            a.push_back(t);
            minl=min(minl,(int)(t.size()));
            maxl=max(maxl,(int)(t.size()));
        }

        sort(a.begin(),a.end(),cmp);
        a.erase(unique(a.begin(),a.end()),a.end());

        multimap<int,string> r;
        for(int i=0;i<a.size();i++)
            r.insert(make_pair(a[i].size(),a[i]));

        string ans;
        multimap<int,string>::iterator
            ibegin=r.begin(),
            iend=r.upper_bound(minl),
            jend=r.end(),
            jbegin=r.lower_bound(maxl);
        for(multimap<int,string>::iterator i=ibegin;i!=iend;i++)
            for(multimap<int,string>::iterator j=jbegin;j!=jend;j++)
            {
                string now(i->second+j->second);
                bool success(true);
                for(multimap<int,string>::iterator k=r.begin();k!=r.end();k++)
                {
                    multimap<int,string>::iterator
                        pbegin=r.lower_bound(minl+maxl-k->first),
                        pend=r.upper_bound(minl+maxl-k->first);
                    bool can(false);
                    for(multimap<int,string>::iterator l=pbegin;l!=pend;l++)
                    {
                        if(k->second+l->second==now || l->second+k->second==now)
                            can=true;
                    }
                    if(!can)
                    {
                        success=false;
                        break;
                    }
                }
                if(success)
                    ans=now;

                now=j->second+i->second;
                success=true;
                for(multimap<int,string>::iterator k=r.begin();k!=r.end();k++)
                {
                    multimap<int,string>::iterator
                        pbegin=r.lower_bound(minl+maxl-k->first),
                        pend=r.upper_bound(minl+maxl-k->first);
                    bool can(false);
                    for(multimap<int,string>::iterator l=pbegin;l!=pend;l++)
                    {
                        if(k->second+l->second==now || l->second+k->second==now)
                            can=true;
                    }
                    if(!can)
                    {
                        success=false;
                        break;
                    }
                }
                if(success)
                    ans=now;
            }

        if(first)
            first=false;
        else
            cout<<endl;
        cout<<ans<<endl;
    }

    return 0;
}

lee1r 2011-05-20 15:44 发表评论

UVa 10905 Children's Game

lee1r — Fri, 20 May 2011 03:32:00 GMT

题目大意：给出n（n<=50）个数字，n个数字按某种顺序连接，要求最终得到的数字最大。
由于不论怎么连接，最终得到数字的长度总是相同的，所以比较大小的方式，相当于比较数字对应的字符串的字典序大小。于是可以把输入中的n个数字看作字符串。
考虑只有两个字符串的情况，设为a和b，结果要么是a+b，要么是b+a（'+'表示字符串连接）。于是，如果a+b>b+a，那么a应该排在b的前面。所以只需要按照这种规则给n个字符串排序即可。
做这道题的时候不是在家，这台电脑里面又没有装g++什么的，写完代码之后没有编译运行直接提交的，于是AC。
以下是我的代码：

#include<iostream>
#include<string>
#include<algorithm>
#include<cstdio>
using namespace std;
const int kMaxn(57);

bool cmp(const string &a,const string &b)
{
    return (a+b>b+a);
}

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif

    int n;
    while(cin>>n && n)
    {
        string r[kMaxn];
        for(int i=1;i<=n;i++)
            cin>>r[i];

        sort(r+1,r+n+1,cmp);

        for(int i=1;i<=n;i++)
            cout<<r[i];
        cout<<endl;
    }

    return 0;
}

lee1r 2011-05-20 11:32 发表评论

UVa 10487 Closest Sums

lee1r — Thu, 19 May 2011 11:34:00 GMT

题目大意：给出n个数字，给出一个数字x，求出n个数字中哪两个数字的和与x最接近。
我的做法是这样的，把n个数字两两求和的结果存在数组里面，排序，去重（这一步无所谓）。每当给出一个x的时候，二分查找大于等于x的第一个数字，和小于x的最后一个数字。比较即可得出结果。
以下是我的代码：

#include<vector>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
using namespace std;

int main()
{
    #ifndef ONLINE_JUDGE
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    #endif

    int case_num(0),n;
    while(scanf("%d",&n)==1 && n)
    {
        vector<int> a,r;
        for(int i=0;i<n;i++)
        {
            int t;
            scanf("%d",&t);
            a.push_back(t);
            for(int j=0;j<i;j++)
                r.push_back(a[j]+t);
        }

        sort(r.begin(),r.end());
        r.erase(unique(r.begin(),r.end()),r.end());

        /*
        for(int i=0;i        {
            if(i!=0)
                printf(" ");
            printf("%d",r[i]);
        }
        printf("\n");
        //*/
        case_num++;
        printf("Case %d:\n",case_num);

        int m;
        scanf("%d",&m);
        for(int i=1;i<=m;i++)
        {
            int x;
            scanf("%d",&x);

            int dist(0x7f7f7f7f),ans;
            vector<int>::iterator lpos(lower_bound(r.begin(),r.end(),x));
            if(lpos!=r.end())
            {
                int t=*lpos;
                if(dist>abs(t-x))
                {
                    dist=abs(t-x);
                    ans=t;
                }
            }
            if(lpos!=r.begin())
            {
                int t=*(lpos-1);
                if(dist>abs(t-x))
                {
                    dist=abs(t-x);
                    ans=t;
                }
            }

            printf("Closest sum to %d is %d.\n",x,ans);
        }
    }
}

lee1r 2011-05-19 19:34 发表评论

UVa 755 487--3279

lee1r — Mon, 11 Apr 2011 15:53:00 GMT

注意输出空格时不能使用ends，否则会WA。就在我对这题感到无比绝望的时候，把ends改成" "，AC。
用map很轻松就可以完成该题。
以下是我的代码：

#include<iostream>
#include<string>
#include<map>
#include<algorithm>
#include<cstdio>
#include<cctype>
using namespace std;
const char kTable[]="2223334445556667777888999";

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int T;
    cin>>T;
    bool first_output(true);
    while(T--)
    {
        int n;
        cin>>n;
        map<string,int> r;
        for(int i=1;i<=n;i++)
        {
            string t;
            cin>>t;
            t.erase(remove(t.begin(),t.end(),'-'),t.end());
            for(int j=0;j<t.size();j++)
                if(!isdigit(t[j]))
                    t[j]=kTable[t[j]-'A'];
            t.insert(3,"-");
            r[t]++;
        }
        if(first_output)
            first_output=false;
        else
            cout<<endl;
        bool found(false);
        for(map<string,int>::iterator i=r.begin();i!=r.end();i++)
            if(i->second>1)
            {
                cout<<i->first<<" "<<i->second<<endl;
                found=true;
            }
        if(!found)
            cout<<"No duplicates."<<endl;
    }

    return 0;
}

lee1r 2011-04-11 23:53 发表评论

UVa 10194 Football (aka Soccer)

lee1r — Mon, 11 Apr 2011 04:02:00 GMT

还不错，一次AC。读入数据时用cin/stringin比较方便处理，输出时则换用printf。另外注意多关键字排序，觉得这题还是使用多次排序比较方便编程。
以下是我的代码：

#include<iostream>
#include<sstream>
#include<vector>
#include<string>
#include<algorithm>
#include<cstdio>
#include<cctype>
using namespace std;

struct Type
{
    Type()
    {
        name_="";
        score_=win_=lose_=draw_=goal_=all_goal_=game_=0;
    }
    string name_;
    int score_,win_,lose_,draw_,goal_,all_goal_,game_;
};

int n;
vector<Type> r;

int Team(const string &team_name)
{
    for(int i=0;i<n;i++)
        if(r[i].name_==team_name)
            return i;
}

bool cmp_1(const Type &a,const Type &b)
{
    string aa(a.name_),bb(b.name_);
    for(int i=0;i<aa.size();i++)
        aa[i]=tolower(aa[i]);
    for(int i=0;i<bb.size();i++)
        bb[i]=tolower(bb[i]);
    return aa<bb;
}
bool cmp_2(const Type &a,const Type &b)
{
    return a.game_<b.game_;
}
bool cmp_3(const Type &a,const Type &b)
{
    return a.all_goal_>b.all_goal_;
}
bool cmp_4(const Type &a,const Type &b)
{
    return a.goal_>b.goal_;
}
bool cmp_5(const Type &a,const Type &b)
{
    return a.win_>b.win_;
}
bool cmp_6(const Type &a,const Type &b)
{
    return a.score_>b.score_;
}

int main()
{
    int T;
    cin>>T;
    getchar();
    bool first(true);
    while(T--)
    {
        string game_name;
        getline(cin,game_name);
        cin>>n;
        getchar();
        r.resize(n);
        for(int i=0;i<n;i++)
            getline(cin,r[i].name_);
        int g;
        cin>>g;
        getchar();
        string s;
        for(int i=0;i<g;i++)
        {
            getline(cin,s);
            int pos_1(s.find('#')),pos_2(s.rfind('#'));
            string team_1(s.substr(0,pos_1)),team_2(s.substr(pos_2+1));
            istringstream sin(s.substr(pos_1+1));
            int goal_1,goal_2;
            sin>>goal_1;
            char ch;
            sin>>ch;
            sin>>goal_2;
            int team_1_num(Team(team_1)),team_2_num(Team(team_2));
            r[team_1_num].all_goal_+=goal_1;
            r[team_1_num].goal_+=(goal_1-goal_2);
            r[team_1_num].game_++;
            r[team_2_num].all_goal_+=goal_2;
            r[team_2_num].goal_+=(goal_2-goal_1);
            r[team_2_num].game_++;
            if(goal_1>goal_2)
            {
                r[team_1_num].score_+=3;
                r[team_1_num].win_++;
                r[team_2_num].lose_++;
            }
            else if(goal_1<goal_2)
            {
                r[team_2_num].score_+=3;
                r[team_2_num].win_++;
                r[team_1_num].lose_++;
            }
            else
            {
                r[team_1_num].score_++;
                r[team_2_num].score_++;
                r[team_1_num].draw_++;
                r[team_2_num].draw_++;
            }
        }

        sort(r.begin(),r.end(),cmp_1);
        stable_sort(r.begin(),r.end(),cmp_2);
        stable_sort(r.begin(),r.end(),cmp_3);
        stable_sort(r.begin(),r.end(),cmp_4);
        stable_sort(r.begin(),r.end(),cmp_5);
        stable_sort(r.begin(),r.end(),cmp_6);

        if(first)
            first=false;
        else
            cout<<endl;
        cout<<game_name<<endl;
        for(int i=0;i<n;i++)
            printf("%d) %s %dp, %dg (%d-%d-%d), %dgd (%d-%d)\n",i+1,r[i].name_.c_str(),r[i].score_,r[i].game_,r[i].win_,r[i].draw_,r[i].lose_,r[i].goal_,r[i].all_goal_,r[i].all_goal_-r[i].goal_);

        fill_n(r.begin(),n,Type());
    }

    return 0;
}

lee1r 2011-04-11 12:02 发表评论

UVa 123 Searching Quickly

lee1r — Sun, 10 Apr 2011 17:50:00 GMT

题目很简单：给出一系列要忽略的单词，这些单词以外的单词都看作关键字。然后给出一些标题，找出标题中所有的关键字，然后按这些关键字的字典序给标题排序。注意两点：相同关键字出现在不同标题中，出现在输入较前位置的标题排在前面（从样例数据可以看出，而且multimap也正是这么做的）；同一个关键字在一个标题中出现多次，关键字位于较前位置的排在前面（从左向右扫描的话就没有问题）。
STL中、神器！用起来很方便，只是担心我再这么用下去Qsort、Bsearch什么的自己都不会写了～
以下是我的代码：

#include<iostream>
#include<string>
#include<map>
#include<set>
#include<cstdio>
#include<cctype>
using namespace std;
const int kMaxn(207);
const string kSign("::");

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    set<string> ignore;
    string t;
    while(getline(cin,t) && t!=kSign)
        ignore.insert(t);
    multimap<string,string> r;
    while(getline(cin,t))
    {
        for(int i=0;i<t.size();i++)
            t[i]=tolower(t[i]);
        for(int i=0;i<t.size();i++)
        {
            if(!isalpha(t[i]))
                continue;
            int j(i);
            string t2;
            while(j<t.size() && isalpha(t[j]))
            {
                t2+=t[j];
                j++;
            }
            if(!ignore.count(t2))
            {
                for(int k=0;k<t2.size();k++)
                    t2[k]=toupper(t2[k]);
                string t3(t);
                t3.replace(i,t2.size(),t2);
                r.insert(make_pair(t2,t3));
            }
            i=j;
        }
    }

    for(map<string,string>::iterator i=r.begin();i!=r.end();i++)
        cout<<i->second<<endl;

    return 0;
}

lee1r 2011-04-11 01:50 发表评论

UVa 400 Unix ls

lee1r — Sat, 09 Apr 2011 09:24:00 GMT

题目要求模拟Unix下ls命令。给出一些列文件名，按字典序排序之后，以列优先的方式输出。除了最后一列之外，其余各列所占的字符数为最长文件名长度加2，最后一列所占数目为最长文件名长度。每行字符数不能超过60，要求最终的行数最少。
WA了2次，实在不应该，列输出方式没有控制好。我的做法是先输出到二维string数组中，因为这个数组并不一定被填满，这样一来接下来输出时有多种选择：1、做标记，没有被标记的元素不用输出（我最初这一步没有做好）；2、判断(i,j)对应的文件名数组中的位置是否越界（不占用额外空间，不用对二维string数组赋值）。
以下是我的代码：

#include<iostream>
#include<string>
#include<algorithm>
#include<cstdio>
using namespace std;
const int kMaxn(107);

string r[kMaxn],ls[kMaxn][kMaxn];

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int n;
    while(cin>>n)
    {
        int max_length(0);
        for(int i=1;i<=n;i++)
        {
            cin>>r[i];
            max_length=max(max_length,static_cast<int>(r[i].size()));
        }

        sort(r+1,r+n+1);
        int row_num,column_num;
        for(row_num=1;row_num<=n;row_num++)
        {
            column_num=n/row_num;
            if(n%row_num)
                column_num++;
            if((max_length+2)*(column_num-1)+max_length<=60)
                break;
        }
        for(int i=1,x=1,y=1;i<=n;i++)
        {
            ls[x][y]=r[i];
            x++;
            if(x>row_num)
            {
                x=1;
                y++;
            }
        }

        for(int i=1;i<=60;i++)
            cout<<"-";
        cout<<endl;
        for(int i=1;i<=row_num;i++)
        {
            for(int j=1;j<=column_num;j++)
            {
                if((j-1)*row_num+i<=n)
                {
                    cout<<ls[i][j];
                    for(int k=ls[i][j].size();k<(j==column_num?max_length:(max_length+2));k++)
                        cout<<" ";
                }
            }
            cout<<endl;
        }
    }

    return 0;
}

lee1r 2011-04-09 17:24 发表评论

UVa 10785 The Mad Numerologist

lee1r — Sat, 09 Apr 2011 05:30:00 GMT

一开始没有注意到“在满足其他条件的同时，按最小字典序输出”。英文读题还需要练习啊～唉。
以下是我的代码：

#include<iostream>
#include<string>
#include<algorithm>
#include<cstdio>
using namespace std;
const string kStr("AJAJAJAJAJASASASASASABABABABABAKAKAKAKAKATUTUTUTUTUCUCUCUCUCULULULULULUDUDUDUDUDUMUMEMEMEMEVEVEVEVEVENENENENENEWEWEWEWEWEFEFEFOFOFOXOXOXOXOXOGOGOGOGOGOPOPOPOPOPOYOYOYOYIYIHIHIHIHIHIQIQIQIQIQIZIZIZIZIZIRIRIRIRIR");

int main()
{
    int T;
    cin>>T;
    for(int case_num=1;case_num<=T;case_num++)
    {
        int n;
        cin>>n;

        string ans(kStr.substr(0,n));
        string odd,even;
        for(int i=0;i<n;i+=2)
            odd+=ans[i];
        for(int i=1;i<n;i+=2)
            even+=ans[i];
        sort(odd.begin(),odd.end());
        sort(even.begin(),even.end());

        cout<<"Case "<<case_num<<": ";
        for(int i=0;i<n;i++)
            if(i&1)
                cout<<even[i>>1];
            else
                cout<<odd[i>>1];
        cout<<endl;
    }

    return 0;
}

lee1r 2011-04-09 13:30 发表评论

UVa 156 Ananagrams

lee1r — Sat, 09 Apr 2011 03:06:00 GMT

把每个单词全部转化成小写字母，然后对每个单词的字母排序，同时原单词也需要存储，因为输出时要用到。如果排序之后的单词只出现了一次，那么将它对应的原单词输出。
STL会不会降低coder设计算法的能力啊？我都担心了～现在成了STL控，多简单的程序map、set都用上了……
以下是我的代码：

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

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    multimap<string,string> r;
    string t;
    while(cin>>t && t!="#")
    {
        string t_copy(t);
        for(int i=0;i<t_copy.size();i++)
            t_copy[i]=tolower(t_copy[i]);
        sort(t_copy.begin(),t_copy.end());
        r.insert(make_pair(t_copy,t));
    }

    vector<string> ans;
    for(multimap<string,string>::iterator i=r.begin();i!=r.end();i++)
        if(r.count(i->first)==1)
            ans.push_back(i->second);
    sort(ans.begin(),ans.end());

    for(int i=0;i<ans.size();i++)
        cout<<ans[i]<<endl;

    return 0;
}

lee1r 2011-04-09 11:06 发表评论

UVa 10420 List of Conquests

lee1r — Fri, 08 Apr 2011 15:35:00 GMT

女孩们的名字没有什么用，用map对象记录每个国家出现的次数即可。
以下是我的代码：

#include<iostream>
#include<string>
#include<map>
#include<cstdio>
using namespace std;
const int kMaxn(2007);

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int n;
    cin>>n;
    map<string,int> r;
    for(int i=1;i<=n;i++)
    {
        string country,t;
        cin>>country;
        r[country]++;
        getchar();
        getline(cin,t);
    }

    for(map<string,int>::iterator i=r.begin();i!=r.end();i++)
        cout<<i->first<<" "<<i->second<<endl;

    return 0;
}

lee1r 2011-04-08 23:35 发表评论

UVa 299 Train Swapping

lee1r — Fri, 08 Apr 2011 14:58:00 GMT

冒泡排序，并记录交换次数。
以下是我的代码：

#include<algorithm>
#include<cstdio>
using namespace std;
const int kMaxn(57);

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);
        int r[kMaxn];
        for(int i=1;i<=n;i++)
            scanf("%d",&r[i]);

        int ans(0);
        for(int i=n;i>=2;i--)
            for(int j=1;j<i;j++)
                if(r[j]>r[j+1])
                {
                    swap(r[j],r[j+1]);
                    ans++;
                }

        printf("Optimal train swapping takes %d swaps.\n",ans);
    }

    return 0;
}

lee1r 2011-04-08 22:58 发表评论