【LeetCode】递归精选8题——基础递归、链表递归

news2024/10/7 6:44:33

目录

基础递归问题：

1. 斐波那契数（简单）

1.1 递归求解

1.2 迭代求解

2. 爬楼梯（简单）

2.1 递归求解

2.2 迭代求解

3. 汉诺塔问题（简单）

3.1 递归求解

4. Pow(x, n)（中等）

4.1 递归求解

4.2 迭代求解

链表递归问题：

1. 合并两个有序链表（简单）

1.1 递归求解

1.2 迭代求解

2. 反转链表（简单）

2.1 递归求解

2.2 迭代求解

3. 两两交换链表中的节点（中等）

3.1 递归求解

3.2 迭代求解

4. 合并 K 个升序链表（困难）

4.1 递归求解

4.2 迭代求解

在解决一个规模为n的问题时，如果满足以下条件，我们可以使用递归来解决：

  1. 问题可以被划分为规模更小的子问题，并且这些子问题具有与原问题相同的解决方法。
  2. 当我们知道规模更小的子问题（规模为n-1）的解时，我们可以直接计算出规模为n的问题的解。
  3. 存在一种简单情况，或者说当问题的规模足够小时，我们可以直接求解问题。

一般的递归求解过程如下：

  1. 验证是否满足简单情况。
  2. 假设较小规模的问题已经解决，解决当前问题。

上述步骤可以通过数学归纳法来证明。

基础递归问题：

1. 斐波那契数（简单）

1.1 递归求解

重复的子问题——函数头设计

int fib(int n)

子问题在做什么——函数体设计

fib(n - 1) + fib(n - 2)

递归出口

fib(0) = 0

fib(1) = 1

class Solution {
public:
    int fib(int n) {
        if (n <= 1)
            return n;

        return fib(n - 1) + fib(n - 2);
    }
};

1.2 迭代求解

递归算法在计算时存在着大量的重复计算，执行效率低，n值稍大时非常耗费时间。斐波那契数列用迭代算法更高效。

class Solution {
public:
    int fib(int n) {
        if (n <= 1)
            return n;

        int a = 0;
        int b = 1;
        int c = 0;
        for (int i = 2; i <= n; i++)
        {
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }
};

2. 爬楼梯（简单）

2.1 递归求解

重复的子问题——函数头设计

int climbStairs(int n)

子问题在做什么——函数体设计

如果先走1级台阶，还剩n - 1级台阶，有climbStairs(n - 1)种走法；如果先走2级台阶，还剩n - 2级台阶，有climbStairs(n - 2)种走法。一共的走法：

climbStairs(n - 1) + climbStairs(n - 2)

递归出口

当n == 1时，只有1种走法。

当n == 2时，可以一次走1级台阶，走两次；也可以一次走2级台阶，走一次。所以一共有2种走法。

climbStairs(1) = 1

climbStairs(2) = 2

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 2)
            return n;

        return climbStairs(n - 1) + climbStairs(n - 2);
    }
};

（But这题在LeetCode上用递归会超时o(´^｀)o）

可以看出爬楼梯是斐波那契数的应用。

2.2 迭代求解

class Solution {
public:
    int climbStairs(int n) {
        if (n <= 2)
            return n;

        int a = 1;
        int b = 2;
        int c = 0;
        for (int i = 3; i <= n; i++)
        {
            c = a + b;
            a = b;
            b = c;
        }
        return c;
    }
};

3. 汉诺塔问题（简单）

3.1 递归求解

​​

重复的子问题——函数头设计

有三根柱子A、B、C，A柱上有n个盘子，将所有盘子从A柱经B柱全部移到C柱上。

void dfs(int n, vector<int>& A, vector<int>& B, vector<int>& C)

子问题在做什么——函数体设计

该问题可划分成2个自相似问题和1次移动：

  1. 将n-1个盘子从A柱经C柱全部移到B柱上：dfs(n - 1, A, C, B);
  2. 将第n个盘子从A柱移到C柱上：C.push_back(A.back());    A.pop_back();
  3. 将n-1个盘子从B柱经A柱全部移到C柱上：dfs(n - 1, B, A, C);

