【sgu161】Intuitionistic Logic

原创已于 2022-01-29 23:47:59 修改 · 368 阅读
1 ·
CC 4.0 BY-SA版权
文章标签：
#深度优先 #leetcode #算法
于 2015-07-21 15:10:52 首次发布
sgu 专栏收录该内容
26 篇文章
订阅专栏
本文介绍了一个基于图论的复杂逻辑表达式解析与验证算法。通过构造图模型并结合 Floyd 算法，实现了对逻辑表达式的有效求解。文章详细展示了如何通过递归遍历和状态组合来解决特定的逻辑验证问题。
~~题意有点坑啊，先放一放，晚上写~~
UPD：闲着没事写大模拟多少沾点
#include <bits/stdc++.h>
using namespace std;

typedef long long LL;

template<typename T>
void print(vector<T> a) {
	size_t sz = a.size();
	for (size_t i = 0; i < sz; i++) {
		cout << a[i] << " \n"[i == sz - 1];
        cout<<endl;
	}
}

const int N = 100 + 5;

struct Graph {
    int n;
    bool e[N][N];

    void init(int n) {
        this->n = n;

        for (int i = 1; i <= n; i++) {
            e[i][i] = true;
        }
    }

    void add_edge(int a, int b) {
        e[a][b] = true;
    }

    void floyd() {
        for (int k = 1; k <= n; k++) {
            for (int i = 1; i <= n; i++) {
                for (int j = 1; j <= n; j++) {
                    e[i][j] |= e[i][k] && e[k][j];
                }
            }
        }
    }

    void dfs(int x, bitset<N> cur, vector<bitset<N>> &H) {
        if (x == n + 1) {
            H.push_back(cur);
            return;
        }
        dfs(x + 1, cur, H);
        
        for (int i = 1; i <= n; i++) {
            if (cur[i]) {
                if (e[i][x] || e[x][i]) {
                    return;
                }
            }
        }
        cur.set(x);
        dfs(x + 1, cur, H);
    }

    vector<bitset<N>> get_H() {
        vector<bitset<N>> H;
        bitset<N> s;
        dfs(1, s, H);
        return H;
    }
} g;

int n, m, q;
vector<string> qry;
vector<bool> ans;

void input()
{
    cin >> n >> m;

    g.init(n);
    for (int i = 1; i <= m; i++) {
        int a, b;
        cin >> a >> b;
        g.add_edge(a, b);
    }
    cin >> q;
    while (cin.get() != '\n');
    for (int i = 0; i < q; i++) {
        string line;
        getline(cin, line);
        qry.push_back(line);
    }
}

bitset<N> Max(bitset<N> a) {
    for (int i = 1; i <= n; i++) {
        if (a[i]) {
            for (int j = 1; j <= n; j++) {
                if (a[j] && j != i && g.e[i][j]) {
                    a[i] = 0;
                    break;
                }
            }
        }
    }
    return a;
}
bitset<N> Implies(bitset<N> a, bitset<N> b) {
    for (int i = 1; i <= n; i++) {
        if (b[i]) {
            for (int j = 1; j <= n; j++) {
                if (a[j] && g.e[i][j]) {
                    b[i] = 0;
                    break;
                }
            }
        }
    }
    return b;
}
bitset<N> And(bitset<N> a, bitset<N> b) {
    return Max(a | b);
}
bitset<N> Or(bitset<N> a, bitset<N> b) {
    bitset<N> c;
    for (int i = 1; i <= n; i++) {
        bool ok1 = false, ok2 = false;
        for (int j = 1; j <= n; j++) {
            if (a[j] && g.e[i][j]) {
                ok1 = true;
                break;
            }
        }
        for (int k = 1; k <= n; k++) {
            if (b[k] && g.e[i][k]) {
                ok2 = true;
                break;
            }
        }
        if (ok1 && ok2) {
            c.set(i);
        }
    }
    return Max(c);
}

bitset<N> Equal(bitset<N> a, bitset<N> b) {
    return And(Implies(a, b), Implies(b, a));
}

bitset<N> Zero() {
    bitset<N> z;
    for (int i = 1; i <= n; i++) {
        z.set(i);
    }
    return Max(z);
}

bitset<N> Not(bitset<N> a) {
    return Implies(a, Zero());
}

bitset<N> One() {
    return bitset<N>();
}

const int MAXS = 100 + 5;
vector<bitset<N>> H;
int _not[MAXS];
int _and[MAXS][MAXS];
int _or[MAXS][MAXS];
int _im[MAXS][MAXS];
int _eq[MAXS][MAXS];

int Not(int a) {
    return _not[a];
}

int And(int a, int b) {
    return _and[a][b];
}

int Or(int a, int b) {
    return _or[a][b];
}

int Implies(int a, int b) {
    return _im[a][b];
}

int Equal(int a, int b) {
    return _eq[a][b];
}

bool occur[26 + 5];
int val[26 + 5];
int ONE, ZERO;

const int NOT = 0;
const int AND = 1;
const int OR = 2;
const int IMPLIES = 3;
const int EQUAL = 4;
const int LEFT_BRACKET = 5;

int get_op_type(int c) {
    switch (c) {
        case '~': return NOT;
        case '&': return AND;
        case '|': return OR;
        case '>': return IMPLIES;
        case '=': return EQUAL;
        default:
                  cout << "wtf?" << endl;
                  return LEFT_BRACKET;
    }
}

