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;
}

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

时间: 2024-10-09 21:16:16

Luogu P1092 虫食算(枚举+剪枝)的相关文章

Luogu P1092 虫食算

题目描述 所谓虫食算,就是原先的算式中有一部分被虫子啃掉了,需要我们根据剩下的数字来判定被啃掉的字母.来看一个简单的例子: 43#9865#045 +8468#6633 44445509678 其中#号代表被虫子啃掉的数字.根据算式,我们很容易判断:第一行的两个数字分别是5和3,第二行的数字是5. 现在,我们对问题做两个限制: 首先,我们只考虑加法的虫食算.这里的加法是N进制加法,算式中三个数都有N位,允许有前导的0. 其次,虫子把所有的数都啃光了,我们只知道哪些数字是相同的,我们将相同的数字用

洛谷 P1092 虫食算

P1092 虫食算 题目描述 所谓虫食算,就是原先的算式中有一部分被虫子啃掉了,需要我们根据剩下的数字来判定被啃掉的字母.来看一个简单的例子: http://paste.ubuntu.com/25448822/ 其中#号代表被虫子啃掉的数字.根据算式,我们很容易判断:第一行的两个数字分别是5和3,第二行的数字是5. 现在,我们对问题做两个限制: 首先,我们只考虑加法的虫食算.这里的加法是N进制加法,算式中三个数都有N位,允许有前导的0. 其次,虫子把所有的数都啃光了,我们只知道哪些数字是相同的,

[NOIP2004] 提高组 洛谷P1092 虫食算

题目描述 所谓虫食算,就是原先的算式中有一部分被虫子啃掉了,需要我们根据剩下的数字来判定被啃掉的字母.来看一个简单的例子: 43#9865#045 +8468#6633 44445509678 其中#号代表被虫子啃掉的数字.根据算式,我们很容易判断:第一行的两个数字分别是5和3,第二行的数字是5. 现在,我们对问题做两个限制: 首先,我们只考虑加法的虫食算.这里的加法是N进制加法,算式中三个数都有N位,允许有前导的0. 其次,虫子把所有的数都啃光了,我们只知道哪些数字是相同的,我们将相同的数字用

洛谷—— P1092 虫食算

https://www.luogu.org/problem/show?pid=1092 题目描述 所谓虫食算,就是原先的算式中有一部分被虫子啃掉了,需要我们根据剩下的数字来判定被啃掉的字母.来看一个简单的例子: http://paste.ubuntu.com/25448822/ 其中#号代表被虫子啃掉的数字.根据算式,我们很容易判断:第一行的两个数字分别是5和3,第二行的数字是5. 现在,我们对问题做两个限制: 首先,我们只考虑加法的虫食算.这里的加法是N进制加法,算式中三个数都有N位,允许有前

洛谷 P1092 虫食算 Label:dfs

题目描述 所谓虫食算,就是原先的算式中有一部分被虫子啃掉了,需要我们根据剩下的数字来判定被啃掉的字母.来看一个简单的例子: 43#9865#045 +8468#6633 44445509678 其中#号代表被虫子啃掉的数字.根据算式,我们很容易判断:第一行的两个数字分别是5和3,第二行的数字是5. 现在,我们对问题做两个限制: 首先,我们只考虑加法的虫食算.这里的加法是N进制加法,算式中三个数都有N位,允许有前导的0. 其次,虫子把所有的数都啃光了,我们只知道哪些数字是相同的,我们将相同的数字用

洛谷P1092虫食算——深搜

题目:https://www.luogu.org/problemnew/show/P1092 剪枝1:从右往左.从上往下按字母出现顺序搜索: 剪枝2:同一列前两个数字确定,可直接算出第三个数字并判断: 剪枝3:每次搜索前看看前面的列上有没有已经不符合的情况(进位最多为1): 代码如下: #include<iostream> #include<cstdio> using namespace std; int n,c[300],jin[30]; char a[5][30]; bool

P1092 虫食算

题目传送:https://www.luogu.org/problem/show?pid=1092 #include <iostream> #include <cstring> #include <cstdlib> #include <cstdio> #include <cmath> #define maxn 30 int n,flag[maxn]; char s[4][maxn]; bool use[maxn]; int id(char ch)/

P1092虫食算题解

2018-10-24 题目链接 题目思路: 我就讲下剪枝操作吧. 三个式子从上到下为A,B,C 剪枝操作 1.从3个式子右边开始从上到下枚举字母对应数字.(搜索顺序关键) 2.末尾(A+B)%n!=C. 3.已知A,B,不知C,且C的可能数字已经使用.(这三个点从2000ms) 4.已知A.C,不知B,且B的可能数字已经使用.(一下剪枝成) 5.已知B,C,不知A,且A的可能数字已经使用.(100ms) 6.已知A,B,C,且A+B不等于C,且A+B+1不等于C. 7.已经A,B,C的最高位,且

LUGOU P1092 虫食算

传送门 解题思路 刚开始按yzy神犇给的方法写,就是每次要把能算出来的都算出来,结果因为太菜写挂了..后来直接爆搜水过.. #include<iostream> #include<cstdio> #include<cstring> #include<cmath> #include<cstdlib> using namespace std; const int MAXN=40; int n,a[MAXN],cnt; char s[4][MAXN];