UVa 10568 n Group k

AI 应用开发 × 算法面试题:业务场景实战 12 题【TopK、LRU、RRF 融合、相似度、限流算法,含手撕代码与底层答案】 本文聚焦AI应用岗算法面试新趋势,剖析12道融合业务场景的高频题:从海量日志中挖掘慢查询(分治+小顶堆)、亿级去重(布隆过滤器)、向量与关键词融合排序(RRF)、语义缓存设计(带租户隔离与TTL的LRU)到限流策略(令牌桶+滑动窗口),强调“场景复述→算法选型→手撕代码→生产落地”四步答题框架。突出考察点已从纯算法转向工程权衡、业务理解与系统设计能力,如误判容忍度、实时性与内存预算的平衡,助力开发者应对2026年真实技术挑战。 阅读详情

题目描述

教授 X 要给 NNN 个学生分组完成学期任务,他希望每个小组恰好有 KKK 个学生。 当无法让所有小组都恰好有 KKK 个学生时,最多可以有一个小组的学生数少于 KKK 。 学生用前 NNN 个大写英文字母表示( A 到 A + N - 1 )。

我们需要处理两种查询:

  1. COUNT\texttt{COUNT}COUNT NNN KKK :计算可以组成小组的方式数量
  2. GENERATE\texttt{GENERATE}GENERATE NNN KKK :生成所有可能的分组方式列表

分组规则

  • 每个学生只能属于一个小组
  • 小组内学生的不同排列顺序被视为相同(即组内无序)
  • 组内学生按字母顺序排列
  • 组间按字典序排列(使用 ASCII 值比较)
  • 所有解按字典序排序

输入限制

  • 最多 1200 个测试用例
  • COUNT\texttt{COUNT}COUNT 查询: 1≤N,K≤301 \le N, K \le 301≤N,K≤30
  • GENERATE\texttt{GENERATE}GENERATE 查询: 1≤N,K≤151 \le N, K \le 151≤N,K≤15
  • 每个 GENERATE\texttt{GENERATE}GENERATE 查询的解不超过 100001000010000 行
  • 所有 GENERATE\texttt{GENERATE}GENERATE 查询的总解不超过 300003000030000 行

题目分析

分组情况分析

设总人数为 NNN ,理想小组大小为 KKK ,则:

  1. 整除情况 :当 N mod K=0N \bmod K = 0NmodK=0 时

    • 所有小组大小都为 KKK
    • 小组数 g=N/Kg = N / Kg=N/K
  2. 非整除情况 :当 N mod K=r>0N \bmod K = r > 0NmodK=r>0 时

    • 有一个小组大小为 rrr
    • 其余 g−1g-1g−1 个小组大小都为 KKK
    • 小组数 g=⌈N/K⌉g = \lceil N/K \rceilg=⌈N/K⌉

数学建模

这是一个 集合划分问题 ,需要考虑以下关键点:

  1. 组内无序 :小组内学生的排列顺序不重要
  2. 组间有序性 :当所有小组大小相同时,组间是无序的;当有不同大小的小组时,大小不同的小组是独特的
  3. 字母顺序 :组内按字母顺序排列,这简化了生成过程

计数公式推导

情况 111:整除情况( N mod K=0N \bmod K = 0NmodK=0 )

小组数 g=N/Kg = N/Kg=N/K ,所有小组大小都为 KKK 。

计算步骤:

  1. 将 NNN 个不同学生分配到 ggg 个小组中,每个小组大小为 KKK
  2. 由于组间无序,需要除以 g!g!g!

公式:
count=N!(K!)g⋅g! \texttt{count} = \frac{N!}{(K!)^g \cdot g!} count=(K!)g⋅g!N!​

情况 222:非整除情况( N mod K=r>0N \bmod K = r > 0NmodK=r>0 )

小组数 g=⌈N/K⌉g = \lceil N/K \rceilg=⌈N/K⌉ ,有一个小组大小为 rrr ,其余 g−1g-1g−1 个小组大小为 KKK 。

