连连看 算法 2013-12-29

最新推荐文章于 2024-07-24 22:13:06 发布
最新推荐文章于 2024-07-24 22:13:06 发布
阅读量386 收藏
点赞数
文章标签： 连连看 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/kelvinlyan/article/details/17667295
版权

连连看算法：判断两个点是否能经过最多两次转折连通

连通情况有：

1.两点相邻

   直接返回true

2.两点不相邻

   进行横向搜索和纵向搜索

   a. 横向搜索

       求出两点分别从左右两边出发能到达的范围,然后再求出两个范围的交集

       如果没有交集,则返回false

       如果存在交集,则求交集中的维度是否存在一条直线连通,如图


       上面的A的范围为[1,5),下面的A的范围为[1,3),它们的交集为[1,3),只需判断(2,1)和(4,1), 或者(2,2)和(4,2)是否连通


       上面的A的范围为[4,5),下面的A的范围为[4,5),它们的交集为[4,5),只需判断(2,4)和(5,4)连通


    上面的A的范围为[5,7),下面的A的范围为[1,7),它们的交集为[5,7),只需判断(2,5)和(4,5), 或者(2,6)和(4,6)是否连通

   b. 纵向搜索 同理


   为了避免每次去判断两点是否连通,我使用了2个数组初始化后分别记录横向和纵向的空白直线

   struct line{

int begin;

        int end;

        line* pNext;

   }

   line* LineMap1[行数];

   line* LineMap2[列数];

   每次查询对应的行或列去找到相应的直线,只需判断该两点是否在这直线上即可,但每次删除点需要更新LineMap的值

   

   还有,像两个点在同一行的时候,只需纵向搜索

   相反,在同一列时,只需横向搜索.


   代码还不完整,不过基本实现了插入,删除,判断是否连接的函数了

   


#ifndef LMAP_H
#define LMAP_H

#define assert(a) ;
#include <iostream>
using namespace std;

typedef int vType;

struct lPoint{
	public:
		lPoint():m_bExist(false){}
		int m_nAbs;
		int m_nOrd;
		vType m_Value;
		bool m_bExist;
};

struct lLine{
	public:
		lLine():m_pNext(NULL){}
		lLine(int begin, int end):m_nBegin(begin),m_nEnd(end),m_pNext(NULL){}
		int m_nBegin;
		int m_nEnd;
		lLine* m_pNext;
};

const int MAX_ABS_DFL = 10;
const int MAX_ORD_DFL = 10;


class lMap{
	public:
		void Init(int max_abs = MAX_ABS_DFL, int max_ord = MAX_ORD_DFL);
		bool Insert(const int abs, const int ord, vType value);
		bool Erase(const int abs, const int ord);
		bool IsLinked(const int pointA_abs, const int pointA_ord, const int pointB_abs, const int pointB_ord);
		bool IsEmpty();
		bool IsDead();
		void PrintLineMap();
		void PrintMap();

	private:
		void _Insert(const int abs, const int ord, vType value);
		void _Erase(const int abs, const int ord);
		bool DoCheckLinked(const int pointA_abs, const int pointA_ord, const int pointB_abs, const int pointB_ord);
		bool IsLinkedInOneAbs(const int pointA_ord, const int pointB_ord, const int point_abs);
		bool IsLinkedInOneOrd(const int pointA_abs, const int pointB_abs, const int point_ord);
		bool IsLinkedInSomeAbs(const int pointA_ord, const int pointB_ord, const int point_abs_begin, const int point_abs_end);
		bool IsLinkedInSomeOrd(const int pointA_abs, const int pointB_abs, const int point_ord_begin, const int point_ord_end);
		bool _CheckLinkedInAbs(const int pointA_abs, const int pointA_ord, const int pointB_abs, const int pointB_ord);
		bool CheckLinkedInAbs(const int pointA_abs, const int pointA_ord, const int pointB_abs, const int pointB_ord);
		bool _CheckLinkedInOrd(const int pointA_abs, const int pointA_ord, const int pointB_abs, const int pointB_ord);
		bool CheckLinkedInOrd(const int pointA_abs, const int pointA_ord, const int pointB_abs, const int pointB_ord);
		void GetCommonRange(int rangeA_begin, int rangeA_end, int rangeB_begin, int rangeB_end, int& range_begin, int& range_end);


	private:
		lPoint* m_pMap;
		lLine** m_LineMap_abs;
		lLine** m_LineMap_ord;
		int m_nUsed;	
		int m_max_abs;
		int m_max_ord;
};

