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

最新推荐文章于 2022-03-03 14:24:10 发布
最新推荐文章于 2022-03-03 14:24:10 发布
阅读量86 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/coder-Uranus/p/9715244.html
版权

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\) 就出来了：

o_%E6%8D%95%E8%8E%B7.PNG

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

怨念--;

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

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

weixin_30907523
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Lightoj 1100 - Again Array Queries (枚举剪枝)
滴水穿石，慢慢积累，总会有成果
10-26 472
1100 - Again Array Queries PDF (English) Statistics Forum Time Limit: 3 second(s) Memory Limit: 32 MB Given an array with n integers, and you are gi
USACO-Arithmetic Progressions（枚举剪枝）
On the way
03-04 327
题目链接：USACO-Arithmetic Progressions 翻译 首先计算出所有的双平方数，有2e4个，然后排序后开始枚举。如果在一个枚举样例中，d*(n-1)+a_0>max(a)，那么说明不可能组成等差数列，则退出，由于n>=3，这里对于a_0较大的情况完成了大量的剪枝。 还有一个剪枝就是从后往前枚举。因为后面较前面而言比较稀疏。因此枚举较少数量的等差数列后就能根据
【算法学习】枚举与剪枝(一)
weixin_34050005的博客
05-05 100
2019独角兽企业重金招聘Python工程师标准>>> ...
poj1018 枚举+剪枝
zht的专栏
04-23 3505
大致题意： 某公司要建立一套通信系统，该通信系统需要n种设备，而每种设备分别可以有m1、m2、m3、...、mn个厂家提供生产，而每个厂家生产的同种设备都会存在两个方面的差别：带宽bandwidths 和 价格prices。 现在每种设备都各需要1个，考虑到性价比问题，要求所挑选出来的n件设备，要使得B/P最大。 其中B为这n件设备的带宽的最小值，P为这n件设备的总价。      解题
编程算法基础_常用思路_1_枚举与剪枝
后知后觉的it路
06-20 183
  剪枝的由来：   暴力破解中，依靠计算机的强大计算能力时，必须考虑计算性能和计算限度 eg: 100W的双层for循环，计算机就会比较吃力，耗时较长.   如果某个问题考虑情况较多，我们可以尝试在逻辑中排除不可能的情况，或者从循环中找出一些规律来排除循环次数(eg 案例2)，减少计算次数，这就是剪枝的由来。    案例如下:   public class pruning...
