Jia Zhang

二分问题的统一解决方案

Jia Zhang — Wed, 03 Apr 2024 00:00:00 +0000

思路来自灵茶山艾府的视频《基础算法精讲 04》。本文是学习记录，结合了我自己的思考，修改后得出这个框架。

引入#

在算法题中有时会遇到这种场景：一个问题的答案是一个整数，且一定落在某个范围内，例如只可能是 $[1, 10^9]$ 中的一个数。并且存在一个条件，对于任何小于答案的数，这个条件都不成立；对于任何大于等于答案的数，这个条件都成立。这时就可以用二分的方法来找到答案。

框架与求解#

下面用严格的语言来表达这类问题（我称为二分问题）。

存在一个函数 check，它接受一个整数 i 作为输入，check(i) 只可能等于 True 或 False。并且存在一个数 $k$，使得对于任何小于 $k$ 的整数 i，都有 check(i) == False；而对于任何大于等于 $k$ 的整数 i，都有 check(i) == True。我们现在有函数 check，需要找到这个整数 $k$，并且知道 $k$ 在 $[a, b]$ 区间内。

接下来提出一个框架来解决这个问题。

首先，从获取信息的角度来思考。在实际跑一次 check 之前，我们没有获取任何信息，这时可以认为 $[a, b]$ 之间的所有整数都处于未知状态。

而运行了 check(i) 之后，由于问题的性质，我们获取到的信息不只是 check(i) 本身的真假，而是一整个范围内的整数满足或者不满足条件：

如果 check(i) == False，那么 $[a, i]$ 闭区间内所有整数的 check 结果一定也都是 False；
如果 check(i) == True，那么 $[i, b]$ 闭区间内所有整数的 check 结果一定也都是 True。

定义闭区间 $[l, r]$ 为求解区间，它满足以下三条性质：

$[l, r]$ 中全是我们还不知道 check 结果的整数；
对于任何大于 $r$ 的整数，check 的结果一定是 True；
对于任何小于 $l$ 的整数，check 的结果一定是 False。

一开始 $[a, b]$ 中全是未知的，所以把求解区间初始化为 $[a, b]$，也就是定义两个变量 l、r，令 l <- a, r <- b。

然后取求解区间的中点 mid <- l + (r - l) / 2，计算 check(mid)：

如果 check(mid) == True，说明 $[mid, r]$ 都是 True，这一段从未知变为已知，因此令 r <- mid - 1；
如果 check(mid) == False，说明 $[l, mid]$ 都是 False，这一段从未知变为已知，因此令 l <- mid + 1。

这两种操作都保持了上面三条性质始终成立。然后重复取中点和上述操作，直到 $r < l$ 为止。此时求解区间为空，也就是未知的部分为空，$[a, b]$ 内每一个整数的 check 结果都已经知道了。我们的目标就是：在三条性质始终成立的前提下，把未知区间变为空。

未知区间为空之后，$r$ 一定等于 $l - 1$。此时 r 就是最后一个 False 所在的位置，l 就是第一个 True 所在的位置，题目要哪一个就返回哪一个。

写成 C++ 就是：

// 返回 [a, b] 中第一个使 check 为 true 的整数
long long first_true(long long a, long long b, auto check)
{
    long long l = a, r = b; // 求解区间 [l, r]：里面全是未知的
    while (l <= r)          // 求解区间非空
    {
        long long mid = l + (r - l) / 2;
        if (check(mid))
            r = mid - 1; // [mid, r] 都是 true
        else
            l = mid + 1; // [l, mid] 都是 false
    }
    return l; // 此时 r == l - 1
}

举例说明（可以先看这个部分）#

假设把 check 应用在下标 0 到 8 上，得到的结果分别是

$$[F, F, F, F, T, T, T, T, T]$$

那么取 l <- 0, r <- 8，计算得到 mid <- 4。

此时 check(4) == T，说明 $[4, 8]$ 区间内的每一个整数都是 T，它们从未知变成已知。执行 r <- mid - 1，得到新的未知区间 [l, r] == [0, 3]。

计算 mid <- l + (r - l) / 2，得到新的 mid == 1。此时 check(1) == F，说明 $[0, 1]$ 区间均为 F。执行 l <- mid + 1，新的未知区间为 [l, r] == [2, 3]。

计算得到新的 mid == 2。此时 check(2) == F，说明 $[0, 2]$ 区间均为 F。执行 l <- mid + 1，新的未知区间为 [l, r] == [3, 3]。

计算得到新的 mid == 3。此时 check(3) == F，说明 $[0, 3]$ 区间均为 F。执行 l <- mid + 1，新的未知区间为 [l, r] == [4, 3]，即空区间。

计算结束。此时 l == 4, r == 3：l 就是第一个 T 所在的位置，r 就是最后一个 F 所在的位置。

2026 年 10 月修订。 修正了例子里的笔误：原文把更新写成了 mid <- (r - 1) 和 mid <- (l + 1)，应为 r <- mid - 1 和 l <- mid + 1；原文说把 check 应用在 1 到 9 上，却又从 l <- 0, r <- 8 开始，现统一为下标 0 到 8。补充了与文字描述一一对应的 C++ 代码（需要 C++20 才能用 auto 形参）。注意 l、r 要用有符号整数：当 $a = 0$ 且 check(0) 为真时，r 会变成 $-1$，无符号类型会在这里回绕。

