Problem:
Score : 600 points

Problem Statement

Given are two integer sequences of N elements each: A_1,...,A_N and B_1,...,B_N.
Determine if it is possible to do the following operation at most N-2 times (possibly zero) so that, for every integer i from 1 to N, A_i \leq B_i holds:

Choose two distinct integers x and y between 1 and N (inclusive), and swap the values of A_x and A_y.

Constraints

2 \leq N \leq 10^5

1 \leq A_i,B_i \leq 10^9

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N
B_1 B_2 ... B_N

Output

If the objective is achievable, print Yes; if it is not, print No.

Sample Input 1

3
1 3 2
1 2 3

Sample Output 1

Yes

We should swap the values of A_2 and A_3.

Sample Input 2

3
1 2 3
2 2 2

Sample Output 2

No

Sample Input 3

6
3 1 2 6 3 4
2 2 8 3 4 3

Sample Output 3

Yes

Solution in Java8 (OpenJDK 1.8.0) (judge verdict: Wrong Answer)

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Comparator;
import java.util.TreeMap;
import java.util.regex.Pattern;
import java.util.stream.IntStream;

public class Main {
    public void solve(BufferedReader stdin, PrintWriter stdout) throws NumberFormatException, IOException {
        int n = Integer.parseInt(stdin.readLine());
        int[] a = toIntArray(stdin.readLine());
        int[] b = toIntArray(stdin.readLine());

        TreeMap<Integer, Integer> d = new TreeMap<>();
        Arrays.stream(a).forEach(k -> d.put(k, d.getOrDefault(k, 0) + 1));

        int[] c = new int[n];
        int[] idxs = IntStream.range(0, n).boxed().sorted(Comparator.comparingInt(i -> b[i])).mapToInt(Integer::intValue).toArray();

        for (int i : idxs) {
            if (a[i] <= b[i] && d.containsKey(a[i])) {
                c[i] = a[i];
                if (d.get(a[i]) == 1) {
                    d.remove(a[i]);
                } else {
                    d.put(a[i], d.get(a[i]) - 1);
                }
            } else {
                Integer k = d.floorKey(b[i]);
                if (k == null) {
                    stdout.println("No");
                    return;
                }

                if (d.get(k) == 1) {
                    d.remove(k);
                } else {
                    d.put(k, d.get(k) - 1);
                }
                c[i] = k;
            }
        }

        int x = 0;
        for (int i = 0; i < n; i++) {
            if (a[i] != c[i]) {
                x++;
            }
        }

        int y = (x % 2 == 0) ? x / 2 : x / 2 + 1;
        stdout.println(y <= n - 2 ? "Yes" : "No");
    }

    private Pattern space = Pattern.compile(" ");

    private int[] toIntArray(String line) {
        return space.splitAsStream(line).mapToInt(Integer::parseInt).toArray();
    }

    public static void main(String[] args) throws NumberFormatException, IOException {
        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
        PrintWriter stdout = new PrintWriter(System.out, false);
        new Main().solve(stdin, stdout);
        stdout.flush();
    }
}