C语言实现扫雷(递归函数的应用)

最新推荐文章于 2024-05-21 23:08:56 发布
最新推荐文章于 2024-05-21 23:08:56 发布
阅读量1k 收藏 22
点赞数 31
文章标签： c语言 逻辑回归
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/z3256707200/article/details/136070631
版权

文章目录


封面
扫雷游戏作为一款我们小时候电脑上为数不多的几个游戏之一，其功能简单，界面简洁。本篇将介绍如何用C语言实现扫雷游戏。本片以介绍9×9的棋盘，内含10颗雷的游戏难度为大家介绍，大家也可以在代码中更改棋盘的尺寸和雷的个数。

游戏介绍

扫雷，顾名思义就是要找到埋在地里的雷，游戏中9×9的棋盘代表了所有土地，每一个小格代表土地的一部分，其中可能埋着雷，也可能没有雷。玩家选择一个坐标来扫雷，若被选中的坐标区域有雷，则游戏失败；若没有雷，则会显示其周围八个坐标的有雷坐标的个数，若其周围没有雷，则会对周围坐标显示其周围的雷数。若将全部没有埋雷的坐标都扫完，则游戏胜利。

实现各功能代码

游戏的控制代码

如果我们要写一个游戏代码，首先要写一个控制代码，用来实现游戏的进入或退出。
那么我们希望程序运行后会出现一个菜单，提示我们：输入1进入游戏，输入2退出游戏，其他输入则提示输入错误，并重新输入。
实现该功能的代码如下：

main()
{
another:
	printf("--------------------------\n");
	printf("---------1  PLAY----------\n");
	printf("---------2  EXIT----------\n");
	printf("--------------------------\n");
	printf("请选择：");
	int input = 0;
	scanf("%d", &input);
	if (input == 1) {
		game();
	}
	else if (input == 2) {
		printf("游戏退出\n");
	}
	else {
		printf("输入错误，请重新输入。\n");
		goto another;
	}
	return 0;
}

实现游戏功能的代码

通过上述代码不难看出，若输入1，则会执行game()函数，执行完后程序结束。那么game()函数该具备那些功能呢？

初始化两个棋盘

大家如果流览过其他的扫雷游戏的代码，会发现都使用了两个二维数组来表示棋盘，那么为什么要用两个数组呢？一个棋盘用一个数组不久可以表示了吗？原因是这样，如果用一个数组来表示棋盘，将不利于分辨该坐标是否被排查过，同时也不利于棋盘的输出。那么我们就用到了两个棋盘，第一个棋盘用来布置雷和计算周围雷的个数，这个棋盘不会输出给玩家看；第二个棋盘初始化全都为*来表示未知，排查过的坐标则显示该坐标周围的雷的个数。这样做的好处很显然，第一个棋盘(即数组)是不会改变的，这样对我们统计某个坐标周围雷的个数时很方便的，如果只使用一个棋盘，则会非常混乱。
我们将第一个数组初始化为0，并随机产生10个坐标，将数组的值改为1，这样当我们计算某个坐标周围的雷的个数时，只需遍历他周围的8个坐标，并将数组的值相加，相加的结果即为雷的个数。
到这里有人就会发现问题了，这种计算雷的个数的方法，对于处在棋盘中间的坐标是可行的，但是对于在棋盘边上的坐标是不可行的，因为这种计算方法会导致数组越界，即计算(9,9)这个位置的周围雷的个数时，会将他周围一圈的坐标的数组值相加，这样就会出现(10,8)(10,9)(10,10)(9,10)(8,10)这几个坐标，很显然我们的数组就会越界，那么为了避免这种情况，我们可以选择将数组定义为[ROW+2][COL+2]这种大小(ROW表示棋盘的行数，COL表示棋盘的列数)，即将棋盘向外扩展了一圈，我们将拓展出来的这一圈坐标对应的数组值定义为0，随机生成雷的时候，限制雷不能生成在最外圈，这样就可以完美契合我们的思路了，这一步是整个扫雷游戏代码的最精华的思想。
我们可以先创建一个头文件，然后在头文件中设置棋盘的尺寸和雷的个数。代码如下：

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<time.h> //为了后续实现随机数

#define ROW 9  //行数和列数，这两个代表棋盘的尺寸
#define COL 9
#define ROWS ROW+2  //这两个代表数组的实际尺寸
#define COLS COL+2

#define mine_number 10    //设置雷的个数

