C++'da Bulut Arama (Cloud Search) Algoritması- Açıklama, Örnek ve Kod

Bulut Arama algoritması, genellikle "bulut" olarak adlandırılan büyük bir rasgele çözümler kümesi oluşturmayı ve ardından bu küme içindeki en iyi çözümleri aramayı içeren bir arama yöntemidir. Bu yaklaşım, belirli bir rehber olmadığında karmaşık problemler için yaklaşık çözümler bulmak için yaygın olarak kullanılır.

Nasıl çalışır

1. Bulut Başlatma: Büyük bir rasgele çözüm kümesi(bulut) oluşturun.
2. Değerlendirme: Amaç işlevine veya değerlendirme kriterlerine göre buluttaki her bir çözümün kalitesini değerlendirin.
3. Seçim: Olasılıklara veya seçim kriterlerine göre buluttan en iyi çözümlerin bir alt kümesini seçin.
4. İyileştirme: Dönüşümler veya optimizasyonlar uygulayarak buluttaki çözümlerin kalitesini iyileştirin.
5. Yineleme: Tatmin edici bir sonuç elde edilene veya önceden tanımlanmış bir yineleme sayısına ulaşılana kadar 2 ila 4 arasındaki adımları tekrarlayın.

Örnek: Gezgin Satıcı Problemi için Bulut Arama

Amacın tüm şehirleri ziyaret eden en kısa Hamilton döngüsünü bulmak olduğu Gezici Satıcı Problemini(TSP) düşünün. Cloud Search yöntemi, çok sayıda rasgele Hamilton döngüsü oluşturabilir, ardından en düşük maliyetli döngüyü seçebilir.

C++'da Kod Örneği

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

Bu örnekte, TSP'yi çözmek için Cloud Search yöntemini kullanıyoruz. Şehirleri rastgele karıştırarak çok sayıda rastgele Hamilton döngüsü oluşturuyoruz, ardından her döngü için maliyeti hesaplıyoruz ve en düşük maliyetli döngüyü seçiyoruz.