"Hashing" Algorithm Implementation - arrays

Question

I am given an input consisting of 2 parts, the first line consists of 2 numbers denoting the size of a matrix, N and M, followed by the matrix itself, A. The maximum size of the matrix is 1 <= N, M <= 100, and each of the elements of the matrix is 0 <= A[i][j] <= pow(10, 9). The "hash" is calculated by adding the elements in each column, and multiplying all the sums, modulo 1000000007 (pow(10, 9) + 7).
My code is as follows:
#include <stdio.h>
int main() {
int rows, cols;
scanf("%d %d", &rows, &cols); getchar();
unsigned long long int data[rows][cols];
for (int row = 0; row < rows; row++) {
for (int col = 0; col < cols; col++) {
scanf("%llu", &data[row][col]);
}
getchar();
}
unsigned long long int coltot[cols];
for(int i=0;i<cols;i++){coltot[i]=0;}
for (int row = 0; row < rows; row++) {
for (int col = 0; col < cols; col++) {
coltot[col] += data[row][col];
}
}
unsigned long long int colmult, colmulttemp = (coltot[0] % 1000000007);
for (int i = 1; i < cols; i++) {
colmulttemp *= coltot[i];
colmulttemp %= 1000000007;
}
colmult = colmulttemp;
printf("%llu\n", colmult);
return 0;
}
However, upon submission, the results I got indicated that some test cases were failing. The question only gave the following test cases:
stdin:
2 2
1 5
1 5
stdout:
20
stdin:
3 3
1 4 7
2 5 8
3 6 9
stdout:
2160
which my code passses correctly. I did however, go out of my way to attempt to input the maximum values. I wrote a program to print 1000000000 100 times horizontally and 100 times vertically into a text file. However, upon directing the file in, I got a bus error:
$ ./main < data.txt
Bus error (core dumped)
$
Could this be the reason some test cases are failing? Or is the problem elsewhere? Regardless, how would I fix it?
Thank you for your time.
Update: I have found the problem with the bus derror: I forgot to specify the matrix's size when I generated the matrix. It now works, but I found it generates a different result compared to a python3 program, with the C program returning 213129341, whereas the python3 program returned 991047043.
>>> import math
>>> x = pow(10, 9)
>>> xx = x * 100
>>> m = x + 7
>>> r = x
>>> i = 1
>>> while(i < 100):
... i += 1
... r = r * xx
... r = r % m
...
>>> r
991047043
>>> r % m
991047043
>>>
This still doesn't bring me any closer to figuring out why my code is incorrect, unfortunately. Any ideas?
Thank you for your time.

Answer 1

Overflow is possible when multiplying the sums.
Denote the maximal element in the matrix by M (here M = 1000000000, which is approximately 230). M is also approximately equal to your modulo-number. If the matrix is NxN, the sum over a row or column is bounded by M*N. The initialization value for colmulttemp is bounded by M. When multiplying these numbers, we get M2*N as an intermediate result. For M=109 and N=102, this is 1020, which overflows 64-bit numbers.
Fortunately, there is a simple fix - just do your modulo reduction to all your sums, and not only to the first one. Then your intermediate result is bounded by M2, which is just below 264. BTW this is the reason for this particular value of M - it's large enough to make all your numbers impressively big, and small enough to fit intermediate results into 64-bit integers.
for (int col = 0; col < cols; col++) {
coltot[col] %= 1000000007;
}
unsigned long long int colmult,
colmulttemp = coltot[0]; // % 1000000007 not necessary here

Answer 2

Could this be the reason some test cases are failing?
Yes.