結果

問題 No.5017 Tool-assisted Shooting
ユーザー ebicochinealebicochineal
提出日時 2023-07-16 15:34:49
言語 C++14
(gcc 13.3.0 + boost 1.87.0)
結果
AC  
実行時間 69 ms / 2,000 ms
コード長 8,229 bytes
コンパイル時間 1,240 ms
コンパイル使用メモリ 114,988 KB
実行使用メモリ 24,420 KB
スコア 74,830
平均クエリ数 399.74
最終ジャッジ日時 2023-07-16 15:35:01
合計ジャッジ時間 9,966 ms
ジャッジサーバーID
(参考情報)
judge11 / judge15
純コード判定しない問題か言語
このコードへのチャレンジ
(要ログイン)
ファイルパターン 結果
other AC * 100
権限があれば一括ダウンロードができます

ソースコード

diff #
プレゼンテーションモードにする

#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("inline")
#include <cmath>
#include <string>
#include <array>
#include <vector>
#include <cstdlib>
#include <sstream>
#include <iostream>
#include <algorithm>
#include <limits>
#include <queue>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <bitset>
#include <chrono>
using namespace std;
template<class F, class S> string in_v_to_str (const pair<F, S> v);
template<class F, class S> string v_to_str (const pair<F, S> v);
string in_v_to_str (const char v) { return "'" + string{v} + "'"; }
string in_v_to_str (const char* v) { return "\"" + string(v) + "\""; }
string in_v_to_str (const string v) { return "\"" + v + "\""; }
template<class T> string in_v_to_str (const T v) { stringstream ss; ss << v; return ss.str(); }
template<class T> string v_to_str (const T v) { stringstream ss; ss << v; return ss.str(); }
template<class T, size_t N> string v_to_str (const array<T, N>& v) { stringstream ss; if (v.size() > 0) { ss << "["; for (size_t i = 0; i < v.size()
    - 1; ++i) { ss << in_v_to_str(v[i]) << ", "; } ss << in_v_to_str(v[v.size() - 1]) << "]"; } else { ss << "[]"; } return ss.str(); }
template<class T, size_t N> string v_to_str (const array< array<T, N>, N >& v) { stringstream ss; if (v.size() > 0) { ss << "["; for (size_t i = 0; i
    < v.size() - 1; ++i) { ss << v_to_str(v[i]) << ", "; } ss << v_to_str(v[v.size() - 1]) << "]"; } else { ss << "[-]"; } return ss.str(); }
template<class T> string v_to_str (const vector<T>& v) { stringstream ss; if (v.size() > 0) { ss << "["; for (size_t i = 0; i < v.size() - 1; ++i) {
    ss << in_v_to_str(v[i]) << ", "; } ss << in_v_to_str(v[v.size() - 1]) << "]"; } else { ss << "[]"; } return ss.str(); }
template<class T> string v_to_str (const vector< vector<T> >& v) { stringstream ss; if (v.size() > 0) { ss << "["; for (size_t i = 0; i < v.size() -
    1; ++i) { ss << v_to_str(v[i]) << ", "; } ss << v_to_str(v[v.size() - 1]) << "]"; } else { ss << "[-]"; } return ss.str(); }
template<class T> string v_to_str (const set<T>& v) { stringstream ss; int len = v.size(); ss << (v.size() > 0 ? "{" : "{}"); for (auto& i : v) { ss
    << in_v_to_str(i) << (len-- > 1 ? ", " : "}"); } return ss.str(); }
template<class K, class V> string v_to_str (const map<K, V>& v) { stringstream ss; int len = v.size(); ss << (v.size() > 0 ? "{" : "{}"); for (auto&
    i : v) { ss << in_v_to_str(i.first) << " : " << in_v_to_str(i.second) << (len-- > 1 ? ", " : "}"); } return ss.str(); }
template<class T> string v_to_str (const unordered_set<T>& v) { stringstream ss; int len = v.size(); ss << (v.size() > 0 ? "{" : "{}"); for (auto& i
    : v) { ss << in_v_to_str(i) << (len-- > 1 ? ", " : "}"); } return ss.str(); }
template<class K, class V> string v_to_str (const unordered_map<K, V>& v) { stringstream ss; int len = v.size(); ss << (v.size() > 0 ? "{" : "{}");
    for (auto& i : v) { ss << in_v_to_str(i.first) << " : " << in_v_to_str(i.second) << (len-- > 1 ? ", " : "}"); } return ss.str(); }
template<class F, class S> string in_v_to_str (const pair<F, S> v) { stringstream ss; ss << "<" << v_to_str(v.first) << ", " << v_to_str(v.second) <<
    ">"; return ss.str(); }
