結果

問題 No.2423 Merge Stones
ユーザー shobonvipshobonvip
提出日時 2023-08-12 14:17:15
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
TLE  
実行時間 -
コード長 6,062 bytes
コンパイル時間 4,433 ms
コンパイル使用メモリ 269,156 KB
実行使用メモリ 154,784 KB
最終ジャッジ日時 2024-04-30 05:33:46
合計ジャッジ時間 10,210 ms
ジャッジサーバーID
（参考情報） 		judge2 / judge4
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
6,812 KB
testcase_01 AC 4 ms
6,940 KB
testcase_02 AC 3 ms
6,944 KB
testcase_03 AC 3 ms
6,940 KB
testcase_04 AC 2 ms
6,944 KB
testcase_05 AC 3 ms
6,944 KB
testcase_06 AC 4 ms
6,940 KB
testcase_07 AC 2 ms
6,944 KB
testcase_08 AC 3 ms
6,940 KB
testcase_09 AC 2 ms
6,940 KB
testcase_10 AC 3 ms
6,940 KB
testcase_11 TLE -
testcase_12 -- -
testcase_13 -- -
testcase_14 -- -
testcase_15 -- -
testcase_16 -- -
testcase_17 -- -
testcase_18 -- -
testcase_19 -- -
testcase_20 -- -
testcase_21 -- -
testcase_22 -- -
testcase_23 -- -
testcase_24 -- -
testcase_25 -- -
testcase_26 -- -
testcase_27 -- -
testcase_28 -- -
testcase_29 -- -
testcase_30 -- -
testcase_31 -- -
testcase_32 -- -
testcase_33 -- -
testcase_34 -- -
testcase_35 -- -
testcase_36 -- -
testcase_37 -- -
testcase_38 -- -
testcase_39 -- -
testcase_40 -- -
testcase_41 -- -
testcase_42 -- -
testcase_43 -- -
testcase_44 -- -
testcase_45 -- -
testcase_46 -- -
testcase_47 -- -
testcase_48 -- -
testcase_49 -- -
testcase_50 -- -
testcase_51 -- -
testcase_52 -- -
testcase_53 -- -
testcase_54 -- -
testcase_55 -- -
testcase_56 -- -
testcase_57 -- -
testcase_58 -- -
testcase_59 -- -
testcase_60 -- -
testcase_61 -- -
testcase_62 -- -
testcase_63 -- -
testcase_64 -- -
testcase_65 -- -
testcase_66 -- -
testcase_67 -- -
testcase_68 -- -
testcase_69 -- -
testcase_70 -- -
testcase_71 -- -
testcase_72 -- -
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include<bits/stdc++.h>
using namespace std;

//* ATCODER
#include<atcoder/all>
using namespace atcoder;
typedef modint998244353 mint;
//*/

/* BOOST MULTIPRECISION
#include<boost/multiprecision/cpp_int.hpp>
using namespace boost::multiprecision;
//*/

typedef long long ll;

#define rep(i, s, n) for (int i = (int)(s); i < (int)(n); i++)
#define rrep(i, s, n) for (int i = (int)(n)-1; i >= (int)(s); i--)

template <typename T> bool chmin(T &a, const T &b) {
	if (a <= b) return false;
	a = b;
	return true;
}

template <typename T> bool chmax(T &a, const T &b) {
	if (a >= b) return false;
	a = b;
	return true;
}

template <typename T> T max(vector<T> &a){
	assert(!a.empty());
	T ret = a[0];
	for (int i=0; i<(int)a.size(); i++) chmax(ret, a[i]);
	return ret;
}

template <typename T> T min(vector<T> &a){
	assert(!a.empty());
	T ret = a[0];
	for (int i=0; i<(int)a.size(); i++) chmin(ret, a[i]);
	return ret;
}

template <typename T> T sum(vector<T> &a){
	T ret = 0;
	for (int i=0; i<(int)a.size(); i++) ret += a[i];
	return ret;
}

