STILL LIVING

题目：630K
题意：给你一个整数n，输出1到n中不能被k整除的数字的数量，k可以是【2，10】中的任意一个整数。
思路：训练赛的B题，也是大部分人都做出来的一题。
涉及到了数论的一些知识，要用到容斥定理。
从1到n，不能被k整除的数的数量： n/k*(k-1)+n%k
当然也可以反过来求能被k整除的数，再减，可能更方便。

1
2
3
4
5
6
7
8
9
10
11
12
13

#include<bits/stdc++.h>
using namespace std;
long long RT(long long n,long long a){
    return n/a*(a-1)+n%a;
}
int main()
{
    long long n;
    cin>>n;
    long long ans = RT(n,2)+RT(n,3)+RT(n,5)+RT(n,7)-RT(n,6)-RT(n,10)-RT(n,14)-RT(n,15)-RT(n,21)-RT(n,35)+RT(n,30)+RT(n,42)+RT(n,105)+RT(n,70)-RT(n,210);
    cout<<ans<<endl;
    return 0;
}

题目如下：
请按要求编写一个类Circle，用于描述一个圆形，并用给定的main函数测试Circle类的功能。Circle类的要求如下：

1. 包含圆形编号、圆心x坐标、圆心y坐标和半径等数据成员。圆形编号为整形。生成第1个圆形对象时编号为1，生成第2个圆形对象时编号为2，以此类推。每构造一个新的圆形，对象编号为当前最大编号加1（如当前最大编号为5，则生成的这个新圆形的编号应该为6）。
2. 是否需要其它数据成员，可视情况自行决定。提示：建议使用两个静态变量。一个静态变量用于记录当前圆形对象的个数，此变量的值可增大或减小；另一个静态变量用于记录已经生成的圆形对象的最大编号，此变量的值只会增大不会减小。
3. 1个带有3个参数的构造函数。3个参数分别初始化圆形的圆心x坐标、圆心y坐标和半径等数据成员。提示：圆形对象的编号也需要初始化。
4. 1个拷贝构造函数。提示：圆形对象的编号不能简单复制。
5. 1个获取当前圆形对象数量的函数。提示：此函数建议为静态函数。
6. 前自增运算符，对半径自增1。
7. 后自增运算符，对半径自增1。
8. +运算符，用于将两个圆形加在一起，得到一个新的圆形。新圆形的圆心坐标是两个圆形坐标连线的中点，面积是两个圆形面积的和。提示：需要根据面积反算半径。
9. 流输出运算，用于显示圆形的编号、圆心x坐标、圆心y坐标和半径、面积、周长。一个圆形的信息占1行。
10. 析构函数。圆形对象销毁时，需要将当前圆形对象的数量减去1。
11. 使用给定的main函数测试Circle类的功能。

代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

///#Author:Rye
#include<bits/stdc++.h>
#define PI 3.1415
using namespace std;

class Circle
{
private:
    static int m_number;//当前圆对象的数量
    static int m_maxCount;//最大编号

    int m_count = 0;//对象编号
    double m_x;
    double m_y;
    double m_r;
public:
    Circle(double x,double y,double r){
        m_x = x;
        m_y = y;
        m_r = r;
        m_count = ++m_maxCount;
//        cout<<"调用了构造函数"<<endl;
        m_number++;
    }
    Circle(const Circle&C){
        m_x = C.m_x;
        m_y = C.m_y;
        m_r = C.m_r;
        m_count = ++m_maxCount;
//        cout<<"调用了拷贝构造函数"<<C.m_count<<endl;
//        m_maxCount++;
        m_number++;

    }
    ~Circle(){
//        cout<<"调用了析构函数"<<endl;
        m_number--;
    }
    static int get_num(){
        return m_number;
    }
    Circle& operator++(){
        m_r++;
//        cout<<"前置++"<<endl;
        return *this;
    }//前置++
    Circle operator++(int){
//        cout<<"后置++"<<endl;
        Circle temp(*this);//调用拷贝构造函数
        temp.m_count = m_count;
        m_r++;
        return temp;
    }//后置++
    friend Circle operator+(const Circle &a,const Circle &b);
    friend ostream &operator<<(ostream &out,const Circle &t);//流输出
};

