b_pat_排序题目大杂烩（map+排序+模拟）

最佳排名

对于每个学生，输出他的最佳排名以及该排名对应的是哪项成绩。
当多项排名相同，且都为最佳时，按照 A>C>M>E 的优先级，选择输出哪项成绩。
如果无法查询到该学生的成绩，则输出 N/A。

每门课也有很多下属（每个学生该门课的成绩）；每个学生也有很多下属（每个学生的所有成绩）；故需要两个结构

#include<bits/stdc++.h>
using namespace std;
const int N=2005;
unordered_map<string, vector<int>> mp;
vector<int> scores[4];

int get_rk(int courseID, int score) {
    int l=0, r=scores[courseID].size();
    while (l<r) {
        int m=l+(r-l)/2;
        if (scores[courseID][m]>score) l=m+1;
        else r=m;
    }
    return l+1;
}
int main() {
    int n,m,info[4]; scanf("%d %d", &n, &m);
    string id;
    for (int i=0; i<n; i++) {
        cin>>id, memset(info, 0, sizeof info);
        for (int j=1; j<4; j++) scanf("%d", &info[j]), info[0]+=info[j];
        info[0]=round(info[0]/3.0);
        for (int j=0; j<4; j++) {
            mp[id].push_back(info[j]);   //id同学的成绩
            scores[j].push_back(info[j]);//第j门课的所有乘积
        }
    }
    for (int i=0; i<4; i++) sort(scores[i].begin(), scores[i].end(), [&](int a, int b){return a>b;});

    string sID;
    char course_name[4]={'A', 'C', 'M', 'E'};
    for (int i=0; i<m; i++) {
        cin>>sID;
        if (mp.find(sID)==mp.end()) printf("N/A\n");
        else {
            //得到sID的排名
            int rk=n+1;
            char course;
            for (int j=0; j<4; j++) {
                int ans_rk=get_rk(j, mp[sID][j]);
                if (ans_rk<rk) {
                    rk=ans_rk;
                    course=course_name[j];
                }
            }
            printf("%d %c\n", rk, course);
        }
    }
    return 0;
}

PAT 排名

然后用以下格式输出最终成绩排名列表：
registration_number final_rank location_number local_rank
具有相同分数的人的排名也要相同，相同分数的人，考号较小的先输出。

先更新局部排名，再将更新好的学生node放到all数组中，然后更新all中的学生排名，最后输出信息

#include<bits/stdc++.h>
using namespace std;
const int N=105;
struct node {
    string sID;
    int score, localID, final_rk, local_rk;
};
int n;
vector<node> locations[N];
vector<node> all;
bool cmp(node& a, node& b) {
    if (a.score!=b.score) return a.score>b.score;
    return a.sID<b.sID;
}
int main() {
    std::ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int tot=0; cin>>n;

    for (int i=0; i<n; i++) {
        int k, score; cin>>k;
        string sID; 
        tot+=k;
        for (int j=0; j<k; j++) {
            cin>>sID>>score;
            locations[i].push_back({sID, score, i});
        }
        sort(locations[i].begin(), locations[i].end(), cmp);
        //更新局部排名
        for (int j=0; j<k; j++) {
            if (j==0 || locations[i][j].score!=locations[i][j-1].score) {
                locations[i][j].local_rk=j+1;
            } else {
                locations[i][j].local_rk=locations[i][j-1].local_rk;
            }
            all.push_back(locations[i][j]);
        }
    }
    cout<<tot<<'\n';
    sort(all.begin(), all.end(), cmp);
    for (int i=0; i<all.size(); i++) {
        if (i==0 || all[i].score!=all[i-1].score) 
            all[i].final_rk=i+1;
        else 
            all[i].final_rk=all[i-1].final_rk;
        cout<<all[i].sID<<' '<<all[i].final_rk<<' '<<all[i].localID+1<<' '<<all[i].local_rk<<'\n';
    }
    return 0;
}

pat评测

以下列格式输出排名列表：
rank user_id total_score s[1] ... s[K]
其中，rank 是根据 total_score 计算的，所以拥有相同 total_score 的用户的 rank 也相同。
s[i] 是第 i 个问题获得的分数。

