算法之前缀和

题目1: 【模板】一维前缀和（easy）

方法一: 暴力解法, 时间复杂度O(n*q), 当n=10^5, q = 10^5, 时间复杂度为O(10^10), 会超时.

方法二:

前缀和: 快速求出数组中某一段连续区间的和.

第一步: 预处理出来一个前缀和数组dp:

1. dp[i]表示区间[1,i]里所有元素的和

2. dp[i] = dp[i-1] + arr[i]

 为什么还有一个前缀和数组? 

使用暴力解法是先把arr存进去, 再遍历一次arr求和.

但是 求和 在存入原始数据的时候就能一起完成 O(n), 而区间[l,r]的和就是dp[r] - dp[l-1], 直接取出数据即可 O(q), 最终时间复杂度是O(n) + O(q), 实际上求前l项数据的和 与 求前r项数据的和 本质是同一类问题,  可以把同一类问题抽象成一种状态表示, 进而用动态规划思想去解决.

 细节问题:

我们的数组都要像题目一样表示, 也就是下标从1开始计数, 为什么?

因为 dp[i] = dp[i-1] + arr[i] 这个公式, 当 i==0 的时候会出现dp[-1]越界访问, 而下标从1开始, 第一个数据是dp[1] = dp[0] + arr[1], 对于dp[0]保证其初始化的时候为0即可.

#include <iostream>
using namespace std;

int main() 
{
    int n,q;
    long long arr[100001]= {0};
    long long dp[100001] = {0};

    cin >> n >> q;

    //O(n)
    for(int i = 1; i <= n; i++)
    {
        cin >> arr[i];
        dp[i] = arr[i] + dp[i-1];
    }

    //O(q)
    for(int j = 0; j < q; j++)
    {
        long long l,r;
        cin >> l >> r;
        
        cout << dp[r] - dp[l-1] << endl;
    }

    return 0;
}
// 64 位输出请用 printf("%lld")

题目2: 【模板】二维前缀和（medium）

方法1: 暴力求解,时间复杂度O(m*n*q) 

方法2:前缀和 

2.1 利用一维前缀和: 

相当于x2x1+1个一维的前缀和相加, 只需要:
1. 确定好每次区间的起始坐标为y1+(x1-1)*m, 则终止坐标为起始坐标+(y2-y1), 
2. 起始坐标+=m, 重复循环计算 

#include <iostream>
using namespace std;

int main()
{
    int n, m, q;
    long long arr[1000001] = { 0 };
    long long dp[1000001] = { 0 };

    cin >> n >> m >> q;

    //O(n)
    for (int i = 1; i <= n * m; i++)
    {
        cin >> arr[i];
        dp[i] = arr[i] + dp[i - 1];
    }

    //O(q)
    for (int j = 0; j < q; j++)
    {
        long long x1, x2, y1, y2, sum = 0;
        cin >> x1 >> y1 >> x2 >> y2;
        long long start = y1 + ((x1 - 1) * m);
        long long gap = y2 - y1;

        for (int i = 0; i < x2 - x1 + 1; i++)
        {
            sum += dp[start+gap] - dp[start- 1];
            start += m;
        }
        cout << sum << endl;
    }

    return 0;
}
// 64 位输出请用 printf("%lld")

 2.2 二维的前缀和

a. 预处理一个前缀和矩阵

dp[i][j]表示: 从 [1][1] 位置到 [i][j] 位置这个矩阵的元素和.

可以把矩阵 i*j 沿 i 和 j 分为四块, 分别标记为A,B,C,D, 因为这样划分A+B 和 A+C 的面积可以分别用dp[i-1][j]和dp[i][j-1]表示, 而D的面积就是arr[i][j], 所以dp[i][j] = A+B  + A+C + D - A = dp[i-1][j] + dp[i][j-1] + dp[i-1][j] + arr[i][j] - dp[i-1][j-1]

b.使用这个前缀和矩阵 

将矩阵沿x1 y1划分成四份, D的面积推导同上:

#include <iostream>
using namespace std;

