답안 #107495

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
107495 2019-04-24T21:30:51 Z Jatana 동기화 (JOI13_synchronization) C++17
10 / 100
8000 ms 194320 KB
/*
                                                                                                     
                                             `-:://:::-                                             
                                           `//:-------:/:`                                          
                                          .+:--.......--:+`                                         
                                         `+:--..`````..--//`                                        
                                         .o:--..`` ``..--:o`                                        
                                         .o:--...```..---+/`                                        
                                       `/y+o/---....---:+o.                                         
                                   `...````-os+/:---:/+o/--.`                                       
              `-/+++++/:.      `...`       :h+d+oooo+/+-`   ...                                     
            `/++//:::://++-`....`         -.`//````````:`     `..`                                  
           `o+/::------://o/`           `-` -.          -`       `..`                               
 `---.-o/:./o/::-..``..-ЗАПУСКАЕМ      ..  ..            -`        `...       ``..``                
  `....o+:-++/:--.```..-://s.        `-`  .-              -`          `-o: .-//::::/:-`             
          `:s+/:--....-::/+s-`      .-   `-                -`           -///:--------:/:`           
           ./s+//:::::://oo-``..НЕЙРОННУЮ: СЕТЬ:::::::-`РАБОТЯГИ        `+:--........--:/`          
            .:ooo+++++osso-`    `.:-...`/` ./::-------:/:`   -`         :+--..``````.--:+:...-+:-`  
             `.-/+++++/+-.-`    -.   ``:so:/:--.......--:+`  `-```````o+/+--..`````..--:o/-..:s+:.  
                 ```````:``.. `-`     -` `+:--..`````..--/+-.../.`````..-o:--.......---/o.    `     
                        `:  `:-      -.  .o:--..`` ``..--:o`   `-`      `:o+:--------:+o-`          
                         `-`-...    ..   .o/--...```..--:+/`    `-`     `oy/so/////++o/.`           
                          -/`  `-` `- ``+s/o/:---...---:++.      `-`   .-../d://///:-.`             
                `.---..``-..-    .-/..`````-oo+/:::::/+o+-        `-``-`  `-.  ````                 
             `:++++/+++++-  ..``.-/:`      /y-:/++o++/:.`..`       ./.   `-                         
            -++/::::::://+/..:-``:` ..   `-.`  ```.```    `..`   `..`-` `-                          
       ``  -o//:--....-::/++` -.-`   `-`.-`                 `..`..`  `-.-                           
  -----ss+:++/:--.```..-://s.  /.     `::                    `-:.     ./`                           
  `````/:..+o/::-..``.--:/+s. ..-`   `-``-`                 ..` `-`  `-`-`                          
          `-s+/::-----::/+oo---``-` ..    .:-    ```      .-`     .-.-  `-`                         
           `:oo+//::://+os/..:`..-/:`      :y.-:::::::.`.-`        ./-`  `-`                        
            `./+oooooooo+/.`-    .-:...`.. .//:-------://`        `- `..` `:.                       
              ``.-::::-.``-/`  `-` `-  `oo:+:--.......--:/`      `-    `.:--h.``..```               
                          -.-`.-    .-   `+:--..`````..--//`    `-       /s-//::::::::.             
                         -` `/-      ..  .o:--..`` ``..--:o.```.-        `//:--------://`           
                        -` .-`.-`     -.`-o/--...```..--:+/.``-:....``:-.+:--....`...--:+`          
                       ..`-.   `-.   ``:os:o/:---...---:++.  `-     ``///+:-..``````.--:+-````-.`   
              `.:///////.-`      .:-..` -``-+o+/:::::/+o/.  `-         `:+:-..`````..--:o/:--/ys+-  
            `-++///////+o/. ``....`-.    :` `.:++++++/:.`  .-           -o/---......---/o.   `.`    
           `++//:-----::/+o:..`     .-`   :    ```````    .-           `+so+:--------:++-`          
  `````:-``:o/::-..`..--:/+o`         -.  `-             .-          `../../+o+////+o+:.`           
  -----syo/o+/:--.```..-://s.          .-` `-           .-        `...     ``-:////:-``             
       .` `/s//:--....-::/+s.            -. `-`        .-       `..`                                
           .+o+/:::--:://+s/-..`          .::+y  ```  .-     `..`                                   
            ./oo++////+oso-`   `....       :y-+:::::::/`   ...                                      
             `.:+oooooo/-`         `....-. .//:-------:/:-.`                                        
                ``...``                 /+:+:--.......--:+`                                         
                                         `+:--..`````..--//`                                        
                                         .o:--..`` ``..--:o`                                        
                                         .+/--...```..--:+/`                                        
                                         `-o/:---...---:++.                                         
                                          `-+o+/:---:/+o/.                                          
                                            `.:+oooo+/-.`                                           
                                               ``````                                               
*/

#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,

#ifdef fast_allocator
const int MAXMEM = 200 * 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;