首先我们要初始化两个棋盘，可以创建一个code.c文件，这个文件中用于存放游戏部分的函数代码。
数组初始化函数：

//将数组初始化为字符'set'
void Init(char arr[ROWS][COLS], int rows, int cols, char set)
//注意传递的数组的行数和列数，这里数组的实际大小为[ROWS][COLS],且我们想要全部初始化，
//所以后面两个参数我们定义的是 rows 和 cols ,即提醒我们传递 ROWS 和 COLS,而不是传递 ROW 和 COL 
#define COLS
{
	int i = 0;
	for (i = 0; i < rows; i++) {
		int j = 0;
		for (j = 0; j < cols; j++) {
			arr[i][j] = set;
		}
	}
}

布置雷

棋盘初始化好了之后，我们就可以随机放置地雷了。
布置雷函数：

void Set_mine(char arr[ROWS][COLS])
{
	srand((unsigned int)time(NULL));
	int num = mine_number;
	while (num) {
		int x = rand() % 9 + 1; //生成1~9之间的随机数，不能生成0和10，因为最外圈不布置雷
		int y = rand() % 9 + 1;
		if (arr[x][y] == '0')
		{
			arr[x][y] = '1';
			num--;
		}
	}
}

棋盘的输出

布置好雷之后，我们可以将棋盘输出给玩家看了，但我们输出的一定是第二个棋盘，那个被我们初始化为*的棋盘，这里如果一不小心将第一个棋盘输出了，那就相当于是把答案告诉玩家了，不过在我们调试程序的过程中可以将第一个棋盘打印出来，用来辅助我们调试。为了方便输出，我们可以写一个输出数组的函数。
数组输出函数：

void Print(char arr[ROWS][COLS], int row, int col)
//这里数组的实际大小虽然为[ROWS][COLS]，但我们只需要打印棋盘大小的数组即可，
//所以我们后续的实参需要给的是 ROW 和 COL ，这里定义形参为 row 和 col 起提示作用
{
	for (int r = 0; r <= rows; r++) //输出横坐标轴
		printf("%d ", r);
	printf("\n");
	int i = 0;
	for (i = 1; i <= rows; i++) {
		printf("%d ", i); //输出纵坐标轴
		int j = 0;
		for (j = 1; j <= cols; j++) {
			printf("%c ", arr[i][j]);
		}
		printf("\n");
	}
}

计算周围雷的个数

玩家输入了想要扫雷的坐标后，程序要计算该坐标周围雷的个数，并将该值替换第二个数组的*，然后输出第二个数组给玩家显示扫雷后的结果。
同时在头文件中定义一个全局数组win[1]并初始化为0，然后每执行一次计算函数，win[0]的值就+1，这样win[0]的值就可以代表已扫过的坐标个数。(指针还没学，暂时用数组代替)
计算函数的实现很简单，只是需要注意我们最开始定义的是字符数组，所以在进行加减计算时，记得'0'的计算。
计算坐标周围雷的个数，并将该值替换在第二个数组中，函数代码如下：

void Count(char arr1[ROWS][COLS], char arr2[ROWS][COLS], int x, int y)
{
	int num = 0;
	for (int i = x - 1; i <= x + 1; i++)
	{
		for (int j = y - 1; j <= y + 1; j++) {
			if (i == x && j == y)
				continue;
			else {
				num += arr1[i][j] - '0';
			}
		}
	}
	arr2[x][y] = num + '0';
	win[0]++;
}

扫雷函数

扫雷函数首先要是一个循环，在雷未被扫完时，一直进行这个循环，在雷被扫完后，跳出循环，并提示玩家游戏胜利。判断游戏胜利的条件可以为win[0]==ROW*COL-mine_number,即扫过的坐标个数=棋盘的总坐标个数-埋了雷的坐标个数；也可以遍历第二个数组，看该数组中有多少个*,如果*的个数等于雷的个数，则游戏胜利，这种方式不需要用到win[0]，所以在上一步中也无需定义win[1]。
循环体中，首先需要玩家输入要判断的坐标，然后判断该坐标是否合法，再判断该坐标是否有雷，再判断该坐标是否已排查过，最后进行扩展函数，输出扩展后的第二个数组。(扩展函数见下)
扫雷函数：