计算步骤:

  1. 从 NNN 个学生中选择 rrr 个给较小的组: C(N,r)C(N, r)C(N,r)
  2. 将剩余 N−rN-rN−r 个学生分配到 g−1g-1g−1 个大小为 KKK 的组中
  3. 大小为 KKK 的组之间无序,需要除以 (g−1)!(g-1)!(g−1)!

公式:
count=C(N,r)⋅(N−r)!(K!)g−1⋅(g−1)! \texttt{count} = C(N, r) \cdot \frac{(N-r)!}{(K!)^{g-1} \cdot (g-1)!} count=C(N,r)⋅(K!)g−1⋅(g−1)!(N−r)!​

大数处理

对于 COUNT\texttt{COUNT}COUNT 查询, N,K≤30N, K \le 30N,K≤30 ,最大的阶乘 30!≈2.65×103230! \approx 2.65 \times 10^{32}30!≈2.65×1032 ,这超出了 646464 位无符号整数的范围(最大值约 1.84×10191.84 \times 10^{19}1.84×1019 )。 因此需要使用 128128128 位整数 来避免溢出。

解题思路

1. COUNT\texttt{COUNT}COUNT 查询实现

使用 __int128 类型处理大数计算:

  1. 预计算阶乘表 factorial[0..30]
  2. 根据 NNN 和 KKK 的关系选择公式
  3. 使用组合数函数计算 C(N,r)C(N, r)C(N,r)
  4. 使用阶乘除法计算结果
  5. 将 __int128 转换为字符串输出

2. GENERATE\texttt{GENERATE}GENERATE 查询实现

使用 回溯法(DFS\texttt{DFS}DFS) 生成所有解:

算法步骤:
  1. 表示方法 :用字符串表示小组,如 ABC 表示包含学生 A、B、C 的小组
  2. 状态表示 :
    • currentGroups :当前已形成的小组列表
    • used :标记哪些学生已被分配
    • currentGroupSize :当前小组的当前大小
    • currentGroupStart :当前小组的下一个学生起始索引(保证组内字母顺序)
  3. 递归过程 :
    • 如果所有学生都已分配(idx == N),检查是否满足小组大小约束(最多一个小组小于 KKK),如果满足则保存解
    • 否则:
      • 尝试将当前学生加入现有小组(如果小组未满)
      • 尝试开始一个新小组
  4. 排序规则 :
    • 组内:按字母顺序(通过 currentGroupStart 参数保证)
    • 组间:按字符串字典序
    • 所有解:按组序列的字典序排序
剪枝优化:
  1. 通过 currentGroupStart 参数避免生成组内无序的重复解
  2. 只在必要时开始新小组
  3. 及时检查小组大小约束

时间复杂度分析

COUNT\texttt{COUNT}COUNT 查询

  • 预计算阶乘: O(30)O(30)O(30)
  • 每次查询: O(1)O(1)O(1)

GENERATE\texttt{GENERATE}GENERATE 查询

  • 最坏情况: N=15,K=1N=15, K=1N=15,K=1 ,解数为 15!=130767436800015! = 130767436800015!=1307674368000 ,但题目保证不超过 10000 个解
  • 实际运行:由于 N≤15N \le 15N≤15 且解数有限,回溯法可以接受

代码实现

// n Group k
// UVa ID: 10568
// Verdict: Accepted
// Submission Date: 2025-12-14
// UVa Run Time: 0.320s
//
// 版权所有(C)2025,邱秋。metaphysis # yeah dot net

#include <bits/stdc++.h>
using namespace std;

using ull = unsigned long long;
using int128 = __int128;

// 预计算阶乘
vector<int128> factorial(31);
void precomputeFactorial() {
    factorial[0] = 1;
    for (int i = 1; i <= 30; ++i) factorial[i] = factorial[i - 1] * i;
}

// 组合数计算 C(n, k)
int128 combination(int n, int k) {
    if (k < 0 || k > n) return 0;
    if (k > n - k) k = n - k;
    
    int128 result = 1;
    for (int i = 1; i <= k; ++i) {
        result = result * (n - k + i) / i;
    }
    return result;
}

