手搓哈希表、列表、队列，只为了用C语言快速求解华容道游戏，我不是大佬，只是一个游戏算法爱好者

背景

多年前曾经写过C语言求解华容道，当时没有用到哈希表，导致整个查重搜索数组过大，每次求解都得花上数分钟的时间，如今时过境迁，对数据结构和算法有了更深的理解，所以得把这一块补上了。(其实就是最近想换工作，发现都喜欢算法大佬，所以写一个来敲一敲面试官的脑壳)

游戏

华容道挑战 7724游戏

方案

 把曹操格子用1表示，横将用2表示，竖将用3表示，小兵用4表示，空地用0表示，上图可以转化了代号

2244
3110
3110
3433
3433

把上术内容保存到文本文件problem.txt当中

编写源文件main.c，内容为

/*==============依赖库导入 start================*/
#include<stdio.h>				/* 标准输入输出库 */
#include<string.h>				/* 字符串处理库 */
#include<malloc.h>				/* 动态内存管理库 */
/*==============依赖库导入 end==================*/

/*================宏定义 start==================*/
/* 格子宏 */
#define SPACE '0'				/* 空格 */
#define BIG '1'					/* 大格 */
#define HORIZONTAL '2'			/* 横格 */
#define VERTICAL '3'			/* 竖格 */
#define SMALL '4'				/* 小格 */
/* 方向宏 */
#define UP 1					/* 上 */
#define DOWN 2					/* 下 */
#define LEFT 3					/* 左 */
#define RIGHT 4					/* 右 */
/* 哈希宏 */
#define PRIMER 31				/* 素数系数 */
#define MOD 10007				/* 素数哈希 */
/*================宏定义 end====================*/

/*===============数据结构 start=================*/
typedef struct LinkList { 		/* 链表 */
	char *str;					/* 字符串 */
	struct LinkList *next;		/* 下一个节点指针 */
} LinkList;

typedef struct HashSet {		/* 哈希集合 */
	LinkList *linkList[MOD];	/* 链表数组 */
} HashSet;

typedef struct Block {			/* 方块 */
	char type;					/* 类型 */
	int x;						/* 左上角横坐标 */
	int y;						/* 左上角纵坐标 */
	int w,h;					/* 格子宽高 */
	struct Block *next;			/* 下一个节点 */
} Block;

typedef struct Operation {		/* 操作 */
	int x,y;					/* 格子位置 */
	int direction;				/* 移动类型 */
} Operation;

typedef struct Node {			/* 节点 */
	char **arr;					/* 字符数组 */
	Operation *operation;		/* 上一步操作 */
	struct Node *previous;		/* 上一个节点 */
	struct Node *next;			/* 下一个节点 */
} Node;

typedef struct Queue {			/* 队列 */
	Node *head;					/* 队头 */
	Node *tail;					/* 队尾 */
	int count;					/* 数量 */
} Queue;
/*===============数据结构 end===================*/

/* 从文件读取题目 */
void readProblemFile(char **arr,char *filepath) {
	freopen(filepath,"r",stdin);
	int i,j;
	for(i=0; i<5; i++) {
		scanf("%s",arr[i]);
		printf("%s\n",arr[i]);
	}
	printf("\n");
}

/* 获取字符数组哈希码 */
int hashCode(char **arr,char value[]) {
	int res=0;
	int i,j,k=0;
	for(i=0; i<5; i++) {
		for(j=0; j<4; j++) {
			value[k]=arr[i][j];
			k++;
			res=res*PRIMER+arr[i][j]-'0';
			res%=MOD;
		}
	}
	return res;
}

/* 往哈希表中添加对象 */
int addObjectToHashSet(char **arr,HashSet *hashSet) {
	char value[21]= {'\0'};
	int code=hashCode(arr,value);
	LinkList *linkList=hashSet->linkList[code];
	while(linkList!=NULL) {
		if(strcmp(linkList->str,value)==0) {
			return 0;
		} else {
			linkList=linkList->next;
		}
	}
	LinkList *listHead=(LinkList*)malloc(sizeof(LinkList));
	listHead->str=(char*)malloc(sizeof(char)*21);
	strcpy(listHead->str,value);
	listHead->next=hashSet->linkList[code];
	hashSet->linkList[code]=listHead;
	return 1;
}

