迷宫问题。

现有一个n*m的地图，地图上每个格子有一个正整数表示该格子的幸运值。 小明初始时站在地图左上角（(1，1)的位置），同时面朝右方，他每次去往一个相邻（上下左右）且没有被经过的格子，若是他前往的格子方向是自己面朝的方向，则不需要转向，否则需要消耗一张转向卡，且小明最开始拥有k张转向卡。小明经过的所有格子中的数字按照顺序拼接起来就是他得到的总的幸运值，比如他经过了（1，45，37，21）四个格子，幸运值就为1453721。 。请问若是小明需要幸运值为7的倍数，请问他有多少种不同的路径可以走？（不需要走到底，符合条件可以随时停下） 。 输入格式： 第一行依次输入三个数字n，m，k分别表示地图大小和转向卡的数量（ 接下来n行输入m个正整数，空格间隔开，表示每个格子上的幸运值  输出格式： 能够实现总幸运值为7的倍数时的不同路径数量  输入样例1： 2 3 2 79 8 12 31 10 5 输入样例2： 2 3 1 79 8 12 31 10 5  输出样例1： 4 输出样例2： 2

#include <stdio.h>

int n, m, k;
int map[11][11];
int count = 0;
int arr[11][11];
void backtrack(int x, int y, int dir, int length, int cards, int luck) {// 0 左 1 右 2 上 3 下
    if (x < 0 || x >= n || y < 0 || y >= m)
    {
        return;
    }
    if (luck % 7 == 0 && length >= 0) 
    {
        count++;
    }
    if (x > 0 && arr[x-1][y]==0)
    {
        int new_luck;
        if (map[x-1][y] >= 10)
        {
             new_luck = luck * 100 + map[x - 1][y];
        }
        else
        {
             new_luck = luck * 10 + map[x - 1][y];
        }
        int new_cards = cards;
        if (dir != 1) 
        {
            new_cards--;
        }
        if (new_cards >= 0) 
        {
            arr[x - 1][y] = 1;
            backtrack(x - 1, y, 0, length + 1, new_cards, new_luck);
            arr[x - 1][y] = 0;
        }
    }
    if (y < m - 1 && arr[x][y + 1] == 0)
    {
        int new_luck;
        if (map[x][y + 1] >= 10)
        {
            new_luck = luck * 100 + map[x][y + 1];
        }
        else
        {
             new_luck = luck * 10 + map[x][y + 1];
        }

        int new_cards = cards;
        if (dir != 2) 
        {
            new_cards--;
        }
        if (new_cards >= 0) 
        {
            arr[x][y + 1] = 1;
            backtrack(x, y + 1, 1, length + 1, new_cards, new_luck);
            arr[x][y + 1] = 0;
        }
    }
    if (x < n - 1 && arr[x + 1][y] ==0)
    {
        int new_luck;
        if (map[x + 1][y] >= 10)
        {
             new_luck = luck * 100 + map[x + 1][y];
        }
        else
        {
             new_luck = luck * 10 + map[x + 1][y];
        }
        int new_cards = cards;
        if (dir != 3) 
        {
            new_cards--;
        }
        if (new_cards >= 0) 
        {
            arr[x+1][y ] = 1;
            backtrack(x + 1, y, 2, length + 1, new_cards, new_luck);
            arr[x + 1][y] = 0;
        }
    }
    if (y > 0 && arr[x][y - 1] == 0)
    {
        int new_luck;
        if (map[x][y - 1] >= 10)
        {
             new_luck = luck * 100 + map[x][y - 1];
        }
        else
        {
             new_luck = luck * 10 + map[x][y - 1];
        }
        int new_cards = cards;
        if (dir != 0) 
        {
            new_cards--;
        }
        if (new_cards >= 0)
        {
            arr[x ][y-1] = 1;
            backtrack(x, y - 1, 3, length + 1, new_cards, new_luck);
            arr[x][y - 1] = 0;
        }
    }
}

int main() {
    scanf("%d %d %d", &n, &m, &k);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &map[i][j]);
        }
    }
    backtrack(0, 0, 1, 0, k, map[0][0]);
    printf("%d\n", count);
    return 0;
}

 题目描述

机器人围绕二维网格移动。开始时，它位于 [0, 0]，面向东。它由一系列指令控制：

.意味着在当前方向上向前迈出一步。

<表示逆时针旋转 90 度。

>表示顺时针旋转 90 度。

你的工作是处理指令并返回机器人的最终位置。

