背包型动态规划

已于 2024-03-01 11:51:36 修改
阅读量104 收藏
点赞数
文章标签： 动态规划 算法
于 2023-02-21 13:31:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43355838/article/details/129138603
版权

01背包

不带价值的01背包，求最优解

92. 背包问题
解法1：背包型DP

class Solution {
public:
    int backPack(int m, vector<int> &a) {
        int n = a.size();

        // state
        vector<vector<int>> dp(n + 1, vector<int>(m + 1));

        // initial
        // dp[0][0 to m] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if (j >= a[i - 1]) {
                    dp[i][j] = max(dp[i - 1][j],
                        dp[i - 1][j - a[i - 1]] + a[i - 1]);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][m];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int backPack(int m, vector<int> &a) {
        int n = a.size();

        // state
        vector<int> dp(m + 1);

        // initial
        // dp[0 to m] = 0;

        // function
        for (int i = 0; i < n; ++i) {
            for (int j = m; j >= a[i]; --j) {
                dp[j] = max(dp[j], dp[j - a[i]] + a[i]);
            }
        }

        // answer
        return dp[m];
    }
};
不带价值的01背包，求方案数

563. 背包问题 V
解法1：背包型DP

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

        // state
        vector<vector<int>> dp(n + 1, vector<int>(target + 1));

        // initial
        dp[0][0] = 1;
        // dp[0][1 to target] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= target; ++j) {
                if (j >= nums[i - 1]) {
                    dp[i][j] = dp[i - 1][j] + 
                        dp[i - 1][j - nums[i - 1]];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][target];
    }
};

解法2：背包型DP+滚动数组

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

        // state
        vector<int> dp(target + 1);

        // initial
        dp[0] = 1;
        // dp[1 to target] = 0;

        // function
        for (int i = 0; i < n; ++i) {
            for (int j = target; j >= nums[i]; --j) {
                dp[j] += dp[j - nums[i]];
            }
        }

        // answer
        return dp[target];
    }
};
带价值的01背包，求最优解

125. 背包问题 II
解法1：背包型DP

class Solution {
public:
    int backPackII(int m, vector<int> &a, vector<int> &v) {
        int n = a.size();

        // state
        vector<vector<int>> dp(n + 1, vector<int>(m + 1));

        // initial
        // dp[0][0 to m] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if (j >= a[i - 1]) {
                    dp[i][j] = max(dp[i - 1][j],
                        dp[i - 1][j - a[i - 1]] + v[i - 1]);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][m];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int backPackII(int m, vector<int> &a, vector<int> &v) {
        int n = a.size();

        // state
        vector<int> dp(m + 1);

        // initial
        // dp[0 to m] = 0;

        // function
        for (int i = 0; i < n; ++i) {
            for (int j = m; j >= a[i]; --j) {
                dp[j] = max(dp[j], dp[j - a[i]] + v[i]);
            }
        }

        // answer
        return dp[m];
    }
};
分割等和子集

416. 分割等和子集
解法1：背包型DP

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int n = nums.size();
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2) {
            return false;
        }
        int m = sum / 2;
        
        // state
        vector<vector<bool>> dp(n + 1, vector<bool>(m + 1));

        // initial
        dp[0][0] = true;
        // dp[0][1 to m] = false;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if (j >= nums[i - 1]) {
                    dp[i][j] = dp[i - 1][j] ||
                        dp[i - 1][j - nums[i - 1]];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][m];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    bool canPartition(vector<int>& nums) {
        int n = nums.size();
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if (sum % 2) {
            return false;
        }
        int m = sum / 2;
        
        // state
        vector<bool> dp(m + 1);

        // initial
        dp[0] = true;
        // dp[1 to m] = false;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = m; j >= nums[i - 1]; --j) {
                dp[j] = dp[j] || dp[j - nums[i - 1]];
            }
        }

        // answer
        return dp[m];
    }
};
最后一块石头的重量 II