Value Categories in C++

Jia Zhang — Tue, 23 Aug 2022 00:00:00 +0000

Intro#

#include <type_traits>

#define IS_XVALUE(expr) \
    (std::is_rvalue_reference<decltype((expr))>{})
#define IS_PRVALUE(expr) \
    (!std::is_reference<decltype((expr))>{})
#define IS_LVALUE(expr) \
    (std::is_lvalue_reference<decltype((expr))>{})

This is a method I recently discovered to determine the value category of an expression. I’ll explain why it works later.

First, let’s take a look at value categories in C++.

The most important thing to notice before we start is that value categories are not a property of values but a property of expressions. Much depends on what you take value to mean: I looked through the C++ standard, and it does not seem to define the term itself. We all know what an expression is, though (if not, see cppreference).

Every expression belongs to exactly one of three primary value categories: lvalue, prvalue and xvalue. (Two more names group them: a glvalue is an lvalue or an xvalue, and an rvalue is a prvalue or an xvalue.)

We know you can write x = 3 but not 3 = x. Both 3 and x are expressions, so there must be some qualitative difference between them. Since x can appear on the left of the assignment sign, we call it an lvalue; 3 is accordingly called an rvalue.

OK, that is the difference between lvalues and rvalues. But what are prvalues and xvalues?

There are two dimensions to an expression: 1. Does it have an identity? 2. Can it be moved from?

An expression that has identity and can be moved from is an xvalue (“eXpiring value”).
One that has identity but cannot be moved from is an lvalue.
One that has no identity but can be moved from is a prvalue (“pure rvalue”).

For example, these are xvalues:

std::move(x);
a.m, a member of an object expression, where a is an rvalue and m is a non-static data member of non-reference type.

Temporary materialization#

The most useful example for understanding xvalues is temporary materialization:

struct S { int m; };
int i = S().m; // member access expects a glvalue as of C++17;
               // the prvalue S() is converted to an xvalue

As cppreference puts it: a prvalue of any complete type T can be converted to an xvalue of the same type T. This conversion initializes a temporary object of type T from the prvalue by evaluating the prvalue with the temporary object as its result object, and produces an xvalue denoting the temporary object. If T is a class or array of class type, it must have an accessible and non-deleted destructor.

So the key difference between an xvalue and a prvalue is that an xvalue refers to an object that already exists, one whose resources we are allowed to reuse, while a prvalue is just a recipe for a value until it initializes something. There is nothing to reuse in the number 3 or 3.7, but we can reuse the memory allocated by a temporary std::string, and that temporary becomes an object (an xvalue) the moment we need one.

decltype and value categories#

decltype is a good tool for determining the category of an expression, because for an expression of type T it yields an rvalue reference T&& for an xvalue, the plain type T for a prvalue, and an lvalue reference T& for an lvalue.

Someone may object: with int x = 3;, x is an lvalue, yet decltype(x) is int rather than int&. That is the special case for id-expressions in the behaviour of decltype:

If the argument is an unparenthesized id-expression or an unparenthesized class member access expression, then decltype yields the type of the entity named by this expression. If there is no such entity, or if the argument names a set of overloaded functions, the program is ill-formed.

So the right way is int x = 3; decltype((x)) xref = x;. Here the type of xref is int&. That is why the macros above wrap expr in an extra pair of parentheses: it turns every id-expression into an ordinary expression, and decltype then reports its value category.

#include <string>
#include <utility>

struct S { int m; };

int main()
{
    int x = 3;
    static_assert(IS_LVALUE(x));
    static_assert(IS_LVALUE("hello"));                // string literals are lvalues
    static_assert(IS_PRVALUE(3));
    static_assert(IS_PRVALUE(x + 1));
    static_assert(IS_PRVALUE(std::string("hi")));
    static_assert(IS_XVALUE(std::move(x)));
    static_assert(IS_XVALUE(S().m));
}

std::move#

The famous function std::move has nothing to do with actually moving something. All it does is turn its argument into an xvalue; usually you call it on an lvalue.

std::move is used to indicate that an object t may be “moved from”, i.e. to allow the efficient transfer of resources from t to another object. In particular, std::move produces an xvalue expression that identifies its argument t. It is exactly equivalent to static_cast<std::remove_reference_t<T>&&>(t) (cppreference).

Revised in October 2026. The macros now spell out std:: and the header they need, and a small test program has been added; it compiles with GCC and Clang in C++17 mode. The prvalue/xvalue comparison was sharpened: since C++17 a prvalue is not an object until it is materialized, so what tells the two apart is whether an object already exists, not whether it can be moved from. Links point to the current cppreference URLs.

Using C++17 or Later with the clangd Extension in VS Code

Jia Zhang — Sun, 07 Aug 2022 00:00:00 +0000

Recently I switched my code completion tool in VS Code from Microsoft’s official C/C++ extension to clangd. On the one hand, clangd gives a better experience; on the other hand, it is also what I use at my company (ByteDance).

I joked to myself that the two most interesting things I learned during my internship were that indentation went from four spaces to two, and that opening braces stopped getting a line of their own.

Now, there was a problem. I installed clangd, switched over, and everything worked fine, until I used std::string_view and clangd told me it didn’t recognize it. I quickly realized that clangd’s default C++ standard was still C++14, so changing that default became something I had to do.

