void quickSort(vector<int>& arr, int low, int high) {
    // 递归结束条件：如果区间只有一个元素或没有元素，就不排了
    if (low < high) {
        // --- 分区操作 (Partition) 开始 ---
        int pivot = arr[high]; // 选取最后一个元素作为“基准”
        
        // i 指向“比 pivot 小的区域”的最后一个元素
        // 初始时该区域为空，所以 i 在 low 的左边
        int i = low - 1; 

        // j 从头遍历到倒数第二个元素
        for (int j = low; j < high; j++) {
            // 如果当前元素比基准小
            if (arr[j] < pivot) {
                i++; // 扩充“小数区域”的边界
                swap(arr[i], arr[j]); // 把这个小数交换到“小数区域”里去
            }
        }
        // 循环结束后，i 左边（包括 i）都是小数，i 的右边都是大数
        // 现在把基准值 pivot (arr[high]) 放到中间（i+1 的位置）
        swap(arr[i + 1], arr[high]);
        
        // 记录基准值现在的下标，它已经排好序了，以后不用动它
        int pi = i + 1; 

        // --- 分区操作结束 ---

        // 递归排序基准值左边的子数组
        quickSort(arr, low, pi - 1);
        // 递归排序基准值右边的子数组
        quickSort(arr, pi + 1, high);
    }
}

// l: 左边界, m: 中间点, r: 右边界
void merge(vector<int>& arr, int l, int m, int r) {
    // --- 第一步：计算长度并备份数据 ---
    int n1 = m - l + 1; // 左半边的长度（注意 +1，因为 m 包含在左边）
    int n2 = r - m;     // 右半边的长度

    // 创建临时数组（归并排序需要额外的内存空间，这是它的缺点）
    vector<int> L(n1), R(n2);

    // 把数据从原数组拷贝到临时数组 L 和 R
    for (int i = 0; i < n1; i++) L[i] = arr[l + i];
    for (int j = 0; j < n2; j++) R[j] = arr[m + 1 + j];

    // --- 第二步：双指针合并 ---
    int i = 0; // L 数组的指针
    int j = 0; // R 数组的指针
    int k = l; // 原数组 arr 的指针（注意从 l 开始，不是 0）

    // 当两个数组都没走完时
    while (i < n1 && j < n2) {
        // 谁小选谁，放回 arr 中
        // 注意：<= 保证了算法的“稳定性”（相同元素位置不变）
        if (L[i] <= R[j]) {
            arr[k++] = L[i++];
        } else {
            arr[k++] = R[j++];
        }
    }

    // --- 第三步：处理剩余元素 ---
    // 有可能左边剩下了，也有可能右边剩下了，把剩下的全部抄过去
    while (i < n1) arr[k++] = L[i++];
    while (j < n2) arr[k++] = R[j++];
}

void mergeSort(vector<int>& arr, int l, int r) {
    if (l < r) {
        // 1. 找中间点（防止 (l+r) 溢出的写法）
        int m = l + (r - l) / 2;
        // 2. 递归拆分左半边 [l ... m]
        mergeSort(arr, l, m);
        // 3. 递归拆分右半边 [m+1 ... r]
        mergeSort(arr, m + 1, r);
        // 4. 【重点】左右两边都排好了，现在把它们“缝合”起来
        merge(arr, l, m, r);
    }
}

void heapify(vector<int>& arr, int n, int i) {
    int largest = i;
    int l = 2 * i + 1;
    int r = 2 * i + 2;
    if (l < n && arr[l] > arr[largest]) largest = l;
    if (r < n && arr[r] > arr[largest]) largest = r;
    if (largest != i) {
        swap(arr[i], arr[largest]);
        heapify(arr, n, largest);
    }
}

void heapSort(vector<int>& arr) {
    int n = arr.size();
    for (int i = n / 2 - 1; i >= 0; i--) heapify(arr, n, i);
    for (int i = n - 1; i > 0; i--) {
        swap(arr[0], arr[i]);
        heapify(arr, i, 0);
    }
}

import numpy as np

# 示例数据
data = np.array([1, 2, 5, 6, 7, 9, 12, 15, 18, 19, 27])

# 计算 Q1, Q3
q1 = np.percentile(data, 25)
q3 = np.percentile(data, 75)

# 计算 IQR
iqr = q3 - q1

print(f"数据集: {data}")
print(f"第一四分位数 (Q1): {q1}")
print(f"第三四分位数 (Q3): {q3}")
print(f"四分位距 (IQR): {iqr}")

# 识别异常值
lower_bound = q1 - 1.5 * iqr
upper_bound = q3 + 1.5 * iqr

outliers = data[(data < lower_bound) | (data > upper_bound)]
print(f"异常值界限: (下界: {lower_bound}, 上界: {upper_bound})")
print(f"异常值: {outliers}")

#include <iostream>
#include <vector>
#include <cstring> 

using namespace std;

const int MAXN = 505; // 最大顶点数
vector<int> adj[MAXN]; // 邻接表存图
int match[MAXN];       // match[v] = u 表示右边的点 v 匹配了左边的点 u
bool vis[MAXN];        // visited 数组，记录右边的点是否在本次 DFS 中被访问过

// 向图中添加边 u -> v (u 在左边，v 在右边)
void addEdge(int u, int v) {
    adj[u].push_back(v);
}