int n, m, q;
vector<vector<int>> g;
vector<bool> used;
vector<int> tsize;
vector<vector<int>> events;
map<pii, int> edge_id;
void dfs_tsize(int v, int _p) {
	tsize[v] = 1;
	for (int sub : g[v]) {
		if (sub == _p) continue;
		if (used[sub]) continue;
		dfs_tsize(sub, v);
		tsize[v] += tsize[sub];
	}
}

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

struct Node {
	Node *l = NULL, *r = NULL;
	int value = 0;
	int mod = 0;
	int prior;
	Node(int _value) {
		value = _value;
		prior = rng();
	}
};

void push(Node *node) {
	// if (node->l) node->l->mod += node->mod;
	// if (node->r) node->r->mod += node->mod;
	// node->value += node->mod;
	// node->mod = 0;
}

Node *merge(Node *l, Node *r) {
	if (!l) return r;
	if (!r) return l;
	if (l->prior > r->prior) {
		push(l);
		l->r = merge(l->r, r);
		return l;
	} else {
		push(r);
		r->l = merge(l, r->l);
		return r;
	}
}

pair<Node*, Node*> split(Node *node, int x) {
	if (!node) return mp(node, node);
	push(node);
	if (node->value >= x) {
		auto t = split(node->l, x);
		node->l = t.y;
		return mp(t.x, node);
	} else {
		auto t = split(node->r, x);	
		node->r = t.x;
		return mp(node, t.y);
	}
}

void _delete(Node *node) {
	if (!node) return;
	_delete(node->l);
	_delete(node->r);
	delete node;
}

Node *merge_imb(Node *a, Node *b) {
	if (!a) return b;
	if (!b) return a;
	if (a->prior < b->prior) swap(a, b);
	auto t = split(b, a->value);
	auto t2 = split(t.y, a->value + 1);
	if (t2.x) a->mod += t2.x->mod;
	_delete(t2.x);
	if (a->mod == 0) {
		Node *rez = merge_imb(merge_imb(a->l, t.x), merge_imb(a->r, t2.y));
		a->l = a->r = NULL;
		_delete(a);
		return rez;
	} else {
		a->l = merge_imb(a->l, t.x);
		a->r = merge_imb(a->r, t2.y);

		return a;
	}
}

int summary(Node *node) {
	if (!node) return 0;
	return node->mod + summary(node->l) + summary(node->r);
}

int _size(Node *node) {
	if (!node) return 0;
	return 1 + _size(node->l) + _size(node->r);
}

Node *apply_range(Node *tree, int id) {
	int pref = -1;
	for (int j = 0; j < len(events[id]); j += 2) {
		if (j > 0) pref = events[id][j - 1];
		auto t = split(tree, pref);
		auto t2 = split(t.y, events[id][j]);
		int sum = summary(t2.x);
		_delete(t2.x);
		Node *_new = new Node(events[id][j]);
		_new->mod = sum;
		tree = merge_imb(t.x, merge_imb(t2.y, _new));
	}
	return split(tree, (int)1e8).x;
}

Node *collect(int v, int _p, int d) {
	Node *cur = new Node(0);
	cur->mod = d;
	for (int sub : g[v]) {
		if (sub == _p) continue;
		if (used[sub]) continue;
		int id = edge_id[mp(v, sub)];
		Node *tree = collect(sub, v, d);
		cur = merge_imb(cur, apply_range(tree, id));
	}
	return cur;
}

vector<int> result;

Node *go(int v, int _p, Node *base) {
	result[v] += summary(base);
	for (int sub : g[v]) {
		if (sub == _p) continue;
		if (used[sub]) continue;
		int id = edge_id[mp(v, sub)];

		vector<Node*> add, del;

		int pref = -1;
		for (int j = 0; j < len(events[id]); j += 2) {
			if (j > 0) pref = events[id][j - 1];
			auto t = split(base, pref);
			auto t2 = split(t.y, events[id][j]);
			int sum = summary(t2.x);
			Node *_new = new Node(events[id][j]);
			_new->mod = sum;
			Node *_del = new Node(events[id][j]);
			_del->mod = -sum;
			del.pb(_del);
			add.pb(t2.x);
			base = merge_imb(t.x, merge_imb(t2.y, _new));
		}
		auto t = split(base, (int)1e8);

		base = t.x;

		base = go(sub, v, base);

		for (Node *x : add) {
			base = merge_imb(base, x);
		}
		for (Node *x : del) {
			base = merge_imb(base, x);
		}
	}
	return base;
}

