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

இந்த எடுத்துக்காட்டில், TSP ஐத் தீர்க்க கிளவுட் தேடல் முறையைப் பயன்படுத்துகிறோம். நகரங்களை சீரற்ற முறையில் மாற்றுவதன் மூலம் அதிக எண்ணிக்கையிலான சீரற்ற ஹாமில்டோனியன் சுழற்சிகளை உருவாக்குகிறோம், பின்னர் ஒவ்வொரு சுழற்சிக்கான செலவைக் கணக்கிட்டு, குறைந்த செலவில் சுழற்சியைத் தேர்ந்தெடுக்கிறோம்.