//Circle& operator++(Circle &t){///友元函数重载
//    t.m_r++;
//    return t;
//}

//Circle operator++(Circle &t,int){
//    Circle temp(t);//调用拷贝构造函数
//    temp.m_count = t.m_count;
//    Circle::m_maxCount--;
//    Circle::m_number--;
//    t.m_r++;
//    return temp;
//}

Circle operator+(const Circle &a,const Circle &b){
    double S = PI * (a.m_r * a.m_r + b.m_r * b.m_r);
    double R = pow(S / PI, 0.5);
    Circle NEW(a.m_x + b.m_x, a.m_y + b.m_y, R);
    return NEW;
}

ostream &operator<<(ostream &out,const Circle &t){
    cout << "圆的编号" << t.m_count << " x:" << t.m_x << " y:" << t.m_y << " 周长:" << 2 * PI * t.m_r << " 面积:" << PI * t.m_r * t.m_r << endl;
    return out;
}

int Circle::m_maxCount = 0;
int Circle::m_number = 0;

int main()
{
    Circle c1( 1.12, 2.23, 3.34 ), c2( c1 );

    cout << c1 << c2;
    cout << "Number of circles = " << Circle::get_num() << endl;

    Circle c3 = c1 + c2;
    cout << c3;
    cout << "Number of circles = " << Circle::get_num() << endl;

    cout << c1++;
    cout << ++c2;
    cout << c1++;

    return 0;
}

其实很简单。
但是踩了一个坑，今天有同学来问我这道题，有关于静态变量。它的序号莫名其妙增加了。
我第一次写的时候也出现了这个问题，后来找到问题所在。
如果使用友元函数重载运算符，传入的参数没有使用常引用的时候，就会调用拷贝构造函数。
比如你把friend ostream &operator<<(ostream &out,const Circle &t);写成了friend ostream &operator<<(ostream &out,Circle t);

那么cout << c1 << c2 就会调用2次拷贝构造函数和2次析构函数。在不涉及静态变量的时候，常引用和不写引用的方式是没有区别的。但是这道题目中，调用拷贝构造函数会使最大序号增加，而析构函数不会使最大序号减小，所以这种写法就错了。

常引用能够提高程序运行的效率，也能保护传递给函数的数据不被改变。引用型参数如果可以被定义为const，应该尽量定义为const。

参考：HZK16汉字16*16点阵字库的使用及示例程序
今天课上老师让我们写一个用16*16的点阵字库显示汉字的程序，给了一个HZK16字库。但是奈何本人太过愚钝，上课时候没怎么听懂，只能在网上借鉴了大神的博客。

我们想要显示一个汉字的16×16的样子，就需要先明白这个原理。
在HZK16字库中，用二进制的形式存储了很多汉字的形状。一个汉字使用32个字节储存。其中0代表空白（白色方块），1代表有笔画/墨水的黑色方块。

比如这个“啊”字。
一字节(byte)对应着8位(bit)，8位中的每一位都代表着一个0或者1，这就是计算机最底层的存储。
也就是说，一个字节能够保存的数字，换算成16进制也就是0x00-0xFF。
上面说了，每一个0或者1都分别代表着空白或者有笔画，所以，我们用一个字节(byte)可以存储8个方块。
16×16就可以被分割为16×2×8，也就是32个字节。
比如第一行，我们把白色方块变成0，黑色方块变成1，8个为一组分开，将会是这样：
0b00000000=0x00;0b00000100=0x04
第二行，就是这样：
0b00101111=0x2F;0b01111110=0x7E
所以存储这个“啊”字的32个字节分别是：00 04 2F 7E ……

我们想要打印这个汉字，只要找到这32个字节，然后分别将每一个位置上的0或者1用别的形式打印出来。
那么怎么将一个二进制数字的每一位都取出来呢？这就需要运用位运算。

1

flag = buffer[k*2+j]&key[i];