void calc_and_pop(vector<int> &num, vector<int> &op) {
    auto t = op.back();
    op.pop_back();
    switch (t) {
        case NOT: 
            {
                auto &a = num.back();
                a = Not(a);
            }
            break;
        case AND:
            {
                auto b = num.back();
                auto &a = num[num.size() - 2];
                a = And(a, b);
                num.pop_back();
            }
            break;
        case OR:
            {
                auto b = num.back();
                auto &a = num[num.size() - 2];
                a = Or(a, b);
                num.pop_back();
            }
            break;
        case IMPLIES:
            {
                auto b = num.back();
                auto &a = num[num.size() - 2];
                a = Implies(a, b);
                num.pop_back();
            }
            break;
        case EQUAL:
            {
                int cnt = 0;
                while (!op.empty() && op.back() == EQUAL) {
                    op.pop_back();
                    cnt++;
                }
                auto b = num.back(); num.pop_back();
                auto a = num.back();
                auto res = Equal(a, b);
                while (cnt--) {
                    b = num.back(); num.pop_back();
                    a = num.back();
                    res = And(res, Equal(a, b));
                }
                num.back() = res;
            }
            break;
        default:
            cout<<"wtf?"<<endl;
            cout<<"not op"<<endl;
    }
}

bool is_left_combine(int op) {
    if (op == AND || op == OR) {
        return true;
    }
    return false;
}

bool is_bracket(int c) {
    return c == '(' || c == ')';
}

bool is_num(int c) {
    return isdigit(c);
}

bool is_var(int c) {
    return isupper(c);
}

bool is_op(int c) {
    return c == '~' || c == '&' || c == '|' || c == '>' || c == '=';
}

bool op_cmp(int op1, int op2) {
    return (op1) > (op2) || ((op1) == (op2) && is_left_combine(op1));
}

bool calc(const string &s) {
     /*for (int i = 0; i < 26; i++) {
        if (occur[i]) {
            cout << char(i+'A') << " " << val[i] << " ";
        }
    }
    cout << endl;*/

    static vector<int> num;
    static vector<int> op;
    num.clear();
    op.clear();

    for (int i = 0; i < s.size(); i++) {
        auto c = s[i];
        if (c == ' ') continue;
        if (c == '=' && i + 1 < s.size() && s[i + 1] == '>') continue;
        if (is_bracket(c)) {
            if (c == '(') {
                op.push_back(LEFT_BRACKET);
            } else {
                while (op.back() != LEFT_BRACKET) {
                    calc_and_pop(num, op);
                }
                op.pop_back();
            }
        } else if (is_num(c)) {
            auto x = c - '0';
            num.push_back(x ? ONE : ZERO);
        } else if (is_var(c)) {
            auto x = c - 'A';
            num.push_back(val[x]);
        } else if (is_op(c)) {
            auto t = get_op_type(c);
            while (!op.empty() && op_cmp(t, op.back())) {
                calc_and_pop(num, op);
            }
            op.push_back(t);
        } else {
            cout<<"wtf?"<<endl;
            cout<<"c="<<c<<endl;
        }
    }

    while (!op.empty()) {
        calc_and_pop(num, op);
    }

    if (op.size() != 0) {
        cout<<"wtf?"<<endl;
        print(op);
    }
    if (num.size() != 1) {
        cout<<"wtf?"<<endl;
        print(num);
    }
    auto res = num[0];
    return res == ONE;
}

bool dfs_eval(int x, const string &s) {
    while (x < 26 && !occur[x]) {
        x++;
    }
    if (x == 26) {
        return calc(s);
    }
    for (int i = 0; i < H.size(); i++) {
        val[x] = i;
        if (!dfs_eval(x + 1, s)) {
            return false;
        }
    }
    return true;
}

bool eval_and_calc(string s) {
    for (int i = 0; i < 26; i++) {
        occur[i] = false;
    }
    for (auto c: s) {
        if (isupper(c)) {
            occur[c - 'A'] = true;
        }
    }
    if (dfs_eval(0, s)) {
        return true;
    }
    return false;
}

void solve()
{
    g.floyd();
    H = g.get_H();
    auto f = [&](bitset<N> a) -> int {
        auto r = find(H.begin(), H.end(), a) - H.begin();
        if (r == H.size()) {
            cout << "wtf?" << endl;
            cout << "not H" << endl;
        }
        return r;
    };
    ONE = f(One());
    ZERO = f(Zero());
    for (int i = 0; i < H.size(); i++) {
        for (int j = 0; j < H.size(); j++) {
            _and[i][j] = f(And(H[i], H[j]));
            _or[i][j] = f(Or(H[i], H[j]));
            _im[i][j] = f(Implies(H[i], H[j]));
            _eq[i][j] = f(Equal(H[i], H[j]));
        }
        _not[i] = f(Not(H[i]));
    }

    ans.resize(q);
    for (int i = 0; i < q; i++) {
        ans[i] = eval_and_calc(qry[i]);
    }
}

void output()
{
    for (int i = 0; i < q; i++) {
        if (ans[i]) {
            cout << "valid" << endl;
        } else {
            cout << "invalid" << endl;
        }
    }
}

int main()
{
	ios::sync_with_stdio(false);
	cin.tie(0);

	input();
	solve();
	output();

	return 0;
}