oj.uz

Submission #650891

# Submission time Handle Problem Language Result Execution time Memory
650891 2022-10-16T03:24:18 Z Benq Uplifting Excursion (BOI22_vault) C++17
5 / 100
 279 ms 2476 KB 
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <vector>
using namespace std;

using ll = long long;
using db = long double; // or double, if TL is tight
using str = string;		// yay python!

// pairs
using pi = pair<int, int>;
using pl = pair<ll, ll>;
using pd = pair<db, db>;
#define mp make_pair
#define f first
#define s second

#define tcT template <class T
#define tcTU tcT, class U
// ^ lol this makes everything look weird but I'll try it
tcT > using V = vector<T>;
tcT, size_t SZ > using AR = array<T, SZ>;
using vi = V<int>;
using vb = V<bool>;
using vl = V<ll>;
using vd = V<db>;
using vs = V<str>;
using vpi = V<pi>;
using vpl = V<pl>;
using vpd = V<pd>;

// vectors
// oops size(x), rbegin(x), rend(x) need C++17
#define sz(x) int((x).size())
#define bg(x) begin(x)
#define all(x) bg(x), end(x)
#define rall(x) x.rbegin(), x.rend()
#define sor(x) sort(all(x))
#define rsz resize
#define ins insert
#define pb push_back
#define eb emplace_back
#define ft front()
#define bk back()

#define lb lower_bound
#define ub upper_bound
tcT > int lwb(V<T> &a, const T &b) { return int(lb(all(a), b) - bg(a)); }
tcT > int upb(V<T> &a, const T &b) { return int(ub(all(a), b) - bg(a)); }

// loops
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define F0R(i, a) FOR(i, 0, a)
#define ROF(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define R0F(i, a) ROF(i, 0, a)
#define rep(a) F0R(_, a)
#define each(a, x) for (auto &a : x)

const int MOD = (int)1e9 + 7; // 998244353;
const int MX = (int)2e5 + 5;
const ll BIG = 1e18; // not too close to LLONG_MAX
const db PI = acos((db)-1);
const int dx[4]{1, 0, -1, 0}, dy[4]{0, 1, 0, -1}; // for every grid problem!!
mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
template <class T> using pqg = priority_queue<T, vector<T>, greater<T>>;

// bitwise ops
// also see https://gcc.gnu.org/onlinedocs/gcc/Other-Builtins.html
constexpr int pct(int x) { return __builtin_popcount(x); } // # of bits set
constexpr int bits(
	int x) { // assert(x >= 0); // make C++11 compatible until USACO updates ...
	return x == 0 ? 0 : 31 - __builtin_clz(x);
} // floor(log2(x))
constexpr int p2(int x) { return 1 << x; }
constexpr int msk2(int x) { return p2(x) - 1; }

ll cdiv(ll a, ll b) {
	return a / b + ((a ^ b) > 0 && a % b);
} // divide a by b rounded up
ll fdiv(ll a, ll b) {
	return a / b - ((a ^ b) < 0 && a % b);
} // divide a by b rounded down

tcT > bool ckmin(T &a, const T &b) {
	return b < a ? a = b, 1 : 0;
} // set a = min(a,b)
tcT > bool ckmax(T &a, const T &b) {
	return a < b ? a = b, 1 : 0;
} // set a = max(a,b)

tcTU > T fstTrue(T lo, T hi, U f) {
	++hi;
	assert(lo <= hi); // assuming f is increasing
	while (lo < hi) { // find first index such that f is true
		T mid = lo + (hi - lo) / 2;
		f(mid) ? hi = mid : lo = mid + 1;
	}
	return lo;
}
tcTU > T lstTrue(T lo, T hi, U f) {
	--lo;
	assert(lo <= hi); // assuming f is decreasing
	while (lo < hi) { // find first index such that f is true
		T mid = lo + (hi - lo + 1) / 2;
		f(mid) ? lo = mid : hi = mid - 1;
	}
	return lo;
}
tcT > void remDup(vector<T> &v) { // sort and remove duplicates
	sort(all(v));
	v.erase(unique(all(v)), end(v));
}
tcTU > void erase(T &t, const U &u) { // don't erase
	auto it = t.find(u);
	assert(it != end(t));
	t.erase(it);
} // element that doesn't exist from (multi)set