1049. 最后一块石头的重量 II
解法1：背包型DP

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int n = stones.size();
        int sum = accumulate(stones.begin(), stones.end(), 0);
        int m = sum / 2;

        // state
        vector<vector<int>> dp(n + 1, vector<int>(m + 1));

        // initial
        // dp[0][0 to m] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if (j >= stones[i - 1]) {
                    dp[i][j] = max(dp[i - 1][j],
                        dp[i - 1][j - stones[i - 1]] + stones[i - 1]);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return sum - 2 * dp[n][m];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int lastStoneWeightII(vector<int>& stones) {
        int n = stones.size();
        int sum = accumulate(stones.begin(), stones.end(), 0);
        int m = sum / 2;

        // state
        vector<int> dp(m + 1);

        // initial
        // dp[0][0 to m] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = m; j >= stones[i - 1]; --j) {
                dp[j] = max(dp[j],
                    dp[j - stones[i - 1]] + stones[i - 1]);
            }
        }

        // answer
        return sum - 2 * dp[m];
    }
};
目标和

494. 目标和
解法1：DFS

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int count = 0;
        dfs(nums, target, 0, count);
        return count;
    }

    void dfs(
        vector<int>& vec, int sum,
        int start, int& count
    ) {
        if (start == vec.size()) {
            if (sum == 0) {
                ++count;
            }
            return;
        }
        dfs(vec, sum - vec[start], start + 1, count);
        dfs(vec, sum + vec[start], start + 1, count);
    }
};

解法2：背包型DP

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int n = nums.size();
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if (abs(target) > sum) {
            return 0;
        }
        if ((target + sum) % 2) {
            return 0;
        }
        int m = (target + sum) / 2;

        // state
        vector<vector<int>> dp(n + 1, vector<int>(m + 1));

        // initial
        dp[0][0] = 1;
        // dp[0][1 to m] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if (j >= nums[i - 1]) {
                    dp[i][j] = dp[i - 1][j] +
                        dp[i - 1][j - nums[i - 1]];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][m];
    }
};

解法3：背包型DP+滚动数组

class Solution {
public:
    int findTargetSumWays(vector<int>& nums, int target) {
        int n = nums.size();
        int sum = accumulate(nums.begin(), nums.end(), 0);
        if (abs(target) > sum) {
            return 0;
        }
        if ((target + sum) % 2) {
            return 0;
        }
        int m = (target + sum) / 2;

        // state
        vector<int> dp(m + 1);

        // initial
        dp[0] = 1;
        // dp[1 to m] = 0;

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

        // answer
        return dp[m];
    }
};
一和零

474. 一和零
解法1：背包型DP+滚动数组

class Solution {
public:
    int findMaxForm(vector<string>& strs, int m, int n) {
        // state
        vector<vector<int>> dp(m + 1, vector<int>(n + 1));
        
        // initial
        // dp[0 to m][0] = 0, dp[0][0 to n] = 0;

        for (const auto& s: strs) {
            int n0 = 0, n1 = 0;
            for (const char& c: s) {
                if (c == '0') {
                    ++n0;
                }
                if (c == '1') {
                    ++n1;
                }
            }
            // function
            for (int i = m; i >= n0; --i) {
                for (int j = n; j >= n1; --j) {
                    dp[i][j] = max(dp[i][j],
                        dp[i - n0][j - n1] + 1);
                }
            }
        }

        // answer
        return dp[m][n];
    }
};

完全背包

不带价值的完全背包，求方案数

562. 背包问题 IV
解法1：背包型DP

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

        // state
        vector<vector<int>> dp(n + 1, vector<int>(target + 1));

        // initial
        dp[0][0] = 1;
        // dp[0][1 to target] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= target; ++j) {
                if (j >= nums[i - 1]) {
                    dp[i][j] = dp[i - 1][j] +
                        dp[i][j - nums[i - 1]];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][target];
    }
};

解法2：背包型DP+滚动数组

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

        // state
        vector<int> dp(target + 1);

        // initial
        dp[0] = 1;
        // dp[1 to target] = 0;

        // function
        for (int i = 0; i < n; ++i) {
            for (int j = nums[i]; j <= target; ++j) {
                dp[j] += dp[j - nums[i]];
            }
        }

        // answer
        return dp[target];
    }
};
带价值的完全背包，求最优解

440. 背包问题 III
解法1：背包型DP

