(Cloud Search) C++ માં ક્લાઉડ સર્ચ અલ્ગોરિધમ- સમજૂતી, ઉદાહરણ અને કોડ

ક્લાઉડ સર્ચ અલ્ગોરિધમ એ એક શોધ પદ્ધતિ છે જેમાં રેન્ડમ સોલ્યુશન્સનો મોટો સમૂહ જનરેટ કરવાનો સમાવેશ થાય છે, જેને ઘણીવાર "ક્લાઉડ" તરીકે ઓળખવામાં આવે છે અને પછી આ સેટમાં શ્રેષ્ઠ ઉકેલો શોધવાનો સમાવેશ થાય છે. જ્યારે કોઈ ચોક્કસ માર્ગદર્શન ઉપલબ્ધ ન હોય ત્યારે આ અભિગમનો ઉપયોગ સામાન્ય રીતે જટિલ સમસ્યાઓ માટે અંદાજિત ઉકેલો શોધવા માટે થાય છે.

તે કેવી રીતે કામ કરે છે

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 ઉકેલવા માટે ક્લાઉડ શોધ પદ્ધતિનો ઉપયોગ કરીએ છીએ. અમે શહેરોને અવ્યવસ્થિત રીતે શફલિંગ કરીને મોટી સંખ્યામાં રેન્ડમ હેમિલ્ટોનિયન ચક્રો જનરેટ કરીએ છીએ, પછી દરેક ચક્ર માટે કિંમતની ગણતરી કરીએ છીએ અને સૌથી ઓછી કિંમત સાથે ચક્ર પસંદ કરીએ છીએ.