也就是这一行。
比如0x2F
二进制形式是0b00101111，想要取出他每一位上的数字，分别和0b10000000(也就是十进制的128，十六进制的0x80)、0x40，0x20…进行&运算，就可以得到结果。

1
2
3

unsigned char key[8] = {
    0x80,0x40,0x20,0x10,0x08,0x04,0x02,0x01
};

这也是最开始定义key数组的原因。

那么怎么在字库中找到这个汉字的位置呢？

老师的PPT中给了一个字形码计算的公式：word[1]-0xA1+94×(word[0]-0xb0)+15×94
这个公式其实等价于：(94×(区码-1)+(位码-1))
如果有对区码和位码的概念不清楚的同学可以参考上面的博客。

但是这个公式并不能用来找到一个汉字在字库中的位置，需要乘以32，可能是因为一个汉字用32个字节显示。

1
2

unsigned int offset = (94*(unsigned int)(word[0]-0xa1)+(word[1]-0xa1))*32;
unsigned int offset2 = (word[1]-0xA1+94*(word[0]-0xb0)+15*94)*32;

这两种都是正确的。

最后，注意字库文件应该用二进制形式打开。

题目见: 1360D
题意：给n把铁锹和一个数k，可以选择任意一个数1<= t <= k，每次都购买t个铁锹，求最少的购买次数。
思路：求n的最大的但不大于k的因数,n除以这个因数就是答案。可以想到的是：1.在k>=n的情况下，只需要购买1次。2.正常来说，为了找到1到k范围内n的最大的因数，我们需要遍历1到k，但是这样很容易导致超时。优化的方法是：遍历1√k，如果能找到一个数x被n整除，这说明它是其因数。并且，n/x也是其因数。
例如第一组样例n=8,k=7
如果遍历17则是：
x=1, n%1=0, 8/1=8;
x=2, n%2=0, 8/2=4;
x=3..
x=4, n%4=0, 8/4=2;
n=5..6..7..
其中最大的因数是4,故而ans = 2;
但是如果遍历1~√7则是
x=1, n%1=0, 8/1=8, 8/(8/1)=1 (8>7 不成立);
x=2, n%2=0, 8/2=4, 8/(8/2)=2;
可以看到，当我们遍历到最小的因数的时候，其实也获得了对应的最大的因数。
只要这个相对小的因数对应的相对大的因数不大于k，我们就可以认为它对应的相对大的因数是最终的答案。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include<bits/stdc++.h>
using namespace std;
int main()
{
    int t;
    cin >> t;
    int a,b;
    while(t--){
        cin >> a >> b;
        if(b >= a ){
            cout << 1 << endl;
            continue;
        }else{
            int ans = a;
            for(int i = 1; i * i <= a; i++){
//                cout << i << endl;
                if(a % i == 0 ){
                    if(i <= b)
                        ans = min(a/i,ans);
                    if(a / i <= b)
                        ans = min(ans, i);
                }
            }
            cout << ans << endl;
        }
    }
    return 0;
}

题目
题意：给一个字符串，寻找最多个数“xtCpc”的子串，有大小写区别。
思路：对于队列不太熟悉，一开始用数组，自己造的数据死活过不了，交了两次也就没写了。用队列保存每个字母出现的下标，然后由x开始检索，查找符合条件的下标大于前一个字母下标的对象，不符合条件的，后面的也不可能成立，于是pop。查完到‘c’的时候，答案+1；如果超出就结束。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

/*
 @Author : Rye Wang
 @Version : 1.0
 @E-mail : Rye10000010000@hotmail.com
 @Site: Rye1024.gitee.io
 @Time : 2020-05-24-19.05.11
*/
#include<bits/stdc++.h>
using namespace std;
#define LL long long
#define dbug cout << "Where?" << endl;

