hiho一下 第108周_Memory Allocating Algorithm(双向链表）

题目

这是一道微软的笔试题，具体题目见http://hihocoder.com/contest/hiho108/problem/1
这道题目的关键地方有两点：当存放数字i时（i的数目为nums[i]），

1. 当有多个地方能放的时候，选最靠前的；
2. 当没有地方能放的时候，不断删除最早的数据，直到有地方能放。

按照上述两条规则存放后，内存区域可能变得非常零散。
对于输入N， M：For 60% of the data 1≤N≤200，10≤M≤100，1≤Ki≤5；For 100% of the data 1≤N≤2,000，10≤M≤109，1≤Ki≤M。开辟连续空间模拟size为M的内存区域时，只有60%的样例可以通过，所以想要完全通过，应该采取更有效的数据结构。

分析

1 因为对于数字i，其存放的区域一定是连续的first–>last,且（last > first)，因此我们可以定义这么一个数据结构，存放每个数据。

struct ListNode {    int val;                 //值    int first;               //存放的首位置    int last;                //存放的最后一个位置的下一位    ListNode *next;          //后继指针    ListNode *prev;          //前驱指针    ListNode(int x, int y, int z) :            val(x), first(y), last(z), next(NULL), prev(NULL) {    }};

2 当有足够多的地方存放当前数字时，从最左边开始存放，假设满足条件的最左边的块为ListNode *p；

void enoughSpace(ListNode *&p, int val, int sum){    if (p->last - p->first == sum) { //如果剩余的位置刚好能存放val，则只需将p->val由0改成val        p->val = val;    } else {//剩下的位置存放完val后，还有剩余，则需要将原来的区域拆分成两部分，一部分存放val,一部分存放0        ListNode *q = new ListNode(0, p->first + sum, p->last);        p->val = val;        p->last = p->first + sum;        q->next = p->next;        p->next->prev = q;        p->next = q;        q->prev = p;    }}

3 当没有地方能放的时候，不断删除最早的数据，直到有地方能放。

void deleteUntilEnough(int val, int sum) {    map<int, ListNode*> m; //用于记录当前的存放块    ListNode* p = head;    while (p != tail) {        if (p->val != 0)            m[p->val] = p;        p = p->next;    }    for (map<int, ListNode *>::iterator it = m.begin(); it != m.end(); it++) { //删除最早的，直到有足够的位置        ListNode *cur = (*it).second;        cur->val = 0;        if (cur->next != tail && cur->next->val == 0) { //合并后面的空余块            cur->last = cur->next->last;            cur->next = cur->next->next;            cur->next->prev = cur;        }        if (cur->prev != tail && cur->prev->val == 0) { //合并前面的空余块            cur = cur->prev;            cur->last = cur->next->last;            cur->next = cur->next->next;            cur->next->prev = cur;        }        if (cur->last - cur->first >= sum) { //有足够位置存放了            enoughSpace(cur, val, sum);            break;        }    }}

完整代码

#include <iostream>#include <algorithm>#include <list>#include <vector>#include <map>using namespace std;struct ListNode {    int val;    int first;    int last;    ListNode *next;    ListNode *prev;    ListNode(int x, int y, int z) :            val(x), first(y), last(z), next(NULL), prev(NULL) {    }};ListNode *head, *tail;void enoughSpace(ListNode *&p, int val, int sum) {    if (p->last - p->first == sum) { //如果剩余的位置刚好能存放val，则只需将p->val由0改成val        p->val = val;    } else { //剩下的位置存放完val后，还有剩余，则需要将原来的区域拆分成两部分，一部分存放val,一部分存放0        ListNode *q = new ListNode(0, p->first + sum, p->last);        p->val = val;        p->last = p->first + sum;        q->next = p->next;        p->next->prev = q;        p->next = q;        q->prev = p;    }}void deleteUntilEnough(int val, int sum) {    map<int, ListNode*> m; //用于记录当前的存放块    ListNode* p = head;    while (p != tail) {        if (p->val != 0)            m[p->val] = p;        p = p->next;    }    for (map<int, ListNode *>::iterator it = m.begin(); it != m.end(); it++) { //删除最早的，直到有足够的位置        ListNode *cur = (*it).second;        cur->val = 0;        if (cur->next != tail && cur->next->val == 0) { //合并后面的空余块            cur->last = cur->next->last;            cur->next = cur->next->next;            cur->next->prev = cur;        }        if (cur->prev != tail && cur->prev->val == 0) { //合并前面的空余块            cur = cur->prev;            cur->last = cur->next->last;            cur->next = cur->next->next;            cur->next->prev = cur;        }        if (cur->last - cur->first >= sum) { //有足够位置存放了            enoughSpace(cur, val, sum);            break;        }    }}ListNode* odd(vector<int> &nums, int size) {    head = new ListNode(0, 0, size);    tail = new ListNode(-1, size, size);    head->next = head->prev = tail;    tail->prev = tail->next = head;    for (int i = 1; i < nums.size(); i++) {        ListNode *p = head;        while (p != tail && (p->val != 0 || p->last - p->first < nums[i])) {            p = p->next;        }        if (p != tail) { //找到足够放的最左位置            enoughSpace(p, i, nums[i]);        } else { //找不到            deleteUntilEnough(i, nums[i]);        }    }    return head;}int N, M;int main() {    cin >> N >> M;    vector<int> nums;    nums.push_back(0);    while (N--) {        int x;        cin >> x;        nums.push_back(x);    }    ListNode *head = odd(nums, M);    vector<pair<int, int> > ret;    while (head->val != -1) {        ret.push_back(make_pair(head->val, head->first));        //cout << head->val << ' ' << head->first << ' ' << head->last << endl;        head = head->next;    }    sort(ret.begin(), ret.end());    for (int i = 0; i < ret.size(); i++) {        if (ret[i].first)            cout << ret[i].first << ' ' << ret[i].second << endl;    }    return 0;}

总结

这题的关键是理解存放的原则，尤其是当没有足够的内存位置存放当前数字时，要从最早存放的内存块开始删，即按存放的数字从小到大开始删除，直到有足够的内存位置可以存放当前的数字。