We're looking for every country the answer — rain number x.
To do so, we need to do parallel binsearch for all country at once, but with different intervals [left, right] for each of them.
In step one every country c has left[c] = 0, right[c] = k. (k-th rain has infinity amount of meteors)
In every step we iterate over each rain, add its interval to segment tree. Also we keep vector<int> check[k]. check[i] stores all countries, that we need check how many meteors lands on their segments after i-th rain. We can make it with segment tree in O(logm).
If country c is 'satisfied' we change right[c] = i, otherwise left[c] = i + 1. If left[c] < right[c] we add country c to check[(left[c]+right[c])/2].

We keep doing this until all check[i] are empty.

Complexity:

while(changed) { // up to O(logk)
        REP(i, k) { // O(k)
            rain_go(i); // O(logm)
            while(check[i].size()) {
                int c = check[i].back(); check[i].pop_back(); // c - current country
                ll curval = 0; // sums of meteors on country's sectors after i rains
                REP(j, sectors[c].size()) curval += tree.query(sectors[c][j]); // amortized O(mlogm), every sector at most 1 time
                if(curval >= p[c]) right[c] = i;
                else left[c] = i+1;
                if(left[c] < right[c]) {
                    check[(left[c] + right[c] )/2].pb(c);
                    changed = true;
                }
            }
        }
    }

O((m + k)log(k)log(m))

I think you can solve this problem with persistent segment trees too. You apply all the updates and then for each country you just binary search over the time(answer for the country) using the segment tree. Complexity: mlogmlogn When I saw that companies owning the states, I thought my solution wouldnt work but it works. Here is my implementation: http://codeforces.net/contest/493/submission/9022316 (It gets mle, need a memory limit of 256mb)

You also can use sqrt-decompositon to solve this problem.

code

Can someone familiar with main.edu.pl please tell why I am getting 98/100 points (13/15 points for 7th test group), even though my solution passed all the tests (all OK)?

The obvious solution that comes to mind is persistent segment tree with complexity O(X * _logM * _logQ) for each country, where X is the number of sectors owned by that country. Since each sector is owned by only one country, the total complexity would be O(M * _logM * _logQ), which should be fast enough, though I'd need to test it to be sure.