void Clear_mine(char arr1[ROWS][COLS], char arr2[ROWS][COLS], int row, int col) {
	while (win[0] < ROW * COL - mine_number)   //替换部分
	//while(Num(arr2, ROW, COL) > mine_number)
	{
		printf("请输入扫雷的坐标：");
		int x = 0;
		int y = 0;
		scanf("%d%d", &x, &y);
		if (x >= 1 && x <= ROW && y >= 1 && y <= COL) { //判断坐标是否合法
			printf("\n");
			if (arr1[x][y] == '1') {
				printf("游戏失败。\n");
				Print(arr1, ROW, COL); //游戏失败后，显示埋雷情况
				break;
			}
			else {
				if (arr2[x][y] != '*') {
					printf("这个位置已经排查过了，请重新选择。\n");
				}
				else if(arr1[x][y]=='0') {
					Extend(arr1, arr2, x, y); //周围展开函数
					Print(arr2, ROW, COL);
				}
			}
		}
		else {
			printf("非法输入，请重新选择。\n");
		}
		if (win[0] == ROW * COL - mine_number) {   //替换部分
			printf("恭喜你！游戏获胜！\n");          //替换部分
			break;                                 //替换部分
		}                                          //替换部分
		/*if (Num(arr2, ROW, COL) == mine_number) {
			printf("恭喜你！游戏获胜！\n");
			break;
		}*/
	}
}

上述代码使用的是win[0]==ROW*COL-mine_number这个判断条件，如果想使用另一个判断条件，就替换上述代码中的注释部分，并在这个函数前面定义一个数第二个数组中*的个数的函数即可。(下面的代码一定要在上面的代码之前)
数*函数：

int Num(char arr[ROWS][COLS], int row , int col )
{
	int number = 0;
	for (int i = 1; i <= ROW; i++)
	{
		for (int j = 1; j <= COL; j++)
		{
			if (arr[i][j] == '*')
				number++;
		}
	}
	return number;
}

扩展函数(递归部分)

扩展函数是整个程序最大的难点，什么条件下执行递归，如何停止递归。
在Clear_mine函数中，如果arr1[x][y]=='0'成立，就执行Extend(arr1, arr2, x, y)，所以我们第一步就是先计算(x,y)坐标周围的雷的个数，所以Extend函数的第一步就是执行一次Count函数。
扫雷游戏在什么情况下会展开周围的坐标呢？我们可以玩两把扫雷游戏找找规律，展开对主坐标和展开坐标都有要求。首先主坐标不能雷，且周围雷的个数为0，代码表示为if (arr1[x][y] == '0' && arr2[x][y] == '0') ，然后遍历周围八个坐标，如果其不是雷，则以该坐标作为主坐标，执行Extend
那么我们的代码就可以表示为：

void Extend(char arr1[ROWS][COLS], char arr2[ROWS][COLS], int x, int y)
{
	Count(arr1, arr2, x, y);
	if (arr1[x][y] == '0' && arr2[x][y] == '0') 
	{
		for (int i = x - 1; i <= x + 1; i++)
		{
			for (int j = y - 1; j <= y + 1; j++) 
			{
				if (arr1[i][j] == '0') 
					Extend(arr1, arr2, i, j);
			}
		}
	}
}

如果用这个代码去调试，就会发现程序进入了死循环，这是为什么呢？
原来是已经扫过的坐标又被作为周围坐标，然后符合做主坐标的条件，从而进入了死循环。即以A坐标作为主坐标展开，展开遇到B坐标，B坐标符合做主坐标的条件，所以以B作为主坐标展开，展开遇到A坐标，A坐标符合…从而进入死循环，那么为了避免这种情况，我们可以设置某个坐标只有未被展开过才能以其为主坐标执行Extend
代码表示为：

void Extend(char arr1[ROWS][COLS], char arr2[ROWS][COLS], int x, int y)
{
	Count(arr1, arr2, x, y);
	if (arr1[x][y] == '0' && arr2[x][y] == '0') 
	{
		for (int i = x - 1; i <= x + 1; i++)
		{
			for (int j = y - 1; j <= y + 1; j++) 
			{
				if (arr1[i][j] == '0' && arr2[i][j] == '*') 
					Extend(arr1, arr2, i, j);
			}
		}
	}
}

