poj 1193

地址：http://poj.org/problem?id=1193

题意：中文，模拟进程调度。

mark：大模拟！手写堆+链表爽到爆！很考验基本功！写完竟然TLE结果发现是链表写搓了！

思路大概是，内存用链表来组织，整个程序建立一个事件队列来驱动，事件队列是优先队列，按时间从小到大排序。一开始把所有任务丢到事件队列里；等待队列队首的任务在每次release一段内存的时候判断是否run。

比较容易错的地方有：

1.release了一段内存后从等待队列取任务判断是否能执行时，若第一个等待队列的任务能执行，要继续循环判断等待队列里下一个任务是否能执行……

3
1 3 2
2 1 1
2 1 1
0 0 0

输出

4

2

2.要完全释放当前时间点的所有内存才可以判断等待队列里的任务运行情况。

11
1 4 1
1 4 1
1 4 1
1 1 1
1 6 1
0 0 0

输出

3

2

 

PS：不存在P[i] = 0的情况。

 

代码：

# include <stdio.h>
# include <stdlib.h>


#define SWAP(a,b) (tmp=a, a=b, b=tmp)


int T[10010], M[10010], P[10010] ;
int type[10010] ;
int ans1, ans2 ;

/*message queue --- priority queue*/
int msgQueue[10010], mqlen ;
/*message queue end*/


/*wait list*/
int wait_rear, wait_front ;
int wait_list[10010] ;
/*wait list end*/


/*memory alloc*/
int mem[10010] ;
/*memory alloc end*/


int cmp (int a, int b)
{
    if (T[a] != T[b]) return T[a] - T[b] ;
    if (type[b] != type[a]) return type[b] - type[a] ;
    return a-b ;
    //return mem[b] - mem[a] ;
//    return type[b]-type[a] ;
}


void imq(int x, int t)
{
    int p = mqlen, q = p/2, tmp ;
    type[x] = t ;
    msgQueue[mqlen++] = x ;
    while (q)
        if (cmp(msgQueue[p],msgQueue[q])<0)
            SWAP(msgQueue[p],msgQueue[q]), p=q, q/=2 ;
        else break ;
}


void mqheapify(int x)
{
    int p = x, q, tmp ;
    q = x*2 ;
    if (q < mqlen && cmp(msgQueue[q], msgQueue[p])<0) p = q ;
    q = x*2+1 ;
    if (q < mqlen && cmp(msgQueue[q], msgQueue[p])<0) p = q ;
    if (p != x)
    {
        SWAP(msgQueue[p], msgQueue[x]) ;
        mqheapify (p) ;
    }
}


int dmq()
{
    int rtn = msgQueue[1], tmp ;
    mqlen-- ;
    SWAP(msgQueue[1], msgQueue[mqlen]) ;
    mqheapify (1) ;
    return rtn ;
}


typedef struct MEM_NODE{
    int hi, lo ;
    MEM_NODE *prev, *next ;
}MEM_NODE ;


MEM_NODE head ;


void mem_init(int size){
    MEM_NODE *p = (MEM_NODE*)malloc(sizeof (MEM_NODE)) ;
    p->hi = size-1, p->lo = 0, p->prev = &head, p->next = NULL ;
    head.next = p ;
}

void mem_delete(MEM_NODE* p)
{
    if (p->next != NULL){
        mem_delete(p->next) ;
        p->next = NULL ;
    }
    free (p) ;
}


int mem_find(int size)
{
    MEM_NODE* p = NULL ;
    for (p = head.next ; p ; p = p->next)
    {
        if (p->hi - p->lo + 1 >= size)
            return p->lo ;
    }
    return -1 ;
}


void mem_delete_node(MEM_NODE *p)
{
    MEM_NODE *prev = p->prev, *next = p->next ;
    //if (prev != &head) 
    prev->next = next ;
    if (next != NULL) next->prev = prev ;
    free (p) ;
}


void mem_alloc(int lo, int size)
{
    MEM_NODE* p = NULL ;
    for (p = head.next ; p ; p = p->next)
        if (p->lo == lo) {
            p->lo += size ;
            break ;
        }
    if (p->lo > p->hi) mem_delete_node(p) ;
}


MEM_NODE* mem_merge(MEM_NODE* p)
{
    MEM_NODE*q = p->next ;
    if (q == NULL) return p ;
    if (p->hi+1 != q->lo) return q ;
    p->hi = q->hi;
    mem_delete_node(q) ;
    return p ;
}


void mem_release (int lo, int size)
{
    MEM_NODE *p = NULL, *q = NULL ;
    
    q = &head, p = q->next ;
    while (p != NULL && p->hi < lo)
        q = p, p = p->next ;
    p = (MEM_NODE*)malloc(sizeof(MEM_NODE)) ;
    p->lo = lo, p->hi = lo+size-1 ;
    p->next = q->next ;
    q->next = p ;
    p->prev = q ;
    if (p->next != NULL) p->next->prev = p ;
    if (q != &head) p = mem_merge(q) ;
    mem_merge(p) ;
}



int try_alloc(int x)
{
    int mem_num = mem_find(M[x]) ;
    if (mem_num == -1) return 0 ;
    mem[x] = mem_num ;
    mem_alloc (mem_num, M[x]) ;
    T[x] += P[x] ;
    imq (x, 1) ;
    return 1 ;
}


void alloc(int x)
{
    if (!try_alloc(x))
    {
        wait_list[wait_rear++] = x ;
        if (wait_rear > ans2) ans2 = wait_rear ;
    }
}


void release(int x){
    int tt = T[x] ;
    if (tt > ans1) ans1 = tt ;
    while (1)
    {
        mem_release(mem[x], M[x]) ;
        if (mqlen == 1) break ;
        if (type[msgQueue[1]]==0) break ;
        if (T[msgQueue[1]] != tt) break ;
        x = dmq() ;
    }
    while (wait_front != wait_rear)
    {
        x = wait_list[wait_front] ;
        T[x] = tt ;
        if (try_alloc(x)) wait_front++ ;
        else break ;
    }
}


int main ()
{
    int n, m, i, x ;
    
    while (~scanf ("%d", &n))
    {
        m = 0 ; wait_rear = wait_front = 0 ;
        mem_init(n) ;
        ans1 = ans2 = 0 ;
        mqlen = 1 ;
        while (~scanf ("%d%d%d", &T[m], &M[m], &P[m]) && (T[m]||M[m]||P[m])) m++ ;
        for (i = 0 ; i < m ; i++) imq(i, 0) ;
        while (mqlen != 1)
        {
            if (type[x=dmq()] == 0) alloc(x) ;
            else release (x) ;
        }
        mem_delete(head.next) ;
        printf ("%d\n%d\n", ans1, ans2) ;
    }
    return 0 ;
}