/* 释放哈希表 */
void freeHashSet(HashSet *hashSet) {
	int i;
	for(i=0; i<MOD; i++) {
		while(hashSet->linkList[i]!=NULL) {
			LinkList *linkList=hashSet->linkList[i];
			hashSet->linkList[i]=hashSet->linkList[i]->next;
			free(linkList);
		}
	}
	free(hashSet);
}

/* 入队 */
void enQueue(char **arr,int x,int y,int direction,Queue *queue) {
	int i;
	Node *node=(Node*)malloc(sizeof(Node));
	node->arr=(char**)malloc(sizeof(char*)*5);
	for(i=0; i<5; i++) {
		node->arr[i]=(char*)malloc(sizeof(char)*5);
		strcpy(node->arr[i],arr[i]);
	}
	if(x==-1||y==-1||direction==-1) {
		node->operation=NULL;
	} else {
		node->operation=(Operation*)malloc(sizeof(Operation));
		node->operation->x=x;
		node->operation->y=y;
		node->operation->direction=direction;
	}
	node->previous=NULL;
	node->next=NULL;

	if(queue->head==NULL) {
		queue->head=node;
		queue->tail=node;
		queue->count=0;
	} else {
		queue->tail->next=node;
		node->previous=queue->head;
		queue->tail=node;
	}
	queue->count++;
}

/* 出队 */
void deQueue(Queue *queue) {
	queue->head=queue->head->next;
	queue->count--;
}

/* 释放队列 */
void freeQueue(Queue *queue) {
	while(queue->head!=NULL) {
		Node* node=queue->head;
		queue->head=queue->head->next;

		if(node->operation!=NULL) {
			free(node->operation);
		}
		if(node->arr!=NULL) {
			int i;
			for(i=0; i<5; i++) {
				free(node->arr[i]);
			}
			free(node->arr);
		}
	}
	free(queue);
}

/* 生成格子链表 */
Block* getBlocks(char **arr) {
	int i,j,u,v;
	Block* blocks=NULL;
	char temp[5][4]= {0};
	for(i=0; i<5; i++) {
		strcpy(temp[i],arr[i]);
	}
	for(i=0; i<5; i++) {
		for(j=0; j<4; j++) {
			if(temp[i][j]==SPACE) {
				continue;
			}
			Block *block=(Block*)malloc(sizeof(Block));
			block->next=blocks;
			blocks=block;
			block->type=temp[i][j];
			block->x=i;
			block->y=j;
			switch(temp[i][j]) {
				case BIG:
					block->w=2;
					block->h=2;
					break;
				case HORIZONTAL:
					block->w=2;
					block->h=1;
					break;
				case VERTICAL:
					block->w=1;
					block->h=2;
					break;
				case SMALL:
					block->w=1;
					block->h=1;
					break;
			}
			for(u=i; u<i+block->h; u++) {
				for(v=j; v<j+block->w; v++) {
					temp[u][v]=SPACE;
				}
			}
		}
	}
	return blocks;
}

/* 释放格子链表 */
void freeBlocks(Block *blocks) {
	while(blocks->next!=NULL) {
		Block *block=blocks;
		blocks=blocks->next;
		free(block);
	}
}

/* 创建字符数组 */ 
char** createArray() {
	int i,j;
	char** res=(char**)malloc(sizeof(char*)*5);
	for(i=0; i<5; i++) {
		res[i]=(char*)malloc(sizeof(char)*5);
		for(j=0; j<4; j++) {
			res[i][j]='0';
		}
		res[i][4]='\0';
	}
	return res;
}

/* 释放字符数组 */
void freeArray(char **arr) {
	int i;
	for(i=0; i<5; i++) {
		free(arr[i]);
	}
	free(arr);
}

/* 方块转字符数组 */
void blocksToArray(Block *blocks,char **arr) {
	int i,j;
	while(blocks!=NULL) {
		Block *block=blocks;
		blocks=blocks->next;

		for(i=block->x; i<block->x+block->h; i++) {
			for(j=block->y; j<block->y+block->w; j++) {
				arr[i][j]=block->type;
			}
		}
	}
}

/* 打印所求结果 */
void displaySolution(Node *node) {
	if(node->operation==NULL) {
		return;
	} else {
		displaySolution(node->previous);
		int i;
		char directionName[][10]= {"","↑","↓","←","→"};
		printf("[%d,%d] %s\n",node->operation->x,node->operation->y,directionName[node->operation->direction]);
	}
}