递归出口

当A柱只剩1个盘子时（即n == 1时），将其从A柱移到C柱上。

C.push_back(A.back());

A.pop_back();

class Solution {
public:
    void hanota(vector<int>& A, vector<int>& B, vector<int>& C) {
        if (A.empty())
            return;
        dfs(A.size(), A, B, C);
    }

private:
    // n个盘子从A经B移到C
    void dfs(int n, vector<int>& A, vector<int>& B, vector<int>& C)
    {
        if (n == 1)
        {
            C.push_back(A.back());
            A.pop_back();
            return;
        }
        dfs(n - 1, A, C, B);
        C.push_back(A.back());
        A.pop_back();
        dfs(n - 1, B, A, C);
    }
};

4. Pow(x, n)（中等）

4.1 递归求解

快速幂算法的核心思想就是每一步都把指数分成两半，而相应的底数做平方运算。这样不仅能把非常大的指数给不断变小，所需要执行的循环次数也变小，而最后表示的结果却一直不会变。其时间复杂度为 O(log₂N)， 与朴素的O(N)相比效率有了极大的提高。

x^{n} = (x^{2})^{\frac{n}{2}}

如果n是负数，x^{n} = \frac{1}{x^{-n}}，所以只需考虑n是自然数的情况：

假设n/2向下取整，则需要分奇偶两种情况：

  • 当n是偶数时，x^{n} = (x^{2})^{\frac{n}{2}}
  • 当n是奇数时，x^{n} = (x^{2})^{\frac{n}{2}} * x

重复的子问题——函数头设计

double dfs(double x, long long n)    n是非负数

用long long接收n，防止-2^31转换成2^31越界。

子问题在做什么——函数体设计

判断n的奇偶性，带入不同的公式。

偶数：return dfs(x * x, n / 2);    偶数：return dfs(x * x, n / 2) * x;

递归出口

当 n == 0 时，任何数的0次幂都等于1，返回1.0

class Solution {
public:
    double myPow(double x, int n) {
        return n < 0 ? 1.0 / dfs(x, -(long long)n) : dfs(x, n);
    }

private:
    double dfs(double x, long long n)
    {
        if (n == 0)
            return 1.0;

        return n % 2 == 0 ? dfs(x * x, n / 2) : dfs(x * x, n / 2) * x;
    }
};

4.2 迭代求解

二进制角度的快速幂算法：

假设n的二进制为bk .….. b2 b1 b0，则：

n = b_{0} * 2^{0} + b_{1} * 2^{1} + b_{2} * 2^{2} + ... + b_{k} * 2^{k}

x^{n} = x^{b_{0} * 2^{0} + b_{1} * 2^{1} + b_{2} * 2^{2} + ... + b_{k} * 2^{k}} = x^{2^{0} * b_{0}} * x^{2^{1} * b_{1}} * x^{2^{2} * b_{2}} * ... * x^{2^{k} * b_{k}}

当bi == 0时，x^{2^{i} * b_{i}} = 1

当bi == 1时，x^{2^{i} * b_{i}} = x^{2^{i}}

我们从x开始不断地进行平方，如果bi == 1，就将对应的x^{2^{i}}计入答案。

举个例子：

计算x^{11}：ans初始值为1.0，11的二进制表示为1011，

b_{0}=1，将x^{1}计入答案，

b_{1}=1，将x^{2}计入答案，

b_{2}=0，将x^{4}不计入答案，

b_{3}=1，将x^{8}计入答案，

即x^{11}=x^{1}*x^{2}*x^{8}

class Solution {
public:
    double myPow(double x, int n) {
        return n < 0 ? 1.0 / quickPower(x, -(long long)n) : quickPower(x, n);
    }

private:
    double quickPower(double x, long long n)
    {
        double ans = 1.0;
        while (n)
        {
            // 如果最低位为1，将对应的x的幂值计入答案
            if ((n & 1) == 1)
            {
                ans *= x;
            }
            x *= x;
            // 舍弃n的二进制的最低位，这样每次只要判断最低位即可
            n >>= 1;
        }
        return ans;
    }
};