void compose(int v) {
	dfs_tsize(v, -1);
	v = find_centroid(v, -1, 0).y;

	Node *all = collect(v, -1, 1);
	result[v] += summary(all);

	for (int sub : g[v]) {
		if (used[sub]) continue;
		int id = edge_id[mp(v, sub)];
		all = merge_imb(all, apply_range(collect(sub, v, -1), edge_id[mp(v, sub)]));
		{
			vector<Node*> add, del;

			int pref = -1;
			for (int j = 0; j < len(events[id]); j += 2) {
				if (j > 0) pref = events[id][j - 1];
				auto t = split(all, pref);
				auto t2 = split(t.y, events[id][j]);
				int sum = summary(t2.x);
				Node *_new = new Node(events[id][j]);
				_new->mod = sum;
				Node *_del = new Node(events[id][j]);
				_del->mod = -sum;
				del.pb(_del);
				add.pb(t2.x);
				all = merge_imb(t.x, merge_imb(t2.y, _new));
			}
			auto t = split(all, (int)1e8);

			all = t.x;

			all = go(sub, v, all);

			for (Node *x : add) {
				all = merge_imb(all, x);
			}
			for (Node *x : del) {
				all = merge_imb(all, x);
			}
		}
		all = merge_imb(all, apply_range(collect(sub, v, 1), edge_id[mp(v, sub)]));
	}

	_delete(all);

	used[v] = true;
	for (int sub : g[v]) {
		if (used[sub]) continue;
		compose(sub);
	}
}

signed main(signed argc, char *argv[]) {
	// freopen("test.in", "r", stdin);
	// freopen("test.out", "w", stdout);
	scan n, m, q;
	result.resize(n);
	tsize.resize(n);
	g.resize(n);
	used.resize(n, false);
	events.resize(n);
	f(i, n - 1) {
		int a, b;
		scan a, b;
		a--;b--;
		g[a].pb(b);
		g[b].pb(a);
		edge_id[mp(a, b)] = edge_id[mp(b, a)] = i;
	}
	f(i, m) {
		int x;
		scan x;
		x--;
		events[x].pb(i);
	}
	f(i, n - 1) {
		events[i].pb(1e9 / 2);
		events[i].pb(1e9);
	}
	compose(0);
	f(i, q) {
		int x;
		scan x;
		x--;
		print result[x];
	}
}

Compilation message

synchronization.cpp: In function 'void fast_scan(int&)':
synchronization.cpp:138: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); }
                          ~~~~~^~~~~~~~~~
synchronization.cpp: In function 'void fast_scan(long long int&)':
synchronization.cpp:139: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); }
                                ~~~~~^~~~~~~~~~~~
synchronization.cpp: In function 'void fast_scan(long long unsigned int&)':
synchronization.cpp:140: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); }
                                         ~~~~~^~~~~~~~~~~~
synchronization.cpp: In function 'void fast_scan(double&)':
synchronization.cpp:141: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); }
                             ~~~~~^~~~~~~~~~~
synchronization.cpp: In function 'void fast_scan(long double&)':
synchronization.cpp:142: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); }
                                  ~~~~~^~~~~~~~~~~
synchronization.cpp: In function 'void fast_scan(char&)':
synchronization.cpp:144:7: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
  scanf("%c", &x);
  ~~~~~^~~~~~~~~~
synchronization.cpp: In function 'void fast_scan(std::__cxx11::string&)':
synchronization.cpp:150:7: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
  scanf("%s", string_in_buffer);
  ~~~~~^~~~~~~~~~~~~~~~~~~~~~~~
# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 384 KB Output is correct
2 Correct 2 ms 384 KB Output is correct
3 Correct 2 ms 384 KB Output is correct
4 Correct 2 ms 256 KB Output is correct
5 Correct 3 ms 384 KB Output is correct
6 Correct 15 ms 1152 KB Output is correct
7 Correct 241 ms 9632 KB Output is correct
8 Correct 214 ms 9336 KB Output is correct
9 Correct 224 ms 9716 KB Output is correct
10 Correct 3844 ms 107052 KB Output is correct
11 Correct 3972 ms 108852 KB Output is correct
12 Correct 4080 ms 191320 KB Output is correct
13 Execution timed out 8045 ms 33060 KB Time limit exceeded
14 Halted 0 ms 0 KB -
# 결과 실행 시간 메모리 Grader output
1 Execution timed out 8032 ms 38940 KB Time limit exceeded
2 Halted 0 ms 0 KB -
# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 384 KB Output is correct
2 Correct 2 ms 256 KB Output is correct
3 Correct 3 ms 384 KB Output is correct
4 Correct 3 ms 384 KB Output is correct
5 Correct 3 ms 384 KB Output is correct
6 Correct 18 ms 1536 KB Output is correct
7 Correct 252 ms 15992 KB Output is correct
8 Correct 4210 ms 194320 KB Output is correct
9 Correct 3932 ms 193920 KB Output is correct
# 결과 실행 시간 메모리 Grader output
1 Correct 4078 ms 191676 KB Output is correct
2 Execution timed out 8055 ms 46584 KB Time limit exceeded
3 Halted 0 ms 0 KB -
# 결과 실행 시간 메모리 Grader output
1 Correct 2 ms 256 KB Output is correct
2 Correct 3 ms 384 KB Output is correct
3 Correct 2 ms 256 KB Output is correct
4 Correct 3 ms 384 KB Output is correct
5 Correct 17 ms 1024 KB Output is correct
6 Correct 239 ms 9724 KB Output is correct
7 Correct 4308 ms 110716 KB Output is correct
8 Correct 3801 ms 193856 KB Output is correct
9 Execution timed out 8039 ms 35140 KB Time limit exceeded
10 Halted 0 ms 0 KB -