[bzoj1054][BFS][移动玩具]

Rose_max Rose_max 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 500+累计阅读 539平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄10年
关注
原创 最新推荐文章于 2026-09-14 12:23:44 发布 539 阅读 AI 写同款· GEO 优化 ›
AI 帮我写单测：pytest 覆盖率提升 40% 的协作日志 AI助力pytest测试覆盖率提升40%的实践总结 本文分享了作者通过AI协作提升Python项目测试覆盖率的实践经验。初始测试覆盖率仅45%的电商后端项目，通过系统化的AI协作策略（代码分析、场景矩阵设计、迭代优化）实现了显著改进。AI不仅生成312个高质量测试用例，更提供了测试设计思路和最佳实践建议。最终覆盖率提升至85%，发现并修复23个潜在bug，效率提升3倍。文章详细展示了用户服务、订单服务等核心模块的测试案例，以及分层Fixture设计、参数化测试等高级技巧。关键成功因素包括明确的协作边界、迭代 阅读详情

Description

　　在一个4*4的方框内摆放了若干个相同的玩具，某人想将这些玩具重新摆放成为他心中理想的状态，规定移动
时只能将玩具向上下左右四个方向移动，并且移动的位置不能有玩具，请你用最少的移动次数将初始的玩具状态移 动到某人心中的目标状态。

Input

　　前4行表示玩具的初始状态，每行4个数字1或0，1表示方格中放置了玩具，0表示没有放置玩具。接着是一个空
行。接下来4行表示玩具的目标状态，每行4个数字1或0，意义同上。

Output

　　一个整数，所需要的最少移动次数。

Sample Input

1111
0000
1110
0010
1010
0101
1010
0101

Sample Output

4

题解

一个队友打了38行的代码我打了350+。。
我觉得我可以考虑一下敲死自己
就，状压成一维，然后我搞了好多情况讨论。。其实根本不用讨论的。。（直接高端check）
直接判第一行第一列第四行第四列还有1 4 13 16 ，这些不能往四周移动
其他就想一想乱搞一下
代码可读性超差

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<cmath>
#include<queue>
using namespace std;
int bin[25];
bool v[(1<<17)];
struct node
{
    int x,dep;
};
int sum[5][5];
void get(int x)
{
    memset(sum,0,sizeof(sum));
    int t=16;
    while(x)
    {
        if(x%2==1)sum[(t-1)/4+1][(t-1)%4+1]=1;
        else sum[(t-1)/4+1][((t-1)%4+1)]=0;
        x/=2;
        t--;
    }
    /*for(int i=1;i<=4;i++)
    {
        for(int j=1;j<=4;j++)printf("%d",sum[i][j]);
        printf("\n");
    }
    printf("\n");*/
}
node list[(1<<17)];int head,tail;
char sx[10][10],sy[10][10];
int st,ed;
int main()
{
    bin[16]=1;for(int i=15;i>=1;i--)bin[i]=bin[i+1]*2;
    for(int i=1;i<=4;i++)scanf("%s",sx[i]+1);
    getchar();
    for(int i=1;i<=4;i++)scanf("%s",sy[i]+1);
    st=ed=0;
    for(int i=1;i<=4;i++)
        for(int j=1;j<=4;j++)
        {
            if(sx[i][j]=='1')st=st*2+1;
            else st=st*2;
        }
    for(int i=1;i<=4;i++)
        for(int j=1;j<=4;j++)
        {
            if(sy[i][j]=='1')ed=ed*2+1;
            else ed=ed*2;
        }
    if(st==ed){printf("0\n");return 0;}
    memset(v,false,sizeof(v));v[st]=true;
    node aa;aa.x=st;aa.dep=0;
    head=1;tail=2;
    list[1]=aa;
    while(head!=tail)
    {
        node tmp=list[head];
        int x=tmp.x;
        for(int i=1;i<=16;i++)
            if((x&bin[i])!=0)
            {
                if(i%4!=1 && i%4!=0 && i>4 && i<12)
                {
                    int u=i-4;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                    u=i+4;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                    u=i-1;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                    u=i+1;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                }
                else if(i%4==1 && i!=13 && i!=1)
                {
                    int u=i+1;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                    if(i>4)
                    {
                        int u=i-4;
                        if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                        {
                            node cnt=tmp;
                            cnt.x=((x^bin[i])|(bin[u]));
                            cnt.dep++;
                        get(cnt.x);
                            if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                            list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                        }
                    }
                    if(i<=12)
                    {
                        int u=i+4;
                        if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                        {
                            node cnt=tmp;
                            cnt.x=((x^bin[i])|(bin[u]));
                            cnt.dep++;
                        get(cnt.x);
                            if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                            list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                        }
                    }
                }
                else if(i%4==0 && i!=4 && i!=16)
                {
                    int u=i-1;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                    if(i>4)
                    {
                        int u=i-4;
                        if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                        {
                            node cnt=tmp;
                            cnt.x=((x^bin[i])|(bin[u]));
                            cnt.dep++;
                        get(cnt.x);
                            if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                            list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                        }
                    }
                    if(i<=12)
                    {
                        int u=i+4;
                        if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                        {
                            node cnt=tmp;
                            cnt.x=((x^bin[i])|(bin[u]));
                            cnt.dep++;
                        get(cnt.x);
                            if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                            list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                        }
                    }
                }
                else if(i>1 && i<4)
                {
                    int u=i-1;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                    u=i+1;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                    u=i+4;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                }
                else if(i>13 && i<16)
                {
                    int u=i-1;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                    u=i+1;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                    u=i-4;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;
                        if(tail==(1<<16)+1)tail=1;
                    }
                }
                else if(i==1)
                {
                    int u=i+1;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                    u=i+4;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                }
                else if(i==16)
                {
                    int u=i-1;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                    u=i-4;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+50)tail=1;
                    }
                }
                else if(i==4)
                {
                    int u=i-1;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                    u=i+4;
                    if(((x&bin[u]))==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                }
                else if(i==13)
                {
                    int u=i+1;
                    if((x&bin[u])==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                    u=i-4;
                    if((x&bin[u])==0 && v[((x^bin[i])|(bin[u]))]==false)
                    {
                        node cnt=tmp;
                        cnt.x=((x^bin[i])|(bin[u]));
                        cnt.dep++;
                        get(cnt.x);
                        if(cnt.x==ed){printf("%d\n",cnt.dep);return 0;}
                        list[tail++]=cnt;v[cnt.x]=true;if(tail==(1<<16)+1)tail=1;
                    }
                }
            }
        head++;
        if(head==(1<<16)+50)head=1;
    }
    return 0;
}
收录于
bzoj

