Problem:
A さんと B 君は，N × M の長方形のマス目状の地域に住んでいる．各マス目は道か壁か家のどれかである．この地域は，道が複雑で入り組んでいるので痴漢被害がよく起こることで有名であるため，この地域と外部との境界は全て壁で囲まれており，隔離されている．

B 君はなんとなく気が向いたので，A さんの家を眺めに行くことにした．しかし，不幸なことにB 君は明らかに怪しい顔をしているので，A さんの家に行く途中に少しでも痴漢の疑いがあるような行動を取ったらすぐに捕まってしまうだろう．特に，右手を壁から離して歩くことは絶対にやってはならない．B 君は，一瞬たりとも右手を離すことなく，A さんの家に辿り着くことが出来るだろうか？

B 君はつねに上下左右いずれかの方向を向いていて，B 君の右手が届く範囲はB 君の向いている方向に対して正面，斜め右前，右，斜め右後ろの4 マスのみである．B 君は，次のいずれかの行動を繰り返す．ただし，これらを同時に行うことは出来ない．

前方に壁がない場合，1 マス進む．

向いている方向を90 度右に変える．

向いている方向を90 度左に変える．

右手が接するマスを変える．ただし，この時にB 君は右手を離すことが出来ないので，変更前のマスと変更後のマスの間には共通した点を持っていなくてはならない．

Input

入力は以下の形式で与えられる．

N M
S1
S2
:
SN

Si (1 ≤ i ≤ N) は， M 文字の文字列で各文字は次を表す．

"^"，"v"，"<"，">" は B 君の最初の位置と最初に向いている方向（上下左右の向き）を表す．

"." は，何もないマスである．B 君は，このマスの上を移動することができる．

"#" は，壁を表す．壁の上を移動することは出来ない．

"G" は A さんの家の位置を表す．B 君は，A さんの家にたどり着くまで移動を繰り返す．

Constraints

1 ≤ N ≤ 50

1 ≤ M ≤ 50

入力には，文字 "^"，"v"，"<"，">" のうちいずれかが必ず一つのみ現れる．

同様に，入力には，文字 "G" が必ず一つのみ現れる．

初期状態では，B 君が向いている方向から右の壁にB 君の右手が接している．

Output

一度も右手を離さずにA さんの家に辿り着くことが出来る場合には，A さんの家にたどり着くまでに通った異なるマスの数の最小値を出力せよ．A さんの家に辿り着くことが出来ない場合には，-1 を出力せよ．

Sample Input 1

3 3
G##
.#.
.<.

Output for the Sample Input 1

4

Sample Input 2

3 3
G##
.#.
.>.

Output for the Sample Input 2

6

Sample Input 3

3 3
...
.G.
.>.

Output for the Sample Input 3

-1

Sample Input 4

4 4
....
.#.G
...#
^#..

Output for the Sample Input 4

8

Solution in Ruby (judge verdict: Accepted)

# Header {{{
require 'set'

def assert(p)
  raise 'Assertion Failed' unless p
end

# Constants {{{
INF = 10**9
# }}}

# IO {{{
class MyIO
  def initialize
    @input = $stdin
    @output = $stdout
  end

  # @param filename [String]
  def set_input(filename)
    @input = File.open(filename, 'r')
  end

  def set_output(filename)
    @output = File.open(filename, 'w')
  end

  def int
    gets.to_i
  end

  def ints
    split.map(&:to_i)
  end

  def split
    @input.gets.chomp.split(' ')
  end
  alias_method :strings, :split

  def gets
    @input.gets.chomp
  end
  alias_method :string, :gets

  def puts(*args)
    @output.puts(*args)
  end
end

io = MyIO.new
# }}}

# Algorithms {{{

def lower_bound(arr, val)
  assert(arr.is_a?(Array))
  low, high = 0, arr.size
  while high - low > 1
    mid = (low + high) / 2
    if arr[mid] < val
      low = mid
    else
      high = mid
    end
  end
  if arr[low] >= val
    low
  else
    high
  end
end

def upper_bound(arr, val)
  assert(arr.is_a?(Array))
  low, high = 0, arr.size
  while high - low > 1
    mid = (low + high) / 2
    if arr[mid] <= val
      low = mid
    else
      high = mid
    end
  end
  if arr[low] > val
    low
  else
    high
  end
end

# }}}

# }}}

# io.set_input('inputs/3')

n, m = io.ints
field = Array.new(n)
n.times do |i|
  field[i] = io.string.split('')
  field[i] << '#'
  field[i].unshift '#'
