`
暴风雪
  • 浏览: 390580 次
  • 性别: Icon_minigender_2
  • 来自: 杭州
社区版块
存档分类
最新评论

[bfs]hdoj 5012

 
阅读更多

大致题意

给出两个色子,问第一个色子翻转多少次之后能变成第二个色子

 

大致思路:

暴力bfs就能过

#include<iostream>
#include<cstdio>
#include<cstring>
#include<queue>
using namespace std;
class nod{
public :
    int face[6];
    int res;
}aa1,aa2;
int vis[7][7][7][7][7][7],ans,num[6];
void turn1(nod& node){
    int i;
    int mark[6];
    for(i=0;i<6;i++){
        mark[i]=node.face[i];
    }
    node.face[0]=mark[3];
    node.face[1]=mark[2];
    node.face[2]=mark[0];
    node.face[3]=mark[1];
    node.face[4]=mark[4];
    node.face[5]=mark[5];
}
void turn2(nod& node){
    int i;
    int mark[6];
    for(i=0;i<6;i++){
        mark[i]=node.face[i];
    }
    node.face[0]=mark[2];
    node.face[1]=mark[3];
    node.face[2]=mark[1];
    node.face[3]=mark[0];
    node.face[4]=mark[4];
    node.face[5]=mark[5];
}
void turn3(nod& node){
    int i;
    int mark[6];
    for(i=0;i<6;i++){
        mark[i]=node.face[i];
    }
    node.face[0]=mark[5];
    node.face[1]=mark[4];
    node.face[2]=mark[2];
    node.face[3]=mark[3];
    node.face[4]=mark[0];
    node.face[5]=mark[1];
}
void turn4(nod& node){
    int i;
    int mark[6];
    for(i=0;i<6;i++){
        mark[i]=node.face[i];
    }
    node.face[0]=mark[4];
    node.face[1]=mark[5];
    node.face[2]=mark[2];
    node.face[3]=mark[3];
    node.face[4]=mark[1];
    node.face[5]=mark[0];
}
bool bfs(){
    int i;
    queue<nod>que;
    que.push(aa1);
    while(!que.empty()){
        nod node;
        node=que.front();
        que.pop();
        if(node.face[0]==aa2.face[0]&&node.face[1]==aa2.face[1]&&node.face[2]==aa2.face[2]&&node.face[3]==aa2.face[3]&&node.face[4]==aa2.face[4]&&node.face[5]==aa2.face[5])
        {
            ans=node.res;
            return 1;
        }
        node.res++;
        for(i=0;i<6;i++){
            num[i]=node.face[i];
        }
        turn1(node);
     //   cout<<"node1"<<node.face[0]<<" "<<node.face[1]<<" "<<node.face[2]<<" "<<node.face[3]<<" "<<node.face[4]<<" "<<node.face[5]<<endl;
        if(!vis[node.face[0]][node.face[1]][node.face[2]][node.face[3]][node.face[4]][node.face[5]]){
            vis[node.face[0]][node.face[1]][node.face[2]][node.face[3]][node.face[4]][node.face[5]]=1;
            que.push(node);

        }

        for(i=0;i<6;i++){
            node.face[i]=num[i];
        }
        turn2(node);
    //    cout<<"node2"<<node.face[0]<<" "<<node.face[1]<<" "<<node.face[2]<<" "<<node.face[3]<<" "<<node.face[4]<<" "<<node.face[5]<<endl;

        if(!vis[node.face[0]][node.face[1]][node.face[2]][node.face[3]][node.face[4]][node.face[5]]){
            vis[node.face[0]][node.face[1]][node.face[2]][node.face[3]][node.face[4]][node.face[5]]=1;
            que.push(node);
        }


        for(i=0;i<6;i++){
            node.face[i]=num[i];
        }
        turn3(node);
   //     cout<<"node3"<<node.face[0]<<" "<<node.face[1]<<" "<<node.face[2]<<" "<<node.face[3]<<" "<<node.face[4]<<" "<<node.face[5]<<endl;

        if(!vis[node.face[0]][node.face[1]][node.face[2]][node.face[3]][node.face[4]][node.face[5]]){
            vis[node.face[0]][node.face[1]][node.face[2]][node.face[3]][node.face[4]][node.face[5]]=1;
            que.push(node);
        }

        for(i=0;i<6;i++){
            node.face[i]=num[i];
        }
        turn4(node);
      //  cout<<"node4"<<node.face[0]<<" "<<node.face[1]<<" "<<node.face[2]<<" "<<node.face[3]<<" "<<node.face[4]<<" "<<node.face[5]<<endl;
        if(!vis[node.face[0]][node.face[1]][node.face[2]][node.face[3]][node.face[4]][node.face[5]]){
            vis[node.face[0]][node.face[1]][node.face[2]][node.face[3]][node.face[4]][node.face[5]]=1;
            que.push(node);
        }
    }
    return 0;
}
int main(){
    int i;
    while(cin>>aa1.face[0]){
        ans=0;
        for(i=1;i<6;i++)cin>>aa1.face[i];
        for(i=0;i<6;i++)cin>>aa2.face[i];
        memset(vis,0,sizeof(vis));
        aa1.res=0;
        vis[aa1.face[0]][aa1.face[1]][aa1.face[2]][aa1.face[3]][aa1.face[4]][aa1.face[5]]=1;
        if(bfs())cout<<ans<<endl;
        else cout<<-1<<endl;
    }
    return 0;
}

 

0
1
分享到:
评论

相关推荐

    ACM HDOJ 课件

    6. **搜索算法**:包括深度优先搜索(DFS)和广度优先搜索(BFS),是解决图论问题和树结构问题的重要工具。课件中会介绍它们的工作原理以及如何在实际问题中应用。 7. **组合博弈论**:这是博弈论的一个分支,研究...

    hdoj解题代码

    这些文件是针对“hdoj”(HDU Online Judge)在线编程竞赛平台的解题代码,涵盖了题目编号从1000到1050的若干题目。HDU Online Judge是一个用于训练和测试编程技能的系统,用户可以提交代码解决各种算法问题,并获取...

    HDOJ.zip_hduoj100题

    【HDOJ.zip_hduoj100题】是一个压缩包文件,包含了HDUOJ(杭州电子科技大学在线评测系统)的约100道编程练习题目及其源代码。这个资源对于想要提升编程技能,尤其是对算法和数据结构有深入学习需求的程序员来说,是...

    HDOJ_1010 Tempter of the Bone

    总之,解决【HDOJ_1010 诱惑者的骨头】的关键在于理解图的概念,掌握图的遍历算法(DFS或BFS),并正确处理时间限制。通过编程实现这些算法,我们可以有效地判断是否存在一条满足条件的路径,从而解决这个问题。在...

    HDOJ暑期多校联赛第三场

    【HDOJ暑期多校联赛第三场】是2013年举办的一场面向广大编程爱好者的在线竞赛,由IOI(国际奥林匹克信息学竞赛)的冠军CLJ设计题目,旨在提升参赛者的信息学和算法解决能力。这次比赛涵盖了丰富的编程和算法知识点,...

    HDOJ2051-2099 acm的AC解题报告

    这些文件是关于ACM(国际大学生程序设计竞赛,简称ICPC)比赛的解题报告,主要涵盖杭电(杭州电子科技大学)在线评测系统HDOJ(HDU Online Judge)中的题目2051到2099。在ACM竞赛中,参赛队伍需要解决一系列算法问题...

    C#可视化连连看实现 广度优先,动态规划,回溯

    在本项目中,"C#可视化连连看实现 广度优先,动态规划,回溯" 是一个使用C#编程语言实现的连连看游戏,它融合了三种算法:广度优先搜索(BFS)、动态规划(DP)和回溯法。这些算法在解决复杂问题时非常有效,尤其是...

    leetcode1198-Algorithm:HDOJ、力码

    标题 "leetcode1198-Algorithm:HDOJ、力码" 暗示这是一个关于算法问题的讨论,特别是与LeetCode平台上的第1198题相关的。LeetCode是一个在线平台,提供各种编程挑战,帮助程序员提升算法技能。HDOJ(HDU Online ...

    2013HDOJ暑期多校联赛第三场解题报告

    这道题可能与树形结构的遍历和查询有关,要求玩家掌握深度优先搜索(DFS)、广度优先搜索(BFS)等图遍历算法,以及树的动态规划应用。题目可能给出一棵树的结构和一些节点属性,要求玩家求解树上的路径长度、子树的...

    收索资料 特棒的收索资料

    另一个例子是HDOJ 1016 "Prime Ring Problem",虽然题目没有明确指出,但根据问题性质,我们可以推断出这是一个需要利用奇偶性剪枝的搜索问题。 另一方面,广度优先搜索(BFS)则是从初始状态开始,先访问所有距离...

    leetcode中国-MyAlgorithmSolutions::balloon:记录我所有的算法/数据结构

    HDOJ LeetCode 程序员面试金典 剑指OFFER PAT 甲级 乙级 ACWing 算法基础班 快排 归并 二分 高精度 前缀和差分 双指针 位运算 离散化 区间合并 单链表 双链表 栈 队列 单调栈 单调队列 KMP Tire 并查集 堆 哈希表 ...

    hdu排序练习

    5. **图论算法**:包括深度优先搜索(DFS)、广度优先搜索(BFS)、最短路径算法(如Dijkstra算法、Floyd算法)、最小生成树算法(如Prim算法、Kruskal算法)等,用于解决图相关的复杂问题。 ### 知识点三:实战...

    AC自动机题解1

    建立失败指针通常通过深度优先搜索(DFS)或广度优先搜索(BFS)实现。在构建过程中,如果当前节点的子节点在失败链中找不到匹配,则将失败指针设置为父节点的失败指针,直至到达根节点。 3. 应用实例 - HDOJ 2222...

    ACM离线题库(1200道)

    2. **搜索算法**:二分查找、深度优先搜索(DFS)、广度优先搜索(BFS)等。 3. **图论**:最短路径(Dijkstra、Floyd-Warshall、Bellman-Ford)、最小生成树(Prim、Kruskal)等。 4. **动态规划**:背包问题、最长...

    杭电ACM训练PPT

    12. **hdoj_offline_2008_07_16**:这可能是某个特定的离线比赛题目集,包含当年杭州电子科技大学在线评测系统(HDOJ)的题目。 这些PPT内容丰富,覆盖了算法和数学的多个方面,是准备编程竞赛和提升算法能力的宝贵...

    杭电acm教程 (贪心算法 动态规划等)

    "(lecture_08)搜索入门071214.rar"是关于搜索算法的初步介绍,包括深度优先搜索(DFS)和广度优先搜索(BFS),它们在解决图遍历和状态空间搜索等问题时十分关键。 通过学习这套教程,你不仅能够理解并掌握这些...

    杭电 acm 入门ppt

    2. **图论**:深度优先搜索(DFS)、广度优先搜索(BFS)、最短路径算法(Dijkstra、Floyd-Warshall)、最小生成树(Prim、Kruskal)等。 3. **动态规划**:状态转移方程、记忆化搜索、贪心策略等,用于解决背包...

    ACM算法基础(必备)

    3. **搜索算法**:深度优先搜索(DFS)和广度优先搜索(BFS)是图论问题中的常用方法,同时也在树结构中应用广泛。二分查找则是处理有序数据的高效策略。 4. **动态规划**:这是一种将大问题分解为小问题的策略,常...

    北邮网研院考研复试08-12年上机真题及答案.pdf

    同时,文件还提到,具有ACM编程竞赛经验的考生在这种机试环节中会有一定的优势,建议考生在如九度在线编程平台(9DP)、北京大学在线编程平台(PKU JudgeOnline)和杭州电子科技大学在线编程平台(HDOJ)等平台上...

    hdu题目分类

    从给定的信息来看,这是一份关于杭州电子科技大学(简称杭电)在线编程平台HDU Online Judge(简称HDOJ)的题目分类列表。这份列表为新手提供了按类别刷题的指南,帮助他们系统地提升算法和编程能力。下面,我们将...

Global site tag (gtag.js) - Google Analytics