int main()
{
    int t;
    string s;
    while(cin >> t >> s)
    {
        queue<int> x;
        queue<int> t;
        queue<int> C;
        queue<int> p;
        queue<int> c;
        while( ! x.empty())
            x.pop();
        while( ! t.empty())
            t.pop();
        while( ! C.empty())
            C.pop();
        while( ! p.empty())
            p.pop();
        while( ! c.empty())
            c.pop();
        for(int i = 0; i < s.size(); i++)
        {
            if(s[i] == 'x') x.push(i);
            else if(s[i] == 't') t.push(i);
            else if(s[i] == 'C') C.push(i);
            else if(s[i] == 'p') p.push(i);
            else if(s[i] == 'c') c.push(i);
        }
        int ans = 0;
        while(x.size()){
            int pos = x.front();
            x.pop();
            while(t.size() && t.front() < pos) t.pop();
            if(t.empty()) break;
            pos = t.front();
            t.pop();
            while(C.size() && C.front() < pos) C.pop();
            if(C.empty()) break;
            pos = C.front();
            C.pop();
            while(p.size() && p.front() < pos) p.pop();
            if(p.empty()) break;
            pos = p.front();
            p.pop();
            while(c.size() && c.front() < pos) c.pop();
            if(c.empty()) break;
            pos = c.front();
            c.pop();
            ans++;
        }
        cout << ans << endl;
    }
    return 0;
}

题目见：1355A
题意：一个数a1，进行K次操作，每次加上a1各个位置上最大的数和最小的数的乘积。
思路：K有可能取到很大，如果单纯模拟绝对会超时。观察题目可以发现，a1进行有限次操作后，各个位置上最小数会变成0，这个时候答案就是不变的了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define db cout<<"where"<<endl;
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        ll a,n;
        string b;
        cin>>a>>n;
        for(int j=1; j<n; j++)
        {
            b=to_string(a);
            char MAX='0',MIN='9';
            for(int i=0; i<b.size(); i++)
            {
                if(b[i]<MIN)
                    MIN=b[i];
                if(b[i]>MAX)
                    MAX=b[i];
            }
            int MAXX=MAX-'0',MINN=MIN-'0';
            if(MINN==0)
                break;
            a+=MAXX*MINN;
        }
        cout<<a<<endl;
    }
    return 0;
}

所谓仪式，是在一件本来没有价值甚至劳民伤财的事件上注入了感情和美好的祝愿，赋予其意义和存在的必要。所以古时候杀猪牛羊，本来是浪费食物，如果说用去祭祀天地，那就是良好的祝福。

所谓仪式感，指的就是这种生活的态度。就像《小王子》中说的，是使这一天与其他的日子不同，这一刻与其他的时刻不同。

一定要把一个单调寻常的东西变得特殊，这是不是自作多情？你别说，我们的生命里有的时候还真就是需要这种自作多情。

一个人只拥有此生此世是不够的，他还需要拥有诗意的世界。

诗意的世界就借由仪式感来创造。

想象一下这样的场景：落叶纷飞的秋天，云的颜色阴沉沉的，路人们都戴着口罩和帽子，低着头脚步匆匆。你也走在大街上，这时你看到了一片银杏落叶。所有的银杏落叶都是金黄色的小扇子，长着细密的纹理，但这一片不一样。这一片不一样在什么地方？它在小扇子的边缘处，边缘的中间，缺了一个小口。这使它看上去不像是一把小扇子，反像是一颗小爱心了。你轻轻地蹲下，是蹲下而不是弯腰，因为你想离得更近一些，再温柔一些地把它捡起来。你把它放到大衣的口袋里，又怕走着走着被压碎了，于是捏着柄拿在手上。回到住所，你第一件做的事就是打开最心爱的那本厚厚的日记本，把它夹在里面。

再想像一下这样的场景吧：一个平平常常的午后，硬要说有什么特别不平常的地方，那就是西边的云比平常多了两朵。温柔的阳光照在你的书桌上，正像所有好天气的冬日下午两点钟一样。你看了看表，两点半，是时候泡一杯咖啡了。卡布奇诺，一定是卡布奇诺，在上面要有图案精美的拉花。可能是一棵树，可能是一朵花，但更多时候是爱心。品着咖啡，静静地读一本书，上周是《百年孤独》，那么这周是《病隙碎笔》，感受到了吗？温暖的阳光，温暖的咖啡，在你的体内酝酿着，在繁忙的日常中无所安放的灵魂也在这样的时刻被安抚了。