I googled but didn’t find anything useful.

I tried a compile_commands.json file. But on the one hand, it has to be set up separately for each project, while what I wanted was C++17 for any file I happen to open. On the other hand, it didn’t work (maybe I didn’t configure it properly).

So here is the final solution. Open (create it if it does not exist) ~/.config/clangd/config.yaml and write:

CompileFlags:
  Add: [-std=c++20]

Cool. Now let’s have fun with C++20.

Edit on 2023-10-21#

The path above is for Linux. On macOS, the configuration file is ~/Library/Preferences/clangd/config.yaml (on Windows it is %LocalAppData%\clangd\config.yaml). For details, see the clangd configuration docs.

You can also use If in config.yaml to avoid adding -std=c++2b to C files (which is funny):

If:
  PathExclude: [.*\.c, .*\.h]
CompileFlags:
  Add:
    - "-std=c++2b"

Excluding .h keeps C headers working, but C++ headers with a .h extension then fall back to the default standard. If your C++ code uses .h headers, exclude only .*\.c.

Revised in October 2026. Both configurations were checked with clangd --check (clangd 23). The C++14 default described above belongs to Clang 15 and earlier; since Clang 16 the default is gnu++17, so std::string_view works out of the box, but you still need this file for C++20 or C++23. Current compilers also accept -std=c++23 in place of -std=c++2b. The note on .h headers is new.

从析构输出看 explicit、emplace_back 与 vector 扩容

Jia Zhang — Tue, 22 Feb 2022 00:00:00 +0000

本文是我的 C++ 笔记的第三篇。

explicit#

explicit 用来防止类的构造函数被用于隐式转换。

class A
{
private:
    int x;

public:
    A(int x_) : x{x_} {}
};

// ...

A a = 3;  // OK
A a2{3};  // OK

这样是对的。而加上 explicit 之后：

class A
{
private:
    int x;

public:
    explicit A(int x_) : x{x_} {}
};

// ...

A a = 3;  // 编译错误：拷贝初始化不能调用 explicit 构造函数
A a2{3};  // OK

析构函数、移动构造与 emplace_back#

看下面的代码：

#include <iostream>
#include <vector>
using namespace std;

class A
{
private:
    int x;

public:
    A(int xx) : x{xx} {}
    A() : A(0) {}
    ~A() { cout << "goodbye " << x << endl; }
};

int main()
{
    vector<A> v;
    v.emplace_back(A{0});
    v.emplace_back(A{1});
    v.emplace_back(A{2});
    cout << "--------------------------------------\n";
}

它的输出是：

goodbye 0
goodbye 0
goodbye 1
goodbye 0
goodbye 1
goodbye 2
--------------------------------------
goodbye 0
goodbye 1
goodbye 2

原因如下。

首先，emplace_back 只有在传入构造函数的参数列表时才和 push_back 有区别，其他时候没有区别。emplace_back(A{0}) 相当于先生成临时对象 A{0}，再把它拷贝构造到 v 里。注意 A 有用户声明的析构函数，所以编译器不会为它隐式生成移动构造函数，这里只能拷贝。语句结束时临时对象析构，于是输出一次 goodbye 0。

之后要加入 A{1}，而此时 v 的容量只有 1，需要重新申请一块容量为 2 的空间。以 libstdc++ 为例：先在新空间里用临时对象 A{1} 拷贝构造出新元素，再把原来的 A{0} 拷贝过去，然后析构旧空间里的 A{0}，输出 goodbye 0。emplace_back 返回之后，临时对象 A{1} 析构，输出 goodbye 1。

加入 A{2} 的过程一样：容量从 2 扩到 4，旧的 A{0}、A{1} 被拷贝过去后析构，最后临时对象 A{2} 析构。

最终，三个元素的生命周期随着 v 一起结束，依次析构。

我们把 capacity 打印出来，就能看到上面的猜测是正确的：

vector<A> v;
cout << "CAPACITY " << v.capacity() << endl;
v.emplace_back(A{0});
cout << "CAPACITY " << v.capacity() << endl;
v.emplace_back(A{1});
cout << "CAPACITY " << v.capacity() << endl;
v.emplace_back(A{2});
cout << "CAPACITY " << v.capacity() << endl;
cout << "--------------------------------------\n";

得到：

CAPACITY 0
goodbye 0
CAPACITY 1
goodbye 0
goodbye 1
CAPACITY 2
goodbye 0
goodbye 1
goodbye 2
CAPACITY 4
--------------------------------------
goodbye 0
goodbye 1
goodbye 2

而如果提前预留空间：

vector<A> v;
v.reserve(10);
v.emplace_back(A{0});
v.emplace_back(A{1});
v.emplace_back(A{2});

就不会再发生扩容，输出变为：

goodbye 0
goodbye 1
goodbye 2
--------------------------------------
goodbye 0
goodbye 1
goodbye 2

剩下的三次 goodbye 来自三个临时对象。如果直接把构造参数传给 emplace_back，连临时对象也没有了：

vector<A> v;
v.reserve(10);
v.emplace_back(0);
v.emplace_back(1);
v.emplace_back(2);

--------------------------------------
goodbye 0
goodbye 1
goodbye 2

结论#

