编写一个C++程序来查找布尔表达式的内核

问：

我是一名大学生，我有一个编程作业，要求我们在布尔表达式中找到内核。老师提供的文档有一个示例伪代码来指导我们如何编写程序。伪代码如下。

// Kernel Algorithm
FindKernels(cube-free SOP expression F) // F: input Boolean function
{
    K = empty; // K: list of kernel(s)
    for(each variable x in F)
    {
        if(there are at least 2 cubes in F that have variable x)
        {
            let S = {cubes in F that have variable x in them};
            let co = cube that results from intersection of all cubes
            in S, this will be the product of just those literals that appear in
            each of these cubes in S;
            K = K ∪ FindKernels(F / co);
        }
    }
    K = K ∪ F ;
    return( K )
}

但我不知道“co”的定义是什么意思。据我所知，S 是那些具有变量 X 的项。以“abc + abd + bcd = b（ac + ad + cd）”为例，S = {abc， abd， bcd}。但什么是公司？？

我还编写了另一个程序

#include <iostream>
#include <fstream>
#include <cstdlib>
#include <iomanip>
#include <vector>
#include <string>
#include <algorithm>

using namespace std;

void find_kernels(vector<string> &terms);
bool eliminate_char(string &doing, char eliminate);
void eliminate_char_complete(vector<string> &terms, char eliminate);

int main()
{
    string file_name;
    vector<string> expression;
    vector<string> expression_name;
    string expression_temp, expression_name_temp, input_untruncated;
    vector<vector<string>> terms;//break each expression into each term

    here:

    cout << "Please enter the file name that you want to load: ";
    cin >> file_name;
    ifstream load_file(file_name, ios::in);
    if(!load_file)
    {
        cout << "The file you choose cannot be opened!\n";
        goto here;
    }

    there:

    cout << "Please enter the name of the output file: ";
    cin >> file_name;
    ofstream output_file(file_name, ios::out);
    if(!output_file)
    {
        cout << "The file cannot be created!\n";
        goto there;
    }

    while(load_file >> input_untruncated)
    {
        expression_name_temp = input_untruncated.substr(0, input_untruncated.find("="));
        expression_temp = input_untruncated.substr(input_untruncated.find("=") + 1);
        expression_name.push_back(expression_name_temp);
        expression.push_back(expression_temp);
    }



    //start to truncate every terms
    for(int i = 0 ; i < (int)expression.size() ; i++)
    {
        int j = 0;
        int k = 0;//k >> last time location
        vector<string> terms_temp_vector;
        string terms_temp;
        string expression_trans = expression[i];
        while(j < (int)expression[i].size())
        {
            if(expression_trans[j] == '+' || expression_trans[j] == '-')
            {
                terms_temp = expression_trans.substr(k, j - k);
                terms_temp_vector.push_back(terms_temp);
                k = j + 1;
            }
            j++;
        }
        terms_temp = expression_trans.substr(k);
        terms_temp_vector.push_back(terms_temp);

        terms.push_back(terms_temp_vector);
    }

    /*for(int i = 0 ; i < (int)expression.size() ; i++)
    {
        cout << "expression_name: " << expression_name[i] << endl;
        cout << expression[i] << endl;
        cout << "terms: ";
        for(int j = 0 ; j < (int)terms[i].size() ; j++)
        {
            cout << terms[i][j] << " ";
        }
        cout << endl;
    }*/
    cout << endl;

    for(int i = 0 ; i < (int)expression.size() ; i++)
    {
        //output_file << expression_name[i] << endl;
        //output_file << expression[i] << endl;
        cout << "*";
        while(terms[i].size() != 0)
        {
            find_kernels(terms[i]);
            if(terms[i].size() != 0)
            {
                cout << "terms: ";
                for(int j = 0 ; j < (int)terms[i].size() ; j++)
                {
                    cout << terms[i][j] << " ";
                }
                cout << endl;
            }
        }
        cout << endl;
    }

    /*for(int i = 0 ; i < (int)expression.size() ; i++)
    {
        cout << "expression_name: " << expression_name[i] << endl;
        cout << expression[i] << endl;
        cout << "terms: ";
        for(int j = 0 ; j < (int)terms[i].size() ; j++)
        {
            cout << terms[i][j] << " ";
        }
        cout << endl;
    }*/




    return 0;
}

void find_kernels(vector<string> &terms)
{
    int a = 0, b = 0, c = 0, d = 0, e = 0, g = 0;
    for(int i = 0 ; i < (int)terms.size() ; i++)
    {
        string terms_temp = terms[i];
        for(int j = 0 ; j < (int)terms_temp.size() ; j++)
        {
            switch(terms_temp[j])
            {
                case 'a':
                    a++;
                    break;
                case 'b':
                    b++;
                    break;
                case 'c':
                    c++;
                    break;
                case 'd':
                    d++;
                    break;
                case 'e':
                    e++;
                    break;
                case 'g':
                    g++;
                    break;
            }
        }
    }

    int compare[] = {a, b, c, d, e, g};
    int biggest = 0;
    char eliminate;

    for(int i = 0 ; i < 6 ; i++)
    {
        if(compare[i] > biggest)
        {
            biggest = compare[i];
        }
    }

    if(biggest == 1)
    {
        terms.erase(terms.begin(), terms.end());
        return;
    }

    if(biggest == a)
    {
        eliminate = 'a';
        eliminate_char_complete(terms, eliminate);
    }
    if(biggest == b)
    {
        eliminate = 'b';
        eliminate_char_complete(terms, eliminate);
    }
    if(biggest == c)
    {
        eliminate = 'c';
        eliminate_char_complete(terms, eliminate);
    }
    if(biggest == d)
    {
        eliminate = 'd';
        eliminate_char_complete(terms, eliminate);
    }
    if(biggest == e)
    {
        eliminate = 'e';
        eliminate_char_complete(terms, eliminate);
    }
    if(biggest == g)
    {
        eliminate = 'g';
        eliminate_char_complete(terms, eliminate);
    }


}

bool eliminate_char(string &doing, char eliminate)
{
    for(int i = 0 ; i < (int)doing.size() ; i++)
    {
        if(doing[i] == eliminate)
        {
            doing.erase (i, 1);
            return 1;
        }
    }
    return 0;
}

void eliminate_char_complete(vector<string> &terms, char eliminate)//delete unrelated terms
{
    for(int i = 0 ; i < (int)terms.size() ; i++)
    {
        if(!eliminate_char(terms[i], eliminate))
        {
            terms.erase(terms.begin() + i);
        }
    }
}

输入文件如下

F1=ace+bce+de+g
F2=abc+abd+bcd

我不遵守上面的伪代码。

1. 首先，我将它们分解为单个项，并将它们推入一个称为项的两维向量中。
   terms[expression number][how many terms in one expression]
2. 第二，我打电话给find_kernels。基金会计算每个字母在一个表达式中出现的次数。PS：只会出现A、B、C、D、E、G。
3. 第三，取出出现次数最多的字母。例如：A、AB、ABC...
4. 然后，在同一表达式的每个术语中消除它们。如果术语没有这些字母，则直接删除该术语。
5. 继续做同样的事情......

但是，问题是，如果 F1 是 abc+abd+bcd，我应该输出 ac+ad+cd c+d a+c a+d，但我的程序只会输出 ac+ad+cd，导致 abc+abd+bcd = b（ac+ad+cd） >>下一轮 ac+ad+cd。a、c、d都apear两次，所以一起删除了。什么都没有了。

Any suggestion to my code or further explination of the pseudo code will be appreciate. Thank you.