puts("\033[0;34m这些字会是蓝色的，\033[0m而这些字是正常的。\n");

上面那段代码中，前半句的文字是蓝色的，后半句是正常的。其奥秘就在 \033[0;34m 和 \033[0m 这两串东西里，前者表示随后输出的字符串都以蓝色显示，后者表示随后输出的字符串都以默认方式显示。

那如果需要其它的颜色怎么办呢？其实还是输出类似 \033[0;#m 这样的字符串，只要把里面的 # 改成代表颜色的数字即可：

可以看出来，上面的例子中的参数是 34, 对应着表中的蓝色，所以输出的字符当然是蓝色的啦。

事实上，Linux 的 Console 支持的文字样式还远不止这些。比如，如果你想让接下来的字符都是粗体字，那么输出 \033[1m 即可；如果你想要其它颜色的粗体字，输出 \033[1;#m 字符串，其中 # 对应着上面表中的颜色就行了。

所以似乎 \033 的参数是这样组织的：\033[@;#m . 其中，@ 代表一个数字，表示字体样式；而 # 又代表一个数字，表示字体的颜色（字体的颜色是可选参数，也就是说，如果 ;#m 部分不写出来，就代表默认颜色）。然而现在我们已经知道了 # 能够写什么，而且 @ 我们也已经知道，0 代表普通样式，1 代表粗体。那 @ 还能是什么呢？看下表：

这样一来，我们能够在 Linux 控制台上使用的文字格式就丰富多了。其实有的时候我们还是不会满足，比如，同时使用粗体和下划线，应该怎么做呢？一种方法是在 \033[1m 之后紧随一个 \033[4m .

还有一些特别奇葩的光标控制输出，列表如下：

A – A Very Simple Problem

一开始，我非常自然地去看 A 题（HUST 1563）。题目中的配图光荣地挂了，我就用 Chrome 的 Inspect Element, 看到了题号，然后到稳定版的 OJ 下看原题，就好了。A 题说的是一个三维空间里，一个 a × b × c 的立方体里，有一个半径为 r 的球，其球心坐标在 (x, y, z) 处。题目保证球不会和立方体产生切割，也不会在立方体之外。然后给球一个 (u, v, w) 的初速，问你在 t 单位时间后，球心位置在哪里。其中，球的任何碰撞都是完全弹性碰撞，不会损耗任何动能，并且不计任何摩擦，任何的反弹都遵循光的反射原理。

其实大体上这题的思路不难。将三个维度分开考虑，以下只考虑第一个维度，其它维度类似。因为球是有半径的东西，所以球心的范围是 [r, a - r], 所以其实可以把 a 减掉两个 r, 然后把 x 减掉 r, 之后再把位置加回来即可。其中会用到一个浮点数求余的函数，叫 fmod. 其实也可以自己写这么一个函数。嗯，然后 tricks 是，可能立方体会紧紧包住这个球，还有速度可能是负的。

事实证明我一开始开这道题是错误的选择，因为其实还有更水的题目在等着我。

C – Sudoku

这道题（HUST 1565）乍一看还以为是特别难的题目，其实是一道猥琐的模拟题，题意不够清晰。主要的意思是，给出一个数独，然后对于一些空位，看看从行列和区域能否推断出这个空位的唯一结果。而且只能“推一步”，还要检查能不能推出来，是否有矛盾等。因为小 bug 我 WA 了多次，其实都是不应该的啊。

E – Snowflakes in YangShen’s Home

这道题（HUST 1574）我认为是这次比赛中最水的题目，杀鸡用牛刀般地用了 STL 里的 stable_sort, 轻易地过了。

F – Next K-Bit Number

这道题（HUST 1568）的题意是，给出一个数字，它的二进制表示里有 k 个 1, 然后你要找出一个比这个数大的，且二进制表示里也有 k 个 1 的数中的，最小的那个数。我的策略是，从低位到高位找到第一次出现的 1, 然后再往高位找到第一次出现的 0, 假设右边（低位）有 n 个 1, 取其中一个取代之前找到那个 0, 然后把剩余的 (n – 1) 个 1 全部挤到右边去。

H – Lazy. Lazy. Laaaaaaaaaaaazy!

这道题（HUST 1570）是一道动规题，但是我一开始很 naive 地没有把它当成动规来写，以为是一道水题，我真是 too simple 了。题意大概是，让你打一串有大写有小写的文字，有 CAPSLOCK 和 SHIFT 两种大小写切换方法，问你最少需要按几下按键。

动规的状态是 dp[i][j], 其含义是打完第 j 个字符之后，且 CAPSLOCK 状态是 i, 需要按键数量最少是几次。其中 i 显然可取 0 和 1 啦。

L – Polynomial Integration

这道题（HUST 1575）算挺水的吧，要求计算多项式函数定积分的值，只要注意 [latex]\int x^{-1} \mathrm{d}x = \ln\left\vert x \right\vert[/latex] 就可以了。

M – Extractor

这道题（HUST 1576）其实也很水，我只看了样例就写过了。没看题，就不描述题意了。

原题地址：http://poj.org/problem?id=2387

我是为了测试用堆优化了的 Dijkstra 算法，才写的这道题。代码前几次犯了一些很 naive 的错误，不过居然有的数据也能对，很神奇。最杯具的事情是，这个用堆优化过的代码，使用了大量的 STL 容器，导致运行时间达到了 235ms 之巨。瞬间感觉堆的优势就因 STL 而消失殆尽了。

源代码如下：

#include <algorithm>
#include <iostream>
#include <climits>
#include <vector>
#include <list>
using namespace std;
struct stl_glist
{
    struct edge_type {
        int first, second; int length;
        edge_type(int f, int s, int l) : first(f), second(s), length(l) { }
    };
    static const int inf;
    vector<list<int> > ves;
    vector<edge_type> es;
    inline void reset(int n) {
        ves.clear(); es.clear();
        ves.resize(n);
    }
    inline void insert(int u, int v, int w) {
        ves[u].push_back(es.size());
        ves[v].push_back(es.size());
        es.push_back(edge_type(u, v, w));
    }
};
struct stl_dijkstra
{
    const stl_glist &g;
    vector<int> dist, v2hi, heap, prev;
    vector<bool> vstd;
    inline stl_dijkstra(const stl_glist &g) : g(g) { }
    inline void heap_swap(int i, int j) {
        swap(v2hi[heap[i]], v2hi[heap[j]]);
        swap(heap[i], heap[j]);
    }
    inline void heap_push(int i) {
        v2hi[i] = heap.size();
        heap.push_back(i);
    }
    inline void heap_pop() {
        v2hi[heap.back()] = 0;
        heap.pop_back();
    }
    inline void min_heapify(size_t i)
    {
        size_t l = i << 1, r = l + 1, t = i;
        if (l < heap.size() && dist[heap[l]] < dist[heap[i]]) t = l;
        if (r < heap.size() && dist[heap[r]] < dist[heap[t]]) t = r;
        if (t != i) {
            heap_swap(i, t);
            min_heapify(t);
        }
    }
    inline void heap_decrease_key(int i, int val)
    {
        dist[heap[i]] = val;
        for (int p = i >> 1; i > 1 && dist[heap[p]] > dist[heap[i]];
                i = p, p = p >> 1) {
            heap_swap(i, p);
        }
    }
    inline void push_shorter(int v, int val) {
        int i = heap.size();
        if (v2hi[v] == 0) heap_push(v);
        else i = v2hi[v];
        heap_decrease_key(i, val);
    }
    inline int pop_shortest() {
        if (heap.size() <= 1) return -1;
        int result = heap[1]; vstd[result] = true;
        heap_swap(1, heap.size() - 1); heap_pop();
        min_heapify(1); return result;
    }
    inline void update_adjacent(int u)
    {
        const list<int> &esou = g.ves[u];
        for (list<int>::const_iterator e = esou.begin(); e != esou.end(); ++e) {
            const stl_glist::edge_type &ed = g.es[*e];
            int v = u == ed.first ? ed.second : ed.first;
            if (vstd[v]) continue;
            int len = ed.length + dist[u];
            if (dist[v] > len) {
                push_shorter(v, len);
                prev[v] = u;
            }
        }
    }
    inline void solve(int s)
    {
        dist.resize(g.ves.size()); fill(dist.begin(), dist.end(), stl_glist::inf);
        vstd.resize(g.ves.size()); fill(vstd.begin(), vstd.end(), false);
        v2hi.resize(g.ves.size()); fill(v2hi.begin(), v2hi.end(), 0);
        prev.resize(g.ves.size()); fill(prev.begin(), prev.end(), -1);
        heap.clear(); heap.reserve(g.ves.size() + 1); heap.push_back(0);
        push_shorter(s, 0);
        while ((s = pop_shortest()) >= 0)
            update_adjacent(s);
    }
};
const int stl_glist::inf = INT_MAX;
int main()
{
    int n, m; cin >> m >> n;
    stl_glist graph; stl_dijkstra dijkstra(graph);
    graph.reset(n);
    for (int i = 0; i < m; ++i) {
        int u, v; int w;
        cin >> u >> v >> w;
        graph.insert(--u, --v, w);
    }
    dijkstra.solve(0);
    cout << dijkstra.dist.back() << endl;
    return 0;
}

今天本来是想写一个带堆优化的 Dijkstra 算法的，我不愿意自己写一个堆，所以就打算用 STL 的相应代码来实现。据我目前所知，STL 里有两种方式维护一个堆，一种是用 priority_queue, 一种是用 make_heap, push_heap, pop_heap 一类的函数。由于 priority_queue 不能实现修改堆中的 key 操作（也就是最大堆中的 Increase-key, 或者最小堆中的 Decrease-key 操作），而且封装得太紧，所以我选用了后者。

由于 Dijkstra 算法中，有一步是要找到最小 dist 的那个顶点，这一步如果用堆优化，就可以把复杂度从 n 降为 1（其主要的开销在堆的维护上，所以总复杂度是 nlogn）。但是有的时候某些已知顶点 v 的 dist 是会改变的，所以这个时候需要把堆里与 v 对应的 key 进行修改。为了修改这个元素，首先要知道这个元素的下标为几何，这个时候可以维护一个数组，其下标为 v 的元素指向堆中相应的代表 v 的元素。这个时候麻烦就来了：如果对堆进行了修改，刚才所述的数组也同样需要修改。这个时候貌似 make_heap 之类的函数也无能为力了。

不过后来我想出了一个比较逆天的方法，专门为堆的元素设计了一个模板类 heds, 名字的全称是 Heap Element for Dijkstra using STL. 我想，在这个类的对象交换的时候，顺便维护一下那个数组，不就可以直接用 STL 的 make_heap 等函数了吗？

首先我做了一个实验，重写了这个 heds 类两个元素之间的 swap 函数。然后兴冲冲地调用了 make_heap 函数，发现 swap 根本没有被调用过。难道 make_heap 自己做了一个奇葩的交换函数么？然后我又观察到，make_heap 居然不会调用 heds 的构造函数，而会调用该类的 operator= , 所以就想通过重写等号运算符来解决。为了测试，我写了下面的代码：

#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
template <class T, T *dist, int **v2hi> struct heds
{
	int v;
	inline bool operator<(const heds &b) const {
		return dist[v] < dist[b.v];
	}
	inline heds &operator=(const heds &b) {
		v2hi[v] = (int *) &b; v = b.v;
	}
};
const int N = 10;
int *v2hi[N]; int dist[N];
heds <int, dist, v2hi> heap[N];
int main()
{
	for (int i = 0; i < N; ++i)
		heap[i].v = dist[i] = i;
	for (int i = 0; i < N; ++i)
		v2hi[i] = (int *) &heap[i];
	random_shuffle(dist, dist + N);
	make_heap(heap, heap + N);
	return 0;
}

结果我发现，在 make_heap 之后，v2hi 这个数组居然有一些元素都指向着同一个指针，且这个指针居然不属于 heap 数组的元素！其中的问题只可能出现在 v2hi[v] = (int *) &b; 这句话上。我认为，make_heap 为了交换两个元素，没有调用 swap, 而是使用了它自己维护的一种方法。这种方法也是使用了一个临时空间，但是这个临时空间居然没有调用它的构造函数。

或许我只能在 heds 类里再加一个成员变量，表示这个元素一开始的指针。这样即使是被 copy 出了临时变量，还可以知道原来的地址在哪里。如果 STL 的算法在交换元素的时候使用自己的函数该多好。

又是一次瞎折腾的过程……

原题地址：http://acm.sgu.ru/problem.php?contest=0&problem=101

其实看到这题后可以很快想到这是一个一笔画问题，其实就是欧拉回路和欧拉通路问题。判断欧拉回路或欧拉通路是否能存在，可以使用 O(V) 的算法实现。找到一条欧拉回路或欧拉通路，有一种算法叫 Fleury’s Algorithm, 复杂度是 O(V²). 但是其实有一种逆天的算法能在 O(V) 的时间内实现。

这道题有很多 tricks, 需要注意的有：

• 图是否是连通的。
• 有的时候输入数据没有把所有顶点用上，这时如果给出的顶点是连通的，那么也应该把图当成连通的。
• 图中是否有欧拉通路或欧拉回路。
• 如果只有欧拉通路，那么一定要选择正确的顶点开始遍历。
• 如果有欧拉回路，必须要从一个数据中给过的顶点开始遍历。

反正这些我是都栽了，绝对是忠告。

以下是源代码：

#include <list>
#include <vector>
#include <cstdio>
#include <utility>
#include <cstdlib>
using namespace std;
typedef list<int> lint;
typedef vector<int> vint;
typedef vector<lint> vlint;
typedef pair<int, int> prii;
typedef vector<prii> vprii;
typedef vector<bool> vbool;
int n;
vlint ves; // vertex to edges.
vprii es; // edges.
vbool vst; // vertex visited;
vbool est; // edge visited.
vint vstk; // vertex stack.
vint vrst; // vertex result.
vint estk; // edge stack.
vint erst; // edge result.
inline void init()
{
    ves.clear(); ves.resize(7);
    es.clear();
}
inline void insert(int u, int v)
{
    ves[u].push_back(es.size());
    ves[v].push_back(es.size());
    es.push_back(make_pair(u, v));
}
void search(int u)
{
    if (vst[u]) return; vst[u] = true;
    lint::iterator e; lint &ve = ves[u];
    for (e = ve.begin(); e != ve.end(); ++e)
    {
        int v = es[*e].first == u ? es[*e].second : es[*e].first;
        search(v);
    }
}
inline bool connected()
{
    vst.clear(); vst.resize(7, false);
    int c = 0, last_node;
    for (int i = 0; i < 7; ++i)
        if (ves[i].size() != 0)
            ++c, last_node = i;
    search(last_node);
    for (int i = 0; i < 7; ++i)
        if (vst[i])
            --c;
    return c == 0;
}
inline void tour(int u)
{
    tour_start:
    {
        lint::iterator e; lint &ve = ves[u];
        for (e = ve.begin(); e != ve.end(); ++e)
        {
            if (est[*e]) continue; est[*e] = true;
            u = es[*e].first == u ? es[*e].second : es[*e].first;
            break;
        }
        if (e == ve.end()) return;
        vstk.push_back(u);
        estk.push_back(*e);
    }
    goto tour_start;
}
inline void euler(int u)
{
    est.clear(); est.resize(es.size(), false);
    vrst.clear(); erst.clear();
    vstk.clear(); estk.clear();
    vstk.push_back(u);
    for (int i = 0; i < n; ++i)
    {
        tour(vstk.back());
        vrst.push_back(vstk.back()); vstk.pop_back();
        erst.push_back(estk.back()); estk.pop_back();
    }
    // vertices are one more than edges.
    // and there is vstk.back() == u.
    vrst.push_back(vstk.back()); vstk.pop_back();
}
inline int start()
{
    int odd_count = 0, last_odd = -1, last_node = -1;
    for (int i = 0; i < ves.size(); ++i) {
        if (ves[i].size() % 2 == 1)
            ++odd_count, last_odd = i;
        else if (ves[i].size() != 0)
            last_node = i;
    }
    if (odd_count == 0) return last_node;
    if (odd_count == 2) return last_odd;
    return -1;
}
int main()
{
    // freopen("101.domino.txt", "r", stdin);
    scanf("%d", &n); init();
    for (int i = 0; i < n; ++i)
    {
        int u, v; scanf("%d%d", &u, &v);
        insert(u, v);
    }
    int s; if (!connected() || (s = start()) == -1) {
        printf("No solution\n");
    } else {
        euler(s);
        for (int i = 0; i < erst.size(); ++i)
            printf("%d %c\n", erst[i] + 1,
                vrst[i] == es[erst[i]].first ? '+' : '-');
    }
    return 0;
}

然后我想起博客上的回复评论以前是有 AJAX 的，现在都没发现。这是很奇怪的事情。开始以为是 WordPress 更新之后，我的老主题 out 了，不兼容了。好吧，经过各种折腾，其实不是主题的问题，而是用了 WP Minify 导致的。这个插件把各种 JavaScript 脚本和 CSS 整合成一个文件，可以加快网页读取速度。后来我在其设置页上把 comment-reply 给排除了，就好了。顺便排除了 Image Lazy Load, 这样久违的延迟载入功能又回来了。我猜出现这样的原因可能是我的某个 JavaScript 有问题，连累了其它的文件吧。

到了金华已是中午 12 点多，和叶总寒暄几句后，马上赶到浙江师范大学，那个热啊，真是符合热身赛的精神了。比赛场地是在机房，有两层，不过据说下半年的区域赛会在新建的体育馆内举行。找到位置后，两个队友过于兴奋，居然看到桌上的信封就想拿，那可是题目啊，比赛还没开始。

热身赛的第一题就这样过了，然后第二题是一个所谓的“最小费用最大流”，我居然从来没做过。然后拍 Wideas 的模板，最后 TLE 了。想想只不过是热热身，就下去看我校另一队——火腿队的战况。他们也差不多，正在奋战 BC 两题。好吧后来据说火腿队用模拟的方法过了 C.

下午去宾馆，由于这次我们居然来了个女生，当然是得住单间的。然后这样男生也成了奇数，所以让翔哥住单间尊贵了一次。说好的巧克力和咖啡晚上都没买。唉，算了，无功不受禄。

第二天早上，闹铃还没响，我在 6 点 15 分左右就起床了。按照舍友 SBH 的标准，所谓“起晚”的定义，是没有听闹铃而自然起床。所以我算是起晚了。然后校车去了比赛场地。

开始比赛后迅速看题。这 A 题怎么有点像最长公共子序列 (longest common sub-sequence) 呢？似乎又不是最长公共子序列，因为题目要求序列必须是连续的 (consecutive). 所以这应该叫最长公共子串 (longest common sub-string). 这是坑爹其一。当然还有坑爹其二：这题我们两个人提交了很多次，都 WA 了，卡到了 10 点 40 多分，居然开始了 rejudge… 结果我们 1A 了。

后来我发现了 E 是计算几何，还好我有清晰的模板，我就向队友表示：“如果你们不打字，就让我打计算几何模板吧。”结果打了一半，B 的思路有了，我就中断了。看到一题似乎是字符串匹配，数据范围 5M, 有点大，比赛时 too simple, sometimes naive 了，以为用 Trie 可以做，赛后 ZL 说会爆内存才意识到。在思考的过程中，B WA 了一次，然后过了。我就继续打计算几何。

调试的过程中，有的数据出错了。所幸还是发现了错误——模板里产生射线的函数我给写错了，少了个取绝对值，所以有的时候射线的方向就会很奇怪。后来还是略带紧张地 1A 了。

此时 LD 想写 D, 写就写吧。我就看那个 Trie 的模板啊，其实这也是无用功。然后 XW 问我那道棋盘的题的题意，我感觉没把握，就表示不敢开这道题。最后 D 那个线段树，LD 的样例都是对的，后来交上去 TLE 了。怒交怒 WA, 这样比赛就结束了。

最后的排名比火腿队稍微低了一点，罚时似乎多了 3 分钟。

浙江师范大学校门内的照片

出来在学校里逛了逛，发现正对大门有一尊孔子雕像，就想起了伟大领袖毛主席。随口问了一下旁边的志愿者同学，她说学校里是没有毛主席雕像的。第一次发现大学里也可以没有毛主席雕像啊。

之后回宾馆，WH 和 Sky Walker 等要做 Google Code Jam, 我感觉衬衫无望，就回校了。动车上各种八卦，在此省略千字。

最后是一点总结，参赛总结我一向不说优点，若是队友看到，不要往心里去啊。当然我也很欢迎队友能够数落一下我。

对自己，这次的比赛还是弱了点。轮到自己带别人，却没有非常充分发挥所谓队长的作用。首先个人算法还是比较稀松，居然让女生去打了 2 道题，差点让人家单挑了；如果能够对各种问题即使是有略微的了解的话，可能我来打会比较快一些，所以这点要向 Wideas 学习。然后对于一些决策上的事情，还是优柔寡断了，比如说开题比较随意。总的来说，要加强训练。

然后说说队友。共同的问题是语言，语言包含两方面，一个是编程语言，一个是英语。LD 高中竞赛用的是 Pascal, 只会很基础的 C 语言，指针什么的不会，更别说 STL 了，快排什么的都是直接手写，怎样把数组指针传递到函数里也不懂；写的程序不够结构化，别人看起来难以调试。相对来说 XW 在这方面好一些。然后是英语，虽然说我的英语也不是特别的好，但是在和 Wideas, WH 组队的时候，就没有带过词典啊。什么 bidirectional, corresponding 都来问我，真是替你们着急啊，看来下次是不是真的要带词典了呢？

很有意思的是这个比赛有一部分是 host 在 Codeforces 上的，似乎官方是俄文，和 Codeforces 国籍相同啊。

我在比赛开始后半个小时才意识到注册了这个比赛。当时还在 Google Camp 里，情急之中做了 2 题，然后看了 C 题才回的宿舍。

首先是 A 题，很水。当时看到 A2 的时候愣了一下，怎么会有一样的题目呢……后来经过肉眼逐字比对发现没有任何区别，我才知道被坑了。其实 A2 就是比 A1 数据范围大一点啊什么的罢了。

B 题，本质上就是分解质因数呗。

这个时候开始回宿舍，并且打了很长时间的电话回家，还在外面吃了东西，在空闲的时候想了想 C 题。一晃一个小时过去了……

C 题，我是用并查集解的。把所有的人看成节点，朋友关系看成无向边，显然每个连通分量都是一个朋友圈。然后如果在一个朋友圈内，如果有两个家伙不喜欢对方，那么其实这个朋友圈是不能聚起来的，所以就把这些圈子排除掉，最后找人数最多的圈子就可以了。

D 题思路很快就出来了，显然就是预处理密钥串，使得能够在常数时间计算从第 i 个元素加到第 j 个元素的结果。然后密文上的第一个元素，加上密钥的第一个元素；密文的第二个元素，加上密钥的第一和第二个元素；以此类推。但是在推“第 t 个元素应该加上密钥的第几到第几个元素”这个问题上，我推了很久……其实这不是很难的内容，说明还需训练啊。

E 题被它的“In some solutions even the 64-bit arithmetic can overflow”吓到了，其实注意一下，也没有那么恐怖。根据题意，有如下式子：

[latex] \LARGE \sum \limits_{i = 1}^{n} \lfloor \frac{x a_i}{b_i} \rfloor = c – n [/latex]

其中，我们要做的事情，就是求出 x 有多少整数解。在此之前我们需要考虑一些特殊情况。

比如，当所有的 a_i 都是 0, 并且 c = n 的时候，也就是说，每个星球都不能允许带包裹，并且星球的数目等于旅行天数时，x 有无数个解；如果第一个条件成立，而 c ≠ n 的时候，则 x 无解。因为没有判断 c ≠ n, 我 WA 了一次。

还有就是万一 c < n 什么的发生也是很恶心的，不知道数据有没有卡这些点，反正我是考虑了。

然后的问题就是求 x 了。求 x 其实可以想到用二分法，经过我的计算，一定有 x ≤ 10¹⁸. 但是其实这还不够，如果二分的上界就认为是这个数了，那么根据上面那个大大的等式，x·a_i 很容易超过 64-bit integer 的范围。

所以枚举上界的时候，要令 [latex] upper(x) = \frac{10^{18}}{max\{a_i\}} [/latex] 才可以。但是这个时候，我居然让 x 去除以每个 a_i, 然后比较哪个比较小，其实这样是有问题的，如果 a_i 含有 0, 那就会出现被 0 除的情况。所以我在这里 WA 了一次。更 2 的事情，是我该的时候居然该成了“如果 a_i 是 0 则不除”这样的方法，而不是之前的 max 方法……不过最后还是过了。

下面是 E 的代码：

#include <cstdio>
#include <iostream>
using namespace std;
typedef long long ll;
const int N = 11111;
ll n, a[N], b[N], c;
inline ll calc(ll x)
{
    ll result = 0ll;
    for (int i = 0; i < n; ++i)
        result += x * a[i] / b[i];
    return result;
}
inline ll lower(ll r, ll cmn)
{
    ll l = 0ll;
    while (r - l > 1ll)
    {
        ll m = (l + r) >> 1;
        if (calc(m) >= cmn)
            r = m;
        else
            l = m;
    }
    return r;
}
inline ll upper(ll r, ll cmn)
{
    ll l = 0ll;
    while (r - l > 1ll)
    {
        ll m = (l + r) >> 1;
        if (calc(m) <= cmn)
            l = m;
        else
            r = m;
    }
    return l;
}
int main()
{
    // freopen("E1.in", "r", stdin);
    cin >> n >> c;
    for (int i = 0; i < n; ++i)
        cin >> a[i] >> b[i];
    bool allzero = true;
    for (int i = 0; i < n; ++i)
        if (a[i] != 0)
            allzero = false;
    if (allzero) // unlimited sols.
    {
        if (c != n)
            cout << 0 << endl;
        else
            cout << -1 << endl;
        return 0;
    }
    ll maxx = 1111111111111111112ll;
    for (int i = 0; i < n; ++i)
    {
        if (a[i] == 0)
            continue;
        ll t = 1111111111111111111ll / a[i];
        if (maxx > t)
            maxx = t;
    }
    ll cmn = c - n;
    if (cmn < 0) // no sols.
    {
        cout << 0 << endl;
        return 0;
    }
    ll lwr = lower(maxx, cmn);
    ll upr = upper(maxx, cmn);
    if (lwr > upr)
        cout << 0 << endl;
    else
        cout << upr - lwr + 1 << endl;
    return 0;
}

最后两题没有看。

后来我上网时发现有人说，如果把用户的 ID 改成 1000 以内的数字，就可以在 GDM 中自动隐藏这个用户。

更改用户 ID 可以用以下命令：

# usermod --uid 998 git

这样，git 用户的 ID 就会变成 998 了。

经过实际测试，git 用户确实不在登录管理器上显示了。

服务器上搭建 Git

首先服务器上得有 Git 和 SSH Server 吧。在 Arch Linux 上安装这两个软件：

~ # pacman -S git sshd

在服务器上创建 Git 的专有账户：

~ # useradd git

再去 /etc/passwd 里把 git 账号的 /bin/bash 改成 /usr/bin/git-shell , 这样的话，别人就只能通过这个账号进行 Git 操作，而不能使用命令行。

如果你发现在 GDM 的启动画面上多了个 git 账号不美观的话，去 /etc/gdm/custom.conf 里修改，在 [greeter] 下添加一些东西：

[greeter]
Exclude=git

网上还有说，要在 /etc/ssh/sshd_config 下设置以下参数（反正我是没有设置也成功了）：

RSAAuthentication yes
PubkeyAuthentication yes

然后服务器端就基本上搭建好了，对，基本上好了。这时可以在 git 用户的 home 文件夹下建立一些仓库什么的，然后打开 SSH Daemon 什么的：

~ # /etc/rc.d/sshd start

客户端上使用 Git

客户端我试过两种，分别是 Windows 和 Linux 客户端。不过大体上来说，每添加一个客户端，主要要做的事情是生成公钥和私钥，然后把公钥给服务器。

Windows 客户端上使用 Git

Windows 上我使用 TortoiseGit 作为资源管理器的一个插件。然后用 PuTTYgen 生成公钥和私钥，这个工具是 PuTTY 里的，但是如果你用默认安装 TortoiseGit 的话，也会有它。用 PuTTYgen 生成公钥/私钥对（如下图所示，点击 Generate 按钮）：

PuTTY Key Generator 生成公钥/私钥对

然后按照程序给的指示，在空白处随便移动一下鼠标。之后，便产生了公钥/私钥对：

PuTTY Key Generator 生成公钥/密钥对后

接下来把 Key Comment 和 Key Passphrase 设置一下，分别导出公钥和私钥就可以了（点击 Save Public Key 和 Save Private Key）。

之后把私钥保留，公钥发给服务器（假设命名为 id_rsa.pub），在服务器的 git 用户的文件夹下创建 .ssh/authorized_keys 文件，里面保存客户端的公钥。如果有多个客户端，只需在后面追加就可以了：

~ $ cat id_rsa.pub >> ~/.ssh/authorized_keys
~ $ chmod 644 ~/.ssh/authorized_keys

（所以说其实服务器的设置只是“基本上完成了”。）

在此后的 TortoiseGit 操作中，只需要指定刚才生成的私钥，就可以将源代码同步到服务器了。在写地址的时候，我是使用 ssh://git@gitserver/~/project_name 这样的格式，看得出来我把 Git 项目的仓库都放到了 git 用户的 home 文件夹下。

Linux 客户端使用 Git

Linux 的话，简单说下吧。用 OpenSSH 中的 ssh-keygen 工具生成公钥/私钥对，然后把公钥扔给服务器，与 Windows 类似：

~ $ ssh-keygen -C "your-key-comment" -t rsa

一路选择默认值，最后会在当前用户的 home 文件夹下生成 .ssh/id_rsa 和 .ssh/id_rsa.pub 文件。那个带 .pub 的文件，就是公钥，在服务器上把公钥加入 authorized_keys 文件中（步骤见本文 Windows 节）。之后就正常使用 Git 就可以了，远程代码仓库见 Windows 中的设置。