Submission #107772

#	Time	Username	Problem	Language	Result	Execution time	Memory
107772		Jatana	Factories (JOI14_factories)	C++17	100 / 100	6452 ms	333868 KiB

factories

#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 (stderr)

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 / 15
• Subtask 2: 18 / 18
• Subtask 3: 67 / 67