class Solution {
public:
    int backPackIII(vector<int> &a, vector<int> &v, int m) {
        int n = a.size();

        // state
        vector<vector<int>> dp(n + 1, vector<int>(m + 1));

        // initial
        // dp[0][0 to m] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= m; ++j) {
                if (j >= a[i - 1]) {
                    dp[i][j] = max(dp[i - 1][j],
                        dp[i][j - a[i - 1]] + v[i - 1]);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][m];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int backPackIII(vector<int> &a, vector<int> &v, int m) {
        int n = a.size();

        // state
        vector<int> dp(m + 1);

        // initial
        // dp[0][0 to m] = 0;

        // function
        for (int i = 0; i < n; ++i) {
            for (int j = a[i]; j <= m; ++j) {
                dp[j] = max(dp[j], dp[j - a[i]] + v[i]);
            }
        }

        // answer
        return dp[m];
    }
};
零钱兑换 II

518. 零钱兑换 II
解法1：背包型DP

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        int n = coins.size();

        // state
        vector<vector<int>> dp(n + 1, vector<int>(amount + 1));

        // initial
        dp[0][0] = 1;
        // dp[0][1 to amount] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= amount; ++j) {
                if (j >= coins[i - 1]) {
                    dp[i][j] = dp[i - 1][j] + dp[i][j - coins[i - 1]];
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][amount];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int change(int amount, vector<int>& coins) {
        int n = coins.size();

        // state
        vector<int> dp(amount + 1);

        // initial
        dp[0] = 1;
        // dp[1 to amount] = 0;

        // function
        for (int i = 0; i < n; ++i) {
            for (int j = coins[i]; j <= amount; ++j) {
                dp[j] += dp[j - coins[i]];
            }
        }

        // answer
        return dp[amount];
    }
};
377. 组合总和 IV

377. 组合总和 IV
解法1：背包型DP

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

        // state
        vector<vector<int>> dp(n + 1, vector<int>(target + 1));

        // initial
        for (int i = 0; i <= n; ++i) {
            dp[i][0] = 1;
        }

        // function
        for (int j = 1; j <= target; ++j) {
            for (int i = 1; i <= n; ++i) {
                for (int k = i; k > 0; --k) {
                    if (j >= nums[k - 1] &&
                        dp[i][j] < INT_MAX - dp[i][j - nums[k - 1]]) {
                        dp[i][j] += dp[i][j - nums[k - 1]];
                    }
                }
            }
        }

        // answer
        return dp[n][target];
    }
};

解法2：背包型DP+滚动数组

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

        // state
        vector<int> dp(target + 1);

        // initial
        dp[0] = 1;
        // dp[1 to target] = 0;

        // function
        for (int j = 0; j <= target; ++j) {
            for (int i = 0; i < n; ++i) {
                if (j >= nums[i] &&
                    dp[j] < INT_MAX - dp[j - nums[i]]) {
                    dp[j] += dp[j - nums[i]];
                }
            }
        }

        // answer
        return dp[target];
    }
};
爬楼梯

70. 爬楼梯
解法1：坐标型DP

class Solution {
public:
    int climbStairs(int n) {
        // state
        vector<int> dp(n + 1);

        // initial
        dp[0] = dp[1] = 1;

        // function
        for (int i = 2; i <= n; ++i) {
            dp[i] = dp[i - 2] + dp[i - 1];
        }
        
        // answer
        return dp[n];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int climbStairs(int n) {
        // state
        vector<int> dp(n + 1);

        // initial
        dp[0] = 1;

        // function
        for (int j = 1; j <= n; ++j) {
            for (int i = 1; i <= 2; ++i) {
                if (j >= i) {
                    dp[j] += dp[j - i];
                }
            }
        }

        // answer
        return dp[n];
    }
};
零钱兑换

322. 零钱兑换
解法1：背包型DP

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        int n = coins.size();

        // state
        vector<vector<int>> dp(n + 1, vector<int>(amount + 1));

