UVa1533 - Moving Pegs(错在什么地方)

最新推荐文章于 2021-03-17 23:01:38 发布
最新推荐文章于 2021-03-17 23:01:38 发布
阅读量1k 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiexingshishu/article/details/9192083
版权 
#include <iostream>
#include <fstream>
#include <cstring>
#include <algorithm>

using namespace std;

const int N = 5;
const int M = 100;
const int HASHSIZE = 10000007;
const int QUEUELEN = 100000;

struct Node {
    int step;
    int m[N][N];
    int ans[M];
};

int src[N][N];
int m;
int head[HASHSIZE];
int next[QUEUELEN];
Node q[QUEUELEN];

void bfs();
int hash(Node node);
int insert(int v);
bool check(Node node);
void print(Node node);

int main()
{
    int t;
    int count;

    #ifndef ONLINE_JUDGE
        ifstream cin("d:\\OJ\\uva_in.txt");
    #endif // ONLINE_JUDGE

    cin >> t;


    while (t--) {
        memset(src, 0x00, sizeof(src));
        cin >> m;
        if (m < 1 && m > 15 ) {
            cout << "IMPOSSIBLE" << endl;
            continue;
        }
        count = 1;
        for (int i = 0; i < N; i++) {
            for (int j = 0; j <= i; j++) {
                if (count != m)
                    src[i][j] = count;
                count++;
            }
        }
        bfs();
    }
    return 0;
}

