【LeetCode 笔记】DFS & BFS

已于 2022-06-02 12:17:18 修改
阅读量684 收藏
点赞数 1
分类专栏： 算法 LeetCode刷题 文章标签： 算法 dfs bfs
于 2022-04-26 15:15:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/kkm09/article/details/124428534
版权

电影院选座

记录一下最近的笔试题

在某区域中，找出连续空闲区域的最大范围

题目描述

看电影选座位，座位用m*n的二维矩阵表示，用1代表该座位已选，0代表未选。求选择出最大的相邻空座位个数（上下左右为相邻）。

示例一：
  • 输入：
4
7
1 0 0 1 0 0 0
1 0 0 0 0 1 1
0 0 0 1 0 0 0
1 1 0 1 1 0 0
  • 输出：
18
示例二：
  • 输入：
4
7
1 0 0 1 0 0 0
1 0 0 1 0 1 1
0 0 0 1 0 0 0
1 1 0 1 1 0 0
  • 输出：
9

解题思路

1. 递归

查找所有未访问过的坐标点，从某一点开始，递归遍历某点的上下左右，直到所有坐标点都访问过。

class Solution {
    public int maxContinuousVacantSeatsNum(int[][] nums, int m, int n) {
        if (m <= 0 || n <= 0) {
            return 0;
        }
        boolean[][] visited = new boolean[m][n];

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (nums[i][j] == 1) {
                    visited[i][j] = true;
                }
            }
        }

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                // 访问过的坐标点直接跳过
                if (visited[i][j]) {
                    continue;
                }
                int res = dfs(nums, m, n, i, j, visited);
                ans = Math.max(ans, res);
            }
        }
        return ans;
    }

    public int dfs(int[][] nums, int m, int n, int startX, int startY, boolean[][] visited) {
        if (startX >= m || startY >= n || startX < 0 || startY < 0 || visited[startX][startY]) {
            return 0;
        }
        visited[startX][startY] = true;
        return 1 + dfs(nums, m, n, startX + 1, startY, visited) + dfs(nums, m, n, startX - 1, startY, visited) + dfs(nums, m, n, startX, startY + 1, visited) + dfs(nums, m, n, startX, startY - 1, visited);
    }
}
2. BFS

使用队列记录压缩的二维坐标，这里注意矩阵坐标的对称性，要分为上、下三角矩阵来存储坐标信息。

class Solution {
    public int maxContinuousVacantSeatsNum(int[][] nums, int m, int n) {
        if (m <= 0 || n <= 0) {
            return 0;
        }
        boolean[][] visited = new boolean[m][n];

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (nums[i][j] == 1) {
                    visited[i][j] = true;
                }
            }
        }

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (visited[i][j]) {
                    continue;
                }
                int res = bfs(nums, m, n, i, j, visited);
                ans = Math.max(ans, res);
            }
        }
        return ans;
    }

    public int bfs(int[][] nums, int m, int n, int startX, int startY, boolean[][] visited) {
        // 主对角线下三角矩阵队列
        Queue<Integer> queue1 = new LinkedList<>();
        // 主对角线上三角矩阵队列
        Queue<Integer> queue2 = new LinkedList<>();
        int count = 0;
        if (startX >= startY) {
            queue1.offer(startX * n + startY);
        } else {
            queue2.offer(startX * n + startY);
        }
        while (!queue1.isEmpty() || !queue2.isEmpty()) {
            int dot = !queue1.isEmpty() ? queue1.poll() : queue2.poll();
            // 上三角矩阵和下三角矩阵，关于主对角线对称的部分，其压缩计算后的值相同，因此需要根据row和col的大小分别计算存取
            int row = dot / n, col = dot % n;
            if (row >= m || col >= n) {
                continue;
            }
            if (!visited[row][col]) {
                visited[row][col] = true;
                if (row >= col) {
                    queue1.offer(row * n + col);
                } else {
                    queue2.offer(row * n + col);
                }
                count++;
            }
            if (col < n - 1 && !visited[row][col + 1]) {
                visited[row][col + 1] = true;
                if (row >= col + 1) {
                    queue1.offer(row * n + col + 1);
                } else {
                    queue2.offer(row * n + col + 1);
                }
                count++;
            }
            if (col > 0 && !visited[row][col - 1]) {
                visited[row][col - 1] = true;
                if (row >= col - 1) {
                    queue1.offer(row * n + col - 1);
                } else {
                    queue2.offer(row * n + col - 1);
                }
                count++;
            }
            if (row < m - 1 && !visited[row + 1][col]) {
                visited[row + 1][col] = true;
                if (row + 1 >= col) {
                    queue1.offer((row + 1) * n + col);
                } else {
                    queue2.offer((row + 1) * n + col);
                }
                count++;
            }
            if (row > 0 && !visited[row - 1][col]) {
                visited[row - 1][col] = true;
                if (row - 1 >= col) {
                    queue1.offer((row - 1) * n + col);
                } else {
                    queue2.offer((row - 1) * n + col);
                }
                count++;
            }
        }
        return count;
    }
}

