Codeforces Round #255 "Modifying matrix" solution(Div-1 B)? - algorithm

Question

I was trying to solve the "DZY Loves Modification" problem from Round #255 of CodeForces.
Problem link:
http://codeforces.com/contest/446/problem/B.
I am getting wrong answers for the system test cases.
My approach is as follows:
Construct two max-heaps - one heap for storing the row totals and
one for the column totals
Store two variables - rowReductionValue and colReductionValue -
these variables store the value that should be subtracted before
using a row or column's total sum.
For each iteration, choose the entry with maximum value from the
rowSum and colSum heaps
If a row is chosen, the row's total is added to the result and then
the row total is reduced by P * (number_of_columns)
After this, each column's value reduces by P. So, this P is
added to colReductionValue.
An analogous approach is used if a column is chosen.
This approach results in wrong answers.
I am sorry if I was not clear in explaining my approach, I wanted it to be as concise as possible.
Any light on the right approach or the flaw with this approach is much appreciated.
The code is below:
long long getMaxResult(int rows, int cols, int reductionValue, int K)
{
vector<long long> rowSums, colSums;
long long rowReductionValue = 0, colReductionValue = 0, result = 0;
for(int row = 0; row < rows; ++row)
{
long long sum = 0;
for(int col = 0; col < cols; ++col)
{
sum += a[row][col];
}
rowSums.push_back(sum);
}
for(int col = 0; col < cols; ++col)
{
long long sum = 0;
for(int row = 0; row < rows; ++row)
{
sum += a[row][col];
}
colSums.push_back(sum);
}
make_heap(rowSums.begin(), rowSums.end());
make_heap(colSums.begin(), colSums.end());
for(int k = 0; k < K; ++k)
{
pop_heap(rowSums.begin(), rowSums.end());
long long rowMax = rowSums.back();
rowSums.pop_back();
pop_heap(colSums.begin(), colSums.end());
long long colMax = colSums.back();
colSums.pop_back();
if(rowMax - rowReductionValue >= colMax - colReductionValue)
{
result += rowMax - rowReductionValue;
rowMax -= reductionValue * cols;
colReductionValue += reductionValue;
}
else
{
result += colMax - colReductionValue;
colMax -= reductionValue * rows;
rowReductionValue += reductionValue;
}
rowSums.push_back(rowMax);
push_heap(rowSums.begin(), rowSums.end());
colSums.push_back(colMax);
push_heap(colSums.begin(), colSums.end());
}
return result;
}
Thanks-

Answer 1

I'll walk you through the Greedy-Brute Force concept that I used to approach this problem:
If p = 0, apparently the best choice is choosing the row or column which can give greatest pleasure value each time.
Let's ignore p first, then we can get a greatest number ans using previous statement. Now if we choose rows for i times, choose column for k-i times, ans should be ansi - ((k-i) X i X p).
So we could enumerate i from 0 to k and calculate ansi - ((k-i) X i X p) each time, max{ansi - ((k-i) X i X p)} is the maximum possible pleasure value DZY could get.
Let ai be the maximum pleasure value we can get after choosing i rows and bi be the maximum pleasure value we can get after choosing i columns. Then ansi = ai+bk-i. We can use two priority queues to calculate ai and bi quickly.
Good luck!