template<class F, class S> string v_to_str (const pair<F, S> v) { stringstream ss; ss << "<" << v_to_str(v.first) << ", " << v_to_str(v.second) << "
    >"; return ss.str(); }
string print () { return ""; }
template<typename F, typename... R> string print (const F& f, const R& ...r) { stringstream ss; ss << v_to_str(f); if (sizeof...(r) > 0) { ss << " "
    << print(r...); } return ss.str(); }
template<typename F, typename... R> void pdebug (const F& f, const R& ...r) {
stringstream ss;
ss << v_to_str(f); if (sizeof...(r) > 0) { ss << " " << print(r...); }
cerr << "<cerr>" << ss.str() << "</cerr>" << endl;
}
template<typename F, typename... R> void fdebug (const F& f, const R& ...r) {
stringstream ss;
ss << v_to_str(f); if (sizeof...(r) > 0) { ss << " " << print(r...); }
cerr << "<cerrfile>" << ss.str() << "</cerrfile>" << endl;
}
template<typename F, typename... R> void tdebug (const F& f, const R& ...r) {
stringstream ss;
ss << v_to_str(f); if (sizeof...(r) > 0) { ss << " " << print(r...); }
cerr << "<cerr>[time]" << ss.str() << "</cerr>" << endl;
}
struct e512pos {
public:
int x;
int y;
e512pos () { this->x = 0; this->y = 0; }
e512pos (int x, int y) {
this->x = x;
this->y = y;
}
e512pos operator + (const e512pos& t) { return e512pos(this->x + t.x, this->y + t.y); }
e512pos operator - (const e512pos& t) { return e512pos(this->x - t.x, this->y - t.y); }
bool operator == (const e512pos& t) const { return this->x == t.x && this->y == t.y; }
};
namespace std {
template <> class hash<e512pos> {
public:
size_t operator()(const e512pos& t) const{ return t.x<<16 | t.y; }
};
}
ostream& operator << (ostream& os, const e512pos& p) {
os << "(" << p.x << ", " << p.y << ")";
return os;
};
class StopWatch {
public:
std::chrono::system_clock::time_point start, tstart, end;
StopWatch () {
this->start = std::chrono::system_clock::now();
}
inline void stop () {
this->tstart = std::chrono::system_clock::now();
}
inline void resume () {
this->start += std::chrono::system_clock::now() - this->tstart;
}
inline uint64_t get_milli_time () {
this->end = std::chrono::system_clock::now();
return std::chrono::duration_cast<std::chrono::milliseconds>(end-start).count();
}
};
inline uint32_t xrnd() {
static uint32_t y = 2463534242;
y = y ^ (y << 13);
y = y ^ (y >> 17);
return y = y ^ (y << 5);
}
constexpr int width = 25; //
constexpr int height = 60; //
constexpr int max_turn = 1000; //
struct E {
int x, y, h, p;
E (int x, int h, int p) {
this->x = x;
this->h = h;
this->p = p;
this->y = height;
}
};
class MM {
public:
StopWatch sw;
MM () { this->sw = StopWatch(); }
int L = 1;
int P = 0;
char out;
int X = 12;
vector<E> es;
void dropDownDel (vector<E>& v) {
int l = 0;
for (int i = 0; i < v.size(); ++i) {
if (v[i].y == 0 || v[i].h <= 0) {
} else {
swap(v[i], v[l]);
l += 1;
}
}
int d = v.size() - l;
for (int i = 0; i < d; ++i) {
v.pop_back();
}
}
void input () {
for(int turn = 1; turn <= max_turn; turn++) {
int n;
cin >> n;
if(n == -1) { return; }
for(int i = 0; i < n; i++) {
int h, p, x;
std::cin >> h >> p >> x;
}
for (auto&& i : this->es) {
i.y -= 1;
if (i.h <= 0) { this->P += i.p; }
}
this->dropDownDel(this->es);
bool dn[] = {false, false, false};
int dnx[] = {this->X-1 >= width ? width-1 : this->X-1, this->X, this->X+1 >= width ? 0 : this->X+1};
for (auto&& i : this->es) {
for (int j = 0; j < 3; ++j) {
if (i.y < 2 && i.x == dnx[j]) {
dn[j] = true;
}
}
}
this->out = 'S';
if (dn[1]) {
if (dn[0] == false) {
this->out = 'L';
} else {
this->out = 'R';
}
}
if (this->out == 'L') { this->X = dnx[0]; }
if (this->out == 'S') { this->X = dnx[1]; }
if (this->out == 'R') { this->X = dnx[2]; }
this->solve();
this->output();
}
}
void output () {
cout << this->out << endl;
}
void solve () {
}
};
int main () {
cin.tie(0);
ios::sync_with_stdio(false);
MM mm;
mm.input();
cout.flush();
return 0;
}
הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
0