Classement HJ68 ●Quantity

décrire

Compte tenu de la séquence d'informations (nom, note) de certains étudiants, veuillez organiser leurs informations en fonction des notes de haut en bas ou de bas en haut, et les mêmes notes seront traitées selon la règle de saisie en premier.

Remarque : 0 signifie de haut en bas, 1 signifie de bas en haut

Plage de données : nombre de personnes : $1\le n \le 200$

Avancé : Complexité temporelle : $O (n l o g n)$ , complexité spatiale : $O (n)$

Saisissez une description :

Saisissez le nombre n de personnes à trier dans la première ligne, saisissez un nombre entier sur la deuxième ligne pour indiquer la méthode de tri, et saisissez leurs noms et grades dans les n lignes suivantes, séparées par un espace.

Description de la sortie :

Affichez le nom et la note selon la méthode spécifiée, et le nom et la note sont séparés par un espace

exemple

Entrée :
3
0
croc 90
yang 50
ning 70
Sortie :
croc 90
ning 70
yang 50

répondre

1. Fusionner le tri

Le titre exige que le tri soit stable, donc le tri par tas ou le tri rapide ne peut pas être utilisé.

Dans le processus de tri, lorsque les scores sont égaux, les éléments de gauche sont sortis en premier ;

Pour la sélection de l'ordre croissant ou décroissant, l' 异或^opérateur est utilisé dans la fonction de traitement.

Complexité temporelle : $O (n l o g n)$ , complexité spatiale : $O (n)$

#include<iostream>
#include<string>
#include<vector>
using namespace std;
typedef vector<pair<string, int>> vec;

void mergeSort(vec& list, vec& sorted, bool flag, int start, int end){
    
    
    if(start >= end) return;
    int mid = start + (end - start) / 2;
    mergeSort(list, sorted, flag, start, mid);
    mergeSort(list, sorted, flag, mid+1, end);
    int left = start, right = mid+1;
    int idx = start;
    while(idx <= end){
    
    
        if(left > mid){
    
    
            sorted[idx++] = list[right++];
        }else if(right > end){
    
    
            sorted[idx++] = list[left++];
        }else if(list[left].second == list[right].second){
    
    
            sorted[idx++] = list[left++];
        }else if(list[left].second > list[right].second ^ flag){
    
    	// 升序或降序选择
            sorted[idx++] = list[left++];
        }else{
    
    
            sorted[idx++] = list[right++];
        }
    }
    for(int i = start; i <= end; ++i){
    
    
        list[i] = sorted[i];
    }
}

int main() {
    
    
    int n, flag;
    while(cin >> n >> flag){
    
    
        vec list(n, {
    
    "", 0});
        for(int i = 0; i < n; ++i){
    
    
            cin >> list[i].first >> list[i].second;
        }
        vec sorted(list);
        mergeSort(list, sorted, flag, 0, list.size()-1);	// 排序
        for(int i = 0; i < n; ++i){
    
    							// 输出
            cout << list[i].first << " " << list[i].second << endl;
        }
    }
}

2. Fonction de tri stable stable_sort

Comme la fonction sort(), le modèle de fonction qui implémente stable_sort() se trouve également dans le fichier d'en-tête de l'algorithme, mais il s'agit d'un algorithme de tri stable implémenté sur la base du tri par fusion.

#include<iostream>
#include<string>
#include<vector>
#include<algorithm>
using namespace std;
typedef pair<string, int> t_pair;

int main() {
    
    
    int n;
    bool flag;
    while(cin >> n >> flag){
    
    
        vector<pair<string, int>> list(n, {
    
    "", 0});
        for(int i = 0; i < n; ++i){
    
    
            cin >> list[i].first >> list[i].second;
        }
        if(flag == 1){
    
    							// lambda 表达式
            stable_sort(list.begin(), list.end(), [](const t_pair& a, const t_pair& b){
    
    
                return a.second < b.second;
            });
        }else{
    
    
            stable_sort(list.begin(), list.end(), [](const t_pair& a, const t_pair& b){
    
    
                return a.second > b.second;
            });
        }
  
        for(int i = 0; i < n; ++i){
    
    
            cout << list[i].first << " " << list[i].second << endl;
        }
    }
}