// 计算分组数
int128 countWays(int n, int k) {
    int groups = (n + k - 1) / k;  // ceil(n/k)
    int remainder = n % k;
    
    if (remainder == 0) {
        // 所有组大小都是k
        int128 ways = factorial[n];
        
        // 除以 (k!)^groups
        int128 kFactorial = factorial[k];
        for (int i = 0; i < groups; ++i) ways /= kFactorial;
        
        // 除以 groups! (组间无序)
        ways /= factorial[groups];
        return ways;
    } else {
        // 有一个大小为remainder的组,其余groups-1个组大小为k
        // 1. 选择remainder个学生给较小的组
        int128 ways = combination(n, remainder);
        
        // 2. 剩余学生分配到groups-1个大小为k的组中
        int remaining = n - remainder;
        ways *= factorial[remaining];
        
        // 除以 (k!)^(groups-1)
        int128 kFactorial = factorial[k];
        for (int i = 0; i < groups - 1; ++i) ways /= kFactorial;
        
        // 除以 (groups-1)! (大小为k的组之间无序)
        ways /= factorial[groups - 1];
        return ways;
    }
}

// 生成所有解的数据结构
vector<vector<string>> allSolutions;
string students;
int N, K;

void generateSolutions(int idx, vector<string>& currentGroups, vector<bool>& used, 
                       int currentGroupSize, int currentGroupStart) {
    if (idx == N) {
        int smallGroups = 0;
        for (const auto& group : currentGroups) {
            if ((int)group.size() < K) smallGroups++;
        }
        if (smallGroups <= 1) allSolutions.push_back(currentGroups);
        return;
    }

    // 尝试加入当前组
    if (!currentGroups.empty() && currentGroupSize < K) {
        for (int i = currentGroupStart; i < N; ++i) {
            if (!used[i]) {
                used[i] = true;
                currentGroups.back().push_back(students[i]);
                generateSolutions(idx + 1, currentGroups, used, currentGroupSize + 1, i + 1);
                currentGroups.back().pop_back();
                used[i] = false;
            }
        }
    }

    // 开始新组
    if ((int)currentGroups.size() < (N + K - 1) / K) {
        for (int i = 0; i < N; ++i) {
            if (!used[i]) {
                used[i] = true;
                currentGroups.push_back(string(1, students[i]));
                generateSolutions(idx + 1, currentGroups, used, 1, i + 1);
                currentGroups.pop_back();
                used[i] = false;
                break;
            }
        }
    }
}

// 将int128转换为字符串
string int128ToString(int128 n) {
    if (n == 0) return "0";
    
    string result = "";
    bool negative = false;
    
    if (n < 0) {
        negative = true;
        n = -n;
    }
    
    while (n > 0) {
        result = char('0' + (n % 10)) + result;
        n /= 10;
    }
    
    if (negative) result = "-" + result;
    return result;
}

int main() {
    precomputeFactorial();
    string query;
    
    while (cin >> query) {
        if (query == "END") break;
        
        int n, k;
        cin >> n >> k;
        
        if (query == "COUNT") {
            int128 result = countWays(n, k);
            cout << int128ToString(result) << endl;
        } 
        else if (query == "GENERATE") {
            N = n;
            K = k;
            students = "";
            for (int i = 0; i < n; ++i) students += char('A' + i);
            
            allSolutions.clear();
            vector<string> currentGroups;
            vector<bool> used(n, false);
            
            // 开始第一个组
            if (n > 0) {
                used[0] = true;
                currentGroups.push_back(string(1, students[0]));
                generateSolutions(1, currentGroups, used, 1, 1);
            } else {
                allSolutions.push_back({});
            }

            // 排序解
            sort(allSolutions.begin(), allSolutions.end());
            
            // 输出数量
            cout << allSolutions.size() << endl;
            
            // 输出具体解
            for (const auto& sol : allSolutions) {
                for (size_t i = 0; i < sol.size(); ++i) {
                    if (i > 0) cout << " ";
                    cout << sol[i];
                }
                cout << endl;
            }
        }
    }
    
    return 0;
}

总结

本题的核心在于:

  1. 数学推导 :正确推导分组计数的组合数学公式,注意区分整除和非整除情况,正确处理组间无序性
  2. 大数处理 :使用 __int128 避免阶乘计算溢出
  3. 回溯生成 :使用 DFS\texttt{DFS}DFS 生成所有解,通过参数控制避免重复和保证排序规则
  4. 排序实现 :严格按照题目要求的三种排序规则实现

