POJ 1193 内存分配

内存分配

Time Limit: 1000MS		Memory Limit: 10000K
Total Submissions: 5110		Accepted: 985

Description

内存是计算机重要的资源之一，程序运行的过程中必须对内存进行分配。 
经典的内存分配过程是这样进行的： 
1. 内存以内存单元为基本单位，每个内存单元用一个固定的整数作为标识，称为地址。地址从0开始连续排列，地址相邻的内存单元被认为是逻辑上连续的。我们把从地址i开始的s个连续的内存单元称为首地址为i长度为s的地址片。 
2. 运行过程中有若干进程需要占用内存，对于每个进程有一个申请时刻T，需要内存单元数M及运行时间P。在运行时间P内（即T时刻开始，T+P时刻结束），这M个被占用的内存单元不能再被其他进程使用。 
3、假设在T时刻有一个进程申请M个单元，且运行时间为P，则： 
1. 若T时刻内存中存在长度为M的空闲地址片，则系统将这M个空闲单元分配给该进程。若存在多个长度为M个空闲地址片，则系统将首地址最小的那个空闲地址片分配给该进程。 
2. 如果T时刻不存在长度为M的空闲地址片，则该进程被放入一个等待队列。对于处于等待队列队头的进程，只要在任一时刻，存在长度为M的空闲地址片，系统马上将该进程取出队列，并为它分配内存单元。注意，在进行内存分配处理过程中，处于等待队列队头的进程的处理优先级最高，队列中的其它进程不能先于队头进程被处理。 
现在给出一系列描述进程的数据，请编写一程序模拟系统分配内存的过程。 

Input

第一行是一个数N，表示总内存单元数（即地址范围从0到N-1）。从第二行开始每行描述一个进程的三个整数T、M、P（M <= N）。最后一行用三个0表示结束。 
数据已按T从小到大排序。 
输入文件最多10000行，且所有数据都小于109。 
输入文件中同一行相邻两项之间用一个或多个空格隔开。

Output

包括2行。 
第一行是全部进程都运行完毕的时刻。 
第二行是被放入过等待队列的进程总数。

Sample Input

10
1 3 10
2 4 3
3 4 4
4 1 4
5 3 4
0 0 0

Sample Output

12
2

Hint

时 刻 T

内存占用情况

进程事件

0

1

2

3

4

5

6

7

8

9

进程A申请空间（M=3, P=10）<成功>

1

A

2

A

B

进程B申请空间（M=4, P=3）<成功>

3

A

B

进程C申请空间（M=4, P=4）<失败进入等待队列>

4

A

B

D

进程D申请空间（M=1, P=4）<成功>

5

A

C

D

进程B结束，释放空间 进程C从等待队列取出，分配空间 进程E申请空间（M=3, P=4）<失败进入等待队列>

6

A

C

D

7

A

C

D

8

A

C

E

进程D结束，释放空间 进程E从等待队列取出，分配空间

9

A

E

进程C结束，释放空间

10

A

E

11

E

进程A结束，释放空间

12

进程E结束，释放空间

Source

Noi 99

思路：用个链表存一下剩的内存块，按题意模拟即可。复杂度k*k（k是行数）。

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <iomanip>
#include <cctype>
#include <cassert>
#include <bitset>
#include <ctime>

using namespace std;

#define pau system("pause")
#define ll long long
#define pii pair<int, int>
#define pb push_back
#define mp make_pair
#define clr(a, x) memset(a, x, sizeof(a))

const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;

/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
tree<pli, null_type, greater<pli>, rb_tree_tag, tree_order_statistics_lis_update> T;
*/

