购买计算，剩余最少余额

769687520

身上有145020.8元，商品1价格为57090.5元，商品2价格为16143.54元，商品3价格为15835.28元，商品4价格为9621.4元，商品5价格为8071.76元
怎么买才剩余最少的钱，可以重复买，
比如买商品2买8个，商品3买1个
16143.54X8=129148.32
145020.8-129148.32-15835.28=37.2
剩余最少37.2元，该怎么用易语言写

a2083657

根据楼主提供的例子
身上有145020.8元，商品1价格为57090.5元，商品2价格为16143.54元，商品3价格为15835.28元，商品4价格为9621.4元，商品5价格为8071.76元
怎么买才剩余最少的钱，可以重复买，
比如买商品2买8个，商品3买1个
16143.54X8=129148.32
145020.8-129148.32-15835.28=37.2


通过脚本计算得到
[color=rgba(0, 0, 0, 0.85)][backcolor=rgba(0, 0, 0, 0.04)]最优购买方案 -----商品5 × 1 = 8071.76商品4 × 1 = 9621.4商品3 × 6 = 95011.68商品2 × 2 = 32287.08----------------------总花费：144991.92剩余金额：28.88----------------------
[color=rgba(0, 0, 0, 0.85)][backcolor=rgba(0, 0, 0, 0.04)]

[color=rgba(0, 0, 0, 0.85)][backcolor=rgba(0, 0, 0, 0.04)]37.2并非为最优解
[color=rgba(0, 0, 0, 0.85)][backcolor=rgba(0, 0, 0, 0.04)]

[color=rgba(0, 0, 0, 0.85)][backcolor=rgba(0, 0, 0, 0.04)]

[color=rgba(0, 0, 0, 0.85)]脚本的核心逻辑是通过[color=var(--md-box-samantha-deep-text-color) !important]递归算法 + 穷举搜索[color=rgba(0, 0, 0, 0.85)]来尝试所有可能的商品购买组合，找到总花费最接近预算（剩余金额最少）的方案
核心思路：递归穷举所有组合
[color=rgba(0, 0, 0, 0.85)]对每个商品，从最大可能数量开始尝试（优先尝试高价组合，可能更快找到优解），通过递归逐层确定所有商品的数量，最终验证组合是否更优。
[color=rgba(0, 0, 0, 0.85)]每次找到更优的组合时（剩余金额更少），立即更新最佳余额[color=rgba(0, 0, 0, 0.85)]和最佳组合[color=rgba(0, 0, 0, 0.85)]，并通过显示结果[color=rgba(0, 0, 0, 0.85)]函数实时展示在界面上
[color=rgba(0, 0, 0, 0.85)]这个脚本的核心是[color=var(--md-box-samantha-deep-text-color) !important]暴力穷举所有可能的组合[color=rgba(0, 0, 0, 0.85)]，通过递归逐层确定每个商品的购买数量，并用贪心策略（从大到小尝试数量）和剪枝（限制数量）优化计算量。
[color=rgba(0, 0, 0, 0.85)]虽然逻辑简单直接，但存在效率和精度问题，适合小规模问题（如 5 种商品、数量限制 20），但面对更多商品或无数量限制时需进一步优化算法。
[color=rgba(0, 0, 0, 0.85)]

计算最优组合.e (967.3 KB, 下载次数: 3)

2025-5-22 14:03 上传

点击文件名下载附件


[color=rgba(0, 0, 0, 0.85)]

z13228604287

[C++] 纯文本查看 复制代码

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>

struct Item {
    double price;
    int maxCount;  // 最大购买数量
};

struct Combination {
    std::vector<int> counts;  // 每种商品的购买数量
    double total;             // 总价
};

// 递归生成所有可能的组合
void generateCombinations(const std::vector<Item>& items, int index, Combination current, 
                          std::vector<Combination>& result, double budget) {
    if (index == items.size()) {
        if (current.total <= budget) {
            result.push_back(current);
        }
        return;
    }

    const Item& item = items[index];
    int maxCount = std::min(static_cast<int>(budget / item.price), item.maxCount);

    for (int count = 0; count <= maxCount; ++count) {
        Combination newComb = current;
        newComb.counts[index] = count;
        newComb.total += item.price * count;
        
        if (newComb.total > budget) continue;  // 剪枝：超出预算则跳过
        
        generateCombinations(items, index + 1, newComb, result, budget);
    }
}

