Datasets:

anonymous1926
/

autocode-fresh-cf

#include <bits/stdc++.h>
using namespace std;

using ull = unsigned long long;

struct Solver {
    int n, q;
    int B;          // heavy threshold
    int W;          // words in a bitset = (n+63)/64
    vector<vector<int>> adj;
    vector<int> deg;
    vector<char> isHeavy;
    vector<int> hId;
    vector<vector<ull>> hBits;      // bitsets for heavy rows
    vector<vector<int>> hDiff;      // hDiff[i][j] = |heavy_i \ heavy_j|
    vector<int> heavyRows;          // heavyRows[i] = row id
    vector<int> tag;
    int timer;
    set<pair<int,int>> ord;         // (degree, row id)
    long long bad;                  // number of incomparable adjacent pairs

    Solver(int n_, int q_) : n(n_), q(q_) {
        B = max(1, (int)std::sqrt((double)q));
        W = (n + 63) >> 6;
        adj.assign(n, {});
        deg.assign(n, 0);
        isHeavy.assign(n, 0);
        hId.assign(n, -1);
        heavyRows.clear();
        tag.assign(n, 0);
        timer = 1;
        ord.clear();
        for (int i = 0; i < n; ++i) ord.insert({0, i});
        bad = 0;
    }

    // return true iff N(a) ⊆ N(b) or N(b) ⊆ N(a)
    bool comp(int a, int b) {
        if (a == b) return true;
        if (deg[a] > deg[b]) swap(a, b);          // a is the smaller (or equal) set
        if (deg[a] > B) {                         // both are heavy
            int ha = hId[a], hb = hId[b];
            return hDiff[ha][hb] == 0;             // a ⊆ b
        }
        if (isHeavy[b]) {                          // a light, b heavy
            const auto &bits = hBits[hId[b]];
            for (int col : adj[a]) {
                if ( ((bits[col >> 6] >> (col & 63)) & 1ULL) == 0 )
                    return false;
            }
            return true;
        }
        // both light
        ++timer;
        for (int col : adj[b]) tag[col] = timer;
        for (int col : adj[a]) if (tag[col] != timer) return false;
        return true;
    }

    void makeHeavy(int r) {
        int id = (int)hBits.size();
        hId[r] = id;
        isHeavy[r] = 1;
        vector<ull> bits(W, 0);
        for (int col : adj[r]) bits[col >> 6] |= 1ULL << (col & 63);
        hBits.push_back(move(bits));

        for (auto &row : hDiff) row.push_back(0);
        hDiff.emplace_back(hBits.size(), 0);

        for (int hi = 0; hi < id; ++hi) {
            int common = 0;
            for (int col : adj[r]) {
                if ( (hBits[hi][col >> 6] >> (col & 63)) & 1ULL ) ++common;
            }
            hDiff[id][hi] = deg[r] - common;                       // r \ h
            hDiff[hi][id] = deg[heavyRows[hi]] - common;             // h \ r
        }
        heavyRows.push_back(r);
    }

    void addHeavyEdge(int r, int c) {
        int id = hId[r];
        for (int hi = 0; hi < (int)hBits.size(); ++hi) {
            if (hi == id) continue;
            if ( (hBits[hi][c >> 6] >> (c & 63)) & 1ULL ) {
                --hDiff[hi][id];          // hi had c, r did not, now it does
            } else {
                ++hDiff[id][hi];          // r gains c which hi lacks
            }
        }
        hBits[id][c >> 6] |= 1ULL << (c & 63);
    }

    void addEdge(int r, int c) {
        adj[r].push_back(c);
        ++deg[r];
        if (isHeavy[r]) {
            addHeavyEdge(r, c);
        } else if (deg[r] > B) {
            makeHeavy(r);
        }
    }

    string answerQuery(int r, int c) {
        // 1) remove r from the degree order, updating the counter
        auto it = ord.find({deg[r], r});
        int oldL = -1, oldR = -1;
        if (it != ord.begin()) {
            auto it2 = it; --it2;
            oldL = it2->second;
        }
        auto itNxt = next(it);
        if (itNxt != ord.end()) oldR = itNxt->second;

        if (oldL != -1 && !comp(oldL, r)) --bad;
        if (oldR != -1 && !comp(r, oldR)) --bad;
        if (oldL != -1 && oldR != -1 && !comp(oldL, oldR)) ++bad;

        ord.erase(it);

        // 2) actually color the cell black
        addEdge(r, c);

        // 3) insert r with its new degree and update the counter
        auto ret = ord.insert({deg[r], r});
        auto it2 = ret.first;
        int newL = -1, newR = -1;
        if (it2 != ord.begin()) {
            auto it3 = it2; --it3;
            newL = it3->second;
        }
        auto it4 = next(it2);
        if (it4 != ord.end()) newR = it4->second;

        if (newL != -1 && newR != -1 && !comp(newL, newR)) --bad;
        if (newL != -1 && !comp(newL, r)) ++bad;
        if (newR != -1 && !comp(r, newR)) ++bad;

        return bad == 0 ? "YES" : "NO";
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int T;
    if (!(cin >> T)) return 0;
    while (T--) {
        int n, q;
        cin >> n >> q;
        Solver solver(n, q);
        for (int i = 0; i < q; ++i) {
            int r, c;
            cin >> r >> c;
            --r; --c;
            cout << solver.answerQuery(r, c) << '\n';
        }
    }
    return 0;
}