#define tcTUU tcT, class... U

inline namespace Helpers {
//////////// is_iterable
// https://stackoverflow.com/questions/13830158/check-if-a-variable-type-is-iterable
// this gets used only when we can call begin() and end() on that type
tcT, class = void > struct is_iterable : false_type {};
tcT > struct is_iterable<
		  T, void_t<decltype(begin(declval<T>())), decltype(end(declval<T>()))>>
	: true_type {};
tcT > constexpr bool is_iterable_v = is_iterable<T>::value;

//////////// is_readable
tcT, class = void > struct is_readable : false_type {};
tcT > struct is_readable<T, typename std::enable_if_t<is_same_v<
								decltype(cin >> declval<T &>()), istream &>>>
	: true_type {};
tcT > constexpr bool is_readable_v = is_readable<T>::value;

//////////// is_printable
// // https://nafe.es/posts/2020-02-29-is-printable/
tcT, class = void > struct is_printable : false_type {};
tcT > struct is_printable<T, typename std::enable_if_t<is_same_v<
								 decltype(cout << declval<T>()), ostream &>>>
	: true_type {};
tcT > constexpr bool is_printable_v = is_printable<T>::value;
} // namespace Helpers

inline namespace Input {
tcT > constexpr bool needs_input_v = !is_readable_v<T> && is_iterable_v<T>;
tcTUU > void re(T &t, U &...u);
tcTU > void re(pair<T, U> &p); // pairs

// re: read
tcT > typename enable_if<is_readable_v<T>, void>::type re(T &x) {
	cin >> x;
} // default
tcT > void re(complex<T> &c) {
	T a, b;
	re(a, b);
	c = {a, b};
} // complex
tcT > typename enable_if<needs_input_v<T>, void>::type
	  re(T &i); // ex. vectors, arrays
tcTU > void re(pair<T, U> &p) { re(p.f, p.s); }
tcT > typename enable_if<needs_input_v<T>, void>::type re(T &i) {
	each(x, i) re(x);
}
tcTUU > void re(T &t, U &...u) {
	re(t);
	re(u...);
} // read multiple

// rv: resize and read vectors
void rv(size_t) {}
tcTUU > void rv(size_t N, V<T> &t, U &...u);
template <class... U> void rv(size_t, size_t N2, U &...u);
tcTUU > void rv(size_t N, V<T> &t, U &...u) {
	t.rsz(N);
	re(t);
	rv(N, u...);
}
template <class... U> void rv(size_t, size_t N2, U &...u) { rv(N2, u...); }

// dumb shortcuts to read in ints
void decrement() {} // subtract one from each
tcTUU > void decrement(T &t, U &...u) {
	--t;
	decrement(u...);
}
#define ints(...)                                                              \
	int __VA_ARGS__;                                                           \
	re(__VA_ARGS__);
#define int1(...)                                                              \
	ints(__VA_ARGS__);                                                         \
	decrement(__VA_ARGS__);
} // namespace Input

inline namespace ToString {
tcT > constexpr bool needs_output_v = !is_printable_v<T> && is_iterable_v<T>;

// ts: string representation to print
tcT > typename enable_if<is_printable_v<T>, str>::type ts(T v) {
	stringstream ss;
	ss << fixed << setprecision(15) << v;
	return ss.str();
} // default
tcT > str bit_vec(T t) { // bit vector to string
	str res = "{";
	F0R(i, sz(t)) res += ts(t[i]);
	res += "}";
	return res;
}
str ts(V<bool> v) { return bit_vec(v); }
template <size_t SZ> str ts(bitset<SZ> b) { return bit_vec(b); } // bit vector
tcTU > str ts(pair<T, U> p);									 // pairs
tcT >
	typename enable_if<needs_output_v<T>, str>::type ts(T v); // vectors, arrays
tcTU > str ts(pair<T, U> p) { return "(" + ts(p.f) + ", " + ts(p.s) + ")"; }
tcT > typename enable_if<is_iterable_v<T>, str>::type ts_sep(T v, str sep) {
	// convert container to string w/ separator sep
	bool fst = 1;
	str res = "";
	for (const auto &x : v) {
		if (!fst) res += sep;
		fst = 0;
		res += ts(x);
	}
	return res;
}
tcT > typename enable_if<needs_output_v<T>, str>::type ts(T v) {
	return "{" + ts_sep(v, ", ") + "}";
}

// for nested DS
template <int, class T>
typename enable_if<!needs_output_v<T>, vs>::type ts_lev(const T &v) {
	return {ts(v)};
}
template <int lev, class T>
typename enable_if<needs_output_v<T>, vs>::type ts_lev(const T &v) {
	if (lev == 0 || !sz(v)) return {ts(v)};
	vs res;
	for (const auto &t : v) {
		if (sz(res)) res.bk += ",";
		vs tmp = ts_lev<lev - 1>(t);
		res.ins(end(res), all(tmp));
	}
	F0R(i, sz(res)) {
		str bef = " ";
		if (i == 0) bef = "{";
		res[i] = bef + res[i];
	}
	res.bk += "}";
	return res;
}
} // namespace ToString