链表递归问题：

1. 合并两个有序链表（简单）

1.1 递归求解

​​

​​

重复的子问题——函数头设计

ListNode* mergeTwoLists(ListNode* list1, ListNode* list2)

子问题在做什么——函数体设计

选择两个链表的头节点中值较小的那一个作为最终合并的新链表的头节点，然后将剩下的链表交给递归函数去处理。

  1. 比较list1->val和list2->val的大小（假设list1->val较小）
  2. list1->next = mergeTwoLists(list1->next, list2);
  3. return list1;

递归出口

当某一个链表为空的时候，返回另外一个链表。

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        if (list1 == nullptr)
            return list2;
        if (list2 == nullptr)
            return list1;

        if (list1->val < list2->val)
        {
            list1->next = mergeTwoLists(list1->next, list2);
            return list1;
        }
        else
        {
            list2->next = mergeTwoLists(list1, list2->next);
            return list2;
        }
    }
};

1.2 迭代求解

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode* preHead = new ListNode; // 哨兵节点
        ListNode* tail = preHead;

        // 取小的尾插
        while (list1 && list2)
        {
            if (list1->val < list2->val)
            {
                tail->next = list1;
                tail = tail->next;
                list1 = list1->next;
            }
            else
            {
                tail->next = list2;
                tail = tail->next;
                list2 = list2->next;
            }
        }

        if (list1)
        {
            tail->next = list1;
        }
        if (list2)
        {
            tail->next = list2;
        }

        return preHead->next;
    }
};

2. 反转链表（简单）

2.1 递归求解

​​

重复的子问题——函数头设计

ListNode* reverseList(ListNode* head)

子问题在做什么——函数体设计

将当前结点之后的链表反转，然后把当前结点添加到反转后的链表后面即可，返回反转后的头节点。

  1. ListNode* newHead = reverseList(head->next);
  2. head->next->next = head;    head->next = nullptr;
  3. return newHead;

递归出口

当前结点为空或者当前只有一个结点的时候，不用反转，直接返回。

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        if (head == nullptr || head->next == nullptr)
            return head;

        ListNode* newHead = reverseList(head->next);
        head->next->next = head;
        head->next = nullptr;
        return newHead;
    }
};

2.2 迭代求解

​​

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* pre = nullptr;
        ListNode* cur = head;
        while (cur)
        {
            ListNode* next = cur->next;
            cur->next = pre;
            pre = cur;
            cur = next;
        }

        return pre;
    }
};

3. 两两交换链表中的节点（中等）

3.1 递归求解

​​

重复的子问题——函数头设计

ListNode* swapPairs(ListNode* head)

子问题在做什么——函数体设计

将从第三个节点开始的链表两两交换节点，然后再把前两个节点交换一下，链接上刚才处理过的链表，并返回。

  1. ListNode* tmp = swapPairs(head->next->next);
  2. ListNode* newHead = head->next;    newHead->next = head;
  3. head->next = tmp;
  4. return newHead;

递归出口

当前结点为空或者当前只有一个结点的时候，不用两两交换，直接返回。

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        if (head == nullptr || head->next == nullptr)
            return head;

        ListNode* tmp = swapPairs(head->next->next);
        ListNode* newHead = head->next;
        newHead->next = head;
        head->next = tmp;
        return newHead;
    }
};

3.2 迭代求解

​​

class Solution {
public:
    ListNode* swapPairs(ListNode* head) {
        ListNode* preHead = new ListNode(0, head); // 哨兵节点
        ListNode* cur = preHead;
        // cur后面的两个节点交换
        while (cur->next && cur->next->next)
        {
            ListNode* node1 = cur->next;
            ListNode* node2 = cur->next->next;
            cur->next = node2;
            node1->next = node2->next;
            node2->next = node1;
            cur = node1;
        }
        return preHead->next;
    }
};

4. 合并 K 个升序链表（困难）

4.1 递归求解

分治的思想，类似归并排序：

  1. 划分两个子区间

  2. 分别对两个子区间的链表进行合并，形成两个有序链表

  3. 合并两个有序链表

