This code is quite terrible to read. Please think about what your goal is when you do these code challenges. Is it just to get some site to say "AC" instead of "TLE"? Or is it to learn how to become a better programmer in general, so you will be able to work effectively on larger projects, and perhaps get a good job as a programmer? I'll go over all the issues below.

Include the proper header files

<bits/stdc++.h> is a non-standard header file. It may work with your particular compiler, but if you want to write portable C++ code, don't use it. Instead, #include the appropriate header files for all the standard library features you are using. For your code, you just need these:

#include <algorithm>
#include <iostream>
#include <vector>

Avoid macros as much as possible

Macros introduce all sorts of problems, but also importantly for you: they don't give you any increase in performance. The way you wrote macros also makes the code very hard to read for both humans and machines; I think that the highlighter in many code editors will be confused, as now you are writing statements that don't end with a semicolon. I suggest you just remove all the macros here.

For long type names, like unsigned long long int, you could use using to create a type alias. But I still would recommend not doing that; instead use one of the fixed-width integer types, like uint32_t. The problem statement says no value will be larger than \$10^9\$.

If you don't like typing a lot, check if your code editor can help you out. Most of them allow you to define macros in the editor itself.

Don't abbreviate too much

Single letter function/variable/macro names are easy to type but are hard to read. Consider f(i,0,n+1): what does f do? What are i and n? I now have to go look at the rest of the code just to figure out what this one line is meant to do. If, as in your case, most of your code is written like that, it really becomes unreadable. Try to give concise but meaningful names to things.

(I also have never heard of anyone getting a "code size exceeded" error on code challenge sites. However, if optimizing code size is your goal, then have a look at Code Golf.)

Don't store data unnecessarily

Your prefix stores (n + 1) * (m + 1) elements, with the top row and left column being filled with zeroes. This wastes memory. If you know those elements are zero anyway, there is no need to store them.

Use one-dimensional vectors to store matrices

This issue is about performance. A std::vector<std::vector<...>> is an inefficient data structure, as a std::vector might have to (re)allocate memory whenever something is added to it. For a single std::vector, it is not an issue, but now you have that overhead for every row of the matrix. Furthermore, the elements of the matrix are now also not consecutive in memory, which could impact performance as well.

If you know you have an n by m matrix, allocate a single vector of n * m elements, then access those elements using prefix[i * m + j].

If you also know up front how large a vector will be, call .reserve() so it can allocate all the memory it needs in one go.

Combine loops where possible

First you read in all the elements of a matrix, then you do "rowAdd", then "columnAdd". This means you loop over all the elements three times. However, you can do all of this in one go while you read the input: keep a sum of the elements you have seen so far in a row, and add that plus the value of the corresponding row above to the current row:

std::vector<uint32_t> prefix;
prefix.reserve(rows * columns);

for (uint32_t row = 0; row < rows; ++row) {
    uint32_t sum = 0;

    for (uint32_t col = 0; col <= column; ++col) {
        uint32_t value;
        std::cin >> value;
        sum += value;

        if (row > 0) {
            prefix.push_back(sum + prefix[col + (row - 1) * cols]);
        } else {
            prefix.push_back(sum);
        }
    }
}

Avoid unnecessary calculations

When trying to count the number of worth submatrices, you use bisection for the inner loop, which is good. But the outer two loops go over all the rows and columns. However, you can do better than that. Just consider getting a matrix as input where value of the bottom right element is less than k: in that case you know there possibly cannot be any worthy submatrix. Conversely, if the top left element is k or larger, you know that all submatrices are worthy. Therefore, by first finding out which part of the input matrix is k or larger, which you can do while you are reading the input, you can reduce the amount of submatrices you have to check.