算法与数据结构基础学习十二（从暴力递归到动态规划）

最新推荐文章于 2026-08-20 09:52:53 发布
原创 最新推荐文章于 2026-08-20 09:52:53 发布 · 237 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
算法与数据结构

当前文章被收录于：

算法与数据结构
14 篇文章 1 人学习
订阅专栏 查看详情
本文通过四个示例展示了暴力递归到动态规划的转换过程，包括机器人行走、纸牌游戏、背包问题和数字字符串转换问题。每个问题首先使用暴力递归解决，然后通过记忆化搜索实现动态规划优化，减少重复计算，提高效率。同时，探讨了动态规划的空间压缩、状态化简和四边形不等式等进一步优化技巧。

什么暴力递归可以优化？

在这里插入图片描述

暴力递归和动态规划的关系

在这里插入图片描述

如何找到某个问题的动态规划方式？

在这里插入图片描述

设计暴力递归过程的原则

在这里插入图片描述

四种尝试模型

在这里插入图片描述

暴力递归到动态规划的套路

在这里插入图片描述

动态规划的进一步优化

1）空间压缩
2）状态化简
3）四边形不等式
4）其他优化技巧

题目一

在这里插入图片描述

public class RobotWalk{
    public static int ways1(int N,int start,int aim,int K){
        if (N < 2 || start < 1 || start > N || aim < 1 || aim > N || K < 1){
            return -1;
        }
        return proccess1(start,K,aim,N);
    }

    // 机器人当前来到的位置是cur，
    // 机器人还有rest步需要去走，
    // 最终的目标是aim，
    // 有哪些位置？1~N
    // 返回：机器人从cur出发，走过rest步之后，最终停在aim的方法数，是多少？
    private static int proccess1(int cur,int rest,int aim,int n){
        if (rest == 0){
            return cur == aim ? 1:0;
        }
        if (cur == 1){
            return proccess1(cur+1,rest-1,aim,n);
        }
        if (cur == n){
            return proccess1(cur-1,rest-1,aim,n);
        }
        return proccess1(cur +1,rest-1,aim,n) + proccess1(cur-1,rest-1,aim,n);
    }
    public static int ways2(int N,int start,int aim,int K){
        if (N < 2 || start < 1 || start > N || aim < 1 || aim > N || K < 1){
            return -1;
        }
        int[][] dp = new int[N+1][K+1];
        for (int i = 0; i < N + 1; i++) {
            for (int j = 0; j < K + 1; j++) {
                dp[i][j] = -1;
            }
        }
        return proccess2(start,K,aim,N,dp);
    }
//记忆搜索法
    private static int proccess2(int cur,int rest,int aim,int n,int[][] dp){
        if (dp[cur][rest] != -1){
            return dp[cur][rest];
        }
        int ans = 0;
        if (rest == 0) {
            ans = cur == aim ? 1 : 0;
            dp[cur][rest] = ans;
            return ans;
        }
        if (cur == 1){
            ans = proccess2(cur+1,rest-1,aim,n,dp);
        }else if (cur == n){
            ans = proccess2(cur-1,rest-1,aim,n,dp);
        }else {
            ans = proccess2(cur-1,rest-1,aim,n,dp) + proccess2(cur+1,rest-1,aim,n,dp);
        }
        dp[cur][rest] = ans;
        return ans;
    }

    public static void main(String[] args){
        System.out.println(ways1(5,2,4,6));
        System.out.println(ways2(5,2,4,6));
    }
}

题目二

在这里插入图片描述

public class CardsInLine{
    //给定一个整型数组arr，代表数值不同的纸牌排成一条线
    //玩家A和玩家B依次拿走每张纸牌
    //规定玩家A先拿，玩家B后拿
    //但是每个玩家每次只能拿走最左或最右的纸牌
    //玩家A和玩家B都绝顶聪明
    //请返回最后获胜者的分数。
    public static int win1(int[] arr){
        if (arr == null || arr.length == 0){
            return 0;
        }
        int first = f1(arr,0,arr.length-1);
        int second = s1(arr,0,arr.length-1);
        return Math.max(first,second);
    }