/* 主函数 */
int main(int argc,char *argv[]) {
	char **array=(char**)malloc(sizeof(char*)*5);
	int i,j;
	for(i=0; i<5; i++) {
		array[i]=(char*)malloc(sizeof(char)*5);
		array[i][4]='\0';
	}

	if(argc==2) {
		readProblemFile(array,argv[1]);
	} else {
		strcpy(array[0],"3113\0");
		strcpy(array[1],"3113\0");
		strcpy(array[2],"3223\0");
		strcpy(array[3],"3443\0");
		strcpy(array[4],"4004\0");
	}

	HashSet hashSet;
	for(i=0; i<MOD; i++) {
		hashSet.linkList[i]=NULL;
	}
	Queue queue;
	queue.head=NULL;
	queue.tail=NULL;

	Node *result=NULL;

	addObjectToHashSet(array,&hashSet);

	enQueue(array,-1,-1,-1,&queue);
	free(array);

	while(queue.head!=NULL) {
		Node *node=queue.head;

		if(node->arr[3][1]==BIG && node->arr[4][2]==BIG) {
			result=node;
			break;
		}


		Block *blocks=getBlocks(node->arr);
		Block *blocksHead=blocks;


		while(blocksHead!=NULL) {
			Block *block=blocksHead;
			blocksHead=blocksHead->next;

			char **arr=NULL;

			switch(block->type) {
				case BIG:
					if(block->x>0 && node->arr[block->x-1][block->y]==SPACE && node->arr[block->x-1][block->y+1]==SPACE) {
						arr=createArray();
						block->x--;
						blocksToArray(blocks,arr);
						block->x++;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,UP,&queue);
						}
					}

					if(block->x+block->h<5 && node->arr[block->x+block->h][block->y]==SPACE && node->arr[block->x+block->h][block->y+1]==SPACE) {
						arr=createArray();
						block->x++;
						blocksToArray(blocks,arr);
						block->x--;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,DOWN,&queue);
						}
					}

					if(block->y>0 && node->arr[block->x][block->y-1]==SPACE && node->arr[block->x+1][block->y-1]==SPACE) {
						arr=createArray();
						block->y--;
						blocksToArray(blocks,arr);
						block->y++;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,LEFT,&queue);
						}
					}

					if(block->y+block->w<4 && node->arr[block->x][block->y+block->w]==SPACE && node->arr[block->x+1][block->y+block->w]==SPACE) {
						arr=createArray();
						block->y++;
						blocksToArray(blocks,arr);
						block->y--;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,RIGHT,&queue);
						}
					}

					break;
				case HORIZONTAL:
					if(block->x>0 && node->arr[block->x-1][block->y]==SPACE && node->arr[block->x-1][block->y+1]==SPACE) {
						arr=createArray();
						block->x--;
						blocksToArray(blocks,arr);
						block->x++;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,UP,&queue);
						}
					}

					if(block->x+block->h<5 && node->arr[block->x+block->h][block->y]==SPACE && node->arr[block->x+block->h][block->y+1]==SPACE) {
						arr=createArray();
						block->x++;
						blocksToArray(blocks,arr);
						block->x--;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,DOWN,&queue);
						}
					}

					if(block->y>0 && node->arr[block->x][block->y-1]==SPACE) {
						arr=createArray();
						block->y--;
						blocksToArray(blocks,arr);
						block->y++;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,LEFT,&queue);
						}
					}

					if(block->y+block->w<4 && node->arr[block->x][block->y+block->w]==SPACE) {
						arr=createArray();
						block->y++;
						blocksToArray(blocks,arr);
						block->y--;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,RIGHT,&queue);
						}
					}

					break;
				case VERTICAL:
					if(block->x>0 && node->arr[block->x-1][block->y]==SPACE) {
						arr=createArray();
						block->x--;
						blocksToArray(blocks,arr);
						block->x++;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,UP,&queue);
						}
					}

					if(block->x+block->h<5 && node->arr[block->x+block->h][block->y]==SPACE) {
						arr=createArray();
						block->x++;
						blocksToArray(blocks,arr);
						block->x--;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,DOWN,&queue);
						}
					}

					if(block->y>0 && node->arr[block->x][block->y-1]==SPACE && node->arr[block->x+1][block->y-1]==SPACE) {
						arr=createArray();
						block->y--;
						blocksToArray(blocks,arr);
						block->y++;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,LEFT,&queue);
						}
					}

					if(block->y+block->w<4 && node->arr[block->x][block->y+block->w]==SPACE && node->arr[block->x+1][block->y+block->w]==SPACE) {
						arr=createArray();
						block->y++;
						blocksToArray(blocks,arr);
						block->y--;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,RIGHT,&queue);
						}
					}
					break;
				case SMALL:

					if(block->x>0 && node->arr[block->x-1][block->y]==SPACE) {
						arr=createArray();
						block->x--;
						blocksToArray(blocks,arr);
						block->x++;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,UP,&queue);
						}
					}

					if(block->x+block->h<5 && node->arr[block->x+block->h][block->y]==SPACE) {
						arr=createArray();
						block->x++;
						blocksToArray(blocks,arr);
						block->x--;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,DOWN,&queue);
						}
					}

					if(block->y>0 && node->arr[block->x][block->y-1]==SPACE) {
						arr=createArray();
						block->y--;
						blocksToArray(blocks,arr);
						block->y++;

						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,LEFT,&queue);
						}
					}

					if(block->y+block->w<4 && node->arr[block->x][block->y+block->w]==SPACE) {
						arr=createArray();
						block->y++;
						blocksToArray(blocks,arr);
						block->y--;
						if(addObjectToHashSet(arr,&hashSet)) {
							enQueue(arr,block->x,block->y,RIGHT,&queue);
						}
					}

					break;
			}
		}

		while(blocks!=NULL) {
			blocksHead=blocks;
			blocks=blocks->next;
			free(blocksHead);
		}
		
		deQueue(&queue);
	}

	if(result!=NULL) {
		printf("求解完成\n");
		displaySolution(result);
	} else {
		printf("此题无解\n");
	}
	
	freeHashSet(&hashSet);
	freeQueue(&queue); 

	return 0;
}

