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("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimization("Ofast")
#pragma GCC optimization("unroll-loops")
using namespace std;
int D;
int c[27], s[400][27];
int L[27];
int last[27];
long long ANS = 0;
long long ans = 0;
int T[27];
long long test() {
for (int i = 1; i <= 26; i++) {
last[i] = 0;
}
long long ans = 0;
for (int i = 1; i <= D; i++) {
ans += s[i][T[i]];
last[T[i]] = i;
for (int j = 1; j <= 26; j++) {
ans -= c[j] * (i - last[j]);
}
}
return ans;
}
int main() {
auto begin_time = chrono::steady_clock::now().time_since_epoch().count();
scanf("%d", &D);
for (int i = 1; i <= 26; i++)
scanf("%d", &c[i]);
for (int i = 1; i <= D; i++) {
for (int j = 1; j <= 26; j++)
scanf("%d", &s[i][j]);
}
for (int i = 1; i <= D; i++) {
int b1 = -1;
long long ok = 0;
for (int t = 1; t <= 26; t++) {
for (int x = 1; x <= 26; x++) {
for (int y = 1; y <= 26; y++) {
ans = ANS;
for (int j = 1; j <= 26; j++) {
last[j] = L[j];
}
ans += s[i][t];
last[t] = i;
for (int j = 1; j <= 26; j++) {
ans -= c[j] * (i - last[j]);
}
if (i != D) {
ans += s[i + 1][x];
last[x] = i + 1;
for (int j = 1; j <= 26; j++) {
ans -= c[j] * (i + 1 - last[j]);
}
}
if (i < D - 1) {
ans += s[i + 2][y];
last[y] = i + 2;
for (int j = 1; j <= 26; j++) {
ans -= c[j] * (i + 2 - last[j]);
}
}
if (b1 == -1 || ans > ok) {
b1 = t;
ok = ans;
}
}
}
// printf("for %d: %lld\n",t,ans);
}
T[i] = b1;
ANS += s[i][b1];
L[b1] = i;
for (int j = 1; j <= 26; j++) {
ANS -= c[j] * (i - L[j]);
}
// printf("%d\n",b1);
// printf("score %lld\n",ANS);
}
long long best = ANS;
// printf("from %lld\n",best);
srand(time(NULL));
while (chrono::steady_clock::now().time_since_epoch().count() - begin_time <
1950000000) {
int rD = rand() % 365 + 1;
int rV = rand() % 26 + 1;
int oldV = T[rD];
T[rD] = rV;
long long cur = test();
if (cur > best) {
best = cur;
} else {
T[rD] = oldV;
}
}
// printf("to %lld\n",best);
for (int i = 1; i <= D; i++) {
printf("%d\n", T[i]);
}
}
| #include <bits/stdc++.h>
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
#pragma GCC optimization("Ofast")
#pragma GCC optimization("unroll-loops")
using namespace std;
int D;
int c[27], s[400][27];
int L[27];
int last[27];
long long ANS = 0;
long long ans = 0;
int T[400];
long long test() {
for (int i = 1; i <= 26; i++) {
last[i] = 0;
}
long long ans = 0;
for (int i = 1; i <= D; i++) {
ans += s[i][T[i]];
last[T[i]] = i;
for (int j = 1; j <= 26; j++) {
ans -= c[j] * (i - last[j]);
}
}
return ans;
}
int main() {
auto begin_time = chrono::steady_clock::now().time_since_epoch().count();
scanf("%d", &D);
for (int i = 1; i <= 26; i++)
scanf("%d", &c[i]);
for (int i = 1; i <= D; i++) {
for (int j = 1; j <= 26; j++)
scanf("%d", &s[i][j]);
}
for (int i = 1; i <= D; i++) {
int b1 = -1;
long long ok = 0;
for (int t = 1; t <= 26; t++) {
for (int x = 1; x <= 26; x++) {
for (int y = 1; y <= 26; y++) {
ans = ANS;
for (int j = 1; j <= 26; j++) {
last[j] = L[j];
}
ans += s[i][t];
last[t] = i;
for (int j = 1; j <= 26; j++) {
ans -= c[j] * (i - last[j]);
}
if (i != D) {
ans += s[i + 1][x];
last[x] = i + 1;
for (int j = 1; j <= 26; j++) {
ans -= c[j] * (i + 1 - last[j]);
}
}
if (i < D - 1) {
ans += s[i + 2][y];
last[y] = i + 2;
for (int j = 1; j <= 26; j++) {
ans -= c[j] * (i + 2 - last[j]);
}
}
if (b1 == -1 || ans > ok) {
b1 = t;
ok = ans;
}
}
}
// printf("for %d: %lld\n",t,ans);
}
T[i] = b1;
ANS += s[i][b1];
L[b1] = i;
for (int j = 1; j <= 26; j++) {
ANS -= c[j] * (i - L[j]);
}
// printf("%d\n",b1);
// printf("score %lld\n",ANS);
}
long long best = ANS;
// printf("from %lld\n",best);
srand(time(NULL));
while (chrono::steady_clock::now().time_since_epoch().count() - begin_time <
1950000000) {
int rD = rand() % 365 + 1;
int rV = rand() % 26 + 1;
int oldV = T[rD];
T[rD] = rV;
long long cur = test();
if (cur > best) {
best = cur;
} else {
T[rD] = oldV;
}
}
// printf("to %lld\n",best);
for (int i = 1; i <= D; i++) {
printf("%d\n", T[i]);
}
}
| replace | 11 | 12 | 11 | 12 | -11 | |
p02618 | C++ | Runtime Error | #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <iostream> // cout, endl, cin
#include <math.h> // sqrt
#include <string> // string, to_string, stoi
#include <vector> // vector
using namespace std;
typedef long long ll;
int main() {
ll D;
cin >> D;
vector<ll> c(26);
for (int i = 0; i < 26; i++) {
cin >> c.at(i);
}
vector<vector<ll>> s(D, vector<ll>(26));
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++) {
cin >> s.at(i).at(j);
}
}
vector<ll> v(26, 0);
vector<ll> last;
for (ll i = 0; i < D; i++) {
ll pointd = 0;
int vd = 0;
for (int j = 0; j < 26; j++) {
last = v;
last.at(j) = i + 1;
ll sumd = 0;
for (int k = 0; k < 26; k++) {
if (k == j) {
sumd += s.at(i).at(k);
} else {
sumd -= (i - last.at(k) + 1) * c.at(k);
}
}
if (pointd < sumd) {
vd = j + 1;
}
pointd = max(pointd, sumd);
}
v.at(vd - 1) = i + 1;
cout << vd << endl;
}
}
| #include <algorithm> // min, max, swap, sort, reverse, lower_bound, upper_bound
#include <iostream> // cout, endl, cin
#include <math.h> // sqrt
#include <string> // string, to_string, stoi
#include <vector> // vector
using namespace std;
typedef long long ll;
int main() {
ll D;
cin >> D;
vector<ll> c(26);
for (int i = 0; i < 26; i++) {
cin >> c.at(i);
}
vector<vector<ll>> s(D, vector<ll>(26));
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++) {
cin >> s.at(i).at(j);
}
}
vector<ll> v(26, 0);
vector<ll> last;
for (ll i = 0; i < D; i++) {
ll pointd = 0;
int vd = 0;
for (int j = 0; j < 26; j++) {
last = v;
last.at(j) = i + 1;
ll sumd = 0;
for (int k = 0; k < 26; k++) {
if (k == j) {
sumd += s.at(i).at(k);
} else {
sumd -= (i - last.at(k) + 1) * c.at(k);
}
}
if (pointd < sumd) {
vd = j + 1;
}
if (j == 0) {
pointd = sumd;
vd = 1;
} else {
pointd = max(pointd, sumd);
}
}
v.at(vd - 1) = i + 1;
cout << vd << endl;
}
}
| replace | 40 | 41 | 40 | 46 | 0 | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int, int>;
#define rep(i, n) for (ll i = 0; i < (ll)n; i++)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
int main() {
srand((unsigned)time(NULL));
int d;
int res = 0;
cin >> d;
vector<int> c(26);
rep(i, 26) cin >> c[i];
vector<vector<int>> v(d, vector<int>(26));
vector<int> contest(d, 0);
vector<int> last(26, 0);
vector<int> satisfy(26, 0);
rep(i, d) rep(j, 26) {
int x;
cin >> x;
v[i][j] = x;
}
{
int j = d;
for (int i = 0; j; i++) {
contest[d - j] = (i % 26) + 1;
j--;
}
}
for (int i = 1; i <= d; i++) {
// rep(j,26)if(v[i-1][contest[i-1]] < v[i-1][j])contest[i-1] = j;
last[contest[i - 1]] = i;
res += v[i - 1][contest[i - 1]];
rep(j, 26) res -= c[j] * (i - last[j]), satisfy[j] += c[j] * (i - last[j]);
}
while (1.0 * clock() / CLOCKS_PER_SEC <= 1.7) {
// int now_time = clock();
// if(1.0*now_time/CLOCKS_PER_SEC > 1.7)break;
int day = rand() % d, pos = rand() % 26;
vector<int> new_contest = contest;
int res_ = res;
int pre = new_contest[day];
res_ += satisfy[pos];
res_ += satisfy[pre];
res_ -= v[day][pre];
res_ += v[day][pos];
int pos_satisfy = 0, pre_satisfy = 0;
last[pos] = last[pre] = 0;
new_contest[day] = pos;
for (int i = 1; i <= d; i++)
last[pos] = (new_contest[i - 1] == pos ? last[pos] = i : last[pos]),
pos_satisfy += c[pos] * (i - last[pos]);
for (int i = 1; i <= d; i++)
last[pre] = (new_contest[i - 1] == pre ? last[pre] = i : last[pre]),
pre_satisfy += c[pre] * (i - last[pre]);
res_ -= (satisfy[pos] + satisfy[pre]);
if (res < res_) {
res = res_;
contest = new_contest;
satisfy[pre] = pre_satisfy;
satisfy[pos] = pos_satisfy;
}
}
rep(i, d) cout << contest[i] + 1 << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using P = pair<int, int>;
#define rep(i, n) for (ll i = 0; i < (ll)n; i++)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
int main() {
srand((unsigned)time(NULL));
int d;
int res = 0;
cin >> d;
vector<int> c(26);
rep(i, 26) cin >> c[i];
vector<vector<int>> v(d, vector<int>(26));
vector<int> contest(d, 0);
vector<int> last(26, 0);
vector<int> satisfy(26, 0);
rep(i, d) rep(j, 26) {
int x;
cin >> x;
v[i][j] = x;
}
{
int j = d;
for (int i = 0; j; i++) {
contest[d - j] = (i % 26);
j--;
}
}
for (int i = 1; i <= d; i++) {
// rep(j,26)if(v[i-1][contest[i-1]] < v[i-1][j])contest[i-1] = j;
last[contest[i - 1]] = i;
res += v[i - 1][contest[i - 1]];
rep(j, 26) res -= c[j] * (i - last[j]), satisfy[j] += c[j] * (i - last[j]);
}
while (1.0 * clock() / CLOCKS_PER_SEC <= 1.7) {
// int now_time = clock();
// if(1.0*now_time/CLOCKS_PER_SEC > 1.7)break;
int day = rand() % d, pos = rand() % 26;
vector<int> new_contest = contest;
int res_ = res;
int pre = new_contest[day];
res_ += satisfy[pos];
res_ += satisfy[pre];
res_ -= v[day][pre];
res_ += v[day][pos];
int pos_satisfy = 0, pre_satisfy = 0;
last[pos] = last[pre] = 0;
new_contest[day] = pos;
for (int i = 1; i <= d; i++)
last[pos] = (new_contest[i - 1] == pos ? last[pos] = i : last[pos]),
pos_satisfy += c[pos] * (i - last[pos]);
for (int i = 1; i <= d; i++)
last[pre] = (new_contest[i - 1] == pre ? last[pre] = i : last[pre]),
pre_satisfy += c[pre] * (i - last[pre]);
res_ -= (satisfy[pos] + satisfy[pre]);
if (res < res_) {
res = res_;
contest = new_contest;
satisfy[pre] = pre_satisfy;
satisfy[pos] = pos_satisfy;
}
}
rep(i, d) cout << contest[i] + 1 << endl;
return 0;
}
| replace | 30 | 31 | 30 | 31 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
typedef unsigned long long ull;
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#define LINF 9223300000000000000
#define LINF2 1223300000000000000
#define LINF3 1000000000000
#define INF 2140000000
const long long MOD = 1000000007;
// const long long MOD = 998244353;
using namespace std;
int D;
int c[26];
vector<int> s;
void input() {
scanf("%d", &D);
s.resize(D * 26);
int i, j;
for (i = 0; i < 26; i++) {
scanf("%d", &c[i]);
}
#define P(i, j) ((i)*26 + (j))
for (i = 0; i < D; i++) {
for (j = 0; j < 26; j++) {
scanf("%d", &s[P(i, j)]);
}
}
return;
}
void calc(const vector<int> &t, vector<int> &ans) {
vector<int> last(26, -1);
int sum = 0;
int i, k;
for (i = 0; i < D; i++) {
sum += s[P(i, t[i])];
last[t[i]] = i;
for (k = 0; k < 26; k++) {
sum -= c[k] * (i - last[k]);
}
ans[i] = sum;
}
return;
}
void sel0(vector<int> &t) { return; }
void sel(vector<int> &t) {
vector<int> last(26, -1);
int i, j, k;
for (i = 0; i < D; i++) {
int max = -INF;
int maxj = -1;
for (j = 0; j < 26; j++) {
int sum0 = s[P(i, j)];
for (k = 0; k < 26; k++) {
if (k != j)
sum0 -= c[k] * (i - last[k]);
}
if (max < sum0) {
max = sum0;
maxj = j;
}
}
t[i] = maxj;
last[maxj] = i;
}
return;
}
void query(vector<int> &t, vector<set<int>> &z, int d, int q, int &ans) {
int diff0 = 0, diff1 = 0;
if (t[d] != q) {
{
int id = t[d];
auto it = z[id].lower_bound(d);
auto it2 = it;
int prev = -1, next = D;
if (it2 != z[id].begin()) {
it2--;
prev = *it2;
}
auto it3 = it;
it3++;
if (it3 != z[id].end()) {
next = *it3;
}
int k0 = d - prev, k1 = next - d, k2 = next - prev;
diff0 = k2 * (k2 - 1) / 2 - k0 * (k0 - 1) / 2 - k1 * (k1 - 1) / 2;
}
{
int id = q;
auto it = z[id].lower_bound(d);
auto it2 = it;
int prev = -1, next = D;
if (it2 != z[id].begin()) {
it2--;
prev = *it2;
}
if (it != z[id].end()) {
next = *it;
}
int k0 = d - prev, k1 = next - d, k2 = next - prev;
diff1 = k2 * (k2 - 1) / 2 - k0 * (k0 - 1) / 2 - k1 * (k1 - 1) / 2;
}
}
int diff = -c[t[d]] * diff0 + c[q] * diff1 - s[P(d, t[d])] + s[P(d, q)];
if (diff > 0) {
ans += diff;
z[t[d]].erase(d);
z[q].insert(d);
t[d] = q;
}
return;
}
int Dice(int num) { return rand() % num; }
void solve() {
input();
int i;
#if 0
vector<int> t(D);
for (i = 0; i < D; i++) {
scanf("%d", &t[i]); t[i]--;
}
#else
vector<int> t(D);
// sel(t);
sel0(t);
#endif
vector<int> ans0(D);
calc(t, ans0);
int ans = ans0[D - 1];
vector<set<int>> z(26);
for (i = 0; i < D; i++) {
z[t[i]].insert(i);
}
srand((unsigned int)time(NULL));
int m = 500000;
for (i = 0; i < m; i++) {
vector<int> ts = t;
vector<set<int>> zs = z;
int anss = ans;
int j;
for (j = 0; j < 4; j++) {
int d = Dice(D), q = Dice(26);
query(t, z, d, q, ans);
// printf("%d\n", ans);
}
if (anss <= ans) {
t.swap(ts);
z.swap(zs);
ans = anss;
}
}
m = 5000000;
for (i = 0; i < m; i++) {
int d = Dice(D), q = Dice(26);
query(t, z, d, q, ans);
// printf("%d\n", ans);
}
#if 1
for (i = 0; i < D; i++) {
printf("%d\n", t[i] + 1);
}
#endif
#ifdef _DEBUG
{
vector<int> ans0(D);
calc(t, ans0);
printf("%d\n", ans0[D - 1]);
}
#endif
return;
}
int main(int argc, char *argv[]) {
#if 1
solve();
#else
int T;
scanf("%d", &T);
int t;
for (t = 0; t < T; t++) {
// printf("Case #%d: ", t+1);
solve();
}
#endif
return 0;
}
| #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#pragma warning(disable : 4996)
typedef long long ll;
typedef unsigned long long ull;
#define MIN(a, b) ((a) > (b) ? (b) : (a))
#define MAX(a, b) ((a) < (b) ? (b) : (a))
#define LINF 9223300000000000000
#define LINF2 1223300000000000000
#define LINF3 1000000000000
#define INF 2140000000
const long long MOD = 1000000007;
// const long long MOD = 998244353;
using namespace std;
int D;
int c[26];
vector<int> s;
void input() {
scanf("%d", &D);
s.resize(D * 26);
int i, j;
for (i = 0; i < 26; i++) {
scanf("%d", &c[i]);
}
#define P(i, j) ((i)*26 + (j))
for (i = 0; i < D; i++) {
for (j = 0; j < 26; j++) {
scanf("%d", &s[P(i, j)]);
}
}
return;
}
void calc(const vector<int> &t, vector<int> &ans) {
vector<int> last(26, -1);
int sum = 0;
int i, k;
for (i = 0; i < D; i++) {
sum += s[P(i, t[i])];
last[t[i]] = i;
for (k = 0; k < 26; k++) {
sum -= c[k] * (i - last[k]);
}
ans[i] = sum;
}
return;
}
void sel0(vector<int> &t) { return; }
void sel(vector<int> &t) {
vector<int> last(26, -1);
int i, j, k;
for (i = 0; i < D; i++) {
int max = -INF;
int maxj = -1;
for (j = 0; j < 26; j++) {
int sum0 = s[P(i, j)];
for (k = 0; k < 26; k++) {
if (k != j)
sum0 -= c[k] * (i - last[k]);
}
if (max < sum0) {
max = sum0;
maxj = j;
}
}
t[i] = maxj;
last[maxj] = i;
}
return;
}
void query(vector<int> &t, vector<set<int>> &z, int d, int q, int &ans) {
int diff0 = 0, diff1 = 0;
if (t[d] != q) {
{
int id = t[d];
auto it = z[id].lower_bound(d);
auto it2 = it;
int prev = -1, next = D;
if (it2 != z[id].begin()) {
it2--;
prev = *it2;
}
auto it3 = it;
it3++;
if (it3 != z[id].end()) {
next = *it3;
}
int k0 = d - prev, k1 = next - d, k2 = next - prev;
diff0 = k2 * (k2 - 1) / 2 - k0 * (k0 - 1) / 2 - k1 * (k1 - 1) / 2;
}
{
int id = q;
auto it = z[id].lower_bound(d);
auto it2 = it;
int prev = -1, next = D;
if (it2 != z[id].begin()) {
it2--;
prev = *it2;
}
if (it != z[id].end()) {
next = *it;
}
int k0 = d - prev, k1 = next - d, k2 = next - prev;
diff1 = k2 * (k2 - 1) / 2 - k0 * (k0 - 1) / 2 - k1 * (k1 - 1) / 2;
}
}
int diff = -c[t[d]] * diff0 + c[q] * diff1 - s[P(d, t[d])] + s[P(d, q)];
if (diff > 0) {
ans += diff;
z[t[d]].erase(d);
z[q].insert(d);
t[d] = q;
}
return;
}
int Dice(int num) { return rand() % num; }
void solve() {
input();
int i;
#if 0
vector<int> t(D);
for (i = 0; i < D; i++) {
scanf("%d", &t[i]); t[i]--;
}
#else
vector<int> t(D);
// sel(t);
sel0(t);
#endif
vector<int> ans0(D);
calc(t, ans0);
int ans = ans0[D - 1];
vector<set<int>> z(26);
for (i = 0; i < D; i++) {
z[t[i]].insert(i);
}
srand((unsigned int)time(NULL));
int m = 10000;
for (i = 0; i < m; i++) {
vector<int> ts = t;
vector<set<int>> zs = z;
int anss = ans;
int j;
for (j = 0; j < 4; j++) {
int d = Dice(D), q = Dice(26);
query(t, z, d, q, ans);
// printf("%d\n", ans);
}
if (anss <= ans) {
t.swap(ts);
z.swap(zs);
ans = anss;
}
}
m = 5000000;
for (i = 0; i < m; i++) {
int d = Dice(D), q = Dice(26);
query(t, z, d, q, ans);
// printf("%d\n", ans);
}
#if 1
for (i = 0; i < D; i++) {
printf("%d\n", t[i] + 1);
}
#endif
#ifdef _DEBUG
{
vector<int> ans0(D);
calc(t, ans0);
printf("%d\n", ans0[D - 1]);
}
#endif
return;
}
int main(int argc, char *argv[]) {
#if 1
solve();
#else
int T;
scanf("%d", &T);
int t;
for (t = 0; t < T; t++) {
// printf("Case #%d: ", t+1);
solve();
}
#endif
return 0;
}
| replace | 168 | 169 | 168 | 169 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
/*==============変数宣言==============*/
int N;
const int M = 26;
int n;
int m = M;
int c[30];
int s[400][30];
void input() {
scanf("%d", &N);
n = N;
for (int i = 0; i < M; i++)
scanf("%d", &c[i]);
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
scanf("%d", &s[i][j]);
return;
}
/*================乱数================*/
/*====================================*/
int init() { input(); }
void output(int ans[]) {
for (int i = 0; i < n; i++) {
printf("%d\n", ans[i] + 1);
}
}
int main() {
init();
int ans[500];
for (int i = 0; i < n; i++) {
ans[i] = i % 26;
}
output(ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
/*==============変数宣言==============*/
int N;
const int M = 26;
int n;
int m = M;
int c[30];
int s[400][30];
void input() {
scanf("%d", &N);
n = N;
for (int i = 0; i < M; i++)
scanf("%d", &c[i]);
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
scanf("%d", &s[i][j]);
return;
}
/*================乱数================*/
/*====================================*/
void init() {
input();
return;
}
void output(int ans[]) {
for (int i = 0; i < n; i++) {
printf("%d\n", ans[i] + 1);
}
}
int main() {
init();
int ans[500];
for (int i = 0; i < n; i++) {
ans[i] = i % 26;
}
output(ans);
return 0;
} | replace | 29 | 30 | 29 | 33 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ALL(x) (x).begin(), (x).end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
typedef pair<int, int> PI;
typedef pair<int, pair<int, int>> PII;
static const int INF = 1010000000000000017LL;
static const double eps = 1e-12;
static const double pi = 3.14159265358979323846;
static const int dx[4] = {1, -1, 0, 0};
static const int dy[4] = {0, 0, 1, -1};
static const int ddx[8] = {1, -1, 0, 0, 1, 1, -1, -1};
static const int ddy[8] = {0, 0, 1, -1, 1, -1, 1, -1};
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;
}
const int MAX_D = 365;
const int MAX_type = 26;
const int BeamWidth = 300;
int D;
int c[MAX_D + 5];
int s[MAX_D + 5][MAX_type + 5];
struct State {
vector<int> contest;
vector<int> last;
int day;
int score;
State() {
day = 1;
score = 0;
last.assign(MAX_type + 5, 0);
}
void update(int type) {
contest.push_back(type);
last[type] = day;
score += s[day][type];
for (int i = 1; i <= MAX_type; ++i) {
score -= c[i] * (day - last[i]);
}
day++;
}
State nextState(int type) {
State next;
next = *this;
next.update(type);
return next;
}
};
bool operator<(const State &state1, const State &state2) {
return state1.score < state2.score;
};
bool operator>(const State &state1, const State &state2) {
return state1.score > state2.score;
};
State beamsearch() {
int D_ = D;
priority_queue<State, vector<State>, greater<State>> nowpq;
for (int type = 1; type <= MAX_type; ++type) {
State s;
nowpq.push(s.nextState(type));
}
while (nowpq.size() > BeamWidth)
nowpq.pop();
D_--;
while (D_--) {
priority_queue<State, vector<State>, greater<State>> nextpq;
while (nowpq.size()) {
State now = nowpq.top();
nowpq.pop();
for (int type = 1; type <= MAX_type; ++type) {
nextpq.push(now.nextState(type));
}
}
while (nextpq.size() > BeamWidth)
nextpq.pop();
nowpq = nextpq;
}
while (nowpq.size() > 1)
nowpq.pop();
State ret = nowpq.top();
return ret;
}
void input() {
cin >> D;
for (int i = 1; i <= MAX_type; ++i)
cin >> c[i];
for (int i = 1; i <= D; ++i) {
for (int j = 1; j <= MAX_type; ++j) {
cin >> s[i][j];
}
}
}
signed main() {
input();
auto res = beamsearch();
for (auto u : res.contest) {
cout << u << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ALL(x) (x).begin(), (x).end()
#define MAX(x) *max_element(ALL(x))
#define MIN(x) *min_element(ALL(x))
typedef pair<int, int> PI;
typedef pair<int, pair<int, int>> PII;
static const int INF = 1010000000000000017LL;
static const double eps = 1e-12;
static const double pi = 3.14159265358979323846;
static const int dx[4] = {1, -1, 0, 0};
static const int dy[4] = {0, 0, 1, -1};
static const int ddx[8] = {1, -1, 0, 0, 1, 1, -1, -1};
static const int ddy[8] = {0, 0, 1, -1, 1, -1, 1, -1};
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;
}
const int MAX_D = 365;
const int MAX_type = 26;
const int BeamWidth = 200;
int D;
int c[MAX_D + 5];
int s[MAX_D + 5][MAX_type + 5];
struct State {
vector<int> contest;
vector<int> last;
int day;
int score;
State() {
day = 1;
score = 0;
last.assign(MAX_type + 5, 0);
}
void update(int type) {
contest.push_back(type);
last[type] = day;
score += s[day][type];
for (int i = 1; i <= MAX_type; ++i) {
score -= c[i] * (day - last[i]);
}
day++;
}
State nextState(int type) {
State next;
next = *this;
next.update(type);
return next;
}
};
bool operator<(const State &state1, const State &state2) {
return state1.score < state2.score;
};
bool operator>(const State &state1, const State &state2) {
return state1.score > state2.score;
};
State beamsearch() {
int D_ = D;
priority_queue<State, vector<State>, greater<State>> nowpq;
for (int type = 1; type <= MAX_type; ++type) {
State s;
nowpq.push(s.nextState(type));
}
while (nowpq.size() > BeamWidth)
nowpq.pop();
D_--;
while (D_--) {
priority_queue<State, vector<State>, greater<State>> nextpq;
while (nowpq.size()) {
State now = nowpq.top();
nowpq.pop();
for (int type = 1; type <= MAX_type; ++type) {
nextpq.push(now.nextState(type));
}
}
while (nextpq.size() > BeamWidth)
nextpq.pop();
nowpq = nextpq;
}
while (nowpq.size() > 1)
nowpq.pop();
State ret = nowpq.top();
return ret;
}
void input() {
cin >> D;
for (int i = 1; i <= MAX_type; ++i)
cin >> c[i];
for (int i = 1; i <= D; ++i) {
for (int j = 1; j <= MAX_type; ++j) {
cin >> s[i][j];
}
}
}
signed main() {
input();
auto res = beamsearch();
for (auto u : res.contest) {
cout << u << endl;
}
} | replace | 36 | 37 | 36 | 37 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Edge = int;
using Graph = vector<vector<Edge>>;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
const ll MOD = 1000000007;
const ll nmax = 8;
const ll INF = 1e13;
const int MAX = 510000;
bool graph[nmax][nmax];
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
vector<vector<ll>> dist = vector<vector<ll>>(nmax, vector<ll>(nmax, INF));
struct SegmentTree {
private:
ll n;
vector<ll> node;
public:
SegmentTree(vector<ll> v) {
ll sz = v.size();
n = 1;
while (n < sz) {
n *= 2;
}
node.resize(2 * n - 1, INF);
for (ll i = 0; i < sz; i++) {
node[i + n - 1] = v[i];
}
for (ll i = n - 2; i >= 0; i--) {
node[i] = min(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(ll x, ll val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = min(node[2 * x + 1], node[2 * x + 2]);
}
}
// findは半開区間で考える
ll find(ll a, ll b, ll k = 0, ll l = 0, ll r = -1) {
if (r < 0)
r = n;
if (r <= a || b <= l)
return INF;
if (a <= l && r <= b)
return node[k];
ll vl = find(a, b, 2 * k + 1, l, (l + r) / 2);
ll vr = find(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
void warshall_floyd(ll n) {
for (size_t i = 0; i < n; i++) {
for (size_t j = 0; j < n; j++) {
for (size_t k = 0; k < n; k++) {
dist[j][k] = min(dist[j][k], dist[j][i] + dist[i][k]);
}
}
}
}
class UnionFind {
public:
vector<ll> Parent;
UnionFind(ll N) { Parent = vector<ll>(N, -1); }
ll find(ll A) {
if (Parent[A] < 0)
return A;
return Parent[A] = find(Parent[A]);
}
ll size(ll A) { return -Parent[find(A)]; }
bool Union(ll A, ll B) {
A = find(A);
B = find(B);
if (A == B) {
return false;
}
if (size(A) < size(B))
swap(A, B);
Parent[A] += Parent[B];
Parent[B] = A;
return true;
}
};
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;
}
ll mulMod(ll a, ll b) { return (((a % MOD) * (b % MOD)) % MOD); }
ll powMod(ll a, ll p) {
if (p == 0) {
return 1;
} else if (p % 2 == 0) {
ll half = powMod(a, p / 2);
return mulMod(half, half);
} else {
return mulMod(powMod(a, p - 1), a);
}
}
ll ceil(ll a, ll b) { return (a + b - 1) / b; }
vector<ll> tsort(Graph G) {
ll N = G.size();
vector<ll> in(N);
for (auto &&edges : G) {
for (auto &&edge : edges) {
in[edge]++;
}
}
queue<int> que;
for (int i = 0; i < N; i++) {
if (in[i] == 0) {
que.push(i);
}
}
int cnt = 0;
vector<ll> ans;
while (!que.empty()) {
int v = que.front();
que.pop();
ans.push_back(v);
for (auto &&next : G[v]) {
in[next]--;
if (in[next] == 0) {
que.push(next);
}
}
}
return ans;
}
long long D;
std::vector<long long> c(26);
std::vector<std::vector<long long>> s(365, std::vector<long long>(26));
vector<ll> last(26, -1);
ll scoring(ll day, ll contest) {
ll score = 0;
vector<ll> tmplast(26);
tmplast = last;
score += s[day][contest];
tmplast[contest] = day;
ll minus = 0;
for (int j = 0; j < 26; j++) {
minus += c[j] * (day - tmplast[j]);
}
score -= minus;
return score;
}
int main() {
scanf("%lld", &D);
for (int i = 0; i < 26; i++) {
scanf("%lld", &c[i]);
}
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++) {
scanf("%lld", &s[i][j]);
}
}
vector<ll> ans(D);
ll sum_score = 0;
for (int day = 0; day < D; day++) {
ll max_score = -INF;
ll tmp = 0;
for (int contest = 0; contest < 26; contest++) {
ll score = scoring(day, contest);
if (max_score < score) {
tmp = contest;
max_score = score;
}
}
ans[day] = tmp + 1;
last[day] = tmp;
}
for (int i = 0; i < D; i++) {
cout << ans[i] << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Edge = int;
using Graph = vector<vector<Edge>>;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
const ll MOD = 1000000007;
const ll nmax = 8;
const ll INF = 1e13;
const int MAX = 510000;
bool graph[nmax][nmax];
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
vector<vector<ll>> dist = vector<vector<ll>>(nmax, vector<ll>(nmax, INF));
struct SegmentTree {
private:
ll n;
vector<ll> node;
public:
SegmentTree(vector<ll> v) {
ll sz = v.size();
n = 1;
while (n < sz) {
n *= 2;
}
node.resize(2 * n - 1, INF);
for (ll i = 0; i < sz; i++) {
node[i + n - 1] = v[i];
}
for (ll i = n - 2; i >= 0; i--) {
node[i] = min(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(ll x, ll val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = min(node[2 * x + 1], node[2 * x + 2]);
}
}
// findは半開区間で考える
ll find(ll a, ll b, ll k = 0, ll l = 0, ll r = -1) {
if (r < 0)
r = n;
if (r <= a || b <= l)
return INF;
if (a <= l && r <= b)
return node[k];
ll vl = find(a, b, 2 * k + 1, l, (l + r) / 2);
ll vr = find(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
void warshall_floyd(ll n) {
for (size_t i = 0; i < n; i++) {
for (size_t j = 0; j < n; j++) {
for (size_t k = 0; k < n; k++) {
dist[j][k] = min(dist[j][k], dist[j][i] + dist[i][k]);
}
}
}
}
class UnionFind {
public:
vector<ll> Parent;
UnionFind(ll N) { Parent = vector<ll>(N, -1); }
ll find(ll A) {
if (Parent[A] < 0)
return A;
return Parent[A] = find(Parent[A]);
}
ll size(ll A) { return -Parent[find(A)]; }
bool Union(ll A, ll B) {
A = find(A);
B = find(B);
if (A == B) {
return false;
}
if (size(A) < size(B))
swap(A, B);
Parent[A] += Parent[B];
Parent[B] = A;
return true;
}
};
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;
}
ll mulMod(ll a, ll b) { return (((a % MOD) * (b % MOD)) % MOD); }
ll powMod(ll a, ll p) {
if (p == 0) {
return 1;
} else if (p % 2 == 0) {
ll half = powMod(a, p / 2);
return mulMod(half, half);
} else {
return mulMod(powMod(a, p - 1), a);
}
}
ll ceil(ll a, ll b) { return (a + b - 1) / b; }
vector<ll> tsort(Graph G) {
ll N = G.size();
vector<ll> in(N);
for (auto &&edges : G) {
for (auto &&edge : edges) {
in[edge]++;
}
}
queue<int> que;
for (int i = 0; i < N; i++) {
if (in[i] == 0) {
que.push(i);
}
}
int cnt = 0;
vector<ll> ans;
while (!que.empty()) {
int v = que.front();
que.pop();
ans.push_back(v);
for (auto &&next : G[v]) {
in[next]--;
if (in[next] == 0) {
que.push(next);
}
}
}
return ans;
}
long long D;
std::vector<long long> c(26);
std::vector<std::vector<long long>> s(365, std::vector<long long>(26));
vector<ll> last(26, -1);
ll scoring(ll day, ll contest) {
ll score = 0;
vector<ll> tmplast(26);
tmplast = last;
score += s[day][contest];
tmplast[contest] = day;
ll minus = 0;
for (int j = 0; j < 26; j++) {
minus += c[j] * (day - tmplast[j]);
}
score -= minus;
return score;
}
int main() {
scanf("%lld", &D);
for (int i = 0; i < 26; i++) {
scanf("%lld", &c[i]);
}
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++) {
scanf("%lld", &s[i][j]);
}
}
vector<ll> ans(D);
ll sum_score = 0;
for (int day = 0; day < D; day++) {
ll max_score = -INF;
ll tmp = 0;
for (int contest = 0; contest < 26; contest++) {
ll score = scoring(day, contest);
if (max_score < score) {
tmp = contest;
max_score = score;
}
}
ans[day] = tmp + 1;
last[tmp] = day;
}
for (int i = 0; i < D; i++) {
cout << ans[i] << endl;
}
return 0;
}
| replace | 220 | 221 | 220 | 221 | 0 | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Edge = int;
using Graph = vector<vector<Edge>>;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
const ll MOD = 1000000007;
const ll nmax = 8;
const ll INF = 1e13;
const int MAX = 510000;
bool graph[nmax][nmax];
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
vector<vector<ll>> dist = vector<vector<ll>>(nmax, vector<ll>(nmax, INF));
struct SegmentTree {
private:
ll n;
vector<ll> node;
public:
SegmentTree(vector<ll> v) {
ll sz = v.size();
n = 1;
while (n < sz) {
n *= 2;
}
node.resize(2 * n - 1, INF);
for (ll i = 0; i < sz; i++) {
node[i + n - 1] = v[i];
}
for (ll i = n - 2; i >= 0; i--) {
node[i] = min(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(ll x, ll val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = min(node[2 * x + 1], node[2 * x + 2]);
}
}
// findは半開区間で考える
ll find(ll a, ll b, ll k = 0, ll l = 0, ll r = -1) {
if (r < 0)
r = n;
if (r <= a || b <= l)
return INF;
if (a <= l && r <= b)
return node[k];
ll vl = find(a, b, 2 * k + 1, l, (l + r) / 2);
ll vr = find(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
void warshall_floyd(ll n) {
for (size_t i = 0; i < n; i++) {
for (size_t j = 0; j < n; j++) {
for (size_t k = 0; k < n; k++) {
dist[j][k] = min(dist[j][k], dist[j][i] + dist[i][k]);
}
}
}
}
class UnionFind {
public:
vector<ll> Parent;
UnionFind(ll N) { Parent = vector<ll>(N, -1); }
ll find(ll A) {
if (Parent[A] < 0)
return A;
return Parent[A] = find(Parent[A]);
}
ll size(ll A) { return -Parent[find(A)]; }
bool Union(ll A, ll B) {
A = find(A);
B = find(B);
if (A == B) {
return false;
}
if (size(A) < size(B))
swap(A, B);
Parent[A] += Parent[B];
Parent[B] = A;
return true;
}
};
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;
}
ll mulMod(ll a, ll b) { return (((a % MOD) * (b % MOD)) % MOD); }
ll powMod(ll a, ll p) {
if (p == 0) {
return 1;
} else if (p % 2 == 0) {
ll half = powMod(a, p / 2);
return mulMod(half, half);
} else {
return mulMod(powMod(a, p - 1), a);
}
}
ll ceil(ll a, ll b) { return (a + b - 1) / b; }
vector<ll> tsort(Graph G) {
ll N = G.size();
vector<ll> in(N);
for (auto &&edges : G) {
for (auto &&edge : edges) {
in[edge]++;
}
}
queue<int> que;
for (int i = 0; i < N; i++) {
if (in[i] == 0) {
que.push(i);
}
}
int cnt = 0;
vector<ll> ans;
while (!que.empty()) {
int v = que.front();
que.pop();
ans.push_back(v);
for (auto &&next : G[v]) {
in[next]--;
if (in[next] == 0) {
que.push(next);
}
}
}
return ans;
}
long long D;
std::vector<long long> c(26);
std::vector<std::vector<long long>> s(365, std::vector<long long>(26));
bool isSelected[365][26] = {false};
ll scoring(ll contest) {
ll sum = 0;
ll cnt = 0;
for (int j = 0; j < D; j++) {
if (isSelected[j][contest]) {
cnt = 0;
sum += s[j][contest];
} else {
cnt++;
sum -= c[contest] * cnt;
}
}
return sum;
}
int main() {
std::chrono::system_clock::time_point start, end;
double elapsed;
start = std::chrono::system_clock::now();
scanf("%lld", &D);
for (int i = 0; i < 26; i++) {
scanf("%lld", &c[i]);
}
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++) {
scanf("%lld", &s[i][j]);
}
}
std::vector<long long> t(D);
for (int i = 0; i < D; i++) {
t[i] = rand() % 26;
}
vector<ll> score(26, 0);
for (int i = 0; i < D; i++) {
isSelected[i][t[i]] = true;
}
for (int c = 0; c < 26; c++) {
score[c] = scoring(c);
}
do {
ll ran = rand() % 2;
if (ran) {
// 一点変更
ll day = rand() % D;
ll to = rand() % 26;
ll now_score = accumulate(score.begin(), score.end(), 0LL);
vector<ll> tmp = score;
ll from = t[day];
t[day] = to;
isSelected[day][from] = false;
isSelected[day][to] = true;
tmp[from] = scoring(from);
tmp[to] = scoring(to);
if (now_score < accumulate(tmp.begin(), tmp.end(), 0LL)) {
score = tmp;
} else {
isSelected[day][to] = false;
isSelected[day][from] = true;
t[day] = from;
}
} else {
// 2点スワップ
ll d1 = rand() % D;
static std::mt19937_64 mt64(0);
std::uniform_int_distribution<> rand100(d1, d1 + 16);
ll d2 = min((ll)rand100(mt64), D);
ll now_score = accumulate(score.begin(), score.end(), 0LL);
vector<ll> tmp = score;
ll c1 = t[d1];
ll c2 = t[d2];
isSelected[d1][c1] = false;
isSelected[d1][c2] = true;
isSelected[d2][c2] = false;
isSelected[d2][c1] = true;
tmp[c1] = scoring(c1);
tmp[c2] = scoring(c2);
if (now_score < accumulate(tmp.begin(), tmp.end(), 0LL)) {
score = tmp;
t[d1] = c2;
t[d2] = c1;
} else {
isSelected[d1][c1] = true;
isSelected[d1][c2] = false;
isSelected[d2][c2] = true;
isSelected[d2][c1] = false;
}
}
end = std::chrono::system_clock::now();
elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
.count();
} while (elapsed <= (double)1990);
for (int i = 0; i < D; i++) {
cout << t[i] + 1 << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Edge = int;
using Graph = vector<vector<Edge>>;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
const ll MOD = 1000000007;
const ll nmax = 8;
const ll INF = 1e13;
const int MAX = 510000;
bool graph[nmax][nmax];
long long fac[MAX], finv[MAX], inv[MAX];
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
ll COM(int n, int k) {
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
vector<vector<ll>> dist = vector<vector<ll>>(nmax, vector<ll>(nmax, INF));
struct SegmentTree {
private:
ll n;
vector<ll> node;
public:
SegmentTree(vector<ll> v) {
ll sz = v.size();
n = 1;
while (n < sz) {
n *= 2;
}
node.resize(2 * n - 1, INF);
for (ll i = 0; i < sz; i++) {
node[i + n - 1] = v[i];
}
for (ll i = n - 2; i >= 0; i--) {
node[i] = min(node[2 * i + 1], node[2 * i + 2]);
}
}
void update(ll x, ll val) {
x += (n - 1);
node[x] = val;
while (x > 0) {
x = (x - 1) / 2;
node[x] = min(node[2 * x + 1], node[2 * x + 2]);
}
}
// findは半開区間で考える
ll find(ll a, ll b, ll k = 0, ll l = 0, ll r = -1) {
if (r < 0)
r = n;
if (r <= a || b <= l)
return INF;
if (a <= l && r <= b)
return node[k];
ll vl = find(a, b, 2 * k + 1, l, (l + r) / 2);
ll vr = find(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
void warshall_floyd(ll n) {
for (size_t i = 0; i < n; i++) {
for (size_t j = 0; j < n; j++) {
for (size_t k = 0; k < n; k++) {
dist[j][k] = min(dist[j][k], dist[j][i] + dist[i][k]);
}
}
}
}
class UnionFind {
public:
vector<ll> Parent;
UnionFind(ll N) { Parent = vector<ll>(N, -1); }
ll find(ll A) {
if (Parent[A] < 0)
return A;
return Parent[A] = find(Parent[A]);
}
ll size(ll A) { return -Parent[find(A)]; }
bool Union(ll A, ll B) {
A = find(A);
B = find(B);
if (A == B) {
return false;
}
if (size(A) < size(B))
swap(A, B);
Parent[A] += Parent[B];
Parent[B] = A;
return true;
}
};
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;
}
ll mulMod(ll a, ll b) { return (((a % MOD) * (b % MOD)) % MOD); }
ll powMod(ll a, ll p) {
if (p == 0) {
return 1;
} else if (p % 2 == 0) {
ll half = powMod(a, p / 2);
return mulMod(half, half);
} else {
return mulMod(powMod(a, p - 1), a);
}
}
ll ceil(ll a, ll b) { return (a + b - 1) / b; }
vector<ll> tsort(Graph G) {
ll N = G.size();
vector<ll> in(N);
for (auto &&edges : G) {
for (auto &&edge : edges) {
in[edge]++;
}
}
queue<int> que;
for (int i = 0; i < N; i++) {
if (in[i] == 0) {
que.push(i);
}
}
int cnt = 0;
vector<ll> ans;
while (!que.empty()) {
int v = que.front();
que.pop();
ans.push_back(v);
for (auto &&next : G[v]) {
in[next]--;
if (in[next] == 0) {
que.push(next);
}
}
}
return ans;
}
long long D;
std::vector<long long> c(26);
std::vector<std::vector<long long>> s(365, std::vector<long long>(26));
bool isSelected[365][26] = {false};
ll scoring(ll contest) {
ll sum = 0;
ll cnt = 0;
for (int j = 0; j < D; j++) {
if (isSelected[j][contest]) {
cnt = 0;
sum += s[j][contest];
} else {
cnt++;
sum -= c[contest] * cnt;
}
}
return sum;
}
int main() {
std::chrono::system_clock::time_point start, end;
double elapsed;
start = std::chrono::system_clock::now();
scanf("%lld", &D);
for (int i = 0; i < 26; i++) {
scanf("%lld", &c[i]);
}
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++) {
scanf("%lld", &s[i][j]);
}
}
std::vector<long long> t(D);
for (int i = 0; i < D; i++) {
t[i] = rand() % 26;
}
vector<ll> score(26, 0);
for (int i = 0; i < D; i++) {
isSelected[i][t[i]] = true;
}
for (int c = 0; c < 26; c++) {
score[c] = scoring(c);
}
do {
ll ran = rand() % 2;
if (ran) {
// 一点変更
ll day = rand() % D;
ll to = rand() % 26;
ll now_score = accumulate(score.begin(), score.end(), 0LL);
vector<ll> tmp = score;
ll from = t[day];
t[day] = to;
isSelected[day][from] = false;
isSelected[day][to] = true;
tmp[from] = scoring(from);
tmp[to] = scoring(to);
if (now_score < accumulate(tmp.begin(), tmp.end(), 0LL)) {
score = tmp;
} else {
isSelected[day][to] = false;
isSelected[day][from] = true;
t[day] = from;
}
} else {
// 2点スワップ
ll d1 = rand() % D;
static std::mt19937_64 mt64(0);
std::uniform_int_distribution<> rand100(d1, d1 + 16);
ll d2 = min((ll)rand100(mt64), D - 1);
ll now_score = accumulate(score.begin(), score.end(), 0LL);
vector<ll> tmp = score;
ll c1 = t[d1];
ll c2 = t[d2];
isSelected[d1][c1] = false;
isSelected[d1][c2] = true;
isSelected[d2][c2] = false;
isSelected[d2][c1] = true;
tmp[c1] = scoring(c1);
tmp[c2] = scoring(c2);
if (now_score < accumulate(tmp.begin(), tmp.end(), 0LL)) {
score = tmp;
t[d1] = c2;
t[d2] = c1;
} else {
isSelected[d1][c1] = true;
isSelected[d1][c2] = false;
isSelected[d2][c2] = true;
isSelected[d2][c1] = false;
}
}
end = std::chrono::system_clock::now();
elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
.count();
} while (elapsed <= (double)1990);
for (int i = 0; i < D; i++) {
cout << t[i] + 1 << endl;
}
return 0;
}
| replace | 252 | 253 | 252 | 253 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define SUM(x) ((x) * (x + 1) / 2)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int D;
cin >> D;
vector<int> c(26);
for (int i = 0; i < 26; i++)
cin >> c[i];
vector<vector<int>> s(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(D);
{
vector<int> last(26, 0);
for (int i = 1; i <= D; i++) {
int mx = -1000000000, ti = 0;
for (int k = 0; k < 26; k++) {
int sd = s[i - 1][k];
for (int l = 0; l < 26; l++) {
if (l == k)
continue;
sd -= c[l] * (i - last[l]);
}
if (sd > mx) {
mx = sd;
ti = k;
}
}
last[ti] = i;
t[i - 1] = ti + 1;
}
}
int score = 0;
{
vector<int> last(26, 0);
for (int i = 1; i <= D; i++) {
score += s[i - 1][t[i - 1] - 1];
last[t[i - 1] - 1] = i;
for (int j = 0; j < 26; j++)
score -= c[j] * (i - last[j]);
}
}
int m = 1000000;
mt19937 mt((int)time(0));
for (int i = 0; i < m; i++) {
int d = mt() % D + 1, q = mt() % 26 + 1;
int p = t[d - 1];
t[d - 1] = q;
int score2 = 0;
vector<int> last(26, 0);
for (int i = 1; i <= D; i++) {
score2 += s[i - 1][t[i - 1] - 1];
last[t[i - 1] - 1] = i;
for (int j = 0; j < 26; j++)
score2 -= c[j] * (i - last[j]);
}
if (score < score2)
score = score2;
else
t[d - 1] = p;
}
for (int i = 0; i < D; i++)
cout << t[i] << endl;
// cout << "score:" << score << endl;
return 0;
}
| #include <bits/stdc++.h>
#define SUM(x) ((x) * (x + 1) / 2)
using namespace std;
using ll = long long;
using P = pair<int, int>;
int main() {
int D;
cin >> D;
vector<int> c(26);
for (int i = 0; i < 26; i++)
cin >> c[i];
vector<vector<int>> s(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(D);
{
vector<int> last(26, 0);
for (int i = 1; i <= D; i++) {
int mx = -1000000000, ti = 0;
for (int k = 0; k < 26; k++) {
int sd = s[i - 1][k];
for (int l = 0; l < 26; l++) {
if (l == k)
continue;
sd -= c[l] * (i - last[l]);
}
if (sd > mx) {
mx = sd;
ti = k;
}
}
last[ti] = i;
t[i - 1] = ti + 1;
}
}
int score = 0;
{
vector<int> last(26, 0);
for (int i = 1; i <= D; i++) {
score += s[i - 1][t[i - 1] - 1];
last[t[i - 1] - 1] = i;
for (int j = 0; j < 26; j++)
score -= c[j] * (i - last[j]);
}
}
int m = 100000;
mt19937 mt((int)time(0));
for (int i = 0; i < m; i++) {
int d = mt() % D + 1, q = mt() % 26 + 1;
int p = t[d - 1];
t[d - 1] = q;
int score2 = 0;
vector<int> last(26, 0);
for (int i = 1; i <= D; i++) {
score2 += s[i - 1][t[i - 1] - 1];
last[t[i - 1] - 1] = i;
for (int j = 0; j < 26; j++)
score2 -= c[j] * (i - last[j]);
}
if (score < score2)
score = score2;
else
t[d - 1] = p;
}
for (int i = 0; i < D; i++)
cout << t[i] << endl;
// cout << "score:" << score << endl;
return 0;
}
| replace | 49 | 50 | 49 | 50 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int, int> P;
int INF = 1e9 + 7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
signed main() {
int D;
cin >> D;
vector<int> c(26);
for (int i = 0; i < 26; i++) {
cin >> c[i];
}
vector<vector<int>> s(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(D);
for (int i = 0; i < D; i++) {
t[i] = rand() % 26 + 1;
}
int ans = 0;
vector<int> Last(26);
for (int i = 0; i < D; i++) {
ans += s[i][t[i] - 1];
Last[t[i] - 1] = i + 1;
for (int j = 0; j < 26; j++) {
ans -= c[j] * (i + 1 - Last[j]);
}
}
int M = 3333333;
vector<P> horyuu;
int cnt = 0;
for (int i = 0; i < M; i++) {
int d = rand() % D + 1;
int q = rand() % 26 + 1;
int ord = ans;
int X = 0;
int Y = 0;
int A = 0;
int B = 0;
ans += s[d - 1][q - 1] - s[d - 1][t[d - 1] - 1];
for (int j = 0; j < D; j++) {
if (t[j] == t[d - 1]) {
if (j == d - 1) {
Y = j + 1;
} else {
X = j + 1;
}
A = j + 1;
}
if (t[j] == q) {
Y = j + 1;
B = j + 1;
}
ans -= c[t[d - 1] - 1] * (j + 1 - X) - c[t[d - 1] - 1] * (j + 1 - A);
ans += c[q - 1] * (j + 1 - B) - c[q - 1] * (j + 1 - Y);
}
if (ans >= ord) {
ord = ans;
horyuu.push_back({d, q});
cnt++;
} else {
ans = ord;
}
if (cnt == 2) {
cnt = 0;
t[horyuu[1].first - 1] = horyuu[1].second;
horyuu = {};
}
}
for (int i = 0; i < D; i++) {
cout << t[i] << "\n";
}
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
typedef pair<int, int> P;
int INF = 1e9 + 7;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
signed main() {
int D;
cin >> D;
vector<int> c(26);
for (int i = 0; i < 26; i++) {
cin >> c[i];
}
vector<vector<int>> s(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(D);
for (int i = 0; i < D; i++) {
t[i] = rand() % 26 + 1;
}
int ans = 0;
vector<int> Last(26);
for (int i = 0; i < D; i++) {
ans += s[i][t[i] - 1];
Last[t[i] - 1] = i + 1;
for (int j = 0; j < 26; j++) {
ans -= c[j] * (i + 1 - Last[j]);
}
}
int M = 3003333;
vector<P> horyuu;
int cnt = 0;
for (int i = 0; i < M; i++) {
int d = rand() % D + 1;
int q = rand() % 26 + 1;
int ord = ans;
int X = 0;
int Y = 0;
int A = 0;
int B = 0;
ans += s[d - 1][q - 1] - s[d - 1][t[d - 1] - 1];
for (int j = 0; j < D; j++) {
if (t[j] == t[d - 1]) {
if (j == d - 1) {
Y = j + 1;
} else {
X = j + 1;
}
A = j + 1;
}
if (t[j] == q) {
Y = j + 1;
B = j + 1;
}
ans -= c[t[d - 1] - 1] * (j + 1 - X) - c[t[d - 1] - 1] * (j + 1 - A);
ans += c[q - 1] * (j + 1 - B) - c[q - 1] * (j + 1 - Y);
}
if (ans >= ord) {
ord = ans;
horyuu.push_back({d, q});
cnt++;
} else {
ans = ord;
}
if (cnt == 2) {
cnt = 0;
t[horyuu[1].first - 1] = horyuu[1].second;
horyuu = {};
}
}
for (int i = 0; i < D; i++) {
cout << t[i] << "\n";
}
} | replace | 33 | 34 | 33 | 34 | TLE | |
p02618 | C++ | Runtime Error | #include <iostream>
#include <iterator>
#include <string>
#include <vector>
#define rep(i, cc, n) for (int i = cc; i < n; ++i)
using namespace std;
using ll = long long;
int main() {
int D;
cin >> D;
vector<int> C(26);
vector<int> conts(26, 0);
rep(i, 0, 26) {
int c;
cin >> c;
C[i] = c;
}
vector<vector<int>> S(D, vector<int>(26));
rep(i, 0, D) {
rep(j, 0, 26) {
int s;
cin >> s;
S.at(i).at(j) = s;
}
}
rep(d, 1, D + 1) {
int max = 0;
int memo = 0;
rep(j, 0, 26) {
rep(k, 0, 26) {
int satit = 0;
if (k == j) {
satit += S.at(d - 1).at(j);
} else {
satit -= C[j] * (d - conts[j]);
}
if (satit > max) {
max = satit;
memo = k;
}
}
}
cout << memo + 1 << endl;
conts[d - 1] = memo;
}
}
| #include <iostream>
#include <iterator>
#include <string>
#include <vector>
#define rep(i, cc, n) for (int i = cc; i < n; ++i)
using namespace std;
using ll = long long;
int main() {
int D;
cin >> D;
vector<int> C(26);
vector<int> conts(26, 0);
rep(i, 0, 26) {
int c;
cin >> c;
C[i] = c;
}
vector<vector<int>> S(D, vector<int>(26));
rep(i, 0, D) {
rep(j, 0, 26) {
int s;
cin >> s;
S.at(i).at(j) = s;
}
}
rep(d, 1, D + 1) {
int max = 0;
int memo = 0;
rep(j, 0, 26) {
rep(k, 0, 26) {
int satit = 0;
if (k == j) {
satit += S.at(d - 1).at(j);
} else {
satit -= C[j] * (d - conts[j]);
}
if (satit > max) {
max = satit;
memo = k;
}
}
}
cout << memo + 1 << endl;
conts[memo] = d;
}
}
| replace | 50 | 51 | 50 | 51 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <chrono>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <time.h>
#include <tuple>
#include <vector>
#ifdef _MSC_VER
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define REP(i, a, b) for (ll i = a; i > b; i--)
#define CST(x) cout << fixed << setprecision(x) // 小数点以下の桁数指定
#define ct(a) cout << a << endl
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repl(i, l, r) for (int i = (1); i < (r); i++)
#define per(i, n) for (int i = ((n)-1); i >= 0; i--)
static const double pi = 3.141592653589793;
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
const ll INF = 1e9 + 7;
const ll mod = 1e9 + 7;
using namespace std::chrono;
inline ll get_time_millisec(void) {
return static_cast<ll>(
duration_cast<milliseconds>(steady_clock::now().time_since_epoch())
.count());
}
unsigned long xor128() {
static unsigned long x = 123456789, y = 362436069, z = 521288629,
w = 88675123;
unsigned long t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
inline int getRange(int l, int r) { return xor128() % (r + 1 - l) + l; }
class Solver {
private:
// 要素
ll D;
ll C[26];
ll S[365][26];
ll date[365];
public:
void input() {
cin >> D;
FOR(i, 0, 26) cin >> C[i];
FOR(i, 0, D) {
FOR(j, 0, 26) { cin >> S[i][j]; }
}
}
int calcScore() {
int score = 0;
return score;
}
void init() {}
void rndchange() {}
void output() {
FOR(i, 0, D) { cout << xor128() % 26 + 1 << endl; }
}
};
Solver solve(void) {
Solver currentSeq;
currentSeq.input();
currentSeq.init();
Solver bestSeq = currentSeq;
int bestScore = currentSeq.calcScore();
int currentScore = bestScore;
const ll saTimeStart = get_time_millisec();
const ll saTimeEnd = saTimeStart + 2995; // milli
double saTimeCurrent = saTimeStart;
while (saTimeCurrent < saTimeEnd) {
Solver nextSeq = currentSeq;
nextSeq.rndchange();
const int nextScore = nextSeq.calcScore();
const ll T = saTimeEnd - saTimeStart;
const ll t = saTimeCurrent - saTimeStart;
const ll R = 10000;
// const bool FORCE_NEXT = R * (T - t) > T*((xor128()) % (R));
const bool FORCE_NEXT = false;
/*
double startTemp = 20;
double endTemp = 10;
double temp = startTemp + (endTemp - startTemp)*t / T;
double probability = exp((nextScore - currentScore) / temp);
const bool FORCE_NEXT = probability > (double)(xor128() % R) / (double)R;
*/
// const bool FORCE_NEXT = (xor128() % R) >998;
if (nextScore > currentScore || FORCE_NEXT) {
currentScore = nextScore;
currentSeq = nextSeq;
}
if (currentScore > bestScore) {
bestScore = currentScore;
// cout << bestScore << endl;
bestSeq = currentSeq;
}
saTimeCurrent = get_time_millisec();
}
return bestSeq;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
Solver ans = solve();
ans.output();
return 0;
}
| #include <algorithm>
#include <chrono>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <time.h>
#include <tuple>
#include <vector>
#ifdef _MSC_VER
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define REP(i, a, b) for (ll i = a; i > b; i--)
#define CST(x) cout << fixed << setprecision(x) // 小数点以下の桁数指定
#define ct(a) cout << a << endl
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repl(i, l, r) for (int i = (1); i < (r); i++)
#define per(i, n) for (int i = ((n)-1); i >= 0; i--)
static const double pi = 3.141592653589793;
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
const ll INF = 1e9 + 7;
const ll mod = 1e9 + 7;
using namespace std::chrono;
inline ll get_time_millisec(void) {
return static_cast<ll>(
duration_cast<milliseconds>(steady_clock::now().time_since_epoch())
.count());
}
unsigned long xor128() {
static unsigned long x = 123456789, y = 362436069, z = 521288629,
w = 88675123;
unsigned long t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
inline int getRange(int l, int r) { return xor128() % (r + 1 - l) + l; }
class Solver {
private:
// 要素
ll D;
ll C[26];
ll S[365][26];
ll date[365];
public:
void input() {
cin >> D;
FOR(i, 0, 26) cin >> C[i];
FOR(i, 0, D) {
FOR(j, 0, 26) { cin >> S[i][j]; }
}
}
int calcScore() {
int score = 0;
return score;
}
void init() {}
void rndchange() {}
void output() {
FOR(i, 0, D) { cout << xor128() % 26 + 1 << endl; }
}
};
Solver solve(void) {
Solver currentSeq;
currentSeq.input();
currentSeq.init();
Solver bestSeq = currentSeq;
int bestScore = currentSeq.calcScore();
int currentScore = bestScore;
const ll saTimeStart = get_time_millisec();
const ll saTimeEnd = saTimeStart + 5; // milli
double saTimeCurrent = saTimeStart;
while (saTimeCurrent < saTimeEnd) {
Solver nextSeq = currentSeq;
nextSeq.rndchange();
const int nextScore = nextSeq.calcScore();
const ll T = saTimeEnd - saTimeStart;
const ll t = saTimeCurrent - saTimeStart;
const ll R = 10000;
// const bool FORCE_NEXT = R * (T - t) > T*((xor128()) % (R));
const bool FORCE_NEXT = false;
/*
double startTemp = 20;
double endTemp = 10;
double temp = startTemp + (endTemp - startTemp)*t / T;
double probability = exp((nextScore - currentScore) / temp);
const bool FORCE_NEXT = probability > (double)(xor128() % R) / (double)R;
*/
// const bool FORCE_NEXT = (xor128() % R) >998;
if (nextScore > currentScore || FORCE_NEXT) {
currentScore = nextScore;
currentSeq = nextSeq;
}
if (currentScore > bestScore) {
bestScore = currentScore;
// cout << bestScore << endl;
bestSeq = currentSeq;
}
saTimeCurrent = get_time_millisec();
}
return bestSeq;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
Solver ans = solve();
ans.output();
return 0;
}
| replace | 97 | 98 | 97 | 98 | TLE | |
p02618 | C++ | Runtime Error | #include <algorithm>
#include <chrono>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <time.h>
#include <tuple>
#include <vector>
#ifdef _MSC_VER
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define REP(i, a, b) for (ll i = a; i > b; i--)
#define CST(x) cout << fixed << setprecision(x) // 小数点以下の桁数指定
#define ct(a) cout << a << endl
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repl(i, l, r) for (int i = (1); i < (r); i++)
#define per(i, n) for (int i = ((n)-1); i >= 0; i--)
static const double pi = 3.141592653589793;
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
const ll INF = 1e9 + 7;
const ll mod = 1e9 + 7;
using namespace std::chrono;
inline ll get_time_millisec(void) {
return static_cast<ll>(
duration_cast<milliseconds>(steady_clock::now().time_since_epoch())
.count());
}
unsigned long xor128() {
static unsigned long x = 123456789, y = 362436069, z = 521288629,
w = 88675123;
unsigned long t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
inline int getRange(int l, int r) { return xor128() % (r + 1 - l) + l; }
class Solver {
private:
// 要素
ll D;
ll C[26];
ll S[365][26];
ll date[365];
pair<int, int> maxC;
public:
void input() {
cin >> D;
// D = 365;
FOR(i, 0, 26) {
cin >> C[i];
if (C[i] > maxC.first) {
maxC.first = C[i];
maxC.second = i;
}
}
/*
FOR(i, 0, 26) {
C[i] = getRange(0, 100);
if (C[i] > maxC.first) {
maxC.first = C[i];
maxC.second = i;
}
}
*/
FOR(i, 0, D) {
FOR(j, 0, 26) {
cin >> S[i][j];
// S[i][j] = getRange(0, 20000);
}
date[i] = xor128() % 26;
}
}
int calcScore() {
ll score = 0;
ll last[365];
FOR(i, 0, 26) last[i] = -1;
FOR(i, 0, D) {
score += S[i][date[i]];
last[date[i]] = i;
FOR(j, 0, 26) {
ll hiku = C[j] * (i - last[j]);
score -= hiku;
}
}
return score;
}
void init() {}
void rndchange() {
ll t = xor128() % D;
date[t] = xor128() % 26;
}
void rndchange2() {
ll t = xor128() % D;
if (t == 0)
swap(date[0], date[1]);
else if (t == 25)
swap(date[25], date[24]);
else {
int judge = xor128() % 2;
if (judge == 0)
swap(date[t], date[t + 1]);
else
swap(date[t], date[t - 1]);
}
}
void output() {
FOR(i, 0, D) { cout << date[i] + 1 << endl; }
// cout << calcScore() << endl;
}
};
ll cnt = 0;
Solver solve(void) {
Solver currentSeq;
currentSeq.input();
currentSeq.init();
Solver bestSeq = currentSeq;
int bestScore = currentSeq.calcScore();
int currentScore = bestScore;
const ll saTimeStart = get_time_millisec();
const ll saTimeEnd = saTimeStart + 1975; // milli
double saTimeCurrent = saTimeStart;
while (saTimeCurrent < saTimeEnd) {
cnt++;
Solver nextSeq = currentSeq;
if (saTimeCurrent < saTimeEnd - 500)
nextSeq.rndchange();
else
nextSeq.rndchange2();
const int nextScore = nextSeq.calcScore();
const ll T = saTimeEnd - saTimeStart;
const ll t = saTimeCurrent - saTimeStart;
const ll R = 10000;
// const bool FORCE_NEXT = R * (T - t) > T*((xor128()) % (R));
// const bool FORCE_NEXT = false;
double startTemp = 4;
double endTemp = 1;
double temp = startTemp + (endTemp - startTemp) * t / T;
double probability = exp((nextScore - currentScore) / temp);
const bool FORCE_NEXT = probability > (double)(xor128() % R) / (double)R;
// const bool FORCE_NEXT = (xor128() % R) > 999;
if (nextScore > currentScore || FORCE_NEXT) {
currentScore = nextScore;
currentSeq = nextSeq;
}
if (currentScore > bestScore) {
bestScore = currentScore;
// cout << bestScore << endl;
bestSeq = currentSeq;
}
saTimeCurrent = get_time_millisec();
}
return bestSeq;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
Solver ans = solve();
ans.output();
// cout << cnt << endl;
return 0;
}
| #include <algorithm>
#include <chrono>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string.h>
#include <string>
#include <time.h>
#include <tuple>
#include <vector>
#ifdef _MSC_VER
#include <intrin.h>
#define __builtin_popcount __popcnt
#endif
#define FOR(i, a, b) for (ll i = a; i < b; i++)
#define REP(i, a, b) for (ll i = a; i > b; i--)
#define CST(x) cout << fixed << setprecision(x) // 小数点以下の桁数指定
#define ct(a) cout << a << endl
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repl(i, l, r) for (int i = (1); i < (r); i++)
#define per(i, n) for (int i = ((n)-1); i >= 0; i--)
static const double pi = 3.141592653589793;
using namespace std;
typedef long long ll;
const ll MOD = 998244353;
const ll INF = 1e9 + 7;
const ll mod = 1e9 + 7;
using namespace std::chrono;
inline ll get_time_millisec(void) {
return static_cast<ll>(
duration_cast<milliseconds>(steady_clock::now().time_since_epoch())
.count());
}
unsigned long xor128() {
static unsigned long x = 123456789, y = 362436069, z = 521288629,
w = 88675123;
unsigned long t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
inline int getRange(int l, int r) { return xor128() % (r + 1 - l) + l; }
class Solver {
private:
// 要素
ll D;
ll C[26];
ll S[365][26];
ll date[365];
pair<int, int> maxC;
public:
void input() {
cin >> D;
// D = 365;
FOR(i, 0, 26) {
cin >> C[i];
if (C[i] > maxC.first) {
maxC.first = C[i];
maxC.second = i;
}
}
/*
FOR(i, 0, 26) {
C[i] = getRange(0, 100);
if (C[i] > maxC.first) {
maxC.first = C[i];
maxC.second = i;
}
}
*/
FOR(i, 0, D) {
FOR(j, 0, 26) {
cin >> S[i][j];
// S[i][j] = getRange(0, 20000);
}
date[i] = xor128() % 26;
}
}
int calcScore() {
ll score = 0;
ll last[365];
FOR(i, 0, 26) last[i] = -1;
FOR(i, 0, D) {
score += S[i][date[i]];
last[date[i]] = i;
FOR(j, 0, 26) {
ll hiku = C[j] * (i - last[j]);
score -= hiku;
}
}
return score;
}
void init() {}
void rndchange() {
ll t = xor128() % D;
date[t] = xor128() % 26;
}
void rndchange2() {
ll t = xor128() % (D - 1);
swap(date[t], date[t + 1]);
}
void output() {
FOR(i, 0, D) { cout << date[i] + 1 << endl; }
// cout << calcScore() << endl;
}
};
ll cnt = 0;
Solver solve(void) {
Solver currentSeq;
currentSeq.input();
currentSeq.init();
Solver bestSeq = currentSeq;
int bestScore = currentSeq.calcScore();
int currentScore = bestScore;
const ll saTimeStart = get_time_millisec();
const ll saTimeEnd = saTimeStart + 1975; // milli
double saTimeCurrent = saTimeStart;
while (saTimeCurrent < saTimeEnd) {
cnt++;
Solver nextSeq = currentSeq;
if (saTimeCurrent < saTimeEnd - 500)
nextSeq.rndchange();
else
nextSeq.rndchange2();
const int nextScore = nextSeq.calcScore();
const ll T = saTimeEnd - saTimeStart;
const ll t = saTimeCurrent - saTimeStart;
const ll R = 10000;
// const bool FORCE_NEXT = R * (T - t) > T*((xor128()) % (R));
// const bool FORCE_NEXT = false;
double startTemp = 4;
double endTemp = 1;
double temp = startTemp + (endTemp - startTemp) * t / T;
double probability = exp((nextScore - currentScore) / temp);
const bool FORCE_NEXT = probability > (double)(xor128() % R) / (double)R;
// const bool FORCE_NEXT = (xor128() % R) > 999;
if (nextScore > currentScore || FORCE_NEXT) {
currentScore = nextScore;
currentSeq = nextSeq;
}
if (currentScore > bestScore) {
bestScore = currentScore;
// cout << bestScore << endl;
bestSeq = currentSeq;
}
saTimeCurrent = get_time_millisec();
}
return bestSeq;
}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
Solver ans = solve();
ans.output();
// cout << cnt << endl;
return 0;
}
| replace | 120 | 132 | 120 | 122 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int D;
vector<pair<int, int>> c(26);
vector<vector<int>> s(D, vector<int>(26));
vector<int> t(D);
cin >> D;
for (int i = 0; i < 26; i++) {
cin >> c.at(i).first;
c.at(i).second = 0;
}
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++) {
cin >> s.at(i).at(j);
}
}
for (int i = 0; i < D; i++) {
t.at(i) = rand() % 26 + 1;
}
int count = 0;
int S = 0;
vector<int> ans(D);
while (count++ < 5000000) {
t.at((rand() % D + 1) - 1) = rand() % 26 + 1;
int Pl = 0;
int Mi = 0;
for (int i = 0; i < D; i++) {
Pl += s.at(i).at(t.at(i) - 1);
c.at(t.at(i) - 1).second = i + 1;
for (int j = 0; j < 26; j++) {
Mi += c.at(j).first * (i + 1 - c.at(j).second);
}
Pl -= Mi;
Mi = 0;
}
if (S < Pl) {
S = Pl;
for (int i = 0; i < D; i++) {
ans.at(i) = t.at(i);
}
} else if (S >= Pl) {
continue;
}
}
for (int i = 0; i < D; i++) {
cout << ans.at(i) << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int D;
vector<pair<int, int>> c(26);
vector<vector<int>> s(D, vector<int>(26));
vector<int> t(D);
cin >> D;
for (int i = 0; i < 26; i++) {
cin >> c.at(i).first;
c.at(i).second = 0;
}
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++) {
cin >> s.at(i).at(j);
}
}
for (int i = 0; i < D; i++) {
t.at(i) = rand() % 26 + 1;
}
int count = 0;
int S = 0;
vector<int> ans(D);
while (count++ < 50000) {
t.at((rand() % D + 1) - 1) = rand() % 26 + 1;
int Pl = 0;
int Mi = 0;
for (int i = 0; i < D; i++) {
Pl += s.at(i).at(t.at(i) - 1);
c.at(t.at(i) - 1).second = i + 1;
for (int j = 0; j < 26; j++) {
Mi += c.at(j).first * (i + 1 - c.at(j).second);
}
Pl -= Mi;
Mi = 0;
}
if (S < Pl) {
S = Pl;
for (int i = 0; i < D; i++) {
ans.at(i) = t.at(i);
}
} else if (S >= Pl) {
continue;
}
}
for (int i = 0; i < D; i++) {
cout << ans.at(i) << endl;
}
}
| replace | 28 | 29 | 28 | 29 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int D;
cin >> D;
vector<pair<int, int>> c(26);
vector<vector<int>> s(D, vector<int>(26));
vector<int> t(D);
for (int i = 0; i < 26; i++) {
cin >> c.at(i).first;
c.at(i).second = 0;
}
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++) {
cin >> s.at(i).at(j);
}
}
for (int i = 0; i < D; i++) {
t.at(i) = rand() % 26 + 1;
}
int count = 0;
int S = 0;
vector<int> ans(D);
while (count++ < 500000) {
t.at((rand() % D + 1) - 1) = rand() % 26 + 1;
int Pl = 0;
int Mi = 0;
for (int i = 0; i < D; i++) {
Pl += s.at(i).at(t.at(i) - 1);
c.at(t.at(i) - 1).second = i + 1;
for (int j = 0; j < 26; j++) {
Mi += c.at(j).first * (i + 1 - c.at(j).second);
}
Pl -= Mi;
Mi = 0;
}
if (S < Pl) {
S = Pl;
for (int i = 0; i < D; i++) {
ans.at(i) = t.at(i);
}
} else if (S >= Pl) {
continue;
}
}
for (int i = 0; i < D; i++) {
cout << ans.at(i) << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
for (int i = 1; i <= 365; i++) {
cout << rand() % 26 + 1 << endl;
}
} | replace | 4 | 55 | 4 | 6 | TLE | |
p02618 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#define F first
#define S second
using namespace std;
int Q = 1e7, h1, h2, cut = 5;
int n, s, D, l, r, up, mx, cnt, mxx, xx, a[30], b[400][30], la[400], u[400],
ans[400], o[400];
pair<int, int> c[400][30];
bool v[400][30];
int f(int p, int q1, int q2) {
int sz = q2 - q1 + 1;
return p * sz * (sz + 1) / 2;
}
int main() {
int i, j, k, t, x, t1, t2;
freopen("input.txt", "r", stdin);
srand(time(NULL));
cin >> D;
for (i = 0; i < 26; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= D; i++) {
mxx = -2e9;
for (j = 0; j < 26; j++) {
scanf("%d", &b[i][j]);
}
for (j = 0; j < 26; j++) {
cnt = b[i][j];
for (k = 0; k < 26; k++) {
if (k == j)
continue;
cnt -= (i - o[k]) * a[k];
}
if (cnt > mxx) {
xx = j;
mxx = cnt;
}
}
o[xx] = i;
ans[i] = u[i] = xx;
}
// for (i = 1; i <= D; i++) {
// ans[i] = u[i] = 1;
// }
// for(i = 1; i <= D; i++) {
// printf("%d\n", ans[i] + 1);
// }
for (i = 1; i <= D; i++) {
// scanf ("%d", &t);
t = u[i];
s += b[i][t];
la[t] = i;
for (j = 0; j < 26; j++) {
s -= a[j] * (i - la[j]);
}
v[i][t] = 1;
}
// cout << s << endl;
// cin >> Q;
for (i = 0; i < 26; i++) {
v[0][i] = 1;
v[D + 1][i] = 1;
}
mx = s;
while (Q--) {
// scanf ("%d %d", &t1, &t2);
t1 = rand() % D + 1;
t2 = rand() % 26;
if (u[t1] == t2)
t2 = (t2 + 1) % 26;
x = u[t1];
s -= b[t1][x];
v[t1][x] = 0;
v[t1][t2] = 1;
u[t1] = t2;
s += b[t1][t2];
for (l = t1 - 1; l >= 0; l--)
if (v[l][x])
break;
for (r = t1 + 1; r <= D + 1; r++)
if (v[r][x])
break;
s += f(a[x], l + 1, t1 - 1);
s += f(a[x], t1 + 1, r - 1);
s -= f(a[x], l + 1, r - 1);
for (l = t1 - 1; l >= 0; l--)
if (v[l][t2])
break;
for (r = t1 + 1; r <= D + 1; r++)
if (v[r][t2])
break;
s += f(a[t2], l + 1, r - 1);
s -= f(a[t2], l + 1, t1 - 1);
s -= f(a[t2], t1 + 1, r - 1);
if (s > mx) {
up = 0;
for (i = 1; i <= D; i++) {
ans[i] = u[i];
}
mx = s;
} else
up++;
if (up == cut) {
up = 0;
memset(v, 0, sizeof(v));
for (i = 0; i < 26; i++) {
v[0][i] = 1;
v[D + 1][i] = 1;
}
for (i = 1; i <= D; i++) {
u[i] = ans[i];
v[i][ans[i]] = 1;
}
s = mx;
}
}
for (i = 1; i <= D; i++) {
printf("%d\n", ans[i] + 1);
}
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#define F first
#define S second
using namespace std;
int Q = 1e7, h1, h2, cut = 5;
int n, s, D, l, r, up, mx, cnt, mxx, xx, a[30], b[400][30], la[400], u[400],
ans[400], o[400];
pair<int, int> c[400][30];
bool v[400][30];
int f(int p, int q1, int q2) {
int sz = q2 - q1 + 1;
return p * sz * (sz + 1) / 2;
}
int main() {
int i, j, k, t, x, t1, t2;
srand(time(NULL));
cin >> D;
for (i = 0; i < 26; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= D; i++) {
mxx = -2e9;
for (j = 0; j < 26; j++) {
scanf("%d", &b[i][j]);
}
for (j = 0; j < 26; j++) {
cnt = b[i][j];
for (k = 0; k < 26; k++) {
if (k == j)
continue;
cnt -= (i - o[k]) * a[k];
}
if (cnt > mxx) {
xx = j;
mxx = cnt;
}
}
o[xx] = i;
ans[i] = u[i] = xx;
}
// for (i = 1; i <= D; i++) {
// ans[i] = u[i] = 1;
// }
// for(i = 1; i <= D; i++) {
// printf("%d\n", ans[i] + 1);
// }
for (i = 1; i <= D; i++) {
// scanf ("%d", &t);
t = u[i];
s += b[i][t];
la[t] = i;
for (j = 0; j < 26; j++) {
s -= a[j] * (i - la[j]);
}
v[i][t] = 1;
}
// cout << s << endl;
// cin >> Q;
for (i = 0; i < 26; i++) {
v[0][i] = 1;
v[D + 1][i] = 1;
}
mx = s;
while (Q--) {
// scanf ("%d %d", &t1, &t2);
t1 = rand() % D + 1;
t2 = rand() % 26;
if (u[t1] == t2)
t2 = (t2 + 1) % 26;
x = u[t1];
s -= b[t1][x];
v[t1][x] = 0;
v[t1][t2] = 1;
u[t1] = t2;
s += b[t1][t2];
for (l = t1 - 1; l >= 0; l--)
if (v[l][x])
break;
for (r = t1 + 1; r <= D + 1; r++)
if (v[r][x])
break;
s += f(a[x], l + 1, t1 - 1);
s += f(a[x], t1 + 1, r - 1);
s -= f(a[x], l + 1, r - 1);
for (l = t1 - 1; l >= 0; l--)
if (v[l][t2])
break;
for (r = t1 + 1; r <= D + 1; r++)
if (v[r][t2])
break;
s += f(a[t2], l + 1, r - 1);
s -= f(a[t2], l + 1, t1 - 1);
s -= f(a[t2], t1 + 1, r - 1);
if (s > mx) {
up = 0;
for (i = 1; i <= D; i++) {
ans[i] = u[i];
}
mx = s;
} else
up++;
if (up == cut) {
up = 0;
memset(v, 0, sizeof(v));
for (i = 0; i < 26; i++) {
v[0][i] = 1;
v[D + 1][i] = 1;
}
for (i = 1; i <= D; i++) {
u[i] = ans[i];
v[i][ans[i]] = 1;
}
s = mx;
}
}
for (i = 1; i <= D; i++) {
printf("%d\n", ans[i] + 1);
}
return 0;
}
| delete | 23 | 24 | 23 | 23 | -8 | |
p02618 | C++ | Runtime Error | // Copyright 2020 yaito3014
#include <bits/stdc++.h>
int main() {
using namespace std;
cin.tie(nullptr);
ios::sync_with_stdio(false);
using namespace chrono_literals;
chrono::high_resolution_clock clock;
auto be = clock.now();
int D;
cin >> D;
array<int, 26> c;
for (auto &e : c)
cin >> e;
vector<array<int, 26>> d(D);
for (auto &r : d)
for (auto &e : r)
cin >> e;
auto eval = [&](vector<int> t) {
int S = 0;
array<int, 26> last = {};
for (int i = 0; i < D; ++i) {
S += d[i][t[i]];
last[t[i]] = i + 1;
for (int j = 0; j < 26; ++j)
S -= c[j] * (i + 1 - last[j]);
}
return S;
};
mt19937 mt(random_device{}());
uniform_int_distribution<int> dist_type(0, 25), dist_day(0, D - 1);
vector<int> t(D);
for (int i = 0; i < D; ++i)
t[i] = distance(cbegin(d[i]), max_element(cbegin(d[i]), cend(d[i]))) + 1;
int S = eval(t);
int cnt = 0;
while (clock.now() - be < 1900ms) {
int day = dist_day(mt);
int prv = t[day];
t[day] = dist_type(mt);
int score = eval(t);
if (score > S) {
S = score;
continue;
}
t[day] = prv;
if (++cnt > 10000) {
cnt = 0;
generate(begin(t), end(t), [&]() { return dist_type(mt); });
}
}
for (const auto &e : t)
cout << (e + 1) << '\n';
cerr << eval(t);
}
| // Copyright 2020 yaito3014
#include <bits/stdc++.h>
int main() {
using namespace std;
cin.tie(nullptr);
ios::sync_with_stdio(false);
using namespace chrono_literals;
chrono::high_resolution_clock clock;
auto be = clock.now();
int D;
cin >> D;
array<int, 26> c;
for (auto &e : c)
cin >> e;
vector<array<int, 26>> d(D);
for (auto &r : d)
for (auto &e : r)
cin >> e;
auto eval = [&](vector<int> t) {
int S = 0;
array<int, 26> last = {};
for (int i = 0; i < D; ++i) {
S += d[i][t[i]];
last[t[i]] = i + 1;
for (int j = 0; j < 26; ++j)
S -= c[j] * (i + 1 - last[j]);
}
return S;
};
mt19937 mt(random_device{}());
uniform_int_distribution<int> dist_type(0, 25), dist_day(0, D - 1);
vector<int> t(D);
for (int i = 0; i < D; ++i)
t[i] = distance(cbegin(d[i]), max_element(cbegin(d[i]), cend(d[i]))) + 1;
int S = eval(t);
int cnt = 0;
while (clock.now() - be < 1900ms) {
int day = dist_day(mt);
int prv = t[day];
t[day] = dist_type(mt);
int score = eval(t);
if (score > S) {
S = score;
continue;
}
t[day] = prv;
if (++cnt > 10000) {
cnt = 0;
generate(begin(t), end(t), [&]() { return dist_type(mt); });
}
}
for (const auto &e : t)
cout << (e + 1) << '\n';
}
| delete | 55 | 56 | 55 | 55 | 0 | 28927 |
p02618 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define rep(i, n) for (lint i = 0; i < n; i++)
#define repr(i, n) for (lint i = n - 1; i >= 0; i--)
#define repi(i, ini, n) for (lint i = ini; i < n; i++)
#define repir(i, ini, n) for (lint i = n - 1; i >= ini; i--)
#define repb(i, start, end) for (lint i = start; i <= end; i++)
#define repbr(i, start, end) for (lint i = end; i >= start; i--)
#define bit(n) (1LL << (n))
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rg(v, ini, end) v.begin() + ini, v.begin() + end
#define rrg(v, ini, end) v.rbegin() + ini, v.rbegin() + end
#define ret return 0;
namespace {
using lint = long long;
using ulint = unsigned long long;
using ld = long double;
struct xy {
lint x, y;
xy() : x(0), y(0) {}
xy(lint _x, lint _y) : x(_x), y(_y) {}
xy operator+(const xy &p) const { return xy(x + p.x, y + p.y); }
bool operator<(xy p) const {
if (y == p.y)
return x < p.x;
return y < p.y;
}
};
struct xyd {
ld x, y;
xyd() : x(0), y(0) {}
xyd(long double _x, long double _y) : x(_x), y(_y) {}
};
using vec = vector<lint>;
using vecd = vector<ld>;
using vecs = vector<string>;
using vecp = vector<xy>;
template <class T> using vect = vector<T>;
class vec2 : public vector<vector<lint>> {
public:
vec2() {}
vec2(lint n) : vector(n) {}
vec2(lint h, lint w) : vector(h, vector<lint>(w)) {}
vec2(lint h, lint w, lint v) : vector(h, vector<lint>(w, v)) {}
};
template <class T> using priq = priority_queue<T>;
template <class T> using rpriq = priority_queue<T, vector<T>, greater<T>>;
template <class Key, class Val> using hashmap = unordered_map<Key, Val>;
template <class Key> using hashset = unordered_set<Key>;
mt19937 mtrand((random_device())());
const double pi = 3.141592653589793238462;
const lint intmax = 9223372036854775807;
const lint inf = 1100100100100100100LL;
template <class T> constexpr auto msum(T arg0) { return arg0; }
template <class T, class... Types> constexpr auto msum(T arg0, Types... args) {
static_assert(sizeof...(args) > 0, "arg err");
return arg0 + msum(args...);
}
template <class It> constexpr typename It::value_type mmax(It begin, It end) {
return *max_element(begin, end);
}
template <class It> constexpr typename It::value_type mmin(It begin, It end) {
return *min_element(begin, end);
}
template <class T> constexpr auto mmax(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmax(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return max(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmax(args...)));
}
template <class T> constexpr auto mmin(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmin(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return min(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmin(args...)));
}
template <class T> struct Mplus {
T operator()(const T &a, const T &b) { return a + b; }
const static T id = T(0);
};
template <class It, class T = typename It::value_type, class Monoid = Mplus<T>>
T acc(It begin, It end, Monoid f = Mplus<T>()) {
return accumulate(begin, end, Monoid::id, f);
}
constexpr auto clamp(lint val, lint left, lint right) {
return mmax(mmin(val, right), left);
}
constexpr lint div2(lint p, lint q) { return (p + q - 1) / q; }
#if (__cplusplus < 201703L)
lint gcd(lint a, lint b) {
while (1) {
if (a < b)
swap(a, b);
if (!b)
break;
a %= b;
}
return a;
}
lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
#endif
constexpr lint powInt(lint a, lint b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
lint tmp = powInt(a, b / 2);
return (b % 2 == 1 ? a * tmp * tmp : tmp * tmp);
}
template <class T> T sgn(T val) {
if (val == T(0))
return T(0);
if (val < 0)
return T(-1);
if (val > 0)
return T(1);
}
template <class T> constexpr auto modK_belowN(T k, T MOD, T n) {
return (n + MOD - k - 1) / MOD;
}
template <class It, class T> bool exist(It begin, It end, const T &val) {
return find(begin, end, val) != end;
}
template <class It, class Pr> bool exist_if(It begin, It end, Pr pred) {
return find_if(begin, end, pred) != end;
}
template <class T> bool between(T val, T l, T r) {
return (val >= l) && (val <= r);
}
lint extGCD(lint a, lint b, lint &x, lint &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
lint d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
template <class It> auto carr(It begin, It end) {
vec c;
c.push_back(1);
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(0);
before = *it;
}
c.back()++;
}
return c;
}
template <class T> struct nval {
lint n;
T val;
nval() : n(0){};
nval(lint _n, T _val) : n(_n), val(_val){};
};
template <class It> auto carr2(It begin, It end) {
using T = nval<remove_reference_t<decltype(*begin)>>;
vect<T> c;
c.push_back(T(1, *begin));
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(T(0, *it));
before = *it;
}
c.back().n++;
}
return c;
}
template <class It, class... T> void sort2(It begin, It end, T... p) {
using val_t = remove_reference_t<decltype(*begin)>;
sort(begin, end, [p...](const val_t &a, const val_t &b) {
bool neq[] = {(a.*p != b.*p)...};
bool sg[] = {(a.*p < b.*p)...};
rep(i, sizeof...(p)) {
if (neq[i]) {
return sg[i];
}
}
return false;
});
}
template <class It, class It2> auto spacel(It i, It2 end) {
if (i + 1 == end) {
return '\n';
} else {
return ' ';
}
}
bool match(string s, string r) { return regex_match(s, regex(r)); }
ostream &setp(ostream &ost) {
cout << setprecision(60) << fixed;
return ost;
}
#ifdef _LOCAL
auto &dbg = cout;
#else
struct dummy_cout {
template <class T> dummy_cout &operator<<(T &&op) { return *this; }
using endl_t = basic_ostream<char, char_traits<char>>;
dummy_cout &operator<<(endl_t &(*)(endl_t &)) { return *this; }
};
dummy_cout dbg;
#endif
const ulint mod = 1000000007;
// const ulint mod = 998244353;
const ld eps = 0.0000001;
}; // namespace
int main() {
lint d;
cin >> d;
vec c(26);
rep(i, 26) cin >> c[i];
vec2 s(d + 1, 26, 0);
repb(i, 1, d) rep(j, 26) cin >> s[i][j];
vec ld(26, 0);
vec t(d + 1);
repb(i, 1, d) { t[i] = (i - 2) % 26 + 1; }
repb(i, 1, d) cout << t[i] + 1 << endl;
lint score = 0;
set<lint> ll[26];
rep(i, 26) {
ll[i].insert(0);
ll[i].insert(d + 1);
}
repb(i, 1, d) { ll[t[i]].insert(i); }
rep(i, 26) {
auto itend = ll[i].end();
itend--;
for (auto it = ll[i].begin(); it != itend; it++) {
auto ita = it;
ita++;
score -= c[i] * (*ita - *it) * (*ita - *it - 1) / 2;
score += s[*it][i];
}
}
auto f = [&](lint dd, lint q) {
q--;
score -= s[dd][t[dd]];
score += s[dd][q];
auto it = ll[t[dd]].find(dd);
auto ita = it, itb = it;
itb--;
ita++;
score -= c[t[dd]] * (*ita - dd) * (dd - *itb);
ll[t[dd]].erase(dd);
ll[q].insert(dd);
auto it2 = ll[q].find(dd);
auto it2a = it2, it2b = it2;
it2b--;
it2a++;
score += c[q] * (*it2a - dd) * (dd - *it2b);
t[dd] = q;
};
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define rep(i, n) for (lint i = 0; i < n; i++)
#define repr(i, n) for (lint i = n - 1; i >= 0; i--)
#define repi(i, ini, n) for (lint i = ini; i < n; i++)
#define repir(i, ini, n) for (lint i = n - 1; i >= ini; i--)
#define repb(i, start, end) for (lint i = start; i <= end; i++)
#define repbr(i, start, end) for (lint i = end; i >= start; i--)
#define bit(n) (1LL << (n))
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define rg(v, ini, end) v.begin() + ini, v.begin() + end
#define rrg(v, ini, end) v.rbegin() + ini, v.rbegin() + end
#define ret return 0;
namespace {
using lint = long long;
using ulint = unsigned long long;
using ld = long double;
struct xy {
lint x, y;
xy() : x(0), y(0) {}
xy(lint _x, lint _y) : x(_x), y(_y) {}
xy operator+(const xy &p) const { return xy(x + p.x, y + p.y); }
bool operator<(xy p) const {
if (y == p.y)
return x < p.x;
return y < p.y;
}
};
struct xyd {
ld x, y;
xyd() : x(0), y(0) {}
xyd(long double _x, long double _y) : x(_x), y(_y) {}
};
using vec = vector<lint>;
using vecd = vector<ld>;
using vecs = vector<string>;
using vecp = vector<xy>;
template <class T> using vect = vector<T>;
class vec2 : public vector<vector<lint>> {
public:
vec2() {}
vec2(lint n) : vector(n) {}
vec2(lint h, lint w) : vector(h, vector<lint>(w)) {}
vec2(lint h, lint w, lint v) : vector(h, vector<lint>(w, v)) {}
};
template <class T> using priq = priority_queue<T>;
template <class T> using rpriq = priority_queue<T, vector<T>, greater<T>>;
template <class Key, class Val> using hashmap = unordered_map<Key, Val>;
template <class Key> using hashset = unordered_set<Key>;
mt19937 mtrand((random_device())());
const double pi = 3.141592653589793238462;
const lint intmax = 9223372036854775807;
const lint inf = 1100100100100100100LL;
template <class T> constexpr auto msum(T arg0) { return arg0; }
template <class T, class... Types> constexpr auto msum(T arg0, Types... args) {
static_assert(sizeof...(args) > 0, "arg err");
return arg0 + msum(args...);
}
template <class It> constexpr typename It::value_type mmax(It begin, It end) {
return *max_element(begin, end);
}
template <class It> constexpr typename It::value_type mmin(It begin, It end) {
return *min_element(begin, end);
}
template <class T> constexpr auto mmax(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmax(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return max(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmax(args...)));
}
template <class T> constexpr auto mmin(T arg) { return arg; }
template <class T, class... Types> constexpr auto mmin(T arg0, Types... args) {
using promote_t = decltype(msum(arg0, args...));
return min(static_cast<promote_t>(arg0),
static_cast<promote_t>(mmin(args...)));
}
template <class T> struct Mplus {
T operator()(const T &a, const T &b) { return a + b; }
const static T id = T(0);
};
template <class It, class T = typename It::value_type, class Monoid = Mplus<T>>
T acc(It begin, It end, Monoid f = Mplus<T>()) {
return accumulate(begin, end, Monoid::id, f);
}
constexpr auto clamp(lint val, lint left, lint right) {
return mmax(mmin(val, right), left);
}
constexpr lint div2(lint p, lint q) { return (p + q - 1) / q; }
#if (__cplusplus < 201703L)
lint gcd(lint a, lint b) {
while (1) {
if (a < b)
swap(a, b);
if (!b)
break;
a %= b;
}
return a;
}
lint lcm(lint a, lint b) { return a / gcd(a, b) * b; }
#endif
constexpr lint powInt(lint a, lint b) {
if (b == 0) {
return 1;
}
if (b == 1) {
return a;
}
lint tmp = powInt(a, b / 2);
return (b % 2 == 1 ? a * tmp * tmp : tmp * tmp);
}
template <class T> T sgn(T val) {
if (val == T(0))
return T(0);
if (val < 0)
return T(-1);
if (val > 0)
return T(1);
}
template <class T> constexpr auto modK_belowN(T k, T MOD, T n) {
return (n + MOD - k - 1) / MOD;
}
template <class It, class T> bool exist(It begin, It end, const T &val) {
return find(begin, end, val) != end;
}
template <class It, class Pr> bool exist_if(It begin, It end, Pr pred) {
return find_if(begin, end, pred) != end;
}
template <class T> bool between(T val, T l, T r) {
return (val >= l) && (val <= r);
}
lint extGCD(lint a, lint b, lint &x, lint &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
lint d = extGCD(b, a % b, y, x);
y -= a / b * x;
return d;
}
template <class It> auto carr(It begin, It end) {
vec c;
c.push_back(1);
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(0);
before = *it;
}
c.back()++;
}
return c;
}
template <class T> struct nval {
lint n;
T val;
nval() : n(0){};
nval(lint _n, T _val) : n(_n), val(_val){};
};
template <class It> auto carr2(It begin, It end) {
using T = nval<remove_reference_t<decltype(*begin)>>;
vect<T> c;
c.push_back(T(1, *begin));
auto before = *begin;
for (auto it = begin + 1; it != end; it++) {
if (before != *it) {
c.push_back(T(0, *it));
before = *it;
}
c.back().n++;
}
return c;
}
template <class It, class... T> void sort2(It begin, It end, T... p) {
using val_t = remove_reference_t<decltype(*begin)>;
sort(begin, end, [p...](const val_t &a, const val_t &b) {
bool neq[] = {(a.*p != b.*p)...};
bool sg[] = {(a.*p < b.*p)...};
rep(i, sizeof...(p)) {
if (neq[i]) {
return sg[i];
}
}
return false;
});
}
template <class It, class It2> auto spacel(It i, It2 end) {
if (i + 1 == end) {
return '\n';
} else {
return ' ';
}
}
bool match(string s, string r) { return regex_match(s, regex(r)); }
ostream &setp(ostream &ost) {
cout << setprecision(60) << fixed;
return ost;
}
#ifdef _LOCAL
auto &dbg = cout;
#else
struct dummy_cout {
template <class T> dummy_cout &operator<<(T &&op) { return *this; }
using endl_t = basic_ostream<char, char_traits<char>>;
dummy_cout &operator<<(endl_t &(*)(endl_t &)) { return *this; }
};
dummy_cout dbg;
#endif
const ulint mod = 1000000007;
// const ulint mod = 998244353;
const ld eps = 0.0000001;
}; // namespace
int main() {
lint d;
cin >> d;
vec c(26);
rep(i, 26) cin >> c[i];
vec2 s(d + 1, 26, 0);
repb(i, 1, d) rep(j, 26) cin >> s[i][j];
vec ld(26, 0);
vec t(d + 1);
repb(i, 1, d) { t[i] = (i - 1) % 26; }
repb(i, 1, d) cout << t[i] + 1 << endl;
lint score = 0;
set<lint> ll[26];
rep(i, 26) {
ll[i].insert(0);
ll[i].insert(d + 1);
}
repb(i, 1, d) { ll[t[i]].insert(i); }
rep(i, 26) {
auto itend = ll[i].end();
itend--;
for (auto it = ll[i].begin(); it != itend; it++) {
auto ita = it;
ita++;
score -= c[i] * (*ita - *it) * (*ita - *it - 1) / 2;
score += s[*it][i];
}
}
auto f = [&](lint dd, lint q) {
q--;
score -= s[dd][t[dd]];
score += s[dd][q];
auto it = ll[t[dd]].find(dd);
auto ita = it, itb = it;
itb--;
ita++;
score -= c[t[dd]] * (*ita - dd) * (dd - *itb);
ll[t[dd]].erase(dd);
ll[q].insert(dd);
auto it2 = ll[q].find(dd);
auto it2a = it2, it2b = it2;
it2b--;
it2a++;
score += c[q] * (*it2a - dd) * (dd - *it2b);
t[dd] = q;
};
return 0;
}
| replace | 300 | 301 | 300 | 301 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
// typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
typedef vector<int> Vi;
// typedef tuple<int, int, int> T;
#define FOR(i, s, x) for (int i = s; i < (int)(x); i++)
#define REP(i, x) FOR(i, 0, x)
#define ALL(c) c.begin(), c.end()
#define DUMP(x) cerr << #x << " = " << (x) << endl
const int dr[4] = {-1, 0, 1, 0};
const int dc[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
using std::chrono::system_clock;
int D;
int C[26];
std::vector<std::vector<int>> S;
const int INF = 1e9;
std::vector<int> T;
system_clock::time_point start;
void init() {
std::cin >> D;
REP(i, 26) std::cin >> C[i];
S.resize(D);
REP(i, D) {
S[i].resize(26);
REP(j, 26) std::cin >> S[i][j];
}
T.resize(D, -1);
}
std::vector<int> prev_days;
int calc_score(std::vector<int> &contests, bool verbose = false) {
int score = 0;
prev_days.assign(26, -1);
REP(i, contests.size()) {
prev_days[contests[i]] = i;
if (verbose) {
for (int d : prev_days)
std::cerr << d << ' ';
std::cerr << endl;
}
REP(j, 26) { score -= C[j] * (i - prev_days[j]); }
score += S[i][contests[i]];
if (verbose) {
std::cerr << score << std::endl;
}
}
return score;
}
void output() {
for (int t : T)
std::cout << t + 1 << '\n';
}
void greedy() {
std::vector<int> contests;
REP(d, D) {
int max_score = -INF, max_con = -1;
REP(i, 26) {
contests.emplace_back(i);
int new_score = calc_score(contests);
if (new_score > max_score) {
max_score = new_score;
max_con = i;
}
contests.pop_back();
}
contests.emplace_back(max_con);
}
T = contests;
std::cerr << calc_score(T) << endl;
}
bool update_greedy() {
int score = calc_score(T);
bool is_updated = false;
int day = -1, cont = -1;
REP(d, D) {
REP(i, 26) {
int tmp = T[d];
T[d] = i;
int new_score = calc_score(T);
if (new_score > score) {
new_score = score;
is_updated = true;
day = d, cont = i;
}
T[d] = tmp;
}
}
if (is_updated)
T[day] = cont;
return is_updated;
}
void greedy2() {
while (true) {
double diff = std::chrono::duration_cast<std::chrono::milliseconds>(
system_clock::now() - start)
.count() /
1000.;
if (diff > 1.99)
break;
if (not update_greedy()) {
break;
}
}
std::cerr << calc_score(T) << endl;
}
int main() {
start = system_clock::now();
// use scanf in CodeForces!
cin.tie(0);
ios_base::sync_with_stdio(false);
init();
greedy();
greedy2();
output();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
// typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
typedef vector<int> Vi;
// typedef tuple<int, int, int> T;
#define FOR(i, s, x) for (int i = s; i < (int)(x); i++)
#define REP(i, x) FOR(i, 0, x)
#define ALL(c) c.begin(), c.end()
#define DUMP(x) cerr << #x << " = " << (x) << endl
const int dr[4] = {-1, 0, 1, 0};
const int dc[4] = {0, 1, 0, -1};
const ll mod = 1e9 + 7;
using std::chrono::system_clock;
int D;
int C[26];
std::vector<std::vector<int>> S;
const int INF = 1e9;
std::vector<int> T;
system_clock::time_point start;
void init() {
std::cin >> D;
REP(i, 26) std::cin >> C[i];
S.resize(D);
REP(i, D) {
S[i].resize(26);
REP(j, 26) std::cin >> S[i][j];
}
T.resize(D, -1);
}
std::vector<int> prev_days;
int calc_score(std::vector<int> &contests, bool verbose = false) {
int score = 0;
prev_days.assign(26, -1);
REP(i, contests.size()) {
prev_days[contests[i]] = i;
if (verbose) {
for (int d : prev_days)
std::cerr << d << ' ';
std::cerr << endl;
}
REP(j, 26) { score -= C[j] * (i - prev_days[j]); }
score += S[i][contests[i]];
if (verbose) {
std::cerr << score << std::endl;
}
}
return score;
}
void output() {
for (int t : T)
std::cout << t + 1 << '\n';
}
void greedy() {
std::vector<int> contests;
REP(d, D) {
int max_score = -INF, max_con = -1;
REP(i, 26) {
contests.emplace_back(i);
int new_score = calc_score(contests);
if (new_score > max_score) {
max_score = new_score;
max_con = i;
}
contests.pop_back();
}
contests.emplace_back(max_con);
}
T = contests;
std::cerr << calc_score(T) << endl;
}
bool update_greedy() {
int score = calc_score(T);
bool is_updated = false;
int day = -1, cont = -1;
REP(d, D) {
REP(i, 26) {
int tmp = T[d];
T[d] = i;
int new_score = calc_score(T);
if (new_score > score) {
new_score = score;
is_updated = true;
day = d, cont = i;
}
T[d] = tmp;
}
}
if (is_updated)
T[day] = cont;
return is_updated;
}
void greedy2() {
while (true) {
double diff = std::chrono::duration_cast<std::chrono::milliseconds>(
system_clock::now() - start)
.count() /
1000.;
if (diff > 1.95)
break;
if (not update_greedy()) {
break;
}
}
std::cerr << calc_score(T) << endl;
}
int main() {
start = system_clock::now();
// use scanf in CodeForces!
cin.tie(0);
ios_base::sync_with_stdio(false);
init();
greedy();
greedy2();
output();
return 0;
}
| replace | 114 | 115 | 114 | 115 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
} else {
return false;
}
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
} else {
return false;
}
}
#define ll long long
#define double long double
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, n) for (int i = 1; i <= (n); i++)
#define mod (ll)(1e9 + 7)
#define inf (ll)(3e18 + 7)
#define pi (double)acos(-1.0)
#define P pair<int, int>
#define PiP pair<int, pair<int, int>>
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
using namespace std;
int d;
vector<int> c(26);
vector<vector<int>> s(400, vector<int>(26));
int get_score(vector<int> t) {
int ans = 0;
vector<int> last(26, 0);
rep(i, d) {
ans += s[i][t[i]];
rep(j, 26) {
if (t[i] == j)
last[j] = i + 1;
ans -= c[j] * ((i + 1) - last[j]);
}
}
return ans;
}
int main() {
cin >> d;
rep(i, 26) cin >> c[i];
rep(i, d) rep(j, 26) cin >> s[i][j];
//-----code------//
vector<int> t(d, 0);
int m;
cin >> m;
while ((clock() / CLOCKS_PER_SEC) < 1.9) {
int D = rand() % d, q = rand() % 26;
int old = t[D], olds = get_score(t);
t[D] = q;
if (get_score(t) < olds)
t[D] = old;
}
rep(i, d) cout << t[i] + 1 << endl;
}
| #include <bits/stdc++.h>
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
} else {
return false;
}
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
} else {
return false;
}
}
#define ll long long
#define double long double
#define rep(i, n) for (int i = 0; i < (n); i++)
#define REP(i, n) for (int i = 1; i <= (n); i++)
#define mod (ll)(1e9 + 7)
#define inf (ll)(3e18 + 7)
#define pi (double)acos(-1.0)
#define P pair<int, int>
#define PiP pair<int, pair<int, int>>
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
using namespace std;
int d;
vector<int> c(26);
vector<vector<int>> s(400, vector<int>(26));
int get_score(vector<int> t) {
int ans = 0;
vector<int> last(26, 0);
rep(i, d) {
ans += s[i][t[i]];
rep(j, 26) {
if (t[i] == j)
last[j] = i + 1;
ans -= c[j] * ((i + 1) - last[j]);
}
}
return ans;
}
int main() {
cin >> d;
rep(i, 26) cin >> c[i];
rep(i, d) rep(j, 26) cin >> s[i][j];
//-----code------//
vector<int> t(d, 0);
int m;
cin >> m;
rep(i, 100000) {
int D = rand() % d, q = rand() % 26;
int old = t[D], olds = get_score(t);
t[D] = q;
if (get_score(t) < olds)
t[D] = old;
}
rep(i, d) cout << t[i] + 1 << endl;
}
| replace | 56 | 57 | 56 | 57 | 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;
}
unsigned int myrand() {
static unsigned int x = 192047155, y = 392751284, z = 194681846,
w = 193571838;
unsigned int t;
t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
}
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;
}
bool check(int diff, int time) {
if (diff < 0)
return true;
return myrand() >= diff * (clock() - time) * 1.2;
}
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 = 1;
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 (myrand() % 3) {
int day, contest, prevcontest;
day = myrand() % D + 1;
contest = myrand() % 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 = myrand() % D + 1;
int w = myrand() % (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;
}
unsigned int myrand() {
static unsigned int x = 192047155, y = 392751284, z = 194681846,
w = 193571838;
unsigned int t;
t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
}
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;
}
bool check(int diff, int time) {
if (diff < 0)
return true;
return myrand() >= diff * (clock() - time) * 1.2;
}
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 = 1;
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 (myrand() % 3) {
int day, contest, prevcontest;
day = myrand() % D + 1;
contest = myrand() % 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 = myrand() % D + 1;
int w = myrand() % (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 | 157 | 159 | 157 | 159 | -8 | |
p02618 | C++ | Time Limit Exceeded | /**
* @brief atcoder
* @author yao
*/
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <utility>
#include <vector>
#define ft first
#define sd second
#ifdef DBG
#define dbg_pri(x...) fprintf(stderr, x)
#else
#define dbg_pri(x...) 0
#define NDEBUG
#endif // DBG
#include <cassert>
typedef unsigned int uint;
typedef long long int lli;
typedef unsigned long long int ulli;
#define N 512
#define M 32
#define K (1048576 * 16)
#define T (512 * 2)
int c[M];
int s[N][M];
int t[N];
std::vector<int> poi[M];
constexpr int n = 365, m = 26;
int count() {
for (int i = 0; i < m; ++i)
poi[i] = {-1};
int res = 0;
for (int i = 0; i < n; ++i) {
int l = poi[t[i]].back(), d = i - l;
poi[t[i]].push_back(i);
res += s[i][t[i]];
res -= c[t[i]] * d * (d - 1) / 2;
}
for (int i = 0; i < m; ++i) {
int l = poi[i].back(), d = n - l;
poi[i].push_back(n);
res -= c[i] * d * (d - 1) / 2;
}
return res;
}
int update(int x, int k) {
int pk = t[x];
int res = s[x][k] - s[x][pk];
std::vector<int>::iterator itl, it, itr;
it = std::find(poi[pk].begin(), poi[pk].end(), x), itl = std::prev(it),
itr = std::next(it);
res -= c[pk] * (x - *itl) * (*itr - x);
poi[pk].erase(it);
itr = std::upper_bound(poi[k].begin(), poi[k].end(), x), itl = std::prev(itr);
res += c[k] * (x - *itl) * (*itr - x);
poi[k].insert(itr, x);
t[x] = k;
return res;
}
int main() {
int d;
scanf("%d", &d);
assert(d == n);
for (int i = 0; i < m; ++i)
scanf("%d", &c[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
scanf("%d", &s[i][j]);
for (int i = 0; i < n; ++i)
t[i] = rand() % m;
int val = count();
#ifdef DBG
int init_val = val;
int ca = 0, cb = 0;
#endif // DBG
for (int i = 0; i < K; ++i) {
int x = rand() % n, k = rand() % m;
int pre_t = t[x];
int nxt_v = val + update(x, k);
if (nxt_v >= val ||
rand() <= (int)(exp((double)(nxt_v - val) / T) * ((lli)RAND_MAX + 1))) {
#ifdef DBG
(nxt_v < val ? ca : cb)++;
#endif // DBG
val = nxt_v;
} else
update(x, pre_t);
}
for (int i = 0; i < n; ++i)
printf("%d\n", t[i] + 1);
dbg_pri("poi 3: init=%d val=%d %d %d\n", init_val, val, ca, cb);
return 0;
}
| /**
* @brief atcoder
* @author yao
*/
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <utility>
#include <vector>
#define ft first
#define sd second
#ifdef DBG
#define dbg_pri(x...) fprintf(stderr, x)
#else
#define dbg_pri(x...) 0
#define NDEBUG
#endif // DBG
#include <cassert>
typedef unsigned int uint;
typedef long long int lli;
typedef unsigned long long int ulli;
#define N 512
#define M 32
#define K (1048576 * 12)
#define T (512 * 2)
int c[M];
int s[N][M];
int t[N];
std::vector<int> poi[M];
constexpr int n = 365, m = 26;
int count() {
for (int i = 0; i < m; ++i)
poi[i] = {-1};
int res = 0;
for (int i = 0; i < n; ++i) {
int l = poi[t[i]].back(), d = i - l;
poi[t[i]].push_back(i);
res += s[i][t[i]];
res -= c[t[i]] * d * (d - 1) / 2;
}
for (int i = 0; i < m; ++i) {
int l = poi[i].back(), d = n - l;
poi[i].push_back(n);
res -= c[i] * d * (d - 1) / 2;
}
return res;
}
int update(int x, int k) {
int pk = t[x];
int res = s[x][k] - s[x][pk];
std::vector<int>::iterator itl, it, itr;
it = std::find(poi[pk].begin(), poi[pk].end(), x), itl = std::prev(it),
itr = std::next(it);
res -= c[pk] * (x - *itl) * (*itr - x);
poi[pk].erase(it);
itr = std::upper_bound(poi[k].begin(), poi[k].end(), x), itl = std::prev(itr);
res += c[k] * (x - *itl) * (*itr - x);
poi[k].insert(itr, x);
t[x] = k;
return res;
}
int main() {
int d;
scanf("%d", &d);
assert(d == n);
for (int i = 0; i < m; ++i)
scanf("%d", &c[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
scanf("%d", &s[i][j]);
for (int i = 0; i < n; ++i)
t[i] = rand() % m;
int val = count();
#ifdef DBG
int init_val = val;
int ca = 0, cb = 0;
#endif // DBG
for (int i = 0; i < K; ++i) {
int x = rand() % n, k = rand() % m;
int pre_t = t[x];
int nxt_v = val + update(x, k);
if (nxt_v >= val ||
rand() <= (int)(exp((double)(nxt_v - val) / T) * ((lli)RAND_MAX + 1))) {
#ifdef DBG
(nxt_v < val ? ca : cb)++;
#endif // DBG
val = nxt_v;
} else
update(x, pre_t);
}
for (int i = 0; i < n; ++i)
printf("%d\n", t[i] + 1);
dbg_pri("poi 3: init=%d val=%d %d %d\n", init_val, val, ca, cb);
return 0;
}
| replace | 30 | 31 | 30 | 31 | TLE | |
p02618 | C++ | Time Limit Exceeded | /**
* @brief atcoder
* @author yao
*/
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <utility>
#include <vector>
#define ft first
#define sd second
#ifdef DBG
#define dbg_pri(x...) fprintf(stderr, x)
#else
#define dbg_pri(x...) 0
#define NDEBUG
#endif // DBG
#include <cassert>
typedef unsigned int uint;
typedef long long int lli;
typedef unsigned long long int ulli;
#define N 512
#define M 32
#define K (1048576 * 24)
#define T (256 * 6)
int c[M];
int s[N][M];
int t[N], max_t[N];
std::vector<int> poi[M];
constexpr int n = 365, m = 26;
int count() {
for (int i = 0; i < m; ++i)
poi[i] = {-1};
int res = 0;
for (int i = 0; i < n; ++i) {
int l = poi[t[i]].back(), d = i - l;
poi[t[i]].push_back(i);
res += s[i][t[i]];
res -= c[t[i]] * d * (d - 1) / 2;
}
for (int i = 0; i < m; ++i) {
int l = poi[i].back(), d = n - l;
poi[i].push_back(n);
res -= c[i] * d * (d - 1) / 2;
}
return res;
}
int pos, ot, nt;
std::vector<int>::iterator oil, oit, oir, nil, nir;
int update_dryrun(int x, int k) {
int res;
pos = x, ot = t[x], nt = k;
res = s[x][nt] - s[x][ot];
oit = std::find(poi[ot].begin(), poi[ot].end(), x), oil = std::prev(oit),
oir = std::next(oit);
res -= c[ot] * (x - *oil) * (*oir - x);
nir = std::upper_bound(poi[nt].begin(), poi[nt].end(), x),
nil = std::prev(nir);
res += c[nt] * (x - *nil) * (*nir - x);
return res;
}
void patch() {
const int &x = pos;
poi[ot].erase(oit);
poi[nt].insert(nir, x);
t[x] = nt;
}
int main() {
int d;
scanf("%d", &d);
assert(d == n);
for (int i = 0; i < m; ++i)
scanf("%d", &c[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
scanf("%d", &s[i][j]);
for (int i = 0; i < n; ++i)
t[i] = rand() % m;
memcpy(max_t, t, sizeof(max_t));
int val = count(), max_val = val;
#ifdef DBG
int init_val = val;
int ca = 0, cb = 0;
#endif // DBG
for (int i = 0; i < K; ++i) {
int x = rand() % n, k = rand() % (m - 1);
if (k >= t[x])
++k;
int nxt_v = val + update_dryrun(x, k);
if (nxt_v >= val ||
rand() <= (int)(exp((double)(nxt_v - val) / T) * ((lli)RAND_MAX + 1))) {
#ifdef DBG
(nxt_v < val ? ca : cb)++;
#endif // DBG
val = nxt_v;
patch();
if (max_val < val) {
max_val = val;
memcpy(max_t, t, sizeof(max_t));
}
}
}
for (int i = 0; i < n; ++i)
printf("%d\n", max_t[i] + 1);
dbg_pri("poi 3: init=%d max=%d val=%d %d %d\n", init_val, max_val, val, ca,
cb);
return 0;
}
| /**
* @brief atcoder
* @author yao
*/
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <utility>
#include <vector>
#define ft first
#define sd second
#ifdef DBG
#define dbg_pri(x...) fprintf(stderr, x)
#else
#define dbg_pri(x...) 0
#define NDEBUG
#endif // DBG
#include <cassert>
typedef unsigned int uint;
typedef long long int lli;
typedef unsigned long long int ulli;
#define N 512
#define M 32
#define K (1048576 * 20)
#define T (256 * 5)
int c[M];
int s[N][M];
int t[N], max_t[N];
std::vector<int> poi[M];
constexpr int n = 365, m = 26;
int count() {
for (int i = 0; i < m; ++i)
poi[i] = {-1};
int res = 0;
for (int i = 0; i < n; ++i) {
int l = poi[t[i]].back(), d = i - l;
poi[t[i]].push_back(i);
res += s[i][t[i]];
res -= c[t[i]] * d * (d - 1) / 2;
}
for (int i = 0; i < m; ++i) {
int l = poi[i].back(), d = n - l;
poi[i].push_back(n);
res -= c[i] * d * (d - 1) / 2;
}
return res;
}
int pos, ot, nt;
std::vector<int>::iterator oil, oit, oir, nil, nir;
int update_dryrun(int x, int k) {
int res;
pos = x, ot = t[x], nt = k;
res = s[x][nt] - s[x][ot];
oit = std::find(poi[ot].begin(), poi[ot].end(), x), oil = std::prev(oit),
oir = std::next(oit);
res -= c[ot] * (x - *oil) * (*oir - x);
nir = std::upper_bound(poi[nt].begin(), poi[nt].end(), x),
nil = std::prev(nir);
res += c[nt] * (x - *nil) * (*nir - x);
return res;
}
void patch() {
const int &x = pos;
poi[ot].erase(oit);
poi[nt].insert(nir, x);
t[x] = nt;
}
int main() {
int d;
scanf("%d", &d);
assert(d == n);
for (int i = 0; i < m; ++i)
scanf("%d", &c[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
scanf("%d", &s[i][j]);
for (int i = 0; i < n; ++i)
t[i] = rand() % m;
memcpy(max_t, t, sizeof(max_t));
int val = count(), max_val = val;
#ifdef DBG
int init_val = val;
int ca = 0, cb = 0;
#endif // DBG
for (int i = 0; i < K; ++i) {
int x = rand() % n, k = rand() % (m - 1);
if (k >= t[x])
++k;
int nxt_v = val + update_dryrun(x, k);
if (nxt_v >= val ||
rand() <= (int)(exp((double)(nxt_v - val) / T) * ((lli)RAND_MAX + 1))) {
#ifdef DBG
(nxt_v < val ? ca : cb)++;
#endif // DBG
val = nxt_v;
patch();
if (max_val < val) {
max_val = val;
memcpy(max_t, t, sizeof(max_t));
}
}
}
for (int i = 0; i < n; ++i)
printf("%d\n", max_t[i] + 1);
dbg_pri("poi 3: init=%d max=%d val=%d %d %d\n", init_val, max_val, val, ca,
cb);
return 0;
}
| replace | 30 | 32 | 30 | 32 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define Rep(i, a, b) for (ll i = a; i < b; ++i)
#define rep(i, b) Rep(i, 0, b)
#define allof(a) (a).begin(), (a).end()
#define Yes(q) ((q) ? "Yes" : "No")
#define YES(q) ((q) ? "YES" : "NO")
#define Possible(q) ((q) ? "Possible" : "Impossible")
#define POSSIBLE(q) ((q) ? "POSSIBLE" : "IMPOSSIBLE")
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll infll = 1ll << 60ll;
constexpr ll mod = 1e9 + 7;
// 0~3までは右下左上 4~7までは斜め
constexpr int dx[] = {1, 0, -1, 0, 1, -1};
constexpr int dy[] = {0, 1, 0, -1, 1, 1};
namespace {
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void Cout(long long x, const char *end = "\n") { std::cout << x << end; }
template <typename T> void Cout(const T &x, const char *end = "\n") {
std::cout << x << end;
}
template <typename T>
void Cout(const std::vector<T> &x, const char *sep = " ",
const char *end = "\n") {
for (std::size_t i = 0, sz = x.size(); i < sz; ++i) {
std::cout << x[i] << (i == sz - 1 ? end : sep);
}
}
// 標準入出力
struct inp {
std::size_t szi, szj;
inp(std::size_t _szi = 1, std::size_t _szj = 1) : szi(_szi), szj(_szj) {}
template <typename T> operator T() const {
T a;
std::cin >> a;
return a;
}
template <typename T> operator std::vector<T>() const {
std::vector<T> a(szi);
for (std::size_t i = 0; i < szi; ++i)
std::cin >> a[i];
return a;
}
template <typename T> operator std::vector<std::vector<T>>() const {
std::vector<std::vector<T>> a(szi, std::vector<T>(szj));
for (std::size_t i = 0; i < szi; ++i)
for (std::size_t j = 0; j < szj; ++j)
cin >> a[i][j];
return a;
}
};
inp inp1;
// int score_down[26]; // 満足度の下がりやすさ
// int score_up[365][26]; // 満足度の増加数
// int contest[365]; // コンテストのタイプ
// int last[26];
int d = 365;
// スコアを計算する
int CalcScore(vector<int> &score_down, vector<vector<int>> &score_up,
vector<int> &contest) {
int score = 0;
vector<int> last(26, -1);
rep(i, d) {
int type = contest[i] - 1;
// 満足度の増加
score += score_up[i][type];
last[type] = i;
// 時間による満足度の低下
rep(j, 26) { score -= score_down[j] * (i - last[j]); }
}
return score;
}
// スコアの差を計算する
int CalcScoreDiff(vector<int> &contest, vector<int> &score_down,
vector<vector<int>> &score_up, int first, int second,
int score) {
int tmp = contest[first];
contest[first] = second;
int new_score = CalcScore(score_down, score_up, contest);
contest[first] = tmp;
return new_score - score;
}
// 山登り法じゃない
int NotHillClimbing(vector<int> &contest, vector<int> &score_down,
vector<vector<int>> &score_up) {
// 初期スコアの計算
int score = 0;
score = CalcScore(score_down, score_up, contest);
int cnt = 0;
while (cnt++ < 5 * 360) {
for (int head = 1; head < d; ++head) {
// 変更先をランダムに
int type = rand() % 26 + 1;
int score_diff =
CalcScoreDiff(contest, score_down, score_up, head, type, score);
// よくなった
if (score_diff > 0) {
score += score_diff;
contest[head] = type;
}
}
}
return true;
}
// 初期のコンテストを設定
void InitializeContests(vector<int> &contests, vector<int> &score_down) {
//// コンテストを均等な数並べる
// vector<pair<int, int>> s_down(26);
// rep(i, 26) {
// s_down[i] = { score_down[i], i };
// }
// sort(allof(s_down), greater<pair<int, int>>());
//// コストの減少が大きい奴ほど量を多くする
// 今はランダムで...
rep(i, d) { contests[i] = rand() % 26 + 1; }
}
} // namespace
int main() {
srand((unsigned)time(NULL));
cin >> d;
vector<int> score_down = inp(26);
vector<vector<int>> score_up = inp(d, 26);
vector<int> contest(d, 1);
// とりあえず山登り法やってみる
InitializeContests(contest, score_down);
NotHillClimbing(contest, score_down, score_up);
Cout(contest, "\n");
return 0;
}
| #include <algorithm>
#include <cmath>
#include <complex>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define Rep(i, a, b) for (ll i = a; i < b; ++i)
#define rep(i, b) Rep(i, 0, b)
#define allof(a) (a).begin(), (a).end()
#define Yes(q) ((q) ? "Yes" : "No")
#define YES(q) ((q) ? "YES" : "NO")
#define Possible(q) ((q) ? "Possible" : "Impossible")
#define POSSIBLE(q) ((q) ? "POSSIBLE" : "IMPOSSIBLE")
using ll = long long;
constexpr int inf = 1e9 + 7;
constexpr ll infll = 1ll << 60ll;
constexpr ll mod = 1e9 + 7;
// 0~3までは右下左上 4~7までは斜め
constexpr int dx[] = {1, 0, -1, 0, 1, -1};
constexpr int dy[] = {0, 1, 0, -1, 1, 1};
namespace {
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
void Cout(long long x, const char *end = "\n") { std::cout << x << end; }
template <typename T> void Cout(const T &x, const char *end = "\n") {
std::cout << x << end;
}
template <typename T>
void Cout(const std::vector<T> &x, const char *sep = " ",
const char *end = "\n") {
for (std::size_t i = 0, sz = x.size(); i < sz; ++i) {
std::cout << x[i] << (i == sz - 1 ? end : sep);
}
}
// 標準入出力
struct inp {
std::size_t szi, szj;
inp(std::size_t _szi = 1, std::size_t _szj = 1) : szi(_szi), szj(_szj) {}
template <typename T> operator T() const {
T a;
std::cin >> a;
return a;
}
template <typename T> operator std::vector<T>() const {
std::vector<T> a(szi);
for (std::size_t i = 0; i < szi; ++i)
std::cin >> a[i];
return a;
}
template <typename T> operator std::vector<std::vector<T>>() const {
std::vector<std::vector<T>> a(szi, std::vector<T>(szj));
for (std::size_t i = 0; i < szi; ++i)
for (std::size_t j = 0; j < szj; ++j)
cin >> a[i][j];
return a;
}
};
inp inp1;
// int score_down[26]; // 満足度の下がりやすさ
// int score_up[365][26]; // 満足度の増加数
// int contest[365]; // コンテストのタイプ
// int last[26];
int d = 365;
// スコアを計算する
int CalcScore(vector<int> &score_down, vector<vector<int>> &score_up,
vector<int> &contest) {
int score = 0;
vector<int> last(26, -1);
rep(i, d) {
int type = contest[i] - 1;
// 満足度の増加
score += score_up[i][type];
last[type] = i;
// 時間による満足度の低下
rep(j, 26) { score -= score_down[j] * (i - last[j]); }
}
return score;
}
// スコアの差を計算する
int CalcScoreDiff(vector<int> &contest, vector<int> &score_down,
vector<vector<int>> &score_up, int first, int second,
int score) {
int tmp = contest[first];
contest[first] = second;
int new_score = CalcScore(score_down, score_up, contest);
contest[first] = tmp;
return new_score - score;
}
// 山登り法じゃない
int NotHillClimbing(vector<int> &contest, vector<int> &score_down,
vector<vector<int>> &score_up) {
// 初期スコアの計算
int score = 0;
score = CalcScore(score_down, score_up, contest);
int cnt = 0;
while (cnt++ < 5 * 30) {
for (int head = 1; head < d; ++head) {
// 変更先をランダムに
int type = rand() % 26 + 1;
int score_diff =
CalcScoreDiff(contest, score_down, score_up, head, type, score);
// よくなった
if (score_diff > 0) {
score += score_diff;
contest[head] = type;
}
}
}
return true;
}
// 初期のコンテストを設定
void InitializeContests(vector<int> &contests, vector<int> &score_down) {
//// コンテストを均等な数並べる
// vector<pair<int, int>> s_down(26);
// rep(i, 26) {
// s_down[i] = { score_down[i], i };
// }
// sort(allof(s_down), greater<pair<int, int>>());
//// コストの減少が大きい奴ほど量を多くする
// 今はランダムで...
rep(i, d) { contests[i] = rand() % 26 + 1; }
}
} // namespace
int main() {
srand((unsigned)time(NULL));
cin >> d;
vector<int> score_down = inp(26);
vector<vector<int>> score_up = inp(d, 26);
vector<int> contest(d, 1);
// とりあえず山登り法やってみる
InitializeContests(contest, score_down);
NotHillClimbing(contest, score_down, score_up);
Cout(contest, "\n");
return 0;
}
| replace | 132 | 133 | 132 | 133 | TLE | |
p02618 | C++ | Time Limit Exceeded | /*
Author:zeke
pass System Test!
GET AC!!
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using ld = long double;
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define rep3(var, min, max) for (ll(var) = (min); (var) < (max); ++(var))
#define repi3(var, min, max) for (ll(var) = (max)-1; (var) + 1 > (min); --(var))
#define Mp(a, b) make_pair((a), (b))
#define F first
#define S second
#define Icin(s) \
ll(s); \
cin >> (s);
#define Scin(s) \
ll(s); \
cin >> (s);
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;
}
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef vector<V> VV;
typedef vector<P> VP;
ll mod = 1e9 + 7;
ll MOD = 1e9 + 7;
ll INF = 1e18;
// cout << "Case #" << index << " :IMPOSSIBLE";
ll evaluate(VV &S, ll d, V &prev, V &C, ll j) {
ll temp = 0;
temp += S[d][j];
rep(k, 26) {
if (j == k) {
continue;
}
temp -= C[k] * (d - prev[k]);
}
return temp;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
ll d;
cin >> d;
V C(26);
rep(i, 26) cin >> C[i];
VV S(d, V(26));
rep(i, d) { rep(j, 26) cin >> S[i][j]; }
ll width = 330;
vector<tuple<ll, V, V>> vec;
V temp;
rep(i, 26) temp.push_back(-1);
V temp2;
vec.push_back({0, temp, temp2});
rep3(i, 0, d) {
priority_queue<tuple<ll, V, V>> q;
ll reg = -INF;
ll res = 0;
for (auto j : vec) {
ll score = get<0>(j);
V prev = get<1>(j);
V history = get<2>(j);
rep(k, 26) {
ll value = evaluate(S, i, prev, C, k);
V prev2 = prev;
prev2[k] = i;
V history2 = history;
history2.push_back(k);
q.push({score + value, prev2, history2});
}
}
vec = {};
for (ll j = 0; j < width && !q.empty(); j++) {
vec.push_back(q.top());
q.pop();
}
}
for (auto i : get<2>(vec[0])) {
cout << i + 1 << endl;
}
}
| /*
Author:zeke
pass System Test!
GET AC!!
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using ll = long long;
using ld = long double;
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define rep3(var, min, max) for (ll(var) = (min); (var) < (max); ++(var))
#define repi3(var, min, max) for (ll(var) = (max)-1; (var) + 1 > (min); --(var))
#define Mp(a, b) make_pair((a), (b))
#define F first
#define S second
#define Icin(s) \
ll(s); \
cin >> (s);
#define Scin(s) \
ll(s); \
cin >> (s);
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;
}
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef vector<V> VV;
typedef vector<P> VP;
ll mod = 1e9 + 7;
ll MOD = 1e9 + 7;
ll INF = 1e18;
// cout << "Case #" << index << " :IMPOSSIBLE";
ll evaluate(VV &S, ll d, V &prev, V &C, ll j) {
ll temp = 0;
temp += S[d][j];
rep(k, 26) {
if (j == k) {
continue;
}
temp -= C[k] * (d - prev[k]);
}
return temp;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
ll d;
cin >> d;
V C(26);
rep(i, 26) cin >> C[i];
VV S(d, V(26));
rep(i, d) { rep(j, 26) cin >> S[i][j]; }
ll width = 250;
vector<tuple<ll, V, V>> vec;
V temp;
rep(i, 26) temp.push_back(-1);
V temp2;
vec.push_back({0, temp, temp2});
rep3(i, 0, d) {
priority_queue<tuple<ll, V, V>> q;
ll reg = -INF;
ll res = 0;
for (auto j : vec) {
ll score = get<0>(j);
V prev = get<1>(j);
V history = get<2>(j);
rep(k, 26) {
ll value = evaluate(S, i, prev, C, k);
V prev2 = prev;
prev2[k] = i;
V history2 = history;
history2.push_back(k);
q.push({score + value, prev2, history2});
}
}
vec = {};
for (ll j = 0; j < width && !q.empty(); j++) {
vec.push_back(q.top());
q.pop();
}
}
for (auto i : get<2>(vec[0])) {
cout << i + 1 << endl;
}
}
| replace | 81 | 82 | 81 | 82 | TLE | |
p02618 | C++ | Time Limit Exceeded | #ifdef _MSC_VER
#include <__msvc_all_public_headers.hpp>
#undef min
#undef max
#else
#define NDEBUG
#include <bits/stdc++.h>
#endif
using namespace std;
using large = long long;
class XorShift {
public:
explicit XorShift(uint64_t x) : state_{x} {}
uint64_t operator()() noexcept { return next(state_); }
private:
static constexpr uint64_t next(uint64_t x) noexcept {
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
return x;
}
uint64_t state_;
};
static array<int, 26> C;
static array<array<int, 26>, 365> S; // S[day][type]
static array<int, 365> X;
static array<set<int>, 26> Days;
static array<array<int, 365>, 26> Gaining; // Gaining[type][day];
static array<array<int, 365>, 26> Losing; // Losing[type][day];
static large currentSatisfaction = 0;
static large eval(const array<int, 365> &x) {
large sat = 0;
for (auto ty = 0; ty < 26; ++ty) {
for (auto d = 0; d < 365; ++d) {
sat += Gaining[ty][d];
}
}
for (auto ty = 0; ty < 26; ++ty) {
for (auto d = 0; d < 365; ++d) {
sat -= Losing[ty][d];
}
}
currentSatisfaction = sat;
return sat;
}
static large update(int d, int ty) {
auto ty0 = X[d];
X[d] = ty;
auto dif = -Gaining[ty0][d];
Gaining[ty0][d] = 0;
Gaining[ty][d] = S[d][ty];
dif += S[d][ty];
auto v = (d > 0 ? Losing[ty0][d - 1] : 0) + C[ty0];
for (auto k = d; k < 365 && not(k != d && Losing[ty0][k] == 0); ++k) {
dif -= v;
Losing[ty0][k] += v;
}
v = Losing[ty][d];
for (auto k = d; k < 365 && Losing[ty][k] != 0; ++k) {
dif += v;
Losing[ty][k] -= v;
}
currentSatisfaction += dif;
return currentSatisfaction;
}
static void solve() {
auto rng = XorShift{std::random_device{}()};
for (auto type = 0; type < 26; ++type) {
Days[type].insert(-1);
Days[type].insert(1000);
}
auto init = array<int, 365>();
{
auto sat = 0LL;
auto elapsed = array<int, 26>();
for (auto d = 0; d < 365; ++d) {
auto Csum = 0;
for (auto t = 0; t < 26; ++t) {
elapsed[t]++;
Csum *= C[t] * elapsed[t];
}
auto s = array<large, 26>();
for (auto t = 0; t < 26; ++t) {
s[t] = S[d][t];
s[t] -= Csum;
s[t] += C[t] * elapsed[t];
}
auto itr = max_element(s.begin(), s.end());
auto ty = int(distance(s.begin(), itr));
elapsed[ty] = 0;
sat += S[d][ty];
for (auto t = 0; t < 26; ++t)
sat -= C[t] * elapsed[t];
init[d] = ty;
}
}
{
auto t = 0;
auto days_since_last = array<int, 26>();
for (auto d = 0; d < 365; ++d) {
t = init[d];
X[d] = t;
Days[t].insert(d);
Gaining[t][d] = S[d][t];
for (auto i = 0; i < 26; ++i) {
if (i == t)
days_since_last[i] = 0;
else
days_since_last[i]++;
Losing[i][d] = C[i] * days_since_last[i];
}
if (++t == 26)
t = 0;
}
}
// cerr << "Satisfaction: " << eval(X) << "\n";
auto sat = eval(X);
#if 1
constexpr int Repeat = 21;
for (auto Attempts = 100'000 * Repeat; Attempts--;) {
auto d = rng() % 365;
// auto d2 = (d < 10 ? d + 10 : d - 10);
auto x1 = X[d];
// auto x2 = X[d2];
auto best_x1 = X[d];
// auto best_x2 = X[d2];
auto best_s = sat;
for (auto Xd = 0; Xd < 26; ++Xd) {
if (Xd == x1)
continue;
auto s = update(d, Xd);
// s = update(d2, Xd);
// cerr << "d " << d << " : " << s << "\n";
if (s > best_s) {
best_s = s;
best_x1 = Xd;
// best_x2 = Xd;
}
}
sat = update(d, best_x1);
// sat = update(d2, best_x2);
assert(sat == best_s);
}
#endif
// cerr << "Result: " << sat << "\n";
}
int main() {
int d;
cin >> d;
// assert(d == 365);
for (auto &Ci : C)
cin >> Ci;
for (auto &row : S)
for (auto &elem : row)
cin >> elem;
solve();
// convert to 1-based
for (auto Xi : X)
cout << (Xi + 1) << "\n";
return 0;
}
| #ifdef _MSC_VER
#include <__msvc_all_public_headers.hpp>
#undef min
#undef max
#else
#define NDEBUG
#include <bits/stdc++.h>
#endif
using namespace std;
using large = long long;
class XorShift {
public:
explicit XorShift(uint64_t x) : state_{x} {}
uint64_t operator()() noexcept { return next(state_); }
private:
static constexpr uint64_t next(uint64_t x) noexcept {
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
return x;
}
uint64_t state_;
};
static array<int, 26> C;
static array<array<int, 26>, 365> S; // S[day][type]
static array<int, 365> X;
static array<set<int>, 26> Days;
static array<array<int, 365>, 26> Gaining; // Gaining[type][day];
static array<array<int, 365>, 26> Losing; // Losing[type][day];
static large currentSatisfaction = 0;
static large eval(const array<int, 365> &x) {
large sat = 0;
for (auto ty = 0; ty < 26; ++ty) {
for (auto d = 0; d < 365; ++d) {
sat += Gaining[ty][d];
}
}
for (auto ty = 0; ty < 26; ++ty) {
for (auto d = 0; d < 365; ++d) {
sat -= Losing[ty][d];
}
}
currentSatisfaction = sat;
return sat;
}
static large update(int d, int ty) {
auto ty0 = X[d];
X[d] = ty;
auto dif = -Gaining[ty0][d];
Gaining[ty0][d] = 0;
Gaining[ty][d] = S[d][ty];
dif += S[d][ty];
auto v = (d > 0 ? Losing[ty0][d - 1] : 0) + C[ty0];
for (auto k = d; k < 365 && not(k != d && Losing[ty0][k] == 0); ++k) {
dif -= v;
Losing[ty0][k] += v;
}
v = Losing[ty][d];
for (auto k = d; k < 365 && Losing[ty][k] != 0; ++k) {
dif += v;
Losing[ty][k] -= v;
}
currentSatisfaction += dif;
return currentSatisfaction;
}
static void solve() {
auto rng = XorShift{std::random_device{}()};
for (auto type = 0; type < 26; ++type) {
Days[type].insert(-1);
Days[type].insert(1000);
}
auto init = array<int, 365>();
{
auto sat = 0LL;
auto elapsed = array<int, 26>();
for (auto d = 0; d < 365; ++d) {
auto Csum = 0;
for (auto t = 0; t < 26; ++t) {
elapsed[t]++;
Csum *= C[t] * elapsed[t];
}
auto s = array<large, 26>();
for (auto t = 0; t < 26; ++t) {
s[t] = S[d][t];
s[t] -= Csum;
s[t] += C[t] * elapsed[t];
}
auto itr = max_element(s.begin(), s.end());
auto ty = int(distance(s.begin(), itr));
elapsed[ty] = 0;
sat += S[d][ty];
for (auto t = 0; t < 26; ++t)
sat -= C[t] * elapsed[t];
init[d] = ty;
}
}
{
auto t = 0;
auto days_since_last = array<int, 26>();
for (auto d = 0; d < 365; ++d) {
t = init[d];
X[d] = t;
Days[t].insert(d);
Gaining[t][d] = S[d][t];
for (auto i = 0; i < 26; ++i) {
if (i == t)
days_since_last[i] = 0;
else
days_since_last[i]++;
Losing[i][d] = C[i] * days_since_last[i];
}
if (++t == 26)
t = 0;
}
}
// cerr << "Satisfaction: " << eval(X) << "\n";
auto sat = eval(X);
#if 1
constexpr int Repeat = 18;
for (auto Attempts = 100'000 * Repeat; Attempts--;) {
auto d = rng() % 365;
// auto d2 = (d < 10 ? d + 10 : d - 10);
auto x1 = X[d];
// auto x2 = X[d2];
auto best_x1 = X[d];
// auto best_x2 = X[d2];
auto best_s = sat;
for (auto Xd = 0; Xd < 26; ++Xd) {
if (Xd == x1)
continue;
auto s = update(d, Xd);
// s = update(d2, Xd);
// cerr << "d " << d << " : " << s << "\n";
if (s > best_s) {
best_s = s;
best_x1 = Xd;
// best_x2 = Xd;
}
}
sat = update(d, best_x1);
// sat = update(d2, best_x2);
assert(sat == best_s);
}
#endif
// cerr << "Result: " << sat << "\n";
}
int main() {
int d;
cin >> d;
// assert(d == 365);
for (auto &Ci : C)
cin >> Ci;
for (auto &row : S)
for (auto &elem : row)
cin >> elem;
solve();
// convert to 1-based
for (auto Xi : X)
cout << (Xi + 1) << "\n";
return 0;
}
| replace | 141 | 142 | 141 | 142 | TLE | |
p02618 | C++ | Time Limit Exceeded | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
constexpr int CONTEST = 26;
constexpr int D = 365;
int C[CONTEST];
int S[D + 1][CONTEST];
/////////////////////////////////////////////////////////////////////////
// TIME MANAGEMENT
/////////////////////////////////////////////////////////////////////////
// const double TIME_LIMIT = 1900;
const double TIME_LIMIT = 19000;
struct TimeManager {
double lim;
double elapsed;
chrono::system_clock::time_point t_start;
TimeManager() {
t_start = chrono::system_clock::now();
lim = TIME_LIMIT;
}
template <typename T> TimeManager(const T &t) {
t_start = chrono::system_clock::now();
lim = static_cast<double>(t);
}
void set_time() { t_start = chrono::system_clock::now(); }
void update() {
auto t_now = chrono::system_clock::now();
elapsed =
chrono::duration_cast<chrono::milliseconds>(t_now - t_start).count();
}
bool is_timeover() { return elapsed > lim; }
double passed_ratio() {
// update();
return elapsed / lim;
}
template <typename T> bool is_passed(const T &r) {
double tmp = static_cast<double>(r);
return tmp > passed_ratio();
}
};
TimeManager t_manager;
/////////////////////////////////////////////////////////////////////////
// TIME MANAGEMENT END
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
// XORSHIFT
/////////////////////////////////////////////////////////////////////////
int xorShift() {
static unsigned long long x = 88172645463325252ULL;
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
return int(x & 0x7fffffff);
}
/////////////////////////////////////////////////////////////////////////
// XORSHIFT END
/////////////////////////////////////////////////////////////////////////
int cur_score = 0, best_score = 0;
int cur_schedule[D + 1], best_schedule[D + 1];
set<int> st[CONTEST];
int last[CONTEST];
void initializer() {
for (int i = 1; i <= D; i++) {
int val = -1;
int idx = -1;
for (int j = 0; j < CONTEST; j++) {
if (val < S[i][j]) {
val = S[i][j];
idx = j;
}
}
cur_schedule[i] = idx;
st[idx].insert(i);
}
for (int i = 0; i < CONTEST; i++) {
st[i].insert(0);
st[i].insert(D + 1);
}
}
int calcScore() {
int res = 0;
for (int i = 0; i < CONTEST; i++)
last[i] = 0;
for (int i = 1; i <= D; i++) {
int &col = cur_schedule[i];
int d = i - last[col];
res += S[i][col];
res -= C[col] * d * (d - 1) / 2;
last[col] = i;
}
for (int i = 0; i < CONTEST; i++) {
int d = D + 1 - last[i];
res -= C[i] * d * (d - 1) / 2;
}
return res;
}
int update_ = 0;
bool updateBest() {
if (best_score >= cur_score)
return false;
best_score = cur_score;
for (int i = 1; i <= D; i++)
best_schedule[i] = cur_schedule[i];
update_++;
return true;
}
bool updateBest(const int &at, const int &col) {
if (best_score >= cur_score)
return false;
best_score = cur_score;
best_schedule[at] = col;
update_++;
return true;
}
double start_temp;
double end_temp;
int changed_ = 0;
bool SA(const int &nxt_score, const int &old_score) {
if (old_score <= nxt_score) {
changed_++;
return true;
}
double temp = start_temp + (end_temp - start_temp) * t_manager.passed_ratio();
double prob = exp((nxt_score - old_score) / temp);
if (prob > (double)(xorShift() % 100) / 100) {
changed_++;
return true;
}
return false;
}
int step = 0;
void change(const int &at, const int &col) {
int rem = cur_schedule[at];
if (rem == col)
return;
// if (!st[rem].count(at)) {
// cerr << "st[rem].count(at) == 0" << endl;
// cerr << rem << " " << at << endl;
// cerr << "step = " << step << endl;
// for (int i = 1; i <= D; i++) {
// cerr << i << " " << cur_schedule[i] << endl;
// }
// }
// assert(st[rem].count(at));
// if (st[col].count(at)) {
// cerr << "st[col].count(at) == 1" << endl;
// cerr << col << " " << at << endl;
// cerr << "step = " << step << endl;
// for (int i = 0; i <= D; i++) {
// cerr << i << " " << cur_schedule[i] << endl;
// }
// }
// assert(!st[col].count(at));
cur_schedule[at] = col;
st[rem].erase(at);
st[col].insert(at);
updateBest(at, col);
}
int tryChange(const int &at, const int &col, const int &base_score) {
if (cur_schedule[at] == col)
return false;
int rem = cur_schedule[at];
int res = base_score;
// removal
{
res -= S[at][rem];
auto nxt = st[rem].find(at);
auto pre = prev(nxt);
nxt++;
int d = at - *pre;
res += C[rem] * d * (d - 1) / 2;
d = *nxt - at;
res += C[rem] * d * (d - 1) / 2;
d = *nxt - *pre;
res -= C[rem] * d * (d - 1) / 2;
}
// adding
{
res += S[at][col];
auto nxt = st[col].upper_bound(at);
auto pre = prev(nxt);
int d = *nxt - *pre;
res += C[col] * d * (d - 1) / 2;
d = at - *pre;
res -= C[col] * d * (d - 1) / 2;
d = *nxt - at;
res -= C[col] * d * (d - 1) / 2;
}
return res;
}
int fail_ = 0;
int replace_ = 0;
bool replace() {
step++;
int at = xorShift() % D + 1;
int col = xorShift() % CONTEST;
int old_score = cur_score;
int nxt_score = tryChange(at, col, cur_score);
if (SA(nxt_score, old_score)) {
replace_++;
cur_score = nxt_score;
change(at, col);
return true;
} else {
cur_score = old_score;
fail_++;
}
return false;
}
int shift_ = 0;
bool shift() {
step++;
int at = xorShift() % D + 1;
int col = cur_schedule[at];
int pre_at = *prev(st[col].find(at));
int cnt = 0;
int at2 = max(1, at - xorShift() % 6 - 1);
if (cur_schedule[at2] == col)
return false;
int old_score = cur_score;
int nxt_score = tryChange(at2, col, cur_score);
nxt_score = tryChange(at, cur_schedule[at2], nxt_score);
if (SA(nxt_score, old_score)) {
cur_score = nxt_score;
change(at2, col);
change(at, cur_schedule[at2]);
shift_++;
return true;
}
return false;
for (int i = pre_at + 1; i < at; i++) {
if (cur_schedule[i] != col) {
int old_score = cur_score;
int nxt_score = tryChange(i, col, cur_score);
nxt_score = tryChange(at, cur_schedule[i], nxt_score);
if (SA(nxt_score, old_score)) {
cur_score = nxt_score;
change(i, col);
change(at, cur_schedule[i]);
shift_++;
return true;
} else {
cur_score = old_score;
}
}
}
return false;
for (int i = pre_at + 1; i < at && cnt < 100; i++) {
for (int j = i + 1; j < at && cnt < 0; j++) {
if (cur_schedule[i] != col && cur_schedule[i] != cur_schedule[j] &&
cur_schedule[j] != col) {
int old_score = cur_score;
int nxt_score = tryChange(i, col, cur_score);
nxt_score = tryChange(j, cur_schedule[i], nxt_score);
nxt_score = tryChange(at, cur_schedule[j], nxt_score);
if (SA(nxt_score, old_score)) {
cur_score = nxt_score;
change(i, col);
change(j, cur_schedule[i]);
change(at, cur_schedule[j]);
shift_++;
return true;
} else {
cur_score = old_score;
}
}
cnt++;
}
}
return false;
}
void init() {
int t;
cin >> t;
for (int i = 0; i < CONTEST; i++)
cin >> C[i];
for (int i = 1; i <= D; i++) {
for (int j = 0; j < CONTEST; j++) {
cin >> S[i][j];
}
}
initializer();
cur_score = calcScore();
best_score = -(1e9);
updateBest();
start_temp = (double)abs(cur_score) / 1e6;
end_temp = 0;
t_manager.update();
}
void output() {
for (int i = 1; i <= D; i++) {
cout << best_schedule[i] + 1 << endl;
}
}
void displeyInfo() {
cerr << endl;
cerr << "cur_score = " << cur_score << endl;
cerr << "best_score = " << best_score << endl;
cerr << "step = " << step << endl;
cerr << "changed = " << changed_ << endl;
cerr << "replace = " << replace_ << endl;
cerr << "shift = " << shift_ << endl;
cerr << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
init();
for (int i = 0; !t_manager.is_timeover(); i++) {
if (i % 255 == 0) {
t_manager.update();
}
bool upd = false;
if (i % 2 == 0)
replace();
else
upd |= shift();
updateBest();
// if (i % 30000 == 0) {
// displeyInfo();
// }
}
// displeyInfo();
// t_manager.update();
// cerr << "time passed = " << setprecision(3) << fixed <<
// t_manager.passed_ratio() << endl;
output();
return 0;
// B
cur_score = calcScore();
cerr << cur_score << endl;
// // B
int res = 0;
for (int i = 1; i <= D; i++) {
for (int j = 0; j < CONTEST; j++) {
if (j == cur_schedule[i]) {
res += S[i][j];
}
int k = 0;
for (int l = 1; l <= i; l++)
if (cur_schedule[l] == j)
k = l;
res -= C[j] * (i - k);
}
// cout << res << endl;
}
cerr << res << endl;
return 0;
} | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
constexpr int CONTEST = 26;
constexpr int D = 365;
int C[CONTEST];
int S[D + 1][CONTEST];
/////////////////////////////////////////////////////////////////////////
// TIME MANAGEMENT
/////////////////////////////////////////////////////////////////////////
const double TIME_LIMIT = 1900;
// const double TIME_LIMIT = 19000;
struct TimeManager {
double lim;
double elapsed;
chrono::system_clock::time_point t_start;
TimeManager() {
t_start = chrono::system_clock::now();
lim = TIME_LIMIT;
}
template <typename T> TimeManager(const T &t) {
t_start = chrono::system_clock::now();
lim = static_cast<double>(t);
}
void set_time() { t_start = chrono::system_clock::now(); }
void update() {
auto t_now = chrono::system_clock::now();
elapsed =
chrono::duration_cast<chrono::milliseconds>(t_now - t_start).count();
}
bool is_timeover() { return elapsed > lim; }
double passed_ratio() {
// update();
return elapsed / lim;
}
template <typename T> bool is_passed(const T &r) {
double tmp = static_cast<double>(r);
return tmp > passed_ratio();
}
};
TimeManager t_manager;
/////////////////////////////////////////////////////////////////////////
// TIME MANAGEMENT END
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
// XORSHIFT
/////////////////////////////////////////////////////////////////////////
int xorShift() {
static unsigned long long x = 88172645463325252ULL;
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
return int(x & 0x7fffffff);
}
/////////////////////////////////////////////////////////////////////////
// XORSHIFT END
/////////////////////////////////////////////////////////////////////////
int cur_score = 0, best_score = 0;
int cur_schedule[D + 1], best_schedule[D + 1];
set<int> st[CONTEST];
int last[CONTEST];
void initializer() {
for (int i = 1; i <= D; i++) {
int val = -1;
int idx = -1;
for (int j = 0; j < CONTEST; j++) {
if (val < S[i][j]) {
val = S[i][j];
idx = j;
}
}
cur_schedule[i] = idx;
st[idx].insert(i);
}
for (int i = 0; i < CONTEST; i++) {
st[i].insert(0);
st[i].insert(D + 1);
}
}
int calcScore() {
int res = 0;
for (int i = 0; i < CONTEST; i++)
last[i] = 0;
for (int i = 1; i <= D; i++) {
int &col = cur_schedule[i];
int d = i - last[col];
res += S[i][col];
res -= C[col] * d * (d - 1) / 2;
last[col] = i;
}
for (int i = 0; i < CONTEST; i++) {
int d = D + 1 - last[i];
res -= C[i] * d * (d - 1) / 2;
}
return res;
}
int update_ = 0;
bool updateBest() {
if (best_score >= cur_score)
return false;
best_score = cur_score;
for (int i = 1; i <= D; i++)
best_schedule[i] = cur_schedule[i];
update_++;
return true;
}
bool updateBest(const int &at, const int &col) {
if (best_score >= cur_score)
return false;
best_score = cur_score;
best_schedule[at] = col;
update_++;
return true;
}
double start_temp;
double end_temp;
int changed_ = 0;
bool SA(const int &nxt_score, const int &old_score) {
if (old_score <= nxt_score) {
changed_++;
return true;
}
double temp = start_temp + (end_temp - start_temp) * t_manager.passed_ratio();
double prob = exp((nxt_score - old_score) / temp);
if (prob > (double)(xorShift() % 100) / 100) {
changed_++;
return true;
}
return false;
}
int step = 0;
void change(const int &at, const int &col) {
int rem = cur_schedule[at];
if (rem == col)
return;
// if (!st[rem].count(at)) {
// cerr << "st[rem].count(at) == 0" << endl;
// cerr << rem << " " << at << endl;
// cerr << "step = " << step << endl;
// for (int i = 1; i <= D; i++) {
// cerr << i << " " << cur_schedule[i] << endl;
// }
// }
// assert(st[rem].count(at));
// if (st[col].count(at)) {
// cerr << "st[col].count(at) == 1" << endl;
// cerr << col << " " << at << endl;
// cerr << "step = " << step << endl;
// for (int i = 0; i <= D; i++) {
// cerr << i << " " << cur_schedule[i] << endl;
// }
// }
// assert(!st[col].count(at));
cur_schedule[at] = col;
st[rem].erase(at);
st[col].insert(at);
updateBest(at, col);
}
int tryChange(const int &at, const int &col, const int &base_score) {
if (cur_schedule[at] == col)
return false;
int rem = cur_schedule[at];
int res = base_score;
// removal
{
res -= S[at][rem];
auto nxt = st[rem].find(at);
auto pre = prev(nxt);
nxt++;
int d = at - *pre;
res += C[rem] * d * (d - 1) / 2;
d = *nxt - at;
res += C[rem] * d * (d - 1) / 2;
d = *nxt - *pre;
res -= C[rem] * d * (d - 1) / 2;
}
// adding
{
res += S[at][col];
auto nxt = st[col].upper_bound(at);
auto pre = prev(nxt);
int d = *nxt - *pre;
res += C[col] * d * (d - 1) / 2;
d = at - *pre;
res -= C[col] * d * (d - 1) / 2;
d = *nxt - at;
res -= C[col] * d * (d - 1) / 2;
}
return res;
}
int fail_ = 0;
int replace_ = 0;
bool replace() {
step++;
int at = xorShift() % D + 1;
int col = xorShift() % CONTEST;
int old_score = cur_score;
int nxt_score = tryChange(at, col, cur_score);
if (SA(nxt_score, old_score)) {
replace_++;
cur_score = nxt_score;
change(at, col);
return true;
} else {
cur_score = old_score;
fail_++;
}
return false;
}
int shift_ = 0;
bool shift() {
step++;
int at = xorShift() % D + 1;
int col = cur_schedule[at];
int pre_at = *prev(st[col].find(at));
int cnt = 0;
int at2 = max(1, at - xorShift() % 6 - 1);
if (cur_schedule[at2] == col)
return false;
int old_score = cur_score;
int nxt_score = tryChange(at2, col, cur_score);
nxt_score = tryChange(at, cur_schedule[at2], nxt_score);
if (SA(nxt_score, old_score)) {
cur_score = nxt_score;
change(at2, col);
change(at, cur_schedule[at2]);
shift_++;
return true;
}
return false;
for (int i = pre_at + 1; i < at; i++) {
if (cur_schedule[i] != col) {
int old_score = cur_score;
int nxt_score = tryChange(i, col, cur_score);
nxt_score = tryChange(at, cur_schedule[i], nxt_score);
if (SA(nxt_score, old_score)) {
cur_score = nxt_score;
change(i, col);
change(at, cur_schedule[i]);
shift_++;
return true;
} else {
cur_score = old_score;
}
}
}
return false;
for (int i = pre_at + 1; i < at && cnt < 100; i++) {
for (int j = i + 1; j < at && cnt < 0; j++) {
if (cur_schedule[i] != col && cur_schedule[i] != cur_schedule[j] &&
cur_schedule[j] != col) {
int old_score = cur_score;
int nxt_score = tryChange(i, col, cur_score);
nxt_score = tryChange(j, cur_schedule[i], nxt_score);
nxt_score = tryChange(at, cur_schedule[j], nxt_score);
if (SA(nxt_score, old_score)) {
cur_score = nxt_score;
change(i, col);
change(j, cur_schedule[i]);
change(at, cur_schedule[j]);
shift_++;
return true;
} else {
cur_score = old_score;
}
}
cnt++;
}
}
return false;
}
void init() {
int t;
cin >> t;
for (int i = 0; i < CONTEST; i++)
cin >> C[i];
for (int i = 1; i <= D; i++) {
for (int j = 0; j < CONTEST; j++) {
cin >> S[i][j];
}
}
initializer();
cur_score = calcScore();
best_score = -(1e9);
updateBest();
start_temp = (double)abs(cur_score) / 1e6;
end_temp = 0;
t_manager.update();
}
void output() {
for (int i = 1; i <= D; i++) {
cout << best_schedule[i] + 1 << endl;
}
}
void displeyInfo() {
cerr << endl;
cerr << "cur_score = " << cur_score << endl;
cerr << "best_score = " << best_score << endl;
cerr << "step = " << step << endl;
cerr << "changed = " << changed_ << endl;
cerr << "replace = " << replace_ << endl;
cerr << "shift = " << shift_ << endl;
cerr << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
init();
for (int i = 0; !t_manager.is_timeover(); i++) {
if (i % 255 == 0) {
t_manager.update();
}
bool upd = false;
if (i % 2 == 0)
replace();
else
upd |= shift();
updateBest();
// if (i % 30000 == 0) {
// displeyInfo();
// }
}
// displeyInfo();
// t_manager.update();
// cerr << "time passed = " << setprecision(3) << fixed <<
// t_manager.passed_ratio() << endl;
output();
return 0;
// B
cur_score = calcScore();
cerr << cur_score << endl;
// // B
int res = 0;
for (int i = 1; i <= D; i++) {
for (int j = 0; j < CONTEST; j++) {
if (j == cur_schedule[i]) {
res += S[i][j];
}
int k = 0;
for (int l = 1; l <= i; l++)
if (cur_schedule[l] == j)
k = l;
res -= C[j] * (i - k);
}
// cout << res << endl;
}
cerr << res << endl;
return 0;
}
| replace | 13 | 15 | 13 | 15 | TLE | |
p02618 | C++ | Time Limit Exceeded | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
constexpr int CONTEST = 26;
constexpr int D = 365;
int C[CONTEST];
int S[D + 1][CONTEST];
/////////////////////////////////////////////////////////////////////////
// TIME MANAGEMENT
/////////////////////////////////////////////////////////////////////////
// const double TIME_LIMIT = 100;
// const double TIME_LIMIT = 1900;
const double TIME_LIMIT = 19000;
struct TimeManager {
double lim;
double elapsed;
chrono::system_clock::time_point t_start;
TimeManager() {
t_start = chrono::system_clock::now();
lim = TIME_LIMIT;
}
template <typename T> TimeManager(const T &t) {
t_start = chrono::system_clock::now();
lim = static_cast<double>(t);
}
void set_time() { t_start = chrono::system_clock::now(); }
void update() {
auto t_now = chrono::system_clock::now();
elapsed =
chrono::duration_cast<chrono::milliseconds>(t_now - t_start).count();
}
bool is_timeover() { return elapsed > lim; }
double passed_ratio() {
// update();
return elapsed / lim;
}
template <typename T> bool is_passed(const T &r) {
double tmp = static_cast<double>(r);
return tmp > passed_ratio();
}
};
TimeManager t_manager;
/////////////////////////////////////////////////////////////////////////
// TIME MANAGEMENT END
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
// XORSHIFT
/////////////////////////////////////////////////////////////////////////
int xorShift() {
static unsigned long long x = 88172645463325252ULL;
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
return int(x & 0x7fffffff);
}
/////////////////////////////////////////////////////////////////////////
// XORSHIFT END
/////////////////////////////////////////////////////////////////////////
int cur_score = 0, best_score = 0;
int cur_schedule[D + 1], best_schedule[D + 1];
int last[CONTEST];
int score_col[CONTEST];
int score_col_old[CONTEST];
int idx2pos[CONTEST][D + 1];
int idx_num[CONTEST];
int pos2idx[CONTEST][D + 1];
bool changed_col[CONTEST];
bool used[CONTEST];
int siz_ca;
int changed_at[CONTEST];
int changed_to_col[CONTEST];
int changed_to_col_rev[CONTEST];
int calcScore() {
int res = 0;
for (int col = 0; col < CONTEST; col++) {
score_col[col] = 0;
int &score = score_col[col];
for (int i = 1; i < idx_num[col]; i++) {
score += S[idx2pos[col][i]][col];
int d = idx2pos[col][i] - idx2pos[col][i - 1];
score -= C[col] * d * (d - 1) / 2;
}
int d = (D + 1) - idx2pos[col][idx_num[col] - 1];
score -= C[col] * d * (d - 1) / 2;
res += score;
}
return res;
}
int calcScore(const int &base_score) {
int res = base_score;
for (int i = 0; i < CONTEST; i++)
if (changed_col[i]) {
int &col = i;
res -= score_col[col];
int &score = score_col[col];
score = 0;
for (int j = 1; j < idx_num[col]; j++) {
score += S[idx2pos[col][j]][col];
int d = idx2pos[col][j] - idx2pos[col][j - 1];
score -= C[col] * d * (d - 1) / 2;
}
int d = (D + 1) - idx2pos[col][idx_num[col] - 1];
score -= C[col] * d * (d - 1) / 2;
res += score;
}
// cout << "calcScore = " << res << endl;
return res;
}
bool change(const int &at, const int &col) {
int rem = cur_schedule[at];
assert(col != -1);
if (rem == col)
return false;
if (rem >= 0) {
int rem_idx = pos2idx[rem][at];
pos2idx[rem][at] = -1;
for (int i = rem_idx + 1; i < idx_num[rem]; i++) {
idx2pos[rem][i - 1] = idx2pos[rem][i];
pos2idx[rem][idx2pos[rem][i - 1]] = i - 1;
}
idx_num[rem]--;
}
if (idx2pos[col][idx_num[col] - 1] < at) {
idx2pos[col][idx_num[col]] = at;
pos2idx[col][idx2pos[col][idx_num[col]]] = idx_num[col];
} else {
bool done = false;
for (int i = 0; i < idx_num[col]; i++) {
if (idx2pos[col][i] > at) {
for (int j = idx_num[col]; j > i; j--) {
idx2pos[col][j] = idx2pos[col][j - 1];
pos2idx[col][idx2pos[col][j]] = j;
}
idx2pos[col][i] = at;
pos2idx[col][at] = i;
done = true;
break;
}
}
if (!done) {
cerr << at << " " << col << endl;
cerr << idx_num[col] << " " << idx2pos[col][idx_num[col] - 1] << endl;
}
assert(done);
}
idx_num[col]++;
cur_schedule[at] = col;
return true;
}
void initializer() {
for (int i = 1; i <= D; i++) {
int val = -1;
int idx = -1;
for (int j = 0; j < CONTEST; j++) {
if (val < S[i][j]) {
val = S[i][j];
idx = j;
}
}
assert(idx != -1);
change(i, idx);
}
}
int update_ = 0;
bool updateBest() {
if (best_score >= cur_score)
return false;
best_score = cur_score;
for (int i = 1; i <= D; i++)
best_schedule[i] = cur_schedule[i];
update_++;
return true;
}
bool updateBest(const int &siz, int at[], int col[]) {
if (best_score >= cur_score)
return false;
best_score = cur_score;
for (int i = 0; i < siz; i++)
best_schedule[at[i]] = col[i];
update_++;
return false;
}
int tryChange(const int &siz, int at[], int col[]) {
for (int i = 0; i < CONTEST; i++) {
score_col_old[i] = score_col[i];
changed_col[i] = false;
}
for (int i = 0; i < siz; i++) {
changed_to_col_rev[i] = cur_schedule[at[i]];
changed_col[cur_schedule[at[i]]] = true;
changed_col[col[i]] = true;
change(at[i], col[i]);
}
// return calcScore();
return calcScore(cur_score);
}
bool rollBack(const int &siz, int at[], int col[], const int &old_score) {
cur_score = old_score;
for (int i = 0; i < CONTEST; i++)
score_col[i] = score_col_old[i];
for (int i = 0; i < siz; i++) {
change(at[i], col[i]);
}
return true;
}
double start_temp;
double end_temp;
int changed_ = 0;
bool SA(const int &nxt_score, const int &old_score) {
if (old_score <= nxt_score) {
changed_++;
return true;
}
double temp = start_temp + (end_temp - start_temp) * t_manager.passed_ratio();
double prob = exp((double)(nxt_score - old_score) / temp);
if (prob > (double)(xorShift() % 100) / 100) {
changed_++;
return true;
}
return false;
}
int step = 0;
int replace_ = 0;
bool replaceAccept(const int &at, const int &col) {
return cur_schedule[at] != col;
}
bool replace() {
step++;
int at = xorShift() % D + 1;
int col = xorShift() % CONTEST;
for (int i = 0; i < 5 && !replaceAccept(at, col); i++) {
at = xorShift() % D + 1;
col = xorShift() % CONTEST;
}
if (!replaceAccept(at, col))
return false;
int old_score = cur_score;
siz_ca = 1;
changed_at[0] = at;
changed_to_col[0] = col;
int from = cur_schedule[at];
int new_score = tryChange(siz_ca, changed_at, changed_to_col);
if (SA(new_score, old_score)) {
cur_score = new_score;
updateBest(siz_ca, changed_at, changed_to_col);
// cout << "replace : " << "at = " << changed_at[0] << " from = " << from
// << " to = " << changed_to_col[0] << endl;
replace_++;
return true;
} else {
rollBack(siz_ca, changed_at, changed_to_col_rev, old_score);
return false;
}
}
int shift_ = 0;
bool shift() {
step++;
int at = xorShift() % D + 1;
int col = cur_schedule[at];
int pre_at = idx2pos[col][pos2idx[col][at] - 1];
for (int i = pre_at + 1; i < at; i++)
if (cur_schedule[i] != col) {
siz_ca = 0;
changed_at[siz_ca] = at;
changed_to_col[siz_ca] = cur_schedule[i];
siz_ca++;
changed_at[siz_ca] = i;
changed_to_col[siz_ca] = col;
siz_ca++;
int old_score = cur_score;
int new_score = tryChange(siz_ca, changed_at, changed_to_col);
if (SA(new_score, old_score)) {
cur_score = new_score;
updateBest(siz_ca, changed_at, changed_to_col);
shift_++;
return true;
} else {
rollBack(siz_ca, changed_at, changed_to_col_rev, old_score);
}
}
int cnt = 0;
for (int i = pre_at + 1; i < at && cnt < 30; i++)
if (cur_schedule[i] != col) {
int col2 = cur_schedule[i];
int pre_at2 = idx2pos[col2][pos2idx[col2][i] - 1];
for (int j = pre_at2 + 1; j < pre_at && cnt < 30; j++)
if (cur_schedule[i] != cur_schedule[j] && cur_schedule[j] != col) {
siz_ca = 0;
changed_at[siz_ca] = at;
changed_to_col[siz_ca] = cur_schedule[j];
siz_ca++;
changed_at[siz_ca] = i;
changed_to_col[siz_ca] = col;
siz_ca++;
changed_at[siz_ca] = j;
changed_to_col[siz_ca] = cur_schedule[i];
siz_ca++;
int old_score = cur_score;
int new_score = tryChange(siz_ca, changed_at, changed_to_col);
if (SA(new_score, old_score)) {
cur_score = new_score;
updateBest(siz_ca, changed_at, changed_to_col);
shift_++;
return true;
} else {
rollBack(siz_ca, changed_at, changed_to_col_rev, old_score);
}
cnt++;
}
}
return false;
}
void init() {
int t;
cin >> t;
for (int i = 0; i <= D; i++)
cur_schedule[i] = best_schedule[i] = -1;
for (int i = 0; i < CONTEST; i++) {
idx2pos[i][idx_num[i]++] = 0;
}
for (int i = 0; i < CONTEST; i++)
cin >> C[i];
for (int i = 1; i <= D; i++) {
for (int j = 0; j < CONTEST; j++) {
cin >> S[i][j];
}
}
initializer();
cur_score = calcScore();
best_score = -(1e9);
updateBest();
start_temp = (double)abs(cur_score) / 5e6;
end_temp = 0;
t_manager.update();
}
void output() {
for (int i = 1; i <= D; i++) {
assert(best_schedule[i] >= 0 && best_schedule[i] <= 25);
cout << best_schedule[i] + 1 << endl;
}
}
void displeyInfo() {
cerr << endl;
cerr << "cur_score = " << cur_score << endl;
cerr << "best_score = " << best_score << endl;
cerr << "step = " << step << endl;
cerr << "changed = " << changed_ << endl;
cerr << "replace = " << replace_ << endl;
cerr << "shift = " << shift_ << endl;
cerr << "time passed = " << setprecision(3) << fixed
<< t_manager.passed_ratio() << endl;
cerr << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
init();
// displeyInfo();
// int res = 0;
// for (int i = 1; i <= D; i++) {
// for (int j = 0; j < CONTEST; j++) {
// if (j == best_schedule[i]) {
// res += S[i][j];
// }
// int k = 0;
// for (int l = 1; l <= i; l++) if (best_schedule[l] == j) k = l;
// res -= C[j] * (i - k);
// }
// // cout << res << endl;
// }
// int res2 = 0;
// for (int i = 0; i < CONTEST; i++) res2 += score_col[i];
// cerr << cur_score << endl;
// cerr << best_score << endl;
// cerr << res << endl;
// cerr << res2 << endl;
for (int i = 0; !t_manager.is_timeover(); i++) {
if (i % 100 == 0) {
t_manager.update();
}
bool upd = false;
upd |= replace();
if (!upd)
upd |= shift();
updateBest();
// if (i % 30000 == 0) {
// displeyInfo();
// }
}
output();
// displeyInfo();
// for (int i = 1; i <= D; i++) cout << " " << i << " " << cur_schedule[i] <<
// endl; for (int i = 0; i < CONTEST; i++) {
// cout << "i = " << i << " idx_num[i] = " << idx_num[i] << endl;
// for (int j = 0; j < idx_num[i]; j++) {
// cout << idx2pos[i][j] << " ";
// }
// cout << endl;
// }
// cout << endl;
// res = 0;
// for (int i = 1; i <= D; i++) {
// for (int j = 0; j < CONTEST; j++) {
// if (j == best_schedule[i]) {
// res += S[i][j];
// }
// int k = 0;
// for (int l = 1; l <= i; l++) if (best_schedule[l] == j) k = l;
// res -= C[j] * (i - k);
// }
// // cout << res << endl;
// }
// res2 = 0;
// for (int i = 0; i < CONTEST; i++) res2 += score_col[i];
// cerr << cur_score << endl;
// cerr << best_score << endl;
// cerr << res << endl;
// cerr << res2 << endl;
return 0;
} | #define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
constexpr int CONTEST = 26;
constexpr int D = 365;
int C[CONTEST];
int S[D + 1][CONTEST];
/////////////////////////////////////////////////////////////////////////
// TIME MANAGEMENT
/////////////////////////////////////////////////////////////////////////
// const double TIME_LIMIT = 100;
const double TIME_LIMIT = 1900;
// const double TIME_LIMIT = 19000;
struct TimeManager {
double lim;
double elapsed;
chrono::system_clock::time_point t_start;
TimeManager() {
t_start = chrono::system_clock::now();
lim = TIME_LIMIT;
}
template <typename T> TimeManager(const T &t) {
t_start = chrono::system_clock::now();
lim = static_cast<double>(t);
}
void set_time() { t_start = chrono::system_clock::now(); }
void update() {
auto t_now = chrono::system_clock::now();
elapsed =
chrono::duration_cast<chrono::milliseconds>(t_now - t_start).count();
}
bool is_timeover() { return elapsed > lim; }
double passed_ratio() {
// update();
return elapsed / lim;
}
template <typename T> bool is_passed(const T &r) {
double tmp = static_cast<double>(r);
return tmp > passed_ratio();
}
};
TimeManager t_manager;
/////////////////////////////////////////////////////////////////////////
// TIME MANAGEMENT END
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
// XORSHIFT
/////////////////////////////////////////////////////////////////////////
int xorShift() {
static unsigned long long x = 88172645463325252ULL;
x ^= x << 13;
x ^= x >> 7;
x ^= x << 17;
return int(x & 0x7fffffff);
}
/////////////////////////////////////////////////////////////////////////
// XORSHIFT END
/////////////////////////////////////////////////////////////////////////
int cur_score = 0, best_score = 0;
int cur_schedule[D + 1], best_schedule[D + 1];
int last[CONTEST];
int score_col[CONTEST];
int score_col_old[CONTEST];
int idx2pos[CONTEST][D + 1];
int idx_num[CONTEST];
int pos2idx[CONTEST][D + 1];
bool changed_col[CONTEST];
bool used[CONTEST];
int siz_ca;
int changed_at[CONTEST];
int changed_to_col[CONTEST];
int changed_to_col_rev[CONTEST];
int calcScore() {
int res = 0;
for (int col = 0; col < CONTEST; col++) {
score_col[col] = 0;
int &score = score_col[col];
for (int i = 1; i < idx_num[col]; i++) {
score += S[idx2pos[col][i]][col];
int d = idx2pos[col][i] - idx2pos[col][i - 1];
score -= C[col] * d * (d - 1) / 2;
}
int d = (D + 1) - idx2pos[col][idx_num[col] - 1];
score -= C[col] * d * (d - 1) / 2;
res += score;
}
return res;
}
int calcScore(const int &base_score) {
int res = base_score;
for (int i = 0; i < CONTEST; i++)
if (changed_col[i]) {
int &col = i;
res -= score_col[col];
int &score = score_col[col];
score = 0;
for (int j = 1; j < idx_num[col]; j++) {
score += S[idx2pos[col][j]][col];
int d = idx2pos[col][j] - idx2pos[col][j - 1];
score -= C[col] * d * (d - 1) / 2;
}
int d = (D + 1) - idx2pos[col][idx_num[col] - 1];
score -= C[col] * d * (d - 1) / 2;
res += score;
}
// cout << "calcScore = " << res << endl;
return res;
}
bool change(const int &at, const int &col) {
int rem = cur_schedule[at];
assert(col != -1);
if (rem == col)
return false;
if (rem >= 0) {
int rem_idx = pos2idx[rem][at];
pos2idx[rem][at] = -1;
for (int i = rem_idx + 1; i < idx_num[rem]; i++) {
idx2pos[rem][i - 1] = idx2pos[rem][i];
pos2idx[rem][idx2pos[rem][i - 1]] = i - 1;
}
idx_num[rem]--;
}
if (idx2pos[col][idx_num[col] - 1] < at) {
idx2pos[col][idx_num[col]] = at;
pos2idx[col][idx2pos[col][idx_num[col]]] = idx_num[col];
} else {
bool done = false;
for (int i = 0; i < idx_num[col]; i++) {
if (idx2pos[col][i] > at) {
for (int j = idx_num[col]; j > i; j--) {
idx2pos[col][j] = idx2pos[col][j - 1];
pos2idx[col][idx2pos[col][j]] = j;
}
idx2pos[col][i] = at;
pos2idx[col][at] = i;
done = true;
break;
}
}
if (!done) {
cerr << at << " " << col << endl;
cerr << idx_num[col] << " " << idx2pos[col][idx_num[col] - 1] << endl;
}
assert(done);
}
idx_num[col]++;
cur_schedule[at] = col;
return true;
}
void initializer() {
for (int i = 1; i <= D; i++) {
int val = -1;
int idx = -1;
for (int j = 0; j < CONTEST; j++) {
if (val < S[i][j]) {
val = S[i][j];
idx = j;
}
}
assert(idx != -1);
change(i, idx);
}
}
int update_ = 0;
bool updateBest() {
if (best_score >= cur_score)
return false;
best_score = cur_score;
for (int i = 1; i <= D; i++)
best_schedule[i] = cur_schedule[i];
update_++;
return true;
}
bool updateBest(const int &siz, int at[], int col[]) {
if (best_score >= cur_score)
return false;
best_score = cur_score;
for (int i = 0; i < siz; i++)
best_schedule[at[i]] = col[i];
update_++;
return false;
}
int tryChange(const int &siz, int at[], int col[]) {
for (int i = 0; i < CONTEST; i++) {
score_col_old[i] = score_col[i];
changed_col[i] = false;
}
for (int i = 0; i < siz; i++) {
changed_to_col_rev[i] = cur_schedule[at[i]];
changed_col[cur_schedule[at[i]]] = true;
changed_col[col[i]] = true;
change(at[i], col[i]);
}
// return calcScore();
return calcScore(cur_score);
}
bool rollBack(const int &siz, int at[], int col[], const int &old_score) {
cur_score = old_score;
for (int i = 0; i < CONTEST; i++)
score_col[i] = score_col_old[i];
for (int i = 0; i < siz; i++) {
change(at[i], col[i]);
}
return true;
}
double start_temp;
double end_temp;
int changed_ = 0;
bool SA(const int &nxt_score, const int &old_score) {
if (old_score <= nxt_score) {
changed_++;
return true;
}
double temp = start_temp + (end_temp - start_temp) * t_manager.passed_ratio();
double prob = exp((double)(nxt_score - old_score) / temp);
if (prob > (double)(xorShift() % 100) / 100) {
changed_++;
return true;
}
return false;
}
int step = 0;
int replace_ = 0;
bool replaceAccept(const int &at, const int &col) {
return cur_schedule[at] != col;
}
bool replace() {
step++;
int at = xorShift() % D + 1;
int col = xorShift() % CONTEST;
for (int i = 0; i < 5 && !replaceAccept(at, col); i++) {
at = xorShift() % D + 1;
col = xorShift() % CONTEST;
}
if (!replaceAccept(at, col))
return false;
int old_score = cur_score;
siz_ca = 1;
changed_at[0] = at;
changed_to_col[0] = col;
int from = cur_schedule[at];
int new_score = tryChange(siz_ca, changed_at, changed_to_col);
if (SA(new_score, old_score)) {
cur_score = new_score;
updateBest(siz_ca, changed_at, changed_to_col);
// cout << "replace : " << "at = " << changed_at[0] << " from = " << from
// << " to = " << changed_to_col[0] << endl;
replace_++;
return true;
} else {
rollBack(siz_ca, changed_at, changed_to_col_rev, old_score);
return false;
}
}
int shift_ = 0;
bool shift() {
step++;
int at = xorShift() % D + 1;
int col = cur_schedule[at];
int pre_at = idx2pos[col][pos2idx[col][at] - 1];
for (int i = pre_at + 1; i < at; i++)
if (cur_schedule[i] != col) {
siz_ca = 0;
changed_at[siz_ca] = at;
changed_to_col[siz_ca] = cur_schedule[i];
siz_ca++;
changed_at[siz_ca] = i;
changed_to_col[siz_ca] = col;
siz_ca++;
int old_score = cur_score;
int new_score = tryChange(siz_ca, changed_at, changed_to_col);
if (SA(new_score, old_score)) {
cur_score = new_score;
updateBest(siz_ca, changed_at, changed_to_col);
shift_++;
return true;
} else {
rollBack(siz_ca, changed_at, changed_to_col_rev, old_score);
}
}
int cnt = 0;
for (int i = pre_at + 1; i < at && cnt < 30; i++)
if (cur_schedule[i] != col) {
int col2 = cur_schedule[i];
int pre_at2 = idx2pos[col2][pos2idx[col2][i] - 1];
for (int j = pre_at2 + 1; j < pre_at && cnt < 30; j++)
if (cur_schedule[i] != cur_schedule[j] && cur_schedule[j] != col) {
siz_ca = 0;
changed_at[siz_ca] = at;
changed_to_col[siz_ca] = cur_schedule[j];
siz_ca++;
changed_at[siz_ca] = i;
changed_to_col[siz_ca] = col;
siz_ca++;
changed_at[siz_ca] = j;
changed_to_col[siz_ca] = cur_schedule[i];
siz_ca++;
int old_score = cur_score;
int new_score = tryChange(siz_ca, changed_at, changed_to_col);
if (SA(new_score, old_score)) {
cur_score = new_score;
updateBest(siz_ca, changed_at, changed_to_col);
shift_++;
return true;
} else {
rollBack(siz_ca, changed_at, changed_to_col_rev, old_score);
}
cnt++;
}
}
return false;
}
void init() {
int t;
cin >> t;
for (int i = 0; i <= D; i++)
cur_schedule[i] = best_schedule[i] = -1;
for (int i = 0; i < CONTEST; i++) {
idx2pos[i][idx_num[i]++] = 0;
}
for (int i = 0; i < CONTEST; i++)
cin >> C[i];
for (int i = 1; i <= D; i++) {
for (int j = 0; j < CONTEST; j++) {
cin >> S[i][j];
}
}
initializer();
cur_score = calcScore();
best_score = -(1e9);
updateBest();
start_temp = (double)abs(cur_score) / 5e6;
end_temp = 0;
t_manager.update();
}
void output() {
for (int i = 1; i <= D; i++) {
assert(best_schedule[i] >= 0 && best_schedule[i] <= 25);
cout << best_schedule[i] + 1 << endl;
}
}
void displeyInfo() {
cerr << endl;
cerr << "cur_score = " << cur_score << endl;
cerr << "best_score = " << best_score << endl;
cerr << "step = " << step << endl;
cerr << "changed = " << changed_ << endl;
cerr << "replace = " << replace_ << endl;
cerr << "shift = " << shift_ << endl;
cerr << "time passed = " << setprecision(3) << fixed
<< t_manager.passed_ratio() << endl;
cerr << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
init();
// displeyInfo();
// int res = 0;
// for (int i = 1; i <= D; i++) {
// for (int j = 0; j < CONTEST; j++) {
// if (j == best_schedule[i]) {
// res += S[i][j];
// }
// int k = 0;
// for (int l = 1; l <= i; l++) if (best_schedule[l] == j) k = l;
// res -= C[j] * (i - k);
// }
// // cout << res << endl;
// }
// int res2 = 0;
// for (int i = 0; i < CONTEST; i++) res2 += score_col[i];
// cerr << cur_score << endl;
// cerr << best_score << endl;
// cerr << res << endl;
// cerr << res2 << endl;
for (int i = 0; !t_manager.is_timeover(); i++) {
if (i % 100 == 0) {
t_manager.update();
}
bool upd = false;
upd |= replace();
if (!upd)
upd |= shift();
updateBest();
// if (i % 30000 == 0) {
// displeyInfo();
// }
}
output();
// displeyInfo();
// for (int i = 1; i <= D; i++) cout << " " << i << " " << cur_schedule[i] <<
// endl; for (int i = 0; i < CONTEST; i++) {
// cout << "i = " << i << " idx_num[i] = " << idx_num[i] << endl;
// for (int j = 0; j < idx_num[i]; j++) {
// cout << idx2pos[i][j] << " ";
// }
// cout << endl;
// }
// cout << endl;
// res = 0;
// for (int i = 1; i <= D; i++) {
// for (int j = 0; j < CONTEST; j++) {
// if (j == best_schedule[i]) {
// res += S[i][j];
// }
// int k = 0;
// for (int l = 1; l <= i; l++) if (best_schedule[l] == j) k = l;
// res -= C[j] * (i - k);
// }
// // cout << res << endl;
// }
// res2 = 0;
// for (int i = 0; i < CONTEST; i++) res2 += score_col[i];
// cerr << cur_score << endl;
// cerr << best_score << endl;
// cerr << res << endl;
// cerr << res2 << endl;
return 0;
} | replace | 14 | 16 | 14 | 16 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
typedef char SINT8;
typedef short SINT16;
typedef int SINT32;
typedef long long SINT64;
typedef double DOUBLE;
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define ABS(a) ((a) > (0) ? (a) : -(a))
#define rep(i, a, b) for (SINT64(i) = SINT64(a); (i) < SINT64(b); (i)++)
#define rrep(i, a, b) for (SINT64(i) = SINT64(a); (i) >= SINT64(b); (i)--)
#define put(a) cout << (a) << endl
#define puts(a) cout << (a) << " "
#define putr(a) \
rep(testIncrement, 0, a.size()) { puts(a[testIncrement]); } \
cout << endl
#define putrr(a) \
rep(Incr1, 0, a.size()) { \
rep(Incr2, 0, a[Incr1].size()) { puts(a[Incr1][Incr2]); } \
cout << endl; \
} \
cout << endl;
#define INF 1000000001
#define MOD 1000000007
#define INF64 1000000000000000001
#define PI (acos(-1))
#define F first
#define S second
#define Pii pair<SINT32, SINT32>
#define Pll pair<SINT64, SINT64>
#define Piii pair<SINT32, pair<SINT32, SINT32>>
#define Plll pair<SINT64, pair<SINT64, SINT64>>
#define Vll(a, b, c) vector<vector<SINT64>> (a)((b),vector<SINT64>((c))
#define Vlll(a, b, c, d) vector<vector<vector<SINT64>>> (a)((b),vector<vector<SINT64>>((c),vector<SINT64>((d)))
#define SSS 365
using namespace std;
vector<SINT64> down(26);
vector<SINT64> last(26, -1);
vector<vector<SINT64>> dat(SSS, vector<SINT64>(26));
SINT64 getsc(vector<SINT64> ss) {
SINT64 ans = 0;
SINT64 score = 0;
rep(i, 0, SSS) {
score += dat[i][ss[i]];
last[ss[i]] = i;
rep(j, 0, 26) { score -= (i - last[j]) * down[j]; }
ans = MAX(ans, score);
}
return ans;
}
int main() {
SINT64 N;
cin >> N;
rep(i, 0, 26) { cin >> down[i]; }
rep(i, 0, N) {
rep(j, 0, 26) { cin >> dat[i][j]; }
}
vector<SINT64> ss(N, 0);
rep(i, 0, N) {
SINT64 ma = -INF64;
SINT64 ans = 0;
rep(j, 0, 26) {
SINT64 buf = dat[i][j];
SINT64 loo = last[j];
last[j] = i;
rep(k, 0, 26) { buf -= (i - last[k]) * down[k]; }
last[j] = loo;
if (buf > ma) {
ma = buf;
ans = j;
}
}
last[ans] = i;
ss[i] = ans;
}
SINT64 score = getsc(ss);
rep(i, 0, 1000000) {
SINT64 a, b, c;
vector<SINT64> now = ss;
a = rand() % N;
b = rand() % 26;
now[a] = b;
a = rand() % N;
b = rand() % 26;
now[a] = b;
a = rand() % N;
b = rand() % 26;
now[a] = b;
SINT64 buf = getsc(now);
if (buf >= score) {
score = buf;
ss = now;
}
// put(score);
}
rep(i, 0, N) { put(ss[i] + 1); }
return 0;
}
// vector<vector<SINT64>> dat(N,vector<SINT64>(N));
////2次元配列 vector<vector<vector<SINT64>>>
//data(N,vector<vector<SINT64>>(N,vector<SINT64>(N))); //3次元配列
// Vll(data,N,N); //2次元配列
// Vlll(data,N,N,N); //3次元配列
// sort(data.begin(),data.end());
// sort(data.begin(),data.end(),std::greater<SINT64>());
// __gcd(A,B);
// reverse(data.begin(),data.end());
// 関数へのvectorポインタ渡し
// void dfs(SINT64 poi, SINT64 d, vector<vector<Pll>>& data) {
// }
/* 複数条件ソート
bool sortcompare(Pll A, Pll B) {
if(A.F == B.F){
return A.S > B.S;
} else {
return A.F < B.F;
}
}
sort(data.begin(),data.end(),sortcompare);
*/
// タプル
// vector<tuple<SINT64,SINT64,SINT64>> edges;
// edges.emplace_back(a,b,c);
// cout << get<0>(edges[i]);
// cout << get<1>(edges[i]);
// cout << get<2>(edges[i]);
// sort(begin(edges), end(edges)); //ソート
// data.emplace_back(BUF); //後ろに追加
// data.erase(std::unique(data.begin(), data.end()), data.end());
// //ソート後に使用 同じ値を消す
// data.insert(data.begin() + X, 0); //X番目の要素に0を挿入
// 隣接リスト
// vector<vector<SINT64>> data(N);
// data[ A ].emplace_back( B );
// 両端キュー
// deque<SINT64> data;
// data.emplace_front(buf); //先頭挿入
// lower_boundは値がなければ最大値(.size())を返す
// posi = lower_bound(data.begin(),data.end(), X) - data.begin();
// // X以上を探す posi = lower_bound(data.begin(),data.end(),make_pair(X,0)) -
// data.begin(); //pair
/* 文字列回転
string N;
cin >> N;
N = N[N.length()-1] + N.substr(0,N.length()-1);
s = to_string(i); //ストリング変換
*/
/* 文字列合成
string N,M;
cin >> N >> M;
SINT64 ans = 0;
ans = stoi(N+M);
*/
/* 文字列変更
string s; cin >> s;
rep(i,0,s.length()) {
s[i] = (((s[i]-'A' + N) % 26) + 'A');
}
put(s);
*/
/*
//ワーシャルフロイド
vector<vector<SINT64>> dist(N,vector<SINT64>(N,INF64));
rep(i,0,N) {
dist[i][i] = 0;
}
rep(k,0,N) {
rep(i,0,N) {
rep(j,0,N) {
dist[i][j] = MIN(dist[i][j],
dist[i][k]+dist[k][j]);
}
}
}
*/
/* 優先度付きキュー
priority_queue<SINT64, vector<SINT64>, greater<SINT64>> q;
//小さいほうから取り出せる priority_queue<SINT64, vector<SINT64>> q;
//大きいほうから取り出せる
q.push(X); //X を挿入
q.top(); //先頭データ読み
q.pop(); //先頭データ削除
*/
/* キュー
queue<SINT64> q; //宣言
q.push(0); //挿入
q.front(); //先頭データ読み
q.pop(); //先頭データ削除
*/
/* マルチセット
multiset<SINT64> mset;
mset.insert(X); //追加
auto it = mset.begin(); //先頭取得
auto it = mset.rbegin(); //最後尾取得
mset.erase(X); //削除(X全部)
//削除 1個
auto hit(mset.find(X));
if (hit!= mset.end()) mset.erase(hit);
*/
/* SET コンテナ
set<SINT64> data;
data.insert(X); //X を挿入
data.erase(data.begin()); //先頭を削除
data.erase(--data.end()); //末尾を削除
*data.begin(); //先頭要素にアクセス
*data.rbegin(); //末尾要素にアクセス
//全表示
set<SINT64>::iterator it; //イテレータを用意
for(it = data.begin(); it != data.end(); it++) {
cout << *it << " ";
}
cout << endl;
//N番目を一部表示
set<SINT64>::iterator it; // イテレータを用意
it = data.begin();
rep (i,0,N) {
it++;
}
cout << *it << endl;
*/
/* map
map<string,SINT64> mp;
for(auto it=mp.begin();it!=mp.end();it++) {
mx=max(mx,it->second);
}
*/
/*
//順列全表示
//sortしてからでないと全列挙にならない
sort(data.begin(),data.end());
do {
cout << buf << endl;
rep(i,0,R) {
cout << data[i] << " ";
}
cout << endl;
} while (next_permutation(data.begin(),data.end()));
*/
/* bit数数え上げ
SINT64 bits64(SINT64 bits)
{
bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
return (bits & 0x0000ffff) + (bits >>16 & 0x0000ffff);
}
*/
// bitシフトのLONG対応
// ans += (1L<<50);
/* 余弦定理 2辺 A,B その間の角度からもう1辺を求める
long double yogen(long double A, long double B, long double angle) {
long double ans = A*A+B*B-A*B*2*cosl((PI/180.0)*angle);
ans = sqrt(ans);
return ans;
}
*/
// 桁指定表示
// ans = ans * M_PI;
// cout << setprecision(15) << ans << endl;
// 桁数0埋め
// cout << std::setfill('0') << std::right << std::setw(2) << 5; //05
// 2次元累積和
/*
vector<vector<SINT64>> data(H,vector<SINT64>(W));
vector<vector<SINT64>> rui(H+1,vector<SINT64>(W+1));
rep(i,0,H) {
rep(j,0,W) {
cin >> data[i][j];
}
}
rep(i,1,H+1) {
rep(j,1,W+1) {
rui[i][j] = data[i-1][j-1] + rui[i][j-1];
}
}
rep(i,1,H+1) {
rep(j,1,W+1) {
rui[i][j] += rui[i-1][j];
}
}
*/
// 逆元 コンビネーション
/*
SINT64 modpow(SINT64 a, SINT64 p) {
if (p == 0) return 1;
if (p % 2 == 0) {
//pが偶数の時
SINT64 halfP = p / 2;
SINT64 half = modpow(a, halfP);
//a^(p/2) をhalfとして、half*halfを計算
return half * half % MOD;
} else {
//pが奇数の時は、偶数にするために1減らす
return a * modpow(a, p - 1) % MOD;
}
}
SINT64 calcComb(SINT64 a, SINT64 b) {
SINT64 Mul = 1;
SINT64 Div = 1;
SINT64 ans = 0;
if (b > a - b) {
return calcComb(a, a - b);
}
rep(i,0,b) {
Mul *= (a - i);
Div *= (i + 1);
Mul %= MOD;
Div %= MOD;
}
ans = Mul * modpow(Div, MOD - 2) % MOD;
return ans;
}
*/
/* UNION FIND
class UnionFind {
public:
vector<SINT64> parent;
UnionFind(SINT64 N) {
parent = vector<SINT64>(N+10, -1); //少し多めに
}
SINT64 root(SINT64 A) {
if (parent[A] < 0) {
return A;
} else {
parent[A] = root(parent[A]);
return parent[A];
}
}
SINT64 size(SINT64 A) {
return parent[root(A)] * (-1);
}
bool judge(SINT64 A, SINT64 B) {
A = root(A);
B = root(B);
if (A == B) {
return true; //同じグループ
} else {
return false; //違うグループ
}
}
void connect(SINT64 A, SINT64 B) {
A = root(A);
B = root(B);
if (A != B) {
if (size(A) < size(B)) {
swap(A, B);
}
parent[A] += parent[B];
parent[B] = A;
}
}
};
UnionFind uni(N);
*/
/* セグ木
class SegTree {
private:
SINT64 size;
vector<SINT64> node;
SINT64 jugdement(SINT64 a, SINT64 b) {
SINT64 ans = 0;
ans = a+b;
return ans;
}
public:
//コンストラクタ
SegTree(vector<SINT64> data) {
SINT64 ori_size;
ori_size = data.size();
size = 1;
while (size < ori_size) {
size *= 2;
}
node.resize(2*size-1, 0);
rep(i,0,ori_size) {
node[size-1+i] = data[i];
}
rrep(i,size-2,0) {
node[i] = jugdement(node[2*i+1], node[2*i+2]);
}
}
//データ更新
void update(SINT64 x, SINT64 val) {
x += (size - 1);
node[x] = val+node[x];
while(x > 0) {
x = (x - 1) / 2;
node[x] = jugdement(node[2*x+1], node[2*x+2]);
}
}
//データ取得 [a,b)
SINT64 getdata(SINT64 a, SINT64 b, SINT64 k = 0, SINT64 l = 0, SINT64 r
= -1) { if (r < 0) { r = size;
}
//要求範囲外
if ((r <= a) || (b <= l)) {
return 0;
}
//完全要求区間内
if ((a <= l) && (r <= b)) {
return node[k];
}
SINT64 vl = getdata(a, b, 2*k+1, l, (l+r)/2);
SINT64 vr = getdata(a, b, 2*k+2, (l+r)/2, r);
return jugdement(vl, vr);
}
//表示
void disp() {
rep(i,0,size) {
puts(node[size-1+i]);
} cout << endl;
}
void alldisp() {
SINT64 cnt = 0;
SINT64 end = 2;
while (1) {
puts(node[cnt]);
if (cnt == end-2) {
end *= 2;
cout << endl;
}
cnt++;
if (cnt == size*2-1) {
break;
}
}
}
};
SegTree seg(N);
*/
/* 最大フロー最小カット
class Dinic {
struct EDGE {
SINT64 to;
SINT64 cap;
SINT64 rev;
};
vector<vector<EDGE>> G;
vector<SINT64> level;
vector<SINT64> root;
SINT64 N;
public:
Dinic(SINT64 n) {
N = n;
G.resize(N);
level.resize(N);
}
void add(SINT64 a, SINT64 b, SINT64 cap) {
G[a].emplace_back((EDGE){b,cap,(SINT64)G[b].size()});
G[b].emplace_back((EDGE){a,0,(SINT64)G[a].size()-1});
}
void bfs(SINT64 s) {
level[s] = 0;
queue<SINT64> q;
q.push(s);
while(q.size() != 0) {
SINT64 buf = q.front();
q.pop();
rep(i,0,G[buf].size()) {
EDGE now = G[buf][i];
if ((now.cap > 0) && (level[now.to] == -1)) {
level[now.to] = level[buf]+1;
q.push(now.to);
}
}
}
}
SINT64 dfs(SINT64 now, SINT64 g, SINT64 flow) {
if (now == g) return flow;
rep(i,root[now],G[now].size()) {
EDGE buf = G[now][i];
root[now] = i;
//dsf進捗更新 if ((buf.cap > 0) && (level[buf.to] > level[now])) { SINT64 mi =
MIN(buf.cap,flow); SINT64 nowf = dfs(buf.to,g,mi); if (nowf > 0) { G[now][i].cap
-= nowf; //順経路に容量削減 G[buf.to][buf.rev].cap +=
nowf; //逆経路に容量追加 return nowf;
//今回探索のFLOW追加数
}
}
}
return 0;
}
SINT64 act(SINT64 s, SINT64 g) {
SINT64 cnt = 0;
//最大FLOWカウント if (s == g) return cnt;
//スタート＝ゴールは例外 while(1) { level.assign(N,-1);
//sからの最短距離初期化 root.assign(N,0);
//dsf進捗初期化 bfs(s); if (level[g] == -1) break;
//gへ到達不可 while(1) { SINT64 flow; flow = dfs(s,g,INF64); if (flow == 0)
break; cnt += flow;
}
}
return cnt;
}
};
*/
/* ダイクストラ
class Dijkstra {
vector<vector<Pll>> G;
vector<SINT64> dist;
public:
Dijkstra(SINT64 n) {
G.resize(n);
dist.resize(n, INF64);
}
void add(SINT64 a, SINT64 b, SINT64 cost) {
G[a].emplace_back(Pll(b,cost));
}
void clear(SINT64 n) {
dist.resize(0);
dist.resize(n,INF64);
}
void form(SINT64 s) {
priority_queue<Pll, vector<Pll>, greater<Pll>> q;
q.push(Pll(0,s));
//cost,位置 while(q.size() != 0) { Pll now = q.top(); q.pop(); if (dist[now.S]
== INF64) { dist[now.S] = now.F; rep(i,0,G[now.S].size()) { Pll buf =
G[now.S][i]; if (dist[buf.F] == INF64) { q.push(Pll(buf.S+now.F,buf.F));
}
}
}
}
}
//form()で構築したsからの距離を返す
SINT64 get_dist(SINT64 a) {
if (dist[a] == INF64) {
return -1; //到達不可
} else {
return dist[a];
}
}
};
*/
/* LCA
class Lca {
vector<vector<SINT64>> G;
vector<vector<SINT64>> D; //ダブリング
vector<SINT64> depth;
SINT64 N;
SINT64 LOG_N;
public:
Lca(SINT64 n) {
N = n;
LOG_N = floor(log2(N));
G.resize(N);
D.resize(N);
depth.resize(N,-1);
}
void add(SINT64 a, SINT64 b) {
G[a].emplace_back(b);
G[b].emplace_back(a);
}
void bfs(SINT64 s) {
depth[s] = 0;
D[s].emplace_back(-1);
queue<SINT64> q;
q.push(s);
while(q.size() != 0) {
SINT64 now = q.front();
q.pop();
rep(i,0,G[now].size()) {
SINT64 next = G[now][i];
if (depth[next] == -1) {
depth[next] = depth[now]+1;
D[next].emplace_back(now);
q.push(next);
}
}
}
}
//頂点のsからのダブリング構築
void form(SINT64 s) {
bfs(s);
rep(i,1,LOG_N+1) {
rep(j,0,N) {
SINT64 buf = D[j][i-1];
if (buf == -1) {
D[j].emplace_back(-1);
} else {
D[j].emplace_back(D[buf][i-1]);
}
}
}
}
//aのx上の頂点を求める
SINT64 get(SINT64 a, SINT64 x) {
rrep(i,LOG_N,0) {
if (((x >> i) & 1) == 1) {
a = D[a][i];
if (a == -1) return -1;
}
}
return a;
}
//aとbの共通祖先を求める
SINT64 get_lca(SINT64 a, SINT64 b) {
if (depth[a] < depth[b]) swap(a,b);
SINT64 diff = depth[a] - depth[b];
a = get(a,diff);
//aのx上の頂点を求める if (a == b) return a; rrep(i,LOG_N,0) { if (D[a][i] !=
D[b][i]) { a = D[a][i]; b = D[b][i];
}
}
return D[a][0];
}
//aとbの共通祖先までの距離の合計を求める
SINT64 get_dist(SINT64 a, SINT64 b) {
SINT64 buf = get_lca(a,b);
return depth[a] + depth[b] - depth[buf]*2;
}
};
*/
/* ベルマンフォード
class Bellman {
struct EDGE {
SINT64 from;
SINT64 to;
SINT64 cost;
};
vector<EDGE> edges;
vector<SINT64> dist;
SINT64 N;
public:
Bellman(SINT64 n) {
N = n;
dist.resize(n, INF64);
}
void add(SINT64 from, SINT64 to, SINT64 cost) {
edges.emplace_back((EDGE){from,to,cost});
}
//sで構築したt迄の距離取得
SINT64 get_dist(SINT64 t) {
//到達不可はINF64
return dist[t];
}
//構築
//負の閉路無し : 0
//負の閉路有り : 1
//負の閉路有るが目的地gの更新は停止 : 2
SINT64 form(SINT64 s, SINT64 g) {
dist[s] = 0;
SINT64 cnt = 0;
SINT64 check = 0;
while(1) {
SINT64 renew = 0;
rep(i,0,edges.size()) {
EDGE e = edges[i];
if (dist[e.from] != INF64) {
if (dist[e.to] > dist[e.from] + e.cost)
{ renew = 1; dist[e.to] = dist[e.from] + e.cost;
}
}
}
if (renew == 0) return 0;
//N回更新後のgの距離と 2N回更新後のgの距離を比較
if (cnt == N) check = dist[g];
if (cnt > 2*N) {
if (check == dist[g]) return 2;
return 1;
}
cnt++;
}
}
};
*/
/*コンビネーション
class Comb {
vector<SINT64> base;
SINT64 N;
public:
Comb (SINT64 n) {
N = n+5;
base.resize(N);
base[0] = 1;
rep(i,1,N) {
base[i] = base[i-1]*i;
base[i] %= MOD;
}
}
SINT64 get_comb(SINT64 a, SINT64 b) {
SINT64 ans = 0;
SINT64 aa = base[a] * modpow(base[a-b], MOD - 2) % MOD;
ans = aa * modpow(base[b], MOD - 2) % MOD;
return ans;
}
SINT64 modpow(SINT64 a, SINT64 p) {
if (p == 0) return 1;
if (p % 2 == 0) {
SINT64 halfP = p / 2;
SINT64 half = modpow(a, halfP);
return half * half % MOD;
} else {
return a * modpow(a, p - 1) % MOD;
}
}
};
*/
/* SUFFIX ARRAY
class SuffixArray {
private:
vector<string> array; // サフィックスアレイ
vector<SINT64> lcp; // LCP
vector<SINT64> sais; // SA IS
string str;
public:
// コンストラクタ
SuffixArray (string s) {
str = s;
vector<SINT64> Vstr;
rep(i,0,str.length()) {
Vstr.emplace_back(str[i]);
}
sais_act(Vstr, sais, 255); // SAIS実行
// lcp_act(); //
隣り合うSUFFIXの先頭から同じ長さを算出
// suffix array 文字列作成
// array.resize(str.length());
// rep(i,0,array.size()) {
// array[i] = str.substr(sais[i]);
// }
// rep(i,0,array.size()) {put(array[i]);} // 表示用
}
// LCP作成
void lcp_act(void) {
lcp.resize(str.length());
vector<SINT64> buffer(str.length());
rep(i,0,str.length()) {
buffer[sais[i]] = i;
}
SINT64 cnt = 0;
rep(i,0,str.length()) {
if (buffer[i] >= str.length()-1) {
cnt = 0;
} else {
SINT64 a = buffer[i];
SINT64 b = buffer[i]+1;
while(1) {
if (cnt >= str.length() - sais[a])
break; if (cnt >= str.length() - sais[a]) break;
if (str[sais[a]+cnt] ==
str[sais[b]+cnt]) { cnt++; } else { break;
}
}
}
lcp[buffer[i]] = cnt;
if (cnt != 0) cnt--;
}
}
// 引数の文字列が何個含まれるか算出
SINT64 get_cnt(string t) {
SINT64 low,high;
SINT64 L,R;
L = -1;
R = str.length();
while(R-L > 1) {
SINT64 M = (R+L)/2;
string buf = str.substr(sais[M]);
if (buf.length() > t.length()) {
buf = buf.substr(0,t.length());
}
if (buf > t) {R = M;} else {L = M;}
}
high = R;
L = -1;
R = str.length();
while(R-L > 1) {
SINT64 M = (R+L)/2;
string buf = str.substr(sais[M]);
if (buf >= t) {R = M;} else {L = M;}
}
low = R;
return high - low;
}
// SAIS実行
void sais_act(vector<SINT64>& Vstr, vector<SINT64>& r_sais, SINT64 type)
{ Vstr.push_back(0); //
番兵追加 vector<SINT64> lms_seed; // LMS
ソート前 vector<SINT64> lms_sort; // LMS
ソート後 vector<SINT64> lms_long(Vstr.size(),0); // LMS 長さ
vector<SINT64> lms_type(Vstr.size(),1); // 0:L 1:S 2:LMS
vector<SINT64> lms_posi(Vstr.size(),-1); //
LMS内での位置
SINT64 len = 0;
// L S LMS判定 初期値は全てS
rrep(i,Vstr.size()-2,0) {
len++;
if (Vstr[i] > Vstr[i+1]) {
lms_type[i] = 0;
// L if (lms_type[i+1] == 1) {
lms_type[i+1] = 2;
// LMS lms_long[i+1] = len; // LMSの長さ格納 len = 1;
}
}
if (Vstr[i] == Vstr[i+1]) lms_type[i] = lms_type[i+1];
// 右と同じ
}
SINT64 cnt = 0;
rep(i,0,Vstr.size()) {
if (lms_type[i] == 2) lms_seed.emplace_back(i);
if (lms_type[i] == 2) lms_posi[i] = cnt++;
}
// Induced Sort初回
vector<SINT64> bucket;
// Induced Sort初回結果格納用 induced_sort(Vstr, lms_seed, bucket, lms_type,
type);
// lms_sortにLMSのソートを格納
rrep(i,Vstr.size()-1,0) {
if ((bucket[i] != -1) && (lms_type[bucket[i]] == 2)) {
lms_sort.emplace_back(bucket[i]);
}
}
SINT64 ok = 0; // 再帰必要性判定 SINT64 rank = 1;
// 再帰用文字 vector<SINT64> next(lms_sort.size(), 1); // 再帰用文字列
rrep(i,lms_sort.size()-2,0) {
SINT64 A = lms_long[lms_sort[i]];
SINT64 B = lms_long[lms_sort[i+1]];
if (A == B) {
SINT64 ck = 0;
rep(j,0,A) {
if (Vstr[lms_sort[i]+j] != Vstr[lms_sort[i+1]+j]) {
ck = 1;
break;
}
}
if (ck == 0) {
ok = 1; // 再帰必要
} else {
rank++;
}
} else {
rank++;
}
next[lms_posi[lms_sort[i]]] = rank;
}
if (ok == 1) {
vector<SINT64> recursive;
sais_act(next, recursive, rank+1);
rep(i,0,recursive.size()) {
lms_sort[recursive.size()-i-1] =
lms_seed[recursive[i]];
}
}
// SORT済みLMSでInduced Sorting
r_sais.resize(Vstr.size(),-1);
induced_sort(Vstr, lms_sort, r_sais, lms_type, type);
r_sais.erase(r_sais.begin()); // 番兵削除
}
// induced_sort
void induced_sort(vector<SINT64>& Vstr, vector<SINT64>& seed,
vector<SINT64>& bucket_sort, vector<SINT64>& lms_type, SINT64 type) {
vector<SINT64> bucket_cnt(type,0); //
バケット 文字種ごとの数 vector<SINT64> bucket_st(type,0);
// バケット 文字種の開始位置
vector<SINT64> bucket_end(type,0); //
バケット 文字種の終了位置 vector<SINT64> bucket_pre(Vstr.size(),-1); //
バケット 初回格納用 vector<SINT64> cnt1(type,0); vector<SINT64> cnt2(type,0);
vector<SINT64> cnt3(type,0);
bucket_sort.resize(Vstr.size(),-1);
// バケットソート位置作成
rep(i,0,Vstr.size()) bucket_cnt[Vstr[i]]++;
// 個数作成
rep(i,1,type) bucket_st[i] = bucket_st[i-1] + bucket_cnt[i-1];
// 開始位置
rep(i,0,type) bucket_end[i] = bucket_st[i] + bucket_cnt[i]-1;
// 終了位置
// LMSをbucket_preに格納
rep(i,0,seed.size()) {
SINT64 no = seed[i];
bucket_pre[bucket_end[Vstr[no]] - cnt1[Vstr[no]]] = no;
cnt1[Vstr[no]]++;
}
// Lをbucket_sortに格納
rep(i,0,Vstr.size()) {
if ((bucket_pre[i] != -1) && (bucket_pre[i] != 0)) {
if (lms_type[bucket_pre[i]-1] == 0) {
// -1がLの場合 SINT64 buf = Vstr[bucket_pre[i]-1]; bucket_pre [bucket_st[buf] +
cnt2[buf]] = bucket_pre[i]-1; bucket_sort[bucket_st[buf] + cnt2[buf]] =
bucket_pre[i]-1; cnt2[buf]++;
}
}
}
// Sをbucket_sortに格納
bucket_sort[0] = Vstr.size()-1;
// 番兵追加 rrep(i,Vstr.size()-1,0) { if ((bucket_sort[i] != -1) &&
(bucket_sort[i] != 0)) { if (lms_type[bucket_sort[i]-1] != 0) { //
-1がS(LMS)の場合 SINT64 buf = Vstr[bucket_sort[i]-1];
bucket_sort[bucket_end[buf] - cnt3[buf]]
= bucket_sort[i]-1; cnt3[buf]++;
}
}
}
}
};
*/
/* 転倒数の数え上げ
SINT64 merge_cnt(vector<SINT64> &a) {
SINT64 n = a.size();
if (n <= 1) { return 0; }
SINT64 cnt = 0;
vector<SINT64> b(a.begin(), a.begin()+n/2);
vector<SINT64> c(a.begin()+n/2, a.end());
cnt += merge_cnt(b);
cnt += merge_cnt(c);
SINT64 ai = 0, bi = 0, ci = 0;
// merge の処理
while (ai < n) {
if ( bi < b.size() && (ci == c.size() || b[bi] <= c[ci]) ) {
a[ai++] = b[bi++];
} else {
cnt += n / 2 - bi;
a[ai++] = c[ci++];
}
}
return cnt;
}
*/
/* 最長部分文字列
SINT64 LCS(string s, string t) {
SINT64 n = s.size();
SINT64 m = t.size();
vector<vector<SINT64>> DP(n+1,vector<SINT64>(m+1,0));
rep(i,0,n) {
rep(j,0,m) {
if (s[i] == t[j]) {
DP[i+1][j+1] = DP[i][j]+1;
} else {
DP[i+1][j+1] = MAX(DP[i+1][j],DP[i][j+1]);
}
}
}
return DP[n][m];
}
*/
| #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
typedef char SINT8;
typedef short SINT16;
typedef int SINT32;
typedef long long SINT64;
typedef double DOUBLE;
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define ABS(a) ((a) > (0) ? (a) : -(a))
#define rep(i, a, b) for (SINT64(i) = SINT64(a); (i) < SINT64(b); (i)++)
#define rrep(i, a, b) for (SINT64(i) = SINT64(a); (i) >= SINT64(b); (i)--)
#define put(a) cout << (a) << endl
#define puts(a) cout << (a) << " "
#define putr(a) \
rep(testIncrement, 0, a.size()) { puts(a[testIncrement]); } \
cout << endl
#define putrr(a) \
rep(Incr1, 0, a.size()) { \
rep(Incr2, 0, a[Incr1].size()) { puts(a[Incr1][Incr2]); } \
cout << endl; \
} \
cout << endl;
#define INF 1000000001
#define MOD 1000000007
#define INF64 1000000000000000001
#define PI (acos(-1))
#define F first
#define S second
#define Pii pair<SINT32, SINT32>
#define Pll pair<SINT64, SINT64>
#define Piii pair<SINT32, pair<SINT32, SINT32>>
#define Plll pair<SINT64, pair<SINT64, SINT64>>
#define Vll(a, b, c) vector<vector<SINT64>> (a)((b),vector<SINT64>((c))
#define Vlll(a, b, c, d) vector<vector<vector<SINT64>>> (a)((b),vector<vector<SINT64>>((c),vector<SINT64>((d)))
#define SSS 365
using namespace std;
vector<SINT64> down(26);
vector<SINT64> last(26, -1);
vector<vector<SINT64>> dat(SSS, vector<SINT64>(26));
SINT64 getsc(vector<SINT64> ss) {
SINT64 ans = 0;
SINT64 score = 0;
rep(i, 0, SSS) {
score += dat[i][ss[i]];
last[ss[i]] = i;
rep(j, 0, 26) { score -= (i - last[j]) * down[j]; }
ans = MAX(ans, score);
}
return ans;
}
int main() {
SINT64 N;
cin >> N;
rep(i, 0, 26) { cin >> down[i]; }
rep(i, 0, N) {
rep(j, 0, 26) { cin >> dat[i][j]; }
}
vector<SINT64> ss(N, 0);
rep(i, 0, N) {
SINT64 ma = -INF64;
SINT64 ans = 0;
rep(j, 0, 26) {
SINT64 buf = dat[i][j];
SINT64 loo = last[j];
last[j] = i;
rep(k, 0, 26) { buf -= (i - last[k]) * down[k]; }
last[j] = loo;
if (buf > ma) {
ma = buf;
ans = j;
}
}
last[ans] = i;
ss[i] = ans;
}
SINT64 score = getsc(ss);
rep(i, 0, 200000) {
SINT64 a, b, c;
vector<SINT64> now = ss;
a = rand() % N;
b = rand() % 26;
now[a] = b;
a = rand() % N;
b = rand() % 26;
now[a] = b;
a = rand() % N;
b = rand() % 26;
now[a] = b;
SINT64 buf = getsc(now);
if (buf >= score) {
score = buf;
ss = now;
}
// put(score);
}
rep(i, 0, N) { put(ss[i] + 1); }
return 0;
}
// vector<vector<SINT64>> dat(N,vector<SINT64>(N));
////2次元配列 vector<vector<vector<SINT64>>>
//data(N,vector<vector<SINT64>>(N,vector<SINT64>(N))); //3次元配列
// Vll(data,N,N); //2次元配列
// Vlll(data,N,N,N); //3次元配列
// sort(data.begin(),data.end());
// sort(data.begin(),data.end(),std::greater<SINT64>());
// __gcd(A,B);
// reverse(data.begin(),data.end());
// 関数へのvectorポインタ渡し
// void dfs(SINT64 poi, SINT64 d, vector<vector<Pll>>& data) {
// }
/* 複数条件ソート
bool sortcompare(Pll A, Pll B) {
if(A.F == B.F){
return A.S > B.S;
} else {
return A.F < B.F;
}
}
sort(data.begin(),data.end(),sortcompare);
*/
// タプル
// vector<tuple<SINT64,SINT64,SINT64>> edges;
// edges.emplace_back(a,b,c);
// cout << get<0>(edges[i]);
// cout << get<1>(edges[i]);
// cout << get<2>(edges[i]);
// sort(begin(edges), end(edges)); //ソート
// data.emplace_back(BUF); //後ろに追加
// data.erase(std::unique(data.begin(), data.end()), data.end());
// //ソート後に使用 同じ値を消す
// data.insert(data.begin() + X, 0); //X番目の要素に0を挿入
// 隣接リスト
// vector<vector<SINT64>> data(N);
// data[ A ].emplace_back( B );
// 両端キュー
// deque<SINT64> data;
// data.emplace_front(buf); //先頭挿入
// lower_boundは値がなければ最大値(.size())を返す
// posi = lower_bound(data.begin(),data.end(), X) - data.begin();
// // X以上を探す posi = lower_bound(data.begin(),data.end(),make_pair(X,0)) -
// data.begin(); //pair
/* 文字列回転
string N;
cin >> N;
N = N[N.length()-1] + N.substr(0,N.length()-1);
s = to_string(i); //ストリング変換
*/
/* 文字列合成
string N,M;
cin >> N >> M;
SINT64 ans = 0;
ans = stoi(N+M);
*/
/* 文字列変更
string s; cin >> s;
rep(i,0,s.length()) {
s[i] = (((s[i]-'A' + N) % 26) + 'A');
}
put(s);
*/
/*
//ワーシャルフロイド
vector<vector<SINT64>> dist(N,vector<SINT64>(N,INF64));
rep(i,0,N) {
dist[i][i] = 0;
}
rep(k,0,N) {
rep(i,0,N) {
rep(j,0,N) {
dist[i][j] = MIN(dist[i][j],
dist[i][k]+dist[k][j]);
}
}
}
*/
/* 優先度付きキュー
priority_queue<SINT64, vector<SINT64>, greater<SINT64>> q;
//小さいほうから取り出せる priority_queue<SINT64, vector<SINT64>> q;
//大きいほうから取り出せる
q.push(X); //X を挿入
q.top(); //先頭データ読み
q.pop(); //先頭データ削除
*/
/* キュー
queue<SINT64> q; //宣言
q.push(0); //挿入
q.front(); //先頭データ読み
q.pop(); //先頭データ削除
*/
/* マルチセット
multiset<SINT64> mset;
mset.insert(X); //追加
auto it = mset.begin(); //先頭取得
auto it = mset.rbegin(); //最後尾取得
mset.erase(X); //削除(X全部)
//削除 1個
auto hit(mset.find(X));
if (hit!= mset.end()) mset.erase(hit);
*/
/* SET コンテナ
set<SINT64> data;
data.insert(X); //X を挿入
data.erase(data.begin()); //先頭を削除
data.erase(--data.end()); //末尾を削除
*data.begin(); //先頭要素にアクセス
*data.rbegin(); //末尾要素にアクセス
//全表示
set<SINT64>::iterator it; //イテレータを用意
for(it = data.begin(); it != data.end(); it++) {
cout << *it << " ";
}
cout << endl;
//N番目を一部表示
set<SINT64>::iterator it; // イテレータを用意
it = data.begin();
rep (i,0,N) {
it++;
}
cout << *it << endl;
*/
/* map
map<string,SINT64> mp;
for(auto it=mp.begin();it!=mp.end();it++) {
mx=max(mx,it->second);
}
*/
/*
//順列全表示
//sortしてからでないと全列挙にならない
sort(data.begin(),data.end());
do {
cout << buf << endl;
rep(i,0,R) {
cout << data[i] << " ";
}
cout << endl;
} while (next_permutation(data.begin(),data.end()));
*/
/* bit数数え上げ
SINT64 bits64(SINT64 bits)
{
bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
return (bits & 0x0000ffff) + (bits >>16 & 0x0000ffff);
}
*/
// bitシフトのLONG対応
// ans += (1L<<50);
/* 余弦定理 2辺 A,B その間の角度からもう1辺を求める
long double yogen(long double A, long double B, long double angle) {
long double ans = A*A+B*B-A*B*2*cosl((PI/180.0)*angle);
ans = sqrt(ans);
return ans;
}
*/
// 桁指定表示
// ans = ans * M_PI;
// cout << setprecision(15) << ans << endl;
// 桁数0埋め
// cout << std::setfill('0') << std::right << std::setw(2) << 5; //05
// 2次元累積和
/*
vector<vector<SINT64>> data(H,vector<SINT64>(W));
vector<vector<SINT64>> rui(H+1,vector<SINT64>(W+1));
rep(i,0,H) {
rep(j,0,W) {
cin >> data[i][j];
}
}
rep(i,1,H+1) {
rep(j,1,W+1) {
rui[i][j] = data[i-1][j-1] + rui[i][j-1];
}
}
rep(i,1,H+1) {
rep(j,1,W+1) {
rui[i][j] += rui[i-1][j];
}
}
*/
// 逆元 コンビネーション
/*
SINT64 modpow(SINT64 a, SINT64 p) {
if (p == 0) return 1;
if (p % 2 == 0) {
//pが偶数の時
SINT64 halfP = p / 2;
SINT64 half = modpow(a, halfP);
//a^(p/2) をhalfとして、half*halfを計算
return half * half % MOD;
} else {
//pが奇数の時は、偶数にするために1減らす
return a * modpow(a, p - 1) % MOD;
}
}
SINT64 calcComb(SINT64 a, SINT64 b) {
SINT64 Mul = 1;
SINT64 Div = 1;
SINT64 ans = 0;
if (b > a - b) {
return calcComb(a, a - b);
}
rep(i,0,b) {
Mul *= (a - i);
Div *= (i + 1);
Mul %= MOD;
Div %= MOD;
}
ans = Mul * modpow(Div, MOD - 2) % MOD;
return ans;
}
*/
/* UNION FIND
class UnionFind {
public:
vector<SINT64> parent;
UnionFind(SINT64 N) {
parent = vector<SINT64>(N+10, -1); //少し多めに
}
SINT64 root(SINT64 A) {
if (parent[A] < 0) {
return A;
} else {
parent[A] = root(parent[A]);
return parent[A];
}
}
SINT64 size(SINT64 A) {
return parent[root(A)] * (-1);
}
bool judge(SINT64 A, SINT64 B) {
A = root(A);
B = root(B);
if (A == B) {
return true; //同じグループ
} else {
return false; //違うグループ
}
}
void connect(SINT64 A, SINT64 B) {
A = root(A);
B = root(B);
if (A != B) {
if (size(A) < size(B)) {
swap(A, B);
}
parent[A] += parent[B];
parent[B] = A;
}
}
};
UnionFind uni(N);
*/
/* セグ木
class SegTree {
private:
SINT64 size;
vector<SINT64> node;
SINT64 jugdement(SINT64 a, SINT64 b) {
SINT64 ans = 0;
ans = a+b;
return ans;
}
public:
//コンストラクタ
SegTree(vector<SINT64> data) {
SINT64 ori_size;
ori_size = data.size();
size = 1;
while (size < ori_size) {
size *= 2;
}
node.resize(2*size-1, 0);
rep(i,0,ori_size) {
node[size-1+i] = data[i];
}
rrep(i,size-2,0) {
node[i] = jugdement(node[2*i+1], node[2*i+2]);
}
}
//データ更新
void update(SINT64 x, SINT64 val) {
x += (size - 1);
node[x] = val+node[x];
while(x > 0) {
x = (x - 1) / 2;
node[x] = jugdement(node[2*x+1], node[2*x+2]);
}
}
//データ取得 [a,b)
SINT64 getdata(SINT64 a, SINT64 b, SINT64 k = 0, SINT64 l = 0, SINT64 r
= -1) { if (r < 0) { r = size;
}
//要求範囲外
if ((r <= a) || (b <= l)) {
return 0;
}
//完全要求区間内
if ((a <= l) && (r <= b)) {
return node[k];
}
SINT64 vl = getdata(a, b, 2*k+1, l, (l+r)/2);
SINT64 vr = getdata(a, b, 2*k+2, (l+r)/2, r);
return jugdement(vl, vr);
}
//表示
void disp() {
rep(i,0,size) {
puts(node[size-1+i]);
} cout << endl;
}
void alldisp() {
SINT64 cnt = 0;
SINT64 end = 2;
while (1) {
puts(node[cnt]);
if (cnt == end-2) {
end *= 2;
cout << endl;
}
cnt++;
if (cnt == size*2-1) {
break;
}
}
}
};
SegTree seg(N);
*/
/* 最大フロー最小カット
class Dinic {
struct EDGE {
SINT64 to;
SINT64 cap;
SINT64 rev;
};
vector<vector<EDGE>> G;
vector<SINT64> level;
vector<SINT64> root;
SINT64 N;
public:
Dinic(SINT64 n) {
N = n;
G.resize(N);
level.resize(N);
}
void add(SINT64 a, SINT64 b, SINT64 cap) {
G[a].emplace_back((EDGE){b,cap,(SINT64)G[b].size()});
G[b].emplace_back((EDGE){a,0,(SINT64)G[a].size()-1});
}
void bfs(SINT64 s) {
level[s] = 0;
queue<SINT64> q;
q.push(s);
while(q.size() != 0) {
SINT64 buf = q.front();
q.pop();
rep(i,0,G[buf].size()) {
EDGE now = G[buf][i];
if ((now.cap > 0) && (level[now.to] == -1)) {
level[now.to] = level[buf]+1;
q.push(now.to);
}
}
}
}
SINT64 dfs(SINT64 now, SINT64 g, SINT64 flow) {
if (now == g) return flow;
rep(i,root[now],G[now].size()) {
EDGE buf = G[now][i];
root[now] = i;
//dsf進捗更新 if ((buf.cap > 0) && (level[buf.to] > level[now])) { SINT64 mi =
MIN(buf.cap,flow); SINT64 nowf = dfs(buf.to,g,mi); if (nowf > 0) { G[now][i].cap
-= nowf; //順経路に容量削減 G[buf.to][buf.rev].cap +=
nowf; //逆経路に容量追加 return nowf;
//今回探索のFLOW追加数
}
}
}
return 0;
}
SINT64 act(SINT64 s, SINT64 g) {
SINT64 cnt = 0;
//最大FLOWカウント if (s == g) return cnt;
//スタート＝ゴールは例外 while(1) { level.assign(N,-1);
//sからの最短距離初期化 root.assign(N,0);
//dsf進捗初期化 bfs(s); if (level[g] == -1) break;
//gへ到達不可 while(1) { SINT64 flow; flow = dfs(s,g,INF64); if (flow == 0)
break; cnt += flow;
}
}
return cnt;
}
};
*/
/* ダイクストラ
class Dijkstra {
vector<vector<Pll>> G;
vector<SINT64> dist;
public:
Dijkstra(SINT64 n) {
G.resize(n);
dist.resize(n, INF64);
}
void add(SINT64 a, SINT64 b, SINT64 cost) {
G[a].emplace_back(Pll(b,cost));
}
void clear(SINT64 n) {
dist.resize(0);
dist.resize(n,INF64);
}
void form(SINT64 s) {
priority_queue<Pll, vector<Pll>, greater<Pll>> q;
q.push(Pll(0,s));
//cost,位置 while(q.size() != 0) { Pll now = q.top(); q.pop(); if (dist[now.S]
== INF64) { dist[now.S] = now.F; rep(i,0,G[now.S].size()) { Pll buf =
G[now.S][i]; if (dist[buf.F] == INF64) { q.push(Pll(buf.S+now.F,buf.F));
}
}
}
}
}
//form()で構築したsからの距離を返す
SINT64 get_dist(SINT64 a) {
if (dist[a] == INF64) {
return -1; //到達不可
} else {
return dist[a];
}
}
};
*/
/* LCA
class Lca {
vector<vector<SINT64>> G;
vector<vector<SINT64>> D; //ダブリング
vector<SINT64> depth;
SINT64 N;
SINT64 LOG_N;
public:
Lca(SINT64 n) {
N = n;
LOG_N = floor(log2(N));
G.resize(N);
D.resize(N);
depth.resize(N,-1);
}
void add(SINT64 a, SINT64 b) {
G[a].emplace_back(b);
G[b].emplace_back(a);
}
void bfs(SINT64 s) {
depth[s] = 0;
D[s].emplace_back(-1);
queue<SINT64> q;
q.push(s);
while(q.size() != 0) {
SINT64 now = q.front();
q.pop();
rep(i,0,G[now].size()) {
SINT64 next = G[now][i];
if (depth[next] == -1) {
depth[next] = depth[now]+1;
D[next].emplace_back(now);
q.push(next);
}
}
}
}
//頂点のsからのダブリング構築
void form(SINT64 s) {
bfs(s);
rep(i,1,LOG_N+1) {
rep(j,0,N) {
SINT64 buf = D[j][i-1];
if (buf == -1) {
D[j].emplace_back(-1);
} else {
D[j].emplace_back(D[buf][i-1]);
}
}
}
}
//aのx上の頂点を求める
SINT64 get(SINT64 a, SINT64 x) {
rrep(i,LOG_N,0) {
if (((x >> i) & 1) == 1) {
a = D[a][i];
if (a == -1) return -1;
}
}
return a;
}
//aとbの共通祖先を求める
SINT64 get_lca(SINT64 a, SINT64 b) {
if (depth[a] < depth[b]) swap(a,b);
SINT64 diff = depth[a] - depth[b];
a = get(a,diff);
//aのx上の頂点を求める if (a == b) return a; rrep(i,LOG_N,0) { if (D[a][i] !=
D[b][i]) { a = D[a][i]; b = D[b][i];
}
}
return D[a][0];
}
//aとbの共通祖先までの距離の合計を求める
SINT64 get_dist(SINT64 a, SINT64 b) {
SINT64 buf = get_lca(a,b);
return depth[a] + depth[b] - depth[buf]*2;
}
};
*/
/* ベルマンフォード
class Bellman {
struct EDGE {
SINT64 from;
SINT64 to;
SINT64 cost;
};
vector<EDGE> edges;
vector<SINT64> dist;
SINT64 N;
public:
Bellman(SINT64 n) {
N = n;
dist.resize(n, INF64);
}
void add(SINT64 from, SINT64 to, SINT64 cost) {
edges.emplace_back((EDGE){from,to,cost});
}
//sで構築したt迄の距離取得
SINT64 get_dist(SINT64 t) {
//到達不可はINF64
return dist[t];
}
//構築
//負の閉路無し : 0
//負の閉路有り : 1
//負の閉路有るが目的地gの更新は停止 : 2
SINT64 form(SINT64 s, SINT64 g) {
dist[s] = 0;
SINT64 cnt = 0;
SINT64 check = 0;
while(1) {
SINT64 renew = 0;
rep(i,0,edges.size()) {
EDGE e = edges[i];
if (dist[e.from] != INF64) {
if (dist[e.to] > dist[e.from] + e.cost)
{ renew = 1; dist[e.to] = dist[e.from] + e.cost;
}
}
}
if (renew == 0) return 0;
//N回更新後のgの距離と 2N回更新後のgの距離を比較
if (cnt == N) check = dist[g];
if (cnt > 2*N) {
if (check == dist[g]) return 2;
return 1;
}
cnt++;
}
}
};
*/
/*コンビネーション
class Comb {
vector<SINT64> base;
SINT64 N;
public:
Comb (SINT64 n) {
N = n+5;
base.resize(N);
base[0] = 1;
rep(i,1,N) {
base[i] = base[i-1]*i;
base[i] %= MOD;
}
}
SINT64 get_comb(SINT64 a, SINT64 b) {
SINT64 ans = 0;
SINT64 aa = base[a] * modpow(base[a-b], MOD - 2) % MOD;
ans = aa * modpow(base[b], MOD - 2) % MOD;
return ans;
}
SINT64 modpow(SINT64 a, SINT64 p) {
if (p == 0) return 1;
if (p % 2 == 0) {
SINT64 halfP = p / 2;
SINT64 half = modpow(a, halfP);
return half * half % MOD;
} else {
return a * modpow(a, p - 1) % MOD;
}
}
};
*/
/* SUFFIX ARRAY
class SuffixArray {
private:
vector<string> array; // サフィックスアレイ
vector<SINT64> lcp; // LCP
vector<SINT64> sais; // SA IS
string str;
public:
// コンストラクタ
SuffixArray (string s) {
str = s;
vector<SINT64> Vstr;
rep(i,0,str.length()) {
Vstr.emplace_back(str[i]);
}
sais_act(Vstr, sais, 255); // SAIS実行
// lcp_act(); //
隣り合うSUFFIXの先頭から同じ長さを算出
// suffix array 文字列作成
// array.resize(str.length());
// rep(i,0,array.size()) {
// array[i] = str.substr(sais[i]);
// }
// rep(i,0,array.size()) {put(array[i]);} // 表示用
}
// LCP作成
void lcp_act(void) {
lcp.resize(str.length());
vector<SINT64> buffer(str.length());
rep(i,0,str.length()) {
buffer[sais[i]] = i;
}
SINT64 cnt = 0;
rep(i,0,str.length()) {
if (buffer[i] >= str.length()-1) {
cnt = 0;
} else {
SINT64 a = buffer[i];
SINT64 b = buffer[i]+1;
while(1) {
if (cnt >= str.length() - sais[a])
break; if (cnt >= str.length() - sais[a]) break;
if (str[sais[a]+cnt] ==
str[sais[b]+cnt]) { cnt++; } else { break;
}
}
}
lcp[buffer[i]] = cnt;
if (cnt != 0) cnt--;
}
}
// 引数の文字列が何個含まれるか算出
SINT64 get_cnt(string t) {
SINT64 low,high;
SINT64 L,R;
L = -1;
R = str.length();
while(R-L > 1) {
SINT64 M = (R+L)/2;
string buf = str.substr(sais[M]);
if (buf.length() > t.length()) {
buf = buf.substr(0,t.length());
}
if (buf > t) {R = M;} else {L = M;}
}
high = R;
L = -1;
R = str.length();
while(R-L > 1) {
SINT64 M = (R+L)/2;
string buf = str.substr(sais[M]);
if (buf >= t) {R = M;} else {L = M;}
}
low = R;
return high - low;
}
// SAIS実行
void sais_act(vector<SINT64>& Vstr, vector<SINT64>& r_sais, SINT64 type)
{ Vstr.push_back(0); //
番兵追加 vector<SINT64> lms_seed; // LMS
ソート前 vector<SINT64> lms_sort; // LMS
ソート後 vector<SINT64> lms_long(Vstr.size(),0); // LMS 長さ
vector<SINT64> lms_type(Vstr.size(),1); // 0:L 1:S 2:LMS
vector<SINT64> lms_posi(Vstr.size(),-1); //
LMS内での位置
SINT64 len = 0;
// L S LMS判定 初期値は全てS
rrep(i,Vstr.size()-2,0) {
len++;
if (Vstr[i] > Vstr[i+1]) {
lms_type[i] = 0;
// L if (lms_type[i+1] == 1) {
lms_type[i+1] = 2;
// LMS lms_long[i+1] = len; // LMSの長さ格納 len = 1;
}
}
if (Vstr[i] == Vstr[i+1]) lms_type[i] = lms_type[i+1];
// 右と同じ
}
SINT64 cnt = 0;
rep(i,0,Vstr.size()) {
if (lms_type[i] == 2) lms_seed.emplace_back(i);
if (lms_type[i] == 2) lms_posi[i] = cnt++;
}
// Induced Sort初回
vector<SINT64> bucket;
// Induced Sort初回結果格納用 induced_sort(Vstr, lms_seed, bucket, lms_type,
type);
// lms_sortにLMSのソートを格納
rrep(i,Vstr.size()-1,0) {
if ((bucket[i] != -1) && (lms_type[bucket[i]] == 2)) {
lms_sort.emplace_back(bucket[i]);
}
}
SINT64 ok = 0; // 再帰必要性判定 SINT64 rank = 1;
// 再帰用文字 vector<SINT64> next(lms_sort.size(), 1); // 再帰用文字列
rrep(i,lms_sort.size()-2,0) {
SINT64 A = lms_long[lms_sort[i]];
SINT64 B = lms_long[lms_sort[i+1]];
if (A == B) {
SINT64 ck = 0;
rep(j,0,A) {
if (Vstr[lms_sort[i]+j] != Vstr[lms_sort[i+1]+j]) {
ck = 1;
break;
}
}
if (ck == 0) {
ok = 1; // 再帰必要
} else {
rank++;
}
} else {
rank++;
}
next[lms_posi[lms_sort[i]]] = rank;
}
if (ok == 1) {
vector<SINT64> recursive;
sais_act(next, recursive, rank+1);
rep(i,0,recursive.size()) {
lms_sort[recursive.size()-i-1] =
lms_seed[recursive[i]];
}
}
// SORT済みLMSでInduced Sorting
r_sais.resize(Vstr.size(),-1);
induced_sort(Vstr, lms_sort, r_sais, lms_type, type);
r_sais.erase(r_sais.begin()); // 番兵削除
}
// induced_sort
void induced_sort(vector<SINT64>& Vstr, vector<SINT64>& seed,
vector<SINT64>& bucket_sort, vector<SINT64>& lms_type, SINT64 type) {
vector<SINT64> bucket_cnt(type,0); //
バケット 文字種ごとの数 vector<SINT64> bucket_st(type,0);
// バケット 文字種の開始位置
vector<SINT64> bucket_end(type,0); //
バケット 文字種の終了位置 vector<SINT64> bucket_pre(Vstr.size(),-1); //
バケット 初回格納用 vector<SINT64> cnt1(type,0); vector<SINT64> cnt2(type,0);
vector<SINT64> cnt3(type,0);
bucket_sort.resize(Vstr.size(),-1);
// バケットソート位置作成
rep(i,0,Vstr.size()) bucket_cnt[Vstr[i]]++;
// 個数作成
rep(i,1,type) bucket_st[i] = bucket_st[i-1] + bucket_cnt[i-1];
// 開始位置
rep(i,0,type) bucket_end[i] = bucket_st[i] + bucket_cnt[i]-1;
// 終了位置
// LMSをbucket_preに格納
rep(i,0,seed.size()) {
SINT64 no = seed[i];
bucket_pre[bucket_end[Vstr[no]] - cnt1[Vstr[no]]] = no;
cnt1[Vstr[no]]++;
}
// Lをbucket_sortに格納
rep(i,0,Vstr.size()) {
if ((bucket_pre[i] != -1) && (bucket_pre[i] != 0)) {
if (lms_type[bucket_pre[i]-1] == 0) {
// -1がLの場合 SINT64 buf = Vstr[bucket_pre[i]-1]; bucket_pre [bucket_st[buf] +
cnt2[buf]] = bucket_pre[i]-1; bucket_sort[bucket_st[buf] + cnt2[buf]] =
bucket_pre[i]-1; cnt2[buf]++;
}
}
}
// Sをbucket_sortに格納
bucket_sort[0] = Vstr.size()-1;
// 番兵追加 rrep(i,Vstr.size()-1,0) { if ((bucket_sort[i] != -1) &&
(bucket_sort[i] != 0)) { if (lms_type[bucket_sort[i]-1] != 0) { //
-1がS(LMS)の場合 SINT64 buf = Vstr[bucket_sort[i]-1];
bucket_sort[bucket_end[buf] - cnt3[buf]]
= bucket_sort[i]-1; cnt3[buf]++;
}
}
}
}
};
*/
/* 転倒数の数え上げ
SINT64 merge_cnt(vector<SINT64> &a) {
SINT64 n = a.size();
if (n <= 1) { return 0; }
SINT64 cnt = 0;
vector<SINT64> b(a.begin(), a.begin()+n/2);
vector<SINT64> c(a.begin()+n/2, a.end());
cnt += merge_cnt(b);
cnt += merge_cnt(c);
SINT64 ai = 0, bi = 0, ci = 0;
// merge の処理
while (ai < n) {
if ( bi < b.size() && (ci == c.size() || b[bi] <= c[ci]) ) {
a[ai++] = b[bi++];
} else {
cnt += n / 2 - bi;
a[ai++] = c[ci++];
}
}
return cnt;
}
*/
/* 最長部分文字列
SINT64 LCS(string s, string t) {
SINT64 n = s.size();
SINT64 m = t.size();
vector<vector<SINT64>> DP(n+1,vector<SINT64>(m+1,0));
rep(i,0,n) {
rep(j,0,m) {
if (s[i] == t[j]) {
DP[i+1][j+1] = DP[i][j]+1;
} else {
DP[i+1][j+1] = MAX(DP[i+1][j],DP[i][j+1]);
}
}
}
return DP[n][m];
}
*/
| replace | 104 | 105 | 104 | 105 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define DEBUG(x) cout << #x << ": " << (x) << '\n'
#define DEBUG_VEC(v) \
cout << #v << ":"; \
REP(i, v.size()) cout << ' ' << v[i]; \
cout << '\n'
#define ALL(a) (a).begin(), (a).end()
template <typename T> inline void CHMAX(T &a, const T b) {
if (a < b)
a = b;
}
template <typename T> inline void CHMIN(T &a, const T b) {
if (a > b)
a = b;
}
constexpr ll MOD = 1000000007ll;
// constexpr ll MOD=998244353ll;
#define FIX(a) ((a) % MOD + MOD) % MOD
const double EPS = 1e-9;
#define EQ0(x) (abs((x)) < EPS)
#define EQ(a, b) (abs((a) - (b)) < EPS)
constexpr int INF = 1e9;
int D, c[30], s[400][30];
int ans[400];
int tans[400];
// 乱数
unsigned int xor32() {
static unsigned int x = 2463534242;
x = x ^ (x << 13);
x = x ^ (x >> 17);
return x = x ^ (x << 15);
}
// スコアを全部計算
int val() {
int last[30];
REP(i, 26) { last[i] = 0; }
int res = 0;
FOR(i, 1, D + 1) {
last[tans[i]] = i;
res += s[i - 1][tans[i]];
REP(j, 26) { res -= c[j] * (i - last[j]); }
}
return res;
}
// スコアを差分計算
int diff() { return 0; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout<<setprecision(10)<<fixed;
time_t start = clock();
// 入力
cin >> D;
REP(i, 26) { cin >> c[i]; }
REP(i, D) {
REP(j, 26) { cin >> s[i][j]; }
}
// 初期解
int score = 0;
int last[30];
REP(i, 26) { last[i] = 0; }
REP(i, D) {
int ma = 0, idx = -1;
REP(j, 26) {
if (ma < s[i][j] + c[j] * (i + 1 - last[j])) {
ma = s[i][j] + c[j] * (i + 1 - last[j]);
idx = j;
}
score -= c[j] * (i + 1 - last[j]);
}
ans[i] = idx;
tans[i] = ans[i];
score += s[i][idx] + c[idx] * (i + 1 - last[idx]);
last[idx] = i;
}
// DEBUG(score);
while (true) {
time_t end = clock();
if ((double)(end - start) / CLOCKS_PER_SEC * 1000 > 1980) {
break;
}
int d1 = xor32() % D;
int d2 = min(D - 1, d1 - 2 + (int)xor32() % 5);
if (d1 == d2) {
continue;
}
swap(tans[d1], tans[d2]);
int tmp = val();
if (tmp > score) {
score = tmp;
swap(ans[d1], ans[d2]);
}
}
// DEBUG(score);
REP(i, D) { cout << ans[i] + 1 << '\n'; }
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define FORR(i, a, b) for (int i = (b)-1; i >= (a); --i)
#define DEBUG(x) cout << #x << ": " << (x) << '\n'
#define DEBUG_VEC(v) \
cout << #v << ":"; \
REP(i, v.size()) cout << ' ' << v[i]; \
cout << '\n'
#define ALL(a) (a).begin(), (a).end()
template <typename T> inline void CHMAX(T &a, const T b) {
if (a < b)
a = b;
}
template <typename T> inline void CHMIN(T &a, const T b) {
if (a > b)
a = b;
}
constexpr ll MOD = 1000000007ll;
// constexpr ll MOD=998244353ll;
#define FIX(a) ((a) % MOD + MOD) % MOD
const double EPS = 1e-9;
#define EQ0(x) (abs((x)) < EPS)
#define EQ(a, b) (abs((a) - (b)) < EPS)
constexpr int INF = 1e9;
int D, c[30], s[400][30];
int ans[400];
int tans[400];
// 乱数
unsigned int xor32() {
static unsigned int x = 2463534242;
x = x ^ (x << 13);
x = x ^ (x >> 17);
return x = x ^ (x << 15);
}
// スコアを全部計算
int val() {
int last[30];
REP(i, 26) { last[i] = 0; }
int res = 0;
FOR(i, 1, D + 1) {
last[tans[i]] = i;
res += s[i - 1][tans[i]];
REP(j, 26) { res -= c[j] * (i - last[j]); }
}
return res;
}
// スコアを差分計算
int diff() { return 0; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout<<setprecision(10)<<fixed;
time_t start = clock();
// 入力
cin >> D;
REP(i, 26) { cin >> c[i]; }
REP(i, D) {
REP(j, 26) { cin >> s[i][j]; }
}
// 初期解
int score = 0;
int last[30];
REP(i, 26) { last[i] = 0; }
REP(i, D) {
int ma = 0, idx = -1;
REP(j, 26) {
if (ma < s[i][j] + c[j] * (i + 1 - last[j])) {
ma = s[i][j] + c[j] * (i + 1 - last[j]);
idx = j;
}
score -= c[j] * (i + 1 - last[j]);
}
ans[i] = idx;
tans[i] = ans[i];
score += s[i][idx] + c[idx] * (i + 1 - last[idx]);
last[idx] = i;
}
// DEBUG(score);
while (true) {
time_t end = clock();
if ((double)(end - start) / CLOCKS_PER_SEC * 1000 > 1980) {
break;
}
int d1 = xor32() % D;
int d2 = max(0, min(D - 1, d1 - 2 + (int)xor32() % 5));
if (d1 == d2) {
continue;
}
swap(tans[d1], tans[d2]);
int tmp = val();
if (tmp > score) {
score = tmp;
swap(ans[d1], ans[d2]);
}
}
// DEBUG(score);
REP(i, D) { cout << ans[i] + 1 << '\n'; }
return 0;
}
| replace | 108 | 109 | 108 | 109 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int D = 365;
int csum;
int c[26];
int s[D][26];
int last[26];
set<int> se[26];
int ans[D];
int cur_score;
int score() {
memset(last, -1, sizeof(last));
int sum = 0;
int diff = 0;
rep(i, D) {
sum += s[i][ans[i]];
diff += csum;
diff -= (i - last[ans[i]]) * c[ans[i]];
sum -= diff;
last[ans[i]] = i;
}
cur_score = sum;
return sum;
}
inline int SUM(int b, int n) { return (b * (n - 1)) * n / 2; }
int update(int pos, int d) {
int x = ans[pos];
auto it = se[x].find(pos);
int diff = 0;
diff -= s[pos][x];
diff += s[pos][d];
int prv = *prev(it), nx = *next(it);
diff += SUM(c[x], pos - prv);
diff += SUM(c[x], nx - pos);
diff -= SUM(c[x], nx - prv);
it = se[d].lower_bound(pos);
prv = *prev(it), nx = *it;
diff += SUM(c[d], nx - prv);
diff -= SUM(c[d], pos - prv);
diff -= SUM(c[d], nx - pos);
cur_score += diff;
return cur_score;
}
int main() {
rep(i, 26) {
se[i].insert(-1);
se[i].insert(D);
}
scanf("%*d");
rep(i, 26) scanf("%d", &c[i]), csum += c[i];
rep(i, D) rep(j, 26) scanf("%d", &s[i][j]);
rep(i, D) {
ans[i] = max_element(s[i], s[i] + 26) - s[i];
se[ans[i]].insert(i);
}
random_device rnd;
mt19937 mt(rnd());
uniform_real_distribution<double> Real(0, 1);
int Max = score();
double stmp = 10000, etmp = 0;
int upd = 0;
int LOOP = 10000000;
rep(loop, LOOP) {
int pos = mt() % D;
int sum = 0;
rep(i, 26) sum += s[pos][i];
int ch, d = -1;
do {
ch = mt() % sum;
rep(i, 26) {
ch -= s[pos][i];
if (ch < 0) {
d = i;
break;
}
}
} while (d == ans[pos]);
int old = ans[pos], old_score = cur_score;
int nx = update(pos, d);
double tmp = stmp + (etmp - stmp) / LOOP * loop;
double p = exp(-double(abs(Max - nx)) / tmp);
if (Max < nx || Real(mt) < p) {
se[old].erase(pos);
se[d].insert(pos);
ans[pos] = d;
Max = nx;
upd++;
} else {
cur_score = old_score;
}
}
cerr << upd << endl;
rep(i, D) { cout << ans[i] + 1 << endl; }
cerr << "score: " << Max << ' ' << score() << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int D = 365;
int csum;
int c[26];
int s[D][26];
int last[26];
set<int> se[26];
int ans[D];
int cur_score;
int score() {
memset(last, -1, sizeof(last));
int sum = 0;
int diff = 0;
rep(i, D) {
sum += s[i][ans[i]];
diff += csum;
diff -= (i - last[ans[i]]) * c[ans[i]];
sum -= diff;
last[ans[i]] = i;
}
cur_score = sum;
return sum;
}
inline int SUM(int b, int n) { return (b * (n - 1)) * n / 2; }
int update(int pos, int d) {
int x = ans[pos];
auto it = se[x].find(pos);
int diff = 0;
diff -= s[pos][x];
diff += s[pos][d];
int prv = *prev(it), nx = *next(it);
diff += SUM(c[x], pos - prv);
diff += SUM(c[x], nx - pos);
diff -= SUM(c[x], nx - prv);
it = se[d].lower_bound(pos);
prv = *prev(it), nx = *it;
diff += SUM(c[d], nx - prv);
diff -= SUM(c[d], pos - prv);
diff -= SUM(c[d], nx - pos);
cur_score += diff;
return cur_score;
}
int main() {
rep(i, 26) {
se[i].insert(-1);
se[i].insert(D);
}
scanf("%*d");
rep(i, 26) scanf("%d", &c[i]), csum += c[i];
rep(i, D) rep(j, 26) scanf("%d", &s[i][j]);
rep(i, D) {
ans[i] = max_element(s[i], s[i] + 26) - s[i];
se[ans[i]].insert(i);
}
random_device rnd;
mt19937 mt(rnd());
uniform_real_distribution<double> Real(0, 1);
int Max = score();
double stmp = 10000, etmp = 0;
int upd = 0;
int LOOP = 8000000;
rep(loop, LOOP) {
int pos = mt() % D;
int sum = 0;
rep(i, 26) sum += s[pos][i];
int ch, d = -1;
do {
ch = mt() % sum;
rep(i, 26) {
ch -= s[pos][i];
if (ch < 0) {
d = i;
break;
}
}
} while (d == ans[pos]);
int old = ans[pos], old_score = cur_score;
int nx = update(pos, d);
double tmp = stmp + (etmp - stmp) / LOOP * loop;
double p = exp(-double(abs(Max - nx)) / tmp);
if (Max < nx || Real(mt) < p) {
se[old].erase(pos);
se[d].insert(pos);
ans[pos] = d;
Max = nx;
upd++;
} else {
cur_score = old_score;
}
}
cerr << upd << endl;
rep(i, D) { cout << ans[i] + 1 << endl; }
cerr << "score: " << Max << ' ' << score() << endl;
} | replace | 74 | 75 | 74 | 75 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
constexpr int INF = 1e9;
int main() {
srand(0);
// input
constexpr int n = 26;
int d;
cin >> d;
vector<int> c(n);
for (auto &e : c)
cin >> e;
vector<vector<int>> s(d, vector<int>(n));
for (auto &se : s) {
for (auto &e : se)
cin >> e;
}
// solve
int satisfaction = 0;
vector<set<int>> v(n);
for (auto &e : v)
e.insert(-1);
vector<int> t(d);
for (int i = 0; i < d; i++) {
t[i] = max_element(s[i].begin(), s[i].end()) - s[i].begin();
satisfaction += s[i][t[i]];
v[t[i]].insert(i);
for (int j = 0; j < n; j++) {
int last_i = *v[j].rbegin();
satisfaction -= c[j] * (i - last_i);
}
}
auto calculate_decline = [](int c, int d) { return -c * ((d - 1) * d / 2); };
auto calculate_difference = [&](int i, int j) {
int difference = 0;
difference -= s[i][t[i]];
difference += s[i][j];
auto it1_to = v[t[i]].upper_bound(i);
auto it1_from = it1_to;
it1_from--;
it1_from--;
int i1_to = it1_to == v[t[i]].end() ? d : *it1_to, i1_from = *it1_from;
auto it2_to = v[j].upper_bound(i);
auto it2_from = it2_to;
it2_from--;
int i2_to = it2_to == v[j].end() ? d : *it2_to, i2_from = *it2_from;
difference -= calculate_decline(c[t[i]], i - i1_from) +
calculate_decline(c[t[i]], i1_to - i);
difference += calculate_decline(c[t[i]], i1_to - i1_from);
difference -= calculate_decline(c[j], i2_to - i2_from);
difference += calculate_decline(c[j], i - i2_from) +
calculate_decline(c[j], i2_to - i);
return difference;
};
double temperature_from = 1e4, temperature_to = 0;
for (int iteration = 0, iteration_end = 1e7; iteration < iteration_end;
iteration++) {
double temperature =
temperature_from +
(temperature_to - temperature_from) * iteration / iteration_end;
if (rand() % 2) {
int i = rand() % d, j = rand() % n;
if (t[i] == j)
continue;
int difference = 0;
difference += calculate_difference(i, j);
double probability = exp(difference / temperature);
if ((rand() % INF) / (double)INF < probability) {
satisfaction += difference;
v[t[i]].erase(i);
v[j].insert(i);
t[i] = j;
}
} else {
int i = rand() % (d - 1);
if (t[i] == t[i + 1])
continue;
int difference = 0;
difference += calculate_difference(i, t[i + 1]);
difference += calculate_difference(i + 1, t[i]);
double probability = exp(difference / temperature);
if ((rand() % INF) / (double)INF < probability) {
satisfaction += difference;
v[t[i]].erase(i);
v[t[i]].insert(i + 1);
v[t[i + 1]].erase(i + 1);
v[t[i + 1]].insert(i);
swap(t[i], t[i + 1]);
}
}
}
// output
cerr << "satisfaction: " << satisfaction << endl;
cerr << "score: " << max((int)1e6 + satisfaction, 0) << endl;
for (auto e : t)
cout << e + 1 << endl;
}
| #include <bits/stdc++.h>
using namespace std;
constexpr int INF = 1e9;
int main() {
srand(0);
// input
constexpr int n = 26;
int d;
cin >> d;
vector<int> c(n);
for (auto &e : c)
cin >> e;
vector<vector<int>> s(d, vector<int>(n));
for (auto &se : s) {
for (auto &e : se)
cin >> e;
}
// solve
int satisfaction = 0;
vector<set<int>> v(n);
for (auto &e : v)
e.insert(-1);
vector<int> t(d);
for (int i = 0; i < d; i++) {
t[i] = max_element(s[i].begin(), s[i].end()) - s[i].begin();
satisfaction += s[i][t[i]];
v[t[i]].insert(i);
for (int j = 0; j < n; j++) {
int last_i = *v[j].rbegin();
satisfaction -= c[j] * (i - last_i);
}
}
auto calculate_decline = [](int c, int d) { return -c * ((d - 1) * d / 2); };
auto calculate_difference = [&](int i, int j) {
int difference = 0;
difference -= s[i][t[i]];
difference += s[i][j];
auto it1_to = v[t[i]].upper_bound(i);
auto it1_from = it1_to;
it1_from--;
it1_from--;
int i1_to = it1_to == v[t[i]].end() ? d : *it1_to, i1_from = *it1_from;
auto it2_to = v[j].upper_bound(i);
auto it2_from = it2_to;
it2_from--;
int i2_to = it2_to == v[j].end() ? d : *it2_to, i2_from = *it2_from;
difference -= calculate_decline(c[t[i]], i - i1_from) +
calculate_decline(c[t[i]], i1_to - i);
difference += calculate_decline(c[t[i]], i1_to - i1_from);
difference -= calculate_decline(c[j], i2_to - i2_from);
difference += calculate_decline(c[j], i - i2_from) +
calculate_decline(c[j], i2_to - i);
return difference;
};
double temperature_from = 1e4, temperature_to = 0;
for (int iteration = 0, iteration_end = 8e6; iteration < iteration_end;
iteration++) {
double temperature =
temperature_from +
(temperature_to - temperature_from) * iteration / iteration_end;
if (rand() % 2) {
int i = rand() % d, j = rand() % n;
if (t[i] == j)
continue;
int difference = 0;
difference += calculate_difference(i, j);
double probability = exp(difference / temperature);
if ((rand() % INF) / (double)INF < probability) {
satisfaction += difference;
v[t[i]].erase(i);
v[j].insert(i);
t[i] = j;
}
} else {
int i = rand() % (d - 1);
if (t[i] == t[i + 1])
continue;
int difference = 0;
difference += calculate_difference(i, t[i + 1]);
difference += calculate_difference(i + 1, t[i]);
double probability = exp(difference / temperature);
if ((rand() % INF) / (double)INF < probability) {
satisfaction += difference;
v[t[i]].erase(i);
v[t[i]].insert(i + 1);
v[t[i + 1]].erase(i + 1);
v[t[i + 1]].insert(i);
swap(t[i], t[i + 1]);
}
}
}
// output
cerr << "satisfaction: " << satisfaction << endl;
cerr << "score: " << max((int)1e6 + satisfaction, 0) << endl;
for (auto e : t)
cout << e + 1 << endl;
}
| replace | 68 | 69 | 68 | 69 | TLE | |
p02618 | C++ | Time Limit Exceeded | // #include<bits/stdc++.h>
#include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
/*
#include <boost/multiprecision/cpp_dec_float.hpp>
#include<boost/multiprecision/cpp_int.hpp>
#include <boost/rational.hpp>
namespace mp = boost::multiprecision;
using Real = mp::number<mp::cpp_dec_float<1024>>;
using Bint = mp::cpp_int;
*/
using namespace std;
#define int long long
#define REP(i, s, e) for ((i) = (s); (i) < (e); (i)++)
#define RREP(i, s, e) for ((i) = ((s)-1); (i) >= (e); (i)--)
#define FOR(i, n) for ((i) = (0); (i) < (n); (i)++)
#define RFOR(i, n) for ((i) = ((n)-1); (i) >= (0); (i)--)
#define MOD 1000000007
int D;
int c[32];
int s[512][32];
int ans[512];
void inp() {
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];
}
}
}
void ans_inp() {
for (int i = 1; i <= D; i++) {
cin >> ans[i];
}
}
void ans_ran() {
for (int i = 1; i <= D; i++) {
ans[i] = rand() % 26 + 1;
}
}
int man_calc(bool disp) {
int l[32] = {0};
int man = 0;
for (int i = 1; i <= D; i++) {
int n = ans[i];
l[n] = i;
man += s[i][n];
for (int j = 1; j <= 26; j++) {
man -= c[j] * (i - l[j]);
}
if (disp)
cout << man << endl;
}
return man;
}
void ans_disp() {
for (int i = 1; i <= D; i++) {
cout << ans[i] << endl;
}
}
void change_ans(int i, int n) { ans[i] = n; }
void solve_C() {
int M;
cin >> M;
for (int i = 0; i < M; i++) {
int from, to;
cin >> from >> to;
change_ans(from, to);
cout << man_calc(false) << endl;
}
}
void random_solve() {
srand(1234);
ans_ran();
for (int i = 0; i <= 1000000; i++) {
int bef = man_calc(false);
int ci = rand() % D + 1;
int tn = rand() % 26 + 1;
int fn = ans[ci];
change_ans(ci, tn);
int aft = man_calc(false);
if (bef > aft) {
change_ans(ci, fn);
}
}
ans_disp();
// cout<<man_calc(false)<<endl;
}
signed main() {
inp();
random_solve();
return 0;
}
| // #include<bits/stdc++.h>
#include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
/*
#include <boost/multiprecision/cpp_dec_float.hpp>
#include<boost/multiprecision/cpp_int.hpp>
#include <boost/rational.hpp>
namespace mp = boost::multiprecision;
using Real = mp::number<mp::cpp_dec_float<1024>>;
using Bint = mp::cpp_int;
*/
using namespace std;
#define int long long
#define REP(i, s, e) for ((i) = (s); (i) < (e); (i)++)
#define RREP(i, s, e) for ((i) = ((s)-1); (i) >= (e); (i)--)
#define FOR(i, n) for ((i) = (0); (i) < (n); (i)++)
#define RFOR(i, n) for ((i) = ((n)-1); (i) >= (0); (i)--)
#define MOD 1000000007
int D;
int c[32];
int s[512][32];
int ans[512];
void inp() {
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];
}
}
}
void ans_inp() {
for (int i = 1; i <= D; i++) {
cin >> ans[i];
}
}
void ans_ran() {
for (int i = 1; i <= D; i++) {
ans[i] = rand() % 26 + 1;
}
}
int man_calc(bool disp) {
int l[32] = {0};
int man = 0;
for (int i = 1; i <= D; i++) {
int n = ans[i];
l[n] = i;
man += s[i][n];
for (int j = 1; j <= 26; j++) {
man -= c[j] * (i - l[j]);
}
if (disp)
cout << man << endl;
}
return man;
}
void ans_disp() {
for (int i = 1; i <= D; i++) {
cout << ans[i] << endl;
}
}
void change_ans(int i, int n) { ans[i] = n; }
void solve_C() {
int M;
cin >> M;
for (int i = 0; i < M; i++) {
int from, to;
cin >> from >> to;
change_ans(from, to);
cout << man_calc(false) << endl;
}
}
void random_solve() {
srand(1234);
ans_ran();
for (int i = 0; i <= 100000; i++) {
int bef = man_calc(false);
int ci = rand() % D + 1;
int tn = rand() % 26 + 1;
int fn = ans[ci];
change_ans(ci, tn);
int aft = man_calc(false);
if (bef > aft) {
change_ans(ci, fn);
}
}
ans_disp();
// cout<<man_calc(false)<<endl;
}
signed main() {
inp();
random_solve();
return 0;
}
| replace | 93 | 94 | 93 | 94 | TLE | |
p02618 | C++ | Time Limit Exceeded | // #include<bits/stdc++.h>
#include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
/*
#include <boost/multiprecision/cpp_dec_float.hpp>
#include<boost/multiprecision/cpp_int.hpp>
#include <boost/rational.hpp>
namespace mp = boost::multiprecision;
using Real = mp::number<mp::cpp_dec_float<1024>>;
using Bint = mp::cpp_int;
*/
using namespace std;
#define int long long
#define REP(i, s, e) for ((i) = (s); (i) < (e); (i)++)
#define RREP(i, s, e) for ((i) = ((s)-1); (i) >= (e); (i)--)
#define FOR(i, n) for ((i) = (0); (i) < (n); (i)++)
#define RFOR(i, n) for ((i) = ((n)-1); (i) >= (0); (i)--)
#define MOD 1000000007
int D;
int c[32];
int s[512][32];
int ans[512];
void inp() {
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];
}
}
}
void ans_inp() {
for (int i = 1; i <= D; i++) {
cin >> ans[i];
}
}
void ans_ran() {
for (int i = 1; i <= D; i++) {
ans[i] = rand() % 26 + 1;
}
}
int man_calc(bool disp) {
int l[32] = {0};
int man = 0;
for (int i = 1; i <= D; i++) {
int n = ans[i];
l[n] = i;
man += s[i][n];
for (int j = 1; j <= 26; j++) {
man -= c[j] * (i - l[j]);
}
if (disp)
cout << man << endl;
}
return man;
}
void ans_disp() {
for (int i = 1; i <= D; i++) {
cout << ans[i] << endl;
}
}
void change_ans(int i, int n) { ans[i] = n; }
void solve_C() {
int M;
cin >> M;
for (int i = 0; i < M; i++) {
int from, to;
cin >> from >> to;
change_ans(from, to);
cout << man_calc(false) << endl;
}
}
void random_solve() {
int seed = 1234;
int cnt = 100000;
srand(seed);
ans_ran();
for (int i = 0; i <= cnt; i++) {
int bef = man_calc(false);
int ci = rand() % D + 1;
int tn = rand() % 26 + 1;
int fn = ans[ci];
change_ans(ci, tn);
int aft = man_calc(false);
if (bef > aft) {
change_ans(ci, fn);
}
if (i % (cnt / 10) == 0) {
for (int ci = 1; ci <= D; ci++) {
for (int tn = 1; tn <= 26; tn++) {
int bef = man_calc(false);
int fn = ans[ci];
change_ans(ci, tn);
int aft = man_calc(false);
if (bef > aft) {
change_ans(ci, fn);
}
}
}
}
}
ans_disp();
// cout<<man_calc(false)<<endl;
}
signed main() {
inp();
random_solve();
return 0;
}
| // #include<bits/stdc++.h>
#include <algorithm>
#include <cmath>
#include <iostream>
#include <queue>
#include <set>
#include <vector>
/*
#include <boost/multiprecision/cpp_dec_float.hpp>
#include<boost/multiprecision/cpp_int.hpp>
#include <boost/rational.hpp>
namespace mp = boost::multiprecision;
using Real = mp::number<mp::cpp_dec_float<1024>>;
using Bint = mp::cpp_int;
*/
using namespace std;
#define int long long
#define REP(i, s, e) for ((i) = (s); (i) < (e); (i)++)
#define RREP(i, s, e) for ((i) = ((s)-1); (i) >= (e); (i)--)
#define FOR(i, n) for ((i) = (0); (i) < (n); (i)++)
#define RFOR(i, n) for ((i) = ((n)-1); (i) >= (0); (i)--)
#define MOD 1000000007
int D;
int c[32];
int s[512][32];
int ans[512];
void inp() {
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];
}
}
}
void ans_inp() {
for (int i = 1; i <= D; i++) {
cin >> ans[i];
}
}
void ans_ran() {
for (int i = 1; i <= D; i++) {
ans[i] = rand() % 26 + 1;
}
}
int man_calc(bool disp) {
int l[32] = {0};
int man = 0;
for (int i = 1; i <= D; i++) {
int n = ans[i];
l[n] = i;
man += s[i][n];
for (int j = 1; j <= 26; j++) {
man -= c[j] * (i - l[j]);
}
if (disp)
cout << man << endl;
}
return man;
}
void ans_disp() {
for (int i = 1; i <= D; i++) {
cout << ans[i] << endl;
}
}
void change_ans(int i, int n) { ans[i] = n; }
void solve_C() {
int M;
cin >> M;
for (int i = 0; i < M; i++) {
int from, to;
cin >> from >> to;
change_ans(from, to);
cout << man_calc(false) << endl;
}
}
void random_solve() {
int seed = 1234;
int cnt = 100000;
srand(seed);
ans_ran();
for (int i = 0; i <= cnt; i++) {
int bef = man_calc(false);
int ci = rand() % D + 1;
int tn = rand() % 26 + 1;
int fn = ans[ci];
change_ans(ci, tn);
int aft = man_calc(false);
if (bef > aft) {
change_ans(ci, fn);
}
if (i % (cnt / 5) == 0) {
// cout<<i<<endl;
for (int ci = 1; ci <= D; ci++) {
for (int tn = 1; tn <= 26; tn++) {
int bef = man_calc(false);
int fn = ans[ci];
change_ans(ci, tn);
int aft = man_calc(false);
if (bef > aft) {
change_ans(ci, fn);
}
}
}
}
}
ans_disp();
// cout<<man_calc(false)<<endl;
}
signed main() {
inp();
random_solve();
return 0;
}
| replace | 105 | 106 | 105 | 107 | TLE | |
p02618 | C++ | Time Limit Exceeded | #pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int D = 365;
const int beam = 240;
int c[26];
int s[D][26];
int ans[D];
struct State {
ll val = 0;
int out[D] = {0};
int cnt[26] = {0};
};
bool operator<(const State &a, const State &b) { return a.val < b.val; }
bool operator>(const State &a, const State &b) { return a.val > b.val; }
void solve(int ca) {
int waste;
scanf("%d", &waste);
for (int i = 0; i < 26; ++i) {
scanf("%d", c + i);
}
for (auto &i : s) {
for (int &j : i) {
scanf("%d", &j);
}
}
priority_queue<State> pq[2];
pq[0].push(State());
for (int i = 0; i < D; ++i) {
int prev = i & 1, next = prev ^ 1;
for (int j = 0; !pq[prev].empty() && j < beam; ++j) {
auto state = pq[prev].top();
pq[prev].pop();
ll dec = 0;
for (int k = 0; k < 26; ++k) {
state.cnt[k]++;
dec += (ll)c[k] * state.cnt[k];
}
for (int k = 0; k < 26; ++k) {
const ll inc = (ll)c[k] * state.cnt[k];
const int tmp = state.cnt[k];
const int tmp_val = state.val;
state.val = state.val - dec + inc + s[i][k];
state.cnt[k] = 0;
state.out[i] = k;
pq[next].push(state);
state.cnt[k] = tmp;
state.val = tmp_val;
}
}
pq[prev] = priority_queue<State>();
}
auto best = pq[D & 1].top().out;
for (int i = 0; i < D; ++i) {
ans[i] = best[i] + 1;
}
for (int i = 0; i < D; ++i) {
printf("%d\n", ans[i]);
}
}
// #define MULTI
int main() {
#ifdef MULTI
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
solve(i + 1);
}
#else
solve(0);
#endif
return 0;
}
| #pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int D = 365;
const int beam = 230;
int c[26];
int s[D][26];
int ans[D];
struct State {
ll val = 0;
int out[D] = {0};
int cnt[26] = {0};
};
bool operator<(const State &a, const State &b) { return a.val < b.val; }
bool operator>(const State &a, const State &b) { return a.val > b.val; }
void solve(int ca) {
int waste;
scanf("%d", &waste);
for (int i = 0; i < 26; ++i) {
scanf("%d", c + i);
}
for (auto &i : s) {
for (int &j : i) {
scanf("%d", &j);
}
}
priority_queue<State> pq[2];
pq[0].push(State());
for (int i = 0; i < D; ++i) {
int prev = i & 1, next = prev ^ 1;
for (int j = 0; !pq[prev].empty() && j < beam; ++j) {
auto state = pq[prev].top();
pq[prev].pop();
ll dec = 0;
for (int k = 0; k < 26; ++k) {
state.cnt[k]++;
dec += (ll)c[k] * state.cnt[k];
}
for (int k = 0; k < 26; ++k) {
const ll inc = (ll)c[k] * state.cnt[k];
const int tmp = state.cnt[k];
const int tmp_val = state.val;
state.val = state.val - dec + inc + s[i][k];
state.cnt[k] = 0;
state.out[i] = k;
pq[next].push(state);
state.cnt[k] = tmp;
state.val = tmp_val;
}
}
pq[prev] = priority_queue<State>();
}
auto best = pq[D & 1].top().out;
for (int i = 0; i < D; ++i) {
ans[i] = best[i] + 1;
}
for (int i = 0; i < D; ++i) {
printf("%d\n", ans[i]);
}
}
// #define MULTI
int main() {
#ifdef MULTI
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
solve(i + 1);
}
#else
solve(0);
#endif
return 0;
}
| replace | 7 | 8 | 7 | 8 | TLE | |
p02618 | C++ | Time Limit Exceeded | #pragma GCC target("avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
constexpr int D = 365;
constexpr int beam = 270;
int c[26];
int s[D][26];
int ans[D];
struct State {
int val = 0;
int out[D] = {0};
int cnt[26] = {0};
};
constexpr bool operator<(const State &a, const State &b) {
return a.val < b.val;
}
constexpr bool operator>(const State &a, const State &b) {
return a.val > b.val;
}
void solve(int ca) {
int waste;
scanf("%d", &waste);
for (int i = 0; i < 26; ++i) {
scanf("%d", c + i);
}
for (auto &i : s) {
for (int &j : i) {
scanf("%d", &j);
}
}
priority_queue<State> pq[2];
pq[0].push(State());
for (int i = 0; i < D; ++i) {
int prev = i & 1, next = prev ^ 1;
for (int j = 0; !pq[prev].empty() && j < beam; ++j) {
auto state = pq[prev].top();
pq[prev].pop();
int dec = 0;
for (int k = 0; k < 26; ++k) {
state.cnt[k]++;
dec += c[k] * state.cnt[k];
}
for (int k = 0; k < 26; ++k) {
const int inc = c[k] * state.cnt[k];
const int tmp = state.cnt[k];
const int tmp_val = state.val;
state.val = state.val - dec + inc + s[i][k];
state.cnt[k] = 0;
state.out[i] = k;
pq[next].push(state);
state.cnt[k] = tmp;
state.val = tmp_val;
}
}
pq[prev] = priority_queue<State>();
}
auto best = pq[D & 1].top().out;
for (int i = 0; i < D; ++i) {
printf("%d\n", best[i] + 1);
}
}
// #define MULTI
int main() {
#ifdef MULTI
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
solve(i + 1);
}
#else
solve(0);
#endif
return 0;
}
| #pragma GCC target("avx2")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
using namespace std;
constexpr int D = 365;
constexpr int beam = 260;
int c[26];
int s[D][26];
int ans[D];
struct State {
int val = 0;
int out[D] = {0};
int cnt[26] = {0};
};
constexpr bool operator<(const State &a, const State &b) {
return a.val < b.val;
}
constexpr bool operator>(const State &a, const State &b) {
return a.val > b.val;
}
void solve(int ca) {
int waste;
scanf("%d", &waste);
for (int i = 0; i < 26; ++i) {
scanf("%d", c + i);
}
for (auto &i : s) {
for (int &j : i) {
scanf("%d", &j);
}
}
priority_queue<State> pq[2];
pq[0].push(State());
for (int i = 0; i < D; ++i) {
int prev = i & 1, next = prev ^ 1;
for (int j = 0; !pq[prev].empty() && j < beam; ++j) {
auto state = pq[prev].top();
pq[prev].pop();
int dec = 0;
for (int k = 0; k < 26; ++k) {
state.cnt[k]++;
dec += c[k] * state.cnt[k];
}
for (int k = 0; k < 26; ++k) {
const int inc = c[k] * state.cnt[k];
const int tmp = state.cnt[k];
const int tmp_val = state.val;
state.val = state.val - dec + inc + s[i][k];
state.cnt[k] = 0;
state.out[i] = k;
pq[next].push(state);
state.cnt[k] = tmp;
state.val = tmp_val;
}
}
pq[prev] = priority_queue<State>();
}
auto best = pq[D & 1].top().out;
for (int i = 0; i < D; ++i) {
printf("%d\n", best[i] + 1);
}
}
// #define MULTI
int main() {
#ifdef MULTI
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
solve(i + 1);
}
#else
solve(0);
#endif
return 0;
}
| replace | 6 | 7 | 6 | 7 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int d, score, i, j, k, pscore, cscore, id;
int c[26], s[365][26], last[26], t[365];
int day1, day2, v1, v2, csize, f, check[4];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> d;
for (i = 0; i < 26; i++) {
cin >> c[i];
}
for (i = 0; i < d; i++) {
for (j = 0; j < 26; j++) {
cin >> s[i][j];
}
}
for (i = 0; i < d; i++) {
for (j = 0; j < 26; j++) {
int tscore = s[i][j];
for (int k = 0; k < 26; k++) {
if (k == j)
continue;
tscore -= c[k] * (i + 1 - last[k]);
}
if (j == 0)
score = tscore;
else if (tscore > score) {
score = tscore;
t[i] = j;
}
}
last[t[i]] = i + 1;
}
int cnt = 400000;
while (cnt--) {
day1 = rand() % d;
v1 = rand() % 26;
while (t[day1] == v1) {
v1 = rand() % 26;
}
check[0] = t[day1];
check[1] = v1;
csize = 2;
f = 0;
if (cnt < 100000) {
f = 1;
day2 = rand() % d;
while (day2 == day1) {
day2 = rand() % d;
}
v2 = rand() % 26;
while (v2 == t[day2]) {
v2 = rand() % d;
}
if (t[day1] != t[day2] && v1 != t[day2]) {
check[csize++] = t[day2];
}
if (t[day1] != v2 && v1 != v2) {
check[csize++] = v2;
}
}
pscore = 0;
cscore = 0;
for (i = 0; i < csize; i++)
last[check[i]] = 0;
for (i = 0; i < d; i++) {
pscore += s[i][t[i]];
last[t[i]] = i + 1;
for (j = 0; j < csize; j++) {
int id = check[j];
pscore -= c[id] * (i + 1 - last[id]);
}
}
for (i = 0; i < csize; i++)
last[check[i]] = 0;
for (i = 0; i < d; i++) {
if (day1 == i) {
cscore += s[i][v1];
last[v1] = i + 1;
} else if (f && day2 == i) {
cscore += s[i][v2];
last[v2] = i + 1;
} else {
cscore += s[i][t[i]];
last[t[i]] = i + 1;
}
for (j = 0; j < csize; j++) {
id = check[j];
cscore -= c[id] * (i + 1 - last[id]);
}
}
if (pscore < cscore) {
t[day1] = v1;
if (f)
t[day2] = v2;
}
}
for (i = 0; i < d; i++) {
printf("%d\n", t[i] + 1);
}
} | #include <bits/stdc++.h>
using namespace std;
int d, score, i, j, k, pscore, cscore, id;
int c[26], s[365][26], last[26], t[365];
int day1, day2, v1, v2, csize, f, check[4];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> d;
for (i = 0; i < 26; i++) {
cin >> c[i];
}
for (i = 0; i < d; i++) {
for (j = 0; j < 26; j++) {
cin >> s[i][j];
}
}
for (i = 0; i < d; i++) {
for (j = 0; j < 26; j++) {
int tscore = s[i][j];
for (int k = 0; k < 26; k++) {
if (k == j)
continue;
tscore -= c[k] * (i + 1 - last[k]);
}
if (j == 0)
score = tscore;
else if (tscore > score) {
score = tscore;
t[i] = j;
}
}
last[t[i]] = i + 1;
}
int cnt = 400000;
while (cnt--) {
day1 = rand() % d;
v1 = rand() % 26;
while (t[day1] == v1) {
v1 = rand() % 26;
}
check[0] = t[day1];
check[1] = v1;
csize = 2;
f = 0;
if (cnt < 100000) {
f = 1;
day2 = rand() % d;
while (day2 == day1) {
day2 = rand() % d;
}
v2 = rand() % 26;
while (v2 == t[day2]) {
v2 = rand() % 26;
}
if (t[day1] != t[day2] && v1 != t[day2]) {
check[csize++] = t[day2];
}
if (t[day1] != v2 && v1 != v2) {
check[csize++] = v2;
}
}
pscore = 0;
cscore = 0;
for (i = 0; i < csize; i++)
last[check[i]] = 0;
for (i = 0; i < d; i++) {
pscore += s[i][t[i]];
last[t[i]] = i + 1;
for (j = 0; j < csize; j++) {
int id = check[j];
pscore -= c[id] * (i + 1 - last[id]);
}
}
for (i = 0; i < csize; i++)
last[check[i]] = 0;
for (i = 0; i < d; i++) {
if (day1 == i) {
cscore += s[i][v1];
last[v1] = i + 1;
} else if (f && day2 == i) {
cscore += s[i][v2];
last[v2] = i + 1;
} else {
cscore += s[i][t[i]];
last[t[i]] = i + 1;
}
for (j = 0; j < csize; j++) {
id = check[j];
cscore -= c[id] * (i + 1 - last[id]);
}
}
if (pscore < cscore) {
t[day1] = v1;
if (f)
t[day2] = v2;
}
}
for (i = 0; i < d; i++) {
printf("%d\n", t[i] + 1);
}
} | replace | 55 | 56 | 55 | 56 | 0 | |
p02618 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define repn(i, n) for (int i = 1; i <= n; i++)
#define repr(e, x) for (auto &e : x)
using namespace std;
typedef long long ll;
typedef long double ld;
// typedef pair<int,int> P;
int const INF = 1001001001;
ll const LINF = 1001001001001001001;
ll const MOD = 1000000007;
ll D;
ll c[26 + 1];
ll s[365 + 1][26 + 1];
ll last[365 + 1];
void input() {
cin >> D;
repn(i, 26) cin >> c[i];
repn(i, D) repn(j, 26) cin >> s[i][j];
}
// 貪欲法2
void solve2() {
ll v[27][366];
ll max_score = -LINF;
ll max_idx = 0;
rep(k, 27) {
ll score = 0;
fill(last, last + 27, 0);
repn(d, D + k) {
ll maxi = -LINF;
ll idx = 0;
repn(i, 26) {
ll res = 0;
if (d <= D)
res += s[d][i];
repn(j, 26) {
if (i == j)
continue;
res -= c[j] * (d - last[j]);
}
if (maxi < res) {
maxi = res;
idx = i;
}
}
last[idx] = d;
score += maxi;
v[k][d] = idx;
}
if (max_score < score) {
max_score = score;
max_idx = k;
}
}
repn(i, D) { cout << v[max_idx][i] << endl; }
}
int main() {
input();
solve2();
} | #include <algorithm>
#include <cmath>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <stdio.h>
#include <string>
#include <unordered_map>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define repn(i, n) for (int i = 1; i <= n; i++)
#define repr(e, x) for (auto &e : x)
using namespace std;
typedef long long ll;
typedef long double ld;
// typedef pair<int,int> P;
int const INF = 1001001001;
ll const LINF = 1001001001001001001;
ll const MOD = 1000000007;
ll D;
ll c[26 + 1];
ll s[365 + 1][26 + 1];
ll last[365 + 1];
void input() {
cin >> D;
repn(i, 26) cin >> c[i];
repn(i, D) repn(j, 26) cin >> s[i][j];
}
// 貪欲法2
void solve2() {
ll v[27][400];
ll max_score = -LINF;
ll max_idx = 0;
rep(k, 27) {
ll score = 0;
fill(last, last + 27, 0);
repn(d, D + k) {
ll maxi = -LINF;
ll idx = 0;
repn(i, 26) {
ll res = 0;
if (d <= D)
res += s[d][i];
repn(j, 26) {
if (i == j)
continue;
res -= c[j] * (d - last[j]);
}
if (maxi < res) {
maxi = res;
idx = i;
}
}
last[idx] = d;
score += maxi;
v[k][d] = idx;
}
if (max_score < score) {
max_score = score;
max_idx = k;
}
}
repn(i, D) { cout << v[max_idx][i] << endl; }
}
int main() {
input();
solve2();
} | replace | 36 | 37 | 36 | 37 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned ll
#define PI acos(-1)
#define vi vector<int>
#define pi pair<int, int>
#define pl pair<ll, ll>
template <typename T> using v2 = vector<vector<T>>;
template <typename T> using v3 = vector<vector<vector<T>>>;
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
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;
}
const int MOD = 1e9 + 7;
const int INF = 1e9 + 200;
const ll INFLL = 2e18 + 200;
struct info {
vector<ll> contest, minus;
ll score;
info(ll value) {
contest = vector<ll>();
minus = vector<ll>(26, 0);
score = value;
}
info() {
contest = vector<ll>();
minus = vector<ll>(26, 0);
score = 0;
}
};
int main() {
ll D;
cin >> D;
vector<ll> c(26);
cin >> c;
vector<vector<ll>> satisfaction(26, vector<ll>(D + 1));
for (int i = 1; i <= D; i++) {
for (int j = 0; j < 26; j++) {
ll temp;
cin >> temp;
satisfaction[j][i] = temp;
}
}
random_device rnd;
mt19937 mt(rnd());
vector<vector<info>> dp(D + 1, vector<info>(26));
for (int day = 1; day <= D; day++) {
for (int now = 0; now < 26; now++) {
if (day < 2)
continue;
auto calc = [&](int middle) {
for (int before = 0; before < 26; before++) {
auto before_info = dp[day - 2][before];
for (int i = 0; i < 26; i++) {
before_info.minus[i] += c[i];
}
before_info.contest.push_back(middle);
before_info.minus[middle] = 0;
before_info.score += satisfaction[middle][day - 1];
for (int i = 0; i < 26; i++) {
before_info.score -= before_info.minus[i];
}
for (int i = 0; i < 26; i++) {
before_info.minus[i] += c[i];
}
before_info.contest.push_back(now);
before_info.minus[now] = 0;
before_info.score += satisfaction[now][day];
for (int i = 0; i < 26; i++) {
before_info.score -= before_info.minus[i];
}
if (dp[day][now].contest.empty()) {
dp[day][now] = before_info;
continue;
}
if (dp[day][now].score == before_info.score) {
ll left = 0, right = 0;
for (int i = 0; i < 26; i++) {
left += dp[day][now].minus[i];
right += before_info.minus[i];
}
if (left > right)
dp[day][now] = before_info;
continue;
}
if (dp[day][now].score < before_info.score)
dp[day][now] = before_info;
}
};
for (int i = 0; i < 26; i++)
calc(i);
if (day < 3)
continue;
for (int a = 0; a < 26; a++) {
for (int before = 0; before < 26; before++) {
auto before_info = dp[day - 3][before];
int middle = mt() % 26;
for (int i = 0; i < 26; i++) {
before_info.minus[i] += c[i];
}
before_info.contest.push_back(middle);
before_info.minus[middle] = 0;
before_info.score += satisfaction[middle][day - 2];
for (int i = 0; i < 26; i++) {
before_info.score -= before_info.minus[i];
}
middle = mt() % 26;
for (int i = 0; i < 26; i++) {
before_info.minus[i] += c[i];
}
before_info.contest.push_back(middle);
before_info.minus[middle] = 0;
before_info.score += satisfaction[middle][day - 1];
for (int i = 0; i < 26; i++) {
before_info.score -= before_info.minus[i];
}
for (int i = 0; i < 26; i++) {
before_info.minus[i] += c[i];
}
before_info.contest.push_back(now);
before_info.minus[now] = 0;
before_info.score += satisfaction[now][day];
for (int i = 0; i < 26; i++) {
before_info.score -= before_info.minus[i];
}
if (dp[day][now].contest.empty()) {
dp[day][now] = before_info;
continue;
}
if (dp[day][now].score == before_info.score) {
ll left = 0, right = 0;
for (int i = 0; i < 26; i++) {
left += dp[day][now].minus[i];
right += before_info.minus[i];
}
if (left > right)
dp[day][now] = before_info;
continue;
}
if (dp[day][now].score < before_info.score)
dp[day][now] = before_info;
}
}
}
}
auto ans = dp[D][0];
for (int i = 0; i < 26; i++) {
if (ans.score < dp[D][i].score)
ans = dp[D][i];
}
for (int i = 0; i < D; i++) {
cout << ans.contest[i] + 1 << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned ll
#define PI acos(-1)
#define vi vector<int>
#define pi pair<int, int>
#define pl pair<ll, ll>
template <typename T> using v2 = vector<vector<T>>;
template <typename T> using v3 = vector<vector<vector<T>>>;
template <class T> istream &operator>>(istream &is, vector<T> &v) {
for (auto &elemnt : v)
is >> elemnt;
return is;
}
template <class T, class U> istream &operator>>(istream &is, pair<T, U> &p) {
is >> p.first >> p.second;
return is;
}
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;
}
const int MOD = 1e9 + 7;
const int INF = 1e9 + 200;
const ll INFLL = 2e18 + 200;
struct info {
vector<ll> contest, minus;
ll score;
info(ll value) {
contest = vector<ll>();
minus = vector<ll>(26, 0);
score = value;
}
info() {
contest = vector<ll>();
minus = vector<ll>(26, 0);
score = 0;
}
};
int main() {
ll D;
cin >> D;
vector<ll> c(26);
cin >> c;
vector<vector<ll>> satisfaction(26, vector<ll>(D + 1));
for (int i = 1; i <= D; i++) {
for (int j = 0; j < 26; j++) {
ll temp;
cin >> temp;
satisfaction[j][i] = temp;
}
}
random_device rnd;
mt19937 mt(rnd());
vector<vector<info>> dp(D + 1, vector<info>(26));
for (int day = 1; day <= D; day++) {
for (int now = 0; now < 26; now++) {
if (day < 2)
continue;
auto calc = [&](int middle) {
for (int before = 0; before < 26; before++) {
auto before_info = dp[day - 2][before];
for (int i = 0; i < 26; i++) {
before_info.minus[i] += c[i];
}
before_info.contest.push_back(middle);
before_info.minus[middle] = 0;
before_info.score += satisfaction[middle][day - 1];
for (int i = 0; i < 26; i++) {
before_info.score -= before_info.minus[i];
}
for (int i = 0; i < 26; i++) {
before_info.minus[i] += c[i];
}
before_info.contest.push_back(now);
before_info.minus[now] = 0;
before_info.score += satisfaction[now][day];
for (int i = 0; i < 26; i++) {
before_info.score -= before_info.minus[i];
}
if (dp[day][now].contest.empty()) {
dp[day][now] = before_info;
continue;
}
if (dp[day][now].score == before_info.score) {
ll left = 0, right = 0;
for (int i = 0; i < 26; i++) {
left += dp[day][now].minus[i];
right += before_info.minus[i];
}
if (left > right)
dp[day][now] = before_info;
continue;
}
if (dp[day][now].score < before_info.score)
dp[day][now] = before_info;
}
};
for (int i = 0; i < 26; i++)
calc(i);
if (day < 3)
continue;
for (int a = 0; a < 16; a++) {
for (int before = 0; before < 26; before++) {
auto before_info = dp[day - 3][before];
int middle = mt() % 26;
for (int i = 0; i < 26; i++) {
before_info.minus[i] += c[i];
}
before_info.contest.push_back(middle);
before_info.minus[middle] = 0;
before_info.score += satisfaction[middle][day - 2];
for (int i = 0; i < 26; i++) {
before_info.score -= before_info.minus[i];
}
middle = mt() % 26;
for (int i = 0; i < 26; i++) {
before_info.minus[i] += c[i];
}
before_info.contest.push_back(middle);
before_info.minus[middle] = 0;
before_info.score += satisfaction[middle][day - 1];
for (int i = 0; i < 26; i++) {
before_info.score -= before_info.minus[i];
}
for (int i = 0; i < 26; i++) {
before_info.minus[i] += c[i];
}
before_info.contest.push_back(now);
before_info.minus[now] = 0;
before_info.score += satisfaction[now][day];
for (int i = 0; i < 26; i++) {
before_info.score -= before_info.minus[i];
}
if (dp[day][now].contest.empty()) {
dp[day][now] = before_info;
continue;
}
if (dp[day][now].score == before_info.score) {
ll left = 0, right = 0;
for (int i = 0; i < 26; i++) {
left += dp[day][now].minus[i];
right += before_info.minus[i];
}
if (left > right)
dp[day][now] = before_info;
continue;
}
if (dp[day][now].score < before_info.score)
dp[day][now] = before_info;
}
}
}
}
auto ans = dp[D][0];
for (int i = 0; i < 26; i++) {
if (ans.score < dp[D][i].score)
ans = dp[D][i];
}
for (int i = 0; i < D; i++) {
cout << ans.contest[i] + 1 << endl;
}
}
| replace | 117 | 118 | 117 | 118 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define drep(i, cc, n) for (int i = (cc); i <= (n); ++i)
#define rep(i, n) drep(i, 0, n - 1)
#define drrep(i, cc, n) for (int i = (cc); i >= (n); --i)
#define rrep(i, n) drrep(i, 0, n - 1)
#define sz(s) (int)(s.size())
#define vecprint(v) \
rep(i, v.size()) if (i == 0) cout << v[i]; \
else cout << " " << v[i]; \
cout << endl;
#define arrprint(v, n) \
rep(i, n) if (i == 0) cout << v[i]; \
else cout << " " << v[i]; \
cout << endl;
#define matprint(v, n, m) \
rep(i, n) { \
rep(j, m) { cout << v[i][j] << " "; } \
cout << endl; \
}
#define SORT(v) sort(v.begin(), v.end())
#define REV(v) reverse(v.begin(), v.end())
using namespace std;
const int mod = 1000000007;
const int INF = 1001001001;
using ll = long long;
using P = pair<int, int>;
template <typename T>
using priority_queue_rev =
priority_queue<T, vector<T>, greater<T>>; // 小さいものから取り出す
int d;
vector<int> c(26);
vector<vector<int>> s;
vector<int> t, now;
vector<int> last(26, -1);
ll best = 0;
ll score() {
ll res = 0;
rep(i, 26) last[i] = -1;
rep(i, d) {
res += s[i][now[i]];
last[now[i]] = i;
rep(j, 26) res -= c[j] * (i - last[j]);
}
return res;
}
int main() {
random_device seed;
mt19937 mt(seed());
uniform_int_distribution<int> rnd1(0, 25);
cin >> d;
uniform_int_distribution<int> rnd2(0, d - 1);
rep(i, 26) cin >> c[i];
s.resize(d);
rep(i, d) s[i].resize(26);
rep(i, d) rep(j, 26) cin >> s[i][j];
t.resize(d);
now.resize(d);
rep(i, d) {
now[i] = i % 26;
t[i] = now[i];
}
best = score();
ll now_s;
rep(__, 20) {
rep(i, d) now[i] = rnd1(mt);
now_s = score();
if (best < now_s) {
best = now_s;
rep(j, d) t[j] = now[j];
}
rep(_, 500) {
// cout << best << endl;
// rep(i,d)now[i] = rnd1(mt);
int choice = rnd2(mt);
rep(i, 26) {
now[choice] = i;
now_s = score();
if (best < now_s) {
best = now_s;
rep(j, d) t[j] = now[j];
}
}
}
}
// cout << score() << endl;
rep(i, d) cout << t[i] + 1 << endl;
return 0;
} | #include <bits/stdc++.h>
#define drep(i, cc, n) for (int i = (cc); i <= (n); ++i)
#define rep(i, n) drep(i, 0, n - 1)
#define drrep(i, cc, n) for (int i = (cc); i >= (n); --i)
#define rrep(i, n) drrep(i, 0, n - 1)
#define sz(s) (int)(s.size())
#define vecprint(v) \
rep(i, v.size()) if (i == 0) cout << v[i]; \
else cout << " " << v[i]; \
cout << endl;
#define arrprint(v, n) \
rep(i, n) if (i == 0) cout << v[i]; \
else cout << " " << v[i]; \
cout << endl;
#define matprint(v, n, m) \
rep(i, n) { \
rep(j, m) { cout << v[i][j] << " "; } \
cout << endl; \
}
#define SORT(v) sort(v.begin(), v.end())
#define REV(v) reverse(v.begin(), v.end())
using namespace std;
const int mod = 1000000007;
const int INF = 1001001001;
using ll = long long;
using P = pair<int, int>;
template <typename T>
using priority_queue_rev =
priority_queue<T, vector<T>, greater<T>>; // 小さいものから取り出す
int d;
vector<int> c(26);
vector<vector<int>> s;
vector<int> t, now;
vector<int> last(26, -1);
ll best = 0;
ll score() {
ll res = 0;
rep(i, 26) last[i] = -1;
rep(i, d) {
res += s[i][now[i]];
last[now[i]] = i;
rep(j, 26) res -= c[j] * (i - last[j]);
}
return res;
}
int main() {
random_device seed;
mt19937 mt(seed());
uniform_int_distribution<int> rnd1(0, 25);
cin >> d;
uniform_int_distribution<int> rnd2(0, d - 1);
rep(i, 26) cin >> c[i];
s.resize(d);
rep(i, d) s[i].resize(26);
rep(i, d) rep(j, 26) cin >> s[i][j];
t.resize(d);
now.resize(d);
rep(i, d) {
now[i] = i % 26;
t[i] = now[i];
}
best = score();
ll now_s;
rep(__, 10) {
rep(i, d) now[i] = rnd1(mt);
now_s = score();
if (best < now_s) {
best = now_s;
rep(j, d) t[j] = now[j];
}
rep(_, 500) {
// cout << best << endl;
// rep(i,d)now[i] = rnd1(mt);
int choice = rnd2(mt);
rep(i, 26) {
now[choice] = i;
now_s = score();
if (best < now_s) {
best = now_s;
rep(j, d) t[j] = now[j];
}
}
}
}
// cout << score() << endl;
rep(i, d) cout << t[i] + 1 << endl;
return 0;
} | replace | 67 | 68 | 67 | 68 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define REP(i, n) for (int 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;
}
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Pl = pair<long long, long long>;
using veci = vector<int>;
using vecl = vector<long long>;
using vecveci = vector<vector<int>>;
using vecvecl = vector<vector<long long>>;
inline void InitRand() { srand((unsigned int)time(NULL)); }
int main() {
InitRand();
int D;
cin >> D;
veci C(26);
vecveci S(D, veci(26));
veci T(D);
REP(i, 26) cin >> C[i];
REP(i, D) REP(j, 26) cin >> S[i][j];
REP(i, D) { T[i] = rand() % 26; }
int M;
M = 3 * 1e5;
veci B(M), Q(M);
REP(i, M) {
B[i] = rand() % D;
Q[i] = rand() % 26;
}
veci last_d(26);
ll old_ans = 0;
REP(i, D) {
int d = i + 1;
last_d[T[i]] = d;
old_ans += S[i][T[i]];
REP(j, 26) { old_ans -= C[j] * (d - last_d[j]); }
}
REP(i, M) {
int old_p = T[B[i]];
T[B[i]] = Q[i];
ll score = 0;
veci last(26);
REP(j, D) {
int d = j + 1;
last[T[j]] = d;
score += S[j][T[j]];
REP(k, 26) { score -= C[k] * (d - last[k]); }
}
if (old_ans < score) {
old_ans = score;
} else {
T[B[i]] = old_p;
}
}
REP(i, D) cout << T[i] + 1 << endl;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int 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;
}
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Pl = pair<long long, long long>;
using veci = vector<int>;
using vecl = vector<long long>;
using vecveci = vector<vector<int>>;
using vecvecl = vector<vector<long long>>;
inline void InitRand() { srand((unsigned int)time(NULL)); }
int main() {
InitRand();
int D;
cin >> D;
veci C(26);
vecveci S(D, veci(26));
veci T(D);
REP(i, 26) cin >> C[i];
REP(i, D) REP(j, 26) cin >> S[i][j];
REP(i, D) { T[i] = rand() % 26; }
int M;
M = 1e5;
veci B(M), Q(M);
REP(i, M) {
B[i] = rand() % D;
Q[i] = rand() % 26;
}
veci last_d(26);
ll old_ans = 0;
REP(i, D) {
int d = i + 1;
last_d[T[i]] = d;
old_ans += S[i][T[i]];
REP(j, 26) { old_ans -= C[j] * (d - last_d[j]); }
}
REP(i, M) {
int old_p = T[B[i]];
T[B[i]] = Q[i];
ll score = 0;
veci last(26);
REP(j, D) {
int d = j + 1;
last[T[j]] = d;
score += S[j][T[j]];
REP(k, 26) { score -= C[k] * (d - last[k]); }
}
if (old_ans < score) {
old_ans = score;
} else {
T[B[i]] = old_p;
}
}
REP(i, D) cout << T[i] + 1 << endl;
} | replace | 38 | 39 | 38 | 39 | TLE | |
p02618 | C++ | Time Limit Exceeded | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <complex>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <new>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#define BIT(nr) (1ULL << (nr))
// #define int long long
#define ll long long
#define double complex<long double>
#define mod 1000000007
#define MAXN (int)1e+5 * 2 + 1
#define LL_MAX 9223372036854775807
#define LL_HALFMAX 9223372036854775807 / 2
#define MIN -(9223372036854775807 / 2)
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define repl(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define mp make_pair
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
using namespace std;
namespace mmlib {
template <typename T1, typename T2> struct Pair {
Pair() {}
Pair(const Pair &) = default;
Pair(Pair &&) = default;
Pair &operator=(const Pair &) = default;
Pair(const T1 &f, const T2 &s) : first(f), second(s) {}
Pair(T1 &&f, T2 &&s) : first(f), second(s) {}
T1 first;
T2 second;
};
template <typename T, unsigned int N> class Vector {
public:
template <class Itr> void assign(Itr first, Itr last) {
size_ = 0;
while (first != last) {
assert(size_ < N);
m_[size_++] = *first++;
}
}
void assign(size_t n, const T &v) {
assert(n < N);
size_ = n;
while (n--)
m_[n] = v;
}
void assign(std::initializer_list<T> il) { assign(il.begin(), il.end()); }
void resize(size_t n) {
assert(0 <= n);
assert(n < N);
size_ = n;
}
T *begin() { return m_.begin(); };
const T *begin() const { return m_.begin(); };
T *end() { return m_.begin() + size_; };
const T *end() const { return m_.begin() + size_; };
void clear() { size_ = 0; };
size_t size() const { return size_; };
void push_back(const T &v) {
assert(size_ < N);
m_[size_++] = v;
}
void pop_back() {
assert(size_ != 0);
size_--;
}
T &front() {
assert(0 < size_);
return *m_.begin();
}
const T &front() const {
assert(0 < size_);
return *m_.begin();
}
T &back() {
assert(0 < size_);
return *(m_.begin() + size_ - 1);
}
const T &back() const {
assert(0 < size_);
return *(m_.begin() + size_ - 1);
}
T &operator[](size_t pos) {
assert(pos < size_);
return m_[pos];
}
const T &operator[](size_t pos) const {
assert(pos < size_);
return m_[pos];
}
private:
std::array<T, N> m_;
uint32_t size_ = 0;
};
template <typename T, int N, class Compare = std::less<T>> class Ranking {
public:
void on_rankout(std::function<void(const T &)> op) { on_pop_min_ = op; }
bool is_rankin(const T &value) {
return m_.size() < N ? true : Compare()(min_element(), value);
}
void push(const T &value) {
m_.insert(value);
if (size() == N) {
on_pop_min_(min_element());
pop_min();
}
}
T min_element() {
assert(!empty());
return *m_.begin();
}
const T &min_element() const {
assert(!empty());
return *m_.begin();
}
T max_element() {
assert(!empty());
return *m_.rbegin();
}
const T &max_element() const {
assert(!empty());
return *m_.rbegin();
}
void pop_min() {
// assert(!empty());
// Work Around: g++ -pthread -DNDEBUG -march=haswell -std=c++14 ./main.cpp
// -O2 build breaks Search Result
if (empty()) {
std::cerr << "Something Wrong." << std::endl;
}
m_.erase(m_.begin());
}
void pop_max() {
assert(!empty());
m_.erase(--m_.end());
}
bool empty() const { return m_.empty(); }
size_t size() const { return m_.size(); }
void clear() { m_.clear(); }
const std::multiset<T> &data() const { return m_; }
private:
std::multiset<T> m_;
std::function<void(const T &)> on_pop_min_;
};
} // namespace mmlib
// 1-indexed にする
const int TYPES = 26;
class Node {
public:
int score;
// contests[i]: i日目に行われたコンテスト 1-indexed
vector<uint8_t> contests;
// last[i]: コンテストi が最後に行われた日 1-indexed
vector<uint16_t> last;
Node() : contests(1, 0), last(27, 0), score(0) {}
// contestId を末尾に追加した時のスコアを計算する
int chal(const vector<int> &c, const vector<vector<int>> s,
uint8_t contestId) {
int day = contests.size();
int add = s[day][contestId];
int beforeLast = last[contestId];
last[contestId] = day;
int sub = 0;
REPS(i, TYPES) { sub += c[i] * (day - last[i]); }
last[contestId] = beforeLast;
return score + add - sub;
}
// contestId を末尾に追加する
int add(const vector<int> &c, const vector<vector<int>> s,
uint8_t contestId) {
int day = contests.size();
int add = s[day][contestId];
last[contestId] = day;
int sub = 0;
REPS(i, TYPES) { sub += c[i] * (day - last[i]); }
score = score + add - sub;
contests.push_back(contestId);
return score + add - sub;
}
bool operator<(const Node &right) const { return score < right.score; }
};
// 変数名は問題Aに準ずる、 t はコンテストの開催計画を表す
int CalcScore(const int &D, const vector<int> &c, const vector<vector<int>> s,
const vector<int> &t, vector<int> *pOutResult) {
assert(t.size() == pOutResult->size());
int score = 0;
vector<int> lastDay(TYPES + 1, 0);
REPS(d, D) {
int add = s[d][t[d]];
lastDay[t[d]] = d;
int sub = 0;
REPS(i, TYPES) { sub += c[i] * (d - lastDay[i]); }
score += add;
score -= sub;
pOutResult->at(d) = score;
}
return score;
}
Node ChokudaiSearch(const int &D, const vector<int> &c,
const vector<vector<int>> s) {
const int BeamWidth = 1000;
const int BeamDepth = D + 1;
const int loopCnt = 1;
Node tmpNode;
mmlib::Ranking<Node, BeamWidth> chokudaiData[366];
rep(i, 366) {
chokudaiData[i].on_rankout([](Node n) {});
}
chokudaiData[0].push(Node());
int startTime = clock();
while (clock() - startTime < 199 * CLOCKS_PER_SEC / 100) {
// rep(dum2, 100){
// 1回の時間計測に対し loopcnt 回ループをまわす
rep(dumm, loopCnt) {
rep(i, 366) {
// 最終日が終わってたらbreak
if (i == D) {
break;
}
auto &prev = chokudaiData[i];
auto &next = chokudaiData[i + 1];
if (prev.empty())
continue;
// 最高のノードをとってくる
auto node = prev.max_element();
prev.pop_max();
// 全コンテストをためす
REPS(contestId, TYPES) {
int chalScore = node.chal(c, s, contestId);
tmpNode.score = chalScore;
if (next.is_rankin(tmpNode)) {
tmpNode = node;
tmpNode.add(c, s, contestId);
next.push(tmpNode);
}
}
}
}
}
return chokudaiData[D].max_element();
}
signed main() {
int D;
cin >> D;
vector<int> c(TYPES + 1, 0);
vector<vector<int>> s(D + 1, vector<int>(TYPES + 1, 0));
REPS(i, TYPES) { cin >> c[i]; }
REPS(i, D) {
REPS(j, TYPES) { cin >> s[i][j]; }
}
// Dにちめまで chokudai サーチをする
auto res = ChokudaiSearch(D, c, s);
REPS(i, D) { cout << (int)res.contests[i] << "\n"; }
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <assert.h>
#include <cmath>
#include <complex>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <new>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
#define BIT(nr) (1ULL << (nr))
// #define int long long
#define ll long long
#define double complex<long double>
#define mod 1000000007
#define MAXN (int)1e+5 * 2 + 1
#define LL_MAX 9223372036854775807
#define LL_HALFMAX 9223372036854775807 / 2
#define MIN -(9223372036854775807 / 2)
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define ALLOF(c) (c).begin(), (c).end()
#define REPS(i, x) for (int i = 1; i <= (int)(x); i++)
#define RREP(i, x) for (int i = ((int)(x)-1); i >= 0; i--)
#define RREPS(i, x) for (int i = ((int)(x)); i > 0; i--)
#define repl(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define mp make_pair
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
using namespace std;
namespace mmlib {
template <typename T1, typename T2> struct Pair {
Pair() {}
Pair(const Pair &) = default;
Pair(Pair &&) = default;
Pair &operator=(const Pair &) = default;
Pair(const T1 &f, const T2 &s) : first(f), second(s) {}
Pair(T1 &&f, T2 &&s) : first(f), second(s) {}
T1 first;
T2 second;
};
template <typename T, unsigned int N> class Vector {
public:
template <class Itr> void assign(Itr first, Itr last) {
size_ = 0;
while (first != last) {
assert(size_ < N);
m_[size_++] = *first++;
}
}
void assign(size_t n, const T &v) {
assert(n < N);
size_ = n;
while (n--)
m_[n] = v;
}
void assign(std::initializer_list<T> il) { assign(il.begin(), il.end()); }
void resize(size_t n) {
assert(0 <= n);
assert(n < N);
size_ = n;
}
T *begin() { return m_.begin(); };
const T *begin() const { return m_.begin(); };
T *end() { return m_.begin() + size_; };
const T *end() const { return m_.begin() + size_; };
void clear() { size_ = 0; };
size_t size() const { return size_; };
void push_back(const T &v) {
assert(size_ < N);
m_[size_++] = v;
}
void pop_back() {
assert(size_ != 0);
size_--;
}
T &front() {
assert(0 < size_);
return *m_.begin();
}
const T &front() const {
assert(0 < size_);
return *m_.begin();
}
T &back() {
assert(0 < size_);
return *(m_.begin() + size_ - 1);
}
const T &back() const {
assert(0 < size_);
return *(m_.begin() + size_ - 1);
}
T &operator[](size_t pos) {
assert(pos < size_);
return m_[pos];
}
const T &operator[](size_t pos) const {
assert(pos < size_);
return m_[pos];
}
private:
std::array<T, N> m_;
uint32_t size_ = 0;
};
template <typename T, int N, class Compare = std::less<T>> class Ranking {
public:
void on_rankout(std::function<void(const T &)> op) { on_pop_min_ = op; }
bool is_rankin(const T &value) {
return m_.size() < N ? true : Compare()(min_element(), value);
}
void push(const T &value) {
m_.insert(value);
if (size() == N) {
on_pop_min_(min_element());
pop_min();
}
}
T min_element() {
assert(!empty());
return *m_.begin();
}
const T &min_element() const {
assert(!empty());
return *m_.begin();
}
T max_element() {
assert(!empty());
return *m_.rbegin();
}
const T &max_element() const {
assert(!empty());
return *m_.rbegin();
}
void pop_min() {
// assert(!empty());
// Work Around: g++ -pthread -DNDEBUG -march=haswell -std=c++14 ./main.cpp
// -O2 build breaks Search Result
if (empty()) {
std::cerr << "Something Wrong." << std::endl;
}
m_.erase(m_.begin());
}
void pop_max() {
assert(!empty());
m_.erase(--m_.end());
}
bool empty() const { return m_.empty(); }
size_t size() const { return m_.size(); }
void clear() { m_.clear(); }
const std::multiset<T> &data() const { return m_; }
private:
std::multiset<T> m_;
std::function<void(const T &)> on_pop_min_;
};
} // namespace mmlib
// 1-indexed にする
const int TYPES = 26;
class Node {
public:
int score;
// contests[i]: i日目に行われたコンテスト 1-indexed
vector<uint8_t> contests;
// last[i]: コンテストi が最後に行われた日 1-indexed
vector<uint16_t> last;
Node() : contests(1, 0), last(27, 0), score(0) {}
// contestId を末尾に追加した時のスコアを計算する
int chal(const vector<int> &c, const vector<vector<int>> s,
uint8_t contestId) {
int day = contests.size();
int add = s[day][contestId];
int beforeLast = last[contestId];
last[contestId] = day;
int sub = 0;
REPS(i, TYPES) { sub += c[i] * (day - last[i]); }
last[contestId] = beforeLast;
return score + add - sub;
}
// contestId を末尾に追加する
int add(const vector<int> &c, const vector<vector<int>> s,
uint8_t contestId) {
int day = contests.size();
int add = s[day][contestId];
last[contestId] = day;
int sub = 0;
REPS(i, TYPES) { sub += c[i] * (day - last[i]); }
score = score + add - sub;
contests.push_back(contestId);
return score + add - sub;
}
bool operator<(const Node &right) const { return score < right.score; }
};
// 変数名は問題Aに準ずる、 t はコンテストの開催計画を表す
int CalcScore(const int &D, const vector<int> &c, const vector<vector<int>> s,
const vector<int> &t, vector<int> *pOutResult) {
assert(t.size() == pOutResult->size());
int score = 0;
vector<int> lastDay(TYPES + 1, 0);
REPS(d, D) {
int add = s[d][t[d]];
lastDay[t[d]] = d;
int sub = 0;
REPS(i, TYPES) { sub += c[i] * (d - lastDay[i]); }
score += add;
score -= sub;
pOutResult->at(d) = score;
}
return score;
}
Node ChokudaiSearch(const int &D, const vector<int> &c,
const vector<vector<int>> s) {
const int BeamWidth = 1000;
const int BeamDepth = D + 1;
const int loopCnt = 1;
Node tmpNode;
mmlib::Ranking<Node, BeamWidth> chokudaiData[366];
rep(i, 366) {
chokudaiData[i].on_rankout([](Node n) {});
}
chokudaiData[0].push(Node());
int startTime = clock();
while (clock() - startTime < 170 * CLOCKS_PER_SEC / 100) {
// rep(dum2, 100){
// 1回の時間計測に対し loopcnt 回ループをまわす
rep(dumm, loopCnt) {
rep(i, 366) {
// 最終日が終わってたらbreak
if (i == D) {
break;
}
auto &prev = chokudaiData[i];
auto &next = chokudaiData[i + 1];
if (prev.empty())
continue;
// 最高のノードをとってくる
auto node = prev.max_element();
prev.pop_max();
// 全コンテストをためす
REPS(contestId, TYPES) {
int chalScore = node.chal(c, s, contestId);
tmpNode.score = chalScore;
if (next.is_rankin(tmpNode)) {
tmpNode = node;
tmpNode.add(c, s, contestId);
next.push(tmpNode);
}
}
}
}
}
return chokudaiData[D].max_element();
}
signed main() {
int D;
cin >> D;
vector<int> c(TYPES + 1, 0);
vector<vector<int>> s(D + 1, vector<int>(TYPES + 1, 0));
REPS(i, TYPES) { cin >> c[i]; }
REPS(i, D) {
REPS(j, TYPES) { cin >> s[i][j]; }
}
// Dにちめまで chokudai サーチをする
auto res = ChokudaiSearch(D, c, s);
REPS(i, D) { cout << (int)res.contests[i] << "\n"; }
return 0;
} | replace | 294 | 295 | 294 | 295 | TLE | |
p02618 | C++ | Time Limit Exceeded | // 山登り法しか思いつかない
#include <bits/stdc++.h>
using namespace std;
int D;
int res[365]; // 解答
long long c[26];
long long s[365][26];
long long evaluate() {
static int LatestProb[26];
long long score = 0;
memset(LatestProb, -1, sizeof(LatestProb));
for (int d = 0; d < D; ++d) {
score += s[d][res[d]];
LatestProb[res[d]] = d;
for (int j = 0; j < 26; ++j) {
if (LatestProb[j] == -1)
continue;
score -= c[j] * (d - LatestProb[j]);
}
}
return score;
}
int main() {
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];
}
}
random_device rnd; // 非決定的な乱数生成期を生成
mt19937 mt(rnd()); // メルセンヌ・ツイスタの32bit版、引数は初期シード値
uniform_int_distribution<> rand26(0, 25); // [0, 25]範囲の一様乱数
uniform_int_distribution<> rand365(0, 364);
for (int i = 0; i < D; ++i) {
res[i] = rand26(mt);
}
// 山登り法をして、解を大きくしていく。
long long score = evaluate();
int IterationNum = 1000000;
while (IterationNum--) {
// 二つ変える
int ch1 = rand365(mt);
int ch2;
while ((ch2 = rand365(mt)) == ch1)
;
// どの問題にするか決める
int ct1 = rand26(mt), ct2 = rand26(mt);
// 変える前の情報を格納
int prev1 = res[ch1], prev2 = res[ch2];
// 変更
res[ch1] = ct1, res[ch2] = ct2;
// スコア計算
long long nxt = evaluate();
if (score < nxt) {
score = nxt;
} else {
// 元に戻す。
res[ch1] = prev1, res[ch2] = prev2;
}
}
for (int i = 0; i < D; ++i) {
cout << res[i] + 1 << endl;
}
// cout << "score: " << score << endl;
return 0;
} | // 山登り法しか思いつかない
#include <bits/stdc++.h>
using namespace std;
int D;
int res[365]; // 解答
long long c[26];
long long s[365][26];
long long evaluate() {
static int LatestProb[26];
long long score = 0;
memset(LatestProb, -1, sizeof(LatestProb));
for (int d = 0; d < D; ++d) {
score += s[d][res[d]];
LatestProb[res[d]] = d;
for (int j = 0; j < 26; ++j) {
if (LatestProb[j] == -1)
continue;
score -= c[j] * (d - LatestProb[j]);
}
}
return score;
}
int main() {
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];
}
}
random_device rnd; // 非決定的な乱数生成期を生成
mt19937 mt(rnd()); // メルセンヌ・ツイスタの32bit版、引数は初期シード値
uniform_int_distribution<> rand26(0, 25); // [0, 25]範囲の一様乱数
uniform_int_distribution<> rand365(0, 364);
for (int i = 0; i < D; ++i) {
res[i] = rand26(mt);
}
// 山登り法をして、解を大きくしていく。
long long score = evaluate();
int IterationNum = 5000;
while (IterationNum--) {
// 二つ変える
int ch1 = rand365(mt);
int ch2;
while ((ch2 = rand365(mt)) == ch1)
;
// どの問題にするか決める
int ct1 = rand26(mt), ct2 = rand26(mt);
// 変える前の情報を格納
int prev1 = res[ch1], prev2 = res[ch2];
// 変更
res[ch1] = ct1, res[ch2] = ct2;
// スコア計算
long long nxt = evaluate();
if (score < nxt) {
score = nxt;
} else {
// 元に戻す。
res[ch1] = prev1, res[ch2] = prev2;
}
}
for (int i = 0; i < D; ++i) {
cout << res[i] + 1 << endl;
}
// cout << "score: " << score << endl;
return 0;
} | replace | 46 | 47 | 46 | 47 | TLE | |
p02618 | C++ | Time Limit Exceeded | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
using namespace std;
int main() {
ll D;
cin >> D;
ll N = 26;
vector<ll> c(N);
for (ll ii = 0; ii < N; ++ii) {
cin >> c[ii];
}
vector<vector<ll>> s(D, vector<ll>(N));
for (ll ii = 0; ii < D; ++ii) {
for (ll jj = 0; jj < N; ++jj) {
cin >> s[ii][jj];
}
}
// 貪欲法
vector<int> ans(D, 0);
vector<int> last(N, -1);
vector<set<int>> select(N);
for (int ii = 0; ii < N; ++ii) {
select[ii].insert(-1);
}
for (ll d = 0; d < D; ++d) {
// d日目の最適解を選ぶ
ll val = 0;
ll idx = 0;
for (int ii = 0; ii < N; ++ii) {
ll tmp = s[d][ii] + c[ii] * (d - last[ii]);
if (tmp > val) {
val = tmp;
idx = ii;
}
}
ans[d] = idx;
last[idx] = d;
select[idx].insert(d);
}
// ランダムに値を変更する
int trial = 2001001;
for (int t = 0; t < trial; ++t) {
int d = rand() % D;
int prevType = ans[d];
int newType = rand() % N;
while (prevType == newType) {
newType = rand() % N;
}
ll dif = s[d][newType] - s[d][prevType];
auto itr = upper_bound(select[newType].begin(), select[newType].end(), d);
ll newDist = (itr != select[newType].end()) ? (*itr - d) : (D - d);
auto itr2 =
upper_bound(select[newType].rbegin(), select[newType].rend(), d);
ll newVal = d - *itr2;
dif += newVal * newDist;
itr = upper_bound(select[prevType].begin(), select[prevType].end(), d);
ll prevDist = (itr != select[prevType].end()) ? (*itr - d) : (D - d);
itr2 = upper_bound(select[prevType].rbegin(), select[prevType].rend(), d);
ll prevVal = d - *itr2;
dif -= prevVal * prevDist;
if (dif > 0) {
select[prevType].erase(d);
select[newType].insert(d);
ans[d] = newType;
}
}
for (ll d = 0; d < D; ++d) {
cout << ans[d] + 1 << "\n";
}
return 0;
}
| #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
#define ll long long
#define ull unsigned long long
using namespace std;
int main() {
ll D;
cin >> D;
ll N = 26;
vector<ll> c(N);
for (ll ii = 0; ii < N; ++ii) {
cin >> c[ii];
}
vector<vector<ll>> s(D, vector<ll>(N));
for (ll ii = 0; ii < D; ++ii) {
for (ll jj = 0; jj < N; ++jj) {
cin >> s[ii][jj];
}
}
// 貪欲法
vector<int> ans(D, 0);
vector<int> last(N, -1);
vector<set<int>> select(N);
for (int ii = 0; ii < N; ++ii) {
select[ii].insert(-1);
}
for (ll d = 0; d < D; ++d) {
// d日目の最適解を選ぶ
ll val = 0;
ll idx = 0;
for (int ii = 0; ii < N; ++ii) {
ll tmp = s[d][ii] + c[ii] * (d - last[ii]);
if (tmp > val) {
val = tmp;
idx = ii;
}
}
ans[d] = idx;
last[idx] = d;
select[idx].insert(d);
}
// ランダムに値を変更する
int trial = 1001001;
for (int t = 0; t < trial; ++t) {
int d = rand() % D;
int prevType = ans[d];
int newType = rand() % N;
while (prevType == newType) {
newType = rand() % N;
}
ll dif = s[d][newType] - s[d][prevType];
auto itr = upper_bound(select[newType].begin(), select[newType].end(), d);
ll newDist = (itr != select[newType].end()) ? (*itr - d) : (D - d);
auto itr2 =
upper_bound(select[newType].rbegin(), select[newType].rend(), d);
ll newVal = d - *itr2;
dif += newVal * newDist;
itr = upper_bound(select[prevType].begin(), select[prevType].end(), d);
ll prevDist = (itr != select[prevType].end()) ? (*itr - d) : (D - d);
itr2 = upper_bound(select[prevType].rbegin(), select[prevType].rend(), d);
ll prevVal = d - *itr2;
dif -= prevVal * prevDist;
if (dif > 0) {
select[prevType].erase(d);
select[newType].insert(d);
ans[d] = newType;
}
}
for (ll d = 0; d < D; ++d) {
cout << ans[d] + 1 << "\n";
}
return 0;
}
| replace | 48 | 49 | 48 | 49 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int F = 26;
const int def = 1e6;
int n;
vector<int> c(F);
vector<vector<int>> a;
void init() {
cin >> n;
a.resize(n, vector<int>(F));
for (int i = 0; i < F; i++)
cin >> c[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < F; j++)
cin >> a[i][j];
}
vector<int> calc(int rng) {
vector<int> last(F, -1);
vector<int> ans;
for (int i = 0; i < n; i++) {
vector<int> cur = a[i];
for (int j = 0; j < F; j++)
cur[j] += (i - last[j]) * (c[j] + rng);
int ind = max_element(cur.begin(), cur.end()) - cur.begin();
last[ind] = i;
ans.emplace_back(ind);
}
return ans;
}
int chack(vector<int> p) {
int sum = 0;
vector<int> last(F, -1);
for (int i = 0; i < n; i++) {
sum += a[i][p[i]];
last[p[i]] = i;
for (int j = 0; j < F; j++)
sum -= (i - last[j]) * c[j];
}
return sum;
}
int main() {
srand((unsigned)time(NULL));
init();
vector<int> ans;
int M = 4 * 1e4, nax = -1e9;
for (int I = 1; I <= M; I++) {
int sed = rand() % (rand() % ((I / 50) + 1)) * ((rand() % 2) ? 1 : -1);
vector<int> cur = calc(sed);
int k = chack(cur);
if (k > nax) {
nax = k;
ans = cur;
}
}
for (auto i : ans)
cout << i + 1 << endl;
}
/*
satisfaction: 424801
score: 1424801
*/
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int F = 26;
const int def = 1e6;
int n;
vector<int> c(F);
vector<vector<int>> a;
void init() {
cin >> n;
a.resize(n, vector<int>(F));
for (int i = 0; i < F; i++)
cin >> c[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < F; j++)
cin >> a[i][j];
}
vector<int> calc(int rng) {
vector<int> last(F, -1);
vector<int> ans;
for (int i = 0; i < n; i++) {
vector<int> cur = a[i];
for (int j = 0; j < F; j++)
cur[j] += (i - last[j]) * (c[j] + rng);
int ind = max_element(cur.begin(), cur.end()) - cur.begin();
last[ind] = i;
ans.emplace_back(ind);
}
return ans;
}
int chack(vector<int> p) {
int sum = 0;
vector<int> last(F, -1);
for (int i = 0; i < n; i++) {
sum += a[i][p[i]];
last[p[i]] = i;
for (int j = 0; j < F; j++)
sum -= (i - last[j]) * c[j];
}
return sum;
}
int main() {
srand((unsigned)time(NULL));
init();
vector<int> ans;
int M = 4 * 1e4, nax = -1e9;
for (int I = 1; I <= M; I++) {
int sed = rand() % (rand() % ((I / 50) + 1) + 1) * ((rand() % 2) ? 1 : -1);
vector<int> cur = calc(sed);
int k = chack(cur);
if (k > nax) {
nax = k;
ans = cur;
}
}
for (auto i : ans)
cout << i + 1 << endl;
}
/*
satisfaction: 424801
score: 1424801
*/
| replace | 54 | 55 | 54 | 55 | -8 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr char newl = '\n';
constexpr double ticks_per_sec = 2800000000;
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;
}
constexpr double TLE = 2; // sec
constexpr double time_limit = TLE * 0.995;
unsigned int randxor() {
static unsigned int x = 123456789, y = 362436069, z = 521288629, w = 88675123;
unsigned int t;
t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
template <typename hoge> void my_shuffle(vector<hoge> &v) {
int sz = v.size();
for (int i = sz - 1; i >= 1; i--) {
swap(v[i], v[randxor() % (i + 1)]);
}
}
// 定数
constexpr int CONTEST_NUM = 26;
// 入力
constexpr int D = 365;
array<int, CONTEST_NUM> c;
array<array<int, CONTEST_NUM>, D> s;
ll calcScore(const array<int, D> &t) {
ll score = 0;
array<int, CONTEST_NUM> lasts{};
for (int i = 0; i < D; i++) {
lasts[t[i]] = i + 1;
score += s[i][t[i]];
for (int j = 0; j < CONTEST_NUM; j++) {
score -= c[j] * (i + 1 - lasts[j]);
}
}
return score;
}
void update(int target_day, int new_contest, array<int, D> &t,
array<set<int>, CONTEST_NUM> &days) {
int old_contest = t[target_day - 1];
days[old_contest].erase(target_day);
days[new_contest].insert(target_day);
t[target_day - 1] = new_contest;
}
// return: diff score
ll calcDiff(int target_day, int new_contest, array<int, D> &t,
array<set<int>, CONTEST_NUM> &days) {
int old_contest = t[target_day - 1];
ll diff = s[target_day - 1][new_contest] - s[target_day - 1][old_contest];
{
auto it = days[new_contest].upper_bound(target_day);
int nex = *it;
int prv = *prev(it);
int d1 = target_day - prv - 1;
int d2 = nex - target_day - 1;
int d3 = nex - prv - 1;
diff -= c[new_contest] * d1 * (d1 + 1) / 2;
diff -= c[new_contest] * d2 * (d2 + 1) / 2;
diff += c[new_contest] * d3 * (d3 + 1) / 2;
}
{
auto it = days[old_contest].find(target_day);
int nex = *next(it);
int prv = *prev(it);
int d1 = target_day - prv - 1;
int d2 = nex - target_day - 1;
int d3 = nex - prv - 1;
diff += c[old_contest] * d1 * (d1 + 1) / 2;
diff += c[old_contest] * d2 * (d2 + 1) / 2;
diff -= c[old_contest] * d3 * (d3 + 1) / 2;
}
return diff;
}
struct State {
int score;
array<int, D> t;
array<int, CONTEST_NUM> lasts;
State() {}
bool operator<(const State &s) const { return score > s.score; }
};
ll init(array<int, D> &t, array<set<int>, CONTEST_NUM> &days) {
ll score = 0;
array<int, CONTEST_NUM> lasts{};
for (int i = 0; i < D; i++) {
ll max_diff = -1e15;
ll pena_sum = 0;
for (int j = 0; j < CONTEST_NUM; j++) {
ll tmp = c[j] * (i + 1 - lasts[j]);
pena_sum += tmp;
if (s[i][j] + tmp > max_diff) {
max_diff = s[i][j] + tmp;
t[i] = j;
}
}
max_diff -= pena_sum;
score += max_diff;
lasts[t[i]] = i + 1;
days[t[i]].insert(i + 1);
}
return score;
}
ll init2(array<int, D> &t, array<set<int>, CONTEST_NUM> &days) {
vector<State> pq;
pq.emplace_back();
constexpr size_t BEAM = 300;
for (int i = 0; i < D; i++) {
vector<State> npq;
int sz = min(pq.size(), BEAM);
if (pq.size() > BEAM)
nth_element(pq.begin(), pq.begin() + BEAM - 1, pq.end());
for (int ii = 0; ii < sz; ++ii) {
State cur = pq[ii];
ll pena_sum = 0;
for (int j = 0; j < CONTEST_NUM; j++) {
ll tmp = c[j] * (i + 1 - cur.lasts[j]);
pena_sum += tmp;
}
for (int j = 0; j < CONTEST_NUM; j++) {
ll tmp = c[j] * (i + 1 - cur.lasts[j]);
cur.t[i] = j;
int sc = cur.score;
int memo = cur.lasts[j];
cur.lasts[j] = i + 1;
cur.score += s[i][j] + tmp - pena_sum;
npq.push_back(cur);
cur.lasts[j] = memo;
cur.score = sc;
}
}
pq = move(npq);
}
State best = *min_element(pq.begin(), pq.end());
t = move(best.t);
for (int i = 0; i < D; i++) {
days[t[i]].insert(i + 1);
}
return best.score;
}
int main() {
double clock_begin = rdtsc();
cin.tie(nullptr);
ios::sync_with_stdio(false);
{
int dummy;
cin >> dummy;
for (int i = 0; i < CONTEST_NUM; i++) {
cin >> c[i];
}
for (int i = 0; i < D; i++) {
for (int j = 0; j < CONTEST_NUM; j++) {
cin >> s[i][j];
}
}
}
array<set<int>, CONTEST_NUM> days;
for (int i = 0; i < CONTEST_NUM; i++) {
days[i].insert(0);
days[i].insert(D + 1);
}
array<int, D> t{};
ll current_score = init2(t, days);
// assert(current_score == calcScore(t));
ll best_score = current_score;
array<int, D> ans = t;
/*
{
array<int, D> t2{};
for (int i = 0; i < D; i++) {
for (int j = 1; j < CONTEST_NUM; j++) {
if (s[i][j] > s[i][t2[i]]) t2[i] = j;
}
}
cerr << current_score << " " << calcScore(t2) << newl;
}*/
// 焼きなまし
/*
{
constexpr double start_temp = 10000;
constexpr double end_temp = 100;
constexpr ll R = 10000;
double current_time;
int counter = 0;
while ((current_time = rdtsc() - clock_begin) < time_limit) {
++counter;
int target_day = randxor() % D + 1;
int new_contest = randxor() % (CONTEST_NUM - 1);
new_contest += (new_contest >= t[target_day - 1]);
ll next_score = current_score + calcDiff(target_day, new_contest, t,
days); double temp = start_temp + (end_temp - start_temp) * current_time /
time_limit; double prob = exp((next_score - current_score) / temp); bool
force_next = prob > (double)(randxor() % R) / R; if (next_score >
current_score || force_next) { update(target_day, new_contest, t, days);
current_score = next_score;
if (current_score > best_score) {
ans = t;
best_score = current_score;
}
}
}
}*/
for (int i = 0; i < D; i++) {
cout << ans[i] + 1 << newl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr char newl = '\n';
constexpr double ticks_per_sec = 2800000000;
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;
}
constexpr double TLE = 2; // sec
constexpr double time_limit = TLE * 0.995;
unsigned int randxor() {
static unsigned int x = 123456789, y = 362436069, z = 521288629, w = 88675123;
unsigned int t;
t = (x ^ (x << 11));
x = y;
y = z;
z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
template <typename hoge> void my_shuffle(vector<hoge> &v) {
int sz = v.size();
for (int i = sz - 1; i >= 1; i--) {
swap(v[i], v[randxor() % (i + 1)]);
}
}
// 定数
constexpr int CONTEST_NUM = 26;
// 入力
constexpr int D = 365;
array<int, CONTEST_NUM> c;
array<array<int, CONTEST_NUM>, D> s;
ll calcScore(const array<int, D> &t) {
ll score = 0;
array<int, CONTEST_NUM> lasts{};
for (int i = 0; i < D; i++) {
lasts[t[i]] = i + 1;
score += s[i][t[i]];
for (int j = 0; j < CONTEST_NUM; j++) {
score -= c[j] * (i + 1 - lasts[j]);
}
}
return score;
}
void update(int target_day, int new_contest, array<int, D> &t,
array<set<int>, CONTEST_NUM> &days) {
int old_contest = t[target_day - 1];
days[old_contest].erase(target_day);
days[new_contest].insert(target_day);
t[target_day - 1] = new_contest;
}
// return: diff score
ll calcDiff(int target_day, int new_contest, array<int, D> &t,
array<set<int>, CONTEST_NUM> &days) {
int old_contest = t[target_day - 1];
ll diff = s[target_day - 1][new_contest] - s[target_day - 1][old_contest];
{
auto it = days[new_contest].upper_bound(target_day);
int nex = *it;
int prv = *prev(it);
int d1 = target_day - prv - 1;
int d2 = nex - target_day - 1;
int d3 = nex - prv - 1;
diff -= c[new_contest] * d1 * (d1 + 1) / 2;
diff -= c[new_contest] * d2 * (d2 + 1) / 2;
diff += c[new_contest] * d3 * (d3 + 1) / 2;
}
{
auto it = days[old_contest].find(target_day);
int nex = *next(it);
int prv = *prev(it);
int d1 = target_day - prv - 1;
int d2 = nex - target_day - 1;
int d3 = nex - prv - 1;
diff += c[old_contest] * d1 * (d1 + 1) / 2;
diff += c[old_contest] * d2 * (d2 + 1) / 2;
diff -= c[old_contest] * d3 * (d3 + 1) / 2;
}
return diff;
}
struct State {
int score;
array<int, D> t;
array<int, CONTEST_NUM> lasts;
State() {}
bool operator<(const State &s) const { return score > s.score; }
};
ll init(array<int, D> &t, array<set<int>, CONTEST_NUM> &days) {
ll score = 0;
array<int, CONTEST_NUM> lasts{};
for (int i = 0; i < D; i++) {
ll max_diff = -1e15;
ll pena_sum = 0;
for (int j = 0; j < CONTEST_NUM; j++) {
ll tmp = c[j] * (i + 1 - lasts[j]);
pena_sum += tmp;
if (s[i][j] + tmp > max_diff) {
max_diff = s[i][j] + tmp;
t[i] = j;
}
}
max_diff -= pena_sum;
score += max_diff;
lasts[t[i]] = i + 1;
days[t[i]].insert(i + 1);
}
return score;
}
ll init2(array<int, D> &t, array<set<int>, CONTEST_NUM> &days) {
vector<State> pq;
pq.emplace_back();
constexpr size_t BEAM = 250;
for (int i = 0; i < D; i++) {
vector<State> npq;
int sz = min(pq.size(), BEAM);
if (pq.size() > BEAM)
nth_element(pq.begin(), pq.begin() + BEAM - 1, pq.end());
for (int ii = 0; ii < sz; ++ii) {
State cur = pq[ii];
ll pena_sum = 0;
for (int j = 0; j < CONTEST_NUM; j++) {
ll tmp = c[j] * (i + 1 - cur.lasts[j]);
pena_sum += tmp;
}
for (int j = 0; j < CONTEST_NUM; j++) {
ll tmp = c[j] * (i + 1 - cur.lasts[j]);
cur.t[i] = j;
int sc = cur.score;
int memo = cur.lasts[j];
cur.lasts[j] = i + 1;
cur.score += s[i][j] + tmp - pena_sum;
npq.push_back(cur);
cur.lasts[j] = memo;
cur.score = sc;
}
}
pq = move(npq);
}
State best = *min_element(pq.begin(), pq.end());
t = move(best.t);
for (int i = 0; i < D; i++) {
days[t[i]].insert(i + 1);
}
return best.score;
}
int main() {
double clock_begin = rdtsc();
cin.tie(nullptr);
ios::sync_with_stdio(false);
{
int dummy;
cin >> dummy;
for (int i = 0; i < CONTEST_NUM; i++) {
cin >> c[i];
}
for (int i = 0; i < D; i++) {
for (int j = 0; j < CONTEST_NUM; j++) {
cin >> s[i][j];
}
}
}
array<set<int>, CONTEST_NUM> days;
for (int i = 0; i < CONTEST_NUM; i++) {
days[i].insert(0);
days[i].insert(D + 1);
}
array<int, D> t{};
ll current_score = init2(t, days);
// assert(current_score == calcScore(t));
ll best_score = current_score;
array<int, D> ans = t;
/*
{
array<int, D> t2{};
for (int i = 0; i < D; i++) {
for (int j = 1; j < CONTEST_NUM; j++) {
if (s[i][j] > s[i][t2[i]]) t2[i] = j;
}
}
cerr << current_score << " " << calcScore(t2) << newl;
}*/
// 焼きなまし
/*
{
constexpr double start_temp = 10000;
constexpr double end_temp = 100;
constexpr ll R = 10000;
double current_time;
int counter = 0;
while ((current_time = rdtsc() - clock_begin) < time_limit) {
++counter;
int target_day = randxor() % D + 1;
int new_contest = randxor() % (CONTEST_NUM - 1);
new_contest += (new_contest >= t[target_day - 1]);
ll next_score = current_score + calcDiff(target_day, new_contest, t,
days); double temp = start_temp + (end_temp - start_temp) * current_time /
time_limit; double prob = exp((next_score - current_score) / temp); bool
force_next = prob > (double)(randxor() % R) / R; if (next_score >
current_score || force_next) { update(target_day, new_contest, t, days);
current_score = next_score;
if (current_score > best_score) {
ans = t;
best_score = current_score;
}
}
}
}*/
for (int i = 0; i < D; i++) {
cout << ans[i] + 1 << newl;
}
return 0;
}
| replace | 139 | 140 | 139 | 140 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
mt19937 rng(time(NULL));
const int D = 365, N = 26;
int d;
ll c[N + 1];
ll s[D + 1][N + 1];
ll last[N];
int contest[D];
ll calc(int idx, int x) {
ll ans = 0;
ll l = idx - 1, r = idx + 1;
ll len, len2;
while (l > 0 && contest[l] != contest[idx])
l--;
len = idx - l;
while (r <= d && contest[r] != contest[idx])
r++;
len2 = r - idx;
ans -= s[idx][contest[idx]];
ans -= c[contest[idx]] * len * len2;
ll tmp = contest[idx];
contest[idx] = x;
l = idx - 1, r = idx + 1;
while (l > 0 && contest[l] != contest[idx])
l--;
len = idx - l;
while (r <= d && contest[r] != contest[idx])
r++;
len2 = r - idx;
ans += s[idx][x];
ans += c[x] * len * len2;
contest[idx] = tmp;
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> d;
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];
}
memset(last, 0, sizeof last);
ll ans = 0;
for (int i = 1; i <= d; i++) {
ll penalty = 0;
for (int j = 1; j <= 26; j++)
penalty += c[j] * (last[j] - i);
ll best = -1, idx = -1;
for (int j = 1; j <= 26; j++) {
ll cur = s[i][j] - penalty + c[j] * (i - last[j]);
if (best < cur)
best = cur, idx = j;
}
last[idx] = i;
ans += best;
contest[i] = idx;
}
for (int i = 0; i < 120000; i++) {
int idx = rng() % d + 1;
for (int to = 1; i <= N; to++)
if (to != contest[idx]) {
ll change = calc(idx, to);
if (change > 0) {
contest[idx] = to;
ans += change;
}
}
}
for (int i = 1; i <= d; i++)
cout << contest[i] << '\n';
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
mt19937 rng(time(NULL));
const int D = 365, N = 26;
int d;
ll c[N + 1];
ll s[D + 1][N + 1];
ll last[N];
int contest[D];
ll calc(int idx, int x) {
ll ans = 0;
ll l = idx - 1, r = idx + 1;
ll len, len2;
while (l > 0 && contest[l] != contest[idx])
l--;
len = idx - l;
while (r <= d && contest[r] != contest[idx])
r++;
len2 = r - idx;
ans -= s[idx][contest[idx]];
ans -= c[contest[idx]] * len * len2;
ll tmp = contest[idx];
contest[idx] = x;
l = idx - 1, r = idx + 1;
while (l > 0 && contest[l] != contest[idx])
l--;
len = idx - l;
while (r <= d && contest[r] != contest[idx])
r++;
len2 = r - idx;
ans += s[idx][x];
ans += c[x] * len * len2;
contest[idx] = tmp;
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> d;
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];
}
memset(last, 0, sizeof last);
ll ans = 0;
for (int i = 1; i <= d; i++) {
ll penalty = 0;
for (int j = 1; j <= 26; j++)
penalty += c[j] * (last[j] - i);
ll best = -1, idx = -1;
for (int j = 1; j <= 26; j++) {
ll cur = s[i][j] - penalty + c[j] * (i - last[j]);
if (best < cur)
best = cur, idx = j;
}
last[idx] = i;
ans += best;
contest[i] = idx;
}
for (int i = 0; i < 120000; i++) {
int idx = rng() % d + 1;
for (int to = 1; to <= 26; to++)
if (to != contest[idx]) {
ll change = calc(idx, to);
if (change > 0) {
contest[idx] = to;
ans += change;
}
}
}
for (int i = 1; i <= d; i++)
cout << contest[i] << '\n';
return 0;
} | replace | 69 | 70 | 69 | 70 | -11 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
class xor_shift_128 {
public:
typedef uint32_t result_type;
explicit xor_shift_128(uint32_t seed = 42) { set_seed(seed); }
void set_seed(uint32_t seed) {
a = seed = 1812433253u * (seed ^ (seed >> 30));
b = seed = 1812433253u * (seed ^ (seed >> 30)) + 1;
c = seed = 1812433253u * (seed ^ (seed >> 30)) + 2;
d = seed = 1812433253u * (seed ^ (seed >> 30)) + 3;
}
uint32_t operator()() {
uint32_t t = (a ^ (a << 11));
a = b;
b = c;
c = d;
return d = (d ^ (d >> 19)) ^ (t ^ (t >> 8));
}
static constexpr uint32_t max() { return numeric_limits<result_type>::max(); }
static constexpr uint32_t min() { return numeric_limits<result_type>::min(); }
private:
uint32_t a{}, b{}, c{}, d{};
};
const int CONTEST_NUM = 26;
struct State {
vector<int> contest_order;
State(const int D) : contest_order(vector<int>(D + 1)) {}
};
template <class Generator>
int choose(int const min, int const max, Generator &gen) {
assert(min <= max);
return uniform_int_distribution<int>(min, max)(gen);
}
long long compute_score(const State &state, const vector<int> &costs,
const vector<vector<int>> &values, const int D) {
long long score = 0;
vector<int> last(CONTEST_NUM + 1, 0);
for (int i = 1; i <= D; i++) {
score += values[i][state.contest_order[i]];
last[state.contest_order[i]] = i;
for (int j = 1; j <= CONTEST_NUM; j++) {
score -= costs[i] * (i - last[j]);
}
}
return score;
}
template <class Generator>
State solve(const vector<int> &costs, const vector<vector<int>> &values,
const int D, Generator &gen) {
State best_state(D), state(D);
if (getenv("RESUME")) {
ifstream ifs(getenv("RESUME"));
string line;
getline(ifs, line);
int cnt = 0;
while (getline(ifs, line)) {
cnt++;
if (cnt % 2 == 0)
continue;
stringstream ss_line(line);
}
} else { // make an initial state
vector<int> last(CONTEST_NUM + 1, 0);
for (int i = 1; i <= D; i++) {
long long maxDiff = LLONG_MIN, contestId = -1;
for (int j = 1; j <= CONTEST_NUM; j++) {
long long diff = values[i][j];
for (int k = 1; k <= CONTEST_NUM; k++) {
if (k == j)
continue;
diff -= costs[i] * (i - last[k]);
}
if (diff > maxDiff) {
maxDiff = diff;
contestId = j;
}
}
assert(contestId != -1);
state.contest_order[i] = contestId;
last[state.contest_order[i]] = i;
}
}
best_state = state;
long long score = compute_score(state, costs, values, D);
long long highscore = score;
// cerr << "[*] highscore = " << highscore << endl;
constexpr int TIME_LIMIT = 1000; // msec
chrono::high_resolution_clock::time_point clock_begin =
chrono::high_resolution_clock::now();
double temperature = 1;
for (unsigned iteration = 0;; ++iteration) {
if (iteration % 128 == 0) {
chrono::high_resolution_clock::time_point clock_end =
chrono::high_resolution_clock::now();
temperature = 1 - chrono::duration_cast<chrono::milliseconds>(clock_end -
clock_begin)
.count() /
TIME_LIMIT;
if (temperature < 0) {
// cerr << "[*] iteration = " << iteration << ": done" <<
// endl;
break;
}
}
const int newContestId = choose(1, CONTEST_NUM, gen);
const int day = choose(1, D, gen);
const int oldContestId = state.contest_order[day];
state.contest_order[day] = newContestId;
long long newScore = compute_score(state, costs, values, D);
long long delta = newScore - score;
constexpr double boltzmann = 3;
if (delta >= 0 or
bernoulli_distribution(exp(boltzmann * delta) * temperature)(gen)) {
if (delta < 0) {
// cerr << "[*] iteration = " << iteration << ": delta =
// " << delta << ": p = " << exp(boltzmann * delta) *
// temperature << endl;
}
score += delta;
if (highscore < score) {
highscore = score;
best_state = state;
// cerr << "[*] iteration = " << iteration << ":
// highscore = " << highscore << endl;
}
} else {
// resume
state.contest_order[day] = oldContestId;
}
}
// cerr << "[*] highscore = " << highscore << endl;
return best_state;
}
int main() {
int D;
scanf("%lld", &D);
std::vector<int> c(CONTEST_NUM + 1);
for (int i = 1; i <= 26; i++) {
scanf("%lld", &c[i]);
}
std::vector<std::vector<int>> s(D + 1, std::vector<int>(CONTEST_NUM + 1));
for (int i = 1; i <= D; i++) {
for (int j = 1; j <= 26; j++) {
scanf("%lld", &s[i][j]);
}
}
// solve
xor_shift_128 gen;
State state = solve(std::move(c), std::move(s), D, gen);
// output
stringstream ss;
int cnt = 0;
for (int i = 1; i <= D; i++) {
ss << state.contest_order[i] << "\n";
}
cout << ss.str();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
class xor_shift_128 {
public:
typedef uint32_t result_type;
explicit xor_shift_128(uint32_t seed = 42) { set_seed(seed); }
void set_seed(uint32_t seed) {
a = seed = 1812433253u * (seed ^ (seed >> 30));
b = seed = 1812433253u * (seed ^ (seed >> 30)) + 1;
c = seed = 1812433253u * (seed ^ (seed >> 30)) + 2;
d = seed = 1812433253u * (seed ^ (seed >> 30)) + 3;
}
uint32_t operator()() {
uint32_t t = (a ^ (a << 11));
a = b;
b = c;
c = d;
return d = (d ^ (d >> 19)) ^ (t ^ (t >> 8));
}
static constexpr uint32_t max() { return numeric_limits<result_type>::max(); }
static constexpr uint32_t min() { return numeric_limits<result_type>::min(); }
private:
uint32_t a{}, b{}, c{}, d{};
};
const int CONTEST_NUM = 26;
struct State {
vector<int> contest_order;
State(const int D) : contest_order(vector<int>(D + 1)) {}
};
template <class Generator>
int choose(int const min, int const max, Generator &gen) {
assert(min <= max);
return uniform_int_distribution<int>(min, max)(gen);
}
long long compute_score(const State &state, const vector<int> &costs,
const vector<vector<int>> &values, const int D) {
long long score = 0;
vector<int> last(CONTEST_NUM + 1, 0);
for (int i = 1; i <= D; i++) {
score += values[i][state.contest_order[i]];
last[state.contest_order[i]] = i;
for (int j = 1; j <= CONTEST_NUM; j++) {
score -= costs[i] * (i - last[j]);
}
}
return score;
}
template <class Generator>
State solve(const vector<int> &costs, const vector<vector<int>> &values,
const int D, Generator &gen) {
State best_state(D), state(D);
if (getenv("RESUME")) {
ifstream ifs(getenv("RESUME"));
string line;
getline(ifs, line);
int cnt = 0;
while (getline(ifs, line)) {
cnt++;
if (cnt % 2 == 0)
continue;
stringstream ss_line(line);
}
} else { // make an initial state
vector<int> last(CONTEST_NUM + 1, 0);
for (int i = 1; i <= D; i++) {
long long maxDiff = LLONG_MIN, contestId = -1;
for (int j = 1; j <= CONTEST_NUM; j++) {
long long diff = values[i][j];
for (int k = 1; k <= CONTEST_NUM; k++) {
if (k == j)
continue;
diff -= costs[i] * (i - last[k]);
}
if (diff > maxDiff) {
maxDiff = diff;
contestId = j;
}
}
assert(contestId != -1);
state.contest_order[i] = contestId;
last[state.contest_order[i]] = i;
}
}
best_state = state;
long long score = compute_score(state, costs, values, D);
long long highscore = score;
// cerr << "[*] highscore = " << highscore << endl;
// constexpr int TIME_LIMIT = 1000; // msec
// chrono::high_resolution_clock::time_point clock_begin =
// chrono::high_resolution_clock::now(); double temperature = 1; for
// (unsigned iteration = 0; ; ++ iteration) {
// if (iteration % 128 == 0) {
// chrono::high_resolution_clock::time_point clock_end =
// chrono::high_resolution_clock::now(); temperature = 1 -
// chrono::duration_cast<chrono::milliseconds>(clock_end -
// clock_begin).count() / TIME_LIMIT; if (temperature < 0) {
//// cerr << "[*] iteration = " << iteration << ": done" <<
///endl;
// break;
// }
// }
//
// const int newContestId = choose(1, CONTEST_NUM, gen);
// const int day = choose(1, D, gen);
// const int oldContestId = state.contest_order[day];
// state.contest_order[day] = newContestId;
//
// long long newScore = compute_score(state, costs, values, D);
// long long delta = newScore - score;
//
// constexpr double boltzmann = 3;
// if (delta >= 0 or bernoulli_distribution(exp(boltzmann * delta) *
// temperature)(gen)) {
// if (delta < 0) {
//// cerr << "[*] iteration = " << iteration << ": delta = " <<
///delta << ": p = " << exp(boltzmann * delta) * temperature << endl;
// }
// score += delta;
// if (highscore < score) {
// highscore = score;
// best_state = state;
//// cerr << "[*] iteration = " << iteration << ": highscore =
///" << highscore << endl;
// }
// } else {
// // resume
// state.contest_order[day] = oldContestId;
// }
// }
// cerr << "[*] highscore = " << highscore << endl;
return best_state;
}
int main() {
int D;
scanf("%lld", &D);
std::vector<int> c(CONTEST_NUM + 1);
for (int i = 1; i <= 26; i++) {
scanf("%lld", &c[i]);
}
std::vector<std::vector<int>> s(D + 1, std::vector<int>(CONTEST_NUM + 1));
for (int i = 1; i <= D; i++) {
for (int j = 1; j <= 26; j++) {
scanf("%lld", &s[i][j]);
}
}
// solve
xor_shift_128 gen;
State state = solve(std::move(c), std::move(s), D, gen);
// output
stringstream ss;
int cnt = 0;
for (int i = 1; i <= D; i++) {
ss << state.contest_order[i] << "\n";
}
cout << ss.str();
return 0;
}
| replace | 98 | 145 | 98 | 140 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cassert>
#include <chrono>
#include <cstdint>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <vector>
#define REP(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define RREP(i, n) for (ll i = (n)-1; i >= 0; --i)
#define SREP(i, s, n) for (ll i = (s), i##_len = (n); i < i##_len; ++i)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
template <typename T> T gcd(T a, T b) {
if (a < b)
gcd(b, a);
if (b == 1)
return 1;
T r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
template <typename T> struct UnionFind {
vector<T> par;
vector<T> rank;
UnionFind(T n = 1) { init(n); }
void init(T n = 1) {
par.resize(n);
rank.resize(n);
for (T i = 0; i < n; ++i) {
par[i] = i;
rank[i] = 0;
}
}
int root(T x) {
if (par[x] == x) {
return x;
} else {
int r = root(par[x]);
return par[x] = r;
}
}
bool issame(T x, T y) { return root(x) == root(y); }
bool merge(T x, T y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (rank[x] < rank[y])
swap(x, y);
if (rank[x] == rank[y])
++rank[x];
par[y] = x;
return true;
}
};
template <typename Monoid, typename OperatorMonoid = Monoid>
struct LazySegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
using G = function<Monoid(Monoid, OperatorMonoid)>;
using H = function<OperatorMonoid(OperatorMonoid, OperatorMonoid)>;
ll sz, height;
vector<Monoid> data;
vector<OperatorMonoid> lazy;
const F f;
const G g;
const H h;
const Monoid M1;
const OperatorMonoid OM0;
LazySegmentTree(ll n, const F f, const G g, const H h, const Monoid &M1,
const OperatorMonoid OM0)
: f(f), g(g), h(h), M1(M1), OM0(OM0) {
sz = 1;
height = 0;
while (sz < n)
sz <<= 1, height++;
data.assign(2 * sz, M1);
lazy.assign(2 * sz, OM0);
}
void reset() {
data.assign(2 * sz, M1);
lazy.assign(2 * sz, OM0);
}
void set(ll k, const Monoid &x) { data[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
data[k] = f(data[2 * k + 0], data[2 * k + 1]);
}
}
inline void propagate(ll k) {
if (lazy[k] != OM0) {
lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]);
lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
data[k] = reflect(k);
lazy[k] = OM0;
}
}
inline Monoid reflect(ll k) {
return lazy[k] == OM0 ? data[k] : g(data[k], lazy[k]);
}
inline void recalc(ll k) {
while (k >>= 1)
data[k] = f(reflect(2 * k + 0), reflect(2 * k + 1));
}
inline void thrust(ll k) {
for (int i = height; i > 0; i--)
propagate(k >> i);
}
void update(ll a, ll b, const OperatorMonoid &x) {
thrust(a += sz);
thrust(b += sz - 1);
for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1)
lazy[l] = h(lazy[l], x), ++l;
if (r & 1)
--r, lazy[r] = h(lazy[r], x);
}
recalc(a);
recalc(b);
}
Monoid query(ll a, ll b) {
thrust(a += sz);
thrust(b += sz - 1);
Monoid L = M1, R = M1;
for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1)
L = f(L, reflect(l++));
if (r & 1)
R = f(reflect(--r), R);
}
return f(L, R);
}
Monoid operator[](const int &k) { return query(k, k + 1); }
template <typename C>
int find_subtree(ll a, const C &check, Monoid &M, bool type) {
while (a < sz) {
propagate(a);
Monoid nxt =
type ? f(reflect(2 * a + type), M) : f(M, reflect(2 * a + type));
if (check(nxt))
a = 2 * a + type;
else
M = nxt, a = 2 * a + 1 - type;
}
return a - sz;
}
template <typename C> int find_first(ll a, const C &check) {
Monoid L = M1;
if (a <= 0) {
if (check(f(L, reflect(1))))
return find_subtree(1, check, L, false);
return -1;
}
thrust(a + sz);
int b = sz;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
Monoid nxt = f(L, reflect(a));
if (check(nxt))
return find_subtree(a, check, L, false);
L = nxt;
++a;
}
}
return -1;
}
template <typename C> int find_last(ll b, const C &check) {
Monoid R = M1;
if (b >= sz) {
if (check(f(reflect(1), R)))
return find_subtree(1, check, R, true);
return -1;
}
thrust(b + sz - 1);
int a = sz;
for (b += sz; a < b; a >>= 1, b >>= 1) {
if (b & 1) {
Monoid nxt = f(reflect(--b), R);
if (check(nxt))
return find_subtree(b, check, R, true);
R = nxt;
}
}
return -1;
}
};
int msb(ll x) {
int n = 0;
while (x > 0) {
x /= 2;
n++;
}
return n;
}
template <ll Modulus> class modint {
public:
ll a;
constexpr modint(const ll x = 0) noexcept : a(x % Modulus) {}
constexpr ll &value() noexcept { return a; }
constexpr operator int() const { return a; }
constexpr operator long long() const { return a; }
constexpr const ll &value() const noexcept { return a; }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator+(const ll rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator-(const ll rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator*(const ll rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint operator/(const ll rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
ll exp = Modulus - 2;
while (exp) {
if (exp % 2) {
*this *= rhs;
}
rhs *= rhs;
exp /= 2;
}
return *this;
}
};
vector<ll> read_vec(ll N, ll offset) {
vector<ll> v(N);
REP(i, N) {
cin >> v[i];
v[i] += offset;
}
return v;
}
#define MOD (ll(998244353))
#define INF (ll(1e15))
ll D;
vector<ll> c;
vector<vector<ll>> s;
ll score(vector<ll> &t, vector<ll>::iterator end) {
vector<ll> last(26, -1);
ll y = 0;
auto it = t.begin();
ll day = 0;
while (it != end) {
y += s[day][*it];
last[*it] = day;
REP(i, 26) { y -= c[i] * (day - last[i]); }
it++;
day++;
}
return y;
}
int main(int argc, const char *argv[]) {
(void)argc;
(void)argv;
cin.tie(0);
ios::sync_with_stdio(false);
cin >> D;
c = read_vec(26, 0);
s.resize(D);
REP(i, D) { s[i] = read_vec(26, 0); }
auto t = vector<ll>(D);
REP(i, D) { t[i] = max_element(ALL(s[i])) - s[i].begin(); }
vector<set<ll>> ts(26);
REP(i, 26) {
ts[i].insert(-1);
ts[i].insert(D);
}
REP(i, D) { ts[t[i]].insert(i); }
ll x = score(t, t.end());
ll M = 20000000;
std::random_device seed_gen;
std::mt19937 engine(seed_gen());
REP(i, M) {
ll d = engine() % D;
ll q = t[d];
while (q == t[d])
q = engine() % 26;
ll y = x;
y -= s[d][t[d]];
y += s[d][q];
auto pit = ts[t[d]].find(d);
ll ph = d - *prev(pit);
ll pw = *next(pit) - d;
y -= c[t[d]] * ph * pw;
auto nit = prev(ts[q].upper_bound(d));
ll nh = d - *nit;
ll nw = *next(nit) - d;
y += c[q] * nh * nw;
if (y > x) {
ts[t[d]].erase(pit);
ts[q].insert(d);
t[d] = q;
x = y;
}
}
// cerr << x << endl;
REP(i, D) { cout << t[i] + 1 << endl; }
}
// https://atcoder.jp/contests/intro-heuristics/tasks/intro_heuristics_a
| #include <algorithm>
#include <cassert>
#include <chrono>
#include <cstdint>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <vector>
#define REP(i, n) for (ll i = 0, i##_len = (n); i < i##_len; ++i)
#define RREP(i, n) for (ll i = (n)-1; i >= 0; --i)
#define SREP(i, s, n) for (ll i = (s), i##_len = (n); i < i##_len; ++i)
#define ALL(v) (v).begin(), (v).end()
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
template <typename T> T gcd(T a, T b) {
if (a < b)
gcd(b, a);
if (b == 1)
return 1;
T r;
while ((r = a % b)) {
a = b;
b = r;
}
return b;
}
template <typename T> struct UnionFind {
vector<T> par;
vector<T> rank;
UnionFind(T n = 1) { init(n); }
void init(T n = 1) {
par.resize(n);
rank.resize(n);
for (T i = 0; i < n; ++i) {
par[i] = i;
rank[i] = 0;
}
}
int root(T x) {
if (par[x] == x) {
return x;
} else {
int r = root(par[x]);
return par[x] = r;
}
}
bool issame(T x, T y) { return root(x) == root(y); }
bool merge(T x, T y) {
x = root(x);
y = root(y);
if (x == y)
return false;
if (rank[x] < rank[y])
swap(x, y);
if (rank[x] == rank[y])
++rank[x];
par[y] = x;
return true;
}
};
template <typename Monoid, typename OperatorMonoid = Monoid>
struct LazySegmentTree {
using F = function<Monoid(Monoid, Monoid)>;
using G = function<Monoid(Monoid, OperatorMonoid)>;
using H = function<OperatorMonoid(OperatorMonoid, OperatorMonoid)>;
ll sz, height;
vector<Monoid> data;
vector<OperatorMonoid> lazy;
const F f;
const G g;
const H h;
const Monoid M1;
const OperatorMonoid OM0;
LazySegmentTree(ll n, const F f, const G g, const H h, const Monoid &M1,
const OperatorMonoid OM0)
: f(f), g(g), h(h), M1(M1), OM0(OM0) {
sz = 1;
height = 0;
while (sz < n)
sz <<= 1, height++;
data.assign(2 * sz, M1);
lazy.assign(2 * sz, OM0);
}
void reset() {
data.assign(2 * sz, M1);
lazy.assign(2 * sz, OM0);
}
void set(ll k, const Monoid &x) { data[k + sz] = x; }
void build() {
for (int k = sz - 1; k > 0; k--) {
data[k] = f(data[2 * k + 0], data[2 * k + 1]);
}
}
inline void propagate(ll k) {
if (lazy[k] != OM0) {
lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]);
lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
data[k] = reflect(k);
lazy[k] = OM0;
}
}
inline Monoid reflect(ll k) {
return lazy[k] == OM0 ? data[k] : g(data[k], lazy[k]);
}
inline void recalc(ll k) {
while (k >>= 1)
data[k] = f(reflect(2 * k + 0), reflect(2 * k + 1));
}
inline void thrust(ll k) {
for (int i = height; i > 0; i--)
propagate(k >> i);
}
void update(ll a, ll b, const OperatorMonoid &x) {
thrust(a += sz);
thrust(b += sz - 1);
for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1)
lazy[l] = h(lazy[l], x), ++l;
if (r & 1)
--r, lazy[r] = h(lazy[r], x);
}
recalc(a);
recalc(b);
}
Monoid query(ll a, ll b) {
thrust(a += sz);
thrust(b += sz - 1);
Monoid L = M1, R = M1;
for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
if (l & 1)
L = f(L, reflect(l++));
if (r & 1)
R = f(reflect(--r), R);
}
return f(L, R);
}
Monoid operator[](const int &k) { return query(k, k + 1); }
template <typename C>
int find_subtree(ll a, const C &check, Monoid &M, bool type) {
while (a < sz) {
propagate(a);
Monoid nxt =
type ? f(reflect(2 * a + type), M) : f(M, reflect(2 * a + type));
if (check(nxt))
a = 2 * a + type;
else
M = nxt, a = 2 * a + 1 - type;
}
return a - sz;
}
template <typename C> int find_first(ll a, const C &check) {
Monoid L = M1;
if (a <= 0) {
if (check(f(L, reflect(1))))
return find_subtree(1, check, L, false);
return -1;
}
thrust(a + sz);
int b = sz;
for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
if (a & 1) {
Monoid nxt = f(L, reflect(a));
if (check(nxt))
return find_subtree(a, check, L, false);
L = nxt;
++a;
}
}
return -1;
}
template <typename C> int find_last(ll b, const C &check) {
Monoid R = M1;
if (b >= sz) {
if (check(f(reflect(1), R)))
return find_subtree(1, check, R, true);
return -1;
}
thrust(b + sz - 1);
int a = sz;
for (b += sz; a < b; a >>= 1, b >>= 1) {
if (b & 1) {
Monoid nxt = f(reflect(--b), R);
if (check(nxt))
return find_subtree(b, check, R, true);
R = nxt;
}
}
return -1;
}
};
int msb(ll x) {
int n = 0;
while (x > 0) {
x /= 2;
n++;
}
return n;
}
template <ll Modulus> class modint {
public:
ll a;
constexpr modint(const ll x = 0) noexcept : a(x % Modulus) {}
constexpr ll &value() noexcept { return a; }
constexpr operator int() const { return a; }
constexpr operator long long() const { return a; }
constexpr const ll &value() const noexcept { return a; }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator+(const ll rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator-(const ll rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator*(const ll rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint operator/(const ll rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
ll exp = Modulus - 2;
while (exp) {
if (exp % 2) {
*this *= rhs;
}
rhs *= rhs;
exp /= 2;
}
return *this;
}
};
vector<ll> read_vec(ll N, ll offset) {
vector<ll> v(N);
REP(i, N) {
cin >> v[i];
v[i] += offset;
}
return v;
}
#define MOD (ll(998244353))
#define INF (ll(1e15))
ll D;
vector<ll> c;
vector<vector<ll>> s;
ll score(vector<ll> &t, vector<ll>::iterator end) {
vector<ll> last(26, -1);
ll y = 0;
auto it = t.begin();
ll day = 0;
while (it != end) {
y += s[day][*it];
last[*it] = day;
REP(i, 26) { y -= c[i] * (day - last[i]); }
it++;
day++;
}
return y;
}
int main(int argc, const char *argv[]) {
(void)argc;
(void)argv;
cin.tie(0);
ios::sync_with_stdio(false);
cin >> D;
c = read_vec(26, 0);
s.resize(D);
REP(i, D) { s[i] = read_vec(26, 0); }
auto t = vector<ll>(D);
REP(i, D) { t[i] = max_element(ALL(s[i])) - s[i].begin(); }
vector<set<ll>> ts(26);
REP(i, 26) {
ts[i].insert(-1);
ts[i].insert(D);
}
REP(i, D) { ts[t[i]].insert(i); }
ll x = score(t, t.end());
ll M = 10000000;
std::random_device seed_gen;
std::mt19937 engine(seed_gen());
REP(i, M) {
ll d = engine() % D;
ll q = t[d];
while (q == t[d])
q = engine() % 26;
ll y = x;
y -= s[d][t[d]];
y += s[d][q];
auto pit = ts[t[d]].find(d);
ll ph = d - *prev(pit);
ll pw = *next(pit) - d;
y -= c[t[d]] * ph * pw;
auto nit = prev(ts[q].upper_bound(d));
ll nh = d - *nit;
ll nw = *next(nit) - d;
y += c[q] * nh * nw;
if (y > x) {
ts[t[d]].erase(pit);
ts[q].insert(d);
t[d] = q;
x = y;
}
}
// cerr << x << endl;
REP(i, D) { cout << t[i] + 1 << endl; }
}
// https://atcoder.jp/contests/intro-heuristics/tasks/intro_heuristics_a
| replace | 351 | 352 | 351 | 352 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define MOD 1000000007
#define f(i, n) for (int i = 0; i < int(n); i++)
#define N 11500
int a[N][27];
int a2[N][27];
int e[N][365];
int v[N][365];
int sz, sz2;
int main() {
int n;
int x, y;
vector<pair<int, pair<int, int>>> b;
int c[26];
int d[365][26];
bool dd[365][26];
vector<int> ds;
int ans[365];
scanf("%d", &n);
f(i, 26) scanf("%d", &c[i]);
f(i, n) {
f(j, 26) scanf("%d", &d[i][j]);
ds.clear();
f(j, 26) ds.push_back(-d[i][j]);
sort(ds.begin(), ds.end());
f(j, 26) {
if ((d[i][j] + ds[5]) > 0)
dd[i][j] = true;
else
dd[i][j] = false;
}
}
sz = 1;
f(i, 26) a[0][i] = -1;
a[0][26] = 0;
f(t, n) {
b.clear();
f(i, sz) {
x = a[i][26];
f(j, 26) { x -= ((t - a[i][j]) * c[j]); }
f(j, 26) {
if (dd[t][j]) {
y = x + d[t][j];
y += ((t - a[i][j]) * c[j]);
b.push_back(make_pair(y, make_pair(i, j)));
}
}
}
sort(b.begin(), b.end(), greater<pair<int, pair<int, int>>>());
sz2 = b.size();
if (sz2 > N)
sz2 = N;
f(i, sz2) {
x = b[i].second.first;
y = b[i].second.second;
a2[i][26] = b[i].first;
f(j, 26) a2[i][j] = a[x][j];
a2[i][y] = t;
e[i][t] = x;
v[i][t] = y;
}
f(i, sz2) { f(j, 27) a[i][j] = a2[i][j]; }
sz = sz2;
}
x = 0;
for (int i = n - 1; i >= 0; i--) {
ans[i] = v[x][i];
x = e[x][i];
}
f(i, n) printf("%d\n", ans[i] + 1);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define MOD 1000000007
#define f(i, n) for (int i = 0; i < int(n); i++)
#define N 10500
int a[N][27];
int a2[N][27];
int e[N][365];
int v[N][365];
int sz, sz2;
int main() {
int n;
int x, y;
vector<pair<int, pair<int, int>>> b;
int c[26];
int d[365][26];
bool dd[365][26];
vector<int> ds;
int ans[365];
scanf("%d", &n);
f(i, 26) scanf("%d", &c[i]);
f(i, n) {
f(j, 26) scanf("%d", &d[i][j]);
ds.clear();
f(j, 26) ds.push_back(-d[i][j]);
sort(ds.begin(), ds.end());
f(j, 26) {
if ((d[i][j] + ds[5]) > 0)
dd[i][j] = true;
else
dd[i][j] = false;
}
}
sz = 1;
f(i, 26) a[0][i] = -1;
a[0][26] = 0;
f(t, n) {
b.clear();
f(i, sz) {
x = a[i][26];
f(j, 26) { x -= ((t - a[i][j]) * c[j]); }
f(j, 26) {
if (dd[t][j]) {
y = x + d[t][j];
y += ((t - a[i][j]) * c[j]);
b.push_back(make_pair(y, make_pair(i, j)));
}
}
}
sort(b.begin(), b.end(), greater<pair<int, pair<int, int>>>());
sz2 = b.size();
if (sz2 > N)
sz2 = N;
f(i, sz2) {
x = b[i].second.first;
y = b[i].second.second;
a2[i][26] = b[i].first;
f(j, 26) a2[i][j] = a[x][j];
a2[i][y] = t;
e[i][t] = x;
v[i][t] = y;
}
f(i, sz2) { f(j, 27) a[i][j] = a2[i][j]; }
sz = sz2;
}
x = 0;
for (int i = n - 1; i >= 0; i--) {
ans[i] = v[x][i];
x = e[x][i];
}
f(i, n) printf("%d\n", ans[i] + 1);
return 0;
}
| replace | 14 | 15 | 14 | 15 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define MOD 1000000007
#define f(i, n) for (int i = 0; i < int(n); i++)
#define N 2750
int a[N][27];
int a2[N][27];
int e[N][365];
int v[N][365];
int sz, sz2;
int main() {
int n;
int x, y;
vector<pair<int, pair<int, int>>> b;
int c[26];
int d[365][26];
int ans[365];
scanf("%d", &n);
f(i, 26) scanf("%d", &c[i]);
f(i, n) { f(j, 26) scanf("%d", &d[i][j]); }
sz = 1;
f(i, 26) a[0][i] = -1;
a[0][26] = 0;
f(t, n) {
b.clear();
f(i, sz) {
x = a[i][26];
f(j, 26) { x -= ((t - a[i][j]) * c[j]); }
f(j, 26) {
y = x + d[t][j];
y += ((t - a[i][j]) * c[j]);
b.push_back(make_pair(y, make_pair(i, j)));
}
}
sort(b.begin(), b.end(), greater<pair<int, pair<int, int>>>());
sz2 = b.size();
if (sz2 > N)
sz2 = N;
f(i, sz2) {
x = b[i].second.first;
y = b[i].second.second;
a2[i][26] = b[i].first;
f(j, 26) a2[i][j] = a[x][j];
a2[i][y] = t;
e[i][t] = x;
v[i][t] = y;
}
f(i, sz2) { f(j, 27) a[i][j] = a2[i][j]; }
sz = sz2;
}
x = 0;
for (int i = n - 1; i >= 0; i--) {
ans[i] = v[x][i];
x = e[x][i];
}
f(i, n) printf("%d\n", ans[i] + 1);
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define MOD 1000000007
#define f(i, n) for (int i = 0; i < int(n); i++)
#define N 2600
int a[N][27];
int a2[N][27];
int e[N][365];
int v[N][365];
int sz, sz2;
int main() {
int n;
int x, y;
vector<pair<int, pair<int, int>>> b;
int c[26];
int d[365][26];
int ans[365];
scanf("%d", &n);
f(i, 26) scanf("%d", &c[i]);
f(i, n) { f(j, 26) scanf("%d", &d[i][j]); }
sz = 1;
f(i, 26) a[0][i] = -1;
a[0][26] = 0;
f(t, n) {
b.clear();
f(i, sz) {
x = a[i][26];
f(j, 26) { x -= ((t - a[i][j]) * c[j]); }
f(j, 26) {
y = x + d[t][j];
y += ((t - a[i][j]) * c[j]);
b.push_back(make_pair(y, make_pair(i, j)));
}
}
sort(b.begin(), b.end(), greater<pair<int, pair<int, int>>>());
sz2 = b.size();
if (sz2 > N)
sz2 = N;
f(i, sz2) {
x = b[i].second.first;
y = b[i].second.second;
a2[i][26] = b[i].first;
f(j, 26) a2[i][j] = a[x][j];
a2[i][y] = t;
e[i][t] = x;
v[i][t] = y;
}
f(i, sz2) { f(j, 27) a[i][j] = a2[i][j]; }
sz = sz2;
}
x = 0;
for (int i = n - 1; i >= 0; i--) {
ans[i] = v[x][i];
x = e[x][i];
}
f(i, n) printf("%d\n", ans[i] + 1);
return 0;
}
| replace | 14 | 15 | 14 | 15 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#include <utility>
#define INF 1e9
using namespace std;
#define REPR(i, n) for (int i = (n); i >= 0; --i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define ALL(a) (a).begin(), (a).end()
#define endl "\n"
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
typedef long long ll;
double getTime(chrono::system_clock::time_point st,
chrono::system_clock::time_point ed) {
return static_cast<double>(
chrono::duration_cast<chrono::microseconds>(ed - st).count() / 1000.0);
}
// Inputs
int D;
vector<int> c;
vector<vector<int>> s;
class Answer {
public:
// 0~25の構造体
vector<int> ans;
explicit Answer() { ans.resize(D, 0); }
void print_ans() {
for (const auto &it : ans)
cout << it + 1 << endl;
}
};
// スコア計算を行う
ll calc(const Answer &ans) {
// あるコンテストi-1が開催されていない日数
vector<int> not_open_term(26, 0);
ll manzoku = 0;
REP(day, D) {
manzoku += s[day][ans.ans[day]];
REP(typ, 26) not_open_term[typ]++;
REP(typ, 26)
if (typ != ans.ans[day]) manzoku -= not_open_term[typ] * c[typ];
not_open_term[ans.ans[day]] = 0;
// For B その日終了時に満足度を出力する。
// cout << manzoku << endl;
}
return manzoku;
}
void read() {
cin >> D;
c.resize(26);
REP(i, 26) cin >> c[i];
s.resize(D);
REP(i, D) {
s[i].resize(26);
REP(j, 26) cin >> s[i][j];
}
}
// 下がりやすさを無視して一番点が高い物を選ぶ
Answer greedy1() {
Answer answer = Answer();
REP(day, D) {
int mx = 0;
REP(typ, 26) if (chmax(mx, s[day][typ])) answer.ans[day] = typ;
}
return answer;
}
// 下がりやすさを考慮して一番高い物を選ぶ
Answer greedy2() {
Answer answer = Answer();
// あるコンテストi-1が開催されていない日数
vector<int> not_open_term(26, 0);
REP(day, D) {
// 期待値の最大値
int mx = 0;
REP(typ, 26) {
// そのコンテストを開催した際の満足度変動値を計算する。
int manzoku = s[day][typ];
REP(_typ, 26) if (_typ != typ) manzoku -= (not_open_term[_typ] * c[_typ]);
if (chmax(mx, manzoku))
answer.ans[day] = typ;
}
REP(i, 26) not_open_term[i]++;
// 開催するコンテストが決定されたらそれの日数を0にする。
not_open_term[answer.ans[day]] = 0;
}
return answer;
}
Answer unstableGreedy2() {
Answer answer = Answer();
// あるコンテストi-1が開催されていない日数
vector<int> not_open_term(26, 0);
REP(day, D) {
// 期待値の最大値
int mx = 0;
REP(typ, 26) {
// そのコンテストを開催した際の満足度変動値を計算する。
int manzoku = s[day][typ];
REP(_typ, 26) if (_typ != typ) manzoku -= (not_open_term[_typ] * c[_typ]);
random_device rnd;
mt19937 mt(rnd());
bool skip = ((mt() + 5) % 5) == 0;
// 20%で更新処理を無視する。
if (!skip && chmax(mx, manzoku))
answer.ans[day] = typ;
}
REP(i, 26) not_open_term[i]++;
// 開催するコンテストが決定されたらそれの日数を0にする。
not_open_term[answer.ans[day]] = 0;
}
return answer;
}
void solveB() {
Answer answer = Answer();
REP(i, D) {
cin >> answer.ans[i];
answer.ans[i]--;
}
cerr << calc(answer) << endl;
}
void solveC() {
Answer answer = Answer();
REP(i, D) {
cin >> answer.ans[i];
answer.ans[i]--;
}
int M;
cin >> M;
REP(i, M) {
int d, q;
cin >> d >> q;
d--;
q--;
answer.ans[d] = q;
cout << calc(answer) << endl;
}
}
// returns score
ll localeSearch(Answer &ans, int milisec) {
auto st = chrono::system_clock::now();
ll now = calc(ans);
while (getTime(st, chrono::system_clock::now()) < milisec) {
random_device rnd;
mt19937 mt(rnd());
int day = (mt() + D) % D;
int contest = (mt() + 26) % 26;
int old_contest = ans.ans[day];
ans.ans[day] = contest;
ll new_score = calc(ans);
if (!chmax(now, new_score))
ans.ans[day] = old_contest;
}
return now;
}
void solve() {
// auto ans = Answer();
// ans.print_ans();
auto ans = greedy2();
ll _ = localeSearch(ans, 1900);
ans.print_ans();
}
void spreadSolve() {
// param
int cnt = 5;
int perMiliSec = 370;
map<ll, Answer> mp;
REP(i, cnt) {
auto a = unstableGreedy2();
ll score = localeSearch(a, perMiliSec);
mp[score] = a;
}
(*mp.rbegin()).second.print_ans();
}
int main() {
read();
spreadSolve();
return 0;
} | #include <bits/stdc++.h>
#include <utility>
#define INF 1e9
using namespace std;
#define REPR(i, n) for (int i = (n); i >= 0; --i)
#define FOR(i, m, n) for (int i = (m); i < (n); ++i)
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define ALL(a) (a).begin(), (a).end()
#define endl "\n"
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
typedef long long ll;
double getTime(chrono::system_clock::time_point st,
chrono::system_clock::time_point ed) {
return static_cast<double>(
chrono::duration_cast<chrono::microseconds>(ed - st).count() / 1000.0);
}
// Inputs
int D;
vector<int> c;
vector<vector<int>> s;
class Answer {
public:
// 0~25の構造体
vector<int> ans;
explicit Answer() { ans.resize(D, 0); }
void print_ans() {
for (const auto &it : ans)
cout << it + 1 << endl;
}
};
// スコア計算を行う
ll calc(const Answer &ans) {
// あるコンテストi-1が開催されていない日数
vector<int> not_open_term(26, 0);
ll manzoku = 0;
REP(day, D) {
manzoku += s[day][ans.ans[day]];
REP(typ, 26) not_open_term[typ]++;
REP(typ, 26)
if (typ != ans.ans[day]) manzoku -= not_open_term[typ] * c[typ];
not_open_term[ans.ans[day]] = 0;
// For B その日終了時に満足度を出力する。
// cout << manzoku << endl;
}
return manzoku;
}
void read() {
cin >> D;
c.resize(26);
REP(i, 26) cin >> c[i];
s.resize(D);
REP(i, D) {
s[i].resize(26);
REP(j, 26) cin >> s[i][j];
}
}
// 下がりやすさを無視して一番点が高い物を選ぶ
Answer greedy1() {
Answer answer = Answer();
REP(day, D) {
int mx = 0;
REP(typ, 26) if (chmax(mx, s[day][typ])) answer.ans[day] = typ;
}
return answer;
}
// 下がりやすさを考慮して一番高い物を選ぶ
Answer greedy2() {
Answer answer = Answer();
// あるコンテストi-1が開催されていない日数
vector<int> not_open_term(26, 0);
REP(day, D) {
// 期待値の最大値
int mx = 0;
REP(typ, 26) {
// そのコンテストを開催した際の満足度変動値を計算する。
int manzoku = s[day][typ];
REP(_typ, 26) if (_typ != typ) manzoku -= (not_open_term[_typ] * c[_typ]);
if (chmax(mx, manzoku))
answer.ans[day] = typ;
}
REP(i, 26) not_open_term[i]++;
// 開催するコンテストが決定されたらそれの日数を0にする。
not_open_term[answer.ans[day]] = 0;
}
return answer;
}
Answer unstableGreedy2() {
Answer answer = Answer();
// あるコンテストi-1が開催されていない日数
vector<int> not_open_term(26, 0);
REP(day, D) {
// 期待値の最大値
int mx = 0;
REP(typ, 26) {
// そのコンテストを開催した際の満足度変動値を計算する。
int manzoku = s[day][typ];
REP(_typ, 26) if (_typ != typ) manzoku -= (not_open_term[_typ] * c[_typ]);
random_device rnd;
mt19937 mt(rnd());
bool skip = ((mt() + 5) % 5) == 0;
// 20%で更新処理を無視する。
if (!skip && chmax(mx, manzoku))
answer.ans[day] = typ;
}
REP(i, 26) not_open_term[i]++;
// 開催するコンテストが決定されたらそれの日数を0にする。
not_open_term[answer.ans[day]] = 0;
}
return answer;
}
void solveB() {
Answer answer = Answer();
REP(i, D) {
cin >> answer.ans[i];
answer.ans[i]--;
}
cerr << calc(answer) << endl;
}
void solveC() {
Answer answer = Answer();
REP(i, D) {
cin >> answer.ans[i];
answer.ans[i]--;
}
int M;
cin >> M;
REP(i, M) {
int d, q;
cin >> d >> q;
d--;
q--;
answer.ans[d] = q;
cout << calc(answer) << endl;
}
}
// returns score
ll localeSearch(Answer &ans, int milisec) {
auto st = chrono::system_clock::now();
ll now = calc(ans);
while (getTime(st, chrono::system_clock::now()) < milisec) {
random_device rnd;
mt19937 mt(rnd());
int day = (mt() + D) % D;
int contest = (mt() + 26) % 26;
int old_contest = ans.ans[day];
ans.ans[day] = contest;
ll new_score = calc(ans);
if (!chmax(now, new_score))
ans.ans[day] = old_contest;
}
return now;
}
void solve() {
// auto ans = Answer();
// ans.print_ans();
auto ans = greedy2();
ll _ = localeSearch(ans, 1900);
ans.print_ans();
}
void spreadSolve() {
// param
int cnt = 5;
int perMiliSec = 330;
map<ll, Answer> mp;
REP(i, cnt) {
auto a = unstableGreedy2();
ll score = localeSearch(a, perMiliSec);
mp[score] = a;
}
(*mp.rbegin()).second.print_ans();
}
int main() {
read();
spreadSolve();
return 0;
}
| replace | 196 | 197 | 196 | 197 | TLE | |
p02618 | C++ | Time Limit Exceeded | #pragma GCC optimize("O3", "unroll-loops", "omit-frame-pointer", \
"inline") // Optimization flags
#pragma GCC option("arch=native", "tune=native", "no-zero-upper") // Enable AVX
#pragma GCC target("avx") // Enable AVX
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = (0); (i) < (int)(n); ++(i))
using ll = long long;
using P = pair<int, int>;
using namespace std;
#define INF ((1LL << 30) - 1)
#define LLINF (1LL << 60)
#define EPS (1e-10)
#define LIMIT_SEC 1.99
class Timer {
chrono::high_resolution_clock::time_point start;
public:
double limit;
Timer() {
start = chrono::high_resolution_clock::now();
limit = LIMIT_SEC;
}
Timer(double limit) : limit(limit) {
start = chrono::high_resolution_clock::now();
}
double get_time() {
return chrono::duration<double>(chrono::high_resolution_clock::now() -
start)
.count();
}
bool time_over() {
if (get_time() > limit) {
return true;
}
return false;
}
void set_start() { start = chrono::high_resolution_clock::now(); }
double get_limit() { return limit; }
};
Timer timer;
// 乱数器
class XorShift {
public:
unsigned long x, y, z, w;
XorShift() {
x = 123456789;
y = 362436069;
z = 521288629;
w = 88675123;
}
XorShift(unsigned long seed) {
XorShift();
w = seed;
for (int i = 0; i < 100; ++i)
(*this)();
}
unsigned long operator()() {
unsigned long t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
}
};
XorShift rnd;
ll c[27];
ll s[366][27];
const int C = 26;
ll bestScore = 0;
ll lc[C];
ll csum[C][367];
vector<int> ans(365, 0);
vector<int> logc[C];
ll getScore() {
ll ret = 0;
for (int i = 0; i < C; ++i)
lc[i] = 0;
for (int d = 0; d < 365; ++d) {
ret += s[d][ans[d]];
lc[ans[d]] = d + 1;
rep(i, C) { ret -= c[i] * ((d + 1) - lc[i]); }
}
return ret;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int D;
cin >> D;
rep(i, C) cin >> c[i];
rep(i, D) rep(j, C) cin >> s[i][j];
// 0日目は0
// 増えて行くのは1日目から(0-index)
for (int i = 0; i < C; ++i) {
for (int d = 0; d < 366; ++d) {
if (d == 0)
continue;
else {
csum[i][d] += (csum[i][d - 1] + c[i]);
}
}
}
// makeGreedy
rep(d, D) {
int ma = 0, idx = 0;
rep(i, C) {
if (ma < s[d][i]) {
ma = s[d][i];
idx = i;
}
}
ans[d] = idx;
// logc[idx].push_back(d);
}
bestScore = getScore();
vector<int> bestAns = ans;
Timer timer;
double startTime = timer.get_time();
double nowTime = startTime;
double startTemp = 50, endTemp = 10;
double prevScore = bestScore;
int cnt = 0;
while (true) {
++cnt;
nowTime = timer.get_time();
if (nowTime - startTime > LIMIT_SEC)
break;
int d = rnd() % D;
int change = rnd() % C;
int prev = ans[d];
ans[d] = change;
ll tmp = getScore();
double temp =
startTemp + (endTemp - startTemp) * (nowTime - startTime) / LIMIT_SEC;
double prob = exp((tmp - prevScore) / temp);
if (tmp > bestScore or prob > (rnd() % INF) / (double)INF) {
prevScore = tmp;
if (tmp > bestScore) {
bestScore = tmp;
bestAns = ans;
}
} else {
ans[d] = prev;
}
// if (tmp > bestScore) {
// //cerr << "Update: " << bestScore << endl;
// bestScore = tmp;
// bestAns = ans;
// }
// else {
// ans[d] = prev;
// }
}
rep(i, D) cout << bestAns[i] + 1 << endl;
cerr << bestScore << ", " << cnt << endl;
}
// 536769
// 548149
| #pragma GCC optimize("O3", "unroll-loops", "omit-frame-pointer", \
"inline") // Optimization flags
#pragma GCC option("arch=native", "tune=native", "no-zero-upper") // Enable AVX
#pragma GCC target("avx") // Enable AVX
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int(i) = (0); (i) < (int)(n); ++(i))
using ll = long long;
using P = pair<int, int>;
using namespace std;
#define INF ((1LL << 30) - 1)
#define LLINF (1LL << 60)
#define EPS (1e-10)
#define LIMIT_SEC 1.97
class Timer {
chrono::high_resolution_clock::time_point start;
public:
double limit;
Timer() {
start = chrono::high_resolution_clock::now();
limit = LIMIT_SEC;
}
Timer(double limit) : limit(limit) {
start = chrono::high_resolution_clock::now();
}
double get_time() {
return chrono::duration<double>(chrono::high_resolution_clock::now() -
start)
.count();
}
bool time_over() {
if (get_time() > limit) {
return true;
}
return false;
}
void set_start() { start = chrono::high_resolution_clock::now(); }
double get_limit() { return limit; }
};
Timer timer;
// 乱数器
class XorShift {
public:
unsigned long x, y, z, w;
XorShift() {
x = 123456789;
y = 362436069;
z = 521288629;
w = 88675123;
}
XorShift(unsigned long seed) {
XorShift();
w = seed;
for (int i = 0; i < 100; ++i)
(*this)();
}
unsigned long operator()() {
unsigned long t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
}
};
XorShift rnd;
ll c[27];
ll s[366][27];
const int C = 26;
ll bestScore = 0;
ll lc[C];
ll csum[C][367];
vector<int> ans(365, 0);
vector<int> logc[C];
ll getScore() {
ll ret = 0;
for (int i = 0; i < C; ++i)
lc[i] = 0;
for (int d = 0; d < 365; ++d) {
ret += s[d][ans[d]];
lc[ans[d]] = d + 1;
rep(i, C) { ret -= c[i] * ((d + 1) - lc[i]); }
}
return ret;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int D;
cin >> D;
rep(i, C) cin >> c[i];
rep(i, D) rep(j, C) cin >> s[i][j];
// 0日目は0
// 増えて行くのは1日目から(0-index)
for (int i = 0; i < C; ++i) {
for (int d = 0; d < 366; ++d) {
if (d == 0)
continue;
else {
csum[i][d] += (csum[i][d - 1] + c[i]);
}
}
}
// makeGreedy
rep(d, D) {
int ma = 0, idx = 0;
rep(i, C) {
if (ma < s[d][i]) {
ma = s[d][i];
idx = i;
}
}
ans[d] = idx;
// logc[idx].push_back(d);
}
bestScore = getScore();
vector<int> bestAns = ans;
Timer timer;
double startTime = timer.get_time();
double nowTime = startTime;
double startTemp = 50, endTemp = 10;
double prevScore = bestScore;
int cnt = 0;
while (true) {
++cnt;
nowTime = timer.get_time();
if (nowTime - startTime > LIMIT_SEC)
break;
int d = rnd() % D;
int change = rnd() % C;
int prev = ans[d];
ans[d] = change;
ll tmp = getScore();
double temp =
startTemp + (endTemp - startTemp) * (nowTime - startTime) / LIMIT_SEC;
double prob = exp((tmp - prevScore) / temp);
if (tmp > bestScore or prob > (rnd() % INF) / (double)INF) {
prevScore = tmp;
if (tmp > bestScore) {
bestScore = tmp;
bestAns = ans;
}
} else {
ans[d] = prev;
}
// if (tmp > bestScore) {
// //cerr << "Update: " << bestScore << endl;
// bestScore = tmp;
// bestAns = ans;
// }
// else {
// ans[d] = prev;
// }
}
rep(i, D) cout << bestAns[i] + 1 << endl;
cerr << bestScore << ", " << cnt << endl;
}
// 536769
// 548149
| replace | 15 | 16 | 15 | 16 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bits/stdc++.h>
#include <cctype>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdint.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long double ld;
typedef int_fast64_t ll;
typedef pair<ll, ll> pii;
typedef pair<ll, pii> piii;
typedef pair<pii, pii> piiii;
typedef pair<ll, bool> pib;
typedef vector<bool> vb;
typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<vpii> vvpii;
typedef vector<double> vf;
typedef queue<ll> qi;
typedef long double ld;
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define rep(i, N) for (ll i = 0; i < N; i++)
#define repa(i, a, N) for (ll i = a; i < N; i++)
#define repr(i, N) for (ll i = N - 1; i >= 0; i--)
#define drep(i, N, j, M) rep(i, N) rep(j, M)
#define trep(i, N, j, M, k, L) rep(i, N) rep(j, M) rep(k, L)
#define all(A) A.begin(), A.end()
#define uni(A) A.erase(unique(all(A)), A.end())
const ll LLMAX = numeric_limits<ll>::max() / 3;
const ld LDMAX = numeric_limits<ld>::max() / 3;
const ld PI = 3.141592653589793;
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
template <ll Modulus> class modint {
public:
ll a;
constexpr modint(const ll x = 0) noexcept : a(x % Modulus) {}
constexpr ll &value() noexcept { return a; }
constexpr const ll &value() const noexcept { return a; }
constexpr modint operator+() const noexcept { return *this; }
constexpr modint operator-() const noexcept {
return modint(0LL) -= modint(*this);
}
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
ll exp = Modulus - 2;
while (exp) {
if (exp % 2) {
*this *= rhs;
}
rhs *= rhs;
exp /= 2;
}
return *this;
}
};
typedef modint<MOD> mod;
constexpr const mod operator+(const ll a, const mod b) noexcept {
return mod(a) += b;
}
constexpr const mod operator-(const ll a, const mod b) noexcept {
return mod(a) -= b;
}
constexpr const mod operator*(const ll a, const mod b) noexcept {
return mod(a) *= b;
}
constexpr const mod operator/(const ll a, const mod b) noexcept {
return mod(a) /= b;
}
template <class T> class SegTree {
ll n;
vector<T> data;
T def;
function<T(T, T)> operation;
function<T(T, T)> update;
T _query(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return def;
if (a <= l && r <= b)
return data[k];
else {
T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2);
T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r);
return operation(c1, c2);
}
}
public:
// _n: サイズ, _def: 初期値・単位元, _operation: クエリ, _update: 更新
SegTree(ll _n, T _def, function<T(T, T)> _operation,
function<T(T, T)> _update)
: def(_def), operation(_operation), update(_update) {
n = 1;
while (n < _n) {
n *= 2;
}
data = vector<T>(2 * n - 1, def);
}
// iの値をxに変更
void change(ll i, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
// [a, b)の区間クエリ実行
T query(ll a, ll b) { return _query(a, b, 0, 0, n); }
// 添え字アクセス
constexpr const T operator[](ll i) const noexcept { return data[i + n - 1]; }
constexpr const ll size() const noexcept { return n; }
constexpr const T unit() const noexcept { return def; }
};
/*
SegTree<ll> st(N, LLMAX,
// a: left child, b: right child
[](ll a, ll b) {return min(a, b); },
// d: old, x: query
[](ll d, ll x) {return x; });
// */
template <class t, class u>
ostream &operator<<(ostream &os, const pair<t, u> &p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t> ostream &operator<<(ostream &os, const vector<t> &v) {
os << "{";
for (auto e : v)
os << e << ",";
return os << "}" << endl;
}
template <class t, class u>
ostream &operator<<(ostream &os, const unordered_map<t, u> &m) {
os << "{";
for (auto itr = m.begin(); itr != m.end(); ++itr) {
os << "(" << itr->first << ", " << itr->second << "), ";
}
return os << "}";
}
template <class t> ostream &operator<<(ostream &os, const set<t> &m) {
os << "{";
for (auto itr = m.begin(); itr != m.end(); ++itr) {
os << *itr << ", ";
}
return os << "}";
}
template <class t> ostream &operator<<(ostream &os, const multiset<t> &m) {
os << "{";
for (auto itr = m.begin(); itr != m.end(); ++itr) {
os << *itr << ", ";
}
return os << "}";
}
template <ll Modulus>
ostream &operator<<(ostream &os, const modint<Modulus> &m) {
return os << (m.a + Modulus) % Modulus;
}
template <class t> ostream &operator<<(ostream &os, const SegTree<t> &st) {
os << "{";
ll s = st.size();
rep(i, s) {
t v = st[i];
if (v == st.unit()) {
os << "-, ";
} else {
os << v << ", ";
}
}
return os << "}\n";
}
typedef vector<mod> vm;
typedef vector<vm> vvm;
typedef vector<vvm> vvvm;
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;
}
void No() { cout << "No" << endl; }
void Yes() { cout << "Yes" << endl; }
void NO() { cout << "NO" << endl; }
void YES() { cout << "YES" << endl; }
// x^n(mod M) ←普通にpow(x,n)では溢れてしまうため，随時mod計算
ll mpow(ll x, ll n) {
ll ans = 1;
while (n != 0) {
if (n & 1)
ans = ans * x % MOD;
x = x * x % MOD;
n = n >> 1;
}
return ans;
}
ll fac_size = 1e6;
vm fac(fac_size + 1); // n! (mod MOD)
vm ifac(fac_size + 1); // k!^{M-2} (mod MOD)
bool fac_calculated = false;
void pre_calc_comb() {
fac[0] = 1;
ifac[0] = 1;
for (ll i = 0; i < fac_size; i++) {
fac[i + 1] = fac[i] * (i + 1); // n!(mod M)
ifac[i + 1] =
ifac[i] * mpow(i + 1, MOD - 2); // k!^{M-2} (mod M) ←累乗にmpowを採用
}
fac_calculated = true;
}
mod comb(ll a, ll b) { // aCbをmod計算
if (!fac_calculated)
pre_calc_comb();
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
mod tmp = ifac[a - b] * ifac[b];
return tmp * fac[a];
}
ll gcd(ll a, ll b) {
if (a == 0)
return b;
if (b == 0)
return a;
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
ll N, M, K, Q;
ll ans = 0;
ll H, W;
string S;
void solve() {
ll D;
cin >> D;
vi C(26);
rep(i, 26) { cin >> C[i]; }
vvi S(D, vi(26));
rep(d, D) {
rep(i, 26) { cin >> S[d][i]; }
}
vi T(D, 0);
auto calc = [&](ll D) {
ll ans = 0;
vi L(26, -1);
// 貪欲
rep(d, D) {
ll t = T[d];
L[t] = d;
ans += S[d][t];
rep(i, 26) { ans -= (d - L[i]) * C[i]; }
}
return ans;
};
// 初期値
rep(d, D) {
ll m = 0;
ll mi = 0;
rep(i, 26) {
T[d] = i;
ll tmp = calc(d + 1);
if (m < tmp) {
mi = i;
m = tmp;
}
}
T[d] = mi;
}
// シミュレーション
vector<set<ll>> Vs(26);
rep(i, 26) {
Vs[i].insert(-1);
Vs[i].insert(D);
}
rep(d, D) { Vs[T[d]].insert(d); }
auto diff = [&](ll d, ll next) {
ll current = T[d];
if (current == next) {
ll zero = 0;
return zero;
}
set<ll> &pre = Vs[current];
set<ll> &post = Vs[next];
auto pr_itr = pre.upper_bound(d);
auto post_itr = post.upper_bound(d);
ll pr = *pr_itr;
ll po = *post_itr;
pr_itr--;
pr_itr--;
post_itr--;
ll nr = *pr_itr;
ll no = *post_itr;
ll di = (pr - d) * C[current] * (d - nr) - (po - d) * C[next] * (d - no);
di += S[d][current] - S[d][next];
return -di;
};
auto update = [&](ll d, ll next) {
ll current = T[d];
if (current == next)
return;
set<ll> &pre = Vs[current];
set<ll> &post = Vs[next];
pre.erase(d);
post.insert(d);
T[d] = next;
};
ll M = 1e6;
vpii DQ(M);
random_device rnd;
rep(i, M) {
DQ[i].first = rnd() % D;
DQ[i].second = rnd() % 26;
}
ans = calc(D);
rep(m, M) {
ll d = DQ[m].first;
ll md = 0;
ll mi = T[d];
rep(i, 26) {
ll di = diff(d, i);
if (md < di) {
mi = i;
md = di;
}
}
// 改善
ans += md;
update(d, mi);
}
rep(d, D) { cout << T[d] + 1 << endl; }
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| #include <algorithm>
#include <bits/stdc++.h>
#include <cctype>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <stdint.h>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long double ld;
typedef int_fast64_t ll;
typedef pair<ll, ll> pii;
typedef pair<ll, pii> piii;
typedef pair<pii, pii> piiii;
typedef pair<ll, bool> pib;
typedef vector<bool> vb;
typedef vector<ll> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<vpii> vvpii;
typedef vector<double> vf;
typedef queue<ll> qi;
typedef long double ld;
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define rep(i, N) for (ll i = 0; i < N; i++)
#define repa(i, a, N) for (ll i = a; i < N; i++)
#define repr(i, N) for (ll i = N - 1; i >= 0; i--)
#define drep(i, N, j, M) rep(i, N) rep(j, M)
#define trep(i, N, j, M, k, L) rep(i, N) rep(j, M) rep(k, L)
#define all(A) A.begin(), A.end()
#define uni(A) A.erase(unique(all(A)), A.end())
const ll LLMAX = numeric_limits<ll>::max() / 3;
const ld LDMAX = numeric_limits<ld>::max() / 3;
const ld PI = 3.141592653589793;
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
template <ll Modulus> class modint {
public:
ll a;
constexpr modint(const ll x = 0) noexcept : a(x % Modulus) {}
constexpr ll &value() noexcept { return a; }
constexpr const ll &value() const noexcept { return a; }
constexpr modint operator+() const noexcept { return *this; }
constexpr modint operator-() const noexcept {
return modint(0LL) -= modint(*this);
}
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
a += rhs.a;
if (a >= Modulus) {
a -= Modulus;
}
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (a < rhs.a) {
a += Modulus;
}
a -= rhs.a;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
a = a * rhs.a % Modulus;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
ll exp = Modulus - 2;
while (exp) {
if (exp % 2) {
*this *= rhs;
}
rhs *= rhs;
exp /= 2;
}
return *this;
}
};
typedef modint<MOD> mod;
constexpr const mod operator+(const ll a, const mod b) noexcept {
return mod(a) += b;
}
constexpr const mod operator-(const ll a, const mod b) noexcept {
return mod(a) -= b;
}
constexpr const mod operator*(const ll a, const mod b) noexcept {
return mod(a) *= b;
}
constexpr const mod operator/(const ll a, const mod b) noexcept {
return mod(a) /= b;
}
template <class T> class SegTree {
ll n;
vector<T> data;
T def;
function<T(T, T)> operation;
function<T(T, T)> update;
T _query(ll a, ll b, ll k, ll l, ll r) {
if (r <= a || b <= l)
return def;
if (a <= l && r <= b)
return data[k];
else {
T c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2);
T c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r);
return operation(c1, c2);
}
}
public:
// _n: サイズ, _def: 初期値・単位元, _operation: クエリ, _update: 更新
SegTree(ll _n, T _def, function<T(T, T)> _operation,
function<T(T, T)> _update)
: def(_def), operation(_operation), update(_update) {
n = 1;
while (n < _n) {
n *= 2;
}
data = vector<T>(2 * n - 1, def);
}
// iの値をxに変更
void change(ll i, T x) {
i += n - 1;
data[i] = update(data[i], x);
while (i > 0) {
i = (i - 1) / 2;
data[i] = operation(data[i * 2 + 1], data[i * 2 + 2]);
}
}
// [a, b)の区間クエリ実行
T query(ll a, ll b) { return _query(a, b, 0, 0, n); }
// 添え字アクセス
constexpr const T operator[](ll i) const noexcept { return data[i + n - 1]; }
constexpr const ll size() const noexcept { return n; }
constexpr const T unit() const noexcept { return def; }
};
/*
SegTree<ll> st(N, LLMAX,
// a: left child, b: right child
[](ll a, ll b) {return min(a, b); },
// d: old, x: query
[](ll d, ll x) {return x; });
// */
template <class t, class u>
ostream &operator<<(ostream &os, const pair<t, u> &p) {
return os << "{" << p.first << "," << p.second << "}";
}
template <class t> ostream &operator<<(ostream &os, const vector<t> &v) {
os << "{";
for (auto e : v)
os << e << ",";
return os << "}" << endl;
}
template <class t, class u>
ostream &operator<<(ostream &os, const unordered_map<t, u> &m) {
os << "{";
for (auto itr = m.begin(); itr != m.end(); ++itr) {
os << "(" << itr->first << ", " << itr->second << "), ";
}
return os << "}";
}
template <class t> ostream &operator<<(ostream &os, const set<t> &m) {
os << "{";
for (auto itr = m.begin(); itr != m.end(); ++itr) {
os << *itr << ", ";
}
return os << "}";
}
template <class t> ostream &operator<<(ostream &os, const multiset<t> &m) {
os << "{";
for (auto itr = m.begin(); itr != m.end(); ++itr) {
os << *itr << ", ";
}
return os << "}";
}
template <ll Modulus>
ostream &operator<<(ostream &os, const modint<Modulus> &m) {
return os << (m.a + Modulus) % Modulus;
}
template <class t> ostream &operator<<(ostream &os, const SegTree<t> &st) {
os << "{";
ll s = st.size();
rep(i, s) {
t v = st[i];
if (v == st.unit()) {
os << "-, ";
} else {
os << v << ", ";
}
}
return os << "}\n";
}
typedef vector<mod> vm;
typedef vector<vm> vvm;
typedef vector<vvm> vvvm;
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;
}
void No() { cout << "No" << endl; }
void Yes() { cout << "Yes" << endl; }
void NO() { cout << "NO" << endl; }
void YES() { cout << "YES" << endl; }
// x^n(mod M) ←普通にpow(x,n)では溢れてしまうため，随時mod計算
ll mpow(ll x, ll n) {
ll ans = 1;
while (n != 0) {
if (n & 1)
ans = ans * x % MOD;
x = x * x % MOD;
n = n >> 1;
}
return ans;
}
ll fac_size = 1e6;
vm fac(fac_size + 1); // n! (mod MOD)
vm ifac(fac_size + 1); // k!^{M-2} (mod MOD)
bool fac_calculated = false;
void pre_calc_comb() {
fac[0] = 1;
ifac[0] = 1;
for (ll i = 0; i < fac_size; i++) {
fac[i + 1] = fac[i] * (i + 1); // n!(mod M)
ifac[i + 1] =
ifac[i] * mpow(i + 1, MOD - 2); // k!^{M-2} (mod M) ←累乗にmpowを採用
}
fac_calculated = true;
}
mod comb(ll a, ll b) { // aCbをmod計算
if (!fac_calculated)
pre_calc_comb();
if (a == 0 && b == 0)
return 1;
if (a < b || a < 0)
return 0;
mod tmp = ifac[a - b] * ifac[b];
return tmp * fac[a];
}
ll gcd(ll a, ll b) {
if (a == 0)
return b;
if (b == 0)
return a;
if (a % b == 0) {
return (b);
} else {
return (gcd(b, a % b));
}
}
ll N, M, K, Q;
ll ans = 0;
ll H, W;
string S;
void solve() {
ll D;
cin >> D;
vi C(26);
rep(i, 26) { cin >> C[i]; }
vvi S(D, vi(26));
rep(d, D) {
rep(i, 26) { cin >> S[d][i]; }
}
vi T(D, 0);
auto calc = [&](ll D) {
ll ans = 0;
vi L(26, -1);
// 貪欲
rep(d, D) {
ll t = T[d];
L[t] = d;
ans += S[d][t];
rep(i, 26) { ans -= (d - L[i]) * C[i]; }
}
return ans;
};
// 初期値
rep(d, D) {
ll m = 0;
ll mi = 0;
rep(i, 26) {
T[d] = i;
ll tmp = calc(d + 1);
if (m < tmp) {
mi = i;
m = tmp;
}
}
T[d] = mi;
}
// シミュレーション
vector<set<ll>> Vs(26);
rep(i, 26) {
Vs[i].insert(-1);
Vs[i].insert(D);
}
rep(d, D) { Vs[T[d]].insert(d); }
auto diff = [&](ll d, ll next) {
ll current = T[d];
if (current == next) {
ll zero = 0;
return zero;
}
set<ll> &pre = Vs[current];
set<ll> &post = Vs[next];
auto pr_itr = pre.upper_bound(d);
auto post_itr = post.upper_bound(d);
ll pr = *pr_itr;
ll po = *post_itr;
pr_itr--;
pr_itr--;
post_itr--;
ll nr = *pr_itr;
ll no = *post_itr;
ll di = (pr - d) * C[current] * (d - nr) - (po - d) * C[next] * (d - no);
di += S[d][current] - S[d][next];
return -di;
};
auto update = [&](ll d, ll next) {
ll current = T[d];
if (current == next)
return;
set<ll> &pre = Vs[current];
set<ll> &post = Vs[next];
pre.erase(d);
post.insert(d);
T[d] = next;
};
ll M = 8e5;
vpii DQ(M);
random_device rnd;
rep(i, M) {
DQ[i].first = rnd() % D;
DQ[i].second = rnd() % 26;
}
ans = calc(D);
rep(m, M) {
ll d = DQ[m].first;
ll md = 0;
ll mi = T[d];
rep(i, 26) {
ll di = diff(d, i);
if (md < di) {
mi = i;
md = di;
}
}
// 改善
ans += md;
update(d, mi);
}
rep(d, D) { cout << T[d] + 1 << endl; }
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
| replace | 405 | 406 | 405 | 406 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define ALL(v) (v).begin(), (v).end()
template <class T>
using reverse_priority_queue = priority_queue<T, vector<T>, greater<T>>;
const int D = 365;
const int NTYPE = 26;
const int MAX_DELTA_DAY = 10;
minstd_rand rng;
clock_t start;
array<int, NTYPE> c;
array<array<int, NTYPE>, D> s;
const int NUM_CAND_TYPE = NTYPE / 2;
array<array<int, NUM_CAND_TYPE>, D> cand_types;
array<set<int>, D> cand_types_set;
array<int, D> day_order;
array<int, NTYPE> type_order;
array<int, NUM_CAND_TYPE> type_order2;
struct TypeSchedule {
int id;
set<int> day;
int score;
int get_prev_day(int x) const {
auto it1 = day.lower_bound(x);
int prev_day = -1;
if (it1 != day.begin()) {
prev_day = *(--it1);
}
return prev_day;
}
int get_next_day(int x) const {
auto it2 = day.upper_bound(x);
if (it2 != day.end() && *it2 == x) {
++it2;
}
int next_day = D;
if (it2 != day.end()) {
next_day = *it2;
}
return next_day;
}
TypeSchedule(int id) : id(id) { score = -c.at(id) * (D + 1) * D / 2; }
int add_gain(int x) const {
const int prev_day = get_prev_day(x);
const int next_day = get_next_day(x);
// prev_day + 1, ... , next_day - 1 = next_day - prev_day - 1 個
const int l = next_day - prev_day - 1;
int g = c.at(id) * (l + 1) * l / 2;
// prev_day + 1, ..., x - 1 = x - prev_day - 1 個
const int m1 = x - prev_day - 1;
const int m2 = next_day - x - 1;
g -= c.at(id) * (m1 * (m1 + 1) / 2 + m2 * (m2 + 1) / 2);
g += s.at(x).at(id);
return g;
}
void add(int x) {
score += add_gain(x);
day.insert(x);
}
int remove_gain(int x) const {
assert(day.count(x) == 1);
const int prev_day = get_prev_day(x);
const int next_day = get_next_day(x);
// prev_day + 1, ... , next_day - 1 = next_day - prev_day - 1 個
const int l = next_day - prev_day - 1;
int g = -c.at(id) * (l + 1) * l / 2;
// prev_day + 1, ..., x - 1 = x - prev_day - 1 個
const int m1 = x - prev_day - 1;
const int m2 = next_day - x - 1;
g += c.at(id) * (m1 * (m1 + 1) / 2 + m2 * (m2 + 1) / 2);
g -= s.at(x).at(id);
return g;
}
void remove(int x) {
score += remove_gain(x);
day.erase(x);
}
};
struct Schedule {
vector<TypeSchedule> type;
array<int, D> d2t;
int score;
Schedule() {
fill(ALL(d2t), -1);
score = 0;
REP(i, NTYPE) {
type.emplace_back(i);
score += type.at(i).score;
}
validate_score();
}
int calc_gain_set(int d, int t) const {
const int t0 = d2t.at(d);
if (t0 == t) {
return 0;
}
int ret = 0;
if (t0 != -1) {
ret += type.at(t0).remove_gain(d);
}
ret += type.at(t).add_gain(d);
return ret;
}
void set(int d, int t) {
if (d2t.at(d) == t) {
return;
}
score += calc_gain_set(d, t);
const int t0 = d2t.at(d);
d2t.at(d) = t;
type.at(t).add(d);
if (t0 != -1) {
type.at(t0).remove(d);
}
validate_score();
}
int get(int d) const { return d2t.at(d); }
void unset(int d, int t) {
score -= type.at(t).score;
d2t.at(d) = -1;
type.at(t).remove(d);
score += type.at(t).score;
validate_score();
}
void swap(int d1, int d2) {
if (get(d1) == get(d2)) {
return;
}
const int t1 = get(d1);
const int t2 = get(d2);
set(d1, t2);
set(d2, t1);
validate_score();
}
void output() const {
REP(i, D) {
assert(d2t.at(i) != -1);
cout << d2t.at(i) + 1 << endl;
}
}
void validate_score() const {
return;
// int tmp = 0;
// array<int, NTYPE> last;
// fill(ALL(last), 0);
// REP(i, D){
// int t = get(i);
// if(t != -1){
// tmp += s.at(i).at(t);
// last.at(t) = i + 1;
// }
// REP(s, NTYPE){
// tmp -= c.at(s) * (i + 1 - last.at(s));
// }
// }
// assert(tmp == score);
}
};
void input() {
int _d;
cin >> _d;
REP(i, NTYPE) { cin >> c.at(i); }
REP(i, D) {
REP(j, NTYPE) { cin >> s.at(i).at(j); }
}
}
int calc_score_type(const array<int, D> &sch, int t) {
int last = 0;
int ret = 0;
REP(i, D) {
if (sch.at(i) == t) {
ret += s.at(i).at(t);
last = i + 1;
}
ret -= c.at(t) * (i + 1 - last);
}
return ret;
}
int calc_satisfaction(const array<int, D> &sch) {
int ret = 0;
REP(i, NTYPE) { ret += calc_score_type(sch, i); }
return ret;
}
void greedy_init(Schedule &ans, int k = 1) {
array<int, NTYPE> last;
fill(ALL(last), 0);
REP(i, D) {
int max_type = -1;
int max_val = numeric_limits<int>::min();
REP(j, NTYPE) {
int tmp = s.at(i).at(j);
tmp += c.at(j) * (i + 1 - last.at(j)) * (min(D, i + k + 1) - i);
if (max_val < tmp) {
max_type = j;
max_val = tmp;
}
}
assert(max_type != -1);
ans.set(i, max_type);
last.at(max_type) = i + 1;
}
}
void init() {
REP(i, D) { day_order.at(i) = i; }
REP(i, NTYPE) { type_order.at(i) = i; }
REP(i, NUM_CAND_TYPE) { type_order2.at(i) = i; }
REP(i, D) {
array<pair<int, int>, NTYPE> tmp;
REP(j, NTYPE) { tmp.at(j) = {s.at(i).at(j) + c.at(j), j}; }
sort(ALL(tmp), greater<pair<int, int>>());
REP(j, NUM_CAND_TYPE) {
cand_types.at(i).at(j) = tmp.at(j).second;
cand_types_set.at(i).insert(tmp.at(j).second);
}
}
}
double get_cur_sec() { return (double)(clock() - start) / CLOCKS_PER_SEC; }
int calc_gain_swap(Schedule &ans, int i, int j) {
if (ans.get(i) == ans.get(j)) {
return 0;
}
const int ti = ans.get(i);
const int tj = ans.get(j);
assert(ti != -1 && tj != -1);
int g = -ans.score;
ans.set(i, tj);
ans.set(j, ti);
g += ans.score;
ans.set(i, ti);
ans.set(j, tj);
return g;
}
void greedy_update(Schedule &ans) {
bool modified = true;
while (modified) {
modified = false;
// change type
REP(j, D) {
REP(k, NTYPE) {
if (ans.get(j) == k) {
continue;
}
const int g = ans.calc_gain_set(j, k);
if (g > 0) {
modified = true;
ans.set(j, k);
}
}
}
// swap day
REP(j, D) {
for (int delta = 1; delta <= MAX_DELTA_DAY && j + delta < D; ++delta) {
const int g = calc_gain_swap(ans, j, j + delta);
if (g > 0) {
modified = true;
ans.swap(j, j + delta);
}
}
}
if (get_cur_sec() >= 1.9) {
break;
}
}
}
void search_cycle(Schedule &out, double exit_time, int max_it) {
for (int it = 0; it < max_it; ++it) {
REP(j, D) {
Schedule s = out;
array<bool, D> moved;
fill(ALL(moved), false);
int cur = j;
moved.at(cur) = true;
while (1) {
int max_j2 = -1;
int max_g = numeric_limits<int>::min();
for (int j2 = max(0, cur - 10); j2 < min(D, cur + 10); ++j2) {
if (moved.at(j2) || s.get(j2) == s.get(cur)) {
continue;
}
int g = calc_gain_swap(s, j, j2);
if (max_g < g) {
max_j2 = j2;
max_g = g;
}
}
if (max_j2 == -1) {
break;
}
cur = max_j2;
s.swap(j, cur);
moved.at(cur) = true;
if (s.score > out.score) {
out = s;
}
if (get_cur_sec() >= exit_time) {
return;
}
}
}
}
}
void search_sa(Schedule &out, double exit_time, double temp_hi = 2000,
double temp_lo = 600) {
Schedule ans = out;
uniform_real_distribution<> ur(0.0, 1.0);
const double start_sec = get_cur_sec();
double temp = temp_hi;
for (int it = 0;; ++it) {
shuffle(ALL(day_order), rng);
// shuffle(ALL(type_order), rng);
shuffle(ALL(type_order2), rng);
for (int j : day_order) {
// for(int k : type_order){
for (int ki : type_order2) {
const int k = cand_types.at(j).at(ki);
if (k == ans.get(j)) {
continue;
}
const int g = ans.calc_gain_set(j, k);
if (exp((double)g / temp) >= ur(rng)) {
ans.set(j, k);
if (ans.score > out.score) {
out = ans;
}
}
}
for (int delta = 1; delta <= MAX_DELTA_DAY && j + delta < D; ++delta) {
const int t1 = ans.get(j), t2 = ans.get(j + delta);
if (!(cand_types_set.at(j).count(t2) &&
cand_types_set.at(j + delta).count(t1))) {
continue;
}
const int g = calc_gain_swap(ans, j, j + delta);
if (exp((double)g / temp) >= ur(rng)) {
ans.swap(j, j + delta);
if (ans.score > out.score) {
out = ans;
}
}
}
}
const double t = (get_cur_sec() - start_sec) / (exit_time - start_sec);
temp = pow(temp_hi, 1 - t) * pow(temp_lo, t);
if (t >= exit_time) {
// cerr << it << endl;
break;
}
}
}
void solve() {
Schedule ans;
greedy_init(ans, 1);
// greedy_update(ans);
search_sa(ans, 1.9);
// search_cycle(ans, 1.95, 1);
ans.output();
}
int main() {
start = clock();
rng.seed(0);
input();
init();
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define REP(i, n) for (int i = 0; i < (n); ++i)
#define RREP(i, n) for (int i = (n)-1; i >= 0; --i)
#define ALL(v) (v).begin(), (v).end()
template <class T>
using reverse_priority_queue = priority_queue<T, vector<T>, greater<T>>;
const int D = 365;
const int NTYPE = 26;
const int MAX_DELTA_DAY = 10;
minstd_rand rng;
clock_t start;
array<int, NTYPE> c;
array<array<int, NTYPE>, D> s;
const int NUM_CAND_TYPE = NTYPE / 2;
array<array<int, NUM_CAND_TYPE>, D> cand_types;
array<set<int>, D> cand_types_set;
array<int, D> day_order;
array<int, NTYPE> type_order;
array<int, NUM_CAND_TYPE> type_order2;
struct TypeSchedule {
int id;
set<int> day;
int score;
int get_prev_day(int x) const {
auto it1 = day.lower_bound(x);
int prev_day = -1;
if (it1 != day.begin()) {
prev_day = *(--it1);
}
return prev_day;
}
int get_next_day(int x) const {
auto it2 = day.upper_bound(x);
if (it2 != day.end() && *it2 == x) {
++it2;
}
int next_day = D;
if (it2 != day.end()) {
next_day = *it2;
}
return next_day;
}
TypeSchedule(int id) : id(id) { score = -c.at(id) * (D + 1) * D / 2; }
int add_gain(int x) const {
const int prev_day = get_prev_day(x);
const int next_day = get_next_day(x);
// prev_day + 1, ... , next_day - 1 = next_day - prev_day - 1 個
const int l = next_day - prev_day - 1;
int g = c.at(id) * (l + 1) * l / 2;
// prev_day + 1, ..., x - 1 = x - prev_day - 1 個
const int m1 = x - prev_day - 1;
const int m2 = next_day - x - 1;
g -= c.at(id) * (m1 * (m1 + 1) / 2 + m2 * (m2 + 1) / 2);
g += s.at(x).at(id);
return g;
}
void add(int x) {
score += add_gain(x);
day.insert(x);
}
int remove_gain(int x) const {
assert(day.count(x) == 1);
const int prev_day = get_prev_day(x);
const int next_day = get_next_day(x);
// prev_day + 1, ... , next_day - 1 = next_day - prev_day - 1 個
const int l = next_day - prev_day - 1;
int g = -c.at(id) * (l + 1) * l / 2;
// prev_day + 1, ..., x - 1 = x - prev_day - 1 個
const int m1 = x - prev_day - 1;
const int m2 = next_day - x - 1;
g += c.at(id) * (m1 * (m1 + 1) / 2 + m2 * (m2 + 1) / 2);
g -= s.at(x).at(id);
return g;
}
void remove(int x) {
score += remove_gain(x);
day.erase(x);
}
};
struct Schedule {
vector<TypeSchedule> type;
array<int, D> d2t;
int score;
Schedule() {
fill(ALL(d2t), -1);
score = 0;
REP(i, NTYPE) {
type.emplace_back(i);
score += type.at(i).score;
}
validate_score();
}
int calc_gain_set(int d, int t) const {
const int t0 = d2t.at(d);
if (t0 == t) {
return 0;
}
int ret = 0;
if (t0 != -1) {
ret += type.at(t0).remove_gain(d);
}
ret += type.at(t).add_gain(d);
return ret;
}
void set(int d, int t) {
if (d2t.at(d) == t) {
return;
}
score += calc_gain_set(d, t);
const int t0 = d2t.at(d);
d2t.at(d) = t;
type.at(t).add(d);
if (t0 != -1) {
type.at(t0).remove(d);
}
validate_score();
}
int get(int d) const { return d2t.at(d); }
void unset(int d, int t) {
score -= type.at(t).score;
d2t.at(d) = -1;
type.at(t).remove(d);
score += type.at(t).score;
validate_score();
}
void swap(int d1, int d2) {
if (get(d1) == get(d2)) {
return;
}
const int t1 = get(d1);
const int t2 = get(d2);
set(d1, t2);
set(d2, t1);
validate_score();
}
void output() const {
REP(i, D) {
assert(d2t.at(i) != -1);
cout << d2t.at(i) + 1 << endl;
}
}
void validate_score() const {
return;
// int tmp = 0;
// array<int, NTYPE> last;
// fill(ALL(last), 0);
// REP(i, D){
// int t = get(i);
// if(t != -1){
// tmp += s.at(i).at(t);
// last.at(t) = i + 1;
// }
// REP(s, NTYPE){
// tmp -= c.at(s) * (i + 1 - last.at(s));
// }
// }
// assert(tmp == score);
}
};
void input() {
int _d;
cin >> _d;
REP(i, NTYPE) { cin >> c.at(i); }
REP(i, D) {
REP(j, NTYPE) { cin >> s.at(i).at(j); }
}
}
int calc_score_type(const array<int, D> &sch, int t) {
int last = 0;
int ret = 0;
REP(i, D) {
if (sch.at(i) == t) {
ret += s.at(i).at(t);
last = i + 1;
}
ret -= c.at(t) * (i + 1 - last);
}
return ret;
}
int calc_satisfaction(const array<int, D> &sch) {
int ret = 0;
REP(i, NTYPE) { ret += calc_score_type(sch, i); }
return ret;
}
void greedy_init(Schedule &ans, int k = 1) {
array<int, NTYPE> last;
fill(ALL(last), 0);
REP(i, D) {
int max_type = -1;
int max_val = numeric_limits<int>::min();
REP(j, NTYPE) {
int tmp = s.at(i).at(j);
tmp += c.at(j) * (i + 1 - last.at(j)) * (min(D, i + k + 1) - i);
if (max_val < tmp) {
max_type = j;
max_val = tmp;
}
}
assert(max_type != -1);
ans.set(i, max_type);
last.at(max_type) = i + 1;
}
}
void init() {
REP(i, D) { day_order.at(i) = i; }
REP(i, NTYPE) { type_order.at(i) = i; }
REP(i, NUM_CAND_TYPE) { type_order2.at(i) = i; }
REP(i, D) {
array<pair<int, int>, NTYPE> tmp;
REP(j, NTYPE) { tmp.at(j) = {s.at(i).at(j) + c.at(j), j}; }
sort(ALL(tmp), greater<pair<int, int>>());
REP(j, NUM_CAND_TYPE) {
cand_types.at(i).at(j) = tmp.at(j).second;
cand_types_set.at(i).insert(tmp.at(j).second);
}
}
}
double get_cur_sec() { return (double)(clock() - start) / CLOCKS_PER_SEC; }
int calc_gain_swap(Schedule &ans, int i, int j) {
if (ans.get(i) == ans.get(j)) {
return 0;
}
const int ti = ans.get(i);
const int tj = ans.get(j);
assert(ti != -1 && tj != -1);
int g = -ans.score;
ans.set(i, tj);
ans.set(j, ti);
g += ans.score;
ans.set(i, ti);
ans.set(j, tj);
return g;
}
void greedy_update(Schedule &ans) {
bool modified = true;
while (modified) {
modified = false;
// change type
REP(j, D) {
REP(k, NTYPE) {
if (ans.get(j) == k) {
continue;
}
const int g = ans.calc_gain_set(j, k);
if (g > 0) {
modified = true;
ans.set(j, k);
}
}
}
// swap day
REP(j, D) {
for (int delta = 1; delta <= MAX_DELTA_DAY && j + delta < D; ++delta) {
const int g = calc_gain_swap(ans, j, j + delta);
if (g > 0) {
modified = true;
ans.swap(j, j + delta);
}
}
}
if (get_cur_sec() >= 1.9) {
break;
}
}
}
void search_cycle(Schedule &out, double exit_time, int max_it) {
for (int it = 0; it < max_it; ++it) {
REP(j, D) {
Schedule s = out;
array<bool, D> moved;
fill(ALL(moved), false);
int cur = j;
moved.at(cur) = true;
while (1) {
int max_j2 = -1;
int max_g = numeric_limits<int>::min();
for (int j2 = max(0, cur - 10); j2 < min(D, cur + 10); ++j2) {
if (moved.at(j2) || s.get(j2) == s.get(cur)) {
continue;
}
int g = calc_gain_swap(s, j, j2);
if (max_g < g) {
max_j2 = j2;
max_g = g;
}
}
if (max_j2 == -1) {
break;
}
cur = max_j2;
s.swap(j, cur);
moved.at(cur) = true;
if (s.score > out.score) {
out = s;
}
if (get_cur_sec() >= exit_time) {
return;
}
}
}
}
}
void search_sa(Schedule &out, double exit_time, double temp_hi = 2000,
double temp_lo = 600) {
Schedule ans = out;
uniform_real_distribution<> ur(0.0, 1.0);
const double start_sec = get_cur_sec();
double temp = temp_hi;
for (int it = 0;; ++it) {
shuffle(ALL(day_order), rng);
// shuffle(ALL(type_order), rng);
shuffle(ALL(type_order2), rng);
for (int j : day_order) {
// for(int k : type_order){
for (int ki : type_order2) {
const int k = cand_types.at(j).at(ki);
if (k == ans.get(j)) {
continue;
}
const int g = ans.calc_gain_set(j, k);
if (exp((double)g / temp) >= ur(rng)) {
ans.set(j, k);
if (ans.score > out.score) {
out = ans;
}
}
}
for (int delta = 1; delta <= MAX_DELTA_DAY && j + delta < D; ++delta) {
const int t1 = ans.get(j), t2 = ans.get(j + delta);
if (!(cand_types_set.at(j).count(t2) &&
cand_types_set.at(j + delta).count(t1))) {
continue;
}
const int g = calc_gain_swap(ans, j, j + delta);
if (exp((double)g / temp) >= ur(rng)) {
ans.swap(j, j + delta);
if (ans.score > out.score) {
out = ans;
}
}
}
}
const double t = (get_cur_sec() - start_sec) / (exit_time - start_sec);
temp = pow(temp_hi, 1 - t) * pow(temp_lo, t);
if (t >= 1.0) {
// cerr << it << endl;
break;
}
}
}
void solve() {
Schedule ans;
greedy_init(ans, 1);
// greedy_update(ans);
search_sa(ans, 1.9);
// search_cycle(ans, 1.95, 1);
ans.output();
}
int main() {
start = clock();
rng.seed(0);
input();
init();
solve();
return 0;
}
| replace | 382 | 383 | 382 | 383 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
// #define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define uniq(x) (x).erase(unique(all(x)), (x).end())
#define bit(n) (1LL << (n))
#define cdiv(a, b) (((a)-1) / (b) + 1)
#define dump(x) cerr << #x " = " << (x) << endl
using vint = vector<int>;
using vvint = vector<vint>;
using pint = pair<int, int>;
using vpint = vector<pint>;
template <typename T>
using priority_queue_rev = priority_queue<T, vector<T>, greater<T>>;
constexpr double PI = 3.1415926535897932384626433832795028;
constexpr int DY[8] = {0, 1, 0, -1, 1, 1, -1, -1};
constexpr int DX[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int gcd(int a, int b) {
while (b) {
swap(a %= b, b);
}
return a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
template <typename T> void fin(T mes) {
cout << mes << endl;
exit(0);
}
template <typename T, typename U> bool chmax(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T, typename U> bool chmin(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &rhs) {
os << "(" << rhs.first << ", " << rhs.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &rhs) {
os << "{";
for (auto itr = rhs.begin(); itr != rhs.end(); itr++) {
os << *itr << (next(itr) != rhs.end() ? ", " : "");
}
os << "}";
return os;
}
struct setup {
static constexpr int PREC = 20;
setup() {
cout << fixed << setprecision(PREC);
cerr << fixed << setprecision(PREC);
};
} setup;
long long xor64(long long range) {
static unsigned long long x = 1145141919810ULL;
x ^= x << 13;
x ^= x >> 7;
return (x ^= x << 17) % range;
}
struct timer {
unsigned long long begin_cycle;
double cycle_per_sec = 2.8e9;
unsigned long long get_cycle() {
unsigned low, high;
__asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
return ((unsigned long long)low) | ((unsigned long long)high << 32);
}
double get_time() { return (get_cycle() - begin_cycle) / cycle_per_sec; }
void init() { begin_cycle = get_cycle(); }
} timer;
void simulated_annealing() {
timer.init();
double T = 5.95;
double start_temp = 0.01;
double end_temp = 0.01;
int it = 0, pre_score;
double time;
while ((time = timer.get_time()) < T) {
it++;
double temp = start_temp + (end_temp - start_temp) * time / T;
int new_score;
// スコアが高いほどいい
double prob = exp((new_score - pre_score) / temp);
if (prob < (double)xor64(10000000) / 10000000) {
// rejected
} else {
// accepted
}
}
}
int D;
int c[33];
int s[440][33];
int A = 26;
struct state {
int val = 0;
vint last = vint(A + 1, 0);
vint history{0};
state() {}
};
state beam_search() {
int T = D;
int beam_width = 500;
vector<state> pre_states = {state()};
reps(i, T) {
vector<state> next_states;
rep(j, pre_states.size()) {
state pre_state = pre_states[j];
int penalty = 0;
reps(k, A) { penalty += c[k] * (i - pre_state.last[k]); }
reps(k, A) {
state next_state = pre_state;
next_state.val += s[i][k] + c[k] * (i - pre_state.last[k]) - penalty;
next_state.last[k] = i;
next_state.history.push_back(k);
next_states.push_back(next_state);
}
}
// pre_statesから次の状態を計算しnext_statesに突っ込む
vector<int> idx(next_states.size());
for (int i = 0; i < idx.size(); i++) {
idx[i] = i;
}
nth_element(idx.begin(), idx.begin() + beam_width - 1, idx.end(),
[&](int l, int r) {
// lのほうが優先度が高い時、true
return next_states[l].val > next_states[r].val;
});
pre_states.clear();
for (int i = 0; i < min(beam_width, (int)idx.size()); i++) {
pre_states.push_back(next_states[idx[i]]);
}
}
state ret;
ret.val = INT_MIN;
for (int i = 0; i < pre_states.size(); i++) {
if (ret.val < pre_states[i].val) {
ret = pre_states[i];
}
}
return ret;
}
int score(vint history) {
vint last(A + 1);
int ret = 0;
reps(i, D) {
ret += s[i][history[i]];
last[history[i]] = i;
reps(j, A) { ret -= c[j] * (i - last[j]); }
}
return ret;
}
int main() {
cin >> D;
reps(i, A) { cin >> c[i]; }
reps(i, D) {
reps(j, A) { cin >> s[i][j]; }
}
state res = beam_search();
reps(i, D) { cout << res.history[i] << endl; }
dump(res.val);
} | #include <bits/stdc++.h>
using namespace std;
// #define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define reps(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define uniq(x) (x).erase(unique(all(x)), (x).end())
#define bit(n) (1LL << (n))
#define cdiv(a, b) (((a)-1) / (b) + 1)
#define dump(x) cerr << #x " = " << (x) << endl
using vint = vector<int>;
using vvint = vector<vint>;
using pint = pair<int, int>;
using vpint = vector<pint>;
template <typename T>
using priority_queue_rev = priority_queue<T, vector<T>, greater<T>>;
constexpr double PI = 3.1415926535897932384626433832795028;
constexpr int DY[8] = {0, 1, 0, -1, 1, 1, -1, -1};
constexpr int DX[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int gcd(int a, int b) {
while (b) {
swap(a %= b, b);
}
return a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
template <typename T> void fin(T mes) {
cout << mes << endl;
exit(0);
}
template <typename T, typename U> bool chmax(T &a, const U &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T, typename U> bool chmin(T &a, const U &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &rhs) {
os << "(" << rhs.first << ", " << rhs.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &rhs) {
os << "{";
for (auto itr = rhs.begin(); itr != rhs.end(); itr++) {
os << *itr << (next(itr) != rhs.end() ? ", " : "");
}
os << "}";
return os;
}
struct setup {
static constexpr int PREC = 20;
setup() {
cout << fixed << setprecision(PREC);
cerr << fixed << setprecision(PREC);
};
} setup;
long long xor64(long long range) {
static unsigned long long x = 1145141919810ULL;
x ^= x << 13;
x ^= x >> 7;
return (x ^= x << 17) % range;
}
struct timer {
unsigned long long begin_cycle;
double cycle_per_sec = 2.8e9;
unsigned long long get_cycle() {
unsigned low, high;
__asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
return ((unsigned long long)low) | ((unsigned long long)high << 32);
}
double get_time() { return (get_cycle() - begin_cycle) / cycle_per_sec; }
void init() { begin_cycle = get_cycle(); }
} timer;
void simulated_annealing() {
timer.init();
double T = 5.95;
double start_temp = 0.01;
double end_temp = 0.01;
int it = 0, pre_score;
double time;
while ((time = timer.get_time()) < T) {
it++;
double temp = start_temp + (end_temp - start_temp) * time / T;
int new_score;
// スコアが高いほどいい
double prob = exp((new_score - pre_score) / temp);
if (prob < (double)xor64(10000000) / 10000000) {
// rejected
} else {
// accepted
}
}
}
int D;
int c[33];
int s[440][33];
int A = 26;
struct state {
int val = 0;
vint last = vint(A + 1, 0);
vint history{0};
state() {}
};
state beam_search() {
int T = D;
int beam_width = 300;
vector<state> pre_states = {state()};
reps(i, T) {
vector<state> next_states;
rep(j, pre_states.size()) {
state pre_state = pre_states[j];
int penalty = 0;
reps(k, A) { penalty += c[k] * (i - pre_state.last[k]); }
reps(k, A) {
state next_state = pre_state;
next_state.val += s[i][k] + c[k] * (i - pre_state.last[k]) - penalty;
next_state.last[k] = i;
next_state.history.push_back(k);
next_states.push_back(next_state);
}
}
// pre_statesから次の状態を計算しnext_statesに突っ込む
vector<int> idx(next_states.size());
for (int i = 0; i < idx.size(); i++) {
idx[i] = i;
}
nth_element(idx.begin(), idx.begin() + beam_width - 1, idx.end(),
[&](int l, int r) {
// lのほうが優先度が高い時、true
return next_states[l].val > next_states[r].val;
});
pre_states.clear();
for (int i = 0; i < min(beam_width, (int)idx.size()); i++) {
pre_states.push_back(next_states[idx[i]]);
}
}
state ret;
ret.val = INT_MIN;
for (int i = 0; i < pre_states.size(); i++) {
if (ret.val < pre_states[i].val) {
ret = pre_states[i];
}
}
return ret;
}
int score(vint history) {
vint last(A + 1);
int ret = 0;
reps(i, D) {
ret += s[i][history[i]];
last[history[i]] = i;
reps(j, A) { ret -= c[j] * (i - last[j]); }
}
return ret;
}
int main() {
cin >> D;
reps(i, A) { cin >> c[i]; }
reps(i, D) {
reps(j, A) { cin >> s[i][j]; }
}
state res = beam_search();
reps(i, D) { cout << res.history[i] << endl; }
dump(res.val);
} | replace | 118 | 119 | 118 | 119 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define N (1000000000 + 7)
#define M 998244353
#define INF 1e16
typedef long long ll;
typedef pair<ll, ll> P;
ll A(ll x) {
if (x >= 0)
return x;
else
return -x;
}
ll gcd(ll a, ll b) {
if (b > a) {
ll tmp = b;
b = a;
a = tmp;
}
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
ll c[27];
ll s[400][27];
ll last[400][27];
ll score[27];
int main(void) {
int D;
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];
}
}
vector<ll> mx(D + 1, 0);
for (int d = 1; d <= D; d++) {
ll S = 0;
for (int i = 1; i <= 26; i++) {
if (S < s[d][i]) {
mx[d] = i;
S = s[d][i];
}
}
}
ll ans = 0;
random_device rnd;
mt19937 mt(rnd());
uniform_int_distribution<> rand26(1, 26), randday(1, D);
for (ll d = 1; d <= D; d++) {
for (int i = 1; i <= 26; i++) {
last[d][i] = last[d - 1][i];
if (i == mx[d])
last[d][mx[d]] = d;
}
ans += s[d][mx[d]];
for (ll j = 1; j <= 26; j++) {
ans -= c[j] * (d - last[d][j]);
}
}
for (ll qu = 0; qu < 5000000; qu++) {
ll d = randday(mt);
ll q = rand26(mt);
// cout<<d<<" "<<q<<endl;
ll tmp = ans;
tmp += s[d][q] - s[d][mx[d]];
ll old1 = last[d][mx[d]];
ll new1 = last[d - 1][mx[d]];
ll old2 = last[d][q];
ll new2 = d;
for (ll i = d; i <= D; i++) {
tmp += c[mx[d]] * (i - last[i][mx[d]]);
if (last[i][mx[d]] == old1)
last[i][mx[d]] = new1;
tmp -= c[mx[d]] * (i - last[i][mx[d]]);
}
for (ll i = d; i <= D; i++) {
tmp += c[q] * (i - last[i][q]);
if (last[i][q] == old2)
last[i][q] = new2;
tmp -= c[q] * (i - last[i][q]);
}
if (ans < tmp) {
ans = tmp;
mx[d] = q;
} else {
for (ll i = d; i <= D; i++) {
if (last[i][mx[d]] == new1)
last[i][mx[d]] = old1;
}
for (ll i = d; i <= D; i++) {
if (last[i][q] == new2)
last[i][q] = old2;
}
}
}
for (int i = 1; i <= D; i++)
cout << mx[i] << endl;
return 0;
} | #include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define N (1000000000 + 7)
#define M 998244353
#define INF 1e16
typedef long long ll;
typedef pair<ll, ll> P;
ll A(ll x) {
if (x >= 0)
return x;
else
return -x;
}
ll gcd(ll a, ll b) {
if (b > a) {
ll tmp = b;
b = a;
a = tmp;
}
if (a % b == 0)
return b;
else
return gcd(b, a % b);
}
ll c[27];
ll s[400][27];
ll last[400][27];
ll score[27];
int main(void) {
int D;
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];
}
}
vector<ll> mx(D + 1, 0);
for (int d = 1; d <= D; d++) {
ll S = 0;
for (int i = 1; i <= 26; i++) {
if (S < s[d][i]) {
mx[d] = i;
S = s[d][i];
}
}
}
ll ans = 0;
random_device rnd;
mt19937 mt(rnd());
uniform_int_distribution<> rand26(1, 26), randday(1, D);
for (ll d = 1; d <= D; d++) {
for (int i = 1; i <= 26; i++) {
last[d][i] = last[d - 1][i];
if (i == mx[d])
last[d][mx[d]] = d;
}
ans += s[d][mx[d]];
for (ll j = 1; j <= 26; j++) {
ans -= c[j] * (d - last[d][j]);
}
}
for (ll qu = 0; qu < 2000000; qu++) {
ll d = randday(mt);
ll q = rand26(mt);
// cout<<d<<" "<<q<<endl;
ll tmp = ans;
tmp += s[d][q] - s[d][mx[d]];
ll old1 = last[d][mx[d]];
ll new1 = last[d - 1][mx[d]];
ll old2 = last[d][q];
ll new2 = d;
for (ll i = d; i <= D; i++) {
tmp += c[mx[d]] * (i - last[i][mx[d]]);
if (last[i][mx[d]] == old1)
last[i][mx[d]] = new1;
tmp -= c[mx[d]] * (i - last[i][mx[d]]);
}
for (ll i = d; i <= D; i++) {
tmp += c[q] * (i - last[i][q]);
if (last[i][q] == old2)
last[i][q] = new2;
tmp -= c[q] * (i - last[i][q]);
}
if (ans < tmp) {
ans = tmp;
mx[d] = q;
} else {
for (ll i = d; i <= D; i++) {
if (last[i][mx[d]] == new1)
last[i][mx[d]] = old1;
}
for (ll i = d; i <= D; i++) {
if (last[i][q] == new2)
last[i][q] = old2;
}
}
}
for (int i = 1; i <= D; i++)
cout << mx[i] << endl;
return 0;
} | replace | 78 | 79 | 78 | 79 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
int N, D;
vector<int> C;
vector<vector<int>> S;
vector<int> ans;
void Read(bool local = false) {
N = 26;
if (local) {
D = 365;
} else {
cin >> D;
}
C.resize(N);
for (int i = 0; i < N; i++) {
if (local) {
C[i] = rnd() % 100;
} else {
cin >> C[i];
}
}
S.resize(D);
for (int i = 0; i < D; i++) {
S[i].resize(N);
for (int j = 0; j < N; j++) {
if (local) {
S[i][j] = rnd() % 20000;
} else {
cin >> S[i][j];
}
}
}
ans.assign(D, 0);
}
void Write() {
for (auto i : ans) {
cout << i + 1 << "\n";
}
}
int Arithmetic(int n) { return n * (n - 1) / 2; }
vector<set<int>> Build(vector<int> a) {
vector<set<int>> occ(N);
for (int i = 0; i < D; i++) {
occ[a[i]].insert(i);
}
for (int i = 0; i < N; i++) {
occ[i].insert(-1);
occ[i].insert(D);
}
return occ;
}
int Evaluate(vector<int> a) {
vector<int> last(N, -1);
int score = 0;
for (int i = 0; i < D; i++) {
score += S[i][a[i]];
last[a[i]] = i;
for (int j = 0; j < 26; j++) {
score -= C[j] * (i - last[j]);
}
}
return score;
}
int Evaluate(int init_score, const vector<int> &a, const vector<set<int>> &occ,
int d, int q) {
if (a[d] == q)
return init_score;
const set<int> &cur = occ[a[d]];
auto pos = cur.lower_bound(d);
int lst = *prev(pos);
int nxt = *next(pos);
int score = init_score;
score += C[a[d]] *
(Arithmetic(nxt - d) + Arithmetic(d - lst) - Arithmetic(nxt - lst));
pos = occ[q].upper_bound(d);
lst = *prev(pos);
nxt = *pos;
score -= C[q] *
(Arithmetic(nxt - d) + Arithmetic(d - lst) - Arithmetic(nxt - lst));
score -= S[d][a[d]];
score += S[d][q];
return score;
}
void Change(int &init_score, vector<int> &a, vector<set<int>> &occ, int d,
int q) {
int new_score = Evaluate(init_score, a, occ, d, q);
init_score = new_score;
occ[a[d]].erase(d);
a[d] = q;
occ[a[d]].insert(d);
}
void Solve() {
vector<int> a(D);
for (int i = 0; i < D; i++) {
a[i] = rnd() % N;
}
int score = Evaluate(a);
vector<set<int>> occ = Build(a);
double temp = 10000;
double cooling_rate = 0.999999;
double absolute_zero = 0.00000001;
int rep = 3e6;
while (rep--) {
int d = rnd() % D;
int q = rnd() % N;
int delta = Evaluate(score, a, occ, d, q) - score;
if (delta >= 0) {
Change(score, a, occ, d, q);
}
// temp *= cooling_rate;
}
if (Evaluate(ans) < Evaluate(a)) {
ans = a;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
Read();
for (int rep = 0; rep < 10; rep++) {
Solve();
}
Write();
// cerr << Evaluate(ans) << "\n";
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
int N, D;
vector<int> C;
vector<vector<int>> S;
vector<int> ans;
void Read(bool local = false) {
N = 26;
if (local) {
D = 365;
} else {
cin >> D;
}
C.resize(N);
for (int i = 0; i < N; i++) {
if (local) {
C[i] = rnd() % 100;
} else {
cin >> C[i];
}
}
S.resize(D);
for (int i = 0; i < D; i++) {
S[i].resize(N);
for (int j = 0; j < N; j++) {
if (local) {
S[i][j] = rnd() % 20000;
} else {
cin >> S[i][j];
}
}
}
ans.assign(D, 0);
}
void Write() {
for (auto i : ans) {
cout << i + 1 << "\n";
}
}
int Arithmetic(int n) { return n * (n - 1) / 2; }
vector<set<int>> Build(vector<int> a) {
vector<set<int>> occ(N);
for (int i = 0; i < D; i++) {
occ[a[i]].insert(i);
}
for (int i = 0; i < N; i++) {
occ[i].insert(-1);
occ[i].insert(D);
}
return occ;
}
int Evaluate(vector<int> a) {
vector<int> last(N, -1);
int score = 0;
for (int i = 0; i < D; i++) {
score += S[i][a[i]];
last[a[i]] = i;
for (int j = 0; j < 26; j++) {
score -= C[j] * (i - last[j]);
}
}
return score;
}
int Evaluate(int init_score, const vector<int> &a, const vector<set<int>> &occ,
int d, int q) {
if (a[d] == q)
return init_score;
const set<int> &cur = occ[a[d]];
auto pos = cur.lower_bound(d);
int lst = *prev(pos);
int nxt = *next(pos);
int score = init_score;
score += C[a[d]] *
(Arithmetic(nxt - d) + Arithmetic(d - lst) - Arithmetic(nxt - lst));
pos = occ[q].upper_bound(d);
lst = *prev(pos);
nxt = *pos;
score -= C[q] *
(Arithmetic(nxt - d) + Arithmetic(d - lst) - Arithmetic(nxt - lst));
score -= S[d][a[d]];
score += S[d][q];
return score;
}
void Change(int &init_score, vector<int> &a, vector<set<int>> &occ, int d,
int q) {
int new_score = Evaluate(init_score, a, occ, d, q);
init_score = new_score;
occ[a[d]].erase(d);
a[d] = q;
occ[a[d]].insert(d);
}
void Solve() {
vector<int> a(D);
for (int i = 0; i < D; i++) {
a[i] = rnd() % N;
}
int score = Evaluate(a);
vector<set<int>> occ = Build(a);
double temp = 10000;
double cooling_rate = 0.999999;
double absolute_zero = 0.00000001;
int rep = 1e6;
while (rep--) {
int d = rnd() % D;
int q = rnd() % N;
int delta = Evaluate(score, a, occ, d, q) - score;
if (delta >= 0) {
Change(score, a, occ, d, q);
}
// temp *= cooling_rate;
}
if (Evaluate(ans) < Evaluate(a)) {
ans = a;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
Read();
for (int rep = 0; rep < 10; rep++) {
Solve();
}
Write();
// cerr << Evaluate(ans) << "\n";
return 0;
}
| replace | 118 | 119 | 118 | 119 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using V = vector<int>;
using VV = vector<V>;
using VVV = vector<VV>;
using VL = vector<ll>;
using VVL = vector<VL>;
using VVVL = vector<VVL>;
template <class T> using VE = vector<T>;
template <class T> using P = pair<T, T>;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define REP(i, k, n) for (int i = (k); i < (n); i++)
#define all(a) (a).begin(), (a).end()
#define output(x, y) cout << fixed << setprecision(y) << x << endl;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
ll upper = MOD + MOD;
ll under = -upper;
ll UPPER = MOD * MOD;
ll UNDER = -UPPER;
const long double pi = 3.141592653589793;
const int D = 26;
V p(D);
V l(D, 0);
VV up(D, V(26));
void calc(ll &now, int x,
int d) { // 今のスコア、どれを選んだか、何日目か(0-indexed)
l[x] = d + 1;
now += up[d][x];
rep(j, 26) { now -= p[j] * ((d + 1) - l[j]); }
}
ll test(ll now, int x, int d) { // その選択をしてみる
ll tmp = now;
tmp += up[d][x];
rep(j, 26) { tmp -= p[j] * ((d + 1) - l[j]); }
return tmp - now;
}
int main() { // とりあえずgreedyにやる
int d;
cin >> d;
ll now = 0;
queue<int> que;
rep(i, 26) cin >> p[i];
rep(i, d) rep(j, 26) cin >> up[i][j];
rep(i, d) {
ll diff = UNDER;
int select = -1;
rep(j, 26) {
if (chmax(diff, test(now, j, i)))
select = j;
}
que.push(select + 1);
calc(now, select, i);
}
while (!que.empty()) {
cout << que.front() << endl;
que.pop();
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using V = vector<int>;
using VV = vector<V>;
using VVV = vector<VV>;
using VL = vector<ll>;
using VVL = vector<VL>;
using VVVL = vector<VVL>;
template <class T> using VE = vector<T>;
template <class T> using P = pair<T, T>;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define REP(i, k, n) for (int i = (k); i < (n); i++)
#define all(a) (a).begin(), (a).end()
#define output(x, y) cout << fixed << setprecision(y) << x << endl;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
ll gcd(ll a, ll b) { return b ? gcd(b, a % b) : a; }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
const ll MOD = 1e9 + 7;
// const ll MOD = 998244353;
ll upper = MOD + MOD;
ll under = -upper;
ll UPPER = MOD * MOD;
ll UNDER = -UPPER;
const long double pi = 3.141592653589793;
const int D = 365;
V p(D);
V l(D, 0);
VV up(D, V(26));
void calc(ll &now, int x,
int d) { // 今のスコア、どれを選んだか、何日目か(0-indexed)
l[x] = d + 1;
now += up[d][x];
rep(j, 26) { now -= p[j] * ((d + 1) - l[j]); }
}
ll test(ll now, int x, int d) { // その選択をしてみる
ll tmp = now;
tmp += up[d][x];
rep(j, 26) { tmp -= p[j] * ((d + 1) - l[j]); }
return tmp - now;
}
int main() { // とりあえずgreedyにやる
int d;
cin >> d;
ll now = 0;
queue<int> que;
rep(i, 26) cin >> p[i];
rep(i, d) rep(j, 26) cin >> up[i][j];
rep(i, d) {
ll diff = UNDER;
int select = -1;
rep(j, 26) {
if (chmax(diff, test(now, j, i)))
select = j;
}
que.push(select + 1);
calc(now, select, i);
}
while (!que.empty()) {
cout << que.front() << endl;
que.pop();
}
return 0;
} | replace | 40 | 41 | 40 | 41 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx2")
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < int(n); i++)
#define FOR(i, m, n) for (int i = int(m); i < int(n); i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define VI vector<int>
#define VP vector<pair<int, int>>
#define VPP vector<pair<int, pair<int, int>>>
#define VLL vector<long long>
#define VVI vector<vector<int>>
#define VVLL vector<vector<long long>>
#define VC vector<char>
#define VS vector<string>
#define VVC vector<vector<char>>
#define VB vector<bool>
#define VVB vector<vector<bool>>
#define fore(i, a) for (auto &i : a)
typedef pair<int, int> P;
template <typename T>
using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
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 int INF = (1 << 30) - 1;
const ll INFL = 1LL << 60;
const ll mod = 10000000007;
std::chrono::system_clock::time_point start;
std::chrono::system_clock::time_point owari;
double calc_time() {
owari = std::chrono::system_clock::now();
return std::chrono::duration_cast<std::chrono::milliseconds>(owari - start)
.count();
}
/*
inline unsigned long long xor128() {
static unsigned long long rx = 411111789, ry = 9471111169, rz =
5212488629, rw = 886575123; unsigned long long rt = (rx ^ (rx << 11)); rx = ry;
ry = rz;
rz = rw;
return (rw = (rw ^ (rw >> 19)) ^ (rt ^ (rt >> 8)));
}
*/
inline uint32_t xor128() {
static uint32_t seed = 2;
seed = seed ^ (seed << 7);
seed = seed ^ (seed >> 12);
return seed = seed & (~1);
}
double rand128() { return (double)(xor128() & 0xFFFF) / 0xFFFF; }
int D;
int pena[26];
int s[365][26];
int ans[365];
int pe[26];
int score = 0;
inline int calc() {
int cur = 0;
REP(i, 365) { cur += s[i][ans[i]]; }
VI a(26, -1);
REP(i, 365) {
cur -= (i - a[ans[i]]) * (i - a[ans[i]] - 1) / 2 * pena[ans[i]];
a[ans[i]] = i;
}
REP(i, 26) { cur -= (365 - a[i]) * (364 - a[i]) / 2 * pena[i]; }
return cur;
}
int main() {
cin >> D;
start = std::chrono::system_clock::now();
REP(i, 26) cin >> pena[i];
REP(i, 365) REP(j, 26) { cin >> s[i][j]; }
REP(i, D) { ans[i] = i % 26; }
score = calc();
REP(_, 2) {
REP(i, 365) {
REP(j, 26) {
int tmp = ans[i];
ans[i] = j;
int cur = calc();
if (cur < score) {
ans[i] = tmp;
} else
score = cur;
}
}
}
FOR(j, 1, 8) {
REP(i, 365) {
if (calc_time() > 1900)
break;
if (j > 364)
continue;
REP(k, 26) REP(l, 26) {
int tmp1 = ans[i];
int tmp2 = ans[i + j];
ans[i] = k;
ans[i + j] = l;
int cur = calc();
if (cur < score) {
ans[i] = tmp1;
ans[i + j] = tmp2;
} else
score = cur;
}
}
}
cerr << score << endl;
int loop = 0;
while (true) {
if (loop % 100 == 0) {
if (calc_time() > 1950)
break;
}
loop++;
int a = xor128() % 363;
int b = xor128() % 7;
int c = xor128() % 7;
b++;
c++;
if (a + b + c >= 365)
continue;
int tmp1 = ans[a];
int tmp2 = ans[a + b];
int tmp3 = ans[a + b + c];
REP(i, 26) REP(j, 26) REP(k, 26) {
ans[a] = i;
ans[a + b] = j;
ans[a + b + c] = k;
int cur = calc();
if (cur > score) {
tmp1 = i;
tmp2 = j;
tmp3 = k;
score = cur;
cerr << score << endl;
}
}
ans[a] = tmp1;
ans[a + b] = tmp2;
ans[a + b + c] = tmp3;
}
cerr << score << endl;
REP(i, 365) { cout << ans[i] + 1 << endl; }
}
| #include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx2")
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0; i < int(n); i++)
#define FOR(i, m, n) for (int i = int(m); i < int(n); i++)
#define ALL(obj) (obj).begin(), (obj).end()
#define VI vector<int>
#define VP vector<pair<int, int>>
#define VPP vector<pair<int, pair<int, int>>>
#define VLL vector<long long>
#define VVI vector<vector<int>>
#define VVLL vector<vector<long long>>
#define VC vector<char>
#define VS vector<string>
#define VVC vector<vector<char>>
#define VB vector<bool>
#define VVB vector<vector<bool>>
#define fore(i, a) for (auto &i : a)
typedef pair<int, int> P;
template <typename T>
using min_priority_queue = priority_queue<T, vector<T>, greater<T>>;
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 int INF = (1 << 30) - 1;
const ll INFL = 1LL << 60;
const ll mod = 10000000007;
std::chrono::system_clock::time_point start;
std::chrono::system_clock::time_point owari;
double calc_time() {
owari = std::chrono::system_clock::now();
return std::chrono::duration_cast<std::chrono::milliseconds>(owari - start)
.count();
}
/*
inline unsigned long long xor128() {
static unsigned long long rx = 411111789, ry = 9471111169, rz =
5212488629, rw = 886575123; unsigned long long rt = (rx ^ (rx << 11)); rx = ry;
ry = rz;
rz = rw;
return (rw = (rw ^ (rw >> 19)) ^ (rt ^ (rt >> 8)));
}
*/
inline uint32_t xor128() {
static uint32_t seed = 2;
seed = seed ^ (seed << 7);
seed = seed ^ (seed >> 12);
return seed = seed & (~1);
}
double rand128() { return (double)(xor128() & 0xFFFF) / 0xFFFF; }
int D;
int pena[26];
int s[365][26];
int ans[365];
int pe[26];
int score = 0;
inline int calc() {
int cur = 0;
REP(i, 365) { cur += s[i][ans[i]]; }
VI a(26, -1);
REP(i, 365) {
cur -= (i - a[ans[i]]) * (i - a[ans[i]] - 1) / 2 * pena[ans[i]];
a[ans[i]] = i;
}
REP(i, 26) { cur -= (365 - a[i]) * (364 - a[i]) / 2 * pena[i]; }
return cur;
}
int main() {
cin >> D;
start = std::chrono::system_clock::now();
REP(i, 26) cin >> pena[i];
REP(i, 365) REP(j, 26) { cin >> s[i][j]; }
REP(i, D) { ans[i] = i % 26; }
score = calc();
REP(_, 2) {
REP(i, 365) {
REP(j, 26) {
int tmp = ans[i];
ans[i] = j;
int cur = calc();
if (cur < score) {
ans[i] = tmp;
} else
score = cur;
}
}
}
FOR(j, 1, 8) {
REP(i, 365) {
if (calc_time() > 1900)
break;
if (j > 364)
continue;
REP(k, 26) REP(l, 26) {
int tmp1 = ans[i];
int tmp2 = ans[i + j];
ans[i] = k;
ans[i + j] = l;
int cur = calc();
if (cur < score) {
ans[i] = tmp1;
ans[i + j] = tmp2;
} else
score = cur;
}
}
}
cerr << score << endl;
int loop = 0;
while (calc_time() < 1900) {
int a = xor128() % 363;
int b = xor128() % 7;
int c = xor128() % 7;
b++;
c++;
if (a + b + c >= 365)
continue;
int tmp1 = ans[a];
int tmp2 = ans[a + b];
int tmp3 = ans[a + b + c];
REP(i, 26) REP(j, 26) REP(k, 26) {
ans[a] = i;
ans[a + b] = j;
ans[a + b + c] = k;
int cur = calc();
if (cur > score) {
tmp1 = i;
tmp2 = j;
tmp3 = k;
score = cur;
cerr << score << endl;
}
}
ans[a] = tmp1;
ans[a + b] = tmp2;
ans[a + b + c] = tmp3;
}
cerr << score << endl;
REP(i, 365) { cout << ans[i] + 1 << endl; }
}
| replace | 141 | 148 | 141 | 142 | TLE | |
p02618 | C++ | Time Limit Exceeded | /*
このコード、と～おれ!
Be accepted!
∧＿∧
（｡･ω･｡)つ━☆・*。
⊂ ノ ・゜+.
しーＪ °。+ *´¨)
.· ´¸.·*´¨) ¸.·*¨)
(¸.·´ (¸.·'* ☆
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
////多倍長整数, cpp_intで宣言
// #include <boost/multiprecision/cpp_int.hpp>
// using namespace boost::multiprecision;
#pragma gcc target("avx2")
#pragma gcc optimization("Ofast")
#pragma gcc optimization("unroll-loops")
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define rep2(i, n) for (int i = 2; i < (n); ++i)
#define repr(i, n) for (int i = n; i >= 0; --i)
#define reprm(i, n) for (int i = n - 1; i >= 0; --i)
#define printynl(a) printf(a ? "yes\n" : "no\n")
#define printyn(a) printf(a ? "Yes\n" : "No\n")
#define printYN(a) printf(a ? "YES\n" : "NO\n")
#define printim(a) printf(a ? "possible\n" : "imposible\n")
#define printdb(a) printf("%.50lf\n", a) // 少数出力
#define printLdb(a) printf("%.50Lf\n", a) // 少数出力
#define printdbd(a) printf("%.16lf\n", a) // 少数出力(桁少なめ)
#define prints(s) printf("%s\n", s.c_str()) // string出力
#define all(x) (x).begin(), (x).end()
#define allsum(a, b, c) ((a + b) * c / 2LL) // 等差数列の和、初項,末項,項数
#define pb push_back
#define rpriq priq<int, vector<int>, greater<int>>
#define deg_to_rad(deg) (((deg) / 360.0L) * 2.0L * PI)
#define rad_to_deg(rad) (((rad) / 2.0L / PI) * 360.0L)
#define Please return
#define AC 0
#define manhattan_dist(a, b, c, d) \
(abs(a - c) + abs(b - d)) /*(a, b) から (c, d) のマンハッタン距離 */
#define inf numeric_limits<double>::infinity();
#define linf numeric_limits<long double>::infinity()
using ll = long long;
constexpr int INF = 1073741823;
constexpr int MINF = -1073741823;
constexpr ll LINF = ll(4661686018427387903);
constexpr ll MOD = 1e9 + 7;
constexpr long double eps = 1e-6;
const long double PI = acosl(-1.0L);
using namespace std;
void scans(string &str) {
char c;
str = "";
scanf("%c", &c);
if (c == '\n')
scanf("%c", &c);
while (c != '\n' && c != -1 && c != ' ') {
str += c;
scanf("%c", &c);
}
}
void scanc(char &str) {
char c;
scanf("%c", &c);
if (c == -1)
return;
while (c == '\n') {
scanf("%c", &c);
}
str = c;
}
double acot(double x) { return PI / 2 - atan(x); }
ll LSB(ll n) { return (n & (-n)); }
/*-----------------------------------------ここからコード-----------------------------------------*/
int main() {
int d;
scanf("%d", &d);
vector<ll> c(26);
rep(i, 26) scanf("%lld", &c[i]);
vector<vector<ll>> s(d, vector<ll>(26));
rep(i, d) rep(j, 26) scanf("%lld", &s[i][j]);
vector<ll> last(26);
ll ans = 0, tmp;
int idx1 = 1, idx2 = 1, idx3 = 1, idx4 = 1;
vector<int> res(d);
rep(i, d - 2) {
ans = -INF;
rep(j, 26) {
rep(k, 26) {
rep(l, 26) {
rep(m, 26) {
ll tmp = 0;
tmp += s[i][j] + s[i + 1][k] + s[i + 2][l] + s[i + 3][m];
int last1 = last[j], last2 = last[k], last3 = last[l],
last4 = last[m];
last[j] = i;
rep(n, 26) tmp -= c[n] * (i - last[n]);
last[k] = i + 1;
rep(n, 26) tmp -= c[n] * (i + 1 - last[n]);
last[l] = i + 2;
rep(n, 26) tmp -= c[n] * (i + 2 - last[n]);
last[m] = i + 3;
rep(n, 26) tmp -= c[n] * (i + 3 - last[n]);
if (tmp >= ans) {
ans = tmp;
idx1 = j;
idx2 = k;
idx3 = l;
idx4 = m;
}
last[j] = last1, last[k] = last2, last[l] = last3, last[m] = last4;
}
}
}
}
last[idx1] = i, last[idx2] = i + 1, last[idx3] = i + 2, last[idx4] = i + 3;
res[i] = idx1, res[i + 1] = idx2, res[i + 2] = idx3, res[i + 3] = idx4;
i += 3;
}
ans = -INF;
int idx = 1;
rep(i, 26) {
ll tmp = s[d - 1][i];
last[i] = d - 1;
rep(j, 26) tmp -= (c[j] * (d - 1 - last[j]));
if (tmp > ans) {
idx = i;
ans = tmp;
}
}
res[d - 1] = idx;
for (const auto &aa : res)
printf("%d\n", aa + 1);
Please AC;
} | /*
このコード、と～おれ!
Be accepted!
∧＿∧
（｡･ω･｡)つ━☆・*。
⊂ ノ ・゜+.
しーＪ °。+ *´¨)
.· ´¸.·*´¨) ¸.·*¨)
(¸.·´ (¸.·'* ☆
*/
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
////多倍長整数, cpp_intで宣言
// #include <boost/multiprecision/cpp_int.hpp>
// using namespace boost::multiprecision;
#pragma gcc target("avx2")
#pragma gcc optimization("Ofast")
#pragma gcc optimization("unroll-loops")
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define rep2(i, n) for (int i = 2; i < (n); ++i)
#define repr(i, n) for (int i = n; i >= 0; --i)
#define reprm(i, n) for (int i = n - 1; i >= 0; --i)
#define printynl(a) printf(a ? "yes\n" : "no\n")
#define printyn(a) printf(a ? "Yes\n" : "No\n")
#define printYN(a) printf(a ? "YES\n" : "NO\n")
#define printim(a) printf(a ? "possible\n" : "imposible\n")
#define printdb(a) printf("%.50lf\n", a) // 少数出力
#define printLdb(a) printf("%.50Lf\n", a) // 少数出力
#define printdbd(a) printf("%.16lf\n", a) // 少数出力(桁少なめ)
#define prints(s) printf("%s\n", s.c_str()) // string出力
#define all(x) (x).begin(), (x).end()
#define allsum(a, b, c) ((a + b) * c / 2LL) // 等差数列の和、初項,末項,項数
#define pb push_back
#define rpriq priq<int, vector<int>, greater<int>>
#define deg_to_rad(deg) (((deg) / 360.0L) * 2.0L * PI)
#define rad_to_deg(rad) (((rad) / 2.0L / PI) * 360.0L)
#define Please return
#define AC 0
#define manhattan_dist(a, b, c, d) \
(abs(a - c) + abs(b - d)) /*(a, b) から (c, d) のマンハッタン距離 */
#define inf numeric_limits<double>::infinity();
#define linf numeric_limits<long double>::infinity()
using ll = long long;
constexpr int INF = 1073741823;
constexpr int MINF = -1073741823;
constexpr ll LINF = ll(4661686018427387903);
constexpr ll MOD = 1e9 + 7;
constexpr long double eps = 1e-6;
const long double PI = acosl(-1.0L);
using namespace std;
void scans(string &str) {
char c;
str = "";
scanf("%c", &c);
if (c == '\n')
scanf("%c", &c);
while (c != '\n' && c != -1 && c != ' ') {
str += c;
scanf("%c", &c);
}
}
void scanc(char &str) {
char c;
scanf("%c", &c);
if (c == -1)
return;
while (c == '\n') {
scanf("%c", &c);
}
str = c;
}
double acot(double x) { return PI / 2 - atan(x); }
ll LSB(ll n) { return (n & (-n)); }
/*-----------------------------------------ここからコード-----------------------------------------*/
int main() {
int d;
scanf("%d", &d);
vector<ll> c(26);
rep(i, 26) scanf("%lld", &c[i]);
vector<vector<ll>> s(d, vector<ll>(26));
rep(i, d) rep(j, 26) scanf("%lld", &s[i][j]);
vector<ll> last(26);
ll ans = 0, tmp;
int idx1 = 1, idx2 = 1, idx3 = 1, idx4 = 1;
vector<int> res(d);
rep(i, d - 2) {
ans = -INF;
rep(j, 26) {
rep(k, 26) {
rep(l, 26) {
rep(m, 26) {
ll tmp = 0;
tmp += s[i][j] + s[i + 1][k] + s[i + 2][l] + s[i + 3][m];
int last1 = last[j], last2 = last[k], last3 = last[l],
last4 = last[m];
last[j] = i;
rep(n, 26) tmp -= c[n] * (i - last[n]);
last[k] = i + 1;
rep(n, 26) tmp -= c[n] * (i + 1 - last[n]);
last[l] = i + 2;
rep(n, 26) tmp -= c[n] * (i + 2 - last[n]);
last[m] = i + 3;
rep(n, 26) tmp -= c[n] * (i + 3 - last[n]);
if (tmp > ans) {
ans = tmp;
idx1 = j;
idx2 = k;
idx3 = l;
idx4 = m;
}
last[j] = last1, last[k] = last2, last[l] = last3, last[m] = last4;
}
}
}
}
last[idx1] = i, last[idx2] = i + 1, last[idx3] = i + 2, last[idx4] = i + 3;
res[i] = idx1, res[i + 1] = idx2, res[i + 2] = idx3, res[i + 3] = idx4;
i += 3;
}
ans = -INF;
int idx = 1;
rep(i, 26) {
ll tmp = s[d - 1][i];
last[i] = d - 1;
rep(j, 26) tmp -= (c[j] * (d - 1 - last[j]));
if (tmp > ans) {
idx = i;
ans = tmp;
}
}
res[d - 1] = idx;
for (const auto &aa : res)
printf("%d\n", aa + 1);
Please AC;
} | replace | 137 | 138 | 137 | 138 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <cstdlib>
#include <ctime>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll d, c[26], s[365][26], t[365], ans = 0, m, x, y, v;
set<ll> se[26];
srand(time(NULL));
cin >> d;
for (int i = 0; i < 26; i++) {
cin >> c[i];
se[i].insert(0);
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < 26; j++) {
cin >> s[i][j];
}
}
for (int i = 0; i < d; i++) {
t[i] = i % 26;
se[t[i]].insert(i + 1);
ans += s[i][t[i]];
for (int j = 0; j < 26; j++) {
ans -= (i + 1 - *se[j].rbegin()) * c[j];
}
}
for (int i = 0; i < 26; i++) {
se[i].insert(d + 1);
}
for (int i = 0; i < 20000000; i++) {
x = rand() % d + 1;
y = rand() % 26;
v = 0LL;
ans += s[x - 1][y] - s[x - 1][t[x - 1]];
set<ll>::iterator it = se[t[x - 1]].find(x);
it--;
ll z = *se[t[x - 1]].upper_bound(x);
v -= c[t[x - 1]] * (z - x) * (x - *it);
it = se[y].lower_bound(x);
it--;
v += c[y] * (*se[y].lower_bound(x) - x) * (x - *it);
if (v > 0LL) {
ans += v;
se[t[x - 1]].erase(x);
t[x - 1] = y;
se[y].insert(x);
}
}
for (int i = 0; i < d; i++) {
cout << t[i] + 1 << endl;
}
} | #include <cstdlib>
#include <ctime>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
ll d, c[26], s[365][26], t[365], ans = 0, m, x, y, v;
set<ll> se[26];
srand(time(NULL));
cin >> d;
for (int i = 0; i < 26; i++) {
cin >> c[i];
se[i].insert(0);
}
for (int i = 0; i < d; i++) {
for (int j = 0; j < 26; j++) {
cin >> s[i][j];
}
}
for (int i = 0; i < d; i++) {
t[i] = i % 26;
se[t[i]].insert(i + 1);
ans += s[i][t[i]];
for (int j = 0; j < 26; j++) {
ans -= (i + 1 - *se[j].rbegin()) * c[j];
}
}
for (int i = 0; i < 26; i++) {
se[i].insert(d + 1);
}
for (int i = 0; i < 20000000; i++) {
x = i % d + 1;
y = i % 26;
v = 0LL;
ans += s[x - 1][y] - s[x - 1][t[x - 1]];
set<ll>::iterator it = se[t[x - 1]].find(x);
it--;
ll z = *se[t[x - 1]].upper_bound(x);
v -= c[t[x - 1]] * (z - x) * (x - *it);
it = se[y].lower_bound(x);
it--;
v += c[y] * (*se[y].lower_bound(x) - x) * (x - *it);
if (v > 0LL) {
ans += v;
se[t[x - 1]].erase(x);
t[x - 1] = y;
se[y].insert(x);
}
}
for (int i = 0; i < d; i++) {
cout << t[i] + 1 << endl;
}
} | replace | 34 | 36 | 34 | 36 | TLE | |
p02618 | C++ | Time Limit Exceeded | const int isDebugMode = 1;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<long long, long long> P;
struct edge {
long long to, cost;
};
const int inf = 1 << 27;
const long long INF = 1LL << 60;
const int COMBMAX = 1001001;
const long long MOD = 1000000007;
const long long dy[] = {-1, 0, 0, 1};
const long long dx[] = {0, -1, 1, 0};
string abc = "abcdefghijklmnopqrstuvwxyz";
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define eachdo(v, e) for (const auto &e : (v))
#define all(v) (v).begin(), (v).end()
#define lower_index(v, e) \
(long long)distance((v).begin(), lower_bound((v).begin(), (v).end(), e))
#define upper_index(v, e) \
(long long)distance((v).begin(), upper_bound((v).begin(), (v).end(), e))
long long mpow(long long a, long long n, long long mod = MOD) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
void pt() {
cout << endl;
return;
}
template <class Head> void pt(Head &&head) {
cout << head;
pt();
return;
}
template <class Head, class... Tail> void pt(Head &&head, Tail &&...tail) {
cout << head << " ";
pt(forward<Tail>(tail)...);
}
void dpt() {
if (!isDebugMode)
return;
cout << endl;
return;
}
template <class Head> void dpt(Head &&head) {
if (!isDebugMode)
return;
cout << head;
pt();
return;
}
template <class Head, class... Tail> void dpt(Head &&head, Tail &&...tail) {
if (!isDebugMode)
return;
cout << head << " ";
pt(forward<Tail>(tail)...);
}
template <class T> void debug(T v) {
if (!isDebugMode)
return;
rep(i, v.size()) cout << v[i] << " ";
cout << endl;
}
template <class T> void debug2(T v) {
if (!isDebugMode)
return;
rep(i, v.size()) {
rep(j, v[i].size()) cout << v[i][j] << " ";
cout << endl;
}
}
template <class T1, class T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2> long long gcd(T1 a, T2 b) {
return a % b ? gcd(b, a % b) : b;
}
template <class T1, class T2> void reduce(T1 &a, T2 &b) {
ll g = gcd(a, b);
a /= g;
b /= g;
return;
}
bool valid(long long H, long long W, long long h, long long w) {
return 0 <= h && h < H && 0 <= w && w < W;
}
int D;
vector<int> c(26);
int ss[365][26];
vector<int> ans(0);
double powyabai = 1.2;
double cyabaipow = 1.2;
double evaluate(int day, int kind) {
double yabasa = 0;
int s = ans.size();
int idx;
for (idx = s - 1; 0 <= idx; idx--) {
if (ans[idx] == kind)
break;
}
yabasa = pow(day - idx, powyabai) * pow(c[kind], cyabaipow);
double uresisa = ss[day][kind];
return yabasa + uresisa;
}
ll cal(vector<int> &ans) {
ll now = 0;
rep(i, D) {
now += ss[i][ans[i]];
rep(j, 26) {
int s = i + 1;
int idx;
for (idx = s - 1; 0 <= idx; idx--) {
if (ans[idx] == j)
break;
}
if (idx >= 0)
now -= (i - idx) * c[j];
}
}
return now;
}
int main() {
cin >> D;
rep(i, 26) cin >> c[i];
rep(i, D) rep(j, 26) cin >> ss[i][j];
rep(i, D) {
double max_eva = -inf;
double choice = 0;
rep(j, 26) {
if (chmax(max_eva, evaluate(i, j)))
choice = j;
}
ans.push_back(choice);
}
random_device rnd;
mt19937 mt(rnd());
rep(i, 3500) {
ll lc = mt() % 365;
ll prev = ans[lc];
ll p = cal(ans);
ans[lc] = mt() % 26;
ll q = cal(ans);
if (q <= p)
ans[lc] = prev;
}
rep(i, D) pt(ans[i] + 1);
return 0;
} | const int isDebugMode = 1;
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<long long, long long> P;
struct edge {
long long to, cost;
};
const int inf = 1 << 27;
const long long INF = 1LL << 60;
const int COMBMAX = 1001001;
const long long MOD = 1000000007;
const long long dy[] = {-1, 0, 0, 1};
const long long dx[] = {0, -1, 1, 0};
string abc = "abcdefghijklmnopqrstuvwxyz";
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define eachdo(v, e) for (const auto &e : (v))
#define all(v) (v).begin(), (v).end()
#define lower_index(v, e) \
(long long)distance((v).begin(), lower_bound((v).begin(), (v).end(), e))
#define upper_index(v, e) \
(long long)distance((v).begin(), upper_bound((v).begin(), (v).end(), e))
long long mpow(long long a, long long n, long long mod = MOD) {
long long res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
void pt() {
cout << endl;
return;
}
template <class Head> void pt(Head &&head) {
cout << head;
pt();
return;
}
template <class Head, class... Tail> void pt(Head &&head, Tail &&...tail) {
cout << head << " ";
pt(forward<Tail>(tail)...);
}
void dpt() {
if (!isDebugMode)
return;
cout << endl;
return;
}
template <class Head> void dpt(Head &&head) {
if (!isDebugMode)
return;
cout << head;
pt();
return;
}
template <class Head, class... Tail> void dpt(Head &&head, Tail &&...tail) {
if (!isDebugMode)
return;
cout << head << " ";
pt(forward<Tail>(tail)...);
}
template <class T> void debug(T v) {
if (!isDebugMode)
return;
rep(i, v.size()) cout << v[i] << " ";
cout << endl;
}
template <class T> void debug2(T v) {
if (!isDebugMode)
return;
rep(i, v.size()) {
rep(j, v[i].size()) cout << v[i][j] << " ";
cout << endl;
}
}
template <class T1, class T2> inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2> inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T1, class T2> long long gcd(T1 a, T2 b) {
return a % b ? gcd(b, a % b) : b;
}
template <class T1, class T2> void reduce(T1 &a, T2 &b) {
ll g = gcd(a, b);
a /= g;
b /= g;
return;
}
bool valid(long long H, long long W, long long h, long long w) {
return 0 <= h && h < H && 0 <= w && w < W;
}
int D;
vector<int> c(26);
int ss[365][26];
vector<int> ans(0);
double powyabai = 1.2;
double cyabaipow = 1.2;
double evaluate(int day, int kind) {
double yabasa = 0;
int s = ans.size();
int idx;
for (idx = s - 1; 0 <= idx; idx--) {
if (ans[idx] == kind)
break;
}
yabasa = pow(day - idx, powyabai) * pow(c[kind], cyabaipow);
double uresisa = ss[day][kind];
return yabasa + uresisa;
}
ll cal(vector<int> &ans) {
ll now = 0;
rep(i, D) {
now += ss[i][ans[i]];
rep(j, 26) {
int s = i + 1;
int idx;
for (idx = s - 1; 0 <= idx; idx--) {
if (ans[idx] == j)
break;
}
if (idx >= 0)
now -= (i - idx) * c[j];
}
}
return now;
}
int main() {
cin >> D;
rep(i, 26) cin >> c[i];
rep(i, D) rep(j, 26) cin >> ss[i][j];
rep(i, D) {
double max_eva = -inf;
double choice = 0;
rep(j, 26) {
if (chmax(max_eva, evaluate(i, j)))
choice = j;
}
ans.push_back(choice);
}
random_device rnd;
mt19937 mt(rnd());
rep(i, 2000) {
ll lc = mt() % 365;
ll prev = ans[lc];
ll p = cal(ans);
ans[lc] = mt() % 26;
ll q = cal(ans);
if (q <= p)
ans[lc] = prev;
}
rep(i, D) pt(ans[i] + 1);
return 0;
} | replace | 161 | 162 | 161 | 162 | TLE | |
p02618 | C++ | Time Limit Exceeded | #if 1
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
template <typename T, typename U>
std::enable_if_t<std::rank<T>::value == 0> fill_all(T &arr, const U &v) {
arr = v;
}
template <typename ARR, typename U>
std::enable_if_t<std::rank<ARR>::value != 0> fill_all(ARR &arr, const U &v) {
for (auto &i : arr) {
fill_all(i, v);
}
}
auto &in = std::cin;
auto &out = std::cout;
#define all_range(C) std::begin(C), std::end(C)
const double PI =
3.141592653589793238462643383279502884197169399375105820974944;
int32_t D;
int32_t C[30];
int32_t S[400][30];
int32_t res[400];
void greedy1() {
int32_t last[40] = {};
fill_all(last, -1);
for (int32_t d = 0; d < D; d++) {
int32_t max = S[d][0];
int32_t max_index = 0;
for (int32_t i = 0; i < 26; i++) {
auto ss = S[d][i] + C[i] * (d - last[i]);
if (max < ss) {
max = ss;
max_index = i;
}
}
res[d] = max_index;
last[max_index] = d;
}
}
int numofbits5(uint32_t bits) {
bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
return (bits & 0x0000ffff) + (bits >> 16 & 0x0000ffff);
}
int32_t bittoindex[1 << 26];
void greedy2_init() {
for (size_t i = 0; i < 26; i++) {
bittoindex[1 << i] = i;
}
}
inline int bittoindexf(int32_t bit) {
switch (bit) {
#define bittoindexf_MACRO(i) \
case (1 << i): \
return i;
bittoindexf_MACRO(0);
bittoindexf_MACRO(1);
bittoindexf_MACRO(2);
bittoindexf_MACRO(3);
bittoindexf_MACRO(4);
bittoindexf_MACRO(5);
bittoindexf_MACRO(6);
bittoindexf_MACRO(7);
bittoindexf_MACRO(8);
bittoindexf_MACRO(9);
bittoindexf_MACRO(10);
bittoindexf_MACRO(11);
bittoindexf_MACRO(12);
bittoindexf_MACRO(13);
bittoindexf_MACRO(14);
bittoindexf_MACRO(15);
bittoindexf_MACRO(16);
bittoindexf_MACRO(17);
bittoindexf_MACRO(18);
bittoindexf_MACRO(19);
bittoindexf_MACRO(20);
bittoindexf_MACRO(21);
bittoindexf_MACRO(22);
bittoindexf_MACRO(23);
bittoindexf_MACRO(24);
bittoindexf_MACRO(25);
#undef bittoindexf_MACRO
default:
return 0;
}
}
int32_t dp[1 << 27];
void greedy2(int start, int base) {
constexpr int MAX_BIT = 26;
constexpr int DIFFBASE = 0;
auto CC = C + start;
auto SS = S + start;
fill_all(dp, 0);
for (int32_t mask = 0; mask < (1 << MAX_BIT); mask++) {
auto d = numofbits5(mask);
auto tmp = ~mask;
auto bit = tmp & -tmp;
tmp ^= bit;
while (bit < (1 << MAX_BIT)) {
auto index = bittoindexf(bit);
auto next = mask | bit;
auto add = SS[d][index] +
CC[index] * (DIFFBASE + d) * (DIFFBASE + d) / 2 +
(26 + DIFFBASE - d) * (26 + DIFFBASE - d) / 2;
dp[next] = std::max(dp[next], dp[mask] + add);
bit = tmp & -tmp;
tmp ^= bit;
}
}
auto R = res + start;
int32_t now = (1 << MAX_BIT) - 1;
while (now > 0) {
auto d = numofbits5(now) - 1;
auto tmp = now;
auto bit = tmp & -tmp;
tmp ^= bit;
while (bit < (1 << MAX_BIT)) {
auto index = bittoindexf(bit);
auto next = now ^ bit;
auto add = SS[d][index] +
CC[index] * (DIFFBASE + d) * (DIFFBASE + d) / 2 +
(26 + DIFFBASE - d) * (26 + DIFFBASE - d) / 2;
if (dp[now] == dp[next] + add) {
R[d] = base + index;
break;
}
bit = tmp & -tmp;
tmp ^= bit;
}
now ^= bit;
}
}
#include <chrono>
auto startTime = std::chrono::system_clock::now();
void greedy3() {
while ((std::chrono::system_clock::now() - startTime) <
std::chrono::milliseconds(1900))
for (size_t COUNT = 0; COUNT < 125; COUNT++)
for (int32_t i = 0; i < D; i++) {
int lefti = i - 1;
while (lefti >= 0 && res[lefti] != res[i]) {
--lefti;
}
int righti = i + 1;
while (righti < D && res[righti] != res[i]) {
++righti;
}
for (int32_t j = std::max(0, i - 26); j < D && j <= i + 26; j++) {
if (i == j) {
continue;
}
if (res[i] == res[j] && i < j) {
break;
}
if (res[i] == res[j]) {
continue;
}
int leftj = j - 1;
while (leftj >= 0 && res[leftj] != res[j]) {
--leftj;
}
int rightj = j + 1;
while (rightj < D && res[rightj] != res[j]) {
++rightj;
}
if (std::max(lefti, leftj) <= std::min(i, j) &&
std::max(i, j) <= std::min(righti, rightj)) {
auto now =
S[i][res[i]] - C[res[i]] * (i - lefti - 1) * (i - lefti) / 2 -
(righti == D
? 0
: C[res[i]] * (righti - i - 1) * (righti - i) / 2) +
S[j][res[j]] - C[res[j]] * (j - leftj - 1) * (j - leftj) / 2 -
(rightj == D ? 0
: C[res[j]] * (rightj - j - 1) * (rightj - j) / 2);
auto next =
S[j][res[i]] - C[res[i]] * (j - lefti - 1) * (j - lefti) / 2 -
(righti == D
? 0
: C[res[i]] * (righti - j - 1) * (righti - j) / 2) +
S[i][res[j]] - C[res[j]] * (i - leftj - 1) * (i - leftj) / 2 -
(rightj == D ? 0
: C[res[j]] * (rightj - i - 1) * (rightj - i) / 2);
if (now < next) {
std::swap(res[i], res[j]);
lefti = i - 1;
while (lefti >= 0 && res[lefti] != res[i]) {
--lefti;
}
righti = i + 1;
while (righti < D && res[righti] != res[i]) {
++righti;
}
}
}
}
if (COUNT == 490)
for (size_t cc = 0; i < 26; i++) {
if (res[i] == cc) {
continue;
}
int leftj = i - 1;
while (leftj >= 0 && res[leftj] != cc) {
--leftj;
}
int rightj = i + 1;
while (rightj < D && res[rightj] != cc) {
++rightj;
}
auto now =
S[i][res[i]] - C[res[i]] * (i - lefti - 1) * (i - lefti) / 2 -
(righti == D
? 0
: C[res[i]] * (righti - i - 1) * (righti - i) / 2) -
(rightj == D
? 0
: C[cc] * (rightj - leftj - 1) * (rightj - leftj) / 2);
auto next =
S[i][cc] - C[cc] * (i - leftj - 1) * (i - leftj) / 2 -
(rightj == D ? 0
: C[cc] * (rightj - i - 1) * (rightj - i) / 2) -
(righti == D
? 0
: C[res[i]] * (righti - lefti - 1) * (righti - lefti) / 2);
if (now < next) {
res[i] = cc;
lefti = i - 1;
while (lefti >= 0 && res[lefti] != res[i]) {
--lefti;
}
righti = i + 1;
while (righti < D && res[righti] != res[i]) {
++righti;
}
}
}
}
}
int main() {
using std::endl;
in.sync_with_stdio(false);
out.sync_with_stdio(false);
in.tie(nullptr);
out.tie(nullptr);
in >> D;
for (size_t i = 0; i < 26; i++) {
in >> C[i];
}
for (size_t d = 0; d < D; d++) {
for (size_t i = 0; i < 26; i++) {
in >> S[d][i];
}
}
greedy1();
// greedy2_init();
// for (size_t i = 0; i < D; i+=26)
//{
// greedy2(i,0);
// //greedy2(i+13,13);
// }
greedy3();
for (size_t d = 0; d < D; d++) {
out << res[d] + 1 << '\n';
}
// for (size_t d = 0; d < D; d++)
//{
// out << (d%26) + 1 << '\n';
// }
return 0;
}
#endif
| #if 1
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdint>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
template <typename T, typename U>
std::enable_if_t<std::rank<T>::value == 0> fill_all(T &arr, const U &v) {
arr = v;
}
template <typename ARR, typename U>
std::enable_if_t<std::rank<ARR>::value != 0> fill_all(ARR &arr, const U &v) {
for (auto &i : arr) {
fill_all(i, v);
}
}
auto &in = std::cin;
auto &out = std::cout;
#define all_range(C) std::begin(C), std::end(C)
const double PI =
3.141592653589793238462643383279502884197169399375105820974944;
int32_t D;
int32_t C[30];
int32_t S[400][30];
int32_t res[400];
void greedy1() {
int32_t last[40] = {};
fill_all(last, -1);
for (int32_t d = 0; d < D; d++) {
int32_t max = S[d][0];
int32_t max_index = 0;
for (int32_t i = 0; i < 26; i++) {
auto ss = S[d][i] + C[i] * (d - last[i]);
if (max < ss) {
max = ss;
max_index = i;
}
}
res[d] = max_index;
last[max_index] = d;
}
}
int numofbits5(uint32_t bits) {
bits = (bits & 0x55555555) + (bits >> 1 & 0x55555555);
bits = (bits & 0x33333333) + (bits >> 2 & 0x33333333);
bits = (bits & 0x0f0f0f0f) + (bits >> 4 & 0x0f0f0f0f);
bits = (bits & 0x00ff00ff) + (bits >> 8 & 0x00ff00ff);
return (bits & 0x0000ffff) + (bits >> 16 & 0x0000ffff);
}
int32_t bittoindex[1 << 26];
void greedy2_init() {
for (size_t i = 0; i < 26; i++) {
bittoindex[1 << i] = i;
}
}
inline int bittoindexf(int32_t bit) {
switch (bit) {
#define bittoindexf_MACRO(i) \
case (1 << i): \
return i;
bittoindexf_MACRO(0);
bittoindexf_MACRO(1);
bittoindexf_MACRO(2);
bittoindexf_MACRO(3);
bittoindexf_MACRO(4);
bittoindexf_MACRO(5);
bittoindexf_MACRO(6);
bittoindexf_MACRO(7);
bittoindexf_MACRO(8);
bittoindexf_MACRO(9);
bittoindexf_MACRO(10);
bittoindexf_MACRO(11);
bittoindexf_MACRO(12);
bittoindexf_MACRO(13);
bittoindexf_MACRO(14);
bittoindexf_MACRO(15);
bittoindexf_MACRO(16);
bittoindexf_MACRO(17);
bittoindexf_MACRO(18);
bittoindexf_MACRO(19);
bittoindexf_MACRO(20);
bittoindexf_MACRO(21);
bittoindexf_MACRO(22);
bittoindexf_MACRO(23);
bittoindexf_MACRO(24);
bittoindexf_MACRO(25);
#undef bittoindexf_MACRO
default:
return 0;
}
}
int32_t dp[1 << 27];
void greedy2(int start, int base) {
constexpr int MAX_BIT = 26;
constexpr int DIFFBASE = 0;
auto CC = C + start;
auto SS = S + start;
fill_all(dp, 0);
for (int32_t mask = 0; mask < (1 << MAX_BIT); mask++) {
auto d = numofbits5(mask);
auto tmp = ~mask;
auto bit = tmp & -tmp;
tmp ^= bit;
while (bit < (1 << MAX_BIT)) {
auto index = bittoindexf(bit);
auto next = mask | bit;
auto add = SS[d][index] +
CC[index] * (DIFFBASE + d) * (DIFFBASE + d) / 2 +
(26 + DIFFBASE - d) * (26 + DIFFBASE - d) / 2;
dp[next] = std::max(dp[next], dp[mask] + add);
bit = tmp & -tmp;
tmp ^= bit;
}
}
auto R = res + start;
int32_t now = (1 << MAX_BIT) - 1;
while (now > 0) {
auto d = numofbits5(now) - 1;
auto tmp = now;
auto bit = tmp & -tmp;
tmp ^= bit;
while (bit < (1 << MAX_BIT)) {
auto index = bittoindexf(bit);
auto next = now ^ bit;
auto add = SS[d][index] +
CC[index] * (DIFFBASE + d) * (DIFFBASE + d) / 2 +
(26 + DIFFBASE - d) * (26 + DIFFBASE - d) / 2;
if (dp[now] == dp[next] + add) {
R[d] = base + index;
break;
}
bit = tmp & -tmp;
tmp ^= bit;
}
now ^= bit;
}
}
#include <chrono>
auto startTime = std::chrono::system_clock::now();
void greedy3() {
while ((std::chrono::system_clock::now() - startTime) <
std::chrono::milliseconds(1850))
for (size_t COUNT = 0; COUNT < 125; COUNT++)
for (int32_t i = 0; i < D; i++) {
int lefti = i - 1;
while (lefti >= 0 && res[lefti] != res[i]) {
--lefti;
}
int righti = i + 1;
while (righti < D && res[righti] != res[i]) {
++righti;
}
for (int32_t j = std::max(0, i - 26); j < D && j <= i + 26; j++) {
if (i == j) {
continue;
}
if (res[i] == res[j] && i < j) {
break;
}
if (res[i] == res[j]) {
continue;
}
int leftj = j - 1;
while (leftj >= 0 && res[leftj] != res[j]) {
--leftj;
}
int rightj = j + 1;
while (rightj < D && res[rightj] != res[j]) {
++rightj;
}
if (std::max(lefti, leftj) <= std::min(i, j) &&
std::max(i, j) <= std::min(righti, rightj)) {
auto now =
S[i][res[i]] - C[res[i]] * (i - lefti - 1) * (i - lefti) / 2 -
(righti == D
? 0
: C[res[i]] * (righti - i - 1) * (righti - i) / 2) +
S[j][res[j]] - C[res[j]] * (j - leftj - 1) * (j - leftj) / 2 -
(rightj == D ? 0
: C[res[j]] * (rightj - j - 1) * (rightj - j) / 2);
auto next =
S[j][res[i]] - C[res[i]] * (j - lefti - 1) * (j - lefti) / 2 -
(righti == D
? 0
: C[res[i]] * (righti - j - 1) * (righti - j) / 2) +
S[i][res[j]] - C[res[j]] * (i - leftj - 1) * (i - leftj) / 2 -
(rightj == D ? 0
: C[res[j]] * (rightj - i - 1) * (rightj - i) / 2);
if (now < next) {
std::swap(res[i], res[j]);
lefti = i - 1;
while (lefti >= 0 && res[lefti] != res[i]) {
--lefti;
}
righti = i + 1;
while (righti < D && res[righti] != res[i]) {
++righti;
}
}
}
}
if (COUNT == 490)
for (size_t cc = 0; i < 26; i++) {
if (res[i] == cc) {
continue;
}
int leftj = i - 1;
while (leftj >= 0 && res[leftj] != cc) {
--leftj;
}
int rightj = i + 1;
while (rightj < D && res[rightj] != cc) {
++rightj;
}
auto now =
S[i][res[i]] - C[res[i]] * (i - lefti - 1) * (i - lefti) / 2 -
(righti == D
? 0
: C[res[i]] * (righti - i - 1) * (righti - i) / 2) -
(rightj == D
? 0
: C[cc] * (rightj - leftj - 1) * (rightj - leftj) / 2);
auto next =
S[i][cc] - C[cc] * (i - leftj - 1) * (i - leftj) / 2 -
(rightj == D ? 0
: C[cc] * (rightj - i - 1) * (rightj - i) / 2) -
(righti == D
? 0
: C[res[i]] * (righti - lefti - 1) * (righti - lefti) / 2);
if (now < next) {
res[i] = cc;
lefti = i - 1;
while (lefti >= 0 && res[lefti] != res[i]) {
--lefti;
}
righti = i + 1;
while (righti < D && res[righti] != res[i]) {
++righti;
}
}
}
}
}
int main() {
using std::endl;
in.sync_with_stdio(false);
out.sync_with_stdio(false);
in.tie(nullptr);
out.tie(nullptr);
in >> D;
for (size_t i = 0; i < 26; i++) {
in >> C[i];
}
for (size_t d = 0; d < D; d++) {
for (size_t i = 0; i < 26; i++) {
in >> S[d][i];
}
}
greedy1();
// greedy2_init();
// for (size_t i = 0; i < D; i+=26)
//{
// greedy2(i,0);
// //greedy2(i+13,13);
// }
greedy3();
for (size_t d = 0; d < D; d++) {
out << res[d] + 1 << '\n';
}
// for (size_t d = 0; d < D; d++)
//{
// out << (d%26) + 1 << '\n';
// }
return 0;
}
#endif
| replace | 170 | 171 | 170 | 171 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int d, ans[365], c[26], s[365][26], last[26], tlast[26];
const int INF = 1e9;
#define REP(i, n) for (int i = 0; i < n; i++)
void FIN(int a) {
if (a) {
ofstream fout("output.txt");
REP(i, d) fout << ans[i] << "\n";
fout.close();
return;
}
REP(i, d) cout << ans[i] << "\n";
return;
}
int score() {
int res = 0;
memset(tlast, -1, sizeof(tlast));
REP(day, d) {
res += s[day][ans[day] - 1];
tlast[ans[day] - 1] = day;
REP(i, 26) res -= c[i] * (day - tlast[i]);
}
return res;
}
void swap() {
int day = rand() % 362, diff = rand() % 3, nowscore = score();
swap(ans[day], ans[day + diff]);
if (score() < nowscore)
swap(ans[day], ans[day + diff]);
}
void onechange() {
int day = rand() % 365, nowscore = score();
REP(i, 26) {
int tmp = ans[day];
ans[day] = i + 1;
if (score() < nowscore)
ans[day] = tmp;
else
nowscore = score();
}
}
int main() {
memset(last, -1, sizeof(last));
cin >> d;
REP(i, 26) cin >> c[i];
REP(i, d) REP(j, 26) cin >> s[i][j];
REP(day, d) {
int idx, mx = -INF;
REP(i, 26) {
int A = c[i] * (day - last[i]) + s[day][i];
if (mx < A)
mx = A, idx = i;
}
ans[day] = idx + 1, last[idx] = day;
}
REP(_, 90) {
REP(__, 100) swap();
REP(__, 100) onechange();
}
FIN(0);
}
| #include <bits/stdc++.h>
using namespace std;
int d, ans[365], c[26], s[365][26], last[26], tlast[26];
const int INF = 1e9;
#define REP(i, n) for (int i = 0; i < n; i++)
void FIN(int a) {
if (a) {
ofstream fout("output.txt");
REP(i, d) fout << ans[i] << "\n";
fout.close();
return;
}
REP(i, d) cout << ans[i] << "\n";
return;
}
int score() {
int res = 0;
memset(tlast, -1, sizeof(tlast));
REP(day, d) {
res += s[day][ans[day] - 1];
tlast[ans[day] - 1] = day;
REP(i, 26) res -= c[i] * (day - tlast[i]);
}
return res;
}
void swap() {
int day = rand() % 362, diff = rand() % 3, nowscore = score();
swap(ans[day], ans[day + diff]);
if (score() < nowscore)
swap(ans[day], ans[day + diff]);
}
void onechange() {
int day = rand() % 365, nowscore = score();
REP(i, 26) {
int tmp = ans[day];
ans[day] = i + 1;
if (score() < nowscore)
ans[day] = tmp;
else
nowscore = score();
}
}
int main() {
memset(last, -1, sizeof(last));
cin >> d;
REP(i, 26) cin >> c[i];
REP(i, d) REP(j, 26) cin >> s[i][j];
REP(day, d) {
int idx, mx = -INF;
REP(i, 26) {
int A = c[i] * (day - last[i]) + s[day][i];
if (mx < A)
mx = A, idx = i;
}
ans[day] = idx + 1, last[idx] = day;
}
REP(_, 80) {
REP(__, 100) swap();
REP(__, 100) onechange();
}
FIN(0);
}
| replace | 61 | 62 | 61 | 62 | TLE | |
p02618 | C++ | Runtime Error | /*/ Author: kal013 /*/
/*/ Author: kal013 /*/
// #pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace std;
using namespace __gnu_pbds;
template <class T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <class key, class value, class cmp = std::less<key>>
using ordered_map =
tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k) returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;
struct custom_hash { // Credits: https://codeforces.com/blog/entry/62393
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);
}
};
template <class T> ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V)
os << v << " ";
return os << "]";
}
template <class T> ostream &operator<<(ostream &os, set<T> S) {
os << "{ ";
for (auto s : S)
os << s << " ";
return os << "}";
}
template <class T> ostream &operator<<(ostream &os, unordered_set<T> S) {
os << "{ ";
for (auto s : S)
os << s << " ";
return os << "}";
}
template <class T> ostream &operator<<(ostream &os, multiset<T> S) {
os << "{ ";
for (auto s : S)
os << s << " ";
return os << "}";
}
template <class T> ostream &operator<<(ostream &os, ordered_set<T> S) {
os << "{ ";
for (auto s : S)
os << s << " ";
return os << "}";
}
template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class L, class R> ostream &operator<<(ostream &os, map<L, R> M) {
os << "{ ";
for (auto m : M)
os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, unordered_map<L, R> M) {
os << "{ ";
for (auto m : M)
os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
template <class L, class R, class chash = std::hash<R>>
ostream &operator<<(ostream &os, gp_hash_table<L, R, chash> M) {
os << "{ ";
for (auto m : M)
os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...) 1
#endif
mt19937_64 random_number_generator(
chrono::steady_clock::now().time_since_epoch().count());
inline int64_t random_long(long long l, long long r) {
uniform_int_distribution<int64_t> generator(l, r);
return generator(random_number_generator);
}
inline int64_t random_long() {
uniform_int_distribution<int64_t> generator(LLONG_MIN, LLONG_MAX);
return generator(random_number_generator);
}
/*/---------------------------Defines----------------------/*/
typedef vector<int> vi;
typedef pair<int, int> pii;
#define ll long long
#define F first
#define S second
#define pb push_back
#define endl "\n"
#define all(v) (v).begin(), (v).end()
/*/-----------------------Modular Arithmetic---------------/*/
const int mod = 1e9 + 7;
inline int add(int x, int y) {
x += y;
if (x >= mod)
return x - mod;
return x;
}
inline int sub(int x, int y) {
x -= y;
if (x < 0)
return x + mod;
return x;
}
inline int mul(int x, int y) { return (x * 1ll * y) % mod; }
inline int power(int x, int y) {
int ans = 1;
while (y) {
if (y & 1)
ans = mul(ans, x);
x = mul(x, x);
y >>= 1;
}
return ans;
}
inline int inv(int x) { return power(x, mod - 2); }
/*/-----------------------------Code begins----------------------------------/*/
struct contest_scheduling {
int D;
int c[26];
long long satisfaction;
vector<int> s[26];
set<int> last_occur[26];
vector<int> curr_t;
friend istream &operator>>(istream &is, contest_scheduling &p) {
is >> p.D;
for (int i = 0; i < 26; ++i) {
p.s[i].resize(p.D, 0);
is >> p.c[i];
}
for (int i = 0; i < p.D; ++i) {
for (int j = 0; j < 26; ++j) {
is >> p.s[j][i];
}
}
return is;
}
void calculate_whole(const vector<int> &t) {
assert(t.size() == D);
for (int i = 0; i < 26; ++i) {
last_occur[i].clear();
last_occur[i].insert(-1);
}
satisfaction = 0;
curr_t.resize(D);
for (int i = 0; i < D; ++i) {
int type = t[i] - 1;
curr_t[i] = type;
satisfaction += s[type][i];
last_occur[type].insert(i);
for (int j = 0; j < 26; ++j) {
satisfaction -= c[j] * (i - (*last_occur[j].rbegin()));
}
// cout<<satisfaction<<endl;
}
}
inline int get_next_day(int day, int type) {
auto it = last_occur[type].upper_bound(day);
if (it == last_occur[type].end())
return D;
return (*it);
}
inline int get_prev_day(int day, int type) {
auto it = last_occur[type].lower_bound(day);
if (it == last_occur[type].begin())
return -1;
--it;
return (*it);
}
inline long long difference_values(int day, int type) {
int next_day = get_next_day(day, type);
int prev_day = get_prev_day(day, type);
return c[type] * (day - prev_day) * (next_day - day);
}
void improve_day(int day, int type) {
if (curr_t[day] == type)
return;
ll prev_satisfaction = satisfaction;
satisfaction -= s[curr_t[day]][day];
satisfaction += s[type][day];
satisfaction -= difference_values(day, curr_t[day]);
satisfaction += difference_values(day, type);
if (satisfaction <= prev_satisfaction) {
satisfaction = prev_satisfaction;
return;
}
last_occur[curr_t[day]].erase(day);
last_occur[type].insert(day);
curr_t[day] = type;
}
};
void solve() {
contest_scheduling U;
auto start = std::chrono::high_resolution_clock::now();
cin >> U;
int D = U.D;
vector<int> t(D);
for (int i = 0; i < D; ++i) {
t[i] = random_long(0, 25);
}
U.calculate_whole(t);
auto stop = std::chrono::high_resolution_clock::now();
auto duration =
std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);
ll time_limit = (ll)(1.5e9);
while (duration.count() < time_limit) {
int d_change = random_long(0, D - 1);
int type = random_long(0, 25);
U.improve_day(d_change, type);
stop = std::chrono::high_resolution_clock::now();
duration =
std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);
}
for (auto e : U.curr_t) {
cout << e + 1 << "\n";
}
}
int main() {
// Use "set_name".max_load_factor(0.25);"set_name".reserve(512); with
// unordered set Or use gp_hash_table<X,null_type>
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(25);
cerr << fixed << setprecision(10);
auto start = std::chrono::high_resolution_clock::now();
int t = 1;
// cin>>t;
while (t--) {
solve();
}
auto stop = std::chrono::high_resolution_clock::now();
auto duration =
std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);
// cerr << "Time taken : " << ((long double)duration.count())/((long double)
// 1e9) <<"s "<< endl;
}
| /*/ Author: kal013 /*/
/*/ Author: kal013 /*/
// #pragma GCC optimize ("O3")
#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace std;
using namespace __gnu_pbds;
template <class T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <class key, class value, class cmp = std::less<key>>
using ordered_map =
tree<key, value, cmp, rb_tree_tag, tree_order_statistics_node_update>;
// find_by_order(k) returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;
struct custom_hash { // Credits: https://codeforces.com/blog/entry/62393
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);
}
};
template <class T> ostream &operator<<(ostream &os, vector<T> V) {
os << "[ ";
for (auto v : V)
os << v << " ";
return os << "]";
}
template <class T> ostream &operator<<(ostream &os, set<T> S) {
os << "{ ";
for (auto s : S)
os << s << " ";
return os << "}";
}
template <class T> ostream &operator<<(ostream &os, unordered_set<T> S) {
os << "{ ";
for (auto s : S)
os << s << " ";
return os << "}";
}
template <class T> ostream &operator<<(ostream &os, multiset<T> S) {
os << "{ ";
for (auto s : S)
os << s << " ";
return os << "}";
}
template <class T> ostream &operator<<(ostream &os, ordered_set<T> S) {
os << "{ ";
for (auto s : S)
os << s << " ";
return os << "}";
}
template <class L, class R> ostream &operator<<(ostream &os, pair<L, R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template <class L, class R> ostream &operator<<(ostream &os, map<L, R> M) {
os << "{ ";
for (auto m : M)
os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
template <class L, class R>
ostream &operator<<(ostream &os, unordered_map<L, R> M) {
os << "{ ";
for (auto m : M)
os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
template <class L, class R, class chash = std::hash<R>>
ostream &operator<<(ostream &os, gp_hash_table<L, R, chash> M) {
os << "{ ";
for (auto m : M)
os << "(" << m.first << ":" << m.second << ") ";
return os << "}";
}
#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1> void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char *names, Arg1 &&arg1, Args &&...args) {
const char *comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
#else
#define trace(...) 1
#endif
mt19937_64 random_number_generator(
chrono::steady_clock::now().time_since_epoch().count());
inline int64_t random_long(long long l, long long r) {
uniform_int_distribution<int64_t> generator(l, r);
return generator(random_number_generator);
}
inline int64_t random_long() {
uniform_int_distribution<int64_t> generator(LLONG_MIN, LLONG_MAX);
return generator(random_number_generator);
}
/*/---------------------------Defines----------------------/*/
typedef vector<int> vi;
typedef pair<int, int> pii;
#define ll long long
#define F first
#define S second
#define pb push_back
#define endl "\n"
#define all(v) (v).begin(), (v).end()
/*/-----------------------Modular Arithmetic---------------/*/
const int mod = 1e9 + 7;
inline int add(int x, int y) {
x += y;
if (x >= mod)
return x - mod;
return x;
}
inline int sub(int x, int y) {
x -= y;
if (x < 0)
return x + mod;
return x;
}
inline int mul(int x, int y) { return (x * 1ll * y) % mod; }
inline int power(int x, int y) {
int ans = 1;
while (y) {
if (y & 1)
ans = mul(ans, x);
x = mul(x, x);
y >>= 1;
}
return ans;
}
inline int inv(int x) { return power(x, mod - 2); }
/*/-----------------------------Code begins----------------------------------/*/
struct contest_scheduling {
int D;
int c[26];
long long satisfaction;
vector<int> s[26];
set<int> last_occur[26];
vector<int> curr_t;
friend istream &operator>>(istream &is, contest_scheduling &p) {
is >> p.D;
for (int i = 0; i < 26; ++i) {
p.s[i].resize(p.D, 0);
is >> p.c[i];
}
for (int i = 0; i < p.D; ++i) {
for (int j = 0; j < 26; ++j) {
is >> p.s[j][i];
}
}
return is;
}
void calculate_whole(const vector<int> &t) {
assert(t.size() == D);
for (int i = 0; i < 26; ++i) {
last_occur[i].clear();
last_occur[i].insert(-1);
}
satisfaction = 0;
curr_t.resize(D);
for (int i = 0; i < D; ++i) {
int type = t[i];
curr_t[i] = type;
satisfaction += s[type][i];
last_occur[type].insert(i);
for (int j = 0; j < 26; ++j) {
satisfaction -= c[j] * (i - (*last_occur[j].rbegin()));
}
// cout<<satisfaction<<endl;
}
}
inline int get_next_day(int day, int type) {
auto it = last_occur[type].upper_bound(day);
if (it == last_occur[type].end())
return D;
return (*it);
}
inline int get_prev_day(int day, int type) {
auto it = last_occur[type].lower_bound(day);
if (it == last_occur[type].begin())
return -1;
--it;
return (*it);
}
inline long long difference_values(int day, int type) {
int next_day = get_next_day(day, type);
int prev_day = get_prev_day(day, type);
return c[type] * (day - prev_day) * (next_day - day);
}
void improve_day(int day, int type) {
if (curr_t[day] == type)
return;
ll prev_satisfaction = satisfaction;
satisfaction -= s[curr_t[day]][day];
satisfaction += s[type][day];
satisfaction -= difference_values(day, curr_t[day]);
satisfaction += difference_values(day, type);
if (satisfaction <= prev_satisfaction) {
satisfaction = prev_satisfaction;
return;
}
last_occur[curr_t[day]].erase(day);
last_occur[type].insert(day);
curr_t[day] = type;
}
};
void solve() {
contest_scheduling U;
auto start = std::chrono::high_resolution_clock::now();
cin >> U;
int D = U.D;
vector<int> t(D);
for (int i = 0; i < D; ++i) {
t[i] = random_long(0, 25);
}
U.calculate_whole(t);
auto stop = std::chrono::high_resolution_clock::now();
auto duration =
std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);
ll time_limit = (ll)(1.5e9);
while (duration.count() < time_limit) {
int d_change = random_long(0, D - 1);
int type = random_long(0, 25);
U.improve_day(d_change, type);
stop = std::chrono::high_resolution_clock::now();
duration =
std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);
}
for (auto e : U.curr_t) {
cout << e + 1 << "\n";
}
}
int main() {
// Use "set_name".max_load_factor(0.25);"set_name".reserve(512); with
// unordered set Or use gp_hash_table<X,null_type>
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed << setprecision(25);
cerr << fixed << setprecision(10);
auto start = std::chrono::high_resolution_clock::now();
int t = 1;
// cin>>t;
while (t--) {
solve();
}
auto stop = std::chrono::high_resolution_clock::now();
auto duration =
std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);
// cerr << "Time taken : " << ((long double)duration.count())/((long double)
// 1e9) <<"s "<< endl;
}
| replace | 195 | 196 | 195 | 196 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <bitset>
#include <chrono>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cstring>
using namespace std;
using ll = long long;
using ull = unsigned long long;
ll const MM = 1000000007;
// ll const NN = 1000000007;
#define pv(val) cerr << #val << '=' << (val) << endl
#define pl cerr << '@' << __LINE__ << endl
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define rep2(i, b, e) for (ll i = (b); i < (e); i++)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
template <class T> ostream &operator<<(ostream &os, vector<T> const &vec);
template <class T, size_t S>
ostream &operator<<(ostream &os, array<T, S> const &arr);
template <class T, class U>
ostream &operator<<(ostream &os, pair<T, U> const &p);
template <class... Args>
ostream &operator<<(ostream &os, tuple<Args...> const &t);
template <class T> ostream &operator<<(ostream &os, vector<T> const &vec) {
if (vec.empty()) {
os << "{}";
} else {
os << '{';
for (size_t i = 0; i < vec.size() - 1; i++)
os << vec[i] << ", ";
os << vec.back() << '}';
}
return os;
}
template <class T, size_t S>
ostream &operator<<(ostream &os, array<T, S> const &arr) {
if (arr.empty()) {
os << "{}";
} else {
os << '{';
for (size_t i = 0; i < arr.size() - 1; i++)
os << arr[i] << ", ";
os << arr.back() << '}';
}
return os;
}
template <class T, class U>
ostream &operator<<(ostream &os, pair<T, U> const &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
template <size_t I, class... Args>
typename enable_if<sizeof...(Args) == (I + 1)>::type
print_tuple(ostream &os, tuple<Args...> const &t) {
os << get<I>(t);
}
template <size_t I, class... Args>
typename enable_if<sizeof...(Args) != (I + 1)>::type
print_tuple(ostream &os, tuple<Args...> const &t) {
os << get<I>(t) << ", ";
print_tuple<I + 1, Args...>(os, t);
}
template <class... Args>
ostream &operator<<(ostream &os, tuple<Args...> const &t) {
os << '(';
print_tuple<0, Args...>(os, t);
os << ')';
return os;
}
struct Timer {
using Clock = std::chrono::system_clock;
Clock::time_point startTime;
Timer() { start(); }
void start() { startTime = Clock::now(); }
long long milli() const {
return std::chrono::duration_cast<std::chrono::milliseconds>(Clock::now() -
startTime)
.count();
}
long long micro() const {
return std::chrono::duration_cast<std::chrono::microseconds>(Clock::now() -
startTime)
.count();
}
};
ll bound(function<bool(ll)> f, ll ng, ll ok) {
while (abs(ng - ok) > 1) {
ll mid = (ng + ok) / 2;
if (f(mid))
ok = mid;
else
ng = mid;
}
return ok;
}
ll order(vector<ll> const &r) {
vector<ll> a(r.size());
iota(all(a), 1);
ll ord = 0;
while (a != r) {
next_permutation(all(a));
ord++;
}
return ord;
}
ll div(ll n) {
ll ans = 0;
while (n > 0) {
ans++;
n /= 2;
}
return ans;
}
// value, weight
ll knapsack(vector<pair<ll, ll>> const &a, ll max_w) {
ll max_n = a.size();
vector<ll> table(max_w + 1, 0);
for (int i = 1; i <= max_n; ++i) {
ll v = a[i].first;
ll w = a[i].second;
if (w <= max_w && table[w] < v)
table[w] = v;
for (int j = 1; j <= max_w - w; j++) {
if (table[j] != 0 && table[w + j] < table[j] + v)
table[w + j] = table[j] + v;
}
}
return *max_element(all(table));
}
ll llpow(ll n, ll m) {
ll ans = 1;
rep(i, m) {
ans *= n;
ans %= MM;
}
return ans;
}
Timer gTimer;
ll D;
array<ll, 26> c;
array<array<ll, 26>, 365> s;
ll score(array<ll, 365> const &ans) {
ll sc = 0;
array<ll, 26> last = {};
rep(d, 365) {
last[ans[d]] = d + 1;
rep(i, 26) sc -= c[i] * (d + 1 - last[i]);
sc += s[d][ans[d]];
}
return sc;
}
ll scoreDiff(array<ll, 365> const &ans, ll i) {
ll sc = 0;
ll last = 0;
rep(d, 365) {
if (ans[d] == i) {
last = d + 1;
sc += s[d][i];
}
sc -= c[i] * (d + 1 - last);
}
return sc;
}
int main(void) {
array<ll, 365> ans;
cin >> D;
rep(i, 26) cin >> c[i];
rep(d, 365) rep(i, 26) cin >> s[d][i];
uniform_int_distribution<ll> dist26(0, 25);
uniform_real_distribution<double> dist01(0.0, 1.0);
mt19937 mt;
rep(d, 365) ans[d] = distance(s[d].begin(), max_element(all(s[d])));
ll currentScore = score(ans);
auto bestAns = ans;
ll bestScore = currentScore;
ll timeLimit = 10 * 1950;
ll nIters = 0;
while (true) {
rep(d, 365) {
rep(i, 26) {
ll const timeMicro = gTimer.micro();
if (timeMicro >= timeLimit * 1000)
goto NEXT;
double const prog = timeMicro / (timeLimit * 1000.0);
if (s[d][i] <= 15000)
continue;
ll prev = ans[d];
ll a0 = scoreDiff(ans, prev);
ll b0 = scoreDiff(ans, i);
ans[d] = i;
ll a1 = scoreDiff(ans, prev);
ll b1 = scoreDiff(ans, i);
ll nextScore = currentScore - (a0 + b0) + (a1 + b1);
double const progg = 1.0 - prog;
++nIters;
if (nextScore > currentScore ||
exp((nextScore - currentScore) / (1000.0 * progg)) > dist01(mt)) {
if (nextScore > bestScore) {
bestScore = nextScore;
bestAns = ans;
}
currentScore = nextScore;
} else {
ans[d] = prev;
}
}
}
}
NEXT:
ans = bestAns;
currentScore = bestScore;
pv(nIters);
pl;
/*
for(double temp = 10.0; temp > 0.01; temp *= 0.80){
rep(d0, 365) {
rep2(d1, d0 + 1, 365) {
rep(i, 26) {
if(gTimer.milli() >= 2 * timeLimit)
goto END;
if(ans[d0] == ans[d1])
continue;
ll a0 = scoreDiff(ans, ans[d0]);
ll b0 = scoreDiff(ans, ans[d1]);
swap(ans[d0], ans[d1]);
ll a1 = scoreDiff(ans, ans[d0]);
ll b1 = scoreDiff(ans, ans[d1]);
ll nextScore = currentScore - (a0 + b0) + (a1 + b1);
if (nextScore > currentScore || exp((nextScore -
currentScore) / temp) > dist01(mt)) { if(nextScore > bestScore){ bestScore
= nextScore; bestAns = ans; pv(bestScore);
}
currentScore = nextScore;
} else {
swap(ans[d0], ans[d1]);
}
}
}
}
}
*/
END:
rep(d, 365) cout << bestAns[d] + 1 << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <chrono>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cstring>
using namespace std;
using ll = long long;
using ull = unsigned long long;
ll const MM = 1000000007;
// ll const NN = 1000000007;
#define pv(val) cerr << #val << '=' << (val) << endl
#define pl cerr << '@' << __LINE__ << endl
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define rep2(i, b, e) for (ll i = (b); i < (e); i++)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
template <class T> ostream &operator<<(ostream &os, vector<T> const &vec);
template <class T, size_t S>
ostream &operator<<(ostream &os, array<T, S> const &arr);
template <class T, class U>
ostream &operator<<(ostream &os, pair<T, U> const &p);
template <class... Args>
ostream &operator<<(ostream &os, tuple<Args...> const &t);
template <class T> ostream &operator<<(ostream &os, vector<T> const &vec) {
if (vec.empty()) {
os << "{}";
} else {
os << '{';
for (size_t i = 0; i < vec.size() - 1; i++)
os << vec[i] << ", ";
os << vec.back() << '}';
}
return os;
}
template <class T, size_t S>
ostream &operator<<(ostream &os, array<T, S> const &arr) {
if (arr.empty()) {
os << "{}";
} else {
os << '{';
for (size_t i = 0; i < arr.size() - 1; i++)
os << arr[i] << ", ";
os << arr.back() << '}';
}
return os;
}
template <class T, class U>
ostream &operator<<(ostream &os, pair<T, U> const &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
template <size_t I, class... Args>
typename enable_if<sizeof...(Args) == (I + 1)>::type
print_tuple(ostream &os, tuple<Args...> const &t) {
os << get<I>(t);
}
template <size_t I, class... Args>
typename enable_if<sizeof...(Args) != (I + 1)>::type
print_tuple(ostream &os, tuple<Args...> const &t) {
os << get<I>(t) << ", ";
print_tuple<I + 1, Args...>(os, t);
}
template <class... Args>
ostream &operator<<(ostream &os, tuple<Args...> const &t) {
os << '(';
print_tuple<0, Args...>(os, t);
os << ')';
return os;
}
struct Timer {
using Clock = std::chrono::system_clock;
Clock::time_point startTime;
Timer() { start(); }
void start() { startTime = Clock::now(); }
long long milli() const {
return std::chrono::duration_cast<std::chrono::milliseconds>(Clock::now() -
startTime)
.count();
}
long long micro() const {
return std::chrono::duration_cast<std::chrono::microseconds>(Clock::now() -
startTime)
.count();
}
};
ll bound(function<bool(ll)> f, ll ng, ll ok) {
while (abs(ng - ok) > 1) {
ll mid = (ng + ok) / 2;
if (f(mid))
ok = mid;
else
ng = mid;
}
return ok;
}
ll order(vector<ll> const &r) {
vector<ll> a(r.size());
iota(all(a), 1);
ll ord = 0;
while (a != r) {
next_permutation(all(a));
ord++;
}
return ord;
}
ll div(ll n) {
ll ans = 0;
while (n > 0) {
ans++;
n /= 2;
}
return ans;
}
// value, weight
ll knapsack(vector<pair<ll, ll>> const &a, ll max_w) {
ll max_n = a.size();
vector<ll> table(max_w + 1, 0);
for (int i = 1; i <= max_n; ++i) {
ll v = a[i].first;
ll w = a[i].second;
if (w <= max_w && table[w] < v)
table[w] = v;
for (int j = 1; j <= max_w - w; j++) {
if (table[j] != 0 && table[w + j] < table[j] + v)
table[w + j] = table[j] + v;
}
}
return *max_element(all(table));
}
ll llpow(ll n, ll m) {
ll ans = 1;
rep(i, m) {
ans *= n;
ans %= MM;
}
return ans;
}
Timer gTimer;
ll D;
array<ll, 26> c;
array<array<ll, 26>, 365> s;
ll score(array<ll, 365> const &ans) {
ll sc = 0;
array<ll, 26> last = {};
rep(d, 365) {
last[ans[d]] = d + 1;
rep(i, 26) sc -= c[i] * (d + 1 - last[i]);
sc += s[d][ans[d]];
}
return sc;
}
ll scoreDiff(array<ll, 365> const &ans, ll i) {
ll sc = 0;
ll last = 0;
rep(d, 365) {
if (ans[d] == i) {
last = d + 1;
sc += s[d][i];
}
sc -= c[i] * (d + 1 - last);
}
return sc;
}
int main(void) {
array<ll, 365> ans;
cin >> D;
rep(i, 26) cin >> c[i];
rep(d, 365) rep(i, 26) cin >> s[d][i];
uniform_int_distribution<ll> dist26(0, 25);
uniform_real_distribution<double> dist01(0.0, 1.0);
mt19937 mt;
rep(d, 365) ans[d] = distance(s[d].begin(), max_element(all(s[d])));
ll currentScore = score(ans);
auto bestAns = ans;
ll bestScore = currentScore;
ll timeLimit = 1950;
ll nIters = 0;
while (true) {
rep(d, 365) {
rep(i, 26) {
ll const timeMicro = gTimer.micro();
if (timeMicro >= timeLimit * 1000)
goto NEXT;
double const prog = timeMicro / (timeLimit * 1000.0);
if (s[d][i] <= 15000)
continue;
ll prev = ans[d];
ll a0 = scoreDiff(ans, prev);
ll b0 = scoreDiff(ans, i);
ans[d] = i;
ll a1 = scoreDiff(ans, prev);
ll b1 = scoreDiff(ans, i);
ll nextScore = currentScore - (a0 + b0) + (a1 + b1);
double const progg = 1.0 - prog;
++nIters;
if (nextScore > currentScore ||
exp((nextScore - currentScore) / (1000.0 * progg)) > dist01(mt)) {
if (nextScore > bestScore) {
bestScore = nextScore;
bestAns = ans;
}
currentScore = nextScore;
} else {
ans[d] = prev;
}
}
}
}
NEXT:
ans = bestAns;
currentScore = bestScore;
pv(nIters);
pl;
/*
for(double temp = 10.0; temp > 0.01; temp *= 0.80){
rep(d0, 365) {
rep2(d1, d0 + 1, 365) {
rep(i, 26) {
if(gTimer.milli() >= 2 * timeLimit)
goto END;
if(ans[d0] == ans[d1])
continue;
ll a0 = scoreDiff(ans, ans[d0]);
ll b0 = scoreDiff(ans, ans[d1]);
swap(ans[d0], ans[d1]);
ll a1 = scoreDiff(ans, ans[d0]);
ll b1 = scoreDiff(ans, ans[d1]);
ll nextScore = currentScore - (a0 + b0) + (a1 + b1);
if (nextScore > currentScore || exp((nextScore -
currentScore) / temp) > dist01(mt)) { if(nextScore > bestScore){ bestScore
= nextScore; bestAns = ans; pv(bestScore);
}
currentScore = nextScore;
} else {
swap(ans[d0], ans[d1]);
}
}
}
}
}
*/
END:
rep(d, 365) cout << bestAns[d] + 1 << endl;
return 0;
}
| replace | 227 | 228 | 227 | 228 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (ll i = (a); i < (b); i++)
#define REP(i, n) rep(i, 0, n)
int cd = 350000;
int d, c[26], s[366][26];
int t[366];
ll r;
void init() {
cin >> d;
REP(i, 26) cin >> c[i];
REP(i, d) REP(j, 26) cin >> s[i][j];
}
void greedy() { REP(i, d) REP(j, 26) t[i] = s[i][j] > s[i][t[i]] ? j : t[i]; }
ll score(int *t) {
ll ans = 0;
vector<int> cnt(26, 0);
REP(i, d) {
cnt[t[i]] = -1;
ans += s[i][t[i]];
REP(j, 26) cnt[j]++, ans -= cnt[j] * c[j];
}
return ans;
}
void crt_new() {
int idx = rand() % d;
int q = rand() % 26;
while (q == t[idx])
q = rand() % 26;
int tmp = t[idx];
t[idx] = q;
ll res = score(t);
if (res > r)
r = res;
else
t[idx] = tmp;
}
void solve() {
init();
// ll begin_t=clock();
greedy();
r = score(t);
while (cd--)
crt_new();
// REP(i,d)cout<<t[i]<<" ";cout<<endl;
REP(i, d) cout << t[i] + 1 << endl;
// cout<<r<<endl;
// ll end_t=clock();cout<<end_t-begin_t<<"ms"<<endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, a, b) for (ll i = (a); i < (b); i++)
#define REP(i, n) rep(i, 0, n)
int cd = 20000;
int d, c[26], s[366][26];
int t[366];
ll r;
void init() {
cin >> d;
REP(i, 26) cin >> c[i];
REP(i, d) REP(j, 26) cin >> s[i][j];
}
void greedy() { REP(i, d) REP(j, 26) t[i] = s[i][j] > s[i][t[i]] ? j : t[i]; }
ll score(int *t) {
ll ans = 0;
vector<int> cnt(26, 0);
REP(i, d) {
cnt[t[i]] = -1;
ans += s[i][t[i]];
REP(j, 26) cnt[j]++, ans -= cnt[j] * c[j];
}
return ans;
}
void crt_new() {
int idx = rand() % d;
int q = rand() % 26;
while (q == t[idx])
q = rand() % 26;
int tmp = t[idx];
t[idx] = q;
ll res = score(t);
if (res > r)
r = res;
else
t[idx] = tmp;
}
void solve() {
init();
// ll begin_t=clock();
greedy();
r = score(t);
while (cd--)
crt_new();
// REP(i,d)cout<<t[i]<<" ";cout<<endl;
REP(i, d) cout << t[i] + 1 << endl;
// cout<<r<<endl;
// ll end_t=clock();cout<<end_t-begin_t<<"ms"<<endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
} | replace | 6 | 7 | 6 | 7 | TLE | |
p02618 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstring>
#include <ctime> //時間を測ります
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random> //乱択します
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
#define TIMELIMIT 1.95
#define SA_COEFF 10000
#define START_TEMP 50
#define END_TEMP 1
inline unsigned long long rdtsc() {
#ifdef __amd64
unsigned long long a, d;
__asm__ volatile("rdtsc" : "=a"(a), "=d"(d));
return (d << 32) | a;
#else
unsigned long long x;
__asm__ volatile("rdtsc" : "=A"(x));
return x;
#endif
}
inline double gettime() { return rdtsc() / 2793344000.0; }
inline double elapsed(double st) { return gettime() - st; }
static unsigned long rand_x = 123456789, rand_y = 362436069, rand_z = 521288629,
rand_w = 88675123;
std::random_device rnd{};
void init_randxor() {
unsigned long s = rnd();
rand_w ^= s;
rand_w ^= rand_w >> 21;
rand_w ^= rand_w << 35;
rand_w ^= rand_w >> 4;
rand_w *= 2685821657736338717LL;
}
inline unsigned int randxor() {
unsigned int t;
t = (rand_x ^ (rand_x << 11));
rand_x = rand_y;
rand_y = rand_z;
rand_z = rand_w;
return (rand_w = (rand_w ^ (rand_w >> 19)) ^ (t ^ (t >> 8)));
}
struct ANSTYPE {
vector<int> t;
};
// **** write variable here ****
int d;
int n = 26;
vector<int> c(26);
vector<vector<int>> s;
// *****************************
void input() {
cin >> d;
for (int i = 0; i < 26; i++)
cin >> c[i];
s = vector<vector<int>>(d, vector<int>(26));
for (int i = 0; i < d; i++)
for (int j = 0; j < 26; j++)
cin >> s[i][j];
}
ANSTYPE ans;
void output() {
for (int i = 0; i < d; i++)
cout << ans.t[i] << endl;
}
void init() {
// ans=
ans.t = vector<int>(d);
for (int i = 0; i < d; i++)
ans.t[i] = i % 26 + 1;
}
int value(ANSTYPE &in_ans) {
int point = 0;
vector<int> bef(26, 0);
for (int i = 0; i < d; i++) {
int now = in_ans.t[i];
point += s[i][now];
bef[now] = i + 1;
for (int j = 0; j < n; j++)
point -= (c[j] * (i + 1 - bef[j]));
}
return point;
}
int next(ANSTYPE &in_ans, int bef_score) {
int bef = 0;
int aft = 0;
return bef_score + (aft - bef);
}
void SA() {
double st = gettime();
double now_time;
bool FORCE_NEXT;
double probability;
double temp;
init();
ANSTYPE now_ans = ans;
ANSTYPE best_ans = now_ans;
ANSTYPE next_ans;
int best_score = value(ans);
int next_score = 0;
int now_score = best_score;
int cnt = 0;
int bad_cnt = 0;
while (elapsed(st) < TIMELIMIT) {
cnt++;
next_ans = now_ans;
next_score = next(next_ans, now_score);
now_time = elapsed(st);
temp = START_TEMP +
(END_TEMP - START_TEMP) * now_time / (TIMELIMIT); // 現在温度
probability = exp((next_score - now_score) / temp);
FORCE_NEXT = (probability > (double(randxor() % 100100) / 100100));
// FORCE_NEXT = false;
if (next_score > now_score or (FORCE_NEXT and next_score > 0)) {
if (next_score < now_score)
bad_cnt++;
now_score = next_score;
now_ans = next_ans;
}
if (now_score > best_score) {
best_score = now_score;
best_ans = now_ans;
}
// cerr << best_score << " : " << next_score << endl;;
}
ans = best_ans;
// cerr << "loop \t: " << cnt << endl;
// cerr << "bad use\t: " << bad_cnt << endl;
// cerr << "score \t: " << value(ans) << endl;
}
void solve() { SA(); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
init_randxor();
input();
solve();
output();
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstring>
#include <ctime> //時間を測ります
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random> //乱択します
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
#define TIMELIMIT 1.95
#define SA_COEFF 10000
#define START_TEMP 50
#define END_TEMP 1
inline unsigned long long rdtsc() {
#ifdef __amd64
unsigned long long a, d;
__asm__ volatile("rdtsc" : "=a"(a), "=d"(d));
return (d << 32) | a;
#else
unsigned long long x;
__asm__ volatile("rdtsc" : "=A"(x));
return x;
#endif
}
inline double gettime() { return rdtsc() / 2793344000.0; }
inline double elapsed(double st) { return gettime() - st; }
static unsigned long rand_x = 123456789, rand_y = 362436069, rand_z = 521288629,
rand_w = 88675123;
std::random_device rnd{};
void init_randxor() {
unsigned long s = rnd();
rand_w ^= s;
rand_w ^= rand_w >> 21;
rand_w ^= rand_w << 35;
rand_w ^= rand_w >> 4;
rand_w *= 2685821657736338717LL;
}
inline unsigned int randxor() {
unsigned int t;
t = (rand_x ^ (rand_x << 11));
rand_x = rand_y;
rand_y = rand_z;
rand_z = rand_w;
return (rand_w = (rand_w ^ (rand_w >> 19)) ^ (t ^ (t >> 8)));
}
struct ANSTYPE {
vector<int> t;
};
// **** write variable here ****
int d;
int n = 26;
vector<int> c(26);
vector<vector<int>> s;
// *****************************
void input() {
cin >> d;
for (int i = 0; i < 26; i++)
cin >> c[i];
s = vector<vector<int>>(d, vector<int>(26));
for (int i = 0; i < d; i++)
for (int j = 0; j < 26; j++)
cin >> s[i][j];
}
ANSTYPE ans;
void output() {
for (int i = 0; i < d; i++)
cout << ans.t[i] << endl;
}
void init() {
// ans=
ans.t = vector<int>(d);
for (int i = 0; i < d; i++)
ans.t[i] = i % 26 + 1;
}
int value(ANSTYPE &in_ans) {
int point = 0;
return point;
}
int next(ANSTYPE &in_ans, int bef_score) {
int bef = 0;
int aft = 0;
return bef_score + (aft - bef);
}
void SA() {
double st = gettime();
double now_time;
bool FORCE_NEXT;
double probability;
double temp;
init();
ANSTYPE now_ans = ans;
ANSTYPE best_ans = now_ans;
ANSTYPE next_ans;
int best_score = value(ans);
int next_score = 0;
int now_score = best_score;
int cnt = 0;
int bad_cnt = 0;
while (elapsed(st) < TIMELIMIT) {
cnt++;
next_ans = now_ans;
next_score = next(next_ans, now_score);
now_time = elapsed(st);
temp = START_TEMP +
(END_TEMP - START_TEMP) * now_time / (TIMELIMIT); // 現在温度
probability = exp((next_score - now_score) / temp);
FORCE_NEXT = (probability > (double(randxor() % 100100) / 100100));
// FORCE_NEXT = false;
if (next_score > now_score or (FORCE_NEXT and next_score > 0)) {
if (next_score < now_score)
bad_cnt++;
now_score = next_score;
now_ans = next_ans;
}
if (now_score > best_score) {
best_score = now_score;
best_ans = now_ans;
}
// cerr << best_score << " : " << next_score << endl;;
}
ans = best_ans;
// cerr << "loop \t: " << cnt << endl;
// cerr << "bad use\t: " << bad_cnt << endl;
// cerr << "score \t: " << value(ans) << endl;
}
void solve() { SA(); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
init_randxor();
input();
solve();
output();
return 0;
}
| delete | 103 | 111 | 103 | 103 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstring>
#include <ctime> //時間を測ります
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random> //乱択します
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
#define TIMELIMIT 2.10
#define SA_COEFF 10000
#define START_TEMP 1200
#define END_TEMP 1
#define INF 1000000007
inline unsigned long long rdtsc() {
#ifdef __amd64
unsigned long long a, d;
__asm__ volatile("rdtsc" : "=a"(a), "=d"(d));
return (d << 32) | a;
#else
unsigned long long x;
__asm__ volatile("rdtsc" : "=A"(x));
return x;
#endif
}
inline double gettime() { return rdtsc() / 2793344000.0; }
inline double elapsed(double st) { return gettime() - st; }
static unsigned long rand_x = 123456789, rand_y = 362436069, rand_z = 521288629,
rand_w = 88675123;
std::random_device rnd{};
void init_randxor() {
unsigned long s = rnd();
rand_w ^= s;
rand_w ^= rand_w >> 21;
rand_w ^= rand_w << 35;
rand_w ^= rand_w >> 4;
rand_w *= 2685821657736338717LL;
}
inline unsigned int randxor() {
unsigned int t;
t = (rand_x ^ (rand_x << 11));
rand_x = rand_y;
rand_y = rand_z;
rand_z = rand_w;
return (rand_w = (rand_w ^ (rand_w >> 19)) ^ (t ^ (t >> 8)));
}
struct ANSTYPE {
vector<int> t;
};
// **** write variable here ****
int d;
int n = 26;
vector<int> c(26);
vector<vector<int>> s;
vector<int> mx;
// *****************************
void input() {
cin >> d;
for (int i = 0; i < 26; i++)
cin >> c[i];
s = vector<vector<int>>(d, vector<int>(26));
mx = vector<int>(d);
for (int i = 0; i < d; i++) {
int mxx = 0;
for (int j = 0; j < 26; j++) {
cin >> s[i][j];
if (s[i][j] > mxx) {
mxx = s[i][j];
mx[i] = j;
}
}
}
}
ANSTYPE ans;
void output() {
for (int i = 0; i < d; i++)
cout << ans.t[i] + 1 << endl;
}
void init() {
// ans=
ans.t = vector<int>(d);
for (int i = 0; i < d; i++)
ans.t[i] = i % 26;
vector<int> bef(26, 0);
for (int i = 0; i < d; i++) {
int nx = -1;
int mx = (-1) * INF;
for (int j = 0; j < n; j++) {
int now = s[i][j];
for (int k = 0; k < n; k++) {
if (j == k)
continue;
now -= (c[k] * (i + 1 - bef[k]));
}
if (mx < now) {
mx = now;
nx = j;
}
}
bef[nx] = i + 1;
ans.t[i] = nx;
}
}
long long value(ANSTYPE &in_ans) {
long long point = 0;
vector<int> bef(26, 0);
for (int i = 0; i < d; i++) {
int now = in_ans.t[i];
point += s[i][now];
bef[now] = i + 1;
for (int j = 0; j < n; j++)
point -= (c[j] * (i + 1 - bef[j]));
}
return point;
}
int next(ANSTYPE &in_ans, int bef_score) {
int bef = 0;
int aft = 0;
in_ans.t[randxor() % d] = randxor() % n;
return value(in_ans);
return bef_score + (aft - bef);
}
int next2(ANSTYPE &in_ans, int bef_score) {
int x = randxor() % (d - 1);
int xx = in_ans.t[x];
in_ans.t[x] = in_ans.t[x + 1];
in_ans.t[x + 1] = xx;
return value(in_ans);
}
int next3(ANSTYPE &in_ans, int bef_score) {
int x = randxor() % (d - 1);
in_ans.t[x] = mx[x];
return value(in_ans);
}
void SA() {
double st = gettime();
double now_time;
bool FORCE_NEXT;
double probability;
double temp;
init();
ANSTYPE now_ans = ans;
ANSTYPE best_ans = now_ans;
ANSTYPE next_ans;
long long best_score = value(ans);
long long next_score = 0;
long long now_score = best_score;
int cnt = 0;
int bad_cnt = 0;
// cerr << "score \t: " << value(ans) << endl;
while (elapsed(st) < TIMELIMIT) {
cnt++;
next_ans = now_ans;
if (elapsed(st) / TIMELIMIT > 2.0 / 3.0 and randxor() % 2 == 0)
next_score = next2(next_ans, now_score);
else {
if (randxor() % 4 == 0)
next_score = next3(next_ans, now_score);
else
next_score = next(next_ans, now_score);
}
now_time = elapsed(st);
temp = START_TEMP +
(END_TEMP - START_TEMP) * now_time / (TIMELIMIT); // 現在温度
probability = exp((next_score - now_score) / temp);
FORCE_NEXT = (probability > (double(randxor() % 100100) / 100100));
// FORCE_NEXT = false;
if (next_score > now_score or (FORCE_NEXT and next_score > 0)) {
if (next_score < now_score)
bad_cnt++;
now_score = next_score;
now_ans = next_ans;
}
if (now_score > best_score) {
best_score = now_score;
best_ans = now_ans;
}
// cerr << best_score << " : " << next_score << endl;;
}
ANSTYPE bef_best_ans = best_ans;
int bef_best_score = best_score;
st = gettime();
while (elapsed(st) < TIMELIMIT) {
cnt++;
next_ans = now_ans;
if (elapsed(st) / TIMELIMIT > 2.0 / 3.0 and randxor() % 2 == 0)
next_score = next2(next_ans, now_score);
else {
if (randxor() % 4 == 0)
next_score = next3(next_ans, now_score);
else
next_score = next(next_ans, now_score);
}
now_time = elapsed(st);
temp = START_TEMP +
(END_TEMP - START_TEMP) * now_time / (TIMELIMIT); // 現在温度
probability = exp((next_score - now_score) / temp);
FORCE_NEXT = (probability > (double(randxor() % 100100) / 100100));
// FORCE_NEXT = false;
if (next_score > now_score or (FORCE_NEXT and next_score > 0)) {
if (next_score < now_score)
bad_cnt++;
now_score = next_score;
now_ans = next_ans;
}
if (now_score > best_score) {
best_score = now_score;
best_ans = now_ans;
}
// cerr << best_score << " : " << next_score << endl;;
}
ans = best_ans;
if (best_score < bef_best_score)
ans = bef_best_ans;
cerr << "loop \t: " << cnt << endl;
cerr << "bad use\t: " << bad_cnt << endl;
cerr << "score \t: " << value(ans) << endl;
}
void solve() { SA(); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
init_randxor();
input();
solve();
output();
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstring>
#include <ctime> //時間を測ります
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random> //乱択します
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
using namespace std;
#define TIMELIMIT 1.05
#define SA_COEFF 10000
#define START_TEMP 1200
#define END_TEMP 1
#define INF 1000000007
inline unsigned long long rdtsc() {
#ifdef __amd64
unsigned long long a, d;
__asm__ volatile("rdtsc" : "=a"(a), "=d"(d));
return (d << 32) | a;
#else
unsigned long long x;
__asm__ volatile("rdtsc" : "=A"(x));
return x;
#endif
}
inline double gettime() { return rdtsc() / 2793344000.0; }
inline double elapsed(double st) { return gettime() - st; }
static unsigned long rand_x = 123456789, rand_y = 362436069, rand_z = 521288629,
rand_w = 88675123;
std::random_device rnd{};
void init_randxor() {
unsigned long s = rnd();
rand_w ^= s;
rand_w ^= rand_w >> 21;
rand_w ^= rand_w << 35;
rand_w ^= rand_w >> 4;
rand_w *= 2685821657736338717LL;
}
inline unsigned int randxor() {
unsigned int t;
t = (rand_x ^ (rand_x << 11));
rand_x = rand_y;
rand_y = rand_z;
rand_z = rand_w;
return (rand_w = (rand_w ^ (rand_w >> 19)) ^ (t ^ (t >> 8)));
}
struct ANSTYPE {
vector<int> t;
};
// **** write variable here ****
int d;
int n = 26;
vector<int> c(26);
vector<vector<int>> s;
vector<int> mx;
// *****************************
void input() {
cin >> d;
for (int i = 0; i < 26; i++)
cin >> c[i];
s = vector<vector<int>>(d, vector<int>(26));
mx = vector<int>(d);
for (int i = 0; i < d; i++) {
int mxx = 0;
for (int j = 0; j < 26; j++) {
cin >> s[i][j];
if (s[i][j] > mxx) {
mxx = s[i][j];
mx[i] = j;
}
}
}
}
ANSTYPE ans;
void output() {
for (int i = 0; i < d; i++)
cout << ans.t[i] + 1 << endl;
}
void init() {
// ans=
ans.t = vector<int>(d);
for (int i = 0; i < d; i++)
ans.t[i] = i % 26;
vector<int> bef(26, 0);
for (int i = 0; i < d; i++) {
int nx = -1;
int mx = (-1) * INF;
for (int j = 0; j < n; j++) {
int now = s[i][j];
for (int k = 0; k < n; k++) {
if (j == k)
continue;
now -= (c[k] * (i + 1 - bef[k]));
}
if (mx < now) {
mx = now;
nx = j;
}
}
bef[nx] = i + 1;
ans.t[i] = nx;
}
}
long long value(ANSTYPE &in_ans) {
long long point = 0;
vector<int> bef(26, 0);
for (int i = 0; i < d; i++) {
int now = in_ans.t[i];
point += s[i][now];
bef[now] = i + 1;
for (int j = 0; j < n; j++)
point -= (c[j] * (i + 1 - bef[j]));
}
return point;
}
int next(ANSTYPE &in_ans, int bef_score) {
int bef = 0;
int aft = 0;
in_ans.t[randxor() % d] = randxor() % n;
return value(in_ans);
return bef_score + (aft - bef);
}
int next2(ANSTYPE &in_ans, int bef_score) {
int x = randxor() % (d - 1);
int xx = in_ans.t[x];
in_ans.t[x] = in_ans.t[x + 1];
in_ans.t[x + 1] = xx;
return value(in_ans);
}
int next3(ANSTYPE &in_ans, int bef_score) {
int x = randxor() % (d - 1);
in_ans.t[x] = mx[x];
return value(in_ans);
}
void SA() {
double st = gettime();
double now_time;
bool FORCE_NEXT;
double probability;
double temp;
init();
ANSTYPE now_ans = ans;
ANSTYPE best_ans = now_ans;
ANSTYPE next_ans;
long long best_score = value(ans);
long long next_score = 0;
long long now_score = best_score;
int cnt = 0;
int bad_cnt = 0;
// cerr << "score \t: " << value(ans) << endl;
while (elapsed(st) < TIMELIMIT) {
cnt++;
next_ans = now_ans;
if (elapsed(st) / TIMELIMIT > 2.0 / 3.0 and randxor() % 2 == 0)
next_score = next2(next_ans, now_score);
else {
if (randxor() % 4 == 0)
next_score = next3(next_ans, now_score);
else
next_score = next(next_ans, now_score);
}
now_time = elapsed(st);
temp = START_TEMP +
(END_TEMP - START_TEMP) * now_time / (TIMELIMIT); // 現在温度
probability = exp((next_score - now_score) / temp);
FORCE_NEXT = (probability > (double(randxor() % 100100) / 100100));
// FORCE_NEXT = false;
if (next_score > now_score or (FORCE_NEXT and next_score > 0)) {
if (next_score < now_score)
bad_cnt++;
now_score = next_score;
now_ans = next_ans;
}
if (now_score > best_score) {
best_score = now_score;
best_ans = now_ans;
}
// cerr << best_score << " : " << next_score << endl;;
}
ANSTYPE bef_best_ans = best_ans;
int bef_best_score = best_score;
st = gettime();
while (elapsed(st) < TIMELIMIT) {
cnt++;
next_ans = now_ans;
if (elapsed(st) / TIMELIMIT > 2.0 / 3.0 and randxor() % 2 == 0)
next_score = next2(next_ans, now_score);
else {
if (randxor() % 4 == 0)
next_score = next3(next_ans, now_score);
else
next_score = next(next_ans, now_score);
}
now_time = elapsed(st);
temp = START_TEMP +
(END_TEMP - START_TEMP) * now_time / (TIMELIMIT); // 現在温度
probability = exp((next_score - now_score) / temp);
FORCE_NEXT = (probability > (double(randxor() % 100100) / 100100));
// FORCE_NEXT = false;
if (next_score > now_score or (FORCE_NEXT and next_score > 0)) {
if (next_score < now_score)
bad_cnt++;
now_score = next_score;
now_ans = next_ans;
}
if (now_score > best_score) {
best_score = now_score;
best_ans = now_ans;
}
// cerr << best_score << " : " << next_score << endl;;
}
ans = best_ans;
if (best_score < bef_best_score)
ans = bef_best_ans;
cerr << "loop \t: " << cnt << endl;
cerr << "bad use\t: " << bad_cnt << endl;
cerr << "score \t: " << value(ans) << endl;
}
void solve() { SA(); }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
init_randxor();
input();
solve();
output();
return 0;
}
| replace | 25 | 26 | 25 | 26 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#include <time.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(i, n, m) for (int i = (n); i <= (m); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
int d;
int c[26];
int s[365][26];
map<int, int> exist[26];
int sum[26];
int sigma(int x) { return (x + 1) * x / 2; }
void make_sum(int i) {
sum[i] = 0;
int last = -1;
for (auto x : exist[i]) {
sum[i] += sigma(x.first - last - 1);
last = x.first;
}
sum[i] += sigma(d - 1 - last);
/*cout << "i=" << (i+1) << ":";
for (auto x:exist[i]) cout << x << ",";
cout <<sum[i]<< endl;*/
}
void sol_init(int order[]) {
rep(i, 26) exist[i].clear();
rep(j, d) exist[order[j]][j] = 1;
rep(i, 26) make_sum(i);
}
int sol_val(int order[]) {
int ans = 0;
rep(j, d) ans += s[j][order[j]];
rep(i, 26) ans -= c[i] * sum[i];
return ans;
}
int diff(int order[], int j, int x) {
int i = order[j];
int ans = -s[j][i] + s[j][x];
int tmp = sum[i];
exist[i].erase(j);
make_sum(i);
ans -= c[i] * (sum[i] - tmp);
sum[i] = tmp;
exist[i][j] = 1;
tmp = sum[x];
exist[x][j] = 1;
make_sum(x);
ans -= c[x] * (sum[x] - tmp);
sum[x] = tmp;
exist[x].erase(j);
return ans;
}
int diff_1opt(int order[], int j) {
int max = 0;
int max_i = order[j];
rep(i, 26) {
if (i == order[j])
continue;
int ans = s[j][i];
int tmp = sum[i];
exist[i][j] = 1;
make_sum(i);
ans -= c[i] * (sum[i] - tmp);
sum[i] = tmp;
exist[i].erase(j);
if (max < ans) {
max = ans;
max_i = i;
}
}
return max_i;
}
int main() {
clock_t start = clock();
cin >> d;
rep(i, 26) cin >> c[i];
rep(j, d) { rep(i, 26) cin >> s[j][i]; }
int order[d];
rep(j, d) {
int max = s[j][0], max_i = 0;
rep(i, 26) {
if (max < s[j][i]) {
max = s[j][i];
max_i = i;
}
}
order[j] = max_i;
// cout << (max_i+1) << endl;
}
sol_init(order);
// cout << sol_val(order) << endl;
int best_val = sol_val(order);
int best_order[d];
memcpy(best_order, order, sizeof(int) * d);
int j = 0, last_j = 0;
while (j < d) {
clock_t now = clock();
if ((now - start) / CLOCKS_PER_SEC > 1.9)
break;
int opt = diff_1opt(order, (last_j + j) % d);
int dif = diff(order, (last_j + j) % d, opt);
if (dif > -100) {
order[(last_j + j) % d] = opt;
sol_init(order);
// cout << last_j+j << "->" << opt+1 << "=" << sol_val(order) << endl;
last_j = (last_j + j) % d;
j = 0;
if (best_val < sol_val(order)) {
best_val = sol_val(order);
memcpy(best_order, order, sizeof(int) * d);
}
}
j++;
}
for (auto x : best_order)
cout << (x + 1) << endl;
// cout << best_val << endl;
}
| #include <bits/stdc++.h>
#include <time.h>
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep2(i, n, m) for (int i = (n); i <= (m); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
using Graph = vector<vector<int>>;
int d;
int c[26];
int s[365][26];
map<int, int> exist[26];
int sum[26];
int sigma(int x) { return (x + 1) * x / 2; }
void make_sum(int i) {
sum[i] = 0;
int last = -1;
for (auto x : exist[i]) {
sum[i] += sigma(x.first - last - 1);
last = x.first;
}
sum[i] += sigma(d - 1 - last);
/*cout << "i=" << (i+1) << ":";
for (auto x:exist[i]) cout << x << ",";
cout <<sum[i]<< endl;*/
}
void sol_init(int order[]) {
rep(i, 26) exist[i].clear();
rep(j, d) exist[order[j]][j] = 1;
rep(i, 26) make_sum(i);
}
int sol_val(int order[]) {
int ans = 0;
rep(j, d) ans += s[j][order[j]];
rep(i, 26) ans -= c[i] * sum[i];
return ans;
}
int diff(int order[], int j, int x) {
int i = order[j];
int ans = -s[j][i] + s[j][x];
int tmp = sum[i];
exist[i].erase(j);
make_sum(i);
ans -= c[i] * (sum[i] - tmp);
sum[i] = tmp;
exist[i][j] = 1;
tmp = sum[x];
exist[x][j] = 1;
make_sum(x);
ans -= c[x] * (sum[x] - tmp);
sum[x] = tmp;
exist[x].erase(j);
return ans;
}
int diff_1opt(int order[], int j) {
int max = 0;
int max_i = order[j];
rep(i, 26) {
if (i == order[j])
continue;
int ans = s[j][i];
int tmp = sum[i];
exist[i][j] = 1;
make_sum(i);
ans -= c[i] * (sum[i] - tmp);
sum[i] = tmp;
exist[i].erase(j);
if (max < ans) {
max = ans;
max_i = i;
}
}
return max_i;
}
int main() {
clock_t start = clock();
cin >> d;
rep(i, 26) cin >> c[i];
rep(j, d) { rep(i, 26) cin >> s[j][i]; }
int order[d];
rep(j, d) {
int max = s[j][0], max_i = 0;
rep(i, 26) {
if (max < s[j][i]) {
max = s[j][i];
max_i = i;
}
}
order[j] = max_i;
// cout << (max_i+1) << endl;
}
sol_init(order);
// cout << sol_val(order) << endl;
int best_val = sol_val(order);
int best_order[d];
memcpy(best_order, order, sizeof(int) * d);
int j = 0, last_j = 0;
while (j < d) {
clock_t now = clock();
if ((double)(now - start) / CLOCKS_PER_SEC > 1.9)
break;
int opt = diff_1opt(order, (last_j + j) % d);
int dif = diff(order, (last_j + j) % d, opt);
if (dif > -100) {
order[(last_j + j) % d] = opt;
sol_init(order);
// cout << last_j+j << "->" << opt+1 << "=" << sol_val(order) << endl;
last_j = (last_j + j) % d;
j = 0;
if (best_val < sol_val(order)) {
best_val = sol_val(order);
memcpy(best_order, order, sizeof(int) * d);
}
}
j++;
}
for (auto x : best_order)
cout << (x + 1) << endl;
// cout << best_val << endl;
}
| replace | 114 | 115 | 114 | 115 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <sys/time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define REP(i, m, n) for (int i = (m); i < (n); ++i)
#define rep(i, n) REP(i, 0, n)
#define all(s) (s).begin(), (s).end()
#define pb push_back
#define fs first
#define sc second
template <typename T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> ll pow2(const T n) { return (1LL << n); }
void setp(const int n) { cout << fixed << setprecision(n); }
constexpr int INF = 1e9 + 1;
constexpr ll LINF = 1e18 + 1;
constexpr ll MOD = 1e9 + 7;
// constexpr ll MOD = 998244353;
constexpr ld EPS = 1e-11;
const ld PI = acos(-1);
constexpr int BEAM_SIZE = 1000;
constexpr int SZ = 26;
constexpr int D = 365;
array<int, SZ> C;
array<array<int, SZ>, D> S;
struct State {
array<int, SZ> last = {};
array<int, D> ans;
int score = 0;
void update_score(int d, int t) {
score += S[d][t];
rep(i, SZ) score -= C[i] * (d + 1 - last[i]);
}
int eval() const { return score; }
State place(int d, int t) {
State res = *this;
res.ans[d] = t;
res.last[t] = d + 1;
res.update_score(d, t);
return res;
}
array<int, D> answer() { return ans; }
};
array<int, D> solve() {
State initial_state;
using f = function<bool(State &, State &)>;
priority_queue<State, vector<State>, f> cur(
[](State &a, State &b) { return a.eval() > b.eval(); });
cur.push(initial_state);
priority_queue<State, vector<State>, f> nxt(
[](State &a, State &b) { return a.eval() > b.eval(); });
rep(d, D) {
while (!nxt.empty())
nxt.pop();
while (!cur.empty()) {
State now = cur.top();
cur.pop();
rep(t, SZ) {
if (nxt.size() < BEAM_SIZE || now.place(d, t).eval() > nxt.top().eval())
nxt.push(now.place(d, t));
if (nxt.size() > BEAM_SIZE)
nxt.pop();
}
}
swap(cur, nxt);
}
State res;
while (!cur.empty()) {
if (cur.size() == 1)
res = cur.top();
cur.pop();
}
cerr << res.eval() << endl;
return res.answer();
}
int main(void) {
int tmp;
cin >> tmp;
rep(i, SZ) cin >> C[i];
rep(i, D) rep(j, SZ) cin >> S[i][j];
auto ans = solve();
for (int i : ans)
cout << i + 1 << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <sys/time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define REP(i, m, n) for (int i = (m); i < (n); ++i)
#define rep(i, n) REP(i, 0, n)
#define all(s) (s).begin(), (s).end()
#define pb push_back
#define fs first
#define sc second
template <typename T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> ll pow2(const T n) { return (1LL << n); }
void setp(const int n) { cout << fixed << setprecision(n); }
constexpr int INF = 1e9 + 1;
constexpr ll LINF = 1e18 + 1;
constexpr ll MOD = 1e9 + 7;
// constexpr ll MOD = 998244353;
constexpr ld EPS = 1e-11;
const ld PI = acos(-1);
constexpr int BEAM_SIZE = 800;
constexpr int SZ = 26;
constexpr int D = 365;
array<int, SZ> C;
array<array<int, SZ>, D> S;
struct State {
array<int, SZ> last = {};
array<int, D> ans;
int score = 0;
void update_score(int d, int t) {
score += S[d][t];
rep(i, SZ) score -= C[i] * (d + 1 - last[i]);
}
int eval() const { return score; }
State place(int d, int t) {
State res = *this;
res.ans[d] = t;
res.last[t] = d + 1;
res.update_score(d, t);
return res;
}
array<int, D> answer() { return ans; }
};
array<int, D> solve() {
State initial_state;
using f = function<bool(State &, State &)>;
priority_queue<State, vector<State>, f> cur(
[](State &a, State &b) { return a.eval() > b.eval(); });
cur.push(initial_state);
priority_queue<State, vector<State>, f> nxt(
[](State &a, State &b) { return a.eval() > b.eval(); });
rep(d, D) {
while (!nxt.empty())
nxt.pop();
while (!cur.empty()) {
State now = cur.top();
cur.pop();
rep(t, SZ) {
if (nxt.size() < BEAM_SIZE || now.place(d, t).eval() > nxt.top().eval())
nxt.push(now.place(d, t));
if (nxt.size() > BEAM_SIZE)
nxt.pop();
}
}
swap(cur, nxt);
}
State res;
while (!cur.empty()) {
if (cur.size() == 1)
res = cur.top();
cur.pop();
}
cerr << res.eval() << endl;
return res.answer();
}
int main(void) {
int tmp;
cin >> tmp;
rep(i, SZ) cin >> C[i];
rep(i, D) rep(j, SZ) cin >> S[i][j];
auto ans = solve();
for (int i : ans)
cout << i + 1 << endl;
return 0;
}
| replace | 54 | 55 | 54 | 55 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <sys/time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define REP(i, m, n) for (int i = (m); i < (n); ++i)
#define rep(i, n) REP(i, 0, n)
#define all(s) (s).begin(), (s).end()
#define pb push_back
#define fs first
#define sc second
template <typename T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> ll pow2(const T n) { return (1LL << n); }
void setp(const int n) { cout << fixed << setprecision(n); }
constexpr int INF = 1e9 + 1;
constexpr ll LINF = 1e18 + 1;
constexpr ll MOD = 1e9 + 7;
// constexpr ll MOD = 998244353;
constexpr ld EPS = 1e-11;
const ld PI = acos(-1);
constexpr int BEAM_SIZE = 1100;
constexpr int SZ = 26;
constexpr int D = 365;
array<int, SZ> C;
array<array<int, SZ>, D> S;
struct State {
array<int, SZ> last = {};
array<int, D> ans;
int score = 0;
void update_score(int d, int t) {
score += S[d][t];
rep(i, SZ) score -= C[i] * (d + 1 - last[i]);
}
int next_eval(int d, int t) {
int res = score;
res += S[d][t];
rep(i, SZ) {
if (i != t)
res -= C[i] * (d + 1 - last[i]);
}
return res;
}
int eval() const { return score; }
State place(int d, int t) {
State res = *this;
res.ans[d] = t;
res.last[t] = d + 1;
res.update_score(d, t);
return res;
}
array<int, D> answer() { return ans; }
};
array<int, D> solve() {
State initial_state;
using f = function<bool(State &, State &)>;
priority_queue<State, vector<State>, f> cur(
[](State &a, State &b) { return a.eval() > b.eval(); });
cur.push(initial_state);
priority_queue<State, vector<State>, f> nxt(
[](State &a, State &b) { return a.eval() > b.eval(); });
rep(d, D) {
while (!nxt.empty())
nxt.pop();
while (!cur.empty()) {
State now = cur.top();
cur.pop();
rep(t, SZ) {
if (nxt.size() < BEAM_SIZE || now.next_eval(d, t) > nxt.top().eval())
nxt.push(now.place(d, t));
if (nxt.size() > BEAM_SIZE)
nxt.pop();
}
}
swap(cur, nxt);
}
State res;
while (!cur.empty()) {
if (cur.size() == 1)
res = cur.top();
cur.pop();
}
cerr << res.eval() << endl;
return res.answer();
}
int main(void) {
int tmp;
cin >> tmp;
rep(i, SZ) cin >> C[i];
rep(i, D) rep(j, SZ) cin >> S[i][j];
auto ans = solve();
for (int i : ans)
cout << i + 1 << endl;
return 0;
}
| #include <algorithm>
#include <array>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <sys/time.h>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
#define REP(i, m, n) for (int i = (m); i < (n); ++i)
#define rep(i, n) REP(i, 0, n)
#define all(s) (s).begin(), (s).end()
#define pb push_back
#define fs first
#define sc second
template <typename T> bool chmax(T &a, const T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, const T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> ll pow2(const T n) { return (1LL << n); }
void setp(const int n) { cout << fixed << setprecision(n); }
constexpr int INF = 1e9 + 1;
constexpr ll LINF = 1e18 + 1;
constexpr ll MOD = 1e9 + 7;
// constexpr ll MOD = 998244353;
constexpr ld EPS = 1e-11;
const ld PI = acos(-1);
constexpr int BEAM_SIZE = 1000;
constexpr int SZ = 26;
constexpr int D = 365;
array<int, SZ> C;
array<array<int, SZ>, D> S;
struct State {
array<int, SZ> last = {};
array<int, D> ans;
int score = 0;
void update_score(int d, int t) {
score += S[d][t];
rep(i, SZ) score -= C[i] * (d + 1 - last[i]);
}
int next_eval(int d, int t) {
int res = score;
res += S[d][t];
rep(i, SZ) {
if (i != t)
res -= C[i] * (d + 1 - last[i]);
}
return res;
}
int eval() const { return score; }
State place(int d, int t) {
State res = *this;
res.ans[d] = t;
res.last[t] = d + 1;
res.update_score(d, t);
return res;
}
array<int, D> answer() { return ans; }
};
array<int, D> solve() {
State initial_state;
using f = function<bool(State &, State &)>;
priority_queue<State, vector<State>, f> cur(
[](State &a, State &b) { return a.eval() > b.eval(); });
cur.push(initial_state);
priority_queue<State, vector<State>, f> nxt(
[](State &a, State &b) { return a.eval() > b.eval(); });
rep(d, D) {
while (!nxt.empty())
nxt.pop();
while (!cur.empty()) {
State now = cur.top();
cur.pop();
rep(t, SZ) {
if (nxt.size() < BEAM_SIZE || now.next_eval(d, t) > nxt.top().eval())
nxt.push(now.place(d, t));
if (nxt.size() > BEAM_SIZE)
nxt.pop();
}
}
swap(cur, nxt);
}
State res;
while (!cur.empty()) {
if (cur.size() == 1)
res = cur.top();
cur.pop();
}
cerr << res.eval() << endl;
return res.answer();
}
int main(void) {
int tmp;
cin >> tmp;
rep(i, SZ) cin >> C[i];
rep(i, D) rep(j, SZ) cin >> S[i][j];
auto ans = solve();
for (int i : ans)
cout << i + 1 << endl;
return 0;
}
| replace | 54 | 55 | 54 | 55 | TLE | |
p02618 | Python | Time Limit Exceeded | import numpy as np
def solve_greedy(dd, c_arr, s_arr):
missing_d = np.zeros(26, dtype=np.int64)
score = 0
res_list = []
for d in range(dd):
missing_d += 1
score_add = s_arr[d, :]
score_miss = c_arr * missing_d
t = np.argmax(score_add + score_miss)
score += score_add[t] + score_miss[t] - score_miss.sum()
res_list.append(t)
missing_d[t] = 0
# print(score)
return score, np.array(res_list)
def solve(dd, c_arr, s_arr):
score, t_arr = solve_greedy(dd, c_arr, s_arr)
score_d = np.zeros(dd, dtype=np.int64)
missing_d = np.zeros((dd, 26), dtype=np.int64)
for d in range(dd):
score_d[d] = s_arr[d, t_arr[d]]
if d == 0:
missing_d[d, :] = 1
else:
missing_d[d, :] = missing_d[d - 1, :] + 1
missing_d[d, t_arr[d]] = 0
for i in range(3000):
d0 = np.random.choice(dd)
q0 = np.random.choice(26)
p0 = t_arr[d0]
t_arr[d0] = q0
score_new = score
score_new += s_arr[d0, q0]
score_new -= s_arr[d0, p0]
score_new += (c_arr[q0] * missing_d[:, q0]).sum()
score_new += (c_arr[p0] * missing_d[:, p0]).sum()
for d in range(dd):
if d == 0:
missing_d[d, p0] = 1
missing_d[d, q0] = 1
else:
missing_d[d, p0] = missing_d[d - 1, p0] + 1
missing_d[d, q0] = missing_d[d - 1, q0] + 1
if t_arr[d] == p0:
missing_d[d, p0] = 0
elif t_arr[d] == q0:
missing_d[d, q0] = 0
score_new -= (c_arr[q0] * missing_d[:, q0]).sum()
score_new -= (c_arr[p0] * missing_d[:, p0]).sum()
if score_new >= score:
score = score_new
else:
t_arr[d0] = p0
for d in range(dd):
if d == 0:
missing_d[d, p0] = 1
missing_d[d, q0] = 1
else:
missing_d[d, p0] = missing_d[d - 1, p0] + 1
missing_d[d, q0] = missing_d[d - 1, q0] + 1
if t_arr[d] == p0:
missing_d[d, p0] = 0
elif t_arr[d] == q0:
missing_d[d, q0] = 0
return [t + 1 for t in t_arr]
def main():
d = np.int64(input())
c_arr = np.array(list(map(int, input().split()))).astype(np.int64)
s_arr = np.array([list(map(int, input().split())) for _ in range(d)]).astype(
np.int64
)
res = solve(d, c_arr, s_arr)
for r in res:
print(r)
if __name__ == "__main__":
main()
| import numpy as np
def solve_greedy(dd, c_arr, s_arr):
missing_d = np.zeros(26, dtype=np.int64)
score = 0
res_list = []
for d in range(dd):
missing_d += 1
score_add = s_arr[d, :]
score_miss = c_arr * missing_d
t = np.argmax(score_add + score_miss)
score += score_add[t] + score_miss[t] - score_miss.sum()
res_list.append(t)
missing_d[t] = 0
# print(score)
return score, np.array(res_list)
def solve(dd, c_arr, s_arr):
score, t_arr = solve_greedy(dd, c_arr, s_arr)
score_d = np.zeros(dd, dtype=np.int64)
missing_d = np.zeros((dd, 26), dtype=np.int64)
for d in range(dd):
score_d[d] = s_arr[d, t_arr[d]]
if d == 0:
missing_d[d, :] = 1
else:
missing_d[d, :] = missing_d[d - 1, :] + 1
missing_d[d, t_arr[d]] = 0
for i in range(1000):
d0 = np.random.choice(dd)
q0 = np.random.choice(26)
p0 = t_arr[d0]
t_arr[d0] = q0
score_new = score
score_new += s_arr[d0, q0]
score_new -= s_arr[d0, p0]
score_new += (c_arr[q0] * missing_d[:, q0]).sum()
score_new += (c_arr[p0] * missing_d[:, p0]).sum()
for d in range(dd):
if d == 0:
missing_d[d, p0] = 1
missing_d[d, q0] = 1
else:
missing_d[d, p0] = missing_d[d - 1, p0] + 1
missing_d[d, q0] = missing_d[d - 1, q0] + 1
if t_arr[d] == p0:
missing_d[d, p0] = 0
elif t_arr[d] == q0:
missing_d[d, q0] = 0
score_new -= (c_arr[q0] * missing_d[:, q0]).sum()
score_new -= (c_arr[p0] * missing_d[:, p0]).sum()
if score_new >= score:
score = score_new
else:
t_arr[d0] = p0
for d in range(dd):
if d == 0:
missing_d[d, p0] = 1
missing_d[d, q0] = 1
else:
missing_d[d, p0] = missing_d[d - 1, p0] + 1
missing_d[d, q0] = missing_d[d - 1, q0] + 1
if t_arr[d] == p0:
missing_d[d, p0] = 0
elif t_arr[d] == q0:
missing_d[d, q0] = 0
return [t + 1 for t in t_arr]
def main():
d = np.int64(input())
c_arr = np.array(list(map(int, input().split()))).astype(np.int64)
s_arr = np.array([list(map(int, input().split())) for _ in range(d)]).astype(
np.int64
)
res = solve(d, c_arr, s_arr)
for r in res:
print(r)
if __name__ == "__main__":
main()
| replace | 38 | 39 | 38 | 39 | TLE | |
p02618 | Python | Time Limit Exceeded | import os
import sys
import numpy as np
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, ttt):
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)
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
t = ttt[i]
score += sss[i, t]
for u in range(26):
if u == t:
continue
score -= ccc[u] * (i - last[u])
last[t] = i
bitree_add(bit, bit_n, t, i + 2, 1)
return bit, score
def update_score(bit, bit_n, bit_d, ccc, sss, ttt, d, q):
diff = 0
t = ttt[d]
k = bitree_sum(bit, t, d + 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 * (d - c) * (e - d)
diff -= sss[d, t]
k = bitree_sum(bit, q, d + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, q, k) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, q, k + 1) - 2
b = ccc[q]
diff += b * (d - c) * (e - d)
diff += sss[d, q]
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]
ttt = np.random.choice(26, d)
bit, score = initial_score(d, ccc, sss, ttt)
bit_n = d + 3
bit_d = int(np.log2(bit_n))
for _ in range(10**7):
cd = np.random.randint(0, d)
ct = np.random.randint(0, 26)
diff = update_score(bit, bit_n, bit_d, ccc, sss, ttt, cd, ct)
if diff > 0:
score += diff
bitree_add(bit, bit_n, ttt[cd], cd + 2, -1)
bitree_add(bit, bit_n, ct, cd + 2, 1)
ttt[cd] = ct
return ttt + 1
if sys.argv[-1] == "ONLINE_JUDGE":
from numba.pycc import CC
cc = CC("my_module")
cc.export("solve", "(i8[:],)")(solve)
cc.compile()
exit()
if os.name == "posix":
# noinspection PyUnresolvedReferences
from my_module import solve
else:
from numba import njit
solve = njit("(i8[:],)", cache=True)(solve)
print("compiled", file=sys.stderr)
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=" ")
ans = solve(inp)
print("\n".join(map(str, ans)))
| import os
import sys
import numpy as np
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, ttt):
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)
last = np.full(26, -1, dtype=np.int64)
score = 0
for i in range(d):
t = ttt[i]
score += sss[i, t]
for u in range(26):
if u == t:
continue
score -= ccc[u] * (i - last[u])
last[t] = i
bitree_add(bit, bit_n, t, i + 2, 1)
return bit, score
def update_score(bit, bit_n, bit_d, ccc, sss, ttt, d, q):
diff = 0
t = ttt[d]
k = bitree_sum(bit, t, d + 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 * (d - c) * (e - d)
diff -= sss[d, t]
k = bitree_sum(bit, q, d + 2)
c = bitree_lower_bound(bit, bit_n, bit_d, q, k) - 2
e = bitree_lower_bound(bit, bit_n, bit_d, q, k + 1) - 2
b = ccc[q]
diff += b * (d - c) * (e - d)
diff += sss[d, q]
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]
ttt = np.random.choice(26, d)
bit, score = initial_score(d, ccc, sss, ttt)
bit_n = d + 3
bit_d = int(np.log2(bit_n))
for _ in range(5 * 10**6):
cd = np.random.randint(0, d)
ct = np.random.randint(0, 26)
diff = update_score(bit, bit_n, bit_d, ccc, sss, ttt, cd, ct)
if diff > 0:
score += diff
bitree_add(bit, bit_n, ttt[cd], cd + 2, -1)
bitree_add(bit, bit_n, ct, cd + 2, 1)
ttt[cd] = ct
return ttt + 1
if sys.argv[-1] == "ONLINE_JUDGE":
from numba.pycc import CC
cc = CC("my_module")
cc.export("solve", "(i8[:],)")(solve)
cc.compile()
exit()
if os.name == "posix":
# noinspection PyUnresolvedReferences
from my_module import solve
else:
from numba import njit
solve = njit("(i8[:],)", cache=True)(solve)
print("compiled", file=sys.stderr)
inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=" ")
ans = solve(inp)
print("\n".join(map(str, ans)))
| replace | 82 | 83 | 82 | 83 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
int D, c[27], s[366][27];
int sco(vector<int> &t, int k, int x) {
int S = 0, L[27] = {};
REP(i, D) {
if (i == k) {
S += s[i][x];
L[x] = i;
} else {
S += s[i][t[i]];
L[t[i]] = i;
}
REP(j, 27) { S -= c[j] * (i - L[j]); }
}
return S;
}
int saga(int d, vector<int> &L) {
int S = 0;
REP(i, 27) { S += c[i] * (d - L[i]); }
return S;
}
int main() {
cin >> D;
D++;
REP(i, 27) { cin >> c[i]; }
REP(i, D) {
REP(j, 27) { cin >> s[i][j]; }
}
vector<int> t(D), last(27, 0);
REP(i, D) {
int a = 1, S = -1000000, u = 0;
REP(j, 27) {
u = s[i][j];
u -= saga(i, last);
u += c[j] * (i - last[j]);
if (S < u) {
a = j;
S = u;
}
}
t[i] = a;
last[a] = i;
}
int S = sco(t, 0, 0), T = 0, n = 0;
REP(i, D) {
REP(j, 27) {
T = sco(t, i, j);
if (S < T) {
t[i] = j;
S = T;
if (n <= 140) {
i = 1;
n++;
break;
}
}
}
}
REP(i, D) { cout << t[i] << "\n"; }
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
int D, c[27], s[366][27];
int sco(vector<int> &t, int k, int x) {
int S = 0, L[27] = {};
REP(i, D) {
if (i == k) {
S += s[i][x];
L[x] = i;
} else {
S += s[i][t[i]];
L[t[i]] = i;
}
REP(j, 27) { S -= c[j] * (i - L[j]); }
}
return S;
}
int saga(int d, vector<int> &L) {
int S = 0;
REP(i, 27) { S += c[i] * (d - L[i]); }
return S;
}
int main() {
cin >> D;
D++;
REP(i, 27) { cin >> c[i]; }
REP(i, D) {
REP(j, 27) { cin >> s[i][j]; }
}
vector<int> t(D), last(27, 0);
REP(i, D) {
int a = 1, S = -1000000, u = 0;
REP(j, 27) {
u = s[i][j];
u -= saga(i, last);
u += c[j] * (i - last[j]);
if (S < u) {
a = j;
S = u;
}
}
t[i] = a;
last[a] = i;
}
int S = sco(t, 0, 0), T = 0, n = 0;
REP(i, D) {
REP(j, 27) {
T = sco(t, i, j);
if (S < T) {
t[i] = j;
S = T;
if (n <= 125) {
i = 1;
n++;
break;
}
}
}
}
REP(i, D) { cout << t[i] << "\n"; }
}
| replace | 56 | 57 | 56 | 57 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
int D, c[27], s[366][27];
int sco(vector<int> &t, int k, int x) {
int S = 0, L[27] = {};
REP(i, D) {
if (i == k) {
S += s[i][x];
L[x] = i;
} else {
S += s[i][t[i]];
L[t[i]] = i;
}
REP(j, 27) { S -= c[j] * (i - L[j]); }
}
return S;
}
int saga(int d, vector<int> &L) {
int S = 0;
REP(i, 27) { S += c[i] * (d - L[i]); }
return S;
}
int main() {
cin >> D;
D++;
REP(i, 27) { cin >> c[i]; }
REP(i, D) {
REP(j, 27) { cin >> s[i][j]; }
}
vector<int> t(D), last(27, 0);
REP(i, D) {
int a = 1, S = -1000000, u = 0, m = 0;
REP(j, 27) {
u = s[i][j];
u -= saga(i, last);
u += c[j] * (i - last[j]);
if (S < u) {
a = j;
S = u;
}
}
t[i] = a;
last[a] = i;
}
int S = sco(t, 0, 0), T = 0, n = 0;
REP(i, D) {
REP(j, 27) {
T = sco(t, i, j);
if (S < T) {
t[i] = j;
S = T;
if (n <= 10000) {
i = 1;
n++;
break;
}
}
}
}
REP(i, D) { cout << t[i] << "\n"; }
}
| #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 1; i < (int)(n); i++)
int D, c[27], s[366][27];
int sco(vector<int> &t, int k, int x) {
int S = 0, L[27] = {};
REP(i, D) {
if (i == k) {
S += s[i][x];
L[x] = i;
} else {
S += s[i][t[i]];
L[t[i]] = i;
}
REP(j, 27) { S -= c[j] * (i - L[j]); }
}
return S;
}
int saga(int d, vector<int> &L) {
int S = 0;
REP(i, 27) { S += c[i] * (d - L[i]); }
return S;
}
int main() {
cin >> D;
D++;
REP(i, 27) { cin >> c[i]; }
REP(i, D) {
REP(j, 27) { cin >> s[i][j]; }
}
vector<int> t(D), last(27, 0);
REP(i, D) {
int a = 1, S = -1000000, u = 0, m = 0;
REP(j, 27) {
u = s[i][j];
u -= saga(i, last);
u += c[j] * (i - last[j]);
if (S < u) {
a = j;
S = u;
}
}
t[i] = a;
last[a] = i;
}
int S = sco(t, 0, 0), T = 0, n = 0;
REP(i, D) {
REP(j, 27) {
T = sco(t, i, j);
if (S < T) {
t[i] = j;
S = T;
if (n <= 100) {
i = 1;
n++;
break;
}
}
}
}
REP(i, D) { cout << t[i] << "\n"; }
}
| replace | 56 | 57 | 56 | 57 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vin = vector<int>;
using vll = vector<long long>;
using vvin = vector<vector<int>>;
using vvll = vector<vector<long long>>;
using vstr = vector<string>;
using vvstr = vector<vector<string>>;
using vch = vector<char>;
using vvch = vector<vector<char>>;
using vbo = vector<bool>;
using vvbo = vector<vector<bool>>;
using vpii = vector<pair<int, int>>;
using pqsin = priority_queue<int, vector<int>, greater<int>>;
#define mp make_pair
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define decp(n) cout << fixed << setprecision((int)n)
const int inf = 1e9 + 7;
const ll INF = 1e18;
int main() {
int d;
cin >> d;
vin c(26);
rep(i, 26) cin >> c[i];
vvin s(d, vin(26));
rep(i, d) rep(j, 26) cin >> s[i][j];
vvin last(d, vin(26, 0));
int sum, tmp;
ll m;
vin ans(d);
rep(i, d) {
m = -INF;
tmp = 0;
if (i > 0)
rep(j, 26) last[i][j] = last[i - 1][j];
rep(j, 26) {
sum = 0;
sum += s[i][j];
rep(k, 26) {
if (k == j)
continue;
sum -= c[k] * (i + 1 - last[i][k]);
}
if ((ll)sum > m) {
tmp = j;
m = (ll)sum;
}
}
ans[i] = tmp;
last[i][tmp] = i + 1;
}
int res, l;
rep(i, 900) {
rep(j, d) {
m = 0;
rep(k, 26) {
sum = 0;
res = ans[j];
rep2(l, j, d) {
if (ans[l] == k) {
sum += c[k] * (j + 1 - last[j][k]) * (l - j);
break;
}
}
rep2(l, j, d) {
if (ans[l] == res) {
sum -= c[res] * (j + 1 - last[j][res]) * (l - j);
}
}
if (m < sum) {
m = sum;
tmp = k;
}
}
if (m == 0)
continue;
ans[j] = tmp;
l = last[j][tmp];
rep2(k, j, d) {
if (last[k][tmp] != l)
break;
last[k][tmp] = j + 1;
}
}
}
rep(i, d) cout << ans[i] + 1 << endl;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vin = vector<int>;
using vll = vector<long long>;
using vvin = vector<vector<int>>;
using vvll = vector<vector<long long>>;
using vstr = vector<string>;
using vvstr = vector<vector<string>>;
using vch = vector<char>;
using vvch = vector<vector<char>>;
using vbo = vector<bool>;
using vvbo = vector<vector<bool>>;
using vpii = vector<pair<int, int>>;
using pqsin = priority_queue<int, vector<int>, greater<int>>;
#define mp make_pair
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, s, n) for (int i = (s); i < (int)(n); i++)
#define all(v) v.begin(), v.end()
#define decp(n) cout << fixed << setprecision((int)n)
const int inf = 1e9 + 7;
const ll INF = 1e18;
int main() {
int d;
cin >> d;
vin c(26);
rep(i, 26) cin >> c[i];
vvin s(d, vin(26));
rep(i, d) rep(j, 26) cin >> s[i][j];
vvin last(d, vin(26, 0));
int sum, tmp;
ll m;
vin ans(d);
rep(i, d) {
m = -INF;
tmp = 0;
if (i > 0)
rep(j, 26) last[i][j] = last[i - 1][j];
rep(j, 26) {
sum = 0;
sum += s[i][j];
rep(k, 26) {
if (k == j)
continue;
sum -= c[k] * (i + 1 - last[i][k]);
}
if ((ll)sum > m) {
tmp = j;
m = (ll)sum;
}
}
ans[i] = tmp;
last[i][tmp] = i + 1;
}
int res, l;
rep(i, 30) {
rep(j, d) {
m = 0;
rep(k, 26) {
sum = 0;
res = ans[j];
rep2(l, j, d) {
if (ans[l] == k) {
sum += c[k] * (j + 1 - last[j][k]) * (l - j);
break;
}
}
rep2(l, j, d) {
if (ans[l] == res) {
sum -= c[res] * (j + 1 - last[j][res]) * (l - j);
}
}
if (m < sum) {
m = sum;
tmp = k;
}
}
if (m == 0)
continue;
ans[j] = tmp;
l = last[j][tmp];
rep2(k, j, d) {
if (last[k][tmp] != l)
break;
last[k][tmp] = j + 1;
}
}
}
rep(i, d) cout << ans[i] + 1 << endl;
} | replace | 56 | 57 | 56 | 57 | TLE | |
p02618 | C++ | Time Limit Exceeded | #define DEBUG
#include <fstream>
#include <iostream>
#include <bits/stdc++.h>
#include <cstdio>
#include <sys/time.h>
#include <sys/timeb.h>
#include <time.h>
using namespace std;
#define ll long long
#define uint unsigned int
#define ulong unsigned long long int
#define Vec vector
#define V2 vector<vector<ll>>
class Xor128 {
private:
uint x, y, z, w;
public:
void init(uint seed = 0) {
x = 123456789;
y = 362436069;
z = 521288629;
w = 88675123;
z ^= seed;
}
Xor128() { init(); }
Xor128(uint seed) { init(seed); }
uint Next() {
uint t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
}
int Next(int ul) { return ul == 0 ? 0 : NextI(0, ul - 1); }
int NextI(int from, int to) {
int mod = to - from + 1;
int ret = (int)(Next() % mod);
return ret + from;
}
double NextD() { return (Next() & 1048575) / 1048575.0; }
};
class Timer {
public:
Timer() { cycle_per_sec = (ulong)2.7e9; }
void Start() { begin_cycle = getCycle(); }
double getTime() {
return (double)(getCycle() - begin_cycle) / cycle_per_sec;
}
int elapsedMilliseconds() { return (int)(1000 * getTime()); }
ulong getCycle() {
uint low, high;
__asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
return ((ulong)low) | ((ulong)high << 32);
}
private:
ulong begin_cycle;
ulong cycle_per_sec;
};
Timer T;
ll Now() { return (ll)T.elapsedMilliseconds(); }
const double Eps = 1e-9;
inline bool InRange(int t, int l, int r) { return l <= t && t < r; }
void Swap(int &a, int &b) {
int t = a;
a = b;
b = t;
}
// SA template
Xor128 lottery(25252525);
const double Csa = 1200;
// double C = 1200;
bool SAgain(double score, double prev, long now, long start,
long limitDuration) {
if (score > prev)
return true;
double ratio = -(prev - score) / prev;
double remainingTime = (now - start) / (double)limitDuration;
if (remainingTime > 1.0)
return false;
remainingTime = 1 - remainingTime;
double acProb = exp(Csa * ratio / remainingTime);
return (lottery.NextD() + Eps) < acProb;
}
bool MCgain(double score, double prev, long now, long start,
long limitDuration) {
if (score < prev)
return true;
return false;
}
template <typename T> bool InRange(T t, T l, T r) { return l <= t && t < r; }
const int Inf = (int)1e9;
int D;
Vec<ll> C;
V2 S;
void OutputAns(Vec<int> &a) {
for (int i = 0; i < D; i++) {
printf("%d\n", a[i] + 1);
}
}
ll calcNaive(Vec<int> &a) {
Vec<int> last(26);
for (int i = 0; i < 26; i++)
last[i] = -1;
ll ret = 0;
for (int i = 0; i < D; i++) {
ret += S[i][a[i]];
last[a[i]] = i;
for (int j = 0; j < 26; j++) {
ret -= C[j] * (i - last[j]);
}
}
return ret;
}
ll calcLine(Vec<int> &a) {
Vec<int> last(26);
for (int i = 0; i < 26; i++)
last[i] = -1;
ll ret = 0;
for (int i = 0; i < D; i++) {
ret += S[i][a[i]];
ll d = (i - last[a[i]]) - 1;
ret -= d * (d + 1) / 2 * C[a[i]];
last[a[i]] = i;
}
for (int i = 0; i < 26; i++) {
ll d = (D - last[i]) - 1;
ret -= d * (d + 1) / 2 * C[i];
}
return ret;
}
void debug1() {
Vec<int> a{1, 17, 13, 14, 13};
for (int i = 0; i < a.size(); i++)
a[i]--;
cerr << calcNaive(a) << endl;
cerr << calcLine(a) << endl;
}
ll maxSc = 0;
Vec<int> maxAr;
void initMax() {
maxAr.resize(D);
maxSc = -(ll)1e9;
}
bool UpdateMax(Vec<int> &a, ll sc, bool recalc = false) {
if (recalc)
sc = calcNaive(a);
if (maxSc >= sc)
return false;
// cerr << sc << "," << maxSc << endl;
maxSc = sc;
for (int i = 0; i < D; i++)
maxAr[i] = a[i];
return true;
}
void SA(Vec<int> &a, ll tl, int seed = 2525) {
ll tstart = Now();
Xor128 rnd(seed);
ll sc = calcLine(a);
UpdateMax(a, sc);
ll ma = sc;
ll cnt = 0;
ll timeLimitDuration = tl - tstart;
ll t1 = Now();
Vec<int> b(D);
for (int i = 0; i < D; i++) {
b[i] = a[i];
}
Vec<int> last(2, -1);
while (true) {
cnt++;
if (cnt % 1000 == 0 && (t1 = Now()) - tstart > timeLimitDuration)
break;
int bw = rnd.Next(2);
if (bw == 0) {
/*
int rp = rnd.Next(D * 26);
int idx = rp / 26;
int val = rp % 26;
*/
int idx = rnd.Next(D);
int val = rnd.Next(26);
int fr = b[idx];
if (fr == val)
continue;
b[idx] = val;
/*
int lose = 0;
last[0] = last[1] = -1;
for(int i=0;i<D;i++){
if(b[i] != val && b[i] != fr) continue;
int iid = b[i] == val ? 0 : 1;
lose += S[i][iid];
int d = (i - last[iid]) - 1;
lose -= d * (d + 1) / 2 * C[iid];
last[iid] = i;
}
for(int i=0;i<2;i++){
int d = (D - last[i]) - 1;
lose -= d * (d + 1) / 2 * C[i];
}
int gain = 0;
b[idx] = val;
last[0] = last[1] = -1;
for(int i=0;i<D;i++){
if(b[i] != val && b[i] != fr) continue;
int iid = b[i] == val ? 0 : 1;
gain += S[i][iid];
int d = (i - last[iid]) - 1;
gain -= d * (d + 1) / 2 * C[iid];
last[iid] = i;
}
for(int i=0;i<2;i++){
int d = (D - last[i]) - 1;
gain -= d * (d + 1) / 2 * C[i];
}
printf("%d %d\n", sc + gain - lose, calcLine(b));
assert(sc + gain - lose == calcLine(b));
*/
ll nsc = calcLine(b);
if (SAgain(nsc, sc, t1, tstart, timeLimitDuration)) {
// sc = sc + gain - lose;
sc = nsc;
UpdateMax(b, sc);
} else {
b[idx] = fr;
}
} else {
/*
int rp = rnd.Next(D * 10);
int left = rp / 10;
int right = min(left + (rp % 10), D - 1);
*/
int left = rnd.Next(D);
int right = min(rnd.Next(10) + left, D - 1);
if (left == right)
continue;
Swap(b[left], b[right]);
ll nsc = calcLine(b);
if (SAgain(nsc, sc, t1, tstart, timeLimitDuration)) {
// sc = sc + gain - lose;
sc = nsc;
UpdateMax(b, sc);
} else {
Swap(b[left], b[right]);
}
}
}
// cerr << "cnt: " << cnt << endl;
}
void randomSample(Vec<int> &a) {
Xor128 rnd(2525);
for (int i = 0; i < D; i++)
a[i] = rnd.Next(26);
}
void greedyS(Vec<int> &a) {
for (int i = 0; i < D; i++) {
int ma = -1;
int idx = -1;
for (int j = 0; j < 26; j++) {
if (ma < S[i][j]) {
ma = S[i][j];
idx = j;
}
}
a[i] = idx;
}
}
void greedyScore(Vec<int> &a) {
Vec<int> prev(26, 0);
for (int i = 0; i < D; i++) {
int ma = -1;
int idx = -1;
for (int j = 0; j < 26; j++) {
if (ma < S[i][j] + (i + 1 - prev[j]) * C[j]) {
ma = S[i][j] + (i + 1 - prev[j]) * C[j];
idx = j;
}
}
a[i] = idx;
prev[idx] = i + 1;
}
}
void Solve() {
// debug1();
initMax();
Vec<int> a(D);
// randomSample(a);
// greedtS(a);
greedyScore(a);
int tl = 19500;
SA(a, tl, 2525);
// cerr << maxSc << endl;
// cerr << calcNaive(maxAr) << endl;
OutputAns(maxAr);
}
int main(int argc, char *argv[]) {
// C = stod(argv[1]);
T.Start();
cin >> D;
C.resize(26);
for (int i = 0; i < 26; i++)
cin >> C[i];
S.resize(D);
for (int i = 0; i < D; i++)
S[i].resize(26);
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++) {
cin >> S[i][j];
}
}
Solve();
/* for(int i=0;i<md.size();i++){
cerr << "sc: " << md[i] << " at: " << msc[i] << endl;
}
*/
/*
ofstream fout("score.csv");
fout << "C,score" << endl;
fout << C << "," << maxSc << endl;
fout.close();
*/
return 0;
} | #define DEBUG
#include <fstream>
#include <iostream>
#include <bits/stdc++.h>
#include <cstdio>
#include <sys/time.h>
#include <sys/timeb.h>
#include <time.h>
using namespace std;
#define ll long long
#define uint unsigned int
#define ulong unsigned long long int
#define Vec vector
#define V2 vector<vector<ll>>
class Xor128 {
private:
uint x, y, z, w;
public:
void init(uint seed = 0) {
x = 123456789;
y = 362436069;
z = 521288629;
w = 88675123;
z ^= seed;
}
Xor128() { init(); }
Xor128(uint seed) { init(seed); }
uint Next() {
uint t = x ^ (x << 11);
x = y;
y = z;
z = w;
return w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
}
int Next(int ul) { return ul == 0 ? 0 : NextI(0, ul - 1); }
int NextI(int from, int to) {
int mod = to - from + 1;
int ret = (int)(Next() % mod);
return ret + from;
}
double NextD() { return (Next() & 1048575) / 1048575.0; }
};
class Timer {
public:
Timer() { cycle_per_sec = (ulong)2.7e9; }
void Start() { begin_cycle = getCycle(); }
double getTime() {
return (double)(getCycle() - begin_cycle) / cycle_per_sec;
}
int elapsedMilliseconds() { return (int)(1000 * getTime()); }
ulong getCycle() {
uint low, high;
__asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
return ((ulong)low) | ((ulong)high << 32);
}
private:
ulong begin_cycle;
ulong cycle_per_sec;
};
Timer T;
ll Now() { return (ll)T.elapsedMilliseconds(); }
const double Eps = 1e-9;
inline bool InRange(int t, int l, int r) { return l <= t && t < r; }
void Swap(int &a, int &b) {
int t = a;
a = b;
b = t;
}
// SA template
Xor128 lottery(25252525);
const double Csa = 1200;
// double C = 1200;
bool SAgain(double score, double prev, long now, long start,
long limitDuration) {
if (score > prev)
return true;
double ratio = -(prev - score) / prev;
double remainingTime = (now - start) / (double)limitDuration;
if (remainingTime > 1.0)
return false;
remainingTime = 1 - remainingTime;
double acProb = exp(Csa * ratio / remainingTime);
return (lottery.NextD() + Eps) < acProb;
}
bool MCgain(double score, double prev, long now, long start,
long limitDuration) {
if (score < prev)
return true;
return false;
}
template <typename T> bool InRange(T t, T l, T r) { return l <= t && t < r; }
const int Inf = (int)1e9;
int D;
Vec<ll> C;
V2 S;
void OutputAns(Vec<int> &a) {
for (int i = 0; i < D; i++) {
printf("%d\n", a[i] + 1);
}
}
ll calcNaive(Vec<int> &a) {
Vec<int> last(26);
for (int i = 0; i < 26; i++)
last[i] = -1;
ll ret = 0;
for (int i = 0; i < D; i++) {
ret += S[i][a[i]];
last[a[i]] = i;
for (int j = 0; j < 26; j++) {
ret -= C[j] * (i - last[j]);
}
}
return ret;
}
ll calcLine(Vec<int> &a) {
Vec<int> last(26);
for (int i = 0; i < 26; i++)
last[i] = -1;
ll ret = 0;
for (int i = 0; i < D; i++) {
ret += S[i][a[i]];
ll d = (i - last[a[i]]) - 1;
ret -= d * (d + 1) / 2 * C[a[i]];
last[a[i]] = i;
}
for (int i = 0; i < 26; i++) {
ll d = (D - last[i]) - 1;
ret -= d * (d + 1) / 2 * C[i];
}
return ret;
}
void debug1() {
Vec<int> a{1, 17, 13, 14, 13};
for (int i = 0; i < a.size(); i++)
a[i]--;
cerr << calcNaive(a) << endl;
cerr << calcLine(a) << endl;
}
ll maxSc = 0;
Vec<int> maxAr;
void initMax() {
maxAr.resize(D);
maxSc = -(ll)1e9;
}
bool UpdateMax(Vec<int> &a, ll sc, bool recalc = false) {
if (recalc)
sc = calcNaive(a);
if (maxSc >= sc)
return false;
// cerr << sc << "," << maxSc << endl;
maxSc = sc;
for (int i = 0; i < D; i++)
maxAr[i] = a[i];
return true;
}
void SA(Vec<int> &a, ll tl, int seed = 2525) {
ll tstart = Now();
Xor128 rnd(seed);
ll sc = calcLine(a);
UpdateMax(a, sc);
ll ma = sc;
ll cnt = 0;
ll timeLimitDuration = tl - tstart;
ll t1 = Now();
Vec<int> b(D);
for (int i = 0; i < D; i++) {
b[i] = a[i];
}
Vec<int> last(2, -1);
while (true) {
cnt++;
if (cnt % 1000 == 0 && (t1 = Now()) - tstart > timeLimitDuration)
break;
int bw = rnd.Next(2);
if (bw == 0) {
/*
int rp = rnd.Next(D * 26);
int idx = rp / 26;
int val = rp % 26;
*/
int idx = rnd.Next(D);
int val = rnd.Next(26);
int fr = b[idx];
if (fr == val)
continue;
b[idx] = val;
/*
int lose = 0;
last[0] = last[1] = -1;
for(int i=0;i<D;i++){
if(b[i] != val && b[i] != fr) continue;
int iid = b[i] == val ? 0 : 1;
lose += S[i][iid];
int d = (i - last[iid]) - 1;
lose -= d * (d + 1) / 2 * C[iid];
last[iid] = i;
}
for(int i=0;i<2;i++){
int d = (D - last[i]) - 1;
lose -= d * (d + 1) / 2 * C[i];
}
int gain = 0;
b[idx] = val;
last[0] = last[1] = -1;
for(int i=0;i<D;i++){
if(b[i] != val && b[i] != fr) continue;
int iid = b[i] == val ? 0 : 1;
gain += S[i][iid];
int d = (i - last[iid]) - 1;
gain -= d * (d + 1) / 2 * C[iid];
last[iid] = i;
}
for(int i=0;i<2;i++){
int d = (D - last[i]) - 1;
gain -= d * (d + 1) / 2 * C[i];
}
printf("%d %d\n", sc + gain - lose, calcLine(b));
assert(sc + gain - lose == calcLine(b));
*/
ll nsc = calcLine(b);
if (SAgain(nsc, sc, t1, tstart, timeLimitDuration)) {
// sc = sc + gain - lose;
sc = nsc;
UpdateMax(b, sc);
} else {
b[idx] = fr;
}
} else {
/*
int rp = rnd.Next(D * 10);
int left = rp / 10;
int right = min(left + (rp % 10), D - 1);
*/
int left = rnd.Next(D);
int right = min(rnd.Next(10) + left, D - 1);
if (left == right)
continue;
Swap(b[left], b[right]);
ll nsc = calcLine(b);
if (SAgain(nsc, sc, t1, tstart, timeLimitDuration)) {
// sc = sc + gain - lose;
sc = nsc;
UpdateMax(b, sc);
} else {
Swap(b[left], b[right]);
}
}
}
// cerr << "cnt: " << cnt << endl;
}
void randomSample(Vec<int> &a) {
Xor128 rnd(2525);
for (int i = 0; i < D; i++)
a[i] = rnd.Next(26);
}
void greedyS(Vec<int> &a) {
for (int i = 0; i < D; i++) {
int ma = -1;
int idx = -1;
for (int j = 0; j < 26; j++) {
if (ma < S[i][j]) {
ma = S[i][j];
idx = j;
}
}
a[i] = idx;
}
}
void greedyScore(Vec<int> &a) {
Vec<int> prev(26, 0);
for (int i = 0; i < D; i++) {
int ma = -1;
int idx = -1;
for (int j = 0; j < 26; j++) {
if (ma < S[i][j] + (i + 1 - prev[j]) * C[j]) {
ma = S[i][j] + (i + 1 - prev[j]) * C[j];
idx = j;
}
}
a[i] = idx;
prev[idx] = i + 1;
}
}
void Solve() {
// debug1();
initMax();
Vec<int> a(D);
// randomSample(a);
// greedtS(a);
greedyScore(a);
int tl = 2150;
SA(a, tl, 2525);
// cerr << maxSc << endl;
// cerr << calcNaive(maxAr) << endl;
OutputAns(maxAr);
}
int main(int argc, char *argv[]) {
// C = stod(argv[1]);
T.Start();
cin >> D;
C.resize(26);
for (int i = 0; i < 26; i++)
cin >> C[i];
S.resize(D);
for (int i = 0; i < D; i++)
S[i].resize(26);
for (int i = 0; i < D; i++) {
for (int j = 0; j < 26; j++) {
cin >> S[i][j];
}
}
Solve();
/* for(int i=0;i<md.size();i++){
cerr << "sc: " << md[i] << " at: " << msc[i] << endl;
}
*/
/*
ofstream fout("score.csv");
fout << "C,score" << endl;
fout << C << "," << maxSc << endl;
fout.close();
*/
return 0;
} | replace | 330 | 331 | 330 | 331 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define repi(n) for (int i = 0; i < (n); i++)
#define repj(n) for (int j = 0; j < (n); j++)
#define repk(n) for (int k = 0; k < (n); k++)
#define repl(n) for (int l = 0; l < (n); l++)
#define rep(i, n) for (int i = 0; (i) < (n); i++)
#define repr(i, a, b) for (auto i = (a); i < (b); i++)
#define repv(itr) for (auto &&v : (itr))
#define repv2(itr) for (auto &&v2 : (itr))
#define repv3(itr) for (auto &&v3 : (itr))
#define updatemax(t, v) (t = max((t), (v)))
#define updatemin(t, v) (t = min((t), (v)))
const double PI = atan(1.0) * 4;
const double E = exp(1);
ll modpow(ll a, ll b, ll m) {
ll re = 1, k = 1;
while (k <= b) {
if (b & k) {
re *= a;
re %= m;
}
k = k << 1;
a *= a;
a %= m;
a += m;
a %= m;
}
return re;
}
ll modinv(ll a, ll m) {
ll b = m, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
ll modbinomial(ll n, ll k, ll m) {
k = min(k, n - k);
if (k < 0)
return 0;
ll re = 1;
for (ll i = 0; i < k; i++) {
re *= n - i;
re %= m;
re *= modinv(i + 1, m);
re %= m;
}
return re;
}
class uftree {
private:
int n, groups;
vector<int> parent, size;
public:
uftree(int _n) {
groups = n = _n;
parent.resize(n);
size.resize(n);
for (int i = 0; i < n; i++) {
parent[i] = i;
size[i] = 1;
}
}
int group(int x) {
if (parent[x] == x)
return x;
return parent[x] = group(parent[x]);
}
bool inSameGroup(int x, int y) { return group(x) == group(y); }
int groupSizeOf(int x) { return size[group(x)]; }
void merge(int x, int y) {
int gx = group(x), gy = group(y);
if (gx != gy) {
parent[gx] = gy;
size[gy] += size[gx];
size[gx] = 0;
groups--;
}
}
int countGroups() { return groups; }
};
template <typename T> class segtree {
private:
int n;
function<T(T, T)> f;
T e;
vector<T> data, lazy;
void _updateP(int i) {
data[i] = f(data[i * 2 + 1], data[i * 2 + 2]);
if (i)
_updateP((i - 1) / 2);
}
T _calc(int begin, int end, int node, int nodeBegin, int nodeEnd) {
if (end <= nodeBegin || nodeEnd <= begin) {
return e;
} else if (begin <= nodeBegin && nodeEnd <= end) {
return data[node];
} else {
int m = (nodeBegin + nodeEnd) / 2;
T left = _calc(begin, end, node * 2 + 1, nodeBegin, m);
T right = _calc(begin, end, node * 2 + 2, m, nodeEnd);
return f(left, right);
}
}
public:
segtree(int n_, function<T(T, T)> f_, T e_, T fill) {
n = pow(2, ceil(log2(n_)));
f = f_;
e = e_;
data.resize(n * 2 - 1);
for (int i = 0; i < n * 2 - 1; i++)
data[i] = fill;
}
segtree(int n_, function<T(T, T)> f_, T e_) : segtree(n_, f_, e_, e_) {}
T value(int i) { return data[n - 1 + i]; }
void update(int i, T value) {
data[n - 1 + i] = value;
if (n)
_updateP((n - 2 + i) / 2);
}
T calc(int begin, int end) { return _calc(begin, end, 0, 0, n); }
static T max(T a, T b) { return std::max(a, b); }
static T min(T a, T b) { return std::min(a, b); }
static T sum(T a, T b) { return a + b; }
};
int d, c[26], s[365][26], last[26];
const int depths[] = {12, 8, 6, 4, 4, 4};
const int maxDepth = 5;
pair<int, int> X(int day, int depth = 0) {
priority_queue<pair<int, int>> vals;
repi(26) {
int score = s[day + depth][i];
repj(26) score -= c[j] * (day + depth - last[j]);
vals.emplace(score, i);
}
if (depth >= min(maxDepth, d - day - 1))
return vals.top();
pair<int, int> result(INT_MIN, -1);
repi(depths[depth]) {
int v, p;
tie(v, p) = vals.top();
vals.pop();
int last_p_0 = last[p];
last[p] = day + depth;
auto ps_ = X(day, depth + 1);
last[p] = last_p_0;
if (result.first < ps_.first + v) {
result.first = ps_.first + v;
result.second = p;
}
}
return result;
}
int main() {
cin >> d;
repi(26) cin >> c[i];
repi(d) repj(26) cin >> s[i][j];
repi(26) last[i] = -1;
repi(d) {
int maxv, maxj;
tie(maxv, maxj) = X(i);
last[maxj] = i;
cout << maxj + 1 << endl;
}
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
#define repi(n) for (int i = 0; i < (n); i++)
#define repj(n) for (int j = 0; j < (n); j++)
#define repk(n) for (int k = 0; k < (n); k++)
#define repl(n) for (int l = 0; l < (n); l++)
#define rep(i, n) for (int i = 0; (i) < (n); i++)
#define repr(i, a, b) for (auto i = (a); i < (b); i++)
#define repv(itr) for (auto &&v : (itr))
#define repv2(itr) for (auto &&v2 : (itr))
#define repv3(itr) for (auto &&v3 : (itr))
#define updatemax(t, v) (t = max((t), (v)))
#define updatemin(t, v) (t = min((t), (v)))
const double PI = atan(1.0) * 4;
const double E = exp(1);
ll modpow(ll a, ll b, ll m) {
ll re = 1, k = 1;
while (k <= b) {
if (b & k) {
re *= a;
re %= m;
}
k = k << 1;
a *= a;
a %= m;
a += m;
a %= m;
}
return re;
}
ll modinv(ll a, ll m) {
ll b = m, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= m;
if (u < 0)
u += m;
return u;
}
ll modbinomial(ll n, ll k, ll m) {
k = min(k, n - k);
if (k < 0)
return 0;
ll re = 1;
for (ll i = 0; i < k; i++) {
re *= n - i;
re %= m;
re *= modinv(i + 1, m);
re %= m;
}
return re;
}
class uftree {
private:
int n, groups;
vector<int> parent, size;
public:
uftree(int _n) {
groups = n = _n;
parent.resize(n);
size.resize(n);
for (int i = 0; i < n; i++) {
parent[i] = i;
size[i] = 1;
}
}
int group(int x) {
if (parent[x] == x)
return x;
return parent[x] = group(parent[x]);
}
bool inSameGroup(int x, int y) { return group(x) == group(y); }
int groupSizeOf(int x) { return size[group(x)]; }
void merge(int x, int y) {
int gx = group(x), gy = group(y);
if (gx != gy) {
parent[gx] = gy;
size[gy] += size[gx];
size[gx] = 0;
groups--;
}
}
int countGroups() { return groups; }
};
template <typename T> class segtree {
private:
int n;
function<T(T, T)> f;
T e;
vector<T> data, lazy;
void _updateP(int i) {
data[i] = f(data[i * 2 + 1], data[i * 2 + 2]);
if (i)
_updateP((i - 1) / 2);
}
T _calc(int begin, int end, int node, int nodeBegin, int nodeEnd) {
if (end <= nodeBegin || nodeEnd <= begin) {
return e;
} else if (begin <= nodeBegin && nodeEnd <= end) {
return data[node];
} else {
int m = (nodeBegin + nodeEnd) / 2;
T left = _calc(begin, end, node * 2 + 1, nodeBegin, m);
T right = _calc(begin, end, node * 2 + 2, m, nodeEnd);
return f(left, right);
}
}
public:
segtree(int n_, function<T(T, T)> f_, T e_, T fill) {
n = pow(2, ceil(log2(n_)));
f = f_;
e = e_;
data.resize(n * 2 - 1);
for (int i = 0; i < n * 2 - 1; i++)
data[i] = fill;
}
segtree(int n_, function<T(T, T)> f_, T e_) : segtree(n_, f_, e_, e_) {}
T value(int i) { return data[n - 1 + i]; }
void update(int i, T value) {
data[n - 1 + i] = value;
if (n)
_updateP((n - 2 + i) / 2);
}
T calc(int begin, int end) { return _calc(begin, end, 0, 0, n); }
static T max(T a, T b) { return std::max(a, b); }
static T min(T a, T b) { return std::min(a, b); }
static T sum(T a, T b) { return a + b; }
};
int d, c[26], s[365][26], last[26];
const int depths[] = {10, 8, 6, 4};
const int maxDepth = 4;
pair<int, int> X(int day, int depth = 0) {
priority_queue<pair<int, int>> vals;
repi(26) {
int score = s[day + depth][i];
repj(26) score -= c[j] * (day + depth - last[j]);
vals.emplace(score, i);
}
if (depth >= min(maxDepth, d - day - 1))
return vals.top();
pair<int, int> result(INT_MIN, -1);
repi(depths[depth]) {
int v, p;
tie(v, p) = vals.top();
vals.pop();
int last_p_0 = last[p];
last[p] = day + depth;
auto ps_ = X(day, depth + 1);
last[p] = last_p_0;
if (result.first < ps_.first + v) {
result.first = ps_.first + v;
result.second = p;
}
}
return result;
}
int main() {
cin >> d;
repi(26) cin >> c[i];
repi(d) repj(26) cin >> s[i][j];
repi(26) last[i] = -1;
repi(d) {
int maxv, maxj;
tie(maxv, maxj) = X(i);
last[maxj] = i;
cout << maxj + 1 << endl;
}
}
| replace | 140 | 142 | 140 | 142 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int D = 365, T = 26;
vector<int> c(T);
vector<vector<int>> s(D, vector<int>(T));
vector<vector<int>> pena(T, vector<int>(D + 2));
class Timer {
private:
chrono::high_resolution_clock::time_point start;
public:
Timer() { reset(); }
void reset() { start = chrono::high_resolution_clock::now(); }
chrono::milliseconds::rep elapsed() {
auto end = chrono::high_resolution_clock::now();
return chrono::duration_cast<chrono::milliseconds>(end - start).count();
}
} timer;
auto current = timer.elapsed();
struct State {
vector<int> ct;
vector<vector<int>> h;
State() : ct(D), h(T) {
for (int t = 0; t < T; ++t) {
h[t].push_back(-1);
h[t].push_back(D);
}
}
void add(int d, int i) {
auto it = lower_bound(h[i].begin(), h[i].end(), d);
h[i].insert(it, d);
ct[d] = i;
}
void rmv(int d) {
h[ct[d]].erase(remove(h[ct[d]].begin(), h[ct[d]].end(), d), h[ct[d]].end());
}
int calc_each(int i) {
int res = 0;
for (int d = 1; d < h[i].size() - 1; ++d) {
res += s[h[i][d]][i];
}
for (int d = 0; d < h[i].size() - 1; ++d) {
res -= pena[i][h[i][d + 1] - h[i][d]];
}
return res;
}
int calc() {
int res = 0;
for (int t = 0; t < T; ++t)
res += calc_each(t);
return res;
}
int calc_diff(int d, int bf, int af) {
int res = s[d][af] - s[d][bf];
{
auto it = lower_bound(h[bf].begin(), h[bf].end(), d);
int r = *next(it) - d, l = d - *prev(it);
res -= pena[bf][l + r] - pena[bf][r] - pena[bf][l];
}
{
auto it = lower_bound(h[af].begin(), h[af].end(), d);
int r = *it - d, l = d - *prev(it);
res += pena[af][l + r] - pena[af][r] - pena[af][l];
}
return res;
}
void output() {
for (int i = 0; i < D; ++i)
cout << ct[i] + 1 << '\n';
}
void update() {
int d = rand() % D, bf = ct[d], af = rand() % T;
if (bf == af)
return;
if (calc_diff(d, bf, af) > 0) {
rmv(d);
add(d, af);
}
}
void swap() {
int b = rand() % 13 + 1;
int d = rand() % (D - b);
int n = d + b;
int bf = ct[d], af = ct[n];
if (calc_diff(d, bf, af) + calc_diff(n, af, bf) > 0) {
ct[d] = n;
ct[n] = d;
rmv(d);
rmv(n);
add(d, af);
add(n, bf);
}
}
void exe() {
update();
swap();
}
};
State state;
void input() {
int _;
cin >> _;
for (int i = 0; i < T; ++i)
cin >> c[i];
for (int i = 0; i < D; ++i) {
for (int j = 0; j < T; ++j)
cin >> s[i][j];
}
}
void init() {
for (int i = 0; i < D; ++i) {
state.ct[i] = max_element(s[i].begin(), s[i].end()) - s[i].begin();
state.add(i, state.ct[i]);
}
for (int t = 0; t < T; ++t) {
for (int i = 2; i <= D + 1; ++i) {
pena[t][i] = pena[t][i - 1] + c[t] * (i - 1);
}
}
}
int main() {
srand(time(NULL));
input();
init();
cerr << state.calc() << '\n';
while (current < 1900) {
current = timer.elapsed();
state.exe();
}
state.output();
cerr << state.calc() << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int D = 365, T = 26;
vector<int> c(T);
vector<vector<int>> s(D, vector<int>(T));
vector<vector<int>> pena(T, vector<int>(D + 2));
class Timer {
private:
chrono::high_resolution_clock::time_point start;
public:
Timer() { reset(); }
void reset() { start = chrono::high_resolution_clock::now(); }
chrono::milliseconds::rep elapsed() {
auto end = chrono::high_resolution_clock::now();
return chrono::duration_cast<chrono::milliseconds>(end - start).count();
}
} timer;
auto current = timer.elapsed();
struct State {
vector<int> ct;
vector<vector<int>> h;
State() : ct(D), h(T) {
for (int t = 0; t < T; ++t) {
h[t].push_back(-1);
h[t].push_back(D);
}
}
void add(int d, int i) {
auto it = lower_bound(h[i].begin(), h[i].end(), d);
h[i].insert(it, d);
ct[d] = i;
}
void rmv(int d) {
h[ct[d]].erase(remove(h[ct[d]].begin(), h[ct[d]].end(), d), h[ct[d]].end());
}
int calc_each(int i) {
int res = 0;
for (int d = 1; d < h[i].size() - 1; ++d) {
res += s[h[i][d]][i];
}
for (int d = 0; d < h[i].size() - 1; ++d) {
res -= pena[i][h[i][d + 1] - h[i][d]];
}
return res;
}
int calc() {
int res = 0;
for (int t = 0; t < T; ++t)
res += calc_each(t);
return res;
}
int calc_diff(int d, int bf, int af) {
int res = s[d][af] - s[d][bf];
{
auto it = lower_bound(h[bf].begin(), h[bf].end(), d);
int r = *next(it) - d, l = d - *prev(it);
res -= pena[bf][l + r] - pena[bf][r] - pena[bf][l];
}
{
auto it = lower_bound(h[af].begin(), h[af].end(), d);
int r = *it - d, l = d - *prev(it);
res += pena[af][l + r] - pena[af][r] - pena[af][l];
}
return res;
}
void output() {
for (int i = 0; i < D; ++i)
cout << ct[i] + 1 << '\n';
}
void update() {
int d = rand() % D, bf = ct[d], af = rand() % T;
if (bf == af)
return;
if (calc_diff(d, bf, af) > 0) {
rmv(d);
add(d, af);
}
}
void swap() {
int b = rand() % 13 + 1;
int d = rand() % (D - b);
int n = d + b;
int bf = ct[d], af = ct[n];
if (calc_diff(d, bf, af) + calc_diff(n, af, bf) > 0) {
ct[d] = af;
ct[n] = bf;
rmv(d);
rmv(n);
add(d, af);
add(n, bf);
}
}
void exe() {
update();
swap();
}
};
State state;
void input() {
int _;
cin >> _;
for (int i = 0; i < T; ++i)
cin >> c[i];
for (int i = 0; i < D; ++i) {
for (int j = 0; j < T; ++j)
cin >> s[i][j];
}
}
void init() {
for (int i = 0; i < D; ++i) {
state.ct[i] = max_element(s[i].begin(), s[i].end()) - s[i].begin();
state.add(i, state.ct[i]);
}
for (int t = 0; t < T; ++t) {
for (int i = 2; i <= D + 1; ++i) {
pena[t][i] = pena[t][i - 1] + c[t] * (i - 1);
}
}
}
int main() {
srand(time(NULL));
input();
init();
cerr << state.calc() << '\n';
while (current < 1900) {
current = timer.elapsed();
state.exe();
}
state.output();
cerr << state.calc() << '\n';
return 0;
}
| replace | 90 | 92 | 90 | 92 | -11 | -91330615
|
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, s, n) for (int i = (s); i < (n); i++)
#define all(v) v.begin(), v.end()
#define outve(v) \
for (auto i : v) \
cout << i << " "; \
cout << endl
#define outmat(v) \
for (auto i : v) { \
for (auto j : i) \
cout << j << " "; \
cout << endl; \
}
#define in(n, v) \
for (int i = 0; i < (n); i++) { \
cin >> v[i]; \
}
#define out(n) cout << (n) << endl
#define fi first
#define se second
#define pb push_back
#define si(v) int(v.size())
#define len(v) int(v.length())
#define lob(v, n) lower_bound(all(v), n)
#define lobi(v, n) lower_bound(all(v), n) - v.begin()
#define upb(v, n) upper_bound(all(v), n)
#define upbi(v, n) upper_bound(all(v), n) - v.begin()
#define mod 1000000007
#define infi 1900000000
#define infl 1100000000000000000
#define cyes cout << "Yes" << endl
#define cno cout << "No" << endl
#define csp << " " <<
#define outset(n) cout << fixed << setprecision(n);
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vs = vector<string>;
using vc = vector<char>;
using vd = vector<double>;
using vvd = vector<vector<double>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vvp = vector<vector<pair<int, int>>>;
template <typename T> using ve = vector<T>;
template <typename T> using pq2 = priority_queue<T>;
template <typename T> using pq1 = priority_queue<T, vector<T>, greater<T>>;
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int D;
int N = 26;
vi c;
vvi s;
vi ans;
vi las;
pii rec(int n, int dd, vi lass) {
if (dd >= D || n == 6)
return {0, 1};
int los = 0;
rep(i, N) los += c[i] * (dd - lass[i]);
int res = -infi;
int an = 1;
set<int> sss;
ve<pii> AA(N);
rep(i, N) AA[i] = {s[dd][i], i};
sort(all(AA));
rep(i, 7) sss.insert(AA[N - i - 1].se);
rep(i, N) {
if (!sss.count(i))
continue;
vi la = lass;
int ddd = s[dd][i] - los + c[i] * (dd - lass[i]);
la[i] = dd;
int da = ddd + rec(n + 1, dd + 1, la).fi;
if (chmax(res, da))
an = i + 1;
}
return {res, an};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
// int ti = clock();
cin >> D;
c.resize(N);
s.resize(D, vi(N));
in(N, c);
rep(i, D) rep(j, N) cin >> s[i][j];
ans.resize(D);
las.assign(N, -1);
rep(d, D) {
ans[d] = rec(0, d, las).se;
las[ans[d] - 1] = d;
}
rep(i, D) cout << ans[i] << endl;
// printf("Execution Time: %.4lf sec\n", 1.0 * (clock() - ti) /
// CLOCKS_PER_SEC);
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define reps(i, s, n) for (int i = (s); i < (n); i++)
#define all(v) v.begin(), v.end()
#define outve(v) \
for (auto i : v) \
cout << i << " "; \
cout << endl
#define outmat(v) \
for (auto i : v) { \
for (auto j : i) \
cout << j << " "; \
cout << endl; \
}
#define in(n, v) \
for (int i = 0; i < (n); i++) { \
cin >> v[i]; \
}
#define out(n) cout << (n) << endl
#define fi first
#define se second
#define pb push_back
#define si(v) int(v.size())
#define len(v) int(v.length())
#define lob(v, n) lower_bound(all(v), n)
#define lobi(v, n) lower_bound(all(v), n) - v.begin()
#define upb(v, n) upper_bound(all(v), n)
#define upbi(v, n) upper_bound(all(v), n) - v.begin()
#define mod 1000000007
#define infi 1900000000
#define infl 1100000000000000000
#define cyes cout << "Yes" << endl
#define cno cout << "No" << endl
#define csp << " " <<
#define outset(n) cout << fixed << setprecision(n);
using namespace std;
using ll = long long;
using ld = long double;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vs = vector<string>;
using vc = vector<char>;
using vd = vector<double>;
using vvd = vector<vector<double>>;
using vl = vector<ll>;
using vvl = vector<vector<ll>>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vvp = vector<vector<pair<int, int>>>;
template <typename T> using ve = vector<T>;
template <typename T> using pq2 = priority_queue<T>;
template <typename T> using pq1 = priority_queue<T, vector<T>, greater<T>>;
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int D;
int N = 26;
vi c;
vvi s;
vi ans;
vi las;
pii rec(int n, int dd, vi lass) {
if (dd >= D || n == 5)
return {0, 1};
int los = 0;
rep(i, N) los += c[i] * (dd - lass[i]);
int res = -infi;
int an = 1;
set<int> sss;
ve<pii> AA(N);
rep(i, N) AA[i] = {s[dd][i], i};
sort(all(AA));
rep(i, 7) sss.insert(AA[N - i - 1].se);
rep(i, N) {
if (!sss.count(i))
continue;
vi la = lass;
int ddd = s[dd][i] - los + c[i] * (dd - lass[i]);
la[i] = dd;
int da = ddd + rec(n + 1, dd + 1, la).fi;
if (chmax(res, da))
an = i + 1;
}
return {res, an};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
// int ti = clock();
cin >> D;
c.resize(N);
s.resize(D, vi(N));
in(N, c);
rep(i, D) rep(j, N) cin >> s[i][j];
ans.resize(D);
las.assign(N, -1);
rep(d, D) {
ans[d] = rec(0, d, las).se;
las[ans[d] - 1] = d;
}
rep(i, D) cout << ans[i] << endl;
// printf("Execution Time: %.4lf sec\n", 1.0 * (clock() - ti) /
// CLOCKS_PER_SEC);
return 0;
}
| replace | 76 | 77 | 76 | 77 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef vector<vi> vvi;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define fi first
#define sc second
#define rep(i, x) for (long long i = 0; i < x; i++)
#define repn(i, x) for (long long i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define rrepn(i, n) for (int i = ((int)(n)); i > 0; --i)
#define SZ(x) ((int)(x).size())
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;
}
vector<pair<string, P>> vec;
// vector<vector<int>> data(3, vector<int>(4));
inline unsigned long long rdtsc() {
#ifdef __amd64
unsigned long long a, d;
__asm__ volatile("rdtsc" : "=a"(a), "=d"(d));
return (d << 32) | a;
#else
unsigned long long x;
__asm__ volatile("rdtsc" : "=A"(x));
return x;
#endif
}
inline double gettime() { return rdtsc() / 2993344000.0; }
inline double elapsed(double st) { return gettime() - st; }
class Xorshift128 {
private:
static constexpr unsigned MASK = 0x7FFFFFFF;
unsigned x = 123456789, y = 987654321, z = 1000000007, w;
public:
unsigned rnd() {
unsigned t = x ^ (x << 11);
x = y;
y = z;
z = w;
w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
return w & MASK;
}
inline double rnd_d() { return (double)rnd() / INT32_MAX; }
Xorshift128(const unsigned seed = 0) : w(seed) {}
};
Xorshift128 prng(21);
int D;
vi c(26);
vvi s(365, vi(26));
int compute_score(const vi &out) {
vector<int> last(26);
int score = 0;
rep(i, out.size()) {
score += s[i][out[i]];
last[out[i]] = i + 1;
int m = 0;
rep(j, 26) { m += c[j] * (i + 1 - last[j]); }
score -= m;
// cout << score << endl;
}
return score;
}
int evaluate(const vi &out, int k) {
vector<int> last(26);
int score = 0;
rep(i, out.size()) {
score += s[i][out[i]];
last[out[i]] = i + 1;
int m = 0;
rep(j, 26) { m += c[j] * (i + 1 - last[j]); }
score -= m;
// cout << score << endl;
}
int n = min(k, D - (int)out.size());
rep(i, 26) {
int a = (int)out.size() + 1 - last[i];
score -= (a + (a + n - 1)) * n / 2 * c[i];
}
return score;
}
int cost(int a, int b) {
int d = b - a;
return d * (d - 1) / 2;
}
struct State {
vi out;
int score;
vvi ds;
State(const vector<int> t) : out(t) {
score = compute_score(out);
vvi dsn(26, vi());
rep(d, D) dsn[out[d]].push_back(d + 1);
ds = dsn;
}
void change(int d, int i) {
int old_i = out[d];
int p = lower_bound(ds[old_i].begin(), ds[old_i].end(), d + 1) -
ds[old_i].begin();
int prev, next;
if (p - 1 >= 0)
prev = ds[old_i][p - 1];
else
prev = 0;
if (p + 1 < ds[old_i].size())
next = ds[old_i][p + 1];
else
next = D + 1;
ds[old_i].erase(ds[old_i].begin() + p);
score +=
(cost(prev, d + 1) + cost(d + 1, next) - cost(prev, next)) * c[old_i];
p = lower_bound(ds[i].begin(), ds[i].end(), d + 2) - ds[i].begin();
if (p - 1 >= 0)
prev = ds[i][p - 1];
else
prev = 0;
if (p < ds[i].size())
next = ds[i][p];
else
next = D + 1;
ds[i].insert(ds[i].begin() + p, d + 1);
score -= (cost(prev, d + 1) + cost(d + 1, next) - cost(prev, next)) * c[i];
score += s[d][i] - s[d][old_i];
out[d] = i;
}
};
vi solve(int k) {
vi t;
rep(i, D) {
int max_score = INT_MIN;
int best_j = 0;
rep(j, 26) {
t.push_back(j);
// TODO:
// Stateで末尾追加できるようにして、最初から計算しなおさないようにする
int score = evaluate(t, k);
if (max_score < score) {
max_score = score;
best_j = j;
}
t.pop_back();
}
t.push_back(best_j);
}
return t;
}
int main() {
const double TL = 2;
double st = gettime();
cin >> D;
rep(i, 26) cin >> c[i];
rep(i, D) rep(j, 26) cin >> s[i][j];
int max_score = INT_MIN;
vi t;
rep(k, 26) {
vi now_t = solve(k);
// TODO: stateを利用して、計算しなくてもいいようにする
int score = compute_score(now_t);
if (max_score < score) {
max_score = score;
t = now_t;
}
}
State state = State(t);
while (true) {
double time = elapsed(st) / TL;
if (time > 0.99)
break;
if (prng.rnd() % 2 == 0) {
int d = prng.rnd() % D, q = prng.rnd() % 26;
int old_contest = state.out[d];
int old_score = state.score;
state.change(d, q);
if (old_score > state.score)
state.change(d, old_contest);
} else {
int d1 = prng.rnd() % (D - 1);
int d2 = min(D, d1 + (int)(prng.rnd() % 16) + 1);
int old_score = state.score;
// TODO: stateにswapを用意する
int tmp = state.out[d1];
state.change(d1, state.out[d2]);
state.change(d2, tmp);
if (old_score > state.score) {
state.change(d2, state.out[d1]);
state.change(d1, tmp);
}
}
}
rep(i, D) printf("%d\n", state.out[i] + 1);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef pair<P, P> P2;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
typedef vector<vi> vvi;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 1000000000
#define fi first
#define sc second
#define rep(i, x) for (long long i = 0; i < x; i++)
#define repn(i, x) for (long long i = 1; i <= x; i++)
#define SORT(x) sort(x.begin(), x.end())
#define ERASE(x) x.erase(unique(x.begin(), x.end()), x.end())
#define POSL(x, v) (lower_bound(x.begin(), x.end(), v) - x.begin())
#define POSU(x, v) (upper_bound(x.begin(), x.end(), v) - x.begin())
#define rrep(i, n) for (int i = ((int)(n)-1); i >= 0; --i)
#define rrepn(i, n) for (int i = ((int)(n)); i > 0; --i)
#define SZ(x) ((int)(x).size())
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;
}
vector<pair<string, P>> vec;
// vector<vector<int>> data(3, vector<int>(4));
inline unsigned long long rdtsc() {
#ifdef __amd64
unsigned long long a, d;
__asm__ volatile("rdtsc" : "=a"(a), "=d"(d));
return (d << 32) | a;
#else
unsigned long long x;
__asm__ volatile("rdtsc" : "=A"(x));
return x;
#endif
}
inline double gettime() { return rdtsc() / 2993344000.0; }
inline double elapsed(double st) { return gettime() - st; }
class Xorshift128 {
private:
static constexpr unsigned MASK = 0x7FFFFFFF;
unsigned x = 123456789, y = 987654321, z = 1000000007, w;
public:
unsigned rnd() {
unsigned t = x ^ (x << 11);
x = y;
y = z;
z = w;
w = (w ^ (w >> 19)) ^ (t ^ (t >> 8));
return w & MASK;
}
inline double rnd_d() { return (double)rnd() / INT32_MAX; }
Xorshift128(const unsigned seed = 0) : w(seed) {}
};
Xorshift128 prng(21);
int D;
vi c(26);
vvi s(365, vi(26));
int compute_score(const vi &out) {
vector<int> last(26);
int score = 0;
rep(i, out.size()) {
score += s[i][out[i]];
last[out[i]] = i + 1;
int m = 0;
rep(j, 26) { m += c[j] * (i + 1 - last[j]); }
score -= m;
// cout << score << endl;
}
return score;
}
int evaluate(const vi &out, int k) {
vector<int> last(26);
int score = 0;
rep(i, out.size()) {
score += s[i][out[i]];
last[out[i]] = i + 1;
int m = 0;
rep(j, 26) { m += c[j] * (i + 1 - last[j]); }
score -= m;
// cout << score << endl;
}
int n = min(k, D - (int)out.size());
rep(i, 26) {
int a = (int)out.size() + 1 - last[i];
score -= (a + (a + n - 1)) * n / 2 * c[i];
}
return score;
}
int cost(int a, int b) {
int d = b - a;
return d * (d - 1) / 2;
}
struct State {
vi out;
int score;
vvi ds;
State(const vector<int> t) : out(t) {
score = compute_score(out);
vvi dsn(26, vi());
rep(d, D) dsn[out[d]].push_back(d + 1);
ds = dsn;
}
void change(int d, int i) {
int old_i = out[d];
int p = lower_bound(ds[old_i].begin(), ds[old_i].end(), d + 1) -
ds[old_i].begin();
int prev, next;
if (p - 1 >= 0)
prev = ds[old_i][p - 1];
else
prev = 0;
if (p + 1 < ds[old_i].size())
next = ds[old_i][p + 1];
else
next = D + 1;
ds[old_i].erase(ds[old_i].begin() + p);
score +=
(cost(prev, d + 1) + cost(d + 1, next) - cost(prev, next)) * c[old_i];
p = lower_bound(ds[i].begin(), ds[i].end(), d + 2) - ds[i].begin();
if (p - 1 >= 0)
prev = ds[i][p - 1];
else
prev = 0;
if (p < ds[i].size())
next = ds[i][p];
else
next = D + 1;
ds[i].insert(ds[i].begin() + p, d + 1);
score -= (cost(prev, d + 1) + cost(d + 1, next) - cost(prev, next)) * c[i];
score += s[d][i] - s[d][old_i];
out[d] = i;
}
};
vi solve(int k) {
vi t;
rep(i, D) {
int max_score = INT_MIN;
int best_j = 0;
rep(j, 26) {
t.push_back(j);
// TODO:
// Stateで末尾追加できるようにして、最初から計算しなおさないようにする
int score = evaluate(t, k);
if (max_score < score) {
max_score = score;
best_j = j;
}
t.pop_back();
}
t.push_back(best_j);
}
return t;
}
int main() {
const double TL = 2;
double st = gettime();
cin >> D;
rep(i, 26) cin >> c[i];
rep(i, D) rep(j, 26) cin >> s[i][j];
int max_score = INT_MIN;
vi t;
rep(k, 26) {
vi now_t = solve(k);
// TODO: stateを利用して、計算しなくてもいいようにする
int score = compute_score(now_t);
if (max_score < score) {
max_score = score;
t = now_t;
}
}
State state = State(t);
while (true) {
double time = elapsed(st) / TL;
if (time > 0.99)
break;
if (prng.rnd() % 2 == 0) {
int d = prng.rnd() % D, q = prng.rnd() % 26;
int old_contest = state.out[d];
int old_score = state.score;
state.change(d, q);
if (old_score > state.score)
state.change(d, old_contest);
} else {
int d1 = prng.rnd() % (D - 1);
int d2 = min(D - 1, d1 + (int)(prng.rnd() % 16) + 1);
int old_score = state.score;
// TODO: stateにswapを用意する
int tmp = state.out[d1];
state.change(d1, state.out[d2]);
state.change(d2, tmp);
if (old_score > state.score) {
state.change(d2, state.out[d1]);
state.change(d1, tmp);
}
}
}
rep(i, D) printf("%d\n", state.out[i] + 1);
return 0;
}
| replace | 227 | 228 | 227 | 228 | -11 | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
int main() {
ll d;
cin >> d;
vector<ll> c(26);
for (ll i = 0; i < 26; ++i) {
cin >> c[i];
}
vector<vector<ll>> s(d, vector<ll>(26));
for (ll i = 0; i < d; ++i) {
for (ll j = 0; j < 26; ++j) {
cin >> s[i][j];
}
}
vector<ll> t(d);
for (ll i = 0; i < d; ++i) {
ll idx = 0;
ll mx = 0;
for (ll j = 0; j < 26; ++j) {
if (mx < s[i][j]) {
mx = s[i][j];
idx = j;
}
}
t[i] = idx;
}
vector<ll> score(d, 0);
vector<vector<ll>> last(d, vector<ll>(26, 0));
auto re_score = [&](ll start) {
for (ll i = start; i < d; ++i) {
score[i] = (i - 1 >= 0 ? score[i - 1] : 0) + s[i][t[i]];
if (i - 1 >= 0) {
last[i] = last[i - 1];
} else {
for (ll j = 0; j < 26; ++j) {
last[0][j] = 0;
}
}
last[i][t[i]] = i + 1;
ll j = i + 1;
for (ll k = 0; k < 26; ++k) {
score[i] -= c[k] * (j - last[i][k]);
}
}
};
re_score(0);
vector<vector<pair<ll, ll>>> kouho(d);
ll mx_score = score[d - 1];
// for (int r = 0; r < 10; ++r) {
for (ll i = 0; i < d; ++i) {
for (ll j = 0; j < 26; ++j) {
ll tmp = t[i];
t[i] = j;
re_score(i);
kouho[i].push_back(make_pair(score[d - 1], i));
if (mx_score >= score[d - 1]) {
t[i] = tmp;
re_score(i);
} else {
mx_score = score[d - 1];
}
}
}
// }
for (int i = 0; i < d; ++i) {
sort(kouho[i].rbegin(), kouho[i].rend());
}
for (int r = 0; r < 10; ++r) {
for (ll i = 0; i < d; ++i) {
for (ll j = 0; j < 10; ++j) {
ll tmp = t[i];
t[i] = kouho[i][j].second;
re_score(i);
if (mx_score >= score[d - 1]) {
t[i] = tmp;
re_score(i);
} else {
mx_score = score[d - 1];
}
}
}
}
for (ll i = 0; i < d; ++i) {
cout << t[i] + 1 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const ll LINF = 1e18;
int main() {
ll d;
cin >> d;
vector<ll> c(26);
for (ll i = 0; i < 26; ++i) {
cin >> c[i];
}
vector<vector<ll>> s(d, vector<ll>(26));
for (ll i = 0; i < d; ++i) {
for (ll j = 0; j < 26; ++j) {
cin >> s[i][j];
}
}
vector<ll> t(d);
for (ll i = 0; i < d; ++i) {
ll idx = 0;
ll mx = 0;
for (ll j = 0; j < 26; ++j) {
if (mx < s[i][j]) {
mx = s[i][j];
idx = j;
}
}
t[i] = idx;
}
vector<ll> score(d, 0);
vector<vector<ll>> last(d, vector<ll>(26, 0));
auto re_score = [&](ll start) {
for (ll i = start; i < d; ++i) {
score[i] = (i - 1 >= 0 ? score[i - 1] : 0) + s[i][t[i]];
if (i - 1 >= 0) {
last[i] = last[i - 1];
} else {
for (ll j = 0; j < 26; ++j) {
last[0][j] = 0;
}
}
last[i][t[i]] = i + 1;
ll j = i + 1;
for (ll k = 0; k < 26; ++k) {
score[i] -= c[k] * (j - last[i][k]);
}
}
};
re_score(0);
vector<vector<pair<ll, ll>>> kouho(d);
ll mx_score = score[d - 1];
// for (int r = 0; r < 10; ++r) {
for (ll i = 0; i < d; ++i) {
for (ll j = 0; j < 26; ++j) {
ll tmp = t[i];
t[i] = j;
re_score(i);
kouho[i].push_back(make_pair(score[d - 1], j));
if (mx_score >= score[d - 1]) {
t[i] = tmp;
re_score(i);
} else {
mx_score = score[d - 1];
}
}
}
// }
for (int i = 0; i < d; ++i) {
sort(kouho[i].rbegin(), kouho[i].rend());
}
for (int r = 0; r < 10; ++r) {
for (ll i = 0; i < d; ++i) {
for (ll j = 0; j < 10; ++j) {
ll tmp = t[i];
t[i] = kouho[i][j].second;
re_score(i);
if (mx_score >= score[d - 1]) {
t[i] = tmp;
re_score(i);
} else {
mx_score = score[d - 1];
}
}
}
}
for (ll i = 0; i < d; ++i) {
cout << t[i] + 1 << endl;
}
} | replace | 76 | 77 | 76 | 77 | 0 | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int d;
// int n=0;//
cin >> d;
int c[26];
int s[d][26];
for (int i = 0; i < 26; i++) {
cin >> c[i];
// n+=c[i];//
}
for (int i = 0; i < d; i++) {
for (int ii = 0; ii < 26; ii++) {
cin >> s[i][ii];
}
}
long long int la[26];
int lad[26];
for (int i = 0; i < 26; i++) {
lad[i] = -1;
}
int mm, md;
// long long int m=0;//満足度確認用
for (int i = 0; i < d; i++) {
md = 0;
// la[i]=(n-c[0])*(-i-1)+s[i][0];//
la[i] = s[i][0];
for (int ii = 1; ii < 26; ii++) {
la[i] -= (i - lad[ii]) * c[ii];
}
for (int ii = 1; ii < 26; ii++) {
// mm=(n-c[ii])*(-i-1)+s[i][ii];//
mm = s[i][ii];
for (int iii = 0; iii < 26; iii++) {
if (ii != iii)
mm -= (i - lad[iii]) * c[iii];
}
if ((la[i] < mm) || (la[i] == mm && c[md] < c[ii])) {
la[i] = mm;
md = ii;
}
}
lad[md] = i;
cout << md + 1 << endl;
// m+=la[i];//満足度確認用
// cout<<m<<endl;//満足度確認用
}
// cout<<m<<endl;//満足度確認用
// cout<<n<<endl;//
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int d;
// int n=0;//
cin >> d;
int c[26];
int s[d][26];
for (int i = 0; i < 26; i++) {
cin >> c[i];
// n+=c[i];//
}
for (int i = 0; i < d; i++) {
for (int ii = 0; ii < 26; ii++) {
cin >> s[i][ii];
}
}
long long int la[d];
int lad[26];
for (int i = 0; i < 26; i++) {
lad[i] = -1;
}
int mm, md;
// long long int m=0;//満足度確認用
for (int i = 0; i < d; i++) {
md = 0;
// la[i]=(n-c[0])*(-i-1)+s[i][0];//
la[i] = s[i][0];
for (int ii = 1; ii < 26; ii++) {
la[i] -= (i - lad[ii]) * c[ii];
}
for (int ii = 1; ii < 26; ii++) {
// mm=(n-c[ii])*(-i-1)+s[i][ii];//
mm = s[i][ii];
for (int iii = 0; iii < 26; iii++) {
if (ii != iii)
mm -= (i - lad[iii]) * c[iii];
}
if ((la[i] < mm) || (la[i] == mm && c[md] < c[ii])) {
la[i] = mm;
md = ii;
}
}
lad[md] = i;
cout << md + 1 << endl;
// m+=la[i];//満足度確認用
// cout<<m<<endl;//満足度確認用
}
// cout<<m<<endl;//満足度確認用
// cout<<n<<endl;//
} | replace | 17 | 18 | 17 | 18 | 0 | |
p02618 | C++ | Runtime Error | #include <algorithm>
#include <complex>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/time.h>
#include <vector>
#define REP(i, m, n) for (int i = int(m); i < int(n); i++)
#define RREP(i, m, n) for (int i = int(n) - 1; i >= int(m); --i)
#define EACH(i, c) for (auto &(i) : c)
#define all(c) begin(c), end(c)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort(begin(c), end(c))
#define pb emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
// #define int long long
#ifdef LOCAL
#define DEBUG(s) cout << (s) << endl
#define dump(x) cerr << #x << " = " << (x) << endl
#define BR cout << endl;
#else
#define DEBUG(s) \
do { \
} while (0)
#define dump(x) \
do { \
} while (0)
#define BR
#endif
using namespace std;
using UI = unsigned int;
using UL = unsigned long;
using LL = long long;
using ULL = unsigned long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VLL = vector<LL>;
using VVLL = vector<VLL>;
using VS = vector<string>;
using PII = pair<int, int>;
using VP = vector<PII>;
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;
}
template <class T> inline T sqr(T x) { return x * x; }
double diff(timeval &start, timeval &now) {
return (now.tv_sec - start.tv_sec) +
(now.tv_usec - start.tv_usec) / 1000000.0;
}
unsigned int xor96(void) {
static unsigned int x = 123456789;
static unsigned int y = 362436069;
static unsigned int z = 521288629;
unsigned int t;
t = (x ^ (x << 3)) ^ (y ^ (y >> 19)) ^ (z ^ (z << 6));
x = y;
y = z;
return z = t;
}
class State {
int d;
public:
VI contests;
int score;
VI scores;
State(const State &rhs)
: contests(rhs.contests), score(rhs.score), scores(rhs.scores), d(rhs.d) {
}
State(const VI &init, int d) : contests(init), d(d), score(0), scores(26) {}
void init(const VI &c, const VVI &s) { score = calcScore(c, s); }
int calcScore(const VI &c, const VVI &s) {
int score = 0;
VI lasts(26, -1);
REP(i, 0, 26) scores[i] = 0;
REP(i, 0, d) {
scores[contests[i]] += s[i][contests[i]];
lasts[contests[i]] = i;
REP(j, 0, 26) { scores[j] -= c[j] * (i - lasts[j]); }
}
REP(i, 0, 26) score += scores[i];
return score;
}
void updateScore(int t, const VI &c, const VVI &s) {
score -= scores[t];
scores[t] = 0;
int lasts = -1;
REP(i, 0, d) {
if (contests[i] == t) {
scores[t] += s[i][t];
lasts = i;
}
scores[t] -= c[t] * (i - lasts);
}
score += scores[t];
}
State modify(const VI &c, const VVI &s) {
State newState(*this);
if (xor96() % 5) {
unsigned int pos = xor96() % d;
int oldt = newState.contests[pos];
int newt = xor96() % 26;
newState.contests[pos] = newt;
newState.updateScore(oldt, c, s);
newState.updateScore(newt, c, s);
} else {
// 一カ所ランダムに変える
unsigned int l = xor96() % d, r = xor96() % d;
swap(newState.contests[l], newState.contests[r]);
newState.updateScore(newState.contests[l], c, s);
newState.updateScore(newState.contests[r], c, s);
}
// newState.score = newState.calcScore(c,s);
return newState;
}
void show() {
REP(i, 0, d) { cout << contests[i] + 1 << endl; }
}
};
// 焼きなまし法
State sa(int d, VI &c, VVI &s, double start_temp, double end_temp,
double TIME_LIMIT) {
VI init(d);
// REP(i,0,d) init[i] = xor96() % 26;
{
VI lasts(26, -1);
REP(i, 0, d) {
int ms = 0, mi = -1;
REP(j, 0, 26) {
int score = s[i][j];
REP(k, 0, 26) {
if (k == j)
continue;
score -= c[k] * (i - lasts[k]);
}
if (mi < 0 || ms < score) {
mi = i;
ms = score;
}
}
lasts[i] = mi;
init[i] = mi;
}
}
State state(init, d);
state.init(c, s);
int times = 0;
struct timeval start_timeval, now_timeval;
gettimeofday(&start_timeval, NULL);
gettimeofday(&now_timeval, NULL);
while (diff(start_timeval, now_timeval) < TIME_LIMIT) { // 時間の許す限り回す
++times;
REP(loop, 0, 100) {
State new_state = state.modify(c, s);
int new_score = new_state.score;
int pre_score = state.score;
// 温度関数
double temp = start_temp + (end_temp - start_temp) *
diff(start_timeval, now_timeval) /
TIME_LIMIT;
// 遷移確率関数(最大化の場合)
double prob = exp((new_score - pre_score) / temp);
if (prob >
(xor96() % 0xffffffffu) / (double)0xffffffffu) { // 確率probで遷移する
state = new_state;
}
}
gettimeofday(&now_timeval, NULL);
}
dump(times);
return state;
}
void solve() {
int d;
cin >> d;
VI c(26);
VVI s(d, VI(26));
REP(i, 0, 26) { cin >> c[i]; }
REP(i, 0, d) REP(j, 0, 26) cin >> s[i][j];
int repeat = 4;
double timelimit = 1.975;
State state = sa(d, c, s, 50, 10, timelimit / repeat);
REP(loop, 1, repeat) {
State newState = sa(d, c, s, 50 + 10 * repeat, 10, timelimit / repeat);
if (state.score < newState.score)
state = newState;
dump(state.score);
}
state.show();
dump(state.score);
}
signed main() {
solve();
return 0;
} | #include <algorithm>
#include <complex>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/time.h>
#include <vector>
#define REP(i, m, n) for (int i = int(m); i < int(n); i++)
#define RREP(i, m, n) for (int i = int(n) - 1; i >= int(m); --i)
#define EACH(i, c) for (auto &(i) : c)
#define all(c) begin(c), end(c)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort(begin(c), end(c))
#define pb emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
// #define int long long
#ifdef LOCAL
#define DEBUG(s) cout << (s) << endl
#define dump(x) cerr << #x << " = " << (x) << endl
#define BR cout << endl;
#else
#define DEBUG(s) \
do { \
} while (0)
#define dump(x) \
do { \
} while (0)
#define BR
#endif
using namespace std;
using UI = unsigned int;
using UL = unsigned long;
using LL = long long;
using ULL = unsigned long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VLL = vector<LL>;
using VVLL = vector<VLL>;
using VS = vector<string>;
using PII = pair<int, int>;
using VP = vector<PII>;
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;
}
template <class T> inline T sqr(T x) { return x * x; }
double diff(timeval &start, timeval &now) {
return (now.tv_sec - start.tv_sec) +
(now.tv_usec - start.tv_usec) / 1000000.0;
}
unsigned int xor96(void) {
static unsigned int x = 123456789;
static unsigned int y = 362436069;
static unsigned int z = 521288629;
unsigned int t;
t = (x ^ (x << 3)) ^ (y ^ (y >> 19)) ^ (z ^ (z << 6));
x = y;
y = z;
return z = t;
}
class State {
int d;
public:
VI contests;
int score;
VI scores;
State(const State &rhs)
: contests(rhs.contests), score(rhs.score), scores(rhs.scores), d(rhs.d) {
}
State(const VI &init, int d) : contests(init), d(d), score(0), scores(26) {}
void init(const VI &c, const VVI &s) { score = calcScore(c, s); }
int calcScore(const VI &c, const VVI &s) {
int score = 0;
VI lasts(26, -1);
REP(i, 0, 26) scores[i] = 0;
REP(i, 0, d) {
scores[contests[i]] += s[i][contests[i]];
lasts[contests[i]] = i;
REP(j, 0, 26) { scores[j] -= c[j] * (i - lasts[j]); }
}
REP(i, 0, 26) score += scores[i];
return score;
}
void updateScore(int t, const VI &c, const VVI &s) {
score -= scores[t];
scores[t] = 0;
int lasts = -1;
REP(i, 0, d) {
if (contests[i] == t) {
scores[t] += s[i][t];
lasts = i;
}
scores[t] -= c[t] * (i - lasts);
}
score += scores[t];
}
State modify(const VI &c, const VVI &s) {
State newState(*this);
if (xor96() % 5) {
unsigned int pos = xor96() % d;
int oldt = newState.contests[pos];
int newt = xor96() % 26;
newState.contests[pos] = newt;
newState.updateScore(oldt, c, s);
newState.updateScore(newt, c, s);
} else {
// 一カ所ランダムに変える
unsigned int l = xor96() % d, r = xor96() % d;
swap(newState.contests[l], newState.contests[r]);
newState.updateScore(newState.contests[l], c, s);
newState.updateScore(newState.contests[r], c, s);
}
// newState.score = newState.calcScore(c,s);
return newState;
}
void show() {
REP(i, 0, d) { cout << contests[i] + 1 << endl; }
}
};
// 焼きなまし法
State sa(int d, VI &c, VVI &s, double start_temp, double end_temp,
double TIME_LIMIT) {
VI init(d);
REP(i, 0, d) init[i] = distance(s[i].begin(), max_element(all(s[i])));
State state(init, d);
state.init(c, s);
int times = 0;
struct timeval start_timeval, now_timeval;
gettimeofday(&start_timeval, NULL);
gettimeofday(&now_timeval, NULL);
while (diff(start_timeval, now_timeval) < TIME_LIMIT) { // 時間の許す限り回す
++times;
REP(loop, 0, 100) {
State new_state = state.modify(c, s);
int new_score = new_state.score;
int pre_score = state.score;
// 温度関数
double temp = start_temp + (end_temp - start_temp) *
diff(start_timeval, now_timeval) /
TIME_LIMIT;
// 遷移確率関数(最大化の場合)
double prob = exp((new_score - pre_score) / temp);
if (prob >
(xor96() % 0xffffffffu) / (double)0xffffffffu) { // 確率probで遷移する
state = new_state;
}
}
gettimeofday(&now_timeval, NULL);
}
dump(times);
return state;
}
void solve() {
int d;
cin >> d;
VI c(26);
VVI s(d, VI(26));
REP(i, 0, 26) { cin >> c[i]; }
REP(i, 0, d) REP(j, 0, 26) cin >> s[i][j];
int repeat = 4;
double timelimit = 1.975;
State state = sa(d, c, s, 50, 10, timelimit / repeat);
REP(loop, 1, repeat) {
State newState = sa(d, c, s, 50 + 10 * repeat, 10, timelimit / repeat);
if (state.score < newState.score)
state = newState;
dump(state.score);
}
state.show();
dump(state.score);
}
signed main() {
solve();
return 0;
}
| replace | 156 | 177 | 156 | 157 | 0 | |
p02618 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
using namespace std;
int main() {
int D;
scanf("%d", &D);
int c[26], s[D][26], last[26], ans[D];
for (int i = 0; i < 26; ++i)
scanf("%d", &c[i]);
for (int i = 0; i < D; ++i) {
for (int j = 0; j < 26; ++j)
scanf("%d", &s[i][j]);
}
fill_n(last, 26, -1);
for (int i = 0; i < D; ++i) {
int x = -1000000000, opt = 0;
for (int j = 0; j < 26; ++j) {
if (c[j] * (i - last[j]) + s[i][j] > x)
x = c[j] * (i - last[j]) + s[i][j], opt = i;
}
last[opt] = i;
ans[i] = opt;
}
for (int i = 0; i < D; ++i)
printf("%d\n", ans[i] + 1);
return 0;
} | #include <algorithm>
#include <cstdio>
using namespace std;
int main() {
int D;
scanf("%d", &D);
int c[26], s[D][26], last[26], ans[D];
for (int i = 0; i < 26; ++i)
scanf("%d", &c[i]);
for (int i = 0; i < D; ++i) {
for (int j = 0; j < 26; ++j)
scanf("%d", &s[i][j]);
}
fill_n(last, 26, -1);
for (int i = 0; i < D; ++i) {
int x = -1000000000, opt = 0;
for (int j = 0; j < 26; ++j) {
if (c[j] * (i - last[j]) + s[i][j] > x)
x = c[j] * (i - last[j]) + s[i][j], opt = j;
}
last[opt] = i;
ans[i] = opt;
}
for (int i = 0; i < D; ++i)
printf("%d\n", ans[i] + 1);
return 0;
} | replace | 18 | 19 | 18 | 19 | 0 | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
using ll = long long;
using vec = vector<ll>;
using vect = vector<double>;
using Graph = vector<vector<ll>>;
#define loop(i, n) for (ll i = 0; i < n; i++)
#define Loop(i, m, n) for (ll i = m; i < n; i++)
#define pool(i, n) for (ll i = n; i >= 0; i--)
#define Pool(i, m, n) for (ll i = n; i >= m; i--)
#define mod 1000000007ll
#define flagcount __builtin_popcount
#define flag(x) (1 << x)
#define flagadd(bit, x) bit |= flag(x)
#define flagpop(bit, x) bit &= ~flag(x)
#define flagon(bit, i) bit &flag(i)
#define flagoff(bit, i) !(bit & (1 << i))
#define all(v) v.begin(), v.end()
#define low2way(v, x) lower_bound(all(v), x)
#define high2way(v, x) upper_bound(all(v), x)
#define idx_lower(v, x) \
(distance(v.begin(), low2way(v, x))) // 配列vでx未満の要素数を返す
#define idx_upper(v, x) \
(distance(v.begin(), high2way(v, x))) // 配列vでx以下の要素数を返す
#define idx_lower2(v, x) \
(v.size() - idx_lower(v, x)) // 配列vでx以上の要素数を返す
#define idx_upper2(v, x) \
(v.size() - idx_upper(v, x)) // 配列vでxより大きい要素の数を返す
#define putout(a) cout << a << endl
#define Gput(a, b) G[a].push_back(b)
#define Sum(v) accumulate(all(v), 0ll)
#define gcd(x, y) __gcd(x, y)
ll ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
template <typename T> T lcm(T x, T y) {
T z = gcd(x, y);
return x * y / z;
}
template <typename T> bool primejudge(T n) {
if (n < 2)
return false;
else if (n == 2)
return true;
else if (n % 2 == 0)
return false;
double sqrtn = sqrt(n);
for (T i = 3; i < sqrtn + 1; i++) {
if (n % i == 0) {
return false;
}
i++;
}
return true;
}
// 場合によって使い分ける
// const ll dx[4]={1,0,-1,0};
// const ll dy[4]={0,1,0,-1};
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
// 2次元配列の宣言
// vector<vector<ll>> field(h, vector<ll>(w));
int main() {
cout << fixed << setprecision(30);
ll D;
cin >> D; //=365
vec c(26);
loop(i, 26) cin >> c[i];
vector<vector<ll>> s(D, vector<ll>(26));
loop(i, D) { loop(j, 26) cin >> s[i][j]; }
vec t(D);
loop(i, D) {
ll nowans = -10000000;
ll ans = 1;
loop(j, 26) {
if (s[i][j] > nowans)
ans = j + 1;
nowans = max(nowans, s[i][j]);
}
t[i] = ans;
}
/*
//score計算
ll score = 0;
vector<ll> before(26); //直近で何日前に開催したか？
loop(i, D)
{
score += s[i][t[i] - 1];
before[t[i] - 1] = i + 1; //リセット
//スコア減点
loop(j, 26)
{
score -= c[j] * ((i + 1) - before[j]);
}
}
*/
ll M;
M = 300000;
ll greatscore = -10000000000;
vec answer(D);
loop(k, M) {
ll d, q;
d = (rand() % D);
q = (rand() % 26) + 1;
ll old = t[d];
t[d] = q;
ll score = 0;
vector<ll> before(26); // 直近で何日前に開催したか？
loop(i, D) {
score += s[i][t[i] - 1];
before[t[i] - 1] = i + 1; // リセット
// スコア減点
loop(j, 26) { score -= c[j] * ((i + 1) - before[j]); }
}
if (greatscore < score) {
answer = t;
} else
t[d] = old;
greatscore = max(greatscore, score);
}
loop(i, D) { putout(answer[i]); }
return 0;
}
| #include <bits/stdc++.h>
#define _GLIBCXX_DEBUG
using namespace std;
using ll = long long;
using vec = vector<ll>;
using vect = vector<double>;
using Graph = vector<vector<ll>>;
#define loop(i, n) for (ll i = 0; i < n; i++)
#define Loop(i, m, n) for (ll i = m; i < n; i++)
#define pool(i, n) for (ll i = n; i >= 0; i--)
#define Pool(i, m, n) for (ll i = n; i >= m; i--)
#define mod 1000000007ll
#define flagcount __builtin_popcount
#define flag(x) (1 << x)
#define flagadd(bit, x) bit |= flag(x)
#define flagpop(bit, x) bit &= ~flag(x)
#define flagon(bit, i) bit &flag(i)
#define flagoff(bit, i) !(bit & (1 << i))
#define all(v) v.begin(), v.end()
#define low2way(v, x) lower_bound(all(v), x)
#define high2way(v, x) upper_bound(all(v), x)
#define idx_lower(v, x) \
(distance(v.begin(), low2way(v, x))) // 配列vでx未満の要素数を返す
#define idx_upper(v, x) \
(distance(v.begin(), high2way(v, x))) // 配列vでx以下の要素数を返す
#define idx_lower2(v, x) \
(v.size() - idx_lower(v, x)) // 配列vでx以上の要素数を返す
#define idx_upper2(v, x) \
(v.size() - idx_upper(v, x)) // 配列vでxより大きい要素の数を返す
#define putout(a) cout << a << endl
#define Gput(a, b) G[a].push_back(b)
#define Sum(v) accumulate(all(v), 0ll)
#define gcd(x, y) __gcd(x, y)
ll ctoi(char c) {
if (c >= '0' && c <= '9') {
return c - '0';
}
return 0;
}
template <typename T> T lcm(T x, T y) {
T z = gcd(x, y);
return x * y / z;
}
template <typename T> bool primejudge(T n) {
if (n < 2)
return false;
else if (n == 2)
return true;
else if (n % 2 == 0)
return false;
double sqrtn = sqrt(n);
for (T i = 3; i < sqrtn + 1; i++) {
if (n % i == 0) {
return false;
}
i++;
}
return true;
}
// 場合によって使い分ける
// const ll dx[4]={1,0,-1,0};
// const ll dy[4]={0,1,0,-1};
const ll dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const ll dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
// 2次元配列の宣言
// vector<vector<ll>> field(h, vector<ll>(w));
int main() {
cout << fixed << setprecision(30);
ll D;
cin >> D; //=365
vec c(26);
loop(i, 26) cin >> c[i];
vector<vector<ll>> s(D, vector<ll>(26));
loop(i, D) { loop(j, 26) cin >> s[i][j]; }
vec t(D);
loop(i, D) {
ll nowans = -10000000;
ll ans = 1;
loop(j, 26) {
if (s[i][j] > nowans)
ans = j + 1;
nowans = max(nowans, s[i][j]);
}
t[i] = ans;
}
/*
//score計算
ll score = 0;
vector<ll> before(26); //直近で何日前に開催したか？
loop(i, D)
{
score += s[i][t[i] - 1];
before[t[i] - 1] = i + 1; //リセット
//スコア減点
loop(j, 26)
{
score -= c[j] * ((i + 1) - before[j]);
}
}
*/
ll M;
M = 200000;
ll greatscore = -10000000000;
vec answer(D);
loop(k, M) {
ll d, q;
d = (rand() % D);
q = (rand() % 26) + 1;
ll old = t[d];
t[d] = q;
ll score = 0;
vector<ll> before(26); // 直近で何日前に開催したか？
loop(i, D) {
score += s[i][t[i] - 1];
before[t[i] - 1] = i + 1; // リセット
// スコア減点
loop(j, 26) { score -= c[j] * ((i + 1) - before[j]); }
}
if (greatscore < score) {
answer = t;
} else
t[d] = old;
greatscore = max(greatscore, score);
}
loop(i, D) { putout(answer[i]); }
return 0;
}
| replace | 102 | 103 | 102 | 103 | 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 rep2(i, n) for (int i = 1; i <= (int)(n); i++)
#define ll long long
#define umap unordered_map
using graph = vector<vector<int>>;
using graph2 = vector<vector<pair<int, int>>>;
#define oorret true // std::out_of_rangeが返された時
#define oor(x) \
[&]() { \
try { \
x; \
} catch (const std::out_of_range &oor) { \
return oorret; \
} \
return x; \
}()
double pi = 3.141592653589793238;
ll mod(ll x, ll y) {
if (x >= 0 || x % y == 0)
return x % y;
return y + x % y;
} // mod including minus
ll dv0(ll x, ll y) {
if (x >= 0 || x % y == 0)
return x / y;
return x / y - 1;
} // rnd down
ll dv1(ll x, ll y) {
if (x % y == 0)
return dv0(x, y);
return dv0(x, y) + 1;
} // rnd up
int D;
void calculate(vector<int> c, vector<vector<int>> s, int contest, int day,
vector<int> &t, ll &score) {
ll p = 0;
int a[26];
rep(i, 26) { a[i] = 0; }
rep(i, D) {
rep(j, 26) { p -= c[j] * (i + 1 - a[j]); }
if (i != day) {
p += s[i].at(t[i]) + c[t[i]] * (i + 1 - a[t[i]]);
a[t[i]] = i + 1;
} else {
p += s[day].at(contest) + c[contest] * (day + 1 - a[contest]);
a[contest] = i + 1;
}
}
if (score < p) {
score = p;
t[day] = contest;
}
}
int main() {
cin >> D;
vector<int> c(26);
rep(i, 26) { cin >> c[i]; }
vector<vector<int>> s(D);
int r;
rep(i, D) {
rep(j, 26) {
cin >> r;
s[i].push_back(r);
}
}
int M2 = 0, M3 = 0, M4 = 0, M5 = 0, M6 = 0, M7 = 0, M8 = 0;
vector<int> m2(D);
vector<int> m3(D);
vector<int> m4(D);
vector<int> m5(D);
vector<int> m6(D);
vector<int> m7(D);
vector<int> m8(D);
vector<int> a(26);
vector<int> m(D);
rep(i, 26) { a[i] = 0; }
int M = 0;
rep(i, D) {}
vector<int> t(D);
ll score = 0;
rep(i, D) {
M = 0;
M2 = 0;
M3 = 0;
M4 = 0;
M5 = 0;
M6 = 0;
M7 = 0;
M8 = 0;
rep(j, 26) {
score -= c[j] * (i + 1 - a[j]);
if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M) {
M8 = M7;
M7 = M6;
M6 = M5;
M5 = M4;
M4 = M3;
M3 = M2;
M2 = M;
M = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = m7[i];
m7[i] = m6[i];
m6[i] = m5[i];
m5[i] = m4[i];
m4[i] = m3[i];
m3[i] = m2[i];
m2[i] = m[i];
m[i] = j;
} else if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M2) {
M8 = M7;
M7 = M6;
M6 = M5;
M5 = M4;
M4 = M3;
M3 = M2;
M2 = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = m7[i];
m7[i] = m6[i];
m6[i] = m5[i];
m5[i] = m4[i];
m4[i] = m3[i];
m3[i] = m2[i];
m2[i] = j;
} else if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M3) {
M8 = M7;
M7 = M6;
M6 = M5;
M5 = M4;
M4 = M3;
M3 = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = m7[i];
m7[i] = m6[i];
m6[i] = m5[i];
m5[i] = m4[i];
m4[i] = m3[i];
m3[i] = j;
} else if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M4) {
M8 = M7;
M7 = M6;
M6 = M5;
M5 = M4;
M4 = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = m7[i];
m7[i] = m6[i];
m6[i] = m5[i];
m5[i] = m4[i];
m4[i] = j;
} else if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M5) {
M8 = M7;
M7 = M6;
M6 = M5;
M5 = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = m7[i];
m7[i] = m6[i];
m6[i] = m5[i];
m5[i] = j;
} else if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M6) {
M8 = M7;
M7 = M6;
M6 = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = m7[i];
m7[i] = m6[i];
m6[i] = j;
} else if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M7) {
M8 = M7;
M7 = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = m7[i];
m7[i] = j;
} else if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M8) {
M8 = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = j;
}
}
score += M;
a[m[i]] = i + 1;
t[i] = m[i];
}
rep(j, 32) {
rep(i, D) { calculate(c, s, m2[i], i, t, score); }
rep(i, D) { calculate(c, s, m3[i], i, t, score); }
rep(i, D) { calculate(c, s, m4[i], i, t, score); }
rep(i, D) { calculate(c, s, m5[i], i, t, score); }
rep(i, D) { calculate(c, s, m6[i], i, t, score); }
rep(i, D) { calculate(c, s, m7[i], i, t, score); }
rep(i, D) { calculate(c, s, m8[i], i, t, score); }
rep(i, D) { calculate(c, s, m[i], i, t, score); }
}
rep(i, D) { cout << t[i] + 1 << endl; }
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, n) for (int i = 1; i <= (int)(n); i++)
#define ll long long
#define umap unordered_map
using graph = vector<vector<int>>;
using graph2 = vector<vector<pair<int, int>>>;
#define oorret true // std::out_of_rangeが返された時
#define oor(x) \
[&]() { \
try { \
x; \
} catch (const std::out_of_range &oor) { \
return oorret; \
} \
return x; \
}()
double pi = 3.141592653589793238;
ll mod(ll x, ll y) {
if (x >= 0 || x % y == 0)
return x % y;
return y + x % y;
} // mod including minus
ll dv0(ll x, ll y) {
if (x >= 0 || x % y == 0)
return x / y;
return x / y - 1;
} // rnd down
ll dv1(ll x, ll y) {
if (x % y == 0)
return dv0(x, y);
return dv0(x, y) + 1;
} // rnd up
int D;
void calculate(vector<int> c, vector<vector<int>> s, int contest, int day,
vector<int> &t, ll &score) {
ll p = 0;
int a[26];
rep(i, 26) { a[i] = 0; }
rep(i, D) {
rep(j, 26) { p -= c[j] * (i + 1 - a[j]); }
if (i != day) {
p += s[i].at(t[i]) + c[t[i]] * (i + 1 - a[t[i]]);
a[t[i]] = i + 1;
} else {
p += s[day].at(contest) + c[contest] * (day + 1 - a[contest]);
a[contest] = i + 1;
}
}
if (score < p) {
score = p;
t[day] = contest;
}
}
int main() {
cin >> D;
vector<int> c(26);
rep(i, 26) { cin >> c[i]; }
vector<vector<int>> s(D);
int r;
rep(i, D) {
rep(j, 26) {
cin >> r;
s[i].push_back(r);
}
}
int M2 = 0, M3 = 0, M4 = 0, M5 = 0, M6 = 0, M7 = 0, M8 = 0;
vector<int> m2(D);
vector<int> m3(D);
vector<int> m4(D);
vector<int> m5(D);
vector<int> m6(D);
vector<int> m7(D);
vector<int> m8(D);
vector<int> a(26);
vector<int> m(D);
rep(i, 26) { a[i] = 0; }
int M = 0;
rep(i, D) {}
vector<int> t(D);
ll score = 0;
rep(i, D) {
M = 0;
M2 = 0;
M3 = 0;
M4 = 0;
M5 = 0;
M6 = 0;
M7 = 0;
M8 = 0;
rep(j, 26) {
score -= c[j] * (i + 1 - a[j]);
if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M) {
M8 = M7;
M7 = M6;
M6 = M5;
M5 = M4;
M4 = M3;
M3 = M2;
M2 = M;
M = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = m7[i];
m7[i] = m6[i];
m6[i] = m5[i];
m5[i] = m4[i];
m4[i] = m3[i];
m3[i] = m2[i];
m2[i] = m[i];
m[i] = j;
} else if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M2) {
M8 = M7;
M7 = M6;
M6 = M5;
M5 = M4;
M4 = M3;
M3 = M2;
M2 = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = m7[i];
m7[i] = m6[i];
m6[i] = m5[i];
m5[i] = m4[i];
m4[i] = m3[i];
m3[i] = m2[i];
m2[i] = j;
} else if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M3) {
M8 = M7;
M7 = M6;
M6 = M5;
M5 = M4;
M4 = M3;
M3 = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = m7[i];
m7[i] = m6[i];
m6[i] = m5[i];
m5[i] = m4[i];
m4[i] = m3[i];
m3[i] = j;
} else if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M4) {
M8 = M7;
M7 = M6;
M6 = M5;
M5 = M4;
M4 = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = m7[i];
m7[i] = m6[i];
m6[i] = m5[i];
m5[i] = m4[i];
m4[i] = j;
} else if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M5) {
M8 = M7;
M7 = M6;
M6 = M5;
M5 = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = m7[i];
m7[i] = m6[i];
m6[i] = m5[i];
m5[i] = j;
} else if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M6) {
M8 = M7;
M7 = M6;
M6 = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = m7[i];
m7[i] = m6[i];
m6[i] = j;
} else if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M7) {
M8 = M7;
M7 = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = m7[i];
m7[i] = j;
} else if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M8) {
M8 = s[i].at(j) + c[j] * (i + 1 - a[j]);
m8[i] = j;
}
}
score += M;
a[m[i]] = i + 1;
t[i] = m[i];
}
rep(j, 20) {
rep(i, D) { calculate(c, s, m2[i], i, t, score); }
rep(i, D) { calculate(c, s, m3[i], i, t, score); }
rep(i, D) { calculate(c, s, m4[i], i, t, score); }
rep(i, D) { calculate(c, s, m5[i], i, t, score); }
rep(i, D) { calculate(c, s, m6[i], i, t, score); }
rep(i, D) { calculate(c, s, m7[i], i, t, score); }
rep(i, D) { calculate(c, s, m8[i], i, t, score); }
rep(i, D) { calculate(c, s, m[i], i, t, score); }
}
rep(i, D) { cout << t[i] + 1 << endl; }
}
| replace | 182 | 183 | 182 | 183 | 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 rep2(i, n) for (int i = 1; i <= (int)(n); i++)
#define ll long long
#define umap unordered_map
using graph = vector<vector<int>>;
using graph2 = vector<vector<pair<int, int>>>;
#define oorret true // std::out_of_rangeが返された時
#define oor(x) \
[&]() { \
try { \
x; \
} catch (const std::out_of_range &oor) { \
return oorret; \
} \
return x; \
}()
double pi = 3.141592653589793238;
ll mod(ll x, ll y) {
if (x >= 0 || x % y == 0)
return x % y;
return y + x % y;
} // mod including minus
ll dv0(ll x, ll y) {
if (x >= 0 || x % y == 0)
return x / y;
return x / y - 1;
} // rnd down
ll dv1(ll x, ll y) {
if (x % y == 0)
return dv0(x, y);
return dv0(x, y) + 1;
} // rnd up
int D;
void calculate(vector<int> c, vector<vector<int>> s, int contest, int day,
vector<int> &t, ll &score) {
ll p = 0;
int a[26];
rep(i, 26) { a[i] = 0; }
rep(i, D) {
rep(j, 26) { p -= c[j] * (i + 1 - a[j]); }
if (i != day) {
p += s[i].at(t[i]) + c[t[i]] * (i + 1 - a[t[i]]);
a[t[i]] = i + 1;
} else {
p += s[day].at(contest) + c[contest] * (day + 1 - a[contest]);
a[contest] = i + 1;
}
}
if (score < p) {
score = p;
t[day] = contest;
}
}
int main() {
cin >> D;
vector<int> c(26);
rep(i, 26) { cin >> c[i]; }
vector<vector<int>> s(D);
int r;
rep(i, D) {
rep(j, 26) {
cin >> r;
s[i].push_back(r);
}
}
int M[26];
rep(i, 26) { M[i] = 0; }
vector<vector<int>> m(D);
rep(i, D) {
rep(j, 26) { m[i].push_back(0); }
}
vector<int> a(26);
rep(i, 26) { a[i] = 0; }
rep(i, D) {}
vector<int> t(D);
ll score = 0;
rep(i, D) {
rep(j, 26) { M[j] = 0; }
rep(j, 26) {
score -= c[j] * (i + 1 - a[j]);
rep(k, j + 1) {
if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M[k]) {
rep(l, j - k) {
M[j - l] = M[j - l - 1];
m[i].at(j - l) = m[i].at(j - l - 1);
}
M[k] = s[i].at(j) + c[j] * (i + 1 - a[j]);
m[i].at(k) = j;
}
}
}
score += M[0];
a[m[i].at(0)] = i + 1;
t[i] = m[i].at(0);
}
rep(j, 25) {
rep(i, j + 2) {
rep(k, D) { calculate(c, s, m[k].at(j + 1 - i), k, t, score); }
}
}
rep(i, D) { cout << t[i] + 1 << endl; }
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, n) for (int i = 1; i <= (int)(n); i++)
#define ll long long
#define umap unordered_map
using graph = vector<vector<int>>;
using graph2 = vector<vector<pair<int, int>>>;
#define oorret true // std::out_of_rangeが返された時
#define oor(x) \
[&]() { \
try { \
x; \
} catch (const std::out_of_range &oor) { \
return oorret; \
} \
return x; \
}()
double pi = 3.141592653589793238;
ll mod(ll x, ll y) {
if (x >= 0 || x % y == 0)
return x % y;
return y + x % y;
} // mod including minus
ll dv0(ll x, ll y) {
if (x >= 0 || x % y == 0)
return x / y;
return x / y - 1;
} // rnd down
ll dv1(ll x, ll y) {
if (x % y == 0)
return dv0(x, y);
return dv0(x, y) + 1;
} // rnd up
int D;
void calculate(vector<int> c, vector<vector<int>> s, int contest, int day,
vector<int> &t, ll &score) {
ll p = 0;
int a[26];
rep(i, 26) { a[i] = 0; }
rep(i, D) {
rep(j, 26) { p -= c[j] * (i + 1 - a[j]); }
if (i != day) {
p += s[i].at(t[i]) + c[t[i]] * (i + 1 - a[t[i]]);
a[t[i]] = i + 1;
} else {
p += s[day].at(contest) + c[contest] * (day + 1 - a[contest]);
a[contest] = i + 1;
}
}
if (score < p) {
score = p;
t[day] = contest;
}
}
int main() {
cin >> D;
vector<int> c(26);
rep(i, 26) { cin >> c[i]; }
vector<vector<int>> s(D);
int r;
rep(i, D) {
rep(j, 26) {
cin >> r;
s[i].push_back(r);
}
}
int M[26];
rep(i, 26) { M[i] = 0; }
vector<vector<int>> m(D);
rep(i, D) {
rep(j, 26) { m[i].push_back(0); }
}
vector<int> a(26);
rep(i, 26) { a[i] = 0; }
rep(i, D) {}
vector<int> t(D);
ll score = 0;
rep(i, D) {
rep(j, 26) { M[j] = 0; }
rep(j, 26) {
score -= c[j] * (i + 1 - a[j]);
rep(k, j + 1) {
if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M[k]) {
rep(l, j - k) {
M[j - l] = M[j - l - 1];
m[i].at(j - l) = m[i].at(j - l - 1);
}
M[k] = s[i].at(j) + c[j] * (i + 1 - a[j]);
m[i].at(k) = j;
}
}
}
score += M[0];
a[m[i].at(0)] = i + 1;
t[i] = m[i].at(0);
}
rep(j, 20) {
rep(i, j + 2) {
rep(k, D) { calculate(c, s, m[k].at(j + 1 - i), k, t, score); }
}
}
rep(i, D) { cout << t[i] + 1 << endl; }
}
| replace | 99 | 100 | 99 | 100 | 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 rep2(i, n) for (int i = 1; i <= (int)(n); i++)
#define ll long long
#define umap unordered_map
using graph = vector<vector<int>>;
using graph2 = vector<vector<pair<int, int>>>;
#define oorret true // std::out_of_rangeが返された時
#define oor(x) \
[&]() { \
try { \
x; \
} catch (const std::out_of_range &oor) { \
return oorret; \
} \
return x; \
}()
double pi = 3.141592653589793238;
ll mod(ll x, ll y) {
if (x >= 0 || x % y == 0)
return x % y;
return y + x % y;
} // mod including minus
ll dv0(ll x, ll y) {
if (x >= 0 || x % y == 0)
return x / y;
return x / y - 1;
} // rnd down
ll dv1(ll x, ll y) {
if (x % y == 0)
return dv0(x, y);
return dv0(x, y) + 1;
} // rnd up
int D;
void calculate(vector<int> c, vector<vector<int>> s, int contest, int day,
vector<int> &t, ll &score) {
ll p = 0;
int a[26];
rep(i, 26) { a[i] = 0; }
rep(i, D) {
rep(j, 26) { p -= c[j] * (i + 1 - a[j]); }
if (i != day) {
p += s[i].at(t[i]) + c[t[i]] * (i + 1 - a[t[i]]);
a[t[i]] = i + 1;
} else {
p += s[day].at(contest) + c[contest] * (day + 1 - a[contest]);
a[contest] = i + 1;
}
}
if (score < p) {
score = p;
t[day] = contest;
}
}
int main() {
cin >> D;
vector<int> c(26);
rep(i, 26) { cin >> c[i]; }
vector<vector<int>> s(D);
int r;
rep(i, D) {
rep(j, 26) {
cin >> r;
s[i].push_back(r);
}
}
int M[26];
rep(i, 26) { M[i] = 0; }
vector<vector<int>> m(D);
rep(i, D) {
rep(j, 26) { m[i].push_back(0); }
}
vector<int> a(26);
rep(i, 26) { a[i] = 0; }
rep(i, D) {}
vector<int> t(D);
ll score = 0;
rep(i, D) {
rep(j, 26) { M[j] = 0; }
rep(j, 26) {
score -= c[j] * (i + 1 - a[j]);
rep(k, j + 1) {
if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M[k]) {
rep(l, j - k) {
M[j - l] = M[j - l - 1];
m[i].at(j - l) = m[i].at(j - l - 1);
}
M[k] = s[i].at(j) + c[j] * (i + 1 - a[j]);
m[i].at(k) = j;
}
}
}
score += M[0];
a[m[i].at(0)] = i + 1;
t[i] = m[i].at(0);
}
rep(j, 30) {
rep(i, j + 2) {
rep(k, D) { calculate(c, s, m[k].at((j + 1 - i) / 2 + 1), k, t, score); }
}
}
rep(i, D) { cout << t[i] + 1 << endl; }
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep2(i, n) for (int i = 1; i <= (int)(n); i++)
#define ll long long
#define umap unordered_map
using graph = vector<vector<int>>;
using graph2 = vector<vector<pair<int, int>>>;
#define oorret true // std::out_of_rangeが返された時
#define oor(x) \
[&]() { \
try { \
x; \
} catch (const std::out_of_range &oor) { \
return oorret; \
} \
return x; \
}()
double pi = 3.141592653589793238;
ll mod(ll x, ll y) {
if (x >= 0 || x % y == 0)
return x % y;
return y + x % y;
} // mod including minus
ll dv0(ll x, ll y) {
if (x >= 0 || x % y == 0)
return x / y;
return x / y - 1;
} // rnd down
ll dv1(ll x, ll y) {
if (x % y == 0)
return dv0(x, y);
return dv0(x, y) + 1;
} // rnd up
int D;
void calculate(vector<int> c, vector<vector<int>> s, int contest, int day,
vector<int> &t, ll &score) {
ll p = 0;
int a[26];
rep(i, 26) { a[i] = 0; }
rep(i, D) {
rep(j, 26) { p -= c[j] * (i + 1 - a[j]); }
if (i != day) {
p += s[i].at(t[i]) + c[t[i]] * (i + 1 - a[t[i]]);
a[t[i]] = i + 1;
} else {
p += s[day].at(contest) + c[contest] * (day + 1 - a[contest]);
a[contest] = i + 1;
}
}
if (score < p) {
score = p;
t[day] = contest;
}
}
int main() {
cin >> D;
vector<int> c(26);
rep(i, 26) { cin >> c[i]; }
vector<vector<int>> s(D);
int r;
rep(i, D) {
rep(j, 26) {
cin >> r;
s[i].push_back(r);
}
}
int M[26];
rep(i, 26) { M[i] = 0; }
vector<vector<int>> m(D);
rep(i, D) {
rep(j, 26) { m[i].push_back(0); }
}
vector<int> a(26);
rep(i, 26) { a[i] = 0; }
rep(i, D) {}
vector<int> t(D);
ll score = 0;
rep(i, D) {
rep(j, 26) { M[j] = 0; }
rep(j, 26) {
score -= c[j] * (i + 1 - a[j]);
rep(k, j + 1) {
if (s[i].at(j) + c[j] * (i + 1 - a[j]) > M[k]) {
rep(l, j - k) {
M[j - l] = M[j - l - 1];
m[i].at(j - l) = m[i].at(j - l - 1);
}
M[k] = s[i].at(j) + c[j] * (i + 1 - a[j]);
m[i].at(k) = j;
}
}
}
score += M[0];
a[m[i].at(0)] = i + 1;
t[i] = m[i].at(0);
}
rep(j, 20) {
rep(i, j + 1) {
rep(k, D) { calculate(c, s, m[k].at(i), k, t, score); }
}
}
rep(i, D) { cout << t[i] + 1 << endl; }
}
| replace | 99 | 102 | 99 | 102 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using ll = long long;
vector<int> c;
vector<vector<int>> s;
int D;
vector<int> v;
vector<set<int>> U;
vector<set<int>> minusU;
int now;
ll calc() {
ll ans = 0;
vector<int> last(26, 0);
for (int i = 0; i < D; i++) {
last[v[i] - 1] = i + 1;
ans += s[i][v[i] - 1];
// cout<<s[i][v[i] - 1]<<endl;
for (int j = 0; j < 26; j++) {
ans -= (ll)(i + 1 - last[j]) * c[j];
}
}
now = ans;
return ans;
}
ll calc(int d, int i) {
int prev = v[d];
now += s[d][i];
now -= s[d][prev];
int n = *U[i].upper_bound(d);
int p = -*minusU[i].upper_bound(-d);
int term = n - p - 1;
now += term * (term + 1) / 2 * c[i];
now -= (n - d) * (n - d - 1) / 2 + (d - p - 1) * (d - p) / 2 * c[i];
n = *U[prev].upper_bound(d);
p = -*minusU[prev].upper_bound(-d);
term = n - p - 1;
now -= term * (term + 1) / 2 * c[prev];
now += (n - d) * (n - d - 1) / 2 + (d - p - 1) * (d - p) / 2 * c[prev];
v[d] = i;
U[prev].erase(d);
minusU[prev].erase(-d);
U[d].insert(d);
minusU[prev].insert(-d);
return now;
}
int retrnd(int n) { // 乱数生成
std::random_device rnd;
std::mt19937 mt(rnd());
std::uniform_int_distribution<> rand100(0, n);
return rand100(mt);
}
int main() {
cin >> D;
for (int i = 0; i < 26; i++) {
int a;
cin >> a;
c.push_back(a);
}
for (int i = 0; i < D; i++) {
vector<int> a;
for (int j = 0; j < 26; j++) {
int b;
cin >> b;
a.push_back(b);
}
s.push_back(a);
}
U = vector<set<int>>(26);
minusU = vector<set<int>>(26);
for (int i = 0; i < 26; i++) {
U[i].insert(0);
U[i].insert(D);
minusU[i].insert(0);
minusU[i].insert(D);
}
for (int i = 0; i < D; i++) {
v.push_back(retrnd(25) + 1);
U[v.back() - 1].insert(i);
U[v.back() - 1].insert(-i);
}
now = calc();
int try_cnt = 5000;
for (int cnt = 0; cnt < try_cnt; cnt++) {
int rnd = retrnd(D - 1);
for (int i = 1; i < 27; i++) {
int p = now;
int prev = v[rnd];
v[rnd] = i;
calc();
if (now < p) {
v[rnd] = prev;
calc();
}
}
}
for (int i = 0; i < D; i++) {
cout << v[i] << endl;
}
} | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using ll = long long;
vector<int> c;
vector<vector<int>> s;
int D;
vector<int> v;
vector<set<int>> U;
vector<set<int>> minusU;
int now;
ll calc() {
ll ans = 0;
vector<int> last(26, 0);
for (int i = 0; i < D; i++) {
last[v[i] - 1] = i + 1;
ans += s[i][v[i] - 1];
// cout<<s[i][v[i] - 1]<<endl;
for (int j = 0; j < 26; j++) {
ans -= (ll)(i + 1 - last[j]) * c[j];
}
}
now = ans;
return ans;
}
ll calc(int d, int i) {
int prev = v[d];
now += s[d][i];
now -= s[d][prev];
int n = *U[i].upper_bound(d);
int p = -*minusU[i].upper_bound(-d);
int term = n - p - 1;
now += term * (term + 1) / 2 * c[i];
now -= (n - d) * (n - d - 1) / 2 + (d - p - 1) * (d - p) / 2 * c[i];
n = *U[prev].upper_bound(d);
p = -*minusU[prev].upper_bound(-d);
term = n - p - 1;
now -= term * (term + 1) / 2 * c[prev];
now += (n - d) * (n - d - 1) / 2 + (d - p - 1) * (d - p) / 2 * c[prev];
v[d] = i;
U[prev].erase(d);
minusU[prev].erase(-d);
U[d].insert(d);
minusU[prev].insert(-d);
return now;
}
int retrnd(int n) { // 乱数生成
std::random_device rnd;
std::mt19937 mt(rnd());
std::uniform_int_distribution<> rand100(0, n);
return rand100(mt);
}
int main() {
cin >> D;
for (int i = 0; i < 26; i++) {
int a;
cin >> a;
c.push_back(a);
}
for (int i = 0; i < D; i++) {
vector<int> a;
for (int j = 0; j < 26; j++) {
int b;
cin >> b;
a.push_back(b);
}
s.push_back(a);
}
U = vector<set<int>>(26);
minusU = vector<set<int>>(26);
for (int i = 0; i < 26; i++) {
U[i].insert(0);
U[i].insert(D);
minusU[i].insert(0);
minusU[i].insert(D);
}
for (int i = 0; i < D; i++) {
v.push_back(retrnd(25) + 1);
U[v.back() - 1].insert(i);
U[v.back() - 1].insert(-i);
}
now = calc();
int try_cnt = 1000;
for (int cnt = 0; cnt < try_cnt; cnt++) {
int rnd = retrnd(D - 1);
for (int i = 1; i < 27; i++) {
int p = now;
int prev = v[rnd];
v[rnd] = i;
calc();
if (now < p) {
v[rnd] = prev;
calc();
}
}
}
for (int i = 0; i < D; i++) {
cout << v[i] << endl;
}
} | replace | 91 | 92 | 91 | 92 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using ll = long long;
vector<int> c;
vector<vector<int>> s;
int D;
vector<int> v;
vector<set<int>> U;
ll calc() {
ll ans = 0;
vector<int> last(26, 0);
for (int i = 0; i < D; i++) {
last[v[i] - 1] = i + 1;
ans += s[i][v[i] - 1];
// cout<<s[i][v[i] - 1]<<endl;
for (int j = 0; j < 26; j++) {
ans -= (ll)(i + 1 - last[j]) * c[j];
}
}
return ans;
}
int retrnd(int n) { // 乱数生成
std::random_device rnd;
std::mt19937 mt(rnd());
std::uniform_int_distribution<> rand100(0, n);
return rand100(mt);
}
int main() {
cin >> D;
for (int i = 0; i < 26; i++) {
int a;
cin >> a;
c.push_back(a);
}
for (int i = 0; i < D; i++) {
vector<int> a;
for (int j = 0; j < 26; j++) {
int b;
cin >> b;
a.push_back(b);
}
s.push_back(a);
}
U = vector<set<int>>(26);
for (int i = 0; i < D; i++) {
v.push_back(retrnd(25) + 1);
}
int now = calc();
int try_cnt = 10000;
for (int cnt = 0; cnt < try_cnt; cnt++) {
int rnd = retrnd(D - 1);
for (int i = 1; i < 27; i++) {
int prev = v[rnd];
v[rnd] = i;
int w = calc();
if (now > w) {
v[rnd] = prev;
} else {
now = w;
}
}
}
for (int i = 0; i < D; i++) {
cout << v[i] << endl;
}
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tag_and_trait.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using ll = long long;
vector<int> c;
vector<vector<int>> s;
int D;
vector<int> v;
vector<set<int>> U;
ll calc() {
ll ans = 0;
vector<int> last(26, 0);
for (int i = 0; i < D; i++) {
last[v[i] - 1] = i + 1;
ans += s[i][v[i] - 1];
// cout<<s[i][v[i] - 1]<<endl;
for (int j = 0; j < 26; j++) {
ans -= (ll)(i + 1 - last[j]) * c[j];
}
}
return ans;
}
int retrnd(int n) { // 乱数生成
std::random_device rnd;
std::mt19937 mt(rnd());
std::uniform_int_distribution<> rand100(0, n);
return rand100(mt);
}
int main() {
cin >> D;
for (int i = 0; i < 26; i++) {
int a;
cin >> a;
c.push_back(a);
}
for (int i = 0; i < D; i++) {
vector<int> a;
for (int j = 0; j < 26; j++) {
int b;
cin >> b;
a.push_back(b);
}
s.push_back(a);
}
U = vector<set<int>>(26);
for (int i = 0; i < D; i++) {
v.push_back(retrnd(25) + 1);
}
int now = calc();
int try_cnt = 1000;
for (int cnt = 0; cnt < try_cnt; cnt++) {
int rnd = retrnd(D - 1);
for (int i = 1; i < 27; i++) {
int prev = v[rnd];
v[rnd] = i;
int w = calc();
if (now > w) {
v[rnd] = prev;
} else {
now = w;
}
}
}
for (int i = 0; i < D; i++) {
cout << v[i] << endl;
}
}
| replace | 57 | 58 | 57 | 58 | TLE | |
p02618 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
// #define int long long
typedef long long ll;
const int INF = 2e9;
// const ll INF = 9e18;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int D;
cin >> D;
vector<int> c(26);
for (int i = 0; i < 26; i++)
cin >> c[i];
vector<vector<int>> s(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(D);
// 初期t[i]の決定
for (int i = 0; i < D; i++) {
t[i] = i % 26;
}
ll oldsum = -INF;
for (int m = 0; m < 100000; m++) {
// ここでt[i]を更新していく
int process = rand() % 2;
if (process == 0) {
int dd = rand() % D;
int qq = rand() % 26;
int oldval = t[dd];
t[dd] = qq;
ll sum = 0;
vector<int> last(26);
for (ll i = 0; i < D; i++) {
sum += s[i][t[i]];
last[t[i]] = i + 1;
for (int j = 0; j < 26; j++) {
sum -= c[j] * (i + 1 - last[j]);
}
}
if (sum > oldsum) {
oldsum = sum;
} else {
t[dd] = oldval;
}
} else {
int dd1 = rand() % D;
int dd2 = dd1 + rand() % (D - dd1 - 1);
int qq1 = t[dd1];
int qq2 = t[dd2];
t[dd1] = qq2;
t[dd2] = qq1;
ll sum = 0;
vector<int> last(26);
for (ll i = 0; i < D; i++) {
sum += s[i][t[i]];
last[t[i]] = i + 1;
for (int j = 0; j < 26; j++) {
sum -= c[j] * (i + 1 - last[j]);
}
}
if (sum > oldsum) {
oldsum = sum;
} else {
t[dd1] = qq1;
t[dd2] = qq2;
}
}
//=======================
}
for (int i = 0; i < D; i++) {
cout << t[i] + 1 << "\n";
}
} | #include <bits/stdc++.h>
using namespace std;
// #define int long long
typedef long long ll;
const int INF = 2e9;
// const ll INF = 9e18;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int D;
cin >> D;
vector<int> c(26);
for (int i = 0; i < 26; i++)
cin >> c[i];
vector<vector<int>> s(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(D);
// 初期t[i]の決定
for (int i = 0; i < D; i++) {
t[i] = i % 26;
}
ll oldsum = -INF;
for (int m = 0; m < 100000; m++) {
// ここでt[i]を更新していく
int process = rand() % 2;
if (process == 0) {
int dd = rand() % D;
int qq = rand() % 26;
int oldval = t[dd];
t[dd] = qq;
ll sum = 0;
vector<int> last(26);
for (ll i = 0; i < D; i++) {
sum += s[i][t[i]];
last[t[i]] = i + 1;
for (int j = 0; j < 26; j++) {
sum -= c[j] * (i + 1 - last[j]);
}
}
if (sum > oldsum) {
oldsum = sum;
} else {
t[dd] = oldval;
}
} else {
int dd1 = rand() % (D - 1);
int dd2 = dd1 + 1 + rand() % (D - dd1 - 1);
int qq1 = t[dd1];
int qq2 = t[dd2];
t[dd1] = qq2;
t[dd2] = qq1;
ll sum = 0;
vector<int> last(26);
for (ll i = 0; i < D; i++) {
sum += s[i][t[i]];
last[t[i]] = i + 1;
for (int j = 0; j < 26; j++) {
sum -= c[j] * (i + 1 - last[j]);
}
}
if (sum > oldsum) {
oldsum = sum;
} else {
t[dd1] = qq1;
t[dd2] = qq2;
}
}
//=======================
}
for (int i = 0; i < D; i++) {
cout << t[i] + 1 << "\n";
}
} | replace | 52 | 54 | 52 | 54 | -8 | |
p02618 | C++ | Time Limit Exceeded | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pll pair<ll, ll>
#define pq priority_queue
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define ios ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define lb(c, x) distance(c.begin(), lower_bound(all(c), x))
#define ub(c, x) distance(c.begin(), upper_bound(all(c), x))
using namespace std;
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 ll mod = 1e9 + 7;
int main() {
ll d;
cin >> d;
vector<ll> c(26);
rep(i, 26) { cin >> c[i]; }
vector<vector<pll>> s(d);
rep(i, d) {
rep(j, 26) {
ll v;
cin >> v;
s[i].push_back(make_pair(v, j + 1));
}
sort(s[i].rbegin(), s[i].rend());
}
vector<ll> ans(d), used(26);
ll tot = d;
ll cnt = 0;
while (tot) {
rep(i, 26) {
if (used[s[tot - 1][i].se - 1] == 0) {
used[s[tot - 1][i].se - 1] = 1;
ans[tot - 1] = s[tot - 1][i].se;
tot--;
cnt++;
break;
}
}
if (cnt == 26) {
used = vector<ll>(26, 0LL);
}
}
rep(i, d) { cout << ans[i] << endl; }
return 0;
} | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define ll long long
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pll pair<ll, ll>
#define pq priority_queue
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define ios ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#define lb(c, x) distance(c.begin(), lower_bound(all(c), x))
#define ub(c, x) distance(c.begin(), upper_bound(all(c), x))
using namespace std;
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 ll mod = 1e9 + 7;
int main() {
ll d;
cin >> d;
vector<ll> c(26);
rep(i, 26) { cin >> c[i]; }
vector<vector<pll>> s(d);
rep(i, d) {
rep(j, 26) {
ll v;
cin >> v;
s[i].push_back(make_pair(v, j + 1));
}
sort(s[i].rbegin(), s[i].rend());
}
vector<ll> ans(d), used(26);
ll tot = d;
ll cnt = 0;
while (tot) {
rep(i, 26) {
if (used[s[tot - 1][i].se - 1] == 0) {
used[s[tot - 1][i].se - 1] = 1;
ans[tot - 1] = s[tot - 1][i].se;
tot--;
cnt++;
break;
}
}
if (cnt == 26) {
for (ll i = d - 27; i >= 0; i--) {
ans[i] = s[i][0].se;
tot--;
}
break;
}
}
rep(i, d) { cout << ans[i] << endl; }
return 0;
} | replace | 61 | 62 | 61 | 66 | TLE | |
p02618 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define For(i, a, b) for (int(i) = (int)(a); (i) < (int)(b); ++(i))
#define rFor(i, a, b) for (int(i) = (int)(a)-1; (i) >= (int)(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef unsigned long long ulint;
typedef pair<int, int> pii;
typedef pair<lint, lint> pll;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> T div_floor(T a, T b) {
if (b < 0)
a *= -1, b *= -1;
return a >= 0 ? a / b : (a + 1) / b - 1;
}
template <class T> T div_ceil(T a, T b) {
if (b < 0)
a *= -1, b *= -1;
return a > 0 ? (a - 1) / b + 1 : a / b;
}
constexpr lint mod = 1e9 + 7;
constexpr lint INF = mod * mod;
constexpr int MAX = 200010;
int D, contests[370], ans[370];
lint c[30], s[370][30];
set<int> held_days[30];
lint best_score;
lint get_score(int dd) {
For(i, 1, 27) {
held_days[i].clear();
held_days[i].insert(0);
held_days[i].insert(D + 1);
}
lint ret = 0;
For(day, 1, dd + 1) {
For(i, 1, 27) {
if (contests[day] == i) {
ret += s[day][i];
held_days[i].insert(day);
} else
ret -= c[i] * (day - *next(held_days[i].rbegin()));
}
}
return ret;
}
lint fsum(int n) { return n * (n + 1) / 2; }
lint score_diff(int day, int idx) {
lint ret = 0;
int prev_id = contests[day];
contests[day] = idx;
ret += s[day][idx];
auto r = held_days[idx].lower_bound(day), l = prev(r);
ret += c[idx] * fsum(*r - 1 - *l);
ret -= c[idx] * (fsum(day - 1 - *l) + fsum(*r - 1 - day));
held_days[idx].insert(day);
ret -= s[day][prev_id];
auto m = held_days[prev_id].find(day);
r = next(m);
l = prev(m);
ret += c[prev_id] * (fsum(day - 1 - *l) + fsum(*r - 1 - day));
ret -= c[prev_id] * fsum(*r - 1 - *l);
held_days[prev_id].erase(day);
return ret;
}
void input() {
scanf("%d", &D);
For(i, 1, 27) scanf("%lld", &c[i]);
For(i, 1, D + 1) For(j, 1, 27) scanf("%lld", &s[i][j]);
}
void output() { For(i, 1, D + 1) printf("%d\n", ans[i]); }
int main() {
input();
For(i, 1, D + 1) ans[i] = contests[i] = i % 26 + 1;
double temperature = 10000, colding_rate = 0.99999;
lint score = get_score(D);
best_score = score;
random_device rd;
mt19937 mt(rd());
uniform_real_distribution<> dist(0.0, 1.0);
clock_t start = clock();
while ((clock() - start) / CLOCKS_PER_SEC < 1.8) {
int day = mt() % D + 1;
int idx = mt() % 26 + 1;
int prev_id = contests[day];
lint diff = score_diff(day, idx);
if (diff > 0)
score += diff;
else {
double prob = dist(mt);
if (prob <= exp(diff / temperature))
score += diff;
else
score_diff(day, prev_id);
}
if (chmax(best_score, score)) {
For(i, 1, D + 1) ans[i] = contests[i];
}
temperature *= colding_rate;
}
output();
} | #include <bits/stdc++.h>
#define For(i, a, b) for (int(i) = (int)(a); (i) < (int)(b); ++(i))
#define rFor(i, a, b) for (int(i) = (int)(a)-1; (i) >= (int)(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef unsigned long long ulint;
typedef pair<int, int> pii;
typedef pair<lint, lint> pll;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> T div_floor(T a, T b) {
if (b < 0)
a *= -1, b *= -1;
return a >= 0 ? a / b : (a + 1) / b - 1;
}
template <class T> T div_ceil(T a, T b) {
if (b < 0)
a *= -1, b *= -1;
return a > 0 ? (a - 1) / b + 1 : a / b;
}
constexpr lint mod = 1e9 + 7;
constexpr lint INF = mod * mod;
constexpr int MAX = 200010;
int D, contests[370], ans[370];
lint c[30], s[370][30];
set<int> held_days[30];
lint best_score;
lint get_score(int dd) {
For(i, 1, 27) {
held_days[i].clear();
held_days[i].insert(0);
held_days[i].insert(D + 1);
}
lint ret = 0;
For(day, 1, dd + 1) {
For(i, 1, 27) {
if (contests[day] == i) {
ret += s[day][i];
held_days[i].insert(day);
} else
ret -= c[i] * (day - *next(held_days[i].rbegin()));
}
}
return ret;
}
lint fsum(int n) { return n * (n + 1) / 2; }
lint score_diff(int day, int idx) {
lint ret = 0;
int prev_id = contests[day];
contests[day] = idx;
ret += s[day][idx];
auto r = held_days[idx].lower_bound(day), l = prev(r);
ret += c[idx] * fsum(*r - 1 - *l);
ret -= c[idx] * (fsum(day - 1 - *l) + fsum(*r - 1 - day));
held_days[idx].insert(day);
ret -= s[day][prev_id];
auto m = held_days[prev_id].find(day);
r = next(m);
l = prev(m);
ret += c[prev_id] * (fsum(day - 1 - *l) + fsum(*r - 1 - day));
ret -= c[prev_id] * fsum(*r - 1 - *l);
held_days[prev_id].erase(day);
return ret;
}
void input() {
scanf("%d", &D);
For(i, 1, 27) scanf("%lld", &c[i]);
For(i, 1, D + 1) For(j, 1, 27) scanf("%lld", &s[i][j]);
}
void output() { For(i, 1, D + 1) printf("%d\n", ans[i]); }
int main() {
input();
For(i, 1, D + 1) ans[i] = contests[i] = i % 26 + 1;
double temperature = 10000, colding_rate = 0.99999;
lint score = get_score(D);
best_score = score;
random_device rd;
mt19937 mt(rd());
uniform_real_distribution<> dist(0.0, 1.0);
clock_t start = clock();
while ((clock() - start) / CLOCKS_PER_SEC < 1.0) {
int day = mt() % D + 1;
int idx = mt() % 26 + 1;
int prev_id = contests[day];
lint diff = score_diff(day, idx);
if (diff > 0)
score += diff;
else {
double prob = dist(mt);
if (prob <= exp(diff / temperature))
score += diff;
else
score_diff(day, prev_id);
}
if (chmax(best_score, score)) {
For(i, 1, D + 1) ans[i] = contests[i];
}
temperature *= colding_rate;
}
output();
} | replace | 109 | 110 | 109 | 110 | TLE | |
p02619 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define per(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define pb push_back
#define mp make_pair
#define bg begin()
#define en end()
#define all(v) (v).begin(), (v).end()
#define sz(v) (int)(v).size()
using namespace std;
typedef long long ll;
typedef long double ld;
static const long long MOD = 1000000007;
static const long long LINF = (ll)(1e18 + 99);
static const int INF = 1e9 + 99;
ll c[30], s[370][30];
ll score[30], last_day[30];
int t[5];
ll calc(int day, int contest) {
score[contest] += s[day][contest];
last_day[contest] = day;
rep(i, 1, 27) score[i] -= c[i] * (day - last_day[i]);
ll sum = 0;
rep(i, 1, 27) sum += score[i];
return sum;
}
int main(void) {
int d;
cin >> d;
rep(i, 1, 27) cin >> c[i];
rep(i, 1, d + 1) rep(j, 1, 27) cin >> s[i][j];
rep(i, 0, d) cin >> t[i];
rep(i, 0, d) { printf("%lld\n", calc(i + 1, t[i])); }
return 0;
}
| #include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define per(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define pb push_back
#define mp make_pair
#define bg begin()
#define en end()
#define all(v) (v).begin(), (v).end()
#define sz(v) (int)(v).size()
using namespace std;
typedef long long ll;
typedef long double ld;
static const long long MOD = 1000000007;
static const long long LINF = (ll)(1e18 + 99);
static const int INF = 1e9 + 99;
ll c[30], s[370][30];
ll score[30], last_day[30];
int t[370];
ll calc(int day, int contest) {
score[contest] += s[day][contest];
last_day[contest] = day;
rep(i, 1, 27) score[i] -= c[i] * (day - last_day[i]);
ll sum = 0;
rep(i, 1, 27) sum += score[i];
return sum;
}
int main(void) {
int d;
cin >> d;
rep(i, 1, 27) cin >> c[i];
rep(i, 1, d + 1) rep(j, 1, 27) cin >> s[i][j];
rep(i, 0, d) cin >> t[i];
rep(i, 0, d) { printf("%lld\n", calc(i + 1, t[i])); }
return 0;
}
| replace | 30 | 31 | 30 | 31 | 0 | |
p02619 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define all(n) begin(n), end(n)
const long long INF = numeric_limits<long long>::max();
typedef long long ll;
typedef vector<int> vint;
typedef vector<vector<int>> vvint;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef unsigned long long ull;
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;
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
int main() {
ll D;
cin >> D;
vll c(26 + 1);
for (size_t i = 1; i <= 26; i++) {
cin >> c[i];
}
auto s = make_v<ll>(D + 1, 26 + 1);
for (size_t i = 1; i <= D; i++) {
for (size_t j = 1; j <= 26; j++) {
cin >>
s[i]
[j]; // s[i][j] := i日目にコンテストjを開催したときの満足度の増加量
}
}
vll t(D);
auto last = make_v<ll>(D + 1, 26 + 1);
for (size_t i = 1; i <= D; i++) {
cin >> t[i];
last[i][t[i]] = i; // i日目以前にタイプt[i]のコンテストを開催した最後の日
for (size_t j = 0; j <= 26; j++) {
if (j == t[i])
continue;
chmax(last[i][j], last[i - 1][j]);
}
}
ll score = 0;
for (int i = 1; i <= D; i++) {
score += s[i][t[i]];
ll decrease = 0;
for (int j = 1; j <= 26; j++) {
decrease += c[j] * (i - last[i][j]);
}
score -= decrease;
cout << score << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define all(n) begin(n), end(n)
const long long INF = numeric_limits<long long>::max();
typedef long long ll;
typedef vector<int> vint;
typedef vector<vector<int>> vvint;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef unsigned long long ull;
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;
}
template <typename T> vector<T> make_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto make_v(size_t a, Ts... ts) {
return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
int main() {
ll D;
cin >> D;
vll c(26 + 1);
for (size_t i = 1; i <= 26; i++) {
cin >> c[i];
}
auto s = make_v<ll>(D + 1, 26 + 1);
for (size_t i = 1; i <= D; i++) {
for (size_t j = 1; j <= 26; j++) {
cin >>
s[i]
[j]; // s[i][j] := i日目にコンテストjを開催したときの満足度の増加量
}
}
vll t(D + 1);
auto last = make_v<ll>(D + 1, 26 + 1);
for (size_t i = 1; i <= D; i++) {
cin >> t[i];
last[i][t[i]] = i; // i日目以前にタイプt[i]のコンテストを開催した最後の日
for (size_t j = 0; j <= 26; j++) {
if (j == t[i])
continue;
chmax(last[i][j], last[i - 1][j]);
}
}
ll score = 0;
for (int i = 1; i <= D; i++) {
score += s[i][t[i]];
ll decrease = 0;
for (int j = 1; j <= 26; j++) {
decrease += c[j] * (i - last[i][j]);
}
score -= decrease;
cout << score << endl;
}
return 0;
} | replace | 54 | 55 | 54 | 55 | -11 | |
p02619 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep_(i, n, m) for (int i = n; i < (int)(m); i++)
#define all(v) v.begin(), v.end()
#define int long long
#define stoi stoll
// #define _GLIBCXX_DEBUG
signed main() {
int D;
cin >> D;
vector<int> c(26);
rep(i, 26) cin >> c[i];
vector<vector<int>> s(D, vector<int>(26));
rep(i, D) rep(j, 26) cin >> s[i][j];
vector<int> t(26);
rep(i, D) {
cin >> t[i];
t[i]--;
}
int score = 0;
vector<int> lt(26, -1);
rep(i, D) {
score += s[i][t[i]];
lt[t[i]] = i;
rep(j, 26) score -= c[j] * (i - lt[j]);
cout << score << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep_(i, n, m) for (int i = n; i < (int)(m); i++)
#define all(v) v.begin(), v.end()
#define int long long
#define stoi stoll
// #define _GLIBCXX_DEBUG
signed main() {
int D;
cin >> D;
vector<int> c(26);
rep(i, 26) cin >> c[i];
vector<vector<int>> s(D, vector<int>(26));
rep(i, D) rep(j, 26) cin >> s[i][j];
vector<int> t(D);
rep(i, D) {
cin >> t[i];
t[i]--;
}
int score = 0;
vector<int> lt(26, -1);
rep(i, D) {
score += s[i][t[i]];
lt[t[i]] = i;
rep(j, 26) score -= c[j] * (i - lt[j]);
cout << score << endl;
}
} | replace | 16 | 17 | 16 | 17 | 0 | |
p02619 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, srt, end) for (long long i = (srt); i < (long long)(end); i++)
int main() {
ll D;
cin >> D;
vector<ll> c(26), t(26), last(26, -1);
vector<vector<ll>> s(365, vector<ll>(26));
rep(i, 0, 26) cin >> c[i];
rep(i, 0, D) { rep(j, 0, 26) cin >> s[i][j]; }
rep(i, 0, D) {
cin >> t[i];
t[i]--;
}
ll res = 0;
rep(d, 0, D) {
res += s[d][t[d]];
last[t[d]] = d;
rep(j, 0, 26) { res -= c[j] * (d - last[j]); }
cout << res << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, srt, end) for (long long i = (srt); i < (long long)(end); i++)
int main() {
ll D;
cin >> D;
vector<ll> c(26), t(D), last(26, -1);
vector<vector<ll>> s(365, vector<ll>(26));
rep(i, 0, 26) cin >> c[i];
rep(i, 0, D) { rep(j, 0, 26) cin >> s[i][j]; }
rep(i, 0, D) {
cin >> t[i];
t[i]--;
}
ll res = 0;
rep(d, 0, D) {
res += s[d][t[d]];
last[t[d]] = d;
rep(j, 0, 26) { res -= c[j] * (d - last[j]); }
cout << res << endl;
}
return 0;
} | replace | 8 | 9 | 8 | 9 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.