2017年9月16日提高组T2 B 三维导弹拦截

Description

---

某国为了防御敌国的导弹袭击，发展出一种导弹拦截系统。
敌国的导弹形成了立体打击，每个导弹可以抽象成一个三维空间中的点(x; y; z)。拦截系统发射的炮弹也很好地应对了这种情况，每一发炮弹也可以视为一个三维空间中的点。
但是这种导弹拦截系统有一个缺陷：虽然它的第一发炮弹能够到达三维空间中任意的点，但是以后每一发炮弹到达点的坐标(x; y; z) 的三个坐标值都必须大于前一发炮弹的对应坐标值。
某天，雷达捕捉到敌国的导弹来袭。由于该系统还在试用阶段，所以只有一套系统，因此有可能不能拦截所有的导弹。
输入导弹飞来的坐标，计算这套系统最多能拦截多少导弹，如果要拦截所有导弹最少要配备多少套这种导弹拦截系统。注意: 所有导弹都是同时飞来的

Input

---

第一行一个正整数n，表示敌国导弹数目。
接下来n 行，每行三个非负整数xi，yi，zi，表示一个敌国导弹的三维坐标。
数据保证所有的导弹坐标互不相同

Output

---

第一行一个整数，表示一套系统最多拦截的导弹数。
第二行一个整数，表示拦截所有导弹最少配备的系统数。

Hint

---

对于30% 的数据，n <=10
对于100% 的数据，n <= 1000，x; y; z <= 10^6

Solution

---

第一问就是三维的dp，第二问就是最小路径覆盖数

Code

---

#include <stdio.h>
#include <string.h>
#include <math.h>
#include <iostream>
#include <algorithm>
#include <queue>
#define rep(i, st, ed) for (int i = st; i <= ed; i += 1)
#define drp(i, st, ed) for (int i = st; i >= ed; i -= 1)
#define erg(i, st) for (int i = ls[st]; i; i = e[i].next)
#define fill(x, t) memset(x, t, sizeof(x))
#define max(x, y) (x)>(y)?(x):(y)
#define min(x, y) (x)<(y)?(x):(y)
#define abs(x) (x)<(0)?(-(x)):(x)
#define INF 0x3f3f3f3f
#define N 2221
#define E N * N + 1
struct edge {int y, w, next;} e[E];
int dis[N], x[N], y[N], z[N], f[N], ls[N], rank[N], cur[N];
int edgeCnt = 1;
inline int read() {
    int x = 0; char ch = getchar();
    for(; ch<'0'||ch>'9'; ch=getchar());
    for(; ch<='9'&&ch>='0'; (x*=10)+=ch-'0',ch=getchar());
    return x;
}
inline void addEdge(int x, int y) {
    e[++ edgeCnt] = (edge) {y, 1, ls[x]}; ls[x] = edgeCnt;
    e[++ edgeCnt] = (edge) {x, 0, ls[y]}; ls[y] = edgeCnt;
}
std:: queue<int> que;
inline int bfs(int st, int ed) {
    while (!que.empty()) {que.pop();}
    que.push(st);
    fill(dis, 0);
    dis[st] = 1;
    while (!que.empty()) {
        int now = que.front(); que.pop();
        erg(i, now) {
            if (e[i].w > 0 && dis[e[i].y] == 0) {
                dis[e[i].y] = dis[now] + 1;
                que.push(e[i].y);
                if (e[i].y == ed) {
                    return 1;
                }
            }
        }
    }
    return 0;
}
inline int find(int now, int ed, int mn) {
    if (now == ed || !mn) {
        return mn;
    }
    int ret = 0;
    for (int &i = cur[now]; i; i = e[i].next) {
        if (e[i].w > 0 && dis[now] + 1 == dis[e[i].y]) {
            int d = find(e[i].y, ed, min(mn-ret, e[i].w));
            ret += d;
            e[i].w -= d;
            e[i ^ 1].w += d;
            if (ret == mn) {
                break;
            }
        }
    }
    return ret;
}
inline int dinic(int st, int ed) {
    int tot = 0;
    while (bfs(st, ed)) {
        rep(i, st, ed) {
            cur[i] = ls[i];
        }
        tot += find(st, ed, INF);
    }
    return tot;
}
inline bool cmp(int a, int b) {
    return x[a] < x[b] || x[a] == x[b] && y[a] < y[b] || x[a] == x[b] && y[a] == y[b] && z[a] < z[b];
}
int main(void) {
    int n = read();
    rep(i, 1, n) {
        x[i] = read();
        y[i] = read();
        z[i] = read();
        rank[i] = i;
    }
    std:: sort(rank + 1, rank + n + 1, cmp);
    int ans1 = 0;
    int st = 0;
    int ed = n * 2 + 1;
    rep(ti, 1, n) {
        int i = rank[ti];
        f[i] = 1;
        rep(tj, 1, ti - 1) {
            int j = rank[tj];
            if (x[j] < x[i] && y[j] < y[i] && z[j] < z[i]) {
                f[i] = max(f[i], f[j] + 1);
                addEdge(i, j + n);
            }
        }
        ans1 = max(ans1, f[i]);
        addEdge(st, i);
        addEdge(i + n, ed);
    }
    int ans2 = dinic(st, ed);
    printf("%d\n%d\n", ans1, n - ans2);
    return 0;
}