当前文章被收录于：

bzoj
482 篇文章 3 人学习
订阅专栏 查看详情
搜索

当前文章被收录于：

搜索
17 篇文章 0 人学习
订阅专栏 查看详情
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
qt open3dBPA重建 open3d BPA重建 阅读详情

相关推荐

AMEsim柱塞泵的建模学习

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言一、为什么要对柱塞泵进行仿真？二、Amesim中柱塞泵的模型1.amesim中自己的定排量五柱塞的斜盘柱塞泵2.压力、流量仿真总结 前言 最近在学习Amesim进行柱塞泵的仿真学习，顺便在这里记录我的学习过程，这是我的初衷 提示：以下是本篇文章正文内容，下面案例可供参考 一、为什么要对柱塞泵进行仿真？ 柱塞泵是功能和动力学比较复杂的流体机械。而在实际实验中，往往没有条件或者需要对柱塞泵做一些优化，所以需要我们利用仿真...

innocent_cft的博客 8181

移动玩具(状态压缩 + bfs)

原题链接 题目描述 具向上下左右四个方向移动，并且移动的位置不能有玩具，请你用最少的移动次数将初始的玩具状态移动到某人心中的目标状态。 输入样例 1111 0000 1110 0010 1010 0101 1010 0101 ####输出样例 4 (状态压缩 + bfs) O(n2)O(n^2)O(n2) 由于本题只有01两种数字，且只有16个元素，所以可以将这个二维数足状压成二进制来做。 在移动过程中，可以想到，我们可以先用 0 覆盖掉移动的位置，再将 1 插入，这一方法我们可以用位运算的方式

山中一扶苏的博客 545

反无人机作战体系全解析：从低慢小探测到分层拦截