重复的子问题——函数头设计

ListNode* merge(vector<ListNode*>& lists, int begin, int end)

子问题在做什么——函数体设计

  1. 划分两个子区间：int mid = (begin + end) / 2;
  2. 递归合并两个子区间：
    ListNode* l1 = merge(lists, begin, mid);
    ListNode* l2 = merge(lists, mid + 1, end);
  3. 合并两个有序链表：return mergeTowList(l1, l2);

递归出口

当区间只有一个链表时，不合并。另外，当题目给出空链表时，不合并。

class Solution {
public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        return merge(lists, 0, lists.size() - 1);
    }

private:
    ListNode* merge(vector<ListNode*>& lists, int begin, int end)
    {
        if (begin > end)
            return nullptr;
        if (begin == end)
            return lists[begin];

        int mid = (begin + end) / 2;
        ListNode* l1 = merge(lists, begin, mid);
        ListNode* l2 = merge(lists, mid + 1, end);
        return mergeTwoLists(l1, l2);
    }
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2)
    {
        ListNode* preHead = new ListNode; // 哨兵节点
        ListNode* tail = preHead;

        // 取小的尾插
        while (list1 && list2)
        {
            if (list1->val < list2->val)
            {
                tail->next = list1;
                tail = tail->next;
                list1 = list1->next;
            }
            else
            {
                tail->next = list2;
                tail = tail->next;
                list2 = list2->next;
            }
        }

        if (list1)
        {
            tail->next = list1;
        }
        if (list2)
        {
            tail->next = list2;
        }

        return preHead->next;
    }
};

4.2 迭代求解

和“合并两个有序链表”类似，就是取小的尾插。怎么判断K个链表未合并的头节点中最小的那个？利用堆这个数据结构即可。把K个链表未合并的头节点放进一个小根堆，堆顶就是最小的那个。

class Solution {
    struct cmp
    {
        bool operator()(ListNode* n1, ListNode* n2)
        {
            return n1->val > n2->val;
        }
    };

public:
    ListNode* mergeKLists(vector<ListNode*>& lists) {
        // 创建小根堆
        priority_queue<ListNode*, vector<ListNode*>, cmp> heap;
        // 将所有头节点放进小根堆
        for (auto& l : lists)
        {
            if (l)
            {
                heap.push(l);
            }
        }
        // 合并链表
        ListNode* preHead = new ListNode; // 哨兵节点
        ListNode* tail = preHead;
        while (!heap.empty())
        {
            // 取堆顶节点尾插
            tail->next = heap.top();
            heap.pop();
            tail = tail->next;
            // 将刚才合并的节点的下一个节点补充进堆
            if (tail->next)
            {
                heap.push(tail->next);
            }
        }
        return preHead->next;
    }
};

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

（每日持续更新）信息系统项目管理（第四版）（高级项目管理）考试重点整理第11章 项目成本管理（一）

（每日持续更新）信息系统项目管理（第四版）（高级项目管理）考试重点整理第11章 项目成本管理（一）

博主2023年11月通过了信息系统项目管理的考试&#xff0c;考试过程中发现考试的内容全部是教材中的内容&#xff0c;非常符合我学习的思路&#xff0c;因此博主想通过该平台把自己学习过程中的经验和教材博主认为重要的知识点分享给大家&#xff0c;希望更多的人能够通过考试&a…
阅读更多...
消息队列-RabbitMQ：workQueues—工作队列、消息应答机制、RabbitMQ 持久化、不公平分发（能者多劳）

消息队列-RabbitMQ：workQueues—工作队列、消息应答机制、RabbitMQ 持久化、不公平分发（能者多劳）

4、Work Queues Work Queues— 工作队列 (又称任务队列) 的主要思想是避免立即执行资源密集型任务&#xff0c;而不得不等待它完成。我们把任务封装为消息并将其发送到队列&#xff0c;在后台运行的工作进程将弹出任务并最终执行作业。当有多个工作线程时&#xff0c;这些工作…
阅读更多...
python51-Python流程控制if分支之不要随意缩进

python51-Python流程控制if分支之不要随意缩进

