1. 打表之“是什么”“为什么”“怎么办”

1-1. 打表是什么？

打表，顾名思义，就是将所有可能的答案打成一个表，进行看似不太正经地求解。

1-2. 为什么要打表？

有时，题目输入的数据很小，我们无法用程序高效求出，这时，我们就可以预先算出答案，存储进一个数组中，然后就可以“对号入座”了。

1-3. 怎么打表？

一般地，我们会有一个 table.cpp/py（用来打表的程序）与 solve.cpp（最终程序），先执行 table.cpp，一般会输出到文件 table.txt，然后复制 table.txt 的内容到 solve.cpp 轻松解题。

2. 打表题选——直接打表

这些题目，我们直接打表输出即可。

2-1. 蛇形方阵

题目描述

给出一个不大于 999 的正整数 nnn，输出 n×nn\times nn×n 的蛇形方阵。
从左上角填上 111 开始，顺时针方向依次填入数字，如同样例所示。注意每个数字有都会占用 333 个字符，前面使用空格齐。

输入格式

输入一个正整数 nnn，含义如题所述。

输出格式

输出符合题目要求的蛇形矩阵。

样例输入
4
样例输出
  1  2  3  412 13 14  511 16 15  610  9  8  7
提示

数据保证，1≤n≤91 \leq n \leq 91≤n≤9。

记得在学数组时，我们会写出类似这样的程序：

#include<bits/stdc++.h>
using namespace std;int n,t,i,j,a[105][105];int main()
{cin>>n;t=i=j=1;while(t<=n*n){while(j<=n&&!a[i][j]){a[i][j]=t++;j++;}i++;j--;while(i<=n&&!a[i][j]){a[i][j]=t++;i++;}i--;j--;while(j>=1&&!a[i][j]){a[i][j]=t++;j--;}i--;j++;while(i>=1&&!a[i][j]){a[i][j]=t++;i--;}i++;j++;}for(int i=1;i<=n;i++){for(int j=1;j<=n;j++){cout<<setw(3)<<a[i][j];}cout<<endl;}return 0;
}

假如有一天，你颓废了，不会写了（雾）。
此时，你发现：

数据保证，1≤n≤91 \leq n \leq 91≤n≤9。

于是，我们可以打表了。
AC Code：

#include<bits/stdc++.h>
using namespace std;int main()
{int n;cin>>n;if(n==1) puts("  1");if(n==2) puts("  1  2\n  4  3");if(n==3) puts("  1  2  3\n  8  9  4\n  7  6  5");if(n==4) puts("  1  2  3  4\n 12 13 14  5\n 11 15 16  6\n 10  9  8  7");if(n==5) puts("  1  2  3  4  5\n 16 17 18 19  6\n 15 24 25 20  7\n 14 23 22 21  8\n 13 12 11 10  9");if(n==6) puts("  1  2  3  4  5  6\n 20 21 22 23 24  7\n 19 32 33 34 25  8\n 18 31 36 35 26  9\n 17 30 29 28 27 10\n 16 15 14 13 12 11");if(n==7) puts("  1  2  3  4  5  6  7\n 24 25 26 27 28 29  8\n 23 40 41 42 43 30  9\n 22 39 48 49 44 31 10\n 21 38 47 46 45 32 11\n 20 37 36 35 34 33 12\n 19 18 17 16 15 14 13");if(n==8) puts("  1  2  3  4  5  6  7  8\n 28 29 30 31 32 33 34  9\n 27 48 49 50 51 52 35 10\n 26 47 60 61 62 53 36 11\n 25 46 59 64 63 54 37 12\n 24 45 58 57 56 55 38 13\n 23 44 43 42 41 40 39 14\n 22 21 20 19 18 17 16 15");if(n==9) puts("  1  2  3  4  5  6  7  8  9\n 32 33 34 35 36 37 38 39 10\n 31 56 57 58 59 60 61 40 11\n 30 55 72 73 74 75 62 41 12\n 29 54 71 80 81 76 63 42 13\n 28 53 70 79 78 77 64 43 14\n 27 52 69 68 67 66 65 44 15\n 26 51 50 49 48 47 46 45 16\n 25 24 23 22 21 20 19 18 17");return 0;
}

2-2. T 型骨牌

题目描述

在 n×mn×mn×m 的棋盘上，摆入 T 型，T 型可以旋转，具体包括如下四个样式（# 代表被 T 型占据的格子，. 代表自由的格子）：
###      ..#      .#.      #..
.#.      ###      .#.      ###
.#.      ..#      ###      #..
问最多能在 n×mn×mn×m 的棋盘上摆入多少个不重叠的T型。

输入格式

两个数 n,m(1≤n,m≤9)n,m(1\le n,m\le 9)n,m(1≤n,m≤9)。

输出格式

一个数，最多能放入多少个 T 型。

样例输入
5 6
样例输出
4
提示

样例说明：

会发现，我们直接写这题，可以得到 70pts70\text{pts}70pts 的好成绩。可惜你颓废了，不会优化（雾）。
此时，你又发现：

两个数 n,m(1≤n,m≤9)n,m(1\le n,m\le 9)n,m(1≤n,m≤9)。

于是，我们又可以打表了。
AC Code：

#include<bits/stdc++.h>
using namespace std;
int ans[10][10];
int main()
{ans[3][3]=1;ans[3][4]=1;ans[3][5]=2;ans[3][6]=2;ans[3][7]=3;ans[3][8]=3;ans[3][9]=4;ans[4][3]=1;ans[4][4]=2;ans[4][5]=2;ans[4][6]=3;ans[4][7]=4;ans[4][8]=4;ans[4][9]=5;ans[5][3]=2;ans[5][4]=2;ans[5][5]=4;ans[5][6]=4;ans[5][7]=5;ans[5][8]=6;ans[5][9]=7;ans[6][3]=2;ans[6][4]=3;ans[6][5]=4;ans[6][6]=5;ans[6][7]=6;ans[6][8]=7;ans[6][9]=8;ans[7][3]=3;ans[7][4]=4;ans[7][5]=5;ans[7][6]=6;ans[7][7]=8;ans[7][8]=9;ans[7][9]=10;ans[8][3]=3;ans[8][4]=4;ans[8][5]=6;ans[8][6]=7;ans[8][7]=9;ans[8][8]=10;ans[8][9]=12;ans[9][3]=4;ans[9][4]=5;ans[9][5]=7;ans[9][6]=8;ans[9][7]=10;ans[9][8]=12;ans[9][9]=13;int n,m;cin>>n>>m;cout<<ans[n][m];return 0;
}

2-3. 球的体积

题目描述

已知一个半径为 rrr 的球体，现在问这个球的体积为多少？
计算时，取 π=3.14\pi = 3.14π=3.14。

输入格式

输入共一行，其中包括一个正整数 rrr 表示球体的半径。

输出格式

输出共一行，其中包括球体的体积。要求保留小数点后 555 位。

样例输入
5
样例输出
523.33333
提示

1≤r≤1001\leq r\leq 1001≤r≤100。

假如你不会处理保留小数点（雾）。

2-4. 旋转数塔

题目描述

小 X\text XX 是 C\text CC 城著名的考古学家。一日，他被重金聘请调查一座荒漠中的宫殿。
宫殿大门紧闭，但这难不倒聪明的小 X\text XX 。他在隐蔽处发现了两个数字正方形：

小 X\text XX 略加思索便发现了其中的奥妙：把数字从小到大依次填入正方形中，每次填最外面的一圈；每一圈从左上角开始，按照顺时针、逆时针、顺时针……的顺序填。
作为小 X\text XX 的助手，他希望你帮助他以相同的规律填上旁边 n×nn\times nn×n 的空白方阵。这里方阵是数字正方形的简称，通常用二维数组来存放其中的数字。

输入格式

输入数据仅有一行，包含一个正整数 nnn ，表示方阵的边长，即每行每列有多少个数。

输出格式

输出仅 nnn 行，每行 nnn 个正整数，相邻两数之间严格用一个空格隔开。

样例输入
6
样例输出
1 2 3 4 5 6
20 21 32 31 30 7
19 22 33 34 29 8
18 23 36 35 28 9
17 24 25 26 27 10
16 15 14 13 12 11
提示

数据规模：
本题共有 101010 个测试点，每个测试点 101010 分：
对于测试点 111：n=1n=1n=1；对于测试点 222：n=2n=2n=2；
对于测试点 333：n=3n=3n=3；对于测试点 444：n=4n=4n=4；
对于测试点 555：n=7n=7n=7；对于测试点 666：n=8n=8n=8；
对于测试点 777：n=10n=10n=10；对于测试点 888：n=15n=15n=15；
对于测试点 999：n=25n=25n=25；对于测试点 101010：n=50n=50n=50。