emplace_back 以构造参数列表的形式传入（如 v.emplace_back(0)）时，不论有没有移动构造函数，都是原地构造，只调用一次构造函数。只有这一点和 push_back 有区别，其他情况两者都一样。
以左值对象的形式传入时，不论有没有移动构造函数，都调用一次拷贝构造函数。
以右值对象的形式传入（例如 std::move(左值对象)，或者本身就是临时对象，如 v.emplace_back(A{0})）时：
- 有移动构造函数，调用一次移动构造；
- 没有移动构造函数，调用拷贝构造函数。
如果传入的是临时对象，那么过程是：构造临时对象，再移动构造（或拷贝构造）到容器里，最后临时对象析构。

2026 年 10 月修订。 修正了 explicit 的拼写和示例里重复定义的变量名，补上了 #include。扩容那一段按实际顺序重写：新元素先在新空间里构造，旧元素搬过去之后才析构，临时对象最后析构。补充了 A 没有移动构造函数的原因（用户声明了析构函数），以及直接传构造参数的对照实验。原文结论里借用的 Person("aaa", "shandong", 1991) 例子换成了本文的 A。上面的输出用 GCC 16（libstdc++，-std=c++17）验证过。容量按 1、2、4 翻倍增长是 libstdc++ 和 libc++ 的实现；MSVC 按 1.5 倍增长，输出会不一样。

CCPC 华为的一道趣题

Jia Zhang — Sun, 22 Aug 2021 00:00:00 +0000

本文记录 CCPC 华为比赛中的一道题目。

题面#

骤风起，仓颉飘飘乎不自觉于孤岛焉。岛无人迹，唯有有理数二族尔。一族曰甲分之乙，一族曰乙分之甲，甲、乙皆正整数。数之，则族族不竭其数。

鹦鹉谓仓颉：“日择二数，合其为平均或调和平均。造得一，吾送汝归！”

仓颉能归于九千九百九十九亿九千九百九十九万九千九百九十九日否？

翻译过来就是：仓颉被一阵风刮到了一个荒无人烟的小岛上，岛上有两族有理数 $\frac{a}{b}$ 和 $\frac{b}{a}$（$a$、$b$ 为正整数），每族数都有无穷多个。鹦鹉告诉仓颉：“每天你可以选两个已有的数 $x$、$y$，把它们合成为 $\frac{x+y}{2}$ 或 $\frac{2xy}{x+y}$。如果你能合成出 1，我就送你回家！”问仓颉能否在 999999999999 天内回家。

输入有 $T$ 组数据，每组给出 $a$ 和 $b$。

输入样例：

输出样例：

Yes
No
Yes

做法#

先打表。因为是网络赛，可以先用 Mathematica 求出一些较小的情况，得到 $(1,3)$、$(1,7)$、$(1,15)$、$(7,9)$、$(3,13)$ 等都可以做到。

猜想：约分之后（注意一定要约分），分子分母之和为 2 的幂时可以做到，否则做不到。

写一份代码交上去试一下：

#include <cstdio>
#include <numeric>

int main()
{
    int t;
    scanf("%d", &t);
    while (t--)
    {
        long long a, b;
        scanf("%lld %lld", &a, &b);
        long long g = std::gcd(a, b);
        long long s = a / g + b / g; // 约分之后分子分母的和
        puts((s & (s - 1)) == 0 ? "Yes" : "No");
    }
}

发现是对的。

证明#

接下来考虑怎么证明。

充分性#

首先，对于 $2^n$ 个数，不断地两两取平均（像归并排序那样一层一层往上合并），经过 $2^n - 1$ 次操作就能得到它们整体的平均值，即

$$\frac{x_1 + x_2 + \cdots + x_{2^n}}{2^n}$$

若既约分数 $\frac{a}{b}$ 满足 $a + b = 2^k$，就可以看作手头有 $2^k$ 个数：$b$ 个 $\frac{a}{b}$ 和 $a$ 个 $\frac{b}{a}$。它们的平均值是

$$\frac{b \cdot \frac{a}{b} + a \cdot \frac{b}{a}}{2^k} = \frac{a + b}{2^k} = 1$$

即可满足条件。

注意，若约分之前分子分母之和就是 2 的幂，那么约分之后也是：公约数 $g$ 整除 $a + b = 2^k$，所以 $g$ 本身也是 2 的幂，$\frac{a+b}{g}$ 仍是 2 的幂。但反过来不成立，约分之前不满足的，约分后也可能满足，例如 $\frac{3}{9}$。因此要先约分，再判断：既约分数的分子分母之和是 2 的幂，就一定可以。

必要性#

那么，对于既约分数，如果分子分母之和不是 2 的幂，会怎么样？

设分数为 $\frac{a}{b}$ 且既约，即 $\gcd(a, b) = 1$。$a + b \ge 2$ 且不是 2 的幂，等价于存在奇素数 $p$ 使得 $p \mid a + b$。

我们证明下面这个性质始终成立：手里的每个数写成既约分数 $\frac{x}{y}$ 之后，都满足 $p \mid x + y$。一开始的 $\frac{a}{b}$ 和 $\frac{b}{a}$ 显然满足。

设手里两个满足条件的既约分数 $\frac{x}{y}$ 和 $\frac{u}{v}$，即 $x \equiv -y$，$u \equiv -v \pmod{p}$。先看算术平均：

$$\frac{1}{2}\left(\frac{x}{y} + \frac{u}{v}\right) = \frac{xv + uy}{2yv}$$

