NOIP前 基础算法模板

/*
	created by scarlyw
	基础算法模板 
*/
#include <bits/stdc++.h>

const int MAXN = 100000 + 10;
//排序
namespace sort {
inline void int_sort() {
	static int n;
	static int a[MAXN]; 
	std::cin >> n;
	for (int i = 1; i <= n; ++i) std::cin >> a[i];
	std::sort(a + 1, a + n + 1);	
}

struct data {
	int x, y, z;
	inline bool operator < (const data &a) const {
		return (x == a.x) ? ((y == a.y) ? (z < a.z) : (y < a.y)) : (x < a.x);
		//x第一关键字，y第二关键字，z第三关键字 
	}
} ; 
//多关键字排序 
inline void struct_sort () {
	static int n;
	static data a[MAXN];
	std::cin >> n;
	for (int i = 1; i <= n; ++i) std::cin >> a[i].x >> a[i].y >> a[i].z;
	std::sort(a + 1, a + n + 1);
}
}
 
//逆序对
namespace inverse_pair() {

//归并排序求逆序对 （ans为答案） 
inline void merge_sort(int l, int r) {
	if (l == r) return ;
	static int b[MAXN];
	int mid = l + r >> 1;
	merge_sort(l, mid), merge_sort(mid + 1, r);
	int i = l, j = mid + 1, cur = l;
	while (i <= mid && j <= r) {
		if (a[j] < a[i]) ans += mid - i + 1, b[cur++] = a[j++];
		else b[cur++] = a[i++];
	}
	while (i <= mid) b[cur++] = a[i++];
	while (j <= r) b[cur++] = a[j++];
	for (int i = l; i <= r; ++i) a[i] = b[i];
}

//树状数组求逆序对 (solve()返回逆序对数) 
struct binary_indexed_tree {
	const int MAXX = 100000;
	int bit[MAXN];
	inline int lowbit(int i) {
		return i & -i;
	}
	
	inline void add(int i) {
		for (; i <= MAXX; i += lowbit(i)) bit[i]++;
	}
	
	inline int query(int i) {
		int ans = 0;
		for (; i; i -= lowbit(i)) ans += bit[i];
		return ans;
	}
	
	inline long long solve() {
		std::cin >> n;
		long long ans = 0;
		for (int i = 1; i <= n; ++i) std::cin >> a[i];
		for (int i = 1; i <= n; ++i)
			ans += (i - 1 - query(a[i])), add(a[i]);
		return ans;
	}
} bit;
}

//中位数
namespace middle_number {

//直接nth_element实现，return为中位数 
inline int get_middle_number() {
	static int n;
	static int a[MAXN];
	std::cin >> n;
	for (int i = 1; i <= n; ++i) std::cin >> a[i];
	if (n & 1) {
		std::nth_element(a + 1, a + n / 2 + 1, a + n + 1);
		return a[n / 2 + 1];
	} else {
		double x;
		std::nth_element(a + 1, a + n / 2, a + n + 1), x = a[n / 2];
		std::nth_element(a + 1, a + n / 2 + 1, a + n + 1), x += a[n / 2 + 1];
		x /= 2;
		return x;
	}
}
}

//离散化 
namespace s_apart {

//num存储原来的大小，ori是原数组编号 
struct data {
	int num, ori;
	inline bool operator < (const data &a) const {
		return num < a.num;
	}
} b[MAXN];

//a数组中是离散化后的 
inline void apart(data *b, int *a, int n) {
	std::sort(b + 1, b + n + 1);
	int i = 1;
	while (i <= n) {
		int j = i;
		while (b[i + 1].num == b[i].num) {
			if (i == n) break ;
			++i;
		}
		++top;
		for (int k = j; k <= i; ++k) a[b[k].ori] = top;
		++i;
	}
}
}

//二分 & 三分 
namespace cut {
//二分
inline int binary() {
	int l = 0, r = n + 1;
	while (l + 1 < r) {
		int mid = l + r >> 1;
		if (check(mid)) l = mid;
		else r = mid;
	}
	return l;
}

//三分 
inline double trisection() {
	double l = 0, r = n + 1;
	while (l + eps < r) {
		double mid1 = l + (r - l) / 3, mid2 = r - (r - l) / 3;
		if (better(calc(mid1), calc(mid2))) r = mid2;
		else l = mid1;
	}
	return better(calc(l), calc(r)) ? l : r;
}
}