C++ प्रोग्राम यह पता लगाने के लिए कि एक फिल्म महोत्सव में एक उपस्थित व्यक्ति पूरी तरह से कितनी फिल्में देख सकता है

मान लीजिए एक फिल्म महोत्सव चल रहा है जो विभिन्न देशों की विभिन्न फिल्मों का प्रदर्शन कर रहा है। अब, एक उपस्थित व्यक्ति उन अधिकतम फिल्मों में भाग लेना चाहता है जो एक दूसरे के साथ ओवरलैप नहीं करती हैं और हमें यह पता लगाने में उनकी मदद करनी है कि वे कितनी फिल्में देख सकते हैं।

एक स्ट्रक्चर Movie है जिसमें निम्नलिखित सदस्य हैं:

फिल्म का प्रारंभ समय।
फिल्म की अवधि।
फिल्म का समाप्ति समय।

एक और स्ट्रक्चर Festival है जिसमें निम्नलिखित सदस्य हैं:

महोत्सव में फिल्मों की संख्या।
Movie प्रकार की एक सरणी जिसका आकार महोत्सव में फिल्मों की संख्या के समान है।

हमें दो सरणियों 'timeBegin' और 'duration' के साथ एक Festival ऑब्जेक्ट बनाना और इनिशियलाइज़ करना है जिनमें क्रमशः कई फिल्मों का प्रारंभ समय और अवधि है। एक पूर्णांक n फिल्मों की कुल संख्या को दर्शाता है और इसका उपयोग ऑब्जेक्ट को इनिशियलाइज़ करने के लिए भी किया जाता है। हम आगे उस ऑब्जेक्ट का उपयोग यह गणना करने के लिए करते हैं कि एक उपस्थित व्यक्ति पूरी तरह से कितनी फिल्में देख सकता है।

तो, यदि इनपुट timeBegin = {1, 3, 0, 5, 5, 8, 8}, duration = {3, 2, 2, 4, 3, 2, 3}, n = 7 है, तो आउटपुट 4 होगा।

उपस्थित व्यक्ति उस महोत्सव में पूरी तरह से कुल 4 फिल्में देख सकता है।

इसे हल करने के लिए, हम इन चरणों का पालन करेंगे:

struct Movie {
- तीन सदस्य वेरिएबल्स timeBegin, duration, timeEnd परिभाषित करें
- एक ऑपरेटर '<' को ओवरलोड करें, यह Movie प्रकार का एक वेरिएबल another लेगा।
  - timeEnd < another.timeEnd लौटाएं
struct Festival {
- एक सदस्य count परिभाषित करें
- Movie प्रकार की वस्तुओं वाली एक सरणी movies परिभाषित करें
एक फंक्शन initialize() परिभाषित करें। यह सरणियों timeBegin और timeEnd और एक पूर्णांक n लेगा।
- filmFestival := एक नया Festival ऑब्जेक्ट
- filmFestival का count := count
- i := 0 से प्रारंभ करें, जब i < count, अपडेट करें (i को 1 से बढ़ाएं), करें:
  - temp := Movie प्रकार का एक नया ऑब्जेक्ट
  - temp का timeBegin := timeBegin[i]
  - temp का duration := duration[i]
  - temp का timeEnd := timeBegin[i] + duration[i]
  - temp को filmFestival की movies सरणी में डालें
- filmFestival लौटाएं
एक फंक्शन solve() परिभाषित करें, यह fest प्रकार का एक वेरिएबल लेगा जो Festival प्रकार का है,
- res := 0
- fest की movies सरणी को क्रमबद्ध करें
- timeEnd := -1
- i := 0 से प्रारंभ करें, जब i < fest->count, अपडेट करें (i को 1 से बढ़ाएं), करें:
  - यदि fest की movies[i] का timeBegin >= timeEnd, तो:
    - (res को 1 से बढ़ाएं)
    - timeEnd := fest की movies[i] का timeEnd
- res लौटाएं

उदाहरण

बेहतर समझ के लिए निम्नलिखित कार्यान्वयन देखें:

#include<bits/stdc++.h>
using namespace std;

struct Movie {
    int timeBegin, duration, timeEnd;
    bool operator<(const Movie& another) const {
        return timeEnd < another.timeEnd;
    }
};

struct Festival {
    int count;
    vector<Movie> movies;
};

Festival* initialize(int timeBegin[], int duration[], int count) {
    Festival* filmFestival = new Festival;
    filmFestival->count = count;
    for (int i = 0; i < count; i++) {
        Movie temp;
        temp.timeBegin = timeBegin[i];
        temp.duration = duration[i];
        temp.timeEnd = timeBegin[i] + duration[i];
        filmFestival->movies.push_back(temp);
    }
    return filmFestival;
}

int solve(Festival* fest) {
    int res = 0;
    sort(fest->movies.begin(), fest->movies.end());
    int timeEnd = -1;
    for (int i = 0; i < fest->count; i++) {
        if (fest->movies[i].timeBegin >= timeEnd) {
            res++;
            timeEnd = fest->movies[i].timeEnd;
        }
    }
    return res;
}

int main(int argc, char *argv[]) {
    int timeBegin[] = {1, 3, 0, 5, 5, 8, 8};
    int duration[] = {3, 2, 2, 4, 3, 2, 3};
    Festival * fest;
    fest = initialize(timeBegin, duration, 7);
    cout << solve(fest) << endl;
    return 0;
}

इनपुट

int timeBegin[] = {1, 3, 0, 5, 5, 8, 8};
int duration[] = {3, 2, 2, 4, 3, 2, 3};
Festival * fest;
fest = initialize(timeBegin, duration, 7);