这种题一定要理清头绪，不能急啊，

#include<bits/stdc++.h>
using namespace std;
unordered_map<string, vector<int>> mp;
const int unsubmit=-2;
struct node {
    string uID;
    int tot_score, ac_cnt;
    vector<int> k_score;
    int rk;
};
bool cmp(node& a, node& b) {
    if (a.tot_score!=b.tot_score) return a.tot_score>b.tot_score;
    if (a.ac_cnt!=b.ac_cnt) return a.ac_cnt>b.ac_cnt;
    return a.uID<b.uID; 
}
int main() {
    int n,k,m; scanf("%d%d%d", &n,&k,&m);    //总用户数，问题数，提交总数
    int p[k]; for (int i=0; i<k; i++) scanf("%d", &p[i]);
    char buff[15];
    int pID, score;
    for (int i=0; i<m; i++) {
        scanf("%s%d%d", buff, &pID, &score); string uID(buff);
        pID-=1;
        if (mp.find(uID)==mp.end()) mp.insert({uID, vector<int>(5+1, unsubmit)});
        mp[uID][pID]=max(mp[uID][pID], score);
    }
    vector<node> v;
    for (auto& info : mp) {
        string uID=info.first;
        auto& scores=info.second;
        int ac_cnt=0, tot_score=0, is_never_submit=true;
        for (int i=0; i<scores.size(); i++) {
            int s=scores[i];
            if (s!=-1 && s!=unsubmit) tot_score+=s,  is_never_submit=false;
            if (s==p[i]) ac_cnt++;
        }
        if (!is_never_submit) v.push_back({uID, tot_score, ac_cnt, scores});
    }
    sort(v.begin(), v.end(), cmp);
    for (int i=0; i<v.size(); i++) {
        if (i==0 || v[i].tot_score!=v[i-1].tot_score) {
            v[i].rk=i+1;
        } else {
            v[i].rk=v[i-1].rk;
        }
    }
    for (auto& a : v) {
        printf("%d %s %d", a.rk, a.uID.c_str(), a.tot_score);
        for (int j=0; j<k; j++) {
            if (a.k_score[j]==unsubmit) printf(" -");
            else if (a.k_score[j]==-1) printf(" 0");
            else printf(" %d", a.k_score[j]); 
        }
        printf("\n");
    }
    return 0;
}

校园内的汽车

现在，给定你所有的有用信息，你需要做的是：

• 对于一些查询，计算出查询时刻校园内的汽车数量。
• 在一天结束时，找到在校园内停放时间最长的汽车

电话账单

对于每个客户，首先以示例显示的格式在一行中打印客户名称和帐单月份。
然后，对于每个通话时间段，在一行中分别打印开始和结束时间和日期（dd:hh:mm），持续时间（以分钟为单位）和通话费用。
通话必须按时间顺序列出。

由于月份是相同的，故以输入月份的1号为基准值，将通过将输入的日期-基准值转化为分钟方便计算；

#include<bits/stdc++.h>
using namespace std;
const int N=1005, ON=1, OFF=0;
int cost[25];

struct node {
    string name;
    int month,day,hour,minute,state,use_time;
} A[N];

double convert(node& info) {
    double ans=cost[info.hour]*info.minute+cost[24]*info.day*60;
    for (int i=0; i<info.hour; i++) ans+=cost[i]*60;
    return ans/100.0;
}

int main() {
    for (int i=0; i<24; i++) scanf("%d", &cost[i]), cost[24]+=cost[i];
    int n; scanf("%d", &n);

    for (int i=0; i<n; i++) {
        cin>>A[i].name; 
        scanf("%d:%d:%d:%d", &A[i].month, &A[i].day, &A[i].hour, &A[i].minute);
        A[i].use_time=A[i].day*24*60+A[i].hour*60+A[i].minute;
        string state_string; cin>>state_string;
        A[i].state=(state_string=="on-line" ? ON : OFF);
    }
    sort(A, A+n, [&](node a, node b) {
        return (a.name!=b.name) ? a.name<b.name : a.use_time<b.use_time;
    });
    map<string, vector<node>> mp;
    for (int i=1; i<n; i++) if (A[i].name==A[i-1].name && A[i-1].state==ON && A[i].state==OFF) {
        mp[A[i].name].push_back(A[i-1]);
        mp[A[i].name].push_back(A[i]);
    }

    for (auto& C : mp) {    //主人
        auto& records=C.second;
        double tot=0;
        printf("%s %02d\n", C.first.c_str(), records[0].month);
        for (int i=1; i<records.size(); i+=2) {
            auto start=records[i-1]; 
            auto& end=records[i];
            double d=convert(end)-convert(start);
            printf("%02d:%02d:%02d %02d:%02d:%02d %d $%.2f\n", start.day, start.hour, start.minute, end.day, end.hour, end.minute, end.use_time-start.use_time, d);
            tot+=d;
        }
        printf("Total amount: $%.2f\n", tot);
    }
    return 0;
}

---

研究生入学

每个申请人都必须提供两个成绩：全国入学考试成绩 GE 和面试成绩 GI，申请人的最终成绩是 (GE+GI)/2。
录取规则如下：

• 申请者将根据其最终成绩由高到低进行排名，并且将从排名列表的顶部开始逐一录取。
• 如果申请者的最终成绩并列，则按照 GE 成绩由高到低进行排名，如果成绩仍然并列，则并列者的排名必须相同。
• 每个申请人可以填报 K 个志愿，并且将根据他/她的志愿进行录取：如果按照排名列表，轮到某位学生被录取了，并且其第一志愿学校还未招满人，则他成功被该学校录取。如果名额已满，则按顺序考虑其他志愿，直至成功被录取为止。如果所有报名学校都无法录取该名学生，则该名学生录取失败。
• 如果出现并列排名，并且并列申请人正在申请同一所学校，那么该学校不得只录取其中一部分申请人，即使超过招生限额，也必须全部录取。

每所学校的录取结果占据一行，其中包含所有学校录取的申请人的编号。编号必须按升序排列，并用空格分隔。
每行的末尾必须没有多余的空格。如果某学校没有录取任何学生，则必须相应地输出空白行。

耐心...

#include<bits/stdc++.h>
using namespace std;
const int N=4e5+5;
struct node {
    int sID, Ge, Gi, Gf;
    int choise[6];
} S[N];
bool cmp1(node& a, node& b) {
    if (a.Gf!=b.Gf) return a.Gf>b.Gf;
    if (a.Ge!=b.Ge) return a.Ge>b.Ge;
    return a.sID<b.sID;
}
int main() {
    std::ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int n,m,k; cin>>n>>m>>k; //n是应用的总数，m是毕业院校总数，k学生的申请总数
    int limit[m];
    //第i个院校的限额
    for (int i=0; i<m; i++) cin>>limit[i];
    for (int i=0; i<n; i++) {
        cin>>S[i].Ge>>S[i].Gi;
        S[i].sID=i, S[i].Gf=S[i].Ge+S[i].Gi;
        for (int j=0; j<k; j++) {
            cin>>S[i].choise[j];
        }
    }
    sort(S, S+n, cmp1);
    //输出每个院校录取的学生编号
    vector<node> school[m];
    for (int i=0; i<n; i++) 
    for (int j=0; j<k; j++) {
        int schID=S[i].choise[j];
        if (limit[schID]>school[schID].size() || (school[schID].back().Ge==S[i].Ge && school[schID].back().Gf==S[i].Gf)) {
            school[schID].push_back(S[i]);
            break;  //如果考前的志愿被录取，则不考虑后面的志愿
        }
    }
    for (int i=0; i<m; i++) {
        sort(school[i].begin(), school[i].end(), [&](node a, node b) {return a.sID<b.sID;});
        for (int j=0; j<school[i].size(); j++) {
            auto& stu=school[i][j];
            if (j==school[i].size()-1) cout<<stu.sID;
            else cout << stu.sID << ' ';
        }
        cout<<'\n';
    }
    return 0;
}

---

校原内的汽车

现在，给定你所有的有用信息，你需要做的是：

• 对于一些查询，计算出查询时刻校园内的汽车数量。
• 在一天结束时，找到在校园内停放时间最长的汽车。

比较繁琐的一道：秒转化为时间 hh:mm:ss

• hh=time/3600
mm=time%3600/60比如1800对应1800/60=30（分针在30分钟的位置）
  ss=time%60

#include<bits/stdc++.h>
using namespace std;
const int N=1e4+5, K=8e4+5;
const char IN='i', OUT='o';
struct node {
    string num;
    int time, isParking;
    char move;  //动作in/out
} C[N];
bool cmp(node& a, node& b) {
    if (a.num==b.num) return a.time<b.time; //优先考虑时间靠前的记录
    return a.num<b.num;
}
bool cmp1(node& a, node& b) {
    if (a.isParking==b.isParking) {
        if (a.time==b.time) return a.num<b.num;
        return a.time<b.time;
    }
    return a.isParking>b.isParking; //1>0，优先选出在
}
map<string, int> mp;
int main() {
    int n,k; scanf("%d%d", &n,&k);
    char t[10], move[5];
    int hour,minute,second; 
    for (int i=0; i<n; i++) {
        scanf("%s %d:%d:%d %s", t,&hour,&minute,&second,move);
        C[i].num=string(t), C[i].time=hour*3600+minute*60+second, C[i].move=move[0];
    }
    sort(C,C+n,cmp);
    //记录每辆车的停车时间
    int max_parkingtime=0;
    for (int i=1; i<n; i++) if (C[i].num==C[i-1].num && C[i-1].move==IN && C[i].move==OUT) {
        mp[C[i].num]+=C[i].time-C[i-1].time;
        C[i].isParking=C[i-1].isParking=true;
        max_parkingtime=max(max_parkingtime, mp[C[i].num]);
    }
    //再排一下序，将不合法的车子弄到数组尾部
    sort(C, C+n, cmp1);
    int j=0, cnt=0;
    while (k--) {
        scanf("%d:%d:%d", &hour,&minute,&second);
        int deadline=hour*3600+minute*60+second;
        while (C[j].isParking && C[j].time<=deadline) {
            if (C[j].move==IN) cnt++;
            else               cnt--;
            j++;
        }
        printf("%d\n", cnt);
    }
    for (auto& info : mp) if (info.second==max_parkingtime) {
        printf("%s ", info.first.c_str());
    }
    printf("%02d:%02d:%02d", max_parkingtime/3600, max_parkingtime%3600/60, max_parkingtime%60);
    return 0;
}

---

快速排序的中轴

给定一个序列，找到这个序列中可以作为快排中轴的元素

思路
傻了，一开始直接用单调栈求出右边大于自己的数的个数到 ans 数组中，然后中轴就是左边小于自己的数的个数为 n-ans[i]-1，这是不对的，比如：

[1,3,2,4,5]，2并不可以作为中轴，但 5-2-1=2，错误认为2是中轴

冷静了一下，想了个暴力：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;

int main() {
    std::ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int n; cin>>n;
    int A[n]; for (int i=0; i<n; i++) cin>>A[i];

    // stack<int> st;
    // int ans[n]; memset(ans, 0, sizeof ans);
    // for (int i=n-1; i>=0; i--) {
    //     while (!st.empty() && A[st.top()]<A[i]) st.pop();
    //     ans[i]=st.empty() ? 0 : n-st.top();
    //     st.push(i);
    // }
    // int cnt=0;
    // for (int i=0; i<n; i++) if (ans[i]==n-i-1) 
    //     cnt++;
    // cout << cnt << '\n';
    // for (int i=0; i<n; i++) if (ans[i]==n-i-1) { 
    //     if (i==n-1) cout << A[i];
    //     else cout << A[i] <<' ';
    // }
    int lmax[n], rmin[n]; 
    memset(lmax, 0, sizeof lmax), memset(rmin, 0x3f3f3f3f, sizeof rmin);
    lmax[0]=A[0], rmin[n-1]=A[n-1];
    for (int i=1; i<n; i++) lmax[i]=max(lmax[i-1], A[i]);
    for (int i=n-2; i>=0; i--) rmin[i]=min(rmin[i+1], A[i]);
    
    vector<int> ans; 
    for (int i=0; i<n; i++) if (A[i]>=lmax[i] && A[i]<=rmin[i]) {
        ans.push_back(A[i]);
    }
    sort(A.begin(), A.end());
    cout << ans.size() << '\n';
    if (ans.size()==0) cout << '\n';
    else for (int i=0; i<ans.size(); i++) {
        if (i==ans.size()-1) cout<<ans[i];
        else        cout<<ans[i]<<' '; 
    }
    return 0;
}