编译源文件main.c得到可执行程序main.exe，把main.exe和problem.txt放在同一个文件夹下。

使用cmd打开此目录，执行命令

main.exe problem.txt > 1.txt

稍后便可在目录下生成1.txt文件，里边保存的就是游戏的通关参考答案。

2244
3110
3110
3433
3433

求解完成
[3,3] ↑
[2,3] ↑
[3,2] →
[4,1] →
[3,1] ↓
[1,1] ↓
[0,2] ↓
[1,2] ←
[0,3] ←
[1,3] ↑
[3,3] ↑
[4,2] →
[0,2] ↓
[0,0] →
[1,0] ↑
[3,0] ↑
[4,1] ←
[2,1] ↓

思路

之前已经有博文进行了详细介绍，此处不再赘述。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/162090.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

POSIX信号量

POSIX信号量

POSIX信号量 POSIX信号量用于同步操作&#xff0c;达到无冲突访问临界资源的目的&#xff0c;可以用于线程之间的通信。而信号量的本质其实就是一把计数器&#xff01;&#xff01;而我们对计数器有2个操作&#xff0c;一个是增加计数器的值&#xff0c;一个是减少计数器的值。…
阅读更多...
MySQL/Oracle用逗号分割的id怎么实现in (逗号分割的id字符串)。find_in_set(`id`, ‘1,2,3‘) 函数,

MySQL/Oracle用逗号分割的id怎么实现in (逗号分割的id字符串)。find_in_set(`id`, ‘1,2,3‘) 函数,

1.MySQL 1.1.正确写法 select * from student where find_in_set(s_id, 1,2,3); 1.2.错误示范 select * from student where find_in_set(s_id, 1,2 ,3); -- 注意&#xff0c;中间不能有空格。1、3 select * from student where find_in_set(s_id, 1,2, 3); -- 注意…
阅读更多...
Nginx安装配置与SSL证书安装部署

Nginx安装配置与SSL证书安装部署

一、Nginx Nginx是一款高性能的开源Web服务器和反向代理服务器&#xff0c;被广泛用于构建现代化的Web应用和提供静态内容。 nginx官网 这里下载nginx-1.24.0-zip Nginx是一款高性能的开源Web服务器和反向代理服务器&#xff0c;被广泛用于构建现代化的Web应用和提供静态内…
阅读更多...
腾讯云新用户专享买什么服务器划算？腾讯云新用户服务器购买建议