int main()
{
    int n, m, q;
    long long arr[1001][1001] = { 0 };
    long long dp[1001][1001] = { 0 };

    cin >> n >> m >> q;

    //O(n)
    for (int i = 1; i <= n; i++)
    {
        for(int j = 1; j<=m;j++)
        {
            cin >> arr[i][j];
            dp[i][j] = dp[i-1][j] + dp[i][j-1] + arr[i][j] - dp[i-1][j-1];
        }
    }

    //O(q)
    for (int j = 0; j < q; j++)
    {
        long long x1, x2, y1, y2, sum = 0;
        cin >> x1 >> y1 >> x2 >> y2;
        cout<< dp[x2][y2] - dp[x1-1][y2] - dp[x2][y1-1] + dp[x1-1][y1-1] << endl;
    }

    return 0;
}
// 64 位输出请用 printf("%lld")

题目3: 寻找数组的中心下标

直接利用前缀和:

同之前一样, 利用递推公式求出dp[i], 来表示前i个数的和:

 而后缀和可以用前缀和来表示: dp[n]-dp[i+1]

class Solution {
public:
    int pivotIndex(vector<int>& nums) 
    {
        int n = nums.size();

        vector<int> dp(n+1);
        dp[0] = 0;
        for(int i = 1; i <= n;i++)
        {
            dp[i] = dp[i-1] + nums[i-1];
        }

        for(int i = 0; i < n;i++)
        {
            if(dp[i] == dp[n]-dp[i+1])
                return i;
        }
        return -1;
    }
};

也可以用f[i]表示题意中的前缀和, g[i]表示题中的后缀和, 注意f[i]要从前向后初始化, 而g[i]要从后向前初始化, 最后用f[i] == g[i]进行比较即可:

class Solution {
public:
    int pivotIndex(vector<int>& nums) 
    {
        int n = nums.size();
        vector<int> f(n);
        vector<int> g(n);

        //初始化dp数组
        f[0] = 0;
        g[n-1] = 0;
        for(int i = 1; i < n;i++)
        {
            f[i] = f[i-1] + nums[i-1];
            g[n-1-i] = g[n-i] + nums[n-i];
        }

        //判断
        for(int i = 0; i < n;i++)
        {
            if(f[i] == g[i])
                return i;
        }
        return -1;
    }
};

题目4: 除自身以外数组的乘积

"前缀和"的思路和上一题几乎一模一样, 只是前缀和变成了前缀积, 注意把 f[0] 和 g[n-1] 设置为1:

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) 
    {
        int n = nums.size();
        vector<int> f(n), g(n), answer(n);

        //初始化dp数组
        f[0] = 1;
        g[n-1] = 1;
        for(int i = 1; i < n;i++)
        {
            f[i] = f[i-1] * nums[i-1];
            g[n-1-i] = g[n-i]* nums[n-i];
        }
        for(int i = 0; i < n; i++)
            answer[i] = f[i]*g[i];

        return answer;
    }
};

 前缀和思路实际上是一种空间换时间的做法, 此题时间复杂度和空间复杂度都是O(N)

优化一下上面的前缀积, 改成空间复杂度为O(1):

由于输出数组不算在空间复杂度内, 那么我们可以将用answer数组计算出前缀积, 然后再动态构造 后缀积得到结果, 最后的answer[i]从后向前计算, 即可很巧妙的利用到上次存放的answer[i]前缀积:

class Solution {
public:
    vector<int> productExceptSelf(vector<int>& nums) 
    {
        int n = nums.size();
        vector<int> answer(n);

        //初始化dp数组
        answer[0] = 1;
        for(int i = 1; i < n;i++)
            answer[i] = answer[i-1] * nums[i-1];//此时answer[i]还是前缀积

        int R = 1;//动态更新后缀积
        for(int i = n-1; i >= 0; i--)
        {
            answer[i] = answer[i] * R;//最终结果,answer[i]为前缀积*后缀积
            R *= nums[i];//后缀积动态更新
        }

        return answer;
    }
};

题目5: 和为 k 的子数组（medium）

此时是连续的子数组, 看上去可以用滑动窗口解决, 但是不能, 因为 数据范围中有0和负数, 滑动窗口滑到和为k时不能停下来, 还要继续往后滑, 因为不确定后面有没有负数和0, 不具备单调性, 所以不能用滑动窗口

 前缀和+哈希表:

