స్థానిక శోధన అల్గోరిథం అనేది ప్రస్తుత స్థితికి సమీపంలో ఉత్తమ పరిష్కారాన్ని కనుగొనే పద్ధతి. మెరుగైన స్థితులను కనుగొనడానికి వ్యక్తిగత భాగాలను పునరావృతంగా సవరించడం ద్వారా సుమారుగా పరిష్కారాలను మెరుగుపరచడానికి ఈ సాంకేతికత తరచుగా ఉపయోగించబడుతుంది.
అది ఎలా పని చేస్తుంది
- ప్రారంభించడం: ప్రారంభ స్థితితో ప్రారంభించండి.
- పొరుగువారిని రూపొందించండి: ప్రస్తుత స్థితి యొక్క భాగాన్ని మార్చడం ద్వారా పొరుగు రాష్ట్రాలను రూపొందించండి.
- మూల్యాంకనం: ఆబ్జెక్టివ్ ఫంక్షన్‌ని ఉపయోగించి పొరుగు రాష్ట్రాల నాణ్యతను అంచనా వేయండి.
- ఉత్తమ రాష్ట్రాన్ని ఎంచుకోండి: ఉత్తమ ఆబ్జెక్టివ్ విలువతో పొరుగు రాష్ట్రాన్ని ఎంచుకోండి.
- పునరావృతం: మెరుగైన పొరుగు రాష్ట్రం కనుగొనబడనంత వరకు 2 నుండి 4 దశల ద్వారా పునరావృతం చేయండి.
ఉదాహరణ: Fibonacci ఫంక్షన్‌ని ఆప్టిమైజ్ చేయడం
F(0) = 0, F(1) = 1తో F(x) = F(x-1) + F(x-2) ఫంక్షన్ యొక్క ఆప్టిమైజేషన్ సమస్యను పరిగణించండి. Fibonacci మేము దీని కోసం 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 ఫంక్షన్‌ను ఆప్టిమైజ్ చేయడానికి స్థానిక శోధన పద్ధతిని ఉపయోగిస్తాము. Fibonacci మేము x యొక్క విభిన్న విలువల ద్వారా పునరావృతం చేస్తాము మరియు ప్రతి x వద్ద విలువను గణిస్తాము. మెరుగైన విలువ కనుగొనబడినప్పుడు, మేము ఉత్తమ విలువను మరియు దాని సంబంధిత xని నవీకరిస్తాము.