Java 算法-网格中的警察和小偷（N*N）

问题陈述：
给定N*N矩阵，矩阵中的每个单元格包含警察或小偷。 找出被警方逮捕的小偷的数量

一名警察只能逮捕一名小偷

警察可以在同一排逮捕小偷

警察可以在K范围内抓捕小偷。（例如：如果K为1，则3号牢房的警察只能在2号和4号牢房抓捕小偷）

输入：
3 1->这里3是N，1是K
T P
T P
P P T

输出：
三,

我的解决方案因某些输入超时：

1. Iterate each row and have two Treeset<Integer> to store position of police and thief
2. If current item is Police, then check if thief Treeset is Not empty, 
   a.if so then iterate the treeset to find the position from thief set which 
   can be removed(satisfying above criteria), remove thief from treeset and 
   increment counter.
     a.1. If such item not available then add current position to police set
   b. if not then add position to police treeset

3. If current item is Thief, then do the same

1。迭代每一行，并有两个树集来存储警察和小偷的位置
2.如果当前项目是警察，则检查小偷树集是否为空，
a、 如果是这样，则迭代树集，从树集中找到
可以移除（满足上述标准），从树上移除小偷，并
递增计数器。
a、 一,。如果该项不可用，则将当前位置添加到警察集合
B如果没有，则将位置添加到警察树集
3.如果当前项目是小偷，则执行相同操作

完成一行的迭代后，再迭代下一行，最后打印计数器

计算一行的时间复杂度：
1.迭代一行中的每个元素O（n）
2.从树集合O（日志（n））添加或删除元素
绝对需要超过O（n*log（n））

---

请告诉我这是什么样的问题，以及我应该如何有效地解决。

这似乎可以通过贪婪的策略来解决。您可以使用队列存储警察和小偷的索引或指针（一个指针表示警察，一个指针表示小偷）

使用指针（或存储索引的变量），可以执行以下操作：

声明两个变量，例如

policyindex

和

thiefIndex

。对于每行：

将

policyindex

移动到该行下一个警察的索引，并将

thiefIndex

移动到该行下一个小偷的索引

比较

policyindex

和

thiefIndex

：

3.1。如果两者之间的绝对差值小于或等于

k

，则将逮捕次数增加一次。返回到步骤2

3.2。否则，根据所更改的索引，将最低索引（

policyindex

或

thiefIndex

）移动到下一个警察或小偷。返回到步骤3

重复此操作，直到

policyindex

或

thiefIndex

到达该行的末尾，然后转到下一行

对于队列，您将执行基本相同的策略：用该类型的所有索引填充每个队列（警察和小偷）；然后获取每个队列的第一个元素之间的差值，然后：如果它们的差值小于或等于

k

，则删除这两个元素并增加逮捕计数；否则，从两个队列中的一个队列中删除最低的索引，然后再次比较。重复此操作，直到任何队列为空。

使用C++:

可以使用向量代替再次迭代来查找索引

int solution (vector<vector<char> > A, int K) {
    int res=0;
   for(int i=0;i<A.size();i++)
   {
       vector<int> pol;
       vector<int> thi;
       for(int j=0;j<A[0].size();j++)
       {
           if (A[i][j] == 'P') 
            pol.push_back(j); 
        else if (A[i][j] == 'T') 
            thi.push_back(j);
       }

       // track lowest current indices of 
    // thief: thi[l], police: pol[r] 

       int l = 0, r = 0; 
    while (l < thi.size() && r < pol.size()) {
        if (abs(thi[l] - pol[r]) <= K) { 
            res++; 
            l++; 
            r++; 
        } 
        // increment the minimum index 
        else if (thi[l] < pol[r]) 
            l++;
        else
            r++; 
    }
    pol.clear();
    thi.clear();
   }
   return res;
}

int解（向量A，int K）{
int res=0；
对于（int i=0；i什么是对N（矩阵大小）的约束？提示：解决方案应该是
O（N^2）
。有N^2个单元格，每个单元格必须至少检查一次。但我认为你不需要检查一个单元格超过一个固定的次数。（根据我头脑中的算法：-），这意味着
O（N^2）
。如果你得到了警察的位置，一个解决方案可能是
O（P）
，其中
P
是警察的数量。（这也是对基于矩阵的问题的一点提示。）好的，现在我注意到外面有完全相同的问题（确切的措辞）…很有可能是那些在线比赛的问题，是吗？是的，同一个问题，是在在线测试中谢谢George，我的方法类似，但使用TreeSet而不是队列或指针，所以我认为这是一个问题。我不需要TreeSet以任何方式存储它order@George.我使用了队列，但a b这是不同的方法。我维持了两个队列。一个是警察队列，一个是小偷队列，存储警察索引。对于每一行，如果我遇到警察，我会查看小偷队列。我不断地抓捕小偷，直到我找到第一个在k范围内的小偷。如果在所有的抓捕之后。队列中没有留下任何元素.我让警察排队。如果在范围内有小偷，我会抓住小偷并增加计数。反之亦然，如果我遇到小偷，我会查看警察排队和我遵循的类似步骤。使用这些步骤，我无法清除所有测试案例。@Manya，我知道你正在使用ArrayDesk，但请尝试使用Linkedlist没有任何删除成本。我现在正在尝试，我的实现和你的一样，但是我使用了treeset，所以对于一些测试用例，它超时了。