当下标为i时, 要找一段和为K的子数组, 只需要在[0, i-1]区间内找, 找有多少个前缀和等于sum[i] - k的子数组, 怎么去找呢?

每次求出sum[i]之后然后遍历一遍0~i-1, 这样时间复杂度还是O(n^2+n), 而暴力解法时间复杂度是O(n^2), 所以不能这样去找.

用一个哈希表去存放 前缀和等于sum[i]-k 出现的次数, 这样每次只需要 +=sum[i-k] 对应的值即可, 因为默认值是0.

注意: 

1.前缀和加入哈希表的时机? 

    在计算sum[i]之前, 只保存 [0,i-1] 位置的前缀和.

2. 如果 sum[i] 等于k, 那么它本身就是一个要找的子数组, 在哈希表中所对应的应该是sum[i]-k=0, 但是这个0相当于在[0,-1]区间内, 并不会被加入进哈希表, 所以在哈希表初始化时要令hash[0]=1, 避免这种情况被遗漏

3. 我们不用真的创建一个前缀和数组, 用一个sum变量去标记前一个前缀和即可.

class Solution {
public:
    int subarraySum(vector<int>& nums, int k) 
    {
        unordered_map<int,int> hash;
        hash[0] = 1;

        int sum = 0, ret = 0;
        for(auto e: nums)
        {
            sum += e;
            ret += hash[sum-k];
            hash[sum]++;
        }
        return ret;
    }
};

题目6: 和可被 K 整除的子数组

前置知识: 

1. 同余定理:
如果 (a - b) % n == 0 , 那么我们可以得到一个结论:  a % n == b % n 。用文字叙述就是, 如果两个数相减的差能被 n 整除, 那么这两个数对 n 取模的结果相同.

2. c++ 中负数取模的结果, 以及如何修正「负数取模」的结果
        a. c++ 中关于负数的取模运算, 因为c++整除是向零取整(余数符号和被除数一样), 而不是向下取整(余数符号和除数相等), 所以我们来推导一下上面的结论, 因为(a - b) % n == 0 , 所以a = b+kn,  两边同时取余即可得到上面的结论, 但是这里两边同时取余是有条件的, 假如以c++的取余规则, a是正数, b是负数, 这就导致a是向下取整(实际是向零取整, 但是方向都相同)得到的余数, 而b是向上取整(实际是向零取整, 方向是向上取整)得到的余数, 取余是不等价的, 所以需要把负数的取余操作进行修正, 以(a % n + n) % n 的形式输出保证为正.

了解了这些再来看这道题:假如一段区间和能被k整除, 也就是(sum-k)%k = 0, 根据同余定理, sum%k = x%k, 所以对于每一个sum, 只需找去找[0, i-1]区间里前缀和(x) = sum%k的次数即可, 又回归到了上一道题, 思路同上一道题, 注意当k==sum的时候, 需要找0, 所以hash[0]要初始化为1:

class Solution {
public:
    int subarraysDivByK(vector<int>& nums, int k) 
    {
        unordered_map<int,int> hash;
        hash[0] = 1;
        
        int sum = 0, ret = 0;
        for(auto e : nums)
        {
            sum += e;
            ret += hash[(sum%k+k)%k];
            hash[(sum%k+k)%k]++;
        }
        return ret;
    }
};

题目7: 连续数组（medium）

 此题如果直接去统计区间0和1的个数会发现很困难, 可以转化一下, 把所有的0看作-1, 含有相同数量的0和1的子数组的和就为0, 问题转化为求 和为0的子数组, 和之前的那道题类似.

前缀和 + 哈希:

1. 哈希表中存什么?

这题不是求和为k的子数组的数目, 而是求区间长度, 所以哈希表应该存 hash<前缀和, 下标>

2. 什么时候存入哈希表?

和之前一样, 判断完再存入 

3. 出现重复的<sum,i>, 该如何处理?

因为是从前向后遍历数组的, 所以下标i越小, 求出的区间就越长, 所以只存入第一个前缀和为sum的i即可. 

4. 区间长度怎么算?

如图, i-j 即为区间长度

5. hash[0]该如何初始化?