例如：如果给机器人一个指令序列 ..<.<.，那么：

第 1 步：. 它仍然面向东方，位于 [1, 0]。
第 2 步：. 它仍然面向东方，位于 [2, 0]。
第 3 步：< 它现在朝北，仍然在 [2, 0]。
第 4 步：. 它仍然朝北，位于 [2, 1]。
第 5 步：< 它现在面向西，并且仍然在 [2, 1]。
第 6 步：. 它仍然面向西方，现在位于 [1, 1]。
所以，track_robot("..<.<.")返回 [1, 1]。

输入输出格式
输入格式
第一行有一个字符串，表示一系列指令控制；
输出格式
一行输出数组，表示机器人的最终位置。

输入输出样例1
输入
>>..
输出
[-2, 0]

输入输出样例2
输入
<>>>><><<<><>>>><><<<><>>><>
输出
[0, 0]

#include <stdio.h>

int x = 0; // 机器人的初始 x 坐标
int y = 0; // 机器人的初始 y 坐标
int dx[4] = { 0, 1, 0, -1 }; // 北、东、南、西四个方向的 x 坐标偏移量
int dy[4] = { 1, 0, -1, 0 }; // 北、东、南、西四个方向的 y 坐标偏移量

void dt(char* instructions, int step, int* result,int i) {//step=1
    while (instructions[i] != '\0')
    {

        if (instructions[i] == '.') { // 如果指令是 .，则继续前进一步
            x += dx[step % 4];
            y += dy[step % 4];
        }
        else if (instructions[i] == '<') { // 如果指令是 <，则向左转
            step--;
            if (step < 0) {
                step += 4;
            }
        }
        else if (instructions[i] == '>') { // 如果指令是 >，则向右转
            step++;
            if (step > 4) {
                step -= 4;
            }
        }
        i++;


    }
}

void track_robot(char* instructions, int* result) {
    dt(instructions, 1, result,0); 

    result[0] = x;
    result[1] = y;
}

int main() {
    char instructions[100];
    scanf("%s", instructions);

    int result[2];
    track_robot(instructions, result);
    printf("[%d, %d]\n", result[0], result[1]);

    return 0;
}

题目描述
张三是一个玩迷宫的高手，天下还没有能难住他的迷宫。但是总有人喜欢刁难蒜头君，不停的给张三出难题。这个出题的人很聪明，他知道天下还没有能难住张三的迷宫。

所以他便转换思维问张三，在不走重复路径的情况下，总共有多少不同可以到达终点的路径呢？张三稍加思索便给出了答案，你要不要也来挑战一下？

输入格式
第一行输入两个整数 n(1 ≤ n ≤ 11), m(1 ≤ m ≤ 11)，表示迷宫的行和列。

然后有一个 n × m 的地图，地图由 '.'、'#'、's'、'e' 这四个部分组成。'.'表示可以通行的路，'#'表示迷宫的墙，'s'表示起始点，'e'表示终点。

输出格式
输出一个整数，表示从 's' 到达 'e' 的所有方案数。
输入样例                                           
输入
5 5
s####
.####
.####
.####
....e
输出
1
输入样例
输入
5 5
s####
.####
.####
.####
..##e
输出
0
输入样例
输入
6 6
s...##
.#..##
.#..##
.#....
.#....
.....e
输出
357

#include <stdio.h>
int n, m; 
char maze[11][11]; 
int visited[11][11]; 
//int dx[4] = { -1, 1, 0, 0 }; 
//int dy[4] = { 0, 0, -1, 1 }; 
int count = 0; 

void dfs(int x, int y) {
    if (maze[x][y] == 'e') {
        count++;
        return;
    }
    if (x < 0 || x >= n|| y < 0 || y >= m || maze[x][y] == '#'||visited[x][y]==1)
        return;
    visited[x][y] = 1;
    dfs(x + 1, y);
    dfs(x - 1, y);
    dfs(x, y - 1);
    dfs(x, y + 1);
   /* for (int i = 0; i < 4; i++) {
        int nx = x + dx[i];
        int ny = y + dy[i];
        if ( visited[nx][ny] == 0) {
            dfs(nx, ny);
        }
    }*/
    visited[x][y] = 0;
    return;
}

int main() {
    scanf("%d %d", &n, &m);

   
    for (int i = 0; i < n; i++) {
        scanf("%s", maze[i]);
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            if (maze[i][j] == 's') {
                dfs(i, j);
                break;
            }
        }
    }
    printf("%d\n", count);

    return 0;
}