全部代码

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        // 输入次数
        int k = scanner.nextInt();
        for (int c = 0; c < k; c++) {
            int m = scanner.nextInt(), n = scanner.nextInt();
            int[][] nums = new int[m][n];
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++) {
                    nums[i][j] = scanner.nextInt();
                }
            }
            Main main = new Main();
            System.out.println(main.maxContinuousVacantSeatsNum(nums, m, n));
        }
    }

    private int ans = Integer.MIN_VALUE;

    public int maxContinuousVacantSeatsNum(int[][] nums, int m, int n) {
        if (m <= 0 || n <= 0) {
            return 0;
        }
        boolean[][] visited = new boolean[m][n];

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (nums[i][j] == 1) {
                    visited[i][j] = true;
                }
            }
        }

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (visited[i][j]) {
                    continue;
                }
                int res = dfs(nums, m, n, i, j, visited);
                ans = Math.max(ans, res);
            }
        }
        return ans;
    }

    public int dfs(int[][] nums, int m, int n, int startX, int startY, boolean[][] visited) {
        if (startX >= m || startY >= n || startX < 0 || startY < 0 || visited[startX][startY]) {
            return 0;
        }
        visited[startX][startY] = true;
        return 1 + dfs(nums, m, n, startX + 1, startY, visited) + dfs(nums, m, n, startX - 1, startY, visited) + dfs(nums, m, n, startX, startY + 1, visited) + dfs(nums, m, n, startX, startY - 1, visited);
    }

    public int bfs(int[][] nums, int m, int n, int startX, int startY, boolean[][] visited) {
        // 主对角线下三角矩阵队列
        Queue<Integer> queue1 = new LinkedList<>();
        // 主对角线上三角矩阵队列
        Queue<Integer> queue2 = new LinkedList<>();
        int count = 0;
        if (startX >= startY) {
            queue1.offer(startX * n + startY);
        } else {
            queue2.offer(startX * n + startY);
        }
        while (!queue1.isEmpty() || !queue2.isEmpty()) {
            int dot = !queue1.isEmpty() ? queue1.poll() : queue2.poll();
            // 上三角矩阵和下三角矩阵，关于主对角线对称的部分，其压缩计算后的值相同，因此需要根据row和col的大小分别计算存取
            int row = dot / n, col = dot % n;
            if (row >= m || col >= n) {
                continue;
            }
            if (!visited[row][col]) {
                visited[row][col] = true;
                if (row >= col) {
                    queue1.offer(row * n + col);
                } else {
                    queue2.offer(row * n + col);
                }
                count++;
            }
            if (col < n - 1 && !visited[row][col + 1]) {
                visited[row][col + 1] = true;
                if (row >= col + 1) {
                    queue1.offer(row * n + col + 1);
                } else {
                    queue2.offer(row * n + col + 1);
                }
                count++;
            }
            if (col > 0 && !visited[row][col - 1]) {
                visited[row][col - 1] = true;
                if (row >= col - 1) {
                    queue1.offer(row * n + col - 1);
                } else {
                    queue2.offer(row * n + col - 1);
                }
                count++;
            }
            if (row < m - 1 && !visited[row + 1][col]) {
                visited[row + 1][col] = true;
                if (row + 1 >= col) {
                    queue1.offer((row + 1) * n + col);
                } else {
                    queue2.offer((row + 1) * n + col);
                }
                count++;
            }
            if (row > 0 && !visited[row - 1][col]) {
                visited[row - 1][col] = true;
                if (row - 1 >= col) {
                    queue1.offer((row - 1) * n + col);
                } else {
                    queue2.offer((row - 1) * n + col);
                }
                count++;
            }
        }
        return count;
    }
}

剑指 Offer II 105. 岛屿的最大面积

这道题与上面的题类似

题目描述

给定一个由 0 和 1 组成的非空二维数组 grid ，用来表示海洋岛屿地图。

一个 岛屿 是由一些相邻的 1 (代表土地) 构成的组合，这里的「相邻」要求两个 1 必须在水平或者竖直方向上相邻。你可以假设 grid 的四个边缘都被 0（代表水）包围着。

找到给定的二维数组中最大的岛屿面积。如果没有岛屿，则返回面积为 0 。

题解

class Solution {
    private int ans = 0;

    public int maxAreaOfIsland(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 0)    continue;
                ans = Math.max(ans, dfs(grid, i, j, m, n));
            }
        }
        return ans;
    }

    public int dfs(int[][] grid, int startX, int startY, int m, int n) {
        if (startX < 0 || startY < 0 || startX >= m || startY >= n || grid[startX][startY] == 0) {
            return 0;
        }
        grid[startX][startY] = 0;
        return 1 + dfs(grid, startX + 1, startY, m, n) + dfs(grid, startX - 1, startY, m, n) + dfs(grid, startX, startY + 1, m, n) + dfs(grid, startX, startY - 1, m, n);
    }
}

2249. 统计圆内格点数目

题目描述

给你一个二维整数数组 circles ，其中 circles[i] = [xi, yi, ri] 表示网格上圆心为 (xi, yi) 且半径为 ri 的第 i 个圆，返回出现在 至少一个 圆内的 格点数目 。

注意：

  • 格点 是指整数坐标对应的点。
  • 圆周上的点 也被视为出现在圆内的点。

在这里插入图片描述
在这里插入图片描述
提示：

  • 1 <= circles.length <= 200
  • circles[i].length == 3
  • 1 <= xi, yi <= 100
  • 1 <= ri <= min(xi, yi)

解题思路

思路一：暴力解法，直接遍历

根据题目的要求，需要将circles数组里面所有的圆遍历一遍，才能知道所有圆内点。又根据提示可知，本题的数据范围很小，可以用暴力解法。但是圆的数目是有限的，因此可以利用圆心和半径来确定遍历范围：(minX, minY)到(maxX, maxY)；然后再在坐标系中遍历坐标点。

class Solution {
    public int countLatticePoints(int[][] circles) {
        int ans = 0;
        int minX = Integer.MAX_VALUE, maxX = 0, minY = Integer.MAX_VALUE, maxY = 0;

        for (int[] c : circles) {
            minX = Math.min(minX, c[0] - c[2]);
            maxX = Math.max(maxX, c[0] + c[2]);
            minY = Math.min(minY, c[1] - c[2]);
            maxY = Math.max(maxY, c[1] + c[2]);
        }

        for (int i = minX; i <= maxX; i++) {
            for (int j = minY; j <= maxY; j++) {
                for (int[] c: circles) {
                    if ((i - c[0]) * (i - c[0]) + (j - c[1]) * (j - c[1]) <= c[2] * c[2]) {
                        ans++;
                        break;
                    }
                }
            }
        }
        return ans;
    }
}
思路二：DFS

这道题的DFS效果不是很好（如图所示），因为有大量的坐标被重复计算。在这里插入图片描述

错误做法

用四个visited数组分别记录坐标系的四个象限，防止越界。每次递归根据一个点的上下、左右是否被访问过来累计计算。