它的分子分母之和满足

$$xv + uy + 2yv \equiv -yv - vy + 2yv = 0 \pmod{p}$$

这一步可能会发生约分，但不会约去 $p$。因为若 $p$ 整除公约数，则 $p \mid 2yv$，而 $p$ 是奇数，所以 $p \mid y$ 或 $p \mid v$。若 $p \mid y$，结合 $p \mid x + y$ 可得 $p \mid x$，与 $\frac{x}{y}$ 是既约分数矛盾；$p \mid v$ 同理。既然公约数不含因子 $p$，约分之后的分子分母之和仍然被 $p$ 整除。

调和平均同理：

$$\frac{2 \cdot \frac{x}{y} \cdot \frac{u}{v}}{\frac{x}{y} + \frac{u}{v}} = \frac{2xu}{xv + uy}, \qquad 2xu + xv + uy \equiv 2yv - yv - vy = 0 \pmod{p}$$

若 $p$ 整除公约数，则 $p \mid 2xu$，即 $p \mid x$ 或 $p \mid u$，同样与既约矛盾。

所以无论怎么合成，得到的数的分子分母之和都含有奇素因子 $p$。而 $1 = \frac{1}{1}$，分子分母之和为 2，不含奇素因子，因此永远得不到 1。

证明完毕。

2026 年 10 月修订。 原文的判定代码重写得更短：改用 std::gcd 和位运算判断 2 的幂，并改用 long long，避免分子分母相加时溢出。必要性部分把第二个分数记作 $\frac{u}{v}$（原文沿用了 $\frac{a}{b}$，容易和题目里的 $a$、$b$ 混淆），并写出了原文一笔带过（“同理”）的调和平均一步。另外，充分性的构造需要 $2^k - 1$ 天；只要 $a + b \le 2^{39}$（$a$、$b$ 在 int 范围内时远远满足），天数限制就不起作用。

C Hello World Again

Jia Zhang — Sat, 02 Jan 2021 00:00:00 +0000

本文是我给地空学院的同学做的 C 语言讲座的讲稿。

指针与数组#

a[i]、*(a + i) 和 i[a] 是一回事：下标运算 a[i] 本来就定义为 *(a + i)，而加法可以交换。

int (*x)[10] 与 int *x[10] 的区别：前者是一个指针，指向长度为 10 的 int 数组；后者是一个长度为 10 的数组，每个元素都是指向 int 的指针。

指针与数组可以互换着用：

int a[10];

for (int i = 0; i < 10; ++i)
{
    a[i] = 0;
}

for (int *p = a; p != a + 10; ++p)
{
    printf("%d\n", *p);
}

C 风格的字符串#

字符串的表示#

char s[100] = "Hello";

char *s = "Hello";
// 这是一个特殊的行为：
// 注意 int *x = 2; 是完全错误的，但这个语句是对的。
// 编译器会开辟一块内存来存放 "Hello"，并让 s 指向它。
// 但注意：这个 "Hello" 是不可修改的，下面的语句是未定义行为，
// 通常会因为写只读内存而崩溃：
s[1] = 'a';

printf("%c\n", "abc"[2]); // 输出 c
printf("%s\n", "abc" + 1); // 输出 bc
// 这里的 "abc" 是数组 {'a', 'b', 'c', '\0'}，在表达式里退化成指向首元素的指针

char s[100] = {'a', 'b', 'c'}; // 剩下的元素都是 0，所以它也是以 '\0' 结尾的字符串

char *s = (char *)malloc(sizeof(char) * 10);
*s++ = 'a';
*s++ = 'b';
*s++ = 'c';
*s = '\0';           // malloc 得到的内存没有初始化，要自己写上结尾的 '\0'
printf("%s", s - 2); // 输出 bc
printf("%s", s - 1); // 输出 c
free(s - 3);         // 释放 malloc 申请的内存，必须传回 malloc 返回的那个地址

字符串拷贝#

void strcpy1(char *a, const char *b) // 把 b 拷贝到 a
{
    while (*b)
    {
        *a++ = *b++;
    }
    *a = '\0';
}

int main(void)
{
    char a[100];
    char b[100];
    while (scanf("%99s", b) == 1)
    {
        strcpy1(a, b);
        printf("%s\n", a);
    }
}

求值顺序#

printf("%c%c%c\n", getchar(), getchar(), getchar());

输入 abc，用 GCC 编译出来的程序（x86-64）输出 cba，因为 GCC 在这里是从右向左对参数求值的；而用 Clang 编译出来的程序输出 abc。C 标准没有规定函数参数的求值顺序，所以不要写依赖它的代码。

变量作用域#

{
    int x = 2;
}
printf("%d", x); // 编译错误：x 只在上面的花括号里可见

int x = 8;
{
    int x = 3;
    printf("%d", x); // 输出 3，里层的 x 遮住了外层的 x
}

用宏实现 max 函数#

#define MAX(x, y) x > y ? x : y

考虑 MAX(1 != 2, 3)，它展开为 1 != 2 > 3 ? 1 != 2 : 3。由于 != 的优先级低于 >，上式为 (1 != (2 > 3)) ? (1 != 2) : 3，即 (1 != 0) ? 1 : 3，结果为 1。而它本来应该是 MAX(1, 3) = 3。

因此给参数加上括号：