    private static int s1(int[] arr,int L,int R){
        if (L == R){
            return arr[L];
        }
        int p1 = f1(arr,L+1,R);
        int p2 = f1(arr,L,R-1);
        return Math.min(p1,p2);
    }

    private static int f1(int[] arr,int L,int R){
        if (L == R){
            return arr[L];
        }
        int p1 = arr[L]+s1(arr,L+1,R);
        int p2 = arr[R] + s1(arr,L,R-1);
        return Math.max(p1,p2);
    }

    public static int win2(int[] arr){
        if (arr == null || arr.length == 0){
            return 0;
        }
        int N = arr.length;
        int[][] fmap = new int[N][N];
        int[][] gmap = new int[N][N];
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                fmap[i][j] = -1;
                gmap[i][j] = -1;
            }
        }
        int first = f2(arr,0,arr.length-1,fmap,gmap);
        int second = g2(arr,0,arr.length-1,fmap,gmap);
        return Math.max(first,second);
    }

    private static int f2(int[] arr,int L,int R,int[][] fmap,int[][] gmap){
        if (fmap[L][R] != -1){
            return fmap[L][R];
        }
        int ans = 0;
        if (L == R){
            ans = arr[L];
        }else {
            int p1 = arr[L]+g2(arr,L+1,R,fmap,gmap);
            int p2 = arr[R] + g2(arr,L,R-1,fmap,gmap);
            ans = Math.max(p1,p2);
        }
        fmap[L][R] = ans;
        return ans;
    }

    private static int g2(int[] arr,int L,int R,int[][] fmap,int[][] gmap){
        if (gmap[L][R] != -1){
            return gmap[L][R];
        }
        int ans = 0;
        if (L != R){
            int p1 = f2(arr,L+1,R,fmap,gmap);
            int p2 = f2(arr,L,R-1,fmap,gmap);
            ans = Math.min(p1,p2);
        }
        gmap[L][R] = ans;
        return ans;
    }

    public static void main(String[] args){
        int[] arr = { 5, 7, 4, 5, 8, 1, 6, 0, 3, 4, 6, 1, 7 };
        System.out.println(win1(arr));
        System.out.println(win2(arr));
    }
}

题目三

在这里插入图片描述

public class Knapsack{
    // 所有的货，重量和价值，都在w和v数组里
    // 为了方便，其中没有负数
    // bag背包容量，不能超过这个载重
    // 返回：不超重的情况下，能够得到的最大价值
    public static int maxValue(int[] w,int[] v,int bag){
        if (w == null || w.length == 0 || v==null || v.length != w.length || bag == 0){
            return 0;
        }
        return proccess1(w,v,0,bag);
    }

    private static int proccess1(int[] w,int[] v,int index,int rest){
        if (rest<0){
            return -1;
        }
        if (index == w.length){
            return 0;
        }
        int ans = proccess1(w,v,index+1,rest-w[index]);
        if (ans != -1){
            ans += v[index];
        }
        int ans2 = proccess1(w,v,index+1,rest);
        return Math.max(ans,ans2);
    }
    public static int dp(int[] w,int[] v,int bag){
        if (w == null || w.length == 0 || v==null || v.length != w.length || bag == 0){
            return 0;
        }
        int N = w.length;
        int[][] dp = new int[N+1][bag+1];
        for(int index = N-1;index >=0; index--){
            for (int rest = 0; rest <= bag;rest++){
                int p1 = dp[index+1][rest];
                int p2 = 0;
                int next = rest - w[index] < 0 ? -1 :dp[index+1][rest-w[index]];
                if (next != -1){
                    p2 = next+v[index];
                }
                dp[index][rest] = Math.max(p1,p2);
            }
        }
        return dp[0][bag];
    }

    public static void main(String[] args){
        int[] weights = { 3, 2, 4, 7, 3, 1, 7 };
        int[] values = { 5, 6, 3, 19, 12, 4, 2 };
        int bag = 15;
        System.out.println(maxValue(weights, values, bag));
        System.out.println(dp(weights,values,bag));
    }

}

题目四

在这里插入图片描述

