1533 Moving Pegs[暴力+打表]

最新推荐文章于 2023-03-01 22:12:20 发布
最新推荐文章于 2023-03-01 22:12:20 发布
阅读量701 收藏
点赞数
分类专栏： DFS、DFS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013451221/article/details/43562031
版权

这个题不是很难，就是暴力模拟一下，利用二进制表示状态，反正最后一共15种结果，暴力程序跑慢点也没事~，2个程序一个250行的暴力，一个150行的表，也是蛮拼的。。

14933000 1533 Moving Pegs Accepted C++ 0.009 2015-02-06 03:15:36

暴力程序：

#include<cstdio>
#include<queue>
#include<set>
#include<cstring>
#include<algorithm>
using namespace std;
typedef pair<int,int> pill;
const int maxd = 20;
int n;
int st;
vector<int>G[maxd][8];
vector<int>vis[1<<16];
struct Node{

    int st;
    vector<int>way;
    Node(int st){
        this -> st = st;
    }
};
//4164;2>;?61::7;441
//4 1 6 4 11 2 15 6 1 10 10 7 14 11 11 4 4 1
//4164;2>;?61::7;441
//4 1 6 4 11 2 14 11 15 6 1 10 10 7 11 4 4 1
queue<Node>q;
bool judge(int v){
    int cnt = 0;
    for(int i = 0; i < 15; i++)
        if(v & (1 << i))
            cnt ++;
    if(cnt == 14)
        return true;
    else
        return false;
}
void debug(int n){
    if(n == 0) return ;
    debug(n / 2);
    printf("%d",n % 2);
}
void init(){
    //6个方向
    //   1   2
    // 3       4
    //   5   6
    //编号1
    G[1][5].push_back(2);G[1][5].push_back(4);G[1][5].push_back(7);G[1][5].push_back(11);
    G[1][6].push_back(3);G[1][6].push_back(6);G[1][6].push_back(10);G[1][6].push_back(15);
    //编号2
    G[2][2].push_back(1);
    G[2][4].push_back(3);
    G[2][5].push_back(4);G[2][5].push_back(7);G[2][5].push_back(11);
    G[2][6].push_back(5);G[2][6].push_back(9);G[2][6].push_back(14);
    //编号3
    G[3][1].push_back(1);
    G[3][3].push_back(2);
    G[3][5].push_back(5);G[3][5].push_back(8);G[3][5].push_back(12);
    G[3][6].push_back(6);G[3][6].push_back(10);G[3][6].push_back(15);
    //编号4
    G[4][2].push_back(2);G[4][2].push_back(1);
    G[4][4].push_back(5);G[4][4].push_back(6);
    G[4][5].push_back(7);G[4][5].push_back(11);
    G[4][6].push_back(8);G[4][6].push_back(13);
    //编号5
    G[5][1].push_back(2);
    G[5][2].push_back(3);
    G[5][3].push_back(4);
    G[5][4].push_back(6);
    G[5][5].push_back(8);G[5][5].push_back(12);
    G[5][6].push_back(9);G[5][6].push_back(14);
    //编号6
    G[6][1].push_back(3);G[6][1].push_back(1);
    G[6][3].push_back(5);G[6][3].push_back(4);
    G[6][5].push_back(9);G[6][5].push_back(13);
    G[6][6].push_back(10);G[6][6].push_back(15);
    //编号7
    G[7][2].push_back(4);G[7][2].push_back(2);G[7][2].push_back(1);
    G[7][4].push_back(8);G[7][4].push_back(9);G[7][4].push_back(10);
    G[7][5].push_back(11);
    G[7][6].push_back(12);
    //编号8
    G[8][1].push_back(4);
    G[8][2].push_back(5);G[8][2].push_back(3);
    G[8][3].push_back(7);
    G[8][4].push_back(9);G[8][4].push_back(10);
    G[8][5].push_back(12);
    G[8][6].push_back(13);
    //编号9
    G[9][1].push_back(5);G[9][1].push_back(2);
    G[9][2].push_back(6);
    G[9][3].push_back(8);G[9][3].push_back(7);
    G[9][4].push_back(10);
    G[9][5].push_back(13);
    G[9][6].push_back(14);
    //编号10
    G[10][1].push_back(6);G[10][1].push_back(3);G[10][1].push_back(1);
    G[10][3].push_back(9);G[10][3].push_back(8);G[10][3].push_back(7);
    G[10][5].push_back(14);
    G[10][6].push_back(15);
    //编号11
    G[11][2].push_back(7);G[11][2].push_back(4);G[11][2].push_back(2);G[11][2].push_back(1);
    G[11][4].push_back(12);G[11][4].push_back(13);G[11][4].push_back(14);G[11][4].push_back(15);
    //编号12
    G[12][1].push_back(7);
    G[12][2].push_back(8);G[12][2].push_back(5);G[12][2].push_back(3);
    G[12][3].push_back(11);
    G[12][4].push_back(13);G[12][4].push_back(14);G[12][4].push_back(15);
    //编号13
    G[13][1].push_back(8);G[13][1].push_back(4);
    G[13][2].push_back(9);G[13][2].push_back(6);
    G[13][3].push_back(12);G[13][3].push_back(11);
    G[13][4].push_back(14);G[13][4].push_back(15);
    //编号14
    G[14][1].push_back(9);G[14][1].push_back(5);G[14][1].push_back(2);
    G[14][2].push_back(10);
    G[14][3].push_back(13);G[14][3].push_back(12);G[14][3].push_back(11);
    G[14][4].push_back(15);
    //编号15
    G[15][1].push_back(10);G[15][1].push_back(6);G[15][1].push_back(3);G[15][1].push_back(1);
    G[15][3].push_back(14);G[15][3].push_back(13);G[15][3].push_back(12);G[15][3].push_back(11);
}
void BFS(){
    while(!q.empty()) q.pop();
    Node start(st);
    q.push(start);
    vector<int>ans;
    int isok = 0;
    while(!q.empty()){
        Node state = q.front(); q.pop();
        int now = state.st;
        if(judge(now)){
            int e = state.way.size();
            if(state.way[e - 1] != n) continue;
//            for(int i = 0; i < state.way.size(); i++)
//                printf("%d ",state.way[i]);
//            printf("\n");
            isok = 1;
            if(!ans.size()){
                ans = state.way;
            }
            else{
                int can_add = 0;
                int L1 = state.way.size();
                int L2 = ans.size();
                if(L1 < L2){
                    ans = state.way;
                }
                else if(L1 == L2)
                for(int x = 0; x < L1 && x < L2; x++){
                     if(state.way[x] > ans[x]){
                         can_add = -1;
                         break;
                     }
                     else  if(state.way[x] < ans[x]){
                         can_add = 1;
                         break;
                     }
                }
                if(can_add == 1){
                    ans = state.way;
                }
                else if(can_add == 0 && L1 < L2){
                    ans = state.way;
                }
            }
        }
        for(int i = 1; i <= 15; i++){
            if(now & (1 << (i - 1))){                    //如果这一位为空,从6个方向找可以跳到这里的位置
                for(int j = 1; j <= 6; j++){
                    int cnt = 0;
                    for(int k = 0; k < G[i][j].size(); k++){
                         int e = G[i][j][k];
                         if(now & (1 << (e - 1)))        //如果是空白，跳出循环
                            break;
                         else{
                            cnt ++;
                            if(cnt == 1)                 //如果不是空白
                                continue;
                            int temp = now;
                            int l;
                            //-------------------------------------------------
                            for(l = 0;l <= k; l++){      //这一条线上的全部清空
                                //这条线上全部清
                                int c = G[i][j][l];
                                temp |= (1 << (c - 1));
                            }
                            temp = ~temp;
                            temp = temp | (1 << (i - 1));
                            temp = ~temp;
                            //-------------------------------------------------
                            Node tmp = state;
                            tmp.st = temp;
                            tmp.way.push_back(e);
                            tmp.way.push_back(i);
                            if(!vis[temp].size()){
                                 vis[temp] = tmp.way;
                                 q.push(tmp);
                            }
                            else{
                                int can_add = 0;
                                int L1 = tmp.way.size();
                                int L2 = vis[temp].size();
                                for(int x = 0; x < L1 && x < L2; x++){
                                     if(tmp.way[x] > vis[temp][x]){
                                         can_add = -1;
                                         break;
                                     }
                                     else  if(tmp.way[x] < vis[temp][x]){
                                         can_add = 1;
                                         break;
                                     }
                                }
                                if(can_add == 1){
                                    vis[temp] = tmp.way;
                                    q.push(tmp);
                                }
                                else if(can_add == 0 && L1 < L2){
                                    vis[temp] = tmp.way;
                                    q.push(tmp);
                                }
                            }
                         }
                    }
                }
            }
        }
    }
    if(!isok){
        printf("IM");
    }
    else{
        printf("%d\n",ans.size() / 2);
        for(int i = 0; i < ans.size(); i++)
            printf("%d ",ans[i]);
    }
    return;
}
int main(){
    int T;
    init();
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        st  = 0;
        st |= (1 << (n - 1));
        BFS();
    }
    return 0;
}

