UVa 11926 - Multitasking

#include <iostream>
#include <vector>
using namespace std;

template<typename V>
class FenwickTree {
	// Fenwick Tree a.k.a. Binary Indexed Tree
	// Stores values at indexes and answers question of the form "sum of all values in the range [m,n]".
	// O(log n) for update and range sum query
private:
	int tree_size;
	vector<V> tree_as_array;
	int getLeastSignificantBit(int number) {
		return number & (-number);
	}
public:
	FenwickTree(int n) {
		tree_size = n;
		tree_as_array.assign(tree_size + 1, 0);
	}
	V getRangeSum(int range_start, int range_end) { // returns range sum of [range_start,range_end]
		V start_sum = getRangeSum(range_start - 1);
		V end_sum = getRangeSum(range_end);
		return end_sum - start_sum;
	}
	V getRangeSum(int index) { // returns range sum of [1,index]
		V sum = 0;
		while (index > 0) {
			sum += tree_as_array[index];
			index -= getLeastSignificantBit(index);
		}
		return sum;
	}
	void increaseValueAtIndex(int index, V increment) {
		while (index <= tree_size) {
			tree_as_array[index] += increment;
			index += getLeastSignificantBit(index);
		}
	}
};

#define MAX_SIZE 1000000

bool considerRange(int a, int b, FenwickTree<int>& fenwick) {
	int sum = fenwick.getRangeSum(a, b);
	if (sum > 0) {
		return true;
	}
	for (int contained = a; contained <= b; contained++) {
		fenwick.increaseValueAtIndex(contained, 1);
	}
	return false;
}

int main() {
	while (true) {
		int one_time_tasks_count, repeating_tasks_count;
		cin >> one_time_tasks_count >> repeating_tasks_count;
		if (one_time_tasks_count == 0 && repeating_tasks_count == 0)
			break;

		// input
		int one_time_task[100][2], repeating_task[100][3];
		for (int i = 0; i < one_time_tasks_count; i++)
			cin >> one_time_task[i][0] >> one_time_task[i][1];
		for (int i = 0; i < repeating_tasks_count; i++)
			cin >> repeating_task[i][0] >> repeating_task[i][1] >> repeating_task[i][2];

		FenwickTree<int> fenwick = FenwickTree<int>(MAX_SIZE);

		bool overlap = false;
		for (int i = 0; i < one_time_tasks_count && !overlap; i++) {
			int a = one_time_task[i][0] + 1, b = one_time_task[i][1];
			overlap = considerRange(a, b, fenwick);
		}

		for (int i = 0; i < repeating_tasks_count && !overlap; i++) {
			int a = repeating_task[i][0] + 1, b = repeating_task[i][1];
			while (a <= MAX_SIZE && !overlap) {
				if (b > MAX_SIZE)
					b = MAX_SIZE;
				overlap = considerRange(a, b, fenwick);
				a += repeating_task[i][2];
				b += repeating_task[i][2];
			}
		}

		if (!overlap)
			cout << "NO ";
		cout << "CONFLICT" << endl;
	}
	return 0;
}