Luogu3.0plusplus:罗谷3.0 ++解释器，求星
04-05
使用方式：命令行格式luogu++ fileplace解释器会自动找到.lgpp源代码和.in栈初始化（可以没有），生成输出至.out .in格式： A data0 data1 ... datan C data0 data1 ... datam 其中data0〜datan按从栈底到栈顶的...
Luogu P2278 [HNOI2003]操作系统
01-20
操作系统是计算机科学中的核心课程，它管理着计算机的硬件资源，包括CPU，以高效地执行各种任务。在本题中，我们关注的是操作系统如何调度任务，特别是如何处理具有优先级的任务。问题描述了一个简单的多任务环境，...
luogu P4568代码
01-27
洛谷P4568题解 其实就是个简单的NOIP..
vscode-luogu:解决VSCode中落谷问题
05-30
vscode-luogu轻松的让你在VSCode 上提交洛谷代码使用说明查看题目按下F1或Ctrl+Shift+P ，查找Luogu: 查看题目命令，点击后输入题号完成搜索点击界面左侧洛谷图片，然后点击搜索图标，输入题号完成搜索完成功能查看...
LuoGu:罗古刷题汇总
03-18
【标题】：“LuoGu:罗古刷题汇总”指的是一个关于编程竞赛平台洛谷（LuoGu，又称洛谷Puzzle）上的题目刷题集合。这个标题表明这是一个集中的资源，包含了用户在洛谷上练习和学习的各种编程题目。 【描述】：“罗谷...
uva 1432 - Fire-Control System(枚举+剪枝）
不慌不忙、不急不躁
02-14 1342
题目链接：uva 1432 - Fire-Control System 题目大意：有一个武器位于（0，0）的位置，它的攻击范围为一个扇形，现在要求攻击到k个点，并且面积越小。 解题思路：首先先按照半径排序，这样可以计算出比该点半径小的点有几个。然后按照角度排序，枚举半径，如果小于当前半径的点的个数不足k可以跳过该半径。需要注意的是第2、3象限的点。 #include
算法思想：枚举与剪枝
大帅哥专栏
07-23 894
在东北话中有一句：“小树不修不直溜，人不修理哏啾啾”。树要剪枝，才能更好的茁壮成长，程序也一样，在逻辑比较复杂的情况下，需要多层嵌套来完成业务逻辑，如果遍历数量比较大的话，计算机的运算速度会慢下来。下面来看这样的一种需求，假如杨云要做生意，但是它不会数学(她的数学有多烂，看为她而战)，不知道怎么找零钱，需要我们写个程序来帮她计算，比如说8元，可以分为5元、2元、1元、5角。有多少种找零方案呢？
最优化剪枝——不无脑的枚举
Freopen的博客
09-26 645
上次给大家讲了一篇关于无脑枚举的编（O）程（J）题（shui）目（ti）。大家是不是觉得枚举既简单又简（bao）单（li）呢？可是除了水题，没有一个题目会安心让你枚举的，到时候就是WA，RE，TL，OL的餐具，比如下面这题： 通讯线路(haywire.cpp)FJ的N(4 <= N <= 12, N 为偶数)头牛建立起原始的通讯系统，在每一对好友之间建起通讯线路。 每头牛都恰好有3个好友。 所有的奶
编程算法基础-枚举与剪枝
u011925500的专栏
04-20 1671
1.2枚举与剪枝 暴力破解虽然简单有效，但是有弱点，考虑的情况很多时，计算机承受不了。 人为排除一些不可能的情况。 剪枝就是为了让计算机尽量避免无用的徒劳的动作。 找零方案 要找8元零钱，有零钞：5元，2元，1元，5角 求所有找零方案。   5角如果写成浮点型的，在计算相等的时候会产生误差，所以全部扩大十倍，再进行比较。 /*要找8元零钱，有零钞：5元，2元，1元，5角 求所有找
枚举与剪枝_观察算式（比标准答案还要牛B）
u012897654的专栏
04-18 1287
△△△ * △△ = △△△△ 某3位数乘以2位数，结果为4位数 要求：在9个△所代表的数字中，1~9的数字恰好每个出现1次。
hdu 1692(枚举+剪枝)
hexianhao的博客
04-16 690
题意：给你一些井的信息，井中原有的水，当井中的水满足一定量后会被破坏并且这些水全部流入下一个井中，用多少能量能直接破坏这个井。然后问要想破坏第n口井至少要多少能量。 解题思路：这题首先是要找到从哪口井开始破坏，因为要破坏第n口井，要么直接破坏n，要么n之前有连续的几口井一同被破坏，如果中间出现了一个不破坏的井，那么之前的能量就浪费了。 一般的思路肯定是两层循环就搞定，但看到这个数据量有点怕超时
第01讲-枚举与剪枝_观察算式
蓝天贤彤
04-27 408
观察算式 观察下面的算式： △△△ * △△ = △△△△ 某3位数乘以2位数，结果为4位数 要求：在9个△所代表的数字中，1~9的数字恰好每个出现1次。
暴力求解法(枚举，搜索，回溯，剪枝策略)
qq_51539256的博客
03-03 1949
暴力求解法，介绍枚举，排列，搜索剪枝，回溯
算法基础——1.2枚举与剪枝
fpf880821的专栏
04-29 753
例一 [java] view plaincopy /*    要找8元钱。    有零钞：5元，2元，1元，5角。    求所有找零方案  */      public class T1   {       public static void main(String[] args)       {           int SUM
Luogu P1088 火星人
最新发布
06-07
这是一道算法竞赛中的题目，需要使用动态规划算法来解决。 题目描述：有n个火星人，他们的能力值分别为a1,a2,…,an。现在你需要将他们划分成两组，使得他们的能力值之差最小，求这个最小的差值。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值