需要说明的是，虽然Python 语法允许代码块随意缩进N个空格，但同一个代码块内的代码必须保持相同的缩进，不能一会缩进2个空格，一会缩进4个空格。例如如下代码。 上面程序中第二条print语句缩进了5个空格，在这样的情况下，Python解释器认为这条语句与前一条语句(缩进了4个空格…
阅读更多...
用html编写的招聘简历

用html编写的招聘简历

用html编写的招聘简历 相关代码 <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><title>Document</tit…
阅读更多...
没有代码签名证书会怎么样？

没有代码签名证书会怎么样？

随着Windows的SmartScreen功能的普及&#xff0c;如果一个软件发布的时候没有通过代码签名证书进行数字签名&#xff0c;那这个软件从发布&#xff0c;下载&#xff0c;安装&#xff0c;运行等&#xff0c;基本都会遭到系统的风险警告&#xff0c;运行拦截。其目的在于警示用户…
阅读更多...
MapGIS 10.6 Pro前端开发低代码，快速构建WebGIS应用

MapGIS 10.6 Pro前端开发低代码，快速构建WebGIS应用

随着实景三维、CIM、数字孪生等的快速发展&#xff0c;相关应用开发需求的市场增长对企业IT交付能力的要求越来越高&#xff0c;为了确保质量并实现提效降本&#xff0c;并让专业开发者更加专注于更具有价值和创新型的工作&#xff0c;低代码开发技术成为大家的优先选择。 为了…
阅读更多...
工作入职必备：一寸照片尺寸要求及自拍换底色方法

工作入职必备：一寸照片尺寸要求及自拍换底色方法

踏入职场的第一步&#xff0c;往往从一张小小的一寸照片开始。这张看似不起眼的照片&#xff0c;却是你给新同事、新领导的第一印象。今天&#xff0c;我们就来深入探讨一寸照片的尺寸要求&#xff0c;以及如何巧妙地通过自拍来更换背景颜色&#xff0c;让你的入职照片既专业又…
阅读更多...
【Java EE初阶二十一】关于http（二）

【Java EE初阶二十一】关于http（二）

2. 深入学习http 2.5 关于referer Referer 描述了当前页面是从哪个页面跳转来的&#xff0c;如果是直接在地址栏输入 url(或者点击收藏夹中的按钮) 都是没有 Referer。如下图所示&#xff1a; HTTP 最大的问题在于"明文传输”,明文传输就容易被第三方获取并篡改. …
阅读更多...
我国为分散染料（分散性染料）生产及出口大国 合成纤维领域为其主要需求端

我国为分散染料（分散性染料）生产及出口大国 合成纤维领域为其主要需求端

我国为分散染料&#xff08;分散性染料&#xff09;生产及出口大国 合成纤维领域为其主要需求端 分散染料又称分散性染料&#xff0c;指分子结构中不含水溶性基团的染料。与其他染料相比&#xff0c;分散染料具有耐光性好、色彩饱和度高、易于分散、绿色环保等优势&#xff0c;…
阅读更多...
探索未来-Sora

探索未来-Sora

AI如何将静态图像转化为动态、逼真的视频&#xff1f; OpenAI 的 Sora 通过时空片段&#xff08;以下统称片段&#xff09;的创新使用给出了答案。 Sora 展示与探讨 在快速发展的生成模型领域&#xff0c;OpenAI 的 Sora成为一个重要的里程碑&#xff0c;有望重塑我们对视频生…
阅读更多...
Python编程实验四：函数的使用

Python编程实验四：函数的使用

目录 一、实验目的与要求 二、实验内容 三、主要程序清单和程序运行结果 第1题 第2题 第3题 第4题 第5题 四、实验结果分析与体会 一、实验目的与要求 &#xff08;1&#xff09;通过本次实验&#xff0c;学生应掌握函数的定义与调用的基本语法&#xff0c;能根据需要…
阅读更多...
K8S的架构（1）

K8S的架构（1）

目录 一.k8s K8S有 master 和 worker node 两类节点&#xff1a; ​编辑 二.K8S创建Pod资源的工作流程 三.K8S资源对象 Pod&#xff1a;是K8S能够创建和管理的最小单位。 Pod控制器: 四.K8S资源配置信息 一.k8s kubernetes &#xff1a; Google旗下的容器跨主机编排…
阅读更多...
linux上安装bluesky的步骤

linux上安装bluesky的步骤

1、设备上安装的操作系统如下&#xff1a; orangepiorangepi5b:~$ lsb_release -a No LSB modules are available. Distributor ID: Ubuntu Description: Ubuntu 22.04.2 LTS Release: 22.04 Codename: jammy 2、在用户家目录下创建一个目录miniconda3目录&a…
阅读更多...
如何系统地自学Python？

如何系统地自学Python？

如何系统地自学Python&#xff1f; 如何系统地自学Python&#xff1f;1.了解编程基础2.学习Python基础语法3.学习Python库和框架4.练习编写代码5.参与开源项目6.加入Python社区7.利用资源学习8.制定学习计划9.持之以恒总结 如何系统地自学Python&#xff1f; 作为一个Python语…
阅读更多...
实现Slider 滑块组件标记动态变化

实现Slider 滑块组件标记动态变化

实现以上效果&#xff0c;下拉框、slider滑块、按钮都在同一行&#xff0c;设置flex布局后&#xff0c;发现silider滑块最右边的标记数字一直都如下竖着显示&#xff0c;后来通过给源组件的标记区.el-slider__marks-text增加一个宽度后解决该问题。 <template><div>…
阅读更多...
可视化大屏：一屏尽览生产数据，管理从未如此轻松！

可视化大屏：一屏尽览生产数据，管理从未如此轻松！

工厂管理者需要对生产过程进行全面的监控和管理。而可视化大屏作为一种新型的生产监控工具&#xff0c;已经被越来越多的企业所采用。本文将从可视化大屏的概念、特点以及在工厂生产中的应用等方面进行详细介绍。 煤炭化工生产大屏看板 一、可视化大屏的概念和特点 可视化大屏…
阅读更多...
js-Vue Router 中的方法,父A-子B-子C依次返回,无法返回到A,BC中形成循环跳转解决

js-Vue Router 中的方法,父A-子B-子C依次返回,无法返回到A,BC中形成循环跳转解决

1.常用的方法 在 Vue Router 中&#xff0c;有一些常用的方法用于实现路由导航和管理。以下是一些常见的 Vue Router 方法及其作用&#xff1a; push: router.push(location, onComplete, onAbort) 作用&#xff1a;向路由历史记录中添加一个新条目&#xff0c;并导航到指定的路…
阅读更多...
[嵌入式系统-32]：RT-Thread -17- 任务、进程、线程的区别

[嵌入式系统-32]：RT-Thread -17- 任务、进程、线程的区别

目录 一、基本概念澄清 1.1 任务 1.2 进程 1.3 线程 1.4 比较 1.5 任务VS进程 1.6 进程 VS 线程 1.7 任务 进程 线程 发展历史 任务&#xff08;Task&#xff09;&#xff1a; 进程&#xff08;Process&#xff09;&#xff1a; 线程&#xff08;Thread&#xff09;…
阅读更多...
Java使用企业邮箱发送预警邮件

Java使用企业邮箱发送预警邮件

前言&#xff1a;最近接到一个需求&#xff0c;需要根据所监控设备的信息&#xff0c;在出现问题时发送企业微信进行预警。 POM依赖 <!-- 邮件 --> <dependency><groupId>com.sun.mail</groupId><artifactId>jakarta.mail</artifactId>…
阅读更多...
电脑开机启动项在哪里设置？优化系统速度不是梦！

电脑开机启动项在哪里设置？优化系统速度不是梦！

电脑的开机启动项设置直接影响着系统启动的速度和性能&#xff0c;合理配置启动项可以提高系统的启动速度&#xff0c;同时确保开机时运行的程序符合个人需求。那么&#xff0c;电脑开机启动项在哪里设置呢&#xff1f;本文将详细介绍电脑开机启动项设置的三种方法&#xff0c;…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023