打表： 

#include<cstdio>
#include<vector>
using namespace std;
const int maxd = 16;
int size[] = {18,18,18,18,20,18,18,20,20,18,18,18,18,18,18};
int L1[] = {4,1,6,4,11,2,14,11,15,6,1,10,10,7,11,4,4,1};    //18
int L2[] = {7,2,1,4,10,1,14,2,1,7,11,14,15,13,13,4,7,2};    //18
int L3[] = {10,3,1,6,7,1,12,3,1,10,14,12,11,13,13,6,15,3};  //18
int L4[] = {1,4,6,1,13,6,10,3,11,13,3,12,15,11,11,2,1,4};   //18
int L5[] = {12,5,3,8,15,12,6,13,7,9,1,7,10,8,7,9,11,14,14,5};//20
int L6[] = {1,6,4,1,13,4,7,2,15,13,2,14,11,15,15,3,1,6};    //18
int L7[] = {1,7,6,1,11,4,9,7,14,11,11,2,15,6,6,4,1,7};      //18
int L8[] = {3,8,12,5,15,3,13,6,1,10,2,9,11,2,14,5,2,9,10,8}; //20
int L9[] = {2,9,11,2,12,5,3,8,13,4,1,7,14,5,15,3,3,8,7,9};   //20
int L10[]= {1,10,4,1,11,4,4,6,12,5,10,8,15,12,12,3,1,10};   //18
int L11[]= {4,11,1,4,10,1,14,2,1,7,11,14,15,13,13,4,4,11};   //18
int L12[]= {14,12,2,14,7,2,1,4,15,13,3,15,11,14,4,13,15,12};    //18
int L13[]= {4,13,1,4,11,2,13,11,15,13,2,14,3,15,15,12,11,13};//18
int L14[]= {11,14,2,11,3,12,10,3,1,6,11,13,15,12,6,13,12,14};//18
int L15[]= {6,15,1,6,7,1,12,3,1,10,15,12,11,13,13,6,6,15};   //18
int main(){
    int T,n;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        int sz = size[n - 1];
        if(n == 1){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L1[i]);
            }
        }
        else if(n == 2){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L2[i]);
            }
        }
        else if(n == 3){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L3[i]);
            }
        }
        else if(n == 4){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L4[i]);
            }
        }
        else if(n == 5){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L5[i]);
            }
        }
        else if(n == 6){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L6[i]);
            }
        }
        else if(n == 7){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L7[i]);
            }
        }
        else if(n == 8){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L8[i]);
            }
        }
        else if(n == 9){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L9[i]);
            }
        }
        else if(n == 10){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L10[i]);
            }
        }
        else if(n == 11){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L11[i]);
            }
        }
        else if(n == 12){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L12[i]);
            }
        }
        else if(n == 13){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L13[i]);
            }
        }
        else if(n == 14){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L14[i]);
            }
        }
        else if(n == 15){
            printf("%d\n",sz / 2);
            for(int i = 0; i < sz; i++){
                if(i) printf(" ");
                printf("%d",L15[i]);
            }
        }
        else
            printf("IMPOSSIBLE");
        printf("\n");
    }
    return 0;
}

