算法专题学习之搜索

DFS之连通性模型

迷宫

一天Extense在森林里探险的时候不小心走入了一个迷宫,迷宫可以看成是由 n∗n 的格点组成,每个格点只有2种状态,.和#,前者表示可以通行后者表示不能通行。

同时当Extense处在某个格点时,他只能移动到东南西北(或者说上下左右)四个方向之一的相邻格点上,Extense想要从点A走到点B,问在不走出迷宫的情况下能不能办到。

如果起点或者终点有一个不能通行(为#),则看成无法办到。

注意:A、B不一定是两个不同的点。

输入格式
第1行是测试数据的组数 k ,后面跟着 k 组输入。

每组测试数据的第1行是一个正整数 n ,表示迷宫的规模是 n∗n 的。

接下来是一个 n∗n 的矩阵,矩阵中的元素为.或者#。

再接下来一行是 4 个整数 ha,la,hb,lb ,描述 A 处在第 ha 行, 第 la 列, B 处在第 hb 行, 第 lb 列。

注意到 ha,la,hb,lb 全部是从 0 开始计数的。

输出格式
k行,每行输出对应一个输入。

能办到则输出“YES”,否则输出“NO”。

数据范围
1≤n≤100

输入样例:

2
3
.##
..#
#..
0 0 2 2
5
.....
###.#
..#..
###..
...#.
0 0 4 0

输出样例:

YES
NO

题目分析
本题目的是判断从起点能否到达终点,故只要有一条道路能到达重点即可,故不需要回溯(恢复现场),这与求路径总数,全排列不同,这两种都是要取得所有的结果,因此需要回溯。
题解

package ACwing.搜索;

import java.util.Arrays;
import java.util.Scanner;

/**
 * @Description
 * @Author:PrinceHan
 * @CreateTime:2022/2/8 15:58
 */
public class _1112 {
    static int[] dx = {-1, 0, 1, 0}, dy = {0, 1, 0, -1};
    static final int N = 110;
    static char[][] maze = new char[N][N];
    static boolean[][] vis = new boolean[N][N];
    static int sx, sy, ex, ey;
    static int n;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int k = scanner.nextInt();
        for (int i = 0; i < k; i++) {
            n = scanner.nextInt();
            vis = new boolean[N][N];
            for (int j = 0; j < n; j++) {
                String str = scanner.next();
                scanner.nextLine();
                maze[j] = str.toCharArray();
            }
            sx = scanner.nextInt();
            sy = scanner.nextInt();
            ex = scanner.nextInt();
            ey = scanner.nextInt();
            if (dfs(sx, sy)) System.out.println("YES");
            else System.out.println("NO");
        }
    }

    static boolean dfs(int x, int y) {
        if (maze[x][y] == '#') return false;
        if (x == ex && y == ey) return true;
        vis[x][y] = true;
        for (int i = 0; i < 4; i++) {
            int a = x + dx[i], b = y + dy[i];
            if (in(a, b) && !vis[a][b]) {
                if (dfs(a, b)) return true;//找到出口就返回
            }
        }
        return false;
    }

    static boolean in(int x, int y) {
        return x >= 0 && x < n && y >= 0 && y < n;
    }
}

迷宫

题目描述

给定一个N*M方格的迷宫,迷宫里有T处障碍,障碍处不可通过。给定起点坐标和终点坐标,问: 每个方格最多经过1次,有多少种从起点坐标到终点坐标的方案。在迷宫中移动有上下左右四种方式,每次只能移动一个方格。数据保证起点上没有障碍。

输入格式
第一行N、M和T,N为行,M为列,T为障碍总数。第二行起点坐标SX,SY,终点坐标FX,FY。接下来T行,每行为障碍点的坐标。

输出格式
给定起点坐标和终点坐标,问每个方格最多经过1次,从起点坐标到终点坐标的方案总数。

输入输出样例
**输入 **

2 2 1
1 1 2 2
1 2

输出

1

说明/提示
【数据规模】
1≤N,M≤5

