经过长时间的筹备，我们 C 社的社刊 c13n 今天正式上线啦！

社刊的主要内容将会涵盖 AI 技术、Web 技术、TeX 和排版相关知识、以及算法题的讲解。将从今天起不定期更新，欢迎大家收看。

我们的内容会同时在网站 (c13n.club) 和微信公众号上发布，网站上还会提供 PDF 版本。

所有的文章、网站框架和 PDF 生成的自动化工具都已开源。
GitHub: Computerization/c13n

(值得一提的是，我们的项目中 83% 的代码都是 C 语言，是一个我们为自动化而自制的 markdown 到 TeX 的转换器，而真正网站部分的代码则相比起这个少很多很多)

中英混排之断行​

第一眼看上去这张图的问题似乎在于知识的问号后面出现了极长的一段空白，造成了灰度的不平均。然而稍微仔细看看就会发现实际上是由于「Asclepius」无法被直接放入上一行。

然而，其实挤一挤就能放下了；如果挤不下也可以对单词应用断行算法，使它在中间断开。

\documentclass{standalone}
\makeatletter
  \def\ltj@stdmcfont{STSong}
  \def\ltj@stdyokojfm{eva/smpl,nstd}
\makeatother
\usepackage{luatexja}
\begin{document}
\vbox{\hsize=25\zw\parindent=0pt%
想要在危急时刻施予援手？想了解医学知识？
快来Asclepius急救医学社，我们旨在帮助更多的人提高急救意识，
科普有用的医学技巧，更有海龟汤，规则怪谈和定向越野赛，协助各位学以致用！
大量CAS时间和专业知识等你来领。我们诚邀你的加入！
}
\end{document}

另外一个隐藏的问题是，他在第一行第一个问号处使用了西文问号而非全角问号，这就导致若需占满行长只能对第二个全角问号插空。至于为什么这个排版引擎不调整kanjiskip我就不知道了。

挑战：窄行排版​

这是另一个问题：超短行长導致的下饭效果。

实际上，对于如此小的行长，浏览器中的排版引擎基本上不可能在无人工干预下做的比较好，而即使是TeX也需要人工调整断行；特别是URL和西文长单词（因为Knuth-Plass算法是为了输出符合标准且人眼易读的断行结果設計的）。

