problem_id stringlengths 6 6 | language stringclasses 2 values | original_status stringclasses 3 values | original_src stringlengths 19 243k | changed_src stringlengths 19 243k | change stringclasses 3 values | i1 int64 0 8.44k | i2 int64 0 8.44k | j1 int64 0 8.44k | j2 int64 0 8.44k | error stringclasses 270 values | stderr stringlengths 0 226k |
|---|---|---|---|---|---|---|---|---|---|---|---|
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
#define repd(i, a, b) for (int i = a; i < int(b); i++)
#define rep(i, n) repd(i, 0, n)
#define VARNAME(v) #v
using P = pair<int, int>;
int main() {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int BEAM = 900;
int d;
vector<int> c(26);
cin >> d;
rep(i, 26) cin >> c[i];
vector<array<int, 26>> s(d);
rep(i, d) rep(j, 26) cin >> s[i][j];
vector<int> curs = {0};
vector<array<int, 26>> curl(1);
vector<vector<int>> cura(1);
rep(i, d) {
int len = int(curs.size()) * 26, ind = 0;
vector<P> nxs(len);
vector<array<int, 26>> nxl(len);
vector<vector<int>> nxa(len);
rep(j, curs.size()) {
rep(t, 26) {
int score = curs[j];
array<int, 26> last = curl[j];
vector<int> ans = cura[j];
score += s[i][t];
last[t] = i + 1;
rep(k, 26) score -= c[k] * (i + 1 - last[k]);
ans.emplace_back(t);
nxs[ind] = P(score, ind);
nxl[ind] = last;
nxa[ind] = ans;
ind++;
}
}
sort(nxs.rbegin(), nxs.rend());
len = min(len, BEAM);
curs.resize(len);
curl.resize(len);
cura.resize(len);
rep(j, len) {
curs[j] = nxs[j].first;
curl[j] = nxl[nxs[j].second];
cura[j] = nxa[nxs[j].second];
}
if (i % 73 == 0)
BEAM -= 200;
}
int ans = 0;
rep(i, min(int(curs.size()), BEAM)) {
if (curs[ans] < curs[i])
ans = i;
}
for (auto x : cura[ans]) {
cout << x + 1 << endl;
}
}
| #include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
using ll = long long;
using ld = long double;
#define repd(i, a, b) for (int i = a; i < int(b); i++)
#define rep(i, n) repd(i, 0, n)
#define VARNAME(v) #v
using P = pair<int, int>;
int main() {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int BEAM = 900;
int d;
vector<int> c(26);
cin >> d;
rep(i, 26) cin >> c[i];
vector<array<int, 26>> s(d);
rep(i, d) rep(j, 26) cin >> s[i][j];
vector<int> curs = {0};
vector<array<int, 26>> curl(1);
vector<vector<int>> cura(1);
rep(i, d) {
int len = int(curs.size()) * 26, ind = 0;
vector<P> nxs(len);
vector<array<int, 26>> nxl(len);
vector<vector<int>> nxa(len);
rep(j, curs.size()) {
rep(t, 26) {
int score = curs[j];
array<int, 26> last = curl[j];
vector<int> ans = cura[j];
score += s[i][t];
last[t] = i + 1;
rep(k, 26) score -= c[k] * (i + 1 - last[k]);
ans.emplace_back(t);
nxs[ind] = P(score, ind);
nxl[ind] = last;
nxa[ind] = ans;
ind++;
}
}
sort(nxs.rbegin(), nxs.rend());
len = min(len, BEAM);
curs.resize(len);
curl.resize(len);
cura.resize(len);
rep(j, len) {
curs[j] = nxs[j].first;
curl[j] = nxl[nxs[j].second];
cura[j] = nxa[nxs[j].second];
}
if (i % 73 == 0)
BEAM -= 150;
}
int ans = 0;
rep(i, min(int(curs.size()), BEAM)) {
if (curs[ans] < curs[i])
ans = i;
}
for (auto x : cura[ans]) {
cout << x + 1 << endl;
}
}
| replace | 56 | 57 | 56 | 57 | 0 | |
p02618 | C++ | Runtime Error | #pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx2")
#define io_init \
cin.tie(0); \
ios::sync_with_stdio(0); \
cout << setprecision(10)
#include <bits/stdc++.h>
constexpr int INF = 2147483647;
constexpr long long int INF_LL = 9223372036854775807;
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
int calcScore(vector<int> &plan, vector<int> &c, vector<vector<int>> &s) {
int D = 365;
int score = 0;
vector<int> last(26, -1);
for (int i = 0; i < D; i++) {
score += s[i][plan[i]];
last[plan[i]] = i;
for (int j = 0; j < 26; j++) {
score -= c[j] * (i - last[j]);
}
}
return score;
}
int main() {
int D;
cin >> D;
vector<int> c(26);
for (int i = 0; i < 26; i++)
cin >> c[i];
vector<vector<int>> s(365, vector<int>(26, 0));
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++)
cin >> s[i][j];
}
vector<int> plan(365, 0);
for (int i = 0; i < 365; i++) {
plan[i] = i % 26 + 1;
}
int sc = calcScore(plan, c, s);
for (int n = 0; n < 300000; n++) {
if (rand() % 10 < 3) {
int i = rand() % 365, j = rand() % 26, old = plan[i];
plan[i] = j;
int nsc = calcScore(plan, c, s);
if (nsc > sc) {
sc = nsc;
} else {
plan[i] = old;
}
} else {
int k = rand() % 5;
int i = rand() % (365 - k), j = i + k;
swap(plan[i], plan[j]);
int nsc = calcScore(plan, c, s);
if (nsc > sc) {
sc = nsc;
} else {
swap(plan[i], plan[j]);
}
}
}
for (int i = 0; i < 365; i++) {
cout << plan[i] + 1 << endl;
}
}
| #pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx2")
#define io_init \
cin.tie(0); \
ios::sync_with_stdio(0); \
cout << setprecision(10)
#include <bits/stdc++.h>
constexpr int INF = 2147483647;
constexpr long long int INF_LL = 9223372036854775807;
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
int calcScore(vector<int> &plan, vector<int> &c, vector<vector<int>> &s) {
int D = 365;
int score = 0;
vector<int> last(26, -1);
for (int i = 0; i < D; i++) {
score += s[i][plan[i]];
last[plan[i]] = i;
for (int j = 0; j < 26; j++) {
score -= c[j] * (i - last[j]);
}
}
return score;
}
int main() {
int D;
cin >> D;
vector<int> c(26);
for (int i = 0; i < 26; i++)
cin >> c[i];
vector<vector<int>> s(365, vector<int>(26, 0));
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++)
cin >> s[i][j];
}
vector<int> plan(365, 0);
for (int i = 0; i < 365; i++) {
plan[i] = i % 26;
}
int sc = calcScore(plan, c, s);
for (int n = 0; n < 300000; n++) {
if (rand() % 10 < 3) {
int i = rand() % 365, j = rand() % 26, old = plan[i];
plan[i] = j;
int nsc = calcScore(plan, c, s);
if (nsc > sc) {
sc = nsc;
} else {
plan[i] = old;
}
} else {
int k = rand() % 5;
int i = rand() % (365 - k), j = i + k;
swap(plan[i], plan[j]);
int nsc = calcScore(plan, c, s);
if (nsc > sc) {
sc = nsc;
} else {
swap(plan[i], plan[j]);
}
}
}
for (int i = 0; i < 365; i++) {
cout << plan[i] + 1 << endl;
}
}
| replace | 44 | 45 | 44 | 45 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
#define FOR(i, s, n) for (int i = (s); i < (n); i++)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) for (int i = (n); i >= 0; i--)
#define ALL(n) (n).begin(), (n).end()
#define RALL(n) (n).rbegin(), (n).rend()
#define ATYN(n) cout << ((n) ? "Yes" : "No") << '\n';
#define CFYN(n) cout << ((n) ? "YES" : "NO") << '\n';
#define OUT(n) cout << (n) << '\n';
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
int main(void) {
IOS const int A = 26;
const int M1 = 2e2;
const int M2 = 2e3;
int D;
cin >> D;
vector<int> c(A);
REP(i, A) cin >> c[i];
vector<vector<int>> s(D, vector<int>(A));
REP(i, D) REP(j, A) cin >> s[i][j];
vector<int> last(A, -1);
vector<int> ans(D);
REP(i, D) {
int mx = 0, a = -1;
REP(j, A) {
int tmp = (i - last[j]) * c[j] + s[i][j];
if (mx < tmp) {
mx = tmp;
a = j;
}
}
ans[i] = a;
last[a] = i;
}
auto calc = [&](const vector<int> &a) {
vector<int> l(A, -1);
int score = 0;
REP(i, D) {
score += s[i][a[i]];
l[a[i]] = i;
REP(j, A) { score -= c[j] * (i - l[j]); }
}
return score;
};
int maxscore = calc(ans);
random_device seed_gen;
mt19937 engine(seed_gen());
REP(_, M1) {
int mx = maxscore;
vector<int> a1(ans);
REP(__, M2) {
vector<int> a2(a1);
a2[engine() % D] = engine() % A;
int tmp = calc(a2);
if (mx < tmp) {
swap(a1, a2);
mx = tmp;
}
}
if (maxscore < mx) {
swap(ans, a1);
maxscore = mx;
}
}
REP(i, D)
OUT(ans[i] + 1)
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define IOS \
ios::sync_with_stdio(false); \
cin.tie(0);
#define FOR(i, s, n) for (int i = (s); i < (n); i++)
#define REP(i, n) FOR(i, 0, n)
#define RREP(i, n) for (int i = (n); i >= 0; i--)
#define ALL(n) (n).begin(), (n).end()
#define RALL(n) (n).rbegin(), (n).rend()
#define ATYN(n) cout << ((n) ? "Yes" : "No") << '\n';
#define CFYN(n) cout << ((n) ? "YES" : "NO") << '\n';
#define OUT(n) cout << (n) << '\n';
using ll = long long;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
int main(void) {
IOS const int A = 26;
const int M1 = 2e1;
const int M2 = 1e4;
int D;
cin >> D;
vector<int> c(A);
REP(i, A) cin >> c[i];
vector<vector<int>> s(D, vector<int>(A));
REP(i, D) REP(j, A) cin >> s[i][j];
vector<int> last(A, -1);
vector<int> ans(D);
REP(i, D) {
int mx = 0, a = -1;
REP(j, A) {
int tmp = (i - last[j]) * c[j] + s[i][j];
if (mx < tmp) {
mx = tmp;
a = j;
}
}
ans[i] = a;
last[a] = i;
}
auto calc = [&](const vector<int> &a) {
vector<int> l(A, -1);
int score = 0;
REP(i, D) {
score += s[i][a[i]];
l[a[i]] = i;
REP(j, A) { score -= c[j] * (i - l[j]); }
}
return score;
};
int maxscore = calc(ans);
random_device seed_gen;
mt19937 engine(seed_gen());
REP(_, M1) {
int mx = maxscore;
vector<int> a1(ans);
REP(__, M2) {
vector<int> a2(a1);
a2[engine() % D] = engine() % A;
int tmp = calc(a2);
if (mx < tmp) {
swap(a1, a2);
mx = tmp;
}
}
if (maxscore < mx) {
swap(ans, a1);
maxscore = mx;
}
}
REP(i, D)
OUT(ans[i] + 1)
return 0;
} | replace | 20 | 22 | 20 | 22 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
// using namespace std;
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define rep(i, j, n) for (ll i = (ll)(j); i < (ll)(n); i++)
#define REP(i, j, n) for (ll i = (ll)(j); i <= (ll)(n); i++)
#define per(i, j, n) for (ll i = (ll)(j); (ll)(n) <= i; i--)
#define ll long long
#define ALL(a) (a).begin(), (a).end()
#define disup(A, key) distance(A.begin(), upper_bound(ALL(A), (ll)(key)))
#define dislow(A, key) distance(A.begin(), lower_bound(ALL(A), (ll)(key)))
#define pb emplace_back
#define mp std::make_pair
//
#define endl "\n"
// using std::endl;
using std::cin;
using std::cout;
using std::lower_bound;
using std::string;
using std::upper_bound;
using std::vector;
using vi = vector<ll>;
using vii = vector<vi>;
using pii = std::pair<ll, ll>;
//
constexpr ll MOD = 1e9 + 7;
// constexpr ll MOD=998244353;
// constexpr ll MOD=10000000;
// constexpr ll MOD=1e5;
constexpr ll MAX = 1e7;
constexpr ll INF = (1ll << 62);
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
const ll N = 26;
ll solve(ll D, vii &A, vi &C, vi &S) {
vi last(N, -1);
ll a = 0;
rep(i, 0, D) {
ll memo;
memo = S[i];
last[memo] = i;
a += A[i][memo];
rep(j, 0, N) a -= (i - last[j]) * C[j];
}
return a;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
srand((unsigned)time(NULL));
ll D;
cin >> D;
vi C(N);
rep(i, 0, N) cin >> C[i];
vii A(D, vi(N));
rep(i, 0, D) { rep(j, 0, N) cin >> A[i][j]; }
vi last(N, -1);
vi ans(D);
rep(i, 0, D) {
ll max = 0, memo = 0;
rep(j, 0, N) {
if (max < A[i][j] + (i - last[j]) * C[j]) {
max = A[i][j] + (i - last[j]) * C[j];
memo = j;
}
}
last[memo] = i;
ans[D] = memo;
}
ll max = solve(D, A, C, ans);
rep(i, 0, D) {
rep(j, 0, N) {
vi S = ans;
S[i] = j;
ll X = solve(D, A, C, S);
if (max < X) {
max = X;
ans = S;
}
}
}
rep(i, 0, D) cout << ans[i] + 1 << endl;
}
| #include <bits/stdc++.h>
// using namespace std;
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define rep(i, j, n) for (ll i = (ll)(j); i < (ll)(n); i++)
#define REP(i, j, n) for (ll i = (ll)(j); i <= (ll)(n); i++)
#define per(i, j, n) for (ll i = (ll)(j); (ll)(n) <= i; i--)
#define ll long long
#define ALL(a) (a).begin(), (a).end()
#define disup(A, key) distance(A.begin(), upper_bound(ALL(A), (ll)(key)))
#define dislow(A, key) distance(A.begin(), lower_bound(ALL(A), (ll)(key)))
#define pb emplace_back
#define mp std::make_pair
//
#define endl "\n"
// using std::endl;
using std::cin;
using std::cout;
using std::lower_bound;
using std::string;
using std::upper_bound;
using std::vector;
using vi = vector<ll>;
using vii = vector<vi>;
using pii = std::pair<ll, ll>;
//
constexpr ll MOD = 1e9 + 7;
// constexpr ll MOD=998244353;
// constexpr ll MOD=10000000;
// constexpr ll MOD=1e5;
constexpr ll MAX = 1e7;
constexpr ll INF = (1ll << 62);
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
const ll N = 26;
ll solve(ll D, vii &A, vi &C, vi &S) {
vi last(N, -1);
ll a = 0;
rep(i, 0, D) {
ll memo;
memo = S[i];
last[memo] = i;
a += A[i][memo];
rep(j, 0, N) a -= (i - last[j]) * C[j];
}
return a;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
srand((unsigned)time(NULL));
ll D;
cin >> D;
vi C(N);
rep(i, 0, N) cin >> C[i];
vii A(D, vi(N));
rep(i, 0, D) { rep(j, 0, N) cin >> A[i][j]; }
vi last(N, -1);
vi ans(D);
rep(i, 0, D) {
ll max = 0, memo = 0;
rep(j, 0, N) {
if (max < A[i][j] + (i - last[j]) * C[j]) {
max = A[i][j] + (i - last[j]) * C[j];
memo = j;
}
}
last[memo] = i;
ans[i] = memo;
}
ll max = solve(D, A, C, ans);
rep(i, 0, D) {
rep(j, 0, N) {
vi S = ans;
S[i] = j;
ll X = solve(D, A, C, S);
if (max < X) {
max = X;
ans = S;
}
}
}
rep(i, 0, D) cout << ans[i] + 1 << endl;
}
| replace | 71 | 72 | 71 | 72 | -6 | Fatal glibc error: malloc assertion failure in sysmalloc: (old_top == initial_top (av) && old_size == 0) || ((unsigned long) (old_size) >= MINSIZE && prev_inuse (old_top) && ((unsigned long) old_end & (pagesize - 1)) == 0)
|
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
using pll = pair<long long, long long>;
constexpr int INF = 1e9;
constexpr long long LINF = 1e17;
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
const int d = 365;
const double MX_SEC = 3.0;
// const int d = 5;
int c[26];
int s[d][26];
int last[26] = {0};
bool llast[d][26] = {false};
vector<int> solution(d, -1);
int myscore = 0;
random_device seed_gen;
mt19937 mt(seed_gen());
uniform_int_distribution<int> con(0, 26 - 1);
uniform_int_distribution<int> day(0, 365 - 1);
uniform_int_distribution<int> num(0, 20);
uniform_real_distribution<double> pro(0.0, 1.0);
int score(vector<int> t) {
vector<int> last(26, 0);
int ans = 0;
rep(i, d) {
ans += s[i][t[i]];
last[t[i]] = i + 1;
rep(j, 26) ans -= c[j] * (i + 1 - last[j]);
// cout << ans << endl;
}
return ans;
}
// p day contest changes q
void better(int p, int q, clock_t start, clock_t end) {
// cout << myscore << endl;
int origin = solution[p];
int newscore = myscore - s[p][origin] + s[p][q];
int before_origin = 0, before_q = 0;
int res = 0;
for (int i = 0; i < d; i++) {
if (llast[i][origin])
before_origin = i + 1;
if (llast[i][q])
before_q = i + 1;
res += (c[origin] * (i + 1 - before_origin) + c[q] * (i + 1 - before_q));
}
llast[p][q] = true;
llast[p][origin] = false;
before_origin = 0;
before_q = 0;
for (int i = 0; i < d; i++) {
if (llast[i][origin])
before_origin = i + 1;
if (llast[i][q])
before_q = i + 1;
res -= (c[origin] * (i + 1 - before_origin) + c[q] * (i + 1 - before_q));
}
// cout << res << endl;
double t = 1 - ((double)(end - start) / CLOCKS_PER_SEC) / MX_SEC;
// cout << t << endl;
newscore += res;
if (newscore - myscore > 0 ||
(exp((double)(newscore - myscore) / t) > pro(mt))) {
myscore = newscore;
solution[p] = q;
} else {
llast[p][q] = false;
llast[p][origin] = true;
}
}
// p day contest swap q day contest
void betterswap(int p, int q, clock_t start, clock_t end) {
int p_origin = solution[p];
int q_origin = solution[q];
int newscore = myscore;
newscore -= s[p][p_origin] + s[q][q_origin];
newscore += s[p][q_origin] + s[q][p_origin];
int before_p_origin = 0, before_q_origin = 0;
int res = 0;
for (int i = 0; i < d; i++) {
if (llast[i][p_origin])
before_p_origin = i + 1;
if (llast[i][q_origin])
before_q_origin = i + 1;
res += (c[p_origin] * (i + 1 - before_p_origin) +
c[q_origin] * (i + 1 - before_q_origin));
}
llast[p][q_origin] = true, llast[p][p_origin] = false;
llast[q][p_origin] = true, llast[q][q_origin] = false;
before_p_origin = 0;
before_q_origin = 0;
for (int i = 0; i < d; i++) {
if (llast[i][p_origin])
before_p_origin = i + 1;
if (llast[i][q_origin])
before_q_origin = i + 1;
res -= (c[p_origin] * (i + 1 - before_p_origin) +
c[q_origin] * (i + 1 - before_q_origin));
}
double t = 1 - ((double)(end - start) / CLOCKS_PER_SEC) / MX_SEC;
newscore += res;
if (newscore - myscore > 0 ||
(exp((double)(newscore - myscore) / t) > pro(mt))) {
myscore = newscore;
solution[p] = q_origin;
solution[q] = p_origin;
} else {
llast[p][q_origin] = false, llast[p][p_origin] = true;
llast[q][p_origin] = false, llast[q][q_origin] = true;
}
}
// day 1-index i_day 's contest is k
int nowscore(int i, int k) {
int res = s[i][k];
int before = last[k];
last[k] = i + 1;
rep(j, 26) res -= c[j] * (i + 1 - last[j]);
last[k] = before;
return res;
}
int main() {
clock_t start = clock();
int tmp;
cin >> tmp;
rep(i, 26) cin >> c[i];
rep(i, d) rep(j, 26) cin >> s[i][j];
for (int i = 0; i < d; i++) {
int id = -1;
int mx = -INF;
for (int j = 0; j < 26; j++) {
int res = nowscore(i, j);
if (mx < res) {
id = j;
mx = res;
}
}
solution[i] = id;
last[id] = i + 1;
llast[i][id] = true;
myscore += mx;
}
clock_t end = clock();
while (((double)(end - start) / CLOCKS_PER_SEC) < MX_SEC) {
int k = day(mt);
betterswap(k, min(k + num(mt), 365 - 1), start, end);
better(day(mt), con(mt), start, end);
end = clock();
}
rep(i, d) cout << solution[i] + 1 << endl;
/*
cout << myscore << endl;
cout << (score(solution) + 1e6) << endl;
cout << (myscore + 1e6) << endl;
*/
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using ll = long long;
using P = pair<int, int>;
using pll = pair<long long, long long>;
constexpr int INF = 1e9;
constexpr long long LINF = 1e17;
constexpr int MOD = 1000000007;
constexpr double PI = 3.14159265358979323846;
const int d = 365;
const double MX_SEC = 1.87;
// const int d = 5;
int c[26];
int s[d][26];
int last[26] = {0};
bool llast[d][26] = {false};
vector<int> solution(d, -1);
int myscore = 0;
random_device seed_gen;
mt19937 mt(seed_gen());
uniform_int_distribution<int> con(0, 26 - 1);
uniform_int_distribution<int> day(0, 365 - 1);
uniform_int_distribution<int> num(0, 20);
uniform_real_distribution<double> pro(0.0, 1.0);
int score(vector<int> t) {
vector<int> last(26, 0);
int ans = 0;
rep(i, d) {
ans += s[i][t[i]];
last[t[i]] = i + 1;
rep(j, 26) ans -= c[j] * (i + 1 - last[j]);
// cout << ans << endl;
}
return ans;
}
// p day contest changes q
void better(int p, int q, clock_t start, clock_t end) {
// cout << myscore << endl;
int origin = solution[p];
int newscore = myscore - s[p][origin] + s[p][q];
int before_origin = 0, before_q = 0;
int res = 0;
for (int i = 0; i < d; i++) {
if (llast[i][origin])
before_origin = i + 1;
if (llast[i][q])
before_q = i + 1;
res += (c[origin] * (i + 1 - before_origin) + c[q] * (i + 1 - before_q));
}
llast[p][q] = true;
llast[p][origin] = false;
before_origin = 0;
before_q = 0;
for (int i = 0; i < d; i++) {
if (llast[i][origin])
before_origin = i + 1;
if (llast[i][q])
before_q = i + 1;
res -= (c[origin] * (i + 1 - before_origin) + c[q] * (i + 1 - before_q));
}
// cout << res << endl;
double t = 1 - ((double)(end - start) / CLOCKS_PER_SEC) / MX_SEC;
// cout << t << endl;
newscore += res;
if (newscore - myscore > 0 ||
(exp((double)(newscore - myscore) / t) > pro(mt))) {
myscore = newscore;
solution[p] = q;
} else {
llast[p][q] = false;
llast[p][origin] = true;
}
}
// p day contest swap q day contest
void betterswap(int p, int q, clock_t start, clock_t end) {
int p_origin = solution[p];
int q_origin = solution[q];
int newscore = myscore;
newscore -= s[p][p_origin] + s[q][q_origin];
newscore += s[p][q_origin] + s[q][p_origin];
int before_p_origin = 0, before_q_origin = 0;
int res = 0;
for (int i = 0; i < d; i++) {
if (llast[i][p_origin])
before_p_origin = i + 1;
if (llast[i][q_origin])
before_q_origin = i + 1;
res += (c[p_origin] * (i + 1 - before_p_origin) +
c[q_origin] * (i + 1 - before_q_origin));
}
llast[p][q_origin] = true, llast[p][p_origin] = false;
llast[q][p_origin] = true, llast[q][q_origin] = false;
before_p_origin = 0;
before_q_origin = 0;
for (int i = 0; i < d; i++) {
if (llast[i][p_origin])
before_p_origin = i + 1;
if (llast[i][q_origin])
before_q_origin = i + 1;
res -= (c[p_origin] * (i + 1 - before_p_origin) +
c[q_origin] * (i + 1 - before_q_origin));
}
double t = 1 - ((double)(end - start) / CLOCKS_PER_SEC) / MX_SEC;
newscore += res;
if (newscore - myscore > 0 ||
(exp((double)(newscore - myscore) / t) > pro(mt))) {
myscore = newscore;
solution[p] = q_origin;
solution[q] = p_origin;
} else {
llast[p][q_origin] = false, llast[p][p_origin] = true;
llast[q][p_origin] = false, llast[q][q_origin] = true;
}
}
// day 1-index i_day 's contest is k
int nowscore(int i, int k) {
int res = s[i][k];
int before = last[k];
last[k] = i + 1;
rep(j, 26) res -= c[j] * (i + 1 - last[j]);
last[k] = before;
return res;
}
int main() {
clock_t start = clock();
int tmp;
cin >> tmp;
rep(i, 26) cin >> c[i];
rep(i, d) rep(j, 26) cin >> s[i][j];
for (int i = 0; i < d; i++) {
int id = -1;
int mx = -INF;
for (int j = 0; j < 26; j++) {
int res = nowscore(i, j);
if (mx < res) {
id = j;
mx = res;
}
}
solution[i] = id;
last[id] = i + 1;
llast[i][id] = true;
myscore += mx;
}
clock_t end = clock();
while (((double)(end - start) / CLOCKS_PER_SEC) < MX_SEC) {
int k = day(mt);
betterswap(k, min(k + num(mt), 365 - 1), start, end);
better(day(mt), con(mt), start, end);
end = clock();
}
rep(i, d) cout << solution[i] + 1 << endl;
/*
cout << myscore << endl;
cout << (score(solution) + 1e6) << endl;
cout << (myscore + 1e6) << endl;
*/
return 0;
}
| replace | 11 | 12 | 11 | 12 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll longinf = 1LL << 60;
constexpr ll mod = 1e9 + 7;
const int N = 365, M = 26;
int c[26], s[365][26];
int res[365];
set<int> st[26];
int calc() {
int ret = 0;
vector<int> last(26, -1);
rep(i, N) {
ret += s[i][res[i]];
last[res[i]] = i;
rep(j, 26) ret -= c[j] * (i - last[j]);
}
return ret;
}
inline int f(int n) { return n * (n - 1) / 2; }
int erase(int i, int j) {
auto itr = st[i].lower_bound(j);
int nxt = *(next(itr)), prv = *(prev(itr));
return -s[j][i] + c[i] * (f(j - prv) + f(nxt - j) - f(nxt - prv));
}
int insert(int i, int j) {
auto itr = st[i].lower_bound(j);
int nxt = *itr, prv = *(prev(itr));
return s[j][i] + c[i] * (-f(j - prv) - f(nxt - j) + f(nxt - prv));
}
struct Xor128 {
unsigned x, y, z, w;
Xor128(unsigned w_ = 88675123)
: x(123456789), y(362436069), z(521288629), w(w_){};
inline unsigned xor128() {
unsigned t;
t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
}
int nextInt(int x, int y) {
if (x > y)
swap(x, y);
return xor128() % (y - x) + x;
}
double nextDouble(double a, double b) {
return (double)(xor128() & 0xffff) / 0xffff * (b - a) + a;
}
};
const int T = 2e7;
const double startT = 0, endT = 1000;
int main() {
int _;
cin >> _;
rep(i, M) cin >> c[i];
rep(i, N) rep(j, M) cin >> s[i][j];
rep(i, M) st[i].insert(-1);
rep(i, M) st[i].insert(N);
auto rnd = Xor128();
rep(i, N) {
res[i] = rnd.nextInt(0, M);
st[res[i]].insert(i);
}
int cur = calc();
rep(loop, T) {
int day = rnd.nextInt(0, N), con = rnd.nextInt(0, M);
if (res[day] == con)
continue;
int diff = insert(con, day) + erase(res[day], day);
double temp = startT + (endT - startT) * loop / T;
double prob = exp((double)diff / temp);
if (prob > rnd.nextDouble(0, 1) || diff > 0) {
cur += diff;
st[res[day]].erase(day);
st[con].insert(day);
res[day] = con;
}
}
rep(i, N) cout << res[i] + 1 << endl;
cerr << cur << endl;
return 0;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll longinf = 1LL << 60;
constexpr ll mod = 1e9 + 7;
const int N = 365, M = 26;
int c[26], s[365][26];
int res[365];
set<int> st[26];
int calc() {
int ret = 0;
vector<int> last(26, -1);
rep(i, N) {
ret += s[i][res[i]];
last[res[i]] = i;
rep(j, 26) ret -= c[j] * (i - last[j]);
}
return ret;
}
inline int f(int n) { return n * (n - 1) / 2; }
int erase(int i, int j) {
auto itr = st[i].lower_bound(j);
int nxt = *(next(itr)), prv = *(prev(itr));
return -s[j][i] + c[i] * (f(j - prv) + f(nxt - j) - f(nxt - prv));
}
int insert(int i, int j) {
auto itr = st[i].lower_bound(j);
int nxt = *itr, prv = *(prev(itr));
return s[j][i] + c[i] * (-f(j - prv) - f(nxt - j) + f(nxt - prv));
}
struct Xor128 {
unsigned x, y, z, w;
Xor128(unsigned w_ = 88675123)
: x(123456789), y(362436069), z(521288629), w(w_){};
inline unsigned xor128() {
unsigned t;
t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
}
int nextInt(int x, int y) {
if (x > y)
swap(x, y);
return xor128() % (y - x) + x;
}
double nextDouble(double a, double b) {
return (double)(xor128() & 0xffff) / 0xffff * (b - a) + a;
}
};
const int T = 15000000;
const double startT = 0, endT = 1000;
int main() {
int _;
cin >> _;
rep(i, M) cin >> c[i];
rep(i, N) rep(j, M) cin >> s[i][j];
rep(i, M) st[i].insert(-1);
rep(i, M) st[i].insert(N);
auto rnd = Xor128();
rep(i, N) {
res[i] = rnd.nextInt(0, M);
st[res[i]].insert(i);
}
int cur = calc();
rep(loop, T) {
int day = rnd.nextInt(0, N), con = rnd.nextInt(0, M);
if (res[day] == con)
continue;
int diff = insert(con, day) + erase(res[day], day);
double temp = startT + (endT - startT) * loop / T;
double prob = exp((double)diff / temp);
if (prob > rnd.nextDouble(0, 1) || diff > 0) {
cur += diff;
st[res[day]].erase(day);
st[con].insert(day);
res[day] = con;
}
}
rep(i, N) cout << res[i] + 1 << endl;
cerr << cur << endl;
return 0;
} | replace | 78 | 79 | 78 | 79 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll longinf = 1LL << 60;
constexpr ll mod = 1e9 + 7;
const int N = 365, M = 26;
int c[26], s[365][26];
int res[365];
set<int> st[26];
int calc() {
int ret = 0;
vector<int> last(26, -1);
rep(i, N) {
ret += s[i][res[i]];
last[res[i]] = i;
rep(j, 26) ret -= c[j] * (i - last[j]);
}
return ret;
}
inline int f(int n) { return n * (n - 1) / 2; }
int erase(int i, int j) {
auto itr = st[i].lower_bound(j);
int nxt = *(next(itr)), prv = *(prev(itr));
return -s[j][i] + c[i] * (f(j - prv) + f(nxt - j) - f(nxt - prv));
}
int insert(int i, int j) {
auto itr = st[i].lower_bound(j);
int nxt = *itr, prv = *(prev(itr));
return s[j][i] + c[i] * (-f(j - prv) - f(nxt - j) + f(nxt - prv));
}
int up(int i, int j) {
auto itr = st[i].lower_bound(j);
int nxt = *(next(itr)), prv = *(prev(itr));
return s[j + 1][i] - s[j][i] +
c[i] * (f(j - prv) + f(nxt - j) - f(j + 1 - prv) - f(nxt - j - 1));
}
int down(int i, int j) {
auto itr = st[i].lower_bound(j);
int nxt = *(next(itr)), prv = *(prev(itr));
return s[j - 1][i] - s[j][i] +
c[i] * (f(j - prv) + f(nxt - j) - f(j - 1 - prv) - f(nxt - j + 1));
}
struct Xor128 {
unsigned x, y, z, w;
Xor128(unsigned w_ = 88675123)
: x(123456789), y(362436069), z(521288629), w(w_){};
inline unsigned xor128() {
unsigned t;
t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
}
int nextInt(int x, int y) {
if (x > y)
swap(x, y);
return xor128() % (y - x) + x;
}
double nextDouble(double a, double b) {
return (double)(xor128() & 0xffff) / 0xffff * (b - a) + a;
}
};
const int T = 14000000;
const double startT = 20000, endT = 0;
const double startT2 = 1000, endT2 = 0;
int main() {
int _;
cin >> _;
rep(i, M) cin >> c[i];
rep(i, N) rep(j, M) cin >> s[i][j];
rep(i, M) st[i].insert(-1);
rep(i, M) st[i].insert(N);
auto rnd = Xor128();
int sum = 0;
rep(j, M) sum += c[j];
rep(i, N) {
int t = rnd.nextInt(0, sum);
int j = 0, cs = 0;
while (cs + c[j] < t) {
cs += c[j++];
}
res[i] = j;
st[res[i]].insert(i);
}
int cur = calc();
cerr << cur << endl;
rep(loop, T) {
if (loop % 2 == 0) {
int day = rnd.nextInt(0, N), con = rnd.nextInt(0, M);
if (res[day] == con)
continue;
int diff = insert(con, day) + erase(res[day], day);
double temp = startT + (endT - startT) * loop / T;
double prob = exp((double)diff / temp);
if (prob > rnd.nextDouble(0, 1) || diff > 0) {
cur += diff;
st[res[day]].erase(day);
st[con].insert(day);
res[day] = con;
}
} else {
int day = rnd.nextInt(0, N - 1);
if (res[day] == res[day + 1])
continue;
int diff = up(res[day], day) + down(res[day + 1], day + 1);
double temp = startT2 + (endT2 - startT2) * loop / T;
double prob = exp((double)diff / temp);
if (prob > rnd.nextDouble(0, 1) || diff > 0) {
cur += diff;
st[res[day]].erase(day);
st[res[day + 1]].erase(day + 1);
swap(res[day], res[day + 1]);
st[res[day]].insert(day);
st[res[day + 1]].insert(day + 1);
}
}
}
rep(i, N) cout << res[i] + 1 << endl;
cerr << cur << endl;
return 0;
} | #include <algorithm>
#include <assert.h>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll longinf = 1LL << 60;
constexpr ll mod = 1e9 + 7;
const int N = 365, M = 26;
int c[26], s[365][26];
int res[365];
set<int> st[26];
int calc() {
int ret = 0;
vector<int> last(26, -1);
rep(i, N) {
ret += s[i][res[i]];
last[res[i]] = i;
rep(j, 26) ret -= c[j] * (i - last[j]);
}
return ret;
}
inline int f(int n) { return n * (n - 1) / 2; }
int erase(int i, int j) {
auto itr = st[i].lower_bound(j);
int nxt = *(next(itr)), prv = *(prev(itr));
return -s[j][i] + c[i] * (f(j - prv) + f(nxt - j) - f(nxt - prv));
}
int insert(int i, int j) {
auto itr = st[i].lower_bound(j);
int nxt = *itr, prv = *(prev(itr));
return s[j][i] + c[i] * (-f(j - prv) - f(nxt - j) + f(nxt - prv));
}
int up(int i, int j) {
auto itr = st[i].lower_bound(j);
int nxt = *(next(itr)), prv = *(prev(itr));
return s[j + 1][i] - s[j][i] +
c[i] * (f(j - prv) + f(nxt - j) - f(j + 1 - prv) - f(nxt - j - 1));
}
int down(int i, int j) {
auto itr = st[i].lower_bound(j);
int nxt = *(next(itr)), prv = *(prev(itr));
return s[j - 1][i] - s[j][i] +
c[i] * (f(j - prv) + f(nxt - j) - f(j - 1 - prv) - f(nxt - j + 1));
}
struct Xor128 {
unsigned x, y, z, w;
Xor128(unsigned w_ = 88675123)
: x(123456789), y(362436069), z(521288629), w(w_){};
inline unsigned xor128() {
unsigned t;
t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
}
int nextInt(int x, int y) {
if (x > y)
swap(x, y);
return xor128() % (y - x) + x;
}
double nextDouble(double a, double b) {
return (double)(xor128() & 0xffff) / 0xffff * (b - a) + a;
}
};
const int T = 10000000;
const double startT = 5000, endT = 100;
const double startT2 = 1000, endT2 = 20;
int main() {
int _;
cin >> _;
rep(i, M) cin >> c[i];
rep(i, N) rep(j, M) cin >> s[i][j];
rep(i, M) st[i].insert(-1);
rep(i, M) st[i].insert(N);
auto rnd = Xor128();
int sum = 0;
rep(j, M) sum += c[j];
rep(i, N) {
int t = rnd.nextInt(0, sum);
int j = 0, cs = 0;
while (cs + c[j] < t) {
cs += c[j++];
}
res[i] = j;
st[res[i]].insert(i);
}
int cur = calc();
cerr << cur << endl;
rep(loop, T) {
if (loop % 2 == 0) {
int day = rnd.nextInt(0, N), con = rnd.nextInt(0, M);
if (res[day] == con)
continue;
int diff = insert(con, day) + erase(res[day], day);
double temp = startT + (endT - startT) * loop / T;
double prob = exp((double)diff / temp);
if (prob > rnd.nextDouble(0, 1) || diff > 0) {
cur += diff;
st[res[day]].erase(day);
st[con].insert(day);
res[day] = con;
}
} else {
int day = rnd.nextInt(0, N - 1);
if (res[day] == res[day + 1])
continue;
int diff = up(res[day], day) + down(res[day + 1], day + 1);
double temp = startT2 + (endT2 - startT2) * loop / T;
double prob = exp((double)diff / temp);
if (prob > rnd.nextDouble(0, 1) || diff > 0) {
cur += diff;
st[res[day]].erase(day);
st[res[day + 1]].erase(day + 1);
swap(res[day], res[day + 1]);
st[res[day]].insert(day);
st[res[day + 1]].insert(day + 1);
}
}
}
rep(i, N) cout << res[i] + 1 << endl;
cerr << cur << endl;
return 0;
} | replace | 92 | 95 | 92 | 95 | TLE | |
p02618 | C++ | Runtime Error | #ifdef LOCAL
#define _GLIBCXX_DEBUG
#define __clock__
#else
#pragma GCC optimize("Ofast")
#endif
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<ll>;
using VV = vector<VI>;
using VS = vector<string>;
using PII = pair<ll, ll>;
// tourist set
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N> string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// tourist set end
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, b) FOR(i, 0, b)
#define ALL(v) (v).begin(), (v).end()
#define p(s) cout << (s) << '\n'
#define p2(s, t) cout << (s) << " " << (t) << '\n'
#define br() p("")
#define pn(s) cout << (#s) << " " << (s) << '\n'
#define SZ(x) ((int)(x).size())
#define SORT(A) sort(ALL(A))
#define RSORT(A) sort(ALL(A), greater<ll>())
#define MP make_pair
#define p_yes() p("Yes")
#define p_no() p("No")
ll SUM(VI &V) { return accumulate(ALL(V), 0LL); }
ll MIN(VI &V) { return *min_element(ALL(V)); }
ll MAX(VI &V) { return *max_element(ALL(V)); }
void print_vector(VI &V) {
ll n = V.size();
rep(i, n) {
if (i)
cout << ' ';
cout << V[i];
}
cout << endl;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
// long double
using ld = long double;
#define EPS (1e-14)
#define equals(a, b) (fabs((a) - (b)) < EPS)
void no() {
p_no();
exit(0);
}
void yes() {
p_yes();
exit(0);
}
const ll mod = 1e9 + 7;
const ll inf = 1e18;
const double PI = acos(-1);
// for codeforces
void solve() {
ll a;
cin >> a;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// input
ll D;
cin >> D;
VI C(26);
rep(i, 26) { cin >> C[i]; }
VV S(D, VI(26));
rep(i, D) {
rep(j, 26) { cin >> S[i][j]; }
}
// スコア関数
auto calc_score = [&](VI &T) {
ll sum = 0;
VI last(26, -1);
VI ret(D);
// i日目
rep(i, D) {
ll id = T[i] - 1; // id番目のコンテストを選んだ
sum += S[i][id];
last[id] = i;
// 満足度の低下
rep(j, 26) { sum -= C[j] * (i + 1 - last[j] - 1); }
ret[i] = sum;
}
return ret;
};
// ランダム
auto generate_random = [&]() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
VI Ans(D);
rep(i, D) {
ll k = rng() % D + 1;
Ans[i] = k;
}
return Ans;
};
ll LOOP = 1000;
auto max_list = generate_random();
ll max_score = calc_score(max_list).back();
while (LOOP--) {
auto candidate = generate_random();
ll candidate_score = calc_score(candidate).back();
if (candidate_score > max_score) {
max_score = candidate_score;
max_list = candidate;
}
}
// 答え
for (ll id : max_list) {
p(id);
}
return 0;
} | #ifdef LOCAL
#define _GLIBCXX_DEBUG
#define __clock__
#else
#pragma GCC optimize("Ofast")
#endif
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
using VI = vector<ll>;
using VV = vector<VI>;
using VS = vector<string>;
using PII = pair<ll, ll>;
// tourist set
template <typename A, typename B> string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string &s) { return '"' + s + '"'; }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N> string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A> string to_string(A v) {
bool first = true;
string res = "{";
for (const auto &x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B> string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << '\n'; }
template <typename Head, typename... Tail> void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif
// tourist set end
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define FOR(i, a, b) for (ll i = (a); i < (b); ++i)
#define rep(i, b) FOR(i, 0, b)
#define ALL(v) (v).begin(), (v).end()
#define p(s) cout << (s) << '\n'
#define p2(s, t) cout << (s) << " " << (t) << '\n'
#define br() p("")
#define pn(s) cout << (#s) << " " << (s) << '\n'
#define SZ(x) ((int)(x).size())
#define SORT(A) sort(ALL(A))
#define RSORT(A) sort(ALL(A), greater<ll>())
#define MP make_pair
#define p_yes() p("Yes")
#define p_no() p("No")
ll SUM(VI &V) { return accumulate(ALL(V), 0LL); }
ll MIN(VI &V) { return *min_element(ALL(V)); }
ll MAX(VI &V) { return *max_element(ALL(V)); }
void print_vector(VI &V) {
ll n = V.size();
rep(i, n) {
if (i)
cout << ' ';
cout << V[i];
}
cout << endl;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll g = gcd(a, b);
return a / g * b;
}
// long double
using ld = long double;
#define EPS (1e-14)
#define equals(a, b) (fabs((a) - (b)) < EPS)
void no() {
p_no();
exit(0);
}
void yes() {
p_yes();
exit(0);
}
const ll mod = 1e9 + 7;
const ll inf = 1e18;
const double PI = acos(-1);
// for codeforces
void solve() {
ll a;
cin >> a;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
// input
ll D;
cin >> D;
VI C(26);
rep(i, 26) { cin >> C[i]; }
VV S(D, VI(26));
rep(i, D) {
rep(j, 26) { cin >> S[i][j]; }
}
// スコア関数
auto calc_score = [&](VI &T) {
ll sum = 0;
VI last(26, -1);
VI ret(D);
// i日目
rep(i, D) {
ll id = T[i] - 1; // id番目のコンテストを選んだ
sum += S[i][id];
last[id] = i;
// 満足度の低下
rep(j, 26) { sum -= C[j] * (i + 1 - last[j] - 1); }
ret[i] = sum;
}
return ret;
};
// ランダム
auto generate_random = [&]() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
VI Ans(D);
rep(i, D) {
ll k = rng() % 26 + 1;
Ans[i] = k;
}
return Ans;
};
ll LOOP = 1000;
auto max_list = generate_random();
ll max_score = calc_score(max_list).back();
while (LOOP--) {
auto candidate = generate_random();
ll candidate_score = calc_score(candidate).back();
if (candidate_score > max_score) {
max_score = candidate_score;
max_list = candidate;
}
}
// 答え
for (ll id : max_list) {
p(id);
}
return 0;
} | replace | 214 | 215 | 214 | 215 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)
#define pb push_back
#define rep(i, n) for (int i = 0; i < (n); i++)
#define INF (1 << 29)
using namespace std;
typedef long long ll;
const int nc = 26;
int D;
ll c[40], t[400];
ll s[400][40];
ll scoring() {
vector<int> last(nc + 10, -1);
long long sat = 0;
for (ll d = 0; d < D; d++) {
last[t[d]] = d;
for (int i = 0; i < nc; i++) {
sat -= c[i] * (d - last[i]);
}
sat += s[d][t[d]];
// cout << sat << endl;
}
return sat;
}
double elapsed_time(chrono::system_clock::time_point start) {
auto now_time = chrono::system_clock::now();
auto elapsed =
chrono::duration_cast<std::chrono::milliseconds>(now_time - start)
.count();
// cout << elapsed << endl;
return elapsed;
}
int main() {
random_device rnd;
mt19937 mt(rnd());
cin >> D;
for (int i = 0; i < nc; i++) {
cin >> c[i];
}
for (int i = 0; i < D; i++) {
for (int j = 0; j < nc; j++) {
cin >> s[i][j];
}
}
ll score = scoring();
for (int i = 0; i < D; i++) {
t[i] = mt() % nc; // 初期解をrandで生成
}
auto start = chrono::system_clock::now();
int cnt = 0;
while (cnt < 1000000) {
cnt++;
// if(elapsed_time(start) > 1.9) break;
int d, q, old;
d = mt() % D;
q = mt() % nc;
old = t[d];
t[d] = q;
ll new_score = scoring();
// cout << new_score << endl;
if (score > new_score) {
t[d] = old;
} else {
score = new_score;
}
}
// cout << score << endl;
for (int i = 0; i < D; i++) {
cout << ++t[i] << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)
#define pb push_back
#define rep(i, n) for (int i = 0; i < (n); i++)
#define INF (1 << 29)
using namespace std;
typedef long long ll;
const int nc = 26;
int D;
ll c[40], t[400];
ll s[400][40];
ll scoring() {
vector<int> last(nc + 10, -1);
long long sat = 0;
for (ll d = 0; d < D; d++) {
last[t[d]] = d;
for (int i = 0; i < nc; i++) {
sat -= c[i] * (d - last[i]);
}
sat += s[d][t[d]];
// cout << sat << endl;
}
return sat;
}
double elapsed_time(chrono::system_clock::time_point start) {
auto now_time = chrono::system_clock::now();
auto elapsed =
chrono::duration_cast<std::chrono::milliseconds>(now_time - start)
.count();
// cout << elapsed << endl;
return elapsed;
}
int main() {
random_device rnd;
mt19937 mt(rnd());
cin >> D;
for (int i = 0; i < nc; i++) {
cin >> c[i];
}
for (int i = 0; i < D; i++) {
for (int j = 0; j < nc; j++) {
cin >> s[i][j];
}
}
ll score = scoring();
for (int i = 0; i < D; i++) {
t[i] = mt() % nc; // 初期解をrandで生成
}
auto start = chrono::system_clock::now();
int cnt = 0;
while (cnt < 100000) {
cnt++;
// if(elapsed_time(start) > 1.9) break;
int d, q, old;
d = mt() % D;
q = mt() % nc;
old = t[d];
t[d] = q;
ll new_score = scoring();
// cout << new_score << endl;
if (score > new_score) {
t[d] = old;
} else {
score = new_score;
}
}
// cout << score << endl;
for (int i = 0; i < D; i++) {
cout << ++t[i] << endl;
}
return 0;
}
| replace | 67 | 68 | 67 | 68 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int ddx[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll MOD = 1000000007;
const ll INF = 1000000000000000000L;
#ifdef __DEBUG
/**
* For DEBUG
* https://github.com/ta7uw/cpp-pyprint
*/
#include "cpp-pyprint/pyprint.h"
#endif
void solve() {
clock_t start = clock();
ll D;
cin >> D;
vector<ll> C(26);
rep(i, 26) cin >> C[i];
vector<vector<ll>> S(D, vector<ll>(26));
rep(i, D) {
rep(j, 26) { cin >> S[i][j]; }
}
vector<ll> T(D);
rep(i, D) {
ll m = -INF;
rep(j, 26) {
if (S[i][j] > m) {
T[i] = j;
m = S[i][j];
}
}
}
vector<ll> last(26, 0);
ll sum = 0;
auto f = [&] {
sum = 0;
last.assign(26, 0);
rep(d, D) {
ll t = T[d];
sum += S[d][t - 1];
last[t - 1] = d + 1;
rep(i, 26) { sum -= C[i] * ((d + 1) - last[i]); }
}
return sum;
};
ll ans = -INF;
clock_t end = clock();
double time = (end - start) / 1000;
while (time <= 1900) {
ll r = rand() % 26;
r++;
ll d = rand() % 365;
ll old = T[d];
T[d] = r;
ll res = f();
if (res > ans) {
ans = res;
} else {
T[d] = old;
}
// cout << ans << '\n';
end = clock();
time = (end - start) / 1000;
}
// cout << time << '\n';
rep(d, D) { cout << T[d] << '\n'; }
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
const int ddx[8] = {0, 1, 1, 1, 0, -1, -1, -1};
const int ddy[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll MOD = 1000000007;
const ll INF = 1000000000000000000L;
#ifdef __DEBUG
/**
* For DEBUG
* https://github.com/ta7uw/cpp-pyprint
*/
#include "cpp-pyprint/pyprint.h"
#endif
void solve() {
clock_t start = clock();
ll D;
cin >> D;
vector<ll> C(26);
rep(i, 26) cin >> C[i];
vector<vector<ll>> S(D, vector<ll>(26));
rep(i, D) {
rep(j, 26) { cin >> S[i][j]; }
}
vector<ll> T(D);
rep(i, D) {
ll m = -INF;
rep(j, 26) {
if (S[i][j] > m) {
T[i] = j + 1;
m = S[i][j];
}
}
}
vector<ll> last(26, 0);
ll sum = 0;
auto f = [&] {
sum = 0;
last.assign(26, 0);
rep(d, D) {
ll t = T[d];
sum += S[d][t - 1];
last[t - 1] = d + 1;
rep(i, 26) { sum -= C[i] * ((d + 1) - last[i]); }
}
return sum;
};
ll ans = -INF;
clock_t end = clock();
double time = (end - start) / 1000;
while (time <= 1900) {
ll r = rand() % 26;
r++;
ll d = rand() % 365;
ll old = T[d];
T[d] = r;
ll res = f();
if (res > ans) {
ans = res;
} else {
T[d] = old;
}
// cout << ans << '\n';
end = clock();
time = (end - start) / 1000;
}
// cout << time << '\n';
rep(d, D) { cout << T[d] << '\n'; }
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
solve();
return 0;
}
| replace | 42 | 43 | 42 | 43 | -6 | free(): invalid pointer
|
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#include <utility>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
const int INF = 1e9;
using Pii = pair<int, int>;
const int con_type = 26;
int D = 365;
int C[con_type];
int S[365][con_type];
vector<int> ans;
int last[con_type];
struct State {
int cost;
vector<int> ans;
vector<int> last;
State() {
cost = 0;
last = vector<int>(26, -1);
}
State(int cost, vector<int> ans, vector<int> last)
: cost(cost), ans(ans), last(last){};
bool operator<(const State &s) const { return cost < s.cost; }
bool operator>(const State &s) const { return cost > s.cost; }
};
void solve() {
priority_queue<State> Q;
Q.push(State());
REP(d, D) {
priority_queue<State> nQ;
while (!Q.empty()) {
State now = Q.top();
Q.pop();
vector<Pii> add_cost;
int sum = 0;
int type_cost[26];
REP(i, con_type) {
sum += (d - now.last[i]) * C[i];
type_cost[i] = (d - now.last[i]) * C[i];
}
REP(i, con_type) {
add_cost.emplace_back(Pii(S[d][i] + (d - now.last[i]) * C[i] - sum, i));
}
sort(add_cost.begin(), add_cost.end(), greater<Pii>());
REP(i, 12) {
int id = add_cost[i].second;
State next = now;
next.cost += S[d][id];
next.cost -= sum;
next.cost += type_cost[id];
next.ans.emplace_back(id);
next.last[id] = d;
nQ.push(next);
}
}
Q = priority_queue<State>();
REP(i, min(1000, (int)nQ.size())) {
Q.push(nQ.top());
nQ.pop();
}
}
ans = Q.top().ans;
}
void input() {
cin >> D;
REP(i, con_type) {
cin >> C[i];
last[i] = -1;
}
REP(i, D) REP(j, con_type) cin >> S[i][j];
}
void output() { REP(i, D) cout << ans[i] + 1 << endl; }
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
input();
solve();
output();
return 0;
}
| #include <bits/stdc++.h>
#include <utility>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
const int INF = 1e9;
using Pii = pair<int, int>;
const int con_type = 26;
int D = 365;
int C[con_type];
int S[365][con_type];
vector<int> ans;
int last[con_type];
struct State {
int cost;
vector<int> ans;
vector<int> last;
State() {
cost = 0;
last = vector<int>(26, -1);
}
State(int cost, vector<int> ans, vector<int> last)
: cost(cost), ans(ans), last(last){};
bool operator<(const State &s) const { return cost < s.cost; }
bool operator>(const State &s) const { return cost > s.cost; }
};
void solve() {
priority_queue<State> Q;
Q.push(State());
REP(d, D) {
priority_queue<State> nQ;
while (!Q.empty()) {
State now = Q.top();
Q.pop();
vector<Pii> add_cost;
int sum = 0;
int type_cost[26];
REP(i, con_type) {
sum += (d - now.last[i]) * C[i];
type_cost[i] = (d - now.last[i]) * C[i];
}
REP(i, con_type) {
add_cost.emplace_back(Pii(S[d][i] + (d - now.last[i]) * C[i] - sum, i));
}
sort(add_cost.begin(), add_cost.end(), greater<Pii>());
REP(i, 12) {
int id = add_cost[i].second;
State next = now;
next.cost += S[d][id];
next.cost -= sum;
next.cost += type_cost[id];
next.ans.emplace_back(id);
next.last[id] = d;
nQ.push(next);
}
}
Q = priority_queue<State>();
REP(i, min(800, (int)nQ.size())) {
Q.push(nQ.top());
nQ.pop();
}
}
ans = Q.top().ans;
}
void input() {
cin >> D;
REP(i, con_type) {
cin >> C[i];
last[i] = -1;
}
REP(i, D) REP(j, con_type) cin >> S[i][j];
}
void output() { REP(i, D) cout << ans[i] + 1 << endl; }
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
input();
solve();
output();
return 0;
}
| replace | 65 | 66 | 65 | 66 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
constexpr int MOD = 1000000007;
constexpr int INF = numeric_limits<int>::max() / 2;
typedef pair<int, int> P;
using Graph = vector<vector<int>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long double PI = acos(-1.0);
// cout << fixed << setprecision(14);
set<int> st[26];
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int D;
cin >> D;
rep(i, 26) {
st[i].insert(-1);
st[i].insert(D);
}
int c[26];
int s[D][26];
int t[D];
int ok[26];
rep(i, 26) ok[i] = -1;
rep(i, 26) cin >> c[i];
rep(i, D) {
rep(j, 26) { cin >> s[i][j]; }
}
int num;
rep(i, D) {
int maxi = -INF;
rep(k, 26) {
int ans = 0;
ans += s[i][k];
// ok[t[i]] = i;
rep(j, 26) {
if (j == k)
continue;
ans -= c[j] * (i - ok[j]);
}
if (maxi < ans) {
maxi = ans;
num = k;
}
}
ok[num] = i;
t[i] = num;
st[num].insert(i);
}
rep(loop, 3) {
rep(i, D - 1) {
int dx = 0;
int old1 = t[i], old2 = t[i + 1];
// st[_].erase(d[i]);
auto itr = st[old1].upper_bound(i);
int W2 = *itr;
--itr;
--itr;
int W1 = *itr;
dx -= c[old1] * (i - W1) * (W2 - i);
auto itr1 = st[old2].upper_bound(i);
int A2 = *itr1;
--itr1;
int A1 = *itr1;
dx += c[old2] * (i - A1) * (A2 - i);
// st[q[i]].insert(d[i]);
dx += s[i][t[i + 1]] - s[i][t[i]];
++i;
// st[_].erase(d[i]);
itr = st[old2].upper_bound(i);
W2 = *itr;
--itr;
--itr;
W1 = *itr;
dx -= c[old2] * (i - W1) * (W2 - i);
itr1 = st[old1].upper_bound(i);
A2 = *itr1;
--itr1;
A1 = *itr1;
dx += c[old1] * (i - A1) * (A2 - i);
// st[q[i]].insert(d[i]);
dx += s[i][t[i - 1]] - s[i][t[i]];
--i;
if (dx > 0) {
t[i] = old2;
t[i + 1] = old1;
}
}
}
rep(loop, 100000) {
rep(i, D - 1) {
int dx = 0;
int old1 = t[i], old2 = t[i + 1];
// st[_].erase(d[i]);
auto itr = st[old1].upper_bound(i);
int W2 = *itr;
--itr;
--itr;
int W1 = *itr;
dx -= c[old1] * (i - W1) * (W2 - i);
auto itr1 = st[old2].upper_bound(i);
int A2 = *itr1;
--itr1;
int A1 = *itr1;
dx += c[old2] * (i - A1) * (A2 - i);
// st[q[i]].insert(d[i]);
dx += s[i][t[i + 1]] - s[i][t[i]];
++i;
// st[_].erase(d[i]);
itr = st[old2].upper_bound(i);
W2 = *itr;
--itr;
--itr;
W1 = *itr;
dx -= c[old2] * (i - W1) * (W2 - i);
itr1 = st[old1].upper_bound(i);
A2 = *itr1;
--itr1;
A1 = *itr1;
dx += c[old1] * (i - A1) * (A2 - i);
// st[q[i]].insert(d[i]);
dx += s[i][t[i - 1]] - s[i][t[i]];
--i;
if (dx > 0) {
t[i] = old2;
t[i + 1] = old1;
}
}
}
rep(i, D) cout << t[i] + 1 << endl;
} | #include <bits/stdc++.h>
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
constexpr int MOD = 1000000007;
constexpr int INF = numeric_limits<int>::max() / 2;
typedef pair<int, int> P;
using Graph = vector<vector<int>>;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
const long double PI = acos(-1.0);
// cout << fixed << setprecision(14);
set<int> st[26];
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int D;
cin >> D;
rep(i, 26) {
st[i].insert(-1);
st[i].insert(D);
}
int c[26];
int s[D][26];
int t[D];
int ok[26];
rep(i, 26) ok[i] = -1;
rep(i, 26) cin >> c[i];
rep(i, D) {
rep(j, 26) { cin >> s[i][j]; }
}
int num;
rep(i, D) {
int maxi = -INF;
rep(k, 26) {
int ans = 0;
ans += s[i][k];
// ok[t[i]] = i;
rep(j, 26) {
if (j == k)
continue;
ans -= c[j] * (i - ok[j]);
}
if (maxi < ans) {
maxi = ans;
num = k;
}
}
ok[num] = i;
t[i] = num;
st[num].insert(i);
}
rep(loop, 3) {
rep(i, D - 1) {
int dx = 0;
int old1 = t[i], old2 = t[i + 1];
// st[_].erase(d[i]);
auto itr = st[old1].upper_bound(i);
int W2 = *itr;
--itr;
--itr;
int W1 = *itr;
dx -= c[old1] * (i - W1) * (W2 - i);
auto itr1 = st[old2].upper_bound(i);
int A2 = *itr1;
--itr1;
int A1 = *itr1;
dx += c[old2] * (i - A1) * (A2 - i);
// st[q[i]].insert(d[i]);
dx += s[i][t[i + 1]] - s[i][t[i]];
++i;
// st[_].erase(d[i]);
itr = st[old2].upper_bound(i);
W2 = *itr;
--itr;
--itr;
W1 = *itr;
dx -= c[old2] * (i - W1) * (W2 - i);
itr1 = st[old1].upper_bound(i);
A2 = *itr1;
--itr1;
A1 = *itr1;
dx += c[old1] * (i - A1) * (A2 - i);
// st[q[i]].insert(d[i]);
dx += s[i][t[i - 1]] - s[i][t[i]];
--i;
if (dx > 0) {
t[i] = old2;
t[i + 1] = old1;
}
}
}
rep(loop, 80000) {
rep(i, D - 1) {
int dx = 0;
int old1 = t[i], old2 = t[i + 1];
// st[_].erase(d[i]);
auto itr = st[old1].upper_bound(i);
int W2 = *itr;
--itr;
--itr;
int W1 = *itr;
dx -= c[old1] * (i - W1) * (W2 - i);
auto itr1 = st[old2].upper_bound(i);
int A2 = *itr1;
--itr1;
int A1 = *itr1;
dx += c[old2] * (i - A1) * (A2 - i);
// st[q[i]].insert(d[i]);
dx += s[i][t[i + 1]] - s[i][t[i]];
++i;
// st[_].erase(d[i]);
itr = st[old2].upper_bound(i);
W2 = *itr;
--itr;
--itr;
W1 = *itr;
dx -= c[old2] * (i - W1) * (W2 - i);
itr1 = st[old1].upper_bound(i);
A2 = *itr1;
--itr1;
A1 = *itr1;
dx += c[old1] * (i - A1) * (A2 - i);
// st[q[i]].insert(d[i]);
dx += s[i][t[i - 1]] - s[i][t[i]];
--i;
if (dx > 0) {
t[i] = old2;
t[i + 1] = old1;
}
}
}
rep(i, D) cout << t[i] + 1 << endl;
} | replace | 108 | 109 | 108 | 109 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
// ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
// clock_t start=clock();clock_t
// end=clock();cout<<(double)(end-start)/CLOCKS_PER_SEC<<endl;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef pair<int, int> pii;
typedef pair<pii, int> ppii;
typedef pair<int, pii> pipi;
typedef pair<ll, ll> pll;
typedef pair<pll, ll> ppll;
typedef pair<ll, pll> plpl;
typedef pair<pii, pii> pippi;
typedef tuple<ll, ll, ll> tl;
typedef pair<double, double> pdd;
typedef vector<vector<ll>> mat;
ll mod = 1000000007;
ll mod2 = 998244353;
ll mod3 = 1000003;
ll mod4 = 998244853;
ll mod5 = 1000000009;
ll inf = 1LL << 61;
int iinf = 1 << 30;
double pi = 3.141592653589793238462643383279L;
double eps = 1e-8;
#define rep(i, m, n) for (ll i = m; i < n; i++)
#define rrep(i, n, m) for (ll i = n; i >= m; i--)
#define srep(itr, st) for (auto itr = st.begin(); itr != st.end(); itr++)
#define mrep(itr, mp) for (auto &itr : mp)
#define Max(a, b) a = max(a, b)
#define Min(a, b) a = min(a, b)
// #define endl "\n"
int dh[4] = {1, -1, 0, 0};
int dw[4] = {0, 0, 1, -1};
int ddh[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
int ddw[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
#define umh unordered_map<int, int, custom_hash>
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
if (a % b == 0)
return b;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll c = gcd(a, b);
return a * b / c;
}
ll Pow(ll n, ll k) {
if (k < 0)
return 0;
ll ret = 1;
ll now = n;
while (k > 0) {
if (k & 1)
ret *= now;
now *= now;
k /= 2;
}
return ret;
}
ll beki(ll n, ll k, ll md) {
ll ret = 1;
ll now = n;
now %= md;
while (k > 0) {
if (k % 2 == 1) {
ret *= now;
ret %= md;
}
now *= now;
now %= md;
k /= 2;
}
return ret;
}
ll gyaku(ll n, ll md) { return beki(n, md - 2, md); }
ll popcount(ll n) {
ll ret = 0;
ll u = n;
while (u > 0) {
ret += u % 2;
u /= 2;
}
return ret;
}
random_device rnd;
mt19937 mt(rnd());
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int d;
cin >> d;
uniform_int_distribution<int> ra(1, 26), ra2(1, d);
int c[26];
rep(i, 0, 26) cin >> c[i];
int s[d + 1][26];
rep(i, 1, d + 1) rep(j, 0, 26) cin >> s[i][j];
ll now = 0;
vector<int> v[26];
rep(i, 0, 26) v[i].push_back(0);
int t[d + 1];
rep(i, 1, d + 1) {
int a = ra(mt);
t[i] = a;
}
rep(i, 1, d + 1) {
t[i]--;
v[t[i]].push_back(i);
now += s[i][t[i]];
rep(j, 0, 26) {
int las = v[j].back();
now -= c[j] * (i - las);
}
}
// cout<<now<<endl;
rep(i, 0, 26) v[i].push_back(d + 1);
rep(_, 0, 30000000) {
ll mae = now;
int dd, q;
dd = ra2(mt);
q = ra(mt);
q--;
int pre = t[dd];
if (pre == q) {
continue;
}
int y = lower_bound(v[pre].begin(), v[pre].end(), dd) - v[pre].begin();
int d1 = v[pre][y - 1];
int d3 = v[pre][y + 1];
now += c[pre] * (d1 - dd) * (d3 - dd);
// v[pre].erase(v[pre].begin()+y);
int yy = lower_bound(v[q].begin(), v[q].end(), dd) - v[q].begin();
int q1 = v[q][yy - 1], q3 = v[q][yy];
now += c[q] * (dd - q1) * (q3 - dd);
// v[q].insert(v[q].begin()+y,dd);
// cout<<d1<<" "<<d3<<" "<<q1<<" "<<q3<<" "<<pre<<endl;
now += s[dd][q] - s[dd][pre];
if (now <= mae) {
now = mae;
continue;
}
t[dd] = q;
v[pre].erase(v[pre].begin() + y);
v[q].insert(v[q].begin() + yy, dd);
}
rep(i, 1, d + 1) cout << t[i] + 1 << endl;
}
| #include <bits/stdc++.h>
// ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
// clock_t start=clock();clock_t
// end=clock();cout<<(double)(end-start)/CLOCKS_PER_SEC<<endl;
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int ui;
typedef pair<int, int> pii;
typedef pair<pii, int> ppii;
typedef pair<int, pii> pipi;
typedef pair<ll, ll> pll;
typedef pair<pll, ll> ppll;
typedef pair<ll, pll> plpl;
typedef pair<pii, pii> pippi;
typedef tuple<ll, ll, ll> tl;
typedef pair<double, double> pdd;
typedef vector<vector<ll>> mat;
ll mod = 1000000007;
ll mod2 = 998244353;
ll mod3 = 1000003;
ll mod4 = 998244853;
ll mod5 = 1000000009;
ll inf = 1LL << 61;
int iinf = 1 << 30;
double pi = 3.141592653589793238462643383279L;
double eps = 1e-8;
#define rep(i, m, n) for (ll i = m; i < n; i++)
#define rrep(i, n, m) for (ll i = n; i >= m; i--)
#define srep(itr, st) for (auto itr = st.begin(); itr != st.end(); itr++)
#define mrep(itr, mp) for (auto &itr : mp)
#define Max(a, b) a = max(a, b)
#define Min(a, b) a = min(a, b)
// #define endl "\n"
int dh[4] = {1, -1, 0, 0};
int dw[4] = {0, 0, 1, -1};
int ddh[8] = {-1, -1, -1, 0, 0, 1, 1, 1};
int ddw[8] = {-1, 0, 1, -1, 1, -1, 0, 1};
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
#define umh unordered_map<int, int, custom_hash>
ll gcd(ll a, ll b) {
if (a < b)
swap(a, b);
if (b == 0)
return a;
if (a % b == 0)
return b;
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
ll c = gcd(a, b);
return a * b / c;
}
ll Pow(ll n, ll k) {
if (k < 0)
return 0;
ll ret = 1;
ll now = n;
while (k > 0) {
if (k & 1)
ret *= now;
now *= now;
k /= 2;
}
return ret;
}
ll beki(ll n, ll k, ll md) {
ll ret = 1;
ll now = n;
now %= md;
while (k > 0) {
if (k % 2 == 1) {
ret *= now;
ret %= md;
}
now *= now;
now %= md;
k /= 2;
}
return ret;
}
ll gyaku(ll n, ll md) { return beki(n, md - 2, md); }
ll popcount(ll n) {
ll ret = 0;
ll u = n;
while (u > 0) {
ret += u % 2;
u /= 2;
}
return ret;
}
random_device rnd;
mt19937 mt(rnd());
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int d;
cin >> d;
uniform_int_distribution<int> ra(1, 26), ra2(1, d);
int c[26];
rep(i, 0, 26) cin >> c[i];
int s[d + 1][26];
rep(i, 1, d + 1) rep(j, 0, 26) cin >> s[i][j];
ll now = 0;
vector<int> v[26];
rep(i, 0, 26) v[i].push_back(0);
int t[d + 1];
rep(i, 1, d + 1) {
int a = ra(mt);
t[i] = a;
}
rep(i, 1, d + 1) {
t[i]--;
v[t[i]].push_back(i);
now += s[i][t[i]];
rep(j, 0, 26) {
int las = v[j].back();
now -= c[j] * (i - las);
}
}
// cout<<now<<endl;
rep(i, 0, 26) v[i].push_back(d + 1);
rep(_, 0, 10000000) {
ll mae = now;
int dd, q;
dd = ra2(mt);
q = ra(mt);
q--;
int pre = t[dd];
if (pre == q) {
continue;
}
int y = lower_bound(v[pre].begin(), v[pre].end(), dd) - v[pre].begin();
int d1 = v[pre][y - 1];
int d3 = v[pre][y + 1];
now += c[pre] * (d1 - dd) * (d3 - dd);
// v[pre].erase(v[pre].begin()+y);
int yy = lower_bound(v[q].begin(), v[q].end(), dd) - v[q].begin();
int q1 = v[q][yy - 1], q3 = v[q][yy];
now += c[q] * (dd - q1) * (q3 - dd);
// v[q].insert(v[q].begin()+y,dd);
// cout<<d1<<" "<<d3<<" "<<q1<<" "<<q3<<" "<<pre<<endl;
now += s[dd][q] - s[dd][pre];
if (now <= mae) {
now = mae;
continue;
}
t[dd] = q;
v[pre].erase(v[pre].begin() + y);
v[q].insert(v[q].begin() + yy, dd);
}
rep(i, 1, d + 1) cout << t[i] + 1 << endl;
}
| replace | 139 | 140 | 139 | 140 | TLE | |
p02618 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
int main() {
freopen("sample.txt", "r", stdin);
freopen("out.txt", "w", stdout);
std::random_device rd;
std::mt19937 mt(rd());
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.98 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 2 == 0) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (curscore < prevscore) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
int w = mt() % (D - day) + 1;
contest = ans[day];
change(day, ans[day + w]);
change(day + w, contest);
if (curscore < prevscore) {
change(day + w, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
int main() {
// freopen("sample.txt","r",stdin);
// freopen("out.txt","w",stdout);
std::random_device rd;
std::mt19937 mt(rd());
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.98 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 2 == 0) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (curscore < prevscore) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
int w = mt() % (D - day) + 1;
contest = ans[day];
change(day, ans[day + w]);
change(day + w, contest);
if (curscore < prevscore) {
change(day + w, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | replace | 142 | 144 | 142 | 144 | -8 | |
p02618 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef double lldo;
#define mp make_pair
#define pub push_back
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
ll gcd(ll a, ll b) {
if (a % b == 0) {
return b;
} else
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
if (a == 0) {
return b;
}
return a / gcd(a, b) * b;
}
template <class T> ll LBI(vector<T> &ar, T in) {
return lower_bound(ar.begin(), ar.end(), in) - ar.begin();
}
template <class T> ll UBI(vector<T> &ar, T in) {
return upper_bound(ar.begin(), ar.end(), in) - ar.begin();
}
ll d, c[30] = {}, s[370][30] = {}, last[30] = {}, ans[370] = {};
int main() {
cin >> d;
rep(i, 26) cin >> c[i];
rep(i, d) { rep(j, 26) cin >> s[i][j]; }
rep(i, d) {
ll satisfaction = -1000000, contest = 0;
rep(j, 26) {
if (satisfaction < s[i][j] - c[i] * (i - last[j])) {
satisfaction = s[i][j] - c[i] * (i - last[j]);
contest = j;
}
ans[i] = contest;
last[contest] = i;
}
}
rep(i, d) cout << ans[i] + 1 << endl;
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef double lldo;
#define mp make_pair
#define pub push_back
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define sz(x) int(x.size())
ll gcd(ll a, ll b) {
if (a % b == 0) {
return b;
} else
return gcd(b, a % b);
}
ll lcm(ll a, ll b) {
if (a == 0) {
return b;
}
return a / gcd(a, b) * b;
}
template <class T> ll LBI(vector<T> &ar, T in) {
return lower_bound(ar.begin(), ar.end(), in) - ar.begin();
}
template <class T> ll UBI(vector<T> &ar, T in) {
return upper_bound(ar.begin(), ar.end(), in) - ar.begin();
}
ll d, c[30] = {}, s[370][30] = {}, last[30] = {}, ans[370] = {};
int main() {
cin >> d;
rep(i, 26) cin >> c[i];
rep(i, d) { rep(j, 26) cin >> s[i][j]; }
rep(i, d) {
ll satisfaction = -1000000, contest = 0;
rep(j, 26) {
if (satisfaction < s[i][j] - c[j] * (i - last[j])) {
satisfaction = s[i][j] - c[j] * (i - last[j]);
contest = j;
}
ans[i] = contest;
last[contest] = i;
}
}
rep(i, d) cout << ans[i] + 1 << endl;
return 0;
} | replace | 51 | 53 | 51 | 53 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
typedef vector<ll> VI;
typedef vector<VI> VVI;
const ll MOD = 1000000007;
const ll INF = 4611686018427387903;
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()
const int w = 18;
const int k = 350;
const int n = 26;
int d;
VI c(n);
VVI s(365, VI(n));
struct st {
VI a;
ll score;
bool operator<(const st &another) const { return score < another.score; };
};
vector<st> f(st p) {
VI a = p.a;
ll score = p.score;
int now = a.size() + 1;
VI last(n, 0);
REP(i, a.size())
last[a[i]] = i + 1;
VI down(n);
ll downsum = 0;
REP(i, n) {
down[i] = c[i] * (now - last[i]);
downsum += down[i];
}
a.push_back(-1);
vector<st> tmp;
REP(i, n) {
a[now - 1] = i;
tmp.push_back({a, score - downsum + down[i] + s[now - 1][i]});
}
sort(ALL(tmp));
vector<st> ret;
REP(i, w)
ret.push_back(tmp[n - 1 - i]);
return ret;
}
int main() {
cin >> d;
REP(i, n) cin >> c[i];
REP(i, d) REP(j, n) cin >> s[i][j];
priority_queue<st> q;
VI a(0);
q.push({a, 0});
REP(i, d) {
priority_queue<st> next;
REP(j, k) {
if (q.empty())
break;
for (auto nx : f(q.top()))
next.push(nx);
q.pop();
}
q = next;
}
REP(i, d)
cout << q.top().a[i] + 1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
typedef vector<ll> VI;
typedef vector<VI> VVI;
const ll MOD = 1000000007;
const ll INF = 4611686018427387903;
#define REP(i, n) for (int i = 0; i < n; i++)
#define ALL(v) v.begin(), v.end()
const int w = 13;
const int k = 300;
const int n = 26;
int d;
VI c(n);
VVI s(365, VI(n));
struct st {
VI a;
ll score;
bool operator<(const st &another) const { return score < another.score; };
};
vector<st> f(st p) {
VI a = p.a;
ll score = p.score;
int now = a.size() + 1;
VI last(n, 0);
REP(i, a.size())
last[a[i]] = i + 1;
VI down(n);
ll downsum = 0;
REP(i, n) {
down[i] = c[i] * (now - last[i]);
downsum += down[i];
}
a.push_back(-1);
vector<st> tmp;
REP(i, n) {
a[now - 1] = i;
tmp.push_back({a, score - downsum + down[i] + s[now - 1][i]});
}
sort(ALL(tmp));
vector<st> ret;
REP(i, w)
ret.push_back(tmp[n - 1 - i]);
return ret;
}
int main() {
cin >> d;
REP(i, n) cin >> c[i];
REP(i, d) REP(j, n) cin >> s[i][j];
priority_queue<st> q;
VI a(0);
q.push({a, 0});
REP(i, d) {
priority_queue<st> next;
REP(j, k) {
if (q.empty())
break;
for (auto nx : f(q.top()))
next.push(nx);
q.pop();
}
q = next;
}
REP(i, d)
cout << q.top().a[i] + 1 << endl;
return 0;
} | replace | 11 | 13 | 11 | 13 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (ll(i) = (0); (i) < (n); ++i)
#define REV(i, n) for (ll(i) = (n)-1; (i) >= 0; --i)
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v, n) \
{ \
REP(WW, n) cerr << v[WW] << ' '; \
cerr << endl; \
}
#define SHOW2d(v, WW, HH) \
{ \
REP(W_, WW) { \
REP(H_, HH) cerr << v[W_][H_] << ' '; \
cerr << endl; \
} \
}
#define ALL(v) v.begin(), v.end()
#define Decimal fixed << setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
#define MOD 998244353
typedef long long ll;
typedef pair<ll, ll> P;
ll cal_score(vector<ll> &c, vector<vector<ll>> &s, vector<ll> v) {
ll score = 0;
ll n = v.size();
vector<ll> now(26);
REP(i, n) {
score += s[i][v[i]];
REP(j, 26) now[j]++;
now[v[i]] = 0;
REP(j, 26) score -= c[j] * now[j];
}
return score;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll d;
cin >> d;
vector<ll> c(26);
REP(i, 26) cin >> c[i];
vector<vector<ll>> s(d, vector<ll>(26));
REP(i, d) REP(j, 26) cin >> s[i][j];
vector<pair<ll, vector<ll>>> lis;
REP(i, 26) lis.EB(cal_score(c, s, {i}), vector<ll>(1, i));
REP(i, d - 1) {
sort(ALL(lis), greater<pair<ll, vector<ll>>>());
lis.resize(min((ll)lis.size(), 1000LL));
vector<pair<ll, vector<ll>>> now;
for (auto seica : lis) {
REP(i, 26) {
vector<ll> tmp = seica.SE;
tmp.PB(i);
now.EB(cal_score(c, s, tmp), tmp);
}
}
lis = now;
}
sort(ALL(lis), greater<pair<ll, vector<ll>>>());
REP(i, d) { cout << (lis[0].SE[i] + 1) << endl; }
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (ll(i) = (0); (i) < (n); ++i)
#define REV(i, n) for (ll(i) = (n)-1; (i) >= 0; --i)
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v, n) \
{ \
REP(WW, n) cerr << v[WW] << ' '; \
cerr << endl; \
}
#define SHOW2d(v, WW, HH) \
{ \
REP(W_, WW) { \
REP(H_, HH) cerr << v[W_][H_] << ' '; \
cerr << endl; \
} \
}
#define ALL(v) v.begin(), v.end()
#define Decimal fixed << setprecision(20)
#define INF 1000000000
#define LLINF 1000000000000000000LL
#define MOD 998244353
typedef long long ll;
typedef pair<ll, ll> P;
ll cal_score(vector<ll> &c, vector<vector<ll>> &s, vector<ll> v) {
ll score = 0;
ll n = v.size();
vector<ll> now(26);
REP(i, n) {
score += s[i][v[i]];
REP(j, 26) now[j]++;
now[v[i]] = 0;
REP(j, 26) score -= c[j] * now[j];
}
return score;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
ll d;
cin >> d;
vector<ll> c(26);
REP(i, 26) cin >> c[i];
vector<vector<ll>> s(d, vector<ll>(26));
REP(i, d) REP(j, 26) cin >> s[i][j];
vector<pair<ll, vector<ll>>> lis;
REP(i, 26) lis.EB(cal_score(c, s, {i}), vector<ll>(1, i));
REP(i, d - 1) {
sort(ALL(lis), greater<pair<ll, vector<ll>>>());
lis.resize(min((ll)lis.size(), 5LL));
vector<pair<ll, vector<ll>>> now;
for (auto seica : lis) {
REP(i, 26) {
vector<ll> tmp = seica.SE;
tmp.PB(i);
now.EB(cal_score(c, s, tmp), tmp);
}
}
lis = now;
}
sort(ALL(lis), greater<pair<ll, vector<ll>>>());
REP(i, d) { cout << (lis[0].SE[i] + 1) << endl; }
return 0;
}
| replace | 73 | 74 | 73 | 74 | TLE | |
p02618 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
std::random_device rd;
std::mt19937 mt(rd());
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
bool check(int diff, int time) {
if (diff < 0)
return true;
return mt() >= diff * (clock() - time);
}
int main() {
freopen("sample.txt", "r", stdin);
freopen("out.txt", "w", stdout);
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.98 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 4) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (!check(prevscore - curscore, time)) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
int w = mt() % (D - day) + 1;
contest = ans[day];
change(day, ans[day + w]);
change(day + w, contest);
if (!check(prevscore - curscore, time)) {
change(day + w, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
std::random_device rd;
std::mt19937 mt(rd());
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
bool check(int diff, int time) {
if (diff < 0)
return true;
return mt() >= diff * (clock() - time);
}
int main() {
// freopen("sample.txt","r",stdin);
// freopen("out.txt","w",stdout);
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.98 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 4) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (!check(prevscore - curscore, time)) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
int w = mt() % (D - day) + 1;
contest = ans[day];
change(day, ans[day + w]);
change(day + w, contest);
if (!check(prevscore - curscore, time)) {
change(day + w, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | replace | 149 | 151 | 149 | 151 | -8 | |
p02618 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
std::random_device rd;
std::mt19937 mt(rd());
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
bool check(int diff, int time) {
if (diff < 0)
return true;
return mt() >= diff * (clock() - time);
}
int main() {
freopen("sample.txt", "r", stdin);
freopen("out.txt", "w", stdout);
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.98 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 3) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (!check(prevscore - curscore, time)) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
int w = mt() % (D - day) + 1;
contest = ans[day];
change(day, ans[day + w]);
change(day + w, contest);
if (!check(prevscore - curscore, time)) {
change(day + w, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
std::random_device rd;
std::mt19937 mt(rd());
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
bool check(int diff, int time) {
if (diff < 0)
return true;
return mt() >= diff * (clock() - time);
}
int main() {
// freopen("sample.txt","r",stdin);
// freopen("out.txt","w",stdout);
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.98 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 3) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (!check(prevscore - curscore, time)) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
int w = mt() % (D - day) + 1;
contest = ans[day];
change(day, ans[day + w]);
change(day + w, contest);
if (!check(prevscore - curscore, time)) {
change(day + w, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | replace | 149 | 151 | 149 | 151 | -8 | |
p02618 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
std::random_device rd;
std::mt19937 mt(rd());
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
bool check(int diff, int time) {
if (diff < 0)
return true;
return mt() % 100000 >= diff * (clock() - time);
}
int main() {
freopen("sample.txt", "r", stdin);
freopen("out.txt", "w", stdout);
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.98 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 3) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (!check(prevscore - curscore, time)) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
int w = mt() % (D - day) + 1;
contest = ans[day];
change(day, ans[day + w]);
change(day + w, contest);
if (!check(prevscore - curscore, time)) {
change(day + w, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
std::random_device rd;
std::mt19937 mt(rd());
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
bool check(int diff, int time) {
if (diff < 0)
return true;
return mt() % 100000 >= diff * (clock() - time);
}
int main() {
// freopen("sample.txt","r",stdin);
// freopen("out.txt","w",stdout);
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.98 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 3) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (!check(prevscore - curscore, time)) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
int w = mt() % (D - day) + 1;
contest = ans[day];
change(day, ans[day + w]);
change(day + w, contest);
if (!check(prevscore - curscore, time)) {
change(day + w, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | replace | 149 | 151 | 149 | 151 | -8 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define m0(x) memset(x, -1, sizeof(x))
const int INF = 1e9 + 1;
const ll MOD = 1e9 + 7;
const double PI = 3.141592653589793;
const int MAX_N = 2e5;
int d, c[365], s[365][26], t[365], last[26], u;
void input() {
cin >> d;
rep(i, 26) cin >> c[i];
rep(i, d) {
rep(j, 26) { cin >> s[i][j]; }
}
rep(i, d) {
int k;
cin >> k;
k--;
t[i] = k;
}
fill(last, last + 26, 0);
}
int test(int k, int i) {
ll res = 0;
rep(j, 26) {
if (j == k)
continue;
res -= c[j] * last[j];
}
return res + s[i][k];
}
void greedy() {
rep(i, d) {
rep(i, 26) last[i]++;
int res = -INF;
rep(k, 26) {
if (res < test(k, i)) {
u = k;
res = test(k, i);
}
}
last[u] = 0;
t[i] = u;
}
}
int p_calc() {
ll res = 0;
int last[26];
fill(last, last + 26, 0);
rep(i, d) {
res += s[i][t[i]];
rep(i, 26) last[i]++;
last[t[i]] = 0;
rep(j, 26) { res -= c[j] * last[j]; }
}
return res;
}
int main() {
input();
greedy();
ll ans = p_calc();
rep(i, 1000000) {
int p = i % 365, q, tmp = t[p];
q = s[i % 365][i % 26] % 26;
t[p] = q;
if (ans > p_calc()) {
t[p] = tmp;
}
}
rep(i, d) cout << t[i] + 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define m0(x) memset(x, -1, sizeof(x))
const int INF = 1e9 + 1;
const ll MOD = 1e9 + 7;
const double PI = 3.141592653589793;
const int MAX_N = 2e5;
int d, c[365], s[365][26], t[365], last[26], u;
void input() {
cin >> d;
rep(i, 26) cin >> c[i];
rep(i, d) {
rep(j, 26) { cin >> s[i][j]; }
}
rep(i, d) {
int k;
cin >> k;
k--;
t[i] = k;
}
fill(last, last + 26, 0);
}
int test(int k, int i) {
ll res = 0;
rep(j, 26) {
if (j == k)
continue;
res -= c[j] * last[j];
}
return res + s[i][k];
}
void greedy() {
rep(i, d) {
rep(i, 26) last[i]++;
int res = -INF;
rep(k, 26) {
if (res < test(k, i)) {
u = k;
res = test(k, i);
}
}
last[u] = 0;
t[i] = u;
}
}
int p_calc() {
ll res = 0;
int last[26];
fill(last, last + 26, 0);
rep(i, d) {
res += s[i][t[i]];
rep(i, 26) last[i]++;
last[t[i]] = 0;
rep(j, 26) { res -= c[j] * last[j]; }
}
return res;
}
int main() {
input();
greedy();
ll ans = p_calc();
rep(i, 10000) {
int p = i % 365, q, tmp = t[p];
q = s[i % 365][i % 26] % 26;
t[p] = q;
if (ans > p_calc()) {
t[p] = tmp;
}
}
rep(i, d) cout << t[i] + 1 << endl;
}
| replace | 74 | 75 | 74 | 75 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
// #include <intrin.h> //AtCoder (gcc)
// 上ではこれがあると動かない。__popcnt用のincludeファイル。
using namespace std;
typedef long long ll;
typedef long double ld;
#define int long long
#define rep(i, n) for (long long i = 0; i < (n); i++)
#define sqrt(d) pow((long double)(d), 0.50)
#define PII pair<int, int>
#define MP make_pair
const int INF = 2000000000; // 2e9
const long long INF2 = 1000000000000000000; // 1e18
const long double pi = acos(-1);
const int large_P = 1000000007; // 1e9 + 7
// const int large_P = 1000000009; //1e9 + 9
// const int large_P = 998244353;
// 繰り返し2乗法
// N^aの、Mで割った余りを求める。
ll my_pow(ll N, ll a, ll M) {
ll tempo;
if (a == 0) {
return 1;
} else {
if (a % 2 == 0) {
tempo = my_pow(N, a / 2, M);
return (tempo * tempo) % M;
} else {
tempo = my_pow(N, a - 1, M);
return (tempo * N) % M;
}
}
}
// N_C_a を M で割った余り
ll my_combination(ll N, ll a, ll M) {
if (N < a)
return 0;
ll answer = 1;
rep(i, a) {
answer *= (N - i);
answer %= M;
}
rep(i, a) {
answer *= my_pow(i + 1, M - 2, M);
answer %= M;
}
return answer;
}
// N_C_i を M で割った余りを、v.at(i) に代入する。
void my_combination_table(ll N, ll M, vector<ll> &v) {
v.assign(N + 1, 1);
for (ll i = 1; i <= N; i++) {
v.at(i) = v.at(i - 1) * (N - (i - 1LL));
v.at(i) %= M;
v.at(i) *= my_pow(i, M - 2, M);
v.at(i) %= M;
}
}
// 階乗。x ! まで計算する。結果は dp に保存する。20 ! = 2.43e18 まで long long
// に入る。
ll factorial(ll x, vector<ll> &dp) {
if ((ll)dp.size() <= x) {
int n = dp.size();
rep(i, x + 1 - n) { dp.push_back(0); }
}
if (x == 0)
return dp.at(x) = 1;
if (dp.at(x) != -1 && dp.at(x) != 0)
return dp.at(x);
return dp.at(x) = x * factorial(x - 1, dp);
}
// 階乗の M で割った余り。x ! まで計算する。結果は dp に保存する。
ll factorial2(ll x, ll M, vector<ll> &dp) {
if ((ll)dp.size() <= x) {
int n = dp.size();
rep(i, x + 1 - n) { dp.push_back(0); }
}
if (x == 0)
return dp.at(x) = 1;
if (dp.at(x) != -1 && dp.at(x) != 0)
return dp.at(x);
return dp.at(x) = (x * factorial2(x - 1, M, dp)) % M;
}
// 階乗の mod M での逆元 (M: prime)。x ! まで計算する。結果は dp に保存する。
ll factorial_inverse(ll x, ll M, vector<ll> &dp) {
if ((ll)dp.size() <= x) {
int n = dp.size();
rep(i, x + 1 - n) { dp.push_back(0); }
}
if (x == 0)
return dp.at(x) = 1;
if (dp.at(x) != -1 && dp.at(x) != 0)
return dp.at(x);
return dp.at(x) = (my_pow(x, M - 2, M) * factorial_inverse(x - 1, M, dp)) % M;
}
// N_C_a を M で割った余り。何度も呼ぶ用。
ll my_combination2(ll N, ll a, ll M, vector<ll> &dp_factorial,
vector<ll> &dp_factorial_inverse) {
if ((ll)dp_factorial.size() <= N) {
factorial2(N, M, dp_factorial);
}
if ((ll)dp_factorial_inverse.size() <= N) {
factorial_inverse(N, M, dp_factorial_inverse);
}
if (N < a)
return 0;
ll answer = 1;
answer *= dp_factorial.at(N);
answer %= M;
answer *= dp_factorial_inverse.at(N - a);
answer %= M;
answer *= dp_factorial_inverse.at(a);
answer %= M;
return answer;
}
long long my_gcd(long long a, long long b) {
if (b == 0)
return a;
return my_gcd(b, a % b);
}
// ax + by = gcd(a, b) を解く。返り値は、gcd(a, b)。
long long my_gcd_extended(long long a, long long b, long long &x,
long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long tempo = my_gcd_extended(b, a % b, y, x);
// bx' + ry' = gcd(a, b) → (qb + r)x + by = gcd(a, b) に戻さないといけない。//
// (r = a % b) b(x' - qy') + (bq + r)y' = gcd(a, b) と同値変形できるから、
// x = y', y = x' - qy'
y -= (a / b) * x;
return tempo;
}
// base を底としたときの、n の i桁目を、v.at(i) に入れる。(桁数は n
// に応じて自動で設定する。)
void ll_to_vector(signed base, long long n, vector<signed> &v) {
long long tempo = n;
long long tempo2 = n;
signed n_digit = 1;
while (tempo2 >= base) {
tempo2 /= base;
n_digit++;
}
v.assign(n_digit, 0); // v のサイズを適切に調整する場合。
// n_digit = v.size(); // v のサイズをそのままにする場合。
for (signed i = 0; i < n_digit; i++) {
long long denominator = 1;
for (signed j = 0; j < n_digit - 1 - i; j++) {
denominator *= base;
}
v.at(i) = tempo / denominator;
tempo -= v.at(i) * denominator;
}
}
int char_to_int(char c) {
switch (c) {
case '0':
return 0;
case '1':
return 1;
case '2':
return 2;
case '3':
return 3;
case '4':
return 4;
case '5':
return 5;
case '6':
return 6;
case '7':
return 7;
case '8':
return 8;
case '9':
return 9;
default:
return 0;
}
}
// エラトステネスの篩で、prime で ないところに false を入れる。O(n loglog n)
void prime_judge(vector<bool> &prime_or_not) {
prime_or_not.assign(prime_or_not.size(), true);
prime_or_not.at(0) = false;
prime_or_not.at(1) = false;
long long n = prime_or_not.size() - 1;
for (long long i = 2; 2 * i <= n; i++) {
prime_or_not.at(2 * i) = false;
}
for (long long i = 3; i * i <= n; i += 2) {
// ここからは奇数のみ探索。i の倍数に false を入れる。
if (prime_or_not.at(i)) {
long long j =
i * i; // i^2 未満の i の倍数には、すでに false が入っているはず。
while (j < n + 1) {
prime_or_not.at(j) = false;
j += 2 * i;
}
}
}
};
// n + 1 の サイズの vector を返す。res.at(i) には、i の 1
// 以外で最小の約数を入れる。res.at(i) == i なら i は素数。 2e8 なら、3.2
// 秒程度で終わる。たぶん、prime_judge より 3倍弱遅い。
vector<long long> sieve(long long n) {
n++; // n まで判定する。配列サイズは +1。
vector<long long> res(n, 0);
for (long long i = 1; i < n; i++) {
if (i % 2 == 0)
res.at(i) = 2; // 偶数をあらかじめ処理。
else
res.at(i) = i;
}
for (long long i = 3; i * i < n; i += 2) {
// ここからは奇数のみ探索。i の倍数に i を入れる。
if (res.at(i) == i) {
long long j =
i * i; // i^2 未満の i の倍数には、すでに最小の約数が入っているはず。
while (j < n) {
if (res.at(j) == j)
res.at(j) = i;
j += 2 * i;
}
}
}
return res;
};
// O (sqrt(n)) で素数判定する用。
bool is_prime(long long N) {
if (N == 1 || N == 0)
return false;
if (N == 2 || N == 3)
return true;
if (N % 2 == 0)
return false;
if (N % 3 == 0)
return false;
for (long long i = 1; (6 * i + 1) * (6 * i + 1) <= N; ++i) {
if (N % (6 * i + 1) == 0)
return false;
}
for (long long i = 0; (6 * i + 5) * (6 * i + 5) <= N; ++i) {
if (N % (6 * i + 5) == 0)
return false;
}
return true;
}
// 素因数分解を O(sqrt(N)) で行うための関数。
map<ll, ll> divide_to_prime(int target) {
map<ll, ll> res;
// sqrt(target) まで調べる。
ll upper_lim = ceil(sqrt(target));
vector<bool> prime_or_not(upper_lim + 3, true);
if (upper_lim < 20)
prime_or_not.assign(25, true);
prime_or_not.at(0) = false;
prime_or_not.at(1) = false;
prime_judge(prime_or_not);
ll tempo = target;
for (int i = 1; i * i <= target; i++) {
if (prime_or_not.at(i)) {
while (tempo % i == 0) {
tempo /= i;
res[i]++;
}
}
if (tempo == 1)
break; // 別に必要はない。
}
if (tempo != 1)
res[tempo]++; // sqrt(target) より大きな素因数は高々1つしかない。
return res;
}
// 関数 sieve で得た、vector min_factor
// を持ってるときに、素因数分解を高速で行うための関数。
map<long long, long long> divide_to_prime2(long long target,
vector<long long> &min_factor) {
map<long long, long long> res;
if (min_factor.empty() || (long long)min_factor.size() - 1 < target)
min_factor = sieve(target);
while (target > 1) {
res[min_factor[target]]++;
target /= min_factor[target];
}
return res;
}
// 約数全列挙を O(sqrt(N)) で行うための関数。
vector<long long> count_dividers(long long target) {
vector<long long> dividers, tempo;
long long i = 1;
while (i * i < target + 1) {
if (target % i == 0) {
dividers.push_back(i);
if (i < target / i)
tempo.push_back(target / i); // if節がないと、平方数の時、sqrt(target)
// がダブルカウントされる。
}
i++;
}
for (long long j = 0; j < (long long)tempo.size(); j++) {
dividers.push_back(tempo.at(tempo.size() - 1 - j));
}
return dividers;
}
// 関数 sieve で得た、vector min_factor
// を持ってるときに、約数全列挙を高速で行うための関数。
vector<long long> count_dividers2(long long target,
vector<long long> &min_factor) {
vector<long long> dividers = {1};
map<long long, long long> memo = divide_to_prime2(target, min_factor);
for (auto &&iter = memo.begin(); iter != memo.end(); iter++) {
vector<long long> tempo = dividers;
for (long long k = 0; k < (long long)tempo.size(); k++) {
long long times = 1;
for (long long j = 1; j <= (iter->second); j++) {
times *= iter->first;
dividers.push_back(tempo[k] * times);
}
}
}
sort(
dividers.begin(),
dividers
.end()); // sortしないと小さい順に並ばないが、必要ないなら消しても良い。
return dividers;
}
void BFS_labyrinth(queue<pair<int, int>> &que, vector<vector<int>> &dist,
int &area) {
int n = dist.size();
int m = dist.at(0).size();
while (!que.empty()) {
int h, w;
pair<int, int> tempo = que.front();
que.pop();
h = tempo.first;
w = tempo.second;
// cout << temp_i << " " << temp_j << endl;
for (int dh = -1; dh <= 1; dh++) {
for (int dw = -1; dw <= 1; dw++) {
if (h + dh < 0 || n <= h + dh)
continue; // 範囲外
if (w + dw < 0 || m <= w + dw)
continue; // 範囲外
if (dh == 0 && dw == 0)
continue; // 動いていない
if (dh * dw != 0)
continue; // 右上など。八近傍の場合は消す。
if (dist.at(h + dh).at(w + dw) != -1)
continue; // 行けない領域に、既に INF
// などが代入されている場合はこの条件だけで ok
dist.at(h + dh).at(w + dw) = dist.at(h).at(w) + 1;
que.push(make_pair(h + dh, w + dw));
}
}
// 何か所も領域がある場合だけ必要
if (que.empty()) {
rep(i, n) {
rep(j, m) {
if (dist.at(i).at(j) == -1) {
que.push(make_pair(i, j));
dist.at(i).at(j) = 0;
area++;
break;
}
}
if (!que.empty())
break;
}
}
}
}
void BFS01_labyrinth(deque<pair<int, int>> &que, vector<vector<int>> &dist,
vector<vector<int>> &cost) {
int n = dist.size();
int m = dist.at(0).size();
while (!que.empty()) {
int h, w;
pair<int, int> tempo = que.front();
que.pop_front();
h = tempo.first;
w = tempo.second;
// cout << temp_i << " " << temp_j << endl;
for (int dh = -1; dh <= 1; dh++) {
for (int dw = -1; dw <= 1; dw++) {
if (h + dh < 0 || n <= h + dh)
continue; // 範囲外
if (w + dw < 0 || m <= w + dw)
continue; // 範囲外
if (dh == 0 && dw == 0)
continue; // 動いていない
if (dh * dw != 0)
continue; // 右上など。八近傍の場合は消す。
if (dist.at(h + dh).at(w + dw) != -1)
continue; // 行けない領域に、既に INF
// などが代入されている場合はこの条件だけで ok
dist.at(h + dh).at(w + dw) =
dist.at(h).at(w) + cost.at(h + dh).at(w + dw);
if (cost.at(h + dh).at(w + dw) == 0) { // コストが低い場合
que.push_front(make_pair(h + dh, w + dw));
} else { // コストが高い場合
que.push_back(make_pair(h + dh, w + dw));
}
}
}
}
}
void dfs(const vector<vector<int>> &G, vector<bool> &seen, int v) {
seen.at(v) = true;
for (int next_v : G.at(v)) {
if (seen.at(next_v))
continue;
dfs(G, seen, next_v);
}
}
class edge {
public:
int to;
int cost;
};
void dijkstra(int s, const vector<vector<edge>> G, vector<int> &dist) {
int V = dist.size(); // 頂点数
dist.assign(V, INF);
// first が最短距離、second が頂点番号。
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
que;
dist.at(s) = 0;
que.push(make_pair(0, s));
while (!que.empty()) {
pair<int, int> p = que.top();
que.pop();
int v = p.second;
if (dist.at(v) < p.first)
continue; // 最短距離がすでに更新されているので無視。
for (int i = 0; i < (int)G.at(v).size(); i++) {
edge e = G.at(v).at(i);
// for (auto&& e : G.at(v)) { // ← なぜか、やや遅いので。
if (dist.at(e.to) > dist.at(v) + e.cost) {
dist.at(e.to) = dist.at(v) + e.cost;
que.push(make_pair(dist.at(e.to), e.to));
}
}
}
}
const int Vmax2 = 1;
int dp_warshall[Vmax2][Vmax2];
// G.at(i).at(j) は i から j への移動コスト。隣接行列。
void warshall_floyd(int V, const vector<vector<int>> G) {
rep(i, V) {
rep(j, V) {
dp_warshall[i][j] = G.at(i).at(j); // 初期化
}
}
rep(k, V) {
rep(i, V) {
rep(j, V) {
dp_warshall[i][j] =
min(dp_warshall[i][j], dp_warshall[i][k] + dp_warshall[k][j]);
}
}
}
}
class UnionFind {
public:
vector<int> parent;
vector<int> rank;
UnionFind(int N) : parent(N), rank(N, 0) {
rep(i, N) { parent.at(i) = i; }
}
int root(int x) {
if (parent.at(x) == x)
return x;
return parent.at(x) = root(parent.at(x));
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry)
return; // xの根とyの根が同じなので、何もしない。
if (rank.at(rx) < rank.at(ry)) {
parent.at(rx) = ry;
} else {
parent.at(ry) = rx;
if (rank.at(rx) == rank.at(ry))
rank.at(rx)++;
}
}
bool same(int x, int y) { return (root(x) == root(y)); }
int count_tree() {
int N = parent.size();
int res = 0;
rep(i, N) {
if (root(i) == i)
res++;
}
return res;
}
};
class wUnionFind {
public:
vector<int> parent;
vector<int> diff_weight; // 親との差分。
vector<int> rank;
wUnionFind(int N) : parent(N), diff_weight(N, 0), rank(N, 0) {
rep(i, N) { parent.at(i) = i; }
}
int root(int x) {
if (parent.at(x) == x)
return x;
int r = root(parent.at(x));
diff_weight.at(x) += diff_weight.at(parent.at(x)); // 累積和
return parent.at(x) = r;
}
// x の重みを出力する関数。
int weight(int x) {
root(x);
return diff_weight.at(x);
}
// weight.at(y) - weight.at(x) == w となるようにする。
bool unite(int x, int y, int w) {
int rx = root(x);
int ry = root(y);
int diff_weight_to_ry_from_rx = w + weight(x) - weight(y);
if (rx == ry)
return false; // xの根とyの根が同じなので、何もしない。
if (rank.at(rx) < rank.at(ry)) {
parent.at(rx) = ry;
diff_weight.at(rx) = -diff_weight_to_ry_from_rx;
} else {
parent.at(ry) = rx;
diff_weight.at(ry) = diff_weight_to_ry_from_rx;
if (rank.at(rx) == rank.at(ry))
rank.at(rx)++;
}
return true;
}
bool same(int x, int y) { return (root(x) == root(y)); }
int count_tree() {
int N = parent.size();
int res = 0;
rep(i, N) {
if (root(i) == i)
res++;
}
return res;
}
};
class SegmentTree {
private:
int ini = INF;
public:
int Size;
vector<int> node;
SegmentTree(int N) : Size(N), node(N) {
int new_N = 1;
while (new_N < N)
new_N *= 2;
node.assign(2 * new_N - 1, ini);
Size = new_N;
}
SegmentTree(vector<int> v) : Size(v.size()), node(v.size()) {
int new_N = 1;
while (new_N < (int)v.size())
new_N *= 2;
node.assign(2 * new_N - 1, ini);
Size = new_N;
// 葉の初期化
for (int i = 0; i < (int)v.size(); i++)
node.at(Size - 1 + i) = v.at(i);
// 上りながら初期化
for (int i = Size - 2; i >= 0; i--)
node.at(i) = min(node.at(2 * i + 1), node.at(2 * i + 2));
}
// k 番目の値 (0-indexed) を x に変更する。
void update(int k, int x) {
// 葉のノードの番号 (等比数列の和の公式)
k += Size - 1;
node.at(k) = x;
// 上りながら更新 (0-indexedの場合、例えば、3 の子は、7, 8)
while (k > 0) {
k = (k - 1) / 2;
// 子の最小値を親の最小値とする。
node.at(k) = min(node.at(k * 2 + 1), node.at(k * 2 + 2));
}
}
//[a, b) の最小値を計算する。[l, r) は、ノード k に対応する区間を与える。
// query(a, b, 0, 0, size) で呼べばよい。
int query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return ini; // 交差しない。
if (a <= l && r <= b)
return node.at(k); // 完全に含む。
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr);
}
}
};
// 転倒数を返す (comp = less<int>() の場合)。
// comp = greater<int>() の場合は、N_C_2 - 転倒数 を返すことになる。
int my_merge(vector<int> &A, vector<int> &B, int left, int mid, int right,
function<bool(int, int)> comp) {
int i = left; // Aを分割したときの、左側の配列を差す配列。
int j = mid; // Bを分割したときの、左側の配列を差す配列。
int k = 0; // 分割した後の配列 (一時的に) B に保存。
int res = 0;
while (i < mid && j < right) {
if (comp(A.at(i), A.at(j)))
B.at(k++) = A.at(i++);
else {
B.at(k++) = A.at(j++);
res += mid - i;
}
}
// 左側をBに移動し尽くしたので、右側を順に入れていく。
if (i == mid) {
while (j < right) {
B.at(k++) = A.at(j++);
}
} else { // 右側をBに移動し尽くしたので、左側を順に入れていく。
while (i < mid) {
B.at(k++) = A.at(i++);
}
}
// Aに値を戻す。
rep(l, k) { A.at(left + l) = B.at(l); }
return res;
}
int my_merge_sort(vector<int> &target, vector<int> &tempo, int left, int right,
function<bool(int, int)> comp) {
int mid, res = 0;
if (left == right || left == right - 1)
return res;
mid = (left + right) / 2;
res += my_merge_sort(target, tempo, left, mid, comp);
res += my_merge_sort(target, tempo, mid, right, comp);
res += my_merge(target, tempo, left, mid, right, comp);
return res;
}
int satisfaction(vector<int> c, vector<vector<int>> s, vector<int> res) {
int D = s.size();
int now_satisfaction = 0;
vector<int> dist(26, 0);
rep(i, D) {
now_satisfaction += s.at(i).at(res.at(i));
rep(j, 26) {
if (j == res.at(i))
dist.at(j) = 0;
else
dist.at(j)++;
now_satisfaction -= c.at(j) * dist.at(j);
}
// B問題用
// cout << now_satisfaction << endl;
}
return now_satisfaction;
}
signed main() {
int D;
cin >> D;
vector<int> c(26);
rep(i, 26) cin >> c.at(i);
vector<vector<int>> s(D, vector<int>(26));
rep(i, D) {
rep(j, 26) { cin >> s.at(i).at(j); }
}
vector<int> dist(26, 0);
vector<vector<int>> dist_memo(D, vector<int>(26));
vector<int> res(D);
rep(i, D) {
vector<int> point(26, 0);
rep(j, 26) {
point.at(j) += s.at(i).at(j);
point.at(j) += c.at(j) * (dist.at(j) + 1);
}
int today = 0;
int tempo = point.at(0);
rep(j, 26) {
if (point.at(j) > tempo) {
tempo = point.at(j);
today = j;
}
}
res.at(i) = today;
}
// B問題用
// rep(i, D) {
// cin >> res.at(i);
// res.at(i)--;
//}
int now_satisfaction = satisfaction(c, s, res);
// cout << now_satisfaction << endl;
int times = 0;
while (times < 1e5) {
int target = times % D;
if (res.at(target) == 25)
res.at(target) = 0;
else
res.at(target)++;
int new_satisfaction = satisfaction(c, s, res);
if (new_satisfaction > now_satisfaction) {
now_satisfaction = new_satisfaction;
} else {
if (res.at(target) != 0)
res.at(target)--;
else
res.at(target) = 25;
}
times++;
}
rep(i, D) { cout << res.at(i) + 1 << endl; }
// cout << now_satisfaction << endl;
}
| #include "bits/stdc++.h"
// #include <intrin.h> //AtCoder (gcc)
// 上ではこれがあると動かない。__popcnt用のincludeファイル。
using namespace std;
typedef long long ll;
typedef long double ld;
#define int long long
#define rep(i, n) for (long long i = 0; i < (n); i++)
#define sqrt(d) pow((long double)(d), 0.50)
#define PII pair<int, int>
#define MP make_pair
const int INF = 2000000000; // 2e9
const long long INF2 = 1000000000000000000; // 1e18
const long double pi = acos(-1);
const int large_P = 1000000007; // 1e9 + 7
// const int large_P = 1000000009; //1e9 + 9
// const int large_P = 998244353;
// 繰り返し2乗法
// N^aの、Mで割った余りを求める。
ll my_pow(ll N, ll a, ll M) {
ll tempo;
if (a == 0) {
return 1;
} else {
if (a % 2 == 0) {
tempo = my_pow(N, a / 2, M);
return (tempo * tempo) % M;
} else {
tempo = my_pow(N, a - 1, M);
return (tempo * N) % M;
}
}
}
// N_C_a を M で割った余り
ll my_combination(ll N, ll a, ll M) {
if (N < a)
return 0;
ll answer = 1;
rep(i, a) {
answer *= (N - i);
answer %= M;
}
rep(i, a) {
answer *= my_pow(i + 1, M - 2, M);
answer %= M;
}
return answer;
}
// N_C_i を M で割った余りを、v.at(i) に代入する。
void my_combination_table(ll N, ll M, vector<ll> &v) {
v.assign(N + 1, 1);
for (ll i = 1; i <= N; i++) {
v.at(i) = v.at(i - 1) * (N - (i - 1LL));
v.at(i) %= M;
v.at(i) *= my_pow(i, M - 2, M);
v.at(i) %= M;
}
}
// 階乗。x ! まで計算する。結果は dp に保存する。20 ! = 2.43e18 まで long long
// に入る。
ll factorial(ll x, vector<ll> &dp) {
if ((ll)dp.size() <= x) {
int n = dp.size();
rep(i, x + 1 - n) { dp.push_back(0); }
}
if (x == 0)
return dp.at(x) = 1;
if (dp.at(x) != -1 && dp.at(x) != 0)
return dp.at(x);
return dp.at(x) = x * factorial(x - 1, dp);
}
// 階乗の M で割った余り。x ! まで計算する。結果は dp に保存する。
ll factorial2(ll x, ll M, vector<ll> &dp) {
if ((ll)dp.size() <= x) {
int n = dp.size();
rep(i, x + 1 - n) { dp.push_back(0); }
}
if (x == 0)
return dp.at(x) = 1;
if (dp.at(x) != -1 && dp.at(x) != 0)
return dp.at(x);
return dp.at(x) = (x * factorial2(x - 1, M, dp)) % M;
}
// 階乗の mod M での逆元 (M: prime)。x ! まで計算する。結果は dp に保存する。
ll factorial_inverse(ll x, ll M, vector<ll> &dp) {
if ((ll)dp.size() <= x) {
int n = dp.size();
rep(i, x + 1 - n) { dp.push_back(0); }
}
if (x == 0)
return dp.at(x) = 1;
if (dp.at(x) != -1 && dp.at(x) != 0)
return dp.at(x);
return dp.at(x) = (my_pow(x, M - 2, M) * factorial_inverse(x - 1, M, dp)) % M;
}
// N_C_a を M で割った余り。何度も呼ぶ用。
ll my_combination2(ll N, ll a, ll M, vector<ll> &dp_factorial,
vector<ll> &dp_factorial_inverse) {
if ((ll)dp_factorial.size() <= N) {
factorial2(N, M, dp_factorial);
}
if ((ll)dp_factorial_inverse.size() <= N) {
factorial_inverse(N, M, dp_factorial_inverse);
}
if (N < a)
return 0;
ll answer = 1;
answer *= dp_factorial.at(N);
answer %= M;
answer *= dp_factorial_inverse.at(N - a);
answer %= M;
answer *= dp_factorial_inverse.at(a);
answer %= M;
return answer;
}
long long my_gcd(long long a, long long b) {
if (b == 0)
return a;
return my_gcd(b, a % b);
}
// ax + by = gcd(a, b) を解く。返り値は、gcd(a, b)。
long long my_gcd_extended(long long a, long long b, long long &x,
long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long tempo = my_gcd_extended(b, a % b, y, x);
// bx' + ry' = gcd(a, b) → (qb + r)x + by = gcd(a, b) に戻さないといけない。//
// (r = a % b) b(x' - qy') + (bq + r)y' = gcd(a, b) と同値変形できるから、
// x = y', y = x' - qy'
y -= (a / b) * x;
return tempo;
}
// base を底としたときの、n の i桁目を、v.at(i) に入れる。(桁数は n
// に応じて自動で設定する。)
void ll_to_vector(signed base, long long n, vector<signed> &v) {
long long tempo = n;
long long tempo2 = n;
signed n_digit = 1;
while (tempo2 >= base) {
tempo2 /= base;
n_digit++;
}
v.assign(n_digit, 0); // v のサイズを適切に調整する場合。
// n_digit = v.size(); // v のサイズをそのままにする場合。
for (signed i = 0; i < n_digit; i++) {
long long denominator = 1;
for (signed j = 0; j < n_digit - 1 - i; j++) {
denominator *= base;
}
v.at(i) = tempo / denominator;
tempo -= v.at(i) * denominator;
}
}
int char_to_int(char c) {
switch (c) {
case '0':
return 0;
case '1':
return 1;
case '2':
return 2;
case '3':
return 3;
case '4':
return 4;
case '5':
return 5;
case '6':
return 6;
case '7':
return 7;
case '8':
return 8;
case '9':
return 9;
default:
return 0;
}
}
// エラトステネスの篩で、prime で ないところに false を入れる。O(n loglog n)
void prime_judge(vector<bool> &prime_or_not) {
prime_or_not.assign(prime_or_not.size(), true);
prime_or_not.at(0) = false;
prime_or_not.at(1) = false;
long long n = prime_or_not.size() - 1;
for (long long i = 2; 2 * i <= n; i++) {
prime_or_not.at(2 * i) = false;
}
for (long long i = 3; i * i <= n; i += 2) {
// ここからは奇数のみ探索。i の倍数に false を入れる。
if (prime_or_not.at(i)) {
long long j =
i * i; // i^2 未満の i の倍数には、すでに false が入っているはず。
while (j < n + 1) {
prime_or_not.at(j) = false;
j += 2 * i;
}
}
}
};
// n + 1 の サイズの vector を返す。res.at(i) には、i の 1
// 以外で最小の約数を入れる。res.at(i) == i なら i は素数。 2e8 なら、3.2
// 秒程度で終わる。たぶん、prime_judge より 3倍弱遅い。
vector<long long> sieve(long long n) {
n++; // n まで判定する。配列サイズは +1。
vector<long long> res(n, 0);
for (long long i = 1; i < n; i++) {
if (i % 2 == 0)
res.at(i) = 2; // 偶数をあらかじめ処理。
else
res.at(i) = i;
}
for (long long i = 3; i * i < n; i += 2) {
// ここからは奇数のみ探索。i の倍数に i を入れる。
if (res.at(i) == i) {
long long j =
i * i; // i^2 未満の i の倍数には、すでに最小の約数が入っているはず。
while (j < n) {
if (res.at(j) == j)
res.at(j) = i;
j += 2 * i;
}
}
}
return res;
};
// O (sqrt(n)) で素数判定する用。
bool is_prime(long long N) {
if (N == 1 || N == 0)
return false;
if (N == 2 || N == 3)
return true;
if (N % 2 == 0)
return false;
if (N % 3 == 0)
return false;
for (long long i = 1; (6 * i + 1) * (6 * i + 1) <= N; ++i) {
if (N % (6 * i + 1) == 0)
return false;
}
for (long long i = 0; (6 * i + 5) * (6 * i + 5) <= N; ++i) {
if (N % (6 * i + 5) == 0)
return false;
}
return true;
}
// 素因数分解を O(sqrt(N)) で行うための関数。
map<ll, ll> divide_to_prime(int target) {
map<ll, ll> res;
// sqrt(target) まで調べる。
ll upper_lim = ceil(sqrt(target));
vector<bool> prime_or_not(upper_lim + 3, true);
if (upper_lim < 20)
prime_or_not.assign(25, true);
prime_or_not.at(0) = false;
prime_or_not.at(1) = false;
prime_judge(prime_or_not);
ll tempo = target;
for (int i = 1; i * i <= target; i++) {
if (prime_or_not.at(i)) {
while (tempo % i == 0) {
tempo /= i;
res[i]++;
}
}
if (tempo == 1)
break; // 別に必要はない。
}
if (tempo != 1)
res[tempo]++; // sqrt(target) より大きな素因数は高々1つしかない。
return res;
}
// 関数 sieve で得た、vector min_factor
// を持ってるときに、素因数分解を高速で行うための関数。
map<long long, long long> divide_to_prime2(long long target,
vector<long long> &min_factor) {
map<long long, long long> res;
if (min_factor.empty() || (long long)min_factor.size() - 1 < target)
min_factor = sieve(target);
while (target > 1) {
res[min_factor[target]]++;
target /= min_factor[target];
}
return res;
}
// 約数全列挙を O(sqrt(N)) で行うための関数。
vector<long long> count_dividers(long long target) {
vector<long long> dividers, tempo;
long long i = 1;
while (i * i < target + 1) {
if (target % i == 0) {
dividers.push_back(i);
if (i < target / i)
tempo.push_back(target / i); // if節がないと、平方数の時、sqrt(target)
// がダブルカウントされる。
}
i++;
}
for (long long j = 0; j < (long long)tempo.size(); j++) {
dividers.push_back(tempo.at(tempo.size() - 1 - j));
}
return dividers;
}
// 関数 sieve で得た、vector min_factor
// を持ってるときに、約数全列挙を高速で行うための関数。
vector<long long> count_dividers2(long long target,
vector<long long> &min_factor) {
vector<long long> dividers = {1};
map<long long, long long> memo = divide_to_prime2(target, min_factor);
for (auto &&iter = memo.begin(); iter != memo.end(); iter++) {
vector<long long> tempo = dividers;
for (long long k = 0; k < (long long)tempo.size(); k++) {
long long times = 1;
for (long long j = 1; j <= (iter->second); j++) {
times *= iter->first;
dividers.push_back(tempo[k] * times);
}
}
}
sort(
dividers.begin(),
dividers
.end()); // sortしないと小さい順に並ばないが、必要ないなら消しても良い。
return dividers;
}
void BFS_labyrinth(queue<pair<int, int>> &que, vector<vector<int>> &dist,
int &area) {
int n = dist.size();
int m = dist.at(0).size();
while (!que.empty()) {
int h, w;
pair<int, int> tempo = que.front();
que.pop();
h = tempo.first;
w = tempo.second;
// cout << temp_i << " " << temp_j << endl;
for (int dh = -1; dh <= 1; dh++) {
for (int dw = -1; dw <= 1; dw++) {
if (h + dh < 0 || n <= h + dh)
continue; // 範囲外
if (w + dw < 0 || m <= w + dw)
continue; // 範囲外
if (dh == 0 && dw == 0)
continue; // 動いていない
if (dh * dw != 0)
continue; // 右上など。八近傍の場合は消す。
if (dist.at(h + dh).at(w + dw) != -1)
continue; // 行けない領域に、既に INF
// などが代入されている場合はこの条件だけで ok
dist.at(h + dh).at(w + dw) = dist.at(h).at(w) + 1;
que.push(make_pair(h + dh, w + dw));
}
}
// 何か所も領域がある場合だけ必要
if (que.empty()) {
rep(i, n) {
rep(j, m) {
if (dist.at(i).at(j) == -1) {
que.push(make_pair(i, j));
dist.at(i).at(j) = 0;
area++;
break;
}
}
if (!que.empty())
break;
}
}
}
}
void BFS01_labyrinth(deque<pair<int, int>> &que, vector<vector<int>> &dist,
vector<vector<int>> &cost) {
int n = dist.size();
int m = dist.at(0).size();
while (!que.empty()) {
int h, w;
pair<int, int> tempo = que.front();
que.pop_front();
h = tempo.first;
w = tempo.second;
// cout << temp_i << " " << temp_j << endl;
for (int dh = -1; dh <= 1; dh++) {
for (int dw = -1; dw <= 1; dw++) {
if (h + dh < 0 || n <= h + dh)
continue; // 範囲外
if (w + dw < 0 || m <= w + dw)
continue; // 範囲外
if (dh == 0 && dw == 0)
continue; // 動いていない
if (dh * dw != 0)
continue; // 右上など。八近傍の場合は消す。
if (dist.at(h + dh).at(w + dw) != -1)
continue; // 行けない領域に、既に INF
// などが代入されている場合はこの条件だけで ok
dist.at(h + dh).at(w + dw) =
dist.at(h).at(w) + cost.at(h + dh).at(w + dw);
if (cost.at(h + dh).at(w + dw) == 0) { // コストが低い場合
que.push_front(make_pair(h + dh, w + dw));
} else { // コストが高い場合
que.push_back(make_pair(h + dh, w + dw));
}
}
}
}
}
void dfs(const vector<vector<int>> &G, vector<bool> &seen, int v) {
seen.at(v) = true;
for (int next_v : G.at(v)) {
if (seen.at(next_v))
continue;
dfs(G, seen, next_v);
}
}
class edge {
public:
int to;
int cost;
};
void dijkstra(int s, const vector<vector<edge>> G, vector<int> &dist) {
int V = dist.size(); // 頂点数
dist.assign(V, INF);
// first が最短距離、second が頂点番号。
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
que;
dist.at(s) = 0;
que.push(make_pair(0, s));
while (!que.empty()) {
pair<int, int> p = que.top();
que.pop();
int v = p.second;
if (dist.at(v) < p.first)
continue; // 最短距離がすでに更新されているので無視。
for (int i = 0; i < (int)G.at(v).size(); i++) {
edge e = G.at(v).at(i);
// for (auto&& e : G.at(v)) { // ← なぜか、やや遅いので。
if (dist.at(e.to) > dist.at(v) + e.cost) {
dist.at(e.to) = dist.at(v) + e.cost;
que.push(make_pair(dist.at(e.to), e.to));
}
}
}
}
const int Vmax2 = 1;
int dp_warshall[Vmax2][Vmax2];
// G.at(i).at(j) は i から j への移動コスト。隣接行列。
void warshall_floyd(int V, const vector<vector<int>> G) {
rep(i, V) {
rep(j, V) {
dp_warshall[i][j] = G.at(i).at(j); // 初期化
}
}
rep(k, V) {
rep(i, V) {
rep(j, V) {
dp_warshall[i][j] =
min(dp_warshall[i][j], dp_warshall[i][k] + dp_warshall[k][j]);
}
}
}
}
class UnionFind {
public:
vector<int> parent;
vector<int> rank;
UnionFind(int N) : parent(N), rank(N, 0) {
rep(i, N) { parent.at(i) = i; }
}
int root(int x) {
if (parent.at(x) == x)
return x;
return parent.at(x) = root(parent.at(x));
}
void unite(int x, int y) {
int rx = root(x);
int ry = root(y);
if (rx == ry)
return; // xの根とyの根が同じなので、何もしない。
if (rank.at(rx) < rank.at(ry)) {
parent.at(rx) = ry;
} else {
parent.at(ry) = rx;
if (rank.at(rx) == rank.at(ry))
rank.at(rx)++;
}
}
bool same(int x, int y) { return (root(x) == root(y)); }
int count_tree() {
int N = parent.size();
int res = 0;
rep(i, N) {
if (root(i) == i)
res++;
}
return res;
}
};
class wUnionFind {
public:
vector<int> parent;
vector<int> diff_weight; // 親との差分。
vector<int> rank;
wUnionFind(int N) : parent(N), diff_weight(N, 0), rank(N, 0) {
rep(i, N) { parent.at(i) = i; }
}
int root(int x) {
if (parent.at(x) == x)
return x;
int r = root(parent.at(x));
diff_weight.at(x) += diff_weight.at(parent.at(x)); // 累積和
return parent.at(x) = r;
}
// x の重みを出力する関数。
int weight(int x) {
root(x);
return diff_weight.at(x);
}
// weight.at(y) - weight.at(x) == w となるようにする。
bool unite(int x, int y, int w) {
int rx = root(x);
int ry = root(y);
int diff_weight_to_ry_from_rx = w + weight(x) - weight(y);
if (rx == ry)
return false; // xの根とyの根が同じなので、何もしない。
if (rank.at(rx) < rank.at(ry)) {
parent.at(rx) = ry;
diff_weight.at(rx) = -diff_weight_to_ry_from_rx;
} else {
parent.at(ry) = rx;
diff_weight.at(ry) = diff_weight_to_ry_from_rx;
if (rank.at(rx) == rank.at(ry))
rank.at(rx)++;
}
return true;
}
bool same(int x, int y) { return (root(x) == root(y)); }
int count_tree() {
int N = parent.size();
int res = 0;
rep(i, N) {
if (root(i) == i)
res++;
}
return res;
}
};
class SegmentTree {
private:
int ini = INF;
public:
int Size;
vector<int> node;
SegmentTree(int N) : Size(N), node(N) {
int new_N = 1;
while (new_N < N)
new_N *= 2;
node.assign(2 * new_N - 1, ini);
Size = new_N;
}
SegmentTree(vector<int> v) : Size(v.size()), node(v.size()) {
int new_N = 1;
while (new_N < (int)v.size())
new_N *= 2;
node.assign(2 * new_N - 1, ini);
Size = new_N;
// 葉の初期化
for (int i = 0; i < (int)v.size(); i++)
node.at(Size - 1 + i) = v.at(i);
// 上りながら初期化
for (int i = Size - 2; i >= 0; i--)
node.at(i) = min(node.at(2 * i + 1), node.at(2 * i + 2));
}
// k 番目の値 (0-indexed) を x に変更する。
void update(int k, int x) {
// 葉のノードの番号 (等比数列の和の公式)
k += Size - 1;
node.at(k) = x;
// 上りながら更新 (0-indexedの場合、例えば、3 の子は、7, 8)
while (k > 0) {
k = (k - 1) / 2;
// 子の最小値を親の最小値とする。
node.at(k) = min(node.at(k * 2 + 1), node.at(k * 2 + 2));
}
}
//[a, b) の最小値を計算する。[l, r) は、ノード k に対応する区間を与える。
// query(a, b, 0, 0, size) で呼べばよい。
int query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return ini; // 交差しない。
if (a <= l && r <= b)
return node.at(k); // 完全に含む。
else {
int vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
int vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr);
}
}
};
// 転倒数を返す (comp = less<int>() の場合)。
// comp = greater<int>() の場合は、N_C_2 - 転倒数 を返すことになる。
int my_merge(vector<int> &A, vector<int> &B, int left, int mid, int right,
function<bool(int, int)> comp) {
int i = left; // Aを分割したときの、左側の配列を差す配列。
int j = mid; // Bを分割したときの、左側の配列を差す配列。
int k = 0; // 分割した後の配列 (一時的に) B に保存。
int res = 0;
while (i < mid && j < right) {
if (comp(A.at(i), A.at(j)))
B.at(k++) = A.at(i++);
else {
B.at(k++) = A.at(j++);
res += mid - i;
}
}
// 左側をBに移動し尽くしたので、右側を順に入れていく。
if (i == mid) {
while (j < right) {
B.at(k++) = A.at(j++);
}
} else { // 右側をBに移動し尽くしたので、左側を順に入れていく。
while (i < mid) {
B.at(k++) = A.at(i++);
}
}
// Aに値を戻す。
rep(l, k) { A.at(left + l) = B.at(l); }
return res;
}
int my_merge_sort(vector<int> &target, vector<int> &tempo, int left, int right,
function<bool(int, int)> comp) {
int mid, res = 0;
if (left == right || left == right - 1)
return res;
mid = (left + right) / 2;
res += my_merge_sort(target, tempo, left, mid, comp);
res += my_merge_sort(target, tempo, mid, right, comp);
res += my_merge(target, tempo, left, mid, right, comp);
return res;
}
int satisfaction(vector<int> c, vector<vector<int>> s, vector<int> res) {
int D = s.size();
int now_satisfaction = 0;
vector<int> dist(26, 0);
rep(i, D) {
now_satisfaction += s.at(i).at(res.at(i));
rep(j, 26) {
if (j == res.at(i))
dist.at(j) = 0;
else
dist.at(j)++;
now_satisfaction -= c.at(j) * dist.at(j);
}
// B問題用
// cout << now_satisfaction << endl;
}
return now_satisfaction;
}
signed main() {
int D;
cin >> D;
vector<int> c(26);
rep(i, 26) cin >> c.at(i);
vector<vector<int>> s(D, vector<int>(26));
rep(i, D) {
rep(j, 26) { cin >> s.at(i).at(j); }
}
vector<int> dist(26, 0);
vector<vector<int>> dist_memo(D, vector<int>(26));
vector<int> res(D);
rep(i, D) {
vector<int> point(26, 0);
rep(j, 26) {
point.at(j) += s.at(i).at(j);
point.at(j) += c.at(j) * (dist.at(j) + 1);
}
int today = 0;
int tempo = point.at(0);
rep(j, 26) {
if (point.at(j) > tempo) {
tempo = point.at(j);
today = j;
}
}
res.at(i) = today;
}
// B問題用
// rep(i, D) {
// cin >> res.at(i);
// res.at(i)--;
//}
int now_satisfaction = satisfaction(c, s, res);
// cout << now_satisfaction << endl;
int times = 0;
while (times < 1e2) {
int target = times % D;
if (res.at(target) == 25)
res.at(target) = 0;
else
res.at(target)++;
int new_satisfaction = satisfaction(c, s, res);
if (new_satisfaction > now_satisfaction) {
now_satisfaction = new_satisfaction;
} else {
if (res.at(target) != 0)
res.at(target)--;
else
res.at(target) = 25;
}
times++;
}
rep(i, D) { cout << res.at(i) + 1 << endl; }
// cout << now_satisfaction << endl;
}
| replace | 841 | 842 | 841 | 842 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cassert>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
int xor64(void) {
static unsigned long long x = 88172645463325252ULL;
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
return int(x & 0x7fffffff);
}
int D;
vector<int> C;
vector<vector<int>> S;
struct State {
vector<int> T;
vector<set<int>> X;
long long score;
State() : T(D, -1), X(26, set<int>{-1, D}) {
score = 0;
for (int i = 0; i < 26; i++)
score -= (long long)C[i] * D * (D + 1) / 2;
}
void add(int d, int t) {
// assert(T[d]==-1);
// assert(X[t].count(d)==0);
auto p1 = X[t].lower_bound(d);
auto p0 = p1;
p0--;
score += (long long)C[t] * (d - *p0) * (*p1 - d);
score += S[d][t];
X[t].insert(d);
T[d] = t;
}
long long add_dry(int d, int t) {
auto p1 = X[t].lower_bound(d);
auto p0 = p1;
p0--;
return (long long)C[t] * (d - *p0) * (*p1 - d) + S[d][t];
}
void remove(int d) {
// assert(T[d]!=-1);
// assert(X[T[d]].count(d)>0);
int t = T[d];
auto p = X[t].find(d);
auto p0 = p;
p0--;
auto p1 = p;
p1++;
score -= (long long)C[t] * (d - *p0) * (*p1 - d);
score -= S[d][t];
X[t].erase(d);
T[d] = -1;
}
};
int main() {
//*
cin >> D;
C = vector<int>(26);
for (int &c : C)
cin >> c;
S = vector<vector<int>>(D, vector<int>(26));
for (auto &s : S)
for (auto &x : s)
cin >> x;
/*/
D = 365;
C = vector<int>(26);
for (int &c: C)
c = xor64()%101;
S = vector<vector<int>>(D, vector<int>(26));
for (auto &s: S)
for (auto &x: s)
x = xor64()%20001;
//*/
/*
cout<<D<<endl;
for (int c: C)
cout<<" "<<c;
cout<<endl;
for (auto s: S)
{
for (auto x: s)
cout<<" "<<x;
cout<<endl;
}
*/
long long best = -99999999;
vector<int> bestT;
for (int i = 0; i < 1; i++) {
State state;
for (int i = 0; i < D; i++)
state.add(i, xor64() % 26);
int R = 4000'000;
// int R = 200'000;
for (int i = 0; i < R; i++) {
if (i % 8 == 0) {
int d = xor64() % D;
state.remove(d);
long long m = state.add_dry(d, 0);
int mt = 0;
for (int t = 1; t < 26; t++) {
long long s = state.add_dry(d, t);
if (s > m) {
m = s;
mt = t;
}
}
state.add(d, mt);
} else {
int d0 = xor64() % D;
int d1;
while (true) {
// int d = max(1, 20*i/R);
int d = 7;
d1 = d0 + xor64() % (2 * d) - d;
if (0 <= d1 && d1 < D)
break;
}
if (state.T[d0] != state.T[d1]) {
long long score0 = state.score;
int t0 = state.T[d0];
int t1 = state.T[d1];
state.remove(d0);
state.remove(d1);
state.add(d0, t1);
state.add(d1, t0);
// if (state.score < score0 && xor64()%(R*8/10)<i)
if (state.score < score0 - xor64() % max(1, 10000 * (R - i) / R)) {
state.remove(d0);
state.remove(d1);
state.add(d0, t0);
state.add(d1, t1);
}
}
}
}
if (state.score > best) {
best = state.score;
bestT = state.T;
}
}
for (int t : bestT)
cout << t + 1 << endl;
cerr << best << endl;
}
| #include <algorithm>
#include <cassert>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
int xor64(void) {
static unsigned long long x = 88172645463325252ULL;
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
return int(x & 0x7fffffff);
}
int D;
vector<int> C;
vector<vector<int>> S;
struct State {
vector<int> T;
vector<set<int>> X;
long long score;
State() : T(D, -1), X(26, set<int>{-1, D}) {
score = 0;
for (int i = 0; i < 26; i++)
score -= (long long)C[i] * D * (D + 1) / 2;
}
void add(int d, int t) {
// assert(T[d]==-1);
// assert(X[t].count(d)==0);
auto p1 = X[t].lower_bound(d);
auto p0 = p1;
p0--;
score += (long long)C[t] * (d - *p0) * (*p1 - d);
score += S[d][t];
X[t].insert(d);
T[d] = t;
}
long long add_dry(int d, int t) {
auto p1 = X[t].lower_bound(d);
auto p0 = p1;
p0--;
return (long long)C[t] * (d - *p0) * (*p1 - d) + S[d][t];
}
void remove(int d) {
// assert(T[d]!=-1);
// assert(X[T[d]].count(d)>0);
int t = T[d];
auto p = X[t].find(d);
auto p0 = p;
p0--;
auto p1 = p;
p1++;
score -= (long long)C[t] * (d - *p0) * (*p1 - d);
score -= S[d][t];
X[t].erase(d);
T[d] = -1;
}
};
int main() {
//*
cin >> D;
C = vector<int>(26);
for (int &c : C)
cin >> c;
S = vector<vector<int>>(D, vector<int>(26));
for (auto &s : S)
for (auto &x : s)
cin >> x;
/*/
D = 365;
C = vector<int>(26);
for (int &c: C)
c = xor64()%101;
S = vector<vector<int>>(D, vector<int>(26));
for (auto &s: S)
for (auto &x: s)
x = xor64()%20001;
//*/
/*
cout<<D<<endl;
for (int c: C)
cout<<" "<<c;
cout<<endl;
for (auto s: S)
{
for (auto x: s)
cout<<" "<<x;
cout<<endl;
}
*/
long long best = -99999999;
vector<int> bestT;
for (int i = 0; i < 1; i++) {
State state;
for (int i = 0; i < D; i++)
state.add(i, xor64() % 26);
int R = 3500'000;
// int R = 200'000;
for (int i = 0; i < R; i++) {
if (i % 8 == 0) {
int d = xor64() % D;
state.remove(d);
long long m = state.add_dry(d, 0);
int mt = 0;
for (int t = 1; t < 26; t++) {
long long s = state.add_dry(d, t);
if (s > m) {
m = s;
mt = t;
}
}
state.add(d, mt);
} else {
int d0 = xor64() % D;
int d1;
while (true) {
// int d = max(1, 20*i/R);
int d = 7;
d1 = d0 + xor64() % (2 * d) - d;
if (0 <= d1 && d1 < D)
break;
}
if (state.T[d0] != state.T[d1]) {
long long score0 = state.score;
int t0 = state.T[d0];
int t1 = state.T[d1];
state.remove(d0);
state.remove(d1);
state.add(d0, t1);
state.add(d1, t0);
// if (state.score < score0 && xor64()%(R*8/10)<i)
if (state.score < score0 - xor64() % max(1, 10000 * (R - i) / R)) {
state.remove(d0);
state.remove(d1);
state.add(d0, t0);
state.add(d1, t1);
}
}
}
}
if (state.score > best) {
best = state.score;
bestT = state.T;
}
}
for (int t : bestT)
cout << t + 1 << endl;
cerr << best << endl;
}
| replace | 109 | 110 | 109 | 110 | TLE | |
p02618 | Python | Runtime Error | import numpy as np
D = int(input())
Cs = list(map(int, input().split()))
Ss = []
for d in range(D):
s = list(map(int, input().split()))
Ss.append(s)
Ss = np.array(Ss)
solution = np.argmax(Ss, axis=1)
days_till_next = np.ones_like(Ss) * (D - 1) - np.arange(D).reshape((D, 1))
def update_days_till_next(d):
contest = solution[d]
for _d in range(d - 1, -1, -1):
if solution[_d] == contest or _d == 0:
days_till_next[_d:d, contest] -= days_till_next[d, contest]
break
for d in range(D - 1, -1, -1):
update_days_till_next(d)
for _ in range(10):
n_contests = len(Ss[0])
days_since_last = np.zeros(n_contests)
for d, i in enumerate(solution):
days_since_last += 1
new_scores = days_till_next[d] * days_since_last[d] * Cs + Ss[d]
new_i = new_scores.argmax()
days_since_last[new_i] = 0
if new_i != i:
solution[d] = new_i
update_days_till_next(d)
for s in solution:
print(s + 1)
| import numpy as np
D = int(input())
Cs = list(map(int, input().split()))
Ss = []
for d in range(D):
s = list(map(int, input().split()))
Ss.append(s)
Ss = np.array(Ss)
solution = np.argmax(Ss, axis=1)
#
# days_till_next = np.ones_like(Ss) * (D - 1) - np.arange(D).reshape((D, 1))
#
#
# def update_days_till_next(d):
# contest = solution[d]
# for _d in range(d - 1, -1, -1):
# if solution[_d] == contest or _d == 0:
# days_till_next[_d:d, contest] -= days_till_next[d, contest]
# break
#
#
# for d in range(D - 1, -1, -1):
# update_days_till_next(d)
#
# for _ in range(10):
# n_contests = len(Ss[0])
# days_since_last = np.zeros(n_contests)
# for d, i in enumerate(solution):
# days_since_last += 1
# new_scores = days_till_next[d] * days_since_last[d] * Cs + Ss[d]
# new_i = new_scores.argmax()
# days_since_last[new_i] = 0
# if new_i != i:
# solution[d] = new_i
# update_days_till_next(d)
#
for s in solution:
print(s + 1)
| replace | 12 | 39 | 12 | 39 | TLE | |
p02618 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
int main() {
freopen("sample.txt", "r", stdin);
// freopen("out.txt","w",stdout);
std::random_device rd;
std::mt19937 mt(rd());
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.97 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 2) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (curscore < prevscore) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
contest = ans[day];
change(day, ans[day + 1]);
change(day + 1, contest);
if (curscore < prevscore) {
change(day + 1, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
int main() {
// freopen("sample.txt","r",stdin);
// freopen("out.txt","w",stdout);
std::random_device rd;
std::mt19937 mt(rd());
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.97 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 2) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (curscore < prevscore) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
contest = ans[day];
change(day, ans[day + 1]);
change(day + 1, contest);
if (curscore < prevscore) {
change(day + 1, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | replace | 142 | 143 | 142 | 143 | -8 | |
p02618 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
int main() {
freopen("sample.txt", "r", stdin);
freopen("out.txt", "w", stdout);
std::random_device rd;
std::mt19937 mt(rd());
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.97 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 3) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (curscore < prevscore) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
contest = ans[day];
change(day, ans[day + 1]);
change(day + 1, contest);
if (curscore < prevscore) {
change(day + 1, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
int main() {
// freopen("sample.txt","r",stdin);
// freopen("out.txt","w",stdout);
std::random_device rd;
std::mt19937 mt(rd());
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.97 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 3) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (curscore < prevscore) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
contest = ans[day];
change(day, ans[day + 1]);
change(day + 1, contest);
if (curscore < prevscore) {
change(day + 1, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | replace | 142 | 144 | 142 | 144 | -8 | |
p02618 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
int main() {
freopen("sample.txt", "r", stdin);
freopen("out.txt", "w", stdout);
std::random_device rd;
std::mt19937 mt(rd());
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.97 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 4 == 0) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (curscore < prevscore) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
int w = mt() % (D - day) + 1;
contest = ans[day];
change(day, ans[day + w]);
change(day + w, contest);
if (curscore < prevscore) {
change(day + w, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
int main() {
// freopen("sample.txt","r",stdin);
// freopen("out.txt","w",stdout);
std::random_device rd;
std::mt19937 mt(rd());
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.97 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 4 == 0) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (curscore < prevscore) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
int w = mt() % (D - day) + 1;
contest = ans[day];
change(day, ans[day + w]);
change(day + w, contest);
if (curscore < prevscore) {
change(day + w, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | replace | 142 | 144 | 142 | 144 | -8 | |
p02618 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
int main() {
freopen("sample.txt", "r", stdin);
freopen("out.txt", "w", stdout);
std::random_device rd;
std::mt19937 mt(rd());
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.98 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 3) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (curscore < prevscore) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
int w = mt() % std::min(5, D - day) + 1;
contest = ans[day];
change(day, ans[day + w]);
change(day + w, contest);
if (curscore < prevscore) {
change(day + w, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
int main() {
// freopen("sample.txt","r",stdin);
// freopen("out.txt","w",stdout);
std::random_device rd;
std::mt19937 mt(rd());
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.98 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 3) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (curscore < prevscore) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
int w = mt() % std::min(5, D - day) + 1;
contest = ans[day];
change(day, ans[day + w]);
change(day + w, contest);
if (curscore < prevscore) {
change(day + w, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | replace | 142 | 144 | 142 | 144 | -8 | |
p02618 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
int main() {
freopen("sample.txt", "r", stdin);
freopen("out.txt", "w", stdout);
std::random_device rd;
std::mt19937 mt(rd());
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.98 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 3) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (curscore < prevscore) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
int w = mt() % std::min(12, D - day) + 1;
contest = ans[day];
change(day, ans[day + w]);
change(day + w, contest);
if (curscore < prevscore) {
change(day + w, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#pragma GCC target("avx")
#pragma GCC optimize("O3")
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define rep(i, n) for (int i = 0; i < (lint)(n); i++)
#define REP(i, n) for (int i = 1; i <= (lint)(n); i++)
#define all(V) V.begin(), V.end()
#define stackReplaceBegin(size) \
void *p = malloc(size); \
esp_new = (lint)p + size - 1; \
void *stack_extend_memory_ = malloc(size); \
void *stack_extend_origin_memory_; \
char *stack_extend_dummy_memory_ = (char *)alloca( \
(1 + (int)(((long long)stack_extend_memory_) & 127)) * 16); \
*stack_extend_dummy_memory_ = 0; \
asm volatile("mov %%rsp, %%rbx\nmov %%rax, %%rsp" \
: "=b"(stack_extend_origin_memory_) \
: "a"((char *)stack_extend_memory_ + (size)-1024));
typedef long long lint;
typedef unsigned long long ulint;
typedef std::pair<int, int> P;
constexpr int INF = INT_MAX / 2;
constexpr lint LINF = LLONG_MAX / 2;
constexpr double eps = DBL_EPSILON;
constexpr double PI = 3.141592653589793238462643383279;
lint esp_new;
template <class T>
class prique : public std::priority_queue<T, std::vector<T>, std::greater<T>> {
};
template <class T, class U> inline bool chmax(T &lhs, const U &rhs) {
if (lhs < rhs) {
lhs = rhs;
return 1;
}
return 0;
}
template <class T, class U> inline bool chmin(T &lhs, const U &rhs) {
if (lhs > rhs) {
lhs = rhs;
return 1;
}
return 0;
}
inline lint gcd(lint a, lint b) {
while (b) {
lint c = a;
a = b;
b = c % b;
}
return a;
}
inline lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
bool isprime(lint n) {
if (n == 1)
return false;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0)
return false;
}
return true;
}
template <typename T> T mypow(T a, unsigned int b) {
T res(1), now(a);
while (b) {
if (b & 1)
res *= now;
b >>= 1;
now *= now;
}
return res;
}
template <typename T> void printArray(std::vector<T> &vec) {
rep(i, vec.size() - 1) std::cout << vec[i] << " ";
std::cout << vec.back() << std::endl;
}
template <typename T> void printArray(T l, T r) {
T rprev = r;
rprev--;
for (T i = l; i != rprev; i++) {
std::cout << *i << " ";
}
std::cout << *rprev << std::endl;
}
int D, c[27], s[370][27], ans[370];
int curscore;
std::set<int> st[27];
void change(int day, int contest) {
int x;
curscore -= s[day][ans[day]];
curscore += s[day][contest];
auto l = *--st[ans[day]].lower_bound(day);
auto r = *st[ans[day]].upper_bound(day);
x = day - l;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - day;
curscore += c[ans[day]] * x * (x - 1) / 2;
x = r - l;
curscore -= c[ans[day]] * x * (x - 1) / 2;
l = *--st[contest].lower_bound(day);
r = *st[contest].upper_bound(day);
x = day - l;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - day;
curscore -= c[contest] * x * (x - 1) / 2;
x = r - l;
curscore += c[contest] * x * (x - 1) / 2;
st[ans[day]].erase(day);
st[contest].insert(day);
ans[day] = contest;
}
int main() {
// freopen("sample.txt","r",stdin);
// freopen("out.txt","w",stdout);
std::random_device rd;
std::mt19937 mt(rd());
scanf("%d", &D);
REP(i, 26) scanf("%d", c + i);
REP(i, D) { REP(j, 26) scanf("%d", &s[i][j]); }
REP(i, 26) {
st[i].insert(0);
st[i].insert(D + 1);
}
int last[27] = {};
REP(i, D) {
int max = -INF, cand;
REP(j, 26) {
int cnt = s[i][j];
REP(k, 26) {
if (j != k)
cnt -= c[k] * (i - last[k]);
}
if (chmax(max, cnt))
cand = j;
}
ans[i] = cand;
st[cand].insert(i);
last[cand] = i;
curscore += max;
}
time_t time = clock();
while ((clock() - time) <= 1.98 * CLOCKS_PER_SEC) {
int prevscore = curscore;
if (mt() % 3) {
int day, contest, prevcontest;
day = mt() % D + 1;
contest = mt() % 26 + 1;
prevcontest = ans[day];
change(day, contest);
if (curscore < prevscore) {
change(day, prevcontest);
}
} else {
int day = D, contest;
while (day == D)
day = mt() % D + 1;
int w = mt() % std::min(12, D - day) + 1;
contest = ans[day];
change(day, ans[day + w]);
change(day + w, contest);
if (curscore < prevscore) {
change(day + w, ans[day]);
change(day, contest);
}
}
}
REP(i, D) std::cout << ans[i] << std::endl;
// std::cout<<curscore<<std::endl;
return 0;
} | replace | 142 | 144 | 142 | 144 | -8 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> mp;
ll inf = 1e9;
#define N 26
#define iteration 100000
ll d, ansv, nowv;
vector<ll> c(N), ans, now;
vector<vector<ll>> s;
vector<ll> last(N, 0);
ll cost(vector<ll> &tmp) {
ll sum = 0;
for (ll i = 0; i < N; i++)
last[i] = 0;
for (ll i = 0; i < d; i++) {
sum += s[i][tmp[i]];
last[tmp[i]] = i + 1;
for (ll j = 0; j < N; j++)
sum -= (i + 1 - last[j]) * c[j];
}
return sum;
}
/*
ll cost(){
return cost(now);
}
*/
int main() {
cin >> d;
// ll c[N];
for (ll i = 0; i < N; i++)
cin >> c[i];
// ll s[d][N];
s = vector<vector<ll>>(d, vector<ll>(N));
for (ll i = 0; i < d; i++)
for (ll j = 0; j < N; j++)
cin >> s[i][j];
srand(time(NULL));
ansv = 0, nowv = 0;
ans = now = vector<ll>(d, 0);
for (ll i = 0; i < N; i++) {
vector<ll> tmp(d);
for (ll j = 0; j < N; j++)
tmp[j] = rand() % N;
ll tv = cost(tmp);
if (tv > nowv) {
ansv = nowv = tv;
ans = now = tmp;
}
}
ll Iteration = iteration;
while (Iteration) {
Iteration--;
if (rand() % 100 != 0) {
// 1-opt
ll day = rand() % d;
// vector<ll> tmp = now;
ll first = now[day];
ll fv = nowv;
ll T = 10;
for (ll t = 0; t < T; t++) {
ll i = rand() % N;
now[day] = i;
nowv = cost(now);
if (nowv < fv) {
if (nowv < ansv) {
ansv = nowv;
ans = now;
}
first = i;
fv = nowv;
}
}
nowv = fv;
now[day] = first;
} else {
ll t = rand() % 10;
for (ll i = 0; i < t; i++) {
now[rand() % d] = rand() % N;
}
nowv = cost(now);
if (nowv < ansv) {
ansv = nowv;
ans = now;
}
}
}
for (ll i = 0; i < d; i++)
cout << ans[i] + 1 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> mp;
ll inf = 1e9;
#define N 26
#define iteration 5000
ll d, ansv, nowv;
vector<ll> c(N), ans, now;
vector<vector<ll>> s;
vector<ll> last(N, 0);
ll cost(vector<ll> &tmp) {
ll sum = 0;
for (ll i = 0; i < N; i++)
last[i] = 0;
for (ll i = 0; i < d; i++) {
sum += s[i][tmp[i]];
last[tmp[i]] = i + 1;
for (ll j = 0; j < N; j++)
sum -= (i + 1 - last[j]) * c[j];
}
return sum;
}
/*
ll cost(){
return cost(now);
}
*/
int main() {
cin >> d;
// ll c[N];
for (ll i = 0; i < N; i++)
cin >> c[i];
// ll s[d][N];
s = vector<vector<ll>>(d, vector<ll>(N));
for (ll i = 0; i < d; i++)
for (ll j = 0; j < N; j++)
cin >> s[i][j];
srand(time(NULL));
ansv = 0, nowv = 0;
ans = now = vector<ll>(d, 0);
for (ll i = 0; i < N; i++) {
vector<ll> tmp(d);
for (ll j = 0; j < N; j++)
tmp[j] = rand() % N;
ll tv = cost(tmp);
if (tv > nowv) {
ansv = nowv = tv;
ans = now = tmp;
}
}
ll Iteration = iteration;
while (Iteration) {
Iteration--;
if (rand() % 100 != 0) {
// 1-opt
ll day = rand() % d;
// vector<ll> tmp = now;
ll first = now[day];
ll fv = nowv;
ll T = 10;
for (ll t = 0; t < T; t++) {
ll i = rand() % N;
now[day] = i;
nowv = cost(now);
if (nowv < fv) {
if (nowv < ansv) {
ansv = nowv;
ans = now;
}
first = i;
fv = nowv;
}
}
nowv = fv;
now[day] = first;
} else {
ll t = rand() % 10;
for (ll i = 0; i < t; i++) {
now[rand() % d] = rand() % N;
}
nowv = cost(now);
if (nowv < ansv) {
ansv = nowv;
ans = now;
}
}
}
for (ll i = 0; i < d; i++)
cout << ans[i] + 1 << endl;
return 0;
}
| replace | 6 | 7 | 6 | 7 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (long long i = 0; i < (n); i++)
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int D;
vector<int> c(26);
vector<vector<int>> s(365, vector<int>(26));
int cal_score(vector<int> t) {
vector<int> res(D);
int satis = 0;
vector<int> last(26, 0);
rep(d, D) {
satis += s[d][t[d] - 1];
last[t[d] - 1] = d + 1;
rep(i, 26) { satis -= c[i] * (d - last[i] + 1); }
res[d] = satis;
}
return res[D - 1];
}
int main() {
// input
cin >> D;
rep(i, 26) cin >> c[i];
rep(i, D) {
rep(j, 26) { cin >> s[i][j]; }
}
// greedy
vector<int> last(26, 0);
vector<int> res(D);
rep(d, D) {
int max_plus = -10000;
int use = -1;
rep(i, 26) {
int tmp = s[d][i] + c[i] * (d - last[i] + 1);
if (max_plus < tmp) {
max_plus = tmp;
use = i;
}
}
last[use] = d + 1;
res[d] = use + 1;
}
int cur_score = cal_score(res);
while (clock() / CLOCKS_PER_SEC <= 1.5) {
int ch_d = rand() % D + 1;
int ch_c = rand() % 26 + 1;
int old_c = res[ch_d - 1];
res[ch_d - 1] = ch_c;
int new_score = cal_score(res);
if (cur_score < new_score) {
cur_score = new_score;
} else {
res[ch_d - 1] = old_c;
}
}
rep(i, D) { cout << res[i] << endl; }
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (long long i = 0; i < (n); i++)
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int D;
vector<int> c(26);
vector<vector<int>> s(365, vector<int>(26));
int cal_score(vector<int> t) {
vector<int> res(D);
int satis = 0;
vector<int> last(26, 0);
rep(d, D) {
satis += s[d][t[d] - 1];
last[t[d] - 1] = d + 1;
rep(i, 26) { satis -= c[i] * (d - last[i] + 1); }
res[d] = satis;
}
return res[D - 1];
}
int main() {
// input
cin >> D;
rep(i, 26) cin >> c[i];
rep(i, D) {
rep(j, 26) { cin >> s[i][j]; }
}
// greedy
vector<int> last(26, 0);
vector<int> res(D);
rep(d, D) {
int max_plus = -10000;
int use = -1;
rep(i, 26) {
int tmp = s[d][i] + c[i] * (d - last[i] + 1);
if (max_plus < tmp) {
max_plus = tmp;
use = i;
}
}
last[use] = d + 1;
res[d] = use + 1;
}
int cur_score = cal_score(res);
while ((clock() / (double)CLOCKS_PER_SEC) < 1.5) {
int ch_d = rand() % D + 1;
int ch_c = rand() % 26 + 1;
int old_c = res[ch_d - 1];
res[ch_d - 1] = ch_c;
int new_score = cal_score(res);
if (cur_score < new_score) {
cur_score = new_score;
} else {
res[ch_d - 1] = old_c;
}
}
rep(i, D) { cout << res[i] << endl; }
return 0;
} | replace | 64 | 65 | 64 | 65 | TLE | |
p02618 | Python | Time Limit Exceeded | import sys
import numpy as np
from numba import njit
@njit("(i8[:],)", cache=True)
def solve(inp):
def bitree_sum(bit, t, i):
s = 0
while i > 0:
s += bit[t, i]
i ^= i & -i
return s
def bitree_add(bit, n, t, i, x):
while i <= n:
bit[t, i] += x
i += i & -i
def bitree_lower_bound(bit, n, d, t, x):
sum_ = 0
pos = 0
for i in range(d, -1, -1):
k = pos + (1 << i)
if k <= n and sum_ + bit[t, k] < x:
sum_ += bit[t, k]
pos += 1 << i
return pos + 1
def initial_score(d, ccc, sss):
bit_n = d + 3
bit = np.zeros((26, bit_n), dtype=np.int64)
INF = 10**18
for t in range(26):
bitree_add(bit, bit_n, t, bit_n - 1, INF)
ttt = np.zeros(d, dtype=np.int64)
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
best_t = 0
best_diff = -INF
costs = ccc * (i - last)
costs_sum = costs.sum()
for t in range(26):
tmp_diff = sss[i, t] - costs_sum + costs[t]
if best_diff < tmp_diff:
best_t = t
best_diff = tmp_diff
ttt[i] = best_t
last[best_t] = i
score += best_diff
bitree_add(bit, bit_n, best_t, i + 2, 1)
return bit, score, ttt
def calculate_score(d, ccc, sss, ttt):
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
t = ttt[i]
last[t] = i
score += sss[i, t] - (ccc * (i - last)).sum()
return score
def pinpoint_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible):
cd = np.random.randint(0, d)
ct = np.random.randint(0, 26)
while ttt[cd] == ct:
ct = np.random.randint(0, 26)
diff = 0
t = ttt[cd]
k = bitree_sum(bit, t, cd + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, t, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, t, k + 1) - 2
b = ccc[t]
diff -= b * (cd - c) * (e - cd)
diff -= sss[cd, t]
k = bitree_sum(bit, ct, cd + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct, k) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct, k + 1) - 2
b = ccc[ct]
diff += b * (cd - c) * (e - cd)
diff += sss[cd, ct]
if diff > permissible:
bitree_add(bit, bit_n, t, cd + 2, -1)
bitree_add(bit, bit_n, ct, cd + 2, 1)
ttt[cd] = ct
else:
diff = 0
return diff
def swap_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible):
cd1 = np.random.randint(0, d - 1)
cd2 = cd1 + 1
ct1 = ttt[cd1]
ct2 = ttt[cd2]
if ct1 == ct2:
return 0
diff = 0
k = bitree_sum(bit, ct1, cd1 + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct1, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct1, k + 1) - 2
diff += ccc[ct1] * (e + c - cd1 - cd2)
k = bitree_sum(bit, ct2, cd2 + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct2, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct2, k + 1) - 2
diff -= ccc[ct2] * (e + c - cd1 - cd2)
diff -= sss[cd1, ct1] + sss[cd2, ct2]
diff += sss[cd1, ct2] + sss[cd2, ct1]
if diff > permissible:
bitree_add(bit, bit_n, ct1, cd1 + 2, -1)
bitree_add(bit, bit_n, ct1, cd2 + 2, 1)
bitree_add(bit, bit_n, ct2, cd1 + 2, 1)
bitree_add(bit, bit_n, ct2, cd2 + 2, -1)
ttt[cd1] = ct2
ttt[cd2] = ct1
else:
diff = 0
return diff
d = inp[0]
ccc = inp[1:27]
sss = np.zeros((d, 26), dtype=np.int64)
for r in range(d):
sss[r] = inp[27 + r * 26 : 27 + (r + 1) * 26]
bit, score, ttt = initial_score(d, ccc, sss)
bit_n = d + 3
bit_d = int(np.log2(bit_n))
loop = 6 * 10**6
permissible_min = -3000.0
method_border = 0.5
best_score = score
best_ttt = ttt.copy()
for lp in range(loop):
permissible = (1 - lp / loop) * permissible_min
if np.random.random() < method_border:
diff = pinpoint_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible)
else:
diff = swap_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible)
score += diff
# print(lp, score, calculate_score(d, ccc, sss, ttt))
if score > best_score:
best_score = score
best_ttt = ttt.copy()
return best_ttt + 1
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=" ")
ans = solve(inp)
print("\n".join(map(str, ans)))
| import sys
import numpy as np
from numba import njit
@njit("(i8[:],)", cache=True)
def solve(inp):
def bitree_sum(bit, t, i):
s = 0
while i > 0:
s += bit[t, i]
i ^= i & -i
return s
def bitree_add(bit, n, t, i, x):
while i <= n:
bit[t, i] += x
i += i & -i
def bitree_lower_bound(bit, n, d, t, x):
sum_ = 0
pos = 0
for i in range(d, -1, -1):
k = pos + (1 << i)
if k <= n and sum_ + bit[t, k] < x:
sum_ += bit[t, k]
pos += 1 << i
return pos + 1
def initial_score(d, ccc, sss):
bit_n = d + 3
bit = np.zeros((26, bit_n), dtype=np.int64)
INF = 10**18
for t in range(26):
bitree_add(bit, bit_n, t, bit_n - 1, INF)
ttt = np.zeros(d, dtype=np.int64)
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
best_t = 0
best_diff = -INF
costs = ccc * (i - last)
costs_sum = costs.sum()
for t in range(26):
tmp_diff = sss[i, t] - costs_sum + costs[t]
if best_diff < tmp_diff:
best_t = t
best_diff = tmp_diff
ttt[i] = best_t
last[best_t] = i
score += best_diff
bitree_add(bit, bit_n, best_t, i + 2, 1)
return bit, score, ttt
def calculate_score(d, ccc, sss, ttt):
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
t = ttt[i]
last[t] = i
score += sss[i, t] - (ccc * (i - last)).sum()
return score
def pinpoint_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible):
cd = np.random.randint(0, d)
ct = np.random.randint(0, 26)
while ttt[cd] == ct:
ct = np.random.randint(0, 26)
diff = 0
t = ttt[cd]
k = bitree_sum(bit, t, cd + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, t, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, t, k + 1) - 2
b = ccc[t]
diff -= b * (cd - c) * (e - cd)
diff -= sss[cd, t]
k = bitree_sum(bit, ct, cd + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct, k) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct, k + 1) - 2
b = ccc[ct]
diff += b * (cd - c) * (e - cd)
diff += sss[cd, ct]
if diff > permissible:
bitree_add(bit, bit_n, t, cd + 2, -1)
bitree_add(bit, bit_n, ct, cd + 2, 1)
ttt[cd] = ct
else:
diff = 0
return diff
def swap_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible):
cd1 = np.random.randint(0, d - 1)
cd2 = cd1 + 1
ct1 = ttt[cd1]
ct2 = ttt[cd2]
if ct1 == ct2:
return 0
diff = 0
k = bitree_sum(bit, ct1, cd1 + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct1, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct1, k + 1) - 2
diff += ccc[ct1] * (e + c - cd1 - cd2)
k = bitree_sum(bit, ct2, cd2 + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, ct2, k - 1) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, ct2, k + 1) - 2
diff -= ccc[ct2] * (e + c - cd1 - cd2)
diff -= sss[cd1, ct1] + sss[cd2, ct2]
diff += sss[cd1, ct2] + sss[cd2, ct1]
if diff > permissible:
bitree_add(bit, bit_n, ct1, cd1 + 2, -1)
bitree_add(bit, bit_n, ct1, cd2 + 2, 1)
bitree_add(bit, bit_n, ct2, cd1 + 2, 1)
bitree_add(bit, bit_n, ct2, cd2 + 2, -1)
ttt[cd1] = ct2
ttt[cd2] = ct1
else:
diff = 0
return diff
d = inp[0]
ccc = inp[1:27]
sss = np.zeros((d, 26), dtype=np.int64)
for r in range(d):
sss[r] = inp[27 + r * 26 : 27 + (r + 1) * 26]
bit, score, ttt = initial_score(d, ccc, sss)
bit_n = d + 3
bit_d = int(np.log2(bit_n))
loop = 4 * 10**6
permissible_min = -3000.0
method_border = 0.5
best_score = score
best_ttt = ttt.copy()
for lp in range(loop):
permissible = (1 - lp / loop) * permissible_min
if np.random.random() < method_border:
diff = pinpoint_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible)
else:
diff = swap_change(bit, bit_n, bit_d, d, ccc, sss, ttt, permissible)
score += diff
# print(lp, score, calculate_score(d, ccc, sss, ttt))
if score > best_score:
best_score = score
best_ttt = ttt.copy()
return best_ttt + 1
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=" ")
ans = solve(inp)
print("\n".join(map(str, ans)))
| replace | 142 | 143 | 142 | 143 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int D;
cin >> D;
vector<int> c(26);
for (int &i : c)
cin >> i;
vector<vector<int>> s(D, vector<int>(26));
for (vector<int> &v : s)
for (int &i : v)
cin >> i;
vector<int> t(D);
vector<int> A(26, 0);
int mzint = 0;
for (int i = 0; i < D; i++) {
int mzi = mzint, mzin = 0, k;
for (int j = 0; j < 26; j++)
mzi -= (i + 1 - A[j]) * c[j];
for (int j = 0; j < 26; j++) {
int l = mzi + s[i][j] - (i + 1 - A[j]) * c[j];
if (l > mzin) {
k = j;
mzin = l;
}
}
A[k] = i + 1;
mzint = mzin;
t[i] = k + 1;
}
int M = 8000000, ans = mzint;
while (M--) {
vector<pair<int, int>> AAA = {make_pair(rand() % D, rand() % 26),
make_pair(rand() % D, rand() % 26)};
vector<int> BBB = {t[AAA[0].first], t[AAA[1].first]};
int ans2 = ans;
for (int aaa = 0; aaa < 2; aaa++) {
int d = AAA[aaa].first, q = AAA[aaa].second;
ans += s[d][q] - s[d][t[d] - 1];
int mae = -1, ato = D;
for (int i = d - 1; i >= 0; i--) {
if (t[i] == t[d]) {
mae = i;
break;
}
}
for (int i = d + 1; i < D; i++) {
if (t[i] == t[d]) {
ato = i;
break;
}
}
ans -= (ato - d) * (d - mae) * c[t[d] - 1];
mae = -1, ato = D;
for (int i = d; i >= 0; i--) {
if (t[i] == q + 1) {
mae = i;
break;
}
}
for (int i = d; i < D; i++) {
if (t[i] == q + 1) {
ato = i;
break;
}
}
ans += (ato - d) * (d - mae) * c[q];
t[d] = q + 1;
}
if (ans2 > ans) {
ans = ans2;
t[AAA[0].first] = BBB[0];
t[AAA[1].first] = BBB[1];
}
}
for (int i : t)
cout << i << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int D;
cin >> D;
vector<int> c(26);
for (int &i : c)
cin >> i;
vector<vector<int>> s(D, vector<int>(26));
for (vector<int> &v : s)
for (int &i : v)
cin >> i;
vector<int> t(D);
vector<int> A(26, 0);
int mzint = 0;
for (int i = 0; i < D; i++) {
int mzi = mzint, mzin = 0, k;
for (int j = 0; j < 26; j++)
mzi -= (i + 1 - A[j]) * c[j];
for (int j = 0; j < 26; j++) {
int l = mzi + s[i][j] - (i + 1 - A[j]) * c[j];
if (l > mzin) {
k = j;
mzin = l;
}
}
A[k] = i + 1;
mzint = mzin;
t[i] = k + 1;
}
int M = 7750000, ans = mzint;
while (M--) {
vector<pair<int, int>> AAA = {make_pair(rand() % D, rand() % 26),
make_pair(rand() % D, rand() % 26)};
vector<int> BBB = {t[AAA[0].first], t[AAA[1].first]};
int ans2 = ans;
for (int aaa = 0; aaa < 2; aaa++) {
int d = AAA[aaa].first, q = AAA[aaa].second;
ans += s[d][q] - s[d][t[d] - 1];
int mae = -1, ato = D;
for (int i = d - 1; i >= 0; i--) {
if (t[i] == t[d]) {
mae = i;
break;
}
}
for (int i = d + 1; i < D; i++) {
if (t[i] == t[d]) {
ato = i;
break;
}
}
ans -= (ato - d) * (d - mae) * c[t[d] - 1];
mae = -1, ato = D;
for (int i = d; i >= 0; i--) {
if (t[i] == q + 1) {
mae = i;
break;
}
}
for (int i = d; i < D; i++) {
if (t[i] == q + 1) {
ato = i;
break;
}
}
ans += (ato - d) * (d - mae) * c[q];
t[d] = q + 1;
}
if (ans2 > ans) {
ans = ans2;
t[AAA[0].first] = BBB[0];
t[AAA[1].first] = BBB[1];
}
}
for (int i : t)
cout << i << endl;
} | replace | 31 | 32 | 31 | 32 | TLE | |
p02618 | C++ | Time Limit Exceeded | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <bitset>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (auto i = a; i < b; i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x *= x;
p /= 2;
} else {
a *= x;
p--;
}
}
return a;
}
ll mpower(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x = x * x % mod;
p /= 2;
} else {
a = a * x % mod;
p--;
}
}
return a;
}
ll ac(ll n, ll k) {
ll a = 1;
rep(i, 1, k) {
a *= n - i + 1;
a /= i;
}
return a;
}
ll mc(ll n, ll m) {
ll k = 1, l = 1;
rep(i, n - m + 1, n + 1) k = k * i % mod;
rep(i, 1, m + 1) l = l * i % mod;
l = mpower(l, mod - 2);
return k * l % mod;
}
int D;
vector<int> c(26);
vector<int> last(26, 0);
vector<vector<int>> s(365, vector<int>(26));
void input();
int score;
int next_num;
const int Way = 10;
const int Nest = 5;
/*void dfs(int nest, int d) {
int M = 0, temp = score;
int prev, n;
vector<pair<int, int>> kouho(26);
rep(j, 0, 26) {
score = temp;
score += s[d - 1][j];
prev = last[j];
last[j] = d;
rep(k, 0, 26)score -= c[k] * (d - last[k]);
kouho[j].first = score;
kouho[j].second = j;
last[j] = prev;
}
//sort(all(kouho), greater<pair<int, int>>());
rep(j, 0, Way) {
//prev = last[kouho[j].second];
//last[kouho[j].second] = d;
score = kouho[j].first;
if (nest && d < D)dfs(nest - 1, d + 1);
if (M < score)M = score, n = kouho[j].second;
printf("j:%2d score:%d\n", j, score);
//last[kouho[j].second] = prev;
}
score = M;
next_num = n;
}*/
int dfs(int nest, int i) {
ll M = -1 << 30, temp = score;
int prev, p;
vector<pair<int, int>> kouho(26);
rep(j, 0, 26) {
score = temp + s[i - 1][j];
rep(k, 0, 26) if (j != k) score -= c[k] * (i - last[k]);
kouho[j].first = score;
kouho[j].second = j;
}
sort(all(kouho), greater<pair<int, int>>());
rep(j, 0, Way) {
score = kouho[j].first;
prev = last[kouho[j].second];
last[kouho[j].second] = i;
if (nest && i < D)
dfs(nest - 1, i + 1);
last[kouho[j].second] = prev;
if (M < score)
M = score, p = kouho[j].second;
}
score = M;
return p;
}
int main() {
input();
/*rep(i, 1, D + 1) {
//score = 0;
dfs(Nest, i);
printf("%d\n", next_num + 1);
last[next_num] = i;
printf("%d\n", score);
}*/
rep(i, 1, D + 1) {
score = 0;
int p = dfs(Nest, i);
last[p] = i;
printf("%d\n", p + 1);
// printf("%d\n", score);
}
return 0;
}
void input() {
cin >> D;
rep(i, 0, 26) cin >> c[i];
rep(i, 0, D) { rep(i2, 0, 26) cin >> s[i][i2]; }
} | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <bitset>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (auto i = a; i < b; i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x *= x;
p /= 2;
} else {
a *= x;
p--;
}
}
return a;
}
ll mpower(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x = x * x % mod;
p /= 2;
} else {
a = a * x % mod;
p--;
}
}
return a;
}
ll ac(ll n, ll k) {
ll a = 1;
rep(i, 1, k) {
a *= n - i + 1;
a /= i;
}
return a;
}
ll mc(ll n, ll m) {
ll k = 1, l = 1;
rep(i, n - m + 1, n + 1) k = k * i % mod;
rep(i, 1, m + 1) l = l * i % mod;
l = mpower(l, mod - 2);
return k * l % mod;
}
int D;
vector<int> c(26);
vector<int> last(26, 0);
vector<vector<int>> s(365, vector<int>(26));
void input();
int score;
int next_num;
const int Way = 10;
const int Nest = 3;
/*void dfs(int nest, int d) {
int M = 0, temp = score;
int prev, n;
vector<pair<int, int>> kouho(26);
rep(j, 0, 26) {
score = temp;
score += s[d - 1][j];
prev = last[j];
last[j] = d;
rep(k, 0, 26)score -= c[k] * (d - last[k]);
kouho[j].first = score;
kouho[j].second = j;
last[j] = prev;
}
//sort(all(kouho), greater<pair<int, int>>());
rep(j, 0, Way) {
//prev = last[kouho[j].second];
//last[kouho[j].second] = d;
score = kouho[j].first;
if (nest && d < D)dfs(nest - 1, d + 1);
if (M < score)M = score, n = kouho[j].second;
printf("j:%2d score:%d\n", j, score);
//last[kouho[j].second] = prev;
}
score = M;
next_num = n;
}*/
int dfs(int nest, int i) {
ll M = -1 << 30, temp = score;
int prev, p;
vector<pair<int, int>> kouho(26);
rep(j, 0, 26) {
score = temp + s[i - 1][j];
rep(k, 0, 26) if (j != k) score -= c[k] * (i - last[k]);
kouho[j].first = score;
kouho[j].second = j;
}
sort(all(kouho), greater<pair<int, int>>());
rep(j, 0, Way) {
score = kouho[j].first;
prev = last[kouho[j].second];
last[kouho[j].second] = i;
if (nest && i < D)
dfs(nest - 1, i + 1);
last[kouho[j].second] = prev;
if (M < score)
M = score, p = kouho[j].second;
}
score = M;
return p;
}
int main() {
input();
/*rep(i, 1, D + 1) {
//score = 0;
dfs(Nest, i);
printf("%d\n", next_num + 1);
last[next_num] = i;
printf("%d\n", score);
}*/
rep(i, 1, D + 1) {
score = 0;
int p = dfs(Nest, i);
last[p] = i;
printf("%d\n", p + 1);
// printf("%d\n", score);
}
return 0;
}
void input() {
cin >> D;
rep(i, 0, 26) cin >> c[i];
rep(i, 0, D) { rep(i2, 0, 26) cin >> s[i][i2]; }
} | replace | 78 | 79 | 78 | 79 | TLE | |
p02618 | C++ | Time Limit Exceeded | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <bitset>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (auto i = a; i < b; i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x *= x;
p /= 2;
} else {
a *= x;
p--;
}
}
return a;
}
ll mpower(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x = x * x % mod;
p /= 2;
} else {
a = a * x % mod;
p--;
}
}
return a;
}
ll ac(ll n, ll k) {
ll a = 1;
rep(i, 1, k) {
a *= n - i + 1;
a /= i;
}
return a;
}
ll mc(ll n, ll m) {
ll k = 1, l = 1;
rep(i, n - m + 1, n + 1) k = k * i % mod;
rep(i, 1, m + 1) l = l * i % mod;
l = mpower(l, mod - 2);
return k * l % mod;
}
int D;
vector<int> c(26);
vector<int> last(26, 0);
vector<vector<int>> s(365, vector<int>(26));
void input();
int score;
int next_num;
const int Way = 9;
const int Nest = 6;
/*void dfs(int nest, int d) {
int M = 0, temp = score;
int prev, n;
vector<pair<int, int>> kouho(26);
rep(j, 0, 26) {
score = temp;
score += s[d - 1][j];
prev = last[j];
last[j] = d;
rep(k, 0, 26)score -= c[k] * (d - last[k]);
kouho[j].first = score;
kouho[j].second = j;
last[j] = prev;
}
//sort(all(kouho), greater<pair<int, int>>());
rep(j, 0, Way) {
//prev = last[kouho[j].second];
//last[kouho[j].second] = d;
score = kouho[j].first;
if (nest && d < D)dfs(nest - 1, d + 1);
if (M < score)M = score, n = kouho[j].second;
printf("j:%2d score:%d\n", j, score);
//last[kouho[j].second] = prev;
}
score = M;
next_num = n;
}*/
int dfs(int nest, int i) {
ll M = -1 << 30, temp = score;
int prev, p;
vector<pair<int, int>> kouho(26);
rep(j, 0, 26) {
score = temp + s[i - 1][j];
rep(k, 0, 26) if (j != k) score -= c[k] * (i - last[k]);
kouho[j].first = score;
kouho[j].second = j;
}
sort(all(kouho), greater<pair<int, int>>());
rep(j, 0, Way) {
score = kouho[j].first;
prev = last[kouho[j].second];
last[kouho[j].second] = i;
if (nest && i < D)
dfs(nest - 1, i + 1);
last[kouho[j].second] = prev;
if (M < score)
M = score, p = kouho[j].second;
}
score = M;
return p;
}
int main() {
input();
/*rep(i, 1, D + 1) {
//score = 0;
dfs(Nest, i);
printf("%d\n", next_num + 1);
last[next_num] = i;
printf("%d\n", score);
}*/
rep(i, 1, D + 1) {
score = 0;
int p = dfs(Nest, i);
last[p] = i;
printf("%d\n", p + 1);
// printf("%d\n", score);
}
return 0;
}
void input() {
cin >> D;
rep(i, 0, 26) cin >> c[i];
rep(i, 0, D) { rep(i2, 0, 26) cin >> s[i][i2]; }
} | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <bitset>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (auto i = a; i < b; i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x *= x;
p /= 2;
} else {
a *= x;
p--;
}
}
return a;
}
ll mpower(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x = x * x % mod;
p /= 2;
} else {
a = a * x % mod;
p--;
}
}
return a;
}
ll ac(ll n, ll k) {
ll a = 1;
rep(i, 1, k) {
a *= n - i + 1;
a /= i;
}
return a;
}
ll mc(ll n, ll m) {
ll k = 1, l = 1;
rep(i, n - m + 1, n + 1) k = k * i % mod;
rep(i, 1, m + 1) l = l * i % mod;
l = mpower(l, mod - 2);
return k * l % mod;
}
int D;
vector<int> c(26);
vector<int> last(26, 0);
vector<vector<int>> s(365, vector<int>(26));
void input();
int score;
int next_num;
const int Way = 12;
const int Nest = 3;
/*void dfs(int nest, int d) {
int M = 0, temp = score;
int prev, n;
vector<pair<int, int>> kouho(26);
rep(j, 0, 26) {
score = temp;
score += s[d - 1][j];
prev = last[j];
last[j] = d;
rep(k, 0, 26)score -= c[k] * (d - last[k]);
kouho[j].first = score;
kouho[j].second = j;
last[j] = prev;
}
//sort(all(kouho), greater<pair<int, int>>());
rep(j, 0, Way) {
//prev = last[kouho[j].second];
//last[kouho[j].second] = d;
score = kouho[j].first;
if (nest && d < D)dfs(nest - 1, d + 1);
if (M < score)M = score, n = kouho[j].second;
printf("j:%2d score:%d\n", j, score);
//last[kouho[j].second] = prev;
}
score = M;
next_num = n;
}*/
int dfs(int nest, int i) {
ll M = -1 << 30, temp = score;
int prev, p;
vector<pair<int, int>> kouho(26);
rep(j, 0, 26) {
score = temp + s[i - 1][j];
rep(k, 0, 26) if (j != k) score -= c[k] * (i - last[k]);
kouho[j].first = score;
kouho[j].second = j;
}
sort(all(kouho), greater<pair<int, int>>());
rep(j, 0, Way) {
score = kouho[j].first;
prev = last[kouho[j].second];
last[kouho[j].second] = i;
if (nest && i < D)
dfs(nest - 1, i + 1);
last[kouho[j].second] = prev;
if (M < score)
M = score, p = kouho[j].second;
}
score = M;
return p;
}
int main() {
input();
/*rep(i, 1, D + 1) {
//score = 0;
dfs(Nest, i);
printf("%d\n", next_num + 1);
last[next_num] = i;
printf("%d\n", score);
}*/
rep(i, 1, D + 1) {
score = 0;
int p = dfs(Nest, i);
last[p] = i;
printf("%d\n", p + 1);
// printf("%d\n", score);
}
return 0;
}
void input() {
cin >> D;
rep(i, 0, 26) cin >> c[i];
rep(i, 0, D) { rep(i2, 0, 26) cin >> s[i][i2]; }
} | replace | 77 | 79 | 77 | 79 | TLE | |
p02618 | C++ | Time Limit Exceeded | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <bitset>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (auto i = a; i < b; i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x *= x;
p /= 2;
} else {
a *= x;
p--;
}
}
return a;
}
ll mpower(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x = x * x % mod;
p /= 2;
} else {
a = a * x % mod;
p--;
}
}
return a;
}
ll ac(ll n, ll k) {
ll a = 1;
rep(i, 1, k) {
a *= n - i + 1;
a /= i;
}
return a;
}
ll mc(ll n, ll m) {
ll k = 1, l = 1;
rep(i, n - m + 1, n + 1) k = k * i % mod;
rep(i, 1, m + 1) l = l * i % mod;
l = mpower(l, mod - 2);
return k * l % mod;
}
int D;
vector<int> c(26);
vector<int> last(26, 0);
vector<vector<int>> s(365, vector<int>(26));
void input();
int score;
int next_num;
const int Way = 22;
const int Nest = 3;
/*void dfs(int nest, int d) {
int M = 0, temp = score;
int prev, n;
vector<pair<int, int>> kouho(26);
rep(j, 0, 26) {
score = temp;
score += s[d - 1][j];
prev = last[j];
last[j] = d;
rep(k, 0, 26)score -= c[k] * (d - last[k]);
kouho[j].first = score;
kouho[j].second = j;
last[j] = prev;
}
//sort(all(kouho), greater<pair<int, int>>());
rep(j, 0, Way) {
//prev = last[kouho[j].second];
//last[kouho[j].second] = d;
score = kouho[j].first;
if (nest && d < D)dfs(nest - 1, d + 1);
if (M < score)M = score, n = kouho[j].second;
printf("j:%2d score:%d\n", j, score);
//last[kouho[j].second] = prev;
}
score = M;
next_num = n;
}*/
int dfs(int nest, int i) {
ll M = -1 << 30, temp = score;
int prev, p;
vector<pair<int, int>> kouho(26);
rep(j, 0, 26) {
score = temp + s[i - 1][j];
rep(k, 0, 26) if (j != k) score -= c[k] * (i - last[k]);
kouho[j].first = score;
kouho[j].second = j;
}
sort(all(kouho), greater<pair<int, int>>());
rep(j, 0, Way) {
score = kouho[j].first;
prev = last[kouho[j].second];
last[kouho[j].second] = i;
if (nest && i < D)
dfs(nest - 1, i + 1);
last[kouho[j].second] = prev;
if (M < score)
M = score, p = kouho[j].second;
}
score = M;
return p;
}
int main() {
input();
/*rep(i, 1, D + 1) {
//score = 0;
dfs(Nest, i);
printf("%d\n", next_num + 1);
last[next_num] = i;
printf("%d\n", score);
}*/
rep(i, 1, D + 1) {
score = 0;
int p = dfs(Nest, i);
last[p] = i;
printf("%d\n", p + 1);
// printf("%d\n", score);
}
return 0;
}
void input() {
cin >> D;
rep(i, 0, 26) cin >> c[i];
rep(i, 0, D) { rep(i2, 0, 26) cin >> s[i][i2]; }
} | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <bitset>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (auto i = a; i < b; i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x *= x;
p /= 2;
} else {
a *= x;
p--;
}
}
return a;
}
ll mpower(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x = x * x % mod;
p /= 2;
} else {
a = a * x % mod;
p--;
}
}
return a;
}
ll ac(ll n, ll k) {
ll a = 1;
rep(i, 1, k) {
a *= n - i + 1;
a /= i;
}
return a;
}
ll mc(ll n, ll m) {
ll k = 1, l = 1;
rep(i, n - m + 1, n + 1) k = k * i % mod;
rep(i, 1, m + 1) l = l * i % mod;
l = mpower(l, mod - 2);
return k * l % mod;
}
int D;
vector<int> c(26);
vector<int> last(26, 0);
vector<vector<int>> s(365, vector<int>(26));
void input();
int score;
int next_num;
const int Way = 20;
const int Nest = 3;
/*void dfs(int nest, int d) {
int M = 0, temp = score;
int prev, n;
vector<pair<int, int>> kouho(26);
rep(j, 0, 26) {
score = temp;
score += s[d - 1][j];
prev = last[j];
last[j] = d;
rep(k, 0, 26)score -= c[k] * (d - last[k]);
kouho[j].first = score;
kouho[j].second = j;
last[j] = prev;
}
//sort(all(kouho), greater<pair<int, int>>());
rep(j, 0, Way) {
//prev = last[kouho[j].second];
//last[kouho[j].second] = d;
score = kouho[j].first;
if (nest && d < D)dfs(nest - 1, d + 1);
if (M < score)M = score, n = kouho[j].second;
printf("j:%2d score:%d\n", j, score);
//last[kouho[j].second] = prev;
}
score = M;
next_num = n;
}*/
int dfs(int nest, int i) {
ll M = -1 << 30, temp = score;
int prev, p;
vector<pair<int, int>> kouho(26);
rep(j, 0, 26) {
score = temp + s[i - 1][j];
rep(k, 0, 26) if (j != k) score -= c[k] * (i - last[k]);
kouho[j].first = score;
kouho[j].second = j;
}
sort(all(kouho), greater<pair<int, int>>());
rep(j, 0, Way) {
score = kouho[j].first;
prev = last[kouho[j].second];
last[kouho[j].second] = i;
if (nest && i < D)
dfs(nest - 1, i + 1);
last[kouho[j].second] = prev;
if (M < score)
M = score, p = kouho[j].second;
}
score = M;
return p;
}
int main() {
input();
/*rep(i, 1, D + 1) {
//score = 0;
dfs(Nest, i);
printf("%d\n", next_num + 1);
last[next_num] = i;
printf("%d\n", score);
}*/
rep(i, 1, D + 1) {
score = 0;
int p = dfs(Nest, i);
last[p] = i;
printf("%d\n", p + 1);
// printf("%d\n", score);
}
return 0;
}
void input() {
cin >> D;
rep(i, 0, 26) cin >> c[i];
rep(i, 0, D) { rep(i2, 0, 26) cin >> s[i][i2]; }
} | replace | 77 | 78 | 77 | 78 | TLE | |
p02618 | C++ | Runtime Error | /*
ЗАПУСКАЕМ
░ГУСЯ░▄▀▀▀▄░РАБОТЯГУ░░
▄███▀░◐░░░▌░░░░░░░
░░░░▌░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▌░░░░░▐▄▄░░░░░
░░░░▌░░░░▄▀▒▒▀▀▀▀▄
░░░▐░░░░▐▒▒▒▒▒▒▒▒▀▀▄
░░░▐░░░░▐▄▒▒▒▒▒▒▒▒▒▒▀▄
░░░░▀▄░░░░▀▄▒▒▒▒▒▒▒▒▒▒▀▄
░░░░░░▀▄▄▄▄▄█▄▄▄▄▄▄▄▄▄▄▄▀▄
░░░░░░░░░░░▌▌░▌▌░░░░░
░░░░░░░░░░░▌▌░▌▌░░░░░
░░░░░░░░░▄▄▌▌▄▌▌░░░░░
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
template <typename T1, typename T2> inline void chkmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chkmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
#define files(FILENAME) \
read(FILENAME); \
write(FILENAME)
#define read(FILENAME) freopen((FILENAME + ".in").c_str(), "r", stdin)
#define write(FILENAME) freopen((FILENAME + ".out").c_str(), "w", stdout)
#define all(c) (c).begin(), (c).end()
#define sz(c) (int)(c).size()
#define left left228
#define right right228
#define y1 y1228
#define mp make_pair
#define pb push_back
#define y2 y2228
#define rank rank228
using ll = long long;
using ld = long double;
const string FILENAME = "input";
const int MAXN = 370;
int d;
int t[MAXN];
int c[MAXN];
int s[MAXN][29];
int last[MAXN];
int q;
set<int> pos[29];
mt19937 as;
ll calcCost() {
for (int i = 1; i <= 26; i++) {
last[i] = 0;
}
ll sat = 0;
for (int i = 1; i <= d; i++) {
sat += s[i][t[i]];
last[t[i]] = i;
for (int j = 1; j <= 26; j++) {
sat -= c[j] * (i - last[j]);
}
}
return sat;
}
ll cur;
void addSeg(int l, int r, int i, int mod) {
l++;
int t = r - l;
if (t <= 0) {
return;
}
cur -= (ll)mod * c[i] * t * (t + 1) / 2;
}
void del(int i, int x) {
cur -= s[x][i];
auto it = pos[i].find(x);
it++;
int nr = *it;
it--;
it--;
int nl = *it;
addSeg(x, nr, i, -1);
addSeg(nl, x, i, -1);
pos[i].erase(x);
addSeg(nl, nr, i, 1);
}
void add(int i, int x) {
cur += s[x][i];
pos[i].insert(x);
auto it = pos[i].find(x);
it++;
int nr = *it;
it--;
it--;
int nl = *it;
addSeg(x, nr, i, 1);
addSeg(nl, x, i, 1);
addSeg(nl, nr, i, -1);
}
void query(int id, int cs) {
del(t[id], id);
t[id] = cs;
add(t[id], id);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// read(FILENAME);
cin >> d;
for (int i = 1; i <= 26; i++) {
cin >> c[i];
pos[i].insert(0);
pos[i].insert(d + 1);
}
for (int i = 1; i <= d; i++) {
for (int j = 1; j <= 26; j++) {
cin >> s[i][j];
}
}
for (int i = 1; i <= d; i++) {
t[i] = as() % 26 + 1;
pos[t[i]].insert(i);
}
cur = calcCost();
while (double(clock()) / CLOCKS_PER_SEC <= 1.8) {
int f = as() % d + 1;
int opt = -1;
int pos = -1;
for (int f1 = 1; f1 <= 26; f1++) {
query(f, f1);
if (opt < cur) {
opt = cur;
pos = f1;
}
}
query(f, pos);
}
for (int i = 1; i <= d; i++) {
cout << t[i] << '\n';
}
return 0;
}
| /*
ЗАПУСКАЕМ
░ГУСЯ░▄▀▀▀▄░РАБОТЯГУ░░
▄███▀░◐░░░▌░░░░░░░
░░░░▌░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▐░░░░░▐░░░░░░░
░░░░▌░░░░░▐▄▄░░░░░
░░░░▌░░░░▄▀▒▒▀▀▀▀▄
░░░▐░░░░▐▒▒▒▒▒▒▒▒▀▀▄
░░░▐░░░░▐▄▒▒▒▒▒▒▒▒▒▒▀▄
░░░░▀▄░░░░▀▄▒▒▒▒▒▒▒▒▒▒▀▄
░░░░░░▀▄▄▄▄▄█▄▄▄▄▄▄▄▄▄▄▄▀▄
░░░░░░░░░░░▌▌░▌▌░░░░░
░░░░░░░░░░░▌▌░▌▌░░░░░
░░░░░░░░░▄▄▌▌▄▌▌░░░░░
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
template <typename T1, typename T2> inline void chkmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chkmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
#define files(FILENAME) \
read(FILENAME); \
write(FILENAME)
#define read(FILENAME) freopen((FILENAME + ".in").c_str(), "r", stdin)
#define write(FILENAME) freopen((FILENAME + ".out").c_str(), "w", stdout)
#define all(c) (c).begin(), (c).end()
#define sz(c) (int)(c).size()
#define left left228
#define right right228
#define y1 y1228
#define mp make_pair
#define pb push_back
#define y2 y2228
#define rank rank228
using ll = long long;
using ld = long double;
const string FILENAME = "input";
const int MAXN = 370;
int d;
int t[MAXN];
int c[MAXN];
int s[MAXN][29];
int last[MAXN];
int q;
set<int> pos[29];
mt19937 as;
ll calcCost() {
for (int i = 1; i <= 26; i++) {
last[i] = 0;
}
ll sat = 0;
for (int i = 1; i <= d; i++) {
sat += s[i][t[i]];
last[t[i]] = i;
for (int j = 1; j <= 26; j++) {
sat -= c[j] * (i - last[j]);
}
}
return sat;
}
ll cur;
void addSeg(int l, int r, int i, int mod) {
l++;
int t = r - l;
if (t <= 0) {
return;
}
cur -= (ll)mod * c[i] * t * (t + 1) / 2;
}
void del(int i, int x) {
cur -= s[x][i];
auto it = pos[i].find(x);
it++;
int nr = *it;
it--;
it--;
int nl = *it;
addSeg(x, nr, i, -1);
addSeg(nl, x, i, -1);
pos[i].erase(x);
addSeg(nl, nr, i, 1);
}
void add(int i, int x) {
cur += s[x][i];
pos[i].insert(x);
auto it = pos[i].find(x);
it++;
int nr = *it;
it--;
it--;
int nl = *it;
addSeg(x, nr, i, 1);
addSeg(nl, x, i, 1);
addSeg(nl, nr, i, -1);
}
void query(int id, int cs) {
del(t[id], id);
t[id] = cs;
add(t[id], id);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// read(FILENAME);
cin >> d;
for (int i = 1; i <= 26; i++) {
cin >> c[i];
pos[i].insert(0);
pos[i].insert(d + 1);
}
for (int i = 1; i <= d; i++) {
for (int j = 1; j <= 26; j++) {
cin >> s[i][j];
}
}
for (int i = 1; i <= d; i++) {
t[i] = as() % 26 + 1;
pos[t[i]].insert(i);
}
cur = calcCost();
while (double(clock()) / CLOCKS_PER_SEC <= 1.8) {
int f = as() % d + 1;
int opt = -1e9;
int pos = -1;
for (int f1 = 1; f1 <= 26; f1++) {
query(f, f1);
if (opt < cur) {
opt = cur;
pos = f1;
}
}
query(f, pos);
}
for (int i = 1; i <= d; i++) {
cout << t[i] << '\n';
}
return 0;
}
| replace | 166 | 167 | 166 | 167 | 0 | |
p02618 | C++ | Time Limit Exceeded | // #include <bits/stdc++.h>
#include <algorithm>
#include <chrono>
#include <iostream>
#include <vector>
using namespace std;
const int typeNum = 26;
void solve(long long D, std::vector<long long> c,
std::vector<std::vector<long long>> s) {
std::chrono::system_clock::time_point start, end; // 型は auto で可
start = std::chrono::system_clock::now(); // 計測開始時間
end = std::chrono::system_clock::now();
double elapsed =
std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
.count();
// initial t
vector<long long> t = vector<long long>(D);
int i = 0;
for (auto &tt : t) {
tt = i + 1;
i = (i + 1) % typeNum;
}
long long pastSut = 0;
long long iterator = 0;
while (true) {
// change id and value
long long changedIndex = iterator % (t.size() - 1);
if (changedIndex < 0)
changedIndex += t.size() - 1;
long long randomValue = (iterator * 18973) % typeNum + 1;
if (randomValue < 1)
randomValue += typeNum;
long long pastValue = t[changedIndex];
t[changedIndex] = randomValue;
vector<long long> newT = vector<long long>();
int skipCount = 0;
for (int i = 0; i < t.size(); ++i) {
if (i = changedIndex) {
skipCount++;
continue;
}
newT.push_back(t[i]);
}
for (int i = 0; i < skipCount; ++i) {
newT.push_back(randomValue);
}
// current sutisfuction
long long sut = 0;
// make table
vector<vector<long long>> table;
for (int i = 0; i < typeNum; ++i) {
table.push_back(vector<long long>(D));
for (int j = 0; j < D; ++j) {
table[i][j] = -1;
}
}
for (int i = 0; i < D; ++i) {
vector<long long> &target = table[newT[i] - 1];
for (int j = i; j < target.size(); ++j) {
target[j] = i;
}
}
for (int d = 0; d < D; ++d) {
sut += s[d][newT[d] - 1];
// minus
for (int i = 0; i < typeNum; ++i) {
sut -= c[i] * (d - table[i][d]);
}
// todays sutisfuction
// cout << sut << endl;
}
if (sut > pastSut) {
// change
pastSut = sut;
for (int i = 0; i < t.size(); ++i) {
t[i] = newT[i];
}
} else {
// cancel
// t[changedIndex] = pastValue;
}
iterator++;
end = std::chrono::system_clock::now();
elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
.count();
if (elapsed > 1970)
break;
// break;
}
for (long long &tt : t) {
cout << tt << endl;
}
// result sutisfuction
// cout << pastSut << endl;
}
// Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips:
// You use the default template now. You can remove this line by using your
// custom template)
int main() {
long long D;
scanf("%lld", &D);
std::vector<long long> c(26);
for (int i = 0; i < 26; i++) {
scanf("%lld", &c[i]);
}
std::vector<std::vector<long long>> s(D, std::vector<long long>(26));
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++) {
scanf("%lld", &s[i][j]);
}
}
solve(D, std::move(c), std::move(s));
return 0;
}
| // #include <bits/stdc++.h>
#include <algorithm>
#include <chrono>
#include <iostream>
#include <vector>
using namespace std;
const int typeNum = 26;
void solve(long long D, std::vector<long long> c,
std::vector<std::vector<long long>> s) {
std::chrono::system_clock::time_point start, end; // 型は auto で可
start = std::chrono::system_clock::now(); // 計測開始時間
end = std::chrono::system_clock::now();
double elapsed =
std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
.count();
// initial t
vector<long long> t = vector<long long>(D);
int i = 0;
for (auto &tt : t) {
tt = i + 1;
i = (i + 1) % typeNum;
}
long long pastSut = 0;
long long iterator = 0;
while (true) {
// change id and value
long long changedIndex = iterator % (t.size() - 1);
if (changedIndex < 0)
changedIndex += t.size() - 1;
long long randomValue = (iterator * 18973) % typeNum + 1;
if (randomValue < 1)
randomValue += typeNum;
long long pastValue = t[changedIndex];
t[changedIndex] = randomValue;
vector<long long> newT = vector<long long>();
int skipCount = 0;
for (int i = 0; i < t.size(); ++i) {
if (i == changedIndex) {
skipCount++;
continue;
}
newT.push_back(t[i]);
}
for (int i = 0; i < skipCount; ++i) {
newT.push_back(randomValue);
}
// current sutisfuction
long long sut = 0;
// make table
vector<vector<long long>> table;
for (int i = 0; i < typeNum; ++i) {
table.push_back(vector<long long>(D));
for (int j = 0; j < D; ++j) {
table[i][j] = -1;
}
}
for (int i = 0; i < D; ++i) {
vector<long long> &target = table[newT[i] - 1];
for (int j = i; j < target.size(); ++j) {
target[j] = i;
}
}
for (int d = 0; d < D; ++d) {
sut += s[d][newT[d] - 1];
// minus
for (int i = 0; i < typeNum; ++i) {
sut -= c[i] * (d - table[i][d]);
}
// todays sutisfuction
// cout << sut << endl;
}
if (sut > pastSut) {
// change
pastSut = sut;
for (int i = 0; i < t.size(); ++i) {
t[i] = newT[i];
}
} else {
// cancel
// t[changedIndex] = pastValue;
}
iterator++;
end = std::chrono::system_clock::now();
elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
.count();
if (elapsed > 1970)
break;
// break;
}
for (long long &tt : t) {
cout << tt << endl;
}
// result sutisfuction
// cout << pastSut << endl;
}
// Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips:
// You use the default template now. You can remove this line by using your
// custom template)
int main() {
long long D;
scanf("%lld", &D);
std::vector<long long> c(26);
for (int i = 0; i < 26; i++) {
scanf("%lld", &c[i]);
}
std::vector<std::vector<long long>> s(D, std::vector<long long>(26));
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++) {
scanf("%lld", &s[i][j]);
}
}
solve(D, std::move(c), std::move(s));
return 0;
}
| replace | 43 | 44 | 43 | 44 | TLE | |
p02618 | C++ | Runtime Error | #include <climits>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
vector<int> cs;
vector<vector<int>> sm;
int total_satisfaction(vector<int> &ts, int d) {
vector<int> ls;
for (int i = 0; i < 26; i++)
ls.push_back(0);
int s = 0;
for (int i = 0; i < d; i++) {
int t = ts[i];
t--;
s += sm[i][t];
ls[t] = i + 1;
int dis = 0;
for (int j = 0; j < 26; j++) {
dis += cs[j] * ((i + 1) - ls[j]);
}
s -= dis;
}
return s;
}
int main() {
int d;
vector<int> ts;
cin >> d;
int x;
for (int i = 0; i < 26; i++) {
cin >> x;
cs.push_back(x);
}
for (int i = 0; i < d; i++) {
vector<int> v;
sm.push_back(v);
for (int j = 0; j < 26; j++) {
cin >> x;
sm[i].push_back(x);
}
}
for (int i = 0; i < d; i++) {
int mx = INT_MIN;
int mxt = -1;
for (int t = 1; t <= d; t++) {
ts.push_back(t);
int s = total_satisfaction(ts, i + 1);
if (s > mx) {
mx = s;
mxt = t;
}
ts.pop_back();
}
ts.push_back(mxt);
cout << mxt << endl;
}
}
| #include <climits>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
vector<int> cs;
vector<vector<int>> sm;
int total_satisfaction(vector<int> &ts, int d) {
vector<int> ls;
for (int i = 0; i < 26; i++)
ls.push_back(0);
int s = 0;
for (int i = 0; i < d; i++) {
int t = ts[i];
t--;
s += sm[i][t];
ls[t] = i + 1;
int dis = 0;
for (int j = 0; j < 26; j++) {
dis += cs[j] * ((i + 1) - ls[j]);
}
s -= dis;
}
return s;
}
int main() {
int d;
vector<int> ts;
cin >> d;
int x;
for (int i = 0; i < 26; i++) {
cin >> x;
cs.push_back(x);
}
for (int i = 0; i < d; i++) {
vector<int> v;
sm.push_back(v);
for (int j = 0; j < 26; j++) {
cin >> x;
sm[i].push_back(x);
}
}
for (int i = 0; i < d; i++) {
int mx = INT_MIN;
int mxt = -1;
for (int t = 1; t <= 26; t++) {
ts.push_back(t);
int s = total_satisfaction(ts, i + 1);
if (s > mx) {
mx = s;
mxt = t;
}
ts.pop_back();
}
ts.push_back(mxt);
cout << mxt << endl;
}
}
| replace | 55 | 56 | 55 | 56 | 0 | |
p02618 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
#define rep(X, N) for (ll X = 0LL; X < (N); X++)
#define ALL(V) (V).begin(), (V).end()
#define endl "\n"
using namespace std;
typedef long long ll;
const double PI = 3.1415926535897932384626;
const ll MODN = 1000000007;
const ll MODN2 = 998244353;
const double EPS = 1e-10;
const int kind = 26;
const int D = 365;
vector<int> c(kind);
vector<vector<int>> s(D, vector<int>(kind));
vector<int> state(D);
vector<int> last(kind);
vector<vector<pair<int, int>>> ranking(D, vector<pair<int, int>>(kind));
double start;
const double TLE = 1.98;
constexpr double ticks_per_sec = 3000000000;
constexpr double ticks_per_sec_inv = 1.0 / ticks_per_sec;
inline double rdtsc() { // in seconds
uint32_t lo, hi;
asm volatile("rdtsc" : "=a"(lo), "=d"(hi));
return (((uint64_t)hi << 32) | lo) * ticks_per_sec_inv;
}
inline uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
inline int intRand(unsigned long long n) { return xor64() % n; }
int score() {
rep(i, kind) { last[i] = 0; }
int result = 0;
rep(i, D) {
result += s[i][ranking[i][state[i]].second];
last[ranking[i][state[i]].second] = i + 1;
rep(j, kind) { result -= ((i + 1) - last[j]) * c[j]; }
}
return result;
}
void init() {
rep(i, D) {
rep(j, kind) { ranking[i][j] = make_pair(s[i][j], j); }
sort(ranking[i].rbegin(), ranking[i].rend());
state[i] = i;
}
}
void finish() {
rep(i, D) { state[i] = ranking[i][state[i]].second; }
}
// 日付、変更前選択順位、変更後選択順位
pair<int, pair<int, int>> m;
void move() {
int tmpd = intRand(D);
if (state[tmpd] == 0 || state[tmpd] == 25) {
if (state[tmpd] == 0) {
m = make_pair(tmpd, make_pair(state[tmpd], state[tmpd] + 1));
state[tmpd] = state[tmpd] + 1;
} else {
m = make_pair(tmpd, make_pair(state[tmpd], state[tmpd] - 1));
state[tmpd] = state[tmpd] - 1;
}
} else {
int r = intRand(2);
if (r) {
m = make_pair(tmpd, make_pair(state[tmpd], state[tmpd] - 1));
state[tmpd] = state[tmpd] - 1;
} else {
m = make_pair(tmpd, make_pair(state[tmpd], state[tmpd] + 1));
state[tmpd] = state[tmpd] + 1;
}
}
}
void undo() { state[m.first] = m.second.first; }
void sa() {
vector<int> bestState = vector<int>(state);
int bestScore = score();
int preScore = bestScore;
int loopCount = 0;
int updateCount = 0;
int undoCount = 0;
while (rdtsc() - start < TLE) {
move();
int tmpScore = score();
if (tmpScore >= bestScore) {
bestScore = tmpScore;
bestState = vector<int>(state);
updateCount++;
}
double temp = 1000 * (TLE - (rdtsc() - start)) / TLE;
double prob = exp((tmpScore - preScore) / temp);
if (prob > 1.0 * intRand(1000000000) / 1000000000) {
preScore = tmpScore;
} else {
undo();
undoCount++;
}
loopCount++;
}
state = vector<int>(bestState);
cerr << " loop count: " << loopCount << endl;
cerr << " undo count: " << undoCount << endl;
cerr << "update count: " << updateCount << endl;
}
void solve() {
init();
cerr << " start score: " << score() << endl;
sa();
cerr << "finish score: " << score() << endl;
finish();
}
int main() {
start = rdtsc();
int tmp;
cin >> tmp;
rep(i, kind) { cin >> c[i]; }
rep(i, D) {
rep(j, kind) { cin >> s[i][j]; }
}
solve();
rep(i, D) { printf("%d\n", state[i] + 1); }
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
#define rep(X, N) for (ll X = 0LL; X < (N); X++)
#define ALL(V) (V).begin(), (V).end()
#define endl "\n"
using namespace std;
typedef long long ll;
const double PI = 3.1415926535897932384626;
const ll MODN = 1000000007;
const ll MODN2 = 998244353;
const double EPS = 1e-10;
const int kind = 26;
const int D = 365;
vector<int> c(kind);
vector<vector<int>> s(D, vector<int>(kind));
vector<int> state(D);
vector<int> last(kind);
vector<vector<pair<int, int>>> ranking(D, vector<pair<int, int>>(kind));
double start;
const double TLE = 1.98;
constexpr double ticks_per_sec = 3000000000;
constexpr double ticks_per_sec_inv = 1.0 / ticks_per_sec;
inline double rdtsc() { // in seconds
uint32_t lo, hi;
asm volatile("rdtsc" : "=a"(lo), "=d"(hi));
return (((uint64_t)hi << 32) | lo) * ticks_per_sec_inv;
}
inline uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
inline int intRand(unsigned long long n) { return xor64() % n; }
int score() {
rep(i, kind) { last[i] = 0; }
int result = 0;
rep(i, D) {
result += s[i][ranking[i][state[i]].second];
last[ranking[i][state[i]].second] = i + 1;
rep(j, kind) { result -= ((i + 1) - last[j]) * c[j]; }
}
return result;
}
void init() {
rep(i, D) {
rep(j, kind) { ranking[i][j] = make_pair(s[i][j], j); }
sort(ranking[i].rbegin(), ranking[i].rend());
state[i] = 0;
}
}
void finish() {
rep(i, D) { state[i] = ranking[i][state[i]].second; }
}
// 日付、変更前選択順位、変更後選択順位
pair<int, pair<int, int>> m;
void move() {
int tmpd = intRand(D);
if (state[tmpd] == 0 || state[tmpd] == 25) {
if (state[tmpd] == 0) {
m = make_pair(tmpd, make_pair(state[tmpd], state[tmpd] + 1));
state[tmpd] = state[tmpd] + 1;
} else {
m = make_pair(tmpd, make_pair(state[tmpd], state[tmpd] - 1));
state[tmpd] = state[tmpd] - 1;
}
} else {
int r = intRand(2);
if (r) {
m = make_pair(tmpd, make_pair(state[tmpd], state[tmpd] - 1));
state[tmpd] = state[tmpd] - 1;
} else {
m = make_pair(tmpd, make_pair(state[tmpd], state[tmpd] + 1));
state[tmpd] = state[tmpd] + 1;
}
}
}
void undo() { state[m.first] = m.second.first; }
void sa() {
vector<int> bestState = vector<int>(state);
int bestScore = score();
int preScore = bestScore;
int loopCount = 0;
int updateCount = 0;
int undoCount = 0;
while (rdtsc() - start < TLE) {
move();
int tmpScore = score();
if (tmpScore >= bestScore) {
bestScore = tmpScore;
bestState = vector<int>(state);
updateCount++;
}
double temp = 1000 * (TLE - (rdtsc() - start)) / TLE;
double prob = exp((tmpScore - preScore) / temp);
if (prob > 1.0 * intRand(1000000000) / 1000000000) {
preScore = tmpScore;
} else {
undo();
undoCount++;
}
loopCount++;
}
state = vector<int>(bestState);
cerr << " loop count: " << loopCount << endl;
cerr << " undo count: " << undoCount << endl;
cerr << "update count: " << updateCount << endl;
}
void solve() {
init();
cerr << " start score: " << score() << endl;
sa();
cerr << "finish score: " << score() << endl;
finish();
}
int main() {
start = rdtsc();
int tmp;
cin >> tmp;
rep(i, kind) { cin >> c[i]; }
rep(i, D) {
rep(j, kind) { cin >> s[i][j]; }
}
solve();
rep(i, D) { printf("%d\n", state[i] + 1); }
return 0;
}
| replace | 65 | 66 | 65 | 66 | -11 | start score: |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
static const int D = 365;
static const int ntype = 26;
class Contest {
public:
Contest() { last = 0; }
int s[D + 1];
int c;
int last;
};
Contest contest[27];
void Input() {
int d;
cin >> d;
for (int i = 1; i <= ntype; ++i) {
int t;
cin >> t;
contest[i].c = t;
}
for (int day = 1; day <= D; ++day) {
for (int type = 1; type <= ntype; ++type) {
int t;
cin >> t;
contest[type].s[day] = t;
}
}
}
int v[D + 1];
int gene[50][D + 1];
int next_gene[50][D + 1];
int elete[D + 1];
vector<pair<double, int>> cumfreq;
void randGene(int i) {
for (int day = 1; day <= D; ++day) {
gene[i][day] = rand() % 26 + 1;
}
}
void Init() {
for (int i = 0; i < 50; ++i) {
randGene(i);
}
}
void decoding(int i) {
v[0] = 0;
for (int day = 1; day <= D; ++day) {
v[day] = 0;
int type = gene[i][day];
v[day] += contest[type].s[day];
contest[type].last = day;
for (int t = 1; t <= ntype; ++t) {
v[day] -= contest[t].c * (day - contest[t].last);
}
v[day] += v[day - 1];
}
cumfreq.push_back(make_pair((double)v[D], i));
}
void CrossOver(int ni, int ci, int cj) {
for (int i = 1; i <= D; ++i) {
double p = rand() / RAND_MAX;
if (p > 0.5)
next_gene[ni][i] = gene[ci][i];
else
next_gene[ni][i] = gene[cj][i];
}
}
void Mutation(int i) {
/*cout<<i<<endl;
reverse(next_gene+i+1,next_gene+i+D+1);
cout<<"mutation"<<endl;*/
/*int tgene[D+1];
for(int d=1;d<=D;++d) tgene[d]=next_gene[i][d];
for(int d=1;d<=D;++d) next_gene[i][d]=tgene[D-d+1];*/
for (int day = 1; day <= D; ++day) {
next_gene[i][day] = rand() % 26 + 1;
}
}
void calcCumFreq() {
double sum = 0;
for (int i = 0; i < 50; ++i) {
sum += cumfreq[i].first;
}
for (int i = 0; i < 50; ++i) {
cumfreq[i].first /= sum;
}
sort(cumfreq.begin(), cumfreq.end());
for (int i = 0; i < 49; ++i) {
cumfreq[i + 1].first += cumfreq[i].first;
}
}
int Select() {
double a = (double)rand() / RAND_MAX;
for (int i = 0; i < 49; ++i) {
if (cumfreq[i + 1].first > a)
return cumfreq[i].second;
}
return cumfreq[49].second;
}
void GA() {
static const double crossRate = 0.3;
static const double mutationRate = 0.05;
for (int i = 0; i < 50; ++i) {
int pi = Select();
double crossrand = (double)rand() / RAND_MAX;
if (crossrand < crossRate) {
int pj = Select();
CrossOver(i, pi, pj);
} else {
for (int j = 1; j <= D; ++j)
next_gene[i][j] = gene[pi][j];
}
double murand = (double)rand() / RAND_MAX;
if (murand < mutationRate) {
Mutation(i);
}
}
cumfreq.resize(0);
for (int i = 0; i < 50; ++i) {
for (int j = 1; j <= D; ++j) {
gene[i][j] = next_gene[i][j];
}
decoding(i);
}
calcCumFreq();
}
int main() {
srand(700);
Input();
Init();
for (int i = 0; i < 50; ++i) {
decoding(i);
}
calcCumFreq();
for (int i = 0; i < 5000; ++i) {
GA();
}
for (int i = 0; i < 50; ++i) {
decoding(i);
}
calcCumFreq();
sort(cumfreq.begin(), cumfreq.end());
int e = cumfreq[49].second;
for (int i = 1; i <= D; ++i)
cout << gene[e][i] << endl;
} | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
static const int D = 365;
static const int ntype = 26;
class Contest {
public:
Contest() { last = 0; }
int s[D + 1];
int c;
int last;
};
Contest contest[27];
void Input() {
int d;
cin >> d;
for (int i = 1; i <= ntype; ++i) {
int t;
cin >> t;
contest[i].c = t;
}
for (int day = 1; day <= D; ++day) {
for (int type = 1; type <= ntype; ++type) {
int t;
cin >> t;
contest[type].s[day] = t;
}
}
}
int v[D + 1];
int gene[50][D + 1];
int next_gene[50][D + 1];
int elete[D + 1];
vector<pair<double, int>> cumfreq;
void randGene(int i) {
for (int day = 1; day <= D; ++day) {
gene[i][day] = rand() % 26 + 1;
}
}
void Init() {
for (int i = 0; i < 50; ++i) {
randGene(i);
}
}
void decoding(int i) {
v[0] = 0;
for (int day = 1; day <= D; ++day) {
v[day] = 0;
int type = gene[i][day];
v[day] += contest[type].s[day];
contest[type].last = day;
for (int t = 1; t <= ntype; ++t) {
v[day] -= contest[t].c * (day - contest[t].last);
}
v[day] += v[day - 1];
}
cumfreq.push_back(make_pair((double)v[D], i));
}
void CrossOver(int ni, int ci, int cj) {
for (int i = 1; i <= D; ++i) {
double p = rand() / RAND_MAX;
if (p > 0.5)
next_gene[ni][i] = gene[ci][i];
else
next_gene[ni][i] = gene[cj][i];
}
}
void Mutation(int i) {
/*cout<<i<<endl;
reverse(next_gene+i+1,next_gene+i+D+1);
cout<<"mutation"<<endl;*/
/*int tgene[D+1];
for(int d=1;d<=D;++d) tgene[d]=next_gene[i][d];
for(int d=1;d<=D;++d) next_gene[i][d]=tgene[D-d+1];*/
for (int day = 1; day <= D; ++day) {
next_gene[i][day] = rand() % 26 + 1;
}
}
void calcCumFreq() {
double sum = 0;
for (int i = 0; i < 50; ++i) {
sum += cumfreq[i].first;
}
for (int i = 0; i < 50; ++i) {
cumfreq[i].first /= sum;
}
sort(cumfreq.begin(), cumfreq.end());
for (int i = 0; i < 49; ++i) {
cumfreq[i + 1].first += cumfreq[i].first;
}
}
int Select() {
double a = (double)rand() / RAND_MAX;
for (int i = 0; i < 49; ++i) {
if (cumfreq[i + 1].first > a)
return cumfreq[i].second;
}
return cumfreq[49].second;
}
void GA() {
static const double crossRate = 0.3;
static const double mutationRate = 0.05;
for (int i = 0; i < 50; ++i) {
int pi = Select();
double crossrand = (double)rand() / RAND_MAX;
if (crossrand < crossRate) {
int pj = Select();
CrossOver(i, pi, pj);
} else {
for (int j = 1; j <= D; ++j)
next_gene[i][j] = gene[pi][j];
}
double murand = (double)rand() / RAND_MAX;
if (murand < mutationRate) {
Mutation(i);
}
}
cumfreq.resize(0);
for (int i = 0; i < 50; ++i) {
for (int j = 1; j <= D; ++j) {
gene[i][j] = next_gene[i][j];
}
decoding(i);
}
calcCumFreq();
}
int main() {
srand(700);
Input();
Init();
for (int i = 0; i < 50; ++i) {
decoding(i);
}
calcCumFreq();
for (int i = 0; i < 1000; ++i) {
GA();
}
for (int i = 0; i < 50; ++i) {
decoding(i);
}
calcCumFreq();
sort(cumfreq.begin(), cumfreq.end());
int e = cumfreq[49].second;
for (int i = 1; i <= D; ++i)
cout << gene[e][i] << endl;
} | replace | 151 | 152 | 151 | 152 | TLE | |
p02618 | C++ | Time Limit Exceeded | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <bitset>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (auto i = a; i < b; i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x *= x;
p /= 2;
} else {
a *= x;
p--;
}
}
return a;
}
ll mpower(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x = x * x % mod;
p /= 2;
} else {
a = a * x % mod;
p--;
}
}
return a;
}
ll ac(ll n, ll k) {
ll a = 1;
rep(i, 1, k) {
a *= n - i + 1;
a /= i;
}
return a;
}
ll mc(ll n, ll m) {
ll k = 1, l = 1;
rep(i, n - m + 1, n + 1) k = k * i % mod;
rep(i, 1, m + 1) l = l * i % mod;
l = mpower(l, mod - 2);
return k * l % mod;
}
int D;
vector<int> c(26);
vector<int> last(26, 0);
vector<vector<int>> s(365, vector<int>(26));
void input();
ll score;
int next_num;
void dfs(int nest, int d) {
ll M = 0, temp = score;
int prev, n;
rep(j, 0, 26) {
score = temp;
score += s[d - 1][j];
prev = last[j];
last[j] = d;
rep(k, 0, 26) score -= c[k] * (d - last[k]);
if (nest && d < D)
dfs(nest - 1, d + 1);
if (M < score)
M = score, n = j;
last[j] = prev;
// printf("%lld %d\n", *score, *next);
}
score = M;
next_num = n;
}
int main() {
input();
rep(i, 1, D + 1) {
// score = 0;
dfs(3, i);
printf("%d\n", next_num + 1);
// printf("%d\n", score);
}
return 0;
}
void input() {
cin >> D;
rep(i, 0, 26) cin >> c[i];
rep(i, 0, D) { rep(i2, 0, 26) cin >> s[i][i2]; }
}
| #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <functional>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
#define _USE_MATH_DEFINES
#include <bitset>
#include <deque>
#include <iostream>
#include <list>
#include <map>
#include <math.h>
#include <queue>
#include <set>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (auto i = a; i < b; i++)
#define all(_x) _x.begin(), _x.end()
#define r_sort(_x) sort(_x.begin(), _x.end(), std::greater<int>())
#define vec_cnt(_a, _n) (upper_bound(all(_a), _n) - lower_bound(all(_a), _n))
#define vec_unique(_a) _a.erase(std::unique(all(_a)), _a.end());
#define vvec vector<vector<ll>>
ll gcd(ll a, ll b) { return a % b == 0 ? b : gcd(b, a % b); }
ll lcm(ll a, ll b) { return (a / gcd(a, b)) * b; }
#define INF 1 << 30
const int mod = 1000000007;
ll power(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x *= x;
p /= 2;
} else {
a *= x;
p--;
}
}
return a;
}
ll mpower(ll x, ll p) {
ll a = 1;
while (p > 0) {
if (p % 2 == 0) {
x = x * x % mod;
p /= 2;
} else {
a = a * x % mod;
p--;
}
}
return a;
}
ll ac(ll n, ll k) {
ll a = 1;
rep(i, 1, k) {
a *= n - i + 1;
a /= i;
}
return a;
}
ll mc(ll n, ll m) {
ll k = 1, l = 1;
rep(i, n - m + 1, n + 1) k = k * i % mod;
rep(i, 1, m + 1) l = l * i % mod;
l = mpower(l, mod - 2);
return k * l % mod;
}
int D;
vector<int> c(26);
vector<int> last(26, 0);
vector<vector<int>> s(365, vector<int>(26));
void input();
ll score;
int next_num;
void dfs(int nest, int d) {
ll M = 0, temp = score;
int prev, n;
rep(j, 0, 26) {
score = temp;
score += s[d - 1][j];
prev = last[j];
last[j] = d;
rep(k, 0, 26) score -= c[k] * (d - last[k]);
if (nest && d < D)
dfs(nest - 1, d + 1);
if (M < score)
M = score, n = j;
last[j] = prev;
// printf("%lld %d\n", *score, *next);
}
score = M;
next_num = n;
}
int main() {
input();
rep(i, 1, D + 1) {
// score = 0;
dfs(2, i);
printf("%d\n", next_num + 1);
// printf("%d\n", score);
}
return 0;
}
void input() {
cin >> D;
rep(i, 0, 26) cin >> c[i];
rep(i, 0, D) { rep(i2, 0, 26) cin >> s[i][i2]; }
}
| replace | 100 | 101 | 100 | 101 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
static const int D = 365;
static const int ntype = 26;
class Contest {
public:
Contest() { last = 0; }
int s[D + 1];
int c;
int last;
};
Contest contest[27];
void Input() {
int d;
cin >> d;
for (int i = 1; i <= ntype; ++i) {
int t;
cin >> t;
contest[i].c = t;
}
for (int day = 1; day <= D; ++day) {
for (int type = 1; type <= ntype; ++type) {
int t;
cin >> t;
contest[type].s[day] = t;
}
}
}
int v[D + 1];
int gene[50][D + 1];
int next_gene[50][D + 1];
int elete[D + 1];
vector<pair<double, int>> cumfreq;
void randGene(int i) {
for (int day = 1; day <= D; ++day) {
gene[i][day] = rand() % 26 + 1;
}
}
void Init() {
for (int i = 0; i < 50; ++i) {
randGene(i);
}
}
void Greedy(int p) {
vector<int> l(ntype + 1, 0);
int score = 0;
for (int d = 1; d <= D; ++d) {
for (int i = 1; i <= ntype; ++i)
score -= contest[i].c * (d - l[i]);
int temp = score;
int t = -1;
for (int i = 1; i <= ntype; ++i) {
int k = contest[i].s[d] + contest[i].c * (d - l[i]) + score;
if (k > temp) {
temp = k;
t = i;
}
}
gene[p][d] = t;
l[t] = d;
score += temp;
}
}
void decoding(int i) {
v[0] = 0;
for (int day = 1; day <= D; ++day) {
v[day] = 0;
int type = gene[i][day];
v[day] += contest[type].s[day];
contest[type].last = day;
for (int t = 1; t <= ntype; ++t) {
v[day] -= contest[t].c * (day - contest[t].last);
}
v[day] += v[day - 1];
}
v[D] = v[D] < 0 ? 1 : v[D];
cumfreq.push_back(make_pair((double)v[D], i));
}
void CrossOver(int ni, int ci, int cj) {
for (int i = 1; i <= D; ++i) {
double p = rand() / RAND_MAX;
if (p > 0.5)
next_gene[ni][i] = gene[ci][i];
else
next_gene[ni][i] = gene[cj][i];
}
}
void Mutation(int i) {
/*cout<<i<<endl;
reverse(next_gene+i+1,next_gene+i+D+1);
cout<<"mutation"<<endl;*/
int tgene[D + 1];
for (int d = 1; d <= D; ++d)
tgene[d] = next_gene[i][d];
for (int d = 1; d <= D; ++d)
next_gene[i][d] = tgene[D - d + 1];
}
void calcCumFreq() {
double sum = 0;
sort(cumfreq.begin(), cumfreq.end());
// for(int i=0;i<cumfreq.size();++i) cout<<i<<"個体: "
// <<cumfreq[i].first<<endl;
for (int i = 0; i < 50; ++i) {
sum += cumfreq[i].first;
}
for (int i = 0; i < 50; ++i) {
cumfreq[i].first /= sum;
}
for (int i = 0; i < 49; ++i) {
cumfreq[i + 1].first += cumfreq[i].first;
}
}
int Select() {
double a = (double)rand() / RAND_MAX;
for (int i = 0; i < 49; ++i) {
if (cumfreq[i + 1].first > a)
return cumfreq[i].second;
}
return cumfreq[49].second;
}
void GA() {
static const double crossRate = 0.7;
static const double mutationRate = 0.6;
for (int i = 0; i < 50; ++i) {
int pi = Select();
double crossrand = (double)rand() / RAND_MAX;
if (crossrand < crossRate) {
int pj = Select();
CrossOver(i, pi, pj);
} else {
for (int j = 1; j <= D; ++j)
next_gene[i][j] = gene[pi][j];
}
double murand = (double)rand() / RAND_MAX;
if (murand < mutationRate) {
Mutation(i);
}
}
cumfreq.resize(0);
for (int i = 0; i < 50; ++i) {
for (int j = 1; j <= D; ++j) {
gene[i][j] = next_gene[i][j];
}
decoding(i);
}
calcCumFreq();
}
int main() {
srand(700);
Input();
Init();
for (int i = 0; i < 5; ++i)
Greedy(i);
for (int i = 0; i < 50; ++i) {
decoding(i);
}
calcCumFreq();
for (int i = 0; i < 5000; ++i) {
GA();
}
for (int i = 0; i < 50; ++i) {
decoding(i);
}
calcCumFreq();
int e = cumfreq[49].second;
for (int i = 1; i <= D; ++i)
cout << gene[e][i] << endl;
}
| #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
static const int D = 365;
static const int ntype = 26;
class Contest {
public:
Contest() { last = 0; }
int s[D + 1];
int c;
int last;
};
Contest contest[27];
void Input() {
int d;
cin >> d;
for (int i = 1; i <= ntype; ++i) {
int t;
cin >> t;
contest[i].c = t;
}
for (int day = 1; day <= D; ++day) {
for (int type = 1; type <= ntype; ++type) {
int t;
cin >> t;
contest[type].s[day] = t;
}
}
}
int v[D + 1];
int gene[50][D + 1];
int next_gene[50][D + 1];
int elete[D + 1];
vector<pair<double, int>> cumfreq;
void randGene(int i) {
for (int day = 1; day <= D; ++day) {
gene[i][day] = rand() % 26 + 1;
}
}
void Init() {
for (int i = 0; i < 50; ++i) {
randGene(i);
}
}
void Greedy(int p) {
vector<int> l(ntype + 1, 0);
int score = 0;
for (int d = 1; d <= D; ++d) {
for (int i = 1; i <= ntype; ++i)
score -= contest[i].c * (d - l[i]);
int temp = score;
int t = -1;
for (int i = 1; i <= ntype; ++i) {
int k = contest[i].s[d] + contest[i].c * (d - l[i]) + score;
if (k > temp) {
temp = k;
t = i;
}
}
gene[p][d] = t;
l[t] = d;
score += temp;
}
}
void decoding(int i) {
v[0] = 0;
for (int day = 1; day <= D; ++day) {
v[day] = 0;
int type = gene[i][day];
v[day] += contest[type].s[day];
contest[type].last = day;
for (int t = 1; t <= ntype; ++t) {
v[day] -= contest[t].c * (day - contest[t].last);
}
v[day] += v[day - 1];
}
v[D] = v[D] < 0 ? 1 : v[D];
cumfreq.push_back(make_pair((double)v[D], i));
}
void CrossOver(int ni, int ci, int cj) {
for (int i = 1; i <= D; ++i) {
double p = rand() / RAND_MAX;
if (p > 0.5)
next_gene[ni][i] = gene[ci][i];
else
next_gene[ni][i] = gene[cj][i];
}
}
void Mutation(int i) {
/*cout<<i<<endl;
reverse(next_gene+i+1,next_gene+i+D+1);
cout<<"mutation"<<endl;*/
int tgene[D + 1];
for (int d = 1; d <= D; ++d)
tgene[d] = next_gene[i][d];
for (int d = 1; d <= D; ++d)
next_gene[i][d] = tgene[D - d + 1];
}
void calcCumFreq() {
double sum = 0;
sort(cumfreq.begin(), cumfreq.end());
// for(int i=0;i<cumfreq.size();++i) cout<<i<<"個体: "
// <<cumfreq[i].first<<endl;
for (int i = 0; i < 50; ++i) {
sum += cumfreq[i].first;
}
for (int i = 0; i < 50; ++i) {
cumfreq[i].first /= sum;
}
for (int i = 0; i < 49; ++i) {
cumfreq[i + 1].first += cumfreq[i].first;
}
}
int Select() {
double a = (double)rand() / RAND_MAX;
for (int i = 0; i < 49; ++i) {
if (cumfreq[i + 1].first > a)
return cumfreq[i].second;
}
return cumfreq[49].second;
}
void GA() {
static const double crossRate = 0.7;
static const double mutationRate = 0.6;
for (int i = 0; i < 50; ++i) {
int pi = Select();
double crossrand = (double)rand() / RAND_MAX;
if (crossrand < crossRate) {
int pj = Select();
CrossOver(i, pi, pj);
} else {
for (int j = 1; j <= D; ++j)
next_gene[i][j] = gene[pi][j];
}
double murand = (double)rand() / RAND_MAX;
if (murand < mutationRate) {
Mutation(i);
}
}
cumfreq.resize(0);
for (int i = 0; i < 50; ++i) {
for (int j = 1; j <= D; ++j) {
gene[i][j] = next_gene[i][j];
}
decoding(i);
}
calcCumFreq();
}
int main() {
srand(700);
Input();
Init();
for (int i = 0; i < 5; ++i)
Greedy(i);
for (int i = 0; i < 50; ++i) {
decoding(i);
}
calcCumFreq();
for (int i = 0; i < 4500; ++i) {
GA();
}
for (int i = 0; i < 50; ++i) {
decoding(i);
}
calcCumFreq();
int e = cumfreq[49].second;
for (int i = 1; i <= D; ++i)
cout << gene[e][i] << endl;
}
| replace | 176 | 177 | 176 | 177 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define INF 1e9
static const int seed = 6;
static const int D = 365;
static const int ntype = 26;
static const int population_size = 100;
int gene[population_size][D + 1];
int next_gene[population_size][D + 1];
static int elete[D + 1];
static long long elete_score = -INF;
static const int init_n_greedyGene = 1;
static double crossRate = 0.7;
static double mutationRate = 0.3;
static double elete_select_prob = 0.05;
static const double after_crossRate = 0.8;
static const double after_mutationRate = 0.9;
static const double after_elete_select_prob = 0.05;
static const int n_mutation_p = 300;
vector<pair<double, int>> cumfreq;
// Info
int change_time = 0;
int crossover_time = 0;
int mutation_time = 0;
int total_cross = 0;
int different_cross = 0;
int change_elete = 0;
void Info() {
cout << "change: " << change_time << endl;
cout << "crossover: " << crossover_time << endl;
cout << "mutation: " << mutation_time << endl;
cout << "total_cross: " << total_cross << endl;
cout << "different_cross: " << different_cross << endl;
cout << "elete_score: " << elete_score << endl;
cout << "change_elete: " << change_elete << endl;
}
class Contest {
public:
Contest() { last = 0; }
int s[D + 1];
int c;
int last;
};
Contest contest[ntype + 1];
void Input() {
int d;
cin >> d;
for (int i = 1; i <= ntype; ++i) {
int t;
cin >> t;
contest[i].c = t;
}
for (int day = 1; day <= D; ++day) {
for (int type = 1; type <= ntype; ++type) {
int t;
cin >> t;
contest[type].s[day] = t;
}
}
}
void randGene(int p) {
for (int day = 1; day <= D; ++day) {
gene[p][day] = rand() % ntype + 1;
}
}
void greedyGene(int p) {
vector<int> l(ntype + 1, 0);
long long score = 0;
for (int d = 1; d <= D; ++d) {
for (int i = 1; i <= ntype; ++i)
score -= contest[i].c * (d - l[i]);
long long temp = score;
int t = -1;
for (int i = 1; i <= ntype; ++i) {
long long k = contest[i].s[d] + contest[i].c * (d - l[i]) + score;
if (k > temp) {
temp = k;
t = i;
}
}
gene[p][d] = t;
l[t] = d;
}
}
int evaluate(int i) {
int v[D + 1];
v[0] = 0;
vector<int> l(ntype + 1, 0);
for (int day = 1; day <= D; ++day) {
v[day] = v[day - 1];
int type = gene[i][day];
v[day] += contest[type].s[day];
l[type] = day;
for (int t = 1; t <= ntype; ++t) {
v[day] -= contest[t].c * (day - l[t]);
}
}
return v[D];
}
void calcCumFreq() {
int n = cumfreq.size();
sort(cumfreq.begin(), cumfreq.end());
// change elete
++change_elete;
if (elete_score < (int)cumfreq[n - 1].first) {
++change_time;
elete_score = (int)cumfreq[n - 1].first;
int i = cumfreq[n - 1].second;
for (int d = 1; d <= D; ++d)
elete[d] = gene[i][d];
}
double cprob = 1 - elete_select_prob;
double cn = n * (n - 1) / 2.0;
cprob /= cn;
for (int i = 0; i < n - 1; ++i) {
cumfreq[i].first = cprob;
}
cumfreq[n - 1].first = elete_select_prob;
for (int i = 0; i < n - 1; ++i) {
cumfreq[i + 1].first += cumfreq[i].first;
}
}
void CrossOver(int gene_i, int ci, int cj) {
++crossover_time;
for (int d = 1; d <= D; ++d)
next_gene[gene_i][d] = gene[ci][d];
int p = rand() % D + 1;
/*
change
*/
++total_cross;
if (next_gene[gene_i][p] != gene[cj][p]) {
++different_cross;
/*
cout<<ci<<" "<<cj<<endl;
cout<<"from: "<<next_gene[gene_i][p]<<" to: "<<gene[cj][p]<<endl;;
*/
next_gene[gene_i][p] = gene[cj][p];
}
}
void Mutation(int ngene_i) {
++mutation_time;
for (int i = 0; i < n_mutation_p; ++i) {
int p = rand() % D + 1;
next_gene[ngene_i][p] = rand() % ntype + 1;
}
}
int Select() {
double a = (double)rand() / RAND_MAX;
int t = cumfreq.size() - 1;
for (int i = 0; i < t; ++i) {
if (cumfreq[i + 1].first > a)
return cumfreq[i].second;
}
return cumfreq[t].second;
}
void Init(int nGreedy) {
for (int i = 0; i < nGreedy; ++i) {
greedyGene(i);
}
for (int i = nGreedy; i < population_size; ++i) {
randGene(i);
}
}
void makeCumFreq() {
for (int i = 0; i < population_size; ++i) {
double e = (double)evaluate(i);
cumfreq.push_back(make_pair(e, i));
}
calcCumFreq();
}
void makeNextGeneration() {
for (int d = 1; d <= D; ++d)
next_gene[0][d] = elete[d];
for (int i = 1; i < population_size; ++i) {
int pi = Select();
double crossrand = (double)rand() / RAND_MAX;
if (crossrand < crossRate) {
int pj = Select();
while (pi == pj)
pj = Select();
CrossOver(i, pi, pj);
} else {
for (int j = 1; j <= D; ++j)
next_gene[i][j] = gene[pi][j];
}
double murand = (double)rand() / RAND_MAX;
if (murand < mutationRate) {
Mutation(i);
}
}
for (int i = 0; i < 50; ++i) {
for (int j = 1; j <= D; ++j) {
gene[i][j] = next_gene[i][j];
}
}
}
void GA(int n) {
for (int i = 0; i < n; ++i) {
makeCumFreq();
makeNextGeneration();
cumfreq.resize(0);
}
}
void Output() {
for (int d = 1; d <= D; ++d)
cout << elete[d] << endl;
}
int main() {
srand(seed);
Input();
Init(1);
GA(3000);
/*crossRate=after_crossRate;
mutationRate=after_mutationRate;
elete_select_prob=after_elete_select_prob;
GA(1000);*/
Output();
// Info();
} | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define INF 1e9
static const int seed = 6;
static const int D = 365;
static const int ntype = 26;
static const int population_size = 100;
int gene[population_size][D + 1];
int next_gene[population_size][D + 1];
static int elete[D + 1];
static long long elete_score = -INF;
static const int init_n_greedyGene = 1;
static double crossRate = 0.7;
static double mutationRate = 0.3;
static double elete_select_prob = 0.05;
static const double after_crossRate = 0.8;
static const double after_mutationRate = 0.9;
static const double after_elete_select_prob = 0.05;
static const int n_mutation_p = 300;
vector<pair<double, int>> cumfreq;
// Info
int change_time = 0;
int crossover_time = 0;
int mutation_time = 0;
int total_cross = 0;
int different_cross = 0;
int change_elete = 0;
void Info() {
cout << "change: " << change_time << endl;
cout << "crossover: " << crossover_time << endl;
cout << "mutation: " << mutation_time << endl;
cout << "total_cross: " << total_cross << endl;
cout << "different_cross: " << different_cross << endl;
cout << "elete_score: " << elete_score << endl;
cout << "change_elete: " << change_elete << endl;
}
class Contest {
public:
Contest() { last = 0; }
int s[D + 1];
int c;
int last;
};
Contest contest[ntype + 1];
void Input() {
int d;
cin >> d;
for (int i = 1; i <= ntype; ++i) {
int t;
cin >> t;
contest[i].c = t;
}
for (int day = 1; day <= D; ++day) {
for (int type = 1; type <= ntype; ++type) {
int t;
cin >> t;
contest[type].s[day] = t;
}
}
}
void randGene(int p) {
for (int day = 1; day <= D; ++day) {
gene[p][day] = rand() % ntype + 1;
}
}
void greedyGene(int p) {
vector<int> l(ntype + 1, 0);
long long score = 0;
for (int d = 1; d <= D; ++d) {
for (int i = 1; i <= ntype; ++i)
score -= contest[i].c * (d - l[i]);
long long temp = score;
int t = -1;
for (int i = 1; i <= ntype; ++i) {
long long k = contest[i].s[d] + contest[i].c * (d - l[i]) + score;
if (k > temp) {
temp = k;
t = i;
}
}
gene[p][d] = t;
l[t] = d;
}
}
int evaluate(int i) {
int v[D + 1];
v[0] = 0;
vector<int> l(ntype + 1, 0);
for (int day = 1; day <= D; ++day) {
v[day] = v[day - 1];
int type = gene[i][day];
v[day] += contest[type].s[day];
l[type] = day;
for (int t = 1; t <= ntype; ++t) {
v[day] -= contest[t].c * (day - l[t]);
}
}
return v[D];
}
void calcCumFreq() {
int n = cumfreq.size();
sort(cumfreq.begin(), cumfreq.end());
// change elete
++change_elete;
if (elete_score < (int)cumfreq[n - 1].first) {
++change_time;
elete_score = (int)cumfreq[n - 1].first;
int i = cumfreq[n - 1].second;
for (int d = 1; d <= D; ++d)
elete[d] = gene[i][d];
}
double cprob = 1 - elete_select_prob;
double cn = n * (n - 1) / 2.0;
cprob /= cn;
for (int i = 0; i < n - 1; ++i) {
cumfreq[i].first = cprob;
}
cumfreq[n - 1].first = elete_select_prob;
for (int i = 0; i < n - 1; ++i) {
cumfreq[i + 1].first += cumfreq[i].first;
}
}
void CrossOver(int gene_i, int ci, int cj) {
++crossover_time;
for (int d = 1; d <= D; ++d)
next_gene[gene_i][d] = gene[ci][d];
int p = rand() % D + 1;
/*
change
*/
++total_cross;
if (next_gene[gene_i][p] != gene[cj][p]) {
++different_cross;
/*
cout<<ci<<" "<<cj<<endl;
cout<<"from: "<<next_gene[gene_i][p]<<" to: "<<gene[cj][p]<<endl;;
*/
next_gene[gene_i][p] = gene[cj][p];
}
}
void Mutation(int ngene_i) {
++mutation_time;
for (int i = 0; i < n_mutation_p; ++i) {
int p = rand() % D + 1;
next_gene[ngene_i][p] = rand() % ntype + 1;
}
}
int Select() {
double a = (double)rand() / RAND_MAX;
int t = cumfreq.size() - 1;
for (int i = 0; i < t; ++i) {
if (cumfreq[i + 1].first > a)
return cumfreq[i].second;
}
return cumfreq[t].second;
}
void Init(int nGreedy) {
for (int i = 0; i < nGreedy; ++i) {
greedyGene(i);
}
for (int i = nGreedy; i < population_size; ++i) {
randGene(i);
}
}
void makeCumFreq() {
for (int i = 0; i < population_size; ++i) {
double e = (double)evaluate(i);
cumfreq.push_back(make_pair(e, i));
}
calcCumFreq();
}
void makeNextGeneration() {
for (int d = 1; d <= D; ++d)
next_gene[0][d] = elete[d];
for (int i = 1; i < population_size; ++i) {
int pi = Select();
double crossrand = (double)rand() / RAND_MAX;
if (crossrand < crossRate) {
int pj = Select();
while (pi == pj)
pj = Select();
CrossOver(i, pi, pj);
} else {
for (int j = 1; j <= D; ++j)
next_gene[i][j] = gene[pi][j];
}
double murand = (double)rand() / RAND_MAX;
if (murand < mutationRate) {
Mutation(i);
}
}
for (int i = 0; i < 50; ++i) {
for (int j = 1; j <= D; ++j) {
gene[i][j] = next_gene[i][j];
}
}
}
void GA(int n) {
for (int i = 0; i < n; ++i) {
makeCumFreq();
makeNextGeneration();
cumfreq.resize(0);
}
}
void Output() {
for (int d = 1; d <= D; ++d)
cout << elete[d] << endl;
}
int main() {
srand(seed);
Input();
Init(1);
GA(1000);
Output();
// Info();
} | replace | 236 | 241 | 236 | 237 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define INF 1e9
static const int seed = 6;
static const int D = 365;
static const int ntype = 26;
static int ans[D + 1];
static int max_score = -INF;
static int t = 1e6;
class Contest {
public:
Contest() { last = 0; }
int s[D + 1];
int c;
int last;
};
static Contest contest[ntype + 1];
void Input() {
int d;
cin >> d;
for (int i = 1; i <= ntype; ++i) {
int t;
cin >> t;
contest[i].c = t;
}
for (int day = 1; day <= D; ++day) {
for (int type = 1; type <= ntype; ++type) {
int t;
cin >> t;
contest[type].s[day] = t;
}
}
}
int evaluate() {
int sum = 0;
vector<int> l(ntype + 1, 0);
for (int day = 1; day <= D; ++day) {
int type = ans[day];
sum += contest[type].s[day];
l[type] = day;
for (int t = 1; t <= ntype; ++t) {
sum -= contest[t].c * (day - l[t]);
}
}
return sum;
}
void Output() {
for (int d = 1; d <= D; ++d)
cout << ans[d] << endl;
}
void Init() {
for (int d = 1; d <= D; ++d)
ans[d] = rand() % ntype + 1;
}
void solve(int time) {
max_score = evaluate();
for (int i = 0; i < time; ++i) {
int p = rand() % D + 1;
int temp = ans[p];
ans[p] = rand() % ntype + 1;
int temp_score = evaluate();
if (max_score < temp_score)
max_score = temp_score;
else
ans[p] = temp;
}
}
int main() {
srand(seed);
Input();
Init();
solve(t);
Output();
}
| #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define INF 1e9
static const int seed = 6;
static const int D = 365;
static const int ntype = 26;
static int ans[D + 1];
static int max_score = -INF;
static int t = 1e4;
class Contest {
public:
Contest() { last = 0; }
int s[D + 1];
int c;
int last;
};
static Contest contest[ntype + 1];
void Input() {
int d;
cin >> d;
for (int i = 1; i <= ntype; ++i) {
int t;
cin >> t;
contest[i].c = t;
}
for (int day = 1; day <= D; ++day) {
for (int type = 1; type <= ntype; ++type) {
int t;
cin >> t;
contest[type].s[day] = t;
}
}
}
int evaluate() {
int sum = 0;
vector<int> l(ntype + 1, 0);
for (int day = 1; day <= D; ++day) {
int type = ans[day];
sum += contest[type].s[day];
l[type] = day;
for (int t = 1; t <= ntype; ++t) {
sum -= contest[t].c * (day - l[t]);
}
}
return sum;
}
void Output() {
for (int d = 1; d <= D; ++d)
cout << ans[d] << endl;
}
void Init() {
for (int d = 1; d <= D; ++d)
ans[d] = rand() % ntype + 1;
}
void solve(int time) {
max_score = evaluate();
for (int i = 0; i < time; ++i) {
int p = rand() % D + 1;
int temp = ans[p];
ans[p] = rand() % ntype + 1;
int temp_score = evaluate();
if (max_score < temp_score)
max_score = temp_score;
else
ans[p] = temp;
}
}
int main() {
srand(seed);
Input();
Init();
solve(t);
Output();
}
| replace | 12 | 13 | 12 | 13 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define INF 1e9
static const int seed = 6;
static const int D = 365;
static const int ntype = 26;
static int ans[D + 1];
static int max_score = -INF;
static int t = 130000;
class Contest {
public:
Contest() { last = 0; }
int s[D + 1];
int c;
int last;
};
static Contest contest[ntype + 1];
void Input() {
int d;
cin >> d;
for (int i = 1; i <= ntype; ++i) {
int t;
cin >> t;
contest[i].c = t;
}
for (int day = 1; day <= D; ++day) {
for (int type = 1; type <= ntype; ++type) {
int t;
cin >> t;
contest[type].s[day] = t;
}
}
}
int evaluate() {
int sum = 0;
vector<int> l(ntype + 1, 0);
for (int day = 1; day <= D; ++day) {
int type = ans[day];
sum += contest[type].s[day];
l[type] = day;
for (int t = 1; t <= ntype; ++t) {
sum -= contest[t].c * (day - l[t]);
}
}
return sum;
}
void Output() {
for (int d = 1; d <= D; ++d)
cout << ans[d] << endl;
}
void Init() {
for (int d = 1; d <= D; ++d)
ans[d] = rand() % ntype + 1;
}
void Greedy() {
vector<int> l(ntype + 1, 0);
int score = 0;
for (int d = 1; d <= D; ++d) {
for (int i = 1; i <= ntype; ++i)
score -= contest[i].c * (d - l[i]);
int temp = score;
int t = -1;
for (int i = 1; i <= ntype; ++i) {
int k = contest[i].s[d] + contest[i].c * (d - l[i]) + score;
if (k > temp) {
temp = k;
t = i;
}
}
ans[d] = t;
l[t] = d;
}
}
void change() {
int p = rand() % D + 1;
int temp = ans[p];
ans[p] = rand() % ntype + 1;
int temp_score = evaluate();
if (max_score < temp_score)
max_score = temp_score;
else
ans[p] = temp;
}
void swap() {
int p1 = rand() % D + 1;
int p2 = rand() % D + 1;
while (p1 == p2)
p2 = rand() % D + 1;
int temp = ans[p1];
ans[p1] = ans[p2];
ans[p2] = temp;
int temp_score = evaluate();
if (max_score < temp_score)
max_score = temp_score;
else {
ans[p2] = ans[p1];
ans[p1] = temp;
}
}
void solve(int times) {
max_score = evaluate();
for (int i = 0; i < times; ++i) {
swap();
change();
}
}
int main() {
srand(seed);
Input();
Greedy();
solve(t);
Output();
}
| #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define INF 1e9
static const int seed = 6;
static const int D = 365;
static const int ntype = 26;
static int ans[D + 1];
static int max_score = -INF;
static int t = 110000;
class Contest {
public:
Contest() { last = 0; }
int s[D + 1];
int c;
int last;
};
static Contest contest[ntype + 1];
void Input() {
int d;
cin >> d;
for (int i = 1; i <= ntype; ++i) {
int t;
cin >> t;
contest[i].c = t;
}
for (int day = 1; day <= D; ++day) {
for (int type = 1; type <= ntype; ++type) {
int t;
cin >> t;
contest[type].s[day] = t;
}
}
}
int evaluate() {
int sum = 0;
vector<int> l(ntype + 1, 0);
for (int day = 1; day <= D; ++day) {
int type = ans[day];
sum += contest[type].s[day];
l[type] = day;
for (int t = 1; t <= ntype; ++t) {
sum -= contest[t].c * (day - l[t]);
}
}
return sum;
}
void Output() {
for (int d = 1; d <= D; ++d)
cout << ans[d] << endl;
}
void Init() {
for (int d = 1; d <= D; ++d)
ans[d] = rand() % ntype + 1;
}
void Greedy() {
vector<int> l(ntype + 1, 0);
int score = 0;
for (int d = 1; d <= D; ++d) {
for (int i = 1; i <= ntype; ++i)
score -= contest[i].c * (d - l[i]);
int temp = score;
int t = -1;
for (int i = 1; i <= ntype; ++i) {
int k = contest[i].s[d] + contest[i].c * (d - l[i]) + score;
if (k > temp) {
temp = k;
t = i;
}
}
ans[d] = t;
l[t] = d;
}
}
void change() {
int p = rand() % D + 1;
int temp = ans[p];
ans[p] = rand() % ntype + 1;
int temp_score = evaluate();
if (max_score < temp_score)
max_score = temp_score;
else
ans[p] = temp;
}
void swap() {
int p1 = rand() % D + 1;
int p2 = rand() % D + 1;
while (p1 == p2)
p2 = rand() % D + 1;
int temp = ans[p1];
ans[p1] = ans[p2];
ans[p2] = temp;
int temp_score = evaluate();
if (max_score < temp_score)
max_score = temp_score;
else {
ans[p2] = ans[p1];
ans[p1] = temp;
}
}
void solve(int times) {
max_score = evaluate();
for (int i = 0; i < times; ++i) {
swap();
change();
}
}
int main() {
srand(seed);
Input();
Greedy();
solve(t);
Output();
}
| replace | 12 | 13 | 12 | 13 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define INF 1e9
static const int seed = 20;
static const int D = 365;
static const int ntype = 26;
static int ans[D + 1];
static int max_score = -INF;
static int t = 130000;
class Contest {
public:
Contest() { last = 0; }
int s[D + 1];
int c;
int last;
};
static Contest contest[ntype + 1];
void Input() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int d;
cin >> d;
for (int i = 1; i <= ntype; ++i) {
int t;
cin >> t;
contest[i].c = t;
}
for (int day = 1; day <= D; ++day) {
for (int type = 1; type <= ntype; ++type) {
int t;
cin >> t;
contest[type].s[day] = t;
}
}
}
int evaluate() {
int sum = 0;
vector<int> l(ntype + 1, 0);
for (int day = 1; day <= D; ++day) {
int type = ans[day];
sum += contest[type].s[day];
l[type] = day;
for (int t = 1; t <= ntype; ++t) {
sum -= contest[t].c * (day - l[t]);
}
}
return sum;
}
void Output() {
ios_base::sync_with_stdio(false);
cin.tie(0);
for (int d = 1; d <= D; ++d)
cout << ans[d] << '\n';
}
void Init() {
for (int d = 1; d <= D; ++d)
ans[d] = rand() % ntype + 1;
}
void Greedy() {
vector<int> l(ntype + 1, 0);
int score = 0;
for (int d = 1; d <= D; ++d) {
for (int i = 1; i <= ntype; ++i)
score -= contest[i].c * (d - l[i]);
int temp = score;
int t = -1;
for (int i = 1; i <= ntype; ++i) {
int k = contest[i].s[d] + contest[i].c * (d - l[i]) + score;
if (k > temp) {
temp = k;
t = i;
}
}
ans[d] = t;
l[t] = d;
}
}
void change() {
int p = rand() % D + 1;
int temp = ans[p];
ans[p] = rand() % ntype + 1;
int temp_score = evaluate();
if (max_score < temp_score)
max_score = temp_score;
else
ans[p] = temp;
}
void swap() {
int p1 = rand() % D + 1;
int p2 = rand() % D + 1;
while (p1 == p2)
p2 = rand() % D + 1;
int temp = ans[p1];
ans[p1] = ans[p2];
ans[p2] = temp;
int temp_score = evaluate();
if (max_score < temp_score)
max_score = temp_score;
else {
ans[p2] = ans[p1];
ans[p1] = temp;
}
}
void solve(int times) {
max_score = evaluate();
for (int i = 0; i < times; ++i) {
swap();
change();
}
}
int main() {
srand(seed);
Input();
Greedy();
solve(t);
for (int i = 0; i < 5000; ++i)
change();
Output();
}
| #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define INF 1e9
static const int seed = 20;
static const int D = 365;
static const int ntype = 26;
static int ans[D + 1];
static int max_score = -INF;
static int t = 130000;
class Contest {
public:
Contest() { last = 0; }
int s[D + 1];
int c;
int last;
};
static Contest contest[ntype + 1];
void Input() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int d;
cin >> d;
for (int i = 1; i <= ntype; ++i) {
int t;
cin >> t;
contest[i].c = t;
}
for (int day = 1; day <= D; ++day) {
for (int type = 1; type <= ntype; ++type) {
int t;
cin >> t;
contest[type].s[day] = t;
}
}
}
int evaluate() {
int sum = 0;
vector<int> l(ntype + 1, 0);
for (int day = 1; day <= D; ++day) {
int type = ans[day];
sum += contest[type].s[day];
l[type] = day;
for (int t = 1; t <= ntype; ++t) {
sum -= contest[t].c * (day - l[t]);
}
}
return sum;
}
void Output() {
ios_base::sync_with_stdio(false);
cin.tie(0);
for (int d = 1; d <= D; ++d)
cout << ans[d] << '\n';
}
void Init() {
for (int d = 1; d <= D; ++d)
ans[d] = rand() % ntype + 1;
}
void Greedy() {
vector<int> l(ntype + 1, 0);
int score = 0;
for (int d = 1; d <= D; ++d) {
for (int i = 1; i <= ntype; ++i)
score -= contest[i].c * (d - l[i]);
int temp = score;
int t = -1;
for (int i = 1; i <= ntype; ++i) {
int k = contest[i].s[d] + contest[i].c * (d - l[i]) + score;
if (k > temp) {
temp = k;
t = i;
}
}
ans[d] = t;
l[t] = d;
}
}
void change() {
int p = rand() % D + 1;
int temp = ans[p];
ans[p] = rand() % ntype + 1;
int temp_score = evaluate();
if (max_score < temp_score)
max_score = temp_score;
else
ans[p] = temp;
}
void swap() {
int p1 = rand() % D + 1;
int p2 = rand() % D + 1;
while (p1 == p2)
p2 = rand() % D + 1;
int temp = ans[p1];
ans[p1] = ans[p2];
ans[p2] = temp;
int temp_score = evaluate();
if (max_score < temp_score)
max_score = temp_score;
else {
ans[p2] = ans[p1];
ans[p1] = temp;
}
}
void solve(int times) {
max_score = evaluate();
for (int i = 0; i < times; ++i) {
swap();
change();
}
}
int main() {
srand(seed);
Input();
Greedy();
solve(t);
for (int i = 0; i < 3000; ++i)
change();
Output();
}
| replace | 129 | 130 | 129 | 130 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x, vector<x>, greater<x>>
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
#define vtpl(x, y, z) vector<tuple<x, y, z>>
#define rev(x) reverse(x);
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
using vpl = vector<pl>;
using vvpl = vector<vpl>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9 + 10;
const ll INF = 4e18;
const ll dy[9] = {1, 0, -1, 0, 1, 1, -1, -1, 0};
const ll dx[9] = {0, -1, 0, 1, 1, -1, 1, -1, 0};
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ll d;
cin >> d;
vl c(26);
rep(i, 26) cin >> c[i];
vvl s(d, vl(26));
rep(i, d) rep(j, 26) cin >> s[i][j];
vector<set<ll>> ch(26);
rep(i, 26) ch[i].ins(-1), ch[i].ins(d);
vl days(d);
ll pre = 0;
vl last(26, -1);
rep(i, d) {
ll t = 0;
ll maxi = -INF;
rep(j, 26) {
ll p = s[i][j];
rep(k, 26) {
if (k == j)
continue;
p -= c[k] * (i - last[k]);
}
if (chmax(maxi, p))
t = j;
}
days[i] = t;
last[t] = i;
}
rep(i, d) {
ll t = days[i];
pre += s[i][t];
ch[t].ins(i);
days[i] = t;
}
ll score = pre;
rep(i, 26) {
ll mini = 0;
ll pp = -1;
for (auto a : ch[i]) {
mini += (a - pp) * (a - pp - 1) / 2;
pp = a;
}
score -= c[i] * mini;
}
// rep(i,d)cout << days[i] <<endl;
ll q = 9000000;
while (q--) {
ll x = rand() % d, y = rand() % 26;
if (days[x] == y)
y += 1, y %= 26;
// cout << x <<" " << y <<endl;
ll old = days[x];
pre -= s[x][days[x]];
ch[days[x]].erase(x);
days[x] = y;
pre += s[x][y];
ch[y].ins(x);
ll p = 0;
rep(i, 26) {
ll mini = 0;
ll pp = -1;
for (auto a : ch[i]) {
mini += (a - pp) * (a - pp - 1) / 2;
pp = a;
}
p += c[i] * mini;
}
// if(q>299990)cout << score <<endl;
if (pre - p >= score) {
score = pre - p;
} else {
ch[y].erase(x);
pre -= s[x][y];
days[x] = old;
ch[days[x]].ins(x);
pre += s[x][old];
}
}
rep(i, d) cout << days[i] + 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (ll i = 0; i < n; i++)
#define repl(i, l, r) for (ll i = (l); i < (r); i++)
#define per(i, n) for (ll i = n - 1; i >= 0; i--)
#define perl(i, r, l) for (ll i = r - 1; i >= l; i--)
#define fi first
#define se second
#define pb push_back
#define ins insert
#define pqueue(x) priority_queue<x, vector<x>, greater<x>>
#define all(x) (x).begin(), (x).end()
#define CST(x) cout << fixed << setprecision(x)
#define vtpl(x, y, z) vector<tuple<x, y, z>>
#define rev(x) reverse(x);
using ll = long long;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pl = pair<ll, ll>;
using vpl = vector<pl>;
using vvpl = vector<vpl>;
const ll MOD = 1000000007;
const ll MOD9 = 998244353;
const int inf = 1e9 + 10;
const ll INF = 4e18;
const ll dy[9] = {1, 0, -1, 0, 1, 1, -1, -1, 0};
const ll dx[9] = {0, -1, 0, 1, 1, -1, 1, -1, 0};
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
ll d;
cin >> d;
vl c(26);
rep(i, 26) cin >> c[i];
vvl s(d, vl(26));
rep(i, d) rep(j, 26) cin >> s[i][j];
vector<set<ll>> ch(26);
rep(i, 26) ch[i].ins(-1), ch[i].ins(d);
vl days(d);
ll pre = 0;
vl last(26, -1);
rep(i, d) {
ll t = 0;
ll maxi = -INF;
rep(j, 26) {
ll p = s[i][j];
rep(k, 26) {
if (k == j)
continue;
p -= c[k] * (i - last[k]);
}
if (chmax(maxi, p))
t = j;
}
days[i] = t;
last[t] = i;
}
rep(i, d) {
ll t = days[i];
pre += s[i][t];
ch[t].ins(i);
days[i] = t;
}
ll score = pre;
rep(i, 26) {
ll mini = 0;
ll pp = -1;
for (auto a : ch[i]) {
mini += (a - pp) * (a - pp - 1) / 2;
pp = a;
}
score -= c[i] * mini;
}
// rep(i,d)cout << days[i] <<endl;
ll q = 950000;
while (q--) {
ll x = rand() % d, y = rand() % 26;
if (days[x] == y)
y += 1, y %= 26;
// cout << x <<" " << y <<endl;
ll old = days[x];
pre -= s[x][days[x]];
ch[days[x]].erase(x);
days[x] = y;
pre += s[x][y];
ch[y].ins(x);
ll p = 0;
rep(i, 26) {
ll mini = 0;
ll pp = -1;
for (auto a : ch[i]) {
mini += (a - pp) * (a - pp - 1) / 2;
pp = a;
}
p += c[i] * mini;
}
// if(q>299990)cout << score <<endl;
if (pre - p >= score) {
score = pre - p;
} else {
ch[y].erase(x);
pre -= s[x][y];
days[x] = old;
ch[days[x]].ins(x);
pre += s[x][old];
}
}
rep(i, d) cout << days[i] + 1 << endl;
}
| replace | 87 | 88 | 87 | 88 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <map>
#include <random>
#include <time.h>
#include <vector>
using namespace std;
const int MAX_D = 365;
const int C_SIZE = 26;
typedef vector<int> State;
typedef pair<int, State> CostState;
map<int, int> BIT_TABLE;
string createBits(int num) {
string ret;
for (int i = 0; i < C_SIZE; i++) {
if ((num >> i) & 1) {
ret += '1';
} else {
ret += '0';
}
}
return ret;
}
void displayState(State state) {
for (int i = 0; i < state.size(); i++) {
cout << createBits(state[i]) << endl;
}
}
int decreaseSatisfaction(const vector<int> &vec_c, vector<int> &last, int d) {
int res = 0;
for (int i = 0; i < C_SIZE; i++) {
res += vec_c[i] * (d - last[i]);
}
return res;
}
int calcCost(const int D, State state, const vector<int> &vec_c,
const vector<vector<int>> vec_s) {
int res = 0;
vector<int> last;
for (int i = 0; i < C_SIZE; i++) {
last.push_back(0);
}
for (int i = 0; i < D; i++) {
res += vec_s[i][BIT_TABLE[state[i]]];
last[BIT_TABLE[state[i]]] = (i + 1);
res -= decreaseSatisfaction(vec_c, last, (i + 1));
}
return res;
}
CostState createCostState(const int D, State state, const vector<int> &vec_c,
const vector<vector<int>> vec_s) {
// displayState(state);
// cout << calcCost(D, state, vec_c, vec_s) << endl;
return CostState(calcCost(D, state, vec_c, vec_s), state);
}
void input(int &D, vector<int> &vec_c, vector<vector<int>> &vec_s) {
cin >> D;
for (int i = 0; i < C_SIZE; i++) {
int c;
cin >> c;
vec_c.push_back(c);
}
for (int i = 0; i < D; i++) {
vector<int> vec;
for (int j = 0; j < C_SIZE; j++) {
int s;
cin >> s;
vec.push_back(s);
}
vec_s.push_back(vec);
}
}
void init(const int D, State &state) {
srand(0);
for (int i = 0; i < D; i++) {
int bit = 0;
for (int j = 0; j < C_SIZE; j++) {
if (i % C_SIZE == j) {
bit = (1 << j);
}
}
state.push_back(bit);
}
for (int i = 0; i < C_SIZE; i++) {
BIT_TABLE[(1 << i)] = i;
}
}
void output(int D, const State &res) {
for (int i = 0; i < D; i++) {
for (int j = 0; j < C_SIZE; j++) {
if ((res[i] >> j) & 1) {
cout << (j + 1) << endl;
}
}
}
}
void StateShuffle(const int D, State &state) {
int bit = 1 << rand() % C_SIZE;
int day = rand() % D;
state[day] = bit;
}
/*
void GenenateState(const int D, State& state, const vector<int>& vec_c, const
vector<vector<int> >vec_s){ int max_cost = -1e8; int max_day = -1; State
max_state; for(int i = 0 ; i < D ; i++){ for(int j = 0 ; j < 2 ; j++){ State s =
state; if(j){ s[i] = min(1 << (C_SIZE-1) , s[i] << 1);
}
else {
s[i] = max(1, s[i] >> 1);
}
int cost = calcCost(D, s, vec_c, vec_s);
if(max_cost < cost){
max_cost = cost;
max_state = s;
max_day = i;
}
}
}
cerr << "max_cost = " << max_cost << endl;
state = max_state;
}
*/
State solve(const int D, const vector<int> &vec_c,
const vector<vector<int>> vec_s, clock_t start) {
vector<vector<int>> res;
State state;
init(D, state);
const int GENERATE_COUNT = 1;
const int LIMIT = 1;
vector<CostState> states;
states.push_back(createCostState(D, state, vec_c, vec_s));
for (int i = 0;; i++) {
// if(clock() - start > 1.9 * CLOCKS_PER_SEC)break;
vector<CostState> candidates;
for (int j = 0; j < states.size() && j < LIMIT; j++) {
CostState cstate = states[j];
candidates.push_back(cstate);
State state = cstate.second;
for (int k = 0; k < GENERATE_COUNT; k++) {
StateShuffle(D, state);
// GenenateState(D, state, vec_c, vec_s);
candidates.push_back(createCostState(D, state, vec_c, vec_s));
}
}
sort(candidates.begin(), candidates.end());
reverse(candidates.begin(), candidates.end());
states = candidates;
}
cerr << states[0].first << endl;
return states[0].second;
}
int main() {
clock_t start = clock();
int D;
vector<int> vec_c;
vector<vector<int>> vec_s;
input(D, vec_c, vec_s);
output(D, solve(D, vec_c, vec_s, start));
return 0;
}
| #include <algorithm>
#include <iostream>
#include <map>
#include <random>
#include <time.h>
#include <vector>
using namespace std;
const int MAX_D = 365;
const int C_SIZE = 26;
typedef vector<int> State;
typedef pair<int, State> CostState;
map<int, int> BIT_TABLE;
string createBits(int num) {
string ret;
for (int i = 0; i < C_SIZE; i++) {
if ((num >> i) & 1) {
ret += '1';
} else {
ret += '0';
}
}
return ret;
}
void displayState(State state) {
for (int i = 0; i < state.size(); i++) {
cout << createBits(state[i]) << endl;
}
}
int decreaseSatisfaction(const vector<int> &vec_c, vector<int> &last, int d) {
int res = 0;
for (int i = 0; i < C_SIZE; i++) {
res += vec_c[i] * (d - last[i]);
}
return res;
}
int calcCost(const int D, State state, const vector<int> &vec_c,
const vector<vector<int>> vec_s) {
int res = 0;
vector<int> last;
for (int i = 0; i < C_SIZE; i++) {
last.push_back(0);
}
for (int i = 0; i < D; i++) {
res += vec_s[i][BIT_TABLE[state[i]]];
last[BIT_TABLE[state[i]]] = (i + 1);
res -= decreaseSatisfaction(vec_c, last, (i + 1));
}
return res;
}
CostState createCostState(const int D, State state, const vector<int> &vec_c,
const vector<vector<int>> vec_s) {
// displayState(state);
// cout << calcCost(D, state, vec_c, vec_s) << endl;
return CostState(calcCost(D, state, vec_c, vec_s), state);
}
void input(int &D, vector<int> &vec_c, vector<vector<int>> &vec_s) {
cin >> D;
for (int i = 0; i < C_SIZE; i++) {
int c;
cin >> c;
vec_c.push_back(c);
}
for (int i = 0; i < D; i++) {
vector<int> vec;
for (int j = 0; j < C_SIZE; j++) {
int s;
cin >> s;
vec.push_back(s);
}
vec_s.push_back(vec);
}
}
void init(const int D, State &state) {
srand(0);
for (int i = 0; i < D; i++) {
int bit = 0;
for (int j = 0; j < C_SIZE; j++) {
if (i % C_SIZE == j) {
bit = (1 << j);
}
}
state.push_back(bit);
}
for (int i = 0; i < C_SIZE; i++) {
BIT_TABLE[(1 << i)] = i;
}
}
void output(int D, const State &res) {
for (int i = 0; i < D; i++) {
for (int j = 0; j < C_SIZE; j++) {
if ((res[i] >> j) & 1) {
cout << (j + 1) << endl;
}
}
}
}
void StateShuffle(const int D, State &state) {
int bit = 1 << rand() % C_SIZE;
int day = rand() % D;
state[day] = bit;
}
/*
void GenenateState(const int D, State& state, const vector<int>& vec_c, const
vector<vector<int> >vec_s){ int max_cost = -1e8; int max_day = -1; State
max_state; for(int i = 0 ; i < D ; i++){ for(int j = 0 ; j < 2 ; j++){ State s =
state; if(j){ s[i] = min(1 << (C_SIZE-1) , s[i] << 1);
}
else {
s[i] = max(1, s[i] >> 1);
}
int cost = calcCost(D, s, vec_c, vec_s);
if(max_cost < cost){
max_cost = cost;
max_state = s;
max_day = i;
}
}
}
cerr << "max_cost = " << max_cost << endl;
state = max_state;
}
*/
State solve(const int D, const vector<int> &vec_c,
const vector<vector<int>> vec_s, clock_t start) {
vector<vector<int>> res;
State state;
init(D, state);
const int GENERATE_COUNT = 1;
const int LIMIT = 1;
vector<CostState> states;
states.push_back(createCostState(D, state, vec_c, vec_s));
for (int i = 0;; i++) {
if (clock() - start > 1.9 * CLOCKS_PER_SEC)
break;
vector<CostState> candidates;
for (int j = 0; j < states.size() && j < LIMIT; j++) {
CostState cstate = states[j];
candidates.push_back(cstate);
State state = cstate.second;
for (int k = 0; k < GENERATE_COUNT; k++) {
StateShuffle(D, state);
// GenenateState(D, state, vec_c, vec_s);
candidates.push_back(createCostState(D, state, vec_c, vec_s));
}
}
sort(candidates.begin(), candidates.end());
reverse(candidates.begin(), candidates.end());
states = candidates;
}
cerr << states[0].first << endl;
return states[0].second;
}
int main() {
clock_t start = clock();
int D;
vector<int> vec_c;
vector<vector<int>> vec_s;
input(D, vec_c, vec_s);
output(D, solve(D, vec_c, vec_s, start));
return 0;
}
| replace | 152 | 153 | 152 | 154 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define REP(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define REPR(i, n) for (int(i) = (n); (i) >= 0; --(i))
#define FOR(i, n, m) for (int(i) = (n); (i) < (m); ++(i))
// constexpr int INF = 1e9;
constexpr ll INF = 1LL << 61;
constexpr ll mod = 1e9 + 7;
class xorShift {
uint32_t x, y, z, w;
static const double TO_DOUBLE;
public:
xorShift() {
x = 123456789;
y = 362436069;
z = 521288629;
w = 88675123;
}
xorShift(uint32_t seed) {
x = seed = 1812433253u * (seed ^ (seed >> 30));
y = seed = 1812433253u * (seed ^ (seed >> 30)) + 1;
z = seed = 1812433253u * (seed ^ (seed >> 30)) + 2;
w = seed = 1812433253u * (seed ^ (seed >> 30)) + 3;
}
uint32_t nextInt(uint32_t n) {
uint32_t t = x ^ (x << 11);
x = y;
y = z;
z = w;
w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
return w % n;
}
uint32_t nextInt() {
uint32_t t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
}
double nextDouble() { return nextInt() * TO_DOUBLE; }
};
const double xorShift::TO_DOUBLE = 1.0 / (1LL << 32);
class Timer {
chrono::time_point<chrono::system_clock> start;
public:
Timer() { start = chrono::system_clock::now(); }
double duration() {
return chrono::duration_cast<chrono::milliseconds>(
chrono::system_clock::now() - start)
.count();
// return
// chrono::duration<chrono::milliseconds>(chrono::system_clock::now()-
// start).count();
}
};
Timer T;
xorShift rnd;
constexpr double TIME_LIMIT = 1950;
int D = 365;
vector<int> c(26);
vector<vector<int>> s(D, vector<int>(26));
struct Ans {
vector<int> ans;
int score = 0;
Ans() : ans(D) {}
};
struct State {
int score = 0, down = 0;
vector<int> ans, last;
State() : last(D, 0){};
int update(int t) {
ans.push_back(t);
down = 0;
int d = ans.size();
last[t] = d;
score += s[d - 1][t];
int maxd = 0;
REP(i, 26) {
score -= c[i] * (d - last[i]);
down -= c[i] * (d + 1 - last[i]);
maxd = max(maxd, c[i] * (d + 1 - last[i]));
}
return score;
}
bool operator<(const State right) const {
return score + down < right.score + right.down;
}
bool operator>(const State left) const {
return score + down > left.score + left.down;
}
};
int cal_score(Ans &ans) {
int manzoku = 0;
vector<int> last(26, 0);
REP(i, D) {
manzoku += s[i][ans.ans[i]];
last[ans.ans[i]] = i + 1;
REP(j, 26) { manzoku -= c[j] * (i + 1 - last[j]); }
}
return manzoku;
}
struct Solver {
Ans bestAns;
Solver() {
// init_ans();
// init_ans2();
// bestAns.score = cal_score(bestAns);
}
void init_ans() {
REP(i, D) { bestAns.ans[i] = i % 26; }
}
void init_ans2() {
vector<int> last(26, 0);
REP(i, D) {
int mint = 0, maxd = 0;
REP(j, 26) {
int loss = c[j] * ((i + 1) - last[j]);
if (loss > maxd) {
maxd = loss;
mint = j;
}
}
bestAns.ans[i] = mint;
last[mint] = i + 1;
}
}
void solve() {
State bestState = beam_search();
bestAns.ans = bestState.ans;
bestAns.score = bestState.score;
yama();
print_ans();
}
State beam_search() {
priority_queue<State> NowStates;
NowStates.push(State());
int k = 100; // ビーム幅
REP(t, D) {
priority_queue<State> NextStates;
REP(i, k) {
if (NowStates.empty())
break;
State NowState = NowStates.top();
NowStates.pop();
REP(j, 26) {
State NextState = NowState;
NextState.update(j);
NextStates.push(NextState);
}
}
NowStates = NextStates;
}
State BestState;
REP(i, 100) {
if (NowStates.empty())
break;
if (BestState.score < NowStates.top().score) {
BestState = NowStates.top();
}
NowStates.pop();
}
return BestState;
}
void yama() {
Ans currentAns = bestAns;
while (true) {
if (T.duration() > TIME_LIMIT)
break;
int a = rnd.nextInt(D), b = rnd.nextInt(D);
while (a == b) {
b = rnd.nextInt(D);
}
swap(currentAns.ans[a], currentAns.ans[b]);
int score = cal_score(currentAns);
if (score > currentAns.score) {
currentAns.score = score;
} else {
swap(currentAns.ans[a], currentAns.ans[b]);
}
}
if (bestAns.score < currentAns.score) {
bestAns = currentAns;
}
}
void print_ans() {
REP(i, D) { cout << bestAns.ans[i] + 1 << endl; }
}
};
int main() {
cin >> D;
REP(i, 26) { cin >> c[i]; }
REP(i, D) {
REP(j, 26) { cin >> s[i][j]; }
}
Solver solver;
solver.solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define REP(i, n) for (int(i) = 0; (i) < (n); ++(i))
#define REPR(i, n) for (int(i) = (n); (i) >= 0; --(i))
#define FOR(i, n, m) for (int(i) = (n); (i) < (m); ++(i))
// constexpr int INF = 1e9;
constexpr ll INF = 1LL << 61;
constexpr ll mod = 1e9 + 7;
class xorShift {
uint32_t x, y, z, w;
static const double TO_DOUBLE;
public:
xorShift() {
x = 123456789;
y = 362436069;
z = 521288629;
w = 88675123;
}
xorShift(uint32_t seed) {
x = seed = 1812433253u * (seed ^ (seed >> 30));
y = seed = 1812433253u * (seed ^ (seed >> 30)) + 1;
z = seed = 1812433253u * (seed ^ (seed >> 30)) + 2;
w = seed = 1812433253u * (seed ^ (seed >> 30)) + 3;
}
uint32_t nextInt(uint32_t n) {
uint32_t t = x ^ (x << 11);
x = y;
y = z;
z = w;
w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
return w % n;
}
uint32_t nextInt() {
uint32_t t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
}
double nextDouble() { return nextInt() * TO_DOUBLE; }
};
const double xorShift::TO_DOUBLE = 1.0 / (1LL << 32);
class Timer {
chrono::time_point<chrono::system_clock> start;
public:
Timer() { start = chrono::system_clock::now(); }
double duration() {
return chrono::duration_cast<chrono::milliseconds>(
chrono::system_clock::now() - start)
.count();
// return
// chrono::duration<chrono::milliseconds>(chrono::system_clock::now()-
// start).count();
}
};
Timer T;
xorShift rnd;
constexpr double TIME_LIMIT = 1950;
int D = 365;
vector<int> c(26);
vector<vector<int>> s(D, vector<int>(26));
struct Ans {
vector<int> ans;
int score = 0;
Ans() : ans(D) {}
};
struct State {
int score = 0, down = 0;
vector<int> ans, last;
State() : last(D, 0){};
int update(int t) {
ans.push_back(t);
down = 0;
int d = ans.size();
last[t] = d;
score += s[d - 1][t];
int maxd = 0;
REP(i, 26) {
score -= c[i] * (d - last[i]);
down -= c[i] * (d + 1 - last[i]);
maxd = max(maxd, c[i] * (d + 1 - last[i]));
}
return score;
}
bool operator<(const State right) const {
return score + down < right.score + right.down;
}
bool operator>(const State left) const {
return score + down > left.score + left.down;
}
};
int cal_score(Ans &ans) {
int manzoku = 0;
vector<int> last(26, 0);
REP(i, D) {
manzoku += s[i][ans.ans[i]];
last[ans.ans[i]] = i + 1;
REP(j, 26) { manzoku -= c[j] * (i + 1 - last[j]); }
}
return manzoku;
}
struct Solver {
Ans bestAns;
Solver() {
// init_ans();
// init_ans2();
// bestAns.score = cal_score(bestAns);
}
void init_ans() {
REP(i, D) { bestAns.ans[i] = i % 26; }
}
void init_ans2() {
vector<int> last(26, 0);
REP(i, D) {
int mint = 0, maxd = 0;
REP(j, 26) {
int loss = c[j] * ((i + 1) - last[j]);
if (loss > maxd) {
maxd = loss;
mint = j;
}
}
bestAns.ans[i] = mint;
last[mint] = i + 1;
}
}
void solve() {
State bestState = beam_search();
bestAns.ans = bestState.ans;
bestAns.score = bestState.score;
yama();
print_ans();
}
State beam_search() {
priority_queue<State> NowStates;
NowStates.push(State());
int k = 100; // ビーム幅
REP(t, D) {
priority_queue<State> NextStates;
REP(i, k) {
if (NowStates.empty())
break;
State NowState = NowStates.top();
NowStates.pop();
REP(j, 26) {
State NextState = NowState;
NextState.update(j);
NextStates.push(NextState);
}
}
NowStates = NextStates;
}
State BestState = NowStates.top();
NowStates.pop();
REP(i, 100) {
if (NowStates.empty())
break;
if (BestState.score < NowStates.top().score) {
BestState = NowStates.top();
}
NowStates.pop();
}
return BestState;
}
void yama() {
Ans currentAns = bestAns;
while (true) {
if (T.duration() > TIME_LIMIT)
break;
int a = rnd.nextInt(D), b = rnd.nextInt(D);
while (a == b) {
b = rnd.nextInt(D);
}
swap(currentAns.ans[a], currentAns.ans[b]);
int score = cal_score(currentAns);
if (score > currentAns.score) {
currentAns.score = score;
} else {
swap(currentAns.ans[a], currentAns.ans[b]);
}
}
if (bestAns.score < currentAns.score) {
bestAns = currentAns;
}
}
void print_ans() {
REP(i, D) { cout << bestAns.ans[i] + 1 << endl; }
}
};
int main() {
cin >> D;
REP(i, 26) { cin >> c[i]; }
REP(i, D) {
REP(j, 26) { cin >> s[i][j]; }
}
Solver solver;
solver.solve();
return 0;
}
| replace | 165 | 166 | 165 | 167 | -6 | free(): invalid pointer
|
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
std::mt19937 mt{std::random_device{}()};
int randint(int lower, int upper) {
std::uniform_int_distribution<int> dist(lower, upper);
return dist(mt);
}
int calc_score(int M, int D, vector<vector<int>> &S, vector<int> &T,
vector<int> &C) {
int ans = 0;
vector<int> last(M, -1);
for (int i = 0; i < D; i++) {
ans += S[i][T[i]];
last[T[i]] = i;
for (int j = 0; j < M; j++) {
ans -= C[j] * (i - last[j]);
}
}
return ans;
}
int main() {
int tstart = clock();
ios::sync_with_stdio(false);
cin.tie(0);
int D;
cin >> D;
const int M = 26;
vector<int> C(M);
for (int i = 0; i < M; i++)
cin >> C[i];
vector<vector<int>> S(D, vector<int>(M));
for (int i = 0; i < D; i++) {
for (int j = 0; j < M; j++) {
cin >> S[i][j];
}
}
vector<int> T(D);
for (int i = 0; i < D; i++) {
int naxj = 0;
int nax = S[i][0];
for (int j = 1; j < M; j++) {
if (chmax(nax, S[i][j])) {
naxj = j;
}
}
T[i] = naxj;
}
int score = calc_score(M, D, S, T, C);
while ((clock() - tstart) / CLOCKS_PER_SEC < 1.8) {
int H = randint(0, D - 1);
int Q = randint(0, M - 1);
int tmp = T[H];
T[H] = Q;
int nscore = calc_score(M, D, S, T, C);
if (score < nscore) {
score = nscore;
} else {
T[H] = tmp;
}
}
for (int i = 0; i < D; i++) {
cout << T[i] + 1 << '\n';
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
std::mt19937 mt{std::random_device{}()};
int randint(int lower, int upper) {
std::uniform_int_distribution<int> dist(lower, upper);
return dist(mt);
}
int calc_score(int M, int D, vector<vector<int>> &S, vector<int> &T,
vector<int> &C) {
int ans = 0;
vector<int> last(M, -1);
for (int i = 0; i < D; i++) {
ans += S[i][T[i]];
last[T[i]] = i;
for (int j = 0; j < M; j++) {
ans -= C[j] * (i - last[j]);
}
}
return ans;
}
int main() {
int tstart = clock();
ios::sync_with_stdio(false);
cin.tie(0);
int D;
cin >> D;
const int M = 26;
vector<int> C(M);
for (int i = 0; i < M; i++)
cin >> C[i];
vector<vector<int>> S(D, vector<int>(M));
for (int i = 0; i < D; i++) {
for (int j = 0; j < M; j++) {
cin >> S[i][j];
}
}
vector<int> T(D);
for (int i = 0; i < D; i++) {
int naxj = 0;
int nax = S[i][0];
for (int j = 1; j < M; j++) {
if (chmax(nax, S[i][j])) {
naxj = j;
}
}
T[i] = naxj;
}
int score = calc_score(M, D, S, T, C);
while (1.0 * (clock() - tstart) / CLOCKS_PER_SEC < 1.8) {
// cout << 1.0 * (clock() - tstart) / CLOCKS_PER_SEC << endl;
int H = randint(0, D - 1);
int Q = randint(0, M - 1);
int tmp = T[H];
T[H] = Q;
int nscore = calc_score(M, D, S, T, C);
if (score < nscore) {
score = nscore;
} else {
T[H] = tmp;
}
}
for (int i = 0; i < D; i++) {
cout << T[i] + 1 << '\n';
}
return 0;
}
| replace | 61 | 62 | 61 | 63 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define INF 1e9
static const int seeds = 630;
static const int D = 365;
static const int ntype = 26;
static const int population_size = 50;
int gene[population_size][D + 1];
int next_gene[population_size][D + 1];
static int elete[D + 1];
static int elete_score = -INF;
static const int init_n_greedyGene = 1;
static const double crossRate = 0.5;
static const double mutationRate = 0.5;
vector<pair<double, int>> cumfreq;
class Contest {
public:
Contest() { last = 0; }
int s[D + 1];
int c;
int last;
};
Contest contest[ntype + 1];
void Input() {
int d;
cin >> d;
for (int i = 1; i <= ntype; ++i) {
int t;
cin >> t;
contest[i].c = t;
}
for (int day = 1; day <= D; ++day) {
for (int type = 1; type <= ntype; ++type) {
int t;
cin >> t;
contest[type].s[day] = t;
}
}
}
void randGene(int p) {
for (int day = 1; day <= D; ++day) {
gene[p][day] = rand() % ntype + 1;
}
}
void greedyGene(int p) {
vector<int> l(ntype + 1, 0);
int score = 0;
for (int d = 1; d <= D; ++d) {
for (int i = 1; i <= ntype; ++i)
score -= contest[i].c * (d - l[i]);
int temp = score;
int t = -1;
for (int i = 1; i <= ntype; ++i) {
int k = contest[i].s[d] + contest[i].c * (d - l[i]) + score;
if (k > temp) {
temp = k;
t = i;
}
}
gene[p][d] = t;
l[t] = d;
score += temp;
}
/*
cout<<endl<<"elete"<<endl;
for(int d=1;d<=D;++d) cout<<elete[d]<<endl;
cout<<endl<<"greedy"<<endl;
for(int d=1;d<=D;++d) cout<<gene[p][d]<<endl;
*/
}
int evaluate(int i) {
int v[D + 1];
v[0] = 0;
for (int day = 1; day <= D; ++day) {
v[day] = 0;
int type = gene[i][day];
v[day] += contest[type].s[day];
contest[type].last = day;
for (int t = 1; t <= ntype; ++t) {
v[day] -= contest[t].c * (day - contest[t].last);
}
v[day] += v[day - 1];
}
return v[D];
}
void calcCumFreq() {
double sum = 0;
int last_n = cumfreq.size();
--last_n;
sort(cumfreq.begin(), cumfreq.end());
// change elete
/*
cout<<endl<<"Gene"<<endl<<endl;
for(int i=0;i<cumfreq.size();++i) cout<<cumfreq[i].first<<endl;
*/
if (elete_score < cumfreq[last_n].first) {
elete_score = cumfreq[last_n].first;
// cout<<elete_score<<endl;
for (int d = 1; d <= D; ++d) {
elete[d] = gene[cumfreq[last_n].second][d];
// cout<<elete[d]<<endl;
}
}
for (int i = 0; i < 50; ++i) {
sum += cumfreq[i].first;
}
for (int i = 0; i < 50; ++i) {
cumfreq[i].first /= sum;
}
for (int i = 0; i < 49; ++i) {
cumfreq[i + 1].first += cumfreq[i].first;
}
}
void CrossOver(int gene_i, int ci, int cj) {
int l = rand() % D + 1;
int r = rand() % D + 1;
while (r == l) {
l = rand() % D + 1;
r = rand() % D + 1;
}
if (r < l)
swap(r, l);
for (int d = 1; d < l; ++d)
next_gene[gene_i][d] = gene[ci][d];
for (int d = l; d <= r; ++d)
next_gene[gene_i][d] = gene[cj][d];
for (int d = r + 1; d <= D; ++d)
next_gene[gene_i][d] = gene[ci][d];
}
void Mutation(int ngene_i) {
int n = rand() % 3 + 1;
for (int i = 0; i < n; ++i) {
int p = rand() % D + 1;
next_gene[ngene_i][p] = rand() % ntype + 1;
}
}
int Select() {
double a = (double)rand() / RAND_MAX;
int t = cumfreq.size() - 1;
for (int i = 0; i < t; ++i) {
if (cumfreq[i + 1].first > a)
return cumfreq[i].second;
}
return cumfreq[t].second;
}
// init
void Init(int nGreedy) {
for (int i = 0; i < nGreedy; ++i)
greedyGene(i);
for (int i = nGreedy; i < population_size; ++i)
randGene(i);
}
void makeCumFreq() {
for (int i = 0; i < population_size; ++i) {
int e = evaluate(i);
// cout<<e<<endl;
cumfreq.push_back(make_pair(e, i));
}
calcCumFreq();
}
void makeNextGeneration() {
for (int d = 0; d <= D; ++d)
next_gene[0][d] = elete[d];
for (int i = 1; i < population_size; ++i) {
int pi = Select();
double crossrand = (double)rand() / RAND_MAX;
if (crossrand < crossRate) {
int pj = Select();
CrossOver(i, pi, pj);
} else {
for (int j = 1; j <= D; ++j)
next_gene[i][j] = gene[pi][j];
}
double murand = (double)rand() / RAND_MAX;
if (murand < mutationRate) {
Mutation(i);
}
}
for (int i = 0; i < 50; ++i) {
for (int j = 1; j <= D; ++j) {
gene[i][j] = next_gene[i][j];
}
}
}
void GA(int n) {
for (int i = 0; i < n; ++i) {
makeCumFreq();
makeNextGeneration();
cumfreq.resize(0);
}
}
void Output() {
for (int d = 1; d <= D; ++d)
cout << elete[d] << endl;
}
int main() {
srand(seeds);
Input();
Init(init_n_greedyGene);
GA(10000);
Output();
}
| #include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
#define INF 1e9
static const int seeds = 630;
static const int D = 365;
static const int ntype = 26;
static const int population_size = 50;
int gene[population_size][D + 1];
int next_gene[population_size][D + 1];
static int elete[D + 1];
static int elete_score = -INF;
static const int init_n_greedyGene = 1;
static const double crossRate = 0.5;
static const double mutationRate = 0.5;
vector<pair<double, int>> cumfreq;
class Contest {
public:
Contest() { last = 0; }
int s[D + 1];
int c;
int last;
};
Contest contest[ntype + 1];
void Input() {
int d;
cin >> d;
for (int i = 1; i <= ntype; ++i) {
int t;
cin >> t;
contest[i].c = t;
}
for (int day = 1; day <= D; ++day) {
for (int type = 1; type <= ntype; ++type) {
int t;
cin >> t;
contest[type].s[day] = t;
}
}
}
void randGene(int p) {
for (int day = 1; day <= D; ++day) {
gene[p][day] = rand() % ntype + 1;
}
}
void greedyGene(int p) {
vector<int> l(ntype + 1, 0);
int score = 0;
for (int d = 1; d <= D; ++d) {
for (int i = 1; i <= ntype; ++i)
score -= contest[i].c * (d - l[i]);
int temp = score;
int t = -1;
for (int i = 1; i <= ntype; ++i) {
int k = contest[i].s[d] + contest[i].c * (d - l[i]) + score;
if (k > temp) {
temp = k;
t = i;
}
}
gene[p][d] = t;
l[t] = d;
score += temp;
}
/*
cout<<endl<<"elete"<<endl;
for(int d=1;d<=D;++d) cout<<elete[d]<<endl;
cout<<endl<<"greedy"<<endl;
for(int d=1;d<=D;++d) cout<<gene[p][d]<<endl;
*/
}
int evaluate(int i) {
int v[D + 1];
v[0] = 0;
for (int day = 1; day <= D; ++day) {
v[day] = 0;
int type = gene[i][day];
v[day] += contest[type].s[day];
contest[type].last = day;
for (int t = 1; t <= ntype; ++t) {
v[day] -= contest[t].c * (day - contest[t].last);
}
v[day] += v[day - 1];
}
return v[D];
}
void calcCumFreq() {
double sum = 0;
int last_n = cumfreq.size();
--last_n;
sort(cumfreq.begin(), cumfreq.end());
// change elete
/*
cout<<endl<<"Gene"<<endl<<endl;
for(int i=0;i<cumfreq.size();++i) cout<<cumfreq[i].first<<endl;
*/
if (elete_score < cumfreq[last_n].first) {
elete_score = cumfreq[last_n].first;
// cout<<elete_score<<endl;
for (int d = 1; d <= D; ++d) {
elete[d] = gene[cumfreq[last_n].second][d];
// cout<<elete[d]<<endl;
}
}
for (int i = 0; i < 50; ++i) {
sum += cumfreq[i].first;
}
for (int i = 0; i < 50; ++i) {
cumfreq[i].first /= sum;
}
for (int i = 0; i < 49; ++i) {
cumfreq[i + 1].first += cumfreq[i].first;
}
}
void CrossOver(int gene_i, int ci, int cj) {
int l = rand() % D + 1;
int r = rand() % D + 1;
while (r == l) {
l = rand() % D + 1;
r = rand() % D + 1;
}
if (r < l)
swap(r, l);
for (int d = 1; d < l; ++d)
next_gene[gene_i][d] = gene[ci][d];
for (int d = l; d <= r; ++d)
next_gene[gene_i][d] = gene[cj][d];
for (int d = r + 1; d <= D; ++d)
next_gene[gene_i][d] = gene[ci][d];
}
void Mutation(int ngene_i) {
int n = rand() % 3 + 1;
for (int i = 0; i < n; ++i) {
int p = rand() % D + 1;
next_gene[ngene_i][p] = rand() % ntype + 1;
}
}
int Select() {
double a = (double)rand() / RAND_MAX;
int t = cumfreq.size() - 1;
for (int i = 0; i < t; ++i) {
if (cumfreq[i + 1].first > a)
return cumfreq[i].second;
}
return cumfreq[t].second;
}
// init
void Init(int nGreedy) {
for (int i = 0; i < nGreedy; ++i)
greedyGene(i);
for (int i = nGreedy; i < population_size; ++i)
randGene(i);
}
void makeCumFreq() {
for (int i = 0; i < population_size; ++i) {
int e = evaluate(i);
// cout<<e<<endl;
cumfreq.push_back(make_pair(e, i));
}
calcCumFreq();
}
void makeNextGeneration() {
for (int d = 0; d <= D; ++d)
next_gene[0][d] = elete[d];
for (int i = 1; i < population_size; ++i) {
int pi = Select();
double crossrand = (double)rand() / RAND_MAX;
if (crossrand < crossRate) {
int pj = Select();
CrossOver(i, pi, pj);
} else {
for (int j = 1; j <= D; ++j)
next_gene[i][j] = gene[pi][j];
}
double murand = (double)rand() / RAND_MAX;
if (murand < mutationRate) {
Mutation(i);
}
}
for (int i = 0; i < 50; ++i) {
for (int j = 1; j <= D; ++j) {
gene[i][j] = next_gene[i][j];
}
}
}
void GA(int n) {
for (int i = 0; i < n; ++i) {
makeCumFreq();
makeNextGeneration();
cumfreq.resize(0);
}
}
void Output() {
for (int d = 1; d <= D; ++d)
cout << elete[d] << endl;
}
int main() {
srand(seeds);
Input();
Init(init_n_greedyGene);
GA(4000);
Output();
}
| replace | 220 | 221 | 220 | 221 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <cstdlib>
#include <iostream>
using namespace std;
#define N 10000
#define C 150
#define CHANGE_RATE 0.5
int main() {
int d = 0;
int c[26];
int s[365][26];
int t_c[C][365];
int last[26] = {0};
int score_c[C] = {0};
int score = 0;
int max_c = 0;
cin >> d;
for (int i = 0; i < 26; i++) {
cin >> c[i];
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < 26; j++) {
cin >> s[i][j];
}
}
for (int i = 0; i < C; i++) {
for (int j = 0; j < 365; j++) {
t_c[i][j] = rand() % 26;
}
}
for (int n = 0; n < N; n++) {
score = 0;
max_c = 0;
for (int ca = 0; ca < C; ca++) {
score_c[ca] = 0;
for (int i = 0; i < 26; i++)
last[i] = 0;
for (int i = 0; i < d; i++) {
for (int j = 0; j < 26; j++) {
if (t_c[ca][i] == j) {
last[j] = 0;
score_c[ca] += s[i][j];
} else {
last[j]++;
score_c[ca] -= c[j] * last[j];
}
}
}
}
for (int ca = 0; ca < C; ca++) {
if (score < score_c[ca]) {
score = score_c[ca];
max_c = ca;
}
}
// cout << score << endl;
for (int ca = 0; ca < C; ca++) {
if (ca == max_c)
continue;
for (int i = 0; i < d; i++) {
if ((rand() / (double)RAND_MAX) < CHANGE_RATE) {
t_c[ca][i] = rand() % 26;
} else {
t_c[ca][i] = t_c[max_c][i];
}
}
}
}
for (int i = 0; i < d; i++) {
cout << ((t_c[max_c][i] % 26) + 1) << endl;
}
return 0;
} | #include <cstdlib>
#include <iostream>
using namespace std;
#define N 5000
#define C 15
#define CHANGE_RATE 0.1
int main() {
int d = 0;
int c[26];
int s[365][26];
int t_c[C][365];
int last[26] = {0};
int score_c[C] = {0};
int score = 0;
int max_c = 0;
cin >> d;
for (int i = 0; i < 26; i++) {
cin >> c[i];
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < 26; j++) {
cin >> s[i][j];
}
}
for (int i = 0; i < C; i++) {
for (int j = 0; j < 365; j++) {
t_c[i][j] = rand() % 26;
}
}
for (int n = 0; n < N; n++) {
score = 0;
max_c = 0;
for (int ca = 0; ca < C; ca++) {
score_c[ca] = 0;
for (int i = 0; i < 26; i++)
last[i] = 0;
for (int i = 0; i < d; i++) {
for (int j = 0; j < 26; j++) {
if (t_c[ca][i] == j) {
last[j] = 0;
score_c[ca] += s[i][j];
} else {
last[j]++;
score_c[ca] -= c[j] * last[j];
}
}
}
}
for (int ca = 0; ca < C; ca++) {
if (score < score_c[ca]) {
score = score_c[ca];
max_c = ca;
}
}
// cout << score << endl;
for (int ca = 0; ca < C; ca++) {
if (ca == max_c)
continue;
for (int i = 0; i < d; i++) {
if ((rand() / (double)RAND_MAX) < CHANGE_RATE) {
t_c[ca][i] = rand() % 26;
} else {
t_c[ca][i] = t_c[max_c][i];
}
}
}
}
for (int i = 0; i < d; i++) {
cout << ((t_c[max_c][i] % 26) + 1) << endl;
}
return 0;
} | replace | 4 | 7 | 4 | 7 | TLE | |
p02618 | C++ | Runtime Error | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "ctime"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(begin, i, end) for (int i = begin; i < (int)(end); i++)
#define all(v) v.begin(), v.end()
const int MOD = 1000000007;
int main() {
ll D;
cin >> D;
vector<ll> c(26);
ll sum_c = 0;
rep(0, i, 26) {
cin >> c.at(i);
sum_c += c.at(i);
}
vector<vector<ll>> s(D, vector<ll>(26, 0));
rep(0, i, D) {
rep(0, j, 26) { cin >> s.at(i).at(j); }
}
ll score = 0, dec = 0; // i日目のスコア、スコアの減少量
vector<ll> t(D), last(26, 0), ans(D, 0);
rep(0, i, D) {
// 今日開くコンテストと得られる満足度
ll today_i = 0, today_score = 0;
// i日目に各コンテストを開催したと仮定して満足度を求める
rep(0, j, 26) {
ll sum = s.at(i).at(j);
sum = sum - (dec + sum_c - (c.at(j) * (last.at(i) + 1)));
if (score + today_score < score + sum) {
today_i = j;
today_score = sum;
}
}
// ループが終了したら今日開くコンテストが決まるので、last(d,i)を更新する
rep(0, j, 26) { last.at(j) += 1; }
last.at(today_i) = 0;
// decの更新
dec = 0;
rep(0, j, 26) { dec += c.at(j) * last.at(j); }
// scoreの更新
score += today_score;
// 答え
t.at(i) = today_i + 1;
ans.at(i) = score;
}
rep(0, i, D) { cout << t.at(i) << endl; }
} | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "ctime"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define rep(begin, i, end) for (int i = begin; i < (int)(end); i++)
#define all(v) v.begin(), v.end()
const int MOD = 1000000007;
int main() {
ll D;
cin >> D;
vector<ll> c(26);
ll sum_c = 0;
rep(0, i, 26) {
cin >> c.at(i);
sum_c += c.at(i);
}
vector<vector<ll>> s(D, vector<ll>(26, 0));
rep(0, i, D) {
rep(0, j, 26) { cin >> s.at(i).at(j); }
}
ll score = 0, dec = 0; // i日目のスコア、スコアの減少量
vector<ll> t(D), last(26, 0), ans(D, 0);
rep(0, i, D) {
// 今日開くコンテストと得られる満足度
ll today_i = 0, today_score = 0;
// i日目に各コンテストを開催したと仮定して満足度を求める
rep(0, j, 26) {
ll sum = s.at(i).at(j);
sum = sum - (dec + sum_c - (c.at(j) * (last.at(j) + 1)));
if (score + today_score < score + sum) {
today_i = j;
today_score = sum;
}
}
// ループが終了したら今日開くコンテストが決まるので、last(d,i)を更新する
rep(0, j, 26) { last.at(j) += 1; }
last.at(today_i) = 0;
// decの更新
dec = 0;
rep(0, j, 26) { dec += c.at(j) * last.at(j); }
// scoreの更新
score += today_score;
// 答え
t.at(i) = today_i + 1;
ans.at(i) = score;
}
rep(0, i, D) { cout << t.at(i) << endl; }
} | replace | 52 | 53 | 52 | 53 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <random>
#include <set>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep1(i, n) for (int i = 1; i <= n; ++i)
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
ll rand26() {
random_device rnd;
mt19937 mt(rnd());
uniform_real_distribution<> rand(0, 25);
return (ll)rand(mt);
}
ll rand365() {
random_device rnd;
mt19937 mt(rnd());
uniform_real_distribution<> rand(0, 364);
return (ll)rand(mt);
}
int main() {
ll D;
cin >> D;
vector<ll> c(26);
rep(i, 26) cin >> c[i];
vector<vector<ll>> s(D, vector<ll>(26));
rep(i, D) {
rep(j, 26) { cin >> s[i][j]; }
}
vector<ll> t(D);
vector<ll> last(26, -1);
rep(i, D) {
ll score = -1000000000;
rep(j, 26) {
ll tmp = 0;
rep(k, 26) {
if (j == k) {
tmp += s[i][j];
} else {
tmp -= c[k] * (i - last[k]);
}
}
if (chmax(score, tmp)) {
t[i] = j;
}
}
last[t[i]] = i;
}
ll m = 26 * 365 * 60;
vector<ll> d(m), q(m);
rep(k, 60) {
rep(i, 26) {
rep(j, 365) {
d[k * 26 * 365 + i * 365 + j] = (j + k) % 365;
q[k * 26 * 365 + i * 365 + j] = (i + k) % 26;
}
}
}
vector<set<ll>> st(26);
rep(i, 26) {
st[i].insert(-1);
st[i].insert(D);
}
rep(i, D) { st[t[i]].insert(i); }
ll res = 0;
// ペナルティ
vector<ll> pen(26, 0);
rep(i, 26) {
auto it = st[i].begin();
it++;
while (it != st[i].end()) {
auto it2 = it;
it2--;
ll x = *it - *it2 - 1;
res -= x * (x + 1) / 2 * c[i];
pen[i] += x * (x + 1) / 2 * c[i];
it++;
}
}
rep(i, D) { res += s[i][t[i]]; }
rep(i, m) {
ll oldres = res;
ll old = t[d[i]];
ll neww = q[i];
if (old == neww)
continue;
set<ll> oldst1 = st[old];
set<ll> oldst2 = st[neww];
ll oldpen1 = pen[old];
ll oldpen2 = pen[neww];
res += s[d[i]][neww] - s[d[i]][old];
st[old].erase(d[i]);
st[neww].insert(d[i]);
// old
res += pen[old];
pen[old] = 0;
auto it = st[old].begin();
it++;
while (it != st[old].end()) {
auto it2 = it;
it2--;
ll x = *it - *it2 - 1;
res -= x * (x + 1) / 2 * c[old];
pen[old] += x * (x + 1) / 2 * c[old];
it++;
}
// new
res += pen[neww];
pen[neww] = 0;
it = st[neww].begin();
it++;
while (it != st[neww].end()) {
auto it2 = it;
it2--;
ll x = *it - *it2 - 1;
res -= x * (x + 1) / 2 * c[neww];
pen[neww] += x * (x + 1) / 2 * c[neww];
it++;
}
if (oldres < res) {
t[d[i]] = neww;
} else {
t[d[i]] = old;
st[old] = oldst1;
st[neww] = oldst2;
pen[old] = oldpen1;
pen[neww] = oldpen2;
}
}
double par = 1.00;
rep(i, m) {
ll d1 = i % 365, d2 = (i + 1) % 365;
ll oldres = res;
ll old = t[d1];
ll neww = t[d2];
if (old == neww)
continue;
set<ll> oldst1 = st[old];
set<ll> oldst2 = st[neww];
ll oldpen1 = pen[old];
ll oldpen2 = pen[neww];
res += s[d1][neww] - s[d1][old];
st[old].erase(d1);
st[neww].insert(d1);
// old
res += pen[old];
pen[old] = 0;
auto it = st[old].begin();
it++;
while (it != st[old].end()) {
auto it2 = it;
it2--;
ll x = *it - *it2 - 1;
res -= x * (x + 1) / 2 * c[old];
pen[old] += x * (x + 1) / 2 * c[old];
it++;
}
// new
res += pen[neww];
pen[neww] = 0;
it = st[neww].begin();
it++;
while (it != st[neww].end()) {
auto it2 = it;
it2--;
ll x = *it - *it2 - 1;
res -= x * (x + 1) / 2 * c[neww];
pen[neww] += x * (x + 1) / 2 * c[neww];
it++;
}
res += s[d2][old] - s[d2][neww];
st[neww].erase(d2);
st[old].insert(d2);
// old
res += pen[old];
pen[old] = 0;
it = st[old].begin();
it++;
while (it != st[old].end()) {
auto it2 = it;
it2--;
ll x = *it - *it2 - 1;
res -= x * (x + 1) / 2 * c[old];
pen[old] += x * (x + 1) / 2 * c[old];
it++;
}
// new
res += pen[neww];
pen[neww] = 0;
it = st[neww].begin();
it++;
while (it != st[neww].end()) {
auto it2 = it;
it2--;
ll x = *it - *it2 - 1;
res -= x * (x + 1) / 2 * c[neww];
pen[neww] += x * (x + 1) / 2 * c[neww];
it++;
}
if ((double)oldres < (double)res * par) {
t[d1] = neww;
t[d2] = old;
par = max(par - 0.01, 1.);
} else {
t[d1] = old;
t[d2] = neww;
st[old] = oldst1;
st[neww] = oldst2;
pen[old] = oldpen1;
pen[neww] = oldpen2;
}
}
rep(i, D) cout << t[i] + 1 << "\n";
return 0;
}
| #include <algorithm>
#include <iostream>
#include <random>
#include <set>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rep1(i, n) for (int i = 1; i <= n; ++i)
using namespace std;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
ll rand26() {
random_device rnd;
mt19937 mt(rnd());
uniform_real_distribution<> rand(0, 25);
return (ll)rand(mt);
}
ll rand365() {
random_device rnd;
mt19937 mt(rnd());
uniform_real_distribution<> rand(0, 364);
return (ll)rand(mt);
}
int main() {
ll D;
cin >> D;
vector<ll> c(26);
rep(i, 26) cin >> c[i];
vector<vector<ll>> s(D, vector<ll>(26));
rep(i, D) {
rep(j, 26) { cin >> s[i][j]; }
}
vector<ll> t(D);
vector<ll> last(26, -1);
rep(i, D) {
ll score = -1000000000;
rep(j, 26) {
ll tmp = 0;
rep(k, 26) {
if (j == k) {
tmp += s[i][j];
} else {
tmp -= c[k] * (i - last[k]);
}
}
if (chmax(score, tmp)) {
t[i] = j;
}
}
last[t[i]] = i;
}
ll m = 26 * 365 * 60;
vector<ll> d(m), q(m);
rep(k, 60) {
rep(i, 26) {
rep(j, 365) {
d[k * 26 * 365 + i * 365 + j] = (j + k) % 365;
q[k * 26 * 365 + i * 365 + j] = (i + k) % 26;
}
}
}
vector<set<ll>> st(26);
rep(i, 26) {
st[i].insert(-1);
st[i].insert(D);
}
rep(i, D) { st[t[i]].insert(i); }
ll res = 0;
// ペナルティ
vector<ll> pen(26, 0);
rep(i, 26) {
auto it = st[i].begin();
it++;
while (it != st[i].end()) {
auto it2 = it;
it2--;
ll x = *it - *it2 - 1;
res -= x * (x + 1) / 2 * c[i];
pen[i] += x * (x + 1) / 2 * c[i];
it++;
}
}
rep(i, D) { res += s[i][t[i]]; }
rep(i, m) {
ll oldres = res;
ll old = t[d[i]];
ll neww = q[i];
if (old == neww)
continue;
set<ll> oldst1 = st[old];
set<ll> oldst2 = st[neww];
ll oldpen1 = pen[old];
ll oldpen2 = pen[neww];
res += s[d[i]][neww] - s[d[i]][old];
st[old].erase(d[i]);
st[neww].insert(d[i]);
// old
res += pen[old];
pen[old] = 0;
auto it = st[old].begin();
it++;
while (it != st[old].end()) {
auto it2 = it;
it2--;
ll x = *it - *it2 - 1;
res -= x * (x + 1) / 2 * c[old];
pen[old] += x * (x + 1) / 2 * c[old];
it++;
}
// new
res += pen[neww];
pen[neww] = 0;
it = st[neww].begin();
it++;
while (it != st[neww].end()) {
auto it2 = it;
it2--;
ll x = *it - *it2 - 1;
res -= x * (x + 1) / 2 * c[neww];
pen[neww] += x * (x + 1) / 2 * c[neww];
it++;
}
if (oldres < res) {
t[d[i]] = neww;
} else {
t[d[i]] = old;
st[old] = oldst1;
st[neww] = oldst2;
pen[old] = oldpen1;
pen[neww] = oldpen2;
}
}
double par = 1.00;
rep(i, m / 2) {
ll d1 = i % 365, d2 = (i + 1) % 365;
ll oldres = res;
ll old = t[d1];
ll neww = t[d2];
if (old == neww)
continue;
set<ll> oldst1 = st[old];
set<ll> oldst2 = st[neww];
ll oldpen1 = pen[old];
ll oldpen2 = pen[neww];
res += s[d1][neww] - s[d1][old];
st[old].erase(d1);
st[neww].insert(d1);
// old
res += pen[old];
pen[old] = 0;
auto it = st[old].begin();
it++;
while (it != st[old].end()) {
auto it2 = it;
it2--;
ll x = *it - *it2 - 1;
res -= x * (x + 1) / 2 * c[old];
pen[old] += x * (x + 1) / 2 * c[old];
it++;
}
// new
res += pen[neww];
pen[neww] = 0;
it = st[neww].begin();
it++;
while (it != st[neww].end()) {
auto it2 = it;
it2--;
ll x = *it - *it2 - 1;
res -= x * (x + 1) / 2 * c[neww];
pen[neww] += x * (x + 1) / 2 * c[neww];
it++;
}
res += s[d2][old] - s[d2][neww];
st[neww].erase(d2);
st[old].insert(d2);
// old
res += pen[old];
pen[old] = 0;
it = st[old].begin();
it++;
while (it != st[old].end()) {
auto it2 = it;
it2--;
ll x = *it - *it2 - 1;
res -= x * (x + 1) / 2 * c[old];
pen[old] += x * (x + 1) / 2 * c[old];
it++;
}
// new
res += pen[neww];
pen[neww] = 0;
it = st[neww].begin();
it++;
while (it != st[neww].end()) {
auto it2 = it;
it2--;
ll x = *it - *it2 - 1;
res -= x * (x + 1) / 2 * c[neww];
pen[neww] += x * (x + 1) / 2 * c[neww];
it++;
}
if ((double)oldres < (double)res * par) {
t[d1] = neww;
t[d2] = old;
par = max(par - 0.01, 1.);
} else {
t[d1] = old;
t[d2] = neww;
st[old] = oldst1;
st[neww] = oldst2;
pen[old] = oldpen1;
pen[neww] = oldpen2;
}
}
rep(i, D) cout << t[i] + 1 << "\n";
return 0;
}
| replace | 154 | 155 | 154 | 155 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
const long Day_num = 365;
const long type_num = 26;
class Scoring {
public:
Scoring(const long arg_days, const std::vector<long> &arg_costs,
const std::vector<std::vector<long>> &arg_incentives);
std::vector<long> score(const std::vector<long> &arg_types);
private:
long days;
std::vector<long> costs;
std::vector<std::vector<long>> incentives;
};
std::vector<long> Scoring::score(const std::vector<long> &arg_types) {
std::vector<long> result(days);
long satisfy = 0;
std::vector<long> last_days(type_num, 0);
for (long day = 1; day <= days; ++day) {
const auto exe_type = arg_types[day - 1];
satisfy += incentives[day - 1][exe_type - 1];
last_days[exe_type - 1] = day;
for (long type = 1; type <= type_num; ++type) {
satisfy -= costs[type - 1] * (day - last_days[type - 1]);
}
result[day - 1] = satisfy;
}
return result;
}
Scoring::Scoring(const long arg_days, const std::vector<long> &arg_costs,
const std::vector<std::vector<long>> &arg_incentives) {
days = arg_days;
costs = arg_costs;
incentives = arg_incentives;
}
int main() {
clock_t start_clock = clock();
std::mt19937 engine(12345678);
std::uniform_int_distribution<> type_random(1, type_num);
std::uniform_int_distribution<> day_random(1, Day_num);
long D;
std::cin >> D;
std::vector<long> costs(type_num);
for (long type = 1; type <= type_num; ++type) {
std::cin >> costs[type - 1];
}
std::vector<std::vector<long>> incentives(D, std::vector<long>(type_num));
for (long day = 1; day <= D; ++day) {
for (long type = 1; type <= type_num; ++type) {
std::cin >> incentives[day - 1][type - 1];
}
}
Scoring scoring(D, costs, incentives);
std::vector<long> types(D);
for (long day = 1; day <= D; ++day) {
types[day - 1] = type_random(engine);
}
while (static_cast<double>(clock() - start_clock) / CLOCKS_PER_SEC <
2.0 - 0.01) {
const auto old_types = types;
types[day_random(engine) - 1] = type_random(engine);
if (scoring.score(old_types).back() > scoring.score(types).back()) {
types = old_types;
}
}
for (long day = 1; day <= D; ++day) {
std::cout << types[day - 1] << std::endl;
}
// std::vector<long> types(D);
// for (long day = 1; day <= D; ++day) {
// std::cin >> types[day-1];
// }
// long M;
// std::cin >> M;
// std::vector<std::array<long,2>> query(M);
// for (long index = 0; index < M; ++index) {
// std::cin >> query[index][0];
// std::cin >> query[index][1];
// }
// Scoring scoring(D, costs, incentives);
// for (long index = 0; index < M; ++index) {
// types[query[index][0]-1] = query[index][1];
// std::cout << scoring.score(types).back() << std::endl;
// }
} | #include <bits/stdc++.h>
const long Day_num = 365;
const long type_num = 26;
class Scoring {
public:
Scoring(const long arg_days, const std::vector<long> &arg_costs,
const std::vector<std::vector<long>> &arg_incentives);
std::vector<long> score(const std::vector<long> &arg_types);
private:
long days;
std::vector<long> costs;
std::vector<std::vector<long>> incentives;
};
std::vector<long> Scoring::score(const std::vector<long> &arg_types) {
std::vector<long> result(days);
long satisfy = 0;
std::vector<long> last_days(type_num, 0);
for (long day = 1; day <= days; ++day) {
const auto exe_type = arg_types[day - 1];
satisfy += incentives[day - 1][exe_type - 1];
last_days[exe_type - 1] = day;
for (long type = 1; type <= type_num; ++type) {
satisfy -= costs[type - 1] * (day - last_days[type - 1]);
}
result[day - 1] = satisfy;
}
return result;
}
Scoring::Scoring(const long arg_days, const std::vector<long> &arg_costs,
const std::vector<std::vector<long>> &arg_incentives) {
days = arg_days;
costs = arg_costs;
incentives = arg_incentives;
}
int main() {
clock_t start_clock = clock();
std::mt19937 engine(12345678);
std::uniform_int_distribution<> type_random(1, type_num);
std::uniform_int_distribution<> day_random(1, Day_num);
long D;
std::cin >> D;
std::vector<long> costs(type_num);
for (long type = 1; type <= type_num; ++type) {
std::cin >> costs[type - 1];
}
std::vector<std::vector<long>> incentives(D, std::vector<long>(type_num));
for (long day = 1; day <= D; ++day) {
for (long type = 1; type <= type_num; ++type) {
std::cin >> incentives[day - 1][type - 1];
}
}
Scoring scoring(D, costs, incentives);
std::vector<long> types(D);
for (long day = 1; day <= D; ++day) {
types[day - 1] = type_random(engine);
}
while (static_cast<double>(clock() - start_clock) / CLOCKS_PER_SEC * 1000.0 <
2000.0 - 100.0) {
const auto old_types = types;
types[day_random(engine) - 1] = type_random(engine);
if (scoring.score(old_types).back() > scoring.score(types).back()) {
types = old_types;
}
}
for (long day = 1; day <= D; ++day) {
std::cout << types[day - 1] << std::endl;
}
// std::vector<long> types(D);
// for (long day = 1; day <= D; ++day) {
// std::cin >> types[day-1];
// }
// long M;
// std::cin >> M;
// std::vector<std::array<long,2>> query(M);
// for (long index = 0; index < M; ++index) {
// std::cin >> query[index][0];
// std::cin >> query[index][1];
// }
// Scoring scoring(D, costs, incentives);
// for (long index = 0; index < M; ++index) {
// types[query[index][0]-1] = query[index][1];
// std::cout << scoring.score(types).back() << std::endl;
// }
} | replace | 66 | 68 | 66 | 68 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <unistd.h>
#include <vector>
#define _USE_MATH_DEFINES
#define _GLIBCXX_DEBUG
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> plglg;
typedef pair<double, ll> pdlg;
typedef tuple<int, int, int> tiii;
typedef tuple<ll, ll, ll> tlglglg;
typedef tuple<ll, ll, ll, ll> tlglglglg;
typedef tuple<double, double, double> tddd;
typedef complex<double> xy_t;
typedef vector<ll> vll;
typedef vector<vector<ll>> matrix;
typedef unsigned int uint;
typedef unsigned long long ull;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
template <class T> using VVV = V<VV<T>>;
#define REP(i, x, y) for (ll i = (ll)x; i < (ll)y; i++)
#define DREP(i, x, y, d) for (ll i = (ll)x; i < (ll)y; i += (ll)d)
#define PER(i, x, y) for (ll i = (ll)x; i > (ll)y; i--)
#define DPER(i, x, y, d) for (ll i = (ll)x; i > (ll)y; i -= (ll)d)
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
double pi = 3.141592653589793;
ll mod = 1000000007;
int intmax = 2147483647;
int intmin = -2147483648;
ll llmax = 9223372036854775807;
ll llmin = -9223372036854775807;
int iinf = intmax / 8;
ll inf = llmax / 8;
double eps = 1e-12;
void yesno(bool ok, string yes = "Yes", string no = "No") {
if (ok) {
cout << yes << endl;
} else {
cout << no << endl;
}
}
ll D;
ll c[26];
ll s[365][26];
ll score[26];
ll last[26];
set<ll> st[26];
void initrand() { srand((ll)time(NULL)); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
initrand();
cin >> D;
REP(i, 0, 26) { cin >> c[i]; }
REP(i, 0, D) {
REP(j, 0, 26) { cin >> s[i][j]; }
}
REP(i, 0, 26) {
st[i].insert(-1);
st[i].insert(D);
}
ll t[D];
REP(i, 0, D) {
t[i] = i % 26;
st[t[i]].insert(i);
}
fill(last, last + 26, -1);
REP(i, 0, D) {
ll contest = t[i];
REP(j, 0, 26) {
if (j == contest) {
score[j] += s[i][j];
last[j] = i;
} else {
score[j] -= c[j] * (i - last[j]);
}
}
}
ll sum = 0;
REP(j, 0, 26) { sum += score[j]; }
REP(i, 0, 100000) {
ll q = rand() % 26;
ll nowsummax = sum;
ll maxind = 0;
ll maxoldq = q;
REP(d, 0, D) {
ll oldq = t[d];
ll nowsum = sum;
nowsum -= s[d][oldq];
nowsum += s[d][q];
auto oldit = st[oldq].upper_bound(d);
ll oldnext = *oldit;
oldit--;
oldit--;
ll oldpre = *oldit;
nowsum -= c[oldq] * (d - oldpre) * (oldnext - d);
auto newit = st[q].upper_bound(d);
ll newnext = *newit;
newit--;
ll newpre = *newit;
nowsum += c[q] * (d - newpre) * (newnext - d);
if (nowsum > nowsummax) {
nowsummax = nowsum;
maxind = d;
maxoldq = oldq;
}
}
st[maxoldq].erase(maxind);
st[q].insert(maxind);
t[maxind] = q;
sum = nowsummax;
// cout << sum << endl;
}
REP(i, 0, D) { cout << t[i] + 1 << endl; }
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <unistd.h>
#include <vector>
#define _USE_MATH_DEFINES
#define _GLIBCXX_DEBUG
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> plglg;
typedef pair<double, ll> pdlg;
typedef tuple<int, int, int> tiii;
typedef tuple<ll, ll, ll> tlglglg;
typedef tuple<ll, ll, ll, ll> tlglglglg;
typedef tuple<double, double, double> tddd;
typedef complex<double> xy_t;
typedef vector<ll> vll;
typedef vector<vector<ll>> matrix;
typedef unsigned int uint;
typedef unsigned long long ull;
template <class T> using V = vector<T>;
template <class T> using VV = V<V<T>>;
template <class T> using VVV = V<VV<T>>;
#define REP(i, x, y) for (ll i = (ll)x; i < (ll)y; i++)
#define DREP(i, x, y, d) for (ll i = (ll)x; i < (ll)y; i += (ll)d)
#define PER(i, x, y) for (ll i = (ll)x; i > (ll)y; i--)
#define DPER(i, x, y, d) for (ll i = (ll)x; i > (ll)y; i -= (ll)d)
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
double pi = 3.141592653589793;
ll mod = 1000000007;
int intmax = 2147483647;
int intmin = -2147483648;
ll llmax = 9223372036854775807;
ll llmin = -9223372036854775807;
int iinf = intmax / 8;
ll inf = llmax / 8;
double eps = 1e-12;
void yesno(bool ok, string yes = "Yes", string no = "No") {
if (ok) {
cout << yes << endl;
} else {
cout << no << endl;
}
}
ll D;
ll c[26];
ll s[365][26];
ll score[26];
ll last[26];
set<ll> st[26];
void initrand() { srand((ll)time(NULL)); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
initrand();
cin >> D;
REP(i, 0, 26) { cin >> c[i]; }
REP(i, 0, D) {
REP(j, 0, 26) { cin >> s[i][j]; }
}
REP(i, 0, 26) {
st[i].insert(-1);
st[i].insert(D);
}
ll t[D];
REP(i, 0, D) {
t[i] = i % 26;
st[t[i]].insert(i);
}
fill(last, last + 26, -1);
REP(i, 0, D) {
ll contest = t[i];
REP(j, 0, 26) {
if (j == contest) {
score[j] += s[i][j];
last[j] = i;
} else {
score[j] -= c[j] * (i - last[j]);
}
}
}
ll sum = 0;
REP(j, 0, 26) { sum += score[j]; }
REP(i, 0, 20000) {
ll q = rand() % 26;
ll nowsummax = sum;
ll maxind = 0;
ll maxoldq = q;
REP(d, 0, D) {
ll oldq = t[d];
ll nowsum = sum;
nowsum -= s[d][oldq];
nowsum += s[d][q];
auto oldit = st[oldq].upper_bound(d);
ll oldnext = *oldit;
oldit--;
oldit--;
ll oldpre = *oldit;
nowsum -= c[oldq] * (d - oldpre) * (oldnext - d);
auto newit = st[q].upper_bound(d);
ll newnext = *newit;
newit--;
ll newpre = *newit;
nowsum += c[q] * (d - newpre) * (newnext - d);
if (nowsum > nowsummax) {
nowsummax = nowsum;
maxind = d;
maxoldq = oldq;
}
}
st[maxoldq].erase(maxind);
st[q].insert(maxind);
t[maxind] = q;
sum = nowsummax;
// cout << sum << endl;
}
REP(i, 0, D) { cout << t[i] + 1 << endl; }
}
| replace | 103 | 104 | 103 | 104 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define P pair<int, int>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
#define pb push_back
constexpr int INF = 1000000000;
int Random(int mi, int ma) {
random_device rnd;
mt19937 mt(rnd()); // 32bit
//[mi,ma]
uniform_int_distribution<int> engine(mi, ma);
return engine(mt);
}
int d, c[26], s[365][26], t[365];
set<int> st[26];
int toscore(int dd, int q) {
int from = t[dd], to = q, score = s[d][to] - s[d][from];
int r = *st[from].upper_bound(dd);
auto it = st[from].lower_bound(dd);
it--;
int l = *it;
score -= (r - dd) * (dd - l);
r = *st[to].upper_bound(dd);
it = st[to].lower_bound(dd);
it--;
l = *it;
score += (r - dd) * (dd - l);
return score;
}
int score = 0;
void init() {
int last[26];
fill(last, last + 26, -1);
rep(i, d) {
int maidx = -1, ma = -INF;
rep(j, 26) {
int score = s[i][j];
int memo = last[j];
last[j] = i;
rep(k, 26) score -= c[k] * (i - last[k]);
last[j] = memo;
if (ma < score) {
ma = score;
maidx = j;
}
}
last[maidx] = i;
t[i] = maidx;
st[t[i]].insert(i);
}
rep(i, 26) {
st[i].insert(-1);
st[i].insert(d);
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> d;
rep(i, 26) cin >> c[i];
rep(i, d) {
rep(j, 26) { cin >> s[i][j]; }
}
init();
int score = 0, last[26];
fill(last, last + 26, -1);
rep(i, d) {
score += s[i][t[i]];
last[t[i]] = i;
rep(j, 26) score -= c[j] * (i - last[j]);
}
rep(_, 170000) {
int dd = Random(0, d - 1), q = Random(0, 24);
if (t[dd] <= q)
q++;
int to = toscore(dd, q);
if (to > 0) {
score += to;
int from = t[dd], to = q;
t[dd] = to;
st[from].erase(dd);
st[to].insert(dd);
}
}
rep(i, d) cout << t[i] + 1 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define P pair<int, int>
#define fi first
#define se second
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
#define pb push_back
constexpr int INF = 1000000000;
int Random(int mi, int ma) {
random_device rnd;
mt19937 mt(rnd()); // 32bit
//[mi,ma]
uniform_int_distribution<int> engine(mi, ma);
return engine(mt);
}
int d, c[26], s[365][26], t[365];
set<int> st[26];
int toscore(int dd, int q) {
int from = t[dd], to = q, score = s[d][to] - s[d][from];
int r = *st[from].upper_bound(dd);
auto it = st[from].lower_bound(dd);
it--;
int l = *it;
score -= (r - dd) * (dd - l);
r = *st[to].upper_bound(dd);
it = st[to].lower_bound(dd);
it--;
l = *it;
score += (r - dd) * (dd - l);
return score;
}
int score = 0;
void init() {
int last[26];
fill(last, last + 26, -1);
rep(i, d) {
int maidx = -1, ma = -INF;
rep(j, 26) {
int score = s[i][j];
int memo = last[j];
last[j] = i;
rep(k, 26) score -= c[k] * (i - last[k]);
last[j] = memo;
if (ma < score) {
ma = score;
maidx = j;
}
}
last[maidx] = i;
t[i] = maidx;
st[t[i]].insert(i);
}
rep(i, 26) {
st[i].insert(-1);
st[i].insert(d);
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> d;
rep(i, 26) cin >> c[i];
rep(i, d) {
rep(j, 26) { cin >> s[i][j]; }
}
init();
int score = 0, last[26];
fill(last, last + 26, -1);
rep(i, d) {
score += s[i][t[i]];
last[t[i]] = i;
rep(j, 26) score -= c[j] * (i - last[j]);
}
rep(_, 150000) {
int dd = Random(0, d - 1), q = Random(0, 24);
if (t[dd] <= q)
q++;
int to = toscore(dd, q);
if (to > 0) {
score += to;
int from = t[dd], to = q;
t[dd] = to;
st[from].erase(dd);
st[to].insert(dd);
}
}
rep(i, d) cout << t[i] + 1 << endl;
return 0;
} | replace | 74 | 75 | 74 | 75 | TLE | |
p02618 | C++ | Time Limit Exceeded | #pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
int D;
vector<int> c(26);
vector<vector<int>> s;
int scoring(const vector<int> &t) {
int v = 0;
vector<int> last(26, -1);
rep(i, D) {
v += s[i][t[i]];
last[t[i]] = i;
rep(j, 26) { v -= c[j] * (i - last[j]); }
}
return v;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
auto start = chrono::system_clock::now();
cin >> D;
rep(i, 26) cin >> c[i];
s.resize(D, vector<int>(26));
rep(i, D) rep(j, 26) cin >> s[i][j];
vector<int> t(D);
rep(i, D) t[i] = max_element(s[i].begin(), s[i].end()) - s[i].begin();
random_device rnd;
mt19937 mt(rnd());
uniform_int_distribution<> rand_d(0, D - 1);
uniform_int_distribution<> rand_t(0, 25);
int v = scoring(t);
int x = 0;
while (true) {
int to_d = rand_d(mt);
int to_t = rand_t(mt);
if (t[to_d] == to_t)
continue;
int old = t[to_d];
t[to_d] = to_t;
int nv = scoring(t);
if (nv < v)
t[to_d] = old;
if (x % 10000 == 0) {
auto end = chrono::system_clock::now();
auto dur = end - start;
auto msec = chrono::duration_cast<chrono::milliseconds>(dur).count();
if (msec >= 1970)
break;
}
x++;
}
rep(i, D) cout << t[i] + 1 << '\n';
}
| #pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
int D;
vector<int> c(26);
vector<vector<int>> s;
int scoring(const vector<int> &t) {
int v = 0;
vector<int> last(26, -1);
rep(i, D) {
v += s[i][t[i]];
last[t[i]] = i;
rep(j, 26) { v -= c[j] * (i - last[j]); }
}
return v;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
auto start = chrono::system_clock::now();
cin >> D;
rep(i, 26) cin >> c[i];
s.resize(D, vector<int>(26));
rep(i, D) rep(j, 26) cin >> s[i][j];
vector<int> t(D);
rep(i, D) t[i] = max_element(s[i].begin(), s[i].end()) - s[i].begin();
random_device rnd;
mt19937 mt(rnd());
uniform_int_distribution<> rand_d(0, D - 1);
uniform_int_distribution<> rand_t(0, 25);
int v = scoring(t);
int x = 0;
while (true) {
int to_d = rand_d(mt);
int to_t = rand_t(mt);
if (t[to_d] == to_t)
continue;
int old = t[to_d];
t[to_d] = to_t;
int nv = scoring(t);
if (nv < v)
t[to_d] = old;
if (x % 1000 == 0) {
auto end = chrono::system_clock::now();
auto dur = end - start;
auto msec = chrono::duration_cast<chrono::milliseconds>(dur).count();
if (msec >= 1970)
break;
}
x++;
}
rep(i, D) cout << t[i] + 1 << '\n';
}
| replace | 54 | 55 | 54 | 55 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rng(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, b) rng(i, 0, b)
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int d;
cin >> d;
const int ContestCount = 26;
vector<int> c(ContestCount);
rep(i, ContestCount) cin >> c.at(i);
vector<vector<int>> s(d, vector<int>(ContestCount));
rep(i, d) {
rep(j, ContestCount) { cin >> s.at(i).at(j); }
}
vector<int> res(ContestCount);
rep(i, d) { res.at(i) = i; }
rep(i, d) { cout << res.at(i) << endl; }
return 0;
}
| #include <bits/stdc++.h>
#define rng(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, b) rng(i, 0, b)
#define gnr(i, a, b) for (int i = int(b) - 1; i >= int(a); i--)
#define per(i, b) gnr(i, 0, b)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int d;
cin >> d;
const int ContestCount = 26;
vector<int> c(ContestCount);
rep(i, ContestCount) cin >> c.at(i);
vector<vector<int>> s(d, vector<int>(ContestCount));
rep(i, d) {
rep(j, ContestCount) { cin >> s.at(i).at(j); }
}
vector<int> res(d);
rep(i, d) { res.at(i) = 1; }
rep(i, d) { cout << res.at(i) << endl; }
return 0;
}
| replace | 22 | 24 | 22 | 24 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define reps(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) reps(i, 0, n)
#define Rreps(i, n, e) for (int i = n - 1; i >= e; --i)
#define Rrep(i, n) Rreps(i, n, 0)
#define ALL(a) a.begin(), a.end()
#define fi first
#define se second
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
ll N, M, H, W, Q, K, A, B;
string S;
const ll MOD = 998244353;
// const ll MOD = (1e+9) + 7;
typedef pair<ll, ll> P;
const ll INF = (1LL << 58);
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
ll calc(mat &s, vec &c, vec &ans) {
ll res = 0;
vec last(26, 0);
rep(day, N) {
last[ans[day]] = day + 1;
rep(i, 26) {
if (i == ans[day]) {
res += s[day][i];
} else {
res -= c[i] * (day + 1 - last[i]);
}
}
}
return res;
}
void make_ans_another(vec &ans, mat &ans_another) {
rep(day, N) { ans_another[ans[day]].push_back(day + 1); }
rep(i, 26) ans_another[i].push_back(N + 1);
}
int main() {
cin >> N;
vec c(26), last(26, 0), ans(N);
mat s(N, vec(26));
rep(i, 26) cin >> c[i];
rep(i, N) rep(j, 26) cin >> s[i][j];
ll score = 0;
rep(day, N) {
vec temp(26, 0);
rep(i, 26) temp[i] += s[day][i];
rep(i, 26) temp[i] += c[i] * (day + 1 - last[i]);
auto ite = max_element(ALL(temp));
ans[day] = ite - temp.begin();
last[ite - temp.begin()] = day + 1;
rep(i, 26) {
if (i == ans[day]) {
score += s[day][i];
} else {
score -= c[i] * (day + 1 - last[i]);
}
}
}
ll total_num = 200000;
bool stopped = false;
while (total_num || stopped) {
mat minus(N + 1, vec(26, 0)), ans_another(26, vec(1, 0));
make_ans_another(ans, ans_another);
++total_num;
priority_queue<P> pque;
rep(i, 26) {
vec &table = ans_another[i];
int id = 0;
reps(day, 1, N) {
if (table[id + 1] == day) {
++id;
} else {
ll weight = s[day - 1][i], len = table[id + 1] - table[id] - 1;
ll wh = day - table[id];
weight +=
c[i] * ((len * (len + 1) / 2) -
(wh * (wh - 1) / 2 + (len - wh) * (len - wh + 1) / 2));
ll vs = ans[day - 1];
auto ite = lower_bound(ALL(ans_another[vs]), day);
len = *(++ite);
ite -= 2;
len -= *ite + 1;
wh = day - *ite;
weight -=
s[day - 1][vs] +
c[vs] * ((len * (len + 1) / 2) -
(wh * (wh - 1) / 2 + (len - wh) * (len - wh + 1) / 2));
pque.emplace(weight, day * 26 + i);
}
}
}
if ((total_num -= 20) < 0)
break;
rep(check, 10000) {
P p = pque.top();
pque.pop();
ll day = p.se / 26, i = p.se % 26;
--day;
if (p.se <= 0) {
stopped = check == 0;
break;
} else if (check == 0) {
ans[day] = i;
score += p.se;
} else {
ll old = ans[day];
ans[day] = i;
if (!chmax(score, calc(s, c, ans))) {
ans[day] = old;
check *= 10;
}
}
if ((--total_num) < 0)
break;
}
}
rep(i, N) cout << ans[i] + 1 << '\n';
}
| #include <bits/stdc++.h>
using namespace std;
#define reps(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) reps(i, 0, n)
#define Rreps(i, n, e) for (int i = n - 1; i >= e; --i)
#define Rrep(i, n) Rreps(i, n, 0)
#define ALL(a) a.begin(), a.end()
#define fi first
#define se second
typedef long long ll;
typedef vector<ll> vec;
typedef vector<vec> mat;
ll N, M, H, W, Q, K, A, B;
string S;
const ll MOD = 998244353;
// const ll MOD = (1e+9) + 7;
typedef pair<ll, ll> P;
const ll INF = (1LL << 58);
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
ll calc(mat &s, vec &c, vec &ans) {
ll res = 0;
vec last(26, 0);
rep(day, N) {
last[ans[day]] = day + 1;
rep(i, 26) {
if (i == ans[day]) {
res += s[day][i];
} else {
res -= c[i] * (day + 1 - last[i]);
}
}
}
return res;
}
void make_ans_another(vec &ans, mat &ans_another) {
rep(day, N) { ans_another[ans[day]].push_back(day + 1); }
rep(i, 26) ans_another[i].push_back(N + 1);
}
int main() {
cin >> N;
vec c(26), last(26, 0), ans(N);
mat s(N, vec(26));
rep(i, 26) cin >> c[i];
rep(i, N) rep(j, 26) cin >> s[i][j];
ll score = 0;
rep(day, N) {
vec temp(26, 0);
rep(i, 26) temp[i] += s[day][i];
rep(i, 26) temp[i] += c[i] * (day + 1 - last[i]);
auto ite = max_element(ALL(temp));
ans[day] = ite - temp.begin();
last[ite - temp.begin()] = day + 1;
rep(i, 26) {
if (i == ans[day]) {
score += s[day][i];
} else {
score -= c[i] * (day + 1 - last[i]);
}
}
}
ll total_num = 200000;
bool stopped = false;
while (total_num && stopped) {
mat minus(N + 1, vec(26, 0)), ans_another(26, vec(1, 0));
make_ans_another(ans, ans_another);
++total_num;
priority_queue<P> pque;
rep(i, 26) {
vec &table = ans_another[i];
int id = 0;
reps(day, 1, N) {
if (table[id + 1] == day) {
++id;
} else {
ll weight = s[day - 1][i], len = table[id + 1] - table[id] - 1;
ll wh = day - table[id];
weight +=
c[i] * ((len * (len + 1) / 2) -
(wh * (wh - 1) / 2 + (len - wh) * (len - wh + 1) / 2));
ll vs = ans[day - 1];
auto ite = lower_bound(ALL(ans_another[vs]), day);
len = *(++ite);
ite -= 2;
len -= *ite + 1;
wh = day - *ite;
weight -=
s[day - 1][vs] +
c[vs] * ((len * (len + 1) / 2) -
(wh * (wh - 1) / 2 + (len - wh) * (len - wh + 1) / 2));
pque.emplace(weight, day * 26 + i);
}
}
}
if ((total_num -= 20) < 0)
break;
rep(check, 10000) {
P p = pque.top();
pque.pop();
ll day = p.se / 26, i = p.se % 26;
--day;
if (p.se <= 0) {
stopped = check == 0;
break;
} else if (check == 0) {
ans[day] = i;
score += p.se;
} else {
ll old = ans[day];
ans[day] = i;
if (!chmax(score, calc(s, c, ans))) {
ans[day] = old;
check *= 10;
}
}
if ((--total_num) < 0)
break;
}
}
rep(i, N) cout << ans[i] + 1 << '\n';
}
| replace | 81 | 82 | 81 | 82 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using namespace chrono;
int main() {
auto start = steady_clock::now();
random_device rnd;
int D;
vector<int> cs(26);
cin >> D;
for (auto &&c : cs) {
cin >> c;
}
vector<vector<int>> sss(D, vector<int>(26));
for (auto &&ss : sss) {
for (auto &&s : ss) {
cin >> s;
}
}
vector<int> ts(D);
for (auto &&t : ts) {
t = rnd() % 26;
}
auto calc_score = [&] {
vector<int> last(26, -1);
int s = 0;
for (int d = 0; d < D; d++) {
s += sss[d][ts[d]];
last[ts[d]] = d;
for (int i = 0; i < 26; i++) {
s -= cs[i] * (d - last[i]);
}
}
// return max(0, 1000000 + s);
return s;
};
auto calc_diff = [&](int d, int q) {
int p = ts[d];
ts[d] = q;
int ret = calc_score();
ts[d] = p;
return ret;
};
int score = calc_score();
while (duration_cast<milliseconds>(steady_clock::now() - start).count() <
1970) {
for (int d = 0; d < D; d++) {
for (int q = 0; q < 26; q++) {
if (ts[d] == q) {
continue;
}
int next_score = calc_diff(d, q);
if (score < next_score) {
ts[d] = q;
score = next_score;
}
}
}
}
for (auto &&t : ts) {
cout << t + 1 << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using namespace chrono;
int main() {
auto start = steady_clock::now();
random_device rnd;
int D;
vector<int> cs(26);
cin >> D;
for (auto &&c : cs) {
cin >> c;
}
vector<vector<int>> sss(D, vector<int>(26));
for (auto &&ss : sss) {
for (auto &&s : ss) {
cin >> s;
}
}
vector<int> ts(D);
for (auto &&t : ts) {
t = rnd() % 26;
}
auto calc_score = [&] {
vector<int> last(26, -1);
int s = 0;
for (int d = 0; d < D; d++) {
s += sss[d][ts[d]];
last[ts[d]] = d;
for (int i = 0; i < 26; i++) {
s -= cs[i] * (d - last[i]);
}
}
// return max(0, 1000000 + s);
return s;
};
auto calc_diff = [&](int d, int q) {
int p = ts[d];
ts[d] = q;
int ret = calc_score();
ts[d] = p;
return ret;
};
int score = calc_score();
while (duration_cast<milliseconds>(steady_clock::now() - start).count() <
1950) {
for (int d = 0; d < D; d++) {
for (int q = 0; q < 26; q++) {
if (ts[d] == q) {
continue;
}
int next_score = calc_diff(d, q);
if (score < next_score) {
ts[d] = q;
score = next_score;
}
}
}
}
for (auto &&t : ts) {
cout << t + 1 << endl;
}
return 0;
} | replace | 61 | 62 | 61 | 62 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
chrono::system_clock::time_point start;
start = chrono::system_clock::now();
ios::sync_with_stdio(false);
cin.tie(0);
const int INF = 1000000000;
int d;
cin >> d;
vector<int> c(26);
vector<vector<int>> s(d, vector<int>(26));
for (int i = 0; i < 26; ++i)
cin >> c[i];
for (int j = 0; j < d; ++j)
for (int i = 0; i < 26; ++i)
cin >> s[j][i];
int m;
vector<int> t(d);
vector<vector<int>> blank(d, vector<int>(26, 1));
for (int j = 0; j < d; ++j) {
for (int i = 0; i < 26; ++i)
if (j != 0)
blank[j][i] = blank[j - 1][i] + 1;
m = -INF;
for (int i = 0; i < 26; ++i) {
if (s[j][i] + c[i] * blank[j][i] > m) {
t[j] = i;
m = s[j][i] + c[i] * blank[j][i];
}
}
blank[j][t[j]] = 0;
}
int d_, q, dt, diff = 0, m2;
vector<int> t_ = t;
vector<vector<int>> blank_ = blank;
srand((unsigned int)time(NULL));
while (chrono::duration_cast<chrono::seconds>(chrono::system_clock::now() -
start)
.count() < 1.5) {
d_ = rand() % d;
m2 = -INF;
for (int i = 0; i < 26; ++i) {
if (s[d_][i] > m2) {
m2 = s[d_][i];
q = i;
}
}
// q = rand() % 26;
diff = 0;
diff -= s[d_][t_[d_]];
diff += s[d_][q];
if (d_ != 0)
blank_[d_][t_[d_]] = blank_[d_ - 1][t_[d_]] + 1;
else
blank_[d_][t_[d_]] = 1;
diff -= c[t_[d_]] * blank_[d_][t_[d_]];
dt = d_ + 1;
while (t_[dt] != t_[d_] && dt < d) {
diff += c[t_[d_]] * blank_[dt][t_[d_]];
blank_[dt][t_[d_]] = blank_[dt - 1][t_[d_]] + 1;
diff -= c[t_[d_]] * blank_[dt][t_[d_]];
dt++;
}
diff += c[q] * blank_[d_][q];
blank_[d_][q] = 0;
dt = d_ + 1;
while (t_[dt] != q && dt < d) {
diff += c[q] * blank_[dt][q];
blank_[dt][q] = blank_[dt - 1][q] + 1;
diff -= c[q] * blank_[dt][q];
dt++;
}
t_[d_] = q;
// printf("%d\n", diff);
if (diff > 0) {
t = t_;
blank = blank_;
} else {
t_ = t;
blank_ = blank;
}
}
for (int j = 0; j < d; ++j) {
printf("%d\n", t[j] + 1);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
chrono::system_clock::time_point start;
start = chrono::system_clock::now();
ios::sync_with_stdio(false);
cin.tie(0);
const int INF = 1000000000;
int d;
cin >> d;
vector<int> c(26);
vector<vector<int>> s(d, vector<int>(26));
for (int i = 0; i < 26; ++i)
cin >> c[i];
for (int j = 0; j < d; ++j)
for (int i = 0; i < 26; ++i)
cin >> s[j][i];
int m;
vector<int> t(d);
vector<vector<int>> blank(d, vector<int>(26, 1));
for (int j = 0; j < d; ++j) {
for (int i = 0; i < 26; ++i)
if (j != 0)
blank[j][i] = blank[j - 1][i] + 1;
m = -INF;
for (int i = 0; i < 26; ++i) {
if (s[j][i] + c[i] * blank[j][i] > m) {
t[j] = i;
m = s[j][i] + c[i] * blank[j][i];
}
}
blank[j][t[j]] = 0;
}
int d_, q, dt, diff = 0, m2;
vector<int> t_ = t;
vector<vector<int>> blank_ = blank;
srand((unsigned int)time(NULL));
while (chrono::duration_cast<chrono::milliseconds>(
chrono::system_clock::now() - start)
.count() < 1900) {
d_ = rand() % d;
m2 = -INF;
for (int i = 0; i < 26; ++i) {
if (s[d_][i] > m2) {
m2 = s[d_][i];
q = i;
}
}
// q = rand() % 26;
diff = 0;
diff -= s[d_][t_[d_]];
diff += s[d_][q];
if (d_ != 0)
blank_[d_][t_[d_]] = blank_[d_ - 1][t_[d_]] + 1;
else
blank_[d_][t_[d_]] = 1;
diff -= c[t_[d_]] * blank_[d_][t_[d_]];
dt = d_ + 1;
while (t_[dt] != t_[d_] && dt < d) {
diff += c[t_[d_]] * blank_[dt][t_[d_]];
blank_[dt][t_[d_]] = blank_[dt - 1][t_[d_]] + 1;
diff -= c[t_[d_]] * blank_[dt][t_[d_]];
dt++;
}
diff += c[q] * blank_[d_][q];
blank_[d_][q] = 0;
dt = d_ + 1;
while (t_[dt] != q && dt < d) {
diff += c[q] * blank_[dt][q];
blank_[dt][q] = blank_[dt - 1][q] + 1;
diff -= c[q] * blank_[dt][q];
dt++;
}
t_[d_] = q;
// printf("%d\n", diff);
if (diff > 0) {
t = t_;
blank = blank_;
} else {
t_ = t;
blank_ = blank;
}
}
for (int j = 0; j < d; ++j) {
printf("%d\n", t[j] + 1);
}
return 0;
} | replace | 45 | 48 | 45 | 48 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
long long D = 365, type = 26, inf = 1001001001;
vector<long long> C(type);
vector<vector<long long>> S(D, vector<long long>(type));
struct STR {
long long score;
vector<long long> ans;
vector<long long> last;
};
bool operator<(const STR &left, const STR &right) {
if (left.score < right.score)
return true;
else
return false;
}
void input() {
cin >> D;
for (int i = 0; i < type; i++)
cin >> C[i];
for (int i = 0; i < D; i++) {
for (int j = 0; j < type; j++) {
cin >> S[i][j];
}
}
return;
}
long long calc(long long day, long long t, vector<long long> &last) {
long long score = S[day][t];
for (int i = 0; i < type; i++) {
score -= C[i] * (day - last[i]);
}
return score;
}
int main() {
input();
long long score = 0;
vector<long long> last(type, -1), V(0);
vector<priority_queue<STR>> Q(2);
STR s = {score, V, last};
Q[0].push(s);
for (int i = 0; i < D; i++) {
while (!Q[(i + 1) % 2].empty())
Q[(i + 1) % 2].pop();
for (int j = 0; j < 50; j++) {
if (Q[i % 2].empty())
break;
STR str = Q[i % 2].top();
Q[i % 2].pop();
for (int k = 0; k < type; k++) {
long long x = calc(i, k, str.last);
vector<long long> y = str.last, z = str.ans;
y[k] = i;
z.push_back(k);
STR str2 = {x, z, y};
Q[(i + 1) % 2].push(str2);
}
}
}
vector<long long> ans = Q[D].top().ans;
for (int i = 0; i < D; i++)
cout << ans[i] + 1 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
long long D = 365, type = 26, inf = 1001001001;
vector<long long> C(type);
vector<vector<long long>> S(D, vector<long long>(type));
struct STR {
long long score;
vector<long long> ans;
vector<long long> last;
};
bool operator<(const STR &left, const STR &right) {
if (left.score < right.score)
return true;
else
return false;
}
void input() {
cin >> D;
for (int i = 0; i < type; i++)
cin >> C[i];
for (int i = 0; i < D; i++) {
for (int j = 0; j < type; j++) {
cin >> S[i][j];
}
}
return;
}
long long calc(long long day, long long t, vector<long long> &last) {
long long score = S[day][t];
for (int i = 0; i < type; i++) {
score -= C[i] * (day - last[i]);
}
return score;
}
int main() {
input();
long long score = 0;
vector<long long> last(type, -1), V(0);
vector<priority_queue<STR>> Q(2);
STR s = {score, V, last};
Q[0].push(s);
for (int i = 0; i < D; i++) {
while (!Q[(i + 1) % 2].empty())
Q[(i + 1) % 2].pop();
for (int j = 0; j < 50; j++) {
if (Q[i % 2].empty())
break;
STR str = Q[i % 2].top();
Q[i % 2].pop();
for (int k = 0; k < type; k++) {
long long x = calc(i, k, str.last);
vector<long long> y = str.last, z = str.ans;
y[k] = i;
z.push_back(k);
STR str2 = {x, z, y};
Q[(i + 1) % 2].push(str2);
}
}
}
vector<long long> ans = Q[D % 2].top().ans;
for (int i = 0; i < D; i++)
cout << ans[i] + 1 << endl;
return 0;
}
| replace | 67 | 68 | 67 | 68 | -11 | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ldb;
const int MAXM = 4e2 + 5;
const int MAXN = 26 + 5;
const int MAXT = 2e7 + 5;
const int inf = 0x3f3f3f3f;
const ll linf = 0x3f3f3f3f3f3f3f3f;
int n = 26, m;
int c[MAXN];
int a[MAXM][MAXN];
int p[MAXM], beg[MAXM];
set<int> idx[MAXN];
int ans;
void init(void) {
for (int i = 1; i <= n; ++i) {
idx[i].clear();
idx[i].insert(0);
idx[i].insert(m + 1);
}
for (int k = 1; k <= m; ++k)
idx[p[k]].insert(k);
}
struct Oper {
int pos, x;
} oper[MAXT];
int tcnt = 0;
int recalc(register int pos, register int x) {
register int old = p[pos];
if (old == x)
return ans;
oper[++tcnt] = (Oper){pos, x};
register int res = ans;
idx[old].erase(pos);
set<int>::iterator it = idx[old].upper_bound(pos);
register int nxt = *it;
register int lst = *(--it);
res -= (pos - lst) * c[old] * (nxt - pos) + a[pos][old];
it = idx[x].upper_bound(pos);
nxt = *it;
lst = *(--it);
res += (pos - lst) * c[x] * (nxt - pos) + a[pos][x];
idx[x].insert(pos);
p[pos] = x;
return res;
}
int main(void) {
srand(time(0));
scanf("%d", &m);
for (int i = 1; i <= n; ++i)
scanf("%d", &c[i]);
for (int i = 1; i <= m; ++i)
for (int j = 1; j <= n; ++j)
scanf("%d", &a[i][j]);
static int lst[MAXN];
ans = 0;
for (int k = 1; k <= m; ++k) {
int mx = -inf;
int mxi = -1;
for (int i = 1; i <= n; ++i) {
int res = a[k][i];
for (int j = 1; j <= n; ++j)
if (j != i)
res -= c[j] * (k - lst[j]);
if (mxi == -1 || mx < res)
mxi = i, mx = res;
}
lst[mxi] = k;
ans += mx;
p[k] = mxi;
}
for (int i = 1; i <= m; ++i)
beg[i] = p[i];
init();
static int pp[MAXM];
static int qq[MAXM];
for (int i = 1; i <= m; ++i)
pp[i] = i;
for (int i = 1; i <= n; ++i)
qq[i] = i;
const ldb Delta = 0.97;
ldb Temp = 1000000;
int mxans = ans, mxi = 0;
int T = 500;
while (T--) {
random_shuffle(pp + 1, pp + m + 1);
for (int i = 1; i <= m; ++i) {
random_shuffle(qq + 1, qq + n + 1);
for (int j = 1; j <= n; ++j) {
int pos = pp[i];
int x = qq[j];
int old = p[pos];
int res = recalc(pos, x);
if (res > ans || (ans - res) / Temp > (ldb)rand() / RAND_MAX) {
if (res > mxans)
mxans = res, mxi = tcnt;
ans = res;
} else
recalc(pos, old);
Temp *= Delta;
}
}
}
for (int i = 1; i <= m; ++i)
p[i] = beg[i];
for (int i = 1; i <= mxi; ++i)
p[oper[i].pos] = oper[i].x;
for (int i = 1; i <= m; ++i)
printf("%d\n", p[i]);
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
typedef long double ldb;
const int MAXM = 4e2 + 5;
const int MAXN = 26 + 5;
const int MAXT = 2e7 + 5;
const int inf = 0x3f3f3f3f;
const ll linf = 0x3f3f3f3f3f3f3f3f;
int n = 26, m;
int c[MAXN];
int a[MAXM][MAXN];
int p[MAXM], beg[MAXM];
set<int> idx[MAXN];
int ans;
void init(void) {
for (int i = 1; i <= n; ++i) {
idx[i].clear();
idx[i].insert(0);
idx[i].insert(m + 1);
}
for (int k = 1; k <= m; ++k)
idx[p[k]].insert(k);
}
struct Oper {
int pos, x;
} oper[MAXT];
int tcnt = 0;
int recalc(register int pos, register int x) {
register int old = p[pos];
if (old == x)
return ans;
oper[++tcnt] = (Oper){pos, x};
register int res = ans;
idx[old].erase(pos);
set<int>::iterator it = idx[old].upper_bound(pos);
register int nxt = *it;
register int lst = *(--it);
res -= (pos - lst) * c[old] * (nxt - pos) + a[pos][old];
it = idx[x].upper_bound(pos);
nxt = *it;
lst = *(--it);
res += (pos - lst) * c[x] * (nxt - pos) + a[pos][x];
idx[x].insert(pos);
p[pos] = x;
return res;
}
int main(void) {
srand(time(0));
scanf("%d", &m);
for (int i = 1; i <= n; ++i)
scanf("%d", &c[i]);
for (int i = 1; i <= m; ++i)
for (int j = 1; j <= n; ++j)
scanf("%d", &a[i][j]);
static int lst[MAXN];
ans = 0;
for (int k = 1; k <= m; ++k) {
int mx = -inf;
int mxi = -1;
for (int i = 1; i <= n; ++i) {
int res = a[k][i];
for (int j = 1; j <= n; ++j)
if (j != i)
res -= c[j] * (k - lst[j]);
if (mxi == -1 || mx < res)
mxi = i, mx = res;
}
lst[mxi] = k;
ans += mx;
p[k] = mxi;
}
for (int i = 1; i <= m; ++i)
beg[i] = p[i];
init();
static int pp[MAXM];
static int qq[MAXM];
for (int i = 1; i <= m; ++i)
pp[i] = i;
for (int i = 1; i <= n; ++i)
qq[i] = i;
const ldb Delta = 0.97;
ldb Temp = 1000000;
int mxans = ans, mxi = 0;
int T = 400;
while (T--) {
random_shuffle(pp + 1, pp + m + 1);
for (int i = 1; i <= m; ++i) {
random_shuffle(qq + 1, qq + n + 1);
for (int j = 1; j <= n; ++j) {
int pos = pp[i];
int x = qq[j];
int old = p[pos];
int res = recalc(pos, x);
if (res > ans || (ans - res) / Temp > (ldb)rand() / RAND_MAX) {
if (res > mxans)
mxans = res, mxi = tcnt;
ans = res;
} else
recalc(pos, old);
Temp *= Delta;
}
}
}
for (int i = 1; i <= m; ++i)
p[i] = beg[i];
for (int i = 1; i <= mxi; ++i)
p[oper[i].pos] = oper[i].x;
for (int i = 1; i <= m; ++i)
printf("%d\n", p[i]);
return 0;
} | replace | 118 | 119 | 118 | 119 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define pb push_back
using VI = vector<int>;
using ll = long long;
const ll inf = 0x3f3f3f3f3f3f3f3f;
const int MXT = 26;
const int MXD = 365;
int D;
int C[MXT + 10], S[MXD + 10][MXT + 10];
VI best;
ll best_score;
namespace MyChecker {
int last[MXT + 10];
ll calc_score(VI ans = best) {
fill_n(last + 1, MXT, 0);
if (ans.size() != D) {
puts("Wrong Answer");
assert(0);
}
int d = 0;
ll score = 0;
for (auto x : ans) {
++d;
score += S[d][x];
last[x] = d;
for (int i = 1; i <= MXT; i++)
score -= 1ll * C[i] * (d - last[i]);
}
return max(0ll, score + 1000000);
}
} // namespace MyChecker
void update_ans(VI ¤t, ll new_score = -inf) {
if (new_score == -inf)
new_score = MyChecker::calc_score(current);
if (best.empty() || best_score < new_score) {
best_score = new_score;
best = current;
}
return;
}
void input_and_init() {
scanf("%d", &D);
for (int i = 1; i <= MXT; i++)
scanf("%d", &C[i]);
for (int i = 1; i <= D; i++) {
for (int j = 1; j <= MXT; j++)
scanf("%d", &S[i][j]);
}
best.clear();
return;
}
void output() {
for (auto x : best)
printf("%d\n", x);
}
namespace Greedy {
int last[MXT + 10];
ll greedy(double param) {
fill_n(last, MXT + 1, 0);
ll delta[MXT + 1] = {0};
VI greedy_ans;
ll score = 0;
for (int i = 1; i <= D; i++) {
for (int j = 1; j <= MXT; j++)
delta[j] += C[j];
ll sum = accumulate(delta + 1, delta + MXT + 1, 0ll);
double mx = -2e18;
int ansd = -1;
for (int j = 1; j <= MXT; j++) {
double val = param * delta[j] + S[i][j];
if (mx < val)
mx = val, ansd = j;
}
score += S[i][ansd] + delta[ansd] - sum;
delta[ansd] = 0;
last[ansd] = i;
greedy_ans.pb(ansd);
}
update_ans(greedy_ans, max(score + 1000000, 0ll));
return score;
}
void greedy_solve() {
for (double x = 1; x <= 10; x += 1)
greedy(x);
}
} // namespace Greedy
namespace Update1 {
VI days[MXT + 1];
VI plan;
ll score;
VI random_days, cur, best;
ll mx = -inf;
void erase(int d, int type) {
auto it = lower_bound(days[type].begin(), days[type].end(), d);
score -= (*it - *prev(it)) * (*next(it) - *it) * C[type];
score -= S[d][type];
days[type].erase(it);
plan[d - 1] = 0;
}
void add(int d, int type) {
auto it = lower_bound(days[type].begin(), days[type].end(), d);
score += (d - *prev(it)) * (*it - d) * C[type];
score += S[d][type];
days[type].insert(it, d);
plan[d - 1] = type;
}
void dfs(int x) {
if (x == random_days.size()) {
if (mx < score)
mx = score, best = cur;
return;
}
for (int i = 1; i <= MXT; i++) {
cur[x] = i;
add(random_days[x], i);
dfs(x + 1);
erase(random_days[x], i);
}
return;
}
void update1(VI &_plan) {
int d = 0;
plan = _plan;
score = MyChecker::calc_score();
for (int i = 1; i <= MXT; i++)
days[i] = {0};
for (auto x : plan)
days[x].pb(++d);
for (int i = 1; i <= MXT; i++)
days[i].pb(D + 1);
for (int step = 0; step < 10000; step++) {
ll prv = score;
random_days.clear();
while (random_days.size() < 2) {
int d = rng() % 365 + 1;
random_days.pb(d);
}
sort(random_days.begin(), random_days.end());
random_days.erase(unique(random_days.begin(), random_days.end()),
random_days.end());
for (auto x : random_days)
erase(x, plan[x - 1]);
cur.resize(random_days.size());
mx = -inf;
dfs(0);
for (int i = 0; i < random_days.size(); i++)
add(random_days[i], best[i]);
assert(score == mx);
}
update_ans(plan, score);
}
} // namespace Update1
namespace Update2 {
VI plan, days[MXT + 1];
ll dp[MXD + 10][MXD + 10];
int prv[MXD + 10][MXD + 10];
void update_solve(int x, int y) {
VI dd;
dd.pb(0);
for (auto y : days[x])
dd.pb(y);
for (auto x : days[y])
dd.pb(x);
sort(dd.begin(), dd.end());
ll pscore = 0;
int prvp = 0;
for (auto y : days[x])
pscore += (y - max(prvp, 1)) * C[x] * prvp + S[y][x], prvp = y;
pscore += (D + 1 - prvp) * C[x] * prvp;
prvp = 0;
for (auto x : days[y])
pscore += (x - max(prvp, 1)) * C[y] * prvp + S[x][y], prvp = x;
pscore += (D + 1 - prvp) * C[y] * prvp;
int sz = dd.size() - 1;
for (int i = 0; i <= sz; i++)
fill(dp[i], dp[i] + sz + 1, -1);
dp[0][0] = 0;
for (int i = 1; i <= sz; i++) {
ll tmp;
for (int j = 0; j < i; j++) {
if (dp[j][i - 1] >= 0) {
tmp =
dp[j][i - 1] + S[dd[i]][y] + C[y] * (dd[i] - dd[i - 1]) * dd[i - 1];
if (dp[j][i] < tmp)
dp[j][i] = tmp, prv[j][i] = (j << 10) | (i - 1);
tmp = dp[j][i - 1] + S[dd[i]][x] + C[x] * (dd[i] - dd[j]) * dd[j];
if (dp[i][i - 1] < tmp)
dp[i][i - 1] = tmp, prv[i][i - 1] = (j << 10) | (i - 1);
}
if (dp[i - 1][j] >= 0) {
tmp =
dp[i - 1][j] + S[dd[i]][x] + C[x] * (dd[i] - dd[i - 1]) * dd[i - 1];
if (dp[i][j] < tmp)
dp[i][j] = tmp, prv[i][j] = (i - 1 << 10) | j;
tmp = dp[i - 1][j] + S[dd[i]][y] + C[y] * (dd[i] - dd[j]) * dd[j];
if (dp[i - 1][i] < tmp)
dp[i - 1][i] = tmp, prv[i - 1][i] = (i - 1 << 10) | j;
}
}
}
ll mx = -1;
int ex = -1, ey = -1;
for (int i = 0; i < sz; i++) {
ll tmp;
tmp = dp[i][sz] + (D + 1 - dd[i]) * C[x] * dd[i] +
(D + 1 - dd[sz]) * C[y] * dd[sz];
if (mx < tmp)
mx = tmp, ex = i, ey = sz;
tmp = dp[sz][i] + (D + 1 - dd[sz]) * C[x] * dd[sz] +
(D + 1 - dd[i]) * C[y] * dd[i];
if (mx < tmp)
mx = tmp, ex = sz, ey = i;
}
days[x].clear(), days[y].clear();
if (ex)
days[x].pb(dd[ex]);
if (ey)
days[y].pb(dd[ey]);
while (ex > 0 || ey > 0) {
int px = prv[ex][ey] >> 10, py = prv[ex][ey] & 1023;
if (px != ex) {
ex = px;
if (ex)
days[x].pb(dd[ex]);
}
if (py != ey) {
ey = py;
if (ey)
days[y].pb(dd[ey]);
}
}
reverse(days[x].begin(), days[x].end());
reverse(days[y].begin(), days[y].end());
assert(mx >= pscore);
return;
}
void update2(VI &_plan) {
plan = _plan;
int d = 0;
for (auto x : plan)
days[x].pb(++d);
for (int step = 0; step < 10000; step++) {
int x = rng() % 26 + 1, y = rng() % 26 + 1;
if (x == y) {
step--;
continue;
}
update_solve(x, y);
}
for (int i = 1; i <= MXT; i++) {
for (auto x : days[i])
plan[x - 1] = i;
}
ll score = MyChecker::calc_score(plan);
update_ans(plan, score);
}
} // namespace Update2
int main() {
input_and_init();
Greedy::greedy_solve();
Update1::update1(best);
Update2::update2(best);
output();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define pb push_back
using VI = vector<int>;
using ll = long long;
const ll inf = 0x3f3f3f3f3f3f3f3f;
const int MXT = 26;
const int MXD = 365;
int D;
int C[MXT + 10], S[MXD + 10][MXT + 10];
VI best;
ll best_score;
namespace MyChecker {
int last[MXT + 10];
ll calc_score(VI ans = best) {
fill_n(last + 1, MXT, 0);
if (ans.size() != D) {
puts("Wrong Answer");
assert(0);
}
int d = 0;
ll score = 0;
for (auto x : ans) {
++d;
score += S[d][x];
last[x] = d;
for (int i = 1; i <= MXT; i++)
score -= 1ll * C[i] * (d - last[i]);
}
return max(0ll, score + 1000000);
}
} // namespace MyChecker
void update_ans(VI ¤t, ll new_score = -inf) {
if (new_score == -inf)
new_score = MyChecker::calc_score(current);
if (best.empty() || best_score < new_score) {
best_score = new_score;
best = current;
}
return;
}
void input_and_init() {
scanf("%d", &D);
for (int i = 1; i <= MXT; i++)
scanf("%d", &C[i]);
for (int i = 1; i <= D; i++) {
for (int j = 1; j <= MXT; j++)
scanf("%d", &S[i][j]);
}
best.clear();
return;
}
void output() {
for (auto x : best)
printf("%d\n", x);
}
namespace Greedy {
int last[MXT + 10];
ll greedy(double param) {
fill_n(last, MXT + 1, 0);
ll delta[MXT + 1] = {0};
VI greedy_ans;
ll score = 0;
for (int i = 1; i <= D; i++) {
for (int j = 1; j <= MXT; j++)
delta[j] += C[j];
ll sum = accumulate(delta + 1, delta + MXT + 1, 0ll);
double mx = -2e18;
int ansd = -1;
for (int j = 1; j <= MXT; j++) {
double val = param * delta[j] + S[i][j];
if (mx < val)
mx = val, ansd = j;
}
score += S[i][ansd] + delta[ansd] - sum;
delta[ansd] = 0;
last[ansd] = i;
greedy_ans.pb(ansd);
}
update_ans(greedy_ans, max(score + 1000000, 0ll));
return score;
}
void greedy_solve() {
for (double x = 1; x <= 10; x += 1)
greedy(x);
}
} // namespace Greedy
namespace Update1 {
VI days[MXT + 1];
VI plan;
ll score;
VI random_days, cur, best;
ll mx = -inf;
void erase(int d, int type) {
auto it = lower_bound(days[type].begin(), days[type].end(), d);
score -= (*it - *prev(it)) * (*next(it) - *it) * C[type];
score -= S[d][type];
days[type].erase(it);
plan[d - 1] = 0;
}
void add(int d, int type) {
auto it = lower_bound(days[type].begin(), days[type].end(), d);
score += (d - *prev(it)) * (*it - d) * C[type];
score += S[d][type];
days[type].insert(it, d);
plan[d - 1] = type;
}
void dfs(int x) {
if (x == random_days.size()) {
if (mx < score)
mx = score, best = cur;
return;
}
for (int i = 1; i <= MXT; i++) {
cur[x] = i;
add(random_days[x], i);
dfs(x + 1);
erase(random_days[x], i);
}
return;
}
void update1(VI &_plan) {
int d = 0;
plan = _plan;
score = MyChecker::calc_score();
for (int i = 1; i <= MXT; i++)
days[i] = {0};
for (auto x : plan)
days[x].pb(++d);
for (int i = 1; i <= MXT; i++)
days[i].pb(D + 1);
for (int step = 0; step < 10000; step++) {
ll prv = score;
random_days.clear();
while (random_days.size() < 2) {
int d = rng() % 365 + 1;
random_days.pb(d);
}
sort(random_days.begin(), random_days.end());
random_days.erase(unique(random_days.begin(), random_days.end()),
random_days.end());
for (auto x : random_days)
erase(x, plan[x - 1]);
cur.resize(random_days.size());
mx = -inf;
dfs(0);
for (int i = 0; i < random_days.size(); i++)
add(random_days[i], best[i]);
assert(score == mx);
}
update_ans(plan, score);
}
} // namespace Update1
namespace Update2 {
VI plan, days[MXT + 1];
ll dp[MXD + 10][MXD + 10];
int prv[MXD + 10][MXD + 10];
void update_solve(int x, int y) {
if (days[x].empty() && days[y].empty())
return;
VI dd;
dd.pb(0);
for (auto y : days[x])
dd.pb(y);
for (auto x : days[y])
dd.pb(x);
sort(dd.begin(), dd.end());
ll pscore = 0;
int prvp = 0;
for (auto y : days[x])
pscore += (y - max(prvp, 1)) * C[x] * prvp + S[y][x], prvp = y;
pscore += (D + 1 - prvp) * C[x] * prvp;
prvp = 0;
for (auto x : days[y])
pscore += (x - max(prvp, 1)) * C[y] * prvp + S[x][y], prvp = x;
pscore += (D + 1 - prvp) * C[y] * prvp;
int sz = dd.size() - 1;
for (int i = 0; i <= sz; i++)
fill(dp[i], dp[i] + sz + 1, -1);
dp[0][0] = 0;
for (int i = 1; i <= sz; i++) {
ll tmp;
for (int j = 0; j < i; j++) {
if (dp[j][i - 1] >= 0) {
tmp =
dp[j][i - 1] + S[dd[i]][y] + C[y] * (dd[i] - dd[i - 1]) * dd[i - 1];
if (dp[j][i] < tmp)
dp[j][i] = tmp, prv[j][i] = (j << 10) | (i - 1);
tmp = dp[j][i - 1] + S[dd[i]][x] + C[x] * (dd[i] - dd[j]) * dd[j];
if (dp[i][i - 1] < tmp)
dp[i][i - 1] = tmp, prv[i][i - 1] = (j << 10) | (i - 1);
}
if (dp[i - 1][j] >= 0) {
tmp =
dp[i - 1][j] + S[dd[i]][x] + C[x] * (dd[i] - dd[i - 1]) * dd[i - 1];
if (dp[i][j] < tmp)
dp[i][j] = tmp, prv[i][j] = (i - 1 << 10) | j;
tmp = dp[i - 1][j] + S[dd[i]][y] + C[y] * (dd[i] - dd[j]) * dd[j];
if (dp[i - 1][i] < tmp)
dp[i - 1][i] = tmp, prv[i - 1][i] = (i - 1 << 10) | j;
}
}
}
ll mx = -1;
int ex = -1, ey = -1;
for (int i = 0; i < sz; i++) {
ll tmp;
tmp = dp[i][sz] + (D + 1 - dd[i]) * C[x] * dd[i] +
(D + 1 - dd[sz]) * C[y] * dd[sz];
if (mx < tmp)
mx = tmp, ex = i, ey = sz;
tmp = dp[sz][i] + (D + 1 - dd[sz]) * C[x] * dd[sz] +
(D + 1 - dd[i]) * C[y] * dd[i];
if (mx < tmp)
mx = tmp, ex = sz, ey = i;
}
days[x].clear(), days[y].clear();
if (ex)
days[x].pb(dd[ex]);
if (ey)
days[y].pb(dd[ey]);
while (ex > 0 || ey > 0) {
int px = prv[ex][ey] >> 10, py = prv[ex][ey] & 1023;
if (px != ex) {
ex = px;
if (ex)
days[x].pb(dd[ex]);
}
if (py != ey) {
ey = py;
if (ey)
days[y].pb(dd[ey]);
}
}
reverse(days[x].begin(), days[x].end());
reverse(days[y].begin(), days[y].end());
assert(mx >= pscore);
return;
}
void update2(VI &_plan) {
plan = _plan;
int d = 0;
for (auto x : plan)
days[x].pb(++d);
for (int step = 0; step < 10000; step++) {
int x = rng() % 26 + 1, y = rng() % 26 + 1;
if (x == y) {
step--;
continue;
}
update_solve(x, y);
}
for (int i = 1; i <= MXT; i++) {
for (auto x : days[i])
plan[x - 1] = i;
}
ll score = MyChecker::calc_score(plan);
update_ans(plan, score);
}
} // namespace Update2
int main() {
input_and_init();
Greedy::greedy_solve();
Update1::update1(best);
Update2::update2(best);
output();
return 0;
}
| insert | 177 | 177 | 177 | 179 | -11 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
#define int long long
constexpr long long INF = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;
#include <random>
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int D;
cin >> D;
int c[26];
int q[D];
rep(i, 26) { cin >> c[i]; }
int s[D][26];
rep(i, D) {
rep(j, 26) { cin >> s[i][j]; }
}
int ans = 0;
// map<int,int> m;
int l[26]{};
int y = 0;
rep(i, D) {
int an = -INF;
int x = 0;
rep(k, 26) {
int a = ans;
// map<int,int> ma=m;
int la[26];
rep(_, 26) { la[_] = l[_]; }
a += s[i][k];
rep(j, 26) {
if (j == k) {
// ma[k]=0;
la[k] = 0;
} else {
// ma[j]++;
la[j]++;
a -= la[j] * c[j];
}
}
if (an < a) {
x = k;
an = a;
}
}
y = x;
ans += s[i][y];
rep(j, 26) {
if (j == y) {
l[y] = 0;
} else {
l[j]++;
ans -= l[j] * c[j];
}
}
y++;
q[i] = y;
}
int tr = 0;
std::random_device rnd;
while (tr <= 400000) {
int g = rnd() % 26;
int h = rnd() % 26;
tr++;
int ansm = 0;
int r[D];
rep(i, D) {
if (i == g) {
if (h != q[i]) {
r[i] = h;
} else {
r[i] = rnd() % 26;
}
} else {
r[i] = q[i];
}
}
// map<int,int> mx;
int lx[26]{};
rep(i, D) {
ansm += s[i][r[i]];
rep(j, 26) {
if (j == r[i]) {
lx[r[i]] = 0;
} else {
lx[j]++;
ansm -= lx[j] * c[j];
}
}
}
if (ansm > ans) {
rep(i, D) { q[i] = r[i]; }
}
}
rep(i, D) { cout << q[i] << endl; }
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
#define int long long
constexpr long long INF = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;
#include <random>
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int D;
cin >> D;
int c[26];
int q[D];
rep(i, 26) { cin >> c[i]; }
int s[D][26];
rep(i, D) {
rep(j, 26) { cin >> s[i][j]; }
}
int ans = 0;
// map<int,int> m;
int l[26]{};
int y = 0;
rep(i, D) {
int an = -INF;
int x = 0;
rep(k, 26) {
int a = ans;
// map<int,int> ma=m;
int la[26];
rep(_, 26) { la[_] = l[_]; }
a += s[i][k];
rep(j, 26) {
if (j == k) {
// ma[k]=0;
la[k] = 0;
} else {
// ma[j]++;
la[j]++;
a -= la[j] * c[j];
}
}
if (an < a) {
x = k;
an = a;
}
}
y = x;
ans += s[i][y];
rep(j, 26) {
if (j == y) {
l[y] = 0;
} else {
l[j]++;
ans -= l[j] * c[j];
}
}
y++;
q[i] = y;
}
int tr = 0;
std::random_device rnd;
while (tr <= 20000) {
int g = rnd() % 26;
int h = rnd() % 26;
tr++;
int ansm = 0;
int r[D];
rep(i, D) {
if (i == g) {
if (h != q[i]) {
r[i] = h;
} else {
r[i] = rnd() % 26;
}
} else {
r[i] = q[i];
}
}
// map<int,int> mx;
int lx[26]{};
rep(i, D) {
ansm += s[i][r[i]];
rep(j, 26) {
if (j == r[i]) {
lx[r[i]] = 0;
} else {
lx[j]++;
ansm -= lx[j] * c[j];
}
}
}
if (ansm > ans) {
rep(i, D) { q[i] = r[i]; }
}
}
rep(i, D) { cout << q[i] << endl; }
}
| replace | 69 | 70 | 69 | 70 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
#define int long long
constexpr long long INF = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;
#include <random>
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int D;
cin >> D;
int c[26];
int q[D];
rep(i, 26) { cin >> c[i]; }
int s[D][26];
rep(i, D) {
rep(j, 26) { cin >> s[i][j]; }
}
int ans = 0;
int l[26]{};
int y = 0;
rep(i, D) {
int an = -INF;
int x = 0;
rep(k, 26) {
int a = ans;
int la[26];
rep(_, 26) { la[_] = l[_]; }
a += s[i][k];
rep(j, 26) {
if (j == k) {
la[k] = 0;
} else {
la[j]++;
a -= la[j] * c[j];
}
}
if (an < a) {
x = k;
an = a;
}
}
y = x;
ans += s[i][y];
rep(j, 26) {
if (j == y) {
l[y] = 0;
} else {
l[j]++;
ans -= l[j] * c[j];
}
}
y++;
q[i] = y;
}
int tr = 0;
std::random_device rnd;
while (tr <= 180000) {
int g = rnd() % 26;
int h = rnd() % 26;
tr++;
int ansm = 0;
int r[D];
rep(i, D) {
if (i == g) {
if (h != q[i]) {
r[i] = h;
} else {
r[i] = rnd() % 26;
}
} else {
r[i] = q[i];
}
}
int lx[26]{};
rep(i, D) {
ansm += s[i][r[i]];
rep(j, 26) {
if (j == r[i]) {
lx[r[i]] = 0;
} else {
lx[j]++;
ansm -= lx[j] * c[j];
}
}
}
if (ansm > ans) {
rep(i, D) { q[i] = r[i]; }
ans = ansm;
}
}
rep(i, D) { cout << q[i] << endl; }
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define PI 3.14159265358979323846
#define int long long
constexpr long long INF = numeric_limits<long long>::max() / 2;
constexpr int MOD = 1000000007;
using Graph = vector<vector<int>>;
#include <random>
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int D;
cin >> D;
int c[26];
int q[D];
rep(i, 26) { cin >> c[i]; }
int s[D][26];
rep(i, D) {
rep(j, 26) { cin >> s[i][j]; }
}
int ans = 0;
int l[26]{};
int y = 0;
rep(i, D) {
int an = -INF;
int x = 0;
rep(k, 26) {
int a = ans;
int la[26];
rep(_, 26) { la[_] = l[_]; }
a += s[i][k];
rep(j, 26) {
if (j == k) {
la[k] = 0;
} else {
la[j]++;
a -= la[j] * c[j];
}
}
if (an < a) {
x = k;
an = a;
}
}
y = x;
ans += s[i][y];
rep(j, 26) {
if (j == y) {
l[y] = 0;
} else {
l[j]++;
ans -= l[j] * c[j];
}
}
y++;
q[i] = y;
}
int tr = 0;
std::random_device rnd;
while (tr <= 100000) {
int g = rnd() % 26;
int h = rnd() % 26;
tr++;
int ansm = 0;
int r[D];
rep(i, D) {
if (i == g) {
if (h != q[i]) {
r[i] = h;
} else {
r[i] = rnd() % 26;
}
} else {
r[i] = q[i];
}
}
int lx[26]{};
rep(i, D) {
ansm += s[i][r[i]];
rep(j, 26) {
if (j == r[i]) {
lx[r[i]] = 0;
} else {
lx[j]++;
ansm -= lx[j] * c[j];
}
}
}
if (ansm > ans) {
rep(i, D) { q[i] = r[i]; }
ans = ansm;
}
}
rep(i, D) { cout << q[i] << endl; }
}
| replace | 65 | 66 | 65 | 66 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ALL(a) (a).begin(), (a).end()
#define INF 1000000000
#define BEAM 250
using namespace std;
class state {
public:
int day;
int previous_score;
vector<int> previous;
vector<int> types;
state() {}
state(const state &a)
: day(a.day), previous_score(a.previous_score), previous(a.previous),
types(a.types) {}
};
int _scoring(const vector<int> &c, const vector<vector<int>> &s, int day,
int type, const vector<int> &previous) {
int score = s[day][type];
REP(i, 26) { score -= c[i] * (day + 1 - previous[i]); }
return score;
}
int scoring(const vector<int> &c, const vector<vector<int>> &s,
state &this_state) {
this_state.previous[this_state.types.back()] = this_state.day + 1;
return this_state.previous_score + _scoring(c, s, this_state.day,
this_state.types.back(),
this_state.previous);
}
using queue_type = pair<state, int>;
struct CustomCompare {
bool operator()(const queue_type &a, const queue_type &b) {
return a.second < b.second;
}
};
int main() {
int D;
cin >> D;
vector<int> c(26);
REP(i, 26)
cin >> c[i];
vector<vector<int>> s(D, vector<int>(26, 0));
REP(i, D)
REP(j, 26)
cin >> s[i][j];
vector<state> initial;
REP(i, 26) {
state this_state;
this_state.day = 0;
this_state.types.push_back(i);
this_state.types.reserve(D);
this_state.previous_score = 0;
this_state.previous = vector<int>(26, 0);
initial.push_back(this_state);
}
priority_queue<queue_type, vector<queue_type>, CustomCompare> q1, q2;
REP(i, D) {
if (i == 0) {
// use initial
for (auto i : initial) {
q2.push(make_pair(i, scoring(c, s, i)));
}
} else {
// use queue
for (int ii = 0; ii < BEAM && !q1.empty(); ++ii) {
auto i = q1.top();
REP(j, 26) {
state new_state = i.first;
new_state.day++;
new_state.types.push_back(j);
q2.push(make_pair(new_state, scoring(c, s, new_state)));
// q2.emplace_back(new_state, scoring(c, s, new_state));
}
q1.pop();
}
}
swap(q1, q2);
q2 = decltype(q2)();
}
auto res = q1.top().first;
for (auto t : res.types)
cout << t + 1 << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <utility>
#include <vector>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ALL(a) (a).begin(), (a).end()
#define INF 1000000000
#define BEAM 100
using namespace std;
class state {
public:
int day;
int previous_score;
vector<int> previous;
vector<int> types;
state() {}
state(const state &a)
: day(a.day), previous_score(a.previous_score), previous(a.previous),
types(a.types) {}
};
int _scoring(const vector<int> &c, const vector<vector<int>> &s, int day,
int type, const vector<int> &previous) {
int score = s[day][type];
REP(i, 26) { score -= c[i] * (day + 1 - previous[i]); }
return score;
}
int scoring(const vector<int> &c, const vector<vector<int>> &s,
state &this_state) {
this_state.previous[this_state.types.back()] = this_state.day + 1;
return this_state.previous_score + _scoring(c, s, this_state.day,
this_state.types.back(),
this_state.previous);
}
using queue_type = pair<state, int>;
struct CustomCompare {
bool operator()(const queue_type &a, const queue_type &b) {
return a.second < b.second;
}
};
int main() {
int D;
cin >> D;
vector<int> c(26);
REP(i, 26)
cin >> c[i];
vector<vector<int>> s(D, vector<int>(26, 0));
REP(i, D)
REP(j, 26)
cin >> s[i][j];
vector<state> initial;
REP(i, 26) {
state this_state;
this_state.day = 0;
this_state.types.push_back(i);
this_state.types.reserve(D);
this_state.previous_score = 0;
this_state.previous = vector<int>(26, 0);
initial.push_back(this_state);
}
priority_queue<queue_type, vector<queue_type>, CustomCompare> q1, q2;
REP(i, D) {
if (i == 0) {
// use initial
for (auto i : initial) {
q2.push(make_pair(i, scoring(c, s, i)));
}
} else {
// use queue
for (int ii = 0; ii < BEAM && !q1.empty(); ++ii) {
auto i = q1.top();
REP(j, 26) {
state new_state = i.first;
new_state.day++;
new_state.types.push_back(j);
q2.push(make_pair(new_state, scoring(c, s, new_state)));
// q2.emplace_back(new_state, scoring(c, s, new_state));
}
q1.pop();
}
}
swap(q1, q2);
q2 = decltype(q2)();
}
auto res = q1.top().first;
for (auto t : res.types)
cout << t + 1 << endl;
return 0;
}
| replace | 12 | 13 | 12 | 13 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <stdlib.h>
using namespace std;
int d, c[29], s[409][29], p[409], cp[29], rs;
set<int> st[29];
int cc() {
for (int i = 0; i < 26; i++)
cp[i] = 0;
int ans = 0;
for (int i = 1; i <= d; i++) {
for (int j = 0; j < 26; j++) {
if (p[i] == j) {
cp[j] = i;
ans += s[i][j];
} else
ans -= (i - cp[j]) * c[j];
}
}
return ans;
}
void rm(int n, int k) {
auto pi = st[k].find(n);
auto l = pi;
l--;
auto r = pi;
r++;
int pl = (n - (*l) - 1), pr = ((*r) - n - 1), plr = ((*r) - (*l) - 1);
st[k].erase(n);
rs -= s[n][k];
rs += pl * (pl + 1) / 2 * c[k];
rs += pr * (pr + 1) / 2 * c[k];
rs -= plr * (plr + 1) / 2 * c[k];
}
void ins(int n, int k) {
auto r = st[k].lower_bound(n);
auto l = r;
l--;
int pl = (n - (*l) - 1), pr = ((*r) - n - 1), plr = ((*r) - (*l) - 1);
st[k].insert(n);
rs += s[n][k];
rs -= pl * (pl + 1) / 2 * c[k];
rs -= pr * (pr + 1) / 2 * c[k];
rs += plr * (plr + 1) / 2 * c[k];
}
void up(int n, int k) {
rm(n, p[n]);
p[n] = k;
ins(n, p[n]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> d;
for (int i = 0; i < 26; i++) {
cin >> c[i];
st[i].insert(0);
st[i].insert(d + 1);
}
for (int i = 1; i <= d; i++) {
for (int j = 0; j < 26; j++)
cin >> s[i][j];
p[i] = rand() % 26;
st[p[i]].insert(i);
}
rs = cc();
double k = 300, sc = 350, kt = 0.99925;
for (int i = 0; i < 1000000; i++) {
double e1 = rs;
int n = (rand() % d) + 1, kp = (rand() % 25) + 1;
int hk = p[n], tk = (hk + kp) % 26;
up(n, tk);
int e2 = rs;
double pb = exp((e2 - e1) / (k * sc));
if (pb < rand() / (double)RAND_MAX)
up(n, hk);
k *= kt;
}
for (int i = 1; i <= d; i++)
cout << p[i] + 1 << '\n';
while (true) {
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <stdlib.h>
using namespace std;
int d, c[29], s[409][29], p[409], cp[29], rs;
set<int> st[29];
int cc() {
for (int i = 0; i < 26; i++)
cp[i] = 0;
int ans = 0;
for (int i = 1; i <= d; i++) {
for (int j = 0; j < 26; j++) {
if (p[i] == j) {
cp[j] = i;
ans += s[i][j];
} else
ans -= (i - cp[j]) * c[j];
}
}
return ans;
}
void rm(int n, int k) {
auto pi = st[k].find(n);
auto l = pi;
l--;
auto r = pi;
r++;
int pl = (n - (*l) - 1), pr = ((*r) - n - 1), plr = ((*r) - (*l) - 1);
st[k].erase(n);
rs -= s[n][k];
rs += pl * (pl + 1) / 2 * c[k];
rs += pr * (pr + 1) / 2 * c[k];
rs -= plr * (plr + 1) / 2 * c[k];
}
void ins(int n, int k) {
auto r = st[k].lower_bound(n);
auto l = r;
l--;
int pl = (n - (*l) - 1), pr = ((*r) - n - 1), plr = ((*r) - (*l) - 1);
st[k].insert(n);
rs += s[n][k];
rs -= pl * (pl + 1) / 2 * c[k];
rs -= pr * (pr + 1) / 2 * c[k];
rs += plr * (plr + 1) / 2 * c[k];
}
void up(int n, int k) {
rm(n, p[n]);
p[n] = k;
ins(n, p[n]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> d;
for (int i = 0; i < 26; i++) {
cin >> c[i];
st[i].insert(0);
st[i].insert(d + 1);
}
for (int i = 1; i <= d; i++) {
for (int j = 0; j < 26; j++)
cin >> s[i][j];
p[i] = rand() % 26;
st[p[i]].insert(i);
}
rs = cc();
double k = 300, sc = 350, kt = 0.99925;
for (int i = 0; i < 1000000; i++) {
double e1 = rs;
int n = (rand() % d) + 1, kp = (rand() % 25) + 1;
int hk = p[n], tk = (hk + kp) % 26;
up(n, tk);
int e2 = rs;
double pb = exp((e2 - e1) / (k * sc));
if (pb < rand() / (double)RAND_MAX)
up(n, hk);
k *= kt;
}
for (int i = 1; i <= d; i++)
cout << p[i] + 1 << '\n';
return 0;
} | delete | 88 | 90 | 88 | 88 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <stdlib.h>
using namespace std;
int d, c[29], s[409][29], p[409], cp[29], rs;
set<int> st[29];
int cc() {
for (int i = 0; i < 26; i++)
cp[i] = 0;
int ans = 0;
for (int i = 1; i <= d; i++) {
for (int j = 0; j < 26; j++) {
if (p[i] == j) {
cp[j] = i;
ans += s[i][j];
} else
ans -= (i - cp[j]) * c[j];
}
}
return ans;
}
void rm(int n, int k) {
auto pi = st[k].find(n);
auto l = pi;
l--;
auto r = pi;
r++;
int pl = (n - (*l) - 1), pr = ((*r) - n - 1), plr = ((*r) - (*l) - 1);
st[k].erase(n);
rs -= s[n][k];
rs += pl * (pl + 1) / 2 * c[k];
rs += pr * (pr + 1) / 2 * c[k];
rs -= plr * (plr + 1) / 2 * c[k];
}
void ins(int n, int k) {
auto r = st[k].lower_bound(n);
auto l = r;
l--;
int pl = (n - (*l) - 1), pr = ((*r) - n - 1), plr = ((*r) - (*l) - 1);
st[k].insert(n);
rs += s[n][k];
rs -= pl * (pl + 1) / 2 * c[k];
rs -= pr * (pr + 1) / 2 * c[k];
rs += plr * (plr + 1) / 2 * c[k];
}
void up(int n, int k) {
rm(n, p[n]);
p[n] = k;
ins(n, p[n]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> d;
for (int i = 0; i < 26; i++) {
cin >> c[i];
st[i].insert(0);
st[i].insert(d + 1);
}
for (int i = 1; i <= d; i++) {
for (int j = 0; j < 26; j++)
cin >> s[i][j];
p[i] = rand() % 26;
st[p[i]].insert(i);
}
rs = cc();
double k = 300, sc = 250, kt = 0.99915;
for (int i = 0; i < 5000000; i++) {
double e1 = rs;
int n = (rand() % d) + 1, kp = (rand() % 25) + 1;
int hk = p[n], tk = (hk + kp) % 26;
up(n, tk);
int e2 = rs;
double pb = exp((e2 - e1) / (k * sc));
if (pb < rand() / (double)RAND_MAX)
up(n, hk);
k *= kt;
}
for (int i = 1; i <= d; i++)
cout << p[i] + 1 << '\n';
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <stdlib.h>
using namespace std;
int d, c[29], s[409][29], p[409], cp[29], rs;
set<int> st[29];
int cc() {
for (int i = 0; i < 26; i++)
cp[i] = 0;
int ans = 0;
for (int i = 1; i <= d; i++) {
for (int j = 0; j < 26; j++) {
if (p[i] == j) {
cp[j] = i;
ans += s[i][j];
} else
ans -= (i - cp[j]) * c[j];
}
}
return ans;
}
void rm(int n, int k) {
auto pi = st[k].find(n);
auto l = pi;
l--;
auto r = pi;
r++;
int pl = (n - (*l) - 1), pr = ((*r) - n - 1), plr = ((*r) - (*l) - 1);
st[k].erase(n);
rs -= s[n][k];
rs += pl * (pl + 1) / 2 * c[k];
rs += pr * (pr + 1) / 2 * c[k];
rs -= plr * (plr + 1) / 2 * c[k];
}
void ins(int n, int k) {
auto r = st[k].lower_bound(n);
auto l = r;
l--;
int pl = (n - (*l) - 1), pr = ((*r) - n - 1), plr = ((*r) - (*l) - 1);
st[k].insert(n);
rs += s[n][k];
rs -= pl * (pl + 1) / 2 * c[k];
rs -= pr * (pr + 1) / 2 * c[k];
rs += plr * (plr + 1) / 2 * c[k];
}
void up(int n, int k) {
rm(n, p[n]);
p[n] = k;
ins(n, p[n]);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> d;
for (int i = 0; i < 26; i++) {
cin >> c[i];
st[i].insert(0);
st[i].insert(d + 1);
}
for (int i = 1; i <= d; i++) {
for (int j = 0; j < 26; j++)
cin >> s[i][j];
p[i] = rand() % 26;
st[p[i]].insert(i);
}
rs = cc();
double k = 300, sc = 270, kt = 0.99915;
for (int i = 0; i < 4000000; i++) {
double e1 = rs;
int n = (rand() % d) + 1, kp = (rand() % 25) + 1;
int hk = p[n], tk = (hk + kp) % 26;
up(n, tk);
int e2 = rs;
double pb = exp((e2 - e1) / (k * sc));
if (pb < rand() / (double)RAND_MAX)
up(n, hk);
k *= kt;
}
for (int i = 1; i <= d; i++)
cout << p[i] + 1 << '\n';
return 0;
} | replace | 74 | 76 | 74 | 76 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const char nl = '\n';
void solve() {
int d;
cin >> d;
vector<int> c;
for (int i = 0; i < 26; ++i) {
int val;
cin >> val;
c.push_back(val);
}
for (int i = 0; i < d; ++i) {
map<int, int, greater<int>> m;
for (int j = 0; j < 26; ++j) {
int val;
cin >> val;
m[val / c[j]] = j + 1;
}
cout << m.begin()->second << nl;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
const char nl = '\n';
void solve() {
int d;
cin >> d;
vector<int> c;
for (int i = 0; i < 26; ++i) {
int val;
cin >> val;
c.push_back(val);
}
for (int i = 0; i < d; ++i) {
map<int, int, greater<int>> m;
for (int j = 0; j < 26; ++j) {
int val;
cin >> val;
m[val / max(c[j], 1)] = j + 1;
}
cout << m.begin()->second << nl;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(nullptr);
solve();
return 0;
} | replace | 21 | 22 | 21 | 22 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#include <chrono>
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 1000000007
using namespace std;
int main() {
chrono::system_clock::time_point start, end;
start = chrono::system_clock::now();
long d;
cin >> d;
long n = 26, csum = 0, ccost = 0;
vector<long> c(n), last(n);
rep(i, n) {
cin >> c[i];
csum += c[i];
last[i] = 0;
}
vector<vector<long>> s(d, vector<long>(n));
rep(i, d) rep(j, n) cin >> s[i][j];
vector<vector<long>> cand;
vector<long> score;
random_device rd{};
vector<long> yotei(d);
vector<long> tmp(d);
long final_ans = 0, final_index;
rep(jj, 100) {
long ans = 0;
rep(i, n) last[i] = 0;
rep(i, d) yotei[i] = rd() % n;
rep(i, d) {
ccost += csum;
ccost -= c[yotei[i]] * (i + 1 - last[yotei[i]]);
ans -= ccost;
last[yotei[i]] = i + 1;
ans += s[i][yotei[i]];
}
int ii = 0;
while (ii < 200000) {
long new_day = rd() % d, new_con;
while (1) {
new_con = rd() % n;
if (yotei[new_day] != new_con)
break;
}
long pre_con = yotei[new_day];
yotei[new_day] = new_con;
long tmpans = 0;
ccost = 0;
rep(i, n) last[i] = 0;
rep(i, d) {
tmp[i] = yotei[i];
ccost += csum;
ccost -= c[yotei[i]] * (i + 1 - last[yotei[i]]);
tmpans -= ccost;
last[yotei[i]] = i + 1;
tmpans += s[i][yotei[i]];
}
if (tmpans < ans)
yotei[new_day] = pre_con;
else {
ans = tmpans;
cand.push_back(tmp);
}
ii++;
}
if (final_ans < ans) {
final_ans = ans;
final_index = int(cand.size() - 1);
}
end = chrono::system_clock::now();
auto time = end - start;
if (static_cast<double>(
chrono::duration_cast<chrono::milliseconds>(time).count()) > 1950)
break;
}
rep(i, d) cout << cand[final_index][i] + 1 << endl;
return 0;
} | #include <bits/stdc++.h>
#include <chrono>
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 1000000007
using namespace std;
int main() {
chrono::system_clock::time_point start, end;
start = chrono::system_clock::now();
long d;
cin >> d;
long n = 26, csum = 0, ccost = 0;
vector<long> c(n), last(n);
rep(i, n) {
cin >> c[i];
csum += c[i];
last[i] = 0;
}
vector<vector<long>> s(d, vector<long>(n));
rep(i, d) rep(j, n) cin >> s[i][j];
vector<vector<long>> cand;
vector<long> score;
random_device rd{};
vector<long> yotei(d);
vector<long> tmp(d);
long final_ans = 0, final_index;
rep(jj, 100) {
long ans = 0;
rep(i, n) last[i] = 0;
rep(i, d) yotei[i] = rd() % n;
rep(i, d) {
ccost += csum;
ccost -= c[yotei[i]] * (i + 1 - last[yotei[i]]);
ans -= ccost;
last[yotei[i]] = i + 1;
ans += s[i][yotei[i]];
}
int ii = 0;
while (ii < 200000) {
long new_day = rd() % d, new_con;
while (1) {
new_con = rd() % n;
if (yotei[new_day] != new_con)
break;
}
long pre_con = yotei[new_day];
yotei[new_day] = new_con;
long tmpans = 0;
ccost = 0;
rep(i, n) last[i] = 0;
rep(i, d) {
tmp[i] = yotei[i];
ccost += csum;
ccost -= c[yotei[i]] * (i + 1 - last[yotei[i]]);
tmpans -= ccost;
last[yotei[i]] = i + 1;
tmpans += s[i][yotei[i]];
}
if (tmpans < ans)
yotei[new_day] = pre_con;
else {
ans = tmpans;
cand.push_back(tmp);
}
ii++;
}
if (final_ans < ans) {
final_ans = ans;
final_index = int(cand.size() - 1);
}
end = chrono::system_clock::now();
auto time = end - start;
if (static_cast<double>(
chrono::duration_cast<chrono::milliseconds>(time).count()) > 1880)
break;
}
rep(i, d) cout << cand[final_index][i] + 1 << endl;
return 0;
} | replace | 75 | 76 | 75 | 76 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int d;
vector<int> c;
vector<vector<int>> s;
int satisfaction(const vector<int> &t) {
vector<int> last(26, -1);
int ans = 0;
for (int i = 0; i < (int)t.size(); i++) {
ans += s[i][t[i]];
last[t[i]] = i;
for (int j = 0; j < 26; j++) {
ans -= c[j] * (i - last[j]);
}
}
return ans;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int myrand(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
srand(time(nullptr));
cin >> d;
c.resize(26);
for (int i = 0; i < 26; i++) {
cin >> c[i];
}
s.assign(d, vector<int>(26));
for (int i = 0; i < d; i++) {
for (int j = 0; j < 26; j++) {
cin >> s[i][j];
}
}
vector<int> t;
for (int i = 0; i < d; i++) {
int best = i;
for (int j = 1; j < 26; j++) {
if (s[i][j] > s[i][best]) {
best = j;
}
}
t.push_back(best);
}
for (int i = 0; i < 50000; i++) {
int pos = myrand(0, d - 1), x = myrand(0, 25);
vector<int> tmp = t;
tmp[pos] = x;
if (satisfaction(tmp) > satisfaction(t)) {
swap(t, tmp);
}
}
for (auto &x : t) {
cout << x + 1 << '\n';
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int d;
vector<int> c;
vector<vector<int>> s;
int satisfaction(const vector<int> &t) {
vector<int> last(26, -1);
int ans = 0;
for (int i = 0; i < (int)t.size(); i++) {
ans += s[i][t[i]];
last[t[i]] = i;
for (int j = 0; j < 26; j++) {
ans -= c[j] * (i - last[j]);
}
}
return ans;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int myrand(int l, int r) { return uniform_int_distribution<int>(l, r)(rng); }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
srand(time(nullptr));
cin >> d;
c.resize(26);
for (int i = 0; i < 26; i++) {
cin >> c[i];
}
s.assign(d, vector<int>(26));
for (int i = 0; i < d; i++) {
for (int j = 0; j < 26; j++) {
cin >> s[i][j];
}
}
vector<int> t;
for (int i = 0; i < d; i++) {
int best = 0;
for (int j = 1; j < 26; j++) {
if (s[i][j] > s[i][best]) {
best = j;
}
}
t.push_back(best);
}
for (int i = 0; i < 50000; i++) {
int pos = myrand(0, d - 1), x = myrand(0, 25);
vector<int> tmp = t;
tmp[pos] = x;
if (satisfaction(tmp) > satisfaction(t)) {
swap(t, tmp);
}
}
for (auto &x : t) {
cout << x + 1 << '\n';
}
return 0;
} | replace | 42 | 43 | 42 | 43 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long;
using ull = uint64_t;
using P = pair<int, int>;
constexpr double EPS = 1e-9;
constexpr int INF = 1001001001;
constexpr int mod = 1000000007;
// constexpr int mod = 998244353;
template <class T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
}
return false;
}
template <class T> inline bool chmin(T &x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
struct Timer {
chrono::high_resolution_clock::time_point st;
Timer() { reset(); }
void reset() { st = chrono::high_resolution_clock::now(); }
chrono::milliseconds::rep elapsed() {
auto ed = chrono::high_resolution_clock::now();
return chrono::duration_cast<chrono::milliseconds>(ed - st).count();
}
};
struct RNG {
mt19937 mt;
RNG() : mt(chrono::steady_clock::now().time_since_epoch().count()) {}
int operator()(int a, int b) {
uniform_int_distribution<int> dist(a, b - 1);
return dist(mt);
}
int operator()(int b) { return (*this)(0, b); }
};
constexpr int D = 365;
vector<int> c(D);
vector<vector<int>> s(D, vector<int>(26));
Timer TimeKeeper;
RNG rng;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int kyomu;
cin >> kyomu;
for (int i = 0; i < 26; ++i)
cin >> c[i];
vector<int> maxe(D, -1);
vector<int> cur(D, 0);
for (int i = 0; i < D; ++i) {
for (int j = 0; j < 26; ++j) {
cin >> s[i][j];
if (chmax(maxe[i], s[i][j]))
cur[i] = j;
}
}
int BestScore = 0;
auto calc_score = [&](vector<int> &v) -> int {
if (v.size() != D)
return -INF;
int res = 0;
vector<int> pre(26, -1);
for (int i = 0; i < D; ++i) {
res += s[i][v[i]];
pre[v[i]] = i;
for (int j = 0; j < 26; ++j) {
if (pre[j] == -1)
continue;
res -= c[j] * (i - pre[j]);
}
}
return res;
};
BestScore = calc_score(cur);
int p = 0;
while (TimeKeeper.elapsed() < 1995) {
int NxtScore = -INF;
int ProblemType = -1;
vector<int> nxt = cur;
for (int i = 0; i < 26; ++i) {
if (i == cur[p])
continue;
nxt[p] = i;
if (chmax(NxtScore, calc_score(nxt)))
ProblemType = i;
}
if (NxtScore > BestScore) {
BestScore = NxtScore;
cur[p] = ProblemType;
}
if (++p == D)
p = 0;
}
for (int i = 0; i < D; ++i)
cout << cur[i] + 1 << '\n';
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
using ll = long long;
using ull = uint64_t;
using P = pair<int, int>;
constexpr double EPS = 1e-9;
constexpr int INF = 1001001001;
constexpr int mod = 1000000007;
// constexpr int mod = 998244353;
template <class T> inline bool chmax(T &x, T y) {
if (x < y) {
x = y;
return true;
}
return false;
}
template <class T> inline bool chmin(T &x, T y) {
if (x > y) {
x = y;
return true;
}
return false;
}
struct Timer {
chrono::high_resolution_clock::time_point st;
Timer() { reset(); }
void reset() { st = chrono::high_resolution_clock::now(); }
chrono::milliseconds::rep elapsed() {
auto ed = chrono::high_resolution_clock::now();
return chrono::duration_cast<chrono::milliseconds>(ed - st).count();
}
};
struct RNG {
mt19937 mt;
RNG() : mt(chrono::steady_clock::now().time_since_epoch().count()) {}
int operator()(int a, int b) {
uniform_int_distribution<int> dist(a, b - 1);
return dist(mt);
}
int operator()(int b) { return (*this)(0, b); }
};
constexpr int D = 365;
vector<int> c(D);
vector<vector<int>> s(D, vector<int>(26));
Timer TimeKeeper;
RNG rng;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int kyomu;
cin >> kyomu;
for (int i = 0; i < 26; ++i)
cin >> c[i];
vector<int> maxe(D, -1);
vector<int> cur(D, 0);
for (int i = 0; i < D; ++i) {
for (int j = 0; j < 26; ++j) {
cin >> s[i][j];
if (chmax(maxe[i], s[i][j]))
cur[i] = j;
}
}
int BestScore = 0;
auto calc_score = [&](vector<int> &v) -> int {
if (v.size() != D)
return -INF;
int res = 0;
vector<int> pre(26, -1);
for (int i = 0; i < D; ++i) {
res += s[i][v[i]];
pre[v[i]] = i;
for (int j = 0; j < 26; ++j) {
if (pre[j] == -1)
continue;
res -= c[j] * (i - pre[j]);
}
}
return res;
};
BestScore = calc_score(cur);
int p = 0;
while (TimeKeeper.elapsed() < 1950) {
int NxtScore = -INF;
int ProblemType = -1;
vector<int> nxt = cur;
for (int i = 0; i < 26; ++i) {
if (i == cur[p])
continue;
nxt[p] = i;
if (chmax(NxtScore, calc_score(nxt)))
ProblemType = i;
}
if (NxtScore > BestScore) {
BestScore = NxtScore;
cur[p] = ProblemType;
}
if (++p == D)
p = 0;
}
for (int i = 0; i < D; ++i)
cout << cur[i] + 1 << '\n';
} | replace | 117 | 118 | 117 | 118 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
constexpr ll LLINF{1001002003004005006}; // ll = 9*LLINF
constexpr int INTINF{1000000000}; // int = 2*INTINF
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
template <typename T> void maxs(T &x, T &&y) { x = std::max(x, y); }
template <typename T> void maxs(T &x, T &y) { x = std::max(x, y); }
template <typename T> void mins(T &x, T &&y) { x = std::min(x, y); }
template <typename T> void mins(T &x, T &y) { x = std::min(x, y); }
constexpr int contest_num{26};
constexpr int order_max_cnt{40000}; // TODO : changeble
ll calc_satisfy(const vector<vector<ll>> &S, const vector<ll> &C,
const vector<int> &order, const int &D) {
ll answer{};
vector<int> fin_day(contest_num, -1);
rep(i, D) {
answer += S[i][order[i] - 1];
fin_day[order[i] - 1] = i;
rep(j, contest_num) { answer -= C[j] * (i - fin_day[j]); }
}
return answer;
}
#include <random>
int main() {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int D;
cin >> D;
vector<ll> c(contest_num);
rep(i, contest_num) cin >> c[i];
vector<vector<ll>> s(D, vector<ll>(contest_num));
rep(i, D) {
rep(j, contest_num) { cin >> s[i][j]; }
}
// vector<int> order(D);
// rep(i, D) cin >> order[i];
// int M;
// cin >> M;
// vector<std::pair<int, int>> query(M);
// rep(i, M) cin >> query[i].first >> query[i].second;
// rep(i, M) {
// order[query[i].first-1] = query[i].second;
// calc_satisfy(s, c, order, D);
// }
std::random_device rnd;
ll max_params{-LLINF};
vector<int> max_order(D);
rep(i, order_max_cnt) {
vector<int> order(D);
rep(j, D) { order[j] = (rnd() % contest_num) + 1; }
ll tmp = calc_satisfy(s, c, order, D);
if (max_params < tmp) {
max_order = order;
}
}
rep(i, D) cout << max_order[i] << '\n';
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
constexpr ll LLINF{1001002003004005006}; // ll = 9*LLINF
constexpr int INTINF{1000000000}; // int = 2*INTINF
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = s; i < t; ++i)
template <typename T> void maxs(T &x, T &&y) { x = std::max(x, y); }
template <typename T> void maxs(T &x, T &y) { x = std::max(x, y); }
template <typename T> void mins(T &x, T &&y) { x = std::min(x, y); }
template <typename T> void mins(T &x, T &y) { x = std::min(x, y); }
constexpr int contest_num{26};
constexpr int order_max_cnt{20000}; // TODO : changeble
ll calc_satisfy(const vector<vector<ll>> &S, const vector<ll> &C,
const vector<int> &order, const int &D) {
ll answer{};
vector<int> fin_day(contest_num, -1);
rep(i, D) {
answer += S[i][order[i] - 1];
fin_day[order[i] - 1] = i;
rep(j, contest_num) { answer -= C[j] * (i - fin_day[j]); }
}
return answer;
}
#include <random>
int main() {
ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int D;
cin >> D;
vector<ll> c(contest_num);
rep(i, contest_num) cin >> c[i];
vector<vector<ll>> s(D, vector<ll>(contest_num));
rep(i, D) {
rep(j, contest_num) { cin >> s[i][j]; }
}
// vector<int> order(D);
// rep(i, D) cin >> order[i];
// int M;
// cin >> M;
// vector<std::pair<int, int>> query(M);
// rep(i, M) cin >> query[i].first >> query[i].second;
// rep(i, M) {
// order[query[i].first-1] = query[i].second;
// calc_satisfy(s, c, order, D);
// }
std::random_device rnd;
ll max_params{-LLINF};
vector<int> max_order(D);
rep(i, order_max_cnt) {
vector<int> order(D);
rep(j, D) { order[j] = (rnd() % contest_num) + 1; }
ll tmp = calc_satisfy(s, c, order, D);
if (max_params < tmp) {
max_order = order;
}
}
rep(i, D) cout << max_order[i] << '\n';
}
| replace | 26 | 27 | 26 | 27 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0, i##_len = int(n); i < i##_len; ++i)
#define rep(i, a, b) for (int i = int(a); i < int(b); ++i)
#define All(x) (x).begin(), (x).end()
#define rAll(x) (x).rbegin(), (x).rend()
using namespace std;
using ll = long long;
int main() {
// 方針
// 毎日満足度は低下し続ける
// 満足度上昇の方法はコンテスト開催のみ
// 開催されてないコンテストを放置すると低下が著しくなる
// 実際にコンテストを開いた時の満足度上昇が最大のものを採用してみる
// 低下をなくせる分を上昇と捉えると、c_i(d-last(d,i)) + s_{d,i}
// だけペイすると考えられる？→あんまり適当じゃない
// r日ずつ全探索を[D/r+1]回繰り返す
// 探索パターン数は26^rで、シミュレーションには26r回かかる、これを[D/r+1]回繰り返すので
// 計算量はO(D26^{r+1})
// r = 3が限界
int D;
cin >> D;
int c[26], last[26] = {}, s[365][26], lastcpy[26];
REP(i, 26) cin >> c[i];
REP(i, D) REP(j, 26) cin >> s[i][j];
constexpr int r = 8; // 何日に分けて全探索を行うか
constexpr int num = 6; // 1日毎にいくつ全探索するか
int all = 1;
REP(i, r) all *= num;
int up, ptncpy;
int res[r], calcres[r], reslast[26];
int ord[26];
iota(ord, ord + 26, 0);
stable_sort(ord, ord + 26, [&](int x, int y) { return c[x] > c[y]; });
stable_sort(c, c + 26, [](int x, int y) { return x > y; });
for (int i = 0; i < D; i += r) {
int tmp = -1e9;
for (int pattern = 0; pattern < all;
pattern++) { // r日でそれぞれ何処を選ぶか全探索
up = 0;
ptncpy = pattern;
memcpy(lastcpy, last,
sizeof(int) * 26); // lastを更新しなければならないのでコピーを取る
REP(j, r) { // r日探索
if (i + j >= D)
break;
calcres[j] = ptncpy % num;
REP(k,
26) { // スコアに影響のある26パターンについて処理しなければならない
if (calcres[j] ==
k) { // 選ぶパターンのときはlastを更新してスコアを加算
last[k] = i + j;
up += s[i + j][k];
} else
up -= c[k] * (i + j - last[k]); // そうでないときはlastを参照して減算
}
ptncpy /= num; // これをi+r-1日目まで繰り返して終了
}
if (tmp < up) { // もしスコアが高くなるならば結果を更新する
tmp = up;
memcpy(res, calcres, sizeof(int) * r); //
memcpy(reslast, last, sizeof(int) * 26);
}
memcpy(last, lastcpy, sizeof(int) * 26);
}
memcpy(last, reslast, sizeof(int) * 26);
REP(j, r) if (i + j < D) { cout << ord[res[j]] + 1 << endl; }
}
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0, i##_len = int(n); i < i##_len; ++i)
#define rep(i, a, b) for (int i = int(a); i < int(b); ++i)
#define All(x) (x).begin(), (x).end()
#define rAll(x) (x).rbegin(), (x).rend()
using namespace std;
using ll = long long;
int main() {
// 方針
// 毎日満足度は低下し続ける
// 満足度上昇の方法はコンテスト開催のみ
// 開催されてないコンテストを放置すると低下が著しくなる
// 実際にコンテストを開いた時の満足度上昇が最大のものを採用してみる
// 低下をなくせる分を上昇と捉えると、c_i(d-last(d,i)) + s_{d,i}
// だけペイすると考えられる？→あんまり適当じゃない
// r日ずつ全探索を[D/r+1]回繰り返す
// 探索パターン数は26^rで、シミュレーションには26r回かかる、これを[D/r+1]回繰り返すので
// 計算量はO(D26^{r+1})
// r = 3が限界
int D;
cin >> D;
int c[26], last[26] = {}, s[365][26], lastcpy[26];
REP(i, 26) cin >> c[i];
REP(i, D) REP(j, 26) cin >> s[i][j];
constexpr int r = 6; // 何日に分けて全探索を行うか
constexpr int num =
6; // 1日毎にいくつ全探索するか:cを降順ソートして前半num個だけを選び続ける貪欲
int all = 1;
REP(i, r) all *= num;
int up, ptncpy;
int res[r], calcres[r], reslast[26];
int ord[26];
iota(ord, ord + 26, 0);
stable_sort(ord, ord + 26, [&](int x, int y) { return c[x] > c[y]; });
stable_sort(c, c + 26, [](int x, int y) { return x > y; });
for (int i = 0; i < D; i += r) {
int tmp = -1e9;
for (int pattern = 0; pattern < all;
pattern++) { // r日でそれぞれ何処を選ぶか全探索
up = 0;
ptncpy = pattern;
memcpy(lastcpy, last,
sizeof(int) * 26); // lastを更新しなければならないのでコピーを取る
REP(j, r) { // r日探索
if (i + j >= D)
break;
calcres[j] = ptncpy % num;
REP(k,
26) { // スコアに影響のある26パターンについて処理しなければならない
if (calcres[j] ==
k) { // 選ぶパターンのときはlastを更新してスコアを加算
last[k] = i + j;
up += s[i + j][k];
} else
up -= c[k] * (i + j - last[k]); // そうでないときはlastを参照して減算
}
ptncpy /= num; // これをi+r-1日目まで繰り返して終了
}
if (tmp < up) { // もしスコアが高くなるならば結果を更新する
tmp = up;
memcpy(res, calcres, sizeof(int) * r); //
memcpy(reslast, last, sizeof(int) * 26);
}
memcpy(last, lastcpy, sizeof(int) * 26);
}
memcpy(last, reslast, sizeof(int) * 26);
REP(j, r) if (i + j < D) { cout << ord[res[j]] + 1 << endl; }
}
}
| replace | 25 | 27 | 25 | 28 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define R cin >>
#define ll long long
#define ln cout << endl
#define in(a) insert(a)
#define pb(a) push_back(a)
#define pd(a) printf("%.10f\n", a)
#define mem(a) memset(a, 0, sizeof(a))
#define all(c) (c).begin(), (c).end()
#define iter(c) __typeof((c).begin())
#define rrep(i, n) for (ll i = (ll)(n)-1; i >= 0; i--)
#define REP(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define tr(it, c) for (iter(c) it = (c).begin(); it != (c).end(); it++)
ll check(ll n, ll m, ll x, ll y) { return x >= 0 && x < n && y >= 0 && y < m; }
void pr() { ln; }
template <class A, class... B> void pr(const A &a, const B &...b) {
cout << a << (sizeof...(b) ? " " : "");
pr(b...);
}
template <class A> void PR(A a, ll n) {
rep(i, n) cout << (i ? " " : "") << a[i];
ln;
}
const ll MAX = 1e9 + 7, MAXL = 1LL << 61, dx[8] = {-1, 0, 1, 0, -1, -1, 1, 1},
dy[8] = {0, 1, 0, -1, -1, 1, 1, -1};
typedef pair<ll, ll> P;
ll calc(ll k, ll d) { return k * (k + 1) / 2 * d; }
const ll n = 26;
ll c[n], q[444];
ll a[444][n];
set<ll> s[n];
ll solve(ll x, ll y, ll t) {
ll ans = 0, e = q[x];
{
ans -= a[x][q[x]];
iter(s[q[x]]) it2 = s[q[x]].lower_bound(x);
iter(s[q[x]]) it1 = it2, it3 = it2;
it1--, it3++;
ans += calc(*it2 - *it1 - 1, c[q[x]]);
ans += calc(*it3 - *it2 - 1, c[q[x]]);
ans -= calc(*it3 - *it1 - 1, c[q[x]]);
s[q[x]].erase(it2);
}
{
q[x] = y;
s[q[x]].in(x);
ans += a[x][q[x]];
iter(s[q[x]]) it2 = s[q[x]].lower_bound(x);
iter(s[q[x]]) it1 = it2, it3 = it2;
it1--, it3++;
ans -= calc(*it2 - *it1 - 1, c[q[x]]);
ans -= calc(*it3 - *it2 - 1, c[q[x]]);
ans += calc(*it3 - *it1 - 1, c[q[x]]);
}
if (!t) {
s[q[x]].erase(x);
q[x] = e;
s[q[x]].in(x);
}
return ans;
}
void Main() {
srand((unsigned)time(NULL));
int T;
R T;
rep(i, n) R c[i];
rep(i, T) rep(j, n) R a[i][j];
rep(i, n) s[i].in(-1), s[i].in(T);
rep(k, T) {
q[k] = 0;
s[0].in(k);
}
ll ans[T];
mem(ans);
clock_t t2 = clock();
for (int tt = 0;; tt++) {
ll x = rand() % T, y = rand() % n;
if (solve(x, y, 0) > 0) {
solve(x, y, 1);
ans[x] = y;
}
clock_t t3 = clock();
double t4 = (double)(t3 - t2) / CLOCKS_PER_SEC;
if (tt >= 2 && (double)t3 / CLOCKS_PER_SEC + t4 * 2 > 1.997)
break;
t2 = t3;
}
rep(i, T) pr(ans[i] + 1);
}
int main() {
Main();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
#define R cin >>
#define ll long long
#define ln cout << endl
#define in(a) insert(a)
#define pb(a) push_back(a)
#define pd(a) printf("%.10f\n", a)
#define mem(a) memset(a, 0, sizeof(a))
#define all(c) (c).begin(), (c).end()
#define iter(c) __typeof((c).begin())
#define rrep(i, n) for (ll i = (ll)(n)-1; i >= 0; i--)
#define REP(i, m, n) for (ll i = (ll)(m); i < (ll)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define tr(it, c) for (iter(c) it = (c).begin(); it != (c).end(); it++)
ll check(ll n, ll m, ll x, ll y) { return x >= 0 && x < n && y >= 0 && y < m; }
void pr() { ln; }
template <class A, class... B> void pr(const A &a, const B &...b) {
cout << a << (sizeof...(b) ? " " : "");
pr(b...);
}
template <class A> void PR(A a, ll n) {
rep(i, n) cout << (i ? " " : "") << a[i];
ln;
}
const ll MAX = 1e9 + 7, MAXL = 1LL << 61, dx[8] = {-1, 0, 1, 0, -1, -1, 1, 1},
dy[8] = {0, 1, 0, -1, -1, 1, 1, -1};
typedef pair<ll, ll> P;
ll calc(ll k, ll d) { return k * (k + 1) / 2 * d; }
const ll n = 26;
ll c[n], q[444];
ll a[444][n];
set<ll> s[n];
ll solve(ll x, ll y, ll t) {
ll ans = 0, e = q[x];
{
ans -= a[x][q[x]];
iter(s[q[x]]) it2 = s[q[x]].lower_bound(x);
iter(s[q[x]]) it1 = it2, it3 = it2;
it1--, it3++;
ans += calc(*it2 - *it1 - 1, c[q[x]]);
ans += calc(*it3 - *it2 - 1, c[q[x]]);
ans -= calc(*it3 - *it1 - 1, c[q[x]]);
s[q[x]].erase(it2);
}
{
q[x] = y;
s[q[x]].in(x);
ans += a[x][q[x]];
iter(s[q[x]]) it2 = s[q[x]].lower_bound(x);
iter(s[q[x]]) it1 = it2, it3 = it2;
it1--, it3++;
ans -= calc(*it2 - *it1 - 1, c[q[x]]);
ans -= calc(*it3 - *it2 - 1, c[q[x]]);
ans += calc(*it3 - *it1 - 1, c[q[x]]);
}
if (!t) {
s[q[x]].erase(x);
q[x] = e;
s[q[x]].in(x);
}
return ans;
}
void Main() {
srand((unsigned)time(NULL));
int T;
R T;
rep(i, n) R c[i];
rep(i, T) rep(j, n) R a[i][j];
rep(i, n) s[i].in(-1), s[i].in(T);
rep(k, T) {
q[k] = 0;
s[0].in(k);
}
ll ans[T];
mem(ans);
clock_t t2 = clock();
for (int tt = 0;; tt++) {
ll x = rand() % T, y = rand() % n;
if (solve(x, y, 0) > 0) {
solve(x, y, 1);
ans[x] = y;
}
clock_t t3 = clock();
double t4 = (double)(t3 - t2) / CLOCKS_PER_SEC;
if (tt >= 2 && (double)t3 / CLOCKS_PER_SEC + t4 * 2 > 1.500)
break;
t2 = t3;
}
rep(i, T) pr(ans[i] + 1);
}
int main() {
Main();
return 0;
}
| replace | 91 | 92 | 91 | 92 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <iostream>
#include <set>
#include <vector>
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
std::vector<int> t(D);
for (int i = 0; i < D; ++i)
t[i] = i % 26;
std::set<int> last[26];
for (auto &li : last)
li.insert(-1); // sentinel
int ans = 0;
for (int d = 0; d < D; ++d) {
int t1 = t[d];
ans += s[d][t1];
last[t1].insert(d);
for (int i = 0; i < 26; ++i) {
ans -= c[i] * (d - *last[i].rbegin());
}
}
for (auto &li : last)
li.insert(D); // sentinel
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d * (d - 1) / 2; };
auto score = [&](int d, int i) -> int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d - pd) + sum_up(nd - d) - sum_up(nd - pd);
res -= c[i] * diff;
return res;
};
// hill climbing
int lm = 0;
int sc[26];
for (;;) {
if ((xor64() >> 25) & 1) {
int dd = -1, ma = 0;
for (int d = 0; d < D; ++d) {
int pi = t[d];
last[pi].erase(d);
for (int i = 0; i < 26; ++i)
sc[i] = score(d, i);
int mi = std::max_element(sc, sc + 26) - sc;
int cur = sc[mi] - sc[pi];
if (ma < cur) {
ma = cur;
dd = d;
}
last[pi].insert(d);
}
if (ma == 0)
++lm;
else {
int pi = t[dd];
last[pi].erase(dd);
for (int i = 0; i < 26; ++i)
sc[i] = score(dd, i);
int mi = std::max_element(sc, sc + 26) - sc;
last[mi].insert(dd);
lm = 0;
}
} else {
// swap
int d1 = xor64() % D, d2 = xor64() % D;
while (d1 < d2 - 16 || d2 < d1 - 16 || t[d1] == t[d2]) {
d1 = xor64() % D;
d2 = xor64() % D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if (diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
++lm;
}
}
if (lm >= 1000)
break;
}
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| #include <algorithm>
#include <array>
#include <iostream>
#include <set>
#include <vector>
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
std::vector<int> t(D);
for (int i = 0; i < D; ++i)
t[i] = i % 26;
std::set<int> last[26];
for (auto &li : last)
li.insert(-1); // sentinel
int ans = 0;
for (int d = 0; d < D; ++d) {
int t1 = t[d];
ans += s[d][t1];
last[t1].insert(d);
for (int i = 0; i < 26; ++i) {
ans -= c[i] * (d - *last[i].rbegin());
}
}
for (auto &li : last)
li.insert(D); // sentinel
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d * (d - 1) / 2; };
auto score = [&](int d, int i) -> int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d - pd) + sum_up(nd - d) - sum_up(nd - pd);
res -= c[i] * diff;
return res;
};
// hill climbing
int lm = 0;
int sc[26];
for (;;) {
if ((xor64() >> 25) & 1) {
int dd = -1, ma = 0;
for (int d = 0; d < D; ++d) {
int pi = t[d];
last[pi].erase(d);
for (int i = 0; i < 26; ++i)
sc[i] = score(d, i);
int mi = std::max_element(sc, sc + 26) - sc;
int cur = sc[mi] - sc[pi];
if (ma < cur) {
ma = cur;
dd = d;
}
last[pi].insert(d);
}
if (ma == 0)
++lm;
else {
int pi = t[dd];
last[pi].erase(dd);
for (int i = 0; i < 26; ++i)
sc[i] = score(dd, i);
int mi = std::max_element(sc, sc + 26) - sc;
last[mi].insert(dd);
lm = 0;
}
} else {
// swap
int d1 = xor64() % D, d2 = xor64() % D;
while (d1 < d2 - 16 || d2 < d1 - 16 || t[d1] == t[d2]) {
d1 = xor64() % D;
d2 = xor64() % D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if (diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
++lm;
}
}
if (lm >= 10)
break;
}
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| replace | 110 | 111 | 110 | 111 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
std::vector<int> t(D);
for (int i = 0; i < D; ++i)
t[i] = i % 26;
std::set<int> last[26];
for (auto &li : last)
li.insert(-1); // sentinel
int ans = 0;
for (int d = 0; d < D; ++d) {
int t1 = t[d];
ans += s[d][t1];
last[t1].insert(d);
for (int i = 0; i < 26; ++i) {
ans -= c[i] * (d - *last[i].rbegin());
}
}
for (auto &li : last)
li.insert(D); // sentinel
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d * (d - 1) / 2; };
auto score = [&](int d, int i) -> int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d - pd) + sum_up(nd - d) - sum_up(nd - pd);
res -= c[i] * diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for (int i = 0; i < 26; ++i)
sc[i] = score(d, i);
int mi = std::max_element(sc, sc + 26) - sc;
if (mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
for (;;) {
int lp = -1;
do {
renew = 0;
for (int d = 0; d < D; ++d)
one_day(d);
++lp;
if (get_time() > 1980)
break;
} while (renew > 0);
if (lp == 0 && lm > 10)
break;
// swap
int rep = 1 + xor64() % 5;
while (rep-- > 0) {
int d1 = xor64() % D, d2 = xor64() % D;
while (d1 < d2 - 16 || d2 < d1 - 16 || t[d1] == t[d2]) {
d1 = xor64() % D;
d2 = xor64() % D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if (diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
++lm;
}
}
}
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
std::vector<int> t(D);
for (int i = 0; i < D; ++i)
t[i] = i % 26;
std::set<int> last[26];
for (auto &li : last)
li.insert(-1); // sentinel
int ans = 0;
for (int d = 0; d < D; ++d) {
int t1 = t[d];
ans += s[d][t1];
last[t1].insert(d);
for (int i = 0; i < 26; ++i) {
ans -= c[i] * (d - *last[i].rbegin());
}
}
for (auto &li : last)
li.insert(D); // sentinel
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d * (d - 1) / 2; };
auto score = [&](int d, int i) -> int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d - pd) + sum_up(nd - d) - sum_up(nd - pd);
res -= c[i] * diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for (int i = 0; i < 26; ++i)
sc[i] = score(d, i);
int mi = std::max_element(sc, sc + 26) - sc;
if (mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
for (;;) {
int lp = -1;
do {
renew = 0;
for (int d = 0; d < D; ++d)
one_day(d);
++lp;
if (get_time() > 1850)
break;
} while (renew > 0);
if (lp == 0 && lm > 10)
break;
// swap
int rep = 1 + xor64() % 5;
while (rep-- > 0) {
int d1 = xor64() % D, d2 = xor64() % D;
while (d1 < d2 - 16 || d2 < d1 - 16 || t[d1] == t[d2]) {
d1 = xor64() % D;
d2 = xor64() % D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if (diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
++lm;
}
}
}
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| replace | 87 | 88 | 87 | 88 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 200;
int const K = 6;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
for (int k = 0; k < K; ++k) {
beam_search(k);
if (ansa[k] > ans) {
ans = ansa[k];
std::copy(t.begin(), t.end(), bestT.begin());
}
}
std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 200;
int const K = 5;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
for (int k = 0; k < K; ++k) {
beam_search(k);
if (ansa[k] > ans) {
ans = ansa[k];
std::copy(t.begin(), t.end(), bestT.begin());
}
}
std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| replace | 49 | 50 | 49 | 50 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 350;
int const K = 4;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
for (int k = 0; k < K; ++k) {
beam_search(k);
if (ansa[k] > ans) {
ans = ansa[k];
std::copy(t.begin(), t.end(), bestT.begin());
}
}
std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 330;
int const K = 4;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
for (int k = 0; k < K; ++k) {
beam_search(k);
if (ansa[k] > ans) {
ans = ansa[k];
std::copy(t.begin(), t.end(), bestT.begin());
}
}
std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| replace | 48 | 49 | 48 | 49 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 495;
int const K = 3;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
for (int k = 0; k < K; ++k) {
beam_search(k);
if (ansa[k] > ans) {
ans = ansa[k];
std::copy(t.begin(), t.end(), bestT.begin());
}
}
std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 495;
int const K = 3;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
for (int k = 1; k < K; ++k) {
beam_search(k);
if (ansa[k] > ans) {
ans = ansa[k];
std::copy(t.begin(), t.end(), bestT.begin());
}
}
std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| replace | 98 | 99 | 98 | 99 | TLE | |
p02618 | C++ | Time Limit Exceeded | // パチンコ
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int N = 26;
int D;
vector<int> c(N + 1);
vector<vector<int>> s;
vector<int> t;
ll now_score = 0;
ll greedy() {
vector<int> last(N + 1, 0);
ll greedy_score = 0;
for (int d = 1; d <= D; d++) {
ll max_score = -1e9;
vector<int> max_last;
for (int n = 1; n <= N; n++) {
ll tmp_score = 0;
vector<int> tmp_last(N + 1);
tmp_last = last;
tmp_score += s[d][n];
tmp_last[n] = d;
int penalty = 0;
for (int i = 1; i <= N; i++) {
penalty += c[i] * (d - tmp_last[i]);
}
tmp_score -= penalty;
if (max_score < tmp_score) {
max_score = tmp_score;
max_last = tmp_last;
t[d] = n;
}
}
last = max_last;
greedy_score += max_score;
}
return greedy_score;
}
ll scoring() {
vector<int> last(N + 1, 0);
ll score = 0;
for (int d = 1; d <= D; d++) {
score += s[d][t[d]];
last[t[d]] = d;
int penalty = 0;
for (int i = 1; i <= N; i++) {
penalty += c[i] * (d - last[i]);
}
score -= penalty;
}
return score;
}
void exchange(int d, int x) {
swap(t[d], t[d + x]);
ll swap_score = scoring();
if (now_score >= swap_score) {
swap(t[d], t[d + x]);
} else {
now_score = swap_score;
}
}
void pachinko() {
srand((unsigned)time(NULL)); /* Use Mersenne Twister */
for (int i = 1; i <= D; i++) {
int pre = t[i];
t[i] = rand() % 26 + 1;
ll pachi_score = scoring();
if (now_score >= pachi_score) {
t[i] = pre;
} else {
now_score = pachi_score;
}
}
}
int main() {
clock_t start = clock();
cin >> D;
s.resize(D + 1);
for (int i = 0; i <= D; i++) {
s[i].resize(N + 1);
}
t.resize(D + 1);
for (int i = 1; i <= N; i++) {
cin >> c[i];
}
for (int i = 1; i <= D; i++) {
for (int j = 1; j <= N; j++) {
cin >> s[i][j];
}
}
for (int i = 1; i <= D; i++) {
cin >> t[i];
}
now_score = greedy();
clock_t now_time = clock();
while ((now_time - start) / CLOCKS_PER_SEC < 1.2) {
// 乱数パチンコ
pachinko();
// 解交換
for (int x = 1; x < D; x++) {
for (int d = 1; d <= D - x; d++) {
exchange(d, x);
}
}
now_time = clock();
}
for (int i = 1; i <= D; i++) {
cout << t[i] << endl;
}
return 0;
} | // パチンコ
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int N = 26;
int D;
vector<int> c(N + 1);
vector<vector<int>> s;
vector<int> t;
ll now_score = 0;
ll greedy() {
vector<int> last(N + 1, 0);
ll greedy_score = 0;
for (int d = 1; d <= D; d++) {
ll max_score = -1e9;
vector<int> max_last;
for (int n = 1; n <= N; n++) {
ll tmp_score = 0;
vector<int> tmp_last(N + 1);
tmp_last = last;
tmp_score += s[d][n];
tmp_last[n] = d;
int penalty = 0;
for (int i = 1; i <= N; i++) {
penalty += c[i] * (d - tmp_last[i]);
}
tmp_score -= penalty;
if (max_score < tmp_score) {
max_score = tmp_score;
max_last = tmp_last;
t[d] = n;
}
}
last = max_last;
greedy_score += max_score;
}
return greedy_score;
}
ll scoring() {
vector<int> last(N + 1, 0);
ll score = 0;
for (int d = 1; d <= D; d++) {
score += s[d][t[d]];
last[t[d]] = d;
int penalty = 0;
for (int i = 1; i <= N; i++) {
penalty += c[i] * (d - last[i]);
}
score -= penalty;
}
return score;
}
void exchange(int d, int x) {
swap(t[d], t[d + x]);
ll swap_score = scoring();
if (now_score >= swap_score) {
swap(t[d], t[d + x]);
} else {
now_score = swap_score;
}
}
void pachinko() {
srand((unsigned)time(NULL)); /* Use Mersenne Twister */
for (int i = 1; i <= D; i++) {
int pre = t[i];
t[i] = rand() % 26 + 1;
ll pachi_score = scoring();
if (now_score >= pachi_score) {
t[i] = pre;
} else {
now_score = pachi_score;
}
}
}
int main() {
clock_t start = clock();
cin >> D;
s.resize(D + 1);
for (int i = 0; i <= D; i++) {
s[i].resize(N + 1);
}
t.resize(D + 1);
for (int i = 1; i <= N; i++) {
cin >> c[i];
}
for (int i = 1; i <= D; i++) {
for (int j = 1; j <= N; j++) {
cin >> s[i][j];
}
}
for (int i = 1; i <= D; i++) {
cin >> t[i];
}
now_score = greedy();
clock_t now_time = clock();
while ((now_time - start) / CLOCKS_PER_SEC < 1) {
// 乱数パチンコ
pachinko();
// 解交換
for (int x = 1; x < D; x++) {
for (int d = 1; d <= D - x; d++) {
exchange(d, x);
}
}
now_time = clock();
}
for (int i = 1; i <= D; i++) {
cout << t[i] << endl;
}
return 0;
} | replace | 122 | 123 | 122 | 123 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 560;
int const K = 3;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
for (int k = 1; k < K; ++k) {
beam_search(k);
if (ansa[k] > ans) {
ans = ansa[k];
std::copy(t.begin(), t.end(), bestT.begin());
}
}
std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 540;
int const K = 3;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
for (int k = 1; k < K; ++k) {
beam_search(k);
if (ansa[k] > ans) {
ans = ansa[k];
std::copy(t.begin(), t.end(), bestT.begin());
}
}
std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| replace | 48 | 49 | 48 | 49 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int d;
cin >> d;
vector<int> c(26, 0);
vector<vector<int>> s(d, vector<int>(26, 0));
vector<int> last(26, 0);
vector<int> ans(d, 0);
for (int i = 0; i < 26; i++) {
cin >> c[i];
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < 26; j++) {
cin >> s[i][j];
}
}
int max;
int k;
for (int i = 0; i < d; i++) {
max = -1;
k = -1;
for (int j = 0; j < 26; j++) {
int p = s[i][j] + c[i] * (i + 1 - last[j]);
if (max < p) {
max = p;
k = j;
} else if (max == p) {
if (c[k] < c[j]) {
max = p;
k = j;
}
}
}
ans[i] = k;
last[k]++;
}
for (int i = 0; i < d; i++) {
cout << ans[i] + 1 << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int d;
cin >> d;
vector<int> c(26, 0);
vector<vector<int>> s(d, vector<int>(26, 0));
vector<int> last(26, 0);
vector<int> ans(d, 0);
for (int i = 0; i < 26; i++) {
cin >> c[i];
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < 26; j++) {
cin >> s[i][j];
}
}
int max;
int k;
for (int i = 0; i < d; i++) {
max = s[i][0] + c[0] * (i + 1 - last[0]);
k = 0;
for (int j = 1; j < 26; j++) {
int p = s[i][j] + c[j] * (i + 1 - last[j]);
if (max < p) {
max = p;
k = j;
} else if (max == p) {
if (c[k] < c[j]) {
max = p;
k = j;
}
}
}
ans[i] = k;
last[k]++;
}
for (int i = 0; i < d; i++) {
cout << ans[i] + 1 << endl;
}
return 0;
}
| replace | 27 | 31 | 27 | 31 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 750;
int const K = 2;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
for (int k = 1; k < K; ++k) {
beam_search(k);
if (ansa[k] > ans) {
ans = ansa[k];
std::copy(t.begin(), t.end(), bestT.begin());
}
}
std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 740;
int const K = 2;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
for (int k = 1; k < K; ++k) {
beam_search(k);
if (ansa[k] > ans) {
ans = ansa[k];
std::copy(t.begin(), t.end(), bestT.begin());
}
}
std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| replace | 48 | 49 | 48 | 49 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 720;
int const K = 3;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
// for(int k = 2; k < K; ++k) {
int k = K;
beam_search(k);
// if(ansa[k] > ans) {
ans = ansa[k];
// std::copy(t.begin(), t.end(), bestT.begin());
// }
// }
// std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 700;
int const K = 3;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
// for(int k = 2; k < K; ++k) {
int k = K;
beam_search(k);
// if(ansa[k] > ans) {
ans = ansa[k];
// std::copy(t.begin(), t.end(), bestT.begin());
// }
// }
// std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| replace | 48 | 49 | 48 | 49 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 1000;
int const K = 0;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score = st.score_k;
/* st.score += s[d][st.type];
for(int cx = 0; cx < 26; ++cx) {
st.score -= c[cx]*(d - st.last[cx]);
}*/
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
// for(int k = 2; k < K; ++k) {
int k = K;
beam_search(k);
// if(ansa[k] > ans) {
ans = ansa[k];
// std::copy(t.begin(), t.end(), bestT.begin());
// }
// }
// std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 800;
int const K = 0;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score = st.score_k;
/* st.score += s[d][st.type];
for(int cx = 0; cx < 26; ++cx) {
st.score -= c[cx]*(d - st.last[cx]);
}*/
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
// for(int k = 2; k < K; ++k) {
int k = K;
beam_search(k);
// if(ansa[k] > ans) {
ans = ansa[k];
// std::copy(t.begin(), t.end(), bestT.begin());
// }
// }
// std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| replace | 48 | 49 | 48 | 49 | TLE | |
p02618 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 1000;
int const K = 2;
std::vector<int> t(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
curr.reserve(prev.size() * 26);
int dd = std::min(d + k, D - 1);
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (d + dd - 2 * st.last[cx]) * (dd - d + 1) / 2;
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d)
beam_step(d, k);
auto it = states[D].begin();
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
beam_search(K);
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 840;
int const K = 2;
std::vector<int> t(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
curr.reserve(prev.size() * 26);
int dd = std::min(d + k, D - 1);
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (d + dd - 2 * st.last[cx]) * (dd - d + 1) / 2;
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d)
beam_step(d, k);
auto it = states[D].begin();
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
beam_search(K);
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| replace | 48 | 49 | 48 | 49 | MLE | |
p02618 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
#define dump(...) \
DUMPOUT << " "; \
DUMPOUT << #__VA_ARGS__ << " :[" << __LINE__ << ":" << __FUNCTION__ << "]" \
<< std::endl; \
DUMPOUT << " "; \
dump_func(__VA_ARGS__)
#define PI 3.14159265358979323846
#define EPS 1e-10
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define all(j) (j).begin(), (j).end()
#define SZ(j) ((int)(j).size())
const int D = 365;
long long eval(vector<int> out, vector<int> c, vector<vector<int>> s) {
long long sat = 0;
vector<int> last(26, 0);
// for d in range(D):
REP(d, D) {
// assert(1 <= out[d] and out[d] <= 26)
assert(1 <= out[d] and out[d] <= 26);
// j = out[d] - 1
int j = out[d] - 1;
// last[j] = d + 1
last[j] = d + 1;
// for i in range(26):
REP(i, 26) {
// sat -= (d + 1 - last[i]) * c[i]
sat -= (d + 1 - last[i]) * c[i];
}
// sat += s[d][j]
sat += s[d][j];
cout << sat << endl;
}
// print("satisfaction: {}".format(sat))
return sat;
// print("score: {}".format(max(0, 1000000 + sat)))
}
int main() {
int tempD;
cin >> tempD;
vector<int> c(26);
REP(i, 26) cin >> c[i];
vector<vector<int>> s(D, vector<int>(26));
REP(d, D) REP(i, 26) cin >> s[d][i];
vector<int> res(D);
eval(res, c, s);
REP(d, D) {
int t = 0;
REP(i, 26) {
if (s[d][i] > t) {
t = s[d][i];
res[d] = i + 1;
}
}
}
for (int e : res)
cout << e << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
#define dump(...) \
DUMPOUT << " "; \
DUMPOUT << #__VA_ARGS__ << " :[" << __LINE__ << ":" << __FUNCTION__ << "]" \
<< std::endl; \
DUMPOUT << " "; \
dump_func(__VA_ARGS__)
#define PI 3.14159265358979323846
#define EPS 1e-10
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define all(j) (j).begin(), (j).end()
#define SZ(j) ((int)(j).size())
const int D = 365;
long long eval(vector<int> out, vector<int> c, vector<vector<int>> s) {
long long sat = 0;
vector<int> last(26, 0);
// for d in range(D):
REP(d, D) {
// assert(1 <= out[d] and out[d] <= 26)
assert(1 <= out[d] and out[d] <= 26);
// j = out[d] - 1
int j = out[d] - 1;
// last[j] = d + 1
last[j] = d + 1;
// for i in range(26):
REP(i, 26) {
// sat -= (d + 1 - last[i]) * c[i]
sat -= (d + 1 - last[i]) * c[i];
}
// sat += s[d][j]
sat += s[d][j];
cout << sat << endl;
}
// print("satisfaction: {}".format(sat))
return sat;
// print("score: {}".format(max(0, 1000000 + sat)))
}
int main() {
int tempD;
cin >> tempD;
vector<int> c(26);
REP(i, 26) cin >> c[i];
vector<vector<int>> s(D, vector<int>(26));
REP(d, D) REP(i, 26) cin >> s[d][i];
vector<int> res(D);
REP(d, D) {
int t = 0;
REP(i, 26) {
if (s[d][i] > t) {
t = s[d][i];
res[d] = i + 1;
}
}
}
for (int e : res)
cout << e << endl;
return 0;
} | delete | 57 | 59 | 57 | 57 | -6 | 63b95b62-ccf4-4b8b-a8af-be3d1890d98e.out: /home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02618/C++/s891565793.cpp:20: long long int eval(std::vector<int>, std::vector<int>, std::vector<std::vector<int> >): Assertion `1 <= out[d] and out[d] <= 26' failed.
|
p02618 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
#define dump(...) \
DUMPOUT << " "; \
DUMPOUT << #__VA_ARGS__ << " :[" << __LINE__ << ":" << __FUNCTION__ << "]" \
<< std::endl; \
DUMPOUT << " "; \
dump_func(__VA_ARGS__)
#define PI 3.14159265358979323846
#define EPS 1e-10
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define all(j) (j).begin(), (j).end()
#define SZ(j) ((int)(j).size())
int D = 365;
const int T = 26;
vector<int> c(T);
vector<vector<int>> s(D, vector<int>(T));
long long compute_score(vector<int> out) {
long long score = 0;
vector<int> last(T, 0);
REP(d, (int)out.size()) {
last[out[d] - 1] = d + 1;
REP(i, T) { score -= (long long)(d + 1 - last[i]) * c[i]; }
score += s[d][out[d] - 1];
// cout << score << endl;
}
return score;
}
vector<int> solve() {
vector<int> out;
REP(_, D) {
int best_i = 1;
long long max_score = -(1e18);
FOR(i, 1, T + 1) {
out.emplace_back(i);
long long score = compute_score(out);
if (max_score < score) {
max_score = score;
best_i = i;
}
out.pop_back();
}
}
return out;
}
void test_score() {
vector<int> t(D);
REP(i, D) cin >> t[i];
compute_score(t);
}
int main(int argc, char const *argv[]) {
int d_;
cin >> d_;
D = d_;
REP(i, T) cin >> c[i];
REP(i, D) REP(j, T) cin >> s[i][j];
vector<int> out = solve();
assert(out.size() == D);
for (int t : solve()) {
cout << t << endl;
}
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
#define dump(...) \
DUMPOUT << " "; \
DUMPOUT << #__VA_ARGS__ << " :[" << __LINE__ << ":" << __FUNCTION__ << "]" \
<< std::endl; \
DUMPOUT << " "; \
dump_func(__VA_ARGS__)
#define PI 3.14159265358979323846
#define EPS 1e-10
#define FOR(i, a, n) for (int i = (a); i < (n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define all(j) (j).begin(), (j).end()
#define SZ(j) ((int)(j).size())
int D = 365;
const int T = 26;
vector<int> c(T);
vector<vector<int>> s(D, vector<int>(T));
long long compute_score(vector<int> out) {
long long score = 0;
vector<int> last(T, 0);
REP(d, (int)out.size()) {
last[out[d] - 1] = d + 1;
REP(i, T) { score -= (long long)(d + 1 - last[i]) * c[i]; }
score += s[d][out[d] - 1];
// cout << score << endl;
}
return score;
}
vector<int> solve() {
vector<int> out;
REP(_, D) {
int best_i = 1;
long long max_score = -(1e18);
FOR(i, 1, T + 1) {
out.emplace_back(i);
long long score = compute_score(out);
if (max_score < score) {
max_score = score;
best_i = i;
}
out.pop_back();
}
out.emplace_back(best_i);
}
return out;
}
void test_score() {
vector<int> t(D);
REP(i, D) cin >> t[i];
compute_score(t);
}
int main(int argc, char const *argv[]) {
int d_;
cin >> d_;
D = d_;
REP(i, T) cin >> c[i];
REP(i, D) REP(j, T) cin >> s[i][j];
vector<int> out = solve();
assert(out.size() == D);
for (int t : solve()) {
cout << t << endl;
}
return 0;
}
| insert | 51 | 51 | 51 | 52 | -6 | 40c47792-2cc6-45c0-8cd5-147bce8e6fbc.out: /home/alex/Documents/bug-detection/input/Project_CodeNet/data/p02618/C++/s208201289.cpp:70: int main(int, const char**): Assertion `out.size() == D' failed.
|
p02618 | C++ | Runtime Error | #include <algorithm>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
typedef long long Int;
#define KIND 26
// #define KIND 2
Int D;
Int c[KIND];
Int s[400][KIND];
Int last[KIND];
vector<Int> best_t;
std::chrono::time_point<std::chrono::steady_clock> start;
double dice() { return double(rand()) / RAND_MAX; }
double prob(double rest) { return rest * 1e-4; }
Int range(Int l, Int r) {
Int len = r - l - 1;
return -len * (len + 1) / 2;
}
void tic() { start = std::chrono::steady_clock::now(); }
double toc() {
auto now = std::chrono::steady_clock::now();
std::chrono::duration<double> duration = now - start;
return duration.count();
}
struct ContestInfo {
set<Int> held[KIND];
vector<Int> t;
int D;
Int score = 0;
ContestInfo(int D) : D(D) {
t.resize(D, -1);
for (int i = 0; i < KIND; i++) {
held[i].insert(-1);
held[i].insert(D);
score += c[i] * range(-1, D);
}
}
void add(int d, int q) {
if (t[d] != -1) {
cout << "Add failed" << endl;
exit(1);
}
t[d] = q;
score += s[d][q];
held[q].insert(d);
auto it = held[q].find(d);
auto rit = next(it);
auto lit = prev(it);
score -= c[q] * range(*lit, *rit);
score += c[q] * range(*it, *rit);
score += c[q] * range(*lit, *it);
}
void erase(int d) {
if (t[d] == -1) {
cout << "erase failed" << endl;
exit(1);
}
int q = t[d];
t[d] = -1;
score -= s[d][q];
auto it = held[q].find(d);
auto rit = next(it);
auto lit = prev(it);
score += c[q] * range(*lit, *rit);
score -= c[q] * range(*it, *rit);
score -= c[q] * range(*lit, *it);
held[q].erase(it);
}
void change(int d, int q) {
erase(d);
add(d, q);
}
void output() {
for (int i = 0; i < D; i++) {
cout << t[i] + 1 << endl;
}
}
void save() { best_t = t; }
};
int main() {
cin >> D;
for (Int i = 0; i < KIND; i++) {
cin >> c[i];
}
for (Int d = 0; d < D; d++) {
for (Int i = 0; i < KIND; i++) {
cin >> s[d][i];
}
}
ContestInfo ci(D);
tic();
for (int _d = 0; _d < D; _d++) {
int new_d;
int new_q;
Int best_score = -1;
for (int d = 0; d < D; d++) {
if (ci.t[d] != -1)
continue;
ci.add(d, 0);
for (int i = 0; i < KIND; i++) {
if (ci.t[d] != i)
ci.change(d, i);
if (ci.score > best_score) {
best_score = ci.score;
new_q = i;
new_d = d;
}
}
ci.erase(d);
}
ci.add(new_d, new_q);
}
Int current_score = ci.score;
ci.save();
Int best_score = current_score;
while (toc() < 1.9) {
Int d, q;
d = rand() % D;
int TRIAL = 1;
int old = ci.t[d];
vector<int> score(TRIAL);
vector<int> contest_type(TRIAL);
int best_contest_type_ind = 0;
for (int i = 0; i < TRIAL; i++) {
contest_type[i] = rand() % KIND;
ci.change(d, contest_type[i]);
score[i] = ci.score;
if (score[best_contest_type_ind] < score[i]) {
best_contest_type_ind = i;
}
}
Int new_score = score[best_contest_type_ind];
if (new_score > current_score || dice() < prob(1.9 - toc())) {
// よかったら登る
current_score = new_score;
ci.change(d, contest_type[best_contest_type_ind]);
} else {
// 悪かったらそっちいかない
ci.change(d, old);
}
if (current_score > best_score) {
best_score = current_score;
ci.save();
}
}
for (int i = 0; i < D; i++)
cout << best_t[i] + 1 << endl;
return 0;
} | #include <algorithm>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
typedef long long Int;
#define KIND 26
// #define KIND 2
Int D;
Int c[KIND];
Int s[400][KIND];
Int last[KIND];
vector<Int> best_t;
std::chrono::time_point<std::chrono::steady_clock> start;
double dice() { return double(rand()) / RAND_MAX; }
double prob(double rest) { return rest * 1e-4; }
Int range(Int l, Int r) {
Int len = r - l - 1;
return -len * (len + 1) / 2;
}
void tic() { start = std::chrono::steady_clock::now(); }
double toc() {
auto now = std::chrono::steady_clock::now();
std::chrono::duration<double> duration = now - start;
return duration.count();
}
struct ContestInfo {
set<Int> held[KIND];
vector<Int> t;
int D;
Int score = 0;
ContestInfo(int D) : D(D) {
t.resize(D, -1);
for (int i = 0; i < KIND; i++) {
held[i].insert(-1);
held[i].insert(D);
score += c[i] * range(-1, D);
}
}
void add(int d, int q) {
if (t[d] != -1) {
cout << "Add failed" << endl;
exit(1);
}
t[d] = q;
score += s[d][q];
held[q].insert(d);
auto it = held[q].find(d);
auto rit = next(it);
auto lit = prev(it);
score -= c[q] * range(*lit, *rit);
score += c[q] * range(*it, *rit);
score += c[q] * range(*lit, *it);
}
void erase(int d) {
if (t[d] == -1) {
cout << "erase failed" << endl;
exit(1);
}
int q = t[d];
t[d] = -1;
score -= s[d][q];
auto it = held[q].find(d);
auto rit = next(it);
auto lit = prev(it);
score += c[q] * range(*lit, *rit);
score -= c[q] * range(*it, *rit);
score -= c[q] * range(*lit, *it);
held[q].erase(it);
}
void change(int d, int q) {
erase(d);
add(d, q);
}
void output() {
for (int i = 0; i < D; i++) {
cout << t[i] + 1 << endl;
}
}
void save() { best_t = t; }
};
int main() {
cin >> D;
for (Int i = 0; i < KIND; i++) {
cin >> c[i];
}
for (Int d = 0; d < D; d++) {
for (Int i = 0; i < KIND; i++) {
cin >> s[d][i];
}
}
ContestInfo ci(D);
tic();
for (int _d = 0; _d < D; _d++) {
int new_d;
int new_q;
Int best_score = -1e10;
for (int d = 0; d < D; d++) {
if (ci.t[d] != -1)
continue;
ci.add(d, 0);
for (int i = 0; i < KIND; i++) {
if (ci.t[d] != i)
ci.change(d, i);
if (ci.score > best_score) {
best_score = ci.score;
new_q = i;
new_d = d;
}
}
ci.erase(d);
}
ci.add(new_d, new_q);
}
Int current_score = ci.score;
ci.save();
Int best_score = current_score;
while (toc() < 1.9) {
Int d, q;
d = rand() % D;
int TRIAL = 1;
int old = ci.t[d];
vector<int> score(TRIAL);
vector<int> contest_type(TRIAL);
int best_contest_type_ind = 0;
for (int i = 0; i < TRIAL; i++) {
contest_type[i] = rand() % KIND;
ci.change(d, contest_type[i]);
score[i] = ci.score;
if (score[best_contest_type_ind] < score[i]) {
best_contest_type_ind = i;
}
}
Int new_score = score[best_contest_type_ind];
if (new_score > current_score || dice() < prob(1.9 - toc())) {
// よかったら登る
current_score = new_score;
ci.change(d, contest_type[best_contest_type_ind]);
} else {
// 悪かったらそっちいかない
ci.change(d, old);
}
if (current_score > best_score) {
best_score = current_score;
ci.save();
}
}
for (int i = 0; i < D; i++)
cout << best_t[i] + 1 << endl;
return 0;
} | replace | 114 | 115 | 114 | 115 | -11 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int D;
cin >> D;
vector<int> c(26);
for (int &i : c)
cin >> i;
vector<vector<int>> s(D, vector<int>(26));
for (vector<int> &v : s)
for (int &i : v)
cin >> i;
vector<int> t(D);
vector<int> A(26, 0);
int mzint = 0;
for (int i = 0; i < D; i++) {
int mzi = mzint, mzin = 0, k;
for (int j = 0; j < 26; j++)
mzi -= (i + 1 - A[j]) * c[j];
for (int j = 0; j < 26; j++) {
int l = mzi + s[i][j] - (i + 1 - A[j]) * c[j];
if (l > mzin) {
k = j;
mzin = l;
}
}
A[k] = i + 1;
mzint = mzin;
t[i] = k + 1;
}
int M = 100000000, ans = mzint;
while (M--) {
int d = rand() % D, q = rand() % 26, ans2 = ans;
ans += s[d][q] - s[d][t[d] - 1];
int mae = -1, ato = D;
for (int i = d - 1; i >= 0; i--) {
if (t[i] == t[d]) {
mae = i;
break;
}
}
for (int i = d + 1; i < D; i++) {
if (t[i] == t[d]) {
ato = i;
break;
}
}
ans -= (ato - d) * (d - mae) * c[t[d] - 1];
mae = -1, ato = D;
for (int i = d; i >= 0; i--) {
if (t[i] == q + 1) {
mae = i;
break;
}
}
for (int i = d; i < D; i++) {
if (t[i] == q + 1) {
ato = i;
break;
}
}
ans += (ato - d) * (d - mae) * c[q];
if (ans2 < ans)
t[d] = q + 1;
else
ans = ans2;
}
for (int i : t)
cout << i << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int D;
cin >> D;
vector<int> c(26);
for (int &i : c)
cin >> i;
vector<vector<int>> s(D, vector<int>(26));
for (vector<int> &v : s)
for (int &i : v)
cin >> i;
vector<int> t(D);
vector<int> A(26, 0);
int mzint = 0;
for (int i = 0; i < D; i++) {
int mzi = mzint, mzin = 0, k;
for (int j = 0; j < 26; j++)
mzi -= (i + 1 - A[j]) * c[j];
for (int j = 0; j < 26; j++) {
int l = mzi + s[i][j] - (i + 1 - A[j]) * c[j];
if (l > mzin) {
k = j;
mzin = l;
}
}
A[k] = i + 1;
mzint = mzin;
t[i] = k + 1;
}
int M = 18000000, ans = mzint;
while (M--) {
int d = rand() % D, q = rand() % 26, ans2 = ans;
ans += s[d][q] - s[d][t[d] - 1];
int mae = -1, ato = D;
for (int i = d - 1; i >= 0; i--) {
if (t[i] == t[d]) {
mae = i;
break;
}
}
for (int i = d + 1; i < D; i++) {
if (t[i] == t[d]) {
ato = i;
break;
}
}
ans -= (ato - d) * (d - mae) * c[t[d] - 1];
mae = -1, ato = D;
for (int i = d; i >= 0; i--) {
if (t[i] == q + 1) {
mae = i;
break;
}
}
for (int i = d; i < D; i++) {
if (t[i] == q + 1) {
ato = i;
break;
}
}
ans += (ato - d) * (d - mae) * c[q];
if (ans2 < ans)
t[d] = q + 1;
else
ans = ans2;
}
for (int i : t)
cout << i << endl;
} | replace | 31 | 32 | 31 | 32 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int D;
cin >> D;
vector<int> c(26);
for (int &i : c)
cin >> i;
vector<vector<int>> s(D, vector<int>(26));
for (vector<int> &v : s)
for (int &i : v)
cin >> i;
vector<int> t(D);
vector<int> A(26, 0);
int mzint = 0;
for (int i = 0; i < D; i++) {
int mzi = mzint, mzin = 0, k;
for (int j = 0; j < 26; j++)
mzi -= (i + 1 - A[j]) * c[j];
for (int j = 0; j < 26; j++) {
int l = mzi + s[i][j] - (i + 1 - A[j]) * c[j];
if (l > mzin) {
k = j;
mzin = l;
}
}
A[k] = i + 1;
mzint = mzin;
t[i] = k + 1;
}
int M = 10000000, ans = mzint;
while (M--) {
vector<pair<int, int>> AAA = {make_pair(rand() % D, rand() % 26),
make_pair(rand() % D, rand() % 26)};
vector<int> BBB = {t[AAA[0].first], t[AAA[1].first]};
int ans2 = ans;
for (int aaa = 0; aaa < 2; aaa++) {
int d = AAA[aaa].first, q = AAA[aaa].second;
ans += s[d][q] - s[d][t[d] - 1];
int mae = -1, ato = D;
for (int i = d - 1; i >= 0; i--) {
if (t[i] == t[d]) {
mae = i;
break;
}
}
for (int i = d + 1; i < D; i++) {
if (t[i] == t[d]) {
ato = i;
break;
}
}
ans -= (ato - d) * (d - mae) * c[t[d] - 1];
mae = -1, ato = D;
for (int i = d; i >= 0; i--) {
if (t[i] == q + 1) {
mae = i;
break;
}
}
for (int i = d; i < D; i++) {
if (t[i] == q + 1) {
ato = i;
break;
}
}
ans += (ato - d) * (d - mae) * c[q];
t[d] = q + 1;
}
if (ans2 > ans) {
ans = ans2;
t[AAA[0].first] = BBB[0];
t[AAA[1].first] = BBB[1];
}
}
for (int i : t)
cout << i << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
signed main() {
int D;
cin >> D;
vector<int> c(26);
for (int &i : c)
cin >> i;
vector<vector<int>> s(D, vector<int>(26));
for (vector<int> &v : s)
for (int &i : v)
cin >> i;
vector<int> t(D);
vector<int> A(26, 0);
int mzint = 0;
for (int i = 0; i < D; i++) {
int mzi = mzint, mzin = 0, k;
for (int j = 0; j < 26; j++)
mzi -= (i + 1 - A[j]) * c[j];
for (int j = 0; j < 26; j++) {
int l = mzi + s[i][j] - (i + 1 - A[j]) * c[j];
if (l > mzin) {
k = j;
mzin = l;
}
}
A[k] = i + 1;
mzint = mzin;
t[i] = k + 1;
}
int M = 6000000, ans = mzint;
while (M--) {
vector<pair<int, int>> AAA = {make_pair(rand() % D, rand() % 26),
make_pair(rand() % D, rand() % 26)};
vector<int> BBB = {t[AAA[0].first], t[AAA[1].first]};
int ans2 = ans;
for (int aaa = 0; aaa < 2; aaa++) {
int d = AAA[aaa].first, q = AAA[aaa].second;
ans += s[d][q] - s[d][t[d] - 1];
int mae = -1, ato = D;
for (int i = d - 1; i >= 0; i--) {
if (t[i] == t[d]) {
mae = i;
break;
}
}
for (int i = d + 1; i < D; i++) {
if (t[i] == t[d]) {
ato = i;
break;
}
}
ans -= (ato - d) * (d - mae) * c[t[d] - 1];
mae = -1, ato = D;
for (int i = d; i >= 0; i--) {
if (t[i] == q + 1) {
mae = i;
break;
}
}
for (int i = d; i < D; i++) {
if (t[i] == q + 1) {
ato = i;
break;
}
}
ans += (ato - d) * (d - mae) * c[q];
t[d] = q + 1;
}
if (ans2 > ans) {
ans = ans2;
t[AAA[0].first] = BBB[0];
t[AAA[1].first] = BBB[1];
}
}
for (int i : t)
cout << i << endl;
} | replace | 31 | 32 | 31 | 32 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 700;
int const K = 3;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
for (int k = 2; k < K; ++k) {
beam_search(k);
if (ansa[k] > ans) {
ans = ansa[k];
std::copy(t.begin(), t.end(), bestT.begin());
}
}
std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| #include <algorithm>
#include <array>
#include <chrono>
#include <iostream>
#include <set>
#include <vector>
int const INF = 1e9;
uint64_t xor64(void) {
static uint64_t x = 88172645463325252ULL;
x = x ^ (x << 7);
return x = x ^ (x >> 9);
}
auto b_cl = std::chrono::system_clock::now();
inline double get_time() {
auto e_cl = std::chrono::system_clock::now();
double msec =
std::chrono::duration_cast<std::chrono::milliseconds>(e_cl - b_cl)
.count();
return msec;
}
struct state {
int score_k;
int type;
int last[26];
int score;
std::vector<state>::iterator prev;
bool operator<(state const &rhs) const {
return score_k > rhs.score_k;
} // reverse order
};
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int D;
std::cin >> D;
int c[26];
for (auto &ci : c)
std::cin >> ci;
std::vector<std::array<int, 26>> s(D);
for (int d = 0; d < D; ++d) {
for (auto &si : s[d])
std::cin >> si;
}
int const B = 670;
int const K = 3;
int ans, ansa[K + 1];
std::vector<int> t(D), bestT(D);
std::vector<std::vector<state>> states(D + 1);
auto beam_step = [&](int d, int k) {
auto &prev = states[d];
auto &curr = states[d + 1];
for (auto it = prev.begin(); it != prev.end(); ++it) {
for (int T = 0; T < 26; ++T) {
curr.push_back(*it);
state &st = curr.back();
st.prev = it;
st.last[T] = d;
st.type = T;
st.score_k = st.score + s[d][T];
for (int dd = d; dd <= d + k && dd < D; ++dd) {
for (int cx = 0; cx < 26; ++cx) {
st.score_k -= c[cx] * (dd - st.last[cx]);
}
}
}
}
std::sort(curr.begin(), curr.end());
if (curr.size() > B)
curr.resize(B);
for (auto &st : curr) {
st.score += s[d][st.type];
for (int cx = 0; cx < 26; ++cx) {
st.score -= c[cx] * (d - st.last[cx]);
}
}
};
auto beam_search = [&](int k) {
states.assign(D + 1, std::vector<state>());
states[0].emplace_back();
states[0][0].score = 0;
states[0][0].score_k = 0;
std::fill_n(states[0][0].last, 26, -1);
for (int d = 0; d < D; ++d) {
beam_step(d, k);
}
auto it = states[D].begin();
ansa[k] = it->score;
for (int d = D - 1; d >= 0; it = it->prev, --d) {
t[d] = it->type;
}
};
for (int k = 2; k < K; ++k) {
beam_search(k);
if (ansa[k] > ans) {
ans = ansa[k];
std::copy(t.begin(), t.end(), bestT.begin());
}
}
std::copy(bestT.begin(), bestT.end(), t.begin());
// for(auto& li: last) li.insert(D); // sentinel
#if 0
// additional score when t[d] = i compare to t[d] = -1
auto sum_up = [](int d) { return d*(d-1)/2; };
auto score = [&](int d, int i)->int {
int res = s[d][i];
auto it = last[i].lower_bound(d);
int nd = *it;
int pd = *--it;
int diff = sum_up(d-pd) + sum_up(nd-d) - sum_up(nd-pd);
res -= c[i]*diff;
return res;
};
int lm = 0, renew = 0;
int sc[26];
auto one_day = [&](int d) {
int pi = t[d];
last[pi].erase(d);
for(int i = 0; i < 26; ++i) sc[i] = score(d, i);
int mi = std::max_element(sc, sc+26) - sc;
if(mi != pi) {
ans += sc[mi] - sc[pi];
++renew;
}
last[mi].insert(d);
};
// hill climbing
int range = 50;
for(int rep = 0;; ++rep) {
if((xor64()>>25)%2) {
one_day(xor64()%365);
} else {
// swap
int d1 = xor64()%D, d2 = xor64()%D;
while(d1 < d2-range || d2 < d1-range || t[d1] == t[d2]) {
d1 = xor64()%D; d2 = xor64()%D;
}
int pi1 = t[d1], pi2 = t[d2];
last[pi1].erase(d1);
int diff = score(d1, pi2) - score(d1, pi1);
last[pi2].insert(d1);
last[pi2].erase(d2);
diff += score(d2, pi1) - score(d2, pi2);
if(diff > 0) {
last[pi1].insert(d2);
t[d1] = pi2;
t[d2] = pi1;
lm = 0;
} else {
last[pi2].insert(d2);
last[pi2].erase(d1);
last[pi1].insert(d1);
}
}
if(rep%100 == 0) {
int x = get_time();
if(x > 1950) break;
}
}
#endif
for (auto ti : t)
std::cout << ti + 1 << "\n";
return 0;
}
| replace | 48 | 49 | 48 | 49 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <chrono>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
typedef int64_t Int;
typedef pair<Int, Int> P;
const Int Q = 26;
Int D;
vector<Int> C(Q);
vector<vector<Int>> S(400, vector<Int>(Q));
Int range(Int l, Int r) {
Int len = r - l - 1;
return -len * (len + 1) / 2;
}
//-------------------- 時間計測用 --------------------------
std::chrono::time_point<std::chrono::steady_clock> start;
void tic() { start = std::chrono::steady_clock::now(); }
double toc() {
auto now = std::chrono::steady_clock::now();
std::chrono::duration<double> duration = now - start;
return duration.count();
}
//-----------------------------------------------------------
struct ContestInformation {
vector<set<Int>> held; // held[q] : コンテストqを行った日程の集合
vector<Int> schedule; // schedule[d]: d日目に実施するコンテストの番号
Int score; // 最終日の満足度
Int cnt;
ContestInformation(Int D) {
schedule.resize(D, 0);
score = 0;
cnt = 0;
held.resize(Q);
rep(q, Q) {
held[q].insert(-1);
held[q].insert(D);
}
}
// scheduleの表示
void OutputSchedule() { rep(d, D) cout << schedule[d] + 1 << endl; }
// scheduleの貪欲法による初期化
void InitSchedule() {
rep(d, D) {
Int score_max = -10000000;
Int opt_q = -1;
rep(q_now, Q) {
Int score_next = 0;
rep(q, Q) {
if (q == q_now) {
score_next += S[d][q];
} else {
auto itr_last_day = lower_bound(held[q].begin(), held[q].end(), d);
score_next -= C[q] * (d - *prev(itr_last_day));
}
}
if (score_next > score_max) {
score_max = score_next;
opt_q = q_now;
}
}
schedule[d] = opt_q;
score += score_max;
held[opt_q].insert(d);
}
}
// d日目のコンテストを一旦なくす
void close(Int d) {
Int q_old = schedule[d]; // 変更前のコンテスト
score -= S[d][q_old];
auto itr_old = held[q_old].find(d);
auto r_old = next(itr_old);
auto l_old = prev(itr_old);
score += C[q_old] * range(*l_old, *r_old);
score -= C[q_old] * range(*l_old, *itr_old);
score -= C[q_old] * range(*itr_old, *r_old);
held[q_old].erase(d);
schedule[d] = -1;
}
// d日目にコンテストqを開催
void open(Int d, Int q_new) {
score += S[d][q_new];
held[q_new].insert(d);
schedule[d] = q_new;
auto itr_new = held[q_new].find(d);
auto r_new = next(itr_new);
auto l_new = prev(itr_new);
score -= C[q_new] * range(*l_new, *r_new);
score += C[q_new] * range(*l_new, *itr_new);
score += C[q_new] * range(*itr_new, *r_new);
}
// 日程・コンテストをランダムに決めて改善したら変更
void modify() {
Int old_score = score;
Int d = rand() % D;
Int q_old = schedule[d];
Int q_new = rand() % 26;
close(d);
open(d, q_new);
if (score < old_score) {
close(d);
open(d, q_old);
cnt++;
}
}
// modifyを2つの日程に対して強制的に実行
void modify2() {
Int d1 = rand() % D, d2 = rand() % D;
Int q1 = rand() % 26, q2 = rand() % 26;
close(d1);
open(d1, q1);
close(d2);
open(d1, q2);
}
// 2つの日程をランダムに決めて改善したらコンテストを入れ替え
void swap() {
Int old_score = score;
Int d1 = rand() % (D - 13), d2 = d1 + 1 + rand() % 13;
Int q_d1 = schedule[d1], q_d2 = schedule[d2];
close(d1);
open(d1, q_d2);
close(d2);
open(d2, q_d1);
if (score < old_score) {
close(d1);
open(d1, q_d1);
close(d2);
open(d2, q_d2);
cnt++;
}
}
};
int main() {
cin >> D;
rep(i, Q) cin >> C[i];
rep(i, D) rep(j, Q) cin >> S[i][j];
ContestInformation CI(D);
tic();
CI.InitSchedule();
// CI.OutputSchedule();
// cout << CI.score << endl;
while (toc() < 1.9) {
Int modify_or_swap = rand() % 2;
if (CI.cnt > 500) {
CI.modify2();
CI.cnt = 0;
} else if (modify_or_swap) {
CI.modify();
} else {
CI.swap();
}
}
CI.OutputSchedule();
} | #include <bits/stdc++.h>
#include <chrono>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
typedef int64_t Int;
typedef pair<Int, Int> P;
const Int Q = 26;
Int D;
vector<Int> C(Q);
vector<vector<Int>> S(400, vector<Int>(Q));
Int range(Int l, Int r) {
Int len = r - l - 1;
return -len * (len + 1) / 2;
}
//-------------------- 時間計測用 --------------------------
std::chrono::time_point<std::chrono::steady_clock> start;
void tic() { start = std::chrono::steady_clock::now(); }
double toc() {
auto now = std::chrono::steady_clock::now();
std::chrono::duration<double> duration = now - start;
return duration.count();
}
//-----------------------------------------------------------
struct ContestInformation {
vector<set<Int>> held; // held[q] : コンテストqを行った日程の集合
vector<Int> schedule; // schedule[d]: d日目に実施するコンテストの番号
Int score; // 最終日の満足度
Int cnt;
ContestInformation(Int D) {
schedule.resize(D, 0);
score = 0;
cnt = 0;
held.resize(Q);
rep(q, Q) {
held[q].insert(-1);
held[q].insert(D);
}
}
// scheduleの表示
void OutputSchedule() { rep(d, D) cout << schedule[d] + 1 << endl; }
// scheduleの貪欲法による初期化
void InitSchedule() {
rep(d, D) {
Int score_max = -10000000;
Int opt_q = -1;
rep(q_now, Q) {
Int score_next = 0;
rep(q, Q) {
if (q == q_now) {
score_next += S[d][q];
} else {
auto itr_last_day = lower_bound(held[q].begin(), held[q].end(), d);
score_next -= C[q] * (d - *prev(itr_last_day));
}
}
if (score_next > score_max) {
score_max = score_next;
opt_q = q_now;
}
}
schedule[d] = opt_q;
score += score_max;
held[opt_q].insert(d);
}
}
// d日目のコンテストを一旦なくす
void close(Int d) {
Int q_old = schedule[d]; // 変更前のコンテスト
score -= S[d][q_old];
auto itr_old = held[q_old].find(d);
auto r_old = next(itr_old);
auto l_old = prev(itr_old);
score += C[q_old] * range(*l_old, *r_old);
score -= C[q_old] * range(*l_old, *itr_old);
score -= C[q_old] * range(*itr_old, *r_old);
held[q_old].erase(d);
schedule[d] = -1;
}
// d日目にコンテストqを開催
void open(Int d, Int q_new) {
score += S[d][q_new];
held[q_new].insert(d);
schedule[d] = q_new;
auto itr_new = held[q_new].find(d);
auto r_new = next(itr_new);
auto l_new = prev(itr_new);
score -= C[q_new] * range(*l_new, *r_new);
score += C[q_new] * range(*l_new, *itr_new);
score += C[q_new] * range(*itr_new, *r_new);
}
// 日程・コンテストをランダムに決めて改善したら変更
void modify() {
Int old_score = score;
Int d = rand() % D;
Int q_old = schedule[d];
Int q_new = rand() % 26;
close(d);
open(d, q_new);
if (score < old_score) {
close(d);
open(d, q_old);
cnt++;
}
}
// modifyを2つの日程に対して強制的に実行
void modify2() {
Int d1 = rand() % D, d2 = rand() % D;
Int q1 = rand() % 26, q2 = rand() % 26;
close(d1);
open(d1, q1);
close(d2);
open(d2, q2);
}
// 2つの日程をランダムに決めて改善したらコンテストを入れ替え
void swap() {
Int old_score = score;
Int d1 = rand() % (D - 13), d2 = d1 + 1 + rand() % 13;
Int q_d1 = schedule[d1], q_d2 = schedule[d2];
close(d1);
open(d1, q_d2);
close(d2);
open(d2, q_d1);
if (score < old_score) {
close(d1);
open(d1, q_d1);
close(d2);
open(d2, q_d2);
cnt++;
}
}
};
int main() {
cin >> D;
rep(i, Q) cin >> C[i];
rep(i, D) rep(j, Q) cin >> S[i][j];
ContestInformation CI(D);
tic();
CI.InitSchedule();
// CI.OutputSchedule();
// cout << CI.score << endl;
while (toc() < 1.9) {
Int modify_or_swap = rand() % 2;
if (CI.cnt > 500) {
CI.modify2();
CI.cnt = 0;
} else if (modify_or_swap) {
CI.modify();
} else {
CI.swap();
}
}
CI.OutputSchedule();
} | replace | 138 | 139 | 138 | 139 | -11 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
typedef int64_t Int;
typedef pair<Int, Int> P;
Int D;
vector<Int> C(26);
vector<vector<Int>> S(365, vector<Int>(26));
// 最終的な満足度を返す関数
Int score(vector<int> schedule) {
vector<int> last_day(26, 0); // 各コンテストを最後に行った日
vector<Int> res(D, 0);
rep(d, D) {
int type = schedule[d] - 1; // その日に行われるコンテスト
res[d] += S[d][type];
rep(i, 26) {
if (i == type)
continue;
res[d] -= C[i] * (d + 1 - last_day[i]);
}
last_day[type] = d + 1;
if (d != D - 1)
res[d + 1] += res[d];
}
return res[D - 1];
}
int main() {
clock_t start = clock();
cin >> D;
rep(i, 26) cin >> C[i];
rep(i, D) rep(j, 26) cin >> S[i][j];
vector<int> t_old(D);
rep(i, D) t_old[i] = (i % 26) + 1;
int old_score = score(t_old);
rep(k, 1000000) {
vector<int> t_new = t_old;
int d = rand() % D, q = rand() % 26 + 1;
// cout << d << " " << q << endl;
t_new[d] = q;
if (score(t_new) > old_score)
t_old = t_new;
}
rep(i, D) cout << t_old[i] << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
typedef int64_t Int;
typedef pair<Int, Int> P;
Int D;
vector<Int> C(26);
vector<vector<Int>> S(365, vector<Int>(26));
// 最終的な満足度を返す関数
Int score(vector<int> schedule) {
vector<int> last_day(26, 0); // 各コンテストを最後に行った日
vector<Int> res(D, 0);
rep(d, D) {
int type = schedule[d] - 1; // その日に行われるコンテスト
res[d] += S[d][type];
rep(i, 26) {
if (i == type)
continue;
res[d] -= C[i] * (d + 1 - last_day[i]);
}
last_day[type] = d + 1;
if (d != D - 1)
res[d + 1] += res[d];
}
return res[D - 1];
}
int main() {
clock_t start = clock();
cin >> D;
rep(i, 26) cin >> C[i];
rep(i, D) rep(j, 26) cin >> S[i][j];
vector<int> t_old(D);
rep(i, D) t_old[i] = (i % 26) + 1;
int old_score = score(t_old);
rep(k, 10000) {
vector<int> t_new = t_old;
int d = rand() % D, q = rand() % 26 + 1;
// cout << d << " " << q << endl;
t_new[d] = q;
if (score(t_new) > old_score)
t_old = t_new;
}
rep(i, D) cout << t_old[i] << endl;
} | replace | 47 | 48 | 47 | 48 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef vector<char> VC;
typedef vector<VC> VVC;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
typedef priority_queue<int> PQGI; // 大きい順
typedef priority_queue<int, VI, greater<int>> PQLI;
typedef priority_queue<PII> PQGP;
typedef priority_queue<PII, VPII, greater<int>> PQLP;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EB emplace_back
#define PB push_back
#define PF push_front
#define POB pop_back
#define POF pop_front
#define MP make_pair
#define SZ(a) int((a).size())
#define SQ(a) ((a) * (a))
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
#define SORTR(c) sort((c).rbegin(), (c).rend())
#define LB lower_bound
#define UB upper_bound
#define NEXP next_permutation
#define FI first
#define SE second
#define Vmin(a) *min_element((a).begin(), (a).end())
#define Vmax(a) *max_element((a).begin(), (a).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORR(i, a, b) for (int i = (b - 1); i >= (a); i--)
#define REPR(i, n) FORR(i, 0, n)
#define CFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define CREP(i, n) CFOR(i, 0, n)
#define CFORR(i, a, b) for (int i = (b); i >= (a); i--)
#define CREPR(i, n) CFORR(i, 0, n)
#define BFOR(bit, a, b) for (int bit = (a); bit < (1 << (b)); ++bit)
#define BREP(bit, n) BFOR(bit, 0, n)
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = INT_MAX / 2;
const LL LINF = LLONG_MAX / 3;
const int RINF = INT_MIN / 2;
const LL RLINF = LLONG_MIN / 3;
const LL MOD = 1e9 + 7;
const LL MODD = 998244353;
const int MAX = 510000;
inline bool Eq(double a, double b) { return fabs(b - a) < EPS; }
// other
//-------------------------------------------
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define COUT(x) cout << (x) << endl
#define COUT2(x, y) cout << (x) << " " << (y) << endl
#define COUT3(x, y, z) cout << (x) << " " << (y) << " " << (z) << endl
#define PR(x) cout << (x)
#define ENDL cout << endl
#define SPACE cout << " "
#define BC(x) __builtin_popcountll(x)
VI dx = {1, 0, -1, 0, 1, 1, -1, -1};
VI dy = {0, 1, 0, -1, 1, -1, 1, -1};
VC dc = {'R', 'D', 'L', 'U'};
VS ds = {"R", "D", "L", "U", "RD", "RU", "LD", "LU"};
LL Gcd(LL a, LL b) { return __gcd(a, b); }
LL Lcm(LL a, LL b) { return a / Gcd(a, b) * b; }
LL ModPow(LL A, LL N, LL M) {
LL res = 1;
while (N > 0) {
if (N & 1)
res = res * A % M;
A = A * A % M;
N >>= 1;
}
return res;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (T &in : v)
is >> in;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < (int)v.size(); i++) {
os << v[i] << (i + 1 != v.size() ? " " : "");
}
return os;
}
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
int D;
cin >> D;
int N = 26;
VI C(N);
cin >> C;
VVI S(D, VI(N));
REP(i, D) cin >> S.at(i);
VI T(D); // cin >> T;
srand(time(NULL));
REP(i, D) T.at(i) = rand() % N + 1;
int M; // cin >> M;
M = 2e5;
int ascore = 0;
VI last(N, -1);
REP(i, D) {
int t = T.at(i) - 1;
ascore += S.at(i).at(t);
last.at(t) = i;
REP(j, N) { ascore -= (i - last.at(j)) * C.at(j); }
}
// COUT(ascore);
REP(m, M) {
int d, q; // cin >> d >> q;
d = rand() % D + 1;
q = rand() % N + 1;
int past = T.at(d - 1);
T.at(d - 1) = q;
int score = 0;
VI last(N, -1);
REP(i, D) {
int t = T.at(i) - 1;
score += S.at(i).at(t);
last.at(t) = i;
REP(j, N) { score -= (i - last.at(j)) * C.at(j); }
}
// COUT(score);
if (ascore > score) {
T.at(d - 1) = past;
} else {
ascore = score;
}
}
REP(i, D) COUT(T.at(i));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// math
//-------------------------------------------
template <class T> inline T sqr(T x) { return x * x; }
// typedef
//------------------------------------------
typedef long long LL;
typedef pair<int, int> PII;
typedef pair<LL, LL> PLL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef vector<char> VC;
typedef vector<VC> VVC;
typedef vector<PII> VPII;
typedef vector<PLL> VPLL;
typedef priority_queue<int> PQGI; // 大きい順
typedef priority_queue<int, VI, greater<int>> PQLI;
typedef priority_queue<PII> PQGP;
typedef priority_queue<PII, VPII, greater<int>> PQLP;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EB emplace_back
#define PB push_back
#define PF push_front
#define POB pop_back
#define POF pop_front
#define MP make_pair
#define SZ(a) int((a).size())
#define SQ(a) ((a) * (a))
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
#define SORTR(c) sort((c).rbegin(), (c).rend())
#define LB lower_bound
#define UB upper_bound
#define NEXP next_permutation
#define FI first
#define SE second
#define Vmin(a) *min_element((a).begin(), (a).end())
#define Vmax(a) *max_element((a).begin(), (a).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORR(i, a, b) for (int i = (b - 1); i >= (a); i--)
#define REPR(i, n) FORR(i, 0, n)
#define CFOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define CREP(i, n) CFOR(i, 0, n)
#define CFORR(i, a, b) for (int i = (b); i >= (a); i--)
#define CREPR(i, n) CFORR(i, 0, n)
#define BFOR(bit, a, b) for (int bit = (a); bit < (1 << (b)); ++bit)
#define BREP(bit, n) BFOR(bit, 0, n)
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = INT_MAX / 2;
const LL LINF = LLONG_MAX / 3;
const int RINF = INT_MIN / 2;
const LL RLINF = LLONG_MIN / 3;
const LL MOD = 1e9 + 7;
const LL MODD = 998244353;
const int MAX = 510000;
inline bool Eq(double a, double b) { return fabs(b - a) < EPS; }
// other
//-------------------------------------------
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
#define COUT(x) cout << (x) << endl
#define COUT2(x, y) cout << (x) << " " << (y) << endl
#define COUT3(x, y, z) cout << (x) << " " << (y) << " " << (z) << endl
#define PR(x) cout << (x)
#define ENDL cout << endl
#define SPACE cout << " "
#define BC(x) __builtin_popcountll(x)
VI dx = {1, 0, -1, 0, 1, 1, -1, -1};
VI dy = {0, 1, 0, -1, 1, -1, 1, -1};
VC dc = {'R', 'D', 'L', 'U'};
VS ds = {"R", "D", "L", "U", "RD", "RU", "LD", "LU"};
LL Gcd(LL a, LL b) { return __gcd(a, b); }
LL Lcm(LL a, LL b) { return a / Gcd(a, b) * b; }
LL ModPow(LL A, LL N, LL M) {
LL res = 1;
while (N > 0) {
if (N & 1)
res = res * A % M;
A = A * A % M;
N >>= 1;
}
return res;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T> istream &operator>>(istream &is, vector<T> &v) {
for (T &in : v)
is >> in;
return is;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (int i = 0; i < (int)v.size(); i++) {
os << v[i] << (i + 1 != v.size() ? " " : "");
}
return os;
}
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
cout << fixed << setprecision(12);
int D;
cin >> D;
int N = 26;
VI C(N);
cin >> C;
VVI S(D, VI(N));
REP(i, D) cin >> S.at(i);
VI T(D); // cin >> T;
srand(time(NULL));
REP(i, D) T.at(i) = rand() % N + 1;
int M; // cin >> M;
M = 150000;
int ascore = 0;
VI last(N, -1);
REP(i, D) {
int t = T.at(i) - 1;
ascore += S.at(i).at(t);
last.at(t) = i;
REP(j, N) { ascore -= (i - last.at(j)) * C.at(j); }
}
// COUT(ascore);
REP(m, M) {
int d, q; // cin >> d >> q;
d = rand() % D + 1;
q = rand() % N + 1;
int past = T.at(d - 1);
T.at(d - 1) = q;
int score = 0;
VI last(N, -1);
REP(i, D) {
int t = T.at(i) - 1;
score += S.at(i).at(t);
last.at(t) = i;
REP(j, N) { score -= (i - last.at(j)) * C.at(j); }
}
// COUT(score);
if (ascore > score) {
T.at(d - 1) = past;
} else {
ascore = score;
}
}
REP(i, D) COUT(T.at(i));
return 0;
}
| replace | 180 | 181 | 180 | 181 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define Int int64_t
using namespace std;
int D;
vector<int> c(30, 0);
vector<vector<int>> s(400, vector<int>(30, 0));
struct schedule {
int score = 0;
vector<int> contest;
vector<int> last;
schedule() { last.assign(30, 0); };
bool operator<(const schedule &s) const { return score > s.score; }
};
void input() {
cin >> D;
for (int i = 1; i <= 26; ++i) {
cin >> c[i];
}
for (int i = 1; i <= D; ++i) {
for (int j = 1; j <= 26; ++j) {
cin >> s[i][j];
}
}
}
schedule calc_score(schedule sc, int con) {
schedule ret = sc;
int day = sc.contest.size() + 1;
ret.last[con] = day;
ret.contest.push_back(con);
ret.score += s[day][con];
for (int i = 1; i <= 26; ++i) {
ret.score -= c[i] * (day - ret.last[i]);
}
return ret;
}
int main() {
constexpr int BEAM = 2500;
input();
vector<schedule> curr;
curr.emplace_back(schedule());
for (int d = 1; d <= D; ++d) {
vector<schedule> nxt;
for (auto sc : curr) {
for (int i = 1; i <= 26; ++i) {
nxt.push_back(calc_score(sc, i));
}
}
sort(nxt.begin(), nxt.end());
if (nxt.size() > BEAM) {
nxt.resize(BEAM);
}
curr = nxt;
}
// cerr << "score = " << curr[0].score << endl;
for (auto t : curr[0].contest) {
cout << t << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define Int int64_t
using namespace std;
int D;
vector<int> c(30, 0);
vector<vector<int>> s(400, vector<int>(30, 0));
struct schedule {
int score = 0;
vector<int> contest;
vector<int> last;
schedule() { last.assign(30, 0); };
bool operator<(const schedule &s) const { return score > s.score; }
};
void input() {
cin >> D;
for (int i = 1; i <= 26; ++i) {
cin >> c[i];
}
for (int i = 1; i <= D; ++i) {
for (int j = 1; j <= 26; ++j) {
cin >> s[i][j];
}
}
}
schedule calc_score(schedule sc, int con) {
schedule ret = sc;
int day = sc.contest.size() + 1;
ret.last[con] = day;
ret.contest.push_back(con);
ret.score += s[day][con];
for (int i = 1; i <= 26; ++i) {
ret.score -= c[i] * (day - ret.last[i]);
}
return ret;
}
int main() {
constexpr int BEAM = 77;
input();
vector<schedule> curr;
curr.emplace_back(schedule());
for (int d = 1; d <= D; ++d) {
vector<schedule> nxt;
for (auto sc : curr) {
for (int i = 1; i <= 26; ++i) {
nxt.push_back(calc_score(sc, i));
}
}
sort(nxt.begin(), nxt.end());
if (nxt.size() > BEAM) {
nxt.resize(BEAM);
}
curr = nxt;
}
// cerr << "score = " << curr[0].score << endl;
for (auto t : curr[0].contest) {
cout << t << endl;
}
return 0;
}
| replace | 45 | 46 | 45 | 46 | TLE |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.