void lMap::PrintMap()
{
	cout << "map count:" << m_nUsed << endl;
	for(int i = 1; i < m_max_abs - 1; ++i)
	{
		for(int j = 1; j < m_max_ord - 1; ++j)
		{
			if(m_pMap[i * m_max_ord + j].m_bExist)
				cout << "| " << m_pMap[i * m_max_ord + j].m_Value << " ";
			else
				cout << "|   ";
			if(j == m_max_ord - 2)
				cout << "|";
		}
		cout << endl;
	}
}

void lMap::PrintLineMap()
{
	cout << "LineMap_abs:" << endl;
	for(int i = 0; i < m_max_abs; ++i)
	{
		cout << " < " << i << " > :";
		lLine* pLine = m_LineMap_abs[i];
		while(pLine != NULL)
		{
			cout << " (" << pLine->m_nBegin << ", " << pLine->m_nEnd << ") ";
			pLine = pLine->m_pNext;
		}
		cout << endl;
	}
	cout << endl << "LineMap_ord:" << endl;
	for(int i = 0; i < m_max_ord; ++i)
	{
		cout << " < " << i << " > :";
		lLine* pLine = m_LineMap_ord[i];
		while(pLine != NULL)
		{
			cout << " (" << pLine->m_nBegin << ", " << pLine->m_nEnd << ") ";
			pLine = pLine->m_pNext;
		}
		cout << endl;
	}
}

void lMap::Init(int max_abs, int max_ord)
{
	m_nUsed = 0;
	m_max_abs = max_abs + 2;
	m_max_ord = max_ord + 2;
	m_pMap = new lPoint[(m_max_abs) * (m_max_ord)];
	m_LineMap_abs = new lLine*[m_max_abs];
	for(int i = 0; i < m_max_abs; ++i)
		m_LineMap_abs[i] = new lLine(0, m_max_ord);
	m_LineMap_ord = new lLine*[m_max_ord];
	for(int i = 0; i < m_max_ord; ++i)
		m_LineMap_ord[i] = new lLine(0, m_max_abs);
}

bool lMap::IsEmpty()
{
	return m_nUsed == 0;
}

bool lMap::IsDead()
{
	return false;
}

bool lMap::IsLinked(const int pointA_abs, const int pointA_ord, const int pointB_abs, const int pointB_ord)
{
	if(!(m_pMap)[pointA_abs * m_max_ord + pointA_ord].m_bExist || !(m_pMap)[pointB_abs * m_max_ord + pointB_ord].m_bExist)
	{
		fprintf(stderr, "IsLinked: Point<%d, %d> or Point<%d, %d> not Exist!\n", pointA_abs, pointA_ord, pointB_abs, pointB_ord);
		return false;
	}
	if(pointA_abs == pointB_abs && pointA_ord == pointB_ord)
	{
		fprintf(stderr, "IsLinked: Point<%d, %d> and Point<%d, %d> are the same Point!\n", pointA_abs, pointA_ord, pointB_abs, pointB_ord);
		return false;
	}
	if((m_pMap)[pointA_abs * m_max_ord + pointA_ord].m_Value != (m_pMap)[pointB_abs * m_max_ord + pointB_ord].m_Value)
	{
		fprintf(stderr, "IsLinked: Point<%d, %d> and Point<%d, %d> are not the same Kind!\n", pointA_abs, pointA_ord, pointB_abs, pointB_ord);
		return false;
	}
	return DoCheckLinked(pointA_abs, pointA_ord, pointB_abs, pointB_ord);
}

bool lMap::Insert(const int abs, const int ord, vType value)
{
	if(m_pMap[abs * m_max_ord + ord].m_bExist)
	{
		fprintf(stderr, "Insert: Point<%d, %d> Exist!\n", abs, ord);
		return false;
	}
	_Insert(abs, ord, value);
	m_nUsed++;
	return true;
}