public class ConvertToLetterString{
    //规定1和A对应、2和B对应、3和C对应...26和Z对应
    //那么一个数字字符串比如"111”就可以转化为:
    //"AAA"、"KA"和"AK"
    //给定一个只有数字字符组成的字符串str，返回有多少种转化结果
    public static int number(String str){
        if (str == null || str.length() == 0){
            return 0;
        }
        return process(str.toCharArray(),0);
    }

    private static int process(char[] str,int i){
        if (str.length == i){
            return 1;
        }
        if (str[i] == '0'){ //没有0对应的字母，说明前一个决定有问题
            return 0;
        }
        int ways = process(str,i+1);
        if (i+1 < str.length && (str[i] - '0')*10 + (str[i+1] - '0') < 27){
            ways += process(str,i+2);
        }
        return ways;
    }
    // 从右往左的动态规划
    // 就是上面方法的动态规划版本
    // dp[i]表示：str[i...]有多少种转化方式
    public static int dp1(String s){
        if (s == null || s.length() == 0){
            return 0;
        }
        char[] str = s.toCharArray();
        int N = str.length;
        if (str[0] == '0'){
            return 0;
        }
        int[] dp = new int[N+1];
        dp[N] = 1;
        for (int i = N-1; i >=0 ; i--) {
            if (str[i] != '0') {
                int ways = dp[i + 1];
                if (i + 1 < str.length && (str[i] - '0') * 10 + (str[i + 1] - '0') < 27) {
                    ways +=dp[i+2];
                }
                dp[i] = ways;
            }
        }
        return dp[0];
    }
    // 从左往右的动态规划
    // dp[i]表示：str[0...i]有多少种转化方式
    public static int dp2(String s){
        if (s == null || s .length() == 0){
            return 0;
        }
        char[] str = s.toCharArray();
        int N = str.length;
        if (str[0] == '0'){
            return 0;
        }
        int[] dp = new int[N];
        dp[0] = 1;
        for (int i =1; i < N; i++){
            if (str[i] == '0'){
                if (str[i-1] == '0' || str[i-1] > '2' || (i-2 >=0 && dp[i-2] ==0)){
                    return 0;
                }else {
                    dp[i] = i-2 >= 0 ? dp[i-2] : 1;
                }
            }else {
                dp[i] = dp[i-1];
                if (str[i-1] != '0' && (str[i-1] - '0')*10 + (str[i] - '0') < 27){
                    dp[i] += i-2 >= 0 ? dp[i-2] : 1;
                }
            }
        }
        return dp[N-1];
    }
    // for test
    public static String randomString(int len) {
        char[] str = new char[len];
        for (int i = 0; i < len; i++) {
            str[i] = (char) ((int) (Math.random() * 10) + '0');
        }
        return String.valueOf(str);
    }
    //for test
    public static void main(String[] args) {
        int N = 30;
        int testTime = 1000000;
        System.out.println("测试开始");
        for (int i = 0; i < testTime; i++) {
            int len = (int) (Math.random() * N);
            String s = randomString(len);
            int ans0 = number(s);
            int ans1 = dp1(s);
            int ans2 = dp2(s);
            if (ans0 != ans1 || ans0 != ans2) {
                System.out.println(s);
                System.out.println(ans0);
                System.out.println(ans1);
                System.out.println(ans2);
                System.out.println("Oops!");
                break;
            }
        }
        System.out.println("测试结束");
    }
}

题目五

在这里插入图片描述

package com.msb.test12;

public class LongestCommonSubsequence{
    //给定两个字符串str1和str2，
    //返回这两个字符串的最长公共子序列长度
    //比如 ： str1 = “a12b3c456d”,str2 = “1ef23ghi4j56k”
    //最长公共子序列是“123456”，所以返回长度6
    public static int longestCommonSubsequence(String s1,String s2){
        if (s1 == null || s2 == null || s1.length() == 0 || s2.length() == 0){
            return 0;
        }
        char[] str1 = s1.toCharArray();
        char[] str2 = s2.toCharArray();
        return process(str1,str2,str1.length-1,str2.length-1);
    }

