oj.uz

Submission #107772

# Submission time Handle Problem Language Result Execution time Memory
107772 2019-04-25T17:49:12 Z Jatana Factories (JOI14_factories) C++17
100 / 100
 6452 ms 333868 KB 
#ifdef aimbot
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
#endif

#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <map>
#include <set>
#include <queue>
#include <ostream>
#include <istream>
#include <typeinfo>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <limits>
#include <fstream>
#include <array>
#include <list>
#include <bitset>
#include <functional>
#include <random>
#include <cstring>
#include <chrono>

#define random escape__from__random__aetuhoetnuhshe
#define mt make_tuple
#define x first
#define y second
#define pb push_back
#define ppb pop_back
#define mp make_pair
#define umap unordered_map
#define uset unordered_set
#define elif else if
#define len(v) ((int)v.size())
#define f(i, n) for (int i = 0; i < (n); i++)
#define rof(i, n) for (int i = ((n) - 1); i >= 0; i--)
#define apply(v, act) for (auto &x : v) { act; }
#define log(args...) {string s = #args;deque<string> deq;\
string buf = "";int bal = 0;for (char c : s) {\
if (c == '(' || c == '[' || c == '{') {bal++;\
} else if (c == ')' || c == ']' || c == '}') {\
bal--;} else {if (bal == 0) {if (c == ',') {\
deq.pb(buf);buf = "";} else {if (c != ' ') {\
buf += c;}}}}}if (!buf.empty()) {deq.pb(buf);}\
smart_io::precall_print();smart_io::_print(deq, args);}

inline int min(const int &x, const int &y) { return (((y-x)>>(32-1))&(x^y))^x; }
inline int max(const int &x, const int &y) { return (((y-x)>>(32-1))&(x^y))^y; }
inline long long min(const long long &x, const long long &y) { return (((y-x)>>(64-1))&(x^y))^x; }
inline long long max(const long long &x, const long long &y) { return (((y-x)>>(64-1))&(x^y))^y; }

#define print    \
smart_io::precall_print(); \
cout,

#define scan cin,
#define fast_allocator
#ifdef fast_allocator
const int MAXMEM = 260 * 1000 * 1024;
char _memory[MAXMEM];
size_t _ptr = 0;
void* operator new(size_t _x) { _ptr += _x; assert(_ptr < MAXMEM); return _memory + _ptr - _x; }
void operator delete (void*) noexcept {}
#endif

using namespace std;

char string_in_buffer[(int)260];


void fast_scan(int &x) { scanf("%d", &x); }
void fast_scan(long long &x) { scanf("%lld", &x); }
void fast_scan(unsigned long long &x) { scanf("%llu", &x); }
void fast_scan(double &x) { scanf("%lf", &x); }
void fast_scan(long double &x) { scanf("%Lf", &x); }
void fast_scan(char &x) {
	scanf("%c", &x);
	if (x == '\n') {
		fast_scan(x);
	}
}
void fast_scan(string &x) {
	scanf("%s", string_in_buffer);
	x = string(string_in_buffer);
}

template<class TFirst, class TSecond>
void fast_scan(pair<TFirst, TSecond> &p) {
	fast_scan(p.first);
	fast_scan(p.second);
}

template <class T>
void fast_scan(vector<T> &v) {
	for (auto &x : v) fast_scan(x);
}

void fast_print(const int &x) { printf("%d", x); }
void fast_print(const unsigned int &x) { printf("%u", x); }
void fast_print(const long long &x) { printf("%lld", x); }
void fast_print(const unsigned long long &x) { printf("%llu", x); }
void fast_print(const double &x) { printf("%.15lf", x); }
void fast_print(const long double &x) { printf("%.15Lf", x); }
void fast_print(const char &x) { printf("%c", x); };
void fast_print(const string &x) { printf("%s", x.c_str());}
void fast_print(const char v[]) { fast_print((string)v); }

template<class TFirst, class TSecond>
void fast_print(const pair<TFirst, TSecond> &p) {
	fast_print(p.first);
	fast_print(' ');
	fast_print(p.second);
}

template <class T>
void fast_print(const vector<T> &v) {
	if (v.empty()) return;
	fast_print(v[0]);
	for (int i = 1; i < v.size(); i++) {
		fast_print(' ');
		fast_print(v[i]);
	}
}

template <class T>
void fast_print(const vector<vector<T>> &v) {
	if (v.empty()) return;
	fast_print(v[0]);
	for (int i = 1; i < v.size(); i++) {
		fast_print('\n');
		fast_print(v[i]);
	}
}

template <class T>
void fast_print(const T &v) {
	for (const auto &x : v) {
		fast_print(x);
		fast_print(' ');
	}
}


using namespace std;


namespace smart_io {
	string print_start = "";
	string sep = " ";
	bool first_print = false;
	
	void precall_print() {
		fast_print(print_start);
		print_start = "\n";
		first_print = true;
	}
	
