Submission #705067

#	Time	Username	Problem	Language	Result	Execution time	Memory
705067		600Mihnea	Boat (APIO16_boat)	C++17	100 / 100	1548 ms	9204 KiB

boat

#include <cmath>
#include <functional>
#include <fstream>
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <list>
#include <time.h>
#include <math.h>
#include <random>
#include <deque>
#include <queue>
#include <unordered_map>
#include <unordered_set>
#include <iomanip>
#include <cassert>
#include <bitset>
#include <sstream>
#include <chrono>
#include <cstring>
#include <numeric>

using namespace std;

typedef long long ll;
const int M = (int)1e9 + 7;
const int FACTN = 300000 + 7;

int add(int a, int b) {
	a += b;
	if (a >= M) return a - M;
	if (a < 0) return a + M;
	return a;
}

int mul(int a, int b) {
	return a * (ll)b % M;
}

int add(int a, int b, int c) {
	return add(add(a, b), c);
}

int mul(int a, int b, int c) {
	return mul(mul(a, b), c);
}

int add(int a, int b, int c, int d) {
	return add(add(a, b, c), d);
}

int mul(int a, int b, int c, int d) {
	return mul(mul(a, b, c), d);
}

int add(int a, int b, int c, int d, int e) {
	return add(add(a, b, c, d), e);
}

int mul(int a, int b, int c, int d, int e) {
	return mul(mul(a, b, c, d), e);
}

int add(int a, int b, int c, int d, int e, int f) {
	return add(add(a, b, c, d, e), f);
}

int mul(int a, int b, int c, int d, int e, int f) {
	return mul(mul(a, b, c, d, e), f);
}

int add(int a, int b, int c, int d, int e, int f, int g) {
	return add(add(a, b, c, d, e, f), g);
}

int mul(int a, int b, int c, int d, int e, int f, int g) {
	return mul(mul(a, b, c, d, e, f), g);
}

int add(int a, int b, int c, int d, int e, int f, int g, int h) {
	return add(add(a, b, c, d, e, f, g), h);
}

int mul(int a, int b, int c, int d, int e, int f, int g, int h) {
	return mul(mul(a, b, c, d, e, f, g), h);
}

int pw(int a, int b) {
	int r = 1;
	while (b) {
		if (b & 1) r = mul(r, a);
		a = mul(a, a);
		b /= 2;
	}
	return r;
}

int dv(int a, int b) {
	return mul(a, pw(b, M - 2));
}

void addup(int& a, int b) {
	a = add(a, b);
}

void mulup(int& a, int b) {
	a = mul(a, b);
}

void dvup(int& a, int b) {
	a = dv(a, b);
}

int fact[FACTN], ifact[FACTN];

void computeFACT() {
	fact[0] = 1;
	for (int i = 1; i < FACTN; i++) fact[i] = mul(fact[i - 1], i);
	ifact[FACTN - 1] = dv(1, fact[FACTN - 1]);
	for (int i = FACTN - 2; i >= 0; i--) ifact[i] = mul(ifact[i + 1], i + 1);
}

int getCOMB(int n, int k) {
	return mul(fact[n], mul(ifact[k], ifact[n - k]));
}

int fastComb(int n, int k)
{
	if (k > n)
	{
		return 0;
	}
	// n is very big
	// k is small
	assert(0 <= k && k <= n);
	int up = 1;
	for (int i = 1; i <= k; i++)
	{
		mulup(up, n + 1 - i);
	}
	return mul(up, ifact[k]);
}


int dumb(vector<pair<int, int>> segs)
{
	int n = (int)segs.size();
	vector<vector<int>> dp(n);
	for (int i = 0; i < n; i++)
	{
		assert(segs[i].first <= segs[i].second);
		dp[i].resize(segs[i].second - segs[i].first + 1, 1);
	}
	for (int i = 0; i < n; i++)
	{
		for (int j = 0; j < i; j++)
		{
			for (int y = segs[i].first; y <= segs[i].second; y++)
			{
				if (segs[j].second <= y - 1)
				{
					addup(dp[i][y - segs[i].first], dp[j].back());
				}
				else
				{
					if (segs[j].first <= y - 1)
					{
						addup(dp[i][y - segs[i].first], dp[j][y - 1 - segs[j].first]);
					}
				}
			}
		}
		int cur = 0;
		for (auto& it : dp[i])
		{
			addup(cur, it);
			it = cur;
		}
	}
	int sol = 0;
	for (int i = 0; i < n; i++)
	{
		addup(sol, dp[i].back());
	}
	return sol;
}


mt19937 rng(228);

int getrng(int l, int r)
{
	assert(l <= r);
	int x = rng() % (r - l + 1) + l;
	assert(l <= x && x <= r);
	return x;
}

