2017微软秋季校园招聘在线编程笔试-#1401 : Registration Day

http://hihocoder.com/problemset/problem/1401

题意理解：每个人进队离队100次，10000个人，所以用优先队列1e6的nlogn应该可以，而将班级混起来，按照时间t排序就是对的。

急转弯：使用优先队列，班级混起来，用时间t和sno排序来做就是对的：同一个课堂的顺序一定对，而不同课堂，若排队的再其他课堂没排队的前面，那么当前排队的优先级一定也在之后的前面，所以是对的。

算法：无

数据结构：优先队列||堆

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>

using namespace std;

const int maxN = 10000 + 100;
const int maxC = 100 + 10;

struct node{
    int t, s_no, now_id, id;
    node(int _t, int _s_no, int _now_id, int _id) {
        t = _t;
        s_no = _s_no;
        now_id = _now_id;
        id = _id;
    }
    bool operator < (const node &o) const {
        if(t == o.t) {
            return s_no > o.s_no;
        }
        return t > o.t;
    }
};

priority_queue<node> q;
int N, M, K;
int c_tim[maxC], p[maxN], ans[maxN];
int s[maxN][maxC][2];

int main() {
    scanf("%d%d%d", &N, &M, &K);
    while(!q.empty()) q.pop();
    memset(c_tim, 0, sizeof(c_tim));
    for(int i = 1; i <= N; i++) {
        int si, ti;
        scanf("%d%d%d", &si, &ti, &p[i]);
        for(int j = 1; j <= p[i]; j++) {
            scanf("%d%d", &s[i][j][0], &s[i][j][1]);
        }
        q.push(node(ti, si, 1, i));
    }
    while(!q.empty()) {
        node u = q.top();
        q.pop();
        int start_t = max(c_tim[s[u.id][u.now_id][0]], u.t);
        int end_t = start_t + s[u.id][u.now_id][1];
        c_tim[s[u.id][u.now_id][0]] = end_t;
        if(u.now_id == p[u.id]) {
            ans[u.id] = end_t;
        } else{
            q.push(node(end_t + K, u.s_no, u.now_id + 1, u.id));
        }
    }
    for(int i = 1; i <= N; i++) printf("%d\n", ans[i] + K);
    return 0;
}

python学习使用的heapq， 但是python T了。。

from __future__ import print_function
#
#

'test for heapq'

__author__ = 'hjkruclion'

import heapq
import sys

def read_int():
     return list(map(int, sys.stdin.readline().split()))

maxC = 100 + 10
maxN = 10000 + 100

N, M, K = read_int()

c_tim = [0 for i in range(maxC)]
s = [[(0, 0) for j in range(maxC)] for i in range(maxN)]
p = [0 for i in range(maxN)]
ans = [0 for i in range(maxN)]

h = []

for i in range(1, N + 1):
    t = read_int()
    si, ti, p[i] = t[0 : 3]
    for j in range(1, p[i] + 1):
        s[i][j] = (t[j * 2 - 2 + 3], t[j * 2 + 1 - 2 + 3])
    heapq.heappush(h, (ti, si, 1, i))

while len(h) > 0:
    (t_u, s_no_u, now_id_u, id_u) = heapq.heappop(h)
    now_c_id , now_c_tim = s[id_u][now_id_u]
    start_t = max(c_tim[now_c_id], t_u)
    end_t = start_t + now_c_tim
    c_tim[now_c_id] = end_t
    if now_id_u == p[id_u]:
        ans[id_u] = end_t
    else:
        get_t = end_t + K
        heapq.heappush(h, (get_t, s_no_u, now_id_u + 1, id_u))

for i in range(1, N + 1):
    print(ans[i] + K)