[NOIP2004]虫食算 T4 简单搜索＋剪枝

最新推荐文章于 2023-10-18 13:03:07 发布
最新推荐文章于 2023-10-18 13:03:07 发布
阅读量1.3k 收藏
点赞数 1
分类专栏： 搜索 noip 文章标签： 搜索 剪枝 NOIP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_32451161/article/details/51330828
版权
搜索 同时被 2 个专栏收录
12 篇文章 0 订阅
订阅专栏
noip
11 篇文章 0 订阅
订阅专栏

最近在刷搜索套餐
我先做了一道简单的
虫食算。。。。
我GO die了。。。。。。。。。。。
这都是啥啊！！！！！！！！！！！！！！！

wawawa

总之就是一个搜啊。。。。
从最右面开始搜
每一行行尾进行check
基本上能过9个点。。。。。。。。

剪枝的话 ，考虑检索前面的每一行 如果改行的数字都己经试过，那么就可以判断合法性，如果已经有两个试过的话，考虑第三个数是否可能（可能已经被用过）
注意：试数的时候从后向前试。。。坑爹的数据
注意进位即可

下面是代码，调试信息懒得删。。。。搜索的第四层可删 略长。。。

#include <stdio.h>
#include <string.h>
#include <iostream>
#include <time.h>
#include <stdlib.h>
#include <algorithm>
#define N 100
using namespace std;
char str[N];
int a[N],b[N],c[N],t[N],n;
bool jinwei[N];
int calc(int ROW)
{return t[a[ROW]]+t[b[ROW]];}
inline void solve()
{
    for(int i=0;i<n-1;++i)cout<<t[i]<<" ";
    cout<<t[n-1];
    puts("");
}
inline int pre(int ROW)
{
    int times=0;
    if(t[a[ROW]]!=-1)++times;
    if(t[b[ROW]]!=-1)++times;
    if(t[c[ROW]]!=-1)++times;
    return times;
}
/*int Call_check(int ROW,int exist)
{
    for(int i=ROW;i>=1;--i)
    {
        int k=pre(i);
    /*  printf("CHECK at LINE ");printf("%d\n",__LINE__);
        printf("ROW==%d EXIST==%d\n",ROW,exist);*/
/*      if(k==3)
        {
            int x=calc(i);
            if(x%n==t[c[ROW]]||(x+1)%n==t[c[ROW]])continue;
            else return false;
        }
        else if(k==2)
        {
            if(t[c[ROW]]==-1)
            {
                int x=calc(i);
                /*printf("CHECK at LINE ");printf("%d\n",__LINE__);
                puts("solve !");
                solve();
                printf("ROW=%d,a[ROW]=%d,b[ROW]=%d,c[ROW]=%d\n",ROW,a[ROW],b[ROW],c[ROW]);*/
/*                int tmp1=x%n,tmp2=(x+1)%n;
                if((1<<tmp1)&exist && (1<<tmp2)&exist)return false;
            }
            else if(t[b[ROW]]==-1)
            {
                if(t[c[ROW]]<=t[a[ROW]])
                {
/*                      printf("CHECK at LINE ");printf("%d\n",__LINE__);
                      puts("solve !");
                      solve();
                      printf("ROW=%d,a[ROW]=%d,b[ROW]=%d,c[ROW]=%d\n",ROW,a[ROW],b[ROW],c[ROW]);*/
/*                      int tmp1=t[c[ROW]]+n;
                      tmp1-=t[a[ROW]];
                      if((1<<tmp1)&exist)return -1;
                }
                else
                {
/*                    printf("CHECK at LINE ");printf("%d\n",__LINE__);
                    puts("solve !");
                    solve();
                    printf("ROW=%d,a[ROW]=%d,b[ROW]=%d,c[ROW]=%d\n",ROW,a[ROW],b[ROW],c[ROW]);*/
/*                    int tmp1=t[c[ROW]]-t[a[ROW]];
                    int tmp2=t[c[ROW]]+n-t[a[ROW]];
                    tmp2%=n;
                    if((1<<tmp1)&exist&&(1<<tmp2)&exist)return -1;
                }
            }
            else if(t[a[ROW]]==-1)
            {
/*                printf("CHECK at LINE ");printf("%d\n",__LINE__);
                puts("solve !");
                solve();
                printf("ROW=%d,a[ROW]=%d,b[ROW]=%d,c[ROW]=%d\n",ROW,a[ROW],b[ROW],c[ROW]);*/
