史上最全的整数分解方法（包含经典的分苹果问题）

已于 2023-05-07 14:55:30 修改
阅读量8.1k 收藏 45
点赞数 7
分类专栏： C++学习专栏 文章标签： 数据结构
于 2020-06-07 12:51:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45541762/article/details/106599865
版权

【华为OD机试真题 2022&2023】真题目录 @点这里@

【华为OD机试真题】信号发射和接收 &试读& @点这里@

【华为OD机试真题】租车骑绿道 &试读& @点这里@

整数分解方法总结

一、加法分解：

题目描述：

给定一个正整数，我们可以定义出下面的公式：

N=a[1]+a[2]+a[3]+...+a[m];
a[i]>0,1<=m<=N;

对于一个正整数，求解满足上面公式的所有算式组合
对于整数4：

4 = 4；
4 = 3+1；
4 = 2+2；
4 = 2+1+1；
4 = 1+1+1+1；

1.所有可能的分解输出（有重复）

方法一：
#include <iostream>
using namespace std;
const int Size = 20;
int res_num;
// 拆分元素暂存在res数组中
int res[Size];
int a, p = 0;
// 将n进行拆分
void resolve(int n);

int main() {
    while (1) {
        cin >> a;
        resolve(a);
        cout << "total num of res: " << res_num << endl;
        res_num = 0;
    }
    return 0;
}

void resolve(int n) {
    if (n<=0) { // 出口
        cout << a << "=";
        for (int i=0; i<p-1; i++)
            cout << res[i] << "+";
        cout << res[p-1] << endl;
        res_num++;
    }

    for (int i = 1; i <= n; i++) {
        res[p] = i;
        p++;        // p ++来顺序存储各个拆分元素
        resolve(n-i);
        p--;        // 此行必须有，执行完这一行，下一次for循环才能回退
    }
}
方法二：
#include <iostream>
#include <vector>

using namespace std;
int counts;
void Backtrack(int n, vector<int>& comb, int cur, int sum)
{
    int tmpSum;
    for (int num = 1; num <= n; num++)
    {
        comb[cur] = num;
        tmpSum = sum + num;
        if (tmpSum > n)
        {
            break;//最好换成break(原来为continue),因为当tmpSum>n之后继续循环是没有意义的
        }
        else if(tmpSum == n)//第一次输出前不断地递归，进入到最里面一层，当tmpSum==n时，通过for循环
        //输出全1的拆分结果，随后看是一层一层退出，依次分别执行外部的for循环，使得通过num的增加，而使
        //拆分的最后一位数字增加（中间可能涉及前进和后退的过程，通过tmpSum<n前进，tmpSum>n回退，回退
        //之后num在原数值基础上继续增加，导致拆分的最后一位数字增加）回退到最外面一层for循环之后，num
        //增加使得输出拆分结果的第一个数字增加。
        {
            cout << n << "=";
            for (int i = 1; i < cur; i++)
                cout << comb[i] << "+";
            cout << comb[cur] << endl;
            counts++;
        }
        else
        {
            Backtrack(n, comb, cur + 1, tmpSum);
        }

    }
}
int main()
{
    int n;
    vector<int> com;
    while (cin >> n)
    {
        com.assign(n+1, 1);
        Backtrack(n, com, 1, 0);
        cout << "The total number is: " << counts << endl;
    }
    return 0;
}
结果如下：

在这里插入图片描述

2.输出不重复的分解结果

方法一改：
#include <iostream>
using namespace std;
const int Size = 20;
int res_num;
// 拆分元素暂存在res数组中
int res[Size];
int a, p = 0;
// 将n进行拆分
void resolve(int n, int flag);

int main() {
    while (1) {
        cin >> a;
        resolve(a, 1);
        cout << "total num of res: " << res_num << endl;
        res_num = 0;
    }
    return 0;
}

void resolve(int n, int flag) {
    if (n<=0) { // 出口
        cout << a << "=";
        for (int i=0; i<p-1; i++)
            cout << res[i] << "+";
        cout << res[p-1] << endl;
        res_num++;
    }

    for (int i = flag; i <= n; i++) {
        res[p] = i;
        p++;        // p ++来顺序存储各个拆分元素
        resolve(n-i, i);
        p--;        // 此行必须有，执行完这一行，下一次for循环才能回退
    }
}
方法二改：
#include <iostream>
#include <vector>