有些人说自己日子单调枯燥，生活无趣乏味。其实每个人的生活都是日复一日地重复。他想象的精彩是什么样子？每天都去不同的地方旅行？如果天天如此，那么在他这里，不也仍然难逃乏味二字吗？米饭九分平淡，但若细细品尝，也有一分甘甜。所以我觉得，没有无趣的生活，只有无趣的人。

生活中的仪式感，它是对生命本身的敬畏，也是对生活本身的热爱。

让平凡的日子也散发出光亮。

世间万物的运行都有其规律，在人生的不同阶段对于世界都会有着不同的认知。

我记得我二年级的时候为了寻找为什么夏天热而冬天冷，提出了在冬天太阳距离地球远而在夏天太阳距离地球近的观点——还把这个想法发在了当时我自己的儿童博客上。后来我才知道1月份的近日点反而是一年中最冷的时候。这样的论点当然在今天看来很可笑，但于当时的我，已经是穷尽所有想象力能为这个世界找到的最科学解释了。

如果一个小球的抛出点和初速度是固定的，力是固定的，重力已知，方向已知……在这样的情况下，小球的运动轨迹是可以计算的。那么，是否一切活动，都是遵循一定的规律的呢？是否只要知道所有的参数，就可以了解过去，现在，和未来呢？

相信一切是被决定着的，这种观点被称作决定论。由此而诞生的一个概念就是拉普拉斯妖，一位全知全能的妖精。说远了，不提。

哲学上而言，我并非不支持自由意志的观点，我认为人的主观能动性是客观存在的。但是，了解一定的规律仍然有利于我们做出更好的选择。

就像我二年级时认为太阳的远近是导致温度差异的原因一样，我只能用自己有限的知识在这个无垠的世界里寻找答案，或许永不可即，但追求知识的脚步是不会停下的。

由最近的学习内容产生了一些感想，记录如下。

本人才疏学浅，言论如有不当之处，还请各位多多包涵。

电影《美丽心灵》介绍了博弈论的奠基人，二十世纪伟大的数学家、经济学家约翰·纳什的一生。纳什因为其对博弈论的贡献，获得了诺贝尔经济学奖。他最重要的理论之一就是提出了纳什均衡，通俗的来说，就是指在一场博弈中的两个当事人都停留在对自己最有利的一个位置的平衡状态。这两个人如果做任何的决策，都会导致局面对自己不利。

这个理论的提出意味着博弈问题是有解的，因此博弈论才有了研究的价值。

在我们计算机算法设计的领域，最著名也是最简单的算法莫过于贪心算法。也即是每次行动都作出目前条件下的最优解，那么将得到最好的效果。显而易见，不是什么情况都能应用贪心算法的，因此，是否能运用贪心是需要证明的。（当然，实际运用的时候，我们并不会去证明，只是觉得好像可以用，然后敲一遍看看答案对不对。）

贪心算法当然和博弈论搭不着边，但是贪心策略却是很重要的一环。

生物的本性是自私的，生物的本能会促使我们做出对自己最有利的选择。

经济学中的“理性人”是指，每次行动都追求自身最大的利益而不管别人的死活。这是合理的。

那么设想一下这样一个情况：两个囚徒被关在监狱里，互相隔离。他们都是理性人。狱警和他们说，如果他们都不检举对方的罪行，他们都会被关押一年。如果一位检举而另一位不检举，那么检举的将被释放，另一位被关押十年；如果两位都坦白，他们各自被关押五年。

这种情况下，对于囚徒A来说，检举对方是最优解。

如果B不检举，那么A就溜之大吉了。如果B检举了而他不检举，那么他将被关押十年。如果B也检举了，那么他被关押五年——也比十年更好。

于是，两个人达成的纳什平衡是互相背叛。此时，任何一个人作出合作的举动都会导致他陷入更差的境地。然而，这并不是最优解。最优解是两个人互相合作。

在电影《少年的你》中小北和陈念被审问的时候，他们没有承认。这就是合作的一种行为。这是感性的一种行为。

如果人们不去考虑对自己的利益最大化，始终抱着合作意愿，那么反而将得到囚徒困境的最优解。

