搜索II 难度：提高

最新推荐文章于 2024-08-26 12:30:32 发布
最新推荐文章于 2024-08-26 12:30:32 发布
阅读量108 收藏 1
点赞数 2
分类专栏： NOIP提高组训练日常 文章标签： 深度优先 广度优先 剪枝 迭代加深 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Frosty_Jackal/article/details/120305550
版权

                                                                                                                ——Frosty_Jackal 于9.14

                                                                                                                                  

由于‘N’较小，考虑用二进制压缩来处理。

令一个长度为9 的 01 数字串 中，1表示该数位上没填数，0表示填了。为什么用1表示没填？方便用lowbit函数找到这个‘1’值，从而找到要去填那个数。

由题意 对一个坐标所在九宫格可以由它的行，列确定：grid（x，y）=（x/3）*3 + y/3

由于是多组数据，预处理就显得尤为重要：

  1. 由题意，优先找到哪个坐标能填合法数字最少，去填。于是处理出每个状态有多少个1：
 for(int i=0;i<(1<<SIZE); ++ i ) 
        for(int j=i;j;j-=lowbit(j))
        {
            cnt[i]++;
        }
  1. 对于一个lowbit运算，我们取出的是1所在的位置，怎么通过位置找到实际对应的填数？

即：

for(int i=0;i<SIZE;++i) num[(1<<i)]=i;

为了方便回溯，填数的时候用异或操作！

inline void filp(int x,int y,int z)
{
    h[x]^=(1<<z);
    l[y]^=(1<<z);
    grid[getgrid1(x,y)]^=(1<<z);
}

输入输出采用这种格式最好！

for(int i=0;i<SIZE;++i)
for(int j=0;j<SIZE;++j)
sta[i][j]=s[i*9+j];

在输入中可以记tot=‘.’的总数，

DFS的过程可以以tot作为每一层状态转移的标志。

代码：

int SIZE=9,c;
char s[MAXN];char sta[21][21];
bool vi[12][12];
int h[11],l[11],grid[11],cnt[(1<<11)],num[(1<<11)];
inline int lowbit(int x){ return  x& ( -x );}
 
inline int getgrid1(int x,int y)
{
    return (x/3)*3+y/3;
}
 
inline void filp(int x,int y,int z)
{
    h[x]^=(1<<z);
    l[y]^=(1<<z);
    grid[getgrid1(x,y)]^=(1<<z);
}
 
bool dfs(int now)
{
    if(now==0)  return true;
    int temp=10,x,y;
    for(int i=0;i<SIZE;++i)
        for(int j=0;j<SIZE;++j)
        {
            if(sta[i][j]!='.') continue;
            int val=h[i] & l[j] & grid[getgrid1(i,j)];
            if(!val) return 0;
            if(cnt[val]<temp)
            {
                temp=cnt[val];
                x=i,y=j;
            }
        }
    int val=(h[x] & l[y] & grid[ getgrid1(x,y)]);
    for(;val;val-=lowbit(val))
    {
        int je=lowbit(val);
        int c=num[je];
        sta[x][y]=c+'1';
        filp(x,y,c);
        if(dfs(now-1)) return 1;
        filp(x,y,c);
        sta[x][y]='.';
    }
    return 0;
}
 
int main()
{   
    for(int i=0;i<(1<<SIZE); ++ i ) 
        for(int j=i;j;j-=lowbit(j))
        {
            cnt[i]++;
        }
    for(int i=0;i<SIZE;++i)  num[(1<<i)]=i;
    while(scanf("%s",s) && s[2]!='d')
    {
        int tot=0;
        for(int i=0;i<SIZE;++i)
            for(int j=0;j<SIZE;++j)
            {
                sta[i][j]=s[i*9+j];
            }
        for(int i=0;i<SIZE;++i) h[i]=l[i]=grid[i]=(1<<9)-1;
        for(int i=0;i<SIZE;++i)
            for(int j=0;j<SIZE;++j)
            {
                if(sta[i][j]!='.')
                {
                    filp(i,j,sta[i][j]-'1');    
                }
                else tot++;
            }
        dfs(tot);
        for(int i=0;i<SIZE;++i)
        for(int j=0;j<SIZE;++j)
        {
                s[i*9+j]=sta[i][j];
        }
        puts(s);
    }
    return 0;
}
 
/*
.2738..1..1...6735.......293.5692.8...........6.1745.364.......9518...7..8..6534.
......52..8.4......3...9...5.1...6..2..7........3.....6...1..........7.4.......3.
expected answer:
527389416819426735436751829375692184194538267268174593643217958951843672782965341
416837529982465371735129468571298643293746185864351297647913852359682714128574936
*/

 

 

