உள்ளூர் தேடல் (Local Search) அல்காரிதம் Java

உள்ளூர் தேடல் அல்காரிதம் என்பது நிரலாக்கத்தில் ஒரு தேடல் நுட்பமாகும் Java, இது தற்போதைய தீர்வுக்கு அருகில் தேடுவதன் மூலம் தீர்வுகளை மேம்படுத்துவதில் கவனம் செலுத்துகிறது. முழு தீர்வு இடத்தையும் தேடுவதற்குப் பதிலாக, அல்காரிதம் ஒரு சிறிய "அருகில்" தீர்வுகளைக் கண்டறிவதில் கவனம் செலுத்துகிறது.

உள்ளூர் தேடல் அல்காரிதம் எவ்வாறு செயல்படுகிறது

அல்காரிதம் ஆரம்ப தீர்விலிருந்து தொடங்குகிறது மற்றும் அருகிலுள்ள சிறந்த தீர்வுகளைத் தேடுவதன் மூலம் அதை மேம்படுத்த தொடர்ந்து முயற்சிக்கிறது. அல்காரிதம் அருகிலுள்ள தீர்வுகள் மூலம் மீண்டும் செயல்படுகிறது மற்றும் அவற்றில் சிறந்த தீர்வைத் தேர்ந்தெடுக்கிறது.

உள்ளூர் தேடல் அல்காரிதத்தின் நன்மைகள் மற்றும் தீமைகள்

நன்மைகள்:

• செயல்திறன்: அல்காரிதம் முழு இடத்துக்குப் பதிலாக அருகிலுள்ள மாநிலங்களைத் தேடுவதன் மூலம் பெரிய சிக்கல் இடைவெளிகளில் பெரும்பாலும் வேகமாகச் செயல்படுகிறது.
• ஒருங்கிணைப்பு: தேடல் செயல்திறனை மேம்படுத்த மற்ற முறைகளுடன் இணைக்கலாம்.

தீமைகள்:

• லோக்கல் ஆப்டிமா: உலகளாவிய தீர்வைக் கண்டறியாமல், அல்காரிதம் ஒரு உள்ளூர் உகந்த புள்ளியாக மாறக்கூடும்.

எடுத்துக்காட்டு மற்றும் விளக்கம்

உள்ளூர் தேடல் அல்காரிதத்தின் நிஜ வாழ்க்கை உதாரணம் போக்குவரத்து வழியை மேம்படுத்துவதாகும். இந்த அல்காரிதம் எவ்வாறு செயல்படுகிறது என்பதைப் பார்ப்போம்:

import java.util.*;  
  
public class LocalSearchExample {  
    static double evaluateSolution(double[] solution) {  
        // Function to evaluate the quality of a solution  
        // Lower value indicates a better solution  
        return 1.0 /(1.0 + solution[0] + solution[1]);  
    }  
  
    static double[] localSearch(double[] initialSolution, double stepSize, int maxIterations) {  
        double[] currentSolution = Arrays.copyOf(initialSolution, initialSolution.length);  
        double currentEvaluation = evaluateSolution(currentSolution);  
  
        for(int i = 0; i < maxIterations; i++) {  
            double[] nextSolution = Arrays.copyOf(currentSolution, currentSolution.length);  
            nextSolution[0] += stepSize;  
            double nextEvaluation = evaluateSolution(nextSolution);  
  
            if(nextEvaluation < currentEvaluation) {  
                currentSolution = nextSolution;  
                currentEvaluation = nextEvaluation;  
            } else {  
                stepSize /= 2;  
            }  
        }  
  
        return currentSolution;  
    }  
}  

மேலே உள்ள எடுத்துக்காட்டில், எண்ணியல் தீர்வை மேம்படுத்த உள்ளூர் தேடல் அல்காரிதத்தைப் பயன்படுத்துகிறோம். அல்காரிதம் ஒரு நிலையான படியை மாற்றுவதன் மூலம் தற்போதைய தீர்வுக்கு அருகில் தேடுகிறது மற்றும் புதிய தீர்வு சிறந்ததா என சரிபார்க்கிறது. இதன் விளைவாக, அல்காரிதம் படிப்படியாக காலப்போக்கில் ஒரு சிறந்த தீர்வைக் காண்கிறது.