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

public class MWGPathfinder
{
	static int vertices,vstart,vend,histlen;
	static ArrayList[] adjlist; // array of arraylist of edges
	static double distance[];
	static int reps = 10000;
	static History globhist;
	static String datafile = "dv2.in";
	
	public static void main(String args[]) throws IOException
	{	
		BufferedReader f = new BufferedReader(new FileReader(datafile));
		StringTokenizer st = new StringTokenizer(f.readLine());
		vertices = Integer.parseInt(st.nextToken());
		int edges = Integer.parseInt(st.nextToken());
		vstart = Integer.parseInt(st.nextToken());
		vend = Integer.parseInt(st.nextToken());
		histlen = Integer.parseInt(st.nextToken());
		adjlist = new ArrayList[vertices];
		globhist = new History(vertices);
		for(int n=0; n<vertices; n++) adjlist[n] = new ArrayList();
		
		for(int n=0; n<edges; n++)
		{
			st = new StringTokenizer(f.readLine());
			int v1 = Integer.parseInt(st.nextToken());
			int v2 = Integer.parseInt(st.nextToken());
			double w = Double.parseDouble(st.nextToken());
			if(v1==v2||w<0) continue;
			Edge e = new Edge(v1,v2,w);
			adjlist[v1].add(e);
			adjlist[v2].add(e);	
			
			double h1;
			double h2=w;
			for(int h=0; h<histlen; h++)
			{
				h1 = Double.parseDouble(f.readLine());
				globhist.addEntry(v1,v2,h1,h2);
				h2=h1;
			}
		}
		//for(int n=0; n<vertices; n++) for(int i=0; i<adjlist[n].size(); i++) if(((Edge)adjlist[n].get(i)).getVertex(n)>n)
		//	System.out.println( n+" "+ ((Edge)adjlist[n].get(i)).getVertex(n)+" "+globhist.predictMutations( ((Edge)adjlist[n].get(i)).getWeight() ,5) );
		
		
/*		distance = new double[vertices];
		for(int n=0; n<vertices; n++) distance[n] = 0;
		for(int n=0; n<reps; n++) updateDists();
		for(int n=0; n<vertices; n++) System.out.print(distance[n]+"   ");
		System.out.println(); */


		int curvertex = vstart;
		double totalcost = 0;
		while(curvertex!=vend)
		{
			System.out.println(curvertex);
			Edge next = alg(curvertex);
			System.out.println(next.getVertex(-1)+"    "+next.getVertex(next.getVertex(-1)));
			totalcost += next.getWeight();
			curvertex = next.getVertex(curvertex);
			evolve();
		}
		
		System.out.println(totalcost);
		
		System.exit(0);
	}
	
	public static void evolve()
	{
		for(int v=0; v<vertices; v++)
			for(int e=0; e<adjlist[v].size(); e++)
			{
				Edge E = (Edge)adjlist[v].get(e);
				E.setWeight(evolfunc( E.getWeight() ));
			}
	}
	public static double evolfunc(double w)
	{
		return w;
		//return Math.exp(Math.random()*2-1)*w;
	}
	
	public static void updateDists()
	{
		double newdist[] = new double[vertices];
		for(int n=0; n<vertices; n++) newdist[n] = 0;
		for(int n=0; n<vertices; n++)
		{
			int degree = adjlist[n].size();
			double t = 1+distance[n];
			newdist[n]+=Math.pow(t,-(double)4);
			for(int a=0; a<degree; a++)
			{
				t = 1+distance[((Edge)adjlist[n].get(a)).getVertex(n)];
				newdist[n]+=Math.pow(t,-(double)4);
			}
		}
		for(int n=0; n<vertices; n++) distance[n] = Math.pow(newdist[n],-(double)1/4);
		distance[vend]=0;
		histlen++;
	}
	
	public static Edge alg(int curvertex)
	{
		return histuse(curvertex);
	}
	
	public static Edge greedy(int curvertex)
	{
		int bestans = -1;
		for(int n=0; n<adjlist[curvertex].size(); n++)
		{
			double dist = distance[((Edge)adjlist[curvertex].get(n)).getVertex(curvertex)];
			if(bestans<0||dist<distance[bestans])
				bestans = n;
		}
		return (Edge)adjlist[curvertex].get(bestans);
	}
	
