Problem:
Problem D: Cliff Climbing

At 17:00, special agent Jack starts to escape from the enemy camp.
There is a cliff in between the camp and the nearest safety zone.
Jack has to climb the almost vertical cliff
by stepping his feet on the blocks that cover the cliff.
The cliff has slippery blocks where Jack has to
spend time to take each step.
He also has to bypass some blocks that are too loose to support his weight.
Your mission is to write a program that calculates the minimum time to complete climbing.

Figure D-1 shows an example of cliff data that you will
receive.
The cliff is covered with square blocks.
Jack starts cliff climbing from the ground under the cliff,
by stepping his left or right foot on one of the blocks marked with
'S' at the bottom row.
The numbers on the blocks are the "slippery levels". It takes
t time units for him to safely put his foot on a
block marked with t, where 1 ≤ t ≤ 9.
He cannot put his feet on blocks marked with 'X'.
He completes the climbing when he puts
either of his feet on one of the blocks marked with 'T' at the top row.

Figure D-1: Example of Cliff Data

Jack's movement must meet the following constraints.
After putting his left (or right) foot on a block, he can only move
his right (or left, respectively) foot.
His left foot position (lx, ly) and his right foot position
(rx, ry) should satisfy
lx < rx
and | lx - rx | + | ly - ry | ≤ 3
.
This implies that, given a position of his left foot in Figure D-2 (a), he has to
place his right foot on one of the nine blocks marked with blue color.
Similarly, given a position of his right foot in Figure D-2 (b),
he has to place his
left foot on one of the nine blocks marked with blue color.

Figure D-2: Possible Placements of Feet

Input

The input is a sequence of datasets.
The end of the input is indicated by a line containing two zeros separated by a space.
Each dataset is formatted as follows:

w h

s(1,1) ... s(1,w)

s(2,1) ... s(2,w)

...

s(h,1) ... s(h,w)

The integers w and h are the width and the height of
the matrix data of the cliff. You may assume 2 ≤ w ≤ 30 and 5 ≤ h ≤ 60.
Each of the following h lines consists of w characters
delimited by a space.
The character s(y, x) represents the state of the block at
position
(x, y) as follows:

'S': Jack can start cliff climbing from this block.

'T': Jack finishes climbing when he reaches this block.

'X': Jack cannot put his feet on this block.

'1' - '9' (= t): Jack has to spend t time units
to put either of his feet on this block.

You can assume that it takes no time to put a foot on a block marked with 'S' or 'T'.

Output

For each dataset, print a line only having a decimal integer indicating
the minimum time required for the cliff climbing,
when Jack can complete it.
Otherwise, print a line only having "-1" for the dataset.
Each line should not have any characters other than these numbers.

Sample Input

6 6
4 4 X X T T
4 7 8 2 X 7
3 X X X 1 8
1 2 X X X 6
1 1 2 4 4 7
S S 2 3 X X
2 10
T 1
1 X
1 X
1 X
1 1
1 X
1 X
1 1
1 X
S S
2 10
T X
1 X
1 X
1 X
1 1
1 X
1 X
1 1
1 X
S S
10 10
T T T T T T T T T T
X 2 X X X X X 3 4 X
9 8 9 X X X 2 9 X 9
7 7 X 7 3 X X 8 9 X
8 9 9 9 6 3 X 5 X 5
8 9 9 9 6 X X 5 X 5
8 6 5 4 6 8 X 5 X 5
8 9 3 9 6 8 X 5 X 5
8 3 9 9 6 X X X 5 X
S S S S S S S S S S
10 7
2 3 2 3 2 3 2 3 T T
1 2 3 2 3 2 3 2 3 2
3 2 3 2 3 2 3 2 3 4
3 2 3 2 3 2 3 2 3 5
3 2 3 1 3 2 3 2 3 5
2 2 3 2 4 2 3 2 3 5
S S 2 3 2 1 2 3 2 3
0 0

Output for the Sample Input