using namespace std;
void Backtrack(int n, vector<int>& comb, int cur, int sum)
{
    int tmpSum;
    for (int num = comb[cur-1]; num <= n; num++)
    {
        comb[cur] = num;
        tmpSum = sum + num;
        if (tmpSum > n)
        {
            break;//最好换成break(原来为continue),因为当tmpSum>n之后继续循环是没有意义的
        }
        else if(tmpSum == n)//第一次输出前不断地递归，进入到最里面一层，当tmpSum==n时，通过for循环
        //输出全1的拆分结果，随后看是一层一层退出，依次分别执行外部的for循环，使得通过num的增加，而使
        //拆分的最后一位数字增加（中间可能涉及前进和后退的过程，通过tmpSum<n前进，tmpSum>n回退，回退
        //之后num在原数值基础上继续增加，导致拆分的最后一位数字增加）回退到最外面一层for循环之后，num
        //增加使得输出拆分结果的第一个数字增加，而由for循环的初始条件num=comb[cur-1]及comb[cur]=num，
        //决定了每次输出的拆分结果，后面的数字不小于前一位数字。
        {
            cout << n << "=";
            for (int i = 1; i < cur; i++)
                cout << comb[i] << "+";
            cout << comb[cur] << endl;
        }
        else
        {
            Backtrack(n, comb, cur + 1, tmpSum);
        }
        
    }
}
int main()
{
    int n;
    vector<int> com;
    while (cin >> n)
    {
        com.assign(n+1, 1);
        Backtrack(n, com, 1, 0);
    }
    return 0;
}
输出结果：

在这里插入图片描述

二、触类旁通之乘法分解：

将一个数n的分解为因子的乘积形式，输出所有可能，并输出表达式。

12=2*2*3；
12=2*6；
12=3*4；
12=6*2；
12=12*1；
代码如下：
#include<iostream>
using namespace std;

int data_s[100]; // 存储因子的数组
int p=0; // 因子数组的指针
int num=0; // 记录分解因子的总数
int x; // 待分解的数

// 递归函数，用于分解因子
void resolve(int n,int minNum)
{
    if(n<2) // 如果n小于2，说明已经分解完毕
    {
        num++; // 记录分解因子的总数
        cout<< x << "="; // 输出待分解的数
        for(int j=0;j<p;j++)
        {
            cout<< data_s[j]; // 输出因子
            if(j!=p-1)
                cout << "*"; // 输出乘号
            if(data_s[j] == x)
                cout << "*1"; // 如果因子等于待分解的数，输出*1
        }
        cout << endl; // 换行
        return;
    }
    for(int i=minNum;i<=n;i++) // 从minNum开始枚举因子
    {
        if(n%i==0) // 如果n能够整除i，说明i是n的因子
        {
            data_s[p]=i; // 将i存储到因子数组中
            p++; // 指针后移
            resolve(n/i, i); // 递归分解n/i的因子，最小因子为i
            p--; // 回溯，指针前移
        }
    }
}

int main()
{
    while(cin >> x) // 循环读入待分解的数
    {
        resolve(x, 2); // 分解因子
        cout<< "The total numbers is  " << num << endl; // 输出分解因子的总数
        cout << "--------------------------" << endl; // 输出分隔符
        num = 0; // 重置分解因子的总数
        break;
    }
    return 0;
    
}

在这里插入图片描述

下面的代码可以实现从小到大的顺序输出质数因子的乘积：

#include <iostream>
const int Num = 100;
using namespace std;

int main()
{
    int data[Num],n; // 定义一个数组data和一个整数n
    while (cin >> n) // 循环读入n的值
    {

        int num = n,j = 0; // 定义一个整数num和一个计数器j
        for (int i = 2; i <= n; ++i) // 从2到n遍历每个数
        {
            while (num % i == 0) // 如果num能被i整除
            {
                num /= i; // 将num除以i
                data[j] = i; // 将i存入数组data中
                j++; // 计数器加1
            }
        }
        for (int i = 0; i < j; ++i) // 遍历数组data
        {
            cout << data[i]; // 输出数组元素
            if (i != j - 1)
                cout << '*'; // 如果不是最后一个元素，输出乘号
        }
        cout << '=' << n << endl; // 输出等号和n的值
    }
    return 0;
}