int n;
struct node {
    int s, e;
    node () {}
    node (int s, int e) : s(s), e(e) {}
    int l() {
        return e - s + 1;
    }
    void output() {
        printf("s = %d, e = %d
", s, e);
    }
} lis[20015];
struct Q1 {
    int m, t, p;
    Q1 () {}
    Q1 (int m, int t, int p) : m(m), t(t), p(p) {}
    bool operator < (const Q1 &q) const {
        return t < q.t;
    }
    void output() {
        printf("m = %d, t = %d, p = %d
", m, t, p);
    }
} q[10015];
struct Q2 {
    int s, e;
    ll t;
    Q2 () {}
    Q2 (int s, int e, ll t) : s(s), e(e), t(t) {}
    bool operator > (const Q2 &q) const {
        return t > q.t;
    }
    void output() {
        printf("s = %d e = %d t = %lld
", s, e, t);
    }
};
priority_queue<Q2, vector<Q2>, greater<Q2> > que;
queue<Q1> que1;
void print_que() {
    priority_queue<Q2, vector<Q2>, greater<Q2> > tque;
    puts("que: ");
    while (que.size()) {
        Q2 qq = que.top(); que.pop();
        qq.output();
        tque.push(qq);
    }
    puts("");
    while (tque.size()) {
        que.push(tque.top()), tque.pop();
    }
}
void print_que1() {
    queue<Q1> tque1;
    puts("que1: ");
    while (que1.size()) {
        Q1 qq = que1.front(); que1.pop();
        qq.output();
        tque1.push(qq);
    }
    puts("");
    while (tque1.size()) {
        que1.push(tque1.front()), tque1.pop();
    }
}
int nex[20015], pre[20015], cnt_index;
void Insert(int p, int x) {
    nex[x] = p, nex[pre[p]] = x;
    pre[x] = pre[p], pre[p] = x;
}
void Erase(int x) {
    nex[pre[x]] = nex[x];
    pre[nex[x]] = pre[x];
}
void printList() {
    for (int i = 0; i != 20000; i = nex[i]) {
        printf("i = %d, ", i);lis[i].output();
    }
    puts("");
}
int main() {
    scanf("%d", &n);
    int index = 0, t, m, p;
    while (scanf("%d%d%d", &t, &m, &p) && t + m + p) {
        q[++index] = Q1(m, t, p);
    }
    //sort(q + 1, q + index + 1);
    pre[20000] = 0, nex[0] = 20000;
    lis[0] = node(-2, -3);
    lis[++cnt_index] = node(0, n - 1);
    Insert(20000, cnt_index);
    lis[++cnt_index] = node(n + 2, n + 1);
    Insert(20000, cnt_index);
    ll ans1 = 0, ans2 = 0, cur_t = 0;
    for (int i = 1; i <= index + 1; ++i) {
        while (que.size() && (i == index + 1 || que.top().t <= q[i].t)) {

            int flag = 1;
            ll pre_t = -MOD;
            while (que.size() && (flag || pre_t == que.top().t)) {
                Q2 qq = que.top(); que.pop();
                flag = 0, pre_t = qq.t;
                ans1 = max(ans1, qq.t);
                cur_t = max(cur_t, qq.t);
                int it = 0;
                for (; it != 20000; it = nex[it]) {
                    if (qq.e < lis[it].s) {
                        int it1 = pre[it];
                        if (lis[it1].e == qq.s - 1) {
                            qq.s = lis[it1].s;
                            Erase(it1);
                        }
                        if (lis[it].s == qq.e + 1) {
                            lis[it].s = qq.s;
                        } else {
                            lis[++cnt_index] = node(qq.s, qq.e);
                            Insert(it, cnt_index);
                        }
                        break;
                    }
                }
            }

            while (que1.size()) {
                int tflag = 0;
                Q1 q1 = que1.front();
                int it = 0;
                for (; it != 20000; it = nex[it]) {
                    if (q1.m <= lis[it].l()) {
                        que.push(Q2(lis[it].s, lis[it].s + q1.m - 1, cur_t + q1.p));
                        if (q1.m  < lis[it].l()) {
                            lis[it].s = lis[it].s + q1.m;
                        } else {
                            Erase(it);
                        }
                        que1.pop();
                        tflag = 1;
                        break;
                    }
                }
                if (!tflag) break;
            }
            /*if (i == index + 1) {
                printf("cur_t = %lld
", cur_t);
                printList();
                print_que();
                print_que1();
            }*/
        }

        //printList();
        if (i == index + 1) {
            if (que.empty()) break;
            --i;
            continue;
        }

        cur_t = max(cur_t, (ll)q[i].t);
        //if (!q[i].p) continue;
        int it = 0;
        int tflag = 0;
        for (; it != 20000; it = nex[it]) {
            if (q[i].m <= lis[it].l()) {
                que.push(Q2(lis[it].s, lis[it].s + q[i].m - 1, cur_t + q[i].p));
                if (q[i].m < lis[it].l()) {
                    lis[it].s = lis[it].s + q[i].m;
                } else {
                    Erase(it);
                }
                tflag = 1;
                break;
            }
        }
        if (!tflag) que1.push(q[i]), ++ans2;
        //printf("i = %d, ans2 = %lld
", i, ans2);
        //q[i].output();
        //printf("i = %d, cur_t = %lld
", i, cur_t);
        //print_que(); print_que1();
        //pau;
    }

    printf("%lld
%lld", ans1, ans2);
    return 0;
}
/*
8
2 1 1
2 1 1
3 7 2
3 7 2
3 2 2
5 3 2
5 2 2
6 4 2
6 6 2
6 1 2
6 8 1
7 1 2
7 2 2
8 3 1
8 1 2
8 1 2
9 1 1
9 2 2
9 1 2
10 7 2
0 0 0
*/