用c++写一个通过频繁项集生成强项集及强关联规则的算法

首先，我们需要定义一些数据结构来存储事务以及频繁项集和支持度计数。这里我们可以用一个二维数组来表示事务，用一个结构体来表示频繁项集和支持度计数：

// 定义事务
vector<vector<int>> transactions;

// 定义频繁项集及支持度计数结构体
struct Itemset {
    vector<int> items; // 频繁项集
    int support; // 支持度计数
};

接下来，我们可以定义一个函数来生成候选项集。这里我们可以用 Apriori 算法来生成候选项集。Apriori 算法的基本思路是：频繁项集的子集也是频繁项集。

// 生成候选项集
vector<Itemset> generateCandidateItemsets(vector<Itemset> frequentItemsets) {
    vector<Itemset> candidateItemsets;

    // 遍历每一个频繁项集
    for (int i = 0; i < frequentItemsets.size(); i++) {
        // 遍历后面的频繁项集
        for (int j = i + 1; j < frequentItemsets.size(); j++) {
            // 比较前 k - 1 个项是否相等
            bool isMergeable = true;
            for (int k = 0; k < frequentItemsets[i].items.size() - 1; k++) {
                if (frequentItemsets[i].items[k] != frequentItemsets[j].items[k]) {
                    isMergeable = false;
                    break;
                }
            }

            // 如果前 k - 1 个项相等，则合并两个频繁项集
            if (isMergeable) {
                Itemset candidateItemset;
                candidateItemset.items = frequentItemsets[i].items;
                candidateItemset.items.push_back(frequentItemsets[j].items.back());
                candidateItemset.support = 0;
                candidateItemsets.push_back(candidateItemset);
            }
        }
    }

    return candidateItemsets;
}

接下来，我们可以定义一个函数来计算候选项集的支持度计数。

// 计算候选项集的支持度计数
void countSupport(vector<Itemset>& itemsets) {
    // 遍历每一个事务
    for (int i = 0; i < transactions.size(); i++) {
        // 遍历每一个候选项集
        for (int j = 0; j < itemsets.size(); j++) {
            // 判断候选项集是否为事务的子集
            bool isSubset = true;
            for (int k = 0; k < itemsets[j].items.size(); k++) {
                if (find(transactions[i].begin(), transactions[i].end(), itemsets[j].items[k]) == transactions[i].end()) {
                    isSubset = false;
                    break;
                }
            }

            // 如果是事务的子集，则增加候选项集的支持度计数
            if (isSubset) {
                itemsets[j].support++;
            }
        }
    }
}

接下来，我们可以定义一个函数来生成频繁项集。这里我们可以用一个阈值来筛选出支持度计数大于等于阈值的频繁项集。

// 生成频繁项集
vector<Itemset> generateFrequentItemsets(vector<Itemset> candidateItemsets, int minSupport) {
    vector<Itemset> frequentItemsets;

    // 遍历每一个候选项集
    for (int i = 0; i < candidateItemsets.size(); i++) {
        // 如果支持度计数大于等于阈值，则加入频繁项集
        if (candidateItemsets[i].support >= minSupport) {
            frequentItemsets.push_back(candidateItemsets[i]);
        }
    }

    return frequentItemsets;
}

最后，我们可以定义一个函数来生成强项集及强关联规则。这里我们可以用一个阈值来筛选出置信度大于等于阈值的强关联规则。

// 生成强项集及强关联规则
void generateStrongRules(vector<Itemset> frequentItemsets, int minSupport, float minConfidence) {
    // 遍历每一个频繁项集
    for (int i = 0; i < frequentItemsets.size(); i++) {
        // 遍历每一个子集
        for (int j = 0; j < pow(2, frequentItemsets[i].items.size()); j++) {
            vector<int> subset;
            for (int k = 0; k < frequentItemsets[i].items.size(); k++) {
                if (j & (1 << k)) {
                    subset.push_back(frequentItemsets[i].items[k]);
                }
            }

            // 如果子集不为空且不等于本身，则计算置信度
            if (subset.size() > 0 && subset.size() < frequentItemsets[i].items.size()) {
                vector<int> complement;
                set_difference(frequentItemsets[i].items.begin(), frequentItemsets[i].items.end(), subset.begin(), subset.end(), inserter(complement, complement.begin()));
                int supportSubset = 0;
                int supportComplement = 0;
                for (int k = 0; k < transactions.size(); k++) {
                    bool isSubset = true;
                    bool isComplement = true;
                    for (int l = 0; l < subset.size(); l++) {
                        if (find(transactions[k].begin(), transactions[k].end(), subset[l]) == transactions[k].end()) {
                            isSubset = false;
                            break;
                        }
                    }
                    for (int l = 0; l < complement.size(); l++) {
                        if (find(transactions[k].begin(), transactions[k].end(), complement[l]) == transactions[k].end()) {
                            isComplement = false;
                            break;
                        }
                    }
                    if (isSubset) {
                        supportSubset++;
                    }
                    if (isComplement) {
                        supportComplement++;
                    }
                }
                float confidence = (float)supportSubset / (float)(supportSubset + supportComplement);
                if (confidence >= minConfidence) {
                    cout << "{";
                    for (int k = 0; k < subset.size(); k++) {
                        cout << subset[k];
                        if (k < subset.size() - 1) {
                            cout << ", ";
                        }
                    }
                    cout << "} => {";
                    for (int k = 0; k < complement.size(); k++) {
                        cout << complement[k];
                        if (k < complement.size() - 1) {
                            cout << ", ";
                        }
                    }
                    cout << "} (support = " << frequentItemsets[i].support << ", confidence = " << confidence << ")" << endl;
                }
            }
        }
    }
}

完整代码如下：