sudo add-apt-repository ppa:webupd8team/sublime-text-2
sudo apt-get update
sudo apt-get install sublime-text-2
假设字体文件夹为：～/Fonts。执行：
sudo mkdir -p /usr/share/fonts/myFonts
sudo cp ~/Fonts/*.ttf /usr/share/fonts/myFonts/
sudo chmod 644 /usr/share/fonts/myFonts/*.ttf
cd /usr/share/fonts/winFonts/
sudo mkfontscale #创建雅黑字体的fonts.scale文件，它用来控制字体旋转缩放
sudo mkfontdir #创建雅黑字体的fonts.dir文件，它用来控制字体粗斜体产生
sudo fc-cache -fv #建立字体缓存信息，也就是让系统认识雅黑
答案来自 StackOverflow:
sudo dpkg --remove --force-remove-reinstreq <your package name>
各种坑爹，我也不知道为什么：
sudo gedit etc/apt/apt.conf.d/00aptitude
最后加一行：Acquire::CompressionTypes::Order "gz";
修改 /etc/mysql/my.cnf：
[client]
default-character-set=utf8
[mysqld]
character_set_server=utf8
[mysql]
default-character-set=utf8
然后 sudo service mysql restart
真是巧妙的算法！
比起树上倍增，Tarjan 算法实现起来更为简单，一个 DFS 加并查集即可。缺点便是：需要先把所有的查询都读进来，并且要储存结果。复杂度为 $O(n+q)$。
Code
var
sets: array [1..100] of longint;
visited: array [1..100] of Boolean;
a: array [1..100, 1..100] of Boolean;
questions: array [1..1000] of record
x, y: longint;
ans: longint;
end;
qn, n, i, m, x, y, root: longint;
function find(x: longint): longint;
begin
if x = sets[x] then exit(x);
sets[x] := find(sets[x]);
exit(sets[x]);
end;
procedure dfs(x: longint);
var
i: longint;
begin
visited[x] := true;
//对于两个节点都已访问到的询问，其结果已经出来了
for i := 1 to qn do
begin
if visited[questions[i].x] and visited[questions[i].y] then
if questions[i].x = x then
questions[i].ans := find(questions[i].y)
else if questions[i].y = x then
questions[i].ans := find(questions[i].x);
end;
for i := 1 to n do
begin
if not a[i, x] or visited[i] then continue;
dfs(i);
sets[find(i)] := x;
end;
end;
begin
assign(input, 'main.in'); reset(input);
assign(output, 'main.out'); rewrite(output);
read(n, m);
for i := 1 to n do
sets[i] := i;
for i := 1 to m do
begin
read(x, y);
a[x, y] := true;
a[y, x] := True;
end;
read(root);
qn := 0;
while not eof do
begin
inc(qn);
read(questions[qn].x, questions[qn].y);
end;
dfs(root);
for i := 1 to qn do
writeln(questions[i].ans);
close(input); close(output);
end.
LCA 树上倍增
zhvar
a: array [1..100, 1..100] of boolean;
depth: array [1..100] of longint;
father: array [1..100, 0..16] of longint;
n, m, i, x, y: longint;
root: longint;
procedure dfs(x: longint);
var
i: longint;
j: longint;
begin
depth[x] := depth[father[x][0]]+1;
j := 1;
while 1<<j<=depth[x]-1 do
begin
father[x][j] := father[father[x][j-1]][j-1];
inc(j);
end;
for i := 1 to n do
begin
if not a[x][i] or (father[x][0] = i) then continue;
father[i][0] := x;
dfs(i);
end;
end;
procedure swap(var x, y: longint);
var
t: longint;
begin
t := x;
x := y;
y := t;
end;
function lca(x, y: longint): longint;
var
t, j: longint;
begin
if depth[x] < depth[y] then
swap(x, y);
t := depth[x] - depth[y];
for j := 0 to 15 do
if t and (1<<j) <> 0 then
x := father[x][j];
if x = y then
exit(x);
for j := 15 downto 0 do
if father[x][j] <> father[y][j] then
begin
x := father[x][j];
y := father[y][j];
end;
lca := father[x][0];
end;
begin
assign(input, 'main.in'); reset(input);
assign(output, 'main.out'); rewrite(output);
read(n, m);
for i := 1 to m do
begin
read(x, y);
a[x, y] := true;
a[y, x] := true;
end;
read(root);
father[root][0] := root;
dfs(root);
while not eof do
begin
read(x, y);
writeln(lca(x, y));
end;
close(input); close(output);
end.
问题描述
已知数组 a 以及若干个查询 $(x, y)$，求 $a[x..y]$ 之间的最小值。
分析
不难发现：若取 t 使得$2^t\leq y-x+1$且$2^{t+1}>y-x+1$，则有：
$$[x, x+t]\bigcup[y-t+1,y]=[x,y]$$
运用二进制的思想，我们只需预处理出 $i..i+2^k-1$ 之间的最小值，即可快速完成查询。设 $dp[i][j]$ 为 $i..i+2^j-1$ 之间的最小值，则有：
$$dp[i][j]=min(dp[i][j-1],dp[i+2^{j-1}][j-1])$$
Code
var
a: array [1..100000] of longint;
dp: array [1..100000, 0..20] of longint;
n, i: longint;
function min(x, y: longint): longint;
begin
if x < y then exit(x) else exit(y);
end;
procedure init;
var
i, j: longint;
begin
for i := 1 to n do dp[i, 0] := a[i];
j := 1;
while 1<<j-1<=n do
begin
for i := 1 to n-1<<(j-1) do
dp[i, j] := min(dp[i, j-1], dp[i+1<<(j-1), j-1]);
inc(j);
end;
end;
function query(x, y: longint): longint;
var
t: longint;
begin
t := 0;
while (1<<(t+1)<=y-x+1) do inc(t);
query := min(dp[x][t], dp[y-(1<<t)+1][t]);
end;
var
x, y: longint;
begin
assign(input, 'main.in'); reset(input);
assign(output, 'main.out'); rewrite(output);
readln(n);
for i := 1 to n do read(a[i]);
init;
while not eof do
begin
read(x, y);
writeln(query(X, y));
end;
close(input); close(output);
end.
树状数组
zh介绍
所谓树状数组，就是将线性的数组预处理成树状的结构以降低时间复杂度。先来看一幅经典的图： 
其中的 a 数组为原生数组，c 数组为辅助数组，计算方式为：
$$c_1=a_1——{(1)}_{10}={(1)}_2$$ $$c_2=a_2+c_1——{(2)}_{10}={(10)}_2$$ $$\ldots$$
不难发现，$c_k$存储的实际上是从 $k$ 开始向前数 $k$ 的二进制表示中右边第一个 $1$ 所代表的数字个元素的和。这样写的好处便是可以利用位运算轻松计算 sum。上代码。
Code
var
n, i: longint;
a, c: array [1..10000] of longint;
//计算x最右边的1所代表的数字。
//如：lowbit(0b1100)=0b100
function lowbit(x: longint): longint;
begin
lowbit := x and (-x);
end;
//给a[index]加上x
procedure add(index, x: longint);
begin
inc(a[index], x);
while index<=n do
begin
inc(c[index], x);
inc(index, lowbit(index));
end;
end;
//求a[1~index]的和
function sum(index: longint): longint;
begin
sum := 0;
while index>0 do
begin
inc(sum, c[index]);
dec(index, lowbit(index));
end;
end;
var
s: longint;
op: longint;
x,y: longint;
begin
assign(input, 'main.in'); reset(input);
assign(output, 'main.out'); rewrite(output);
readln(n);
for i := 1 to n do
begin
read(a[i]);
add(i, a[i]);
end;
while not eof do
begin
read(op);
if op = 1 then //添加操作
begin
read(x, y);
Add(x, y);
end
else //求和操作
begin
read(s);
writeln(sum(s));
end;
end;
close(input); close(output);
end.
二进制的启示
zh在学习数论时我们都知道：只用 2 的幂次可以组合出所有的正整数。这便是二进制的魅力——状态简单而又变化万千。
引子
实际算法中，常常有一些线性的但数据量特别大的问题，如区间求和、求最小值等。很多时候，为了把时间复杂度从 $O(n^2)$ 甚至更高的地方降下来，我们需要对数据进行一些预处理，以提高计算的速度。在这其中，有很大一部分是来自二进制运算特点的启发。
