2015 USP-ICMC gym 100733 I. The Cool Monkeys

I. The Cool Monkeys

time limit per test

4.0 s

memory limit per test

256 MB

input

standard input

output

standard output

The first mafia on planet Earth was actually composed of a bunch of cool jumping monkeys. The name of that group was pretty simple - Monkafia - and they dominated the food chain and the transport systems in the biggest tropical forest of the world at the time.

Tha typical Monkafia squadron was composed of a group of m monkeys. They had headquarters - usually composed of two trees. We will call those trees A and B. The monkeys slept on the highest branches of tree A, and, during morning, used to climb down to the lowest branches of tree B, alternating between branches of trees A and B. They could jump multiple times between the two trees.

Monkeys in the Monkafia are very irritating and don't like sharing, so they could never jump on a branch that another monkey had already jumped or been that morning.

We know that each branch of trees A and B has a certain height, H. It is possible for a monkey to jump from a branch Ga to a branch Gbonly if |HGa - HGb| < T, where T is the height a single monkey can jump.

It is not always possible for two arbitrary trees to have all monkeys of a Monkafia squadron jump down from the topmost branches of one of the trees to the bottommost branches of the other without breaking the rules. Given that, your job here is the following: given a pair o trees, with the heights of their branches and the distance T, find out if it is possible for the squadron to do the morning descend considering all the constraints. Any of the trees can be tree A (the starting tree) or tree B (the ending tree).

Input

The input begins with four numbers, m, nA, nB e T (1 ≤ m ≤ nA, nB ≤ 500, 1 < T ≤ 108), the number of monkeys, the number of branches in one tree, the number of branches in the other tree and the distance the monkeys can jump. Follow na lines, each with the height of a branch from the first tree (1 ≤ HGa ≤ 108). Then follows nb lines, each with the height of a branch from the second tree (1 ≤ HGb ≤ 108).

Output

Answer 'S' if it is possible to use that pair of trees and 'N' otherwise.

Examples

input

Copy

1 2 2 3
1
3
2
1

output

Copy

S

input

Copy

1 2 3 2
1
3
2
1
1

output

Copy

S

input

Copy

2 2 3 2
1
3
2
1
1

output

Copy

S

input

Copy

2 6 7 4
8
4
5
2
9
11
2
2
8
3
12
3
12

output

Copy

N
思路：拆点最大流裸题

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <queue>
#include <stack>
#include <vector>
#include <set>
#include <map>
#include <list>
#include <iomanip>
#include <cctype>
#include <cassert>
#include <bitset>
#include <ctime>

using namespace std;

#define pau system("pause")
#define ll long long
#define pii pair<int, int>
#define pb push_back
#define mp make_pair
#define clr(a, x) memset(a, x, sizeof(a))

const double pi = acos(-1.0);
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;
const int Max_E = 3e6;
const int Max_V = 2e3;
/*
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

using namespace __gnu_pbds;
tree<pli, null_type, greater<pli>, rb_tree_tag, tree_order_statistics_node_update> T;
*/

int m, na, nb, T, aa[Max_V + 15], ab[Max_V + 15];
struct Edge {
    int u, v, w;
    Edge () {}
    Edge (int u, int v, int w) : u(u), v(v), w(w) {}
} e[Max_E + 15];
int head[Max_V + 15], nex[Max_E + 15], tot;
void add_edge(int u, int v, int w) {
    e[++tot] = Edge(u, v, w);
    nex[tot] = head[u], head[u] = tot;
    e[++tot] = Edge(v, u, 0);
    nex[tot] = head[v], head[v] = tot;
}
void build(int arr1[], int arr2[], int na, int nb) {
    tot = -1;
    clr(head, -1), clr(nex, -1);
    sort(arr1 + 1, arr1 + na + 1);
    reverse(arr1 + 1, arr1 + na + 1);
    sort(arr2 + 1, arr2 + nb + 1);
    int s = 0;
    for (int i = 1; i <= m; ++i) {
        add_edge(s, i * 2 - 1, 1);
    }
    for (int i = 1; i <= na; ++i) {
        add_edge(i * 2 - 1, i * 2, 1);
    }
    int t = 2 * (na + nb) + 1;
    for (int i = 1; i <= m; ++i) {
        add_edge(2 * na + 2 * i, t, 1);
    }
    for (int i = 1; i <= nb; ++i) {
        add_edge(2 * na + 2 * i - 1, 2 * na + 2 * i, 1);
    }
    for (int i = 1; i <= na; ++i) {
        for (int j = 1; j <= nb; ++j) {
            if (abs(arr1[i] - arr2[j]) < T) {
                add_edge(2 * i, 2 * na + 2 * j - 1, 1);
                add_edge(2 * na + 2 * j, 2 * i - 1, 1);
            }
        }
    }
}
int dep[Max_V + 15];
queue<int> que;
bool bfs() {
    clr(dep, 0);
    while (que.size()) que.pop();
    que.push(0), dep[0] = 1;
    while (que.size()) {
        int x = que.front(); que.pop();
        if (x == 2 * na + 2 * nb + 1) return true;
        for (int i = head[x]; ~i; i = nex[i]) {
            int v = e[i].v, w = e[i].w;
            if (w && !dep[v]) {
                que.push(v);
                dep[v] = dep[x] + 1;
            }
        }
    }
    return false;
}
int cur[Max_V + 15];
int dfs(int x, int c) {
    if (x == 2 * na + 2 * nb + 1) {
        return c;
    }
    if (!c) return 0;
    int res = 0;
    for (int i = cur[x]; ~i; i = nex[i]) {
        if (e[i].w && dep[e[i].v] == dep[x] + 1) {
            int dd = dfs(e[i].v, min(c, e[i].w));
            e[i].w -= dd;
            e[i ^ 1].w += dd;
            res += dd;
            c -= dd;
        }
        cur[x] = i;
    }
    return res;
}
int dinic() {
    int res = 0;
    while (bfs()) {
        for (int i = 0; i <= 2 * (na + nb) + 1; ++i) {
            cur[i] = head[i];
        }
        res += dfs(0, MOD);
    }
    return res;
}
void solve() {
    build(ab, aa, nb, na);
    int res1 = dinic();
    build(aa, ab, na, nb);
    int res2 = dinic();
    putchar(max(res1, res2) >= m ? 'S' : 'N');
}
int main() {
    scanf("%d%d%d%d", &m, &na, &nb, &T);
    for (int i = 1; i <= na; ++i) {
        scanf("%d", &aa[i]);
    }
    for (int i = 1; i <= nb; ++i) {
        scanf("%d", &ab[i]);
    }
    solve();
    return 0;
}