मैं इस C++ समस्या का समाधान करता हूँ

किसान जॉन अपने खेत में शतावरी के N(1≤N≤2⋅10^5) पौधे उगा रहे हैं! हालाँकि उनके कुछ पौधों में आनुवंशिक अंतर है, इसलिए कुछ पौधे दूसरों की तुलना में तेजी से बढ़ेंगे। इथ पौधे की प्रारंभिक ऊंचाई 1 इंच होती है, और प्रत्येक दिन के बाद, इथ पौधा 3 इंच बढ़ जाता है।
एफजे को अपने कुछ पौधे दूसरों की तुलना में अधिक पसंद हैं, और वह चाहता है कि कुछ विशिष्ट पौधे दूसरों की तुलना में लम्बे हों। वह आपको अलग-अलग मानों की एक श्रृंखला देता है जिसमें 0 से N−1 तक के सभी पूर्णांक होते हैं और वह चाहता है कि इस पौधे में बिल्कुल अन्य पौधे हों जो उससे लम्बे हों। न्यूनतम दिनों की संख्या ज्ञात करें ताकि एफजे का अनुरोध संतुष्ट हो, या निर्धारित करें कि यह असंभव है।
इनपुट:
पहले में एक पूर्णांक T शामिल होगा, जो स्वतंत्र परीक्षण मामलों की संख्या को दर्शाता है (1≤T≤10)
प्रत्येक परीक्षण मामले की पहली पंक्ति में एक पूर्णांक N होता है।
दूसरी पंक्ति में N पूर्णांक hi (1≤hi≤10^9) शामिल है जो इंच में itवें पौधे की प्रारंभिक ऊंचाई को दर्शाता है।
तीसरी पंक्ति में N पूर्णांक ai (1≤ai≤10^9) शामिल है, जो प्रत्येक दिन बढ़ने वाले इंच की संख्या को दर्शाता है।
चौथी पंक्ति में N विशिष्ट पूर्णांक होते हैं जो उस सरणी को दर्शाते हैं जो FJ आपको देता है।
यह गारंटी है कि सभी परीक्षण मामलों में N का योग 2⋅10^5 से अधिक नहीं है

आउटपुट:
आउटपुट टी लाइनें, प्रत्येक परीक्षण मामले का उत्तर एक अलग लाइन पर। यदि यह संभव नहीं है, तो आउटपुट -1।
ध्यान दें कि इस समस्या में शामिल पूर्णांकों के बड़े आकार के लिए 64-बिट पूर्णांक डेटा प्रकारों (उदाहरण के लिए, C/C++ में “लंबा लंबा”) के उपयोग की आवश्यकता हो सकती है।
नमूना इनपुट 1:
6
1
10
1
0
2
7 3
8 10
1 0
2
3 6
10 8
0 1
2
7 3
8 9
1 0
2
7 7
8 8
0 1
2
7 3
8 8
1 0

नमूना आउटपुट 1:
0
3
2
5
-1
-1

पहले नमूना इनपुट में, 6 परीक्षण मामले हैं।
पहले परीक्षण मामले में, केवल एक पौधा है, इसलिए स्थिति 0 दिन पर पूरी हो जाती है।
दूसरे परीक्षण मामले में, हमें पहला पौधा दूसरे पौधे से छोटा होना चाहिए। दिन 1 के बाद, ऊँचाई 15 और 13 हैं। दिन 2 के बाद, ऊँचाई दोनों 23 हैं। दिन 3 के बाद, ऊँचाई 31 और 33 हैं, और वह पहला दिन है जिसमें शर्त पूरी होती है।
तीसरा और चौथा परीक्षण मामला दूसरे के समान है।
पांचवें परीक्षण मामले में, दोनों पौधे 7 की प्रारंभिक ऊंचाई और 8 की वृद्धि दर के साथ शुरू होते हैं। इसलिए उनकी ऊंचाई हमेशा समान होगी, और इसलिए शर्त कभी भी संतुष्ट नहीं होती है।
छठे परीक्षण मामले में, स्थिति शुरू में संतुष्ट नहीं है और विकास दर समान है। अत: शर्त कभी पूरी नहीं हो सकती।
नमूना इनपुट 2:
2
5
7 4 1 10 12
3 4 5 2 1
2 1 0 3 4
5
4 10 12 7 1
3 1 1 4 5
2 4 3 1 0

