ZOJ 3803 Function DP_zoj function3803-优快云博客

本文链接：https://blog.youkuaiyun.com/ACMmaxx/article/details/38798837

本文深入探讨了一种基于动态规划的算法，用于解决特定二进制数操作的问题。通过从高位到低位的递推过程，文章详细解释了如何计算满足给定条件的二进制数的数量。特别关注了状态转移的复杂性，包括如何处理取反加1后可能的进位问题。此外，文章还提供了代码实现和实例分析，帮助读者理解并应用这一算法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

【题目大意】

有一个n位的二进制数x，G（x） = x ^（x>>1），C（x）== ( 2^n - x ) % 2^n。现在告诉你G（x）和C（x），问有多少个G（x）。

【思路】

因为做过类似的题，很快就知道这个是个DP。从高位到低位的DP，或者从低位到高位的DP应该都是行的。我采用的是从高位到低位的DP。

如果用dp[i][j]表示填好了前i位，第i位填的数字是j，并且满足了G（x）和C（x）的前i位的状态，的方法数。可以发现，满足G（x）的转移是容易的，但是满足C（x）就比较麻烦了。因为如果x>0时，C（x）= （~x）+1。因为有1个“+1”，这可能会导致进位。

直接的转移是困难的，我们不妨再加一维，用dp[i][j][k]表示表示填好了前i位，第i位填的数字是j，当x取反加1后，第i位会进1，这样的方法数。

这样的话，k==1时，显然后面的数字只能填0；而k==0时，DP的转移的只能两种情况。

P.S. 因为C（x）= （~x）+1 的前提是x>0，所以x==0的时候会有一个小坑，比赛的时候我被这个卡了快一个小时。。。so sad

//#pragma comment(linker, "/STACK:102400000,102400000")
#include<cstdio>
#include<cstring>
#include<vector>
#include<queue>
#include<cmath>
#include<cctype>
#include<string>
#include<algorithm>
#include<iostream>
#include<ctime>
#include<map>
#include<set>
using namespace std;
#define MP(x,y) make_pair((x),(y))
#define PB(x) push_back(x)
//typedef __int64 LL;
//typedef unsigned __int64 ULL;
/* ****************** */
const int INF = 100011122;
const double INFF = 1e100;
const double eps = 1e-8;
const int mod = 1000000007;
const int NN = 100010;
const int MM = 5000010;
/* ****************** */

int dp[NN][2][2];
int ok[NN][2][2];
int prej[NN][2][2];
int prek[NN][2][2];

char g[NN],c[NN];
int x[NN],gg[NN],cc[NN];

bool fun(int x,char cc)
{
    if( cc == '?' )
        return true;
    if( x == (cc-'0') )
        return true;
    return false;
}

void FF(int n,int j,int k)
{
    int i, jj, kk;

    for(i = n;i >= 1;i --)
    {
        x[i] = j;

        jj = prej[i][j][k];
        kk = prek[i][j][k];

        j = jj;
        k = kk;
    }

    x[0] = 0;
    for(i = 1;i <= n;i ++)
    {
        gg[i] = x[i]^x[i-1];
        cc[i] = 1-x[i];
    }
    cc[n]++;
    for(i = n;i >= 1;i --)
    {
        if(cc[i] == 2)
        {
            cc[i] = 0;
            cc[i-1]++;
        }
        else
            break;
    }

    for(i = 1;i <= n;i ++)
    {
        printf("%d", gg[i]);
    }
    puts("");
    for(i = 1;i <= n;i ++)
    {
        printf("%d", cc[i]);
    }
    puts("");
}

void INC(int &a,int b)
{
    a += b;
    a = min(a, 10);
}

int goo(int n)
{
    int i;
    for(i = 1;i <= n;i ++)
    {
        if(g[i] != '0' && g[i] != '?')
            return 0;
    }
    for(i = 1; i <= n; i ++)
    {
        if(c[i] != '0' && c[i] != '?')
            return 0;
    }
    return 1;
}

int main()
{
    int i, j, k, jj, n, ans, temp;
    while(scanf("%s%s",g+1,c+1) != EOF)
    {
        n = strlen(g+1);
        memset(dp, 0, sizeof(dp));
        memset(ok, 0, sizeof(ok));

        dp[0][0][0] = 1;
        ok[0][0][0] = 1;

        for(i = 0;i < n;i ++)
        {
            for(j = 0;j < 2;j ++)
                for(k = 0;k < 2;k ++)
                    if(ok[i][j][k] > 0)
                    {
                        if(k == 1)
                        {
                            jj = 0;
                            if(fun(jj^j, g[i+1]) && fun(0,c[i+1]))
                            {
                                dp[i+1][jj][1] += dp[i][j][k];
                                dp[i+1][jj][1] %= mod;
                                INC(ok[i+1][jj][1], ok[i][j][k]);
                                prej[i+1][jj][1] = j;
                                prek[i+1][jj][1] = k;
                            }
                        }
                        else
                        {
                            for(jj = 0;jj < 2;jj ++)
                                if(fun(j^jj, g[i+1]))
                                {
                                    if( jj==1 && fun(1, c[i+1]) )
                                    {
                                        dp[i+1][jj][1] += dp[i][j][k];
                                        dp[i+1][jj][1] %= mod;
                                        INC(ok[i+1][jj][1], ok[i][j][k]);
                                        prej[i+1][jj][1] = j;
                                        prek[i+1][jj][1] = k;
                                    }
                                    if( fun(1-jj, c[i+1]) )
                                    {
                                        dp[i+1][jj][0] += dp[i][j][k];
                                        dp[i+1][jj][0] %= mod;
                                        INC(ok[i+1][jj][0],ok[i][j][k]);
                                        prej[i+1][jj][0] = j;
                                        prek[i+1][jj][0] = k;
                                    }
                                }
                        }
                    }
        }
        ans = dp[n][0][1] + dp[n][1][1];
        ans %= mod;
        temp = goo(n);
        ans = (ans+temp)%mod;

        if(ok[n][0][1] + ok[n][1][1] + temp > 0 )
        {
            if(ok[n][0][1] + ok[n][1][1] + temp == 1)
            {
                puts("UNIQUE");
                if(ok[n][0][1] == 1)
                    FF(n, 0, 1);
                else if(ok[n][1][1])
                    FF(n, 1, 1);
                else
                {
                    for(i = 1;i <= n;i ++)
                        printf("0");
                    puts("");
                    for(i = 1;i <= n;i ++)
                        printf("0");
                    puts("");
                }
            }
            else
            {
                printf("AMBIGUOUS %d\n",ans);
            }
        }
        else
        {
            puts("IMPOSSIBLE");
        }
    }
    return 0;
}