inline namespace Output {
template <class T> void pr_sep(ostream &os, str, const T &t) { os << ts(t); }
template <class T, class... U>
void pr_sep(ostream &os, str sep, const T &t, const U &...u) {
	pr_sep(os, sep, t);
	os << sep;
	pr_sep(os, sep, u...);
}
// print w/ no spaces
template <class... T> void pr(const T &...t) { pr_sep(cout, "", t...); }
// print w/ spaces, end with newline
void ps() { cout << "\n"; }
template <class... T> void ps(const T &...t) {
	pr_sep(cout, " ", t...);
	ps();
}
// debug to cerr
template <class... T> void dbg_out(const T &...t) {
	pr_sep(cerr, " | ", t...);
	cerr << endl;
}
void loc_info(int line, str names) {
	cerr << "Line(" << line << ") -> [" << names << "]: ";
}
template <int lev, class T> void dbgl_out(const T &t) {
	cerr << "\n\n" << ts_sep(ts_lev<lev>(t), "\n") << "\n" << endl;
}
#ifdef LOCAL
#define dbg(...) loc_info(__LINE__, #__VA_ARGS__), dbg_out(__VA_ARGS__)
#define dbgl(lev, x) loc_info(__LINE__, #x), dbgl_out<lev>(x)
#else // don't actually submit with this
#define dbg(...) 0
#define dbgl(lev, x) 0
#endif

const clock_t beg = clock();
#define dbg_time() dbg((db)(clock() - beg) / CLOCKS_PER_SEC)
} // namespace Output

inline namespace FileIO {
void setIn(str s) { freopen(s.c_str(), "r", stdin); }
void setOut(str s) { freopen(s.c_str(), "w", stdout); }
void setIO(str s = "") {
	cin.tie(0)->sync_with_stdio(0); // unsync C / C++ I/O streams
	// cin.exceptions(cin.failbit);
	// throws exception when do smth illegal
	// ex. try to read letter into int
	if (sz(s)) setIn(s + ".in"), setOut(s + ".out"); // for old USACO
}
} // namespace FileIO

void add_max(vi &dp, int sum, int num) {
	if (sum > 0) {
		dbg("ADD MAX", sum, num);
		R0F(i, sz(dp) - sum) {
			if (dp[i] != -1) ckmax(dp[i + sum], dp[i] + num);
		}
		dbg("DONE MAX", sum, num);
	} else {
		FOR(i, -sum, sz(dp)) {
			if (dp[i] != -1) ckmax(dp[i + sum], dp[i] + num);
		}
	}
}

int M;
void add_max_all(vi &v, int x, ll num) {
	for (int j = 1;; j *= 2) {
		ckmin(j, (int)num);
		if (j == 0) break;
		num -= j;
		add_max(v, j * x, j);
	}
}

int main() {
	// read read read
	setIO();
	re(M);
	ll L;
	re(L);
	vl A(2 * M + 1);
	re(A);
	vi dp(2 * 50 * 50 * 50 + 1, -1);
	dp.at(50 * 50 * 50) = 0;
	FOR(i, -M, M + 1) { add_max_all(dp, i, A.at(i + M)); }
	// FOR(i, -10, 10) dbg(i, dp.at(i + 50 * 50 * 50));
	L += 50 * 50 * 50;
	ll ans = -1;
	if (0 <= L && L < sz(dp)) ans = dp.at(L);
	if (ans == -1) ps("impossible");
	else ps(ans);
	// you should actually read the stuff at the bottom
}

