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 सोडवण्यासाठी क्लाउड शोध पद्धत वापरतो. शहरे यादृच्छिकपणे बदलून आम्ही मोठ्या संख्येने यादृच्छिक हॅमिलटोनियन सायकल तयार करतो, त्यानंतर प्रत्येक सायकलसाठी खर्चाची गणना करतो आणि सर्वात कमी किमतीसह सायकल निवडा.