通向码农的道路(运镖系统，推荐算法)

#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;

}