腾讯云新用户专享买什么服务器划算？腾讯云新用户服务器购买建议

腾讯云近期推出了一系列的轻量应用服务器活动&#xff0c;其中包括了两款三年时长的优惠配置。这两款配置分别是2核2G4M和2核4G5M&#xff0c;价格分别为540元和756元。相较于按月购买的费用&#xff0c;三年时长的套餐更加划算&#xff0c;并且能够有效省下续费费用。所以&…
阅读更多...
【LeetCode刷题-滑动窗口】-- 239.滑动窗口最大值

【LeetCode刷题-滑动窗口】-- 239.滑动窗口最大值

239.滑动窗口最大值 分析&#xff1a; 方法&#xff1a;优先队列 对于最大值&#xff0c;可以使用优先队列(堆)&#xff0c;其中的大根堆可以帮助实时维护一系列元素中的最大值 在本题中&#xff0c;初始时&#xff0c;将数组nums的前k个元素放入优先队列中&#xff0c;每当我…
阅读更多...
【JavaEE初阶】 CSS的引入方式和选择器

【JavaEE初阶】 CSS的引入方式和选择器

文章目录 &#x1f332;CSS是什么&#xff1f;&#x1f340;CSS基础语法规范&#x1f384;引入方式&#x1f6a9;内部样式表&#x1f6a9;行内样式表&#x1f6a9;外部样式 &#x1f334;代码风格&#x1f333;选择器&#x1f6a9;选择器的种类&#x1f6eb;基础选择器&#x1…
阅读更多...
【代码随想录】算法训练计划23

【代码随想录】算法训练计划23

1、669. 修剪二叉搜索树 题目&#xff1a; 给你二叉搜索树的根节点 root &#xff0c;同时给定最小边界low 和最大边界 high。通过修剪二叉搜索树&#xff0c;使得所有节点的值在[low, high]中。修剪树 不应该 改变保留在树中的元素的相对结构 (即&#xff0c;如果没有被移除&…
阅读更多...
Windows安装Java环境（OracleJDK）

Windows安装Java环境（OracleJDK）

在下载之前&#xff0c;我们先了解一下java的前世今生 1991年&#xff1a;Java 的前身 Oak 由 James Gosling 和他的团队在 Sun Microsystems 公司开发。1995年&#xff1a;Oak 更名为 Java&#xff0c;并在同年发布。Java 1.0 版本正式推出。1996年&#xff1a;Sun Microsyst…
阅读更多...
springboot项目中没有识别到yml文件解决办法

springboot项目中没有识别到yml文件解决办法

springboot项目中没有识别到yml文件解决办法 ![外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传] 1、这个意思就是没有配置数据库的数据源路径。所以需要配置数据源&#xff0c;比如mysql的驱动和路径。检查是否在properties或者yml文件中是否已经配置好。…
阅读更多...
车载开发岗位如何？Android程序员是否转行

车载开发岗位如何？Android程序员是否转行

这几年的大环境让大家都过的不安逸&#xff1b;社会动荡与就业问题一直困扰了不少人。在大家都认为的高薪工作程序员行业中&#xff0c;现在也是费力不讨好裁员风潮大部分指向互联网。 我们Android开发基本上已经感受很久了&#xff0c;就这就业问题很难存活。对此我们的目光都…
阅读更多...
CI/CD - jenkins

CI/CD - jenkins

目录 一、部署 1、简介 2、部署 二、配置 三、实时触发 四、自动化构建docker镜像 五、通过ssh插件交付任务 六、添加jenkins节点 七、RBAC 八、pipeline 九、jenkins结合ansible参数化构建 1、安装ansible 2、新建gitlab项目 3、jenkins新建项目playbook 一、部…
阅读更多...
使用Lychee搭建个人图片存储系统并进行远程访问设置实现公网访问本地私人图床

使用Lychee搭建个人图片存储系统并进行远程访问设置实现公网访问本地私人图床

文章目录 1.前言2. Lychee网站搭建2.1. Lychee下载和安装2.2 Lychee网页测试2.3 cpolar的安装和注册 3.本地网页发布3.1 Cpolar云端设置3.2 Cpolar本地设置 4.公网访问测试5.结语 1.前言 图床作为图片集中存放的服务网站&#xff0c;可以看做是云存储的一部分&#xff0c;既可…
阅读更多...
LeetCode Hot100之十：239.滑动窗口最大值