再设想这样一种情况，让人们从1~100报一个数，最接近平均数的三分之二那个人将得到奖品，最优解是多少？首先设想所有人的数均匀分布，那么均值是50，答案是33。显然，你不应该猜超过33的数。如果所有人都这么想，那么你不该猜超过22的数……继续，继续，继续……最后，你应该猜1。如果所有人都是这样理性驱动，猜1，大家都有奖品。

但是如果其中有一个人没有考虑这么多，胡乱猜了一个数字呢？

美好的局面就被破坏掉了。最美的结局建立在所有人都是绝对理性的情况下，这样的情况是不稳定的。感性会破坏最优解。

生物的进化正源自于此。如果所有人都是怀揣着恶意的，那么这个族群就会在互相攻讦中毁灭。如果所有人都是利他的，他们通过合作可以取得更大的利益，但是一旦这个族群中突变出了一个利己主义者，那么所有的利他行为者都会变成待宰的小白羊被收割。

如何破解囚徒困境？说来很简单，一报还一报。

先尝试合作，接下来每次行为都模仿对方上次的行为。这样需多次重复之后，即使对方的行为是不确定的，坐牢的年数总和也是最少的。

利他和利己，感性和理性，二者之间都是彼此不可分割的。

贪心算法是有助于解决实际问题的，因为对象只有一个。

而当问题变成非零和博弈的时候，即使是最理性的人作出的最理性的选择也未必是最优解。人与人之间交互的神奇之处就在于此了。

今天上课的时候讲到人工智能，绝对理性的人工智能能摆脱囚徒困境吗？恐怕未必比小北和陈念做得更好吧。人们的相处，是不能用什么理论去预料的呀。拉普拉斯妖，你能知道吗？

山石巴是一家自助餐厅，坐落在南洋广场不起眼的一个犄角旮旯里。

之所以叫山石巴，是取了“三十八”的谐音：自助餐，38元一位。这样的取名风格，大概是为了凸显出实惠吧。

第一次去那儿，是小乐乐带我去的。高中时候的我们，唯一有的空闲时间无疑是周日。那时在学校中自习，上午和晚上都是埋头在书本里暗无天日的学习时间，但也得益于此，同学们一起出去吃饭很方便。中午打个车或者坐个公交，去南洋或是万达，总是有几家心仪的实惠小店。在夕阳西下之前优哉游哉地转回来，这就是我们在那些单调乏味的日子里最大的欢乐了。

十八岁时的我没有顾虑和忧愁，不担心未来和过去。

小乐乐说，王雨，要不要陪我去吃饭。

我说，好。

于是我们就出发了。周末中午时候的112总是拥挤的，我们常把这班车次戏称为校车，因为上面都是被关了一个星期迫不及待出去放风的太高学生。

小乐乐第一次带我去时，我被震惊到了。你能想象吗？一家餐厅建在二楼，而通上去的楼梯竟然是塌的，布满了钢筋和灰尘，像是被强拆的钉子户一样不堪。他尴尬地笑了笑，说：“这里卖相确实不怎么好，但是你一定不会后悔的。“

跟着他绕来绕去，原来不是走楼梯上去的，在颓圮的房间里藏着一扇电梯门，通过电梯，就可以上去了。正式进入了餐厅，眼前一亮。人出乎意料地多，沙发上坐满了排队等候的顾客。房间里面热气腾腾的，氤氲着温暖的人间烟火气。

三十八元一位，对于自助餐来说，确实是很实惠的价格了。可供选择的菜品还真是不少，种类齐全。至于味道？至少比食堂的饭菜更容易下口。

来了一次，就想来第二次。然后我们又挟上了其他的小伙伴。

旺哥被我们带来的时候，也被楼梯口的破败吓到了。他一脸怀疑地看着我们俩，怀疑是在耍他。与后来他大快朵颐的样子形成了强烈的反差。

有一块灰黑色的饼，我不知道那是什么，因为我至今不敢下口。我们仨那时看着这个不明物体，面面相觑。

“猜拳吧，谁输了谁吃。“