void lMap::_Insert(const int abs, const int ord, vType value)
{
	m_pMap[abs * m_max_ord + ord].m_Value = value;
	m_pMap[abs * m_max_ord + ord].m_bExist = true;
	lLine* pLine = m_LineMap_abs[abs];
	lLine* pTemp = pLine;
	while(pLine != NULL)
	{
		if(ord < pLine->m_nEnd)
		{
			if(pLine->m_nEnd - pLine->m_nBegin == 1)
			{
				pTemp->m_pNext = pLine->m_pNext;
				delete pLine;
			}
			else if(ord == pLine->m_nBegin)
				pLine->m_nBegin++;
			else if(ord == pLine->m_nEnd - 1)
				pLine->m_nEnd--;
			else
			{
				lLine* pNewLine = new lLine(ord + 1, pLine->m_nEnd);
				pLine->m_nEnd = ord;
				pNewLine->m_pNext = pLine->m_pNext;
				pLine->m_pNext = pNewLine;
			}
			break;
		}
		pTemp = pLine;
		pLine = pLine->m_pNext;
	}
	pLine = m_LineMap_ord[ord];
	pTemp = pLine;
	while(pLine != NULL)
	{
		if(abs < pLine->m_nEnd)
		{
			if(pLine->m_nEnd - pLine->m_nBegin == 1)
			{
				pTemp->m_pNext = pLine->m_pNext;
				delete pLine;
			}
			else if(abs == pLine->m_nBegin)
				pLine->m_nBegin++;
			else if(abs == pLine->m_nEnd - 1)
				pLine->m_nEnd--;
			else
			{
				lLine* pNewLine = new lLine(abs + 1, pLine->m_nEnd);
				pLine->m_nEnd = abs;
				pNewLine->m_pNext = pLine->m_pNext;
				pLine->m_pNext = pNewLine;
			}
			break;
		}
		pTemp = pLine;
		pLine = pLine->m_pNext;
	}
}

bool lMap::Erase(const int abs, const int ord)
{
	if(!(m_pMap)[abs * m_max_ord + ord].m_bExist)
	{
		fprintf(stderr, "Erase: Point<%d, %d> not Exist!\n", abs, ord);
		return false;
	}
	_Erase(abs, ord);
	m_nUsed--;
	return true;
}

void lMap::_Erase(const int abs, const int ord)
{
	m_pMap[abs * m_max_ord + ord].m_bExist = false;
	lLine* pLine = m_LineMap_abs[abs];
	lLine* pTemp = pLine;
	while(pLine != NULL)
	{
		if(ord < pLine->m_nBegin)
		{
			if(pLine->m_nBegin - pTemp->m_nEnd == 1)
			{
				pTemp->m_nEnd = pLine->m_nEnd;
				pTemp->m_pNext = pLine->m_pNext;
				delete pLine;
			}
			else if(ord == pLine->m_nBegin - 1)
				pLine->m_nBegin--;
			else if(ord == pTemp->m_nEnd)
				pTemp->m_nEnd++;
			else
			{
				lLine* pNewLine = new lLine(ord, ord + 1);
				pTemp->m_pNext = pNewLine;
				pNewLine->m_pNext = pLine;
			}
			break;
		}
		pTemp = pLine;
		pLine = pLine->m_pNext;
	}
	pLine = m_LineMap_ord[ord];
	pTemp = pLine;
	while(pLine)
	{
		if(abs < pLine->m_nBegin)
		{
			if(pLine->m_nBegin - pTemp->m_nEnd == 1)
			{
				pTemp->m_nEnd = pLine->m_nEnd;
				pTemp->m_pNext = pLine->m_pNext;
				delete pLine;
			}
			else if(abs == pLine->m_nBegin - 1)
				pLine->m_nBegin--;
			else if(abs == pTemp->m_nEnd)
				pTemp->m_nEnd++;
			else
			{
				lLine* pNewLine = new lLine(abs, abs + 1);
				pTemp->m_pNext = pNewLine;
				pNewLine->m_pNext = pLine;
			}
			break;
		}
		pTemp = pLine;
		pLine = pLine->m_pNext;
	}
}

bool lMap::DoCheckLinked(const int pointA_abs, const int pointA_ord, const int pointB_abs, const int pointB_ord)
{
	if(pointA_abs == pointB_abs)
	{
		if(pointB_ord - pointA_ord == 1 || pointA_ord - pointB_ord == 1)
			return true;
		else
			return CheckLinkedInOrd(pointA_abs, pointA_ord, pointB_abs, pointB_ord);
	}
	if(pointA_ord == pointB_ord)
	{
		if(pointA_abs - pointB_abs == 1 || pointB_abs - pointA_abs == 1)
			return true;
		else
			return CheckLinkedInAbs(pointA_abs, pointA_ord, pointB_abs, pointB_ord);
	}
	if(CheckLinkedInAbs(pointA_abs, pointA_ord, pointB_abs, pointB_ord))
		return true;
	else
		return CheckLinkedInOrd(pointA_abs, pointA_ord, pointB_abs, pointB_ord);
}