是一个深搜为主题的大模拟。十分考验代码技巧。

首先是消除操作，不能逢3就消除，这样对于5个同色的情况便不能全部消除，应当先全部标记后统一消除。

inline bool remove()
{
    int flag=0;
    for(int i=1;i<=5;++i)
        for(int j=1;j<=7;++j)
        {
            if(i-1>=1 && i+1<=5 && map[i-1][j]==map[i][j] &&  map[i][j]==map[i+1][j] && map[i][j])
            {
                xiao[i-1][j]=xiao[i][j]=xiao[i+1][j]=1;flag=1;
            }
            if(j-1>=1 && j+1<=7 && map[i][j-1] == map[i][j] && map[i][j]==map[i][j+1] && map[i][j])
            {
                xiao[i][j-1]=xiao[i][j]=xiao[i][j+1]=1;flag=1;
            }
    }
    if(!flag) return 0;
    for(int i=1;i<=5;++i)
        for(int j=1;j<=7;++j)
        {
            if(xiao[i][j])
            {
                xiao[i][j]=0;
                map[i][j]=0;
            }
        }
    return 1;
}

其次是下落操作。

inline void update()
{
    for(int i=1;i<=5;++i)
    {
        int x=0;
        for(int j=1;j<=7;++j)
        {
            if(!map[i][j]) x++;
            else
            {
                if(!x) continue;
                map[i][j-x]=map[i][j];
                map[i][j]=0;
            }
        }
    }
}

然后是复制操作，用于回溯。

for(int i=1;i<=5;++i)
    {
        for(int j=1;j<=7;++j)
        last[x][i][j]=map[i][j];
    }
}

由于last的第一维度是步数，于是进一步深搜时，步数+1，不会被覆盖掉。

检查是否全部消除

inline bool check()
{
    for(int i=1;i<=5;++i)
        if(map[i][1]) return 0;
    return 1;
}

左右移动操作：

注意，若移动并掉落后，可能会同色，此时需要不断进行消除和掉落操作保证状态图合法。

void move(int i,int j,int x)
{
    int tmp=map[i][j];
    map[i][j]=map[i+x][j];
    map[i+x][j]=tmp;
    update();
    while(remove()) update();
}

搜索中的剪枝：

  1. 对于一个方块，若它左边有方块则不再往左边搜索，因为当枚举完左边那个方块时，已经通过搜索证明了往左搜的情况是不合法的。
  2. 在（1）对向左边搜的限制下，当右边同色，不再向右搜。

代码：

int n,map[MAXN][MAXN];
int ans[MAXN][38];
int last[MAXN][MAXN][MAXN];
bool xiao[MAXN][MAXN];
 
inline void update()
{
    for(int i=1;i<=5;++i)
    {
        int x=0;
        for(int j=1;j<=7;++j)
        {
            if(!map[i][j]) x++;
            else
            {
                if(!x) continue;
                map[i][j-x]=map[i][j];
                map[i][j]=0;
            }
        }
    }
}
inline bool remove()
{
    int flag=0;
    for(int i=1;i<=5;++i)
        for(int j=1;j<=7;++j)
        {
            if(i-1>=1 && i+1<=5 && map[i-1][j]==map[i][j] &&  map[i][j]==map[i+1][j] && map[i][j])
            {
                xiao[i-1][j]=xiao[i][j]=xiao[i+1][j]=1;flag=1;
            }
            if(j-1>=1 && j+1<=7 && map[i][j-1] == map[i][j] && map[i][j]==map[i][j+1] && map[i][j])
            {
                xiao[i][j-1]=xiao[i][j]=xiao[i][j+1]=1;flag=1;
            }
    }
    if(!flag) return 0;
    for(int i=1;i<=5;++i)
        for(int j=1;j<=7;++j)
        {
            if(xiao[i][j])
            {
                xiao[i][j]=0;
                map[i][j]=0;
            }
        }
    return 1;
}
 
void move(int i,int j,int x)
{
    int tmp=map[i][j];
    map[i][j]=map[i+x][j];
    map[i+x][j]=tmp;
    update();
    while(remove()) update();
}
 
inline void copy(int x)
{
    for(int i=1;i<=5;++i)
    {
        for(int j=1;j<=7;++j)
        last[x][i][j]=map[i][j];
    }
}
 
inline bool check()
{
    for(int i=1;i<=5;++i)
        if(map[i][1]) return 0;
    return 1;
}
 