end
field << Array.new(m+2, '#')
field.unshift Array.new(m+2, '#')

n += 2
m += 2
gy, gx, state = nil, nil, nil
n.times do |i|
  m.times do |j|
    if ['^', '>', 'v', '<'].include?(field[i][j])
      state = { y: i, x: j, dir: ['^', '>', 'v', '<'].index(field[i][j]), hand: :right, cells: Set.new([[i, j]]) }
      field[i][j] = '.'
    end
    if field[i][j] == 'G'
      gy, gx = i, j
      field[i][j] = '.'
    end
  end
end

def rotate(dydx, dir)
  return dydx if dir == 0
  dy, dx = dydx
  dydx = [dx, dy * -1]
  rotate(dydx, dir-1)
end

class Heap
  def initialize(&comparator)
    @arr = []
    @comparator = comparator || lambda { |lhs, rhs| lhs < rhs }
  end

  def push(v)
    @arr << v
    last_i = @arr.size - 1
    @arr[0], @arr[last_i] = @arr[last_i], @arr[0]
    make_heap!
  end
  alias_method :<<, :push

  def pop
    if @arr.size == 1
      @arr.pop
    else
      ret = @arr.first
      @arr[0] = @arr.pop
      make_heap!
      ret
    end
  end

  def top
    @arr.first
  end

  def empty?
    @arr.empty?
  end

  private

  def make_heap!
    make_heap_at!(0)
  end

  def make_heap_at!(i)
    return unless @arr[i]
    l, r = left(i), right(i)
    if @arr[l] && !@comparator.call(@arr[i], @arr[l])
      @arr[i], @arr[l] = @arr[l], @arr[i]
      make_heap_at!(l)
    elsif @arr[r] && !@comparator.call(@arr[i], @arr[r])
      @arr[i], @arr[r] = @arr[r], @arr[i]
      make_heap_at!(r)
    end
  end

  def parent(i)
    (i - 1) / 2
  end

  def left(i)
    i * 2 + 1
  end

  def right(i)
    i * 2 + 2
  end
end

dy = [-1, 0, 1, 0]
dx = [0, 1, 0, -1]
HAND_POSITIONS = [:front, :frontright, :right, :backright]
dydx_by_hand = { front: [-1, 0], frontright: [-1, 1], right: [0, 1], backright: [1, 1] }
dp = Array.new(n) { Array.new(m) { Array.new(4) { Hash.new(nil) } } }
q = Heap.new { |rhs, lhs| rhs[:cells].size <=> lhs[:cells].size }
q.push(state)
while !q.empty?
  state = q.pop
  y, x, dir, hand, cells = state[:y], state[:x], state[:dir], state[:hand], state[:cells]
  next if dp[y][x][dir][hand]
  dp[y][x][dir][hand] = cells

  # Move front
  if field[y + dy[dir]][x + dx[dir]] == '.' && [:frontright, :right].include?(hand)
    q << { y: y + dy[dir], x: x + dx[dir], dir: dir, hand: hand == :frontright ? :right : :backright, cells: cells + Set.new([[y+dy[dir], x+dx[dir]]]) }
  end

  # Turn right
  if [:right, :backright].include?(hand)
    q << { y: y, x: x, dir: (dir + 1) % 4, hand: hand == :right ? :front : :frontright, cells: cells }
  end

  # Turn left
  if [:front, :frontright].include?(hand)
    q << { y: y, x: x, dir: (dir + 4 - 1) % 4, hand: hand == :front ? :right : :backright, cells: cells }
  end

  # Move hand
  HAND_POSITIONS.each do |next_hand|
    next if hand == next_hand
    _dy, _dx = rotate(dydx_by_hand[next_hand], dir)
    if (hand == :backright && next_hand != :right) || ([:front, :frontright].include?(hand) && next_hand == :backright)
      rdy, rdx = rotate(dydx_by_hand[:right], dir)
      if field[y + rdy][x + rdx] == '#' && field[y + _dy][x + _dx] == '#'
        q << { y: y, x: x, dir: dir, hand: next_hand, cells: cells }
      end
    else
      if field[y + _dy][x + _dx] == '#'
        q << { y: y, x: x, dir: dir, hand: next_hand, cells: cells }
      end
    end
  end
end

ans = nil
dp[gy][gx].each do |t|
  t.each do |k, v|
    ans ||= v.size
    ans = [ans, v.size].min
  end
end

puts ans ? ans : -1

# vim: foldmethod=marker