#define MAX(x, y) (x) > (y) ? (x) : (y)

但考虑 3 + MAX(1, 2)，它展开为 3 + (1) > (2) ? (1) : (2)，即 4 > 2 ? 1 : 2，结果为 1，而实际上应该是 5。

因此继续修改这个宏，给整体也加上括号：

#define MAX(x, y) ((x) > (y) ? (x) : (y))

但考虑 MAX(i++, j++)，展开后为 ((i++) > (j++) ? (i++) : (j++))：比较时 i 和 j 各自增一次，被选中的那个还会再自增一次。例如 i = 1, j = 2 时，结果是 3 而不是 2，并且 j 变成了 4。

为此可以这么定义宏：

#define MAX(x, y) ({          \
    __typeof__(x) _x = (x);   \
    __typeof__(y) _y = (y);   \
    _x > _y ? _x : _y;        \
})

这个宏先把两个参数各求值一次，存进临时变量 _x 与 _y 再比较，从而使得 MAX(i++, j++) 符合要求。注意 ({ ... })（语句表达式）和 __typeof__ 都是 GCC 扩展，Clang 也支持，但不是标准 C。

函数与数组的相似点#

	数组	函数
声明	`int x[10]`	`int sum(int, int)`
类型	`int [10]`	`int (int, int)`
指向它的指针	`int (*x)[10]`	`int (*sum)(int, int)`
指针的类型	`int (*)[10]`	`int (*)(int, int)`

数组和函数的共同点：

数组和函数都不能被拷贝（不能整体赋值）。
因为第 1 点，数组和函数都不能做函数的返回值，但函数可以返回指向数组的指针或指向函数的指针。
数组和函数都可以写在函数的形参里，但因为第 1 点，编译器会对其做处理：如果形参类型是数组，实际的形参类型会转换成元素类型的指针，例如 void fun(int arr[5]) 等价于 void fun(int *arr)；如果形参类型是函数，实际的形参类型会转换成对应的函数指针类型，例如 void fun(int test()) 等价于 void fun(int (*test)())。

如何返回一个数组#

用结构体包装一下：

#include <stdio.h>

#define MAXNUM 1000

struct Array
{
    int a[MAXNUM];
};

struct Array DoubleIt(struct Array x)
{
    struct Array y;
    for (int i = 0; i < MAXNUM; ++i)
    {
        y.a[i] = x.a[i] << 1; // 移位的优先级比加减还低，和别的运算混用时要加括号
    }
    return y;
}

int main(void)
{
    struct Array a = {{1, 2, 3, 4, 5}};
    struct Array b = DoubleIt(a);
    for (int i = 0; i < 5; ++i)
    {
        printf("%d\n", b.a[i]);
    }
}

C 学习经验#

多写一些简单的程序做实验，验证自己的想法，从实践中学习。
多写代码，多写代码，多写代码。
找一些好书看，不要看谭浩强之类的。
学会使用搜索引擎。
不要害怕写代码，其实真的不难。这属于技术活，写得越多越熟练。
C 是比较偏向底层的语言，如果有计算机硬件和底层相关的知识，会更好理解。

2026 年 10 月修订。 几处更正：

求值顺序：原文说 GCC 一定从右向左求值。实际上 C 标准没有规定函数参数的求值顺序；GCC 16 在 x86-64 上的确输出 cba，但 Clang 23 输出 abc。
MAX(i++, j++)：原文说 i 和 j 都会自增两次，实际上只有被选中的那个会自增两次。语句表达式版本改用 __typeof__，不再只能比较 int，并注明它是 GCC 扩展。
strcpy1：原来的版本没有写结尾的 '\0'，而是去清空目标缓冲区里残留的字符，对没有初始化的数组会越界读写；改成了直接写 '\0'。scanf 加了长度限制和返回值检查。
malloc 的例子补上了结尾的 '\0'，否则 printf("%s") 会读到未初始化的内存。
修改字符串字面量是未定义行为，不保证报错；void fun(int arr*) 改为 void fun(int *arr)；移位运算符优先级的注释改得更准确。
推荐书目合并成一个列表，删去了书名无法确认的《明解 C 指针》，《C 与指针》更正为中译本书名《C 和指针》。

N Queens Problem

Jia Zhang — Sun, 27 Dec 2020 00:00:00 +0000

This article presents a fast way to find a solution to the famous N queens problem.

Note that we only look for one valid placement, not all of them. For N = 8 there are 92 placements; our program just finds one of those 92. If the problem itself is unfamiliar, the Wikipedia article is a good start.

N = 4#

When N = 4 there are only two placements (1 is a queen):

0100        0010
0001        1000
1000        0001
0010        0100

Our program will find one of the two. So, here we go.

The idea#

Representation. Put exactly one queen in every row and store only its column: queen[i] = j means the queen of row i stands in column j. If queen is a permutation of 1..N, no two queens share a row or a column, so the only possible conflicts are on the diagonals.

Diagonals. Number the anti-diagonals by row + column (from 2 to 2N) and the main diagonals by column - row (from 1 - N to N - 1). The arrays dn and dp count how many queens stand on each of them. The evaluation function collisions is the sum, over all diagonals, of the queens beyond the first one. A placement is a solution exactly when collisions == 0.

Moves. The only move is swapping the columns of two rows. A swap keeps queen a permutation and touches just four diagonals, so its effect on collisions is computed in constant time.