LeetCode Hot100之十：239.滑动窗口最大值

题目 给你一个整数数组 nums&#xff0c;有一个大小为 k 的滑动窗口从数组的最左侧移动到数组的最右侧。你只可以看到在滑动窗口内的 k 个数字。滑动窗口每次只向右移动一位。 返回 滑动窗口中的最大值 。 提示&#xff1a; 1 < nums.length < 10^5 -10^4 < nums[i…
阅读更多...
管理类联考——逻辑——知识+记忆篇——综合推理——考点+记忆

管理类联考——逻辑——知识+记忆篇——综合推理——考点+记忆

文章目录 整体目录大纲法汇总分类法记忆宫殿法绘图记忆法 考点记忆/考点汇总——按大纲 局部数字编码法归类记忆法重点记忆法歌决记忆法谐音记忆法理解记忆法比较记忆法 本篇思路&#xff1a;根据各方的资料&#xff0c;比如名师的资料&#xff0c;按大纲或者其他方式&#xff…
阅读更多...
【新闻稿】Solv 与 zCloak 联合开发跨境贸易场景下可编程数字凭证项目，获得新加坡、加纳两国央行支持...

【新闻稿】Solv 与 zCloak 联合开发跨境贸易场景下可编程数字凭证项目，获得新加坡、加纳两国央行支持...

关于昨天 Solv 携手 zCloak 与新加坡和加纳两个央行合作的 Project DESFT&#xff0c;很多朋友都发来恭喜和祝福&#xff0c;并希望了解详情。这个事我们秘密努力了半年多&#xff0c;终于有一个阶段性的成果。这里我转载中文版官宣新闻稿&#xff0c;欢迎大家关注。等我忙过这…
阅读更多...
无需公网IP、简单3步，直连远程NAS实现高速访问

无需公网IP、简单3步，直连远程NAS实现高速访问

面对NAS远程访问难题 蒲公英旁路组网盒子X1 一招搞定&#xff01; 无需公网IP、无需设置原有路由 简单3步&#xff0c;即可实现异地组网 更有点对点直连&#xff08;P2P&#xff09;模式 不限流量、不限速 传输速率取决于实际网络带宽 贝锐蒲公英X1&#xff0c;无需改变原…
阅读更多...
mac系统安装docker desktop

mac系统安装docker desktop

Docker的基本概念 Docker 包括三个基本概念: 镜像&#xff08;Image&#xff09;&#xff1a;相当于是一个 root 文件系统。比如官方镜像 ubuntu:16.04 就包含了完整的一套 Ubuntu16.04 最小系统的 root 文件系统。比如说nginx,mysql,redis等软件可以做成一个镜像。容器&#…
阅读更多...
基于深度学习的单帧图像超分辨率重建综述

基于深度学习的单帧图像超分辨率重建综述

论文标题&#xff1a;基于深度学习的单帧图像超分辨率重建综述作者&#xff1a; 吴 靖&#xff0c;叶晓晶&#xff0c;黄 峰&#xff0c;陈丽琼&#xff0c;王志锋&#xff0c;刘文犀发表日期&#xff1a;2022 年9 月阅读日期 &#xff1a;2023.11.18研究背景&#xff1a; 图像…
阅读更多...
【C#】字符串拼接相关

【C#】字符串拼接相关

目录 1.字符串拼接方式1 用号进行字符串拼接 复合运算符 2.字符串拼接方式2 3.控制台打印拼 4.例子 1.字符串拼接方式1 之前的算数运算符 只是用来数值类型变量进行数学运算的而 string 不存在算数运算符 不能计算 但是可以通过号来进行字符串拼接 用号进行字符串拼接 …
阅读更多...
【Linux】进程替换

【Linux】进程替换

Halo&#xff0c;这里是Ppeua。平时主要更新C语言&#xff0c;C&#xff0c;数据结构算法…感兴趣就关注我吧&#xff01;你定不会失望。 本篇导航 1. 进程替换库函数接口execl与execv如何用makefile同时编译多文件execlp与execvpexecle与execvpe 2. 进程替换系统调用接口 # 0…
阅读更多...
最新文章

Copyright @ 2022~2023