算法中的数学知识

分类:热门推荐日期:2024-04-02浏览:1评论:0

文章目录

  • 算法中的数学知识
    • 约数
      • 约数个数
      • 约数之和
      • 筛法求质数
        • 阶乘分解
          • 解法一
          • 解法二：
          • 欧拉函数
            • 基本模板
            • 筛法求欧拉函数
            • 大数据幂的欧拉函数
            • 快速幂
            • 费马小定理
            • 快速幂求逆元
            • 数论分块
                • 例题：[因数平方和](https://www.acwing.com/problem/content/4665/)
                • 分析:
                • 具体代码：
                  • __int128写法
                  • 逆元写法
                  • 例题2：余数之和
                  • 高斯消元法
                        • 算法步骤
                        • 组合数学
                            • 题型一
                            • 题型二
                            • 题型三（卢卡斯定理）
                            • 卡特兰数
                              • 889. 满足条件的01序列
                              • 129.火车进站问题
                              • 130.火车进出栈问题

                                算法中的数学知识

                                约数

                                约数个数

                                原题链接：约束个数

                                代码如下:

                                #include #include #include 
using namespace std;
const int N = 110, mod = 1e9 + 7;
int main() { int n;
    cin >> n;
    unordered_map primes; //分别存储质因子的底数和指数
    while(n--) { int x;
        cin >> x;
        for(int i = 2; i <= x / i; i++) { while(x % i == 0) { x /= i;
                primes[i]++;
            }
        }
        if(x > 1)   primes[x]++;
    }
    long long res = 1;
    for(auto prime : primes)    res = res * (prime.second + 1) % mod;
    cout << res;
    return 0;
}

                                约数之和

                                原题链接：约数之和

                                代码如下：

                                #include using namespace std;
const int mod = 1e9 + 7;
int main() { int n;
    cin >> n;
    unordered_map primes;
    while(n--) { int x;
        cin >> x;
        for(int i = 2; i <= x / i; i++) { while(x % i == 0) { x /= i;
                primes[i]++;
            }
        }
        if(x > 1)   primes[x]++;
    }
    long long res = 1;
    
    for(auto prime : primes) { long long t = 1;
        while(prime.second --)
            t = (prime.first * t + 1) % mod;
        res = res * t % mod;
    }
    cout << res;
    return 0;
}

                                筛法求质数

                                原题链接：筛质数

                                每次从最小质数开始遍历，可以保证n只会被最小质数筛到， 避免多次筛到， 每个数只会被筛一次， 即时间复杂度为 O ( n ) O(n) O(n)， 线性筛法

                                #include using namespace std;
const int N = 1e6 + 10;
int primes[N];
bool st[N];
int n;
int get_primes(int n) { if(n < 2)   return 0;
    int cnt = 0;
    for(int i = 2; i <= n; i++ ) {//一次线性筛选，即可完成操作
        if(!st[i]) primes[cnt++] = i;	//没被筛到，则为质数
        for(int j = 0; primes[j] * i <= n; j++) { st[primes[j] * i] = true;	//从最小质数集开始筛选相关合数
            if(i % primes[j] == 0)  break;	//找到最小质因数，直接操作结束
        }
    }
    return cnt;
}
int main() { cin >> n;
    cout << get_primes(n);
    return 0;
}

                                阶乘分解

                                题目链接：https://www.acwing.com/problem/content/description/199/

                                解法一

                                思路分析：

                                先用线性筛法求出质数数组，随后对每个质数进行操作

                                a n s = ∑ p r i m e s [ i ] n n p + n p 2 + n p 3 + … ans = \sum_{primes[i]}^{n} \frac{n}{p} + \frac{n }{p^2} + \frac{n}{p^3} + … ans=∑primes[i]n​pn​+p2n​+p3n​+…

                                代码

                                //思路：将质数最小到大进行枚举，直接通过“倍数”[n/p]来计算相应次数，然而[1,n]中
//有的数含的p的次数不止一次，故进行[n/p] + [n / p^2] + [n / p^3] + ...
#include using namespace std;
const int N = 1e6 + 10;
int primes[N], cnt = 0;
bool st[N];
void get_primes(int n) { for(int i = 2; i <= n; i++) { //枚举1~n中的所有筛选质数
        if(!st[i])  primes[cnt++] = i;  //若没有被筛掉，则为质数
        for(int j = 0; primes[j] * i <= n; j++) { st[primes[j] * i] = true;
            if(i % primes[j] == 0)  break;
        }
    }
}
int main() { int n;
    cin >> n;
    get_primes(n);  //先初始化primes数组
    //然后进行枚举各个质数算出次数
    for(int i = 0; i < cnt; i++) { int p = primes[i];  //质数
        int t = n, ct = 0;
        while(t) ct += t / p, t /= p;   //每次的t/=p，下一次就成了cnt += t/p^2
        printf("%d %d\n", primes[i], ct);
    }
    
}
                                解法二：

                                思路同上

                                #include using namespace std;
int n;
bool prime(int x) { if (x == 2) return 1;
    for (int i = 2; i * i <= x; i++) if (x % i == 0) return 0;
    return 1;
}
int main() { scanf("%d", &n);
    for (int i = 2; i <= n; i++) { if (!prime(i)) continue;
        long long x = i; int ans = 0;
        while (x <= n) ans += n / x, x *= i;
        printf("%d %d\n", i, ans);
    }
    return 0;
}

                                欧拉函数

                                基本模板

                                原题链接：欧拉函数

                                #include #include using namespace std;
int euler(int x) { int res = x;
    for(int i = 2; i <= x / i; i++) { if(x % i == 0) { res = res / i * (i - 1);
            while(x % i == 0)    x /= i;
        }
    }
    if(x > 1)   res = res / x * (x - 1);
    return res;
}
int main() { int n;
    cin >> n;
    while(n --) { int a;
        cin >> a;
        cout << euler(a) << endl;
    }
    return 0;
}

                                筛法求欧拉函数

                                原题链接

                                代码如下：

                                //欧拉：1 ~ n - 1 中与n互质的数的个数
#include #include using namespace std;
const int N = 1e6 + 10;
int primes[N], cnt;
int phi[N];
bitset st;
long long get_eulers(int n) { long long res = 0;
    phi[1] = 1;
    for(int i = 2; i <= n; i++) { //线性筛法，遍历一次n
        if(!st[i]) { //没有被筛，质数
            primes[cnt++] = i;
            phi[i] = i - 1; //若为质数，则代表1 ~ i - 1都为互质
        }
        for(int j = 0; primes[j] <= n / i; j++) { st[primes[j] * i] = 1;
            if(i % primes[j] == 0)  { //若primes[j]为i的质因数，则有 primes[j] 的质因子必然存在于i中
                phi[i * primes[j]] = primes[j] * phi[i];
                break;
            }
            //若i % primes[j] != 0，则对质数primes[j]另行计算有:p[j] * (p[j] - 1) / p[j]
            phi[i * primes[j]] = phi[i] * (primes[j] - 1);
        }
    }
    for(int i = 1; i <= n; i++) res += phi[i];
    return res;
}
int main() { int n;
    cin >> n;
    cout << get_eulers(n); 
    return 0;
}

                                大数据幂的欧拉函数

                                原题链接：互质数的个数

                                分析：

                                如上图可以将 ϕ ( a b ) \phi(a^b) ϕ(ab)分解为 a b ∗ ϕ ( a ) a^b*\phi(a) ab∗ϕ(a)， 继续演变为求欧拉和快速幂的结合应用

                                *** 代码如下：***

                                #include using namespace std;
const int MOD = 998244353;
long long qmi(long long a, long long b) { long long res = 1;
    while(b) { if(b & 1)   res = res * a % MOD;
        a = a * a % MOD;
        b >>= 1;
    }
    return res;
}
int main() { long long a, b;
    cin >> a >> b;
    if(a == 1) { //题目要求是x不能取到a^b, 故如果a=1,互质个数为0
        cout << 0 << endl;
        return 0;
    }
    long long res = a, x = a;
    for(int i = 2; i <= x / i; i++) { if(x % i == 0) { res = res / i * (i - 1);
            while(x % i == 0)   x /= i;
        }
    }
    if(x > 1)   res = res / x * (x - 1);
    cout << res * qmi(a, b - 1) % MOD << endl;
    return 0;
}

                                ​

                                快速幂

                                基本思想：

                                将 a k a^k ak化为 a 2 x   1   ∗ a 2 x   2   ∗ a 2 x   3 ∗ . . . ∗ a 2 x   t   a^{2x~1~}*a ^{2x~2~} * a^{2x~3} * ...*a^{2x~t~} a2x 1 ∗a2x 2 ∗a2x 3∗...∗a2x t 

                                ***本质：***将k化为若干个2的次幂之和

                                这时候可以想到用二进制来操作

                                例如：若 k = 1101010 < = = > <==> <==> 2 1 + 2 3 + 2 5 + 2 6 2^1 + 2^3 + 2^5 + 2^6 21+23+25+26

                                对二进制位数进行遍历， 当k & 1 == 1，即当前k的最后一个位置为1，进行累乘

                                代码如下：

                                #include using namespace std;
typedef long long LL;
// a^k % p
int qmi(int a, int k, int p) { int res = 1;
    //本质：将k拆分为2的n次幂之和
    while(k){ if(k & 1)   res = (LL)res * a % p;
        k >>= 1;
        a = (LL)a * a % p; 
    }
    return res;
}
int main() { int n;
    cin >> n;
    while(n-- ) { int a, b, p;
        scanf("%d%d%d", &a, &b, &p);
        cout << qmi(a, b, p) << endl;
    }
    return 0;
}

                                费马小定理

                                ​

                                ​ a p 与 a 在 m o d ( p ) 的情况下是同余的 a^p与a在mod(p)的情况下是同余的 ap与a在mod(p)的情况下是同余的

                                快速幂求逆元

                                快速幂求逆元

                                **分析：**只需求出 b p − 2   %   p b^{p-2}\ \%\ p bp−2 % p的快速幂即可

                                代码如下：

                                #include using namespace std;
typedef long long LL;
int qmi(int a, int k, int p) { int res = 1;
    while(k) { if(k & 1)   res = (LL)res * a % p;
        k >>= 1;
        a = (LL)a * a % p;
    }
    return res;
}
int main() { int n;
    cin >> n;
    while(n-- ) { int a, p;
        scanf("%d%d", &a, &p);
        if(a % p == 0)  cout << "impossible" << endl;
        else cout << qmi(a, p - 2, p) << endl;
    }
    return 0;
}

                                数论分块

                                一般在算法中遇到时间复杂度为1e9的， 那么一次 O ( n ) O(n) O(n)的遍历无法解决问题

                                求··· ∑ i = 1 n [ n i ] \sum_{i=1}^n{[\frac{n}{i}]} ∑i=1n​[in​]···

                                例题：因数平方和
                                分析:

                                要求 n n n的约数，时间复杂度肯定不够， 所以想到反着求

                                a是b的约数 <==> b是a的倍数，所以我们只需要求哪些数包含约数a相加

                                每一个约数a 对答案的贡献度为 a 2 a^2 a2， 每个数a是 n a \frac{n}{a} an​个数的约数

                                故a这个数对答案的总贡献为 a 2   ∗   [ n a ] a^2\ *\ [\frac{n}{a}] a2 ∗ [an​]，故答案为：

                                ∑ i = 1 n   [ n i ] ∗ i 2 \sum_{i=1}^n\ [\frac{n}{i}]*i^2 i=1∑n​ [in​]∗i2

                                由上可知， 可以将n划分为前半段和后半段的话， 可计算出只需操作 2 n 2\sqrt{n} 2n ​个数即可

                                如此， 可以将 n n n优化为 2 n 2\sqrt{n} 2n ​个数进行计算

                                进行分块治理，如下

                                将区间长度为 n n n划分为 2 n 2\sqrt{n} 2n ​个区间， 对每个区间进行求值，每个区间值相同， 只需算连续平方和，可以直接用公式求平方和值， 故每个区间只需要算一次即可

                                结果： O ( N ) − − > O ( N 2 ) O(N) - - > O(N^2) O(N)−−>O(N2)

                                推导出：每个区间最大的位置： y = n / x y = n / x y=n/x ， 对于各个区间值为== x = n / i x = n / i x=n/i==

                                即计算区间和每个== [ i , y ] [i, y] [i,y]区间即可， 然后算完一个区间直接 i = y + 1 i = y + 1 i=y+1，来跳跃到下一个区间进行计算， 总共只需要算 2 n 2\sqrt{n} 2n ​==次

                                具体代码：

                                此题在计算平方和时可能数据量会超大（超LL）

                                __int128写法
                                #include using namespace std;
const int MOD = 1e9 + 7;
typedef long long LL;
//__int128 : 2^127 - 1
LL calc(int n) { //计算平方和
//这里可能特别大超过2^64(LL)，故用__int128临时存储数值
    return n * (__int128)(n + 1) * (2*n + 1) / 6 % MOD;   
}
int main() { int n;
    cin >> n;
    LL res = 0;
    for(int i = 1; i <= n; ) { //划分为2sqrt(n)个区间，每个区间的所有数相等，第i个区间值为n/i
        int x = n / i, y = n / x;   
        //求区间[i, y]的平方和，再乘上x值
        res = res + x * (calc(y) - calc(i - 1)) % MOD;
        i = y + 1;  
    }
    //这块可能取模相减为负值，故
    cout << (res + MOD) % MOD << endl;
    return 0;   
}
                                逆元写法
                                LL calc(int n) { //计算平方和
//这里可能特别大超过2^64(LL)，故用__int128临时存储数值
    // return n * (LL)(n + 1) * (2*n + 1) / 6 % MOD;   
//逆元写法
    return n * (LL)(n + 1) % MOD * (2*n + 1) % MOD * 166666668 % MOD;
}
//计算 /6 的逆元
/for(int i = 1; ;i++) {//算出逆元答案为166666668， 带入上式替换掉 '/6'
    if(i * 6 % MOD == 1) { cout << i << endl;
        return 0;
	}
}
                                例题2：余数之和

                                原题链接

                                思想：

                                首先看到数据范围为1e9级别，故可以想到用分块思想，优化到 O ( 2 n ) O(2\sqrt{n}) O(2n ​)

                                k % i k \% i k%i <==> k − [ k i ] ∗ i k - [\frac{k}{i}]*i k−[ik​]∗i

                                则 k % ∑ 1 n k \% \sum_1^n k%∑1n​ < = = > <==> <==> n ∗ k   −   ∑ i = 1 n [ k i ] ∗ i n*k\ -\ \sum_{i=1}^n[\frac{k}{i}]*i n∗k − ∑i=1n​[ik​]∗i

                                代码：

                                #include using namespace std;
typedef long long LL;
LL sum_primes(int n, int k) { //k % i = k - [k / i] * i  ---> k % [1, n] = n*k - k / [1,n]*i
    LL res = (LL)n * k;
    for(int i = 1; i <= n; ) { if(k < i)   break;  //此时往后全为0，不用操作了
        int x = k / i, y = min(k / x, n);   //区间有极限值为n，防止越界
        //求区间总值 * x  --- > 等差数列求和：n * (a1 + an) / 2
        res -= x * (LL)(y - i + 1) * (i + y) / 2;
        i = y + 1;  //操作下一个区间
    }
    return res;
}
int main() { int n, k;
    cin >> n >> k;
    cout << sum_primes(n, k) << endl;
    return 0;
}

                                高斯消元法

                                基本性质：

                                1. 把某一行乘一个非 0 0 0的数 (方程的两边同时乘上一个非 0 0 0数不改变方程的解)

                                2. 交换某两行 (交换两个方程的位置)

                                3. 把某行的若干倍加到另一行上去 （把一个方程的若干倍加到另一个方程上去）

                                算法步骤

                                枚举每一列c

                                  1. 找到绝对值最大的一行
                                  1. 将该行换到最上面
                                  1. 将该行第1个数变成1
                                  1. 将下面所有行的第c列清成0
                                  #include #include 
#include using namespace std;
const int N = 110;
double a[N][N];
int n;
const double eps = 1e-8;    //浮点型存在精度误差，容易
/*枚举每一列
- 1. 找到绝对值最大的一行 
- 2. 将该行换到最上面（第r行）
- 3. 将该行第1个数变成1
- 4. 将下面所有行的第`c`列清成0
    
*/
int gauss() { int c, r;
    //首先开始枚举每一列进行“清零”操作
    for(c = 0, r = 0; c < n; c ++) { int mx_r = r;
        for(int i = r; i < n; i++)  //找到绝对值最大的一行
            if(fabs(a[i][c]) > fabs(a[mx_r][c]))
                mx_r = i;
        if(fabs(a[mx_r][c]) < eps)    continue;    //判断最大如果为0，那么没有算的必要
        for(int i = c; i <= n; i++) swap(a[mx_r][i], a[r][i]);  //换到第r行
        for(int i = n; i >= 0; i-- )    a[r][i] /= a[r][c]; //第”首位(c)“变为1
        for(int i = r + 1; i < n; i++ ) { // 将下面所有行的第`c`列清成0
            if(fabs(a[i][c]) > eps) //若是=0则没必要操作
                for(int j = n; j >= c; j--)
                    a[i][j] -= a[i][c] * a[r][j];   //a[r][c]为1，故这样可以消0
        }
        r++;    //该方程式固定好，进行下一个方程式行的操作
    }
    //判断无解和无限解的情况
    if(r < n) { //这样的话，那么说明未知数方程式个数不足n，则无法构成完美梯形
        for(int i = r; i < n; i++ )
            if(fabs(a[i][n]) > eps) //多出的答案bi若是不等于0
                return 2;   //无解
        return 1;  //无限解    0 == 0
    }   
    //进行上三角矩阵的方程化简
    for(int i = n - 1; i >= 0; i -- ) { //从后往前，anxn = bn，一步一步推前方的方程式未知数
        for(int j = i + 1; j < n; j++)  //每i到最后只需保留第i个数(1),其它数全清零
            a[i][n] -= a[i][j] * a[j][n];   //这里第j行的答案已经算出，后续数（清零）的同步操作
    }
    return 0;   //有唯一解
}
int main() { cin >> n;
    for(int i = 0; i < n; i++ )
        for(int j = 0; j < n + 1; j++ )
            cin >> a[i][j];
    int r = gauss();
    if(r == 0) { for(int i = 0; i < n; i ++) printf("%.2lf\n", a[i][n]);
    } else if(r == 1)   puts("Infinite group solutions");
      else puts("No solution");
      
    return 0;
}

                                  组合数学

                                  题型一

                                  直接算的话会超时

                                  考虑到只有2000 *2000个数，可以直接先打好表

                                  C a b = C a − 1 b − 1 + C a − 1 b C^b_a = C^{b-1}_{a-1} + C^{b}_{a-1} Cab​=Ca−1b−1​+Ca−1b​

                                  代码

                                  #include using namespace std;
const int N = 2010, MOD = 1e9 + 7;
int n;
int c[N][N];    //表示组合数C^b_a
void init() { for(int i = 0; i < N; i++ ) 
        for(int j = 0; j <= i; j++) 
            if(j == 0)  
                c[i][j] = 1;
            else 
                c[i][j] = c[i - 1][j - 1] % MOD + c[i - 1][j] % MOD;
}
int main() { cin >> n;
    init();
    while(n --) { int a, b;
        scanf("%d%d", &a, &b);
        printf("%d\n", c[a][b] % MOD);
    }
    return 0;
}
                                  题型二

                                  时间复杂度高，直接算不行，用集合状态的公式也不行

                                  可以想到如何直接算出fact[N]的表然后套公式打表

                                  C a b = a ! ( b ! ) ∗ ( a − b ) ! C^b_a = \frac{a!}{(b!)*(a - b)!} Cab​=(b!)∗(a−b)!a!​

                                  由于存在除法，数据量过大需要及时取模，而除法直接取模会导致答案变化，故想到求逆元（费马小定理+快速幂）然后进行相乘

                                  代码如下

                                  #include using namespace std;
typedef long long LL;
const int N = 100010, MOD = 1e9 + 7;
int n;
int fact[N], infact[N]; //分别存储阶乘\阶乘的逆元
int qmi(int a, int b, int p) { int res = 1;
    while(b) { if(b & 1)   res = (LL)res * a % MOD;
        a = (LL)a * a % MOD;
        b >>= 1;
    }
    return res;
}
void init() { //0的阶乘/逆元阶都为1
    fact[0] = infact[0] = 1;
    for(int i = 1; i < N; i++) { fact[i] = (LL)fact[i - 1] * i % MOD;
        infact[i] = (LL)infact[i - 1] * qmi(i, MOD - 2, MOD) % MOD;
    }
}
int main() { init();
    cin >> n;
    while(n-- ) { int a, b;
        scanf("%d%d", &a, &b);
        printf("%d\n", (LL)fact[a] % MOD * infact[b] % MOD * infact[a - b] % MOD);
    }
    
    return 0;
}
                                  题型三（卢卡斯定理）

                                  公式如下

                                  C a b ≡ C a   m o d   p b   m o d   p ∗ C a   /   p b   /   p   ( m o d   p ) C^b_a \equiv C^{b\ mod\ p}_{a\ mod\ p} * C^{b\ /\ p}_{a\ /\ p}\ (mod\ p) Cab​≡Ca mod pb mod p​∗Ca / pb / p​ (mod p)

                                  推导

                                  代码：

                                  //发现a,b很大，而p很小，这种情况下用lucas定理来处理
#include using namespace std;
typedef long long LL;
int qmi(int a, int b, int p) { int res = 1;
    while(b) { if(b & 1)   res = (LL)res * a % p;
        a = (LL)a * a  % p;
        b >>= 1;
    }
    return res;
}
int C(int a, int b, int p) { if(b > a)   return 0;   //！边界条件
    int res = 1; // a!/(b!(a-b)!) = (a-b+1)*...*a / b!
    for(int i = 1, j = a; i <= b; i++, j--) { res = (LL)res * j % p;
        res = (LL)res * qmi(i, p - 2, p) % p;
    }
    return res;
}
int lucas(LL a,LL b, int p) { if(a < p && b < p)  return C(a, b, p);
    return (LL)C(a % p, b % p, p) * lucas(a / p, b / p, p) % p;//a%p后肯定是 int n;
    cin >> n;
    while(n--) { int p;
        LL a, b;
        cin >> a >> b >> p;
        printf("%d\n", lucas(a, b, p));
    }
    return 0;
}

                                  卡特兰数

                                  889. 满足条件的01序列

                                  题目链接：https://www.acwing.com/problem/content/891/

                                  题目思路：

                                  通过以上举例n=6时的情况，可以推出最终：

                                  a n s = C 2 n n   −   C 2 n n − 1 ans = C_{2n}^n\ -\ C_{2n}^{n-1} ans=C2nn​ − C2nn−1​

                                  又可化简为：

                                  C 2 n n   −   C 2 n n − 1 = C 2 n n n + 1 C_{2n}^n\ -\ C_{2n}^{n-1} = \frac{C_{2n}^n}{n+1} C2nn​ − C2nn−1​=n+1C2nn​​

                                  代码实现：

                                  #include using namespace std;
const int MOD = 1e9 + 7;
typedef long long LL;
//用卡特兰公式: ans = (c^n_2n) / (n + 1)
int qmi(int a, int b, int p) { int res = 1;
    while(b) { if(b & 1)   res = (LL)res * a % p;
        a = (LL)a * a % p;
        b >>= 1;
    }
    return res;
}
int main() { int n;
    cin >> n;
    int res = 1;
    // res = [(2n)! / (n! * n!)] / (n + 1)
    for(int i = 2 * n; i > 2*n - n; i--)    res = (LL)res * i % MOD;
    for(int i = 1; i <= n; i++) res = (LL)res * qmi(i, MOD - 2, MOD) % MOD;
    res = (LL)res * qmi(n + 1, MOD - 2, MOD) % MOD;
    cout << res;
    return 0;
}

                                  129.火车进站问题

                                  原题链接：https://www.acwing.com/problem/content/131/

                                  输入样例:

                                  3

                                  输出样例：

                                  123

                                  132

                                  213

                                  231

                                  321

                                  代码

                                  #include #include #include #define end '\n'
using namespace std;
vector path;
stack stk;
int n, remain = 20;
void dfs(int u) { if(remain == 0) return ;
    if(path.size() == n) { remain --;  //剩余输出量
        for(auto t : path)
            cout << t;
        cout << endl;
        return ;
    }
    //两种操作选择
    //1. 出栈操作
    if(!stk.empty()) { path.push_back(stk.top());
        stk.pop();
        dfs(u); //从1开始进行枚举
        //恢复操作
        stk.push(path.back());
        path.pop_back();
    }
    //2. 入栈操作
    if(u <= n) { stk.push(u);
        dfs(u + 1);
        //恢复操作
        stk.pop();
    }
}
int main() { cin >> n;
    dfs(1);
    return 0;
}

                                  130.火车进出栈问题

                                  原题链接：https://www.acwing.com/problem/content/132/

相关推荐

关于我们常见问题广告服务免责声明联系我们
Powered By Z-BlogPHP 1.7.3 Theme By 优美主题
Copyright Your WebSite.Some Rights Reserved. 浙ICP备2023018783号