A good start. Most of the work goes into the initial placement. Row by row, we pick a random queen among the ones not placed yet and keep it only if it attacks none of the queens already placed. After at most 4N attempts we give up and place the rest at random. For large N this greedy start leaves only a handful of collisions, so the search that follows is short.

Hill climbing. We keep a list attack of the queens that are under attack. For each of them we pick a random partner and swap the two if the swap lowers collisions. Recomputing the list after every swap would be too expensive, so it is rebuilt only when collisions has dropped below half of its value at the last rebuild.

Random restart. If the climb has made about 32N attempts without reaching zero, it is stuck in a local minimum, and we start over with a new random placement.

This scheme is essentially the conflict-minimizing local search of Rok Sosič and Jun Gu (Efficient local search with conflict minimization: a case study of the n-queens problem, IEEE TKDE, 1994).

Code#

The program takes N on the command line and optionally a file to write the placement to (the column of each row, followed by a drawing of the board when N ≤ 20). It checks the result independently before reporting it.

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

// queen[i] = j 表示第 i 行的皇后在第 j 列（行列都从 1 开始编号）
// dn[k]：编号为 k = 行号 + 列号 的反对角线上有几个皇后，k ∈ [2, 2n]
// dp[k]：编号为 k = 列号 - 行号 的主对角线上有几个皇后，k ∈ [1-n, n-1]
// attack[]：所有正在被攻击的皇后的行号
static int n;
static int *queen, *dn, *dp, *attack;
static long collisions; // 评估函数：每条对角线上多出来的皇后个数之和

static uint64_t rng_state;

// 64 位线性同余随机数（Knuth MMIX 的参数），只用高 32 位
static uint32_t next_random(void)
{
    rng_state = rng_state * 6364136223846793005ULL + 1442695040888963407ULL;
    return (uint32_t)(rng_state >> 32);
}

// [0, k) 内的随机整数
static int random_below(int k)
{
    return (int)(next_random() % (uint32_t)k);
}

static void swap_int(int *p, int *q)
{
    int temp = *p;
    *p = *q;
    *q = temp;
}

// 把第 row 行的皇后从棋盘上拿走
static void remove_queen(int row)
{
    int col = queen[row];
    if (--dn[col + row] >= 1) // 这条对角线上原来就不止一个皇后
        --collisions;
    if (--dp[col - row] >= 1)
        --collisions;
}

// 把第 row 行的皇后放到第 col 列
static void place_queen(int row, int col)
{
    queen[row] = col;
    if (dn[col + row]++ >= 1) // 这条对角线上已经有皇后了
        ++collisions;
    if (dp[col - row]++ >= 1)
        ++collisions;
}

// 交换第 i 行和第 j 行的皇后，同时更新 dn、dp 和 collisions
static void swap_queens(int i, int j)
{
    int ci = queen[i], cj = queen[j];
    remove_queen(i);
    remove_queen(j);
    place_queen(i, cj);
    place_queen(j, ci);
}

static int is_attacked(int row)
{
    return dn[queen[row] + row] > 1 || dp[queen[row] - row] > 1;
}

// 重新计算 attack 数组，返回被攻击的皇后个数
static int compute_attack(void)
{
    int k = 0;
    for (int i = 1; i <= n; ++i)
        if (is_attacked(i))
            attack[++k] = i;
    return k;
}

// 生成初始棋盘
static void initialize(void)
{
    for (int k = 2; k <= 2 * n; ++k)
        dn[k] = 0;
    for (int k = 1 - n; k <= n - 1; ++k)
        dp[k] = 0;
    collisions = 0;

    for (int i = 1; i <= n; ++i)
        queen[i] = i;

    // 我们的目标是在初始化阶段生成一个很好的初态，
    // 这样初态的 collisions 已经很小，爬山的过程会大幅度缩短。
    // 做法是在初始化的时候就尽可能地避免碰撞：
    // 逐行从剩下的皇后里随机挑一个，如果放在这一行不和已经放好的皇后冲突，就采用它。
    // j 表示已经有多少个皇后被优化处理了（下一个要放的是第 j 行），
    // i 用来限制优化阶段所用的时间，超过 search_max 次尝试就强制退出。
    long search_max = 4L * n;
    int j = 1;
    for (long i = 1; i <= search_max && j <= n; ++i)
    {
        int m = j + random_below(n - j + 1); // m 为 [j, n] 之间的一个随机数
        if (dn[queen[m] + j] == 0 && dp[queen[m] - j] == 0)
        {
            swap_int(&queen[m], &queen[j]);
            place_queen(j, queen[j]);
            ++j;
        }
    }

    // 剩下的皇后随机打乱后直接放上去，同时累计 dn、dp 和 collisions
    for (int i = j; i <= n; ++i)
    {
        int m = i + random_below(n - i + 1);
        swap_int(&queen[m], &queen[i]);
        place_queen(i, queen[i]);
    }
}

