标签：bcd   amp   i++   strong   顺序   lse   c++   题目   简单   

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 虫食算(枚举+剪枝)

标签：bcd   amp   i++   strong   顺序   lse   c++   题目   简单   

原文地址：https://www.cnblogs.com/coder-Uranus/p/9715244.html