Luogu P1092 虫食算(枚举+剪枝)

Posted coder-uranus

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了Luogu P1092 虫食算(枚举+剪枝)相关的知识,希望对你有一定的参考价值。

P1092 虫食算

题面

题目描述

所谓虫食算,就是原先的算式中有一部分被虫子啃掉了,需要我们根据剩下的数字来判定被啃掉的字母。来看一个简单的例子:

 43#9865#045
+  8468#6633
 44445509678

其中 (#) 号代表被虫子啃掉的数字。根据算式,我们很容易判断:第一行的两个数字分别是 (5)(3) ,第二行的数字是 (5)

现在,我们对问题做两个限制:

首先,我们只考虑加法的虫食算。这里的加法是 (N) 进制加法,算式中三个数都有 (N) 位,允许有前导的 (0)

其次,虫子把所有的数都啃光了,我们只知道哪些数字是相同的,我们将相同的数字用相同的字母表示,不同的数字用不同的字母表示。如果这个算式是 (N) 进制的,我们就取英文字母表午的前 (N) 个大写字母来表示这个算式中的 (0)(N?1)(N) 个不同的数字:但是这 (N) 个字母并不一定顺序地代表 (0)(N?1) 。输入数据保证 (N) 个字母分别至少出现一次。

 BADC
+CBDA
 DCCC

上面的算式是一个 (4) 进制的算式。很显然,我们只要让 (ABCD) 分别代表 (0123) ,便可以让这个式子成立了。你的任务是,对于给定的 (N) 进制加法算式,求出 (N) 个不同的字母分别代表的数字,使得该加法算式成立。输入数据保证有且仅有一组解。

输入输出格式

输入格式:

包含四行。

第一行有一个正整数 (N(N leq 26))

后面的三行,每行有一个由大写字母组成的字符串,分别代表两个加数以及和。这3个字符串左右两端都没有空格,从高位到低位,并且恰好有 (N) 位。

输出格式:

一行,即唯一的那组解。

解是这样表示的:输出 (N) 个数字,分别表示 (A,B,C,…) 所代表的数字,相邻的两个数字用一个空格隔开,不能有多余的空格。

输入输出样例

输入样例:

5
ABCED
BDACE
EBBAA

输出样例:

1 0 3 4 2

说明

对于 $30 % $ 的数据,保证有 (N leq 10)

对于 $50 % $ 的数据,保证有 (N leq 15)

对于全部的数据,保证有 (N leq 26)

noip2004提高组第4题

思路

太??强了吧。 --Mercury

这是一道搜索题,只需要简单地枚举就好了。

你真以为这题就这么过了?

首先,从时间复杂度来分析,如果只是单纯的枚举的话,时间复杂度就是 (O(N!)) ,对于 (N leq 26) 这样的数据范围,显然会 TLE

我们再来考虑剪枝以及分类讨论。例如,我们从右到左按照竖式计算的方法依次计算。这样写完之后码量就从 (1KB) 变成了 (9.82KB)

接下来,只需要进行 简单的 调试,就能 很容易地 AC 了。

不信你看,我只调试了 (5h) 就出来了:

技术分享图片

没错,这道题目的恶心之处,不在于根本就没有思路,而在于长时间的调试。耐心与代码力,才是解这道题的关键。

怨念--;

代码摆在这里,想借鉴可以,不过每个人都有每个人的写法吧。

AC代码

#include<bits/stdc++.h>
using namespace std;
int n,ans[26];
string str[3];
bool use[26];
bool dfs(int now,int is_up)
{
    if(now==-1) return true;
    int a=str[0][now]-‘A‘,b=str[1][now]-‘A‘,c=str[2][now]-‘A‘;
    if(ans[a]!=-1&&ans[b]!=-1&&ans[c]!=-1)
    {
        int tot=ans[a]+ans[b]+is_up;
        int nex=(tot>=n)?1:0;
        if(nex) tot-=n;
        if(tot!=ans[c]) return false;
        else return dfs(now-1,nex);
    }
    else if(ans[a]!=-1&&ans[b]!=-1)
    {
        int rest=ans[a]+ans[b]+is_up;
        int nex=(rest>=n)?1:0;
        if(nex) rest-=n;
        if(use[rest]) return false;
        else
        {
            use[rest]=true;
            ans[c]=rest;
            if(dfs(now-1,nex)) return true;
            use[rest]=false;
            ans[c]=-1;
            return false;
        }
    }
    else if(ans[a]!=-1&&ans[c]!=-1)
    {
        int rest=ans[c]-ans[a]-is_up;
        int nex=(rest<0)?1:0;
        if(nex) rest+=n;
        if(use[rest]) return false;
        else
        {
            use[rest]=true;
            ans[b]=rest;
            if(dfs(now-1,nex)) return true;
            use[rest]=false;
            ans[b]=-1;
            return false;
        }
    }
    else if(ans[b]!=-1&&ans[c]!=-1)
    {
        int rest=ans[c]-ans[b]-is_up;
        int nex=(rest<0)?1:0;
        if(nex) rest+=n;
        if(use[rest]) return false;
        else
        {
            use[rest]=true;
            ans[a]=rest;
            if(dfs(now-1,nex)) return true;
            use[rest]=false;
            ans[a]=-1;
            return false;
        }
    }
    else if(ans[a]!=-1)
    {
        if(b==c)
        {
            if(ans[a]==0&&!is_up)
            {
                for(int i=n-1;i>=0;i--)
                    if(!use[i])
                    {
                        ans[b]=i;
                        use[i]=true;
                        if(dfs(now-1,0)) return true;
                        ans[b]=-1;
                        use[i]=false;
                    }
            }
            else if(ans[a]==n-1&&is_up)
            {
                for(int i=n-1;i>=0;i--)
                    if(!use[i])
                    {
                        ans[b]=i;
                        use[i]=true;
                        if(dfs(now-1,1)) return true;
                        ans[b]=-1;
                        use[i]=false;
                    }
            }
            return false;
        }
        else
        {
            for(int i=n-1;i>=0;i--)
                if(!use[i])
                {
                    int tot=ans[a]+i+is_up;
                    int nex=(tot>=n)?1:0;
                    if(nex) tot-=n;
                    if(!use[tot]&&i!=tot)
                    {
                        use[tot]=use[i]=true;
                        ans[b]=i,ans[c]=tot;
                        if(dfs(now-1,nex)) return true;
                        use[tot]=use[i]=false;
                        ans[b]=ans[c]=-1;
                    }
                }
            return false;
        }
    }
    else if(ans[b]!=-1)
    {
        if(a==c)
        {
            if(ans[b]==0&&!is_up)
            {
                for(int i=n-1;i>=0;i--)
                    if(!use[i])
                    {
                        ans[a]=i;
                        use[i]=true;
                        if(dfs(now-1,0)) return true;
                        ans[a]=-1;
                        use[i]=false;
                    }
            }
            else if(ans[b]==n-1&&is_up)
            {
                for(int i=n-1;i>=0;i--)
                    if(!use[i])
                    {
                        ans[a]=i;
                        use[i]=true;
                        if(dfs(now-1,1)) return true;
                        ans[a]=-1;
                        use[i]=false;
                    }
            }
            return false;
        }
        else
        {
            for(int i=n-1;i>=0;i--)
            if(!use[i])
            {
                int tot=ans[b]+i+is_up;
                int nex=(tot>=n)?1:0;
                if(nex) tot-=n;
                if(!use[tot]&&i!=tot)
                {
                    use[tot]=use[i]=true;
                    ans[a]=i,ans[c]=tot;
                    if(dfs(now-1,nex)) return true;
                    use[tot]=use[i]=false;
                    ans[a]=ans[c]=-1;
                }
            }
            return false;
        }
    }
    else if(ans[c]!=-1)
    {
        if(a==b)
        {
            int tot=ans[c]-is_up;
            if(!(tot&1))
            {
                int tmp=tot>>1;
                if(!use[tmp])
                {
                    use[tmp]=true;
                    ans[a]=tmp;
                    if(dfs(now-1,0)) return true;
                    use[tmp]=false;
                    ans[a]=-1;
                }
            }
            tot+=n;
            if(!(tot&1))
            {
                int tmp=tot>>1;
                if(!use[tmp])
                {
                    use[tmp]=true;
                    ans[a]=tmp;
                    if(dfs(now-1,1)) return true;
                    use[tmp]=false;
                    ans[a]=-1;
                }
            }
        }
        else
        {
            for(int i=n-1;i>=0;i--)
                if(!use[i])
                {
                    int rest=ans[c]-i-is_up;
                    int nex=(rest<0)?1:0;
                    if(nex) rest+=n;
                    if(!use[rest]&&i!=rest)
                    {
                        use[rest]=use[i]=true;
                        ans[a]=i,ans[b]=rest;
                        if(dfs(now-1,nex)) return true;
                        use[rest]=use[i]=false;
                        ans[a]=ans[b]=-1;
                    }
                }
            return false;
        }
    }
    else
    {
        if(a==b&&a==c)
        {
            if(!use[0]&&!is_up)
            {
                use[0]=true;
                ans[a]=0;
                if(dfs(now-1,0)) return true;
                use[0]=false;
                ans[a]=-1;
            }
            else if(!use[n-1]&&is_up)
            {
                use[n-1]=true;
                ans[a]=n-1;
                if(dfs(now-1,1)) return true;
                use[n-1]=false;
                ans[a]=-1;
            }
            return false;
        }
        else if(a==b)
        {
            for(int i=n-1;i>=0;i--)
                if(!use[i])
                {
                    int tot=i+i+is_up;
                    int nex=0;
                    if(tot>=n) nex=1,tot-=n;
                    if(!use[tot]&&tot!=i)
                    {
                        use[tot]=use[i]=true;
                        ans[a]=i,ans[c]=tot;
                        if(dfs(now-1,nex)) return true;
                        use[tot]=use[i]=false;
                        ans[a]=ans[c]=-1;
                    }
                }
            return false;
        }
        else if(a==c)
        {
            if(!use[0]&&!is_up)
            {
                for(int i=n-1;i>=0;i--)
                    if(!use[i]&&i!=0)
                    {
                        use[i]=use[0]=true;
                        ans[a]=i,ans[b]=0;
                        if(dfs(now-1,0)) return true;
                        use[i]=use[0]=false;
                        ans[a]=ans[b]=-1;
                    }
            }
            if(!use[n-1]&&is_up)
            {
                for(int i=n-1;i>=0;i--)
                    if(!use[i]&&i!=n-1)
                    {
                        use[i]=use[n-1]=true;
                        ans[a]=i,ans[b]=n-1;
                        if(dfs(now-1,1)) return true;
                        use[i]=use[n-1]=false;
                        ans[a]=ans[b]=-1;
                    }
            }
            return false;
        }
        else if(b==c)
        {
            if(!use[0]&&!is_up)
            {
                for(int i=n-1;i>=0;i--)
                    if(!use[i]&&i!=0)
                    {
                        use[i]=use[0]=true;
                        ans[b]=i,ans[a]=0;
                        if(dfs(now-1,0)) return true;
                        use[i]=use[0]=false;
                        ans[b]=ans[a]=-1;
                    }
            }
            if(!use[n-1]&&is_up)
            {
                for(int i=n-1;i>=0;i--)
                    if(!use[i]&&i!=n-1)
                    {
                        use[i]=use[n-1]=true;
                        ans[b]=i,ans[a]=n-1;
                        if(dfs(now-1,1)) return true;
                        use[i]=use[n-1]=false;
                        ans[b]=ans[a]=-1;
                    }
            }
            return false;
        }
        else
        {
            for(int i=n-1;i>=0;i--)
                for(int j=n-1;j>=0;j--)
                    if(i!=j&&!use[i]&&!use[j])
                    {
                        int tot=i+j+is_up;
                        int nex=(tot>=n)?1:0;
                        if(nex) tot-=n;
                        if(!use[tot]&&tot!=i&&tot!=j)
                        {
                            use[tot]=use[i]=use[j]=true;
                            ans[a]=i,ans[b]=j,ans[c]=tot;
                            if(dfs(now-1,nex)) return true;
                            use[tot]=use[i]=use[j]=false;
                            ans[a]=ans[b]=ans[c]=-1;
                        }
                    }
            return false;
        }
    }
    return false;
}
int main()
{
    cin>>n>>str[0]>>str[1]>>str[2];
    memset(ans,-1,sizeof ans);
    if(dfs(n-1,0)) for(int i=0;i<n;i++) cout<<ans[i]<<‘ ‘;
    return 0;
}

以上是关于Luogu P1092 虫食算(枚举+剪枝)的主要内容,如果未能解决你的问题,请参考以下文章

洛谷P1092虫食算——深搜

P1092虫食算题解

Luogu P1092 虫食算

P1092 虫食算[搜索]

P1092 虫食算

P1092 虫食算