void dfs(int x)
{
    if(check())
    {
        for(int i=1;i<=n;++i)
        {
            if(i!=1) printf("\n");
            for(int j=1;j<=3;++j)
            printf("%d ",ans[i][j]);
        }
        exit(0);
    }
    if(x==n+1) return ;
    copy(x);
    for(int i=1;i<=5;++i)
        for(int j=1;j<=7;++j)
        {
            if(!map[i][j]) continue;
            if(map[i][j]!=map[i+1][j] && i+1<=5)
            {
                move(i,j,1);
                ans[x][1]=i-1;ans[x][2]=j-1;ans[x][3]=1;
                dfs(x+1);
                for(int i=1;i<=5;++i)
                {
                    for(int j=1;j<=7;++j)
                    {
                        map[i][j]=last[x][i][j];
                    }
                }
                ans[x][1]=-1;ans[x][2]=-1;ans[x][3]=-1;
            }
            if(map[i-1][j]==0 && i-1>=1)
            {
                move(i,j,-1);
                ans[x][1]=i-1;ans[x][2]=j-1;ans[x][3]=-1;
                dfs(x+1);
                for(int i=1;i<=5;++i)
                {
                    for(int j=1;j<=7;++j)
                    {
                        map[i][j]=last[x][i][j];
                    }
                }
                ans[x][1]=-1;ans[x][2]=-1;ans[x][3]=-1;
            }
        }
     
}
 
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=5;++i)
        for(int j=1;j<=8;++j)
        {
            int x;  scanf("%d",&x);
            if(x==0) break;
            map[i][j]=x;
        }
    memset(ans,-1,sizeof(ans));
    dfs(1);
    puts("-1");
    return 0;
}
 
/*
3
1 0
2 1 0
2 3 4 0
3 1 0
2 4 3 4 0
 
expected answer:
2 1 1
3 1 1
3 0 1
*/

