输入注意：（！表示 非；&表示 合取 ；|表示 析取；>表示蕴含 ） 

实现思路：

1. 利用数据结构——栈，将表达式转换为后缀表达式
2. 深度搜索(暴力枚举)每个变量的可能值
3. 根据每次暴力枚举结果计算后缀表达式得出真值表
4. 根据真值表输出主析取范式和主合取范式

#include<iostream>
#include<cstdio>
#include<stack>
#include<vector>
#include<algorithm>
#include<unordered_map>
using namespace std;

unordered_map<char,int> pri={{'!',2},{'|',1},{'&',1},{'>',1},{'(',0} };//哈希表存优先级(注意!优先级最高)
unordered_map<char,int> h;//哈希表存每个变量对应的真值
vector<char> v;//存变量
vector<int> p;//存真值表
string s1,s2;//原式和其后缀表达式

void Change(string s1,string &s2)//转换为后缀表达式
{
    stack<char> a;
    for(int i=0;i<s1.size();i++)
    {
        if(s1[i]>='a' && s1[i]<='z')
        {
            s2+=s1[i];
            if(h.find(s1[i])==h.end())//没找到,说明变量第一次出现
            {
                h[s1[i]]; //创建s1[i]的哈希
                v.push_back(s1[i]);//变量加入v中
            }
        }
        else if(s1[i]=='(')
            a.push(s1[i]);
        else if(s1[i]==')')
        {
            while(a.top()!='(')
            {
                s2+=a.top();
                a.pop();
            }
            a.pop();
        }
        else
        {
            while(!a.empty() && pri[s1[i]]<=pri[a.top()])//单调栈维护栈顶是优先级高的运算符优先参与计算
            {
                s2+=a.top();
                a.pop();
            }
            a.push(s1[i]);
        }
    }
    
    while(!a.empty())//剩余操作符
    {
        s2+=a.top();
        a.pop();
    }
    return ;
}

int cal(string s2)//计算
{
    stack<int> val;
    for(int i=0;i<s2.size();i++)
    {
        if(s2[i]>='a' && s2[i]<='z')
            val.push(h[s2[i]]);
        else if(s2[i]=='!')//单目运算符
        {
            int tmp=val.top();
            val.pop();
            val.push(!tmp);
        }
        else//双目运算符
        {
            int tmp1=val.top();
            val.pop();
            
            int tmp2=val.top();
            val.pop();
            
            switch(s2[i])
            {
                case '&':val.push(tmp2&tmp1);break;
                case '|':val.push(tmp2|tmp1);break;
                case '>':val.push(!tmp2|tmp1);break;
            }
        }
    }
    return val.top();
}

void dfs(int n)//深搜暴力枚举每个变量的每一种可能
{
    if(n>=v.size())
    {
        for(auto x:v)cout<<h[x]<<' ';
        int x=cal(s2);
        p.push_back(x);
        cout<<"真值为:"<<x<<endl;
        return ;
    }
    
    for(int i=1;i<=2;i++)//每个变量两种可能(0 OR 1)
    {
        if(i==1)
        {
            h[v[n]]=0;
            dfs(n+1);
        }
        else
        {
            h[v[n]]=1;
            dfs(n+1);
        }
    }
    return ;
}

int main()
{
    cin>>s1;
    cout<<"原式为:"<<s1<<endl;
    
    Change(s1,s2);//将中缀表达式s1转换为后缀表达式s2
    cout<<"其后缀表达式为:"<<s2<<endl;

    cout<<"变量:"<<endl;
    for(auto x:v)cout<<x<<' ';//遍历变量
    cout<<endl;
    
    dfs(0);//从第一个变量暴力枚举
    
    bool flag=false;
    cout<<"析取范式为:";
    for(int i=0;i<p.size();i++)
    {
        if(p[i]==1 && !flag)//第一个成真赋值不输出析取符合
        {
            flag=true;
            cout<<'m'<<i;
        }
        else if(p[i]==1 && flag)cout<<"∨"<<'m'<<i;
    }
    cout<<endl;
    flag=false;
    cout<<"合取范式为:";
    for(int i=0;i<p.size();i++)
    {
        if(p[i]==0 && !flag)//第一个成假赋值不输出合取符合
        {
            flag=true;
            cout<<'M'<<i;
        }
        else if(p[i]==0 && flag)cout<<"∧"<<'M'<<i;
    }
return 0;
}