在这里插入图片描述

如果需要输出所有分解组合，只需要将resolve()的第二个参数去掉即可，如下面这段代码，输出所有因子组合（有重复）：

#include<iostream>
using namespace std;

int data_s[100]; // 存储因子的数组
int p=0; // 因子数组的指针
int num=0; // 记录分解因子的总数
int x; // 待分解的数

// 递归函数，用于分解因子
void resolve(int n)
{
    if(n<2) // 如果n小于2，说明已经分解完毕
    {
        num++; // 记录分解因子的总数
        cout<< x << "="; // 输出待分解的数
        for(int j=0;j<p;j++)
        {
            cout<< data_s[j]; // 输出因子
            if(j!=p-1)
                cout << "*"; // 输出乘号
            if(data_s[j] == x)
                cout << "*1"; // 如果因子等于待分解的数，输出*1
        }
        cout << endl; // 换行
        return;
    }
    for(int i=2;i<=n;i++) // 从minNum开始枚举因子
    {
        if(n%i==0) // 如果n能够整除i，说明i是n的因子
        {
            data_s[p]=i; // 将i存储到因子数组中
            p++; // 指针后移
            resolve(n/i); // 递归分解n/i的因子，最小因子为i
            p--; // 回溯，指针前移
        }
    }
}

int main()
{
    while(cin >> x) // 循环读入待分解的数
    {
        resolve(x); // 分解因子
        cout<< "The total numbers is  " << num << endl; // 输出分解因子的总数
        cout << "--------------------------" << endl; // 输出分隔符
        num = 0; // 重置分解因子的总数
        break;
    }
    return 0;
    
}
输出结果：

在这里插入图片描述

三、分苹果相关问题

接下来是只需要输出组合数的代码：

将要拆的数n，当作n个苹果。拆成k个数，当作k个盘子。
k > n时，多出来的盘子必定是空的，拆分情况的数量和k==n没区别。
k < n时，两种情况：
1)至少有一个空盘子，则相当于少一个盘子的情况q(n, k) = q(n, k-1)
2)没有空盘子，分配完之后相当于每个盘子里都减少一个苹果的情况q(n, k) = q(n-k, k)
两种情况合起来就是：q(n, k) = q(n, k-1) + q(n-k, k)
n的最大值为120，可以用空间换时间，用一个120*120的二维数组存储所有结果

在这里插入图片描述

#include <iostream>
using namespace std;
int main()
{
    int solution[121][121] = {0}; // 定义一个二维数组solution，用于存储结果
    for (int n = 1; n <= 120; n++) // n表示苹果的个数，从1到120遍历
    {
        for (int k = 1; k <= 120; k++) // k表示盘子的个数，从1到120遍历
        {
            if (n == 1 || k == 1) // 如果苹果个数为1或盘子个数为1，那么只有一种放法
            {
                solution[n][k] = 1;
            }
            else if (n > k) // 如果苹果个数大于盘子个数，那么可以分成两种情况
            {
                // 第一种情况：至少有一个盘子不放苹果，即f(n-k,k)
                // 第二种情况：每个盘子都放至少一个苹果，即f(n,k-1)
                solution[n][k] = solution[n-k][k] + solution[n][k-1];
            }
            else if(n == k) // 如果苹果个数等于盘子个数，那么只有一种放法
            {
                // n个苹果，k-1个盘子只是比k个盘子少了一种全1的组合，即只少了一种情况
                solution[n][k] = 1 + solution[n][k-1];
            }
        }
    }
    int n;
    while (cin >> n) // 循环读入n
    {
        cout << solution[n][n] << endl; // 输出结果
    }
    return 0;
}

本题就是先建一个二维数组用以存储数据，然后根据前面的分析填充数据，然后使用输入的值查表就可以得到结果。

补充放苹果问题：

题目描述:

把M个同样的苹果放在N个同样的盘子里，允许有的盘子空着不放，问共有多少种不同的分法？（用K表示）5，1，1和1，5，1 是同一种分法。

输入

