C++ 实现 组合

一：问题

二：单纯组合

#include <iostream>
#include <vector>

// 递归函数生成组合
void generateCombinations(const std::vector<char>& elements, int k, int start, std::vector<char>& current, std::vector<std::vector<char>>& result) {
    // 如果当前组合的大小等于 k，将其添加到结果中
    if (current.size() == k) {
        result.push_back(current);
        return;
    }

    // 遍历剩余元素
    for (int i = start; i < elements.size(); ++i) {
        current.push_back(elements[i]); // 选择当前元素
        generateCombinations(elements, k, i + 1, current, result); // 递归选择下一个元素
        current.pop_back(); // 回溯，移除当前元素
    }
}

int main2() {
    std::vector<char> elements = { 'a', 'b', 'c'}; // 元素集合
    std::vector<std::vector<char>> result; // 存储所有组合
    std::vector<char> current; // 当前组合

    for (int i=1; i<=4; ++i)
    {
        // 生成组合
        generateCombinations(elements, i, 0, current, result);
    }
   
    // 输出所有组合
    std::cout << "C(3, 2) 的所有组合为：" << std::endl;
    for (const auto& comb : result) {
        for (char ch : comb) {
            std::cout << ch << " ";
        }
        std::cout << std::endl;
    }
    return 0;
}

C(3, 2) 的所有组合为：
a
b
c
a b
a c
b c
a b c

三：实际解决问题

#include <iostream>
#include <iterator>
#include <vector>
#include <set>
using namespace std;
struct AA {
    int p;
    int w;
    int n;
};
int nMaxR = 0;
int m, n;
std::vector<AA> vA;

void calcData(std::vector<int>& src, std::vector<int>& vTemp, int index, int k)
{
    auto calcRes = [&]() {
        int nSP = 0;
        int nSW = 0;
        std::vector<int> sZ(n,0);
        for (auto dd : vTemp)
        {
            if (vA[dd].n == 0 && sZ[dd] == 0)
            {
                sZ[dd] = 1;
                nSP += vA[dd].p;
                nSW += vA[dd].p * vA[dd].w;
            }
            else if(vA[dd].n > 0)
            {
                nSP += vA[dd].p;
                nSW += vA[dd].p * vA[dd].w;
                int cz = vA[dd].n - 1;
                if (sZ[cz] == 0)
                {
                    sZ[cz] = 1;
                    nSP += vA[cz].p;
                    nSW += vA[cz].p * vA[cz].w;
                }
            }
            if(nSP > m)
            {
                return;
            }
        }
        nMaxR = max(nMaxR, nSW);
        };
    if (vTemp.size() == k)
    {
        calcRes();
        return;
    }
    for (int i = index; i < src.size(); ++i)
    {
        vTemp.push_back(src[i]);
        calcData(src, vTemp, i + 1, k);
        vTemp.pop_back();
    }
}

void calc(std::vector<int>& src, int k)
{
    std::vector<int> vTemp;
    calcData(src, vTemp, 0, k);
}

int main() {
    //输入值
    cin >> m >> n;
    vA.resize(n);
    std::vector<int> vIndex(n);
    for (int i = 0; i < n; ++i)
    {
        cin >> vA[i].p >> vA[i].w >> vA[i].n;
        vIndex[i] = i;
    }
    //组合数
    for (int i = 1; i <= n; ++i)
    {
        calc(vIndex, i);
    }
    cout << nMaxR << endl;
    return 0;
}