【补题】网易 2018 校招笔试编程题 - 解题思路-爱编程
【补题】网易 2018 校招笔试编程题 - 解题思路
牛客网给出的题解：
我只补了前 6 题，后面两题实在困得要死，先放着。我自己的解析也发在牛客网的题目下了。。不知能不能骗骗赞 233
Description
小易准备去魔法王国采购魔法神器,购买魔法神器需要使用魔法币,但是小易现在一枚魔法币都没有,但是小易有两台魔法机器可以通过投入x(x可以为0)个魔法币产生更多的魔法币。
魔法机器1:如果投入x个魔法币,魔法机器会将其变为2x+1个魔法币
魔法机器2:如果投入x个魔法币,魔法机器会将其变为2x+2个魔法币
小易采购魔法神器总共需要n个魔法币,所以小易只能通过两台魔法机器产生恰好n个魔法币,小易需要你帮他设计一个投入方案使他最后恰好拥有n个魔法币。
输入包括一行,包括一个正整数n(1 ≤ n ≤ 10^9),表示小易需要的魔法币数量。
输出一个字符串,每个字符表示该次小易选取投入的魔法机器。其中只包含字符'1'和'2'。
Sample Input
Sample Output
水题，求 x 经过若干次 \(f(x)=2x+c\) 的变换恰好到 n ，显然次数不超过 \(log(n)+1=32\) 次，而 \(c=1 || 2\) 使得每次 n' 具有奇偶性，直接递归出来。
#include &stdio.h&
void read() {
scanf(&%d&, &n);
void magic(int n) {
if (n &= 0) return;
if (n % 2) {
magic((n - 1) / 2);
putchar('1');
magic((n - 2) / 2);
putchar('2');
void work() {
putchar('\n');
int main() {
Description
为了得到一个数的&相反数&,我们将这个数的数字顺序颠倒,然后再加上原先的数得到&相反数&。例如,为了得到1325的&相反数&,首先我们将该数的数字顺序颠倒,我们得到5231,之后再加上原先的数,我们得到56.如果颠倒之后的数字有前缀零,前缀零将会被忽略。例如n = 100, 颠倒之后是1.
输入包括一个整数n,(1 ≤ n ≤ 10^5)
输出一个整数,表示n的相反数
Sample Input
Sample Output
水题，可以算程序设计入门课作业题。
#include &stdio.h&
void read() {
scanf(&%d&, &n);
int reverse(int n) {
int res = 0;
while (n) {
res = res * 10 + n % 10;
void work() {
printf(&%d\n&, n + reverse(n));
int main() {
字符串碎片
Description
一个由小写字母组成的字符串可以看成一些同一字母的最大碎片组成的。例如,&aaabbaaac&是由下面碎片组成的:'aaa','bb','c'。牛牛现在给定一个字符串,请你帮助计算这个字符串的所有碎片的平均长度是多少。
输入包括一个字符串s,字符串s的长度length(1 ≤ length ≤ 50),s只含小写字母('a'-'z')
输出一个整数,表示所有碎片的平均长度,四舍五入保留两位小数。
如样例所示: s = &aaabbaaac&
所有碎片的平均长度 = (3 + 2 + 3 + 1) / 4 = 2.25
Sample Input
Sample Output
水题，所有块的总长度就是字符串的长度，数一下有多少块。
#include &stdio.h&
char str[55];
void read() {
scanf(&%s&, str);
void work() {
int i, cnt = 0;
if (str[i] != str[i-1]) {
} while (str[i]);
double res =
printf(&%.2lf\n&, res);
int main() {
游历魔法王国
Description
魔法王国一共有n个城市,编号为0~n-1号,n个城市之间的道路连接起来恰好构成一棵树。
小易现在在0号城市,每次行动小易会从当前所在的城市走到与其相邻的一个城市,小易最多能行动L次。
如果小易到达过某个城市就视为小易游历过这个城市了,小易现在要制定好的旅游计划使他能游历最多的城市,请你帮他计算一下他最多能游历过多少个城市(注意0号城市已经游历了,游历过的城市不重复计算)。
输入包括两行,第一行包括两个正整数n(2 ≤ n ≤ 50)和L(1 ≤ L ≤ 100),表示城市个数和小易能行动的次数。
第二行包括n-1个整数parent, 对于每个合法的i(0 ≤ i ≤ n - 2),在(i+1)号城市和parent[i]间有一条道路连接。
输出一个整数,表示小易最多能游历的城市数量。
Sample Input
Sample Output
原本以为是树上 dp ，其实是贪心。
画个图可以知道，可当作 (i+1) 的上一个节点是 parent[i] （因为 parent[i] 是可以重复的）。这个建图方式很坑，题目并没有说明是顺序标号，我决定用链式前向星（当然也可以直接做一个有两个子节点的节点结构，但是题目连几叉树都没有说）。
得到链式前向星之后，就可以从树根扩散出每个节点所在最长树链的长度，选出最长的一条树链，记其长度为 maxLen 。
分类讨论：
若 L ≤ maxLen ，显而易见得结果；
若 L & maxLen ，意味着可以往回走，继续对 rest = L - maxLen 进行讨论：
若树链上存在某个祖先拥有一条子链，其长度 x 必定小于或等于该祖先到原链末端的长度，重复该判断直到最远祖先的一条最短子链：
当 x ≤ rest 可以在中途预先用掉 2x 步而不影响要走的 maxLen 最长链，可达城市增加 x 个；
当 x & rest 可以在中途预先用掉 rest 步而不影响要走的 maxLen 最长链，可达城市增加 rest/2 个；
若从最短链到次最长链都能被 rest 步覆盖，那么可达城市为 n 个。
也就是说，先贪心出一条最长路，再将剩余的步数从短链到长链消耗掉。
#include &stdio.h&
#include &string.h&
#define MAXN 55
#define MAXM 55
inline void getMax(int& n, int x) {
n & x && (n = x);
inline void getMin(int& n, int x) {
n & x && (n = x);
struct Edge {
} edge[MAXM];
int head[MAXN], len[MAXN];
void init() {
memset(head, 0xff, sizeof(head));
void addEdge(int u, int v) {
edge[cnt].to =
edge[cnt].next = head[u];
head[u] = cnt++;
void read() {
scanf(&%d%d&, &n, &L);
for (int i = 1; i & ++i) {
scanf(&%d&, &parent);
addEdge(parent, i);
void walk(int u) {
for (int i = head[u]; ~i; i = edge[i].next) {
len[edge[i].to] = len[u] + 1;
walk(edge[i].to);
void work() {
int maxLen = 0;
for (int i = 0; i & ++i) {
getMax(maxLen, len[i]);
if (L &= maxLen) {
printf(&%d\n&, L + 1);
getMin(res, maxLen + (L - maxLen) / 2 + 1);
printf(&%d\n&, res);
int main() {
Description
小易有一个长度为N的正整数数列A = {A[1], A[2], A[3]..., A[N]}。
牛博士给小易出了一个难题:
对数列A进行重新排列,使数列A满足所有的A[i] * A[i + 1] (1 ≤ i ≤ N - 1)都是4的倍数。
小易现在需要判断一个数列是否可以重排之后满足牛博士的要求。
输入的第一行为数列的个数t(1 ≤ t ≤ 10),
接下来每两行描述一个数列A,第一行为数列长度n(1 ≤ n ≤ 10^5)
第二行为n个正整数A
对于每个数列输出一行表示是否可以满足牛博士要求,如果可以输出Yes,否则输出No。
Sample Input
Sample Output
分类讨论下。
显然，任意数和 4 的倍数相乘，其结果仍是 4 的倍数；
显然，若存在任意数量 2 的倍数，两两之间乘起来就是 4 的倍数；
如果存在一个数既不是 4 的倍数，也不是 2 的倍数（即因子里没有 2 ）：
放在 2 的倍数旁边，一定不符合要求；
放在 4 的倍数旁边，两两相乘一定是 4 的倍数。
因此符合要求的排列一定是，所有 2 的倍数相邻排在一起，所有 4 的倍数和剩下的数相间排列，这些剩下的元素个数不能超过 4 的倍数的数量，不然所有 4 的倍数都被包起来了。
#include &stdio.h&
int arr[100100];
int countMod4, countMod2;
void read() {
countMod4 = 0;
countMod2 = 0;
scanf(&%d&, &n);
for (int i = 0; i & ++i) {
scanf(&%d&, arr + i);
if (arr[i] % 4 == 0) {
++countMod4;
} else if (arr[i] % 2 == 0) {
++countMod2;
void work() {
if (countMod4 &= (n - countMod4 - countMod2)) {
puts(&Yes&);
puts(&No&);
int main() {
scanf(&%d&, &t);
while (t--) {
最长公共子括号序列
Description
一个合法的括号匹配序列被定义为:
空串&&是合法的括号序列
如果&X&和&Y&是合法的序列,那么&XY&也是一个合法的括号序列
如果&X&是一个合法的序列,那么&(X)&也是一个合法的括号序列
每个合法的括号序列都可以由上面的规则生成
例如&&, &()&, &()()()&, &(()())&, &(((()))&都是合法的。
从一个字符串S中移除零个或者多个字符得到的序列称为S的子序列。
例如&abcde&的子序列有&abe&,&&,&abcde&等。
定义LCS(S,T)为字符串S和字符串T最长公共子序列的长度,即一个最长的序列W既是S的子序列也是T的子序列的长度。
小易给出一个合法的括号匹配序列s,小易希望你能找出具有以下特征的括号序列t:
1、t跟s不同,但是长度相同
2、t也是一个合法的括号匹配序列
3、LCS(s, t)是满足上述两个条件的t中最大的
因为这样的t可能存在多个,小易需要你计算出满足条件的t有多少个。
如样例所示: s = &(())()&,跟字符串s长度相同的合法括号匹配序列有:
&()(())&, &((()))&, &()()()&, &(()())&,其中LCS( &(())()&, &()(())& )为4,其他三个都为5,所以输出3.
输入包括字符串s(4 ≤ |s| ≤ 50,|s|表示字符串长度),保证s是一个合法的括号匹配序列。
输出一个正整数,满足条件的t的个数。
Sample Input
Sample Output
根据题意，当且仅当修改距离为 1 时 LCS 最大。很容易证明对于两种基本序列 (()) 和 ()() 都有距离为 1 的合法修改。
原本想的是对每个左括号，跟每个右括号替换，判断合法后累计。
后来发现会漏掉一些情况，那就暴力得干脆一点，把每个符号插入到任意位置，判合法，去重，累计。
#include &stdio.h&
#include &algorithm&
#include &string&
#include &set&
using namespace
char str[55];
void read() {
scanf(&%s&, str);
bool test(const string& s) {
int cnt = 0;
for (int i = 0; s[i]; ++i) {
s[i] == '(' ? ++cnt : --
if (cnt & 0) {
return false;
return true;
void work() {
set&string&
for (int i = 1; str[i+1]; ++i) {
string tmp(str);
tmp.erase(i, 1);
for (int j = 1; str[j]; ++j) {
if (str[i] == str[j]) continue;
string s(tmp);
s.insert(j, 1, str[i]);
if (test(s)) {
record.insert(s);
printf(&%lu\n&, record.size());
int main() {
发布，欢迎引用、转载或演绎，但是必须保留本文的署名
以及本文链接
，且未经许可不能用于商业目的。如有疑问或授权协商请
版权所有 爱编程 (C) Copyright 2012. . All Rights Reserved.
闽ICP备号-3
微信扫一扫关注爱编程，每天为您推送一篇经典技术文章。魔法王国一共有n个城市,编号为0~n-1号,n个城市之间的道路连接起来恰好构成一棵树。
小易现在在0号城市,每次行动小易会从当前所在的城市走到与其相邻的一个城市,小易最多能行动L次。
如果小易到达过某个城市就视为小易游历过这个城市了,小易现在要制定好的旅游计划使他能游历最多的城市,请你帮他计算一下他最多能游历过多少个城市(注意0号城市已经游历了,游历过的城市不重复计算)。&
输入包括两行,第一行包括两个正整数n(2 ≤ n ≤ 50)和L(1 ≤ L ≤ 100),表示城市个数和小易能行动的次数。
第二行包括n-1个整数parent[i](0 ≤ parent[i] ≤ i), 对于每个合法的i(0 ≤ i ≤ n - 2),在(i+1)号城市和parent[i]间有一条道路连接。
输出一个整数,表示小易最多能游历的城市数量。
输入例子1:
输出例子1:
#include&iostream&
#include&vector&
#include&algorithm&
void traversal(int n,int L,vector&int& &parent){
int maxlen=0;
vector&int& dp(n);
for(int i=0;i&n-1;i++){
dp[i+1]=dp[parent[i]]+1;
maxlen=max(maxlen,dp[i+1]);
//使用贪心算法计算最长链的长度
int validpath=min(maxlen,L);
cout&&min(n,1+validpath+(L-validpath)/2);
int main(){
cin&&n&&L;
vector&int&
for(int i=0;i&n-1;i++){
parent.push_back(temp);
traversal(n,L,parent);
思路就是：求出最长的那条链，然后与L比较，当L&maxlen时，存在回马枪的可能
写的时候不知道如何处理回马枪的情况，还是参考了大佬的代码
(L-validpath)/2这个式子表示先走非最长路径，后走最长路径。
L-validpath的值即为来回非最长路径的总步数，除以二即为访问过的城市数量。
validpath为最长路径的步数。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：5219次
排名：千里之外
原创：85篇
(9)(39)(14)(18)(13)(1)
(window.slotbydup = window.slotbydup || []).push({
id: '4740887',
container: s,
size: '250,250',
display: 'inlay-fix'关注社区微信公众号: PMvideo
【补题】网易 2018 校招笔试编程题 - 解题思路
牛客网给出的题解： 我只补了前 6 题，后面两题实在困得要死，先放着。我自己的解析也发在牛客网的题目下了。。不知能不能骗骗赞 233
Description
小易准备去魔法王国采购魔法神器,购买魔法神器需要使用魔法币,但是小易现在一枚魔法币都没有,但是小易有两台魔法机器可以通过投入x(x可以为0)个魔法币产生更多的魔法币。 魔法机器1:如果投入x个魔法币,魔法机器会将其变为2x+1个魔法币 魔法机器2:如果投入x个魔法币,魔法机器会将其变为2x+2个魔法币 小易采购魔法神器总共需要n个魔法币,所以小易只能通过两台魔法机器产生恰好n个魔法币,小易需要你帮他设计一个投入方案使他最后恰好拥有n个魔法币。
输入包括一行,包括一个正整数n(1 ≤ n ≤ 10^9),表示小易需要的魔法币数量。
输出一个字符串,每个字符表示该次小易选取投入的魔法机器。其中只包含字符'1'和'2'。
Sample Input
Sample Output
水题，求 x 经过若干次 \(f(x)=2x+c\) 的变换恰好到 n ，显然次数不超过 \(log(n)+1=32\) 次，而 \(c=1 || 2\) 使得每次 n' 具有奇偶性，直接递归出来。
#include &stdio.h&
void read() {
scanf("%d", &n);
void magic(int n) {
if (n &= 0) return;
if (n % 2) {
magic((n - 1) / 2);
putchar('1');
magic((n - 2) / 2);
putchar('2');
void work() {
putchar('\n');
int main() {
Description
为了得到一个数的"相反数",我们将这个数的数字顺序颠倒,然后再加上原先的数得到"相反数"。例如,为了得到1325的"相反数",首先我们将该数的数字顺序颠倒,我们得到5231,之后再加上原先的数,我们得到56.如果颠倒之后的数字有前缀零,前缀零将会被忽略。例如n = 100, 颠倒之后是1.
输入包括一个整数n,(1 ≤ n ≤ 10^5)
输出一个整数,表示n的相反数
Sample Input
Sample Output
水题，可以算程序设计入门课作业题。
#include &stdio.h&
void read() {
scanf("%d", &n);
int reverse(int n) {
int res = 0;
while (n) {
res = res * 10 + n % 10;
void work() {
printf("%d\n", n + reverse(n));
int main() {
字符串碎片
Description
一个由小写字母组成的字符串可以看成一些同一字母的最大碎片组成的。例如,"aaabbaaac"是由下面碎片组成的:'aaa','bb','c'。牛牛现在给定一个字符串,请你帮助计算这个字符串的所有碎片的平均长度是多少。
输入包括一个字符串s,字符串s的长度length(1 ≤ length ≤ 50),s只含小写字母('a'-'z')
输出一个整数,表示所有碎片的平均长度,四舍五入保留两位小数。
如样例所示: s = "aaabbaaac" 所有碎片的平均长度 = (3 + 2 + 3 + 1) / 4 = 2.25
Sample Input
Sample Output
水题，所有块的总长度就是字符串的长度，数一下有多少块。
#include &stdio.h&
char str[55];
void read() {
scanf("%s", str);
void work() {
int i, cnt = 0;
if (str[i] != str[i-1]) {
} while (str[i]);
double res =
printf("%.2lf\n", res);
int main() {
游历魔法王国
Description
魔法王国一共有n个城市,编号为0~n-1号,n个城市之间的道路连接起来恰好构成一棵树。 小易现在在0号城市,每次行动小易会从当前所在的城市走到与其相邻的一个城市,小易最多能行动L次。 如果小易到达过某个城市就视为小易游历过这个城市了,小易现在要制定好的旅游计划使他能游历最多的城市,请你帮他计算一下他最多能游历过多少个城市(注意0号城市已经游历了,游历过的城市不重复计算)。
输入包括两行,第一行包括两个正整数n(2 ≤ n ≤ 50)和L(1 ≤ L ≤ 100),表示城市个数和小易能行动的次数。 第二行包括n-1个整数parent, 对于每个合法的i(0 ≤ i ≤ n - 2),在(i+1)号城市和parent[i]间有一条道路连接。
输出一个整数,表示小易最多能游历的城市数量。
Sample Input
5 2 0 1 2 3
Sample Output
原本以为是树上 dp ，其实是贪心。 画个图可以知道，可当作 (i+1) 的上一个节点是 parent[i] （因为 parent[i] 是可以重复的）。这个建图方式很坑，题目并没有说明是顺序标号，我决定用链式前向星（当然也可以直接做一个有两个子节点的节点结构，但是题目连几叉树都没有说）。 得到链式前向星之后，就可以从树根扩散出每个节点所在最长树链的长度，选出最长的一条树链，记其长度为 maxLen 。 分类讨论：
若 L ≤ maxLen ，显而易见得结果；
若 L & maxLen ，意味着可以往回走，继续对 rest = L - maxLen 进行讨论：
若树链上存在某个祖先拥有一条子链，其长度 x 必定小于或等于该祖先到原链末端的长度，重复该判断直到最远祖先的一条最短子链：
当 x ≤ rest 可以在中途预先用掉 2x 步而不影响要走的 maxLen 最长链，可达城市增加 x 个；
当 x & rest 可以在中途预先用掉 rest 步而不影响要走的 maxLen 最长链，可达城市增加 rest/2 个；
若从最短链到次最长链都能被 rest 步覆盖，那么可达城市为 n 个。
也就是说，先贪心出一条最长路，再将剩余的步数从短链到长链消耗掉。
#include &stdio.h&
#include &string.h&
#define MAXN 55
#define MAXM 55
inline void getMax(int& n, int x) {
n & x && (n = x);
inline void getMin(int& n, int x) {
n & x && (n = x);
struct Edge {
} edge[MAXM];
int head[MAXN], len[MAXN];
void init() {
memset(head, 0xff, sizeof(head));
void addEdge(int u, int v) {
edge[cnt].to =
edge[cnt].next = head[u];
head[u] = cnt++;
void read() {
scanf("%d%d", &n, &L);
for (int i = 1; i & ++i) {
scanf("%d", &parent);
addEdge(parent, i);
void walk(int u) {
for (int i = head[u]; ~i; i = edge[i].next) {
len[edge[i].to] = len[u] + 1;
walk(edge[i].to);
void work() {
int maxLen = 0;
for (int i = 0; i & ++i) {
getMax(maxLen, len[i]);
if (L &= maxLen) {
printf("%d\n", L + 1);
getMin(res, maxLen + (L - maxLen) / 2 + 1);
printf("%d\n", res);
int main() {
Description
小易有一个长度为N的正整数数列A = {A[1], A[2], A[3]..., A[N]}。 牛博士给小易出了一个难题: 对数列A进行重新排列,使数列A满足所有的A[i] * A[i + 1] (1 ≤ i ≤ N - 1)都是4的倍数。 小易现在需要判断一个数列是否可以重排之后满足牛博士的要求。
输入的第一行为数列的个数t(1 ≤ t ≤ 10), 接下来每两行描述一个数列A,第一行为数列长度n(1 ≤ n ≤ 10^5) 第二行为n个正整数A
对于每个数列输出一行表示是否可以满足牛博士要求,如果可以输出Yes,否则输出No。
Sample Input
2 3 1 10 100 4 1 2 3 4
Sample Output
分类讨论下。
显然，任意数和 4 的倍数相乘，其结果仍是 4 的倍数；
显然，若存在任意数量 2 的倍数，两两之间乘起来就是 4 的倍数；
如果存在一个数既不是 4 的倍数，也不是 2 的倍数（即因子里没有 2 ）：
放在 2 的倍数旁边，一定不符合要求；
放在 4 的倍数旁边，两两相乘一定是 4 的倍数。
因此符合要求的排列一定是，所有 2 的倍数相邻排在一起，所有 4 的倍数和剩下的数相间排列，这些剩下的元素个数不能超过 4 的倍数的数量，不然所有 4 的倍数都被包起来了。
#include &stdio.h&
int arr[100100];
int countMod4, countMod2;
void read() {
countMod4 = 0;
countMod2 = 0;
scanf("%d", &n);
for (int i = 0; i & ++i) {
scanf("%d", arr + i);
if (arr[i] % 4 == 0) {
++countMod4;
} else if (arr[i] % 2 == 0) {
++countMod2;
void work() {
if (countMod4 &= (n - countMod4 - countMod2)) {
puts("Yes");
puts("No");
int main() {
scanf("%d", &t);
while (t--) {
最长公共子括号序列
Description
一个合法的括号匹配序列被定义为:
空串""是合法的括号序列
如果"X"和"Y"是合法的序列,那么"XY"也是一个合法的括号序列
如果"X"是一个合法的序列,那么"(X)"也是一个合法的括号序列
每个合法的括号序列都可以由上面的规则生成 例如"", "()", "()()()", "(()())", "(((()))"都是合法的。 从一个字符串S中移除零个或者多个字符得到的序列称为S的子序列。 例如"abcde"的子序列有"abe","","abcde"等。 定义LCS(S,T)为字符串S和字符串T最长公共子序列的长度,即一个最长的序列W既是S的子序列也是T的子序列的长度。 小易给出一个合法的括号匹配序列s,小易希望你能找出具有以下特征的括号序列t: 1、t跟s不同,但是长度相同 2、t也是一个合法的括号匹配序列 3、LCS(s, t)是满足上述两个条件的t中最大的 因为这样的t可能存在多个,小易需要你计算出满足条件的t有多少个。
如样例所示: s = "(())()",跟字符串s长度相同的合法括号匹配序列有: "()(())", "((()))", "()()()", "(()())",其中LCS( "(())()", "()(())" )为4,其他三个都为5,所以输出3.
输入包括字符串s(4 ≤ |s| ≤ 50,|s|表示字符串长度),保证s是一个合法的括号匹配序列。
输出一个正整数,满足条件的t的个数。
Sample Input
Sample Output
根据题意，当且仅当修改距离为 1 时 LCS 最大。很容易证明对于两种基本序列 (()) 和 ()() 都有距离为 1 的合法修改。 原本想的是对每个左括号，跟每个右括号替换，判断合法后累计。 后来发现会漏掉一些情况，那就暴力得干脆一点，把每个符号插入到任意位置，判合法，去重，累计。
#include &stdio.h&
#include &algorithm&
#include &string&
#include &set&
using namespace
char str[55];
void read() {
scanf("%s", str);
bool test(const string& s) {
int cnt = 0;
for (int i = 0; s[i]; ++i) {
s[i] == '(' ? ++cnt : --
if (cnt & 0) {
return false;
return true;
void work() {
set&string&
for (int i = 1; str[i+1]; ++i) {
string tmp(str);
tmp.erase(i, 1);
for (int j = 1; str[j]; ++j) {
if (str[i] == str[j]) continue;
string s(tmp);
s.insert(j, 1, str[i]);
if (test(s)) {
record.insert(s);
printf("%lu\n", record.size());
int main() {
发布，欢迎引用、转载或演绎，但是必须保留本文的署名
以及本文链接
，且未经许可不能用于商业目的。如有疑问或授权协商请
笔记社区是一个面向中高端IT开发者、程序员的知识共享社区，通过网络抓取与文章分类总结，由专家为用户提供高质量的专题文章系列。
原文链接：/BlackStorm/p/7499974.html
声明：所有文章资源均从网络抓取，如果侵犯到您的著作权，请联系删除文章。联系方式请关注微信公众号PMvideo【锤子视频-程序员喜欢的短视频】，笔记社区开发者交流群 。
今日签到8人
关注微信公众号:PMvideo}