本文解析了网易2017年春季实习生招聘中的十道编程题目，涉及双核处理任务调度、路线规划、队列调整、序列操作、矩阵变换等算法问题。
网易2017春招实习生编程题
说明：本文部分内容参考了网上一些大神的思路，这里可能没有列举出来，实在抱歉，仅作为学习参考。
1、双核处理
时间限制：1秒
空间限制：32768K
一种双核CPU的两个核能够同时的处理任务，现在有n个已知数据量的任务需要交给CPU处理，假设已知CPU的每个核1秒可以处理1kb，每个核同时只能处理一项任务。n个任务可以按照任意顺序放入CPU进行处理，现在需要设计一个方案让CPU处理完这批任务所需的时间最少，求这个最小的时间。
输入描述:
输入包括两行：
第一行为整数n(1 ≤ n ≤ 50)
第二行为n个整数length[i](1024 ≤ length[i] ≤ 4194304)，表示每个任务的长度为length[i]kb，每个数均为1024的倍数。
输出描述:
输出一个整数，表示最少需要处理的时间
输入例子:
5
3072 3072 7168 3072 1024
输出例子:
9216
解题思路：
这个问题转化为将数组分成两部分使得两部分的和的差最小，差最小就是说两部分的和最接近，而且和所有数的和SUM的一半也是最接近的。假设用sum1表示第一部分的和，sum2表示第二部分的和，SUM表示所有数的和，那么sum1+sum2=SUM。假设sum1 < sum2 那么SUM/2-sum1 = sum2-SUM/2; 所以我们就有目标了，使得sum1<=SUM/2的条件下尽可能的大。也就是说从n个数中选出某些数，使得这些数的和尽可能的接近或者等于所有数的和的一半。
这其实就是背包问题：
背包容量是SUM/2. 每个物体的体积是数的大小，然后尽可能的装满背包。
dp方程：dp[i][j] = max(dp[i-1][j-v[i]]+v[i], dp[i-1][j] )
dp[i][j]表示用前i个物体装容量为j的背包能够装下的最大值，
dp[i-1][j-v[i]]+v[i]表示第i个物体装进背包的情况，
dp[i-1][j]表示第i件物品不装进背包的情况。
最终差值就是SUM-2*f[n-1][SUM/2];
转回本题，则结果为max(dp[n][sum/2],sum-dp[n][sum/2])
C++代码实现：
#include <iostream>
using namespace std;
int main()
{
int a[50];
int n;
cin>>n;
int sum = 0;
for(int i=0; i<n; ++i)
{
cin>>a[i];
a[i] /= 1024;
sum += a[i];
}
int capacity = sum/2;
int **dp = new int*[n+1];
for(int i=0; i<=n; ++i)
dp[i] = new int[capacity+1];
for(int i=0; i<=n; ++i)
dp[i][0] = 0;
for(int i=0; i<=capacity; ++i)
dp[0][i] = 0;
for(int i=0; i<n; ++i)
{
for(int j=1; j<=capacity; ++j)
{
dp[i+1][j] = dp[i][j];
if(j>=a[i] && dp[i][j]<(dp[i][j-a[i]]+a[i]))
dp[i+1][j] = dp[i][j-a[i]]+a[i];
}
}
Int result = dp[n][capacity] > (sum-dp[n][capacity])?dp[n][capacity]:(sum-dp[n][capacity]);
cout<<result*1024;
for(int i=0; i<n; ++i)
delete dp[i];
delete dp;
return 0;
}2、赶去公司
时间限制：1秒
空间限制：32768K
终于到周末啦！小易走在市区的街道上准备找朋友聚会，突然服务器发来警报,小易需要立即回公司修复这个紧急bug。假设市区是一个无限大的区域，每条街道假设坐标是(X，Y)，小易当前在(0，0)街道，办公室在(gx,gy)街道上。小易周围有多个出租车打车点，小易赶去办公室有两种选择，一种就是走路去公司，另外一种就是走到一个出租车打车点，然后从打车点的位置坐出租车去公司。每次移动到相邻的街道(横向或者纵向)走路将会花费walkTime时间，打车将花费taxiTime时间。小易需要尽快赶到公司去，现在小易想知道他最快需要花费多少时间去公司。
输入描述:
输入数据包括五行:
第一行为周围出租车打车点的个数n(1 ≤ n ≤ 50)
第二行为每个出租车打车点的横坐标tX[i] (-10000 ≤ tX[i] ≤ 10000)
第三行为每个出租车打车点的纵坐标tY[i] (-10000 ≤ tY[i] ≤ 10000)
第四行为办公室坐标gx,gy(-10000 ≤ gx,gy ≤ 10000),以空格分隔
第五行为走路时间walkTime(1 ≤ walkTime ≤ 1000)和taxiTime(1 ≤ taxiTime ≤ 1000),以空格分隔
输出描述:
输出一个整数表示，小易最快能赶到办公室的时间
输入例子:
2
-2 -2
0 -2
-4 -2
15 3
输出例子:
42
解题思路：
采用走路的方式，最短需要(|x-x0|+|y-y0|)*walkTime；
采用走路+打的方式，最短需要(|xt-x|+|yt-y|)*walkTime+(|x2-xt|+|y2-yt|)*taxiTime。
C++代码实现
#include <iostream>
#include <stdlib.h>
using namespace std;
typedef struct{
int x;
int y;
}Point;
int main()
{
Point carPoint[50];
Point office;
int n=0;
unsigned int walkTime=0,taxiTime=0;
unsigned int result=0,temp=0;
cin>>n;
for(int i=0; i<n; ++i)
cin>>carPoint[i].x;
for(int i=0; i<n; ++i)
cin>>carPoint[i].y;
cin>>office.x>>office.y;
cin>>walkTime>>taxiTime;
//走路需要的最短时间
result = (abs(office.x)+abs(office.y))*walkTime;
for(int i=0; i<n; ++i)
{
temp = (abs(carPoint[i].x)+abs(carPoint[i].y))*walkTime;
temp += (abs(office.x-carPoint[i].x)+abs(office.y-carPoint[i].y))*taxiTime;
if(temp<result)
result = temp;
}
cout<<result;
return 0;
}3、调整队形
时间限制：1秒
空间限制：32768K
在幼儿园有n个小朋友排列为一个队伍，从左到右一个挨着一个编号为(0~n-1)。其中有一些是男生，有一些是女生，男生用’B’表示，女生用’G’表示。小朋友们都很顽皮，当一个男生挨着的是女生的时候就会发生矛盾。作为幼儿园的老师，你需要让男生挨着女生或者女生挨着男生的情况最少。你只能在原队形上进行调整，每次调整只能让相邻的两个小朋友交换位置，现在需要尽快完成队伍调整，你需要计算出最少需要调整多少次可以让上述情况最少。例如：
GGBBG -> GGBGB -> GGGBB
这样就使之前的两处男女相邻变为一处相邻，需要调整队形2次
输入描述:
输入数据包括一个长度为n且只包含G和B的字符串.n不超过50.
输出描述:
输出一个整数，表示最少需要的调整队伍的次数
输入例子:
GGBBG
输出例子:
2
解题思路：
最后的状态一定是：
BBBBBGGGGG或GGGGGBBBBB
所以我们对于串中第一个’B’，然后计算把它swap到第一个位置需要多少次,第二个’B’swap到第二个位置需要多少次…依次类推.. 。
然后对于’G’同理,最后取个较小值即为答案。
C++代码实现：
#include <iostream>
#include <string>
using namespace std;
int main()
{
string x;
cin>>x;
int bcount=0,gcount=0,b=0,g=0;
for(int i=0; i<x.size(); ++i)
{
if(x[i]=='B')
{
bcount += (i-b);
b++;
}
else
{
gcount += (i-g);
g++;
}
}
b = (bcount<gcount)?bcount:gcount;
cout<<b;
return 0;
}4、消除重复元素
时间限制：1秒
空间限制：32768K
小易有一个长度为n序列，小易想移除掉里面的重复元素，但是小易想是对于每种元素保留最后出现的那个。小易遇到了困难,希望你来帮助他。
输入描述:
输入包括两行：
第一行为序列长度n(1 ≤ n ≤ 50)
第二行为n个数sequence[i](1 ≤ sequence[i] ≤ 1000)，以空格分隔
输出描述:
输出消除重复元素之后的序列，以空格分隔，行末无空格
输入例子:
9
100 100 100 99 99 99 100 100 100
输出例子:
99 100
解题思路：
这题比较简单，直接上代码。
C++代码实现：
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
bool comp(int a,int b)
{
return a>b;
}
int main()
{
int n;
vector<int> a(1001,0);
int b[51] = {0};
cin>>n;
for(int i=1; i<=n; ++i)
{
cin>>b[i];
a[ b[i] ] = i; //记录数字最后出现的索引
}
sort(a.begin(),a.end(),comp); //对索引进行从大到小排序
for(int i=50; i>=0; --i)
{
if(a[i]>=1)
{
if(i!=0)
cout<<b[a[i]]<<' ';
else
cout<<b[a[i]];
}
}
return 0;
}5、魔力手环
时间限制：1秒
空间限制：32768K
小易拥有一个拥有魔力的手环上面有n个数字(构成一个环),当这个魔力手环每次使用魔力的时候就会发生一种奇特的变化：每个数字会变成自己跟后面一个数字的和(最后一个数字的后面一个数字是第一个),一旦某个位置的数字大于等于100就马上对100取模(比如某个位置变为103,就会自动变为3).现在给出这个魔力手环的构成，请你计算出使用k次魔力之后魔力手环的状态。
输入描述:
输入数据包括两行：
第一行为两个整数n(2 ≤ n ≤ 50)和k(1 ≤ k ≤ 2000000000),以空格分隔
第二行为魔力手环初始的n个数，以空格分隔。范围都在0至99.
输出描述:
输出魔力手环使用k次之后的状态，以空格分隔，行末无空格。
输入例子:
3 2
1 2 3
输出例子:
8 9 7
解题思路：
方法一：简单的方法，循环对数组前后两个数相加，即[j] = (a[j]+a[(j+1)%n])%100; a[i]=b[i];。但是当K过大时，程序容易超时。
方法二：利用矩阵的快速幂。如下图。[1 2 3]经过两轮之后，变成[8 9 7]
C++代码实现：采用第二种方式
#include <iostream>
#include <vector>
using namespace std;
//矩阵相乘
vector<vector<int>> vertix_multiple(vector< vector<int> >&m,
vector< vector<int> >&n)
{
int row1 = m.size();
int col1 = m[0].size();
int col2 = n[0].size();
vector<vector<int>> result(row1,vector<int>(col2,0));
for(int i=0; i<row1; ++i)
{
for(int j=0; j<col2; ++j)
{
for(int k=0; k<col1; ++k)
result[i][j] = (result[i][j]+m[i][k]*n[k][j])%100;
}
}
return result;
}
//矩阵的幂
vector< vector<int> > vertix_pow(vector< vector<int> >m,int n)
{
int row = m.size();
vector<vector<int>> result(row,vector<int>(row,0));
//单位矩阵
for(int i=0; i<row; ++i)
result[i][i] = 1;
while(n)
{
if(n&1)
result= vertix_multiple(result,m);
n>>=1;
m = vertix_multiple(m,m);
}
return result;
}
int main()
{
int n,k;
cin>>n>>k;
int a[50]={0};
int result[50] = {0};
for(int i=0; i<n; ++i)
cin>>a[i];
vector< vector<int> >origin(n,vector<int>(n,0));
/*
构建矩阵：
1 0 1
1 1 0
0 1 1
*/
for(int i=0; i<(n-1); ++i)
origin[i][i] = origin[i+1][i] = 1;
origin[n-1][n-1] = origin[0][n-1] = 1;
//k次幂
origin = vertix_pow(origin,k);
for(int i=0; i<n; ++i)
{
for(int j=0; j<n; ++j)
{
result[i] = (result[i]+ a[j]*origin[j][i])%100;
}
}
for(int i=0; i<(n-1); ++i)
cout<<result[i]<<' ';
cout<<result[n-1];
}6、工作安排
时间限制：1秒
空间限制：32768K
现在有n位工程师和6项工作(编号为0至5)，现在给出每个人能够胜任的工作序号表(用一个字符串表示，比如：045，表示某位工程师能够胜任0号，4号，5号工作)。现在需要进行工作安排，每位工程师只能被安排到自己能够胜任的工作当中去，两位工程师不能安排到同一项工作当中去。如果两种工作安排中有一个人被安排在的工作序号不一样就被视为不同的工作安排，现在需要计算出有多少种不同工作安排计划。
输入描述:
输入数据有n+1行：
第一行为工程师人数n(1 ≤ n ≤ 6)
接下来的n行，每行一个字符串表示第i(1 ≤ i ≤ n)个人能够胜任的工作(字符串不一定等长的)
输出描述:
输出一个整数，表示有多少种不同的工作安排方案
输入例子:
6
012345
012345
012345
012345
012345
012345
输出例子:
720
解题思路：
回溯法，遍历空间树，路径数量即为结果。
C++代码实现：
#include <iostream>
using namespace std;
int work[6]={0,0,0,0,0,0};
int n = 0;
string str[6];
//回溯法
int backtrack(int t) //t表示第几个工程师选择某个工作
{
if(t>=n)
return 1;
int result = 0;
for(int i=0; i<str[t].length(); ++i)
{
if(work[str[t][i]-'0']==0) //第几项工作是否已安排
{
work[str[t][i]-'0'] = 1;
result += backtrack(t+1);
work[str[t][i]-'0'] = 0;
}
}
return result;
}
int main()
{
cin>>n;
for(int i=0; i<n; ++i)
cin>>str[i];
cout<<backtrack(0);
return 0;
}7、集合
时间限制：1秒
空间限制：32768K
小易最近在数学课上学习到了集合的概念,集合有三个特征：1.确定性 2.互异性 3.无序性.
小易的老师给了小易这样一个集合：
S = { p/q | w ≤ p ≤ x, y ≤ q ≤ z }
需要根据给定的w，x，y，z,求出集合中一共有多少个元素。小易才学习了集合还解决不了这个复杂的问题,需要你来帮助他。
输入描述:
输入包括一行：
一共4个整数分别是w(1 ≤ w ≤ x)，x(1 ≤ x ≤ 100)，y(1 ≤ y ≤ z)，z(1 ≤ z ≤ 100).以空格分隔
输出描述:
输出集合中元素的个数
输入例子:
1 10 1 1
输出例子:
10
解题思路：
这题比较简单，直接上代码
C++代码实现：
#include <iostream>
#include <map>
using namespace std;
int main()
{
unsigned int w,x,y,z;
cin>>w>>x>>y>>z;
map<double,int> result;
double temp = 0;
for(unsigned int i=w; i<=x; ++i)
{
temp = i*1.0;
for(unsigned int j=y; j<=z; ++j)
{
result[temp/j] = 1;
}
}
cout<<result.size();
return 0;
}8、奇怪的表达式求值
时间限制：1秒
空间限制：32768K
常规的表达式求值，我们都会根据计算的优先级来计算。比如/的优先级就高于+-。但是小易所生活的世界的表达式规则很简单，从左往右依次计算即可，而且小易所在的世界没有除法，意味着表达式中没有/，只有(+, - 和 )。现在给出一个表达式，需要你帮忙计算出小易所在的世界这个表达式的值为多少
输入描述:
输入为一行字符串，即一个表达式。其中运算符只有-,+,*。参与计算的数字只有0~9.
保证表达式都是合法的，排列规则如样例所示。
输出描述:
输出一个数，即表达式的值
输入例子:
3+5*7
输出例子:
56
解题思路：
这题比较简单，直接上代码
C++代码实现：
#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;
int main()
{
string str;
cin>>str;
int length = str.length();
int total = 0;
char last = 0; //运算符
char temp[10] = {0};
int templen = 0;
for(int i=0; i<length; )
{
if(str[i]=='+' || str[i]=='-' || str[i]=='*')
last = str[i++];
else
{
////读取这个数字，不止一位
while(i<length && str[i]>='0' && str[i]<='9')
{
temp[templen++] = str[i++];
}
temp[templen] = 0;
switch(last)
{
case '-':
total -= atoi(temp); break;
case '+':
total += atoi(temp); break;
case '*':
total *= atoi(temp); break;
default:
last = 0; total = atoi(temp); break;
}
templen = 0;
}
}
cout<<total;
return 0;
}9、涂棋盘
时间限制：1秒
空间限制：32768K
小易有一块n*n的棋盘，棋盘的每一个格子都为黑色或者白色，小易现在要用他喜欢的红色去涂画棋盘。小易会找出棋盘中某一列中拥有相同颜色的最大的区域去涂画，帮助小易算算他会涂画多少个棋格。
输入描述:
输入数据包括n+1行：
第一行为一个整数n(1 ≤ n ≤ 50),即棋盘的大小
接下来的n行每行一个字符串表示第i行棋盘的颜色，’W’表示白色，’B’表示黑色
输出描述:
输出小易会涂画的区域大小
输入例子:
3
BWW
BBB
BWB
输出例子:
3
解题思路：
这题比较简单，直接上代码
C++代码实现：
#include <iostream>
#include <string>
using namespace std;
int main()
{
string a[50];
unsigned int n,i,j;
cin>>n;
for(i=0; i<n; ++i)
cin>>a[i];
unsigned int count = 1;
unsigned int max = 1;
char lastColor = 0; //上一行的颜色
for(i=0; i<n; ++i)
{
count = 1;
lastColor = a[0][i];
j = 1;
while(j<n)
{
if(lastColor==a[j][i])
++count;
else
{
if(count>max)
max = count;
if(max>=n)
break; //最大区域快为n
count = 1;
lastColor = a[j][i];
}
++j;
}
if(count>max)
max = count;
if(max>=n)
break; //最大区域快为n
}
cout<<max;
return 0;
}10、小易记单词
时间限制：1秒
空间限制：32768K
小易参与了一个记单词的小游戏。游戏开始系统提供了m个不同的单词，小易记忆一段时间之后需要在纸上写出他记住的单词。小易一共写出了n个他能记住的单词，如果小易写出的单词是在系统提供的，将获得这个单词长度的平方的分数。注意小易写出的单词可能重复，但是对于每个正确的单词只能计分一次。
输入描述:
输入数据包括三行：
第一行为两个整数n(1 ≤ n ≤ 50)和m(1 ≤ m ≤ 50)。以空格分隔
第二行为n个字符串，表示小易能记住的单词，以空格分隔，每个单词的长度小于等于50。
第三行为m个字符串，系统提供的单词，以空格分隔，每个单词的长度小于等于50。
输出描述:
输出一个整数表示小易能获得的分数
输入例子:
3 4
apple orange strawberry
strawberry orange grapefruit watermelon
输出例子:
136
解题思路：
用Map
#include <iostream>
#include <map>
#include <string>
using namespace std;
int pow2(int a)
{
return a*a;
}
int main()
{
int n,m;
map<string,int> wordlist;
map<string,int> dict;
cin>>n>>m;
string temp;
for(int i=0; i<n; ++i)
{
cin>>temp;
wordlist[temp] = temp.length();
}
for(int i=0; i<m; ++i)
{
cin>>temp;
dict[temp] = 1;
}
map<string,int>::iterator it = wordlist.begin();
int total = 0;
while(it!=wordlist.end())
{
if((dict.find(it->first))!=dict.end())
total += pow2(it->second);
it++;
}
cout<<total;
return 0;
}11、堆砖块
时间限制：1秒
空间限制：32768K
小易有n块砖块，每一块砖块有一个高度。小易希望利用这些砖块堆砌两座相同高度的塔。为了让问题简单，砖块堆砌就是简单的高度相加，某一块砖只能使用在一座塔中一次。小易现在让能够堆砌出来的两座塔的高度尽量高，小易能否完成呢。
输入描述:
输入包括两行：
第一行为整数n(1 ≤ n ≤ 50)，即一共有n块砖块
第二行为n个整数，表示每一块砖块的高度height[i] (1 ≤ height[i] ≤ 500000)
输出描述:
如果小易能堆砌出两座高度相同的塔，输出最高能拼凑的高度，如果不能则输出-1.
保证答案不大于500000。
输入例子:
3
2 3 5
输出例子:
5
解题思路：
不能按照0−1背包问题去解，因为不能保证堆砌的两个塔高度相等。砖块bk ：for k=0∼n−1。定义h[i,j]为使用前i块砖能够堆砌的低塔高度，j表示高塔和低塔的高度差。i=0∼n而j=0∼sum(bk)这样定义的好处是可以计算出任意状态下低塔和高塔各自的高度，且原问题就是h[n,0]。递归式为：
当i=0时表示还没有砖块，高度差j一定为0，j≠0为不可能情况。需要比较的四种情况如下图所示：
C++代码实现：
#include <iostream>
using namespace std;
const int MIN_INT = 0x80000000;
void calculate(int *a,int n,int **h,int sum)
{
int b = 0;
h[0][0] = 0;
for(int j=1; j<=sum; ++j)
h[0][j] = MIN_INT;
for(int i=1; i<=n; i++)
{
b = a[i-1];
for(int j=0; j<=sum; ++j)
{
h[i][j] = h[i-1][j];
if((j+b)<=sum)
h[i][j] = std::max(h[i][j],h[i-1][j+b]+b);
if((b-j)>=0)
h[i][j] = std::max(h[i][j],h[i-1][b-j]+b-j);
else
h[i][j] = std::max(h[i][j],h[i-1][j-b]);
}
}
}
int main()
{
int a[50]={0};
int n;
cin>>n;
int sum = 0;
for(int i=0; i<n; ++i)
{
cin>>a[i];
sum += a[i];
}
int **h=new int*[n+1];
for(int i=0; i<=n; ++i)
h[i] = new int[sum+1];
calculate(a,n,h,sum);
if(h[n][0]>0)
cout<<h[n][0];
else
cout<<-1;
for(int i=0; i<=n; ++i)
delete h[i];
delete h;
return 0;
}12、分饼干
时间限制：1秒
空间限制：32768K
易老师购买了一盒饼干，盒子中一共有k块饼干，但是数字k有些数位变得模糊了，看不清楚数字具体是多少了。易老师需要你帮忙把这k块饼干平分给n个小朋友，易老师保证这盒饼干能平分给n个小朋友。现在你需要计算出k有多少种可能的数值
输入描述:
输入包括两行：
第一行为盒子上的数值k，模糊的数位用X表示，长度小于18(可能有多个模糊的数位)
第二行为小朋友的人数n
输出描述:
输出k可能的数值种数，保证至少为1
输入例子:
9999999999999X
3
输出例子:
4
解题思路：
动态规划算法。dp[i][j]表示长度为i的数 除以小朋友的人数之后得到的余数为j的个数。结果就是dp[str.length][0]
那么状态转移方程该怎么写呢，举个例子，对于确定的数值K=1244，小朋友个数n=3来说，如果当前的i为走到了3，也就是我们只看124这三位，那么算出余数j为1，也就是说对于这个特殊的例子dp[3][1]=1；那么当i=4的时候，我们现在要看1244了，那我们怎么更新呢，来看1244除以3的过程，其实前面完全就是124除以3，只不过得到过程中的余数1之后，要和最后的4拼接构成14，再和3除，得到最后的余数2，那这时候其实，新的余数是j=2，也就是dp[4][2]+=dp[3][1].
上述情况如果理解了，现在就把最后那个4 换成X，那么这时候，由于X可以从0到9，所以我们得到的新余数应该是newJ=（1*10+X）%3，这样由于X不定，我们可以更新很多值，但是这更新的新余数，都来自这个旧余数，或者依赖于他。
如果str[i]=’X’，则X可替换为0-9
newJ = (j*10+k)%n; dp[i][newJ] += dp[i-1][j]
如果str[i]=0-9,则：
newJ = (j*10+str[i]-‘0’)%n; dp[i][newJ] += dp[i-1][j]
C++代码实现：
#include <iostream>
#include <string>
using namespace std;
int main()
{
string str;
int n;
cin>>str;
cin>>n;
if(n<=0)
return 0;
long long **dp = new long long*[str.length()+1];
for(int i=0; i<=str.length(); ++i)
dp[i] = new long long[n];
for(int i=0; i<=str.length(); ++i)
for(int j=0; j<n; ++j)
dp[i][j] = 0;
dp[0][0] = 1;
int newJ = 0;
for(int i=1; i<=str.length(); ++i)
{
for(int j=0; j<n; ++j)
{
if(str[i-1]=='X')
{
for(int k=0; k<=9; ++k)
{
newJ = (j*10+k)%n;
dp[i][newJ] += dp[i-1][j];
}
}
else
{
newJ = (j*10+str[i-1]-'0')%n;
dp[i][newJ] += dp[i-1][j];
}
}
}
cout<<dp[str.length()][0];
for(int i=0; i<=str.length(); ++i)
delete dp[i];
delete dp;
return 0;
}
扫一扫
437
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
