C++ में क्लाउड सर्च (Cloud Search) एल्गोरिथम- स्पष्टीकरण, उदाहरण और कोड

क्लाउड सर्च एल्गोरिदम एक खोज विधि है जिसमें यादृच्छिक समाधानों का एक बड़ा सेट तैयार करना शामिल है, जिसे अक्सर "क्लाउड" के रूप में जाना जाता है और फिर इस सेट के भीतर सर्वोत्तम समाधानों की खोज करना शामिल है। इस दृष्टिकोण का उपयोग आमतौर पर जटिल समस्याओं के अनुमानित समाधान खोजने के लिए किया जाता है जब कोई विशिष्ट मार्गदर्शन उपलब्ध नहीं होता है।

यह काम किस प्रकार करता है

1. क्लाउड आरंभीकरण: यादृच्छिक समाधानों(क्लाउड) का एक बड़ा सेट बनाएं।
2. मूल्यांकन: उद्देश्य फ़ंक्शन या मूल्यांकन मानदंड के आधार पर क्लाउड में प्रत्येक समाधान की गुणवत्ता का मूल्यांकन करें।
3. चयन: संभावनाओं या चयन मानदंडों के आधार पर क्लाउड से सर्वोत्तम समाधानों का एक सबसेट चुनें।
4. सुधार: परिवर्तनों या अनुकूलन को लागू करके क्लाउड में समाधानों की गुणवत्ता में सुधार करें।
5. पुनरावृत्ति: संतोषजनक परिणाम प्राप्त होने तक या पुनरावृत्तियों की पूर्वनिर्धारित संख्या तक पहुंचने तक चरण 2 से 4 दोहराएँ।

उदाहरण: ट्रैवलिंग सेल्समैन समस्या के लिए क्लाउड सर्च

ट्रैवलिंग सेल्समैन प्रॉब्लम(टीएसपी) पर विचार करें, जहां लक्ष्य सभी शहरों का दौरा करने वाली सबसे छोटी हैमिल्टनियन साइकिल ढूंढना है। क्लाउड सर्च विधि बड़ी संख्या में यादृच्छिक हैमिल्टनियन चक्र उत्पन्न कर सकती है, फिर सबसे कम लागत वाले चक्र का चयन करें।

C++ में कोड उदाहरण

#include <iostream>  
#include <vector>  
#include <algorithm>  
#include <ctime>  
#include <cstdlib>  
  
struct City {  
    int x;  
    int y;  
};  
  
double calculateDistance(const City& city1, const City& city2) {  
    return std::sqrt((city1.x- city2.x)*(city1.x- city2.x) +(city1.y- city2.y)*(city1.y- city2.y));  
}  
  
double cloudSearchTSP(std::vector<City>& cities, int maxIterations) {  
    int numCities = cities.size();  
    double bestDistance = std::numeric_limits<double>::max();  
  
    srand(time(0));  
  
    for(int i = 0; i < maxIterations; ++i) {  
        std::random_shuffle(cities.begin(), cities.end());  
  
        double totalDistance = 0.0;  
        for(int j = 0; j < numCities- 1; ++j) {  
            totalDistance += calculateDistance(cities[j], cities[j + 1]);  
        }  
        totalDistance += calculateDistance(cities[numCities- 1], cities[0]);  
  
        bestDistance = std::min(bestDistance, totalDistance);  
    }  
  
    return bestDistance;  
}  
  
int main() {  
    std::vector<City> cities = {{0, 0}, {1, 2}, {3, 1}, {4, 3}, {2, 4}};  
    int maxIterations = 1000;  
    double shortestDistance = cloudSearchTSP(cities, maxIterations);  
  
    std::cout << "Shortest distance in TSP: " << shortestDistance << std::endl;  
  
    return 0;  
}  

इस उदाहरण में, हम टीएसपी को हल करने के लिए क्लाउड सर्च पद्धति का उपयोग करते हैं। हम शहरों को यादृच्छिक रूप से फेरबदल करके बड़ी संख्या में यादृच्छिक हैमिल्टनियन चक्र उत्पन्न करते हैं, फिर प्रत्येक चक्र की लागत की गणना करते हैं और सबसे कम लागत वाले चक्र का चयन करते हैं।