题目分析
本题目的是求路径总数要取得所有的结果,在搜索过程中需要不断回溯。

题解

import java.util.Scanner;

/**
 * @Description
 * @Author:PrinceHan
 * @CreateTime:2022/2/8 13:30
 */
public class Main {
    static int[][] maze = new int[10][10];
    static int[][] der = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};
    static boolean[][] vis = new boolean[10][10];
    static int ans;
    static int n;
    static int m;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int t, sx, sy, fx, fy;
        n = scanner.nextInt();
        m = scanner.nextInt();
        t = scanner.nextInt();
        sx = scanner.nextInt();
        sy = scanner.nextInt();
        fx = scanner.nextInt();
        fy = scanner.nextInt();
        maze[sx][sy] = 1;//开始为1
        maze[fx][fy] = 3;//结束为3
        for (int i = 1; i <= t; i++) {
            int tx, ty;
            tx = scanner.nextInt();
            ty = scanner.nextInt();
            maze[tx][ty] = 2;//障碍为2
        }
        vis[sx][sy] = true;//起点标记走过
        dfs(sx, sy);
        System.out.println(ans);
    }

    public static void dfs(int x, int y) {
        if (maze[x][y] == 3) {
            ans++;
            return;
        }
        else {
            int tx, ty;
            for (int i = 0; i < 4; i++) {
                tx = x + der[i][0];
                ty = y + der[i][1];
                if(in(tx, ty) && !vis[tx][ty] && maze[x][y] != 2) {
                    vis[tx][ty] = true;//标记走过
                    dfs(tx,ty);
                    vis[tx][ty] = false;//回溯
                }
            }
        }
        
    }

    public static boolean in(int x, int y) {
        return x >= 1 && x <= n && y >= 1 && y <= m;
    }
}

FloodFill

1097池塘

题目描述
农夫约翰有一片 N∗M 的矩形土地。

最近,由于降雨的原因,部分土地被水淹没了。

现在用一个字符矩阵来表示他的土地。

每个单元格内,如果包含雨水,则用”W”表示,如果不含雨水,则用”.”表示。

现在,约翰想知道他的土地中形成了多少片池塘。

每组相连的积水单元格集合可以看作是一片池塘。

每个单元格视为与其上、下、左、右、左上、右上、左下、右下八个邻近单元格相连。

请你输出共有多少片池塘,即矩阵中共有多少片相连的”W”块。

输入格式
第一行包含两个整数 N 和 M 。

接下来 N 行,每行包含 M 个字符,字符为”W”或”.”,用以表示矩形土地的积水状况,字符之间没有空格。

输出格式
输出一个整数,表示池塘数目。

数据范围
1≤N,M≤1000
输入样例:

10 12
W........WW.
.WWW.....WWW
....WW...WW.
.........WW.
.........W..
..W......W..
.W.W.....WW.
W.W.W.....W.
.W.W......W.
..W.......W.

输出样例:

3

题目分析
这是一个求连通块的问题,调用一次dfs算一个连通块,并将’W’换为’.’,计算调用了几次dfs,即有几个池塘。这种方法也可以判断一个图是否连通。

import java.util.Scanner;

/**
 * @Description
 * @Author:PrinceHan
 * @CreateTime:2022/2/8 17:40
 */
public class Main {
    static final int N = 1005;
    static char[][] pool = new char[N][N];
    static int n, m;
    static int[] dx = {1, 0, -1, 0, 1, -1, 1, -1}, dy = {0, 1, 0, -1, 1, -1, -1, 1};//上 右 下 左 右下 左上 左下 右上
    static int ans;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        for (int i = 0; i < n; i++) {
            String str = scanner.next();//Java里无法直接输入字符
            pool[i] = str.toCharArray();
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (pool[i][j] == 'W') {
                    dfs(i, j);//出现积水开始搜索
                    ans++;//一次搜索说明有一个池塘
                }
            }
        }
        System.out.println(ans);
    }

    static void dfs(int x, int y) {
        pool[x][y] = '.';//走过的地方变为陆地
        for (int i = 0; i < 8; i++) {
            int xx = x + dx[i];
            int yy = y + dy[i];
            if (in(xx, yy) && pool[xx][yy] == 'W') {
                dfs(xx, yy);
            }
        }
    }

    static boolean in(int x, int y) {
        return x >= 0 && x < n && y >= 0 && y < m;
    }
}


剪枝优化

小猫爬山

翰翰和达达饲养了 N 只小猫,这天,小猫们要去爬山。

经历了千辛万苦,小猫们终于爬上了山顶,但是疲倦的它们再也不想徒步走下山了(呜咕>_<)。

翰翰和达达只好花钱让它们坐索道下山。

索道上的缆车最大承重量为 W,而 N 只小猫的重量分别是 C1、C2……CN。

当然,每辆缆车上的小猫的重量之和不能超过 W。

每租用一辆缆车,翰翰和达达就要付 1 美元,所以他们想知道,最少需要付多少美元才能把这 N 只小猫都运送下山?

输入格式
第 1 行:包含两个用空格隔开的整数,N 和 W。
第 2…N+1 行:每行一个整数,其中第 i+1 行的整数表示第 i 只小猫的重量 Ci。

输出格式
输出一个整数,表示最少需要多少美元,也就是最少需要多少辆缆车。

数据范围
1≤N≤18,
1≤Ci≤W≤108
输入样例:

5 1996
1
2
1994
12
29

输出样例:

2

题目分析
搜索过程其实是按照一种树的形状进行搜索的,剪枝顾名思义就是减去剪去树的枝干,从而提高运算效率。将猫放进车里有两种情况,一种是放到已有的车里,一种是新开一辆车,因此dfs里有两个参数,表示第几只小猫和第几辆车。
剪枝优化可以优化几个地方,当小车个数大于答案时,返回;所有的小猫都放进车里时,更新答案并返回;另外要先考虑小猫决策小的情况,小猫体重越大,所能选择的车就越少,因此要对数组进行从大到小的排序。

题解


#include<iostream>
#include<algorithm>
using namespace std;
const int N = 20;
int n, m;
int c[N], w[N];
int ans = N;
void dfs(int u, int k)
{
    if(k >= ans)return;
    if(u == n)
    {
        ans = k;
        return;
    }
    for(int i = 1; i <= k; i++)
    {
        if(w[i] + c[u] <= m)//不超重
        {
            w[i] += c[u];//放入第u只小猫
            dfs(u + 1, k);
            w[i] -= c[u];//回溯
        }
    }
    w[k + 1] += c[u];//将第u只小猫放入第k+1个车中
    dfs(u + 1, k + 1);
    w[k + 1] -= c[u];//回溯
}
int main()
{
    cin >> n >> m;
    for(int i = 0; i < n; i++)
    {
        cin >> c[i];
    }
    sort(c, c + n,greater<int>());//从大到小排序
    dfs(0, 0);
    cout << ans;
    return 0;
}

数的划分

题目描述
将整数 n分成 k 份,且每份不能为空,任意两个方案不相同(不考虑顺序)。

例如:n=7,k=3,下面三种分法被认为是相同的。

1,1,5;
1,5,1;
5,1,1.

问有多少种不同的分法。

输入格式
n,k (6<n≤200,2≤k≤6)

输出格式
1 个整数,即不同的分法。

输入输出样例

输入

7 3

输出

4

题目分析

这是一道标准的DFS题目,思路简单清晰,要求算出指定的一个数可以按照指定的份数分成几份。本题要求只要两个划分所包含的数字集合相同,即可看作一个分法。判断一个划分是否为按照要求的分法有两个要求。第一,划分出的数的个数等于k。第二,每个划分出的数集的和等于n。满足这两个条件即可看作一个分法,同时也是递归调用空操作返回的一个判定条件。

如果当一个数以及划分的数量都很大时,采用DFS会有很高的时间复杂度,递归调用次数太多也会有栈溢出的风险,在这里我们要使用剪枝。DFS执行期间会产生一棵搜索树,减去一些不重要的枝干从而提高计算效率这种策略,我们称之为剪枝。我们可以一开始就按递增顺序存,这样可以避免计算相同的分法。同时,若sum + i * (k - num) <= n,这样可以减少不必要的计算。

题解

import java.util.Scanner;

/**
 * @Description
 * @Author:PrinceHan
 * @CreateTime:2022/2/9 15:06
 */
public class Main {
        static int ans;
        static int n ,k;
        public static void main(String[] args) {
                Scanner scanner = new Scanner(System.in);
                n = scanner.nextInt();
                k = scanner.nextInt();
                dfs(1,0,0);
                System.out.println(ans);
        }
        public static void dfs(int start, int sum, int num){
                if(num == k) {
                        if(sum == n)ans++;
                        return ;
                }
                for(int i = start; sum + i * (k - num) <= n; i++) {
                        dfs(i , sum + i, num + 1);
                }
        }
}

马的遍历

题目描述

有一个 n×m 的棋盘,在某个点 (x, y)上有一个马,要求你计算出马到达棋盘上任意一个点最少要走几步。

输入格式
输入只有一行四个整数,分别为 n, m, x, y。

输出格式
一个 n×m 的矩阵,代表马到达某个点最少要走几步(左对齐,宽 5格,不能到达则输出 -1)。

输入输出样例

输入

3 3 1 1

输出

0    3    2    
3    -1   1    
2    1    4    

说明/提示

数据规模与约定

对于全部的测试点,保证 1 ≤ x ≤ n ≤ 400,1 ≤ y ≤ m ≤ 400。

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

/**
 * @Description
 * @Author:PrinceHan
 * @CreateTime:2022/3/25 15:01
 */
public class Main {
    static final int N = 405;
    static int[][] dir = {{-1, -2}, {-2, -1}, {-2, 1}, {-1, 2}, {1, 2}, {2, 1}, {2, -1}, {1, -2}};
    static int n, m;

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        n = scanner.nextInt();
        m = scanner.nextInt();
        int x = scanner.nextInt();
        int y = scanner.nextInt();
        bfs(x, y);
    }

    public static void bfs(int x, int y) {
        int[][] dist = new int[N][N];
        for (int i = 1; i < N; i++) {
            Arrays.fill(dist[i], -1);
        }
        Queue<Point> q = new LinkedList<>();
        q.add(new Point(x, y));
        dist[x][y] = 0;
        while (!q.isEmpty()) {
            Point poll = q.poll();
            for (int i = 0; i < 8; i++) {
                int dx = poll.x + dir[i][0];
                int dy = poll.y + dir[i][1];
                if (dx >= 1 && dx <= n && dy >= 1 && dy <= m && dist[dx][dy] == -1) {
                    dist[dx][dy] = dist[poll.x][poll.y] + 1;
                    q.add(new Point(dx, dy));
                }
            }
        }
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                System.out.printf("%-5d", dist[i][j]);
            }
            System.out.println();
        }
    }

    static class Point {
        int x;
        int y;

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

}

01迷宫

题目描述

有一个仅由数字0与1组成的n × n格迷宫。若你位于一格00上,那么你可以移动到相邻4格中的某一格1上,同样若你位于一格1上,那么你可以移动到相邻4格中的某一格0上。

你的任务是:对于给定的迷宫,询问从某一格开始能移动到多少个格子(包含自身)。

输入格式

第11行为两个正整数n,m。

下面n行,每行n个字符,字符只可能是0或者1,字符之间没有空格。

接下来m行,每行2个用空格分隔的正整数i,j,对应了迷宫中第i行第j列的一个格子,询问从这一格开始能移动到多少格。

输出格式

m行,对于每个询问输出相应答案。

输入输出样例

输入

2 2
01
10
1 1
2 2

输出

4
4

说明/提示

所有格子互相可达。

对于20%的数据,n≤10;

对于40%的数据,n≤50;

对于50%的数据,m≤5;

对于60%的数据,n≤100,m≤100;

对于100%的数据,n≤1000,m≤100000。

#include <iostream>
using namespace std;
const int N = 1005;
char maze[N][N];
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int book[N][N];
struct point
{
    int x, y;
} q[1000005];
int n, m, sx, sy;
void bfs(int x, int y)
{
    int ans = 1, head = 0, tail = 0;
    q[tail].x = x;
    q[tail].y = y;
    book[x][y] = 1;
    tail++;
    while (head < tail)
    {
        for (int i = 0; i < 4; i++)
        {
            int tx = q[head].x + dx[i];
            int ty = q[head].y + dy[i];
            if (!(tx <= n && tx >= 1 && ty <= n && ty >= 1)) continue;
            if (book[tx][ty] == 0 && maze[q[head].x][q[head].y] != maze[tx][ty])
            {
                book[tx][ty] = 1;
                q[tail].x = tx;
                q[tail].y = ty;
                ans++;
                tail++;
            }
        }
        head++;
    }
    for (int i = 0; i < tail; i++)
    {
        book[q[i].x][q[i].y] = ans;
    }
}
int main()
{
    cin >> n >> m;
    for (int i = 1; i <= n; ++i)
    {
        for (int j = 1; j <= n; ++j)
            cin >> maze[i][j];
    }
    for (int i = 0; i < m; ++i)
    {
        cin >> sx >> sy;
        if (book[sx][sy] != 0) cout << book[sx][sy] << endl;
        else
        {
            bfs(sx, sy);
            cout << book[sx][sy] << endl;
        }
    }
    return 0;
}


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
### 回答1: 可以使用深度优先搜索广度优先搜索算法来解决这个问题。首先判断起点和终点是否可通行,如果不可通行则无法到达。然后从起点开始搜索,每次向四个方向扩展,如果扩展到的点可通行且未被访问过,则将其加入搜索队列或栈中,并标记为已访问。直到找到终点或搜索队列或栈为空时停止搜索。如果找到了终点,则说明可以到达,否则无法到达。 ### 回答2: #。其中.表示该点可以通过,#表示该点不可通过。现在,extense通过了地图上一个设定好的起点,需要穿过这个迷宫,并到达一个设定好的终点。请为extense找出到达终点的最短路径,并输出路径长度。 这采用广度优先搜索(BFS)算法来解决这个问题。 首先,我们需要定义一个队列来保存待搜索的节点。同时,我们还需要定义一个dist数组来保存每个节点到起点的最短距离。由于起点为给定的点,因此我们可以将起点的dist值设置为0,并将其压入队列中。 之后,我们开始进行BFS搜索。对于当前搜索的节点,我们寻找所有与其直接相邻的节点,并计算它们到起点的距离(即当前节点到起点距离加1)。如果该节点未被访问过且可以通过(即为.),则将其dist值更新为新的距离,并将该节点压入队列中等待后续搜索。此外,如果我们在搜索中找到了终点,那么我们可以直接返回当前的dist值,此时就找到了最短路径的长度。 当队列中所有的节点都被搜索完成后,我们就可以得到起点到终点的最短路径长度。当然,我们还可以通过回溯dist数组来获取具体的最短路径。 总之,采用BFS算法,我们可以非常高效地解决这个问题,用C++代码来实现如下: ```cpp #include <iostream> #include <queue> using namespace std; const int MAXN = 105; int n, sx, sy, ex, ey; char maze[MAXN][MAXN]; int dist[MAXN][MAXN]; bool vis[MAXN][MAXN]; int dx[] = {0, 0, 1, -1}; int dy[] = {1, -1, 0, 0}; int bfs(int x, int y) { queue<pair<int, int>> q; q.push({x, y}); dist[x][y] = 0; vis[x][y] = true; while(!q.empty()) { auto p = q.front(); q.pop(); if(p.first == ex && p.second == ey) break; for(int i = 0; i < 4; i++) { int nx = p.first + dx[i], ny = p.second + dy[i]; if(nx < 1 || ny < 1 || nx > n || ny > n) continue; if(maze[nx][ny] == '#') continue; if(vis[nx][ny]) continue; dist[nx][ny] = dist[p.first][p.second] + 1; vis[nx][ny] = true; q.push({nx, ny}); } } return dist[ex][ey]; } int main() { cin >> n >> sx >> sy >> ex >> ey; for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++) cin >> maze[i][j]; cout << bfs(sx, sy) << endl; return 0; } ``` ### 回答3: #,其中.表示空地,#表示墙壁,你需要帮助extense寻找到从起点到终点的一条路径。 首先,我们需要对迷宫进行建模,可以采用二维数组来表示迷宫的状态。例如,可以使用0表示空地,使用1表示墙壁。同时,我们需要定义起点和终点的坐标,可以用(x1, y1)表示起点的坐标,用(x2, y2)表示终点的坐标。接下来,我们可以使用广度优先搜索算法搜索从起点到终点的最短路径。 广度优先搜索算法的核心思想是,从起点开始,依次扩展其周围的节点,直到找到终点或者全部节点都被访问。在访问每个节点时,我们需要记录其距离和路径,以便在找到终点后回溯路径。具体实现时,可以使用队列或者数组来存储待访问的节点,并在访问过程中更新它们的状态。 下面是一份样例代码,供参考: ``` const int MAXN = 1005; // 迷宫大小 int maze[MAXN][MAXN]; // 迷宫状态 int vis[MAXN][MAXN]; // 标记数组,记录节点是否被访问过 int dis[MAXN][MAXN]; // 距离数组,记录起点到每个节点的距离 pair<int, int> pre[MAXN][MAXN]; // 前驱数组,记录每个节点的前驱节点 int dx[4] = {-1, 0, 1, 0}; // 方向数组,表示上下左右四个方向 int dy[4] = {0, 1, 0, -1}; bool bfs(int x1, int y1, int x2, int y2) { queue<pair<int, int>> q; memset(vis, 0, sizeof(vis)); memset(dis, 0, sizeof(dis)); dis[x1][y1] = 0; vis[x1][y1] = 1; q.push(make_pair(x1, y1)); while (!q.empty()) { pair<int, int> cur = q.front(); q.pop(); if (cur.first == x2 && cur.second == y2) { return true; // 找到终点,返回true } for (int i = 0; i < 4; i++) { int nx = cur.first + dx[i]; int ny = cur.second + dy[i]; if (nx < 1 || nx > n || ny < 1 || ny > n || vis[nx][ny] || maze[nx][ny]) { continue; // 节点越界或者被访问过或者是墙壁,跳过 } dis[nx][ny] = dis[cur.first][cur.second] + 1; vis[nx][ny] = 1; pre[nx][ny] = cur; q.push(make_pair(nx, ny)); } } return false; // 没有找到终点,返回false } void output_path(int x1, int y1, int x2, int y2) { if (x1 == x2 && y1 == y2) { return; // 起点和终点重合,返回 } output_path(pre[x2][y2].first, pre[x2][y2].second, x1, y1); printf("(%d,%d) ", x2, y2); // 输出路径 } int main() { // 读入迷宫数据 scanf("%d", &n); for (int i = 1; i <= n; i++) { for (int j = 1; j <= n; j++) { char c; scanf(" %c", &c); maze[i][j] = (c == '#'); } } // 读入起点和终点坐标 int x1, y1, x2, y2; scanf("%d%d%d%d", &x1, &y1, &x2, &y2); // 搜索最短路径 if (bfs(x1, y1, x2, y2)) { printf("找到了一条长度为%d的路径:\n", dis[x2][y2]); output_path(x1, y1, x2, y2); printf("\n"); } else { printf("无法到达终点!\n"); } return 0; } ``` 在实现过程中,需要注意以下几点: 1. 搜索时需要判断节点是否越界,否则可能会导致程序崩溃。 2. 为了避免重复访问同一个节点,需要使用标记数组进行记录。 3. 在记录路径时,需要使用前驱数组,即对于每个节点,记录其是从哪个节点转移而来的。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值