于是张道旺哭丧着脸把它塞进嘴里。
我狂笑。

看他的表情，整个脸都皱到一块去了。好不容易咀嚼了几下，就捂住嘴巴，一脸要吐的样子。其浮夸的颜艺，堪比城之内。

而我和小乐乐，丝毫没有一点愧疚之情。

因为他真的太好笑了。

后来，我们常来这里。一起的同学越来越多，有的时候甚至一桌子坐不下。小乐乐一直在不遗余力地推广着这家餐厅，即使他们不会给他广告费。然后，这里就留下了我们的许多回忆。

说起来也没有过很长时间，却让人好怀念。

真想和你们再聚一聚，即使那些时光已经消失不见。

一

如果说这座小城里还有什么可爱的去处，应该就是南园了。

万历年间的首辅王锡爵建了这座小园，在这里赏花论道。大书画家董其昌曾在此赋诗，文坛领袖王世贞曾在此题匾。据说，脍炙人口的昆曲《牡丹亭》是在王锡爵的支持下才得以面世，而这里就是《牡丹亭》第一次演出的地方。

回溯过去，竟已过了四百年。春秋更迭，物是人非，曾经在这里发生的风流往事都已经湮没于尘烬，昔日权宦的私人居所也已变成了公共景点。

我初识南园，大概是在初中。学业繁重的时候，总想着去哪里散散心。听说，在这里可以找到所有秋天的颜色。

菊展是一年一度的盛事。你可以找到穷尽你的想象所能描摹出的所有色彩的秋菊，它们无一不在热烈而骄傲地绽放。那些花瓣，或是规整而有序地排列着，或是狂放而张扬地散落着。若逢一场秋雨，吹过一阵萧瑟的冷风，则又是另外一副光景了。银杏叶和枫叶从树上飘下，在空中打着转，落到地上，盖住了长满青苔的地砖。砖上那些斑驳的痕迹，大概是名为岁月吧。

南园位于喧哗的闹市，里面却是别有一番天地。而我坐在这里，日光的影子透过石亭的缝隙洒在桌面上，我张开一本厚厚的旧书，成为了南园的一部分。

那本书是村上春树的《挪威的森林》，依稀记得里面有一段话是这么写的：

“每个人都有属于自己的一片森林，也许我们从来不曾走过，但它一直在那里，总会在那里。迷失的人迷失了，相逢的人会再相逢。”

二

前年初夏，和肖洁同游南园。

那天的云是懒散的，阳光也很好。

她撑着一把遮阳的伞，穿着像云一样白的T恤衫。简单地梳了一个低低的马尾辫。扎头发的皮筋，一粒粒红色的，又与红豆十分相像。

午饭，是在南园旁边的和乐满屋吃的。曾经太高还在南园路上时，同学们经常在放学后于此约会。屋内的装饰很用心，桌椅整齐干净，光线明亮温暖。鸡排咖喱饭，鸡排很大，咖喱也很好吃。从那以后，肖洁常常点和乐满屋的外卖。

路上有一家卖绿豆汤的小店，店主是一位本地口音浓重的婆婆。苏式绿豆汤，像苏州的园林一样精致。除了绿豆之外，还有糯米，薄荷，冬瓜糖，金桔，蜜枣。在一个小小的碗里，不仅冰凉解渴，卖相也十分可爱。我们一起喝了绿豆汤。

初夏，南园的荷花含苞待放。花瓣尖尖的，粉里透着白。用荷花比作少女是老套的比喻了，但要我来说，着实没有什么更恰当贴切的说法。她们亭亭玉立着，微微含笑。回想起来，竟是那样地难忘。

回去的路上，在公交车站等车。夏日的天气总是说变就变，忽然间暴雨已至。肖洁的伞很努力地抵挡着狂风和大雨，可惜收效甚微。刚刚错过了一班公交车，我们在车站等了很久。雨下的好大，地面上的低洼处，眨眼间就泛滥成一片汪洋。然后水流一股一股地冲刷下来。

路过的车开的飞快，溅起很高的水流，把我们俩都淋湿了。