/*                if(t[c[ROW]]<=t[b[ROW]])
                {
                    int tmp1=t[c[ROW]]+n;
                    tmp1-=t[b[ROW]];
                    if((1<<tmp1)&exist)return -1;
                }
                else
                {
                    int tmp1=t[c[ROW]]-t[b[ROW]];
                    int tmp2=t[c[ROW]]+n-t[b[ROW]];
                    tmp2%=n;
                    if((1<<tmp1)&exist&&(1<<tmp2)&exist)return -1;
                }
            }
        }
        else
            continue;
    }
    return 1;
}*/  
inline int Call_check(int ROW,int exist)
{
    for(int i=ROW;i>=1;--i)
    {
        int k=pre(i);
    /*  printf("CHECK at LINE ");printf("%d\n",__LINE__);
        printf("ROW==%d EXIST==%d\n",ROW,exist);*/
        if(k==3)
        {
            int x=calc(i);
            if( x%n==t[c[i]] || (x+1)%n==t[c[i]])continue;
            else return -1;
        }
    }
    return 1;
}
inline int recheck(int ROW)
{
    if(t[a[ROW]]!=-1&&t[b[ROW]]!=-1&&t[c[ROW]]!=-1)
    {
        int tmp=calc(ROW);
        if(jinwei[ROW])++tmp;
        int k=tmp;
        tmp%=n;
        if(tmp^t[c[ROW]])return -1;
        else if(k>=n)
        {
            jinwei[ROW-1]=true;
            return 2;
        }
        else
        {
            return 1;
        }
    }
    else
    {
        return 0;
    }
}
inline bool DFS(int LINE,int ROW,int exist)
{
/*  if(ROW==18)
    {
        printf("CHECK at LINE ");printf("%d\n",__LINE__);
        printf("LINE==%d ROW==%d EXIST==%d\n",LINE,ROW,exist);
        solve();
    }*/
    if(LINE==4)
    {
        int tmp=calc(ROW);
        //printf("%d\n",tmp );
        //*if(tmp<0)
        /*{ 
            printf("Check at LINE 23\n");
            printf("LINE=%d ROW=%d\n",LINE,ROW );
            for(int i=1;i<=n;++i)
                printf("%d ",t[a[i]] );
            puts("");
            for(int i=1;i<=n;++i)
                printf("%d ",t[b[i]] );
            puts("");
            for(int i=1;i<=n;++i)
                printf("%d ",t[c[i]] );
            puts("");
        }*/
        if(ROW==n)
        {   
            if(tmp%n==t[c[ROW]])
            {   
                if(tmp>=n) jinwei[ROW-1]=true;
                if( DFS(1,ROW-1,exist))return true;     
                else { jinwei[ROW-1]=false;return false;}
            }
            else return false;
        }   
        else
        {
            if(ROW==1)
            {
                int re=recheck(ROW);
                if(re==-1)return false;
                else if(re==2&&ROW!=1)
                {
                    if(DFS(1,ROW-1,exist))return true;
                    else
                    {
                        jinwei[ROW-1]=false;
                        return false;
                    }
                }
                else if(re==2&&ROW==1)
                {
                    solve();
                    return true;
                }
                else if(re==1&&ROW!=1)
                {
                    if(DFS(1,ROW-1,exist))
                    return true;
                    else return false;
                }
                else if(re==1&&ROW==1)
                {
                    solve();
                    return true;
                }
                else if(!re)
                {
                    if(jinwei[ROW])
                    {
                        if((tmp+1)%n==t[c[ROW]])
                        {solve();return true;}
                        else
                        {   return false;}
                    }
                    else
                    {
                        if(tmp%n==t[c[ROW]])
                        {
                            solve();return true;}
                        else
                            return false;
                    }
                }
            }
            else
            {
                if(jinwei[ROW])
                {
                    if((tmp+1)%n==t[c[ROW]])
                    {
                        if(tmp+1>=n)
                        {
                            jinwei[ROW-1]=true;
                            if(DFS(1,ROW-1,exist))return true;
                            jinwei[ROW-1]=false;return false;
                        }
                        else
                        {
                            return DFS(1,ROW-1,exist);
                        }
                    }
                }
                else
                {
                    if(tmp%n==t[c[ROW]])
                    {
                        if(tmp>=n)
                        {
                            jinwei[ROW-1]=true;
                            if( DFS(1,ROW-1,exist))return true;
                            jinwei[ROW-1]=false;return false;
                        }
                        else
                        {
                            if( DFS(1,ROW-1,exist))return true;
                            else return false;
                        }
                    }
                }
            }
        }
    }
    else
    {
        if(LINE==1)
        {
            int re=recheck(ROW);
            if(re==-1)return false;
            else if(re==2&&ROW!=1)
            {
                if(DFS(1,ROW-1,exist))return true;
                else
                {
                    jinwei[ROW-1]=false;
                    return false;
                }
            }
            else if(re==2&&ROW==1)
            {
                solve();
                return true;
            }
            else if(re==1&&ROW!=1)
            {
                if(DFS(1,ROW-1,exist))
                return true;
                else return false;
            }
            else if(re==1&&ROW==1)
            {
                solve();
                return true;
            }
            //printf("ROW==%d  t[a[ROW]]=%d  a[ROW]=%d\n",ROW,t[a[ROW]],a[ROW]);
            else if(re==0)
            {
                if(t[a[ROW]]!=-1) return DFS(LINE+1,ROW,exist);
                else
                {
                    for(int i=n-1;i>=0;--i)
                    {   
                        if((1<<i)&exist)continue;
                        t[a[ROW]]=i;
                        int ss=Call_check(ROW,exist|(1<<i));
                        if(ss==-1){t[a[ROW]]=-1;continue;}
                        //cout<<t[a[ROW]]<<endl;
                        if(DFS(LINE+1,ROW,exist|(1<<i)))return true;
                        t[a[ROW]]=-1;
                    }
                    return false;
                }
            }
        }
        else if(LINE==2)
        {
            int re=recheck(ROW);
            if(re==-1)return false;
            else if(re==2&&ROW!=1)
            {
                if(DFS(1,ROW-1,exist))return true;
                else
                {
                    jinwei[ROW-1]=false;
                    return false;
                }
            }
            else if(re==2&&ROW==1)
            {
                solve();
                return true;
            }
            else if(re==1&&ROW!=1)
            {
                if(DFS(1,ROW-1,exist))
                return true;
                else return false;
            }
            else if(re==1&&ROW==1)
            {
                solve();
                return true;
            }
            else if(re==0)
            {
                if(t[b[ROW]]!=-1)return DFS(3,ROW,exist);
                else
                {
                    for(int i=n-1;i>=0;--i)
                    {   
                        if((1<<i)&exist)continue;
                        t[b[ROW]]=i;
                        int x=Call_check(ROW,exist|(1<<i));
                        if(x==-1){t[b[ROW]]=-1;continue;}
                        if(DFS(LINE+1,ROW,exist|(1<<i)))return true;
                        t[b[ROW]]=-1;
                    }
                    return false;
                }
            }
        }
        else if(LINE==3&&ROW!=1)
        {
            //puts("Check at LINE 141");
            //printf("LINE = %d ROW = %d\n",LINE,ROW );
            //solve();
            int tmp=calc(ROW);
            if(jinwei[ROW])tmp++;
            int k=tmp%n;
            if(t[c[ROW]]!=-1&&k==t[c[ROW]])
            {
                if(tmp>=n)jinwei[ROW-1]=true;
                if( DFS(1,ROW-1,exist))return true;
                else
                {
                    jinwei[ROW-1]=false;return false;
                }
            }
            else if(t[c[ROW]]!=-1&&k!=t[c[ROW]])return false;
            else
            {
                if((1<<k)&exist)return false;
                else 
                {
                    t[c[ROW]]=k;if(tmp>=n)jinwei[ROW-1]=true;
                    if(DFS(1,ROW-1,exist|(1<<k)))return true;
                    else{t[c[ROW]]=-1;jinwei[ROW-1]=false;return false;}
                }
            }
        }
        else if(ROW==1&&LINE==3)
        {
        //  puts("Check at LINE 168");
            int tmp=calc(1);if(jinwei[ROW])tmp++;tmp%=n;
            if(tmp==t[c[1]]){solve();return true;}
        }
    }
    return false;
}
int main()
{   
    cin>>n;
    scanf("%s",str+1);for(int i=1;i<=n;++i)a[i]=str[i]-65;
    scanf("%s",str+1);for(int i=1;i<=n;++i)b[i]=str[i]-65;
    scanf("%s",str+1);for(int i=1;i<=n;++i)c[i]=str[i]-65;
//  for(int i=1;i<=n;++i)printf("%d",a[i] );puts("");
//  for(int i=1;i<=n;++i)printf("%d",b[i] );puts("");
//  for(int i=1;i<=n;++i)printf("%d",c[i] );puts("");
    for(int i=0;i<n;++i)t[i]=-1;    DFS(1,n,0);
    //if(cmp)   puts("23333333");
//  else
//  puts("wawawa");
}

