Нельзя объяснить, "как решаются задачи такого рода". Потому что это задачи, а не упражнения. "жадный алгоритм" — это лишь одна из идей, которые используются при решении задачи, это не значит, что знание, что задача решается жадным алгоритмом, делает задачу очевидной.

Как решать задачу, пока не придумал.

Жадный алгоритм — применяем на каждом шаге оптимальное решение по некоторому критерию. Навскидку, не знаю верно или нет — сортируем отрезки по возрастанию li (конца отрезка), бежим по всем отрезкам, и каждый раз когда можно отрезок удалить согласно условиям — удаляем.

А, понял.

1. Если есть несколько инструкций с одинаковым a_i, то оставляем только ту, у которой наибольшее l_i.
   
2. Сортируем инструкции по возрастанию a_i.
   3.
   Дальше будем перебирать все инструкции по порядку, и каждую брать или отклонять. Для начала берём самую первую нерассмотренную инструкцию (изначально это просто самая первая). И запоминаем, что мы обеспечили заполнение памяти до места pos = a_i + l_i.
   4.
   a. Если ещё есть инструкции, у которых a_j <= pos, то перебираем их всех и оставляем ту, у которой a_j+l_j максимально. Её добавляем в отмет, остальные отбрасываем, обновляем pos = a_j+l_j. Снова переходим к пункту 4.
   b. Если таких инструкций нет, то забываем pos и переходим к пункту 3.
   

Рассмотрим самую левую из всех покрытых точек L. Естественно, это точка является началом какого-то отрезка, и для того чтобы ее покрыть нужно включить в ответ какой-либо из отрезков, начинающихся в этой точке. Очевидно, что выгоднее всего будет выбрать тот из них, который имеет наибольшую длину. Пусть мы выбрали отрезок [L,R]. Тогда все отрезки, целиком в него входящие, можно выбросить за ненадобностью, а отрезки [L1,R1] имеющие с ним пересечение (т.е. L < L1 < R < R1) урезать до [R,R1]. После этого получаем ту же задачу с меньшим числом отрезков и самой левой точкой >= R. Продолжаем применять описанную процедуру пока не покроем все интервалы.

Проделать это все удобно, если предварительно отсортировать все отрезки по левому концу, и при равенстве по длине. Тогда, в течение одного прохода, мы будем либо добавлять к ответу текущий отрезок, если он не покрывается предыдущим выбранным, либо игнорировать.

http://codeforces.me/contest/306/submission/3720123 Извиняюсь что код не отформатирован.

Сортируем все отрезки в порядке возрастания начальной ячейки. И в цикле - пропускаем все которые заканчиваются на уже покрытом отрезке. Для первого которые выходит за покрытый отрезок смотрим начало. Если оно дальше чем уже покрытый отрезок, то за точку старта берем его. Если не дальше, то за точку старта берем ячейку сразу за уже покрытым отрезком. Перебираем все команды начало которых не дальше чем точка старта, и выбираем среди них тот, который заканчивается дальше. и т.д. Решается в один проход, за O(m) Информация о n, и сбор данных о покрытых ячейках — в решении не нужно.

UPD. общая сложность (m*log m), за счет сортировки массива команд.

Моё решение таково: Представим каждую команду как скобки (). Левая скобка — a[i], правая скобка — a[i]+l[i]-1.
1) Уберём все скобки, которые вложены в другие.
2) Заведём массив длины n, элементы которого будут хранить количество скобок, которые "покрывают" этот элемент.
3) Скобки, которые покрывают элементы, в которых записана единица, являются "нужными" — их удалить нельзя.
4) Остались скобки, которые не "покрывают" единицы. Понятно, что эти скобки лежат на пересечении с "нужными". Поступим жадно. Уберём все скобки, кроме нужных. Будем пытаться "заделать" пустое пространство между ними наиболее длинными скобками. Пометим эти наиболее длинные скобки как "нужные".
5) Все скобки кроме нужных — есть ответ.
Длинно, некрасиво, но думаю такое решение имеет место быть.