```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

const INF = 1000000000

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var n int
	fmt.Fscan(reader, &n)

	a := make([][]int, n)
	zeroExists := false
	zr, zc := -1, -1

	for i := 0; i < n; i++ {
		a[i] = make([]int, n)
		for j := 0; j < n; j++ {
			fmt.Fscan(reader, &a[i][j])
			if a[i][j] == 0 {
				zeroExists = true
				zr, zc = i, j
			}
		}
	}

	solve := func(factor int) ([][]int, [][]byte) {
		dp := make([][]int, n)
		path := make([][]byte, n)
		for i := 0; i < n; i++ {
			dp[i] = make([]int, n)
			path[i] = make([]byte, n)
			for j := 0; j < n; j++ {
				cost := 0
				if a[i][j] == 0 {
					cost = INF
				} else {
					val := a[i][j]
					for val > 0 && val%factor == 0 {
						cost++
						val /= factor
					}
				}

				if i == 0 && j == 0 {
					dp[i][j] = cost
					continue
				}

				up := INF
				left := INF
				if i > 0 {
					up = dp[i-1][j]
				}
				if j > 0 {
					left = dp[i][j-1]
				}

				if up < left {
					dp[i][j] = up + cost
					path[i][j] = 'D'
				} else {
					dp[i][j] = left + cost
					path[i][j] = 'R'
				}
			}
		}
		return dp, path
	}

	dp2, path2 := solve(2)
	dp5, path5 := solve(5)

	ans2 := dp2[n-1][n-1]
	ans5 := dp5[n-1][n-1]

	if zeroExists && ans2 > 1 && ans5 > 1 {
		fmt.Fprintln(writer, 1)
		for i := 0; i < zr; i++ {
			writer.WriteByte('D')
		}
		for i := 0; i < zc; i++ {
			writer.WriteByte('R')
		}
		for i := zr; i < n-1; i++ {
			writer.WriteByte('D')
		}
		for i := zc; i < n-1; i++ {
			writer.WriteByte('R')
		}
		writer.WriteByte('\n')
		return
	}

	var bestPath [][]byte
	if ans2 < ans5 {
		fmt.Fprintln(writer, ans2)
		bestPath = path2
	} else {
		fmt.Fprintln(writer, ans5)
		bestPath = path5
	}

	res := make([]byte, 0, 2*n)
	r, c := n-1, n-1
	for r > 0 || c > 0 {
		d := bestPath[r][c]
		res = append(res, d)
		if d == 'D' {
			r--
		} else {
			c--
		}
	}

	for i := len(res) - 1; i >= 0; i-- {
		writer.WriteByte(res[i])
	}
	writer.WriteByte('\n')
}
```