class Solution {
    boolean[][] visited1 = new boolean[110][110];
    boolean[][] visited2 = new boolean[110][110];
    boolean[][] visited3 = new boolean[110][110];
    boolean[][] visited4 = new boolean[110][110];

    public int countLatticePoints(int[][] circles) {
        int m = circles.length;
        int ans = 0;
        for (int i = 0; i < m; i++) {
            ans += dfs(circles[i], circles[i][0], circles[i][1]);
        }
        return ans;
    }

    public int dfs(int[] nums, int startX, int startY) {
        if (!isInside(startX, startY, nums[0], nums[1], nums[2])) {
            return 0;
        }
        if (startX >= 0 && startY >= 0) {
            if (visited1[startX][startY]) return 0;
            visited1[startX][startY] = true;
        } else if (startX < 0 && startY >= 0) {
            if (visited2[-startX][startY]) return 0;
            visited2[-startX][startY] = true;
        } else if (startX < 0) {
            if (visited3[-startX][-startY]) return 0;
            visited3[-startX][-startY] = true;
        } else {
            if (visited4[startX][-startY]) return 0;
            visited4[startX][-startY] = true;
        }


        return 1 + dfs(nums, startX - 1, startY) + dfs(nums, startX, startY - 1) + dfs(nums, startX, startY + 1) + dfs(nums, startX + 1, startY);
    }

    public boolean isInside(int x, int y, int x0, int y0, int r) {
        return (x - x0) * (x - x0) + (y - y0) * (y - y0) <= r * r;
    }
}

但是这样做会出现一个bug：
在这里插入图片描述
因为dfs在遍历每个圆的过程中，如果将某一点 A 访问，发现 A 在边界上并且它周围的坐标不在这个圆内，但是其中一点 B 在另外一个圆中，因此在后续遍历可能访问不到这个点，会漏掉计算。修复这个bug可以利用两种visited数组来记录，如果一个数组内没有记录访问这个圆内点，那么就对其进行访问，下面采用减少数组后的方法来做（避免越界）：

class Solution {
    boolean[][] visited = new boolean[310][310];
    boolean[][] visited1;
    public int countLatticePoints(int[][] circles) {
        int m = circles.length;
        int ans = 0;
        for (int i = 0; i < m; i++) {
            visited1 = new boolean[310][310];
            ans += dfs(circles[i], circles[i][0], circles[i][1]);
        }
        return ans;
    }

    public int dfs(int[] nums, int startX, int startY) {
        if (!isInside(startX, startY, nums[0], nums[1], nums[2])) {
            return 0;
        }
        if (visited1[startX + 100][startY + 100]) {
            return 0;
        } 
        visited1[startX + 100][startY + 100] = true;
        int flag = 0;
        if (!visited[startX + 100][startY + 100]) {
            flag = 1;
        }
        visited[startX + 100][startY + 100] = true;

        return flag + dfs(nums, startX - 1, startY) + dfs(nums, startX, startY - 1) + dfs(nums, startX, startY + 1) + dfs(nums, startX + 1, startY);
    }

    public boolean isInside(int x, int y, int x0, int y0, int r) {
        return (x - x0) * (x - x0) + (y - y0) * (y - y0) <= r * r;
    }
}

473. 火柴拼正方形

题目描述

在这里插入图片描述

解题思路

【DFS 回溯】根据题意，要使得用 所有的火柴 拼成正方形，则每条边长都必须相等 => 可以将边长看作四个桶，每个的容量为火柴总长度/4。

  • 若能恰好装满四个桶，return true
  • 否则，return false

优化：从大到小排列火柴，若大的超过了桶的容量，则表明溢出，跳过后续遍历。

class Solution {
    public boolean makesquare(int[] matchsticks) {
        int totalLen = Arrays.stream(matchsticks).sum();
        if (totalLen % 4 != 0) {
            return false;
        }
        Arrays.sort(matchsticks);
        for (int i = 0, j = matchsticks.length - 1; i < j; i++, j--) {
            int temp = matchsticks[i];
            matchsticks[i] = matchsticks[j];
            matchsticks[j] = temp;
        }
        int[] edges = new int[4];
        return dfs(0, matchsticks, edges, totalLen / 4);
    }