bool lMap::IsLinkedInOneAbs(const int pointA_ord, const int pointB_ord, const int point_abs)
{
	lLine* pLine = m_LineMap_abs[point_abs];
	while(pLine != NULL)
	{
		if(pLine->m_nEnd > pointA_ord)
		{
			if(pLine->m_nBegin <= pointA_ord && pLine->m_nEnd > pointB_ord)
				return true;
			else
				return false;
		}
		pLine = pLine->m_pNext;
	}
}

bool lMap::IsLinkedInOneOrd(const int pointA_abs, const int pointB_abs, const int point_ord)
{
	lLine* pLine = m_LineMap_abs[point_ord];
	while(pLine != NULL)
	{
		if(pLine->m_nEnd > pointA_abs)
		{
			if(pLine->m_nBegin <= pointA_abs && pLine->m_nEnd > pointB_abs)
				return true;
			else
				return false;
		}
		pLine = pLine->m_pNext;
	}
}

bool lMap::IsLinkedInSomeAbs(const int pointA_ord, const int pointB_ord, const int point_abs_begin, const int point_abs_end)
{
	for(int i = point_abs_begin; i < point_abs_end; ++i)
	{
		if(IsLinkedInOneAbs(pointA_ord, pointB_ord, i))
			return true;
	}
	return false;	
}

bool lMap::IsLinkedInSomeOrd(const int pointA_abs, const int pointB_abs, const int point_ord_begin, const int point_ord_end)
{
	for(int i = point_ord_begin; i < point_ord_end; ++i)
	{
		if(IsLinkedInOneOrd(pointA_abs, pointB_abs, i))
			return true;
	}
	return false;	
}

bool lMap::CheckLinkedInAbs(const int pointA_abs, const int pointA_ord, const int pointB_abs, const int pointB_ord)
{
	if(pointA_abs < pointB_abs)
		return _CheckLinkedInAbs(pointA_abs, pointA_ord, pointB_abs, pointB_ord);
	else
		return _CheckLinkedInAbs(pointB_abs, pointB_ord, pointA_abs, pointA_ord);
}

bool lMap::_CheckLinkedInAbs(const int pointA_abs, const int pointA_ord, const int pointB_abs, const int pointB_ord)
{
	int pointA_ord_begin = pointA_ord, pointA_ord_end = pointA_ord + 1;
	int	pointB_ord_begin = pointB_ord, pointB_ord_end = pointB_ord + 1;
	bool flag = false;
	lLine* pLine = m_LineMap_abs[pointA_abs];
	if(!m_pMap[pointA_abs * m_max_ord + pointA_ord - 1].m_bExist)
	{
		while(pLine != NULL)
		{
			if(pLine->m_nEnd == pointA_ord)
			{
				pointA_ord_begin = pLine->m_nBegin;
				flag = true;
				break;
			}
			pLine = pLine->m_pNext;
		}
		assert(pointA_ord_begin != pointA_ord);
	}
	if(!m_pMap[pointA_abs * m_max_ord + pointA_ord + 1].m_bExist)
	{
		if(flag)
		{
			pLine = pLine->m_pNext;
			assert(pLine != NULL && pointA_ord + 1 == pLine->m_nBegin);
			pointA_ord_end = pLine->m_nEnd;
			flag = false;
		}
		else
		{
			while(pLine != NULL)
			{
				if(pLine->m_nBegin == pointA_ord + 1){
					pointA_ord_end = pLine->m_nEnd;
					break;
				}
				pLine = pLine->m_pNext;
			}
			assert(pointA_ord_end != pointA_ord + 1);
		}
	}

	pLine = m_LineMap_abs[pointB_abs];
	if(!m_pMap[pointB_abs * m_max_ord + pointB_ord - 1].m_bExist)
	{
		while(pLine != NULL)
		{
			if(pLine->m_nEnd == pointB_ord)
			{
				pointB_ord_begin = pLine->m_nBegin;
				flag = true;
				break;
			}
			pLine = pLine->m_pNext;
		}
		assert(pointB_ord_begin != pointB_ord);
	}

	if(!m_pMap[pointB_abs * m_max_ord + pointB_ord + 1].m_bExist)
	{
		if(flag)
		{
			pLine = pLine->m_pNext;
			assert(pLine != NULL && pointB_ord + 1 == pLine->m_nBegin);
			pointB_ord_end = pLine->m_nEnd;
			flag = false;
		}
		else
		{
			while(pLine != NULL)
			{
				if(pLine->m_nBegin == pointB_ord + 1)
				{
					pointB_ord_end = pLine->m_nEnd;
					break;
				}
				pLine = pLine->m_pNext;
			}
			assert(pointB_ord_end != pointB_ord + 1);
		}
	}

	int point_ord_begin = 0, point_ord_end = 0;

	GetCommonRange(pointA_ord_begin, pointA_ord_end, pointB_ord_begin, pointB_ord_end, point_ord_begin, point_ord_end);

	if(point_ord_begin == point_ord_end)
		return false;

	return IsLinkedInSomeOrd(pointA_abs + 1, pointB_abs - 1, point_ord_begin , point_ord_end);
}

