import java.util.*;
import java.io.*;

class Route implements Comparable<Route> {
    private String start;
    private String end;
    private int length;

    public Route(String start, String end, int length){
        this.start = start;
        this.end = end;
        this.length = length;
    }

    public static Route add(Route a, Route b){
        if(a != null && b != null && (a.end.equalsIgnoreCase(b.start))){
            return new Route(a.start, b.end, a.length + b.length);
        }
        return null;
    }

    public Route add(Route b){
        return Route.add(this, b);
    }

    public int getLength(){
        return length;
    }

    public int compareTo(Route r){
        return Integer.compare(this.length, r.length);
    }

    public boolean hasCity(String city){
        return city.equalsIgnoreCase(start) || city.equalsIgnoreCase(end);
    }

    public boolean equals(Route route){
        boolean eqStart = this.start.equalsIgnoreCase(route.start);
        boolean eqEnd = this.end.equalsIgnoreCase(route.end);
        boolean eqLength = this.length == route.length;
        return (eqStart && eqEnd && eqLength);
    }

    public String toString(){
        return start + "-" + end + ", " + length + "km.";
    }
}

class RouteSorterByLength implements Comparator<Route> {
    public int compare(Route r1, Route r2){
        return Integer.compare(r1.getLength(), r2.getLength());
    }
}

class Utils {
    public static ArrayList<Route> filterByCity(ArrayList<Route> data, String city){
        ArrayList<Route> arr = new ArrayList<>();
        for(int i = 0; i < data.size(); ++i){
            if (data.get(i).hasCity(city)){
                arr.add(data.get(i));
            }
        }
        return arr;
    }

    public static void print(ArrayList<Route> data){
        for(int i = 0; i < data.size(); ++i){
            System.out.println(data.get(i));
        }
    }


    public static boolean isSorted(ArrayList<Route> data){
        for(int i = 0; i < data.size()-1; ++i){
            if(data.get(i).getLength() < data.get(i+1).getLength()){
            } else {
                return false;
            }
        }
        return true;
    }

    public static void sort(ArrayList<Route> data){
        while(!isSorted(data)){
            for(int i = 0; i < data.size()-1; ++i){
                if(data.get(i+1).getLength() < data.get(i).getLength()){
                    Collections.swap(data, i, i+1);
                }
            }
        }
    }
}

public class Sandbox {

    public static void main(String args[]) {
        try {
            ArrayList<Route> arr = new ArrayList<>();
            arr.add(new Route("Vilnius", "Kaunas", 100));
            arr.add(new Route("Kaunas", "Klaipeda", 200));
            arr.add(new Route("Vilnius", "Klaipeda", 300));
            arr.add(new Route("Kaunas", "Marijampole", 50));
            arr.add(new Route("Klaipeda", "Siauliai", 150));


            ArrayList<Route> hasKaunas = Utils.filterByCity(arr, "Kaunas");
            Collections.sort(hasKaunas, new RouteSorterByLength());

            Utils.print(hasKaunas);
            System.out.println(Utils.isSorted(hasKaunas));

            ArrayList<Route> hasKlaipeda = Utils.filterByCity(arr, "Klaipeda");
            Collections.sort(hasKlaipeda, new RouteSorterByLength());

            Utils.print(hasKlaipeda);
            System.out.println(Utils.isSorted(hasKlaipeda));




        } catch(Exception e){
            e.printStackTrace();
            System.out.println("Unexpected error, sorry!");
        }
    }
}