	void _print(deque<string>) {}
	template<class T, class... Args>
	void _print(deque<string> names, T elem, Args... args) {
		if (!first_print) {
			fast_print("\n");
		} else {
			first_print = false;
		}
		fast_print(names.front());
		fast_print(" = ");
		fast_print(elem);
		names.pop_front();
		_print(names, args...);
	}
} //namespace smart_io


template <class T>
ostream &operator,(ostream &os, const T &object) {
	if (!smart_io::first_print) {
		fast_print(smart_io::sep);
	} else {
		smart_io::first_print = false;
	}
	fast_print(object);
	return os;
}

template <class T>
istream &operator,(istream &is, T &object) {
	fast_scan(object);
	return is;
}

namespace random {
	using namespace std::chrono;
	mt19937 rng(duration_cast< milliseconds >(
											  system_clock::now().time_since_epoch()
											  ).count());
	uniform_real_distribution<> prob_dist(0.0, 1.0);
};

namespace typedefs {
	typedef long long ll;
	typedef unsigned long long ull;
	typedef pair<int, int> pii;
	typedef long double ld;
}

namespace numbers_operation {
	template<class T>
	T floor_mod(T a, T b) {
		if (a >= 0 && b >= 0) return a % b;
		if (a <= 0 && b <= 0) return a % b;
		return abs(b) - (abs(a) % abs(b));
	}
}

using namespace numbers_operation;
using namespace typedefs;
using namespace random;

const int N = 5e5;
int n;
vector<pii> g[N];
vector<int> tsize;
vector<bool> used;

void dfs_size(int v, int _p) {
	tsize[v] = 1;
	for (pii sub : g[v]) {
		if (sub.x == _p) continue;
		if (used[sub.x]) continue;
		dfs_size(sub.x, v);
		tsize[v] += tsize[sub.x];
	}
}

pii find_centroid(int v, int _p, int up) {
	int _max = up;
	for (pii sub : g[v]) {
		if (sub.x == _p) continue;
		if (used[sub.x]) continue;
		_max = max(_max, tsize[sub.x]);
	}
	pii best = mp(_max, v);
	for (pii sub : g[v]) {
		if (sub.x == _p) continue;
		if (used[sub.x]) continue;
		best = min(best, find_centroid(sub.x, v, up + tsize[v] - tsize[sub.x]));
	}
	return best;
}


vector<ll> con[N];
vector<int> pref;

void go(int v, int _p, ll dist, int root) {
	con[v].pb(dist);
	for (pii sub : g[v]) {
		if (sub.x == _p) continue;
		if (used[sub.x]) continue;
		go(sub.x, v, dist + sub.y, root);
	}
}

void compose(int v, int _p) {
	dfs_size(v, -1);
	v = find_centroid(v, -1, 0).y;
	pref[v] = _p;

	go(v, -1, 0, v);

	used[v] = true;
	for (pii sub : g[v]) {
		if (used[sub.x]) continue;
		compose(sub.x, v);
	}	
}

vector<ll> minA;

void Init(int _n, int *a, int *b, int *d) {
	n = _n;
	tsize.resize(n);
	used.resize(n, false);
	minA.resize(n, 1e18);
	pref.resize(n, -1);
	f(i, n - 1) {
		g[a[i]].emplace_back(b[i], d[i]);
		g[b[i]].emplace_back(a[i], d[i]);
	}
	compose(0, -1);
	f(i, n) {
		reverse(con[i].begin(), con[i].end());
	}
}

ll Query(int a, int *x, int b, int *y) {
	if (a > b) { swap(a, b); swap(x, y); }

	int cur = 0;
	int j = 0;
	f(i, a) {
		cur = x[i];
		j = 0;
		while (cur != -1) {
			minA[cur] = min(minA[cur], con[x[i]][j++]);
			cur = pref[cur];
		}
	}
	ll result = 1e18;
	f(i, b) {
		cur = y[i];
		j = 0;
		while (cur != -1) {
			result = min(result, minA[cur] + con[y[i]][j++]);
			cur = pref[cur];
		}
	}
	f(i, a) {
		cur = x[i];
		while (cur != -1) {
			minA[cur] = 1e18;
			cur = pref[cur];
		}
	}
	return result;
}

int A[] = {0, 1, 2, 2, 4, 1};
int B[] = {1, 2, 3, 4, 5, 6};
int D[] = {4, 4, 5, 6, 5, 3};
int Q1X[] = {0, 6};
int Q1Y[] = {3, 4};
int Q2X[] = {0, 1, 3};
int Q2Y[] = {4, 6};
int Q3X[] = {2};
int Q3Y[] = {5};

// signed main(signed argc, char *argv[]) {
// 	int n = 7;
// 	int m = 3;
// 	Init(n, A, B, D);
// 	print Query(2, Q1X, 2, Q1Y);
// 	print Query(3, Q2X, 2, Q2Y);
// 	print Query(1, Q3X, 1, Q3Y);
// }

Compilation message