bool lMap::CheckLinkedInOrd(const int pointA_abs, const int pointA_ord, const int pointB_abs, const int pointB_ord)
{
	if(pointA_ord < pointB_ord)
		return _CheckLinkedInOrd(pointA_abs, pointA_ord, pointB_abs, pointB_ord);
	else
		return _CheckLinkedInOrd(pointB_abs, pointB_ord, pointA_abs, pointA_ord);
}

bool lMap::_CheckLinkedInOrd(const int pointA_abs, const int pointA_ord, const int pointB_abs, const int pointB_ord)
{
	int pointA_abs_begin = pointA_abs, pointA_abs_end = pointA_abs + 1;
	int	pointB_abs_begin = pointB_abs, pointB_abs_end = pointB_abs + 1;
	bool flag = false;
	lLine* pLine = m_LineMap_ord[pointA_ord];
	if(!m_pMap[(pointA_abs - 1) * m_max_ord + pointA_ord].m_bExist)
	{
		while(pLine != NULL)
		{
			if(pLine->m_nEnd == pointA_abs)
			{
				pointA_abs_begin = pLine->m_nBegin;
				flag = true;
				break;
			}
			pLine = pLine->m_pNext;
		}
		assert(pointA_abs_begin != pointA_abs);
	}
	if(!m_pMap[(pointA_abs + 1) * m_max_ord + pointA_ord].m_bExist)
	{
		if(flag)
		{
			pLine = pLine->m_pNext;
			assert(pLine != NULL && pointA_abs + 1 == pLine->m_nBegin);
			pointA_abs_end = pLine->m_nEnd;
			flag = false;
		}
		else
		{
			while(pLine != NULL)
			{
				if(pLine->m_nBegin == pointA_abs + 1){
					pointA_abs_end = pLine->m_nEnd;
					break;
				}
				pLine = pLine->m_pNext;
			}
			assert(pointA_abs_end != pointA_abs + 1);
		}
	}

	pLine = m_LineMap_ord[pointB_ord];
	if(!m_pMap[(pointB_abs - 1) * m_max_ord + pointB_ord].m_bExist)
	{
		while(pLine != NULL)
		{
			if(pLine->m_nEnd == pointB_abs)
			{
				pointB_abs_begin = pLine->m_nBegin;
				flag = true;
				break;
			}
			pLine = pLine->m_pNext;
		}
		assert(pointB_abs_begin != pointB_abs);
	}

	if(!m_pMap[(pointB_abs + 1) * m_max_ord + pointB_ord].m_bExist)
	{
		if(flag)
		{
			pLine = pLine->m_pNext;
			assert(pLine != NULL && pointB_abs + 1 == pLine->m_nBegin);
			pointB_abs_end = pLine->m_nEnd;
			flag = false;
		}
		else
		{
			while(pLine != NULL)
			{
				if(pLine->m_nBegin == pointB_abs + 1)
				{
					pointB_abs_end = pLine->m_nEnd;
					break;
				}
				pLine = pLine->m_pNext;
			}
			assert(pointB_abs_end != pointB_abs + 1);
		}
	}

	int point_abs_begin = 0, point_abs_end = 0;

	GetCommonRange(pointA_abs_begin, pointA_abs_end, pointB_abs_begin, pointB_abs_end, point_abs_begin, point_abs_end);

	if(point_abs_begin == point_abs_end)
		return false;

	return IsLinkedInSomeAbs(pointA_ord + 1, pointB_ord - 1, point_abs_begin , point_abs_end);
}

