(Cloud Search) C++ ਵਿੱਚ ਕਲਾਉਡ ਖੋਜ ਐਲਗੋਰਿਦਮ- ਵਿਆਖਿਆ, ਉਦਾਹਰਨ ਅਤੇ ਕੋਡ

ਕਲਾਉਡ ਖੋਜ ਐਲਗੋਰਿਦਮ ਇੱਕ ਖੋਜ ਵਿਧੀ ਹੈ ਜਿਸ ਵਿੱਚ ਬੇਤਰਤੀਬ ਹੱਲਾਂ ਦਾ ਇੱਕ ਵੱਡਾ ਸਮੂਹ ਤਿਆਰ ਕਰਨਾ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ, ਜਿਸਨੂੰ ਅਕਸਰ "ਕਲਾਊਡ" ਕਿਹਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਫਿਰ ਇਸ ਸੈੱਟ ਦੇ ਅੰਦਰ ਸਭ ਤੋਂ ਵਧੀਆ ਹੱਲਾਂ ਦੀ ਖੋਜ ਕਰਨਾ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ। ਇਹ ਪਹੁੰਚ ਆਮ ਤੌਰ 'ਤੇ ਜਟਿਲ ਸਮੱਸਿਆਵਾਂ ਲਈ ਅੰਦਾਜ਼ਨ ਹੱਲ ਲੱਭਣ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ ਜਦੋਂ ਕੋਈ ਖਾਸ ਮਾਰਗਦਰਸ਼ਨ ਉਪਲਬਧ ਨਹੀਂ ਹੁੰਦਾ ਹੈ।

ਕਿਦਾ ਚਲਦਾ

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 ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਕਲਾਉਡ ਖੋਜ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ। ਅਸੀਂ ਸ਼ਹਿਰਾਂ ਨੂੰ ਬੇਤਰਤੀਬੇ ਰੂਪ ਵਿੱਚ ਬਦਲ ਕੇ ਵੱਡੀ ਗਿਣਤੀ ਵਿੱਚ ਬੇਤਰਤੀਬ ਹੈਮਿਲਟੋਨੀਅਨ ਚੱਕਰ ਤਿਆਰ ਕਰਦੇ ਹਾਂ, ਫਿਰ ਹਰੇਕ ਚੱਕਰ ਲਈ ਲਾਗਤ ਦੀ ਗਣਨਾ ਕਰੋ ਅਤੇ ਸਭ ਤੋਂ ਘੱਟ ਲਾਗਤ ਵਾਲੇ ਚੱਕਰ ਦੀ ਚੋਣ ਕਰੋ।