与 2-1 类似。

2-5. 阶乘之和

题目描述

用高精度计算出 S=1!+2!+3!+⋯+n!S = 1! + 2! + 3! + \cdots + n!S=1!+2!+3!+⋯+n!（n≤50n \le 50n≤50）。
其中 ! 表示阶乘，定义为 n!=n×(n−1)×(n−2)×⋯×1n!=n\times (n-1)\times (n-2)\times \cdots \times 1n!=n×(n−1)×(n−2)×⋯×1。例如，5!=5×4×3×2×1=1205! = 5 \times 4 \times 3 \times 2 \times 1=1205!=5×4×3×2×1=120。

输入格式

一个正整数 nnn。

输出格式

一个正整数 SSS，表示计算结果。

样例输入
3
样例输出
9
提示

对于 100%100 \%100% 的数据，1≤n≤501 \le n \le 501≤n≤50。

假如你不会高精度（雾），可以先用 Python 计算答案然后存进表中。

3. 打表题选——打表找规律

这些题目，我们可以通过把答案打一个表，然后寻找其中的规律。

3-1. 无穷的序列

题目描述

有一个无穷序列如下：
110100100010000100000\texttt{110100100010000100000}110100100010000100000…
请你找出这个无穷序列中指定位置上的数字。

输入格式

第一行一个正整数 NNN ，表示询问次数；
接下来的 NNN 行每行一个正整数 AiA_iAi，AiA_iAi 表示在序列中的位置。

输出格式

输出为 NNN 行，每行为 000 或 lll ，表示序列第 AiA_iAi 位上的数字。

样例输入
4
3
14
7
6
样例输出
0
0
1
0
提示

对于 100%100\%100% 的数据，N≤1500000N \leq 1\,500\,000N≤1500000，Ai≤109A_i≤10^9Ai≤109。

我们可以通过打表，来列举出所有是 111 的位：1,2,4,7,11,16,22,⋯1,2,4,7,11,16,22,\cdots1,2,4,7,11,16,22,⋯。
我们发现，第 nnn 个就是 1+1+2+3+4+5+⋯+n=n(n+1)2+11+1+2+3+4+5+\cdots+n=\frac{n(n+1)}{2}+11+1+2+3+4+5+⋯+n=2n(n+1)+1。
故对于第 nnn 个是不是 111，只要判断 2(n−1)×(2(n−1)+1)2=n−1\frac{\sqrt{2(n-1)}\times(\sqrt{2(n-1)}+1)}{2}=n-122(n−1)×(2(n−1)+1)=n−1 即可。
AC Code：

#include<bits/stdc++.h>
using namespace std;int main()
{int t;scanf("%d",&t);while(t--){int n;scanf("%d",&n);n--;printf("%d\n",int(sqrt(n*2))*int(sqrt(n*2)+1)==n*2);} return 0;
}

3-2. 数列之异或

题目描述

求 1⨁2⨁⋯⨁N1 \bigoplus 2 \bigoplus\cdots\bigoplus N1⨁2⨁⋯⨁N 的值。
A⨁BA \bigoplus BA⨁B 即AAA , BBB 按位异或。

输入格式

1 个整数NNN。

输出格式

1 个整数，表示所求的值。

样例输入
3
样例输出
0
提示

对于50% 的数据，1≤N≤1061 \le N \le 10^61≤N≤106；

对于100% 的数据，1≤N≤10181 \le N \le 10^{18}1≤N≤1018。

对于这道题，我们先从 111 打表找规律：1,3,0,4,1,7,0,8,1,11,0,12,⋯1,3,0,4,1,7,0,8,1,11,0,12,\cdots1,3,0,4,1,7,0,8,1,11,0,12,⋯。
我们把其四个四个分成一组：(1,3,0,4),(1,7,0,8),(1,11,0,12),⋯(1,3,0,4),(1,7,0,8),(1,11,0,12),\cdots(1,3,0,4),(1,7,0,8),(1,11,0,12),⋯。
会发现，每组的第一、三个分别为 1,01,01,0；第二、四个分别为 n+1,nn+1,nn+1,n。
AC Code：