12
5
-1
22
12

Solution in JAVA (judge verdict: Accepted)

import java.util.*;
import java.io.*;
import java.awt.geom.*;
import java.math.*;

public class Main {

	static final Reader in = new Reader();
	static final PrintWriter out = new PrintWriter(System.out,false);
	static boolean debug = false;

	static int[][][] directedGraph(int n, int[] s, int[] t, int[] cost) {
		int[] cnt = new int[n];
		for (int i : s) cnt[i]++;

		int[][][] g = new int[n][][];
		for (int i=0; i<n; i++) g[i] = new int[cnt[i]][2];
		for (int i=0; i<s.length; i++) {
			int from = s[i];
			int to = t[i];

			g[from][--cnt[from]][0] = to;
			g[from][cnt[from]][1] = cost[i];
		}

		return g;
	}

	static int[] dijkstra(int[][][] g, int source) {
		int n = g.length;

		final int[] d = new int[n];
		Arrays.fill(d, 1<<29);
		d[source] = 0;

		TreeSet<Integer> pQ = new TreeSet<Integer>(new Comparator<Integer>(){
			public int compare(Integer a, Integer b) {
				if (d[a] != d[b]) return d[a] - d[b];
				return a - b;
			}
		});
		pQ.add(source);

		while (!pQ.isEmpty()) {
			int cur = pQ.pollFirst();

			for (int i=0; i<g[cur].length; i++) {
				int next = g[cur][i][0];
				int dist = d[cur] + g[cur][i][1];
				if (dist < d[next]) {
					pQ.remove(next);
					d[next] = dist;
					pQ.add(next);
				}
			}
		}

		return d;
	}


	static boolean solve(){
		int w = in.nextInt();
		int h = in.nextInt();
		if (w + h == 0) return false;

		char[][] table = new char[h][w];
		for (int i=0; i<h; i++) {
			for (int j=0; j<w; j++) {
				table[i][j] = in.nextChar();
			}
		}

		int[] rx = {1, 1, 1, 2, 2, 3, 1, 1, 2};
		int[] ry = {0, 1, 2, 1, 0, 0, -1, -2, -1};

		int[] lx = {-1, -1, -1, -2, -2, -3, -1, -1, -2};
		int[] ly = {0, 1, 2, 1, 0, 0, -1, -2, -1};

		ArrayList<Integer> s = new ArrayList<>();
		ArrayList<Integer> t = new ArrayList<>();
		ArrayList<Integer> cost = new ArrayList<>();

		for (int i=0; i<h; i++) {
			for (int j=0; j<w; j++) {
				if (table[i][j] == 'X') continue;

				// r
				for (int k=0; k<9; k++) {
					int ni = i + ry[k];
					int nj = j + rx[k];
					if (ni < 0 || nj < 0 || h <= ni || w <= nj) continue;
					if (table[ni][nj] == 'X') continue;
					s.add(i*w+j);
					t.add(ni*w+nj + h*w);
					cost.add(table[ni][nj] == 'T' ? 0 : table[ni][nj] - '0');
				}

				// l
				for (int k=0; k<9; k++) {
					int ni = i + ly[k];
					int nj = j + lx[k];
					if (ni < 0 || nj < 0 || h <= ni || w <= nj) continue;
					if (table[ni][nj] == 'X') continue;
					s.add(i*w+j + h*w);
					t.add(ni*w+nj);
					cost.add((table[ni][nj] == 'T' ||table[ni][nj] == 'S') ? 0 : (table[ni][nj] - '0'));
				}
			}
		}

		int start = h*w*2;
		int goal = start + 1;

		for (int j=0; j<w; j++) {
			if (table[h-1][j] == 'S') {
				s.add(start);
				t.add((h-1)*w+j);
				cost.add(0);

				s.add(start);
				t.add((h-1)*w+j + h*w);
				cost.add(0);
			}
		}

		for (int j=0; j<w; j++) {
			if (table[0][j] == 'T') {
				s.add(0*w+j);
				t.add(goal);
				cost.add(0);

				s.add(0*w+j + h*w);
				t.add(goal);
				cost.add(0);
			}
		}

		int m = s.size();
		int[] ss = new int[m];
		int[] tt = new int[m];
		int[] cc = new int[m];
		for (int i=0; i<m; i++) {
			ss[i] = s.get(i);
			tt[i] = t.get(i);
			cc[i] = cost.get(i);
		}

		// dump(ss);
		// dump(tt);
		// dump(cc);

		int[][][] g = directedGraph(goal+1, ss, tt, cc);

		// dump(g);

		int[] d = dijkstra(g, start);

		out.println(d[goal] >= 1<<29 ? -1 : d[goal]);

		// dump(d);

		return true;
	}