        // initial
        fill(dp[0].begin(), dp[0].end(), INT_MAX);
        dp[0][0] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= amount; ++j) {
                if (j >= coins[i - 1] &&
                    dp[i][j - coins[i - 1]] < INT_MAX) {
                    if (dp[i - 1][j] < INT_MAX) {
                        dp[i][j] = min(dp[i - 1][j],
                            dp[i][j - coins[i - 1]] + 1);
                    } else {
                        dp[i][j] = dp[i][j - coins[i - 1]] + 1;
                    }
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][amount] == INT_MAX ? -1 : dp[n][amount];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        int n = coins.size();

        // state
        vector<int> dp(amount + 1, INT_MAX);

        // initial
        dp[0] = 0;
        // dp[1 to amount] = INT_MAX;

        // function
        for (int i = 0; i < n; ++i) {
            for (int j = coins[i]; j <= amount; ++j) {
                if (dp[j - coins[i]] < INT_MAX) {
                    dp[j] = min(dp[j], dp[j - coins[i]] + 1);
                }
            }
        }

        // answer
        return dp[amount] == INT_MAX ? -1 : dp[amount];
    }
};
完全平方数

279. 完全平方数
解法1：背包型DP

class Solution {
public:
    int numSquares(int n) {
        // state
        vector<vector<int>> dp(n + 1, vector<int>(n + 1));

        // initial
        fill(dp[0].begin(), dp[0].end(), INT_MAX);
        dp[0][0] = 0;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = 0; j <= n; ++j) {
                if (j >= i * i) {
                    dp[i][j] = min(dp[i - 1][j],
                        dp[i][j - i * i] + 1);
                } else {
                    dp[i][j] = dp[i - 1][j];
                }
            }
        }

        // answer
        return dp[n][n];
    }
};

解法2：背包型DP+滚动数组