这样代码就不会死循环了，运行调试感觉也像模像样的。
在这里插入图片描述
但我们多试几次，就会发现代码是有问题的。
在这里插入图片描述
可以看到，左边部分的代码展开是没有问题的，但是为什么右面也有部分代码被展开了呢？
经过数个小时的调试，终于发现了问题所在，原来我们之前设置的最外面一圈数也参与进了递归的判断。
也就是说，除了输出的9×9棋盘，最外面还有一圈0，这一圈0符合本身没有雷，所以只要他的周围也没有雷，就会以他作为主坐标展开，就会有可能逐个以最外圈的坐标作为主坐标展开，从而展开到很远的地方，上述情形就是如此。
所以在判断条件中还应该限制坐标在(1,1)~（9,9）之间。
所以最终我们的Extend函数应该为：

void Extend(char arr1[ROWS][COLS], char arr2[ROWS][COLS], int x, int y)
{
	Count(arr1, arr2, x, y);
	if (arr1[x][y] == '0' && arr2[x][y] == '0') 
	{
		for (int i = x - 1; i <= x + 1; i++)
		{
			for (int j = y - 1; j <= y + 1; j++) 
			{
				if (arr1[i][j] == '0' && i >= 1 && j >= 1 && arr2[i][j] == '*' && i<=ROW && j<=COL)
					Extend(arr1, arr2, i, j);
			}
		}
	}
}

至此我们的扫雷游戏各个部分就已经都准备好了。

参考代码

code.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "code.h"
#include<time.h>


extern mine;
extern show;
extern int win[1] = { 0 };


void Init(char arr[ROWS][COLS], int rows, int cols, char set)
{
	int i = 0;
	for (i = 0; i < rows; i++) {
		int j = 0;
		for (j = 0; j < cols; j++) {
			arr[i][j] = set;
		}
	}
}


void Print(char arr[ROWS][COLS], int row, int col)
{
	for (int r = 0; r <= row; r++)
		printf("%d ", r);
	printf("\n");
	int i = 0;
	for (i = 1; i <= row; i++) {
		printf("%d ", i);
		int j = 0;
		for (j = 1; j <= col; j++) {
			printf("%c ", arr[i][j]);
		}
		printf("\n");
	}
}

void Set_mine(char arr[ROWS][COLS])
{
	srand((unsigned int)time(NULL));
	int num = mine_number;
	while (num) {
		int x = rand() % 9 + 1;
		int y = rand() % 9 + 1;
		if (arr[x][y] == '0')
		{
			arr[x][y] = '1';
			num--;
		}
	}
}

void Count(char arr1[ROWS][COLS], char arr2[ROWS][COLS], int x, int y)
{
	int num = 0;
	for (int i = x - 1; i <= x + 1; i++)
	{
		for (int j = y - 1; j <= y + 1; j++) {
			if (i == x && j == y)
				continue;
			else {
				num += arr1[i][j] - '0';
			}
		}
	}
	arr2[x][y] = num + '0';
	win[0]++;
}

void Extend(char arr1[ROWS][COLS], char arr2[ROWS][COLS], int x, int y)
{
	Count(arr1, arr2, x, y);
	if (arr1[x][y] == '0' && arr2[x][y] == '0') 
	{
		for (int i = x - 1; i <= x + 1; i++)
		{
			for (int j = y - 1; j <= y + 1; j++) 
			{
				if (arr1[i][j] == '0' && i >= 1 && j >= 1 && arr2[i][j] == '*' && i<=ROW && j<=COL) 
					Extend(arr1, arr2, i, j);
			}
		}
	}
}

void Clear_mine(char arr1[ROWS][COLS], char arr2[ROWS][COLS], int row, int col) {
	while (win[0] < ROW * COL - mine_number)
	//while(Num(arr2, ROW, COL) > mine_number)
	{
		printf("请输入扫雷的坐标：");
		int x = 0;
		int y = 0;
		scanf("%d%d", &x, &y);
		if (x >= 1 && x <= ROW && y >= 1 && y <= COL) {
			printf("\n");
			if (arr1[x][y] == '1') {
				printf("游戏失败。\n");
				Print(arr1, ROW, COL);
				break;
			}
			else {
				if (arr2[x][y] != '*') {
					printf("这个位置已经排查过了，请重新选择。\n");
				}
				else if(arr1[x][y]=='0') {
					Extend(arr1, arr2, x, y);
					Print(arr2, ROW, COL);
				}
			}
		}
		else {
			printf("非法输入，请重新选择。\n");
		}
		if (win[0] == ROW * COL - mine_number) {
			printf("恭喜你！游戏获胜！\n");
			break;
		}
		/*if (Num(arr2, ROW, COL) == mine_number) {
			printf("恭喜你！游戏获胜！\n");
			break;
		}*/
	}
}

code.h

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<time.h>

