寒假数据结构学习Day7

今天主要复习题目

单词方阵

#include<stdio.h>
 
int n, book[105][105];          //book数组进行标记
char a[105][105], nextalp[200];              //数组a存储输入数据
 
int next[][2] = { {0, 1}, {1, 0}, {0, -1}, {-1, 0}, {-1, -1}, {-1, 1}, {1, -1}, {1 , 1} };       
//三妙：二维数组next表示向八个方向移动时横纵坐标的变化情况
 
int dfs(int x, int y, char c, int p) {        //四妙：引用大佬原话：我在哪，我是谁，我要往哪个方向
	if (c == 'g') {                     //如果已经搜到了 ‘g’说明一趟已经结束，并返回1
		book[x][y] = 1;                //标记该点为1
		return 1;
	}
	int tx = x + next[p][0], ty = y + next[p][1];      //tx，ty表示往p方向下一个点的横纵坐标
	if (tx >= 0 && tx < n && ty >= 0 && ty < n && a[tx][ty] == nextalp[c] && dfs(tx, ty, nextalp[c], p)) 
    {       //五妙：第五个式子表示下一个字符和当前字符是连着的（即按yizhong顺序），第六个式子表示可以搜到 ‘g’（因为本题递归是逐层返回1的）
		book[x][y] = 1;         //标记该点为1
		return 1;
	}
	return 0;               //前面没有返回1，说明没有搜到最后的‘g’，这里则返回0
 
}
 
 
int main(){
	int i, j, k;                 
	nextalp['y'] = 'i';  nextalp['i'] = 'z';  nextalp['z'] = 'h';   //一妙：nextalp数组以字符为下标，表示这个下标字符的下一个字符（将yizhong串起来）
	nextalp['h'] = 'o';  nextalp['o'] = 'n';  nextalp['n'] = 'g';
	scanf("%d", &n);
	for (i = 0; i < n; i++)
		scanf("%s", a[i]);   
 
	for (i = 0; i < n; i++)
		for (j = 0; j < n; j++)
			if (a[i][j] == 'y')             
				for (k = 0; k < 8; k++)           //二妙：分别八个方向搜索
					dfs(i, j, a[i][j], k);
 
	for (i = 0; i < n; i++) {
		for (j = 0; j < n; j++)
			if (book[i][j])              //如果标记为1就输出它本身
				printf("%c", a[i][j]);
			else                     //否则输出 ‘*’
				printf("*"); 
		printf("\n");               //每行输出后换行
	}
 
	return 0;
}

不是自己写出来的，这大佬的思路是真滴厉害，看第一遍愣是没看明白。方法运用的很巧妙，大师我悟了。

今天继续学习的是栈和队列知识，

#include <stdio.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define MAXSIZE 20
typedef int ElemType;
typedef int State;
typedef struct {   //顺序栈的存储结构
    ElemType data[MAXSIZE];   //用数组存放数据，最大为MAXSIZE，作为栈满条件
    int top;   //用作栈顶指针
}SqStack;

//初始化顺序栈
State initStack(SqStack* S) {
    S->top = -1;   //将栈顶指针置为-1，即将栈作为还是空的时候
    return OK;
}

//获得顺序栈的长度
int getLength(SqStack S) {
    return (S.top) + 1;   //根据数组下标的规则，数组中的长度为指针+1个元素
}

//清空顺序栈
State clearStack(SqStack* S) {
    S->top = -1;   //将栈顶指针重新设置为-1，即此时表示栈空
    return OK;
}

//判断顺序栈是否为空
State isEmpty(SqStack S) {
    if (S.top == -1) {   //如果此时栈顶指针为-1表示栈此时为空，非-1则表示非空
        return TRUE;
    }
    else {
        return FALSE;
    }
}

//入栈
State push(SqStack* S, ElemType* e) {
    if (S->top == MAXSIZE - 1) {   //根据数组下标的特点，当指针指向最后一个元素时为MAXSIZE-1，此时栈满
        printf("栈满，无法入栈\n");
        return ERROR;   //栈满说明空间已满已经不可以再入栈
    }
    else {    //如果栈非满则执行添加过程
        S->top++;   //栈顶指针+1指向一个新的顶部空间
        S->data[S->top] = e;   //将现在指向的这个新的空的栈顶空间元素置为指定元素（后进先出）
        return OK;
    }
}