关键难点在于处理 COUNT\texttt{COUNT}COUNT 查询时的大数计算和 GENERATE\texttt{GENERATE}GENERATE 查询时的排序约束。 通过预计算阶乘、使用 __int128 类型和精心设计的回溯算法,可以高效解决这两个问题。

DJI MobileSDK运行实例代码教程(保姆级)坑踩完了 其中比较重要的是PackageName也就是我们应用的包名,在这里我们可以直接使用官方文档中的包名,com.dji.ImportSDKDemo,appname为:ImportSDKDemo,其他的可以随意。在C盘中根据路径先找到 “用户/admin/.gradle”下的.gradle文件夹,然后依次打开wrapper/dists文件夹,找到我们刚刚要下载的gradle版本名的文件夹。在Androidstudio中打开,选在打开项目选择文件下载后的保存路径(解压之后的),在打开项目后会自动下载gradle。 阅读详情

相关推荐

OpenClaw 企业级自动化系统架构设计与实现

本文介绍基于 OpenClaw 构建的企业级自动化系统的完整架构设计、技术选型、实现细节和性能优化方案。

2604_95445636的博客 485

UVa Problem 10181 15-Puzzle Problem (15 数码游戏)

// 15-Puzzle Problem (15 数码游戏)// PC/UVa IDs: 110802/10181, Popularity: B, Success rate: average Level: 3// Verdict: Accepted // Submission Date: 2011-06-22// UVa Run Time: 0.320s//// 版权所有(C)20

寂静山林 6946

利用GPAC生成MP4文件

GPAC主要针对学生和内容创作者,代表了一个跨平台的多媒体框架,开发人员可以使用它在 LGPL 许可下制作开源媒体。GPAC多媒体框架兼容范围广泛的流行文件类型,从常见格式(如 AVI、MPEG 和 MOV)到复杂格式(如 MPEG-4 系统或 VRML/X3D)和 360 电影。

深之JohnChen的专栏 1774

UVa Problem 861 Little Bishops (棋盘上的象)

// Little Bishops (棋盘上的象)// PC/UVa IDs: 110801/861, Popularity: C, Success rate: high Level: 2// Verdict: Accepted // Submission Date: 2011-06-19// UVa Run Time: 0.024s//// 版权所有(C)2011,邱秋。meta

寂静山林 5903

高精度磁力计RM3100 传感器LR振荡电路偏置电路分析

LR振荡器电路通过正向和反向偏置实现磁场测量。Sen-XY-f/Z-f传感器线圈作为电感元件构成LR弛张振荡电路,其振荡频率随磁场变化而改变。测量时,线圈一端接地,另一端交替通入正反向电流,通过两次偏置测量消除电路自身磁场干扰,仅保留外部磁场影响。MagI2C芯片通过高速时钟测量振荡次数和时间差,计算磁场强度。该设计具有抗干扰强、数字化输出和高分辨率等优势,是RM3100传感器高精度磁测量的核心原理。

bother3000的博客 1138

铭飞MCMS源码部署

文章目录前言一、下载铭飞源码二、部署源码1.使用IDEA打开源码2.配置tomcat环境2.1下载tomcat并测试是否可以成功启动(此处不赘述)2.2在IDEA中安装tomcat环境并配置3.添加数据库,并配置3.1新建数据库3.2 导入sql配置三、启动测试 前言 铭飞MCMS基于IDEA、tomcat和mysql的环境搭建。 提示:以下是本篇文章正文内容,下面案例可供参考 一、下载铭飞源码 gitee:https://gitee.com/mingSoft/MCMS/releases(各种版本按需下

MARS_ZORO的博客 4071

UVa Problem 843 Crypt Kicker (解密)

// Crypt Kicker (解密) // PC/UVa IDs: 110204/843, Popularity: B, Success rate: low Level: 2 // Verdict: Accepted // Submission Date: 2011-05-2

寂静山林 5186

CST 2023安装避坑指南:从下载到破解的完整流程(附常见报错解决方案)

