LeetCode 面试题 08.14. 布尔运算

最新推荐文章于 2024-07-25 21:13:04 发布

HumbleFool

最新推荐文章于 2024-07-25 21:13:04 发布

阅读量108

点赞数 1

分类专栏：算法文章标签： leetcode 深度优先算法记忆化搜索

本文链接：https://blog.csdn.net/qq_45925322/article/details/126310826

版权

算法专栏收录该内容

106 篇文章 1 订阅

订阅专栏

LeetCode 面试题 08.14. 布尔运算
在这里插入图片描述
暴力递归

struct Node
{
    int t, f;
};
class Solution {
public:
    Node dfs(string s, int l, int r)
    {
        int t = 0, f = 0;
        if(l == r)
        {
            t = s[l] == '1';
            f = s[l] == '0';
        }
        else
        {
            for(int i = l + 1; i < r; i += 2)
            {
                Node left = dfs(s, l, i - 1);
                Node right = dfs(s, i + 1, r);
                if(s[i] == '&')
                {
                    t += left.t * right.t;
                    f += left.t * right.f + left.f * right.t + left.f * right.f;
                }
                else if(s[i] == '|')
                {
                    t += left.t * right.t + left.t * right.f + left.f * right.t;
                    f += left.f * right.f;
                }
                else 
                {
                    t += left.f * right.t + left.t * right.f;
                    f += left.t * right.t + left.f * right.f;
                }
            }
        }
        return {t, f};
    }
    int countEval(string s, int result) {

        Node res = dfs(s, 0, s.size() - 1);
        if(result)
            return res.t;
        else
            return res.f; 
    }
};

记忆化搜索

#define t first
#define f second
const int N = 50;
typedef pair<int, int> PII;
class Solution {
public:
    PII f[N][N];
    PII dfs(string s, int l, int r)
    {
        if(f[l][r].t != -1 || f[l][r].f != -1)
            return f[l][r];
        int tr = 0, fa = 0;
        if(l == r)
        {
            tr = s[l] == '1';
            fa = s[l] == '0';
        }
        else
        {
            for(int i = l + 1; i < r; i += 2)
            {
                PII left = dfs(s, l, i - 1);
                PII right = dfs(s, i + 1, r);
                if(s[i] == '&')
                {
                    tr += left.t * right.t;
                    fa += left.t * right.f + left.f * right.t + left.f * right.f;
                }
                else if(s[i] == '|')
                {
                    tr += left.t * right.t + left.t * right.f + left.f * right.t;
                    fa += left.f * right.f;
                }
                else 
                {
                    tr += left.f * right.t + left.t * right.f;
                    fa += left.t * right.t + left.f * right.f;
                }
            }
        }
        f[l][r].t = tr, f[l][r].f = fa;
        return f[l][r];
    }
    int countEval(string s, int result) {
        for(int i = 0; i < N; i ++)
            for(int j = 0; j < N; j ++)
                f[i][j].t = -1, f[i][j].f = -1;

        PII res = dfs(s, 0, s.size() - 1);
        if(result)
            return res.t;
        else
            return res.f; 
    }
};