We assume that $R_1 \geq R_2\geq \dots \geq R_N$.

First of all, we can safely ignore bars $j\ (j > i)$ when determining the final position of bar $i$ (because the bars that are initially above bar $i$ never end up below bar $i$). Thus, we may consider the last position of bar $i$ for $i=1,2,\dots,N$, one by one.

Let us consider how to find the final position of some bar $a\ (1\leq a\leq N)$ when that of bars $i\ (i < a)$ are already known.

For each $1\leq j\leq W$, let $m_j$ be the row index of the topmost cell in column $j$ that is occupied by one of bars $1,2,\dots,a-1$ after sufficient time (or $H+1$ if none of the cells in the column is occupied).

Then, we can prove that the row $R'_a$ at which bar $a$ will end up after sufficient time is $\min\{m_j: C_a \leq j < C_a+L_a\}-1$.

Once you have found the final row of bar $a$, we need to appropriately update the values $m_j$ to find the final positions of bars $a+1,a+2,\dots$. Specifically, we need to set $m_j$ to $R'_a$ for each $j\ (C_a \leq j < C_a+L_a)$.

In summary, it is sufficient to do the following process fast:

1. Initialize as $m_1=m_2=\dots=m_W=H+1$.
2. For $i=1,2,\dots,N$, do the following:
   1. Let $R'_i\leftarrow \min\{m_j: C_i \leq j < C_i+L_i\}-1$.
   2. For each $j\ (C_i \leq j < C_i+L_i)$, set $m_j\leftarrow R'_i$.

This can be processed in a total of $O(W+N\log W)$ time using a lazy segment tree allowing segment-min & segment-update, or segment-min & segment-chmin (chmin = change to the smaller value). Therefore, the problem has been solved.

Sample code (C++9:

#include <bits/stdc++.h>
#include <atcoder/lazysegtree>
using namespace std;
using namespace atcoder;
const int inf = 1e9;
using S = int;
using F = int;
S op(S l, S r) { return min(l, r); }
S e() { return inf; }
S mapping(F l, S r) { return min(l, r); }
F composition(F l, F r) { return min(l, r); }
F id() { return inf; }
int main() {
    int h, w, n;
    cin >> h >> w >> n;
    vector<int> r(n), c(n), l(n);
    for (int i = 0; i < n; i++) {
        cin >> r[i] >> c[i] >> l[i];
        --c[i];
    }
    vector<int> ord(n);
    iota(ord.begin(), ord.end(), 0);
    sort(ord.begin(), ord.end(), [&](int i, int j) { return r[i] > r[j]; });
    vector<int> ans(n);
    lazy_segtree<S, op, e, F, mapping, composition, id> seg(vector<int>(w, h + 1));
    for (int i: ord) {
        ans[i] = seg.prod(c[i], c[i] + l[i]) - 1;
        seg.apply(c[i], c[i] + l[i], ans[i]);
    }
    for (int i = 0; i < n; i++) {
        cout << ans[i] << '\n';
    }
}

#include <bits/stdc++.h>
#include <atcoder/lazysegtree>

using namespace std;
using namespace atcoder;

const int inf = 1e9;

using S = int;
using F = int;

S op(S l, S r) { return min(l, r); }

S e() { return inf; }

S mapping(F l, S r) { return min(l, r); }

F composition(F l, F r) { return min(l, r); }

F id() { return inf; }

int main() {
    int h, w, n;
    cin >> h >> w >> n;
    vector<int> r(n), c(n), l(n);
    for (int i = 0; i < n; i++) {
        cin >> r[i] >> c[i] >> l[i];
        --c[i];
    }
    vector<int> ord(n);
    iota(ord.begin(), ord.end(), 0);
    sort(ord.begin(), ord.end(), [&](int i, int j) { return r[i] > r[j]; });

    vector<int> ans(n);
    lazy_segtree<S, op, e, F, mapping, composition, id> seg(vector<int>(w, h + 1));
    for (int i: ord) {
        ans[i] = seg.prod(c[i], c[i] + l[i]) - 1;
        seg.apply(c[i], c[i] + l[i], ans[i]);
    }
    for (int i = 0; i < n; i++) {
        cout << ans[i] << '\n';
    }
}