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

总结

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