void lMap::GetCommonRange(int rangeA_begin, int rangeA_end, int rangeB_begin, int rangeB_end, int& range_begin, int& range_end)
{
	if(rangeA_begin < rangeB_begin)
	{
		if(rangeA_end <= rangeB_begin)
			return;
		else if(rangeB_end > rangeA_end)
		{
			range_begin = rangeB_begin;
			range_end = rangeA_end;
		}
		else
		{
			range_begin = rangeB_begin;
			range_end = rangeB_end;
		}
	}
	else
	{
		if(rangeB_end == rangeA_begin)
			return;
		else if(rangeB_end < rangeA_end)
		{
			range_begin = rangeA_begin;
			range_end = rangeB_end;
		}
		else
		{
			range_begin = rangeA_begin;
			range_end = rangeA_end;
		}
	}
}

#endif





  


_kelvin
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
连连看核心算法-易语言
06-13
连连看是一款广受欢迎的休闲消除类游戏，其核心算法是实现游戏逻辑的关键。在易语言这一编程环境中，我们可以构建连连看的游戏系统，并通过理解和实现核心算法来创建一个功能完备的游戏。下面将详细介绍连连看的核心...
java游戏开发-连连看2-实现游戏算法.doc
11-30
在Java游戏中开发连连看2，实现游戏算法是一个关键步骤，主要涉及到以下几个方面： 1. **游戏地图的表示**： 游戏地图通常通过二维数组来描述，这使得我们可以方便地处理每个位置上的元素。在这个例子中，选择了8...
一道算法题--连连看
sesiria的博客
01-30 962
群里的小伙伴发了一道在题目，判断一个棋盘上连连看的两个点是否可以消除。 原题目的点参考： http://acm.hdu.edu.cn/showproblem.php?pid=1175 思路：参考了这篇blog http://blog.csdn.net/artzok/article/details/51622782 大概意思，两个点最多通过两次折点相连分两种情况： 1）两
跟着BOY学习--史上最通俗易懂的连连看算法--cocos2d-x 环境下开发
郑州|boy的专栏
08-19 3506
兄弟们大家好，本来说好的是星期五出连连看的。不过被我给睡过去了，这些天一直都很瞌睡。不过睡眠好了做事的效率就高。希望兄弟们不要见怪。废话话不多说，首先我先说明说明一下《连连看地图布局之谜》 先上一张图给大家看看 当大家看到这张图片的时候会看到周围一圈对号，这个是我做标记用的，当然 真正的开发游戏过程中 这些对号是不存在的。我这里想给大家说明的是 假如我们的 地图是14*8的 那么其实真正的
连连看算法--cocos2d-x 环境下开发
TheClimb的池塘
01-16 501
先上一张图给大家看看 当大家看到这张图片的时候会看到周围一圈对号，这个是我做标记用的，当然 真正的开发游戏过程中 这些对号是不存在的。我这里想给大家说明的是 假如我们的 地图是14*8的 那么其实真正的地图布局应该是16*10 为什么要这么做呢 那是因为我们要让我们所有的路线都从我们规定的方格内经过，不能越界。如果你是14*8 的那么当四边上有可以连通的时候 就要做大量的判断来处理。那么
cocos2d-x 3.6 连连看算法
大掌教的Cocos Creator研究院
06-18 3760
我的原创博客：http://blog.csdn.net/dawn_moon好了，在开始讲连连看游戏场景之前先来讲讲连连看算法。连连看算法网上有很多，算法控首先想到的就是广度优先搜索，求出路径，然后求最小拐弯路径。这个算法可以，但是对没有学过算法的同学可能有点困难，我这里也不讲。我百度到一个比较通俗简便的算法，拿来用一下在开始讲算法之前，讲一下地图布局，假设 4*4 的棋盘。 初始化地图，将要加载的图
cocos2d-x3.6 连连看连通算法
大掌教的Cocos Creator研究院
06-26 3861
我的博客：http://blog.csdn.net/dawn_moon上一章讲了连连看游戏的主要逻辑，连通算法并有讲如何实现。这个连连看没有使用广度优先搜索算法，采用的是一种比较有技巧的算法，参见前面章节。大致分为几个部分： 直连通 两个点X轴扩展后可以直连通 两个点Y轴扩展后可以直连通 看下连接函数 bool GameScene::link(cocos2d::Vec2 v1, cocos2d::V
连连看 算法 总结
zebin的博客
06-30 3779
连连看 算法 总结 首先 连连看 是 一款休闲小游戏，非常适合锻炼算法，一门语言的入门 也是不错的， 首先是 匹配算法， 匹配函数需要 接受两个 位置 进行 取得数据进行匹配， 取得数据 就只是 访问数组，因此 只要先判断这两个值 是否一样就 可以进行下一步匹配。 检测函数 很简单 判断结果 是否相同， 是否越界 public 0拐点 分 垂直遍历，水平遍历 垂直遍历： 水平遍历： 1拐点： 一...
Java 实现连连看算法
Doge的技术小屋
06-03 1656
连连看是个经典的小游戏，规则是：两图案相同的方块在2折以内的线连接下可以消除。里面的算法还是非常有趣，今天来研究一下。 初始化棋盘 假设有一个8*8的棋盘，我们要将其扩充至10*10，为什么？因为这样外围的连接就可以不用越界了。 消除基本条件 判断是否具备消除的基本条件有 3 个 两个方块不能是同一个坐标 两个方块必须是同种类型(图案) 两个方块中不能有任何一个已经消除过的(消除过后的值用 mark 表示) // 判断是否具备消除的基本条件：两个方块不能是同一个坐标；两个方块必须是同种类型；两个方块中
c语言连连看算法,C++实现连连看消除算法
weixin_34820733的博客
05-21 235
#include#includeusing namespace std;bool CheckRemove(int x1,int y1,int x2,int y2,int rows,int cols,int ***pArray);void Swap(int &a,int &b);typedef struct{int x;int y;}point;int main(){int Num=...
小学期算法----广搜bfs
y77777ccc的博客
07-19 81
bfs
java游戏开发-连连看3-将算法与代码结合.doc
11-30
Java游戏开发连连看3-将算法与代码结合 在 Java 游戏开发中，连连看 3 是一种非常流行的游戏类型，本文将介绍如何将算法与代码结合，实现一个完整的连连看 3 游戏。 首先，我们需要设计一个合适的算法来实现游戏的...
连连看通杀算法思路及源码-易语言
06-11
先通过屏幕截图，获取在场的方块矩阵信息，再筛选相同的两个图标，计算两者能否相连，如果能连就点击两方块的坐标，并在方块矩阵中删去这两个元素，循环执行到所有元素都被删除。 最复杂的是计算能否相连，代码的...
连连看游戏----可行性分析报告
04-23
分析现有的连连看游戏处理逻辑，如图像配对算法、用户交互流程和数据存储结构，为新项目提供设计依据。 3.2 功能分析 比较现有游戏的功能特点，如游戏模式、排行榜、道具系统等，以确定新游戏的竞争优势。 4. ...
cf场+线性dp
xxx_jsu的博客
07-23 276
令a[1]=x[1]+1后我们可以让a[i+1]=a[i]+x[i]，但是这样的话数可能会比较小，所以我们可以累加a[i]，因为是mod所以只要不大于x[i+1]可以一直加下去。2.n>b-a>0这种情况我们还需要考虑到使用到的a，在此之前我们按照等差数列出售了(b-a)个，那么剩下n-(b-a)个我们则需要按照a来出售。采用双指针，一个指向a的头部，一个指向b的头部，两者开始进行匹配，若相同则b往下走一位，否则就终止。题目的第一问其实就是让我们求最长不上升子序列，第二问就是求有多少段最长不上升序列。
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 170
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 115
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
【算法】字典序最小的 01 字符串
2301_79728896的博客
07-24 176
每次只能交换相邻的两个字符,从前向后遍历字符,如果遇到10组合的要交换,同时k–,注意交换后的情况是前面有可能会出现10组合,因此k>0时要回退,直到(用while)前面没有10组合或k==0为止。小红有一个 01 字符串，她可以进行最多 k 次提作，每次操作可以交换相邻的两个字符，问可以得到的字典序最小的字符串是什么。第一行包含两个整数，n（1 < n < 10^5）和 k（1 < k < 10^9），表示字符串的长度和可以进行的操作次数。输出一个长度为 n 的字符串，表示字典序最小的字符串。
python连连看算法
04-21
以下是一个简单的Python连连看游戏的连接算法的示例[^1： ```python def is_valid_move(board, x1, y1, x2, y2 # 判断两个方块是否可以连接 if board[x1][y1] != board[x2][y2]: return False # 判断两个方块...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值