Question

我有一个大小为m*m的2D数组，其元素值为0或1。此外，阵列的每列具有1s的连续块（在该块外部为0）。数组本身太大而无法保存在内存中（多达10 ^ 6行），但对于每一列，我可以确定下限a和上限b，该列中的1。对于给定的n，我需要找出最大数量为1的n个连续行。我可以通过逐个计算每一行的总和，然后选择n个连续的行来实现较小的数字，其总和最大，但对于大数字，它消耗了太多时间。有没有有效的计算方法？也许使用动态编程？

这是一个示例代码片段，显示了我当前的方法，其中对read_int()的连续调用（此处未给出）提供了连续列的下限和上限：

   long int harr[10000]={0};       //initialized to zero
   for(int i=0;i<m;i++)
    {
        a=read_int();
        b=read_int();
        for(int j=a;j<=b;j++)        // for finding sum of each row
           harr[j]++;
    }
   answer=0;
    for(int i=0;i<n;i++)
    {
        answer=answer+harr[i];
    }
    current=answer;
    for(int i=n;i<m;i++)
    {
        current=current+harr[i]-harr[i-n];
        if(current>answer)
        {
            answer=current;
        }
    }

例如（m = 6且n = 3）

这里的答案是第1行到第3行，这些行的总计1计数为13。（第2行到第4行也最大化总和，因为存在平局。）

Answer 1

这是一种不同的方法。将每对a，b视为定义形式[a，b + 1]的间隔。任务是找到n个连续索引，这些索引最大化该区间中数字的括号深度的总和。每个新的a都会将a处的括号深度增加1.每个新的b会导致 b后的括号深度减少1在第一遍 - 只需加载这些括号深度增量。然后一次传递从这些增量获得括号深度。以下代码说明了这种方法。为了测试目的，我将m减少为6，并通过访问硬连线数组（对应于问题中的示例）替换了对未知read_int()的调用：

#include <stdio.h> int main(void){ int a,b,answer,current,lower,upper; int n = 3; int lower_bound[6] = {0,1,2,3,1,2}; int upper_bound[6] = {3,4,3,5,2,4}; int m = 6; int harr[6]={0}; //load parenthesis depth-deltas (all initially 0) for(int i=0;i<m;i++) { a = lower_bound[i]; b = upper_bound[i]; harr[a]++; if(b < m-1)harr[b+1]--; } //determine p-depth at each point for(int i = 1; i < m; i++){ harr[i] += harr[i-1]; } //find optimal n-rows by sliding-window answer = 0; for(int i=0;i<n;i++) { answer = answer+harr[i]; } current =answer; lower = 0; upper = n-1; for(int i=n;i<m;i++) { current = current+harr[i]-harr[i-n]; if(current>answer) { answer = current; lower = i-n+1; upper = i; } } printf("Max %d rows are %d to %d with a total sum of %d ones\n", n,lower,upper,answer); return 0; }

（显然，加载harr的循环可以与计算answer的循环组合。我将它保留为两遍以更好地说明最终harr值的逻辑可以从括号增量中获得。）

编译并运行此代码时，其输出为：

Max 3 rows are 1 to 3 with a total sum of 13 ones

Answer 2

我不确定以下内容将如何缩放10^6行，但它会在没有函数调用开销的情况下管理单个传递中x个连续行的尾随总和。这可能值得一试。还要确保您正在使用完全优化进行编译，因此编译器也可以添加2美分。

我最初的想法是找到一些方法来阅读x * n整数（来自你的m x n矩阵）并以某种方式查看超过该数量的一组设定位字节。（检查字节顺序）并获取每个整数的第一个或最后一个字节以检查是否设置了一个位。但是，在尝试优化逻辑时，逻辑似乎只是简单地携带尾随x行的总和并单步执行数组。

我没有从你的数据中得到任何基准来进行比较，但也许这会给你一个或两个想法。

#include <stdio.h>
#include <stdlib.h>

#ifndef CHAR_BIT
#define CHAR_BIT  8
#endif

#ifndef INT_MIN
#define INT_MIN -(1U << (sizeof (int) * CHAR_BIT - 1))
#endif

int main (int argc, char **argv) {

    /* number of consecutive rows to sum */
    size_t ncr = argc > 1 ? (size_t)atoi (argv[1]) : 3;

    /* static array to test summing and row id logic, not
       intended to simulate the 0's or 1's */
    int a[][5] = {{1,2,3,4,5},
                  {2,3,4,5,6},
                  {3,4,5,6,7},
                  {4,5,6,7,8},
                  {3,4,5,6,7},
                  {0,1,2,3,4},
                  {1,2,3,4,5}};
    int sum[ncr];               /* array holding sum on ncr rows */
    int sumn = 0;               /* sum of array values */
    int max = INT_MIN;          /* variable holding maximum sum  */
    size_t m, n, i, j, k, row = 0, sidx;

    m = sizeof  a / sizeof *a;  /* matrix m x n dimensions */
    n = sizeof *a / sizeof **a;

    for (k = 0; k < ncr; k++)   /* initialize vla values */
        sum[k] = 0;

    for (i = 0; i < m; i++)     /* for each row */
    {
        sidx = i % ncr;         /* index for sum array */

        if (i > ncr - 1) {      /* sum for ncr prior rows */
            for (k = 0; k < ncr; k++)
                sumn += sum[k];
            /* note 'row' index assignment below is 1 greater
               than actual but simplifies output loop indexes */
            max = sumn > max ? row = i, sumn : max;
            sum[sidx] = sumn = 0; /* zero index to be replaced and sumn */
        }

        for (j = 0; j < n; j++) /* compute sum for current row */
            sum [sidx] += a[i][j];
    }

    /* output results */
    printf ("\n The maximum sum for %zu consecutive rows: %d\n\n", ncr, max);

    for (i = row - ncr; i < row; i++) {
        printf (" row[%zu] : ", i);
        for (j = 0; j < n; j++)
            printf (" %d", a[i][j]);
        printf ("\n");
    }

    return 0;
}

示例输出

$./bin/arraymaxn

 The maximum sum for 3 consecutive rows: 80

 row[2] :  3 4 5 6 7
 row[3] :  4 5 6 7 8
 row[4] :  3 4 5 6 7

$./bin/arraymaxn 4

 The maximum sum for 4 consecutive rows: 100

 row[1] :  2 3 4 5 6
 row[2] :  3 4 5 6 7
 row[3] :  4 5 6 7 8
 row[4] :  3 4 5 6 7

$ ./bin/arraymaxn 2

 The maximum sum for 2 consecutive rows: 55

 row[2] :  3 4 5 6 7
 row[3] :  4 5 6 7 8

注意：如果有多个等效的最大连续行（即两组行，其中1＆＃39; s加上相同的数字），则选择第一次出现的最大值。

我不确定您选择使用哪种优化，但无论您使用哪种代码，您都可以尝试使用简单的提示编译器内联所有函数（如果您的代码中有函数）和完全优化代码。两个有用的是：

gcc -finline-functions -Ofast

查找最大数量为1的2D数组的连续行

2 个答案: