CodeForces - 704C

题目大意：给你一个逻辑表达式，然后让你计算表达式为真的取值情况数，表达式由一系列的 a 或者 a|b 亦或起来，每个变量最多出现两次(包括反变量)

嘴炮开始：每个变量最多出现两次，那么跟它相关联的变量也最多是两个，转化成图的话，那么整个图就是由很多链和很多环组成，分别DP就好了；

链DP很简单，从一段DP到另一端就可以了

环上的DP就是先确定一个点的值然后链DP就好了，一个环DP两次

写起来感觉还是有点麻烦。。

#include<cstdio>
#include<vector>
#include<cstring>
#include<algorithm>
using namespace std;

const int mod=1e9+;
const int maxn=*;
int n,m,d[maxn];
int fir[maxn],last[maxn<<],nex[maxn<<],a[maxn<<],b[maxn<<],tot=;
vector <int> e[maxn];
bool vis[maxn];
long long dp[maxn][][];

int sgn(int x)
{
    if(x>)return ;
    if(x<)return ;
}

void add(int u,int v,int aa,int bb)
{
    ++tot;
    last[tot]=v;
    a[tot]=aa;
    b[tot]=bb;
    nex[tot]=fir[u];
    fir[u]=tot;
}

struct node{
    int a,b;
}fa[maxn];
bool evis[maxn<<];
int s[maxn],cnt;

void dfs(int x)
{
    //printf("%d\n",x);
    vis[x]=;
    s[++cnt]=x;
    for(int i = fir[x];i;i=nex[i])
    {
        if(!evis[i])
        {
            evis[i]=;
            evis[i^]=;
            fa[x]=(node){a[i],b[i]};
            if(!vis[last[i]])dfs(last[i]);
        }
    }
}

void up(long long &a,long long b)
{
    a+=b;
    a%=mod;
}

