template < class Key, class Compare = less<Key>, class Alloc = allocator<Key> > class set;

set<int, greater<int>> s;  // 降序

struct MyCmp {
    bool operator()(int a, int b) const {
        return a > b;  // 降序：a > b 时 a 排在 b 前
    }
};
set<int, MyCmp> s;

auto cmp = [](int a, int b) { return a > b; };
set<int, decltype(cmp)> s(cmp);  // 注意要传入 cmp 对象

struct Student {
    string name;
    int score;
};

struct CmpByScore {
    bool operator()(const Student& a, const Student& b) const {
        if (a.score != b.score) return a.score > b.score; // 分数高的在前
        return a.name < b.name; // 分数相同按姓名升序
    }
};

set<Student, CmpByScore> studentSet;

#include <iostream>
#include <set>
#include <map>
#include <string>
#include <functional> // for std::greater
using namespace std;

// 自定义比较器结构体：降序
struct DescendingCmp {
    bool operator()(int a, int b) const {
        return a > b; // 如果 a > b，说明 a 应该排在 b 前面（降序）
    }
};

// 自定义结构体：学生
struct Student {
    string name;
    int score;
};

// 学生比较器：按成绩降序，成绩相同按姓名升序
struct CmpStudent {
    bool operator()(const Student& a, const Student& b) const {
        if (a.score != b.score) return a.score > b.score; // 分数高优先
        return a.name < b.name; // 分数相同按姓名升序
    }
};

int main() {
    // 1. 使用 greater 降序
    cout << "=== 使用 greater 降序 set ===" << endl;
    set<int, greater<int>> s1 = {5, 2, 8, 1, 9};
    for (int x : s1) cout << x << " "; // 9 8 5 2 1
    cout << endl;

    // 2. 自定义比较器结构体
    cout << "=== 自定义比较器结构体 set ===" << endl;
    set<int, DescendingCmp> s2 = {5, 2, 8, 1, 9};
    for (int x : s2) cout << x << " "; // 9 8 5 2 1
    cout << endl;

    // 3. 对 map 自定义键的比较器（按键降序）
    cout << "=== map 按键降序 ===" << endl;
    map<int, string, greater<int>> m1;
    m1[1] = "one";
    m1[3] = "three";
    m1[2] = "two";
    for (const auto& p : m1) cout << p.first << ":" << p.second << " "; // 3:three 2:two 1:one
    cout << endl;

    // 4. 自定义结构体 set
    cout << "=== 自定义结构体 set（按成绩降序）===" << endl;
    set<Student, CmpStudent> students;
    students.insert({"Alice", 95});
    students.insert({"Bob", 87});
    students.insert({"Charlie", 92});
    students.insert({"David", 92});  // 与 Charlie 同分，按姓名升序
    for (const auto& s : students) {
        cout << s.name << " : " << s.score << endl;
    }
    // 输出:
    // Alice: 95
    // Charlie: 92
    // David: 92
    // Bob: 87

    // 5. 使用 lambda 的比较器（set）
    cout << "\n=== 使用 lambda 的 set（偶数在前，同奇偶升序）===" << endl;
    auto cmp = [](int a, int b) {
        bool aEven = (a % 2 == 0);
        bool bEven = (b % 2 == 0);
        if (aEven != bEven) return aEven; // 偶数排在奇数前面
        return a < b; // 同奇偶时升序
    };
    set<int, decltype(cmp)> s3(cmp);
    s3.insert({1,2,3,4,5,6});
    for (int x : s3) cout << x << " "; // 2 4 6 1 3 5
    cout << endl;

    return 0;
}

=== 使用 greater 降序 set ===
9 8 5 2 1 
=== 自定义比较器结构体 set ===
9 8 5 2 1 
=== map 按键降序 ===
3:three 2:two 1:one 
=== 自定义结构体 set（按成绩降序）===
Alice : 95
Charlie : 92
David : 92
Bob : 87

=== 使用 lambda 的 set（偶数在前，同奇偶升序）===
2 4 6 1 3 5 

from functools import cmp_to_key

# 1. 列表降序排序
numbers = [5, 2, 8, 1, 9]
sorted_desc = sorted(numbers, key=lambda x: -x)  # 通过取负实现降序
print("降序:", sorted_desc)  # [9, 8, 5, 2, 1]

# 2. 字典按键降序输出
m = {1: "one", 3: "three", 2: "two"}
for key in sorted(m, reverse=True):
    print(f"{key}: {m[key]}", end=" ")  # 3:three 2:two 1:one
print()

# 3. 用列表模拟一个有序集合（保证不重复，且保持自定义顺序）
class CustomSet:
    def __init__(self, cmp_func=None):
        self._data = []
        # cmp_func: (a,b) -> bool, 返回 True 表示 a 应排在 b 前
        self._cmp = cmp_func if cmp_func else (lambda a,b: a < b)

    def add(self, value):
        # 检查是否已存在（用比较器判断等价）
        for i, x in enumerate(self._data):
            if not self._cmp(x, value) and not self._cmp(value, x):
                return  # 已等价，不插入
        # 插入并重新排序
        self._data.append(value)
        # 使用自定义比较器排序（通过 cmp_to_key 转换）
        self._data.sort(key=cmp_to_key(lambda a,b: -1 if self._cmp(a,b) else 1 if self._cmp(b,a) else 0))

    def __repr__(self):
        return str(self._data)

# 示例：偶数优先，同奇偶升序
def custom_less(a, b):
    a_even = a % 2 == 0
    b_even = b % 2 == 0
    if a_even != b_even:
        return a_even  # 偶数应排在奇数前
    return a < b

cs = CustomSet(custom_less)
for x in [1,2,3,4,5,6]:
    cs.add(x)
print("自定义集合:", cs)  # 输出类似 [2,4,6,1,3,5]

# 4. 对学生按成绩降序、姓名升序排序
students = [
    ("Alice", 95),
    ("Bob", 87),
    ("Charlie", 92),
    ("David", 92)
]
sorted_students = sorted(students, key=lambda s: (-s[1], s[0]))
print("学生排序:", sorted_students)
# 输出: [('Alice', 95), ('Charlie', 92), ('David', 92), ('Bob', 87)]