vector<pair<int, int>> getrng()
{
	const int N = 10;
	const int L = 10;
	int n = getrng(1, N);
	vector<pair<int, int>> v(n);
	for (auto& it : v)
	{
		it.first = getrng(1, L);
		it.second = getrng(1, L);
		if (it.first > it.second)
		{
			swap(it.first, it.second);
		}
		assert(it.first <= it.second);
	}
	return v;
}

int smart(vector<pair<int, int>> v)
{
	int n = (int)v.size();
	map<int, int> mp;
	for (auto& it : v)
	{
		mp[it.first] = 0;
		mp[it.second + 1] = 0;
	}
	vector<int> xs;
	int y = 0;
	for (auto& it : mp)
	{
		xs.push_back(it.first);
		it.second = y++;
	}
	vector<int> dim;
	for (int i = 0; i + 1 < (int)xs.size(); i++)
	{
		dim.push_back(xs[i + 1] - xs[i]);
	}
	assert((int)dim.size() == y - 1);
	y = (int)dim.size();
	for (auto& it : v)
	{
		assert(mp.count(it.first));
		assert(mp.count(it.second + 1));
		it.first = mp[it.first];
		it.second = mp[it.second + 1] - 1;
	}
	vector<vector<int>> dp(y, vector<int>(n + 1, 0));
	vector<vector<int>> prod(y, vector<int>(n + 1, 0));
	for (int i = 0; i < y; i++)
	{
		prod[i][0] = 1;
		for (int j = 1; j <= n; j++)
		{
			prod[i][j] = mul(prod[i][j - 1], dim[i] + 1 - j);
		}
	}
	for (int i = 0; i < y; i++)
	{
		for (int t = 1; t <= n; t++)
		{
			mulup(prod[i][t], ifact[t]);
		}
	}
	for (auto& seg : v)
	{
		vector<int> sigma(y + 1, 0);
		int l = seg.first, r = seg.second;
		auto ndp = dp; // nu fac nimic aici
		// incep ceva nou aici
		for (int i = l; i <= r; i++)
		{
			addup(ndp[i][1], +1);
		}
		for (int i = 0; i < y; i++)
		{
			int orice = 0;
			for (int t = 1; t <= n; t++)
			{
				addup(orice, mul(dp[i][t], prod[i][t]));
			}
			if (max(l, i + 1) <= min(r, y - 1))
			{
				addup(sigma[max(l, i + 1)], orice);
				addup(sigma[min(r, y - 1) + 1], -orice);
			}
		}
		int cur = 0;
		for (int i = 0; i < y; i++)
		{
			addup(cur, sigma[i]);
			addup(ndp[i][1], cur);
		}
		for (int i = l; i <= r; i++)
		{
			for (int t = 1; t <= n; t++)
			{
				addup(ndp[i][t], dp[i][t - 1]);
			}
		}
		dp = ndp;
	}
	int sol = 0;
	for (int i = 0; i < y; i++)
	{
		for (int t = 0; t <= n; t++)
		{
			addup(sol, mul(dp[i][t], prod[i][t]));
		}
	}
	return sol;
}

signed main()
{
	computeFACT();
#ifdef ONPC	
	FILE* stream;
	freopen_s(&stream, "input.txt", "r", stdin);
#else
	ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#endif

	if (0)
	{
		vector<pair<int, int>> v;
		v = { {1, 2}, {1, 1} };
		int d = dumb(v);
		int s = smart(v);
		if (d != s)
		{
			cout << "WA!\n";
			cout << (int)v.size() << "\n";
			for (auto& it : v)
			{
				cout << it.first << " " << it.second << "\n";
			}
			cout << "good = " << d << "\n";
			cout << "me   = " << s << "\n";
			exit(0);
		}
		cout << "AC!\n";
		exit(0);
	}
	
	if (0)
	{
		cout << "debug time!\n";
		long long printtime = (long long)1e4;
		for (long long tc = 1; 1; tc++)
		{
			vector<pair<int, int>> v = getrng();
			int d = dumb(v);
			int s = smart(v);
			if (tc % printtime == 0)
			{
				cout << "done " << tc << ", n = " << (int)v.size() << ", sol = " << s << "\n";
			}
			if (d != s)
			{
				cout << "WA!\n";
				cout << (int)v.size() << "\n";
				for (auto& it : v)
				{
					cout << it.first << " " << it.second << "\n";
				}
				cout << "good = " << d << "\n";
				cout << "me   = " << s << "\n";
				exit(0);
			}
		}
		exit(0);
	}

	int n;
	cin >> n;
	vector<pair<int, int>> v(n);
	for (auto& it : v)
	{
		cin >> it.first >> it.second;
	}
	
	//cout << dumb(v) << "\n";
	cout << smart(v) << "\n";
	return 0;
}

• Subtask 1: 9 / 9
• Subtask 2: 22 / 22
• Subtask 3: 27 / 27
• Subtask 4: 42 / 42