	#include <bits/stdc++.h>
	using namespace std;

	using ull = unsigned long long;

	struct Solver {
	int n, q;
	int B; // heavy threshold
	int W; // words in a bitset = (n+63)/64
	vector<vector<int>> adj;
	vector<int> deg;
	vector<char> isHeavy;
	vector<int> hId;
	vector<vector<ull>> hBits; // bitsets for heavy rows
	vector<vector<int>> hDiff; // hDiff[i][j] = \|heavy_i \ heavy_j\|
	vector<int> heavyRows; // heavyRows[i] = row id
	vector<int> tag;
	int timer;
	set<pair<int,int>> ord; // (degree, row id)
	long long bad; // number of incomparable adjacent pairs

	Solver(int n_, int q_) : n(n_), q(q_) {
	B = max(1, (int)std::sqrt((double)q));
	W = (n + 63) >> 6;
	adj.assign(n, {});
	deg.assign(n, 0);
	isHeavy.assign(n, 0);
	hId.assign(n, -1);
	heavyRows.clear();
	tag.assign(n, 0);
	timer = 1;
	ord.clear();
	for (int i = 0; i < n; ++i) ord.insert({0, i});
	bad = 0;
	}

	// return true iff N(a) ⊆ N(b) or N(b) ⊆ N(a)
	bool comp(int a, int b) {
	if (a == b) return true;
	if (deg[a] > deg[b]) swap(a, b); // a is the smaller (or equal) set
	if (deg[a] > B) { // both are heavy
	int ha = hId[a], hb = hId[b];
	return hDiff[ha][hb] == 0; // a ⊆ b
	}
	if (isHeavy[b]) { // a light, b heavy
	const auto &bits = hBits[hId[b]];
	for (int col : adj[a]) {
	if ( ((bits[col >> 6] >> (col & 63)) & 1ULL) == 0 )
	return false;
	}
	return true;
	}
	// both light
	++timer;
	for (int col : adj[b]) tag[col] = timer;
	for (int col : adj[a]) if (tag[col] != timer) return false;
	return true;
	}

	void makeHeavy(int r) {
	int id = (int)hBits.size();
	hId[r] = id;
	isHeavy[r] = 1;
	vector<ull> bits(W, 0);
	for (int col : adj[r]) bits[col >> 6] \|= 1ULL << (col & 63);
	hBits.push_back(move(bits));

	for (auto &row : hDiff) row.push_back(0);
	hDiff.emplace_back(hBits.size(), 0);

	for (int hi = 0; hi < id; ++hi) {
	int common = 0;
	for (int col : adj[r]) {
	if ( (hBits[hi][col >> 6] >> (col & 63)) & 1ULL ) ++common;
	}
	hDiff[id][hi] = deg[r] - common; // r \ h
	hDiff[hi][id] = deg[heavyRows[hi]] - common; // h \ r
	}
	heavyRows.push_back(r);
	}

	void addHeavyEdge(int r, int c) {
	int id = hId[r];
	for (int hi = 0; hi < (int)hBits.size(); ++hi) {
	if (hi == id) continue;
	if ( (hBits[hi][c >> 6] >> (c & 63)) & 1ULL ) {
	--hDiff[hi][id]; // hi had c, r did not, now it does
	} else {
	++hDiff[id][hi]; // r gains c which hi lacks
	}
	}
	hBits[id][c >> 6] \|= 1ULL << (c & 63);
	}

	void addEdge(int r, int c) {
	adj[r].push_back(c);
	++deg[r];
	if (isHeavy[r]) {
	addHeavyEdge(r, c);
	} else if (deg[r] > B) {
	makeHeavy(r);
	}
	}

	string answerQuery(int r, int c) {
	// 1) remove r from the degree order, updating the counter
	auto it = ord.find({deg[r], r});
	int oldL = -1, oldR = -1;
	if (it != ord.begin()) {
	auto it2 = it; --it2;
	oldL = it2->second;
	}
	auto itNxt = next(it);
	if (itNxt != ord.end()) oldR = itNxt->second;

	if (oldL != -1 && !comp(oldL, r)) --bad;
	if (oldR != -1 && !comp(r, oldR)) --bad;
	if (oldL != -1 && oldR != -1 && !comp(oldL, oldR)) ++bad;

	ord.erase(it);

	// 2) actually color the cell black
	addEdge(r, c);

	// 3) insert r with its new degree and update the counter
	auto ret = ord.insert({deg[r], r});
	auto it2 = ret.first;
	int newL = -1, newR = -1;
	if (it2 != ord.begin()) {
	auto it3 = it2; --it3;
	newL = it3->second;
	}
	auto it4 = next(it2);
	if (it4 != ord.end()) newR = it4->second;

	if (newL != -1 && newR != -1 && !comp(newL, newR)) --bad;
	if (newL != -1 && !comp(newL, r)) ++bad;
	if (newR != -1 && !comp(r, newR)) ++bad;

	return bad == 0 ? "YES" : "NO";
	}
	};

	int main() {
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	int T;
	if (!(cin >> T)) return 0;
	while (T--) {
	int n, q;
	cin >> n >> q;
	Solver solver(n, q);
	for (int i = 0; i < q; ++i) {
	int r, c;
	cin >> r >> c;
	--r; --c;
	cout << solver.answerQuery(r, c) << '\n';
	}
	}
	return 0;
	}