नमूना आउटपुट 2:
4
7

दूसरे नमूना इनपुट में, 2 परीक्षण मामले हैं।
पहले परीक्षण मामले में, दिन 4 के बाद अंतिम ऊँचाई 19, 20, 21, 18, 16 है।
दूसरे परीक्षण मामले में, दिन 7 के बाद अंतिम ऊँचाई 25, 17, 19, 35, 36 है।

मैंने क्या प्रयास किया है:

इन 2 (बहुत थोड़े) अलग-अलग कोडों को आज़माया:
1.

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

bool isPossible(const vector<int>& h, const vector<int>& a, const vector<int>& t, long long days) {
    int n = h.size();
    vector<pair<long long, int>> heights;

    for (int i = 0; i < n; ++i) {
        heights.push_back({h[i] + days * a[i], t[i]});
    }

    sort(heights.begin(), heights.end(), greater<pair<long long, int>>());

    for (int i = 0; i < n; ++i) {
        if (heights[i].second > i) {
            return false;
        }
    }

    return true;
}

long long minDays(const vector<int>& h, const vector<int>& a, const vector<int>& t) {
    int n = h.size();

    if (n <= 1) {
        return 0; // No need for days if there are 0 or 1 plants.
    }

    long long low = 0, high = 1e18, result = -1;  // Adjusted upper limit

    // Handle smaller inputs efficiently
    if (n <= 2) {
        for (long long i = 0; i <= 1e3; ++i) {
            if (isPossible(h, a, t, i)) {
                result = i;
                break;
            }
        }
    } else if (n <= 50) {
        for (long long i = 0; i <= 1e3; ++i) {
            if (isPossible(h, a, t, i)) {
                result = i;
                break;
            }
        }
    } else {
        while (low <= high) {
            long long mid = low + (high - low) / 2;

            if (isPossible(h, a, t, mid)) {
                result = mid;
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
    }

    return result;
}

int main() {
    int T;
    cin >> T;

    while (T--) {
        int N;
        cin >> N;

        vector<int> h(N), a(N), t(N);

        for (int i = 0; i < N; ++i) {
            cin >> h[i];
        }

        for (int i = 0; i < N; ++i) {
            cin >> a[i];
        }

        for (int i = 0; i < N; ++i) {
            cin >> t[i];
        }

        long long result = minDays(h, a, t);
        cout << result << endl;
    }

    return 0;
}

2.

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

bool isPossible(const vector<int>& h, const vector<int>& a, const vector<int>& t, long long days) {
    int n = h.size();
    vector<pair<long long, int>> heights;

    for (int i = 0; i < n; ++i) {
        heights.push_back({h[i] + days * a[i], t[i]});
    }

    sort(heights.begin(), heights.end(), greater<pair<long long, int>>());

    for (int i = 0; i < n; ++i) {
        if (heights[i].second > i) {
            return false;
        }
    }

    return true;
}

long long minDays(const vector<int>& h, const vector<int>& a, const vector<int>& t) {
    int n = h.size();

    long long low = 0, high = 2e9, result = -1;  // Adjusted upper limit for large inputs

    // Handle smaller inputs efficiently
    if (n <= 2) {
        for (long long i = 0; i <= 2e3; ++i) {  // Adjusted range for small inputs
            if (isPossible(h, a, t, i)) {
                result = i;
                break;
            }
        }
    } else if (n <= 50) {
        for (long long i = 0; i <= 2e3; ++i) {  // Adjusted range for medium inputs
            if (isPossible(h, a, t, i)) {
                result = i;
                break;
            }
        }
    } else {
        while (low <= high) {
            long long mid = low + (high - low) / 2;

            if (isPossible(h, a, t, mid)) {
                result = mid;
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
    }

    return result;
}

int main() {
    int T;
    cin >> T;

    while (T--) {
        int N;
        cin >> N;

        vector<int> h(N), a(N), t(N);

        for (int i = 0; i < N; ++i) {
            cin >> h[i];
        }

        for (int i = 0; i < N; ++i) {
            cin >> a[i];
        }

        for (int i = 0; i < N; ++i) {
            cin >> t[i];
        }

        long long result = minDays(h, a, t);
        cout << result << endl;
    }

    return 0;
}