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

સ્થાનિક શોધ અલ્ગોરિધમ એ વર્તમાન સ્થિતિની આસપાસના વિસ્તારમાં શ્રેષ્ઠ ઉકેલ શોધવા માટેની પદ્ધતિ છે. આ ટેકનીકનો ઉપયોગ ઘણીવાર સારી સ્થિતિઓ શોધવા માટે વ્યક્તિગત ઘટકોને પુનરાવર્તિત રીતે સંશોધિત કરીને અંદાજિત ઉકેલોને સુધારવા માટે થાય છે.

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

1. આરંભ: પ્રારંભિક સ્થિતિથી પ્રારંભ કરો.
2. પાડોશીઓ બનાવો: વર્તમાન સ્થિતિના ઘટકને બદલીને પડોશી રાજ્યો બનાવો.
3. મૂલ્યાંકન: ઉદ્દેશ્ય કાર્યનો ઉપયોગ કરીને પડોશી રાજ્યોની ગુણવત્તાનું મૂલ્યાંકન કરો.
4. શ્રેષ્ઠ રાજ્ય પસંદ કરો: શ્રેષ્ઠ ઉદ્દેશ્ય મૂલ્ય સાથે પડોશી રાજ્ય પસંદ કરો.
5. પુનરાવર્તન કરો: જ્યાં સુધી કોઈ સારું પડોશી રાજ્ય ન મળે ત્યાં સુધી પગલાં 2 થી 4 દ્વારા પુનરાવર્તન કરો.

ઉદાહરણ: Fibonacci કાર્યને ઑપ્ટિમાઇઝ કરવું

Fibonacci F(0) = 0, F(1) = 1 સાથે F(x) = F(x-1) + F(x-2) ફંક્શનની ઑપ્ટિમાઇઝેશન સમસ્યાને ધ્યાનમાં લો. આપણે x ની કિંમત શોધવા માંગીએ છીએ જેના માટે F(x) મહત્તમ છે. અમે સ્થાનિક શોધ અભિગમનો ઉપયોગ પુનરાવર્તિત રીતે દરેક પગલાથી વધુ દૂર અન્વેષણ કરવા માટે કરી શકીએ છીએ.

C++ માં કોડનું ઉદાહરણ

#include <iostream>  
  
int fibonacci(int n) {  
    if(n <= 0) return 0;  
    if(n == 1) return 1;  
    return fibonacci(n- 1) + fibonacci(n- 2);  
}  
  
int localSearchFibonacci(int maxIterations) {  
    int bestX = 0;  
    int bestValue = 0;  
  
    for(int x = 0; x < maxIterations; ++x) {  
        int value = fibonacci(x);  
        if(value > bestValue) {  
            bestValue = value;  
            bestX = x;  
        }  
    }  
  
    return bestX;  
}  
  
int main() {  
    int maxIterations = 20;  
    int result = localSearchFibonacci(maxIterations);  
  
    std::cout << "Optimal x for maximum Fibonacci value: " << result << std::endl;  
  
    return 0;  
}  

આ ઉદાહરણમાં, અમે Fibonacci કાર્યને ઑપ્ટિમાઇઝ કરવા માટે સ્થાનિક શોધ પદ્ધતિનો ઉપયોગ કરીએ છીએ. અમે x ના વિવિધ મૂલ્યો દ્વારા પુનરાવર્તન કરીએ છીએ અને Fibonacci દરેક x પર મૂલ્યની ગણતરી કરીએ છીએ. જ્યારે વધુ સારું મૂલ્ય મળે, ત્યારે અમે શ્રેષ્ઠ મૂલ્ય અને તેના અનુરૂપ xને અપડેટ કરીએ છીએ.