/* stuff you should look for
 * int overflow, array bounds
 * special cases (n=1?)
 * do smth instead of nothing and stay organized
 * WRITE STUFF DOWN
 * DON'T GET STUCK ON ONE APPROACH
 */

Compilation message

vault.cpp: In function 'void add_max(vi&, int, int)':
vault.cpp:303:18: warning: statement has no effect [-Wunused-value]
  303 | #define dbg(...) 0
      |                  ^
vault.cpp:325:3: note: in expansion of macro 'dbg'
  325 |   dbg("ADD MAX", sum, num);
      |   ^~~
vault.cpp:303:18: warning: statement has no effect [-Wunused-value]
  303 | #define dbg(...) 0
      |                  ^
vault.cpp:329:3: note: in expansion of macro 'dbg'
  329 |   dbg("DONE MAX", sum, num);
      |   ^~~
vault.cpp: In function 'void FileIO::setIn(str)':
vault.cpp:312:28: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  312 | void setIn(str s) { freopen(s.c_str(), "r", stdin); }
      |                     ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~
vault.cpp: In function 'void FileIO::setOut(str)':
vault.cpp:313:29: warning: ignoring return value of 'FILE* freopen(const char*, const char*, FILE*)' declared with attribute 'warn_unused_result' [-Wunused-result]
  313 | void setOut(str s) { freopen(s.c_str(), "w", stdout); }
      |                      ~~~~~~~^~~~~~~~~~~~~~~~~~~~~~~~

Subtask #1
5.0 / 5.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 1236 KB Output is correct
2 Correct 3 ms 1224 KB Output is correct
3 Correct 2 ms 1216 KB Output is correct
4 Correct 9 ms 1236 KB Output is correct
5 Correct 107 ms 1236 KB Output is correct
6 Correct 109 ms 1236 KB Output is correct
7 Correct 50 ms 1236 KB Output is correct
8 Correct 123 ms 1236 KB Output is correct
9 Correct 142 ms 1236 KB Output is correct
10 Correct 5 ms 1236 KB Output is correct
11 Correct 6 ms 1220 KB Output is correct

Subtask #2
0 / 15.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 1236 KB Output is correct
2 Correct 3 ms 1224 KB Output is correct
3 Correct 2 ms 1216 KB Output is correct
4 Correct 9 ms 1236 KB Output is correct
5 Correct 107 ms 1236 KB Output is correct
6 Correct 109 ms 1236 KB Output is correct
7 Correct 50 ms 1236 KB Output is correct
8 Correct 123 ms 1236 KB Output is correct
9 Correct 142 ms 1236 KB Output is correct
10 Correct 5 ms 1236 KB Output is correct
11 Correct 6 ms 1220 KB Output is correct
12 Correct 3 ms 1228 KB Output is correct
13 Correct 3 ms 1236 KB Output is correct
14 Correct 2 ms 1236 KB Output is correct
15 Correct 11 ms 1236 KB Output is correct
16 Correct 116 ms 1220 KB Output is correct
17 Correct 113 ms 1236 KB Output is correct
18 Correct 49 ms 1236 KB Output is correct
19 Correct 110 ms 1208 KB Output is correct
20 Correct 144 ms 1236 KB Output is correct
21 Correct 5 ms 1236 KB Output is correct
22 Correct 6 ms 1236 KB Output is correct
23 Correct 279 ms 1236 KB Output is correct
24 Incorrect 279 ms 1220 KB Output isn't correct
25 Halted 0 ms 0 KB -

Subtask #3-1
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 9 ms 1236 KB Output is correct
2 Runtime error 9 ms 2476 KB Execution killed with signal 11
3 Halted 0 ms 0 KB -

Subtask #3-2
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 9 ms 1236 KB Output is correct
2 Runtime error 9 ms 2476 KB Execution killed with signal 11
3 Halted 0 ms 0 KB -