#include<bits/stdc++.h>
using namespace std;int main()
{long long n;cin>>n;long long ans[]={1,n+1,0,n};cout<<ans[(n-1)%4];return 0;
}

4. 打表题选——间接打表

这些题目，我们可以在某些操作上进行打表，方便求解。

4-1. 马的遍历

题目描述

有一个 n×mn \times mn×m 的棋盘，在某个点 (x,y)(x, y)(x,y) 上有一个马，要求你计算出马到达棋盘上任意一个点最少要走几步。

输入格式

输入只有一行四个整数，分别为 n,m,x,yn, m, x, yn,m,x,y。

输出格式

一个 n×mn \times mn×m 的矩阵，代表马到达某个点最少要走几步（不能到达则输出 −1-1−1）。

样例输入
3 3 1 1
样例输出
0    3    2
3    -1   1
2    1    4
提示

对于全部的测试点，保证 1≤x≤n≤4001 \leq x \leq n \leq 4001≤x≤n≤400，1≤y≤m≤4001 \leq y \leq m \leq 4001≤y≤m≤400。

显然，我们可以 bfs 求解。
但是马有 888 种走法，将每种走法都写一遍会很烦。
于是，我们可以用 X[]\text X[]X[] 记第 iii 种时 xxx 的变化，Y[]\text Y[]Y[] 同理。
AC Code：