同之前一样, 可能当前的sum和就为0, 要去区间 [0,-1] 寻找0, 所以hash[0] = - 1

class Solution {
public:
    int findMaxLength(vector<int>& nums)
    {
        unordered_map<int, int> hash;
        hash[0] = -1; //默认有一个前缀和为0的情况

        int sum = 0, ret = 0, n = nums.size();
        for(int i = 0; i < n; i++)
        {
            sum += nums[i] == 0 ? -1 : 1;//计算当前前缀和
            if(hash.count(sum)) 
                ret = max(ret,i-hash[sum]);
            else //找不到sum才存下标
                hash[sum] = i;
        }
        return ret;
    }
};

题目8 : 矩阵区域和（medium）

题目的描述是让我们求出一个矩阵, 矩阵里每个元素answer[i][j] 是 mat[i][j]  周围k格内元素的和, 如果越界则以边界为界限.

解法: 利用二维前缀和

a. dp[i][j]表示: dp[i][j] = A+B  + A+C + D - A = dp[i-1][j] + dp[i][j-1] + dp[i-1][j] + arr[i][j] - dp[i-1][j-1]

b.使用这个前缀和矩阵 

所以只要我们给定两个点x1,y1 和 x2,y2, 对应矩阵的和可以求出来,  所以对于每一个answer[i][j], 我们只需要确定好x1,y1,x2,y2即可, 由题意, x1 = i-k, y1 = j-k, x2 = i+k, y2=j+k,  但是还要考虑越界情况, 所以x1 = max(i-k,0),  y1 = max(j-k,0), x2 = min(i+k, n-1), y2 = min(j+k, m-1)

下标的对应关系:

此题大体思路是这样, 但是注意我们原题中给的矩阵mat是下标从0开始的, 也就是说对应的dp[i][j]如果在边界上初始化会出现越界访问, 所以我们应该给dp数组开辟一个n+1*m+1大小的空间, 其中第0行第0列全部初始化为0, 方便dp[i][j]的计算, 与之对应的, 初始化公式也要进行修改:

dp里用到mat就要减1: 

 ans里用到dp就要加1, 因为ans的下标是对应着mat的下标:

class Solution {
public:
    vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int k) 
    {
        int n = mat.size(), m = mat[0].size();
        vector<vector<int>> dp(n+1,vector<int>(m+1));//n+1 * m+1

        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= m; j++)
            {
                dp[i][j] = dp[i][j-1] + dp[i-1][j] + mat[i-1][j-1] - dp[i-1][j-1];
            }
        }

        vector<vector<int>> ret(n, vector<int>(m));//n * m
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < m; j++)
            {
                int x1 = max(0,i-k)+1, y1 = max(0,j-k)+1;
                int x2 = min(n-1,i+k)+1, y2 = min(m-1,j+k)+1; 
                ret[i][j] = dp[x2][y2] - dp[x1-1][y2] - dp[x2][y1-1] + dp[x1-1][y1-1];
            }
        }
        return ret;
    }
};

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/466753.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

ConcurrentHashMap的相关介绍和使用

ConcurrentHashMap的相关介绍和使用

概述 ConcurrentHashMap是Java中提供的一个关于线程安全的哈希表实现&#xff0c;他是java.util.concurrent包的一部分&#xff0c;允许多个读操作并发进行&#xff0c;提高了并发环境下的性能。ConcurrentHashMap实现了ConcurrentMap接口&#xff0c;故而他也有ConcurrentMap…
阅读更多...
2024.3.18

2024.3.18

1、试编程 封装一个动物的基类&#xff0c;类中有私有成员:姓名&#xff0c;颜色&#xff0c;指针成员年纪再封装一个狗这样类&#xff0c;共有继承于动物类&#xff0c;自己拓展的私有成员有:指针成员:腿的个数(整型intcount)&#xff0c;共有成员函数:会叫:void speak() 要求…
阅读更多...
ardupilot开发 --- 机载(边缘)计算机-VISP 篇

ardupilot开发 --- 机载(边缘)计算机-VISP 篇

