Untitled

#define MAX_USER_ID 100001
#define MAX_NEWS 50001
#define MAX_SECTION 10
typedef struct News
{
    int Score;
    int Section;
    int Id;
    int HeapPos;
    int ClubbedScore;
};
News news[MAX_NEWS];
News* newsPtr[MAX_NEWS];
News* HeapArray[MAX_SECTION][MAX_NEWS];
int HeapSize[MAX_SECTION];
int UserIDMap[MAX_USER_ID];
void init()
{
    //register int n = 2500100001;
    for (register int i = 0; i < MAX_SECTION; i++)
    {
        HeapSize[i] = 0;
    }
    for (register int i = 0; i < MAX_USER_ID; i++)
    {
        UserIDMap[i] = -1;
    }
}
  
  
void HeapifyUp(News* heapArray[], register int section, register int upPos)
{
    register int Child = upPos;
    register int Parent = (Child - 1) / 2;
    register int tempPos;
    News* tempPtr;
    while (heapArray[Parent]->ClubbedScore < heapArray[Child]->ClubbedScore)
    {
        tempPos = heapArray[Parent]->HeapPos;
        heapArray[Parent]->HeapPos = heapArray[Child]->HeapPos;
        heapArray[Child]->HeapPos = tempPos;
  
  
        tempPtr = heapArray[Parent];
        heapArray[Parent] = heapArray[Child];
        heapArray[Child] = tempPtr;
        Child = Parent;
        Parent = (Child - 1) / 2;
    }
}
void HeapifyDown(News* heapArray[], register int section, register int DownPos)
{
    register int Size = HeapSize[section];
    register int Parent = DownPos;
    register int Max;
    register int tempPos;
    News* tempPtr;
    register int LC;
    register int RC;
    while (1)
    {
        LC = 2 * Parent + 1;
        RC = LC + 1;
        Max = Parent;
        if (LC < Size && (heapArray[Max]->ClubbedScore < heapArray[LC]->ClubbedScore ))
        {
            Max = LC;
        }
  
  
        if (RC < Size && (heapArray[Max]->ClubbedScore < heapArray[RC]->ClubbedScore ))
        {
            Max = RC;
        }
        if (Max != Parent)
        {
            tempPos = heapArray[Parent]->HeapPos;
            heapArray[Parent]->HeapPos = heapArray[Max]->HeapPos;
            heapArray[Max]->HeapPos = tempPos;
  
  
            tempPtr = heapArray[Parent];
            heapArray[Parent] = heapArray[Max];
            heapArray[Max] = tempPtr;
            Parent = Max;
        }
        else
        {
            break;
        }
    }
}
void Insert(News* heapArray[], News* ptr, register int section)
{
    register int size = HeapSize[section];
    ptr->HeapPos = HeapSize[section];
    heapArray[size] = ptr;
    if (size == 0)
    {
        HeapSize[section]++;
        return;
    }
    HeapifyUp(heapArray, section, size);
    HeapSize[section]++;
}
void Erase(News* heapArray[], register int section, register int pos)
{
    register int size = --HeapSize[section];
    heapArray[size]->HeapPos = heapArray[pos]->HeapPos;
    heapArray[pos] = heapArray[size];
    if (size == 1) return;
    HeapifyUp(heapArray, section, pos);
    HeapifyDown(heapArray, section, pos);
}
void addNews(register int sec, register int id)
{
    //prregister intf("addNews sec = %d id = %d\n", sec, id);
    News* ptr = &news[id];
    ptr->Id = id;
    ptr->Score = 0;
    ptr->ClubbedScore = id;
    ptr->Section = sec;
    newsPtr[id] = ptr;
    Insert(HeapArray[sec], ptr, sec);
}
  
  
void eraseNews(register int id)
{
    ////prregister intf("eraseNews id = %d\n", id);
    News* ptr = newsPtr[id];
    register int sec = ptr->Section;
    Erase(HeapArray[sec], sec, ptr->HeapPos);
}
  
  
void readNews(register int uid, register int id)
{
    News* ptr = newsPtr[id];
    register int section = ptr->Section;
    //prregister intf("readNews sec = %d id = %d uid = %d\n", section, id, uid);
    UserIDMap[uid] = section;
    ptr->Score++;
    ptr->ClubbedScore = ptr->Score * MAX_NEWS + id;
    HeapifyUp(HeapArray[section], section, ptr->HeapPos);
    HeapifyDown(HeapArray[section], section, ptr->HeapPos);
}
  
  
void changeSection(register int id, register int sec)
{
    News* ptr = &news[id];
    eraseNews(id);
    //prregister intf("changeSection from sec = %d to sec = %d id = %d \n", ptr->Section, sec, id);
    ptr->Section = sec;    
    Insert(HeapArray[sec], ptr, sec);
}
  
  
typedef struct Info
{
    int sec;
    int id;
    int pos;
};
int getList(register int uid, register int mList[])
{
    //prregister intf("getList uid = %d \n", uid);
    Info info[21];
    Info temp;
    register int CurrentIndex = 0;
    register int counter = 0;
    Info* currentInfo;
    for (register int i = 0; i < 10; i++)
    {
        if (HeapSize[i] > 0)
        {
            currentInfo = &info[CurrentIndex];
            currentInfo->id = HeapArray[i][0]->Id;
            currentInfo->pos = 0;
            currentInfo->sec = i;
            CurrentIndex++;
        }
    }
    register int UserSec = UserIDMap[uid];
    for (register int i = 0; i < 10; i++)
    {
        register int index = -1;
        register int maxScore = -65535;
        register int id = -1;
        register int score;
        for (register int j = 0; j < CurrentIndex; j++)
        {
            score = HeapArray[info[j].sec][info[j].pos]->ClubbedScore;
            if (UserSec == info[j].sec)
            {
                score += 10 * MAX_NEWS;
            }
            if (score > maxScore )
            {
                index = j;
                maxScore = score;                
            }
        }
        if (index == -1) break;
        id = info[index].id;
        CurrentIndex--;
        temp = info[index];
        info[index] = info[CurrentIndex];
        mList[counter++] = id;
        register int LC = 2 * temp.pos + 1;
        register int RC = LC + 1;
        if (RC < HeapSize[temp.sec])
        {
            currentInfo = &info[CurrentIndex];
            currentInfo->id = HeapArray[temp.sec][RC]->Id;
            currentInfo->pos = RC;
            currentInfo->sec = temp.sec;
            CurrentIndex++;
        }
        if (LC < HeapSize[temp.sec])
        {
            currentInfo = &info[CurrentIndex];
            currentInfo->id = HeapArray[temp.sec][LC]->Id;
            currentInfo->pos = LC;
            currentInfo->sec = temp.sec;
            CurrentIndex++;
        }
    }
    return counter;
}