随着小型无人机在军事和民用领域的广泛使用，低慢小目标探测与拦截成为低空安全的核心挑战。传统防空体系面对成本低廉、飞行高度低、雷达特征小的无人机集群时，暴露出探测难、识别难、处置成本失衡等问题。为应对威胁，反无人机体系采用分层闭环设计，融合雷达、光电、声学与无线电侦测实现多源感知，通过电子战软杀伤与导弹、高炮、激光等硬杀伤手段协同配合，并借助自动化指控系统缩短“传感器到射手”的响应时延。该体系既可支撑战场要地防护，也能为民用低空安防提供参考。围绕分层反制逻辑，梳理探测、软硬杀伤、指控布防及实战短板，提供理解反

weixin_42533120的博客 333

移动玩具（信息学奥赛一本通-T1453）

【题目描述】 在一个 4×4 的方框内摆放了若干个相同的玩具，某人想将这些玩具重新摆放成为他心中理想的状态，规定移动时只能将玩具向上下左右四个方向移动，并且移动的位置不能有玩具，请你用最少的移动次数将初始的玩具状态移动到目标状态。 【输入】 前四行表示玩具的初始状态，每行 4 个数字 1 或 0，1 表示方格中放置了玩具，0 表示没有放置玩具。 接着是一个空行。 接下来四行表示玩具的目...

Alex_McAvoy的博客 1794

GD32F105RBT6 keil工程模板

创建GD32F105RBT6的keil初始基础工程，未来的所有外设驱动都是基于这个基础工程进行扩展。

RMDYBW的博客 1926

用Multisim复刻经典收音机：从零搭建超外差中波调幅接收机（附仿真源文件）

本文详细介绍了如何使用Multisim软件从零搭建超外差中波调幅接收机，复刻经典收音机的设计过程。通过模块化搭建、稳定性优化和增益分配等实战指南，帮助读者掌握超外差架构的核心技术，并附赠仿真源文件供实践参考。

weixin_28744423的博客 474

1054: [HAOI2008]移动玩具

Description 　　在一个4*4的方框内摆放了若干个相同的玩具，某人想将这些玩具重新摆放成为他心中理想的状态，规定移动 时只能将玩具向上下左右四个方向移动，并且移动的位置不能有玩具，请你用最少的移动次数将初始的玩具状态移 动到某人心中的目标状态。 Input 　　前4行表示玩具的初始状态，每行4个数字1或0，1表示方格中放置了玩具，0表示没有放置玩具。接着是...

ailiao2015的博客 377

YOLOv11知识蒸馏实战：让小模型拥有大模型90%精度，速度提升3倍的终极教程

在self.alpha = alpha # 蒸馏损失权重self.temperature = temperature # 温度系数，控制分布平滑度# 输出分布蒸馏（KL散度损失）# 中间特征蒸馏（MSE损失，对齐中间层特征）# 总蒸馏损失知识蒸馏是YOLOv11在“小模型高性能部署”场景的“破局之法”——它让小模型能“站在大模型的肩膀上”，兼具速度与精度。从损失函数定义到多阶段训练，再到实战落地，本教程已为你铺就了一条清晰的路径。

m0_64661770的博客 801

第1部分 基础算法(提高篇)--第4章 广搜的优化技巧1453：移动玩具

1453：移动玩具 时间限制: 1000 ms 内存限制: 65536 KB 提交数: 296 通过数: 172 【题目描述】 原题来自：HAOI 2008 在一个 4×4 的方框内摆放了若干个相同的玩具，某人想将这些玩具重新摆放成为他心中理想的状态，规定移动时只能将玩具向上下左右四个方向移动，并且移动的位置不能有玩具，请你用最少的移动次数将初始的玩具状态移动到目标状态。 【输入】 前四行表示玩具的初始状态，每行 4 个数字 1 或 0，1 表示方格中放置了玩具，0 表示没有放置玩具

zqhf123的博客 691

Python爬虫教程：抓取Android或iOS应用中的数据

随着智能手机的普及，移动应用程序已经成为我们生活中不可或缺的一部分。从社交媒体、在线购物到金融服务和健康管理，几乎所有领域都有相应的手机应用程序（App）服务用户。而这些应用程序通常会存储大量的数据，例如用户行为、产品信息、订单记录等。如果我们能有效地抓取这些数据，可以为数据分析、商业智能、用户行为分析等提供有力支持。本文将重点介绍如何使用Python爬虫技术抓取Android或iOS应用中的数据，尤其是如何从这些应用的后端接口、存储、或网页中提取数据。我们将探讨如何通过反向工程技术访问移动应用中的API接

2201_76125261的博客 801

为什么idea已经改了UTF-8还是乱码，如何解决？

