计算可以捕获的最大盗贼数量

Question

问题是这样的：

N * N 网格。

1. 网格的每个单元格都可以有由P 表示的警察或由T 表示的小偷。
2. 只有当他们在同一排时，警察才能抓住小偷。
3. 警察只能抓到一个小偷。
4. 警察无法抓住一个超过 K单位的小偷。

计算可以捕获的最大盗贼数量。

实施例

T P T
P T P
T T P

输出：3

方法：

我使用的方法是，警察需要抓住在给定范围内最远离他的小偷，即k。我使用了2个队列实现了这种方法，一个用于警察，另一个用于小偷。

在24个测试案例中，18个过去了，其余的答案都是错误的 如果方法有误，我想知道正确的答案 如果我错过了一些测试用例，我想知道。

您可以在下面找到我的代码段：

CODE：

import java.util.*;
public class policemenAndThief
{
    public int maxThiefCaught(char[][] mat,int k)
    {
        int count = 0;
        ArrayDeque<Integer> police = null;
        ArrayDeque<Integer> thief = null;
        int n = mat.length;
        for(int i = 0 ; i < n ; i++)
        {
            police = new ArrayDeque<>(n);
            thief = new ArrayDeque<>(n);
            for(int j = 0 ; j < n ; j++)
            {
                if(mat[i][j] == 'T')
                {
                    while(police.isEmpty() == false && j - police.peekFirst() > k)
                    {
                        police.pollFirst();
                    }

                    if(police.isEmpty())
                    {
                        thief.addLast(j);
                    }

                    else
                    {
                        police.pollFirst();
                        count++;
                    }
                }

                else
                {
                    while(thief.isEmpty() == false && j - thief.peekFirst() > k)
                    {
                        thief.pollFirst();
                    }

                    if(thief.isEmpty())
                    {
                        police.addLast(j);
                    }

                    else
                    {
                        thief.pollFirst();
                        count++;
                    }

                }
            }
        }
        return count;
    }
}

Answer 1

使用链接列表：

int count = 0;
        for (int i = 0; i < N; i++) {
            String row = N_A[i];
            LinkedList<Integer> policeList = new LinkedList<>();
            LinkedList<Integer> thiefList = new LinkedList<>();
            for (int j = 0; j < N; j++) {
                char c = row.charAt(j);
                int jk = j + 1;
                if (c == 'T') {
                    boolean add = true;
                    while (!policeList.isEmpty()) {
                        int p = policeList.pollFirst();
                        if ((jk - p) <= k) {
                            count++;
                            add = false;
                            break;
                        }
                    }
                    if (add) {
                        thiefList.add(jk);
                    }

                } else {
                    boolean add = true;
                    while (!thiefList.isEmpty()) {
                        int t = thiefList.pollFirst();
                        if ((jk - t) <= k) {
                            count++;
                            add = false;
                            break;
                        }
                    }
                    if (add) {
                        policeList.add(jk);
                    }
                }
            }
        }
        System.out.println(count);

Answer 2

C ++解决方案：

   String[] arrOfStr = str.split(" ", 3);
 String str1 =  arrOfStr[0];
 int int2 = Integer.parseInt (arrOfStr[1]);
 int int3 =  Integer.parseInt (arrOfStr [2]);

它通过了所有24个测试用例。