NOJ1042——算法实验三——电子老鼠闯迷宫

电子老鼠闯迷宫

描述

有一只电子老鼠被困在如下图所示的迷宫中。这是一个12*12单元的正方形迷宫,黑色部分表示建筑物,白色部分是路。电子老鼠可以在路上向上、下、左、右行走,每一步走一个格子。现给定一个起点S和一个终点T,求出电子老鼠最少要几步从起点走到终点。
在这里插入图片描述
输入

本题包含一个测例。在测例的第一行有四个由空格分隔的整数,分别表示起点的坐标S(x.y)和终点的坐标T(x,y)。从第二行开始的12行中,每行有12个字符,描述迷宫的情况,其中’X’表示建筑物,’.'表示路.

输出

输出一个整数,即电子老鼠走出迷宫至少需要的步数。

输入样例:

2 9 11 8
XXXXXXXXXXXX
X…X.XXX
X.X.XX…X
X.X.XX.XXX.X
X.X…X…X
X.XXXXXXXXXX
X…X.X…X
X.XXX…XXXX
X…X…X
XXX.XXXX.X.X
XXXXXXX…XXX
XXXXXXXXXXXX

输出样例:

28

源代码

#include <iostream>
#include <queue>
using namespace std;
int walk[4][2] = {
    1,0,
    0,1,
    -1,0,
    0,-1
};
int maze[12][12];
int step[12 * 12];
void input()
{
    int i, j;
    char c;
    for (i = 0; i < 12; i++)
    {
        for (j = 0; j < 12; j++)
        {
            cin >> c;
            if(c == 'X')
                maze[i][j] = 1;
        }
    }
}
int make_new_place(int row,int col,int type)
{
    row += walk[type][0];
    col += walk[type][1];
    if(row < 0 || row >= 12 || col < 0 || col >= 12)
    {
        return -1;
    }
    if(maze[row][col] != 0)
        return -1;
    else
        return row * 12 + col;
}
void bfs(queue<int> q,int end_r,int end_c)
{
    int i;
    while(!q.empty())
    {
        int pop_num = q.front();
        q.pop();
        int place_r = pop_num / 12;
        int place_c = pop_num % 12;
        int new_num[4];
        for (i = 0; i < 4; i++)
        {
            new_num[i] = make_new_place(place_r, place_c, i);
            if(new_num[i] != -1)
            {
                step[new_num[i]] = step[pop_num] + 1;
                int row = new_num[i] / 12;
                int col = new_num[i] % 12;
                maze[row][col] = pop_num;
                q.push(new_num[i]);
                if(row == end_r && col == end_c)
                {
                    return;
                }
            }
        }
    }
}
int main()
{
    queue<int> q;
    int begin_x, begin_y;
    int end_x, end_y;
    cin >> begin_x >> begin_y;
    cin >> end_x >> end_y;
    input();
    q.push((begin_x - 1) * 12 + (begin_y - 1));
    maze[begin_x - 1][begin_y - 1] = 1;
    bfs(q, end_x - 1, end_y - 1);
    cout << step[(end_x - 1) * 12 + (end_y - 1)] << endl;
}

思路

之前用深搜也写过迷宫问题,不过广搜是为了找到最短路径,而且找到一条最优解后就可以退出。
扩展新结点的时候只需要判断是否越界,撞墙,重复,如果都没有,那么返回行*12+列就可以得到扩展结点的位置。

  1. 出队元素,扩展四个结点,若返回值不为-1,则入队。
  2. 如果入队元素的横纵坐标为目标点就返回。

这道题和其他题稍有不同,它的坐标是从1开始的,这是需要注意的。

哈夫曼编码是一种常用的数据压缩算法,可以将原始数据转换为更短的编码,从而减少存储空间。它的基本思想是:根据字符出现的频率,构建一颗二叉树,使得出现频率高的字符离根节点近,出现频率低的字符离根节点远。然后,对于每个字符,从根节点出发,沿着对应的路径到达该字符所在的叶子节点,记录下路径,作为该字符的编码。 哈夫曼编码的具体实现步骤如下: 1. 统计每个字符在原始数据中出现的频率。 2. 根据字符的频率构建哈夫曼树。构建方法可以采用贪心策略,每次选择出现频率最低的两个字符,将它们作为左右子节点,父节点的权值为两个子节点的权值之和。重复这个过程,直到只剩下一个根节点。 3. 对哈夫曼树进行遍历,记录下每个字符的编码,为了避免编码产生歧义,通常规定左子节点为0,右子节点为1。 4. 将原始数据中的每个字符,用它对应的编码来代替。这一步可以通过哈夫曼树来实现。 5. 将编码后的数据存储起来。此时,由于每个字符的编码长度不同,所以压缩后的数据长度也不同,但总体上来说,压缩效果通常是比较好的。 实现哈夫曼编码的关键在于构建哈夫曼树和计算每个字符的编码。构建哈夫曼树可以采用优先队列来实现,每次从队列中取出两个权值最小的节点,合并成一个节点,再将合并后的节点插入队列中。计算每个字符的编码可以采用递归遍历哈夫曼树的方式,从根节点出发,如果走到了左子节点,则将0添加到编码中,如果走到了右子节点,则将1添加到编码中,直到走到叶子节点为止。 以下是基于C++的代码实现,供参考: ```c++ #include <iostream> #include <queue> #include <string> #include <unordered_map> using namespace std; // 定义哈夫曼树节点的结构体 struct Node { char ch; // 字符 int freq; // 出现频率 Node* left; // 左子节点 Node* right; // 右子节点 Node(char c, int f) : ch(c), freq(f), left(nullptr), right(nullptr) {} }; // 定义哈夫曼树节点的比较函数,用于优先队列的排序 struct cmp { bool operator() (Node* a, Node* b) { return a->freq > b->freq; } }; // 构建哈夫曼树的函数 Node* buildHuffmanTree(unordered_map<char, int> freq) { priority_queue<Node*, vector<Node*>, cmp> pq; for (auto p : freq) { pq.push(new Node(p.first, p.second)); } while (pq.size() > 1) { Node* left = pq.top(); pq.pop(); Node* right = pq.top(); pq.pop(); Node* parent = new Node('$', left->freq + right->freq); parent->left = left; parent->right = right; pq.push(parent); } return pq.top(); } // 遍历哈夫曼树,计算每个字符的编码 void calcHuffmanCode(Node* root, unordered_map<char, string>& code, string cur) { if (!root) return; if (root->ch != '$') { code[root->ch] = cur; } calcHuffmanCode(root->left, code, cur + "0"); calcHuffmanCode(root->right, code, cur + "1"); } // 将原始数据编码成哈夫曼编码 string encode(string s, unordered_map<char, string> code) { string res; for (char c : s) { res += code[c]; } return res; } // 将哈夫曼编码解码成原始数据 string decode(string s, Node* root) { string res; Node* cur = root; for (char c : s) { if (c == '0') { cur = cur->left; } else { cur = cur->right; } if (!cur->left && !cur->right) { res += cur->ch; cur = root; } } return res; } int main() { string s = "abacabad"; unordered_map<char, int> freq; for (char c : s) { freq[c]++; } Node* root = buildHuffmanTree(freq); unordered_map<char, string> code; calcHuffmanCode(root, code, ""); string encoded = encode(s, code); string decoded = decode(encoded, root); cout << "Original string: " << s << endl; cout << "Encoded string: " << encoded << endl; cout << "Decoded string: " << decoded << endl; return 0; } ```
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

Alfred young

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

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

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

打赏作者

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

抵扣说明:

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

余额充值