oj.uz

답안 #46727

# 제출 시각 아이디 문제 언어 결과 실행 시간 메모리
46727 2018-04-22T16:04:41 Z Jatana Soccer (JOI17_soccer) C++17
100 / 100
 1548 ms 51648 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>

#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 fuck(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);}

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

#define scan cin,

#ifdef fast_allocator
const int MAXMEM = 50000000;
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 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 kek, Args... args) {
		if (!first_print) {
			fast_print("\n");
		} else {
			first_print = false;
		}
		fast_print(names.front());
		fast_print(" = ");
		fast_print(kek);
		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;
}

#define int long long

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 % b == 0) return 0;
		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;

#define end aaoenthuosaeuh

const int N = 510;

int w, h;
int n;
int A, B, C;

vector<vector<int>> player;
pii st, end;

const vector<pii> shifts = {
	mp(0, 1),
	mp(1, 0),
	mp(0, -1),
	mp(-1, 0)
};

int dist[N][N][2][4]; 

enum StateType {
	WITH_HUMAN, FLY
};

struct State {
	StateType type;
	int dir;	
	pii pos;

	State() {}
	State(StateType _type, pii _pos, int _dir) {
		type = _type;
		pos = _pos;
		dir = _dir;
	}

	int get_dist() {
		return dist[pos.x][pos.y][type][dir];
	}

	void set_dist(int _d) {
		dist[pos.x][pos.y][type][dir] = _d;
	}
};

bool norm(pii ceil) {
	return 0 <= ceil.x && ceil.x < N && 0 <= ceil.y && ceil.y < N;
}

pii operator+(pii a, pii b) {
	return mp(a.x + b.x, a.y + b.y);
}

signed main(signed argc, char *argv[]) {
	{
		scan w, h;
		w++;h++;
		scan A, B, C;
	}
	{
		f(i, N) {
			f(j, N) {
				f(k, 2) {
					f(t, 4) {
						dist[i][j][k][t] = 1e18;
					}
				}
			}	
		}
	}
	{
		deque<pii> deq;
		player.resize(N, vector<int>(N, 1e18));
		scan n;

		f(i, n) {
			pii p;
			scan p;
			player[p.x][p.y] = 0;
			if (i == 0) {
				st = p;
			}
			if (i == n - 1) {
				end = p;
			}
			deq.pb(p);
		}

		while (!deq.empty()) {
			pii v = deq[0];
			deq.pop_front();
			for (pii d : shifts) {
				pii sub = v + d;
				if (norm(sub)) {
					if (player[sub.x][sub.y] > player[v.x][v.y] + 1) {
						player[sub.x][sub.y] = player[v.x][v.y] + 1;
						deq.pb(sub);
					}
				}
			}
		}
	}
	{
		auto cmp = [](State a, State b) {
			return a.get_dist() > b.get_dist();
		};
		priority_queue<State, vector<State>, decltype(cmp)> deq(cmp);
		State start(WITH_HUMAN, st, 0);
		start.set_dist(0);
		deq.push(start);
		while (!deq.empty()) {
			State v = deq.top();
			deq.pop();
			if (v.type == WITH_HUMAN) {
				for (pii d : shifts) {
					pii sub = mp(v.pos.x + d.x, v.pos.y + d.y);
					if (norm(sub)) {
						State s(WITH_HUMAN, sub, 0);
						if (s.get_dist() > v.get_dist() + C) {
							s.set_dist(v.get_dist() + C);
							deq.push(s);
						}
					}
				}
				f(d, len(shifts)) {
					State s(FLY, v.pos, d);
					if (s.get_dist() > v.get_dist() + B) {
						s.set_dist(v.get_dist() + B);
						deq.push(s);
					}
				}	
			} else if (v.type == FLY) {
				State s(WITH_HUMAN, v.pos, 0);
				if (s.get_dist() > v.get_dist() + player[v.pos.x][v.pos.y] * C) {
					s.set_dist(v.get_dist() + player[v.pos.x][v.pos.y] * C);
					deq.push(s);
				}
				pii sub = v.pos + shifts[v.dir];
				if (norm(sub)) {
					State s(FLY, sub, v.dir);
					if (s.get_dist() > v.get_dist() + A) {
						s.set_dist(v.get_dist() + A);
						deq.push(s);
					}
				}
			}
		}
		print State(WITH_HUMAN, end, 0).get_dist();
		// print State(WITH_HUMAN, mp(1, 2), 0).get_dist();
	}
}

