About My Codestyle

记录下自己的代码风格吧，虽然挺丑的。

---

头文件#

从短到长依次编写，不打空格，常用头文件一般留7，8个，不写万能头。

Copy
#include<cmath>
#include<ctime>
#include<queue>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
...

宏定义#

不常用，只用来简化部分代码，（宏定义慎用）

Copy
#define debug() puts("FBI WARNING!") 
#define ll long long
#define ull unsigned long long
#define ls tree[p].l_son
#define rs tree[p].r_son
...

常用模板#

• 快读

Copy
inline int read(){
	int f = 1,x = 0; char ch;
	do { ch = getchar(); if(ch == '-')f = -1; } while (ch < '0' || ch > '9');
	do {x = x*10+ch-'0'; ch = getchar(); } while (ch >= '0' && ch <= '9');
	return f*x;
}

• 快速幂 + 快速乘

Copy
inline ull jia_fa(ull a,ull k,ull p){//快速乘 
	ull ans = 0;
	for(ull i = k; i; i >>= 1, a = (a+a)%p)
		if (i & 1) ans = (ans+a)%p;
	return ans;
}
inline ull pows(ull a, ull b, ull p) {//快速幂进制位实现 
	ull ans = 1;
	while (b) {
		if(b & 1) ans = jia_fa(ans, a, p);
		a = jia_fa(a, a, p), b /= 2;
	}
	return ans;
}

主体 & 细节#

• 申明全局常量用const，不用#define。
• 函数之间空行。
• 大括号不换行。
• 赋值，逻辑运算符左右空格。
• 逗号后空格。
• 命名变量，函数随缘，部分变量过多元素，用下划线隔开。
• bool变量用0和1。
• 数据结构喜欢用$namespace$。
• 喜欢用$switch$。

待补充。。。

码风一览#

题目：二逼平衡树

Copy
#include <cstdio>
#include <cstdlib>

const int MAX = 100000 + 5; 
const int INF = 0x7fffffff;
int n, m, a[MAX];

namespace TOOL {
	
	inline int read(){
		int f = 1, x = 0;char ch;
		do { ch = getchar(); if (ch == '-') f = -1; } while (ch < '0'||ch>'9');
		do {x = x*10+ch-'0'; ch = getchar(); } while (ch >= '0' && ch <= '9'); 
		return f*x;
	}
	
	int randoms() {
	    static int seed = 23333;
	    return seed = (int)seed * 482711LL % INF; 
	}
	
	inline int max(int a, int b) { return a > b ? a : b; }
	
	inline int min(int a, int b) { return a < b ? a : b; }
	
}using namespace TOOL;


namespace TREAP {
	
	struct Treap {
		int l, r;
		int cnt, rd, size, val;
	}sak[MAX * 20];
	
	int root, pos;
	#define ls sak[p].l
	#define rs sak[p].r
	
	inline int create(int val) {
		++pos;
		sak[pos].val = val;
		sak[pos].rd = randoms();
		sak[pos].cnt = sak[pos].size = 1;
		sak[pos].l = sak[pos].r = 0;
		return pos;
	}
	
	inline void push_up(int p) {
		sak[p].size = sak[ls].size + sak[rs].size + sak[p].cnt;
	}
	
/*	
	inline void tre_build() {
		create(-INF), create(INF);
		root = 1, sak[1].r = 2;
		push_up(root);
	}
*/	

	inline void zig(int &p) {
		int q = ls;
		ls = sak[q].r;
		sak[q].r = p;
		p = q;
		push_up(rs), push_up(p);
	}
	
	inline void zag(int &p) {
		int q = rs;
		rs = sak[q].l;
		sak[q].l = p;
		p = q;
		push_up(ls), push_up(p);
	}

	inline void insert(int &p, int val) {
		if (p == 0) {
			p = create(val);
		}
		else if (val == sak[p].val) {
			sak[p].cnt++;
			push_up(p);
			return;
		}
		else {
			if (val < sak[p].val) {
				insert(ls, val);
				if (sak[p].rd < sak[ls].rd) zig(p);
			}
			else {
				insert(rs, val);
				if (sak[p].rd < sak[rs].rd) zag(p);
			}			
		}
		push_up(p);
	}
	