    public boolean dfs(int index, int[] matchsticks, int[] edges, int len) {
        if (index == matchsticks.length) {
            return true;
        }
        for (int i = 0; i < edges.length; i++) {
            edges[i] += matchsticks[index];
            if (edges[i] <= len && dfs(index + 1, matchsticks, edges, len)) {
                return true;
            }
            edges[i] -= matchsticks[index];
        }
        return false;
    }
}
【LeetCode刷题笔记】DFS&BFS（一）
川峰的博客
11-22 1090
LeetCode刷题笔记之DFS&BFS篇。
【LeetCode刷题笔记】DFS&BFS（二）
川峰的博客
11-23 842
LeetCode刷题笔记之DFS&BFS篇（二）。
二维数组实现电影院选座
qq_46027570的博客
07-10 971
java使用二维数组实现电影院选座
leetcode：827. 最大人工岛
OceanStar的博客
04-20 573
题目来源 题目描述 题目解析 这道题是leetcode：695. 岛屿的最大面积的升级版。 现在我们有填海造陆的能力，可以把一个海洋各自变成陆地格子，进而让两块岛屿连城一块
经典算法之分治法 求最大区间和
striner的博客
04-08 1612
问题描述: 数组中整数有正有负 求一连续子段，使得和最大化 例如： 2,4,-7,5,2,-1,2,-4,3 最大连续段： 5,2,-1,2 其最大和为8 解题思路: 制造递归条件,将数组分为两部分. 将区间和分为三部分计算: 第一部分:从begin开始计算[begin, index) 第二部分:从end开始计算[index, end) 第三部分:
[学习C++ ]C++ STL 全排列函数详解(排列组合与匹配算法)--2
开源节流
12-18 1530
排列组合n选m C++实现 排列组合n选m算法 本代码实现http://blog.chinaunix.net/uid-20684578-id-1572099.html所介绍找10组合算法。 算法摘要： 本程序的思路是开一个n长度的数组，其下标表示为0到n-1，数组元素的值为1表示其下标代表的数被选中，为0则没选中，算法过程： 1)初始化，将数组前m个元素置1，表示第一个组合为前m个数 2)然后...
算法学习-局部最大值
HelloNiGeSB的博客
11-23 5652
没时间了，以后补上
Leetcode刷题笔记之 DFS&BFS
weixin_43540151的博客
07-28 159
剑指 Offer 32 - I. 从上到下打印二叉树 从上到下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。 例如: 给定二叉树: [3,9,20,null,null,15,7], 3 / \ 9 20 / \ 15 7 返回： [3,9,20,15,7] 提示： 节点总数 &lt;= 1000 1。分层删除 耗时更短 vector&lt;int&gt; levelOrder(TreeNode* root) {
【LeetCode刷题笔记】DFS&BFS（三）
川峰的博客
11-24 1158
LeetCode刷题笔记之DFS&BFS篇（三）。
leetcode高频题笔记之DFS和BFS
clonechen
03-23 2561
文章目录代码模板BFS模板DFS模板递归玩法非递归玩法二叉树的层次遍历括号生成在每个树行中找最大值岛屿数量岛屿的最大面积被围绕的区域单词接龙 代码模板 BFS模板 def BFS(graph, start, end): visited = set() queue = [] queue.append([start]) while queue: node = queue.po...
【LeetCode】树与图的dfs和bfs
flora
06-22 443
参考： lzh的笔记 树与图的存储结构：邻接表 由于树是特殊的图，所以我们存储树也是用的邻接表或邻接图。 邻接表是指对于图上的每个结点来说，用一个单链表存储它的临接点。 我们需要h[],e[],ne[],idx来表示这个邻接点： h[v] : 指向节点v形成的链表的头节点注意初始化为-1 e[i] : 第i个点的值v（表示下标和值的映射） ne[i] : 表示邻接表链表中 i 节点的下一个节点 idx : 当前遍历到的节点的索引,等边都插入完idx就是节点个数 在节点a的后面插入b： idx为当前遍历
数据结构学习（C++）——图【3】（无向图）（上）
08-26 1901
要是在纸上随便画画，或者只是对图做点示范性的说明，大多数人都会选择无向图。然而在计算机中，无向图却是按照有向图的方法来储存的——存两条有向边。实际上，当我们说到无向的时候，只是忽略方向——在纸上画一条线，难不成那线“嗖”的就出现了，不是从一头到另一头画出来的？无向图有几个特有的概念，连通分量、关节点、最小生成树。下面将分别介绍，在此之前，先完成无向图类的基本操作。无向图类templat
在二叉排序树中，找所有结点值小于 x 中的最大结点
0202zc 的博客
07-04 3102
题目描述 找二叉排序树中，结点值小于 x 且是所有小于 x 的结点中最大的结点。 其中，二叉排序树定义如下： typedef struct BTNode { int val; struct BTNode *lchild; struct BTNode *rchild; } BSTNode, *BiTree; 算法思路 用max记录当前遍历到的比x小的最大值，使用bt遍历二叉排序树； 在 bt-&gt;val &gt;= x 的结点的左子树中查找；在 bt-&gt;val &lt; x 的结点的右子
如何判断身份证顶点的相对位置
0202zc 的博客
03-18 1861
已知身份证的四个角点，判断它们的相对位置问题的多次尝试...
二叉排序树的相关算法
0202zc 的博客
12-10 1650
1. 判断给定的二叉树是否是二叉排序树 利用中序遍历，若始终能保持前一个值比后一个值小，则是二叉排序树。 int predt = -32767; //中序前驱的值 int JudgeBST(BiTree bt){ int left, right; if(bt == NULL) //空树 return 1; else { left = JudgeBST(bt-&gt;lchild); //判断左子树 if(left == 0 || predt &gt;= bt-&gt;data) //左子
就地逆置线性表元素（基本操作 + 扩展）
0202zc 的博客
03-19 776
本文分为线性表逆置操作的基本操作和扩展操作
【LeetCode 笔记】动态规划
0202zc 的博客
04-07 533
一篇博文便涉水：《为什么你学不过动态规划？告别动态规划，谈谈我的经验》从中摘出来的中心思想方法：文中讲解了3道例题，依次为：以下均是基于数组空间的DP解法，在后续可以对空间进行优化，达到 O(1)O(1)O(1)大佬的经验附：LeetCode 动态规划入口 解题思路：想到了一次的正序遍历，但是结果求出的是非连续序列的最大和： 官方题解：简而言之，就是检测：定义数组元素含义 定义记录局部最大和，表示当前局部最大和定义状态转移方程 要取最大值，则要看 是加了之后变大，还是原来就比较大，肯定不能是加了一个数之后反
【力扣hot100题】（073）数组中的第K个最大元素
最新发布
s478527548的博客
04-09 614
当左指针在右指针左边时，移动左指针到第一个大于mid的位置，移动右指针到第一个小于mid的位置，若左指针在右指针左边，则交换两者元素，循环以上。循环最终结果：左指针指向从左往右第一个大于mid的元素，右指针指向从右往左第一个小于mid的元素，且左指针不在右指针左边。（选择排序做法）继续递归右指针往右部分的数组和右指针往左部分的数组。（这道题做法）若右指针的位置在k右边，则递归右指针往左部分，否则递归右指针往右部分。初写时犯了不少错误，也有很多问题：错误一：最后将mid移至left的位置。
DFS与BFS算法模板：leetcode个人笔记解析
资源摘要信息:&quot;leetcode中关于dfs解题思路-Personal-Notes:个人笔记&quot; 知识点一：DFS解题思路 在leetcode中，DFS（深度优先搜索）是一种常用的算法，它的基本思路是从一个节点开始，尽可能深的搜索每一个分支，当一...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Beta Lemon

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值