    private static int process(char[] str1,char[] str2,int i,int j){
        if (i == 0 && j == 0){
            return str1[i] == str2[j] ? 1 : 0;
        }else if (i == 0){
            if (str1[i] == str2[j]){
                return 1;
            }else {
                return process(str1,str2,i,j-1);
            }
        }else if (j == 0){
            if (str1[i] == str2[j]){
                return 1;
            }else {
                return process(str1,str2,i-1,j);
            }
        }else {
            int p1 = process(str1,str2,i-1,j);
            int p2 = process(str1,str2,i,j-1);
            int p3 = str1[i] == str2[j] ? 1+process(str1,str2,i-1,j-1) :process(str1,str2,i-1,j-1);
            return Math.max(p1,Math.max(p2,p3));
        }
    }
    public static int dp1(String s1,String s2){
        if (s1 == null || s2 == null || s1.length() == 0 || s2.length() == 0){
            return 0;
        }
        char[] str1 = s1.toCharArray();
        char[] str2 = s2.toCharArray();
        int M = str1.length;
        int N = str2.length;
        int[][] dp = new int[M][N];
        dp[0][0] = str1[0] == str2[0] ? 1 :0;
        for (int i = 1; i < M; i++) {
            if (str1[i] == str2[0]){
                dp[i][0] =1;
            }else {
                dp[i][0] = dp[i-1][0];
            }
        }
        for (int j = 1; j <N ; j++) {
            if (str1[0] == str2[j]){
                dp[0][j] = 1;
            }else {
                dp[0][j] = dp[0][j-1];
            }
        }
        for (int i = 1; i < M; i++) {
            for (int j = 1; j < N; j++) {
                dp[i][j] = str1[i] == str2[j] ? 1+dp[i-1][j-1] : Math.max(dp[i-1][j],dp[i][j-1]);
            }
        }
        return dp[M-1][N-1];
    }
}

----from左程云算法基础课