// https://lorent-kyopro.hatenablog.com/entry/2021/03/12/025644
template <class S, S (*op)(S, S), S (*e)()> class dynamic_segtree {
public:
	dynamic_segtree(size_t n) : n(n), root(nullptr) {}

	void set(size_t p, S x) {
		assert(p < n);
		set(root, 0, n, p, x);
	}

	S get(size_t p) const {
		assert(p < n);
		return get(root, 0, n, p);
	}

	S prod(size_t l, size_t r) const {
		assert(l <= r && r <= n);
		return prod(root, 0, n, l, r);
	}

	S all_prod() const { return root ? root->product : e(); }

	void reset(size_t l, size_t r) {
		assert(l <= r && r <= n);
		return reset(root, 0, n, l, r);
	}

	template <bool (*f)(S)> size_t max_right(size_t l) const {
		return max_right(l, [](S x) { return f(x); });
	}

	template <class F> size_t max_right(size_t l, const F& f) const {
		assert(l <= n);
		S product = e();
		assert(f(product));
		return max_right(root, 0, n, l, f, product);
	}

	template <bool (*f)(S)> size_t min_left(size_t r) const {
		return min_left(r, [](S x) { return f(x); });
	}

	template <class F> size_t min_left(size_t r, const F& f) const {
		assert(r <= n);
		S product = e();
		assert(f(product));
		return min_left(root, 0, n, r, f, product);
	}

private:
	struct node;
	using node_ptr = std::unique_ptr<node>;

	struct node {
		size_t index;
		S value, product;
		node_ptr left, right;

		node(size_t index, S value)
			: index(index),
			  value(value),
			  product(value),
			  left(nullptr),
			  right(nullptr) {}

		void update() {
			product = op(op(left ? left->product : e(), value),
						 right ? right->product : e());
		}
	};

	const size_t n;
	node_ptr root;

	void set(node_ptr& t, size_t a, size_t b, size_t p, S x) const {
		if (!t) {
			t = std::make_unique<node>(p, x);
			return;
		}
		if (t->index == p) {
			t->value = x;
			t->update();
			return;
		}
		size_t c = (a + b) >> 1;
		if (p < c) {
			if (t->index < p) std::swap(t->index, p), std::swap(t->value, x);
			set(t->left, a, c, p, x);
		} else {
			if (p < t->index) std::swap(p, t->index), std::swap(x, t->value);
			set(t->right, c, b, p, x);
		}
		t->update();
	}

	S get(const node_ptr& t, size_t a, size_t b, size_t p) const {
		if (!t) return e();
		if (t->index == p) return t->value;
		size_t c = (a + b) >> 1;
		if (p < c) return get(t->left, a, c, p);
		else return get(t->right, c, b, p);
	}

	S prod(const node_ptr& t, size_t a, size_t b, size_t l, size_t r) const {
		if (!t || b <= l || r <= a) return e();
		if (l <= a && b <= r) return t->product;
		size_t c = (a + b) >> 1;
		S result = prod(t->left, a, c, l, r);
		if (l <= t->index && t->index < r) result = op(result, t->value);
		return op(result, prod(t->right, c, b, l, r));
	}

	void reset(node_ptr& t, size_t a, size_t b, size_t l, size_t r) const {
		if (!t || b <= l || r <= a) return;
		if (l <= a && b <= r) {
			t.reset();
			return;
		}
		size_t c = (a + b) >> 1;
		reset(t->left, a, c, l, r);
		reset(t->right, c, b, l, r);
		t->update();
	}

	template <class F>
	size_t max_right(const node_ptr& t, size_t a, size_t b,
					 size_t l, const F& f, S& product) const {
		if (!t || b <= l) return n;
		if (f(op(product, t->product))) {
			product = op(product, t->product);
			return n;
		}
		size_t c = (a + b) >> 1;
		size_t result = max_right(t->left, a, c, l, f, product);
		if (result != n) return result;
		if (l <= t->index) {
			product = op(product, t->value);
			if (!f(product)) return t->index;
		}
		return max_right(t->right, c, b, l, f, product);
	}

	template <class F>
	size_t min_left(const node_ptr& t, size_t a, size_t b,
					size_t r, const F& f, S& product) const {
		if (!t || r <= a) return 0;
		if (f(op(t->product, product))) {
			product = op(t->product, product);
			return 0;
		}
		size_t c = (a + b) >> 1;
		size_t result = min_left(t->right, c, b, r, f, product);
		if (result != 0) return result;
		if (t->index < r) {
			product = op(t->value, product);
			if (!f(product)) return t->index + 1;
		}
		return min_left(t->left, a, c, r, f, product);
	}
};

int op(int a, int b){
	return a + b;
}
int e(){
	return 0;
}

int main(){
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);

	int n, f; cin >> n >> f;
	vector<ll> a(2*n);
	vector<int> c(2*n);
	rep(i,0,n){
		cin >> a[i];
		a[i+n] = a[i];
	}
	rep(i,0,n){
		cin >> c[i];
		c[i]--;
		c[i+n] = c[i];
	}

	vector dp(50, vector(2*n, vector<ll>(2*n+1, -1e18)));
	rep(i,0,2*n){
		dp[c[i]][i][i+1] = a[i];
	}

	rep(len,2,n+1){
		rep(i,0,2*n+1-len){
			// [i, i+len)
			rep(j,i+1,i+len){
				rep(k,0,50){
					if (dp[k][i][j] < 0) continue;
					rep(l,k-f,k+f+1){
						if (!(0 <= l && l < 50)){
							continue;
						}
						chmax(dp[k][i][i+len], dp[k][i][j] + dp[l][j][i+len]);
					}
				}
				rep(k,0,50){
					if (dp[k][j][i+len] < 0) continue;
					rep(l,k-f,k+f+1){
						if (!(0 <= l && l < 50)){
							continue;
						}
						chmax(dp[k][i][i+len], dp[k][j][i+len] + dp[l][i][j]);
					}
				}
			}
		}
	}

	ll ans = -1e18;
	rep(i,0,50){
		rep(j,0,2*n){
			rep(k,0,2*n+1){
				chmax(ans, dp[i][j][k]);
			}
		}
	}

	cout << ans << '\n';

}
0