🏆本文收录于 《全栈Bug调优(实战版)》 专栏，该专栏专注于分享我在真实项目开发中遇到的各类疑难Bug及其深层成因，并系统提供高效、可复现的解决思路和实操方案。无论你是刚入行的新手开发者，还是拥有多年项目经验的资深工程师，本专栏都将为你提供一条系统化、高质量的问题排查与优化路径，助力你加速成长，攻克技术壁垒，迈向技术价值最大化与职业发展的更高峰🚀！

**My Coding Family** 1576

【BZOJ1054】[HAOI2008]移动玩具 BFS

【BZOJ1054】[HAOI2008]移动玩具 Description 　　在一个4*4的方框内摆放了若干个相同的玩具，某人想将这些玩具重新摆放成为他心中理想的状态，规定移动 时只能将玩具向上下左右四个方向移动，并且移动的位置不能有玩具，请你用最少的移动次数将初始的玩具状态移 动到某人心中的目标状态。 Input 　　前4行表示玩具的初始状态，每行4个数字1或0...

aodanchui1057的博客 118

uniapp - 实现免费OCR文字识别方案，用户上传图片后进行扫描识别获取图片上的文字，uniApp纯前端做图片OCR识别——无需服务器进行OCR识别插件（不需要依赖任何SDK或第三方API服务）

uniapp实现orc识别免费的插件识别不花钱，无需第三方OCR文字识别API，uniApp拍照或者选择图片免费识别，纯前端不需要服务器，Uniapp提取图片上的文字，本地ocr识别技术，uni-app图片OCR识别文本，uniapp有没有免费的ocr识别组件，uniapp前端实现文字识别，身份证识别，营业执照识别 （兼容APP、H5、小程序 不需要任何SDK）跨端无SDK方案：Uniapp实现OCR文字，离线OCR识别，uniapp tesseract.js实现文字识别，uniapp文字识别无需依赖sdk

🏆 前端领域优质创作者 4250

BZOJ 1054: [HAOI2008]移动玩具【BFS】

1054: [HAOI2008]移动玩具 Time Limit: 10 Sec Memory Limit: 162 MB Description 　　在一个4*4的方框内摆放了若干个相同的玩具，某人想将这些玩具重新摆放成为他心中理想的状态，规定移动 时只能将玩具向上下左右四个方向移动，并且移动的位置不能有玩具，请你用最少的移动次数将初始的玩具状态移 动到某人...

aiweiluan5095的博客 140

C# WinForm 基于DirectShow.dll编写的程序，可边预览边保存视频，音频和图片

基于微软的DirectShow.dll的二次开发1.自动识别连接的摄像头跟麦克风且可以对其进行选择（默认选中第一个）2.可录制wmv和avi两种格式的视频并且都带有音频，avi可以录制的分辨率和帧数进行选择，wmv默认进行了淸晰度优化如不喜欢可去除代码中有相关提示3.可在预览点开之后进行拍照，也可边录制视频边拍照4.添加了视频和音频的压缩功能（酌情使用）这次二次开发发现C#对DirectShow的相关信息太少，这次做完也不敢藏私共享出来，还望大家指正

STM32F407中文手册

STM32f407中文手册 本参考手册面向应用开发人员，提供有关使用 STM32F405xx/07xx、STM32F415xx/17xx、 STM32F42xxx 和 STM32F43xxx 微控制器存储器与外设的完整信息。STM32F405xx/07xx、STM32F415xx/17xx、STM32F42xxx 和 STM32F43xxx 构成一个微 控制器系列，各产品具有不同的存储器大小、封装和外设。有关订购信息以及器件的机械与电气特性，请参见数据手册。有关 ARM Cortex™-M4F 内核的信息，请参见《Cortex™-M4F 技术参考手册》。

BZOJ1054 移动玩具 [BFS][HASH]

1054: [HAOI2008]移动玩具Time Limit: 10 Sec  Memory Limit: 162 MBSubmit: 2407  Solved: 1345[Submit][Status][Discuss]Description　　在一个4*4的方框内摆放了若干个相同的玩具，某人想将这些玩具重新摆放成为他心中理想的状态，规定移动时只能将玩具向上下左右四个方向移动，并且移动的位置不能有

lemonoil的博客 464

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术，以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索，主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式，计算机控制系统的数学描述与基本分析方法，以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

[BZOJ1054]HAOI2008移动玩具|bfs