Frosty_Jackal
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
LeetCode第40题：组合总和ll【python 40/1000】
10年数据\经营分析经验，现任大厂数据分析负责人
04-19 1083
LeetCode的第40题“组合总和II”要求在一个可能包含重复元素的整数数组中找出所有的组合，这些组合中的元素之和等于给定的目标数。这些组合中的每个数字在每个组合中只能使用一次。本文将探讨三种不同的方法来解决这个问题，并分析它们的时间和空间复杂度。
DeepMind:星际争霸2：强化学习新挑战（翻译）
gonganDV的博客
03-18 6594
DeepMind：StarCraftII:A New Challenge for Reinforcement Learning 星际争霸2：强化学习新挑战 原文下载链接：https://deepmind.com/documents/110/sc2le.pdf 本文绿色字体是学习过程中的注释，蓝色字体为总结，可以忽略，最后附有个人翻译后记。 整个论文分为： 摘要（Abstract） 1....
​LeetCode刷题实战291：单词规律II
程序IT圈
06-11 288
算法的重要性，我就不多说了吧，想去大厂，就必须要经过基础知识和业务逻辑面试+算法面试。所以，为了提高大家的算法能力，这个公众号后续每天带大家做一道算法题，题目就从LeetCode上面选 ！...
​LeetCode刷题实战90：子集 II
程序IT圈
11-08 170
算法的重要性，我就不多说了吧，想去大厂，就必须要经过基础知识和业务逻辑面试+算法面试。所以，为了提高大家的算法能力，这个公众号后续每天带大家做一道算法题，题目就从LeetCode上面选 ...
子集和问题 算法_LeetCode刷题实战90：子集 II
weixin_39638048的博客
11-22 149
算法的重要性，我就不多说了吧，想去大厂，就必须要经过基础知识和业务逻辑面试+算法面试。所以，为了提高大家的算法能力，这个公众号后续每天带大家做一道算法题，题目就从LeetCode上面选 ！今天和大家聊的问题叫做子集 II，我们先来看题面：https://leetcode-cn.com/problems/subsets-ii/Given a collection of integers ...
IE安全系列：IE的自我介绍 （II）
weixin_34380781的博客
03-08 105
blast · 2015/04/08 9:46本篇依然是三段II.1 介绍一些基础概念和简单实现II.2介绍一些实用操作II.3介绍IE对某些内容实现的具体细节三节的内容并不是强联系，需要了解的内容也并不相同，跳过一节并不会影响到其他内容的理解，请根据需要来阅读。II.1 HTML与网马攻击跟龙总（@瞌睡龙）商量了一下更换了大纲顺序，所以本来放在后面的网马解密决定放在前面和HTML、Javascr...
​LeetCode刷题实战82：删除排序链表中的重复元素 II
程序IT圈
10-31 197
算法的重要性，我就不多说了吧，想去大厂，就必须要经过基础知识和业务逻辑面试+算法面试。所以，为了提高大家的算法能力，这个公众号后续每天带大家做一道算法题，题目就从LeetCode上面选 ...
leetcode解题报告：240. Search a 2D Matrix II
wengyunpeng的博客
09-12 479
题目大意： Write an efficient algorithm that searches for a value in an m x n matrix. This matrix has the following properties: Integers in each row are sorted in ascending from left to right.I
​LeetCode刷题实战79：单词搜索
程序IT圈
10-27 153
算法的重要性，我就不多说了吧，想去大厂，就必须要经过基础知识和业务逻辑面试+算法面试。所以，为了提高大家的算法能力，这个公众号后续每天带大家做一道算法题，题目就从LeetCode上面选 ...
洛谷试炼场---提高历练地
mrcrack的博客
04-11 9565
洛谷试炼场---提高历练地 搜索Ex   1.NOIP 2004 提高组 复赛 alpha 虫食算 //P1092 虫食算 //读完题目，第一直觉，要用高精度算法。 //N进制，该题处理，对理解进制很有帮助。 //为何要从高位往低位搜索，这篇文章写得不错http://blog.sina.com.cn/s/blog_918b1f910100zuzr.html摘抄如下： // 仔细考虑过后，因...
神经结构搜索的计算有效性综述：提高计算效率是NAS的关键，CE-NAS方法的系统概述
自动化与智能学报1（2022）100002计算有效的神经结构搜索综述刘世清a，张浩宇c，靳耀初a，b，张伟德国比勒费尔德大学技术学院自然启发计算与工程系主任，邮编：33619b英国吉尔福德萨里大学计算机科学系GU2 7XHc东华...
SADEA-II：天线设计与多维度模型优化
可在www.sciencedirect.com上在线获取Journalof Computational Design and Engineering 4（2017）86九www.elsevier.com/locate/jcdeSADEA-II：天线设计Bo Liua，n，SlawomirKobarb，Nazar Alica英国雷克瑟姆格林杜尔...
"SADEA-II：天线设计自动化代理模型辅助进化算法
可在www.sciencedirect.com上在线获取Journalof Computational Design and Engineering 4（2017）86九www.elsevier.com/locate/jcdeSADEA-II：天线设计Bo Liua，n，SlawomirKobarb，Nazar Alica英国雷克瑟姆格林杜尔...
改进的 RSA 算法: 提高信息安全性的随机比特填充技术 (RBMRSA)
埃及信息学杂志23（2022）291一种基于改进RSA算法的信息安全抗攻击随机比特填充技术（RBMRSA）法洛沃岛...2021年11月20日收到2022年2月1日修订2022年2月11日接受2022年3月4日在线发布保留字：计算复杂度穷举搜索攻
合成潜在指纹生成器: 提高指纹匹配准确性和数据集性能
971合成潜在指纹生成器安德烈'巴西维埃拉Wyzykowski1和阿尼尔K。耆那教11密歇根州立大学{wyzykow 2，jain}@ msu.edu摘要给定一个完整的指纹图像（卷或巴掌），我们提出了CycleGAN模型来生成多个潜在的immuno，作为...
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5147
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
神经网络模型剪枝快速指南
最新发布
新缸中之脑
08-26 1027
模型剪枝（Model Pruning）是指从深度学习神经网络模型中删除不重要的参数，以减小模型大小并实现更高效的模型推理。通常，只剪枝参数的权重，而不影响偏差。偏差的剪枝往往有更明显的缺点。非结构化剪枝期间权重如何归零的可视化由于这些参数被删除，可能会导致模型推理性能下降，因此应谨慎执行。在后续章节中，我们将探讨剪枝的类型以及剪枝策略，然后再讨论适合你特定用例的最佳剪枝策略。
Llama 4B剪枝蒸馏实战
新缸中之脑
08-26 543
大型语言模型 (LLM) 因其有效性和多功能性，如今已成为自然语言处理和理解领域的主导力量。LLM（例如 Llama 3.1 405B 和 NVIDIA Nemotron-4 340B）在许多具有挑战性的任务中表现出色，包括编码、推理和数学。然而，它们的部署需要大量资源。因此，业界还有另一种趋势，即开发小型语言模型 (SLM)，这种模型在许多语言任务中足够熟练，但部署到大众中却便宜得多。
力扣每日一题 划分为k个相等的子集 回溯 递归 细节剪枝
人言束负
08-25 413
👨‍🏫 参考题解
LeetCode训练营：Task23 - 不同的二叉搜索树II解析
"LSGO软件技术团队的第二期基础算法训练营中，针对LeetCode的刻意练习，涉及的题目是中等难度的95号问题——不同的二叉搜索树II。训练营涵盖五个知识点，其中之一是树。二叉搜索树是一种特殊的树结构，满足所有节点...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值