---

合影

每行的人数必须为 N/K（向下取整），所有多余的人（如果有）都放到最后一行；
位于后排的所有人都不得矮于位于前排的任何人；
在每一行中，最高的人站在该行的中心位置（定义为位置 (m/2+1)，位置从1开始编号，其中 m 是该行的总人数，除法结果向下取整）；
在每一行中，其他人必须按照其身高非递增顺序依次排入该行，交替地将他们的位置先安排到最高人的右侧，然后再安排到最高人的左侧
身高相同时，必须按姓名的字典序升序进行排序

思路
这题如果真的是从中心开始扩张，每次扩张都需要用O(logn)时间（最优了吧）去找最高和次高进行安排，然后删除他两，比较慢；比较聪明的做法是：事先对学生数组 A 按照规则排序，对于每一行，从中心开始扩展，我都用一个数组记录扩张时的人的在 A 中的索引

#include<bits/stdc++.h>
using namespace std;
struct node {
    string name;
    int h;
};
bool cmp(node& a, node& b) {
    if (a.h!=b.h) return a.h>b.h;
    return a.name<b.name;
}
int main() {
    std::ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
    int n,k; cin>>n>>k;
    node A[n+1];
    for (int i=0; i<n; i++) cin>>A[i].name>>A[i].h;
    sort(A, A+n, cmp);
    int idx=0;
    
    for (int i=0; i<k; i++) {
        int sz=round(n/k);
        if (i==0) sz+=n%k;
        int row[sz+1], m=sz/2+1, l=m-1, r=m;
        while (l>0 || r<=sz) {
            if (r<=sz) row[r++]=idx++;
            if (l>0) row[l--]=idx++;
        }
        for (int j=1; j<=sz; j++) {
            cout<<A[row[j]].name;
            if (j!=sz) cout<<' ';
        }
        cout<<'\n';
    }
    return 0;
}

---

世界首富

接下来输出给定年龄段内最富有的 M 个人的信息，格式为：
Name Age Net_Worth
输出必须按照净资产的非递增顺序排列，如果净资产相同，则按照年龄不降序排列，如果年龄也相同，则按照字典序不降序排列。

思路
如果数据不卡暴力算法还好，就要优化：题目限定每个case最多输出100个人，所以可用一个数组记录每个年龄出现的次数，某个年龄出现次数多余100时，后面的人不用管了，反正都输出不了

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=1e5+5;
struct node {
    string name;
    int age, nw;
};
bool cmp(node& a, node& b) {
    if (a.nw!=b.nw) return a.nw>b.nw;
    if (a.age!=b.age) return a.age<b.age;
    return a.name<b.name;
}
int main() {
    int n,k; scanf("%d%d", &n, &k);
    node A[n];
    string name; 
    int age, nw;
    for (int i=0; i<n; i++) {
        cin>>A[i].name;
        scanf("%d%d", &A[i].age,&A[i].nw);
    }
    sort(A, A+n, cmp);
    int m, lo, hi;
    for (int i=0; i<k; i++) {
        scanf("%d%d%d", &m,&lo,&hi);
        printf("Case #%d:\n", i+1);
        vector<node> candidates;
        int cnt=0;
        while (cnt<m) {
            int i;
            for (i=0; i<n && cnt<m; i++) if (A[i].age>=lo && A[i].age<=hi) {
                candidates.push_back(A[i]);
                cnt++;
            }
            if (i==n) break;
        }
        sort(candidates.begin(), candidates.end(), cmp);
        if (candidates.empty()) printf("None\n");
        else for (auto& c : candidates) {
            printf("%s %d %d\n", c.name.c_str(), c.age, c.nw);
        }
    }
    return 0;
}