KinderRiven
关注
专栏目录
L . Moving Pegs
weixin_52346398的博客
07-27 100
Description Venture MFG Company, Inc. has made a game board. This game board has 15 holes and these holes are filled with pegs except one hole. A peg can jump over one or more consecutive peg s to the nearest empty hole along the straight line. As a peg j
Moving Pegs UVA - 1533
zju2016的博客
11-21 202
首先将图形中每个点的位置关系梳理出来，假设每个点可以向6个方向进行移动，可以移动到的位置就记录成对应的数字，不能移动到的位置就记录成-1。记录结束之后，就利用移位操作记录状态，每个数字都占据一位，以1表示该数字是存在的，以0表示是不存在的，然后从初始状态开始bfs，放入队列，每次都从队列中取出队头，作为当前的状态，然后分析每个数字是否存在，如果数字在当前的状态是存在的，就开始判断每个数字是否能够向
UVA - 1533 Moving Pegs
那些年
07-06 1389
题意：首先给你空闲的位置，可以跳过几个来吃掉几个，求最短的吃完所有的，且最后一个回到开始指定的位置 思路：BFS+HASH判重，对于每个位置有六个方向，当然有的是不能走的，加上map的判重就可以了 #include #include #include #include #include #include using namespace std; const int MAXN =
UVA 1533 - Moving Pegs （广搜+hash判重)
Remilia's
12-28 1968
Venture MFG Company, Inc. has made a game board. This game board has 15 holes and these holes are filled with pegs except one hole. A peg can jump over one or more consecutive peg s to the nearest emp
UVa 1533：Moving Pegs（迭代加深搜索）
nullptr
09-15 380
题目链接：https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&category=842&page=show_problem&problem=4308 分析：如图所示，一共有15个洞，其中一个空着，剩下的洞里各有一个小球。每次可以让一个小球越过同一条直线上的一个或多个连续的小球，落到最近的空洞（不能越过空洞），
UVA 1533 Moving Pegs（bfs+hash）
小G的ACM之路
04-23 545
题意： 一个跳棋，给定一个空位。求最少步数且字典序最小使得跳到最后棋盘只剩一个旗子，且在初始的空位上。 思路： BFS + hash判重，这题的思路还是比较好想的，但是我看网络上面的代码，都是打表+bfs，我直接把状态转换为2维数组，对6个方向进行bfs。 AC代码#include <cstdio> #include <cstring> #include <algorithm> #inclu
UVa 1533 Moving Pegs 解题报告（暴力+码力）
SF-_- 的 ACM 博客
07-25 989
1533 - Moving Pegs Time limit: 3.000 seconds Venture MFG Company, Inc. has made a game board. This game board has 15 holes and these holes are filled with pegs except one hole. A peg can jump over
UVa 1533 Moving Pegs 移动小球 BFS 二进制
qq_45523675的博客
03-01 158
存在一个如图所示的金字塔形状的网格，其中一个结点为空（图中白色结点），其余结点均放置一个石头（图中黑色结点），空节点的位置会通过输入告诉你，你现在每次可以进行一次移动操作，移动操作可以将一个石头沿直线移动到一个空白，移动后，经过的石头同样会被拿掉（类似于跳棋的规则）例如你可以将。位的二进制来表示每个节点是否存在石头，可以知道的是，一个节点能够移动的方向最多有六个：左上、右上、左、右、左下、右下。位置有一个石头，需要注意的一点是：你不能将一个石头直接移动到空白中，例如你不能将。
PEGS 的 DUG pdf
03-14
《PEG的DUG pdf》文档主要聚焦于如何为特定硬件创建自定义的PEG屏幕驱动程序。PEG（可能是Power eGrafics或Platform Enhanced Graphics的缩写）通常与Freescale Semiconductor的图形控制器驱动程序相关，它提供了一...
pegs-and-jokers
03-05
"pegs-and-jokers"似乎是一个基于JavaScript的项目，但没有提供足够的具体信息来深入讨论项目的细节。然而，我们可以从这个简短的标题和描述中推测，这可能是一个游戏或者是一个与棋盘游戏“Pegs and Jokers”相关的...
可爱淘宠物网站（windows 2003,xp;html ;PS;）
08-08
文件名称"zongwu"可能是网站的源代码文件或资源文件，可能包含了网站的HTML文件、CSS样式表、JavaScript脚本、图片和其他多媒体资源。为了维护和更新网站，开发者需要对这些文件进行管理和编辑。 总之，【可爱淘...
Master_Mind_Game:在Master Mind游戏中，四种不同的颜色处于不同的位置。 我们仅获得关于它们彼此之间立场的某些陈述。 目的是找到每种颜色的确切位置
04-08
这种反馈通常分为两种类型：正确颜色且位置准确的“黑珠”（black pegs）和正确颜色但位置错误的“白珠”（white pegs）。 在Python中，我们可以创建一个函数来生成随机的隐藏序列。这通常涉及到使用`random`模块来...
【uva】1600 - Patrol Robot
花月阁
07-23 1975
用一个vis[x][y][z]表示走到x，y的时候 穿过了zdu
【Codeforces】C. Ice Cave（bfs）
花月阁
05-15 1627
我了个草，这个题明明bfs不知道谁挂了个dfs+剪枝的标签。。。 从起点bfs一步一步搜，碰到X判断是不是终点，如果是终点就结束，如果为‘.',那么把该位置改成X，坐标入队。 #include #include #include #include #include using namespace std; const int maxn = 505; const int dir[4][2] =
1103 - Ancient Messages【后台数据】
花月阁
07-27 1604
#include #include #include #include #include #include #include #define MAXD 500 + 10 using namespace std; int m,n,t; char Map[MAXD + 10][400 + 10]; int vis[MAXD + 10][400 + 10]; char biao[20][10]; co
【hdu】The Donkey of Gui Zhou（搜索）
花月阁
09-16 1244
一开始的思路是，先走驴子，之后走老虎，每次走的时候记录他们的达到该位置的步数，如果一样就可以相遇，特殊处理末尾。 但是没办法过，之后索性让他们一起走，一起修改移动的坐标，结果过了。。。 真心不知道错哪了。。 11662502 2014-09-16 00:43:01 Accepted 4740 31MS 8300K 2547 B G++ KinderRiven
【uva】225 - Golygons（dfs有坑）
花月阁
07-31 1172
dfs的路径问题，毕竟坑d
【CF】E. Anya and Cubes（双向DFS）
花月阁
03-30 1063
根据题意的话每次递归分3种情况 一共最多25个数，时间复杂度为3^25，太大了 我们可以分2次求解第一次求一半的结果，也就是25/2 = 12，记录结果 之后利用剩余的一半求结果 s-结果 = 之前记录过的结果 就可以 时间复杂度降低为 3 ^ (n/2+1) 题目链接：http://codeforces.com/contest/525/problem/E #include #incl
请用迭代的方式实现汉诺塔
最新发布
04-14
if not pegs[temp_peg] or pegs[start_peg][-1] < pegs[temp_peg][-1]: pegs[temp_peg].append(pegs[start_peg].pop()) print(f"Step {step}: Move disk from peg {start_peg + 1} to peg {temp_peg + 1}") else...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值