\catcode`@=11
  \def\ltj@stdmcfont{STSong}
  \def\ltj@stdyokojfm{eva/smpl,nstd}
\catcode`@=12
\input luatexja.sty
\pagewidth=13\zw
\pageheight=\numexpr 16*16\relax pt
\hoffset=-2.54cm
\voffset=-2.54cm
\vbox{\hsize=13\zw\parindent=0pt\baselineskip=16pt%
我们是世外信息化社，我们是一个长期在幕后工作的，以面向社团的知识性服务为主的，
一个小而精的CS社团。我们是世外唯一计算机工程相关的社团。
我们眼中的程序，不仅仅只是作为形式载体的代码，而是其背后的程序逻辑和思想；
是Algorithms造就了Compu\-ter Scientists，而不是代码，这是我们坚定的信念，
也是我们自称CS社团而不是编程社团的原因。也正是因此，我们有着程序设计交流的社团文化。\par
\bgroup\setbox0\hbox{官网\enspace}%
  \hbox to\hsize{\baselineskip=10pt\box0\vtop{\tt{https://computeriza{\break}tion.io}}}%
\egroup\vskip3.6pt
GitHub\enspace\tt{@Computerization}
}
\bye

注意因为LaTeX2e格式改动了很多东西，为了能干净地微调，我使用了plain-TeX。若有需要请使用LuaTeX编译之。

可见效果还是比较勉强。建议不要使用如此短的边距。

最后：争议​

众所周知，如果中英混排的时候，在汉字（kanji）和西文之间插入适当大小的铅空效果才好。这在TeX中大部分的CJK支持宏集会自动帮你做这件事，然而直到目前，除支援Text Module Level 4的Google Chrome和Safari之外的浏览器还是不能自动插入xkanjiskip。

于是就有一些人认为在写作时，应手动插入一个空格。但这是一种错误的妥协。这些东西理应是由负责最终渲染的浏览器处理的。手动加空格不但是对浏览器中本就不成熟的排版引擎的纵容，更是对空格的滥用。

不过和这一篇学生会推文中体现出的种种问题比起来，加不加空格似乎也不算什么了。

作为一个有九年悠久历史的老社团，在 2024 年的今天，我们继续开启今年招新的大门，欢迎加入我们，和我们共同打造辉煌的第十年！

校内活动​

作为一个「全能」的 CS 社团，我们把日常的活动分为了 Web, AI, OI 三个部门。

Web 部是许多社团大项目的基石，在这里你可以学习到丰富的前端知识，在维护项目时也能接触到大量运维和后端的知识。这个部门将会负责 Enspire 平台 (学生会社团部官方合作) 的后续开发维护，以及大部分社团联动的活动。

在 AI 部，你能与社团成员一起研讨最前沿的人工智能论文，探索技术，并一起开发相关的小项目。AI 部同样也有着与其它社团丰富的合作机会。

OI 部经过一年的静默于今年全新重启，你可以与我们 USACO 金牌而且特别能装的副社一同讨论算法竞赛，并和成员一起备战各类信息奥赛。

Enspire 是由世外信息化社领导的开源项目，旨在为学校的 CAS 活动与社团管理提供技术支持平台，可让同学们的 CAS 生活更加便捷高效。Enspire 的目标很简单: Make CAS Life Easier for Everyone! 这是一个依照 MIT License 完全开源的项目。

我们同时也于今年推出我们社团的社刊 c13n，向更多的人分享技术、普及技术。

校外及国际关系​

作为高中生，我们深知在计算机科学领域，一个高中社团的影响力也仍然十分局限。因此，我们也在不断寻求跨校以及国际上的往来。

CS Clubs 是一个由世外信息化社发起、一群热爱计算机科学的高中生共同组建的全球联盟。联盟的初创成员由来自 2 个国家的 6 个计算机相关社团组成。

通过各种形式的合作，我们力求让更多高中的 CS 社团得到更丰富的机会、得到互相的资源整合，将最先进的技术理念引入高中生的学习生活。

还有​

我们的领导层以及社员有着上述活动之外远远丰富的多的技能 ，尤其是一位精通 LaTeX / TeX 的副社。

在这里，你不光能得到技术的提升，认识一群志同道合的人，还是一个极为优秀的个人展示平台：你可以向同学讲解你所熟知的计算机原理，在公众号、blog、社刊上大展身手，与其它社团联动，或是在 Web 部项目协作中为学校的信息化贡献自己的力量。

我们是世外信息化社。
我们是服务类社团。

加入我们！一起见证我们的十年！

CS Clubs 是一个由世外信息化社发起、一群热爱计算机科学的高中生共同组建的全球联盟。联盟的初创成员由来自 2 个国家的 6 个计算机相关社团组成。

作为高中生，我们深知在计算机科学领域，一个人的力量是非常有限的，而一个高中社团的影响力也仍然十分局限。因此，我们决定联合起来，跨越地理和文化的障碍，共同学习、交流互鉴。

通过各种形式的合作，我们力求让更多高中的 CS 社团得到更丰富的机会、得到互相的资源整合，将最先进的技术理念引入高中生的学习生活。

官网 https://csclubs.org (现由 C 社运营维护)
GitHub @csclubs

成员​

CS Clubs 由来自 2 个国家的 6 个高中计算机科学社团联合创立。

Computerization
世界外国语中学 📍Shanghai
https://computerization.io
GitHub @Computerization

星河湾 CS 社
上海星河湾双语学校 📍Shanghai

Lady.Coder
YK Pao School 📍Shanghai

Pomelo Bay 柚学湾
YK Pao School 📍Shanghai

PHCS
上海民办平和学校 📍Shanghai

CyberDragons
Dana Hall School 📍Wellesley, MA

题目​

题解​

这道题在理解了题目的需求——生成一个符合给定约束的字典序最小的排列后，应该难度不高。我们可以按字典序生成全部的排列（一共有$8!=40320$种），然后输出第一个满足所有约束条件的。如果不会用回溯算法生成全排列，可能需要借助 algorithm 中的 next_permutation 函数。这也是典型的铜组思路：因为规模极小，可以暴力枚举之后挑选解而不是构造解。

当然，这种方法对于有一些竞赛经验的参赛者来说反倒不容易想到。这些参赛者会试图通过约束条件来构造解。这需要一点点贪心的思想：为了让排列字典序最小，就一定要让每一位上的奶牛字典序尽可能小。我们可以把一个排列看作一个“约束链”，其中每一头奶牛都因为它相邻位置奶牛的约束而只有唯一的可能。每完成一条约束链的连接后，都可以从剩下未被安排进队的奶牛中挑选编号最小的，但不能是有两个未满足的约束的（因为一个“约束链”中头和尾的奶牛都只能和它相邻的一头奶牛间有约束），然后在确定了链头之后，就可以非常自然地得到整个链条。重复同样的构造过程，直到所有奶牛都被添加入队列。

程序​

暴力法的代码：

/**
 * Adopted from official solution at
 * http://www.usaco.org/current/data/sol_lineup_bronze_dec19.html
 */
#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>

using namespace std;

string names[8] = {"Beatrice", "Belinda", "Bella", "Bessie", "Betsy", "Blue", "Buttercup", "Sue"};
// beside_a 和 beside_b 中对应下标的奶牛表示一组约束关系
vector<string> beside_a, beside_b;
int n;

int getID(string name) {
    for (int i = 0; i < 8; i++)
        if (names[i] == name)
            return i;
    return -1;
}

bool satisfies_constraints() {
    for (int i = 0; i < n; i++)
        if (abs(getID(beside_a[i]) - getID(beside_b[i])) != 1)
            return false;
    return true;
}

int main() {
    ifstream fin("lineup.in");
    ofstream fout("lineup.out");
    fin >> n;
    string a, b;
    for (int i = 0; i < n; i++) {
        fin >> a >> b >> b >> b >> b >> b;
        beside_a.push_back(a);
        beside_b.push_back(b);
    }
    // 遍历所有的8头奶牛的排列，输出第一个满足约束的解
    do {
        if (satisfies_constraints()) {
            for (int i = 0; i < 8; i++)
                fout << names[i] << endl;
            return 0;
        }
    } while (next_permutation(names.begin(), names.end()));
    return 0;
}

构造法的代码：

#include <iostream>
#include <fstream>

using namespace std;

struct cow {
    int adj[2];  // 需要和这头奶牛相邻的奶牛的ID
    int adjcnt;  // 这头奶牛一共有几个约束条件；决定了能否把它放在约束链的开头
    bool chosen; // 是否已经进队
} cows[8];
string names[8] = {"Beatrice", "Belinda", "Bella", "Bessie", "Betsy", "Blue", "Buttercup", "Sue"};

int getID(string name) {
    for(int i = 0; i < 8; i++)
        if(names[i] == name)
            return i;
    return -1;
}

int main() {
    ifstream fin("lineup.in");
    ofstream fout("lineup.out");
    int n;
    fin >> n;
    string a, b;
    for (int i = 0; i < n; i++) {
        fin >> a >> b >> b >> b >> b >> b;
        cows[getID(a)].adj[cows[getID(a)].adjcnt++] = getID(b);
        cows[getID(b)].adj[cows[getID(b)].adjcnt++] = getID(a);
    }
    int prev = -1;
    // 每次循环向队列中添加一头奶牛；如果上一头奶牛没有更多的约束条件了，则可以选择一头新的，否则选择需要和上一头相邻的奶牛
    for (int _ = 0; _ < 8; _++) {
        if (_ == 0 || cows[prev].adjcnt == 0) {
            for (int i = 0; i < 8; i++) {
                if (!cows[i].chosen && cows[i].adjcnt < 2) {
                    cows[i].chosen = true;
                    fout << names[i] << endl;
                    prev = i;
                    break;
                }
            }
        } else if (cows[prev].adjcnt == 1) {
            int i = cows[prev].adj[0];
            cows[i].chosen = true;
            // 这里的操作是在把cows[i]添加入队列的同时“删除”掉它已经满足的那条约束
            cows[i].adjcnt--;
            if(cows[i].adj[0] == prev)
                cows[i].adj[0] = cows[i].adj[1];
            fout << names[i] << endl;
            prev = i;
        }
    }
    return 0;
}

题目​

题解​

暴力解法自然是枚举全排列并检验，30%的分数到手，不过这个程序没有其它太大意义，甚至由于阶乘级的时间复杂度难以对拍。不多作讨论。

考虑 70%的分数。$n\le 20$，可以考虑$\mathcal{O}(2^n)$的算法。既然不能进行全排列的枚举，那么完全可以考虑状态压缩动态规划，枚举一个字母是否出现在状态中。由于要求解的是整个字符串中是否存在前$n$个字母的全排列，则考虑$f(x)$表示$x$对应的几个字母的全排列最早出现在字符串种的何处。状态转移方程举例：

但是如果对于每一个寻找都是通过循环寻找的话，时间会有点长，只能拿 50 分，需要进行一定的预处理。可以在预处理之后用二分查找，但是方便起见建议添加一个数组标记每一个位置下一个目标字母的位置，所需时间不长，$450\times 26$而已。

最后，考虑剩下的分数点。可以发现，对于过大的$n$，可以直接输出"No"，至于这个值如何确定？按照$n=3\implies S=\mathtt{abcbab}$，$n=4\implies S=\mathtt{abcdcbabcdcba}$这种构造方式$S$的长度为$n^2-n+1$，$n\le 21$，不过证明过于困难。为保险起见，因为$n=22$时用时是可以接受的，取$n\ge 23$时直接输出"No"。

程序​

#include <iostream>

using namespace std;

int main(){
    int t;
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        string s;
        cin >> s;
        if (n >= 23) {
            cout << "NO" << endl;
        } else {
            short NEXT[26][450];
            for (int i = s.length() - 1; i >= 0; i--) {
                if (i == s.length() - 1) {
                    for (int j = 0; j < 26; j++)
                        NEXT[j][i] = -1;
                } else {
                    for (int j = 0; j < 26; j++)
                        NEXT[j][i] = NEXT[j][i + 1];
                }
                NEXT[s[i] - 'a'][i] = i;
            }
            short *f = new short[1 << n];
            for (int i = 0; i < (1 << n); i++) {
                f[i] = 0;
                for (int j = 0; (1 << j) <= i; j++) {
                    if (i & (1 << j)) {
                        if (NEXT[j][f[i - (1 << j)]] == -1) {
                            cout << "NO" << endl;
                            return 0;
                        }
                        f[i] = max(f[i], NEXT[j][f[i - (1 << j)]]);
                    }
                }
            }
            cout << "YES" << endl;
        }
    }
}

题目​

题解​

$10^{19}$显然灭掉了所有用循环解决的想法。有没有比简单的$\mathcal{O}(n)$更好一点的方法？用矩阵快速幂，可以达到$\mathcal{O}(\log n)$。观察到：

$\begin{pmatrix}F_{n+1}\\F_{n+2}\end{pmatrix}=\begin{pmatrix}F_{n+1}\\F_{n}+F_{n+1}\end{pmatrix}=\begin{pmatrix}0&1\\1&1\end{pmatrix}\begin{pmatrix}F_{n}\\F_{n+1}\end{pmatrix}$

这一步对于所有递推数列都是适用的，因此在有经验之后应该非常容易得到。一般地，对于$F_{n+2}=aF_{n}+bF_{n+1}$，有

$\begin{pmatrix}F_{n+1}\\F_{n+2}\end{pmatrix}=\begin{pmatrix}F_{n+1}\\aF_{n}+bF_{n+1}\end{pmatrix}=\begin{pmatrix}0&1\\a&b\end{pmatrix}\begin{pmatrix}F_{n}\\F_{n+1}\end{pmatrix}$

从递推式中有

$\begin{pmatrix}F_{n+m}\\F_{n+m+1}\end{pmatrix}=\begin{pmatrix}0&1\\1&1\end{pmatrix}^m\begin{pmatrix}F_{n}\\F_{n+1}\end{pmatrix}$

取$n=0$，得到

$\begin{pmatrix}F_{m}\\F_{m+1}\end{pmatrix}=\begin{pmatrix}0&1\\1&1\end{pmatrix}^m\begin{pmatrix}F_0\\F_1\end{pmatrix}$

因此把问题转化成了如何求矩阵$m$次方的问题。如果设$m=2^0a_0+2^1a_1+2^2a_2+\dots$（也就是把$m$用二进制表示），那么有

$\begin{pmatrix}0&1\\1&1\end{pmatrix}^m=\left(\begin{pmatrix}0&1\\1&1\end{pmatrix}^{1}\right)^{a_0}\times \left(\begin{pmatrix}0&1\\1&1\end{pmatrix}^{2}\right)^{a_1}\times \left(\begin{pmatrix}0&1\\1&1\end{pmatrix}^{4}\right)^{a_2}\dots$

而这些矩阵的$2^k$次方，完全可以预处理。当$m$的数量级为$10^{19}$时，$k<\log_2 10^{19}<64$，最多只需要存储 63 个矩阵。并且

$\begin{pmatrix}0&1\\1&1\end{pmatrix}^{2^k}=\begin{pmatrix}0&1\\1&1\end{pmatrix}^{2^{k-1}}\times \begin{pmatrix}0&1\\1&1\end{pmatrix}^{2^{k-1}}$

这些乘方可以在$\mathcal{O}(\log m)$时间内得到。这便是快速幂的思想：计算所有的$2^k$次方，然后把其中需要的那些组合起来即可。

程序​

下面是 C++ 代码，其中最繁琐的部分是实现矩阵乘法：

#include <iostream>
#include <cmath>

using namespace std;

struct mat {
    unsigned long long a[4];
    mat operator *(mat o) {
        mat t;
        t.a[0] = (this->a[0] * o.a[0] + this->a[1] * o.a[2]) % 1000000007;
        t.a[1] = (this->a[0] * o.a[1] + this->a[1] * o.a[3]) % 1000000007;
        t.a[2] = (this->a[2] * o.a[0] + this->a[3] * o.a[2]) % 1000000007;
        t.a[3] = (this->a[2] * o.a[1] + this->a[3] * o.a[3]) % 1000000007;
        return t;
    }
};

// 预处理的矩阵 2^k 次幂
mat mat_pow[64];

int fib(unsigned long long k) {
    // 临时矩阵，每次在此上面乘以 mat_pow 中的某项
    mat tmp;
    tmp.a[0] = 1;
    tmp.a[1] = 0;
    tmp.a[2] = 0;
    tmp.a[3] = 1;
    for (int i = 0; i < 64; i++) {
        // 如果 a_i 为 1
        if (k & (1ull << i)) {
            tmp = tmp * mat_pow[i];
        }
    }
    return tmp.a[1];
}

int main() {
    mat_pow[0].a[0] = 0;
    mat_pow[0].a[1] = 1;
    mat_pow[0].a[2] = 1;
    mat_pow[0].a[3] = 1;
    for (int i = 1; i < 64; i++) {
        mat_pow[i] = mat_pow[i-1] * mat_pow[i-1];
    }
    unsigned long long n;
    cin >> n;
    cout << fib(n) << endl;
    return 0;
}

补充一下矩阵的乘法公式：

$\begin{pmatrix}a_0&a_1\\a_2&a_3\end{pmatrix}\times\begin{pmatrix}b_0&b_1\\b_2&b_3\end{pmatrix}=\begin{pmatrix}a_0b_0+a_1b_2&a_0b_1+a_1b_3\\a_2b_0+a_3b_2&a_2b_1+a_3b_3\end{pmatrix}$

$\begin{pmatrix}a_0&a_1\\a_2&a_3\end{pmatrix}\times\begin{pmatrix}b_0\\b_1\end{pmatrix}=\begin{pmatrix}a_0b_0+a_1b_1\\a_2b_0+a_3b_1\end{pmatrix}$

这篇文章是从C 社的新成员练手 repo 的 README.md 的第一节转移过来的，添加了一些内容，并做了相应的翻译。（原文用英文的原因，应该是 sy 大佬和我都更习惯用英语写技术相关的内容吧……）

添加文件时，你既可以用带图形用户界面（GUI）的 GitHub Desktop，也可以用命令行。你可以从 GUI 入手，但你会有一天意识到命令行功能的强大，开始用它的。另外，Visual Studio Code 的用户们也可以试试其自带的源代码管理工具。

我们觉得有必要给你解释你每一步究竟在做什么，而不是让你机械地重复我们写好的教程。这对你尤其有帮助，因为教程通常都把事情想得很完美，但现实则充满了各种意外和变数。阅读时，我们并不要求你事先懂得任何 Git 操作。

你可以把 Git 理解成一个版本控制系统。它能记录每个文件的创建、更改、和删除，而仓库管理者可以在各个版本（commit¹）间自由切换，就好像游戏中的若干存档一样。

基础操作：clone, branch, commit, push, pull request​

假设现在 GitHub 上有这样一个叫 Hello 的仓库，是由小丽创建的，装着可能是历史上最著名的一段代码。它的目录长这个样子：

.
├── Hello.cpp
│
├── Contributors.txt
│
└── README.md

// Hello.cpp
#include <iostream>
using namespace std;
int main() {
  cout << "Hello world!" << endl;
}

// Contributors.txt
XiaoLi

// README.md

# Hello world

A piece of C++ code that prints `Hello world!`

你可以把每个 commit 看作是整个仓库的一个快照，一个拷贝。实际上它要比一份完整的拷贝轻量得多，但原理上它保存了那一时刻仓库的全部信息。比如上面的版本就可以看作 C0 commit。（每个 commit 都有一个独有的哈希值，但长到人类无法阅读。因此用 C0 来指代就好了。）我们也管这个 commit 叫 master 分支。一个分支即一系列有线性发展关系的 commit，而 master 分支则作为主分支。实际上，一个分支就是一个指向某个 commit 的指针。 该项目目前的树状结构如下：

语言学家小明发现了这个仓库。他对此很感兴趣，但他对小丽还在用古早的 Hello world! 非常不满，因此决定做点贡献。为此，他需要先把这个文件夹（也就是仓库）下载下来。这基本就是 克隆仓库 (clone the repo) 做的事情。

小明在自己的机器上有了一份完整的拷贝后，就可以像本地项目一样作编辑了。他对三个文件都作了更新：

// Hello.cpp
#include <iostream>
using namespace std;
int main() {
  cout << "Bonjour le monde!" << endl;
}

// Contributors.txt
XiaoLi
XiaoMing

// README.md

# Hello world

A piece of C++ code that prints `Bonjour le monde!`

现在他的直觉告诉他，他需要把这些代码发回 GitHub。要做到这一点，他可以直接提交一个 commit。但这里有个严峻的问题：小丽对小明的行为完全没有控制。 事实上，大多数公开仓库（包括 C 社的）都限制了其他人直接向 master 提交 commit，因为没有哪个环节可以做安全验证。一旦成功 commit，小丽就会惊讶地发现她 GitHub 上的代码变成了法语。并且无论如何，这也是非常恶劣的行为：在任何合作项目中，都永远不要直接向 master 分支提交 commit。（除非你还有一周就要辞职了） 向 master 提交 commit 还有一个问题，我们马上就会看到。

因此为了解决这一问题，小明 新建了一个分支 (create a branch) ，并把它命名为 XiaoMing/change-output-language。我们可以认为，小明是在一个和 master 相同但独立的文件夹里工作，而他做出的任何改动都不会影响 master。这不仅能明确他的目的，确定他分支作者的地位，还能避免冲突和混乱。

现在这些变更都会被记录在 XiaoMing/change-output-language 中。但当他准备 commit 时，他记起了另一条准则：一个 commit 只应该实现一个功能。 重新审视自己的改动，他觉得改变语言和在 Contributors.txt 里添加自己的名字应该是独立的改动。（这里的区别微乎其微，但在实际的项目中还是非常容易判断的。）因此他 上传了两个 commit (make a commit) ，分别命名为 Change output to French 和 Add XiaoMing's name to Contributors.txt，而它们的哈希值分别为 C1 和 C2。注意，他不一定是按顺序做出这些改动的，但 Git 把 C2 当作 C1 的继承者，因为它是后来的 commit。现在，XiaoMing/change-output-language 这一分支就指向了 C2 commit。该仓库现在的 Git 树如下：

此时他的改动还只是本地的——没人能在 GitHub 网页上看到它们。因此他接下来 发布了分支并将其推送至源 (publish branch and push to origin) 。这会把 XiaoMing/change-output-language 这一分支及其包含的所有 commit 上传到 GitHub 远程终端。

当他发布了分支之后，其后在该分支上做出的任何 commit 都会自动被同步到 GitHub 上。

紧接着，他 发布了拉取请求 (create pull request) ，请求代码拥有者（也就是小丽）合并这一分支。分支被合并后，所有的改变都会在 master 中体现出来。

只有一个分支时，事情非常简单，因为此时分支上所有的 commit 都是 master 的继承者，在合并分支时，Git 只需要把所有东西都加到 master，也就是 C0 上，就可以了。因此，它会移动 master 指针：

而事实上，以上就是所有 Git 新用户需要明白的操作。但作为未来的 GitHub 代码管理者，你应当思考得更深入一点。

解决冲突​

为了让事情更有趣一点，我们又同时请来了守旧派小红。她对小丽忘记在 cpp 文件结尾加 return 0; 非常不满，因此决定修正这一问题。同样地，她复制了仓库，在 master 上新建了一个叫 XiaoHong/improve-code-style 的分支，而由于此时小明还没有提交分支，master 仍然指向 C0。文件改动如下（C3）：

// Hello.cpp
#include <iostream>
using namespace std;
int main() {
  cout << "Hello world!" << endl;
  return 0;
}

// Contributors.txt
XiaoLi
XiaoHong

// README.md

# Hello world

A piece of C++ code that prints `Hello world!`

她发布了分支并提交了合并请求。此时，Git 树如下：

小丽午休结束之后，回到 GitHub 页面上，发现多了两个合并请求。她开心地合并了小明的请求：

但却发现不能直接合并小红的。GitHub 警告说，该分支和 master 间有冲突，因为有同时作出的修改，Git 不知道要留下哪一个，因此需要她手动解决冲突。解决页面有如下的内容：

// Hello.cpp
 #include <iostream>
 using namespace std;
 int main() {
 <<<<<<< master
   cout << "Bonjour le monde!" << endl;
 =======
   cout << "Hello world!" << endl;
   return 0;
 >>>>>>> XiaoHong/improve-code-style
 }

// Contributors.txt
 XiaoLi
 <<<<<<< master
 XiaoMing
 =======
 XiaoHong
 >>>>>>> XiaoHong/improve-code-style

注意到 README.md 文件不需要解决冲突，因为只有小明作了修改；Git 还是能意识到这一点的。怎么解决上述问题对小丽这样的人类还是非常显然的：只要同时留下两人所做的改动即可。因此，她删去了多余的内容，解决了冲突，并合并了小红的分支。文件现在的样子（C4）：

// Hello.cpp
#include <iostream>
using namespace std;
int main() {
  cout << "Bonjour le monde!" << endl;
  return 0;
}

// Contributors.txt
XiaoLi
XiaoMing
XiaoHong

// README.md

# Hello world

A piece of C++ code that prints `Bonjour le monde!`

而在合并一个并不是自己的继承者的分支时，Git 会新建一个 commit：

此时，小丽、小明、小红三人就成功地完成了一次在 GitHub 上的开源项目合作。

如果想要学习更多 Git 有关的知识，并深入研究它的树状结构，可以访问这个网站：Learn Git Branching

拓展阅读​

如果想要了解 pull, push, commit, add, 和 checkout 时具体发生了什么，可以参考以下网站：

• Git SCM - Getting Started: Git Basics
• Git SCM - Git Branching: Branches in a Nutshell
• Git SCM - Git Branching: Branching Workflows
• Stack Overflow - What's the difference between HEAD, working tree and index, in Git?
• Understanding Git: Data Model
• Understanding Git: Branching
• Understanding Git: Index

除此之外，如果你不喜欢阅读长篇大论，你可以观看下面这个长约 82 分钟的 YouTube 视频：

• [VIDEO] Introduction to Git with Scott Chacon of GitHub

也可以在这个可视化的页面上尝试各类 Git 指令：

• Learn Git Branching

在这里，你可以：

• 参与新平台 Enspire 的开发；
• 研究人工智能 (e.g. 神经网络、机器学习)；
• 参与 Leetcode 周赛等各类算法竞赛；
• 学习前后端技术与网页设计，零距离体验 Web 项目开发；
• ……

我们希望各位新成员能在这一年内愉快学习，获得自我提升，并结识志趣相投的伙伴。