#define ROW 9
#define COL 9
#define ROWS ROW+2
#define COLS COL+2

#define mine_number 10 


//初始化
void Init(char arr[ROWS][COLS], int rows, int cols, char set);

//打印数组
void Print(char arr[ROWS][COLS], int rows, int cols);

//埋雷
void Set_mine(char arr[ROWS][COLS]);

//扫雷
void Clear_mine(char arr1[ROWS][COLS], char arr2[ROWS][COLS], int row, int col);

//展开周围
void Extend(char arr1[ROWS][COLS], char arr2[ROWS][COLS], int x, int y);

Mine_game.c

#define _CRT_SECURE_NO_WARNINGS 1

#include "code.h"

void game()
{
	//创建两个二维数组并初始化
	char mine[ROWS][COLS] = { 0 };
	char show[ROWS][COLS] = { 0 };
	Init(mine,ROWS,COLS, '0');
	Init(show, ROWS, COLS, '*');
	//打印
	//Print(mine, ROW, COL);
	//Print(show, ROW, COL);
	printf("该棋盘中共有%d个雷，请将其他区域选择出来。\n", mine_number);
	//随机加入地雷
	Set_mine(mine);
	//Print(mine, ROW, COL);//调试时可以取消注释，打印mine数组
	Print(show, ROW, COL);
	//扫雷
	Clear_mine(mine,show,ROW,COL);
}



main()
{
another:
	printf("--------------------------\n");
	printf("---------1  PLAY----------\n");
	printf("---------2  EXIT----------\n");
	printf("--------------------------\n");
	printf("请选择：");
	int input = 0;
	scanf("%d", &input);
	if (input == 1) {
		game();
	}
	else if (input == 2) {
		printf("游戏退出\n");
	}
	else {
		printf("输入错误，请重新输入。\n");
		goto another;
	}
	return 0;
}

运行演示

控制代码

在这里插入图片描述

扫雷游戏

为了方便演示，这里设置雷的个数为3。
在这里插入图片描述

结语

扫雷游戏是C语言的一道很老的练手题了，最巧妙的是用两个棋盘来分别表示埋雷和扫雷。但哪怕是在知道这种方法的情况下，想完整的写出扫雷游戏对初学者来说仍很困难，在我写的过程中，耗费时间最长的就是Extend函数的递归，在何种情况下进入递归，文章中写的过程就是我试错的过程，写出来后确实看着不难，但想写出来确实不简单。
除此之外，扫雷游戏还可以再完善，比如：第一步一定不会踩到雷，标记雷的功能，记录走的步数，记录游戏时间等等，这些就属于细枝末节了，想加的话可以自己写一写。
最后，祝大家都能写出来！