void bfs()
{
    int front = 0, rear = 0;
    Node node, newNode;
    bool flag;
    int step;

    memset(&node, 0x00, sizeof(Node));
    memset(head, -1, sizeof(head));
    memcpy(node.m, src, sizeof(src));

    q[rear++] = node;


    while (front < rear) {
        Node tmp = q[front++];
        if (check(tmp)) {
            int step = tmp.step;
            cout << step << endl;
            for (int i = 0; i < step; i++) {
                if (i)
                    cout << " ";
                cout << tmp.ans[2 * i] << " " << tmp.ans[2 * i + 1];
            }
            cout << endl;
            return;
        }
        for (int i = 0; i < N; i++) {
            for (int j = 0; j <= i; j++) {
                if (tmp.m[i][j] == 0) {
                    //水平方向
                    flag = true;
                    int jj = j + 1;
                    if (jj > i)
                        flag = false;

                    if (flag && tmp.m[i][jj] == 0)
                        flag = false;

                    while (flag && jj <= i && tmp.m[i][jj] != 0) {
                        if (jj - j >= 2) {
                            newNode = tmp;
                            swap(newNode.m[i][jj], newNode.m[i][j]);
                            fill(&(newNode.m[i][j + 1]), &(newNode.m[i][jj]), 0x00);
                            step = newNode.step;
                            newNode.ans[2 * step] = (i + 1) * i / 2 + jj + 1;
                            newNode.ans[2 * step + 1] = (i + 1) * i / 2 + j + 1;
                            newNode.step++;
                            q[rear] = newNode;
                            if (insert(rear)) rear++;
                        }
                        jj++;
                    }
                    if (flag && jj - 1 - j < 2)
                        flag = false;;

                    if (flag ) {
                        newNode = tmp;
                        swap(newNode.m[i][j], newNode.m[i][jj - 1]);
                        fill(&(newNode.m[i][j + 1]), &(newNode.m[i][jj]), 0x00);
                        step = newNode.step;
                        newNode.ans[2 * step] = (i + 1) * i / 2 + jj;
                        newNode.ans[2 * step + 1] = (i + 1) * i / 2 + j + 1;
                        newNode.step++;

                        q[rear] = newNode;


                        if (insert(rear)) rear++;
                    }

                    //竖直方向
                    flag = true;
                    int ii = i + 1;
                    //cout << "ii1:" << ii << endl;
                    if (ii >= N)
                        flag = false;

                    if (flag && tmp.m[ii][j] == 0)
                        flag = false;;

                    while (flag && ii < N && tmp.m[ii][j] != 0) {
                        if (ii - i >= 2) {
                            newNode = tmp;
                            swap(newNode.m[i][j], newNode.m[ii][j]);
                            for (int k = i + 1; k < ii; k++) {
                                newNode.m[k][j] = 0;
                            }
                            step = newNode.step;
                            newNode.ans[2 * step] = (ii + 1) * ii / 2 + j + 1;
                            newNode.ans[2 * step + 1] = (i + 1) * i / 2 + j + 1;
                            newNode.step++;
                            q[rear] = newNode;
                            if (insert(rear)) rear++;
                        }
                        ii++;
                    }
                    ii--;

                    if (flag && ii - i < 2)
                        flag = false;

                    if (flag) {
                        newNode = tmp;
                        swap(newNode.m[i][j], newNode.m[ii][j]);
                        for (int k = i + 1; k < ii; k++)
                            newNode.m[k][j] = 0;
                        step = newNode.step;
                        newNode.ans[2 * step] = (ii + 1) * ii / 2 + j + 1;
                        newNode.ans[2 * step + 1] = (i + 1) * i / 2 + j + 1;
                        newNode.step++;

                        q[rear] = newNode;
                        if (insert(rear)) rear++;
                    }

                    //对角线方向
                    flag = true;
                    ii = i + 1;
                    jj = j + 1;
                    if (ii >= N)
                        flag = false;

                    if (flag && tmp.m[ii][jj] == 0)
                        flag = false;

                    while (flag &&ii < N && tmp.m[ii][jj] != 0) {
                        if (ii - i >= 2) {
                            newNode = tmp;
                            swap(newNode.m[i][j], newNode.m[ii][jj]);
                            for (int k = i + 1, p = j + 1; k < ii; k++, p++) {
                                newNode.m[k][p] = 0;
                            }
                            step = newNode.step;
                            newNode.ans[2 * step] = (ii + 1) * ii / 2 + jj + 1;
                            newNode.ans[2 * step + 1] = (i + 1) * i / 2 + j + 1;
                            newNode.step++;

                            q[rear] = newNode;
                            if (insert(rear)) rear++;
                        }
                        ii++, jj++;
                    }

                    ii--, jj--;
                    if (flag && ii - i < 2)
                        flag = false;

                    if (flag) {
                        newNode = tmp;
                        swap(newNode.m[i][j], newNode.m[ii][jj]);
                        for (int k = i + 1, p = j + 1; k < ii; k++, p++)
                            newNode.m[k][p] = 0;
                        step = newNode.step;
                        newNode.ans[2 * step] = (ii + 1) * ii / 2 + jj + 1;
                        newNode.ans[2 * step + 1] = (i + 1) * i / 2 + j + 1;
                        newNode.step++;

                        q[rear] = newNode;
                        if (insert(rear)) rear++;


                    }

                } else {
                    //水平方向
                    flag = true;
                    int jj = j + 1;
                    if (jj > i)
                        flag = false;;


                    if (flag && tmp.m[i][jj] == 0)
                        flag = false;

                    while (flag && jj <= i && tmp.m[i][jj] != 0) jj++;
                    if (flag && jj > i)
                        flag = false;

                    if (flag && jj - j < 2)
                        flag = false;

                    if (flag) {
                        newNode = tmp;
                        swap(newNode.m[i][j], newNode.m[i][jj]);
                        fill(&newNode.m[i][j + 1], &newNode.m[i][jj], 0x00);
                        int step = newNode.step;
                        newNode.ans[2 * step] = (i + 1) * i / 2 + j + 1;
                        newNode.ans[2 * step + 1] = (i + 1) * i / 2 + jj + 1;
                        newNode.step++;

                        q[rear] = newNode;
                        if (insert(rear)) rear++;
                    }

                    //竖直方向
                    flag = true;
                    int ii = i + 1;
                    if (ii >= N)
                        flag = false;

                    if (flag && tmp.m[ii][j] == 0)
                        flag = false;

                    while (flag && ii < N && tmp.m[ii][j] != 0) ii++;
                    if (flag && ii >= N)
                        flag = false;

                    if (flag && ii - i < 2)
                        flag = false;

                    if (flag) {
                        newNode = tmp;
                        swap(newNode.m[i][j], newNode.m[ii][j]);
                        for (int k = i + 1; k < ii; k++)
                            newNode.m[k][j] = 0;
                        step = newNode.step;
                        newNode.ans[2 * step] = (i + 1) * i / 2 + j + 1;
                        newNode.ans[2 * step + 1] = (ii + 1) * ii / 2 + j + 1;
                        newNode.step++;

                        q[rear] = newNode;
                        if (insert(rear)) rear++;
                    }


                    //对角线方向
                    flag = true;
                    ii = i + 1;
                    jj = j + 1;
                    if (ii >= N)
                        flag = false;

                    if (flag && tmp.m[ii][jj] == 0)
                        flag = false;

                    while (flag && ii < N && tmp.m[ii][jj] != 0) ii++, jj++;
                    if (flag && ii >= N)
                        flag = false;

                    if (flag && ii - i < 2)
                        flag = false;

                    if (flag ) {
                        newNode = tmp;
                        swap(newNode.m[i][j], newNode.m[ii][jj]);
                        for (int k = i + 1, p = j + 1; k < ii; k++, p++)
                            newNode.m[k][p] = 0;
                        step = newNode.step;
                        newNode.ans[2 * step] = (i + 1) * i / 2 + j + 1;
                        newNode.ans[2 * step + 1] = (ii + 1) * ii / 2 + jj + 1;
                        newNode.step++;

                        q[rear] = newNode;
                        if (insert(rear)) rear++;
                    }
                }
            }
        }

    }

    cout << "IMPOSSIBLE" <<  endl;
}

