#include <iostream>
#include <map>
#include <list>
#include <deque>
#include <vector>
#include <string.h>
#define Param 1000000
using namespace std;
template <typename T>
class SafeQueue
{
public:
SafeQueue()
:m_size(0)
{
}
~SafeQueue()
{
}
T front()
{
if (m_queue.empty())
{
return T(0);
}
else
{
return m_queue.front();
}
}
T pop()
{
if (!m_queue.empty())
{
T ret = m_queue.front();
m_queue.pop_front();
--m_size;
return ret;
}
else
{
return T(0);
}
}
void push(T val)
{
m_queue.push_back(val);
++m_size;
}
long size()
{
return m_size;
}
private:
list <T> m_queue;
int m_size;
};
template<typename T>
class ObjectPool_
{
public:
ObjectPool_( int initCount, int maxCount)
: m_initCount(initCount), m_maxCount(maxCount)
{
for ( int i = 0; i != initCount; ++i)
{
push(new T);
}
}
~ObjectPool_()
{
T *pVal = NULL;
while ((pVal = m_pool.pop()) != NULL)
{
delete pVal;
}
}
T* pop()
{
T *pVal = m_pool.pop();
if (pVal == NULL)
{
pVal = new T;
}
pVal->reset();
return pVal;
}
void push(T *pVal)
{
if (pVal != NULL)
{
pVal->reset();
m_pool.push(pVal);
if (m_pool.size() > m_maxCount)
{
delete m_pool.pop();
}
}
}
private:
SafeQueue<T*> m_pool;
int m_initCount;
int m_maxCount;
};
struct DeliverInfo
{
void Init(int &_playerlv,int &_quanliy,int &_battleforce,int &_ID)
{
playerlv = _playerlv;
quanliy = _quanliy;
battleforce = _battleforce;
ID = _ID;
}
void reset()
{
memset(this,0,sizeof(DeliverInfo));
}
int playerlv;
int quanliy;
int battleforce;
int ID;
};
ObjectPool_<DeliverInfo> m_DeliverPool(3000,4000);
map<int, DeliverInfo*> m_AllDeliverData;
static const int DeliverDeltaBattleForce = 20000; //战斗力 间隔
static const int DeliverDeltaLv = 20; //等级 间隔
static const int DeliverMaxLvSize = 3;
static const int DeliverMaxSize = 255;
static const int DeliverMaxDevierCount = 255;
class Test
{
public:
~Test()
{
m_AllDeliverData.clear();
}
Test()
{
for(int i = 0; i < DeliverMaxSize; i++)
{
DequeInfo info;
FastFind.push_back(info);
}
for(int i = 0; i < DeliverMaxSize; i++)
{
DequeInfo info;
FastFindHigh.push_back(info);
}
}
struct DequeInfo
{
DequeInfo()
{
index = 0;
}
deque<DeliverInfo*> deq;
int index;
void Add(DeliverInfo* i)
{
deq.push_back(i);
}
bool Remove(DeliverInfo* i)
{
bool isFind = false;
for (deque<DeliverInfo*>::iterator it = deq.begin(); it != deq.end(); it++)
{
if (*it == i)
{
it = deq.erase(it);
isFind = true;
}
}
return isFind;
}
int GetSize()
{
return deq.size();
}
int Random()
{
//index在于 每次进行刷新镖车匹配对应时候,保证不一致!
if (deq.size() == 0)
return -1;
if (index >= (int)deq.size())
{
index = 0;
int id = deq[index]->ID;
index++;
return id;
}
else
{
int id = deq[index]->ID;
index ++;
return id;
}
}
};
vector<DequeInfo> FastFind; //普通镖车 按战斗力 分布
vector<DequeInfo> FastFindHigh; //高级镖车 按玩家等级 分布
int m_DeliverId[4]; //运送ID时间
void SetDeliverID( int i, int id)
{
if (i > 4 || i < 0)
return;
m_DeliverId[i] = id;
}
// 快速查找队列中 添加 对应的镖车
int GetBattleForceIndex(int battleForce)
{
int x = battleForce / DeliverDeltaBattleForce;
if ( x >= DeliverMaxSize)
x = DeliverMaxSize -1;
return x;
}
// 快速查找队列中 添加 对应的镖车
void AddInFastFind(DeliverInfo* info)
{
if (info != NULL)
{
//通过配置的机器人数据,品质判断如果品质不等于4,就通过战斗力来匹配推荐数据,如果品质等于4就通过等级来匹配数据
if (info->quanliy != 4)
{
int x = GetBattleForceIndex(info->battleforce);
FastFind[x].Add(info);
}
else
{
int x = GetLevelIndex(info->playerlv);
FastFindHigh[x].Add(info);
}
}
}
int GetLevelIndex(int lv)
{
int x = lv / DeliverDeltaLv;
if ( x >= DeliverMaxLvSize)
x = DeliverMaxLvSize -1;
return x;
}
void RandomDevierID_Function(int x, int deltaValue, int type, vector<int>& vec, int needSize, int expertID)
{
if (type == 0)
{
if (x < 0 || x > DeliverMaxSize)
return;
int size = FastFind[x].GetSize();
if (size <= 0)
{
RandomDevierID_Function1(deltaValue, x, type, vec, needSize, expertID);
}
else
{
for (int i = 0; i < size; i++)
{
int getid = FastFind[x].Random();
if (getid != expertID)
vec.push_back(getid);
if (vec.size() >= needSize)
break;
}
//如果取完之后 仍然小于 要取得数量,继续递归
if (vec.size() < needSize)
{
RandomDevierID_Function1(deltaValue, x, type, vec, needSize, expertID);
}
}
}
else if (type == 1)
{
if ( x < 0 || x > DeliverMaxLvSize)
return;
int size = FastFindHigh[x].GetSize();
if (size <= 0)//这个格子没有数据 , 直接进入递归
{
RandomDevierID_Function1(deltaValue, x, type, vec, needSize, expertID);
}
else
{
for (int i = 0; i < size; i++)
{
int getid = FastFindHigh[x].Random();
if (getid != expertID)
vec.push_back(getid);
if (vec.size() >= needSize)
break;
}
//如果取完之后 仍然小于 要取得数量,继续递归
if (vec.size()< needSize)
{
RandomDevierID_Function1(deltaValue, x, type, vec, needSize, expertID);
}
}
}
}
//递归辅助函数, 越来越小和越来越大
void RandomDevierID_Function1(int deltaValue, int x, int type, vector<int>& vec, int needSize, int expertID)
{
if (deltaValue == 0)
{
RandomDevierID_Function(x , 1, type, vec, needSize, expertID);
RandomDevierID_Function(x-1 , -1, type, vec, needSize, expertID);
}
else if (deltaValue == 1)
{
RandomDevierID_Function(x+1 , 1, type, vec, needSize, expertID);
}
else if (deltaValue == -1)
{
RandomDevierID_Function(x-1 , -1, type, vec, needSize, expertID);
}
}
// 快速查找队列中 移除 对应的镖车
bool RemoveInFastFind(DeliverInfo* info)
{
if (info != NULL)
{
if (info->quanliy != 4)
{
int x = info->battleforce / DeliverDeltaBattleForce;
if ( x >= DeliverMaxSize)
x = DeliverMaxSize -1;
if(x < 0)
x = 0;
for (deque<DeliverInfo*>::iterator it = FastFind[x].deq.begin(); it != FastFind[x].deq.end(); it++)
{
if (*it == info)
{
it = FastFind[x].deq.erase(it);
return true;
}
}
}
else
{
int x = info->playerlv / DeliverDeltaLv;
if ( x >= DeliverMaxLvSize)
x = DeliverMaxLvSize -1;
for (deque<DeliverInfo*>::iterator it = FastFindHigh[x].deq.begin(); it != FastFindHigh[x].deq.end(); it++)
{
if (*it == info)
{
it = FastFindHigh[x].deq.erase(it);
return true;
}
}
}
}
return false;
}
void RandomDevierID(int ID)
{
vector<int> ids;//存储于玩家自身相近的镖车数据,用于展示在前台界面显示
int expertID = ID;//在匹配数据的时候,加入玩家自身的ID,避免匹配到自己的数据
int level = Param;
int x = GetLevelIndex(level);
RandomDevierID_Function(x, 0, 1, ids, 1, expertID);
int battleForce = Param;
int y = GetBattleForceIndex(battleForce);
if (ids.size() == 1)
RandomDevierID_Function(y, 0, 0, ids, 3, expertID);
else
RandomDevierID_Function(y, 0, 0, ids, 4, expertID);
for (size_t i = 0; i < ids.size(); i++)
{
SetDeliverID(i, ids[i]);
}
}
void Begin()
{
for(int i = 1000000; i < 1002000; i++)
{
DeliverInfo *deliver = m_DeliverPool.pop();//启动进程时候,已经开辟出了3000个对象,此时从list这个结构冲,拉出一个数据
deliver->Init(i,i,i,i);
m_AllDeliverData.insert(make_pair(i,deliver));//把所有的数据加入到一个map中,这个目的在于镖车数据在结束(通过time判定)查找的对应镖车ID
AddInFastFind(deliver);//将数据加入到一个vector<> + deque结构当中,vecotr存储区间范围,deque存储具体数据, 比如镖车数据为60 61 62 63 当我除以/2 都在30这个区间!! 那么vector[30]中就存储60 61 62 63 的数据
}
}
void End(DeliverInfo* info)
{
m_DeliverPool.push(info);
}
DeliverInfo* GetDeliverInfo(int id)
{
map<int, DeliverInfo*>::iterator it =m_AllDeliverData.find(id);
if (it != m_AllDeliverData.end())
return it->second;
return NULL;
}
};
int main()
{
Test test;
test.Begin(); //开始new出2000个机器人数据!!!
DeliverInfo *data = test.GetDeliverInfo(Param);//测试下镖车中有没有100000这个ID数据
if(data == NULL)
return 0;
test.RandomDevierID(data->ID);
for(int i = 0 ; i < 4;i++)
{
cout<<test.m_DeliverId[i]<<endl;
}
//在镖车数据中删除玩家数据,并回收到对象池
for(map<int, DeliverInfo*>::iterator it = m_AllDeliverData.begin(); it != m_AllDeliverData.end(); ++it)
{
test.RemoveInFastFind(it->second);
test.End(it->second);
it = m_AllDeliverData.erase(it);//erase一定要注意it =
break;
}
//在进程结束时候手动delete数据
for(map<int, DeliverInfo*>::iterator it = m_AllDeliverData.begin(); it != m_AllDeliverData.end(); ++it)
{
delete it->second;
}
//进程结束,对象池析构函数自动释放内存
return 0;
}
#include <map>
#include <list>
#include <deque>
#include <vector>
#include <string.h>
#define Param 1000000
using namespace std;
template <typename T>
class SafeQueue
{
public:
SafeQueue()
:m_size(0)
{
}
~SafeQueue()
{
}
T front()
{
if (m_queue.empty())
{
return T(0);
}
else
{
return m_queue.front();
}
}
T pop()
{
if (!m_queue.empty())
{
T ret = m_queue.front();
m_queue.pop_front();
--m_size;
return ret;
}
else
{
return T(0);
}
}
void push(T val)
{
m_queue.push_back(val);
++m_size;
}
long size()
{
return m_size;
}
private:
list <T> m_queue;
int m_size;
};
template<typename T>
class ObjectPool_
{
public:
ObjectPool_( int initCount, int maxCount)
: m_initCount(initCount), m_maxCount(maxCount)
{
for ( int i = 0; i != initCount; ++i)
{
push(new T);
}
}
~ObjectPool_()
{
T *pVal = NULL;
while ((pVal = m_pool.pop()) != NULL)
{
delete pVal;
}
}
T* pop()
{
T *pVal = m_pool.pop();
if (pVal == NULL)
{
pVal = new T;
}
pVal->reset();
return pVal;
}
void push(T *pVal)
{
if (pVal != NULL)
{
pVal->reset();
m_pool.push(pVal);
if (m_pool.size() > m_maxCount)
{
delete m_pool.pop();
}
}
}
private:
SafeQueue<T*> m_pool;
int m_initCount;
int m_maxCount;
};
struct DeliverInfo
{
void Init(int &_playerlv,int &_quanliy,int &_battleforce,int &_ID)
{
playerlv = _playerlv;
quanliy = _quanliy;
battleforce = _battleforce;
ID = _ID;
}
void reset()
{
memset(this,0,sizeof(DeliverInfo));
}
int playerlv;
int quanliy;
int battleforce;
int ID;
};
ObjectPool_<DeliverInfo> m_DeliverPool(3000,4000);
map<int, DeliverInfo*> m_AllDeliverData;
static const int DeliverDeltaBattleForce = 20000; //战斗力 间隔
static const int DeliverDeltaLv = 20; //等级 间隔
static const int DeliverMaxLvSize = 3;
static const int DeliverMaxSize = 255;
static const int DeliverMaxDevierCount = 255;
class Test
{
public:
~Test()
{
m_AllDeliverData.clear();
}
Test()
{
for(int i = 0; i < DeliverMaxSize; i++)
{
DequeInfo info;
FastFind.push_back(info);
}
for(int i = 0; i < DeliverMaxSize; i++)
{
DequeInfo info;
FastFindHigh.push_back(info);
}
}
struct DequeInfo
{
DequeInfo()
{
index = 0;
}
deque<DeliverInfo*> deq;
int index;
void Add(DeliverInfo* i)
{
deq.push_back(i);
}
bool Remove(DeliverInfo* i)
{
bool isFind = false;
for (deque<DeliverInfo*>::iterator it = deq.begin(); it != deq.end(); it++)
{
if (*it == i)
{
it = deq.erase(it);
isFind = true;
}
}
return isFind;
}
int GetSize()
{
return deq.size();
}
int Random()
{
//index在于 每次进行刷新镖车匹配对应时候,保证不一致!
if (deq.size() == 0)
return -1;
if (index >= (int)deq.size())
{
index = 0;
int id = deq[index]->ID;
index++;
return id;
}
else
{
int id = deq[index]->ID;
index ++;
return id;
}
}
};
vector<DequeInfo> FastFind; //普通镖车 按战斗力 分布
vector<DequeInfo> FastFindHigh; //高级镖车 按玩家等级 分布
int m_DeliverId[4]; //运送ID时间
void SetDeliverID( int i, int id)
{
if (i > 4 || i < 0)
return;
m_DeliverId[i] = id;
}
// 快速查找队列中 添加 对应的镖车
int GetBattleForceIndex(int battleForce)
{
int x = battleForce / DeliverDeltaBattleForce;
if ( x >= DeliverMaxSize)
x = DeliverMaxSize -1;
return x;
}
// 快速查找队列中 添加 对应的镖车
void AddInFastFind(DeliverInfo* info)
{
if (info != NULL)
{
//通过配置的机器人数据,品质判断如果品质不等于4,就通过战斗力来匹配推荐数据,如果品质等于4就通过等级来匹配数据
if (info->quanliy != 4)
{
int x = GetBattleForceIndex(info->battleforce);
FastFind[x].Add(info);
}
else
{
int x = GetLevelIndex(info->playerlv);
FastFindHigh[x].Add(info);
}
}
}
int GetLevelIndex(int lv)
{
int x = lv / DeliverDeltaLv;
if ( x >= DeliverMaxLvSize)
x = DeliverMaxLvSize -1;
return x;
}
void RandomDevierID_Function(int x, int deltaValue, int type, vector<int>& vec, int needSize, int expertID)
{
if (type == 0)
{
if (x < 0 || x > DeliverMaxSize)
return;
int size = FastFind[x].GetSize();
if (size <= 0)
{
RandomDevierID_Function1(deltaValue, x, type, vec, needSize, expertID);
}
else
{
for (int i = 0; i < size; i++)
{
int getid = FastFind[x].Random();
if (getid != expertID)
vec.push_back(getid);
if (vec.size() >= needSize)
break;
}
//如果取完之后 仍然小于 要取得数量,继续递归
if (vec.size() < needSize)
{
RandomDevierID_Function1(deltaValue, x, type, vec, needSize, expertID);
}
}
}
else if (type == 1)
{
if ( x < 0 || x > DeliverMaxLvSize)
return;
int size = FastFindHigh[x].GetSize();
if (size <= 0)//这个格子没有数据 , 直接进入递归
{
RandomDevierID_Function1(deltaValue, x, type, vec, needSize, expertID);
}
else
{
for (int i = 0; i < size; i++)
{
int getid = FastFindHigh[x].Random();
if (getid != expertID)
vec.push_back(getid);
if (vec.size() >= needSize)
break;
}
//如果取完之后 仍然小于 要取得数量,继续递归
if (vec.size()< needSize)
{
RandomDevierID_Function1(deltaValue, x, type, vec, needSize, expertID);
}
}
}
}
//递归辅助函数, 越来越小和越来越大
void RandomDevierID_Function1(int deltaValue, int x, int type, vector<int>& vec, int needSize, int expertID)
{
if (deltaValue == 0)
{
RandomDevierID_Function(x , 1, type, vec, needSize, expertID);
RandomDevierID_Function(x-1 , -1, type, vec, needSize, expertID);
}
else if (deltaValue == 1)
{
RandomDevierID_Function(x+1 , 1, type, vec, needSize, expertID);
}
else if (deltaValue == -1)
{
RandomDevierID_Function(x-1 , -1, type, vec, needSize, expertID);
}
}
// 快速查找队列中 移除 对应的镖车
bool RemoveInFastFind(DeliverInfo* info)
{
if (info != NULL)
{
if (info->quanliy != 4)
{
int x = info->battleforce / DeliverDeltaBattleForce;
if ( x >= DeliverMaxSize)
x = DeliverMaxSize -1;
if(x < 0)
x = 0;
for (deque<DeliverInfo*>::iterator it = FastFind[x].deq.begin(); it != FastFind[x].deq.end(); it++)
{
if (*it == info)
{
it = FastFind[x].deq.erase(it);
return true;
}
}
}
else
{
int x = info->playerlv / DeliverDeltaLv;
if ( x >= DeliverMaxLvSize)
x = DeliverMaxLvSize -1;
for (deque<DeliverInfo*>::iterator it = FastFindHigh[x].deq.begin(); it != FastFindHigh[x].deq.end(); it++)
{
if (*it == info)
{
it = FastFindHigh[x].deq.erase(it);
return true;
}
}
}
}
return false;
}
void RandomDevierID(int ID)
{
vector<int> ids;//存储于玩家自身相近的镖车数据,用于展示在前台界面显示
int expertID = ID;//在匹配数据的时候,加入玩家自身的ID,避免匹配到自己的数据
int level = Param;
int x = GetLevelIndex(level);
RandomDevierID_Function(x, 0, 1, ids, 1, expertID);
int battleForce = Param;
int y = GetBattleForceIndex(battleForce);
if (ids.size() == 1)
RandomDevierID_Function(y, 0, 0, ids, 3, expertID);
else
RandomDevierID_Function(y, 0, 0, ids, 4, expertID);
for (size_t i = 0; i < ids.size(); i++)
{
SetDeliverID(i, ids[i]);
}
}
void Begin()
{
for(int i = 1000000; i < 1002000; i++)
{
DeliverInfo *deliver = m_DeliverPool.pop();//启动进程时候,已经开辟出了3000个对象,此时从list这个结构冲,拉出一个数据
deliver->Init(i,i,i,i);
m_AllDeliverData.insert(make_pair(i,deliver));//把所有的数据加入到一个map中,这个目的在于镖车数据在结束(通过time判定)查找的对应镖车ID
AddInFastFind(deliver);//将数据加入到一个vector<> + deque结构当中,vecotr存储区间范围,deque存储具体数据, 比如镖车数据为60 61 62 63 当我除以/2 都在30这个区间!! 那么vector[30]中就存储60 61 62 63 的数据
}
}
void End(DeliverInfo* info)
{
m_DeliverPool.push(info);
}
DeliverInfo* GetDeliverInfo(int id)
{
map<int, DeliverInfo*>::iterator it =m_AllDeliverData.find(id);
if (it != m_AllDeliverData.end())
return it->second;
return NULL;
}
};
int main()
{
Test test;
test.Begin(); //开始new出2000个机器人数据!!!
DeliverInfo *data = test.GetDeliverInfo(Param);//测试下镖车中有没有100000这个ID数据
if(data == NULL)
return 0;
test.RandomDevierID(data->ID);
for(int i = 0 ; i < 4;i++)
{
cout<<test.m_DeliverId[i]<<endl;
}
//在镖车数据中删除玩家数据,并回收到对象池
for(map<int, DeliverInfo*>::iterator it = m_AllDeliverData.begin(); it != m_AllDeliverData.end(); ++it)
{
test.RemoveInFastFind(it->second);
test.End(it->second);
it = m_AllDeliverData.erase(it);//erase一定要注意it =
break;
}
//在进程结束时候手动delete数据
for(map<int, DeliverInfo*>::iterator it = m_AllDeliverData.begin(); it != m_AllDeliverData.end(); ++it)
{
delete it->second;
}
//进程结束,对象池析构函数自动释放内存
return 0;
}