class Solution {
public:
    int numSquares(int n) {
        // state
        vector<int> dp(n + 1, INT_MAX);

        // initial
        dp[0] = 0;
        // dp[1 to n] = INT_MAX;

        // function
        for (int i = 1; i <= n; ++i) {
            for (int j = i * i; j <= n; ++j) {
                dp[j] = min(dp[j], dp[j - i * i] + 1);
            }
        }

        // answer
        return dp[n];
    }
};
koukouvagia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
背包型动态规划——背包问题1
sinat_40875078的博客
02-04 234
在n个物品中挑选若干物品装入背包，最多能装多满？假设背包的大小为m，每个物品的大小为A[i] 示例： 样例 1: 输入: [3,4,8,5], backpack size=10 输出: 9 样例 2: 输入: [2,3,5,7], backpack size=12 输出: 12 1、题目分析 首先要明确一点，在背包问题中，数组大小和总称重有关。 给定N个物品，重量分别为正整数A0, A1, …, AN-1。一个背包最大承重是M，物品的重量都是整数。每个装物品的方案的总重量都是0到M。如.
(01背包型动态规划+三维状态数组)lintcode中等668 · 一和零
weixin_46035615的博客
03-26 680
01背包型动态规划+三维状态数组
【算法】动态规划 ④ ( 动态规划分类 | 坐标型动态规划 | 前缀划分型动态规划 | 前缀匹配型动态规划 | 区间型动态规划 | 背包型动态规划 )
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
12-10 1098
一、动态规划场景、 二、动态规划分类、 1、坐标型动态规划、 2、前缀划分型动态规划、 3、前缀匹配型动态规划、 4、区间型动态规划、 5、背包型动态规划、
背包型动态规划——背包问题5
sinat_40875078的博客
02-04 156
给出 n 个物品, 以及一个数组, nums[i] 代表第i个物品的大小, 保证大小均为正数, 正整数 target 表示背包的大小, 找到能填满背包的方案数。 每一个物品只能使用一次 给出候选物品集合 [1,2,3,3,7] 以及 target 7 结果的集合为: [7] [1,3,3] 返回 2 1、题目分析 从题目的提问方式可以看出是属于典型的计数类型的动态规划。 2、确定状态 需要知道N个物品有多少种方式拼出重量W (W =0, 1, …, Target) 最后一步：第N个物品（重量AN-1 ）.
背包型动态规划——背包问题3
sinat_40875078的博客
02-04 169
给定 n 种物品, 每种物品都有无限个. 第 i 个物品的体积为 A[i], 价值为 V[i]. 再给定一个容量为 m 的背包. 问可以装入背包的最大价值是多少? 样例 1: 输入: A = [2, 3, 5, 7], V = [1, 5, 2, 4], m = 10 输出: 15 解释: 装入三个物品 1 (A[1] = 3, V[1] = 5), 总价值 15. 样例 2: 输入: A = [1, 2, 3], V = [1, 2, 3], m = 5 输出: 5 解释: 策略不唯一. 比如, 装入.
(背包型动态规划)lintcode92背包问题
weixin_46035615的博客
03-19 536
背包型动态规划
(01背包型动态规划)lintcode125背包问题（二）
weixin_46035615的博客
03-20 378
01背包型动态规划
背包型动态规划：整数划分
少儿编程乔老师
12-02 941
背包型动态规划：整数划分
(完全背包型动态规划)lintcode440 · 背包问题 III
weixin_46035615的博客
03-21 109
完全背包问题
改进动态规划跳跃点之0-1背包问题python实现
03-12
这个是动态规划之跳跃点0-1背包问题，如果只是想要动态规划0-1背包问题求解代码，请到主页查看。18级学姐自主完成的算法作业，呕心沥血，基于四舍五入等于0基础的python实现，如果在语言规范上存在不足，那就。就憋...
基于动态规划方法改进0-1背包问题.docx
06-03
【基于动态规划方法改进0-1背包问题】 0-1背包问题是一个经典的组合优化问题，其基本形式是：给定一组物品，每种物品都有一个重量和一个价值，目标是在不超过背包容量的前提下，选择物品使得总价值最大。在这个问题...
运筹学第七章：动态规划.pdf
11-23
这一章主要讨论了离散确定型的动态规划模型，这是最基础的形式，但其核心思想和原则同样适用于其他类型的动态规划问题。 首先，理解动态规划的关键在于掌握多阶段决策过程的最优化。在这样的过程中，每一阶段都需要...
基于动态规划的0-1背包问题的解决.docx
06-03
0-1背包问题的动态规划解决方案通常包含以下几个步骤： 1. **问题描述**： 我们需要确定在不超过背包容量W的情况下，如何从n个物品中选择，使得总价值最大。物品的价值和重量分别为v[i]和w[i]，i表示物品的编号。...
各种动态规划
07-19
合并类型动态规划，树形动态规划，线型动态规划，资源背包动态规划，坐标型动态规划。
力扣2187.完成旅途的最少时间
最新发布
Pisasama的博客
06-12 421
二分答案。
指针和数组
2301_77634163的博客
06-10 461
有3个指针，中间是一个数组arr，有个指针指向中间,其他两个指向两边，一个指向前面，一个人指向后面。虽然简化好，但是我们C语言要求是不允许这样写的,虽然大部分编译器是可以允许我这样写的。下面那个用数组名也是可以用的，因为他也表示一个地址，加1就会找后面那个元素的地址。我们C语言编译器中说指针允许往后比较大小，但不允许往前比面的指针比较大小。地址向后移，指针相比较，指针减减就是减去一个整数。同一指针相减的绝对值得到的是之间元素的个数。数组和指针的地址是一样的，说明是可以的。地址加地址，指针加指针没有意义。
C++的算法：Kosaraju算法与Tarjan算法
全栈工程师Linda的博客
06-10 479
C++的算法：Kosaraju算法与Tarjan算法
算法：位运算题目练习
一名还在努力学习技术的程序员的博客
06-10 729
本篇博客是关于滑动窗口算法的练习题，每道题都超链接了力扣的网页，每道题都有详细的解答过程
背包问题np完全和动态规划矛盾吗
05-12
不完全矛盾。背包问题是一个经典的动态规划问题，可以使用动态规划算法来解决。但是，背包问题是一个NP完全问题，这意味着在一定的时间内，无法找到一个多项式时间的算法来解决它，除非P=NP。因此，即使使用动态规划算法，对于大型的背包问题，仍然需要指数级的时间来解决，因此在实际应用中可能需要使用启发式算法等其他技术来解决。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值