Fake Recognition mit Dijkstra

        //define keyboard neighbors (german layout)
        $neighbors = array(
            'q' => array('w','a','s'),
            'w' => array('q','e','d','s','a'),
            'e' => array('r','f','d','s','w'),
            'r' => array('e','t','d','f','g'),
            't' => array('r','z','f','g','h'),
            'z' => array('t','u','g','h','j'),
            'u' => array('z','h','j','k','i'),
            'i' => array('u','j','k','l','o'),
            'o' => array('i','k','l','ö','p'),
            'p' => array('o','l','ö','ä','ü'),
            'ü' => array('p','ö','ä'),
            'a' => array('q','w','s','y'),
            's' => array('a','q','w','e','d','x','y'),
            'd' => array('w','e','r','f','c','x','s'),
            'f' => array('e','r','t','g','v','c','d'),
            'g' => array('r','t','z','h','b','v','f'),
            'h' => array('t','z','u','j','n','b'),
            'j' => array('h','z','u','i','k','m','n'),
            'k' => array('j','u','i','o','l','m'),
            'l' => array('k','i','o','p','ö'),
            'ö' => array('l','p','ü','ä'),
            'y' => array('a','s','x'),
            'x' => array('y','s','d','c'),
            'c' => array('x','d','f','v'),
            'v' => array('c','f','g','v'),
            'b' => array('v','g,','h','n'),
            'n' => array('b','h','j','m'),
            'm' => array('n','j','k'),
            'ä' => array('ö','ü')
        );

        $points = array();
        $map = array();
        //generate routes
        foreach($neighbors as $letter => $n){
            $points[] = array($letter,$n,1);
        }

        //generate map
        foreach ($points as $point) {
            $x = $point[0];
            $y = $point[1];
            $c = $point[2];
            $map[$x][$y] = $c;
            $map[$y][$x] = $c;
        }
 
        //init map
        for ($i=0; $i < count($map); $i++) {
            $map[$i][$i] = 0;
        }

class Dijkstra {
 
	var $visited = array();
	var $distance = array();
	var $previousNode = array();
	var $startnode =null;
	var $map = array();
	var $infiniteDistance = 0;
	var $bestPath = 0;
	var $matrixWidth = 0;
 
	function Dijkstra(&$ourMap, $infiniteDistance) {
		$this -> infiniteDistance = $infiniteDistance;
		$this -> map = &$ourMap;
		$this -> bestPath = 0;
	}
 
	function findShortestPath($start,$to = null) {
		$this -> startnode = $start;
		foreach (array_keys($this->map) as $i) {
			if ($i == $this -> startnode) {
				$this -> visited[$i] = true;
				$this -> distance[$i] = 0;
			} else {
				$this -> visited[$i] = false;
				$this -> distance[$i] = isset($this -> map[$this -> startnode][$i])
					? $this -> map[$this -> startnode][$i]
					: $this -> infiniteDistance;
			}
			$this -> previousNode[$i] = $this -> startnode;
		}
 
		$maxTries = count($this->map);
		for ($tries = 0; in_array(false,$this -> visited,true) && $tries <= $maxTries; $tries++) { 			$this -> bestPath = $this->findBestPath($this->distance,array_keys($this -> visited,false,true));
			if($to !== null && $this -> bestPath === $to) {
				break;
			}
			$this -> updateDistanceAndPrevious($this -> bestPath);
			$this -> visited[$this -> bestPath] = true;
		}
	}
 
	function findBestPath($ourDistance, $ourNodesLeft) {
		$bestPath = $this -> infiniteDistance;
		$bestNode = 0;
		foreach ($ourNodesLeft as $node) {
			if($ourDistance[$node] < $bestPath) { 				$bestPath = $ourDistance[$node]; 				$bestNode = $node; 			} 		} 		return $bestNode; 	} 	function updateDistanceAndPrevious($obp) { 		foreach (array_keys($this->map) as $i) {
			if( 	isset($this->map[$obp][$i])
			    &&	($this->map[$obp][$i] != $this->infiniteDistance || $this->map[$obp][$i] == 0 )
				&&	($this->distance[$obp] + $this->map[$obp][$i] < $this -> distance[$i])
			)
			{
					$this -> distance[$i] = $this -> distance[$obp] + $this -> map[$obp][$i];
					$this -> previousNode[$i] = $obp;
			}
		}
	}
 
	function printMap(&$map) {
		$placeholder = ' %' . strlen($this -> infiniteDistance) .'d';
		$foo = '';
		for($i=0,$im=count($map);$i<$im;$i++) {
			for ($k=0,$m=$im;$k<$m;$k++) { 				$foo.= sprintf($placeholder, isset($map[$i][$k]) ? $map[$i][$k] : $this -> infiniteDistance);
			}
			$foo.= "\n";
		}
		return $foo;
	}
 
	function getResults($to = null) {
		$ourShortestPath = array();
		$foo = '';
		foreach (array_keys($this->map) as $i) {
			if($to !== null && $to !== $i) {
				continue;
			}
			$ourShortestPath[$i] = array();
			$endNode = null;
			$currNode = $i;
			$ourShortestPath[$i][] = $i;
			while ($endNode === null || $endNode != $this -> startnode) {
				$ourShortestPath[$i][] = $this -> previousNode[$currNode];
				$endNode = $this -> previousNode[$currNode];
				$currNode = $this -> previousNode[$currNode];
			}
			$ourShortestPath[$i] = array_reverse($ourShortestPath[$i]);
			if ($to === null || $to === $i) {
			if($this -> distance[$i] >= $this -> infiniteDistance) {
				$foo .= sprintf("no route from %d to %d. \n",$this -> startnode,$i);
			} else {
				$foo .= sprintf('%d => %d = %d [%d]: (%s).'."\n" ,
						$this -> startnode,$i,$this -> distance[$i],
						count($ourShortestPath[$i]),
						implode('-',$ourShortestPath[$i]));
			}
			$foo .= str_repeat('-',20) . "\n";
				if ($to === $i) {
					break;
				}
			}
		}
		return $foo;
	}
} // end class

        $wort = "asd";
        $elems = str_split($wort);
        $from = null;
        $to = null;
        $result = 0;
        for($i=0;$i<count($elems)-1;$i++){
            $from = $elems[$i];
            $to = $elems[$i+1];
            $result += $dijkstra->getResult($from,$to);
        }