啊啊啊我的妻王氏宝钏 1. 一些概念 1. 一些概念 什么是VISP VISP即Visual servoing platform. Allows to control a robot equipped with a camera from measures extracted from the images.实现无人机飞行控制&#xff0c;机器人运动控制。实现实时目标检测。实现实时位姿估…
阅读更多...
SpringCloud Sleuth 分布式请求链路跟踪

SpringCloud Sleuth 分布式请求链路跟踪

一、前言 接下来是开展一系列的 SpringCloud 的学习之旅&#xff0c;从传统的模块之间调用&#xff0c;一步步的升级为 SpringCloud 模块之间的调用&#xff0c;此篇文章为第十篇&#xff0c;即介绍 Sleuth 分布式请求链路跟踪。 二、概述 2.1 出现的原因 在微服务框架中&…
阅读更多...
什么是IoT物联网平台？

什么是IoT物联网平台？

在数字化浪潮的席卷下&#xff0c;物联网&#xff08;IoT&#xff09;技术逐渐渗透到我们生活的方方面面&#xff0c;从智能家居到智慧城市&#xff0c;从工业自动化到智能农业&#xff0c;IoT正以其独特的魅力改变着世界。然而&#xff0c;当我们谈论IoT时&#xff0c;我们究竟…
阅读更多...
maven一点通

maven一点通

1.maven简介 Maven是一个基于Java的工程构建工具&#xff0c;用于管理和构建项目的依赖关系。它提供了一种标准的项目结构和一组约定&#xff0c;使得项目的开发、构建、部署和文档化更加容易和可靠。 Maven的主要功能包括&#xff1a; 依赖管理&#xff1a;Maven可以自动下载…
阅读更多...
elementui el-table表格自动循环滚动【超详细图解】

elementui el-table表格自动循环滚动【超详细图解】

效果如图 1. 当表格内容超出时&#xff0c;自动滚动&#xff0c;滚动到最后一条之后在从头滚动。 2. 鼠标移入表格中&#xff0c;停止滚动&#xff1b;移出后&#xff0c;继续滚动。 直接贴代码 <template><div><div class"app-container"><e…
阅读更多...
蓝桥杯前端Web赛道-输入搜索联想

蓝桥杯前端Web赛道-输入搜索联想

蓝桥杯前端Web赛道-输入搜索联想 题目链接&#xff1a;1.输入搜索联想 - 蓝桥云课 (lanqiao.cn) 题目要求&#xff1a; 题目中还包含effect.gif 更详细的说明了需求 那么观察这道题需要做两件事情 把表头的每一个字母进行大写进行模糊查询 这里我们会用到几个js函数&#…
阅读更多...
matlab FR共轭梯度法求解无约束问题

matlab FR共轭梯度法求解无约束问题

1、内容简介 略 75-可以交流、咨询、答疑 matlab FR共轭梯度法求解无约束问题 一维搜索 黄金搜索到单峰&#xff0c;单变量最小值 2、内容说明 略 Fletcher-Reeves共轭梯度法&#xff0c;简称FR法。 共轭梯度法的基本思想是把共轭性与最速下降方法相结合&#xff0c;利用…
阅读更多...
rt-thread之通讯协议modbus软件包的使用记录(lwip+modbus组合)

rt-thread之通讯协议modbus软件包的使用记录(lwip+modbus组合)

前言 使用freemodbus软件包使用网口通讯(sallwip)ip地址使用dhcp动态获取 软件包 相关宏定义 /*-----------------------------------------NET 宏定义-------------------------------------------*/#define RT_USING_SAL #define SAL_INTERNET_CHECK /* Docking with prot…
阅读更多...
mysqlcheck 数据完整性检查与修复

mysqlcheck 数据完整性检查与修复

目录 mysqlcheck 命令文档 描述 选项 参数 示例 mysqlcheck 命令文档 mysqlcheck 是MySQL提供的一个工具&#xff0c;用于检查、修复、优化和分析数据库和表的健康状态。你可以使用它来确保数据库表的完整性和性能。 mysqlcheck [options] db_name [tbl_name ...]mysqlch…
阅读更多...
德迅蜂巢（容器安全）全面出击

德迅蜂巢（容器安全）全面出击