许晓曼
关注
  • 31
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【C语言】扫雷(递归展开 + 标记功能)
StackFrame
07-29 2410
扫雷图文讲解实现 + 递归展开一篇 + 标记功能
C语言中的递归函数及其注意
11-20
递归函数C语言 递归函数是指在函数的定义中调用自身的一种函数。递归函数在解决一些问题时非常有用，因为它可以将问题分解成更小的子问题，然后使用这些子问题的解来解决原始问题。 在C语言中，递归函数是一种特殊的...
C语言 扫雷（含递归展开）
weixin_73258319的博客
10-13 3099
想必大家在上学时代都或多或少玩过扫雷游戏，通过棋盘上已有的数据分析出雷所在的位置获取胜利，每一次游戏都带给我们强大的满足感与能力的提升。那么今天我就带领大家用C语言实现扫雷的编写。（长文加详细代码）
C语言 扫雷游戏（递归函数）
bolife的博客
10-07 651
C语言 、 扫雷 、扫雷小游戏 下面这段代码是源文件achieve.c的具体代码和文字解释。（用于解释自定义函数）下面这段代码是源文件gamemain.c的具体代码和文字解释。将代码分别放入三个文件（头文件、源文件）中，这样代码更有可读性。下面这段代码是头文件achieve.h的具体代码和文字解释。下面是使用自定义函数所编写的扫雷小游戏。
C语言扫雷函数成绩,C语言实现扫雷
weixin_42109178的博客
05-19 117
实现用C语言编写一个扫雷游戏大家想必都玩过扫雷，无论那个版本都有难度供已选择，下面来分享一个自己用C语言编写的扫雷游戏吧！编写语言：C语言编写软件：visual studio 20171.首先是将游戏的测试模块写好，要有提示玩家进入的菜单函数以及选择函数等各种需要编写的函数想出一个整体框架来//测试模块test。c#include "game.h"void Menu(){printf("*****...
C语言扫雷（递归展开）（详细注释）（完整代码）
AAAAA_9的博客
08-02 7551
c语言扫雷游戏
【C语言】函数递归实现——扫雷小游戏（详细步骤）
DerrickWestbrook的博客
07-30 1592
一看就懂的c语言 有手就行——三子棋小游戏 —————————————————————————————————————————— 相信大家都是玩过三子棋的，今天就来讲一下如何用非常基础的c语言写一个简单的三子棋代码 —————————————————————————————————————————— 思路概览一看就懂的c语言 有手就行——三子棋小游戏1.初始化棋盘1.1打印棋盘2.玩家下棋3.电脑下棋4.判断游戏输赢 1.初始化棋盘 1.1打印棋盘 2.玩家下棋 3.电脑下棋 4.判断游戏输赢 ..
C语言实现扫雷游戏（完整版）
王元笙
05-28 9560
利用C语言模拟实现扫雷游戏：主要利用到二维数组、循环与分支语句、函数的递归以及指针等知识。
详解C语言实现扫雷游戏
weixin_73053512的博客
05-13 1643
优点实现了扫雷函数的大部分功能，比如展开，标记，清除标记等等。游戏难度没办法由玩家手动设置，扫雷过程中标记和清除标记的顺序比较固定，这些交由读者来完善~
c语言扫雷（递归实现展开）
x2656271356的博客
11-18 753
扫雷递归实现，美化棋盘，没有实现标记功能（实在是没有时间了）
递归应用C语言实现
02-09
包含多个经典的递归应用代码： 1.fibonacci.c 是斐波拉契数列递归解法 2.hanoi.c 是汉诺塔递归算法 3.permutation.c 是全排列递归算法 4.queen.c 是八皇后递归算法 5. reverse.c 是递归的测试代码 6.strlrn.c 是求...
C语言学习之递归函数ppt.zip
06-02
C语言学习资源C语言学习资源C语言学习资源C语言学习资源C语言学习资源C语言学习资源C语言学习资源C语言学习资源C语言学习资源C语言学习资源C语言学习资源C语言学习资源C语言学习资源C语言学习资源C语言学习资源C语言...
C语言中递归函数的应用.pdf
09-19
C语言中递归函数的应用.pdf
C语言函数的递归和调用实例分析
01-20
　要点：　1、C语言函数可以递归调用。　2、可以通过直接或间接两种方式调用。目前只讨论直接递归调用。 二、递归条件 　采用递归方法来解决问题，必须符合以下三个条件：　1、可以把要解决的问题转化为一个新问题，...
【c语言】TIMI哥听课笔记
EllaZeng的博客
05-16 1336
函数的声明，需要告诉编译器函数的一些信息：返回类型，参数列表，函数名#pragma once//防止头文件重复包含函数定义中，参数名不可省略。
06.逻辑回归
最新发布
冷月寒笙的博客
05-21 181
可以通过线性变换到另一个线性空间中，重新定义特征向量。也称linear model。做不了，因为边界是一条直线。假设样本符合高斯分布。减少参数，降低过拟合。
逻辑回归的损失函数和线性回归的损失函数
weixin_57128596的博客
05-18 970
其实很简单理解，我们需要求解最优的参数比如w，那么损失函数需要最小，我们dL/dw求解损失函数对w权重的局部梯度，当梯度变化较大时，说明w变化剧烈，离最优值比较远，需要加大我们的学习率lr（自适应学习率，参考之前的梯度大小），梯度变化大说明损失函数在当前参数值w附近对参数的变化非常敏感。1、**局部最小值：**在非凸损失函数中，存在多个局部最小值，这是损失函数在一定区域内的最小值。，可以高效地计算损失函数对网络中所有参数的梯度，无需手动计算每个参数的偏导数，大大提高了梯度计算的效率。
druid-1.0.11.jar
05-21
javaee/javaweb常用jar包，亲测可用，导入到java工程中即可使用
c语言扫雷如何实现格子的递归打开
05-20
在C语言中实现扫雷游戏格子的递归打开可以通过以下步骤来实现： 1. 定义一个递归函数，该函数的参数为当前需要打开格子的坐标和游戏面板的状态数组。 2. 首先判断当前格子是否已经被打开，如果是则直接返回。 3. ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值