factories.cpp: In function 'void fast_scan(int&)':
factories.cpp:82:31: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 void fast_scan(int &x) { scanf("%d", &x); }
                          ~~~~~^~~~~~~~~~
factories.cpp: In function 'void fast_scan(long long int&)':
factories.cpp:83:37: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 void fast_scan(long long &x) { scanf("%lld", &x); }
                                ~~~~~^~~~~~~~~~~~
factories.cpp: In function 'void fast_scan(long long unsigned int&)':
factories.cpp:84:46: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 void fast_scan(unsigned long long &x) { scanf("%llu", &x); }
                                         ~~~~~^~~~~~~~~~~~
factories.cpp: In function 'void fast_scan(double&)':
factories.cpp:85:34: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 void fast_scan(double &x) { scanf("%lf", &x); }
                             ~~~~~^~~~~~~~~~~
factories.cpp: In function 'void fast_scan(long double&)':
factories.cpp:86:39: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 void fast_scan(long double &x) { scanf("%Lf", &x); }
                                  ~~~~~^~~~~~~~~~~
factories.cpp: In function 'void fast_scan(char&)':
factories.cpp:88:7: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
  scanf("%c", &x);
  ~~~~~^~~~~~~~~~
factories.cpp: In function 'void fast_scan(std::__cxx11::string&)':
factories.cpp:94:7: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
  scanf("%s", string_in_buffer);
  ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~

Subtask #1
15.0 / 15.0

# Verdict Execution time Memory Grader output
1 Correct 28 ms 24312 KB Output is correct
2 Correct 378 ms 40324 KB Output is correct
3 Correct 423 ms 40696 KB Output is correct
4 Correct 369 ms 40680 KB Output is correct
5 Correct 406 ms 41464 KB Output is correct
6 Correct 294 ms 39800 KB Output is correct
7 Correct 430 ms 40696 KB Output is correct
8 Correct 353 ms 40568 KB Output is correct
9 Correct 399 ms 41112 KB Output is correct
10 Correct 324 ms 39672 KB Output is correct
11 Correct 392 ms 40404 KB Output is correct

Subtask #2
18.0 / 18.0

# Verdict Execution time Memory Grader output
1 Correct 21 ms 23936 KB Output is correct
2 Correct 3167 ms 171224 KB Output is correct
3 Correct 4910 ms 241272 KB Output is correct
4 Correct 1083 ms 68264 KB Output is correct
5 Correct 5900 ms 333868 KB Output is correct
6 Correct 5086 ms 241284 KB Output is correct
7 Correct 1291 ms 67320 KB Output is correct
8 Correct 400 ms 45228 KB Output is correct
9 Correct 1541 ms 81656 KB Output is correct
10 Correct 1407 ms 68364 KB Output is correct

Subtask #3
67.0 / 67.0

# Verdict Execution time Memory Grader output
1 Correct 28 ms 24312 KB Output is correct
2 Correct 378 ms 40324 KB Output is correct
3 Correct 423 ms 40696 KB Output is correct
4 Correct 369 ms 40680 KB Output is correct
5 Correct 406 ms 41464 KB Output is correct
6 Correct 294 ms 39800 KB Output is correct
7 Correct 430 ms 40696 KB Output is correct
8 Correct 353 ms 40568 KB Output is correct
9 Correct 399 ms 41112 KB Output is correct
10 Correct 324 ms 39672 KB Output is correct
11 Correct 392 ms 40404 KB Output is correct
12 Correct 21 ms 23936 KB Output is correct
13 Correct 3167 ms 171224 KB Output is correct
14 Correct 4910 ms 241272 KB Output is correct
15 Correct 1083 ms 68264 KB Output is correct
16 Correct 5900 ms 333868 KB Output is correct
17 Correct 5086 ms 241284 KB Output is correct
18 Correct 1291 ms 67320 KB Output is correct
19 Correct 400 ms 45228 KB Output is correct
20 Correct 1541 ms 81656 KB Output is correct
21 Correct 1407 ms 68364 KB Output is correct
22 Correct 3373 ms 170908 KB Output is correct
23 Correct 3436 ms 175380 KB Output is correct
24 Correct 6031 ms 241840 KB Output is correct
25 Correct 5950 ms 246024 KB Output is correct
26 Correct 6011 ms 243124 KB Output is correct
27 Correct 6452 ms 327592 KB Output is correct
28 Correct 1400 ms 96684 KB Output is correct
29 Correct 5781 ms 266164 KB Output is correct
30 Correct 6187 ms 265640 KB Output is correct
31 Correct 5832 ms 266404 KB Output is correct
32 Correct 1528 ms 93732 KB Output is correct
33 Correct 512 ms 56448 KB Output is correct
34 Correct 1213 ms 70520 KB Output is correct
35 Correct 1225 ms 71404 KB Output is correct
36 Correct 1496 ms 75984 KB Output is correct
37 Correct 1546 ms 76292 KB Output is correct