//出栈
State pop(SqStack* S, ElemType* e) {
    if (S->top == -1) {   //当栈顶指针指向-1，说明栈空，则无法出栈
        printf("栈空，无法出栈\n");
        return ERROR;
    }
    else {   //如果栈非空则执行出栈程序
        *e = S->data[S->top];   //将当前栈顶元素的指针赋给可供返回查看的e
        S->top--;   //栈顶元素出栈后，栈顶指针向下走一格，表示新的栈顶元素
        return OK;
    }
}

//获取栈顶元素（只供查看，不出栈）
State getTop(SqStack S, ElemType* e) {
    if (S.top == -1) {   //当栈顶指针指向-1，说明栈空，栈顶元素为空
        printf("栈空，无栈顶元素\n");
        return ERROR;
    }
    else {   //当栈非空的时候，则将栈顶元素赋值给可供返回查看的e，但是栈顶元素并不出栈
        *e = S.data[S.top];   //将栈顶元素赋值给e，栈顶指针top不变
        return OK;
    }
}

//遍历打印顺序栈
State printStack(SqStack S) {
    if (S.top == -1) {   //当栈顶指针指向-1，说明栈空，无栈元素可供打印
        printf("栈空\n");
        return ERROR;
    }
    int i = 0;   //计数器，记录当前是第几个元素
    while (S.top != -1) {
        i++;   //栈顶指针还未到-1，则说明当前栈顶指针有元素，计数器+1
        printf("栈顶向下第%d个元素为：%d\n", i, S.data[S.top]);  //当前栈顶指针的元素打印出
        S.top--;   //栈顶指针向下走一格，继续进行循环打印
    }
    return OK;
}

栈是“先进后出”，主要注意在出的时候要调整顺序。

BFS解决炸弹人游戏

//炸弹人游戏
#include<stdio.h>
struct note {
    int x;
    int y;
};
char a[21][21];

int getnum(int i, int j) {
    int sum, x, y;
    sum = 0;
    //向上统计
    x = i; y = j;
    while (a[x][y] != '#') {
        if (a[x][y] = 'G')
            sum++;
        x--;
    }
    //向下统计
    while (a[x][y] != '#') {
        if (a[x][y] = 'G')
            sum++;
        x++;
    }
    //向左统计
    while (a[x][y] != '#') {
        if (a[x][y] = 'G')
            sum++;
        y--;
    }
    //向右统计
    while (a[x][y] != '#') {
        if (a[x][y] = 'G')
            sum++;
        y++;
    }
    return sum;
}

int main()
{
    struct note que[401];
    int head, tail;
    int book[20][20] = { 0 };
    int n, m, startx, starty, tx, ty, sum;
    int next[4][2] = { {0,1},{1,0},{0,-1},{-1,0} };
    scanf("%d %d %d %d", &n, &m, &startx, &starty);

    //读入地图
    for (int i = 0; i < 20; i++)
        for (int j = 0; j < 20; j++)
            scanf("%d", &a[i][j]);

    //初始化坐标
    head = 1;
    tail = 1;
    que[tail].x = startx;
    que[tail].y = starty;
    tail++;
    book[startx][starty] = 1;
    int mx = startx;
    int my = starty;
    int max = get(startx, starty);

    while (head < tail) {
        //枚举四个路径
        for (int k = 0; k < 4; k++) {
            tx = que[head].x + next[k][0];
            ty = que[head].y + next[k][1];

            //判断是否越界
            if (tx<0 || tx>n || ty<1 || ty>m)
                continue;
            //判断是否为平地或者曾经走过
            if (a[tx][ty] == '.' && book[tx][ty] == 0) {
                book[tx][ty] = 1;
                que[tail].x = tx;
                que[tail].y = ty;
                tail++;
                //统计可以杀多少敌人
                sum = getnum(tx, ty);

                if (max < sum) {
                    max = sum;
                    mx = tx;
                    my = ty;

                }
                
            }

        }
        head++;
    }
    printf("放在（%d，%d）处，可以消灭%d个敌人\n", mx, my, max);
    getchar(); getchar();
    return 0;
}