本文提供CST 2023三维全波电磁场仿真软件的完整安装指南,涵盖从下载到破解的全流程,并附常见报错解决方案。详细解析安装步骤、许可证配置优化及高频问题诊断,帮助用户快速部署并优化软件性能,适用于射频电路设计、天线优化等场景。

7z8x2c4v6b9的博客 662

UVa Problem 10270 Bigger Square Please... (拼接正方形)

// Bigger Square Please... (拼接正方形) // PC/UVa IDs: 110808/10270, Popularity: C, Success rate: high Level: 3 // Verdict: Accepted // Submissio

寂静山林 4228

CloudCompare 二次开发(36)——非均匀体素降采样

使用CloudCompare与PCL编程实现的非均匀体素降采样。

点云侠的博客 748

pytorch 51 GroundingDINO模型导出tensorrt并使用c++进行部署,53ms一张图

博主基于https://github.com/hpc203/GroundingDINO-onnxrun项目分享的onnx c++推理代码,修改为GroundingDINO模型的tensorrt推理代码。对于600x400的输入,在3060显卡下,cuda 12.1,TensorRT-10.4.0,window环境下53ms处理完一张图片。

a486259的博客 1226

UVa Problem 10032 Tug of War (拔河)

// Tug of War (拔河) // PC/UVa IDs: 110805/10032, Popularity: B, Success rate: low Level: 2 // Verdict: UVa Online Judge - Wrong answer, Progr

寂静山林 4212

VN5620以太网测试——环境搭建篇

CANoe(CAN open environment)VN5620 :是一个紧凑而强大的接口,用于以太网网络的分析、仿真、测试和验证。VN5620 接口支持各种可能的应用。它适用于与其他总线系统、网络参与(例如在模拟和生成帧、测试中的负载和错误)的同步以太网监控。在2021年Vector公司的以太网接口卡VN5610和VN5640设备已经陆续停产,相应被VN5620和VN5650代替。

诊断协议那些事儿's blog 8953

UVa Problem 10160 Servicing Stations (服务站)

// Servicing Stations (服务站) // PC/UVa IDs: 110804/10160, Popularity: B, Success rate: low Level: 3 // Verdict: Accepted // Submission Date:

寂静山林 4076

Data-Structures-and-Algorithm-Analysis-in-Java.pdf

作者: Weiss, Mark A. 出版社: Addison Wesley Data Structures and Algorithm Analysis in Java is an “advanced algorithms” book that fits between traditional CS2 and Algorithms Analysis courses. In the old ACM Curriculum Guidelines, this course was known as CS7. This text is for readers who want to learn good programming and algorithm analysis skills simultaneously so that they can develop such programs with the maximum amo...

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

UVa Problem 10128 Queue (队伍)

// Queue (队伍)// PC/UVa IDs: 110803/10128, Popularity: B, Success rate: high Level: 2// Verdict: Accepted // Submission Date: 2011-07-08// UVa Run Time: 0.040s//// 版权所有(C)2011,邱秋。metaphysis # y

寂静山林 3117

Probability and Statistics - 4th edition

Probability and Statistics - 4th edition

UVa Problem 10001 Garden of Eden (伊甸园)

// Garden of Eden (伊甸园) // PC/UVa IDs: 110806/10001, Popularity: B, Success rate: average Level: 2 // Verdict: Accepted // Submission Date:

寂静山林 3001

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

UVa Problem 704 Colour Hash (色彩缤纷游戏)

// Colour Hash (色彩缤纷游戏) // PC/UVa IDs: 110807/704, Popularity: B, Success rate: average Level: 3 // Verdict: Accepted // Submission Date: 20

寂静山林 2777

UVa 124 Following Orders

// Following Orders // UVa ID: 124 // Verdict: Accepted // Submission Date: 2015-11-27 // UVa Run Time: 0.000s // // 版权所有(C)2015,邱秋。metaphysis # yeah dot net #include #include #include #include

寂静山林 2593

UVa 10447 Sum-up the Primes (II)

本题要求在给定限制下将整数N表示为t个素数之和。所有素数必须小于300,且每个奇数素数有使用次数限制,素数2最多使用一次。需输出字典序最小的解或判定无解。

寂静山林 1591

UVa 12877 GREAT + SWERC = PORTO

本文探讨字母算术谜题的求解方法,如SEND + MORE = MONEY问题。给定n个单词(前n-1个为加数,最后为结果),要求为不同字母分配唯一数字(首字母非零),满足加法等式。采用深度优先搜索算法,通过反转单词实现右对齐处理,逐列验证并剪枝优化。关键步骤包括高位非零约束、进位处理和结果长度验证。对于最多10个字母的情况,算法在合理时间内完成搜索,统计可行解数量。样例测试表明该方法能正确求解不同规模的谜题。

寂静山林 1440

UVa 10798 Be Wary of Roses

题目要求设计一条从N×N网格中心出发的逃生路径,使得无论初始朝向如何,踩到的玫瑰数尽可能少。解题思路是利用旋转对称性,只需搜索第一象限路径,其他方向通过旋转得到。采用DFS算法从中心点开始探索所有可能路径,记录四个方向对应的玫瑰数,并通过剪枝优化搜索效率。预处理阶段计算每个位置到边界的最少玫瑰数作为启发式剪枝依据,进一步减少不必要的搜索。最终输出保证能踩到的最少玫瑰数。该算法通过对称性处理和启发式剪枝有效降低了时间复杂度。

寂静山林 1256

UVa 817 According to Bartjens

在给定数字序列中插入运算符(+、-、*),使表达式结果为2000,且满足无前导零、至少一个运算符等约束条件。 主要挑战: 运算符组合爆炸,需递归生成所有可能表达式 正确处理运算优先级(先乘后加减) 验证数字有效性(无前导零) 解题思路: 使用深度优先搜索递归生成表达式 检查数字有效性和运算符位置 按运算优先级计算表达式值 输出等于2000的表达式或IMPOSSIBLE; 算法复杂度为O(3^(n-1)*n),适用于较短数字序列(n≤9)。

寂静山林 1112

P14361 [CSP-S 2025] 社团招新 解题报告

本题的核心是带限制的贪心。先忽略限制得到理想最优解,再利用反悔机制修正超员部门:将超员部门中“转出损失最小”的成员改派到其他部门。由于总人数为nnn最多只有一个部门会超员,因此只需对该部门进行修正。使用优先队列可以高效地选出损失最小的成员,总复杂度Onlog⁡nOnlogn。

weixin_45254471的博客 320

算法:全景梳理前端项目开发中常用算法合集

本文系统梳理前端高频算法场景,按业务分类汇总10类核心算法:基础查找(哈希、二分)、排序(Timsort、归并)、树结构(DFS/BFS、LCA)、滑动窗口、字符串匹配(正则为主)、节流防抖、虚拟滚动、图算法(Dijkstra、A*)、随机哈希及贪心动态规划。强调前端算法重点在于性能优化与交互流畅,非单纯追求复杂度,推荐优先使用内置方法与成熟库,关键掌握哈希查找、防抖节流、LRU缓存、区间合并、虚拟滚动等必会技能,确保页面不卡顿、响应快。

snow的博客 635

智能体训练-模仿学习-DAgger算法详解与实战

DAgger 用「学习者探索 + 专家标注 + 数据聚合」的简洁思路,优雅地解决了行为克隆的分布偏移问题,并从理论上把复合误差从OϵT2OϵT2降到OϵTOϵT。问题定位准确:明确指出 BC 的失败根源是训练与测试状态分布不一致;方法简单有效:只需在策略访问的状态上补充专家标签;理论保证扎实:通过 no-regret 在线学习框架给出收敛性证明。当然,DAgger 的代价是需要在线访问专家,这在很多真实场景中并不便宜。

qq_42773521的博客 319

算法一千零一夜 · 第三十五夜 · 恢复风暴

第34夜的结尾留了两笔债。一笔是答案的另一半,报告侧敢一把互斥锁都不加地同跑,结构给的那一半当夜讲完,部署给的那一半留到现在。另一笔是 3 个开关,一场风暴。这一夜两笔一起还。

qq_41057763的博客 355
上一篇: UVa 10627 Infinite Race
下一篇: UVa 10838 The Pawn Chess
寂静山林
博客等级 码龄22年 648粉丝 2077原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址