close

C++ मा क्लाउड खोज (Cloud Search) एल्गोरिदम- व्याख्या, उदाहरण र कोड

क्लाउड खोज एल्गोरिथ्म एउटा खोज विधि हो जसमा अनियमित समाधानहरूको ठूलो सेट उत्पन्न हुन्छ, जसलाई प्राय: "क्लाउड" भनिन्छ र त्यसपछि यो सेट भित्र उत्कृष्ट समाधानहरू खोजी गरिन्छ। यो दृष्टिकोण सामान्यतया जटिल समस्याहरूको लागि अनुमानित समाधान खोज्न प्रयोग गरिन्छ जब कुनै विशेष मार्गदर्शन उपलब्ध छैन।

यो कसरी काम गर्दछ

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

उदाहरण: यात्रा सेल्सम्यान समस्याको लागि क्लाउड खोज

ट्राभलिंग सेल्सम्यान प्रॉब्लेम(TSP) लाई विचार गर्नुहोस्, जहाँ लक्ष्य सबै शहरहरूमा जाने छोटो ह्यामिलटोनियन चक्र फेला पार्नु हो। क्लाउड खोज विधिले धेरै संख्यामा अनियमित ह्यामिलटोनियन चक्रहरू उत्पन्न गर्न सक्छ, त्यसपछि सबैभन्दा कम लागतमा चक्र चयन गर्नुहोस्।

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;  
}

यस उदाहरणमा, हामी TSP समाधान गर्न क्लाउड खोज विधि प्रयोग गर्छौं। हामी सहरहरू अनियमित रूपमा फेर्दै, त्यसपछि प्रत्येक चक्रको लागि लागत गणना गर्नुहोस् र सबैभन्दा कम लागतमा चक्र चयन गर्नुहोस्।