// DFS 寻找增广路径
bool dfs(int u) {
    for (int v : adj[u]) {
        if (!vis[v]) {
            vis[v] = true; // 标记右边的点 v 已访问
            
            // 如果 v 还没有匹配，或者 v 已经匹配了但它的匹配对象 match[v] 可以找到另一个匹配
            if (match[v] == -1 || dfs(match[v])) {
                match[v] = u; // 尝试把 v 匹配给 u
                return true;
            }
        }
    }
    return false;
}

int hungarian(int N) {
    int result = 0;
    memset(match, -1, sizeof(match)); // 初始化所有点未匹配
    
    // 遍历左边的所有点 N
    for (int i = 1; i <= N; i++) {
        memset(vis, 0, sizeof(vis)); // 每次寻找增广路前都要清空 visited
        if (dfs(i)) {
            result++;
        }
    }
    return result;
}

int main() {
    int n, m, e; // n: 左边点数, m: 右边点数, e: 边数
    cin >> n >> m >> e;
    
    for (int i = 0; i < e; i++) {
        int u, v;
        cin >> u >> v;
        // 假设输入是 1-based index，如果题目要求，这里可能要做调整
        addEdge(u, v);
    }
    
    cout << hungarian(n) << endl;
    return 0;
}

import heapq

class PriorityQueue:
    def __init__(self):
        self._queue = []
        self._index = 0

    def push(self, item, priority):
        # heapq是最小堆，所以我们存入一个元组 (priority, index, item)
        # index 是为了在优先级相同时，保持插入顺序
        heapq.heappush(self._queue, (priority, self._index, item))
        self._index += 1

    def pop(self):
        # heappop总是返回优先级最小的元素
        return heapq.heappop(self._queue)[-1]

    def is_empty(self):
        return not self._queue

# 示例
pq = PriorityQueue()
pq.push("任务A", 3)
pq.push("任务B", 1)
pq.push("任务C", 2)

print("按优先级顺序处理任务:")
while not pq.is_empty():
    print(pq.pop())  # 输出: 任务B, 任务C, 任务A

class DisjointSet {
public:
    DisjointSet(int n): n_(n), components(n) {
        parent = new int[n];
        sz = new int[n];
        for (int i = 0; i < n; ++i) { parent[i] = i; sz[i] = 1; }
    }
    ~DisjointSet() {
        delete[] parent;
        delete[] sz;
    }
    int find(int x) {
        while (parent[x] != x) {
            parent[x] = parent[parent[x]];
            x = parent[x];
        }
        return x;
    }
    bool unite(int a, int b) {
        int ra = find(a), rb = find(b);
        if (ra == rb) return false;
        if (sz[ra] < sz[rb]) { int t = ra; ra = rb; rb = t; }
        parent[rb] = ra;
        sz[ra] += sz[rb];
        --components;
        return true;
    }
    bool same(int a, int b) { return find(a) == find(b); }
    int set_size(int x) { return sz[find(x)]; }
    int count() const { return components; }
private:
    int n_;
    int* parent;
    int* sz;
    int components;
};

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>

using namespace std;

struct Point {
    vector<int> coords;
    int id;
};

struct Node {
    Point point;
    Node *left = nullptr;
    Node *right = nullptr;
    int axis;

    Node(Point p, int ax) : point(p), axis(ax) {}
};

// 计算两点间的欧几里得距离平方
double distSq(const Point& a, const Point& b) {
    double sum = 0;
    for (size_t i = 0; i < a.coords.size(); ++i) {
        double diff = a.coords[i] - b.coords[i];
        sum += diff * diff;
    }
    return sum;
}

// 构建 KD-Tree
Node* buildKDTree(vector<Point>& points, int depth) {
    if (points.empty()) return nullptr;

    int k = points[0].coords.size();
    int axis = depth % k;

    // 根据当前轴排序
    sort(points.begin(), points.end(), [axis](const Point& a, const Point& b) {
        return a.coords[axis] < b.coords[axis];
    });

    int mid = points.size() / 2;
    Node* node = new Node(points[mid], axis);

    vector<Point> leftPoints(points.begin(), points.begin() + mid);
    vector<Point> rightPoints(points.begin() + mid + 1, points.end());

    node->left = buildKDTree(leftPoints, depth + 1);
    node->right = buildKDTree(rightPoints, depth + 1);

    return node;
}

// 最近邻搜索
void nearestNeighbor(Node* root, const Point& target, Node*& best, double& minDistSq) {
    if (root == nullptr) return;

    double d = distSq(root->point, target);
    if (d < minDistSq) {
        minDistSq = d;
        best = root;
    }

    int axis = root->axis;
    double diff = target.coords[axis] - root->point.coords[axis];
    
    // 优先搜索可能更近的一侧
    Node* near = (diff < 0) ? root->left : root->right;
    Node* far = (diff < 0) ? root->right : root->left;

    nearestNeighbor(near, target, best, minDistSq);

    // 如果分割平面与当前最小球相交，则需要搜索另一侧
    if (diff * diff < minDistSq) {
        nearestNeighbor(far, target, best, minDistSq);
    }
}

int main() {
    vector<Point> points = {
        {{2, 3}, 1}, {{5, 4}, 2}, {{9, 6}, 3}, {{4, 7}, 4}, {{8, 1}, 5}, {{7, 2}, 6}
    };

    Node* root = buildKDTree(points, 0);

    Point target = {{9, 2}, 0};
    Node* best = nullptr;
    double minDistSq = 1e9;

    nearestNeighbor(root, target, best, minDistSq);

    cout << "Nearest point: (" << best->point.coords[0] << ", " << best->point.coords[1] << ")" << endl;
    cout << "Distance squared: " << minDistSq << endl;

    return 0;
}