#include<bits/stdc++.h>
using namespace std;const int X[]={1,1,2,2,-1,-1,-2,-2};
const int Y[]={2,-2,1,-1,2,-2,1,-1};
int n,m,sx,sy,ans[405][405],qx[160005],qy[160005];void bfs()
{int h=1,t=1;qx[h]=sx;qy[h]=sy;ans[sx][sy]=0;while(h<=t){int x=qx[h];int y=qy[h];for(int i=0;i<8;i++){int x_=x+X[i];int y_=y+Y[i];//...}h++;}
}int main()
{//...
}

4-2. 靶形数独

题目描述

小城和小华都是热爱数学的好学生，最近，他们不约而同地迷上了数独游戏，好胜的他们想用数独来一比高低。但普通的数独对他们来说都过于简单了，于是他们向 Z 博士请教，Z 博士拿出了他最近发明的“靶形数独”，作为这两个孩子比试的题目。
靶形数独的方格同普通数独一样，在 999 格宽且 999 格高的大九宫格中有 999 个 333 格宽且 333 格高的小九宫格（用粗黑色线隔开的）。在这个大九宫格中，有一些数字是已知的，根据这些数字，利用逻辑推理，在其他的空格上填入 111 到 999 的数字。每个数字在每个小九宫格内不能重复出现，每个数字在每行、每列也不能重复出现。但靶形数独有一点和普通数独不同，即每一个方格都有一个分值，而且如同一个靶子一样，离中心越近则分值越高。（如图）

上图具体的分值分布是：最里面一格（黄色区域）为 101010 分，黄色区域外面的一圈（红色区域）每个格子为 999 分，再外面一圈（蓝色区域）每个格子为 888 分，蓝色区域外面一圈（棕色区域）每个格子为 777 分，最外面一圈（白色区域）每个格子为 666 分，如上图所示。比赛的要求是：每个人必须完成一个给定的数独（每个给定数独可能有不同的填法），而且要争取更高的总分数。而这个总分数即每个方格上的分值和完成这个数独时填在相应格上的数字的乘积的总和。
总分数即每个方格上的分值和完成这个数独时填在相应格上的数字的乘积的总和。如图，在以下的这个已经填完数字的靶形数独游戏中，总分数为 2829。游戏规定，将以总分数的高低决出胜负。

由于求胜心切，小城找到了善于编程的你，让你帮他求出，对于给定的靶形数独，能够得到的最高分数。

输入格式

一共 999 行。每行 999 个整数（每个数都在 0∼90 \sim 90∼9 的范围内），表示一个尚未填满的数独方格，未填的空格用“000”表示。每两个数字之间用一个空格隔开。

输出格式

输出共 111 行。输出可以得到的靶形数独的最高分数。如果这个数独无解，则输出整数 −1-1−1。

样例输入 1
7 0 0 9 0 0 0 0 1
1 0 0 0 0 5 9 0 0
0 0 0 2 0 0 0 8 0
0 0 5 0 2 0 0 0 3
0 0 0 0 0 0 6 4 8
4 1 3 0 0 0 0 0 0
0 0 7 0 0 2 0 9 0
2 0 1 0 6 0 8 0 4
0 8 0 5 0 4 0 1 2
样例输出 1
2829
样例输入 2
0 0 0 7 0 2 4 5 3
9 0 0 0 0 8 0 0 0
7 4 0 0 0 5 0 1 0
1 9 5 0 8 0 0 0 0
0 7 0 0 0 0 0 2 5
0 3 0 5 7 9 1 0 8
0 0 0 6 0 1 0 0 0
0 6 0 9 0 0 0 0 1
0 0 0 0 0 0 0 0 6
样例输出 2
2852
提示

对于 40%40\%40% 的数据，数独中非 000 数的个数不少于 303030；

对于 80%80\%80% 的数据，数独中非 000 数的个数不少于 262626；

对于 100%100\%100% 的数据，数独中非 000 数的个数不少于 242424。

众所周知，这是一道经典的 dfs 剪枝题。
对于计算分值时，我们也可以打表（具体看代码）。
AC Code：

#include<bits/stdc++.h>
using namespace std;const int PTS[15][15]={{6,6,6,6,6,6,6,6,6},{6,7,7,7,7,7,7,7,6},{6,7,8,8,8,8,8,7,6},{6,7,8,9,9,9,8,7,6},{6,7,8,9,10,9,8,7,6},{6,7,8,9,9,9,8,7,6},{6,7,8,8,8,8,8,7,6},{6,7,7,7,7,7,7,7,6},{6,6,6,6,6,6,6,6,6}};
struct node{int s,h;
}zr[15];
int a[15][15],ans=-1;
bool h[15][15],l[15][15],g[15][15];bool cmp(node x,node y)
{//...
}int f()
{int res=0;for(int i=1;i<=9;i++){for(int j=1;j<=9;j++){res+=PTS[i-1][j-1]*a[i][j];}}return res;
}void dfs(int now,int x,int y,int s)
{//...
}int main()
{//...return 0;
}

4-3. 生活大爆炸版石头剪刀布

题目描述

石头剪刀布是常见的猜拳游戏:石头胜剪刀,剪刀胜布,布胜石头。如果两个人出拳一样，则不分胜负。在《生活大爆炸》第二季第 8 集中出现了一种石头剪刀布的升级版游戏。
升级版游戏在传统的石头剪刀布游戏的基础上,增加了两个新手势:
斯波克:《星际迷航》主角之一。
蜥蜴人:《星际迷航》中的反面角色。
这五种手势的胜负关系如表一所示,表中列出的是甲对乙的游戏结果。

现在,小 A 和小 B 尝试玩这种升级版的猜拳游戏。已知他们的出拳都是有周期性规律的，但周期长度不一定相等。例如：如果小 A 以“石头-布-石头-剪刀-蜥蜴人-斯波克”长度为 666 的周期出拳,那么他的出拳序列就是“石头-布-石头-剪刀-蜥蜴人-斯波克-石头-布-石头-剪刀-蜥蜴人-斯波克-…”,而如果小 B 以“剪刀-石头-布-斯波克-蜥蜴人”长度为 555 的周期出拳,那么他出拳的序列就是“剪刀-石头-布-斯波克-蜥蜴人-剪刀-石头-布-斯波克-蜥蜴人-…”
已知小 A 和小 B 一共进行 NNN 次猜拳。每一次赢的人得 111 分，输的得 000 分；平局两人都得 000 分。现请你统计 NNN 次猜拳结束之后两人的得分。

输入格式

第一行包含三个整数：N,NA,NBN,N_A,N_BN,NA,NB,分别表示共进行 NNN 次猜拳、小 A 出拳的周期长度，小 B 出拳的周期长度。数与数之间以一个空格分隔。
第二行包含 NAN_ANA 个整数,表示小 A 出拳的规律,第三行包含 NBN_BNB 个整数,表示小 B 出拳的规律。其中，000 表示“剪刀”，111 表示“石头”，222 表示“布”，333 表示“蜥蜴人”，$4 $表示“斯波克”。数与数之间以一个空格分隔。

输出格式

输出一行，包含两个整数，以一个空格分隔，分别表示小 A、小 B 的得分。

样例输入 1
10 5 6
0 1 2 3 4
0 3 4 2 1 0
样例输出 1
6 2
样例输入 2
9 5 5
0 1 2 3 4
1 0 3 2 4
样例输出 2
4 4
提示

对于100%100\%100%的数据，0<N≤200,0<NA≤200,0<NB≤2000 < N \leq 200, 0 < N_A \leq 200, 0 < N_B \leq 2000<N≤200,0<NA≤200,0<NB≤200 。

这题中，对于猜拳胜负情况，我们亦可打一个表，把每种胜负情况都记下来。
AC Code：

#include<bits/stdc++.h>
using namespace std;const int A[5][5]={{0,0,1,1,0},{1,0,0,1,0},{0,1,0,0,1},{0,0,1,0,1},{1,1,0,0,0}};int main()
{//...for(int i=0;i<n;i++){ans1+=A[a[i%na]][b[i%nb]];ans2+=A[b[i%nb]][a[i%na]];}//...return 0;
}

5. 打表优化

有时，打的表代码长度很长，导致 MLE。通常我们有以下的优化：

部分打表。对于可以在规定时间计算的答案，我们直接算；其余的输入的数均打成一个表。
十六进制优化。如果输出的是数字，我们可以对部分表进行十六进制的转换以缩短代码长度（具体方法参见洛谷 P8115）。类似地，我们甚至可以三十六进制优化。
分段打表。也是比较常用的方法，要有分块基础。与分块类似，将答案分成若干块，对于每一块先计算答案。最后输出时利用与分块类似的做法进行处理答案（详见 OI Wiki）。
差分优化。类似十六进制优化。
二次差分优化。
……

CSP 2022-J2/S2 将至，愿大家考出好成绩！

「杂谈·I」浅谈打表相关推荐

python量化投资视频_【邢不行|量化小讲堂系列21-Python量化入门】「视频讲解」浅谈机器学习与量化投资...
引言: 邢不行的系列帖子"量化小讲堂",通过实际案例教初学者使用python进行量化投资,了解行业研究方向,希望能对大家有帮助. [历史文章汇总]请点击此处 [必读文章]: 个人微 ...
「系统安全」浅谈RASP技术攻防
一 .什么是RASP? 在2014年的时候,Gartner引入了"Runtime application self-protection"一词,简称为RASP.它是一种新型应用安全 ...
浅谈MySQL表类型
小小子的文章写的不错哦. 转载:http://www.xiaoxiaozi.com/2009/07/14/1171/ 浅谈MySQL表类型 MySQL为我们提供了很多表类型供选择,有MyISAM.IS ...
洛谷P1156 垃圾陷阱题解浅谈刷表法与填表法
洛谷P1156 垃圾陷阱题解&浅谈刷表法与填表法填表法 :就是一般的动态规划,当前点的状态,可以直接用状态方程,根据之前点的状态推导出来. 刷表法:由当前点的状态,更新其他点的状态.需要注 ...
浅谈GOT表与PLT表
文章目录浅谈GOT表与PLT表 1. 实例 2. PLT表 3. 动态解析 4. 总结浅谈GOT表与PLT表我们都知道动态链接库是我们程序开发中比较基础的手段,我们将公共的函数封装在一个so库中 ...
沈家桢：「我相、人相、众生相、寿者相。」浅谈
我收到好几位朋友的信,认为「我相.人相.众生相.寿者相」这四相是<金刚经>中极重要的名词,可是我却没有详加解释,轻轻带过.希望我有机会再讲的时候,能先以此为题,加以申述.我很感激这几位朋友 ...
「offer来了」浅谈前端面试中开发环境常考知识点
「面试专栏」前端面试之开发环境篇
服务器收到消息怎么推送给app_「刹那问答24」浅谈FCM推送
今天和大家聊一下FCM推送,它是GCM的升级版,也是安卓的官方推送,就比如腾讯旗下的几个社交软件,考虑到让用户及时收到消息,而能够让后台常驻,但这不经意间会让耗电量增加,但是有了FCM,根据它的运行机 ...
「切图仔日常」浅谈加载动画两板斧
1.前言此刻深圳大雨瓢泼,周围一片黑压压的.对于这样的日子,果断从冰箱里面拿出肥宅快乐水,打开电脑查看最近更新的番剧,舒服窝在沙发里真是美滋滋. 但是不知道大雨原因,网络加载一直时好时坏,看的贼忧伤 ...