int main()
{
    scanf("%d%d",&n,&m);
    long long ans1=,ans0=;
    for(int i = ;i <= n;i++)
    {
        int k;
        scanf("%d",&k);
        if(k==)
        {
            int x;
            scanf("%d",&x);
            e[abs(x)].push_back(sgn(x));
        }
        else
        {
            int u,v;
            scanf("%d%d",&u,&v);
            if(abs(u)==abs(v))
            {
                if(u!=v)
                {
                    vis[abs(u)]=;
                    swap(ans1,ans0);
                    ans1=ans1*%mod;
                    ans0=ans0*%mod;
                }
                else
                {
                    e[abs(u)].push_back(sgn(u));
                }
                continue;
            }
            add(abs(u),abs(v),sgn(u),sgn(v));
            add(abs(v),abs(u),sgn(v),sgn(u));
            d[abs(u)]++;
            d[abs(v)]++;
        }
    }
    for(int i = ;i <= m;i++)
        if(!vis[i] && d[i]== && e[i].size()>)
        {
            vis[i]=;
            if(e[i].size()==)
            {
                ans1=(ans1+ans0)%mod;
                ans0=ans1;
            }
            else
            {
                if(e[i][]==e[i][])
                {
                    ans1=ans1*%mod;
                    ans0=ans0*%mod;
                }
                else
                {
                    swap(ans1,ans0);
                    ans1=ans1*%mod;
                    ans0=ans0*%mod;
                }
            }
            //printf("%I64d %I64d\n",ans1,ans0);
        }
    for(int i = ;i <= m;i++)
        if(d[i]== && !vis[i])
        {
            cnt=;
            dfs(i);
            dp[i][][]=;
            dp[i][][]=;
            dp[i][][]=;
            dp[i][][]=;
            if(e[i].size())
            {
                if(e[i][]==)
                {
                    swap(dp[i][][],dp[i][][]);
                }
                else
                {
                    swap(dp[i][][],dp[i][][]);
                }
            }
            for(int step = ;step < cnt;step++)
            {
                for(int ii = ;ii < ;ii++)
                    for(int jj = ;jj < ;jj++)
                        for(int kk = ;kk < ;kk++)
                        {
                            up(dp[s[step+]][kk][((ii^fa[s[step]].a)|(kk^fa[s[step]].b))^jj],dp[s[step]][ii][jj]);
                        }
            }
            int x=s[cnt];
            if(e[x].size())
            {
                if(e[x][]==)
                {
                    swap(dp[x][][],dp[x][][]);
                }
                else
                {
                    swap(dp[x][][],dp[x][][]);
                }
            }
            //printf("xx %I64d %I64d %I64d %I64d\n",dp[x][0][0],dp[x][0][1],dp[x][1][0],dp[x][1][1]);
            long long a1=,a0=;

            //printf("%I64d %I64d\n",ans1,ans0);
            a1=(dp[x][][]+dp[x][][])*ans1%mod+(dp[x][][]+dp[x][][])*ans0%mod;
            a0=(dp[x][][]+dp[x][][])*ans0%mod+(dp[x][][]+dp[x][][])*ans1%mod;
            ans1=a1%mod;
            ans0=a0%mod;
            //printf("%I64d %I64d\n",ans1,ans0);
        }
    for(int i = ;i <= m;i++)
        if(d[i]== && !vis[i])
        {
            cnt=;
            dfs(i);
            dp[i][][]=;
            dp[i][][]=;
            dp[i][][]=;
            dp[i][][]=;
            for(int step = ;step <= cnt;step++)
                memset(dp[s[step]],,sizeof(dp[s[step]]));
            for(int step = ;step < cnt;step++)
            {
                for(int ii = ;ii < ;ii++)
                    for(int jj = ;jj < ;jj++)
                        for(int kk = ;kk < ;kk++)
                        {
                            up(dp[s[step+]][kk][((ii^fa[s[step]].a)|(kk^fa[s[step]].b))^jj],dp[s[step]][ii][jj]);
                        }
            }
            int x=s[cnt];
            for(int ii=;ii<;ii++)
                if((ii^fa[x].a)|(fa[x].b))swap(dp[x][ii][],dp[x][ii][]);
            long long a1=,a0=;
            //printf("xx %I64d %I64d %I64d %I64d\n",dp[x][0][0],dp[x][0][1],dp[x][1][0],dp[x][1][1]);
            a1+=(dp[x][][]+dp[x][][])*ans1%mod+(dp[x][][]+dp[x][][])*ans0%mod;
            a0+=(dp[x][][]+dp[x][][])*ans0%mod+(dp[x][][]+dp[x][][])*ans1%mod;

            dp[i][][]=;
            dp[i][][]=;
            dp[i][][]=;
            dp[i][][]=;
            for(int step = ;step <= cnt;step++)
                memset(dp[s[step]],,sizeof(dp[s[step]]));
            for(int step = ;step < cnt;step++)
            {
                for(int ii = ;ii < ;ii++)
                    for(int jj = ;jj < ;jj++)
                        for(int kk = ;kk < ;kk++)
                        {
                            up(dp[s[step+]][kk][((ii^fa[s[step]].a)|(kk^fa[s[step]].b))^jj],dp[s[step]][ii][jj]);
                        }
            }
            for(int ii=;ii<;ii++)
                if((ii^fa[x].a)|(^fa[x].b))swap(dp[x][ii][],dp[x][ii][]);
            //printf("xx %I64d %I64d %I64d %I64d\n",dp[x][0][0],dp[x][0][1],dp[x][1][0],dp[x][1][1]);
            a1+=(dp[x][][]+dp[x][][])*ans1%mod+(dp[x][][]+dp[x][][])*ans0%mod;
            a0+=(dp[x][][]+dp[x][][])*ans0%mod+(dp[x][][]+dp[x][][])*ans1%mod;
            ans1=a1%mod;
            ans0=a0%mod;
            //printf("%I64d %I64d\n",ans1,ans0);
        }
    for(int i = ;i <= m;i++)
        if(!vis[i])ans1=ans1*%mod;
    printf("%I64d\n",ans1);
    return ;
}

AC code