PROGRAM ROYFLOYD(INPUT,OUTPUT);                             
(* SUCHE KUERZESTE WEGE ZWISCHEN ALLEN PUNKTEPAAREN *)      
CONST N=3;                                                  
TYPE INDEX=1..N;                                            
     LMATRIX=ARRAY[INDEX,INDEX] OF REAL;                    
VAR UM,UM1:LMATRIX;                                         
    I,J,M:INTEGER;                                          
                                                            
FUNCTION MIN(A,B:REAL):REAL;                                
BEGIN                                                       
 IF A<B THEN MIN:=A ELSE MIN:=B                             
END;                                                        
                                                            
PROCEDURE LESEN(VAR L:LMATRIX);                             
 VAR I,J:INDEX;                                             
BEGIN                                                       
 FOR I:=1 TO N DO                                           
  BEGIN                                                     
   FOR J:= 1 TO N DO                                        
     READ(L[I,J]);                                          
   READLN                                                   
  END;                                                      
END; (* LESEN *)                                            
                                                            
PROCEDURE ZEIGE(VAR L:LMATRIX);                             
 VAR I,J:INDEX;                                             
BEGIN                                                       
 FOR I:=1 TO N DO                                           
  BEGIN                                                     
   FOR J:= 1 TO N DO                                        
     WRITE(L[I,J]:3);                                       
   WRITELN                                                  
  END;                                                      
 WRITELN                                                    
END; (* ZEIGE *)                                            
                                                            
BEGIN                                                       
 LESEN(UM);                                                 
 FOR M:=1 TO N DO                                           
  BEGIN ZEIGE(UM);                                          
   FOR I:=1 TO N DO                                         
    FOR J:=1 TO N DO                                        
     UM1[I,J]:=MIN(UM[I,J],UM[I,M]+UM[M,J]);                
   UM:=UM1                                                  
  END;                                                      
 ZEIGE(UM);                                                 
END.