这里写图片描述

qq_32451161
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
NOIP2004普及组复赛试卷与测试数据
08-29
NOIP2004普及组复赛试卷与测试数据NOIP2004普及组复赛试卷与测试数据NOIP2004普及组复赛试卷与测试数据NOIP2004普及组复赛试卷与测试数据NOIP2004普及组复赛试卷与测试数据NOIP2004普及组复赛试卷与测试数据NOIP2004...
虫食算-CSP
qq_38376545的博客
09-04 591
题目描述 下面是一个乘法算式，但是所有的数字都看不见了。 * * * × * * ----------- * * * * * * ----------- * * * * 如果一个*可以是任何一个数字，想必这个虫食算有相当多的解； 但如果一个*只能从给定集合中选取数字，那么这个虫食算有多少个解呢？ 输入格式 从文件alpha2.in中读入数据。 第一行有一个正整数 n，代表可选数字的个数。 第二行有 n个用空格隔开的数字，这些数字只能是1 到 9中的一...
洛谷P1092 虫食算（DFS+减枝）
weixin_43175029的博客
05-26 327
首先，我们只考虑加法的虫食算。这里的加法是N进制加法，算式中三个数都有N位，允许有前导的0。 其次，虫子把所有的数都啃光了，我们只知道哪些数字是相同的，我们将相同的数字用相同的字母表示，不同的数字用不同的字母表示。如果这个算式是N进制的，我们就取英文字母表午的前N个大写字母来表示这个算式中的0到N−1这N个不同的数字：但是这N个字母并不一定顺序地代表0到N−1N−1。输入数据保证N个字母分别至少出...
虫食算
qq_43765829的博客
02-21 694
题目描述 所谓虫食算，就是原先的算式中有一部分被虫子啃掉了，需要我们根据剩下的数字来判定被啃掉的字母。来看一个简单的例子： 43#9865#045 + 8468#6633 44445509678 其中#号代表被虫子啃掉的数字。根据算式，我们很容易判断：第一行的两个数字分别是5和3，第二行的数字是5。 现在，我们对问题做两个限制： 首先，我们只考虑加法的虫食算。这里的加法是N进制加法，算式中...
[NOIP 2004] 虫食算 (深搜+剪枝)
cqbz_luoyiran的博客
07-10 613
题目描述 所谓虫食算，就是原先的算式中有一部分被虫子啃掉了，需要我们根据剩下的数字来判定被啃掉的字母。来看一个简单的例子： 43#9865#045 + 8468#6633 44445509678 其中 # 号代表被虫子啃掉的数字。根据算式，我们很容易判断：第一行的两个数字分别是 5 和 3，第二行的数字是 5。 现在，我们对问题做两个限制： 首先，我们只考虑加法的虫食算。这里的加法是 n 进制加法，算式中三个数都有 n 位，允许有前导的 0。 其次，虫子把所有的数都啃光了，我们只知道哪些数字是相同的
NOIP2004-2017提高组初赛试题集
06-10
NOIP2004-2017提高组初赛试题集
NOIP2004普及组复赛试题1
08-03
第十届全国青少年信息学奥林匹克联赛复赛试题 第二行是一个正整数 M，表示要加上去的小整数（1 ） 第一题：不高兴的津津 第二题：花生采摘
noip2004普及组
10-25
noip2004不高兴的津津花生采摘FBI树火星人noip2004不高兴的津津花生采摘FBI树火星人
NOIP2004 .doc
06-15
NOIP题目 没有题解 普及组复赛试题 word文档
虫食算c++
Dh_virgil的博客
10-18 106
如果这个算式是 N� 进制的，我们就取英文字母表的前 N� 个大写字母来表示这个算式中的 00 到 N−1�−1 这 N� 个不同的数字：但是这 N� 个字母并不一定顺序地代表 00 到 N−1�−1。if (f[a[i]]==-1 || f[b[i]]==-1 || f[c[i]]==-1)//如果有一个数字没确定。其次，虫子把所有的数都啃光了，我们只知道哪些数字是相同的，我们将相同的数字用相同的字母表示，不同的数字用不同的字母表示。i--)//从后到前枚举。fir(i,1,n)//将字符变成整数。
虫食算——DFS
ChuRi_BaiYu的博客
07-14 586
虫食算——DFS 由最后一列的字符开始，逐步确定每一列的字符对应的数字
虫食算（dfs + 剪枝）
m0_59120421的博客
12-23 535
最近感觉遇到dfs时根本没什么递归搜索之类的想法，就想找点题做，从简单开始循序渐进，然后就看到这个简单题，做了下发现不是普通的简单题，看了别的网站发现是NOIP提高组的题，所以做完后就来总结一下。 剪枝：因为加法进位只有0或者1，所以如果前面进位不确定，则判断进位为0或者进位为1时a+b是否等于c即可，当最高位时，如果进位为0时都超出n则输出false；如果前面进位确定，则加上进位判断即可，最高位同理。 注意：给bi赋值时，一定要注意是同时给一列赋值，所以第一重循环是循环列，而不是行，在这里...
虫食算-详解-noip2004-深搜
legan的专栏
10-12 9881
虫食算 网址：https://vijos.org/p/1099 描述 所谓虫食算，就是原先的算式中有一部分被虫子啃掉了，需要我们根据剩下的数字来判定被啃掉的字母。来看一个简单的例子： 43#9865#045 + 8468#6633 = 44445506678 其中#号代表被虫子啃掉的数字。根据算式，我们很容易判断：第一行的两个数字分别是5和3，第二行的数字是5。
【搜索】【NOIP2004提高组】四、虫食算
diying4157的博客
08-19 348
四、虫食算(alpha.pas/dpr/c/cpp)【问题描述】所谓虫食算，就是原先的算式中有一部分被虫子啃掉了，需要我们根据剩下的数字来判定被啃掉的字母。来看一个简单的例子： 43#9865#045+8468#6633 44445506978其中#号代表被虫子啃掉的数字。根据算式，我们很容易判断：第一行的两个数字分别是5和3，第二...
【NOIP2004提高组T4】虫食算-搜索剪枝
Maxwei_wzj的OI世界
10-31 515
【NOIP2004提高组T4】虫食算-搜索剪枝
noip2004虫食算--搜索
caoyang1123的博客
08-11 192
链接：https://www.luogu.org/problemnew/show/P1092 首先这题标算据说是高斯消元，但标签已经是搜索了。。。身为蒟蒻当然只会打搜索。而我的搜索又打的很翔，从右到左dfs搜过来，暴枚这一列三个数的情况，然后进位。注意枚举从大到小枚，因为第一位（最左边）不会进位，所以从右到左时从大到小会更好，不然会被卡tle一个点。。。 // luogu-judger-en...
P1092 虫食算
Clannad
09-03 315
【题目描述】 所谓虫食算，就是原先的算式中有一部分被虫子啃掉了，需要我们根据剩下的数字来判定被啃掉的字母。来看一个简单的例子： http://paste.ubuntu.com/25448822/ 其中#号代表被虫子啃掉的数字。根据算式，我们很容易判断：第一行的两个数字分别是5和3，第二行的数字是5。 现在，我们对问题做两个限制： 首先，我们只考虑加法的虫食算。这里的加法是N进制加法，算式中
【高斯消元】[NOIP2004]虫食算(这是正解)
weixin_30770783的博客
01-30 262
题目描述 所谓虫食算，就是原先的算式中有一部分被虫子啃掉了，需要我们根据剩下的数字来判定被啃掉的字母。来看一个简单的例子： +43a9865a045008468a663344445506978 其中a代表被虫子啃掉的数字。 根据算式，我们很容易判断：第一行的两个数字分别是5和3，第二行的数字是5。 现在，我们对问题做两个限制： 首先，我们只考虑加法的虫食算...
python noip2004花生采摘
最新发布
01-26
根据提供的引用内容，题目是关于Python解决NOIP2004花生采摘问题的。下面是一个Python解决NOIP2004花生采摘问题的示例代码： ```python def max_peanuts(peanuts): m = len(peanuts) n = len(peanuts[0]) dp = ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值