// 找到一组解：初始化 + 爬山，陷入局部最优时随机重启
static void solve(void)
{
    for (;;)
    {
        initialize();
        if (collisions == 0)
            return;

        // limit 用来决定何时重新计算 attack 数组。
        // 每次交换都重新计算的话开销太大，所以设一个阈值：
        // 只有当 collisions 降到 limit 以下时才重新计算。
        long limit = collisions / 2;
        int number_of_attacks = compute_attack();

        // loopcount 用来判断何时随机重启：
        // 它比较大时，说明爬山法陷入了局部困境
        long loopcount = 0;
        while (loopcount < 32L * n)
        {
            for (int k = 1; k <= number_of_attacks; ++k)
            {
                // 取一个被攻击的皇后和一个随机的皇后，看交换它们能不能减少冲突
                int i = attack[k];
                int j = 1 + random_below(n);
                if (i == j)
                    continue;

                long before = collisions;
                swap_queens(i, j);
                if (collisions >= before)
                {
                    swap_queens(i, j); // 没有变好，换回去
                    continue;
                }

                if (collisions == 0)
                    return;
                if (collisions < limit)
                {
                    // 棋盘变动较大，重新计算 attack 数组
                    limit = collisions / 2;
                    number_of_attacks = compute_attack();
                }
            }
            loopcount += number_of_attacks;
        }
    }
}

// 独立地检查一遍答案：每列恰好一个皇后，且没有两个皇后在同一条对角线上
static int verify(void)
{
    char *col = calloc((size_t)n + 1, 1);
    char *d1 = calloc(2 * (size_t)n + 1, 1);
    char *d2 = calloc(2 * (size_t)n + 1, 1);
    int ok = col && d1 && d2;
    for (int i = 1; ok && i <= n; ++i)
    {
        int c = queen[i];
        if (c < 1 || c > n || col[c] || d1[c + i] || d2[c - i + n])
            ok = 0;
        else
            col[c] = d1[c + i] = d2[c - i + n] = 1;
    }
    free(col);
    free(d1);
    free(d2);
    return ok;
}

int main(int argc, char **argv)
{
    if (argc < 2 || (n = atoi(argv[1])) < 1 || n > 100000000)
    {
        fprintf(stderr, "usage: %s N [output-file]   (1 <= N <= 100000000)\n", argv[0]);
        return 1;
    }
    if (n == 2 || n == 3)
    {
        printf("no solution for N = %d\n", n);
        return 0;
    }

    // 下面几个数组的下标可能为负，所以先开辟空间，再让指针指向合适的位置，
    // 例如 queen[1] = pre_queen[0]，dn[2] = pre_dn[0]，dp[1-n] = pre_dp[0]
    int *pre_queen = malloc(sizeof(int) * (size_t)n);
    int *pre_dn = malloc(sizeof(int) * (2 * (size_t)n - 1));
    int *pre_dp = malloc(sizeof(int) * (2 * (size_t)n - 1));
    int *pre_attack = malloc(sizeof(int) * (size_t)n);
    if (!pre_queen || !pre_dn || !pre_dp || !pre_attack)
    {
        fprintf(stderr, "out of memory\n");
        return 1;
    }
    queen = pre_queen - 1;
    dn = pre_dn - 2;
    dp = pre_dp + (n - 1);
    attack = pre_attack - 1;

    rng_state = (uint64_t)time(NULL);

    clock_t start = clock();
    solve();
    clock_t end = clock();

    printf("N = %d: found a solution in %.3f seconds (%s)\n", n,
           (double)(end - start) / CLOCKS_PER_SEC, verify() ? "verified" : "INVALID");

    if (argc >= 3)
    {
        FILE *fp = fopen(argv[2], "w");
        if (!fp)
        {
            perror(argv[2]);
            return 1;
        }
        // 第 i 个数是第 i 行皇后所在的列；N 不超过 20 时再画出棋盘（* 为皇后）
        for (int i = 1; i <= n; ++i)
            fprintf(fp, "%d%c", queen[i], i == n ? '\n' : ' ');
        if (n <= 20)
            for (int i = 1; i <= n; ++i)
            {
                for (int j = 1; j <= n; ++j)
                    fputc(j == queen[i] ? '*' : '-', fp);
                fputc('\n', fp);
            }
        fclose(fp);
    }

    free(pre_queen);
    free(pre_dn);
    free(pre_dp);
    free(pre_attack);
    return 0;
}

Build and run:

$ cc -O2 -o nqueens nqueens.c
$ ./nqueens 8 out.txt
N = 8: found a solution in 0.000 seconds (verified)
$ cat out.txt
5 1 8 6 3 7 2 4
----*---
*-------
-------*
-----*--
--*-----
------*-
-*------
---*----
$ ./nqueens 1000000
N = 1000000: found a solution in 0.060 seconds (verified)

The placement differs between runs because the random seed comes from the clock.

Revised in October 2026. The original program had a few bugs, fixed above:

It picked the random partner with ((rand() << 6) + rand()) % n + 1. On glibc, where RAND_MAX is 2³¹ − 1, the shift overflows int, which is undefined behaviour; in practice the index went negative and the program wrote outside its arrays. For large N it printed placements that were not even permutations. The program now uses its own 64-bit generator.
The change in collisions caused by a swap was computed with a shortcut formula that is wrong when the two queens share a diagonal, so collisions could drift from the true count. A swap is now applied as “remove both queens, put them back swapped” and undone if it does not help, which is exact.
The arrays were always allocated for 123,456,789 queens; they are now sized by N. N = 2 and N = 3, which have no solution, used to loop forever.
Interactive prompts were replaced by command-line arguments, and the solution is verified before it is printed. Timings above were measured on an AMD Ryzen 9 9950X.