每个用例包含二个整数M和N。0<=m<=10，1<=n<=10。

样例输入:
7 3
样例输出:
8
解题分析：

设f(m,n)为m个苹果，n个盘子的放法数目，则先对n作讨论，

  1. 当m < n：则必定有n-m个盘子永远空着，去掉它们对摆放苹果方法数目不产生影响。即 if(n>m) f(m,n) = f(m,m)
  2. 当m >= n:不同的放法可以分成两类：含有0的方案数，不含有0的方案数
  • 含有0的方案数，即有至少一个盘子空着，即相当于 f(m,n)=f(m,n-1);
  • 不含有0的方案数，即所有的盘子都有苹果，相当于可以从每个盘子中拿掉一个苹果，不影响不同放法的数目，即 f(m,n)=f(m-n,n)。

而总的放苹果的放法数目等于两者的和，即 f(m,n)=f(m,n-1)+f(m-n,n)

递归出口条件说明：
当n=1时，所有苹果都必须放在一个盘子里，所以返回1；
当m==0(没有苹果可放)时，定义为1种放法；
递归解法：

#include <iostream>
using namespace std;
int fun(int m,int n)
{
    if(m==0||n==1)
        return 1;
    else if(m<n)
        return fun(m,m);
    else
        return fun(m-n,n)+fun(m,n-1);
}
int main()
{
    int a,b,num;
    while(cin >> a >> b)
    {
        cout << fun(a,b) << endl;
    }
}


//动态归划解法：
#include <iostream>
using namespace std;
int main()
{
    int solution[11][11] = {0};
    for (int n = 0; n <= 10; n++)
    {
        for (int k = 0; k <= 10; k++)
        {
            if (n == 0 || k == 1)
            {
                solution[n][k] = 1;
            }
            else if (n >= k)
            {
                solution[n][k] = solution[n-k][k] + solution[n][k-1];
            }
            else if(n < k)
            {
                solution[n][k] = solution[n][n];
            }                                         
        }
    }
    int n, k;
    while (cin >> n >> k)
    {
        cout << solution[n][k] << endl;
    }
    return 0;
}

问题描述：将整数N分成K个整数的和且每个数大于等于A小于等于B，求有多少种分法

#include <iostream>
using namespace std;
int Dynamics(int n, int k, int min, int max)
{ //将n分为k个整数，最小的大于等于min,最大的不超过B
    if(n < min)
        return 0;  //当剩下的比min小，则不符合要求，返回0
    if(n <= max && k == 1)//原来只有k==1最后一个判断条件，下面k==0也没有，
    //现在做这样的修改是为了处理按照要求不能分配的特殊情况
        return 1;
    if (k == 0)//在不能正确划分的情况下，防止k变为负值，提前终止！
    {
        //cout << "The value of k is " <<  k << endl;
        return 0;
    }
    int sum = 0;//sum直到最后把n划分完才会得到返回值1，否则递归过程中每段都返回0；如果划分成功，则最后就得到0+...+0+1等于1
    for(int t = min; t <= max; t++)
    {
        sum += Dynamics(n-t, k-1, t, max);//为了避免重复，所以第三个参数用t,说明t是每次递归完成后是动态变化的
    }
    return sum;
}

int main()
{
    int a, b, mins, maxs;
    while (cin >> a >> b >> mins >> maxs)
    {
        cout << Dynamics(a, b, mins, maxs) << endl;//最开始函数的min由这里控制，
        //随后的min由函数内的for循环控制

    }
}

问题拓展：前面的放苹果问题，如果每个盘子都不能为空，则有多少种放法？
思路，先把每个盘子都放一个苹果，这样问题就转化为：m-n个苹果放进n个盘子里，盘子允许空，即为前面的问题。

笑着的程序员
关注
  • 7
    点赞
  • 踩
  • 45
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 3
    评论