标签
#算法 #数据结构 #学习
暴力递归转动态规划详解
grave2015的博客
08-24 2427
以一个题目为例： 一排有N个位置，一个机器人在最开始停留在P位置上，如果P==0，下一分钟机器人一定向右移动到1位置，如果P=N-1，下一分钟机器人一定向左移动到N-2位置。如果P在0到N-1之间，下一分钟机器人一定会向左或向右移动，求K分钟时候，机器人到达T位置有多少种走法。 思路：这里我们先用递归求解，然后再阐释暴力递归转动态规划的做法。 递归：在K分钟是T位置上只能从K-1分钟的T
【数据结构与算法】第二篇：算法部分
qq_35635374的博客
01-04 1118
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 TODO:写完再整理 文章目录系列文章目录前言一、程序的时间和空间复杂度分析（1）理解算法时间复杂度的表示法（2）线性复杂度的分析（3）递归复杂度的分析（4）各种数据结构的时间复杂度二、顺序、条件、循环基本结构三、位运算（1）总的运算符（2）位运算的应用四、字符串算法（1）字符串的定义（2）字符串的比较（3）注意五、数组的排序算法（1）各种算法的时间\空间复杂度比较（2）比较类排序（常用）（1）交换排序1）冒泡排序（重要）2）
从暴力递归到动态规划（六）
KudouShinichi3的博客
05-11 707
从暴力递归到动态规划已经接近尾声，动态规划所有的内容都在这几篇文章中了，这篇文章主要是做一些总结。在总结之前，我们先回顾一下之前改写的整个套路。
【开发工程篇】第二篇：数据结构与算法
qq_35635374的博客
11-05 238
认知有限，望大家多多包涵，有什么问题也希望能够与大家多交流，共同成长！本文先对算法部分做个简单的介绍，具体内容后续再更，其他模块可以参考去我其他文章提示：以下是本篇文章正文内容（1）归并排序和快速排序具有相似性，但是步骤相反归并排序：先排序左右子数组，然后合并有序的子数组快速排序：先调配出左右子数组，然后对于作呕有子数组进行排序（2）没有限制说明不能应API进行排序就可以用API进行排序数组排序算法（升序）//数组排序。
动态规划详解（二）：从暴力递归到动态规划的完整优化之路
xiaoyu❅的博客
03-08 2189
动态规划（Dynamic Programming, DP）本质是一种通过**"聪明的穷举"解决问题的思想。它的核心是发现重叠子问题和最优子结构**，并通过存储中间结果避免重复计算。暴力递归 → 发现重复计算 → 记忆化搜索 → 推导状态转移 → 自底向上动态规划定义状态：明确dp数组的含义推导转移方程：分析状态间的关系初始化：设置边界条件确定遍历顺序：保证前置状态已计算输出结果：从dp数组中提取答案。
从暴力递归到动态规划
qq_45797026的博客
10-10 361
暴力递归： 1、把问题转化为ie规模缩小了的同类问题的子问题 2、有明确的不需要继续进行递归的条件（base case） 3、有当得到了子问题结果之后的决策过程 4、不记录每一个子问题的解 例一：求n!的结果 这道题很简单，你的脑中可能会出现一个非递归版本的解法，那是我们知道它该怎么算的状况下，现在我们来看看递归版本： 递归版本的思想是：求n!,只要去求(n-1)!然后乘以n long getFactorial(int n){ if (n==1){ return 1;
详解动态规划——从暴力递归到动态规划
qq_35531985的博客
06-11 600
以下内容参照了https://zhuanlan.zhihu.com/p/78220312。 动态规划遵循一套固定的流程： 递归的暴力解法 -> 带备忘录的递归解法 -> 非递归的动态规划解法 下面以斐波那契数列为例，揭开动态规划的面纱： 斐波那契数列 一、暴力递归法 int fib(int N) { if (N == 1 || N == 2) return 1; return fib(N - 1) + fib(N - 2); } 但是使用递归算法求解该问题往往是十分低效的，不仅
数据结构与算法 - 回溯算法的框架：递归、选择、撤销选择的流程
热门推荐
千淘万漉虽辛苦，吹尽狂沙始到金
11-12 2万+
数据结构与算法 - 回溯算法框架解析 回溯算法是一种系统化试错的搜索策略，通过递归、选择和撤销选择三大步骤，在约束条件下高效探索所有可能解。本文将深入剖析回溯算法的标准框架： 核心框架 递归调用：实现深度优先遍历 做出选择：将当前选项加入路径 撤销选择：恢复状态以便尝试其他选项 关键特点 适用于排列、组合、子集等搜索问题 通过剪枝优化减少无效计算 时间复杂度通常为指数级，但比纯暴力搜索高效 实战案例 全排列问题：使用used数组标记已选元素 子集问题：通过start索引避免重复计算 实现要点 必须进行状态恢
算法与数据结构（二十二）动态规划解题套路框架
Dby_freedom的博客
08-09 753
第一个斐波那契数列的问题，解释了如何通过「备忘录」或者「dp table」的方法来优化递归树，并且明确了这两种方法本质上是一样的，只是自顶向下和自底向上的不同而已。第二个凑零钱的问题，展示了如何流程化确定「状态转移方程」，只要通过状态转移方程写出暴力递归解，剩下的也就是优化递归树，消除重叠子问题而已。如果你不太了解动态规划，还能看到这里，真得给你鼓掌，相信你已经掌握了这个算法的设计技巧。计算机解决问题其实没有任何特殊的技巧，它唯一的解决办法就是穷举，穷举所有可能性。
算法与数据结构基础课第十二节笔记
yshuoo的博客
05-20 241
暴力递归转动态规划 什么暴力递归可以继续优化？ 有重复调用同一个子问题的解，这种递归可以优化 如果每一个子问题都是不同的解，无法优化也不用优化 例1： 假设有排成一行的N个位置，记为1~N，N 一定大于或等于 2 开始时机器人在其中的M位置上(M 一定是 1~N 中的一个) 如果机器人来到1位置，那么下一步只能往右来到2位置； 如果机器人来到N位置，那么下一步只能往左来到 N-1 位置； 如果机器人来到中间位置，那么下一步可以往左走或者往右走； 规定机器人必须走 K 步，最终能来到P位置(P也是1
蓝桥杯学习大纲
2302_80067378的博客
02-20 9141
致酷德与热爱算法、编程的小伙伴们
数据结构与算法 - 括号生成问题：回溯+合法性判断的结合
千淘万漉虽辛苦，吹尽狂沙始到金
11-13 2万+
本文探讨了经典的括号生成问题，通过回溯算法和合法性判断相结合的方法，高效生成所有合法的n对括号组合。文章分析了合法括号序列的定义（数量平衡且前缀合法），揭示了其与卡特兰数的数学关联。重点介绍了基于计数器的回溯实现，通过维护open和close变量避免生成非法序列，显著优于暴力枚举法。通过决策树可视化展示了剪枝过程，并对比了三种合法性判断方式的效率。最终实现的时间复杂度为O(4^n/√n)，空间复杂度O(n)，达到理论最优解。该算法体现了回溯与剪枝的精妙结合，是理解组合生成问题的典型案例。
算法修炼入门指南：从数据结构到基础算法的二十二层体系构建
最新发布
weixin_30621711的博客
08-20 673
数据结构与算法是计算机科学的核心基础，它们共同构成了高效解决复杂问题的理论框架。数据结构如数组、链表、栈、队列和哈希表，负责数据的组织与存储，而算法思想如递归、分治、排序和查找，则定义了处理数据的逻辑步骤。掌握这些基础能显著提升代码效率与系统性能，是进行系统设计、优化和通过技术面试的基石。在实际开发中，无论是构建高并发服务、实现快速检索，还是优化数据处理流程，都离不开扎实的算法内功。本文以“练气二十二层”为隐喻，系统梳理了从变量、流程控制到二叉树、堆等核心内容的渐进式学习路径，并融入递归、动态规划等高频技术
Java数据结构与算法（四）
weixin_42469070的博客
09-05 1877
B 树通过重新组织节点，降低树的高度，并且减少i/o读写次数来提升效率。1）如图 B 树通过重新组织节点， 降低了树的高度.2）文件系统及数据库系统的设计者利用了磁盘预读原理，将一个节点的大小设为等于一个页(页得大小通常为 4k)，这样每个节点只需要一次 I/O 就可以完全载入3） 将树的度 M 设置为 1024，在 600 亿个元素中最多只需要 4 次 I/O 操作就可以读取到想要的元素, B 树(B+)广泛应用于文件存储系统以及数据库系统中B-tree 树即B 树，B 即Balanced。
从暴力递归到记忆递归再到动态规划（从超时到超越100%的历程）
weixin_44816439的博客
05-14 324
1.暴力递归：设有S和T两个字符串，我们一个一个字符从前往后来看：设i为在S中的位置，j为在T中的位置。初始时i，j为0，在两个字符串往后匹配的过程中分为两种情况： ①S[i]==T[j] 当前有匹配，可以都向后移一位，也可以只把i向后移一位。 ②S[i]!=T[j] 当前无匹配，i向后移一位. 直到i=S.length（说明这条路没有匹配，返回0）或者j=T.length（说明这条路匹配了一次，返回1） 如图，递归的本质就是一个压栈出栈的树形遍历过程，最终能到达目的节点的路径即为一次成功的匹配。 代码.
算法：从暴力递归到动态规划
一群专业码农的笔记本
06-18 388
本文通过介绍一道LeetCode算法题的三种解法(Java代码实现)，分析各解法的复杂度及优缺点，探索它们的内在逻辑联系，分享一种算法优化思路。
左神算法：从暴力递归到动态规划
qq_42247286的博客
03-14 762
1.暴力递归 递归行为是大问题和子问题同样的流程和标准，有自己的base case，递归代表尝试。我不知怎么算，知道怎么试 n!问题 怎么尝试，n!问题的子问题就是(n - 1)! * n,base case是什么，就是样本量划分到什么程度的时候就不用划分子问题了。n规模的问题，解决n - 1规模的问题，再去解决n - 2规模的问题，直到解决1规模的问题，如果尝试顺序定了的话，他就是这么个依赖关...
【搞定左神算法初级班】第7节：暴力递归、动态规划
Java学习
04-04 2283
目 录: 一、递归 题目1：求 n! 的结果 题目2：汉诺塔问题 题目3：打印一个字符串的全部子序列，包括空字符串 题目4：打印一个字符串的全部排列 题目5：母牛每年生一只母牛，新出生的母牛成长三年后也能每年生一只母牛，假设不会死。求N年后，母牛的数量 二、动态规划 动态规划的特点 如何把暴力递归套路变为动态规划 题目1：矩阵最小路径和 题目2：（背包问题）从数组任意选择数字...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值