Subtask #4-1
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 9 ms 1236 KB Output is correct
2 Runtime error 9 ms 2476 KB Execution killed with signal 11
3 Halted 0 ms 0 KB -

Subtask #4-2
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 1236 KB Output is correct
2 Correct 3 ms 1224 KB Output is correct
3 Correct 2 ms 1216 KB Output is correct
4 Correct 9 ms 1236 KB Output is correct
5 Correct 107 ms 1236 KB Output is correct
6 Correct 109 ms 1236 KB Output is correct
7 Correct 50 ms 1236 KB Output is correct
8 Correct 123 ms 1236 KB Output is correct
9 Correct 142 ms 1236 KB Output is correct
10 Correct 5 ms 1236 KB Output is correct
11 Correct 6 ms 1220 KB Output is correct
12 Correct 9 ms 1236 KB Output is correct
13 Runtime error 9 ms 2476 KB Execution killed with signal 11
14 Halted 0 ms 0 KB -

Subtask #5-1
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 9 ms 1236 KB Output is correct
2 Runtime error 9 ms 2476 KB Execution killed with signal 11
3 Halted 0 ms 0 KB -

Subtask #5-2
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 1236 KB Output is correct
2 Correct 3 ms 1224 KB Output is correct
3 Correct 2 ms 1216 KB Output is correct
4 Correct 9 ms 1236 KB Output is correct
5 Correct 107 ms 1236 KB Output is correct
6 Correct 109 ms 1236 KB Output is correct
7 Correct 50 ms 1236 KB Output is correct
8 Correct 123 ms 1236 KB Output is correct
9 Correct 142 ms 1236 KB Output is correct
10 Correct 5 ms 1236 KB Output is correct
11 Correct 6 ms 1220 KB Output is correct
12 Correct 3 ms 1228 KB Output is correct
13 Correct 3 ms 1236 KB Output is correct
14 Correct 2 ms 1236 KB Output is correct
15 Correct 11 ms 1236 KB Output is correct
16 Correct 116 ms 1220 KB Output is correct
17 Correct 113 ms 1236 KB Output is correct
18 Correct 49 ms 1236 KB Output is correct
19 Correct 110 ms 1208 KB Output is correct
20 Correct 144 ms 1236 KB Output is correct
21 Correct 5 ms 1236 KB Output is correct
22 Correct 6 ms 1236 KB Output is correct
23 Correct 279 ms 1236 KB Output is correct
24 Incorrect 279 ms 1220 KB Output isn't correct
25 Halted 0 ms 0 KB -

Subtask #6-1
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 9 ms 1236 KB Output is correct
2 Runtime error 9 ms 2476 KB Execution killed with signal 11
3 Halted 0 ms 0 KB -

Subtask #6-2
0 / 10.0

# Verdict Execution time Memory Grader output
1 Correct 3 ms 1236 KB Output is correct
2 Correct 3 ms 1224 KB Output is correct
3 Correct 2 ms 1216 KB Output is correct
4 Correct 9 ms 1236 KB Output is correct
5 Correct 107 ms 1236 KB Output is correct
6 Correct 109 ms 1236 KB Output is correct
7 Correct 50 ms 1236 KB Output is correct
8 Correct 123 ms 1236 KB Output is correct
9 Correct 142 ms 1236 KB Output is correct
10 Correct 5 ms 1236 KB Output is correct
11 Correct 6 ms 1220 KB Output is correct
12 Correct 3 ms 1228 KB Output is correct
13 Correct 3 ms 1236 KB Output is correct
14 Correct 2 ms 1236 KB Output is correct
15 Correct 11 ms 1236 KB Output is correct
16 Correct 116 ms 1220 KB Output is correct
17 Correct 113 ms 1236 KB Output is correct
18 Correct 49 ms 1236 KB Output is correct
19 Correct 110 ms 1208 KB Output is correct
20 Correct 144 ms 1236 KB Output is correct
21 Correct 5 ms 1236 KB Output is correct
22 Correct 6 ms 1236 KB Output is correct
23 Correct 279 ms 1236 KB Output is correct
24 Incorrect 279 ms 1220 KB Output isn't correct
25 Halted 0 ms 0 KB -