暴力bfs+hash判重咯，只有2^16个状态，直接压成二进制数。。 #include #include #include #define N 1000000 using namespace std; struct node{ bool a[4][4]; int d; }que[N+5],get,st,end; char s[10]; int i,j,head,tail,hh,tt,to,u

Tag_king的专栏 647

OV9734 DATASHEET，完整规格书

OV9734完整规格书，包括电气参数，尺寸规格，寄存器配置表等

BZOJ1054 移动玩具 BFS+hash

Description 在一个4*4的方框内摆放了若干个相同的玩具，某人想将这些玩具重新摆放成为他心中理想的状态，规定移动时只能将玩具向上下左右四个方向移动，并且移动的位置不能有玩具，请你用最少的移动次数将初始的玩具状态移动到某人心中的目标状态。 Input 前4行表示玩具的初始状态，每行4个数字1或0，1表示方格中放置了玩具，0表示没有放置玩具。接着是一个空行。接下

qq_37321744的博客 599

【BZOJ1054】[HAOI2008]移动玩具【BFS】【Hash】

【题目链接】 大暴搜...hash去重一下就行。 搜到答案时候直接输出是因为BFS时队列前的状态步数是最小的。 /* Footprints In The Blood Soaked Snow */ #include #include using namespace std; const int maxn = 7, maxq = 1 << 17, inf = 0x3f3f3f3f; c

BraketBN 581

【bzoj1054】[HAOI2008]移动玩具 Bfs

题目描述 在一个4*4的方框内摆放了若干个相同的玩具，某人想将这些玩具重新摆放成为他心中理想的状态，规定移动时只能将玩具向上下左右四个方向移动，并且移动的位置不能有玩具，请你用最少的移动次数将初始的玩具状态移动到某人心中的目标状态。 输入 前4行表示玩具的初始状态，每行4个数字1或0，1表示方格中放置了玩具，0表示没有放置玩具。接着是一个空行。接下来4行表示玩具的目标状态，每行4个...

weixin_30672295的博客 83

BZOJ 1054: [HAOI2008]移动玩具 BFS, Hash

Description 　　在一个4*4的方框内摆放了若干个相同的玩具，某人想将这些玩具重新摆放成为他心中理想的状态，规定移动 时只能将玩具向上下左右四个方向移动，并且移动的位置不能有玩具，请你用最少的移动次数将初始的玩具状态移 动到某人心中的目标状态。 Input 　　前4行表示玩具的初始状态，每行4个数字1或0，1表示方格中放置了玩具，0表示没有放置玩具。接着是一个空 行。接下来4行

I good vegetable a! 695

[BZOJ]1054: [HAOI2008]移动玩具BFS

Description 　　在一个4*4的方框内摆放了若干个相同的玩具，某人想将这些玩具重新摆放成为他心中理想的状态，规定移动 时只能将玩具向上下左右四个方向移动，并且移动的位置不能有玩具，请你用最少的移动次数将初始的玩具状态移 动到某人心中的目标状态。 Input 　　前4行表示玩具的初始状态，每行4个数字1或0，1表示方格中放置了玩具，0表示没有放置玩具。接着是一个空

TYB的博客 523

BZOJ 1054: [HAOI2008]移动玩具（状压，BFS）

Description 在一个4*4的方框内摆放了若干个相同的玩具，某人想将这些玩具重新摆放成为他心中理想的状态，规定移动 时只能将玩具向上下左右四个方向移动，并且移动的位置不能有玩具，请你用最少的移动次数将初始的玩具状态移 动到某人心中的目标状态。 Input 前4行表示玩具的初始状态，每行4个数字1或0，1表示方格中放置了玩具，0表示没有放置玩具。接着是一个空 行。接下来4行表示玩具的目标状态...

qq_43544481的博客 272

【BZOJ】1054: [HAOI2008]移动玩具（bfs+hash）

http://www.lydsy.com/JudgeOnline/problem.php?id=1054 一开始我还以为要双向广搜。。。。但是很水的数据，不需要了。 直接bfs+hash判重即可。 #include <cstdio> #include <cstring> #include <cmath> #include <str...

124
上一篇： [bzoj3504][网络流-最大流]危桥
下一篇： [bzoj1028][贪心]麻将
点赞 0
评论 0
书签 书签 0
Rose_max
Rose_max
博客等级 码龄10年 97粉丝 610原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值