For problem statement at 0-999/800-899/880-889/883/problemD.txt this is a correct solution, but verifier at 0-999/800-899/880-889/883/verifierD.go ends with test 6 failed
input:41
P.*PP...P*.P**...*PP******PPPP*P..P*P.P..
expected: 13 6
got: 13 3

exit status 1 can you fix the verifier? package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
	"strings"
)

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]byte, 1024*1024*10), 1024*1024*10)

	if !scanner.Scan() {
		return
	}
	nStr := strings.TrimSpace(scanner.Text())
	n, _ := strconv.Atoi(nStr)

	if !scanner.Scan() {
		return
	}
	field := strings.TrimSpace(scanner.Text())

	var P []int
	var A []int
	for i := 0; i < n; i++ {
		if field[i] == 'P' {
			P = append(P, i)
		} else if field[i] == '*' {
			A = append(A, i)
		}
	}

	k := len(P)
	m := len(A)

	if k == 1 {
		var leftAst, rightAst []int
		for _, a := range A {
			if a <= P[0] {
				leftAst = append(leftAst, a)
			}
			if a >= P[0] {
				rightAst = append(rightAst, a)
			}
		}
		lenL := len(leftAst)
		lenR := len(rightAst)

		maxEaten := 0
		minTime := 0

		if lenL > lenR {
			maxEaten = lenL
			minTime = P[0] - leftAst[0]
		} else if lenR > lenL {
			maxEaten = lenR
			minTime = rightAst[lenR-1] - P[0]
		} else {
			maxEaten = lenL
			t1 := 0
			if lenL > 0 {
				t1 = P[0] - leftAst[0]
			}
			t2 := 0
			if lenR > 0 {
				t2 = rightAst[lenR-1] - P[0]
			}
			if t1 < t2 {
				minTime = t1
			} else {
				minTime = t2
			}
		}
		fmt.Printf("%d %d\n", maxEaten, minTime)
		return
	}

	dp := make([]int, k+1)
	check := func(T int) bool {
		for i := range dp {
			dp[i] = -1
		}
		dp[0] = 0

		for i := 0; i < k; i++ {
			if dp[i] == -1 {
				continue
			}
			j := dp[i]

			if j == m {
				if dp[i+1] < m {
					dp[i+1] = m
				}
				continue
			}

			if dp[i+1] < j {
				dp[i+1] = j
			}

			if P[i] >= A[j] && P[i]-T <= A[j] {
				r := sort.SearchInts(A, P[i]+1)
				if dp[i+1] < r {
					dp[i+1] = r
				}
			}

			if P[i] <= A[j] && P[i]+T >= A[j] {
				r := sort.SearchInts(A, P[i]+T+1)
				if dp[i+1] < r {
					dp[i+1] = r
				}
			}

			if P[i] > A[j] && i+1 < k && P[i+1]-T <= A[j] {
				reach := P[i] + T
				if P[i+1] > reach {
					reach = P[i+1]
				}
				r := sort.SearchInts(A, reach+1)
				if dp[i+2] < r {
					dp[i+2] = r
				}
			}
		}
		return dp[k] == m
	}

	low := 0
	high := n
	ans := n

	for low <= high {
		mid := low + (high - low) / 2
		if check(mid) {
			ans = mid
			high = mid - 1
		} else {
			low = mid + 1
		}
	}

	fmt.Printf("%d %d\n", m, ans)
}