int main() {
    double budget = 145020.8;
    std::vector<Item> items = {
        {57090.5, static_cast<int>(budget / 57090.5)},    // 商品1
        {16143.54, static_cast<int>(budget / 16143.54)},  // 商品2
        {15835.28, static_cast<int>(budget / 15835.28)},  // 商品3
        {9621.4, static_cast<int>(budget / 9621.4)},      // 商品4
        {8071.76, static_cast<int>(budget / 8071.76)}     // 商品5
    };

    // 初始化当前组合
    Combination initial;
    initial.counts.resize(items.size(), 0);
    initial.total = 0.0;

    // 生成所有可能的组合
    std::vector<Combination> combinations;
    generateCombinations(items, 0, initial, combinations, budget);

    // 找到最接近预算的组合
    double minRemainder = INT_MAX;
    const Combination* bestCombination = nullptr;

    for (const auto& comb : combinations) {
        double remainder = budget - comb.total;
        if (remainder >= 0 && remainder < minRemainder) {
            minRemainder = remainder;
            bestCombination = &comb;
        }
    }

    // 输出结果
    if (bestCombination) {
        std::cout << "最优购买方案：" << std::endl;
        for (size_t i = 0; i < items.size(); ++i) {
            if (bestCombination->counts > 0) {
                std::cout << "商品" << (i + 1) << " x " << bestCombination->counts 
                          << " = " << items.price * bestCombination->counts << "元" << std::endl;
            }
        }
        std::cout << "总价：" << bestCombination->total << "元" << std::endl;
        std::cout << "剩余金额：" << minRemainder << "元" << std::endl;
    } else {
        std::cout << "没有找到合适的购买组合。" << std::endl;
    }

    return 0;
}    

萌新来学习

这可太复杂了

补充内容 (2025-5-22 09:36):
数学太差，唉

769687520

z13228604287 发表于 2025-5-22 09:32
[mw_shl_code=cpp,true]#include
#include
#include

哥，有E的代码吗？

青春已不再

  

子程序名	返回值类型	公开	备 注
__启动窗口_创建完毕

变量名	类 型	静态	数组	备 注
总金额	双精度小数型
花费	双精度小数型
剩余	双精度小数型
x2	整数型
x3	整数型

总金额 ＝ 145020.8
x2 ＝ 8  ' 商品2购买数量
x3 ＝ 1  ' 商品3购买数量
' 计算总花费和剩余金额
花费 ＝ x2 × 16143.54 ＋ x3 × 15835.28
剩余 ＝ 总金额 － 花费
信息框 (“最优购买方案：” ＋ #换行符 ＋ “商品2：” ＋ 到文本 (x2) ＋ “个” ＋ #换行符 ＋ “商品3：” ＋ 到文本 (x3) ＋ “个” ＋ #换行符 ＋ “剩余金额：” ＋ 到文本 (剩余), 0, “最少剩余”, )

.版本 2<br /> <br /> .子程序 __启动窗口_创建完毕<br /> .局部变量 总金额, 双精度小数型<br /> .局部变量 花费, 双精度小数型<br /> .局部变量 剩余, 双精度小数型<br /> .局部变量 x2, 整数型<br /> .局部变量 x3, 整数型<br /> <br /> 总金额 ＝ 145020.8<br /> <br /> x2 ＝ 8  ' 商品2购买数量<br /> <br /> x3 ＝ 1  ' 商品3购买数量<br /> <br /> ' 计算总花费和剩余金额<br /> 花费 ＝ x2 × 16143.54 ＋ x3 × 15835.28<br /> <br /> 剩余 ＝ 总金额 － 花费<br /> <br /> 信息框 (“最优购买方案：” ＋ #换行符 ＋ “商品2：” ＋ 到文本 (x2) ＋ “个” ＋ #换行符 ＋ “商品3：” ＋ 到文本 (x3) ＋ “个” ＋ #换行符 ＋ “剩余金额：” ＋ 到文本 (剩余), 0, “最少剩余”, )

769687520

青春已不再 发表于 2025-5-22 09:45
[e=3].版本 2

.子程序 __启动窗口_创建完毕

哥，你这答案抄的的真好

青春已不再

769687520 发表于 2025-5-22 09:48
哥，你这答案抄的的真好

数学不行就抄答案呗！找个数学好的给你研究一下

花间一壶酒

得方程吧

aipca

大概这个意思