제출 #823523

#	제출 시각	아이디	문제	언어	결과	실행 시간	메모리
823523		phoenix	Rectangles (IOI19_rect)	C++17	72 / 100	5053 ms	575024 KiB

rect

#include<bits/stdc++.h>
#include "rect.h"

using namespace std;
using ll = long long;

struct SegTree {
	static const int N = (1 << 13);
	vector<bool> t;
	SegTree() {
		t.assign(2 * N, false);
	}
	void insert(int pos) {
		for(t[pos += N] = true; pos > 1; pos >>= 1) 
			t[pos >> 1] = true;
	}
	int right(int x, int l = 0, int r = N - 1, int v = 1) {
		if(r < x || !t[v]) return -1;
		if(l == r) return l;
		int mid = (l + r) / 2;
		int res = right(x, l, mid, 2 * v);
		if(res == -1) res = right(x, mid + 1, r, 2 * v + 1);
		return res;
	}
	int left(int x, int l = 0, int r = N - 1, int v = 1) {
		if(l > x || !t[v]) return -1;
		if(l == r) return l;
		int mid = (l + r) / 2;
		int res = left(x, mid + 1, r, 2 * v + 1);
		if(res == -1) res = left(x, l, mid, 2 * v);
		return res;
	}
};

struct FenwickTree {
    vector<int> bit;  // binary indexed tree
    int n;
    FenwickTree(int n) {
        this->n = n;
        bit.assign(n, 0);
    }
    FenwickTree(vector<int> const &a) : FenwickTree(a.size()) {
        for (size_t i = 0; i < a.size(); i++)
            add(i, a[i]);
    }
    int sum(int r) {
        int ret = 0;
        for (; r >= 0; r = (r & (r + 1)) - 1)
            ret += bit[r];
        return ret;
    }
    int sum(int l, int r) {
        return sum(r) - sum(l - 1);
    }
    void add(int idx, int delta) {
        for (; idx < n; idx = idx | (idx + 1))
            bit[idx] += delta;
    }
};

// O(nlogn)
SegTree sg; 
vector<pair<int, int>> get_segments(vector<int> a) {
	int n = (int)a.size();
	
	vector<pair<int, int>> b;
	vector<pair<int, int>> res;
	for(int i = 0; i < n; i++) {
		b.push_back({a[i], i});
	}
	sort(b.rbegin(), b.rend());
	int l = 0;
	while(l < n) {
		int r = l;
		while(r < n && b[r].first == b[l].first) ++r;
		for(int i = l; i < r; i++)  
			sg.insert(b[i].second);
		for(int i = l; i < r; i++) {
			int pos = b[i].second;
			int rb = sg.right(pos + 1), lb = sg.left(pos - 1);
			if(rb != -1 && rb - pos > 1) 
				res.push_back({pos + 1, rb - 1});
			if(lb != -1 && pos - lb > 1 && (i == r - 1 || b[i + 1].second != lb)) 
				res.push_back({lb + 1, pos - 1});
		}
		l = r;
	}
	sg = SegTree();
	return res;	
}

const int N = 2505;

struct segment {
	int l, d;
};

vector<segment> h[N][N], g[N][N];

ll count_rectangles(vector<vector<int>> a) {
	int n = (int)a.size(), m = (int)a[0].size();
	if(n < 3 || m < 3) return 0;
	for(int i = 0; i < n; i++) {
		vector<pair<int, int>> s = get_segments(a[i]);
		for(auto [l, r] : s) 
			g[i][r].push_back({l, 0});
	}
	for(int i = 0; i < m; i++) {
		vector<int> b;
		for(int j = 0; j < n; j++) 
			b.push_back(a[j][i]);
		vector<pair<int, int>> s = get_segments(b);
		for(auto [l, r] : s) 
			h[r][i].push_back({l, 0});
	}
	for(int i = 0; i < n; i++) {
		int cnt[n] = {};
		bool us[n] = {};
		for(int j = 0; j < m; j++) {
			if(!j) {
				for(auto c : h[i][j]) 
					cnt[c.l]++;
			} else {
				for(auto c : h[i][j])
					us[c.l] = 1;
				for(auto c : h[i][j - 1])
					if(!us[c.l]) cnt[c.l] = 0;
				
				for(auto c : h[i][j]) {
					cnt[c.l]++;
					us[c.l] = 0;
				}
			}
			for(auto &c : h[i][j]) {
				c.d = cnt[c.l];
			}
		}
	}
	for(int i = 0; i < m; i++) {
		int cnt[m] = {};
		bool us[m] = {};
		for(int j = 0; j < n; j++) {
			if(!j) {
				for(auto c : g[j][i]) 
					cnt[c.l]++;
			} else {
				for(auto c : g[j][i]) 
					us[c.l] = 1;
				for(auto c : g[j - 1][i]) 
					if(!us[c.l]) 
						cnt[c.l] = 0;
				for(auto c : g[j][i]) {
					cnt[c.l]++;
					us[c.l] = 0;
				}
			}
			for(auto &c : g[j][i])
				c.d = cnt[c.l];
		}
	}
	ll ans = 0;
	FenwickTree st(n);
	for(int i = 0; i < n; i++) {
		for(int j = 0; j < m; j++) {
			sort(h[i][j].begin(), h[i][j].end(), [](segment x, segment y) {return x.d > y.d;});
			int h_l = 0;
			for(segment cur : g[i][j]) {
				while(h_l < (int)h[i][j].size() && j - h[i][j][h_l].d < cur.l) {
					st.add(h[i][j][h_l++].l, +1);
				} 
				ans += st.sum(i - cur.d + 1, i);
			}
			while(h_l > 0) 
				st.add(h[i][j][--h_l].l, -1);
		}
	}
	return ans;
}

• Subtask 1: 8 / 8
• Subtask 2: 7 / 7
• Subtask 3: 12 / 12
• Subtask 4: 22 / 22
• Subtask 5: 10 / 10
• Subtask 6: 13 / 13
• Subtask 7: 0 / 28