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

Heuristic ਖੋਜ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਐਲਗੋਰਿਦਮਿਕ ਪਹੁੰਚ ਹੈ ਜੋ ਕਿ ਔਸ਼ਧੀ ਜਾਂ ਅੰਗੂਠੇ ਦੇ ਨਿਯਮਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਸੂਚਿਤ ਫੈਸਲੇ ਲੈ ਕੇ ਗੁੰਝਲਦਾਰ ਸਮੱਸਿਆ ਵਾਲੇ ਸਥਾਨਾਂ ਵਿੱਚ ਹੱਲ ਲੱਭਣ ਲਈ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਵਿਸ਼ੇਸ਼ ਤੌਰ 'ਤੇ ਲਾਭਦਾਇਕ ਹੁੰਦਾ ਹੈ ਜਦੋਂ ਇੱਕ ਵਿਆਪਕ ਖੋਜ ਵੱਡੀ ਖੋਜ ਥਾਂ ਦੇ ਕਾਰਨ ਅਵਿਵਹਾਰਕ ਹੁੰਦੀ ਹੈ।

ਕਿਦਾ ਚਲਦਾ

1. Heuristic ਮੁਲਾਂਕਣ: ਐਲਗੋਰਿਦਮ ਇੱਕ heuristic ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਮੱਸਿਆ ਵਾਲੀ ਥਾਂ ਵਿੱਚ ਹਰੇਕ ਸਥਿਤੀ ਦਾ ਮੁਲਾਂਕਣ ਕਰਦਾ ਹੈ। ਇਹ ਫੰਕਸ਼ਨ ਟੀਚਾ ਅਵਸਥਾ ਦੇ ਨਾਲ ਇਸਦੀ ਨੇੜਤਾ ਦੇ ਰੂਪ ਵਿੱਚ ਹਰੇਕ ਰਾਜ ਦੀ "ਹੋਨਹਾਰਤਾ" ਦਾ ਅਨੁਮਾਨ ਲਗਾਉਂਦਾ ਹੈ।
2. ਖੋਜ ਰਣਨੀਤੀ: ਐਲਗੋਰਿਦਮ heuristic ਮੁਲਾਂਕਣ ਦੇ ਆਧਾਰ 'ਤੇ ਸਭ ਤੋਂ ਵਧੀਆ ਸਥਿਤੀ ਦੀ ਚੋਣ ਕਰਦਾ ਹੈ। Best-First ਇਹ ਖੋਜ, A* ਖੋਜ, ਜਾਂ Greedy ਖੋਜ ਵਰਗੀ ਖੋਜ ਰਣਨੀਤੀ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ ।
3. ਰਾਜ ਦਾ ਵਿਸਤਾਰ: ਚੁਣੇ ਹੋਏ ਰਾਜ ਦਾ ਵਿਸਥਾਰ ਆਪਣੇ ਗੁਆਂਢੀ ਰਾਜਾਂ ਨੂੰ ਪੈਦਾ ਕਰਕੇ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਹ ਅਗਲੇ ਪੜਾਅ ਲਈ ਸੰਭਾਵੀ ਉਮੀਦਵਾਰ ਹਨ।
4. ਦੁਹਰਾਓ: ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਦੁਹਰਾਇਆ ਜਾਂਦਾ ਹੈ, ਰਾਜਾਂ ਨੂੰ ਚੁਣਨਾ ਅਤੇ ਵਿਸਤਾਰ ਕਰਨਾ ਜਦੋਂ ਤੱਕ ਟੀਚਾ ਅਵਸਥਾ ਨਹੀਂ ਮਿਲਦੀ ਜਾਂ ਸਮਾਪਤੀ ਦੀ ਸਥਿਤੀ ਪੂਰੀ ਨਹੀਂ ਹੁੰਦੀ।

ਉਦਾਹਰਨ: ਟਰੈਵਲਿੰਗ ਸੇਲਜ਼ਮੈਨ ਸਮੱਸਿਆ(TSP)

