Problem:
Problem I: Mobile Network

The trafic on the Internet is increasing these days due to smartphones. The wireless carriers
have to enhance their network infrastructure.

The network of a wireless carrier consists of a number of base stations and lines. Each line connects two base stations bi-directionally. The bandwidth of a line increases every year and is given by a polynomial f(x) of the year x.

Your task is, given the network structure, to write a program to calculate the maximal bandwidth between the 1-st and N-th base stations as a polynomial of x.

Input

The input consists of multiple datasets. Each dataset has the following format:

N M

u1 v1 p1

...

uM vM pM

The first line of each dataset contains two integers N (2 ≤ N ≤ 50) and M (0 ≤ M ≤ 500), which indicates the number of base stations and lines respectively. The following M lines describe the network structure. The i-th of them corresponds to the i-th network line and contains two integers ui and vi and a polynomial pi. ui and vi indicate the indices of base stations (1 ≤ ui, vi ≤ N); pi indicates the network bandwidth.

Each polynomial has the form of:

aLxL + aL-1xL-1 + ... + a2x2 + a1x + a0

where L (0 ≤ L ≤ 50) is the degree and ai's (0 ≤ i ≤ L, 0 ≤ ai ≤ 100) are the coefficients. In the input,

each term aixi (for i ≥ 2) is represented as <ai>x^<i>

the linear term (a1x) is represented as <a1>x;

the constant (a0) is represented just by digits;

these terms are given in the strictly decreasing order of the degrees and connected by a
plus sign ("+");

just like the standard notations, the <ai> is omitted if ai = 1 for non-constant terms;

similarly, the entire term is omitted if ai = 0 for any terms; and

the polynomial representations contain no space or characters other than digits, "x", "^", and "+".

For example, 2x2 + 3x + 5 is represented as 2x^2+3x+5; 2x3 + x is represented as 2x^3+x, not 2x^3+0x^2+1x+0 or the like. No polynomial is a constant zero, i.e. the one with all the coefficients being zero.

The end of input is indicated by a line with two zeros. This line is not part of any dataset.

Output

For each dataset, print the maximal bandwidth as a polynomial of x. The polynomial should be represented in the same way as the input format except that a constant zero is possible and should be represented by "0" (without quotes).

Sample Input

3 3
1 2 x+2
2 3 2x+1
3 1 x+1
2 0
3 2
1 2 x
2 3 2
4 3
1 2 x^3+2x^2+3x+4
2 3 x^2+2x+3
3 4 x+2
0 0

Output for the Sample Input

2x+3
0
2
x+2

Solution in Ruby (judge verdict: Runtime Error)

require 'set'

class Graph
	def initialize(*options)
		@options = Set[*options]
	end

	def add_node(property = {})
		Node.new(property)
	end

	def add_edge(u, v, property = {})
		e = Edge.new(u, v, property)
		u.add_edge(e)
		v.add_edge(e)
		e
	end
	
	def del_edge(e)
		u, v = e.opposite.keys
		u.del_edge(e)
		v.del_edge(e)
		e
	end

	class Node
		def initialize(property)
			@property = property
			@edges = Set.new
		end

		def add_edge(e)
			@edges << e
		end

		def del_edge(e)
			@edges.delete(e)
		end

		def to_s
			@property[:name] || super
		end

		def each_edge
			@edges.each{|e| 
				yield e
			}
		end

		attr_reader :property
	end

	class Edge
		def initialize(u, v, property)
			@opposite = {u => v, v => u}
			@property = property
		end
		attr_reader :opposite, :property

		def to_s
			@property[:name] || super
		end

		def length
			@property[:length] || 1
		end
	end

	def each_out_connection_of(u)
		u.each_edge{|e|
			yield(e.opposite[u], e.length)
		}
	end

	alias :each_in_connection_of :each_out_connection_of
end

def get_path(s, t, reached = Set[s])
	return [t] if s == t
	s.each_edge do |e|
		v = e.opposite[s]
		next if reached.include?(v)

		cap = e.property[:capacity]
		flow = (e.property[:flow] ||= 0)
		to = (e.property[:flow_to] ||= v)
		rest = (to == v ? cap - flow : cap + flow)
		next if rest <= 0

		reached << v
		if path = get_path(v, t, reached)
			return [s, e, *path]
		end
	end	
	return nil
end

def compute_min(path)
	m = Float::INFINITY
	i = 0
	while i < path.size - 1
		u = path[i]
		e = path[i+1]
		v = path[i+2]
		cap = e.property[:capacity]
		flow = e.property[:flow]
		to = e.property[:flow_to]
		rest = (to == v ? cap - flow : cap + flow)
		m = rest if rest < m
		i += 2
	end
	m
end

def add_flow(df, path)
	i = 0
	while i < path.size - 1
		u = path[i]
		e = path[i+1]
		v = path[i+2]
		cap = e.property[:capacity]
		flow = e.property[:flow]
		to = e.property[:flow_to]

		if to == v && flow >= df
			e.property[:flow] -= df
		elsif to == v && flow < df
			e.property[:flow_to] = u
			e.property[:flow] = df - flow
		elsif to == u && flow >= df
			e.property[:flow] -= df
		else
			e.property[:flow_to] = v
			e.property[:flow] = df - flow
		end
		i += 2
	end
end

class Poly
	def initialize(s)
		@hash = Hash.new(0)
		s.chomp.split(?+).each do |term|
			if term =~ /(\d*)x(^(\d+))?/
				@hash[$2 ? $3.to_i : 1] = ($1 == "" ? 1 : $1.to_i)
			else
				@hash[0] = term.to_i
			end
		end
	end

	def +(poly)
		sum = self.class.new("")
		@hash.each {|k, a| sum.hash[k] += a}
		poly.hash.each {|k, a| sum.hash[k] += a}
		sum
	end

	def to_s
		ks = @hash.keys
		ks.delete_if {|k| !@hash[k] || @hash[k] == 0}
		return ?0 if ks.empty?
		ks.sort!
		ks.reverse!	
		ks.map {|k|
			[@hash[k] == 1 ? "" : @hash[k], k == 0 ? "" : ?x, k <= 1 ? "" : "^#{k}"].join
		}.join(?+)
	end

	attr_reader :hash
end

loop do
	n, m = gets.split.map(&:to_i)	
	break if n == 0
	g = Graph.new
	nodes = (0..n).map { g.add_node }
	edges = []

	x = 100000
	m.times do
		i, j, poly = gets.chomp.split
		poly.gsub!(?^, '**')
		poly.gsub!(/\dx/){|s| s[0..-2] + '*x'}
		e = g.add_edge(nodes[i.to_i], nodes[j.to_i])
		e.property[:poly_capacity] = poly
		e.property[:capacity] = eval(poly)
		edges << e
	end

	loop do
		path = get_path(nodes[1], nodes[n])
		break if !path
		min = compute_min(path)	
		add_flow(min, path)
	end
	saturated = edges.select{|e| e.property[:flow] == e.property[:capacity]}
	polys = saturated.map {|e| Poly.new(e.property[:poly_capacity])}
	puts (polys.inject(:+) || Poly.new(""))
end