package main

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

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

type Pair struct {
	dp_val int
	j_idx  int
}

func find_j_min(target int, valid_dp []Pair) int {
	left := 0
	right := len(valid_dp) - 1
	ans := -1
	for left <= right {
		mid := (left + right) / 2
		if valid_dp[mid].dp_val >= target {
			ans = mid
			right = mid - 1
		} else {
			left = mid + 1
		}
	}
	return ans
}

func main() {
	input, _ := io.ReadAll(os.Stdin)
	pos := 0

	nextInt := func() int {
		for pos < len(input) && (input[pos] < '0' || input[pos] > '9') {
			pos++
		}
		if pos >= len(input) {
			return 0
		}
		res := 0
		for pos < len(input) && input[pos] >= '0' && input[pos] <= '9' {
			res = res*10 + int(input[pos]-'0')
			pos++
		}
		return res
	}

	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	t := nextInt()
	if t == 0 {
		return
	}

	for tc := 0; tc < t; tc++ {
		n := nextInt()

		p := make([]int, n+1)
		for i := 1; i <= n; i++ {
			p[i] = nextInt()
		}

		K := 0
		for (1 << K) <= n {
			K++
		}
		st := make([]int, K*(n+1))

		for i := 1; i <= n; i++ {
			st[0*(n+1)+i] = i + p[i]
		}
		for j := 1; j < K; j++ {
			length := 1 << (j - 1)
			for i := 1; i+length*2-1 <= n; i++ {
				st[j*(n+1)+i] = max(st[(j-1)*(n+1)+i], st[(j-1)*(n+1)+i+length])
			}
		}

		logArr := make([]int, n+1)
		for i := 2; i <= n; i++ {
			logArr[i] = logArr[i/2] + 1
		}

		query := func(L, R int) int {
			if L > R {
				return 0
			}
			j := logArr[R-L+1]
			return max(st[j*(n+1)+L], st[j*(n+1)+R-(1<<j)+1])
		}

		dp := make([]int, n+1)
		from := make([]int, n+1)
		dir := make([]byte, n+1)

		for i := 0; i <= n; i++ {
			dp[i] = -1
		}
		dp[0] = 0
		valid_dp := make([]Pair, 0, n+1)
		valid_dp = append(valid_dp, Pair{0, 0})

		for i := 1; i <= n; i++ {
			if dp[i-1] >= i {
				dp[i] = max(dp[i-1], i+p[i])
				from[i] = i - 1
				dir[i] = 'R'
			}

			target := i - p[i] - 1
			idx := find_j_min(target, valid_dp)
			if idx != -1 {
				j := valid_dp[idx].j_idx
				M := query(j+1, i-1)
				reach := max(dp[j], M)
				if reach >= i && reach > dp[i] {
					dp[i] = reach
					from[i] = j
					dir[i] = 'L'
				}
			}

			if dp[i] != -1 {
				if len(valid_dp) == 0 || dp[i] > valid_dp[len(valid_dp)-1].dp_val {
					valid_dp = append(valid_dp, Pair{dp[i], i})
				}
			}
		}

		if dp[n] < n {
			fmt.Fprintln(out, "NO")
		} else {
			fmt.Fprintln(out, "YES")
			ans := make([]byte, n+1)
			curr := n
			for curr > 0 {
				d := dir[curr]
				f := from[curr]
				if d == 'R' {
					ans[curr] = 'R'
					curr = f
				} else {
					ans[curr] = 'L'
					for k := f + 1; k < curr; k++ {
						ans[k] = 'R'
					}
					curr = f
				}
			}
			fmt.Fprintln(out, string(ans[1:]))
		}
	}
}