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ని పరిష్కరించడానికి క్లౌడ్ శోధన పద్ధతిని ఉపయోగిస్తాము. మేము నగరాలను యాదృచ్ఛికంగా షఫుల్ చేయడం ద్వారా పెద్ద సంఖ్యలో యాదృచ్ఛిక హామిల్టోనియన్ సైకిల్‌లను రూపొందిస్తాము, ఆపై ప్రతి చక్రం కోసం ధరను లెక్కించి, తక్కువ ధరతో సైకిల్‌ను ఎంచుకుంటాము.