	inline void remove(int &p, int val) {
		if (p == 0) return;
		if (val == sak[p].val) {
			if (sak[p].cnt > 1) {
				sak[p].cnt--;
				push_up(p);
				return;
			}
			if (ls || rs) {
				if (rs == 0 || sak[ls].rd > sak[rs].rd) {
					zig(p), remove(rs, val);
				}
				else {
					zag(p), remove(ls, val);
				}
				push_up(p);
			}
			else p = 0;
			return;
		}
		val < sak[p].val ? remove(ls, val) : remove(rs, val);
		push_up(p);
		return;
	}	
	
	inline int get_rank(int p, int val){
		if (p == 0) return 0;
		if (val == sak[p].val) return sak[ls].size;
		if (val < sak[p].val) return get_rank(ls, val);
		return get_rank(rs, val) + sak[ls].size + sak[p].cnt;
	}
	
	inline int get_val (int p, int rank) {
		if (sak[ls].size >= rank) return get_val(ls, rank);
		if (sak[ls].size + sak[p].cnt >= rank) return sak[p].val;
		return get_val(rs, rank - sak[ls].size - sak[p].cnt);
	}

	inline int get_pre(int p, int val) {
		if (!p) return -INF;
		if (sak[p].val >= val) 
			return get_pre(ls, val);
		else return max(sak[p].val, get_pre(rs, val));	
	}
	
	inline int get_next(int p, int val) {
		if (!p) return INF;
		if (sak[p].val <= val) 
			return get_next(rs, val);
		else return min(sak[p].val, get_next(ls, val));			
	}
}using namespace TREAP;

namespace SEGMENT{
	struct Segment{
		int l, r;
		int root;
	}tree[4*MAX];
	
	inline void seg_build(int p, int l, int r) {
		tree[p].l = l, tree[p].r = r;
		for (int i = l;i <= r; ++i) {
			insert(tree[p].root, a[i]);
		}
		if (l == r) return;
		int mid = (l + r) >> 1;
		seg_build(p << 1, l, mid);
		seg_build((p << 1) | 1, mid + 1, r);
	}
	
	inline void change(int p, int x, int k) {
		remove(tree[p].root, a[x]);
		insert(tree[p].root, k);
		if (tree[p].l == tree[p].r) return;
		int mid = (tree[p].l + tree[p].r) >> 1;
		if (x <= mid) change(p << 1, x, k);
		else change((p << 1) | 1, x, k);		
	}
	
	inline int ask_rank(int p, int l, int r, int k) {
		if (tree[p].l > r || tree[p].r < l) 
			return 0;
		if (tree[p].l >= l && tree[p].r <= r) {
			return get_rank(tree[p].root, k);
		}
		else return ask_rank(p << 1, l, r, k) + ask_rank((p << 1) | 1, l, r, k);
	}
	
	inline int ask_val(int l, int r, int k) {
		int x = 0, y = 1e8;
		while (x < y) {
			int mid = (x + y + 1) >> 1;
			if (ask_rank(1, l, r, mid) < k) {
				x = mid;
			}
			else y = mid - 1;
		}
		return y;
	}
	
	inline int ask_pre(int p, int l, int r, int k) {
		if (tree[p].l > r || tree[p].r < l) return -INF;	
		if (tree[p].l >= l && tree[p].r <= r) 
			return get_pre(tree[p].root, k);
		else return max(ask_pre(p << 1, l, r, k), ask_pre((p << 1) | 1, l, r, k)); 
	}
	
	inline int ask_next(int p, int l, int r, int k) {
		if (tree[p].l > r || tree[p].r < l) return INF;	
		if (tree[p].l >= l && tree[p].r <= r) 
			return get_next(tree[p].root, k);
		else return min(ask_next(p << 1, l, r, k), ask_next((p << 1) | 1, l, r, k)); 			
	}
}using namespace SEGMENT;

int main(){
	n = read(), m = read();
	for (int i = 1;i <= n; ++i) a[i] = read();
	seg_build(1, 1, n);
	while (m--) {
		int opt = read();
		switch(opt) {
			case 1: {
				int l = read(), r = read(), k = read();
				printf("%d\n", ask_rank(1, l, r, k) + 1);
				break;
			}
			case 2: {
				int l = read(), r = read(), k = read();
				printf("%d\n", ask_val(l, r, k));
				break;
			}
			case 3: {
				int x= read(), y = read();
				change(1, x, y);
				a[x] = y;
				break;
			}
			case 4: {
				int l = read(), r = read(), k = read();				
				printf("%d\n", ask_pre(1, l, r, k));
				break;
			}
			case 5: {
				int l = read(), r = read(), k = read();				
				printf("%d\n", ask_next(1, l, r, k));
				break;
			}
		}
	}
	return 0;
}