随着云计算的发展&#xff0c;以容器和微服务为代表的云原生技术&#xff0c;受到了人们的广泛关注&#xff0c;德迅云安全德迅蜂巢&#xff08;容器安全&#xff09;是企业容器运行时和容器编排的首要选择。然而&#xff0c;在应用容器过程中&#xff0c;大多数企业都遇到过不…
阅读更多...
分数相加减（C语言）

分数相加减（C语言）

一、流程图&#xff1b; 二、源代码&#xff1b; # define _CRT_SECURE_NO_WARNINGS # include <stdio.h>int main() {//初始化变量值&#xff1b;int fenmu 2;int result 1;int fuhao 1;//执行循环&#xff1b;while (fenmu < 100){//运算&#xff1b;fuhao (-1…
阅读更多...
TSINGSEE青犀AI智能分析网关V4酿酒厂安全挂网AI检测算法

TSINGSEE青犀AI智能分析网关V4酿酒厂安全挂网AI检测算法

在酿酒行业中&#xff0c;安全生产一直是企业经营中至关重要的一环。为了确保酒厂生产过程中的安全&#xff0c;TSINGSEE青犀AI智能分析网关V4的安全挂网AI检测算法发挥了重要作用。 TSINGSEE青犀AI智能分析网关V4的安全挂网检测算法是针对酒厂里酒窖挂网行为进行智能检测与识…
阅读更多...
[java基础揉碎]Object类详解

[java基础揉碎]Object类详解

目录 equals方法: hashCode: toString: finalize: equals方法: 和equals对比 1.: 既可以判断基本类型&#xff0c;又可以判断引用类型 2.: 如果判断基本类型&#xff0c;判断的是值是否相等。示例: int i10; double d10.0; 3.:如果判断引用类型&#xff0c;判断的是地址是…
阅读更多...
SQLiteC/C++接口详细介绍sqlite3_stmt类简介

SQLiteC/C++接口详细介绍sqlite3_stmt类简介

返回&#xff1a;SQLite—系列文章目录 上一篇&#xff1a;SQLiteC/C接口详细介绍之sqlite3类&#xff08;十八&#xff09; 下一篇&#xff1a;SQLiteC/C接口详细介绍sqlite3_stmt类&#xff08;一&#xff09; 预准备语句对象 typedef struct sqlite3_stmt sqlite3_stmt…
阅读更多...
关于安卓USB开发（一）文件复制，文件夹创建

关于安卓USB开发（一）文件复制，文件夹创建

背景 在安卓应用中&#xff0c;把某个文件&#xff0c;复制到插入的U盘中 开发环境 win10,jdk8,as4 测试机型 红米Note11&#xff0c;android13 源码问题 文末将会提供博主整合好的源码项目连接&#xff0c;以供学习交流 注意 本次实战&#xff0c;u盘格式是fat32&…
阅读更多...
弗洛伊德-华沙算法求任意两点之间的最短路径算法

弗洛伊德-华沙算法求任意两点之间的最短路径算法

对于弗洛伊德-华沙算法首先是要假设研究的图中是不包含有负边的&#xff0c;对于所给的图中的任意亮点v1&#xff0c;vm&#xff0c;假设两点之间存在一条连通路径&#xff0c;对于该路径中去掉头和尾节点&#xff0c;也就是v1&#xff0c;vm&#xff0c;剩下的节点也就称之为这…
阅读更多...
【MySQL】2. 数据库基础

【MySQL】2. 数据库基础

1. 数据库基础&#xff08;重点&#xff09; 1.1 什么是数据库 存储数据用文件就可以了&#xff0c;为什么还要弄个数据库? 文件保存数据有以下几个缺点&#xff1a; 文件的安全性问题 文件不利于数据查询和管理 文件不利于存储海量数据 文件在程序中控制不方便 数据库存储介…
阅读更多...
告别紧张，轻松应对！公众演讲的实用技巧

告别紧张，轻松应对！公众演讲的实用技巧

告别紧张&#xff0c;轻松应对&#xff01;公众演讲的实用技巧 公众演讲&#xff0c;对于许多人来说&#xff0c;是一项充满挑战的任务。面对众多的听众&#xff0c;紧张情绪往往难以避免&#xff0c;甚至可能影响到演讲的效果。然而&#xff0c;通过掌握一些实用的技巧&#…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站