ਯਾਤਰਾ ਕਰਨ ਵਾਲੇ ਸੇਲਜ਼ਮੈਨ ਦੀ ਸਮੱਸਿਆ 'ਤੇ ਗੌਰ ਕਰੋ, ਜਿੱਥੇ ਇੱਕ ਸੇਲਜ਼ਮੈਨ ਨੂੰ ਕੁੱਲ ਦੂਰੀ ਨੂੰ ਘੱਟ ਕਰਦੇ ਹੋਏ ਸ਼ਹਿਰਾਂ ਦੇ ਇੱਕ ਸਮੂਹ ਦਾ ਦੌਰਾ ਕਰਨ ਅਤੇ ਸ਼ੁਰੂਆਤੀ ਸ਼ਹਿਰ ਵਿੱਚ ਵਾਪਸ ਜਾਣ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਇੱਕ heuristic ਪਹੁੰਚ ਸਭ ਤੋਂ ਨਜ਼ਦੀਕੀ ਨੇਬਰ ਐਲਗੋਰਿਦਮ ਹੋ ਸਕਦੀ ਹੈ:

1. ਇੱਕ ਬੇਤਰਤੀਬ ਸ਼ਹਿਰ ਤੋਂ ਸ਼ੁਰੂ ਕਰੋ.
2. ਹਰ ਪੜਾਅ 'ਤੇ, ਅਗਲੀ ਮੰਜ਼ਿਲ ਦੇ ਤੌਰ 'ਤੇ ਸਭ ਤੋਂ ਨਜ਼ਦੀਕੀ ਅਣਜਾਣ ਸ਼ਹਿਰ ਦੀ ਚੋਣ ਕਰੋ।
3. ਸਾਰੇ ਸ਼ਹਿਰਾਂ ਦਾ ਦੌਰਾ ਕਰਨ ਤੱਕ ਦੁਹਰਾਓ, ਫਿਰ ਸ਼ੁਰੂਆਤੀ ਸ਼ਹਿਰ 'ਤੇ ਵਾਪਸ ਜਾਓ।

C++ ਵਿੱਚ ਕੋਡ ਦੀ ਉਦਾਹਰਨ

#include <iostream>  
#include <vector>  
#include <cmath>  
#include <algorithm>  
  
struct City {  
    int x, y;  
};  
  
double distance(const City& city1, const City& city2) {  
    return std::sqrt(std::pow(city1.x- city2.x, 2) + std::pow(city1.y- city2.y, 2));  
}  
  
std::vector<int> nearestNeighbor(const std::vector<City>& cities) {  
    int numCities = cities.size();  
    std::vector<int> path(numCities);  
    std::vector<bool> visited(numCities, false);  
  
    path[0] = 0;  
    visited[0] = true;  
  
    for(int i = 1; i < numCities; ++i) {  
        int currentCity = path[i- 1];  
        double minDist = std::numeric_limits<double>::max();  
        int nextCity = -1;  
  
        for(int j = 0; j < numCities; ++j) {  
            if(!visited[j]) {  
                double dist = distance(cities[currentCity], cities[j]);  
                if(dist < minDist) {  
                    minDist = dist;  
                    nextCity = j;  
                }  
            }  
        }  
  
        path[i] = nextCity;  
        visited[nextCity] = true;  
    }  
  
    path.push_back(0); // Return to the starting city  
    return path;  
}  
  
int main() {  
    std::vector<City> cities = {{0, 0}, {1, 3}, {4, 2}, {3, 6}, {7, 1}};  
    std::vector<int> path = nearestNeighbor(cities);  
  
    std::cout << "Traveling Salesman Path: ";  
    for(int city: path) {  
        std::cout << city << ";  
    }  
    std::cout << std::endl;  
  
    return 0;  
}  

ਇਸ ਉਦਾਹਰਨ ਵਿੱਚ, ਨਜ਼ਦੀਕੀ ਗੁਆਂਢੀ ਐਲਗੋਰਿਦਮ ਦੀ ਵਰਤੋਂ ਟਰੈਵਲਿੰਗ ਸੇਲਜ਼ਮੈਨ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਇਹ ਇੱਕ ਅਜਿਹੀ heuristic ਪਹੁੰਚ ਹੈ ਜੋ ਹਰ ਪੜਾਅ 'ਤੇ ਸਭ ਤੋਂ ਨਜ਼ਦੀਕੀ ਅਣਦੇਖੀ ਸ਼ਹਿਰ ਦੀ ਚੋਣ ਕਰਦੀ ਹੈ, ਨਤੀਜੇ ਵਜੋਂ ਅਜਿਹਾ ਹੱਲ ਹੁੰਦਾ ਹੈ ਜੋ ਅਕਸਰ ਅਨੁਕੂਲ ਦੇ ਨੇੜੇ ਹੁੰਦਾ ਹੈ।