计算2D网格中的帧

Question

给定由0和1组成的[NxM]矩阵。 找到此矩阵中没有1（每个单元格为0）的方框数。 固定方框的框架是一组单元，它们中的每一个是最左边，最右边，最顶部或最底部的单元之一。 因此，边长为1的方框包含1个单元，边长2包含4个，边长3-8个单元，边长4-12个单元。

大小为4的示例框架是：

0000
0  0
0  0
0000

我们需要计算仅由0组成的方框数。

示例设N=3且M=4且矩阵为：

0100
0100
0000

然后答案是12，因为有10个一个大小的帧和2个两个大小的帧。

主要问题是N，M可以达到1 ≤ N ， M ≤ 2000 。 因此需要O(N^2)方法。

Answer 1

每个框架可以等同于一对矩阵的元素 - 相对的角。 假设左上和右下。 它们必须在对角线上，显而易见。 首先请注意，如果是例如。 ((1;1);(5;5))是我们的框架，元素(1;1)和(5;5)必须为空。 此外，从(1;1)向右和向下至少有四个空值。 从(5;5)向左和向上相同。 因此，第一个想法是计算每个元素x最小的空值向下和向左与自己（线性时间）。

如果我没有犯错，那就是例子：

-->(x;y) = (min(right, down); min(left,upward))

00000    (5;1)(1;1)(1;1)(2;1)(1;1)
01101    (1;1)(0;0)(0;0)(1;1)(0;0)
01001--->(1;1)(0;0)(2;1)(1;2)(0;0)
00000    (2;1)(1;1)(1;2)(1;4)(1;1)
01110    (1;1)(0;0)(0;0)(0;0)(1;1)

第二个想法：分别从左上角到右下角分析每条对角线。

1. （1; 1）
2. （2; 1）（0; 0）
3. （1; 1）（1; 1）（0; 0）
4. 等等...

你需要一些结构Q对，这将允许你：

• 擦除后继小于... O（lg n）的元素
• 计算前一个大于... O（lg n）的元素
• 添加对。 O（lg n）

将全局结果设置为null。 每个对角线的算法很容易。 取空​​Q.迭代以下元素， i = 0,1,2,... 每个：

• 擦除Q元素，其中后继小于i 。 （它可能只是最小继任者的元素。）
• 如果实际元素不是（0; 0）：
  • 推对，前身： i和后继：具有女巫实际元素的最后一个元素的数量可以配对。 它是i+x_i-1 ，其中x_i是实际元素的min(right, down) 。
  • 在Q中计算具有较大前驱的元素而不是i-y_i 。 这些是可以与实际元素配对的元素。 将该数字添加到“全局”结果中。

在全球结果中，您有答案。 它是O（NM log N）算法，我不确定，如果你能更快地完成它。

---

对角线的例子。 我们有table =（（5; 1），（0; 0），（2; 1），（1; 4），（1; 1））来分析。

Generally for element:
   Current element: (x;y); i=i           // O(1)
   Q.erase_smaller_than(i)              // O(lg N)
   if (x;y) == (0;0) :                  // O(1)
        skip element
   Q.emplace(i, i+x-1)                  // O(lg N)
   result += Q.count_bigger_than(i-y)   // O(lg N)


For diagonal example:

0. Q = {}
   result = 0
   for element in ((5;1),(0;0),(2;1),(1;4),(1;1))

1. Current element: (5;1); i = 0
   Q.erase_smaller_than(i)
   Q.emplace(i, i+5-1) // (0; 4)
   temp = Q.count_bigger(i-1) //taking only predecessor
   // bigger than -1, 1. element (frame with only one element)
   result += temp // result = 1

2. Current element: (0;0); i = 1
   Q.erase_smaller_than(i) //nothing changed
   (0;0) element, skip

3. Current element: (2;1); i = 2
   Q.erase_smaller_than(i) //nothing changed, Q = {(0;4)}
   Q.emplace(i, i+2-1) // (2;4)
   temp = Q.count_bigger(i-1) // only current element
   result += temp // result = 2

4. Current element (1;4); i = 3
   Q.erase_smaller_than(i) //Q = {(0;4)(2;4)}
   Q.emplace(i; i+1-1) // (3; 3)
   temp = Q.count_bigger(i-4) //all three elements from Q
   result += temp // result = 5\

5. Current element (1;1); i = 4
   Q.erase_smaller_than(i) // Q = {}
   Q.emplace(i;i+1-1) // (4;4)
   temp = Q.count_bigger(i-1) // only current element
   result += 1

6. End of loop. Print "On main diagonal $result frames have corners.".
   Continue that algorithm for next diagonal lines.

Answer 2

我用c＃中的代码解释了我的算法：

static void Main(string[] args)
{
    int[,] ar = new int[,] { {0,1,0,0}, 
                             {0,1,0,0}, 
                             {0,0,0,0} };

    int count = 0; // Count of square matrices
    int sum = 0;   // A temporary variable for checking validation of a square matrices

    int max = 0;   // Max size of square matrices for each point

    for (int i = 0; i < ar.GetLength(0) ; i++)
    {
        for (int j = 0; j < ar.GetLength(1); j++)
        {
            if (ar[i, j] == 0)
            {
                //calculate maximum size of square Matrices
                max = ar.GetLength(0) - i;
                if (max > ar.GetLength(1) - j)
                    max = ar.GetLength(1) - j;

                //Search kxk square matrice
                for (int k = 0; k < max; k++)
                {
                    sum = 0;
                    // Search Borders
                    for (int l = 1; l <= k; l++)
                    {
                        sum += ar[i + l, j];
                        sum += ar[i, j + l];
                        sum += ar[i + l, j + k];
                        sum += ar[i + k, j + l];
                        if (sum > 0)
                            break;
                    }
                    sum += ar[i + k, j + k];

                    if (sum == 0)
                        count++;
                }
            }
        }
    }

    Console.WriteLine("{0}", count.ToString());
    Console.ReadKey();
}

我用一个sum变量来发现它的所有边界点都是0。

Answer 3

一个帧总是左上角0 。 因此，您可以遍历矩阵（对于N和M内部），并且在每次迭代计数中，左上角元素为0所有帧。 在你的例子中：

0100
0100
0000

1. 对于N=1和M=1您可以找到1帧。
2. 接下来是N=1且M=2 。 你可以找到0帧。
3. 对于N=1和M=3您可以找到2 。

等等...