	public static Edge dijkstra(int curvertex)
	{
		System.out.println("starting dijkstra on " + curvertex);
		if(curvertex==vend) {System.out.println("WTF? start=end?"); return null;}
		Vertex[] var = new Vertex[vertices];
		Heap heap = new Heap();
		double inf = Double.MAX_VALUE;
		for(int n=0; n<vertices; n++) if(n!=vend) var[n] = new Vertex(n, inf);
		var[vend] = new Vertex(vend, 0);
		for(int n=0; n<vertices; n++) heap.add(var[n]);
		
		heap.print();
		
		Edge beste = null; double bestw=inf;
		while(heap.size()>0)
		{
			Vertex v = (Vertex)heap.removeMin();
			System.out.println("hit vertex "+v.getIndex()+" with value "+v.getValue());
			if(v.getIndex()==curvertex) break;
			for(int n=0; n<adjlist[v.getIndex()].size(); n++)
			{
				Edge e = (Edge)adjlist[v.getIndex()].get(n);
				System.out.println("updating on "+e.getVertex(v.getIndex()));
				Vertex v2 = var[e.getVertex(v.getIndex())];
				if(v2.getIndex()==curvertex&&e.getWeight()+v.getValue()<bestw) {beste = e; bestw=e.getWeight()+v.getValue();}
				if(v2.isCovered()) continue;
				v2.setValue(Math.min(v2.getValue(),v.getValue()+e.getWeight()));
				heap.reheap(heap.getKey(v2.getIndex()));
			}
			v.cover();
		}
		
		if(beste==null)System.out.println("WTF? not connected?");
		return beste;
	}
	
	public static Edge histuse(int curvertex)
	{
		int tlimit = 10;
		double[] curvals = new double[vertices];
		double[] prevvals = new double[vertices];
		Edge[][] bestprev = new Edge[vertices][tlimit];
		int bestendtime = -1;
		double bestend = -1;
		double inf = Double.MAX_VALUE/5;
		for(int v=0; v<vertices; v++) prevvals[v] = inf;
		prevvals[curvertex] = 0;
		for(int t=0; t<tlimit; t++)
		{
			for(int v=0; v<vertices; v++)
			{
				curvals[v] = inf;
				for(int e=0; e<adjlist[v].size(); e++)
				{
					Edge E = (Edge)adjlist[v].get(e);
					if(prevvals[E.getVertex(v)]>=inf) continue;
					double x = globhist.predictMutations(E.getWeight(),t) + prevvals[E.getVertex(v)];
					if(x<curvals[v])
					{
						curvals[v] = x;
						bestprev[v][t] = E;
					}
				}
			}
			for(int v=0; v<vertices; v++)
				prevvals[v] = curvals[v];
			if(curvals[vend]<inf)
			{
				if(curvals[vend]<bestend||bestend<0)
				{
					bestendtime = t;
					bestend = curvals[vend];
				}
			}
			else if(t==tlimit-1) System.out.println("Time limit is insufficient for the width of this graph");
		}			
		int btrack = vend;
		for(int t=bestendtime; t>0; t--)
		{
			System.out.println(t + " " + btrack);
			btrack = bestprev[btrack][t].getVertex(btrack);
		}
		return bestprev[btrack][0];
	}
	
	/*pseudoalg
	-bfs to find shortest path using predicted values
	-for each timestep
	-for each vertex
	  find the best of each edge it could come from
	
	*/
}

class History
{
	TreeMap hmap;
	int hvertices;
	public History(int numv)
	{
		hmap = new TreeMap();
		hvertices = numv;
	}
	public void addEntry(int v1, int v2, double w1, double w2)
	{
		while(hmap.containsKey(new Double(w1))) w1+=0.0000000001;
		hmap.put(new Double(w1), new Double(w2));
	}
	public double predictMutation(double w1)
	{
		double ti=0;
		double pred=0;
		Iterator it = hmap.keySet().iterator();
		while(it.hasNext())
		{
			double d = ((Double)it.next()).doubleValue();
			double i = 1.0/(1+(d-w1)*(d-w1)*(d-w1)*(d-w1));
			ti+=i;
			pred+=i*(((Double)hmap.get(d)).doubleValue()-d);
		}
		return w1+pred/ti;
	}
	public double predictMutations(double w1, int steps)
	{
		for(int n=0; n<steps; n++) w1=predictMutation(w1);
		return w1;
	}
	
}

