Ural 1774 Barber of the Army of Mages 最大流

题目链接：http://acm.timus.ru/problem.aspx?space=1&num=1774

1774. Barber of the Army of Mages

Time limit: 0.5 second
Memory limit: 64 MB

Petr, elected as a warlord of the army of mages, faced a challenging problem. All magicians recruited in the army had heavy beards, which were quite unacceptable for soldiers. Therefore, Petr ordered all recruits to shave their beards as soon as possible. Of course, all magicians refused to do it, referring to the fact they don't know any shaving spell. Fortunately, a magician Barberian agreed to shave all recruits.

Barberian can cast a “Fusion Power” spell which shaves beards of at most k magicians in one minute. In order to achieve full effect every magician should be shaved twice: the first spell shaves close, the second spell shaves even closer. For each recruit Petr appointed a time when he should visit Barberian. Unfortunately, the discipline in the new army is still far from perfect, so every magician will come to Barberian in time, but everyone will wait for the shave until his patience is exhausted and will disappear after that.

Determine whether Barberian will be able to shave beards of all magicians before they disappear.

Input

The first line contains two space-separated integers n and k (1 ≤ n, k ≤ 100), which are the number of recruits in the army and the number of magicians Barber can shave simultaneously. The i-th of the following n lines contains space-separated integers ti and si (0 ≤ ti ≤ 1000; 2 ≤ si ≤ 1000), which are the time in minutes, at which the i-th magician must come to Barberian, and the time in minutes he is ready to spend there, including shaving time.

Output

If Barberian is able to shave beards of all magicians, output “Yes” in the first line. The i-th of the following n lines should contain a pair of integers pi, qi, which are the moments at which Barberian should cast the spell on the i-th magician(ti ≤ pi < qi ≤ ti + si − 1). If at least one magician disappears before being completely shaved, output a single word “No”.

Samples

input	output
3 2 1 3 1 3 1 3	Yes 1 2 1 3 2 3
2 1 1 3 1 3	No

题意

有很多人要剃胡子，有个很神奇的理发师，可以在每分钟给k个人护理。每个人必须被护理两次。给你每个人进入理发店的时间和耐心，输出在什么时候给这些人剪胡子。

题解

发现时间只有1000，那么可以每一分钟建立一个节点，然后连到人的节点上，容量为1，表示每个人1分钟最多被护理一次;每个人连接一条边到T，容量为2，表示每个人需要被护理两次;从S连接容量为k的边到每个时间，表示每一分钟可以处理k个人。然后跑一发Dinic，最后在残余网络上找解就好。详见代码：

代码

#include<iostream>
#include<stack>
#include<vector>
#include<cstring>
#include<algorithm>
#include<queue>
#define MAX_V 4567
#define MAX_N 10004
#define INF 2500005
using namespace std;

struct edge{int to,cap,rev;bool isRev;};

vector<edge> G[MAX_N];
int level[MAX_V];
int iter[MAX_V];

void add_edge(int from,int to,int cap) {
    G[from].push_back((edge) {to, cap, G[to].size(),});
    G[to].push_back((edge) {from, , G[from].size() - ,});
}

void bfs(int s) {
    memset(level, -, sizeof(level));
    queue<int> que;
    level[s] = ;
    que.push(s);
    while (!que.empty()) {
        int v = que.front();
        que.pop();
        for (int i = ; i < G[v].size(); i++) {
            edge &e = G[v][i];
            if (e.cap >  && level[e.to] < ) {
                level[e.to] = level[v] + ;
                que.push(e.to);
            }
        }
    }
}

int dfs(int v,int t,int f) {
    if (v == t)return f;
    for (int &i = iter[v]; i < G[v].size(); i++) {
        edge &e = G[v][i];
        if (e.cap >  && level[v] < level[e.to]) {
            int d = dfs(e.to, t, min(f, e.cap));
            if (d > ) {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return ;
}

int max_flow(int s,int t) {
    int flow = ;
    for (; ;) {
        bfs(s);
        if (level[t] < )return flow;
        memset(iter, , sizeof(iter));
        int f;
        while ((f = dfs(s, t, INF)) > ) {
            flow += f;
        }
    }
}

int n,k;
int t[MAX_N],r[MAX_N];
int m=;

int S=;
int T=;

int ans[MAX_N][];

int main() {
    scanf("%d%d", &n, &k);
    memset(ans, -, sizeof(ans));
    for (int i = ; i < n; i++) {
        scanf("%d%d", &t[i], &r[i]);
        for (int j = ; j < r[i]; j++)
            add_edge(j + t[i], i + m, );
    }
    for (int i = ; i < m; i++)add_edge(S, i, k);
    for (int i = ; i < n; i++)add_edge(i + m, T, );

    int f = max_flow(S, T);
    if (f !=  * n) {
        cout << "No" << endl;
        return ;
    }
    printf("Yes\n");
    for (int i = ; i < m; i++) {
        for (int j = ; j < G[i].size(); j++) {
            if(G[i][j].isRev||(G[i][j].cap==))continue;
            int u = G[i][j].to - m;
            if (ans[u][] == -)ans[u][] = i;
            else if (ans[u][] == -)ans[u][] = i;
        }
    }
    for (int i = ; i < n; i++)
        printf("%d %d\n", ans[i][], ans[i][]);
    return ;
}