int hash(Node node)
{
    int h = 0;

    for (int i = 0; i < 5; i++) {
        for (int j = 0; j <= i; j++) {
            h = h * 10 + node.m[i][j];
        }
    }

    return (h & 0x7fffffff) % HASHSIZE;
}

int insert(int v)
{
    int h = hash(q[v]);

    for (int u = head[h]; u != -1; u = next[u])
        if (memcmp(q[u].m, q[v].m, sizeof(src)) == 0)
            return 0;

    next[v] = head[h];
    head[h] = v;

    return 1;
}

bool check(Node node)
{
    int count = 1;
    int cx, cy;

    for (int i = 0; i < N; i++) {
        for (int j = 0; j <= i; j++) {
            if (count != m) {
                if (node.m[i][j] != 0)
                    return false;
            } else {
                cx = i;
                cy = j;
            }
            count++;
        }
    }

    return node.m[cx][cy] != 0;

}


void print(Node node)
{
    for (int i = 0; i < N; i++) {
        for (int j = 0; j <= i; j++) {
            cout << node.m[i][j] << " ";
        }
        cout << endl;
    }
}


kgduu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
space-pegs:玩转jpeg编码和解码
04-27
在"space-pegs-master"这个文件名中，"master"通常指代Git仓库的主分支，意味着这个压缩包可能是从一个开源GitHub项目克隆下来的。因此，解压后，我们可以找到源代码、文档、示例或其他资源，帮助我们了解和使用...
pegs-and-jokers
03-05
"pegs-and-jokers"似乎是一个基于JavaScript的项目，但没有提供足够的具体信息来深入讨论项目的细节。然而，我们可以从这个简短的标题和描述中推测，这可能是一个游戏或者是一个与棋盘游戏“Pegs and Jokers”相关的...
UVA 1533 - Moving Pegs （广搜+hash判重)
Remilia's
12-28 1940
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(BFS)
不慌不忙、不急不躁
12-29 1455
题目链接：uva 1533 - Moving Pegs 题目大意：在一个跳棋的棋盘上，有15个位置，如题目中图示，现在给出n，表示第n个位置上的没有棋子，问说最少跳几步可以使的棋盘上的棋子只剩一个，并且位置处于n上，输出跳法，多中的话按照字典序最小输出。 解题思路：15个位置，可以用一个二进制数表示状态，然后BFS搜索。优化，如果状态已经入队过，则可不用重复入队。 #
Moving Pegs UVA - 1533
zju2016的博客
11-21 196
首先将图形中每个点的位置关系梳理出来，假设每个点可以向6个方向进行移动，可以移动到的位置就记录成对应的数字，不能移动到的位置就记录成-1。记录结束之后，就利用移位操作记录状态，每个数字都占据一位，以1表示该数字是存在的，以0表示是不存在的，然后从初始状态开始bfs，放入队列，每次都从队列中取出队头，作为当前的状态，然后分析每个数字是否存在，如果数字在当前的状态是存在的，就开始判断每个数字是否能够向
UVA - 1533Moving Pegs移动小球 （bfs加状态压缩）
timeruler的博客
12-10 239
题意：一共有15个洞，成三角形分布，有一个洞是空的，其余都是有一个小球，小球可以穿过一个或多个小球到空洞里，被穿过的小球就被拿走（注意，穿过的小球必须至少一个），最后只剩一个小球，且在开始时候的空位上，问最少多少步，结果按字典序最小输出。 分析：此题不难想到用bfs搜索，数据储存是一个难点，数据成三角形，每一个点最多和6给点相邻。于是可以先列举这15个点的相邻节点，因为要按照字典序输出，所以方向...
uva1533(bfs)
潜水的程序猿
04-22 863
题意: 图中15个格子;只有一个是空的,其余都有珠子 你可以把珠子沿图中的一条直线,跳过一个或多个珠子(注意不可以是0个),到达最近的空格,并把中间的珠子拿走; 最后要使只剩一个珠子,并且位置在刚开始的空位那; 思路: bfs + set判重； 用２进制压缩状态，然后用set判重状态； 一开始打一个表，表示每一个点的６个方向是什么，－１表示没有；因为最后要找字典序最小的，所以
pegs-in-puzzlescript:用于 TI-83+ 图形计算器的游戏 Pegs，移植到 PuzzleScript HTML5 引擎
06-20
PuzzleScript 中的挂钩用于 TI-83+ 图形计算器的游戏 Pegs，移植到浏览器的。 ，还是在PuzzleScript编辑器。 是 Detached Solutions 的 PuzzPack 的一部分，其主要开发人员是 Fred Coughlin。 这个端口是由。 另请...
PEGS 的 DUG pdf
03-14
PegScreen是PEG类的核心，它提供了用于绘制图形的基本元素，使得PEG对象能够在显示设备上进行自我绘制。窗口和控件不直接操作视频内存，而是通过调用PegScreen的成员函数来绘制线条、文本、位图等。关键的是，...
Python-图文课件5.pptx
03-26
这段代码将什么也不执行，因为 Pass 语句什么也不做。 小结：控制语句执行结构是 Python 语言中的一种基本结构，有三种执行结构：顺序结构、选择结构和循环结构。if 语句用于选择结构，而 while 语句和 for 语句...
uva 1533(bfs+状态压缩)
俯瞰风景
04-22 1126
题意：有一个棋盘如下，黑色表示有棋子，白色表示空，棋盘初始状态为有一个位置n为空，其他位置都有棋子。 每次可以选择一个棋子在一条直线上隔一个或连续多个棋子跳到空白位置，然后这一个或多个棋子就被拿走，问最少几步可以使棋盘上的棋子拿走到只剩下一个且位置和初始空白位置相同。输出几步和每步的起始与落子位置。输出字典序最小的解，无解输出IMPOSSIBLE。 题解：因为棋盘上有15个位置，可以用
UVA - 1533 (Moving Pegs)
playwfun的专栏
11-20 590
思路简单，把状态看成一个长
习题7-12(uva-1533)
小刀刺大熊
03-17 82
#include <iostream> #include <istream> #include <sstream> #include <vector> #include <stack> #include <list> #include <map> #include <set> #include <deque> #include <queue> #include <cstring&gt
UVA 1533 - Moving Pegs 状态压缩 + bfs
s_h_r
04-20 431
这题需要注意的是 当一个球的相邻位置为空时 不能直接跳过去 之间必须要有球垫着 #include #include #include #include #include using namespace std; #define bug puts("bug") const int link[15][6] = { {-1,-1,-1,-1, 1, 2}, {-1, 0,-1, 2,
UVa 1533 Moving Pegs 解题报告（暴力+码力）
SF-_- 的 ACM 博客
07-25 978
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
转载：ACM题目难度分级列表
weixin_30781775的博客
08-26 2941
# ID Title Solved by Difficulty 1 100 The 3n + 1 problem 26485 1 2 102 Ecological Bin Packing 10608 2 3 10071 Back to High School Physics 9554 3 4 10055 Has...
应用调试之配置内核输出应用程序的段错误信息
yuyin86的专栏
12-22 2201
根据之前的调试我们知道，当应用程序出错的时候，会打印一些信息。但是有时候这些信息时不够的，那么我们能否配置内核使其输出更多的信息呢？答案是肯定的，本节我们就来详细讲一下： 还记得我们在运行firstdrvtest的时候曾经输出过如下一些错误信息： Unable to handle kernel paging request at virtual address 56000050 pg
UVA1533-Moving Pegs（BFS+状态压缩）
weixin_30736301的博客
09-06 119
Problem UVA1533-Moving Pegs Accept：106 Submit：375 Time Limit: 3000 mSec Problem Description Input The input consists of T test cases. The number of test cases (T) is given in the...
UVA -12569 (BFS+状态压缩)
playwfun的专栏
11-20 1048
#include #include #include #include #include #include using namespace std; const int N = 491520+10; const int maxn = 15; struct node{ int s,x; node(int s=0,int x=0):s(s),x(x){} }q[N],act[N];
请用迭代的方式实现汉诺塔
最新发布
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...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

kgduu

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值