	public static void main(String[] args) throws Exception {
		debug = args.length > 0;
		long start = System.nanoTime();

		while(solve());
		out.flush();

		long end = System.nanoTime();
		dump((end - start) / 1000000 + " ms");
		in.close();
		out.close();
	}

	static void dump(Object... o) { if (debug) System.err.println(Arrays.deepToString(o)); }
}

class Reader {
	private final InputStream in;
	private final byte[] buf = new byte[1024];
	private int ptr = 0;
	private int buflen = 0;

	public Reader() { this(System.in);}
	public Reader(InputStream source) { this.in = source;}

	private boolean hasNextByte() {
		if (ptr < buflen) return true;
		ptr = 0;
		try{
			buflen = in.read(buf);
		}catch (IOException e) {e.printStackTrace();}
		if (buflen <= 0) return false;
		return true;
	}

	private int readByte() { if (hasNextByte()) return buf[ptr++]; else return -1;}

	private boolean isPrintableChar(int c) { return 33 <= c && c <= 126;}

	private void skip() { while(hasNextByte() && !isPrintableChar(buf[ptr])) ptr++;}

	public boolean hasNext() {skip(); return hasNextByte();}

	public String next() {
		if (!hasNext()) throw new NoSuchElementException();
		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while (isPrintableChar(b)) {
			sb.appendCodePoint(b);
			b = readByte();
		}
		return sb.toString();
	}

	public long nextLong() {
		if (!hasNext()) throw new NoSuchElementException();
		boolean minus = false;
		long num = readByte();

		if(num == '-'){
			num = 0;
			minus = true;
		}else if (num < '0' || '9' < num){
			throw new NumberFormatException();
		}else{
			num -= '0';
		}

		while(true){
			int b = readByte();
			if('0' <= b && b <= '9')
				num = num * 10 + (b - '0');
			else if(b == -1 || !isPrintableChar(b))
				return minus ? -num : num;
			else
				throw new NoSuchElementException();
		}
	}

	public int nextInt() {
		long num = nextLong();
		if (num < Integer.MIN_VALUE || Integer.MAX_VALUE < num)
			throw new NumberFormatException();
		return (int)num;
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}

	public char nextChar() {
		if (!hasNext()) throw new NoSuchElementException();
		return (char)readByte();
	}

	public String nextLine() {
		while (hasNextByte() && (buf[ptr] == '\n' || buf[ptr] == '\r')) ptr++;
		if (!hasNextByte()) throw new NoSuchElementException();

		StringBuilder sb = new StringBuilder();
		int b = readByte();
		while (b != '\n' && b != '\r' && b != -1) {
			sb.appendCodePoint(b);
			b = readByte();
		}

		return sb.toString();
	}

	public int[] nextIntArray(int n) {
		int[] res = new int[n];
		for (int i=0; i<n; i++) res[i] = nextInt();
		return res;
	}

	public char[] nextCharArray(int n) {
		char[] res = new char[n];
		for (int i=0; i<n; i++) res[i] = nextChar();
		return res;
	}

	public void close() {try{ in.close();}catch(IOException e){ e.printStackTrace();}};
}