Algoritma Panelusuran Heuristik ing Java

Algoritma Panelusuran Heuristik minangka metode telusuran cerdas ing Java pemrograman sing gumantung nggunakake informasi perkiraan(kawruh) kanggo nuntun proses panelusuran. Heuristics minangka cara kira-kira pemecahan masalah adhedhasar kawruh sing ora sampurna lan perkiraan informasi babagan kahanan saiki.

Cara Kerja Algoritma Panelusuran Heuristik

Algoritma Panelusuran Heuristik nggunakake fungsi heuristik kanggo ngevaluasi "kecekatan" negara menyang tujuan. Sajrone saben iterasi telusuran, algoritma milih arah telusuran adhedhasar nilai heuristik negara potensial. Tujuane kanggo ngoptimalake nilai heuristik, ngarah menyang solusi kira-kira kanggo masalah kasebut.

Kaluwihan lan Kaluwihan saka Algoritma Panelusuran Heuristik

Kaluwihan:

• Panelusuran cerdas: Algoritma nggunakake perkiraan kawruh kanggo nuntun telusuran, ngoptimalake wektu lan sumber daya.
• Aplikasi sing wiyar: Heuristics bisa ditrapake kanggo macem-macem masalah optimasi lan telusuran ing skenario nyata.

Kekurangan:

• Potensi ora akurat: Heuristics gumantung marang estimasi lan informasi sing bisa uga ora akurat, nyebabake solusi sing ora sampurna.

Tuladha lan Panjelasan

Conto umum saka algoritma Heuristic Search yaiku algoritma A*, sing digunakake kanggo nemokake jalur paling cedhak ing peta. Ayo ndeleng carane algoritma iki bisa digunakake:

import java.util.*;  
  
class Node {  
    int x, y;  
    int cost, heuristic;  
  
    Node(int x, int y, int cost, int heuristic) {  
        this.x = x;  
        this.y = y;  
        this.cost = cost;  
        this.heuristic = heuristic;  
    }  
}  
  
public class HeuristicSearchExample {  
    static int heuristic(int x, int y, int targetX, int targetY) {  
        return Math.abs(targetX- x) + Math.abs(targetY- y);  
    }  
  
    static void heuristicSearch(int[][] grid, int startX, int startY, int targetX, int targetY) {  
        PriorityQueue<Node> pq = new PriorityQueue<>((a, b) ->(a.cost + a.heuristic)-(b.cost + b.heuristic));  
        pq.offer(new Node(startX, startY, 0, heuristic(startX, startY, targetX, targetY)));  
  
        while(!pq.isEmpty()) {  
            Node current = pq.poll();  
            int x = current.x;  
            int y = current.y;  
  
            if(x == targetX && y == targetY) {  
                System.out.println("Found target at(" + x + ", " + y + ")");  
                return;  
            }  
  
            // Explore neighboring nodes and add to the priority queue  
            // based on total cost and heuristic  
            // ...  
        }  
    }  
}  

Ing conto ing ndhuwur, kita nggunakake algoritma A * kanggo nemokake dalan paling cendhak ing peta. Node tetanggan ditliti adhedhasar biaya total simpul saiki lan estimasi heuristik. Asil nemokake dalan paling cendhak saka titik wiwitan menyang titik target.