Algartam Cuardaigh Heuristic i Java

Is modh cuardaigh cliste é an t-algartam Heoristic Search i Java ríomhchlárú a bhraitheann ar fhaisnéis mheasta(eolas) a úsáid chun an próiseas cuardaigh a threorú. Heuristics Is modh neas-réiteach fadhbanna é atá bunaithe ar eolas neamhfhoirfe agus ar fhaisnéis mheasta faoi staid reatha na faidhbe.

Conas a Oibríonn Algartam Cuardaigh Heoraíoch

Fostaíonn an t-algartam Heoristic Search feidhmeanna heorastúla chun "garacht" stáit don sprioc a mheas. Le linn gach atriallta cuardaigh, roghnaíonn an t-algartam treo cuardaigh bunaithe ar luachanna heorastúla na stát ionchasacha. Is é an sprioc an luach heuristic a bharrfheabhsú, rud a fhágann go dtiocfaidh réiteach garbh ar an bhfadhb.

Buntáistí agus Míbhuntáistí Algartam Cuardaigh Heuristic

Buntáistí:

• Cuardach Chliste: Úsáideann an algartam eolas measta chun an cuardach a threorú, ag barrfheabhsú ama agus acmhainní.
• Infheidhmeacht leathan: Heuristics is féidir é a chur i bhfeidhm ar fhadhbanna optamaithe agus cuardaigh éagsúla i gcásanna fíor-domhain.

Míbhuntáistí:

• Míchruinneas féideartha: Heuristics ag brath ar mheastachán agus ar fhaisnéis a d'fhéadfadh a bheith míchruinn, rud a fhágann go mbeidh réitigh neamhfhoirfe ann.

Sampla agus Míniú

Sampla coitianta den algartam Cuardach Heorastúil is ea an t-algartam A*, a úsáidtear chun an chonair is giorra ar léarscáil a aimsiú. Feicfimid conas a oibríonn an algartam seo:

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  
            // ...  
        }  
    }  
}  

Sa sampla thuas, úsáidimid an t-algartam A* chun an cosán is giorra ar léarscáil a fháil. Déantar nóid chomharsanachta a iniúchadh bunaithe ar an gcostas iomlán ar an nód reatha agus ar an meastachán heorastúil. Is é an toradh ná an cosán is giorra a aimsiú ón bpointe tosaigh go dtí an spriocphointe.