Compilation message

soccer.cpp: In function 'void fast_scan(int&)':
soccer.cpp:131: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); }
                          ~~~~~^~~~~~~~~~
soccer.cpp: In function 'void fast_scan(long long int&)':
soccer.cpp:132: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); }
                                ~~~~~^~~~~~~~~~~~
soccer.cpp: In function 'void fast_scan(long long unsigned int&)':
soccer.cpp:133: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); }
                                         ~~~~~^~~~~~~~~~~~
soccer.cpp: In function 'void fast_scan(double&)':
soccer.cpp:134: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); }
                             ~~~~~^~~~~~~~~~~
soccer.cpp: In function 'void fast_scan(long double&)':
soccer.cpp:135: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); }
                                  ~~~~~^~~~~~~~~~~
soccer.cpp: In function 'void fast_scan(char&)':
soccer.cpp:137:7: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
  scanf("%c", &x); 
  ~~~~~^~~~~~~~~~
soccer.cpp: In function 'void fast_scan(std::__cxx11::string&)':
soccer.cpp:143: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
5.0 / 5.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1042 ms 27012 KB Output is correct
2 Correct 928 ms 51648 KB Output is correct
3 Correct 946 ms 51648 KB Output is correct
4 Correct 989 ms 51648 KB Output is correct
5 Correct 302 ms 51648 KB Output is correct

Subtask #2
30.0 / 30.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1127 ms 51648 KB Output is correct
2 Correct 1087 ms 51648 KB Output is correct
3 Correct 1074 ms 51648 KB Output is correct
4 Correct 749 ms 51648 KB Output is correct
5 Correct 1043 ms 51648 KB Output is correct
6 Correct 863 ms 51648 KB Output is correct
7 Correct 1024 ms 51648 KB Output is correct
8 Correct 1115 ms 51648 KB Output is correct
9 Correct 1195 ms 51648 KB Output is correct
10 Correct 1111 ms 51648 KB Output is correct
11 Correct 1230 ms 51648 KB Output is correct
12 Correct 1194 ms 51648 KB Output is correct
13 Correct 948 ms 51648 KB Output is correct
14 Correct 1241 ms 51648 KB Output is correct
15 Correct 1205 ms 51648 KB Output is correct

Subtask #3
65.0 / 65.0

# 결과 실행 시간 메모리 Grader output
1 Correct 1042 ms 27012 KB Output is correct
2 Correct 928 ms 51648 KB Output is correct
3 Correct 946 ms 51648 KB Output is correct
4 Correct 989 ms 51648 KB Output is correct
5 Correct 302 ms 51648 KB Output is correct
6 Correct 1127 ms 51648 KB Output is correct
7 Correct 1087 ms 51648 KB Output is correct
8 Correct 1074 ms 51648 KB Output is correct
9 Correct 749 ms 51648 KB Output is correct
10 Correct 1043 ms 51648 KB Output is correct
11 Correct 863 ms 51648 KB Output is correct
12 Correct 1024 ms 51648 KB Output is correct
13 Correct 1115 ms 51648 KB Output is correct
14 Correct 1195 ms 51648 KB Output is correct
15 Correct 1111 ms 51648 KB Output is correct
16 Correct 1230 ms 51648 KB Output is correct
17 Correct 1194 ms 51648 KB Output is correct
18 Correct 948 ms 51648 KB Output is correct
19 Correct 1241 ms 51648 KB Output is correct
20 Correct 1205 ms 51648 KB Output is correct
21 Correct 466 ms 51648 KB Output is correct
22 Correct 1433 ms 51648 KB Output is correct
23 Correct 1329 ms 51648 KB Output is correct
24 Correct 1404 ms 51648 KB Output is correct
25 Correct 1142 ms 51648 KB Output is correct
26 Correct 1300 ms 51648 KB Output is correct
27 Correct 447 ms 51648 KB Output is correct
28 Correct 399 ms 51648 KB Output is correct
29 Correct 1054 ms 51648 KB Output is correct
30 Correct 361 ms 51648 KB Output is correct
31 Correct 1359 ms 51648 KB Output is correct
32 Correct 1548 ms 51648 KB Output is correct
33 Correct 1002 ms 51648 KB Output is correct
34 Correct 1537 ms 51648 KB Output is correct
35 Correct 299 ms 51648 KB Output is correct