专栏目录
整数拆分问题
jsjsbsb464548的博客
06-06 353
/整数拆分问题：编写一个程序，找出一个正整数的所有可能拆分方式。例如，对于正整数 4，有以下拆分方式：1 + 1 + 1 + 1、1 + 1 + 2、1 + 3、2 + 2、4。
整数拆分问题的四种解法
热门推荐
NEWPLAN的专栏
04-01 12万+
整数划分问题是算法中的一个经典命题之一 所谓整数划分，是指把一个正整数n写成如下形式： n=m1+m2+m3+....+mi;（其中mi为正整数，并且1&lt;=mi&lt;=n），则{m1,m2,m3,....,mi}为n的一个划分。 如果{m1,m2,m3,....,mi}中的最大值不超过m，即max{m1,m2,m3,....,mi} &lt;= m，则称它属于n的一个m划分。这...
整数分解算法
05-18
#include #include struct DP { int num; int sum; } d[50000]= {0}; int max=0; void qsort(int low,int high,struct DP key[]) { int i=low,j=high; struct DP tag=key[i]; if(i<j) { do { while(tag.num<key[j].num && i<j) j--; if(i=key[i].num && i<j) i++; if(i<j) { key[j]=key[i]; j--; } } } while(i<j); key[i]=tag; qsort(low,j-1,key); qsort(i+1,high,key); } } int dfs(int left) { int i,p; int l,r,m; int count=0; l=0; r=max; while(l>1; if(d[m].num<left) l=m+1; else r=m-1; } p=l; if(d[p].sum) return d[p].sum; for(i=1; i<=d[i].num; i++) { if(left%d[i].num==0) count+=dfs(left/d[i].num); } d[p].sum=count; return count; } int main(void) { int i,j,tmp; int n; scanf("%d",&n); tmp=sqrt(n); for(i=1; i<=tmp; i++) { if(n%i==0) { d[max].num=i; max++; d[max].num=n/i; max++; } } max--; qsort(0,max,d); d[0].sum=1; printf("%d\n",dfs(n)); return 0; }
整数分解方法
casion
03-16 2万+
题目大意：给定一个整数n，找到k个数，使得其和等于n。 如： 4=1+1+1+1 4=1+1+2; 4=1+3; 4=2+2； 4=4； 求其分解的所有可能，并输出分解表达式。 解题思路：要拆分整数n，肯定先要找到一个元素，然后我们会发现，剩下的问题还是一个整数差分问题，因此容易得到问题的解。 定义函数f(n)为n可以拆分的解的个数，即可以先拆分出一个数字k(k = 1,2，……，n...
整数分解
weixin_30609287的博客
04-14 500
倒序分解 #include<stdio.h> int main() { int n; int num; scanf("%d",&n); do{ num=n%10; printf("%d",num); if(n>9) { printf(" ");...
大整数分解——Pollard Rho算法
xffyjq的博客
09-28 8961
延续上一篇，这次来讲一讲大整数分解算法的应用。要解决的问题很简单，对一个整数进行分解质因数。首先还是效率非常低的暴力算法，相信大家都会，不多提。和上次一样，当数达到非常大的时候，分解将变得非常困难。于是这次又带来一个提升分解速度的“非完美”算法。之所以打引号，是因为这次不完美的不是结果，而是时间效率。Pollard Rho算法分解一个数n的过程大体上是这样子的：1、找到一个数p，使得p|np|n，将
大整数分解——Pollard Rho算法(floyd判圈)
jkchen's Haven
08-23 3294
环境 : 给定一个数n,让你把它分解成多个素数的乘积 你离此算法大成就差一个Miller-Rabin素数检测算法了 对于一个数n,只需要如下步骤即可分成若干个素数 找到一个数p , 使p|n 那么n就可以变成p和n/p 如果p或者n/p不是质数,当成n重新第一步 判断是否为质数用Miller-Rabin素数检测算法 最关键的是如何找到这个数p...
北师大版二年级上册数学2分苹果教学课件.ppt
05-12
北师大版二年级上册数学“2分苹果”这一教学课件主要涵盖了平均分的概念，旨在帮助学生理解和掌握如何平均分配物体，并培养他们的实践操作和思维能力。以下是本课件涉及的重要知识点： 1. 平均分的概念：平均分是指...
基础算法-python分苹果
11-05
python分苹果 def distribute_apples(apple_count, child_count): apple_per_child = apple_count // child_count remaining_apples = apple_count % child_count return apple_per_child, remaining_apples # ...
分苹果问题详解
10-08
这个方法基于如下思路：为满足每个猴子都能平均分配苹果的要求，我们需要在原始苹果堆中增加特定数量的苹果，使得每一轮分苹果时，猴子能看到的苹果数量（包括新增的和原有的）是猴子数量的整数倍加上一个固定的值。...
大数分解（基于非常大的整数的分解）
11-28
对大整数进行分解！
整数分解问题算法（C++)代码
11-11
这是关于整数的划分问题的算法的c++代码，整数划分：如5可以分解为1 4 2 3，里边有各个步骤的说明，利于参考学习。
史上最全经典数据结构算法c语言实现代码合集
10-13
苹果分法.txt 螺旋数组1.txt 螺旋数组2.txt 试题.txt 诺汉塔画图版.txt 读写文本文件.txt 货郎担分枝限界图形演示.txt 货郎担限界算法.txt 质因子.txt 输出自已.txt 迷宫.txt 迷宫问题.txt 逆波兰...
“弯曲门”牵头，细数苹果史上七大败笔
08-27
本文将详细分析“弯曲门”事件以及其他六个苹果历史上的重大败笔，探讨这些问题对苹果品牌的影响及其后续的应对策略。 首先，“弯曲门”是苹果在推出iPhone 6时遭遇的重大挑战。为了追求更轻薄的设计，iPhone 6的...
整数拆分算法详解
sysleo的博客
10-18 1万+
问题描述 输入一个N，输出所有拆分的方式。如输入3 输出1+1+1 1+2 3 算法思想 用一个数组res[]存放拆分的解，用全局变量存放拆分的方法数。divN（n，k）使用n表示要分解的整数，k表示res数组下标，即第k次拆分。先从divN（n，1）开始，用num表示第k个拆分的数，即res[k]=num，让num在[1，n]内遍历。用rest=n-num表示拆分后剩下的整数值。若rest等于零...
数论 —— 整数分解
Alex_McAvoy的博客
08-01 1万+
【概述】 整数分解目前仍是世界级难题，是非常重要的研究方向，其有很多种算法，性能上各有差异，本文仅介绍试除法、Fermat 算法、Pollard Rho 算法。 【试除法】 试除法也叫穷举法，是整数分解算法中最简单和最容易理解的算法，但也是效率最低的算法。 试除法是用小于等于 n 的每个素数去试除待分解的整数，如果找到一个数能够整除除尽，这个数就是待分解整数的因子。 试除法一定能够找到 ...
一个分解整数的方法
scsongls的专栏
12-30 1743
一个分解整数的算法 这里提供一个分解整数的算法，该算法可能存在不足，欢迎大家批评指证。一、原理介绍 在介绍算法前，先介绍一下原理。 ①、设a≡b(mod n)，如果(a，n)=c>1，那么(b，n)=c>1，或者如果(b，n)=c>1，则(a，n)=c>1。 证明: ∵a≡b(mod n) => a-jn=b，j≥0 又 ∵(a，n)=c>1 => a=cf，n=cg (f,g≥1) ∴ 代入上式
整数分解问题（二）
陌初的专栏
01-03 1108
我们一起来看看这个问题吧！上个问题我们已经接触过整数分解了，那么你有没有一定的了解了吗？ 题意：输出N的整数分解 有没有感觉比上一题简单多了，没有脑筋急转和，题意粗暴明了，唯一让人头疼的是，怎么输出呢？ 需要注意的是，如果幂为1次，则不需要输入该幂！如果幂超过两次，则需要用括号单独包起来 #include   #include   using namespace std;  #define
python正整数分解质因数
最新发布
01-04
以下是一个用Python分解正整数质因数的例子： ```python num = int(input("请输入一个正整数：")) ans1 = [] # 存质因数 ans2 = [] # 存质因数的指数 def test(num): for i in range(2, num): if num % i == 0: ans1.append(i) sum = 0 while num % i == 0: sum += 1 num /= i ans2.append(sum) t = [] # 统一整合 test(num) t.append(ans1) t.append(ans2) print(t) ``` 这段代码会将输入的正整数分解为质因数和对应的指数，并将结果存储在列表`t`中。其中，`ans1`存储质因数，`ans2`存储质因数的指数。最后，将`t`打印出来即可得到结果。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

笑着的程序员

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

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

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

打赏作者

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

抵扣说明：

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

余额充值