狼狈地抱着背包，几乎睁不开眼睛。她笑着说，淋雨是体验生活的一种方式。

碰到这么大一场雨，两只落汤鸡竟然没有一丝不愉快。

肖洁上车前，硬把她的伞往我手里塞。

回家后，她悄悄地发了一条语音消息，很快地又撤回了。

“就算大雨把这座城市颠倒，我会给你拥抱。”

三

我回家的路是很跌跌撞撞的。路上有很多处，积水可以没过膝盖。骑过那些地方的后果可想而知了。绿化带都被淹了，我磕到了两次绿化带。裤腿，袜子，都是又湿又脏的。回家之后，洗了整整半个钟头的澡。

去年的生日，胡佳琪要为我准备生日礼物。她觉得最好的礼物一定不是买来的，于是从十月份就开始思考这件事。

她知道我深爱着这个园子，从上海专程来到南园。在这里拍下了照片，写了文字，打算在我生日的时候寄给我。

你知道吗？

那样的感觉是很奇妙的，我在南园中曾经虚度的许多时光，游离的思考，产生的许多感情，在那之前从未有人在意过。他们不知道大雪落下的时候，百年的红梅还在开；他们不知道下午的鹤梅仙馆里会有老人唱戏；他们不知道雨水积在荷叶的叶面上形成的小水潭是什么样的，也不知道鸭子们排队游过小桥是什么样的。

这些我从未告诉过别人。我并不期待着他们能懂。总是有很多人说着自己能懂，其实说着一些完全不相关的话。每个人都是一团火，路过的人只能看到烟。

但那天我突然开始幻想了。

因为那天，有人想要走进那个瑰丽宁静的世界。

那是一种惊喜至极以至于惶惑的卑怯。

那是一种孤独苦闷却得到和解的释然。

四

可惜的是，我没能收到这份生日礼物。我们有了一些矛盾。十一月，我们约定不再以写信的方式联络，而我的生日在十二月。

她给我准备的礼物是这段她的旅程，我也是后来才知道的。但是她到底拍了一些什么样的照片，写了一些什么样的文字。她在南园里所看到的，究竟是不是我在南园里所看到的，而她的心情和感受又是怎样的。这些，我都无从得知了。

六月份的时候，高考结束了。半个月之后，肖洁离开了这个不属于她的城市，回到桐城。我们就那样轻描淡写地说了再见，即使我们都知道，她或许不会再回到太仓了。就像一本故事书，写到了最后一页，就再也没有可以写的地方了。

再见，大概指的是，此生再难相见。

但也没有什么值得遗憾的。告别是人生永恒的命题，孤独也是。

即使是从小抚养你长大的父母，有一天也要和他们说再见。生死是最大的告别，能够接受生老病死的规律，为什么不能承担离别呢？

胡佳琪走进了那个世界吗？我想，应该没有。在长久与南园的相处中，它于我已经不是一个地缘意义上的概念了。在南园的那些记忆，被抽象，揉碎了而后重组，然后慢慢随着时间的流逝积淀着。它们组成了我的南园，而独属于我的那座园子，是别人进不来看不到的。

她也许也看到了些什么，但那些体验是我不能够分享的。即使辞藻再优美，用词再斟酌谨慎而精确，发生过的事终究还是是失真了。她也许走进了一个世界，但那是她的世界。

“就算大雨把这座城市颠倒，我会给你拥抱。”

肖洁在发出那条语音消息的不到一分钟就把它撤回了。或许她没有想让我听到。

那家很好吃的和乐满屋关了。最后一次看到的时候，里面的桌椅歪七扭八地叠放着，布满了厚厚的一层灰尘。

我又想起了那个独坐在亭子里读书的午后，南园里是空荡荡的，只有花草，石桥，落叶和我。

书里还写了一句话：

“即使是你最心爱的人，心中都会有一片你无法到达的森林。”

那真是好宁静的一段时光，听着树叶沙沙地响，荷塘里不时泛起一圈圈涟漪，我抬起头，看着周围的世界，

这里，怎么这么空呢？

https://pic.imgdb.cn/item/5f7889bb160a154a6719b621.jpg