class Edge
{
	int ev1;
	int ev2;
	double ew;
	boolean evolved;
	public Edge(int v1, int v2, double w)
	{
		ev1=v1; ev2=v2; ew=w; evolved=false;
	}
	public void setWeight(double w)
	{
		evolved=!evolved;
		if(evolved) ew=w;
	}
	public double getWeight()
	{
		return ew;
	}
	public int getVertex(int a)
	{
		if(a==ev1) return ev2;
		if(a==ev2) return ev1;
		return Math.min(ev1,ev2);
	}
}

class Vertex implements Comparable
{
	int vindex;
	double vvalue;
	boolean vcovered;
	public Vertex(int index, double value)
	{
		vindex=index; vvalue=value; vcovered=false;
	}
	public double getValue()
	{
		return vvalue;
	}
	public int getIndex()
	{
		return vindex;
	}
	public boolean isCovered()
	{
		return vcovered;
	}
	public void setValue(double value)
	{
		vvalue = value;
	}
	public void cover()
	{
		vcovered = true;
	}
	public int compareTo(Object rhs)
	{
		double d = vvalue-((Vertex)rhs).getValue();
		if(d>0) return 1;
		if(d<0) return -1;
		return 0;
	}
}

class Heap
{
	ArrayList hal;
	ArrayList keys;
	int size;
	public Heap()
	{
		hal = new ArrayList();
		keys = new ArrayList();
		size=0;
	}
	public void add(Comparable o)
	{
		keys.add(new Integer(size));
		if(hal.size()==size)
			hal.add(size, o);
		else
			hal.set(size, o);
		size++;
		reheap(size-1);
	}
	public Object getMin()
	{
		return hal.get(0);
	}
	public int getKey(int k)
	{
		return ((Integer)keys.get(k)).intValue();
	}
	public Object removeMin()
	{
		if(size()==0) return null;
		Object o = hal.get(0);
		size--;
		swap(0,size);
		keys.set(((Vertex)hal.get(size)).getIndex(), new Integer(-1));
		hal.set(size, null);
		reheap(0);
		return o;
	}
	public void reheap(int pos)
	{
		int cur = pos;
		while(cur>0&&((Comparable)hal.get(cur)).compareTo((Comparable)hal.get((cur-1)/2))<0)
		{
			swap(cur, (cur-1)/2);
			cur=(cur-1)/2;
		}
		while(size>cur*2+1)
		{
			if(size>cur*2+2&&((Comparable)hal.get(cur*2+2)).compareTo((Comparable)hal.get(cur*2+1))<0)
			{
				if(((Comparable)hal.get(cur*2+2)).compareTo((Comparable)hal.get(cur))<0) 
				{ 
					swap(cur, cur*2+2);
					cur=cur*2+2;
				}
				else break;
			}
			else
			{
				if(((Comparable)hal.get(cur*2+1)).compareTo((Comparable)hal.get(cur))<0) 
				{
					swap(cur, cur*2+1);
					cur=cur*2+1;
				}
				else break;
			}
		}
	}
	public int size()
	{
		return size;
	}	
	public void print()
	{
		for(int n=0; n<size; n++) System.out.println(((Vertex)hal.get(n)).getValue());
	}
	void swap(int i1, int i2)
	{
		if(i1<0||i2<0||i1>=hal.size()||i2>=hal.size()||i1==i2) return;
		Object o = hal.get(i1);
		hal.set(i1, hal.get(i2));
		keys.set(((Vertex)hal.get(i2)).getIndex(),i1);
		hal.set(i2, o);
		keys.set(((Vertex)o).getIndex(),i2);
	}
}


/*

bfs:
for each time period 
for each vertex v
for each edge of v
update shortest distance to that vertex in time t greedily








*/