#include <vector>
#include <cmath>
#include <algorithm>
using namespace std;

int solution(const vector<int>& start, const vector<int>& dest, const vector<int>& limit) {
    int N = start.size();
    int K = limit.size();
    int totalCost = 0, maxStation = 0;

    for (int i = 0; i < N; ++i) {
        maxStation = max(maxStation, max(start[i], dest[i]));
        totalCost += abs(start[i] - dest[i]) * 2 + 1;
    }

    if (maxStation >= K) return -1; 
    return min(totalCost, limit[maxStation]);
}

#include <vector>
#include <unordered_map>
#include <algorithm>
using namespace std;

void dfs(int node, unordered_map<int, vector<pair<int, int>>>& graph, vector<bool>& visited, int& count) {
    visited[node] = true;
    for (auto& neighbor : graph[node]) {
        int nextNode = neighbor.first;
        int direction = neighbor.second;
        if (!visited[nextNode]) {
            count += direction;
            dfs(nextNode, graph, visited, count);
        }
    }
}

int solution(vector<int> A, vector<int> B) {
    unordered_map<int, vector<pair<int, int>>> graph;
    int N = max(*max_element(A.begin(), A.end()), *max_element(B.begin(), B.end())); 

    for (int i = 0; i < A.size(); i++) {
        graph[A[i]].push_back({B[i], 1});
        graph[B[i]].push_back({A[i], 0});
    }

    vector<bool> visited(N + 1, false);
    int count = 0;
    dfs(0, graph, visited, count);

    return count;
}