text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 5;
set<pair<int, int> > b, w;
int s[MAXN];
int n;
set<pair<int, pair<int, int> > > edges;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
scanf("%d", &n);
int lab = -1, law = -1;
for (auto i = 0; i != n; i++) {
int c;
scanf("%d%d", &c, &s[i]);
if (c == 0)
b.insert(make_pair(s[i], i));
else
w.insert(make_pair(s[i], i));
}
int es = 0;
while (!b.empty() && !w.empty()) {
if (b.begin()->first < w.begin()->first) {
int i = b.begin()->second, j = w.begin()->second;
edges.insert(make_pair(i + 1, make_pair(j + 1, s[i])));
b.erase(b.begin());
w.erase(w.begin());
s[j] -= s[i];
if (lab == -1) lab = i;
w.insert(make_pair(s[j], j));
} else {
int i = w.begin()->second, j = b.begin()->second;
edges.insert(make_pair(i + 1, make_pair(j + 1, s[i])));
w.erase(w.begin());
b.erase(b.begin());
s[j] -= s[i];
if (law == -1) law = i;
b.insert(make_pair(s[j], j));
}
es++;
}
if (!b.empty())
b.erase(b.begin());
else if (!w.empty())
w.erase(w.begin());
while (es != n - 1 && !b.empty()) {
edges.insert(make_pair(law + 1, make_pair(1 + b.begin()->second, 0)));
b.erase(b.begin());
es++;
}
while (es != n - 1 && !w.empty()) {
edges.insert(make_pair(lab + 1, make_pair(1 + w.begin()->second, 0)));
w.erase(w.begin());
es++;
}
for (auto c : edges)
printf("%d %d %d\n", c.first, c.second.first, c.second.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct ans {
int x, y, z;
};
vector<ans> a;
int main() {
int n;
cin >> n;
set<pair<int, int>> set0, set1;
for (int i = 1; i <= n; ++i) {
int c, v;
cin >> c >> v;
(c ? set1 : set0).insert({v, i});
}
while (set1.size() + set0.size() > 1) {
if (set1.begin()->first < set0.begin()->first || set0.size() == 1u) {
auto pi = *(--set0.end());
set0.erase(--set0.end());
a.push_back({set1.begin()->second, pi.second, set1.begin()->first});
pi.first -= set1.begin()->first;
set1.erase(set1.begin());
set0.insert(pi);
} else {
auto pi = *(--set1.end());
set1.erase(--set1.end());
a.push_back({set0.begin()->second, pi.second, set0.begin()->first});
pi.first -= set0.begin()->first;
set0.erase(set0.begin());
set1.insert(pi);
}
}
for (auto i : a) {
cout << i.x << " " << i.y << " " << i.z << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
class N {
public:
long id, value;
N(long _id, long _value);
};
N::N(long _id, long _value) {
id = _id;
value = _value;
}
class H {
private:
vector<N> elem;
void swap(long a, long b);
public:
bool empty();
H();
void modify(long value);
void pop();
N top();
void push(long id, long value);
} B, W;
void H::modify(long value) {
if (value == 0) {
pop();
return;
}
elem[1].value = value;
}
bool H::empty() {
if (elem.size() <= 1) return true;
return false;
}
N H::top() { return elem[1]; }
void H::pop() {
elem[1] = elem.back();
elem.pop_back();
bool finished;
long maxChild;
long n = 1;
do {
finished = true;
if (2 * n >= elem.size()) return;
if (2 * n + 1 >= elem.size()) maxChild = 2 * n;
if (2 * n + 1 < elem.size())
maxChild = elem[2 * n].value > elem[2 * n + 1].value ? 2 * n : 2 * n + 1;
if (elem[n].value < elem[maxChild].value) {
swap(n, maxChild);
n = maxChild;
finished = false;
}
} while (!finished);
}
void H::swap(long a, long b) {
long t_id = elem[a].id;
long t_value = elem[a].value;
elem[a].id = elem[b].id;
elem[a].value = elem[b].value;
elem[b].id = t_id;
elem[b].value = t_value;
}
H::H() { elem.push_back(N(0, 2000000000)); }
void H::push(long id, long value) {
elem.push_back(N(id, value));
long n = elem.size() - 1;
while (elem[n].value > elem[n / 2].value) {
swap(n, n / 2);
n /= 2;
}
}
int Color[100005];
long N;
vector<long> Child[100005];
void in() {
scanf("%ld", &N);
long value;
for (long i = 1; i <= N; i++) {
scanf("%d %ld", &Color[i], &value);
if (Color[i] == 0)
B.push(i, value);
else
W.push(i, value);
}
}
void makeConnected() {
bool visited[100005];
long v = 1;
for (long i = 0; i < 100005; i++) visited[i] = false;
long n;
queue<long> q;
visited[1] = true;
q.push(1);
while (v < N) {
if (q.empty()) {
for (long i = 1; i <= N; i++)
if (!visited[i]) {
for (long j = 1; j <= N; j++)
if (visited[j] && Color[i] != Color[j]) {
printf("%ld %ld 0\n", i, j);
visited[i] = true;
v++;
Child[i].push_back(j);
Child[j].push_back(i);
q.push(i);
i = j = N + 1;
}
}
}
n = q.front();
q.pop();
for (long i = 0; i < Child[n].size(); i++)
if (!visited[Child[n][i]]) {
visited[Child[n][i]] = true;
v++;
q.push(Child[n][i]);
}
}
}
void solve() {
while (!B.empty() && !W.empty()) {
long value =
(B.top().value < W.top().value ? B.top().value : W.top().value);
printf("%ld %ld %ld\n", B.top().id, W.top().id, value);
Child[B.top().id].push_back(W.top().id);
Child[W.top().id].push_back(B.top().id);
B.modify(B.top().value - value);
W.modify(W.top().value - value);
}
makeConnected();
}
int main() {
in();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100224;
int n, color, weight;
set<pair<int, int> > S1, S2;
int cntb, cntr;
int main() {
cin.sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> color >> weight;
if (color)
S1.insert(make_pair(weight, i));
else
S2.insert(make_pair(weight, i));
if (color)
cntb++;
else
cntr++;
}
int edges = 0;
for (set<pair<int, int> >::iterator it1 = S1.begin(), it2 = S2.begin();
!S1.empty() && !S2.empty();) {
int w1 = (*it1).first, w2 = (*it2).first;
if (w1 > w2) {
printf("%d %d %d\n", (*it1).second, (*it2).second, w2);
int idx = (*it1).second;
S2.erase(it2);
S1.erase(it1);
it2 = S2.begin();
S1.insert(make_pair(w1 - w2, idx));
it1 = S1.begin();
} else if (w2 > w1) {
printf("%d %d %d\n", (*it1).second, (*it2).second, w1);
int idx = (*it2).second;
S2.erase(it2);
S1.erase(it1);
it1 = S1.begin();
S2.insert(make_pair(w2 - w1, idx));
it2 = S2.begin();
} else {
int i = (*it1).second, j = (*it2).second;
S1.erase(it1);
S2.erase(it2);
if (cntr > cntb) {
S1.insert(make_pair(0, i));
cntr--;
} else {
S2.insert(make_pair(0, j));
cntb--;
}
it1 = S1.begin();
it2 = S2.begin();
printf("%d %d %d\n", i, j, w1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
scanf("%d", &N);
vector<pair<long long int, int> > B, W;
for (int i = 0; i < N; i++) {
int c, s;
scanf("%d %d", &c, &s);
if (c == 0)
B.push_back(make_pair(s, i));
else
W.push_back(make_pair(s, i));
}
sort(B.rbegin(), B.rend());
sort(W.rbegin(), W.rend());
while (B.size() > 0 && W.size() > 0) {
auto b = B.back();
B.pop_back();
auto w = W.back();
W.pop_back();
long long int wt = min(b.first, w.first);
printf("%d %d %lld\n", b.second + 1, w.second + 1, wt);
b.first -= wt;
w.first -= wt;
if (b.first > 0)
B.push_back(b);
else if (w.first > 0)
W.push_back(w);
else if (B.size() > W.size())
W.push_back(w);
else
B.push_back(b);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > w, b, tv;
vector<int> x, y, z, m1, m2;
int p[100001], r[100001];
bool cmp(pair<int, int> a, pair<int, int> b) { return (a.second < b.second); }
int findSet(int x) {
if (x != p[x]) p[x] = findSet(p[x]);
return p[x];
}
void mergeSet(int x, int y) {
int px = findSet(x);
int py = findSet(y);
if (r[px] > r[py])
p[py] = px;
else
p[px] = py;
if (r[px] == r[py]) r[py]++;
}
void newEdge(int v1, int v2, int cost) {
x.push_back(v1);
y.push_back(v2);
z.push_back(cost);
mergeSet(v1, v2);
}
int main() {
int i, n, color, weight;
cin >> n;
for (i = 1; i <= n; i++) p[i] = i;
for (i = 0; i < n; i++) {
scanf("%d%d", &color, &weight);
if (color == 0) {
b.push_back(make_pair(i + 1, weight));
m1.push_back(i + 1);
} else {
w.push_back(make_pair(i + 1, weight));
m2.push_back((i + 1));
}
}
if (w.size() < b.size()) {
tv = w;
w = b;
b = tv;
}
sort(w.begin(), w.end(), cmp);
sort(b.rbegin(), b.rend(), cmp);
int p = b.size() - 1;
for (i = 0; i < w.size(); i++) {
while (w[i].second > 0) {
int tmp = min(w[i].second, b[p].second);
newEdge(w[i].first, b[p].first, tmp);
w[i].second -= tmp;
b[p].second -= tmp;
if (b[p].second == 0) p--;
}
}
for (i = 0; i < m2.size(); i++) {
if (findSet(m1[0]) != findSet(m2[i])) newEdge(m1[0], m2[i], 0);
}
for (i = 0; i < m1.size(); i++) {
if (findSet(m2[0]) != findSet(m1[i])) newEdge(m2[0], m1[i], 0);
}
int size = x.size();
for (i = 0; i < size; i++) {
printf("%d %d %d\n", x[i], y[i], z[i]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > white;
vector<pair<int, int> > black;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
int c, s;
cin >> c >> s;
if (c)
black.push_back(pair<int, int>(s, i));
else
white.push_back(pair<int, int>(s, i));
}
n--;
pair<int, int> w, b;
sort(white.begin(), white.end());
sort(black.begin(), black.end());
while (white.size() && black.size()) {
w = white.back();
b = black.back();
int mn = min(w.first, b.first);
w.first -= mn;
b.first -= mn;
if (w.first == 0) {
black[black.size() - 1] = b;
white.pop_back();
} else if (b.first == 0) {
white[white.size() - 1] = w;
black.pop_back();
}
cout << w.second << ' ' << b.second << ' ' << mn << endl;
}
if (white.size()) {
for (auto idx : white)
if (idx.second != w.second)
cout << idx.second << ' ' << b.second << ' ' << 0 << endl;
}
if (black.size()) {
for (auto idx : black)
if (idx.second != b.second)
cout << idx.second << ' ' << w.second << ' ' << 0 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxint = -1u >> 1;
struct point {
int a, b;
} x[100010], y[100010];
int n, a, b, l1, l2, la;
bool cmp(point p1, point p2) { return p1.a < p2.a; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d%d", &a, &b);
if (a) {
l1++;
x[l1].a = b;
x[l1].b = i;
} else {
l2++;
y[l2].a = b;
y[l2].b = i;
}
}
sort(x + 1, x + l1 + 1, cmp);
sort(y + 1, y + l2 + 1, cmp);
la = l1;
l1 = 1, l2 = 1;
for (int i = 1; i < n; i++) {
if (x[l1].a <= y[l2].a && l1 < la) {
printf("%d %d %d\n", x[l1].b, y[l2].b, x[l1].a);
y[l2].a -= x[l1].a;
l1++;
} else {
printf("%d %d %d\n", x[l1].b, y[l2].b, y[l2].a);
x[l1].a -= y[l2].a;
l2++;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[100005], b[100005];
int w[100005][3], N, A = 0, B = 0, W = 0;
int main() {
scanf("%d", &N);
for (int i = 1, c, v; i <= N; ++i) {
scanf("%d%d", &c, &v);
if (!c)
a[++A] = make_pair(i, v);
else
b[++B] = make_pair(i, v);
}
int i = 1, j = 1;
while (i <= A && j <= B) {
if (a[i].second <= b[j].second) {
w[++W][0] = a[i].first;
w[W][1] = b[j].first;
w[W][2] = a[i].second;
b[j].second -= a[i++].second;
} else {
w[++W][0] = a[i].first;
w[W][1] = b[j].first;
w[W][2] = b[j].second;
a[i].second -= b[j++].second;
}
}
while (i < A) {
w[++W][0] = a[++i].first;
w[W][1] = b[B].first;
w[W][2] = 0;
}
while (j < B) {
w[++W][0] = a[A].first;
w[W][1] = b[++j].first;
w[W][2] = 0;
}
for (int i = 1; i <= W; ++i) printf("%d %d %d\n", w[i][0], w[i][1], w[i][2]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
multimap<int, int> V[2];
int main() {
cin >> N;
int c, v;
for (int i = 1; i <= N; i++) {
cin >> c >> v;
V[c].insert(make_pair(v, i));
}
while (V[0].size() > 0 && V[1].size() > 0) {
int goal = (V[0].begin()->first < V[1].begin()->first) ? 0 : 1;
if (V[1 - goal].begin()->first == (--V[1 - goal].end())->first &&
V[1 - goal].size() != 1)
goal = 1 - goal;
int key = V[goal].begin()->first;
multimap<int, int>::iterator F = V[1 - goal].upper_bound(key);
if (F == V[1 - goal].end()) F--;
cout << F->second << " " << V[goal].begin()->second << " " << key << endl;
V[1 - goal].insert(make_pair(F->first - key, F->second));
V[1 - goal].erase(F);
V[goal].erase(V[goal].begin());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 11, mod = 1e9 + 7;
const int INF1 = 2e9 + 11;
const long long INF2 = 2e18 + 11;
const int base = 500;
const int P = 31;
const int dx[] = {1, -1, 0, 0, 1, 1, -1, -1};
const int dy[] = {0, 0, 1, -1, 1, -1, 1, -1};
const double EPS = 1e-12;
const double PI = acos(-1.0);
int n, c[N], s[N];
vector<int> weight[5], id[5];
int main() {
if (fopen("queue"
".in",
"r"))
freopen(
"queue"
".in",
"r", stdin),
freopen(
"queue"
".out",
"w", stdout);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i += 1) {
int x, y;
cin >> x >> y;
weight[x].emplace_back(y);
id[x].emplace_back(i);
}
int cur1 = 0, cur2 = 0;
for (int i = 1; i <= n - 1; i += 1) {
int w = min(weight[0][cur1], weight[1][cur2]);
cout << id[0][cur1] << " " << id[1][cur2] << " " << w << "\n";
weight[0][cur1] -= w;
weight[1][cur2] -= w;
if (cur1 < id[0].size() - 1 && weight[0][cur1] == 0)
++cur1;
else
++cur2;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 1e5 + 100, INF = 1e9;
long long n, c[MAX_N], s[MAX_N], tsih, tsef;
vector<pair<long long, long long>> siah, sefid;
vector<pair<pair<long long, long long>, long long>> jav;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c[i] >> s[i];
if (c[i] == 1) {
siah.push_back({s[i], i});
tsih++;
} else {
sefid.push_back({s[i], i});
tsef++;
}
}
sort(siah.begin(), siah.end());
sort(sefid.begin(), sefid.end());
long long sef = 0, sih = 0;
while (sef < tsef && sih < tsih) {
if (siah[sih].first < sefid[sef].first) {
sefid[sef].first -= siah[sih].first;
jav.push_back({{siah[sih].second, sefid[sef].second}, siah[sih].first});
sih++;
} else if (sefid[sef].first < siah[sih].first) {
siah[sih].first -= sefid[sef].first;
jav.push_back({{sefid[sef].second, siah[sih].second}, sefid[sef].first});
sef++;
} else if (sefid[sef].first == siah[sih].first) {
jav.push_back({{sefid[sef].second, siah[sih].second}, siah[sih].first});
siah[sih].first = 0;
sefid[sef].first = 0;
if (sef > sih) {
sef++;
} else {
sih++;
}
}
}
if (sih < tsih - 1) {
for (int i = sih; i < tsih; i++) {
jav.push_back({{siah[i].second, sefid[0].second}, 0});
}
}
if (sef < tsef - 1) {
for (int i = sef + 1; i < tsef; i++) {
jav.push_back({{sefid[i].second, siah[0].second}, 0});
}
}
for (int i = 0; i < n - 1; i++) {
cout << jav[i].first.first << " " << jav[i].first.second << " "
<< jav[i].second << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, x;
set<pair<int, int> > v0, v1;
int main() {
cin >> n;
int i, m = 0, p;
for (i = 0; i < n; i++) {
cin >> p >> m;
(p ? v0 : v1).insert(pair<int, int>(m, i + 1));
}
for (i = 1; i < n; i++) {
if (pair<int, int>(v1.begin()->first, -(int)v1.size()) <
pair<int, int>(v0.begin()->first, -(int)v0.size()))
v0.swap(v1);
cout << v0.begin()->second << " " << v1.begin()->second << " "
<< v0.begin()->first << endl;
pair<int, int> t = *v1.begin();
v1.erase(t);
t.first -= v0.begin()->first;
v1.insert(t);
v0.erase(v0.begin());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<int, int> > pq[2];
struct node {
int a, b, c;
};
int main() {
int t, tc = 0;
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int a, b;
scanf("%d%d", &a, &b);
pq[a].push(pair<int, int>(b, i + 1));
}
while (pq[0].size() && pq[1].size()) {
int x = pq[0].top().first, y = pq[1].top().first;
cout << pq[0].top().second << " " << pq[1].top().second << " " << min(x, y)
<< endl;
if (x < y || (x == y && pq[0].size() > pq[1].size())) {
y -= x;
pq[1].push(pair<int, int>(y, pq[1].top().second));
} else {
x -= y;
pq[0].push(pair<int, int>(x, pq[0].top().second));
}
pq[0].pop();
pq[1].pop();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > v[2];
int anchor[2];
int P[111111];
int get_p(int x) { return (P[x] == -1) ? x : (P[x] = get_p(P[x])); }
void merge(int x, int y, int val) {
int a = get_p(x), b = get_p(y);
if (a == b) return;
P[a] = b;
printf("%d %d %d\n", x, y, val);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
int color, val;
scanf("%d%d", &color, &val);
v[color].push_back(make_pair(val, i));
anchor[color] = i;
}
sort(v[0].begin(), v[0].end());
sort(v[1].begin(), v[1].end());
memset(P, -1, sizeof P);
int p[2];
p[0] = v[0].size() - 1;
p[1] = v[1].size() - 1;
int rem = 0, x = -1, cur_id;
int edge_remain = n - 1;
while (rem || p[0] >= 0 && v[0][p[0]].first ||
p[1] >= 0 && v[1][p[1]].first) {
if (rem == 0) {
rem = v[0][p[0]].first;
x = v[0][p[0]].second;
p[0]--;
cur_id = 0;
}
int nxt_id = 1 - cur_id;
while (rem > 0) {
pair<int, int> info = v[nxt_id][p[nxt_id]];
int val = info.first;
int det = min(rem, val);
merge(x, info.second, det);
rem -= det;
if (val > det) {
p[nxt_id]--;
rem = val - det;
cur_id = 1 - cur_id;
x = info.second;
break;
} else
p[nxt_id]--;
}
}
if (edge_remain) {
for (int i = 0; i < 2; i++)
for (int j = 0; j < v[1 - i].size(); j++)
merge(anchor[i], v[1 - i][j].second, 0);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000010;
int s[MAXN];
vector<pair<int, int> > vb, vw;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int n;
cin >> n;
int c;
for (int i = 1; i < n + 1; ++i) {
cin >> c >> s[i];
if (c == 0) {
vb.push_back(make_pair(s[i], i));
} else
vw.push_back(make_pair(s[i], i));
}
sort(vb.begin(), vb.end());
sort(vw.begin(), vw.end());
int i = 0, j = 0;
int bo = 0;
while (i != vb.size() && j != vw.size()) {
int wt = min(vb[i].first, vw[j].first);
cout << vb[i].second << " " << vw[j].second << " " << wt << endl;
;
vb[i].first -= wt;
vw[j].first -= wt;
if (vb[i].first == 0 && i != vb.size() - 1)
i++;
else
j++;
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize("inline")
using namespace std;
const int N = 100050, INF = 0x3f3f3f3f;
int n, col, sum, n1, n2;
struct node {
int color, val, id;
friend bool operator<(node x, node y) { return x.val < y.val; }
} white[N], black[N];
int min(int x, int y) { return (x > y) ? y : x; }
signed main() {
scanf("%d", &n);
for (register int i = 1; i <= n; i++) {
scanf("%d%d", &col, &sum);
if (col)
white[++n1] = node{col, sum, i};
else
black[++n2] = node{col, sum, i};
}
sort(white + 1, white + 1 + n1);
sort(black + 1, black + 1 + n2);
for (register int i = 1, j = 1; i <= n1 && j <= n2;) {
int now = min(white[i].val, black[j].val);
cout << white[i].id << " " << black[j].id << " " << now << endl;
white[i].val -= now;
black[j].val -= now;
if (white[i].val)
j++;
else if (black[j].val)
i++;
else if (i < n1)
i++;
else
j++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ts, kk = 1, _DB = 1;
inline int LEN(string a) { return a.length(); }
inline int LEN(char a[]) { return strlen(a); }
template <class T>
inline T _abs(T n) {
return (n < 0 ? -n : n);
}
template <class T>
inline T _max(T a, T b) {
return (a > b ? a : b);
}
template <class T>
inline T _min(T a, T b) {
return (a < b ? a : b);
}
template <class T>
inline T _sq(T x) {
return x * x;
}
template <class T>
inline T _sqrt(T x) {
return (T)sqrt((double)x);
}
template <class T>
inline T _pow(T x, T y) {
T z = 1;
for (int i = 1; i <= y; i++) {
z *= x;
}
return z;
}
template <class T>
inline T _gcd(T a, T b) {
a = _abs(a);
b = _abs(b);
if (!b) return a;
return _gcd(b, a % b);
}
template <class T>
inline T _lcm(T a, T b) {
a = _abs(a);
b = _abs(b);
return (a / _gcd(a, b)) * b;
}
template <class T>
inline T _extended(T a, T b, T &x, T &y) {
a = _abs(a);
b = _abs(b);
T g, x1, y1;
if (!b) {
x = 1;
y = 0;
g = a;
return g;
}
g = _extended(b, a % b, x1, y1);
x = y1;
y = x1 - (a / b) * y1;
return g;
}
template <class T>
inline T getbit(T x, T i) {
T t = 1;
return (x & (t << i));
}
template <class T>
inline T setbit(T x, T i) {
T t = 1;
return (x | (t << i));
}
template <class T>
inline T resetbit(T x, T i) {
T t = 1;
return (x & (~(t << i)));
}
template <class T>
inline T _bigmod(T n, T m) {
T ans = 1, mult = n % 1000000007;
while (m) {
if (m & 1) ans = (ans * mult) % 1000000007;
m >>= 1;
mult = (mult * mult) % 1000000007;
}
ans %= 1000000007;
return ans;
}
template <class T>
inline T _modinv(T x) {
return _bigmod(x, (T)(1000000007 - 2)) % 1000000007;
}
struct node {
int first, second;
};
vector<node> vv[2];
node N;
int main() {
int n, col, x;
cin >> n;
for (int i = 1; i <= n; i++) {
N.second = i;
cin >> col >> N.first;
vv[col].push_back(N);
}
while (!vv[0].empty() && !vv[1].empty()) {
int mn = _min(vv[0].back().first, vv[1].back().first);
for (int i = 0; i <= 1; i++)
cout << vv[i].back().second << " ", vv[i].back().first -= mn;
cout << mn << endl;
if (vv[0].back().first < vv[1].back().first ||
(vv[0].back().first == vv[1].back().first &&
vv[0].size() > vv[1].size()))
vv[0].pop_back();
else
vv[1].pop_back();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct stru {
int color;
int value;
int node;
bool operator<(const stru& a) const {
if (value != a.value) return value < a.value;
return node < a.node;
}
} a[110000];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
multiset<stru> st[2];
multiset<stru> all;
for (int i = 0; i < n; i++) {
cin >> a[i].color >> a[i].value;
a[i].node = i;
st[a[i].color].insert(a[i]);
all.insert(a[i]);
}
for (int i = 1; i < n; i++) {
stru b;
if (st[0].size() > st[1].size())
b = *st[0].begin();
else
b = *st[1].begin();
st[b.color].erase(st[b.color].find(b));
stru b2 = *(--st[1 - b.color].end());
st[b2.color].erase(st[b2.color].find(b2));
cout << b.node + 1 << " " << b2.node + 1 << " " << b.value << "\n";
b2.value -= b.value;
st[b2.color].insert(b2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int n, a[300001], was[300001][3];
long long d[300001][3];
long long calc(int v, int bit) {
if (v <= 0 || v > n) return 0ll;
if (v == 1) return -1;
if (was[v][bit] == 2) return d[v][bit] = -1;
if (was[v][bit] == 1) return d[v][bit];
was[v][bit] = 2;
if (bit) {
if (calc(v + a[v], bit ? 0 : 1) != -1)
d[v][bit] = calc(v + a[v], bit ? 0 : 1) + a[v];
else
d[v][bit] = -1;
} else {
if (calc(v - a[v], bit ? 0 : 1) != -1)
d[v][bit] = calc(v - a[v], bit ? 0 : 1) + a[v];
else
d[v][bit] = -1;
}
was[v][bit] = 1;
return d[v][bit];
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 2; i <= n; ++i) {
if (!was[i][0]) calc(i, 0);
if (!was[i][1]) calc(i, 1);
}
for (int i = 1; i < n; i++)
if (d[i + 1][0] != -1)
cout << d[i + 1][0] + i << '\n';
else
puts("-1");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T abs(T t) {
return t < 0 ? -t : t;
}
const long long modn = 1000000007;
inline long long mod(long long x) { return x % modn; }
int n;
int a[200009];
pair<int, long long> memo[200009][2];
int seen[200009][2];
const int ok = 0, imp = 1, a1 = 2;
pair<int, long long> solve(int i, bool on2) {
if (i < 0 || i >= n) return pair<int, long long>(ok, 0);
if (i == 0 && on2) return pair<int, long long>(imp, 0);
if (i == 0) return pair<int, long long>(a1, 0);
pair<int, long long> &r = memo[i][on2];
if (seen[i][on2] == 2) return r;
if (seen[i][on2] == 1) return r = pair<int, long long>(imp, 0);
seen[i][on2] = 1;
pair<int, long long> x = solve(i + a[i] * (on2 * 2 - 1), !on2);
r = x;
if (r.first != imp) r.second += a[i];
seen[i][on2] = 2;
return r;
}
int main() {
int i;
scanf("%d", &n);
for (i = 1; i < n; i++) scanf("%d", &a[i]);
for (i = 0; i < n - 1; i++) {
pair<int, long long> y = solve(i + 1, false);
y.second += i + 1;
if (y.first == a1) y.second += i + 1;
if (y.first == imp)
puts("-1");
else
printf("%I64d\n", y.second);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 10;
long long a[N];
long long dp[N][2];
long long n;
bool visited[N][2];
long long rec(long long x, long long z) {
if (x <= 0 || x > n) return 0;
if (visited[x][z]) return -2;
if (dp[x][z] != -1) return dp[x][z];
visited[x][z] = true;
dp[x][z] = rec(x + (z == 0 ? a[x] : -a[x]), z ^ 1);
if (dp[x][z] != -2) dp[x][z] += a[x];
visited[x][z] = false;
return dp[x][z];
}
void go() {
cin >> n;
for (long long i = 2; i <= n; i++) cin >> a[i];
memset(dp, -1, sizeof(dp));
memset(visited, false, sizeof(visited));
for (long long i = 1; i < n; i++) {
long long ans = rec(i + 1, 1);
if (ans == -2)
cout << -1 << endl;
else
cout << ans + i << endl;
}
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long t = 1;
cout << fixed << setprecision(12);
while (t--) {
go();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[210000];
long long dp[210000][2];
const long long INF = 1LL << 60;
int N;
void init() {
for (int i = 0; i < 210000; i++)
for (int j = 0; j < 2; j++) dp[i][j] = INF;
}
long long solve(int x, bool t) {
if (x <= 0 || x > N) return 0;
if (x == 1) return -1;
if (dp[x][t] == -INF) return dp[x][t] = -1;
if (dp[x][t] != INF) return dp[x][t];
dp[x][t] = -INF;
int x2 = x;
if (t) {
x2 += a[x];
} else {
x2 -= a[x];
}
long long tmp = solve(x2, !t);
if (tmp == -1) return dp[x][t] = -1;
return dp[x][t] = a[x] + tmp;
}
int main() {
cin >> N;
for (int i = 2; i <= N; i++) cin >> a[i];
init();
for (int i = 1; i < N; i++) {
long long ret = solve(1 + i, false);
if (~ret) ret += i;
cout << ret << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > forw(200001);
vector<vector<int> > backw(200001);
int a[200001];
long long ansb[200001], ansf[200001];
bool flagb[200001], flagf[200001];
void dfs(int pos, long long val, bool f) {
if (!f) {
if (flagb[pos]) {
ansb[pos] = -pos;
} else {
ansb[pos] = val + a[pos];
flagb[pos] = true;
for (int i = 0; i < backw[pos].size(); i++)
dfs(backw[pos][i], val + a[pos], !f);
}
} else {
if (flagf[pos]) {
ansf[pos] = -pos;
} else {
flagf[pos] = true;
ansf[pos] = val + a[pos];
for (int i = 0; i < forw[pos].size(); i++)
dfs(forw[pos][i], val + a[pos], !f);
}
}
}
int main(int argc, char* argv[]) {
memset(flagf, 0, sizeof(flagf));
memset(flagb, 0, sizeof(flagb));
memset(ansb, 0, sizeof(ansb));
memset(ansf, 0, sizeof(ansf));
int n;
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 2; i <= n; i++) {
if (i - a[i] > 0) forw[i - a[i]].push_back(i);
if (i + a[i] <= n) backw[i + a[i]].push_back(i);
}
for (int i = 2; i <= n; i++) {
if (i - a[i] <= 0) {
dfs(i, 0, 0);
}
if (i + a[i] > n) dfs(i, 0, 1);
}
for (int i = 2; i <= n; i++) {
if (ansb[i] == 0)
cout << -1 << endl;
else
cout << ansb[i] + i - 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 2 * (int)(1e5);
int n;
long long a[N_MAX + 1];
long long dp[N_MAX + 1];
bool used[N_MAX + 1];
long long dfs(int i) {
if (dp[i] != 0) return dp[i];
if (used[i]) {
dp[i] = -1;
return dp[i];
}
used[i] = true;
int j = i - a[i];
if (j <= 0) {
dp[i] = a[i];
return dp[i];
}
if (j == 1) {
dp[i] = -1;
return dp[i];
}
int k = j + a[j];
if (k > n) {
dp[i] = a[i] + a[j];
return dp[i];
}
dp[i] = dfs(k);
if (dp[i] != -1) dp[i] += a[i] + a[j];
return dp[i];
}
void solve() {
for (int i = 2; i <= n; ++i) dfs(i);
for (int i = 1; i < n; ++i) {
long long ans = i + dp[1 + i];
if (dp[1 + i] == -1) ans = -1;
cout << ans << endl;
}
}
int main() {
cin >> n;
for (int i = 0; i < (n - 1); ++i) cin >> a[i + 2];
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int *A, n;
long long int ans[200009];
long long int rec(int i, int f) {
long long int c;
if (i > n || i <= 0) return 0;
if (ans[i] == -2 && f == 1) {
ans[i] = -1;
return -1;
} else if (ans[i] != 0 && f == 1)
return ans[i];
if (f == 1) {
ans[i] = -2;
c = rec(i - A[i], 0);
if (c == -1)
ans[i] = -1;
else
ans[i] = A[i] + c;
return ans[i];
} else if (f == 0) {
c = rec(i + A[i], 1);
if (c == -1)
return -1;
else
return c + A[i];
}
}
int main() {
int i, j;
long long int c;
cin >> n;
A = new int[n + 1];
for (int i = 0; i < n + 1; i++) {
A[i] = 0;
ans[i] = 0;
}
for (i = 2; i <= n; i++) cin >> A[i];
for (i = 1; i < n; i++) {
c = rec(i + 1, 1);
if (c == -1)
cout << "-1" << endl;
else
cout << i + c << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[2000000];
long long dp[2000000][2], v[2000000][2];
int val(int x) { return 0 <= x && x < n; }
long long find(int x, int y) {
if (dp[x][y] != -1) return dp[x][y];
if (v[x][y]) return dp[x][y] = -(1LL << 60);
v[x][y] = 1;
long long ret;
if (y) {
if (val(x - a[x])) {
long long tmp = find(x - a[x], 0);
if (tmp < -1)
return dp[x][y] = -(1LL << 60);
else
return dp[x][y] = tmp + a[x];
} else
return dp[x][y] = a[x];
} else {
if (val(x + a[x])) {
long long tmp = find(x + a[x], 1);
if (tmp < -1)
return dp[x][y] = -(1LL << 60);
else
return dp[x][y] = tmp + a[x];
} else
return dp[x][y] = a[x];
}
v[x][y] = 0;
return dp[x][y] = -(1LL << 60);
}
int main() {
scanf("%d", &n);
memset(dp, -1, sizeof(dp));
for (int i = (1); i < (n); i++) scanf("%d", a + i);
for (int i = (1); i < (n); i++) {
a[0] = i;
long long tmp = find(i, 1);
printf("%lld\n", tmp < -1 ? -1 : tmp + i);
}
return 0;
}
|
#include <bits/stdc++.h>
const int N = 200005;
using namespace std;
int a[N], n;
long long dp[N];
long long solve(int x) {
if (dp[x] != -1) return dp[x];
int cur = x;
dp[cur] = -2;
long long res = 0;
res += a[x];
x -= a[x];
if (x <= 0) {
dp[cur] = res;
return dp[cur];
}
if (x == 1) {
dp[cur] = -2;
return dp[cur];
}
res += a[x];
x += a[x];
if (x > n) {
dp[cur] = res;
return dp[cur];
}
if (x == 1) {
dp[cur] = -2;
return dp[cur];
}
long long answer = solve(x);
if (answer == -2) {
dp[cur] = -2;
return dp[cur];
}
dp[cur] = answer + res;
return dp[cur];
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) {
scanf("%d", &a[i]);
}
memset(dp, -1, sizeof(dp));
for (int i = 1; i < n; ++i) {
long long ans = solve(1 + i);
if (ans == -2)
puts("-1");
else
printf("%I64d\n", ans + i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
const long double PI = acos(-1);
const long long MOD = 1000000000 + 7;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long add(long long a, long long b, long long m = MOD) {
return (a % m + b % m + 2 * m) % m;
}
long long mul(long long a, long long b, long long m = MOD) {
return ((a % m + m) * (b % m + m)) % m;
}
long long pow_mod(long long a, long long b, long long m = MOD) {
long long res = 1LL;
a = a % m;
while (b) {
if (b & 1) res = mul(res, a, m);
b >>= 1;
a = mul(a, a, m);
}
return res;
}
long long fastexp(long long a, long long b) {
long long res = 1LL;
while (b) {
if (b & 1) res = res * a;
b >>= 1;
a *= a;
}
return res;
}
int gcdExtendido(int a, int b, int *x, int *y) {
if (a == 0) {
*x = 0;
*y = 1;
return b;
}
int x1, y1;
int gcd = gcdExtendido(b % a, a, &x1, &y1);
*x = y1 - (b / a) * x1;
*y = x1;
return gcd;
}
int modInverso(int a, int m) {
int x, y;
int g = gcdExtendido(a, m, &x, &y);
if (g != 1)
return -1;
else
return (x % m + m) % m;
}
const int N = 200000 + 5;
int n;
int a[N];
bool vis[N];
long long ans[N];
vector<int> act_path;
bool valid;
pair<int, long long> getFirst(int i) {
int x = i + 1 - a[i + 1];
long long y = i + a[i + 1];
return make_pair(x, y);
}
pair<int, long long> getStep(int x) {
long long y = a[x];
x += a[x];
if (x <= 0 or x > n) return make_pair(x, y);
y += a[x];
x -= a[x];
return make_pair(x, y);
}
void DFS(int u) {
if (u == 1) {
valid = false;
return;
}
long long y = 0LL;
vis[u] = true;
int x = u;
y += a[x];
x += a[x];
if (x == 1) {
valid = false;
return;
}
act_path.push_back(u);
if (x <= 0 or x > n) {
ans[u] = y;
return;
}
if (x == 1) {
valid = false;
return;
}
y += a[x];
x -= a[x];
if (x <= 0 or x > n) {
ans[u] = y;
return;
}
if (x == 1) {
valid = false;
return;
}
if (!vis[x]) {
DFS(x);
} else {
act_path.push_back(x);
return;
}
}
long long simulate(int i, int id) {
if (ans[i] != 0) return ans[i];
long long y = 0LL;
vis[i] = true;
int x = i + a[i];
y += a[i];
if (x <= 0 or x > n) {
return y;
}
y += a[x];
x -= a[x];
if (x <= 0 or x > n) {
return y;
}
if (!vis[x]) {
long long nxt = simulate(x, id);
return nxt == -1 ? -1 : y + nxt;
} else
return -1;
}
void print() {
for (int i = 0; i < act_path.size(); i++) {
cout << act_path[i] << " ";
}
puts("");
}
int main() {
scanf("%d", &(n));
for (int i = 2; i <= n; i++) {
scanf("%d", &(a[i]));
}
for (int i = 2; i <= n; i++) {
if (!vis[i]) {
valid = true;
act_path.clear();
DFS(i);
int f = 0;
for (int j = 0; j < act_path.size(); j++) {
if (act_path[j] == act_path.back()) {
f = j;
break;
}
}
if (valid and f != act_path.size() - 1) {
for (int j = f; j < act_path.size(); j++) {
ans[act_path[j]] = -1LL;
}
}
}
}
memset(vis, 0, sizeof vis);
for (int i = 2; i <= n; i++) {
if (ans[i] == -1) vis[i] = true;
}
for (int i = 2; i <= n; i++) {
if (!vis[i]) {
valid = true;
act_path.clear();
DFS(i);
if (valid and ans[act_path.back()] != 0) {
for (int j = act_path.size() - 2; j >= 0; j--) {
int x = act_path[j];
int nx = act_path[j + 1];
pair<int, long long> nxt = getStep(x);
nxt.second += ans[nx];
if (ans[nx] < 0) nxt.second = -1;
ans[x] = nxt.second;
}
}
}
}
for (int i = 1; i < n; i++) {
a[1] = i;
pair<int, long long> at = getStep(1);
if (at.first == 1) {
puts("-1");
} else if (at.first <= 0 or at.first > n) {
cout << at.second << endl;
} else {
int nx = at.first;
long long y = at.second;
if (ans[nx] > 0) {
cout << y + ans[nx] << endl;
} else if (ans[nx] == 0) {
memset(vis, 0, sizeof vis);
cout << simulate(1, 0) << endl;
;
} else {
puts("-1");
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mas[210000];
long long mem[210000][2];
int N;
long long f(int index, int fw) {
if (index <= 0 || index > N) return 0;
if (index == 1) return -1;
if (mem[index][fw] != -2) return mem[index][fw];
mem[index][fw] = -1;
int i2 = index;
if (fw)
i2 += mas[index];
else
i2 -= mas[index];
long long r = f(i2, (fw + 1) % 2);
long long res;
if (r == -1)
res = -1;
else
res = mas[index] + r;
mem[index][fw] = res;
return res;
}
int main() {
for (int i = 0; i < 210000; i++)
for (int j = 0; j < 2; j++) mem[i][j] = -2;
scanf("%d", &N);
for (int i = 0; i < N - 1; i++) cin >> mas[i + 2];
for (int i = 1; i < N; i++) {
long long r = f(1 + i, 0);
if (r != -1) r += i;
cout << r << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200001] = {0}, state[200001][2] = {0};
long long m[200001][2] = {0};
int n;
long long dfs(int x, int f, int i) {
long long result;
if (x <= 0 || x > n) return 0;
if (state[x][f] == i || state[x][f] == -1) return -1;
if (state[x][f]) return m[x][f];
state[x][f] = i;
if (f)
result = dfs(x - a[x], 1 - f, i);
else
result = dfs(x + a[x], 1 - f, i);
if (result == -1)
return state[x][f] = -1;
else
return m[x][f] = result + a[x];
}
int main() {
cin >> n;
for (int i = 2; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++) {
a[1] = i;
state[1][0] = 0;
cout << dfs(1, 0, i) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
int dpu[maxn][2];
long long dp[maxn][2];
int a[maxn];
int sta[maxn * 2];
int main() {
memset(dpu, 0, sizeof(dpu));
int n;
scanf("%d", &n);
for (int i = 2; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
long long x = 1;
long long y = 0;
a[1] = i;
int sn = 1;
bool u = true;
sta[0] = 1;
dpu[1][0] = 0;
dp[1][0] = 0;
while (x > 0 && x <= n) {
if (sn % 2 == 1)
x = x + a[x];
else
x = x - a[x];
if (x > 0 && x <= n) {
if (dpu[x][sn % 2] == 3) {
y = dp[x][sn % 2];
break;
} else if (dpu[x][sn % 2] == 1 || dpu[x][sn % 2] == 2) {
u = false;
break;
} else
dpu[x][sn % 2]++;
sta[sn++] = x;
} else
y = 0;
}
if (u == false) {
while (sn != 0) {
sn--;
long long k = sta[sn];
dpu[k][sn % 2] = 2;
}
printf("-1\n");
} else {
while (sn != 0) {
sn--;
long long k = sta[sn];
dpu[k][sn % 2] = 3;
dp[k][sn % 2] = y + a[k];
y = y + a[k];
}
printf("%I64d\n", y);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int maxN = 201000;
int n;
int a[maxN];
pair<long long, int> dp[maxN][2];
int used[maxN][2];
pair<long long, int> dfs(int v, int move) {
if (used[v][move] == 2) {
used[v][move] = 1;
return dp[v][move] = make_pair(-1, -1);
}
if (used[v][move] == 1) {
return dp[v][move];
}
used[v][move] = 2;
long long ch = a[v];
int nv = v;
if (move == 1) {
nv -= a[v];
} else {
nv += a[v];
}
if (nv <= 0 || nv > n) {
used[v][move] = 1;
int val = 0;
if (v == 1 && nv <= 0) ++val;
return dp[v][move] = make_pair(ch, val);
}
pair<long long, int> val = dfs(nv, 1 - move);
if (val.first == -1) {
used[v][move] = 1;
return dp[v][move] = make_pair(-1, -1);
} else {
used[v][move] = 1;
return dp[v][move] = make_pair(ch + val.first, val.second);
}
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) {
scanf("%d", &a[i]);
}
a[0] = 1;
used[1][0] = 2;
for (int i = 2; i <= n; ++i) {
dp[i][1] = dfs(i, 1);
}
for (int i = 1; i < n; ++i) {
pair<long long, int> st = dp[i + 1][1];
if (st.first == -1) {
printf("%I64d\n", st.first);
} else {
printf("%I64d\n", st.first + (long long)(i) + (long long)st.second * i);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000 * 100 + 19;
int col[maxn][3], n, fix[maxn][3];
long long ans[maxn][3], A[maxn];
void dfs(int u, int t) {
col[u][t] = 1;
if (t) {
if (A[u] + u <= n) {
if (!col[A[u] + u][0])
dfs(A[u] + u, 0);
else if (!fix[u + A[u]][0])
ans[u][t] = -1, ans[u + A[u]][0] = -1;
if (fix[A[u] + u][0] and ans[A[u] + u][0] != -1)
ans[u][t] = 1ll * A[u] + ans[A[u] + u][0];
else
ans[u][t] = -1;
} else
ans[u][t] = A[u];
}
if (!t) {
if (u - A[u] > 0) {
if (!col[u - A[u]][1])
dfs(u - A[u], 1);
else if (!fix[u - A[u]][1])
ans[u][t] = -1, ans[u - A[u]][1] = -1;
if (fix[u - A[u]][1] and ans[u - A[u]][1] != -1)
ans[u][t] = 1ll * A[u] + ans[u - A[u]][1];
else
ans[u][t] = -1;
} else
ans[u][t] = A[u];
}
fix[u][t] = 1;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 2; i <= n; i++) cin >> A[i];
for (int i = 1; i <= n - 1; i++) {
A[1] = i;
fix[1][1] = 0;
dfs(1, 1);
cout << ans[1][1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void _print(long long t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(double t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]" << endl;
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
long long power(long long x, unsigned long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long mod_inverse(long long a, long long p) { return power(a, p - 2, p); }
void swap(long long &x, long long &y) {
long long temp = x;
x = y;
y = temp;
}
vector<long long> sieve(long long n) {
long long *arr = new long long[n + 1]();
vector<long long> vect;
for (long long i = 2; i <= n; i++)
if (arr[i] == 0) {
vect.push_back(i);
for (long long j = 2 * i; j <= n; j += i) arr[j] = 1;
}
return vect;
}
long long mod_add(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
long long mod_mul(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
long long mod_sub(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
long long mod_div(long long a, long long b, long long m) {
a = a % m;
b = b % m;
return (mod_mul(a, mod_inverse(b, m), m) + m) % m;
}
long long modfact(long long n, long long p) {
if (p <= n) return 0;
long long res = (p - 1);
for (long long i = n + 1; i < p; i++) res = (res * mod_inverse(i, p)) % p;
return res;
}
long long fact(long long n) {
if (n == 0) return 1;
return n * fact(n - 1);
}
vector<pair<long long, long long> > v;
vector<bool> vis;
long long dfs(long long n) {
if (vis[n]) {
if (v[n].first == -1 || v[n].second != 0)
return -1;
else
return v[n].first;
}
vis[n] = true;
long long z = dfs(v[n].second);
if (z == -1) {
v[n].first = -1;
return -1;
}
v[n].first += z;
v[n].second = 0;
return v[n].first;
}
void solve() {
long long n;
cin >> n;
vector<long long> a(n + 1);
a[1] = 1;
for (long long i = 2; i <= n; i++) {
cin >> a[i];
}
v.resize(n + 1, {0, 0});
vis.resize(n + 1, false);
vis[0] = true;
for (long long i = n; i > 1; i--) {
long long x = i;
v[i].first += a[i];
x += a[i];
if (x > n) {
continue;
} else {
v[i].first += a[x];
x -= a[x];
if (x <= 0) {
continue;
} else if (i == x || x == 1) {
v[i].first = -1;
continue;
}
v[i].second = x;
}
};
for (long long i = 2; i <= n; i++) {
dfs(i);
;
};
vector<long long> ans(n + 1);
for (long long i = 1; i < n; i++) {
a[1] = i;
long long x = 1;
ans[i] += a[x];
x += a[x];
if (x > n) {
continue;
} else {
ans[i] += a[x];
x -= a[x];
if (x == 1) {
ans[i] = -1;
} else if (x <= 0) {
continue;
} else if (v[x].first != -1)
ans[i] += v[x].first;
else
ans[i] = -1;
}
}
for (long long i = 1; i < n; i++) {
cout << ans[i] << endl;
}
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
auto start1 = high_resolution_clock::now();
solve();
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 5;
int n;
int a[maxN];
long long dp[maxN][2];
bool mark[maxN][2];
inline long long DFS(int u, bool id) {
if (u > n || u <= 0) return 0;
if (mark[u][id]) return (dp[u][id] > 0 ? dp[u][id] : -1);
mark[u][id] = true;
long long value = 0;
if (id)
value = DFS(u + a[u], 0);
else
value = DFS(u - a[u], 1);
if (value == -1)
dp[u][id] = -1;
else
dp[u][id] = value + a[u];
return dp[u][id];
}
int main() {
ios_base::sync_with_stdio(false);
scanf("%d", &n);
for (int i = 2; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n - 1; ++i) {
a[1] = i;
dp[1][1] = 0;
mark[1][1] = false;
printf("%I64d\n", DFS(1, 1));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 8;
long long n, a[N], mark[N][5], dp[N][5], q;
long long dfs(int x, int t) {
if (x < 0 || x > n - 1) return 0;
if (mark[x][t] == 1) return -1;
if (mark[x][t] == 2) return dp[x][t];
mark[x][t] = 1;
if (t)
q = dfs(x - a[x], 0);
else
q = dfs(x + a[x], 1);
mark[x][t] = 2;
if (q == -1)
dp[x][t] = -1;
else
dp[x][t] = q + a[x];
return dp[x][t];
}
int main() {
cin >> n;
for (int i = 1; i < n; i++) cin >> a[i];
mark[0][0] = 1;
for (int i = 1; i < n; i++)
if (!mark[i][1]) dfs(i, 1);
for (int i = 1; i < n; i++) {
if (dp[i][1] == -1)
cout << -1 << '\n';
else
cout << dp[i][1] + i << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200100];
long long f[200100], g[200100];
bool vf[200100], vg[200100];
long long dfs(int x, long long y, int cur) {
int dx;
if (cur) {
vf[x] = true;
dx = x + a[x];
if (dx > n)
f[x] = a[x];
else {
if (vg[dx] && g[dx]) f[x] = a[x] + g[dx];
if (!vg[dx] && dfs(dx, y + a[x], 0)) f[x] = a[x] + g[dx];
}
if (!f[x])
return 0;
else
return f[x] + y;
} else {
vg[x] = true;
dx = x - a[x];
if (dx <= 0)
g[x] = a[x];
else {
if (vf[dx] && f[dx]) g[x] = a[x] + f[dx];
if (!vf[dx] && dfs(dx, y + a[x], 1)) g[x] = a[x] + f[dx];
}
if (!g[x])
return 0;
else
return g[x] + y;
}
}
int main() {
cin >> n;
int i;
a[1] = 1;
for (i = 2; i <= n; i++) scanf("%d", &a[i]);
memset(f, 0, sizeof(f));
memset(g, 0, sizeof(g));
memset(vf, false, sizeof(vf));
memset(vg, false, sizeof(vg));
for (i = 1; i < n; i++) {
a[1] = i;
f[1] = 0;
dfs(1, 0, 1);
if (!f[1])
cout << -1 << endl;
else
cout << f[1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> vec, tmp;
bool vis[200005][2];
bool cyc[200005][2];
long long memo[200005][2];
const long long inf = 1LL << 60;
long long solve(int x, bool stp2) {
if (x <= 0 || x > n) return 0;
if (x == 1 || cyc[x][stp2]) return inf;
long long &ret = memo[x][stp2];
if (ret != -1) return ret;
ret = 0;
if (stp2) {
ret += solve(x + vec[x], 0) + vec[x];
} else {
ret += solve(x - vec[x], 1) + vec[x];
}
return ret;
}
bool iscyc(int x, bool stp2) {
if (x <= 0 || x > n) return 0;
if (vis[x][stp2]) return cyc[x][stp2];
if (x == 1 || cyc[x][stp2]) return 1;
vis[x][stp2] = 1;
bool &ret = cyc[x][stp2];
ret = 1;
if (stp2) {
ret &= iscyc(x + vec[x], 0);
} else {
ret &= iscyc(x - vec[x], 1);
}
return ret;
}
int main() {
scanf("%d", &n);
vec.resize(n + 6);
for (int i = 2; i <= n; i++) scanf("%d", &vec[i]);
memset(memo, -1, sizeof memo);
for (int pos = 2; pos <= n; pos++) {
iscyc(pos + vec[pos], 0);
iscyc(pos - vec[pos], 1);
}
for (int it = 1; it < n; it++) {
vec[1] = it;
long long res = solve(1 + it, 0) + it;
cout << (res >= inf ? -1 : res) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[210000];
long long dp[210000][2];
const long long INF = 1LL << 60;
int N;
void init() {
for (int i = 0; i < 210000; i++)
for (int j = 0; j < 2; j++) dp[i][j] = INF;
}
long long solve(int x, bool t) {
if (x <= 0 || x > N) return 0;
if (x == 1) return -1;
if (dp[x][t] == -INF) return dp[x][t] = -1;
if (dp[x][t] != INF) return dp[x][t];
dp[x][t] = -INF;
int x2 = x;
if (t) {
x += a[x2];
} else {
x -= a[x2];
}
long long tmp = solve(x, !t);
if (tmp == -1) return dp[x2][t] = -1;
return dp[x2][t] = a[x2] + tmp;
}
int main() {
cin >> N;
for (int i = 2; i <= N; i++) cin >> a[i];
init();
for (int i = 1; i < N; i++) {
long long ret = solve(1 + i, false);
if (~ret) ret += i;
cout << ret << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mas[210000];
long long mem[210000][2];
int N;
long long f(int index, int fw) {
if (index <= 0 || index > N) return 0;
if (index == 1) return -1;
if (mem[index][fw] != -2) return mem[index][fw];
mem[index][fw] = -1;
int i2 = index;
if (fw)
i2 += mas[index];
else
i2 -= mas[index];
long long r = f(i2, (fw + 1) % 2);
long long res;
if (r == -1)
res = -1;
else
res = mas[index] + r;
mem[index][fw] = res;
return res;
}
int main() {
for (int i = 0; i < 210000; i++)
for (int j = 0; j < 2; j++) mem[i][j] = -2;
scanf("%d", &N);
for (int i = 0; i < N - 1; i++) cin >> mas[i + 2];
for (int i = 1; i < N; i++) {
long long r = f(1 + i, 0);
if (r != -1) r += i;
cout << r << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
long long dp[MAXN][2];
long long a[MAXN];
int N;
bool vis[MAXN][2];
long long calcu(int x, int op) {
if (x < 1 || x > N) return 0;
if (dp[x][op]) return dp[x][op];
if (vis[x][op]) return -1;
vis[x][op] = true;
if (op == 0)
dp[x][op] = calcu(x + a[x], op ^ 1);
else
dp[x][op] = calcu(x - a[x], op ^ 1);
if (dp[x][op] != -1) dp[x][op] += a[x];
return dp[x][op];
}
int main() {
scanf("%d", &N);
for (int i = 2; i <= N; i++) scanf("%I64d", &a[i]);
for (int i = 2; i <= N; i++)
for (int j = 0; j < 2; j++) calcu(i, j);
for (int i = 1; i < N; i++) {
if (dp[i + 1][1] == -1)
puts("-1");
else
cout << dp[i + 1][1] + i << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
long long dp[MAXN][2];
int b[MAXN][2], a[MAXN];
int n;
long long dfs(int x, int op, int cur) {
if (x <= 0 || x > n) {
return 0;
}
if (dp[x][op] != 0) {
return dp[x][op];
}
if (b[x][op] == cur) {
return -1;
}
b[x][op] = cur;
int delta = op == 0 ? a[x] : -a[x];
long long ret = dfs(x + delta, 1 - op, cur);
if (ret == -1) {
return dp[x][op] = -1;
}
return dp[x][op] = ret + a[x];
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) {
scanf("%d", a + i);
}
for (int i = 1; i < n; ++i) {
a[1] = i;
dp[1][0] = 0;
long long ret = dfs(1, 0, i);
cout << ret << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[200010][2];
int vis[200010][2], goal;
long long a[200010], n;
long long dfs(long long pos, int st) {
if (pos <= 0 || pos > n) return 0;
if (dp[pos][st] != -1) return dp[pos][st];
if (vis[pos][st] == goal) return -2;
vis[pos][st] = goal;
if (st == 0) {
long long ans = dfs(pos + a[pos], st ^ 1);
if (ans == -2)
dp[pos][st] = -2;
else
dp[pos][st] = a[pos] + ans;
} else {
long long ans = dfs(pos - a[pos], st ^ 1);
if (ans == -2)
dp[pos][st] = -2;
else
dp[pos][st] = a[pos] + ans;
}
return dp[pos][st];
}
int main() {
cin >> n;
memset(dp, -1, sizeof(dp));
memset(vis, 0, sizeof(vis));
for (int i = 2; i <= n; i++) cin >> a[i];
dp[0][1] = -2;
for (int i = 1; i < n; i++) {
a[1] = i;
goal = i;
long long ans = dfs(i + 1, 1);
if (ans == -2)
cout << -1 << endl;
else
cout << ans + i << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 3;
int n;
bool vis[N][2];
long long mem[N][2];
long long a[N];
long long solve(int x, int d) {
if (x <= 0 || x > n) return 0;
if (vis[x][d]) return mem[x][d];
vis[x][d] = 1;
mem[x][d] = -1;
long long ans = solve(x + a[x] * (d ? 1 : -1), !d);
if (ans != -1) ans += a[x];
return mem[x][d] = ans;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) {
scanf("%d", &a[i]);
}
for (int i = 1; i < n; ++i) {
a[1] = i;
vis[1][1] = vis[1][0] = 0;
cout << solve(1, 1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[200002], b[200002], c[200002];
int n;
long long temp;
long long f(long long x) {
if (c[x] != 0) {
return c[x];
}
long long xx = x;
if (b[x] == 1) {
c[x] = -1;
return -1;
}
b[x] = 1;
long long y = a[x];
x += a[x];
if (x > n) {
c[xx] = y;
b[xx] = 0;
return y;
}
y += a[x];
x -= a[x];
if (x <= 0) {
c[xx] = y;
b[xx] = 0;
return y;
} else if (x == 1) {
c[xx] = -1;
b[xx] = 0;
return -1;
}
temp = f(x);
if (temp != -1) {
c[xx] = temp + y;
b[xx] = 0;
return temp + y;
} else {
c[xx] = -1;
b[xx] = 0;
return -1;
}
}
int main() {
long long x, y;
int i, j;
scanf("%d", &n);
for (i = 2; i <= n; i++) {
cin >> a[i];
b[i] = 0;
c[i] = 0;
}
b[1] = b[0] = 0;
c[1] = c[0] = 0;
for (i = 2; i <= n; i++) {
f(i);
}
for (i = 1; i < n; i++) {
x = 1;
y = 0;
j = 0;
a[1] = i;
y += a[x];
x += a[x];
if (x > n) {
cout << y << endl;
continue;
}
y += a[x];
x -= a[x];
if (x <= 0) {
cout << y << endl;
continue;
} else if (x == 1) {
cout << "-1\n";
continue;
}
if (c[x] == -1) {
cout << "-1\n";
} else {
cout << c[x] + y << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5;
long long r, p[2][N + 1], a[2 * N];
int n;
long long suma(int i, int j) {
if (j <= 0 || j > n) return 0;
if (p[i][j] != 0) return p[i][j];
p[i][j] = -1;
r = suma(1 - i, i ? j + a[j] : j - a[j]);
if (r == -1) return -1;
return p[i][j] = a[j] + r;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n - 1; i++)
a[1] = i, p[1][1] = 0, cout << suma(1, 1) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long a[200005];
long long dp[2][200005];
int vis[2][200005];
long long work(int s, int x) {
if (x <= 0 or x > n) {
return 0;
}
if (x == 1 or vis[s][x] == 1) {
return -1;
}
long long &res = dp[s][x];
if (vis[s][x] == 2) {
return res;
}
vis[s][x] = 1;
long long val = work(s ^ 1, (s == 0 ? x + a[x] : x - a[x]));
vis[s][x] = 2;
if (val == -1) {
return res = -1;
} else {
return res = a[x] + val;
}
}
int main() {
cin >> n;
for (int i = 2; i <= n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
long long val = work(1, 1 + i);
if (val == -1) {
cout << -1 << endl;
} else {
cout << val + i << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 200005;
long long inc[N], decr[N];
int had1[N], had2[N];
int a[N];
int n;
long long dpdecr(int x, int k);
long long dpinc(int x, int k) {
if (x <= 0 || x > n) return 0;
if (had1[x] == k) return -1;
if (inc[x] != -2) return inc[x];
had1[x] = k;
long long tmp = dpdecr(x + a[x], k);
if (tmp == -1) return (inc[x] = -1);
return (inc[x] = tmp + a[x]);
}
long long dpdecr(int x, int k) {
if (x <= 0 || x > n) return 0;
if (had2[x] == k) return -1;
if (decr[x] != -2) return decr[x];
had2[x] = k;
long long tmp = dpinc(x - a[x], k);
if (tmp == -1) return (decr[x] = -1);
return (decr[x] = tmp + a[x]);
}
int main() {
while (cin >> n) {
for (int i = 2; i <= n; ++i) cin >> a[i];
memset(had1, 0, sizeof(had1));
memset(had2, 0, sizeof(had2));
for (int i = 1; i <= n; ++i) inc[i] = decr[i] = -2;
inc[1] = -1;
decr[1] = 0;
for (int i = 2; i <= n; ++i) {
long long k = dpdecr(i, i);
if (k == -1)
cout << "-1" << endl;
else
cout << (k + i - 1) << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[210000];
long long dp[210000][2];
int N;
long long solve(int index, int fw) {
if (index <= 0 || index > N) return 0;
if (index == 1) return -1;
if (dp[index][fw] != -2) return dp[index][fw];
dp[index][fw] = -1;
int i2 = index;
if (fw)
i2 += a[index];
else
i2 -= a[index];
long long r = solve(i2, (fw + 1) % 2);
long long res;
if (r == -1)
res = -1;
else
res = a[index] + r;
dp[index][fw] = res;
return res;
}
int main() {
for (int i = 0; i < 210000; i++)
for (int j = 0; j < 2; j++) dp[i][j] = -2;
scanf("%d", &N);
for (int i = 0; i < N - 1; i++) cin >> a[i + 2];
for (int i = 1; i < N; i++) {
long long r = solve(1 + i, 0);
if (r != -1) r += i;
cout << r << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
int n, dat[MAXN], vis[MAXN][2];
long long dp[MAXN][2];
long long dfs(int x, int d) {
if (x <= 0 || x > n) return 0;
if (vis[x][d] == 1) return -1;
if (vis[x][d] == 2) return dp[x][d];
vis[x][d] = 1;
long long dist = d ? dfs(x + dat[x], 0) : dfs(x - dat[x], 1);
vis[x][d] = 2;
if (dist == -1)
return dp[x][d] = -1;
else
return dp[x][d] = dist + dat[x];
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) scanf("%d", &dat[i]);
vis[1][0] = vis[1][1] = 1;
for (int i = 2; i <= n; i++) {
if (!vis[i][0]) dfs(i, 0);
printf("%I64d\n", dp[i][0] == -1 ? -1 : i + dp[i][0] - 1);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long arr[200010];
int mem1[2][200010];
int vis1[2][200010];
int run[2][200010];
int n;
bool get1(bool a, int b) {
if (b <= 0 || b > n) return 1;
if (run[a][b]) return 0;
if (vis1[a][b]) return mem1[a][b];
run[a][b] = 1;
bool ret;
if (a == 0)
ret = get1(a ^ 1, b + arr[b]);
else
ret = get1(a ^ 1, b - arr[b]);
run[a][b] = 0;
vis1[a][b] = 1;
mem1[a][b] = ret;
return ret;
}
long long mem2[2][200010];
int vis2[2][200010];
long long get2(bool a, int b) {
if (b <= 0 || b > n) return 0;
if (vis2[a][b]) return mem2[a][b];
long long ret;
if (a == 0)
ret = get2(a ^ 1, b + arr[b]) + arr[b];
else
ret = get2(a ^ 1, b - arr[b]) + arr[b];
vis2[a][b] = 1;
mem2[a][b] = ret;
return ret;
}
int main() {
int i, j, k, q, t;
scanf("%d", &n);
for (i = 2; i <= n; i++) scanf("%I64d", &arr[i]);
run[0][1] = 1;
for (i = 1; i < n; i++) {
arr[1] = i;
if (get1(1, 1 + arr[1]) == 0) {
printf("-1\n");
continue;
} else {
printf("%I64d\n", get2(1, 1 + arr[1]) + arr[1]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[200005] = {0}, dp[2][200005] = {0};
long long dpf(int idx, int inc) {
if (idx == 1) return -1;
if (idx > n || idx < 2) return 0LL;
long long &res = dp[inc][idx];
if (res != 0) return res;
res = -1LL;
if (inc)
res = dpf(idx + a[idx], inc ^ 1);
else
res = dpf(idx - a[idx], inc ^ 1);
if (res == -1) return res;
return res = res + a[idx];
}
int main(int argc, char **argv) {
std::ios::sync_with_stdio(false);
cin >> n;
for (int i = 2; i <= n; i++) cin >> a[i];
for (int i = 2; i <= n; i++) dpf(i, 0);
for (int i = 1; i < n; i++) {
if (dp[0][i + 1] == -1LL)
cout << -1LL << endl;
else
cout << dp[0][i + 1] + i << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool check(long long n, long long pos) { return n & (1LL << pos); }
long long Set(long long n, long long pos) { return n = n | (1LL << pos); }
long long dp[200005][2];
long long arr[200005];
long long n;
long long solve(long long x, long long step) {
if (x <= 0 || x > n) return 0;
long long &ret = dp[x][step];
if (ret != -1) return ret;
ret = -LLONG_MAX;
if (step == 0)
ret = solve(x + arr[x], step ^ 1);
else
ret = solve(x - arr[x], step ^ 1);
ret += arr[x];
return ret;
}
int main() {
long long i, j, k, l, m, o, r, q;
long long testcase;
long long input, flag, tag, ans;
while (cin >> n) {
memset(dp, -1, sizeof dp);
for (i = 2; i <= n; i++) scanf("%lld", &arr[i]);
dp[1][0] = -LLONG_MAX;
for (i = 2; i <= n; i++) {
ans = solve(i, 1) + i - 1;
if (ans < 0) ans = -1;
printf("%lld\n", ans);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[210000];
long long dp[210000][2];
const long long INF = 1LL << 60;
int N;
void init() {
for (int i = 0; i < 210000; i++)
for (int j = 0; j < 2; j++) dp[i][j] = INF;
}
long long solve(int x, bool t) {
if (x <= 0 || x > N) return 0;
if (x == 1) return -1;
if (dp[x][t] == -INF) return dp[x][t] = -1;
if (dp[x][t] != INF) return dp[x][t];
dp[x][t] = -INF;
int i2 = x;
if (t)
i2 += a[x];
else
i2 -= a[x];
long long r = solve(i2, !t);
long long res;
if (r == -1)
res = -1;
else
res = a[x] + r;
return dp[x][t] = res;
}
int main() {
cin >> N;
for (int i = 0; i < N - 1; i++) cin >> a[i + 2];
init();
for (int i = 1; i < N; i++) {
long long r = solve(1 + i, 0);
if (r != -1) r += i;
cout << r << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long Y[200010][2];
char V[200010][2];
long long a[200010];
long long dfs(int, int);
long long N;
int main() {
for (int i = 0; i < 200010; i++) {
V[i][0] = 'W';
V[i][1] = 'W';
}
cin >> N;
for (int j = 2; j <= N; j++) cin >> a[j];
for (int i = 2; i <= N; i++) {
if (V[i][0] = 'W') dfs(i, 0);
if (V[i][1] = 'W') dfs(i, 1);
}
for (int i = 1; i < N; i++) {
a[1] = i;
V[1][0] = 'W';
V[1][1] = 'W';
cout << dfs(1, 1) << endl;
}
return 0;
}
long long dfs(int nod, int type) {
V[nod][type] = 'G';
long long nextNod;
if (type) {
nextNod = nod + a[nod];
} else {
nextNod = nod - a[nod];
}
long long y = a[nod];
if (nextNod > N or nextNod <= 0LL) {
} else {
int next_node = nextNod;
if (next_node == 1LL)
y = -1LL;
else if (V[next_node][type ^ 1] == 'G') {
y = -1LL;
} else if (V[next_node][type ^ 1] == 'W') {
long long tmp = dfs(next_node, type ^ 1);
if (tmp == -1LL)
y = -1LL;
else
y += tmp;
} else {
if (V[next_node][type ^ 1] == 'B') {
long long tmp = Y[next_node][type ^ 1];
if (tmp == -1LL)
y = -1LL;
else
y += tmp;
}
}
}
V[nod][type] = 'B';
Y[nod][type] = y;
return y;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e) {
cout << e << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
void BINARY(int n) {
cout << "Mask: ";
for (int i = 10; i >= 0; i--)
if (n & (1 << i))
cout << 1;
else
cout << 0;
cout << endl;
}
template <class T>
inline T sqr(T n) {
return n * n;
}
template <class T>
T Abs(T x) {
return (x > 0) ? x : -x;
}
template <class T>
inline double LOG(T a, T b) {
return (log(a) / log(b));
}
template <class T>
T power(T B, T P) {
return (P == 0) ? 1 : B * (power(B, P - 1));
}
template <class T>
inline T gcd(T a, T b) {
if (a < 0) return gcd(-a, b);
if (b < 0) return gcd(a, -b);
return (b == 0) ? a : gcd(b, a % b);
}
template <class T>
int BigMod(T B, T P, T M) {
if (P == 0)
return 1;
else if (P % 2 == 0)
return sqr(BigMod(B, P / 2, M)) % M;
else
return (B % M) * (BigMod(B, P - 1, M)) % M;
}
template <class T>
inline T lcm(T a, T b) {
if (a < 0) return lcm(-a, b);
if (b < 0) return lcm(a, -b);
return a * (b / (gcd(a, b)));
}
template <class T>
inline T MOD(T a, T b) {
return (((a % b) + b) % b);
}
int Set(int n, int p) { return n = (n | (1 << p)); }
int Clear(int n, int p) { return n = (n & ~(1 << p)); }
int Check(int n, int p) { return (n & (1 << p)); }
int Toggle(int n, int p) {
if (Check(n, p)) return n = Clear(n, p);
return n = Set(n, p);
}
bool isUpperCase(char c) { return c >= 'A' && c <= 'Z'; }
bool isLowerCase(char c) { return c >= 'a' && c <= 'z'; }
bool isVowel(char c) {
c = tolower(c);
if (c == 'a' or c == 'e' or c == 'i' or c == 'o' or c == 'u') return 1;
return 0;
}
typedef unsigned long long ull;
long long dp[200009][2], arr[200009];
int N;
long long rec(int x, bool st) {
if (x > N or x <= 0) return 0;
long long &ret = dp[x][st];
if (ret != -1) return ret;
ret = (1LL << 62);
if (st == 0)
ret = rec(x + arr[x], !st) + arr[x];
else
ret = rec(x - arr[x], !st) + arr[x];
return ret;
}
int main() {
while (cin >> N) {
for (int i = 2; i <= N; i++) {
cin >> arr[i];
}
memset(dp, -1, sizeof(dp));
for (int i = 1; i < N; i++) {
dp[1][0] = -1;
dp[1][1] = -1;
arr[1] = i;
long long ans = rec(1, 0);
if (ans < (1LL << 62))
cout << ans << endl;
else
puts("-1");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
static const double PI = acos(-1.0);
static const double EPS = 1e-9;
long long n;
long long a[200010];
long long dp[200010][2];
inline bool border(long long x) { return 0 <= x && x < n; }
long long dfs(long long x, long long step) {
if (dp[x][step] != -1) return dp[x][step];
dp[x][step] = -2;
if (step == 0) {
if (!border(x + a[x])) {
return dp[x][step] = a[x];
} else {
long long y = dfs(x + a[x], 1);
if (y == -2)
return dp[x][step] = -2;
else
return dp[x][step] = y + a[x];
}
} else if (step == 1) {
if (!border(x - a[x])) {
return dp[x][step] = a[x];
} else {
long long y = dfs(x - a[x], 0);
if (y == -2)
return dp[x][step] = -2;
else
return dp[x][step] = y + a[x];
}
}
}
int main() {
int i, j;
cin >> n;
for (i = 1; i < n; ++i) cin >> a[i];
for (i = 0; i < n; ++i)
for (j = 0; j < 2; ++j) dp[i][j] = -1;
for (i = 1; i < n; ++i)
for (j = 0; j < 2; ++j) dfs(i, j);
for (i = 1; i < n; ++i) {
if (dp[i][1] == -2)
puts("-1");
else
printf("%I64d\n", dp[i][1] + i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[210000];
long long dp[210000][2];
const long long INF = 1LL << 60;
int N;
void init() {
for (int i = 0; i < 210000; i++)
for (int j = 0; j < 2; j++) dp[i][j] = INF;
}
long long solve(int x, bool t) {
if (x <= 0 || x > N) return 0;
if (x == 1) return -1;
if (dp[x][t] == -INF) return dp[x][t] = -1;
if (dp[x][t] != INF) return dp[x][t];
dp[x][t] = -INF;
int i2 = x;
if (t)
i2 += a[x];
else
i2 -= a[x];
long long r = solve(i2, !t);
long long res;
if (r == -1)
res = -1;
else
res = a[x] + r;
return dp[x][t] = res;
}
int main() {
cin >> N;
for (int i = 2; i <= N; i++) cin >> a[i];
init();
for (int i = 1; i < N; i++) {
long long ret = solve(1 + i, false);
if (~ret) ret += i;
cout << ret << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
long long mem[MAXN + 1][2];
int visited[MAXN + 1][2];
int b[MAXN + 1][2];
int a[MAXN + 1];
int n;
int input() {
int i;
scanf("%d", &n);
for (i = 2; i <= n; i++) scanf("%d", &a[i]);
return 0;
}
int search(int x, int k) {
int i, tx;
if (visited[x][k] == 1) {
mem[x][k] = -1;
return 0;
}
if (visited[x][k] == 2) {
return 0;
}
if (x == 1 && k == 1) {
b[x][k] = 1;
mem[x][k] = 0;
return 0;
}
mem[x][k] += a[x];
visited[x][k] = 1;
tx = x;
if (k)
tx -= a[x];
else
tx += a[x];
if (tx >= 1 && tx <= n) {
search(tx, k ^ 1);
if (mem[tx][k ^ 1] != -1) {
mem[x][k] += mem[tx][k ^ 1];
b[x][k] = b[tx][k ^ 1];
} else
mem[x][k] = -1;
}
visited[x][k] = 2;
return 0;
}
int solve() {
int i;
memset(mem, 0, sizeof(mem));
memset(b, 0, sizeof(b));
memset(visited, 0, sizeof(visited));
visited[1][0] = 1;
for (i = 2; i <= n; i++) {
if (!visited[i][1]) search(i, 1);
}
for (i = 1; i < n; i++) {
a[1] = i;
a[0] = 0;
if (mem[i + 1][1] == -1)
printf("-1\n");
else
printf("%I64d\n", mem[i + 1][1] + i + a[b[i + 1][1]]);
}
return 0;
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 200001;
long long n, a[N], od[N], ev[N];
bool fod[N], fev[N];
long long odd(long long);
long long even(long long);
long long odd(long long i) {
if (i < 1) return 0;
if (fod[i]) {
if (od[i] <= 0) return od[i] = -i;
return od[i];
}
fod[i] = true;
return od[i] = a[i] + even(i + a[i]);
}
long long even(long long i) {
if (i == 1 || i > n) return 0;
if (fev[i]) {
if (ev[i] <= 0) return ev[i] = -i;
return ev[i];
}
fev[i] = true;
long long d = odd(i - a[i]);
if (d < 0) return ev[i] = -i;
return ev[i] = a[i] + d;
}
int main() {
cin >> n;
for (long long i = 2; i <= n; i++) cin >> a[i];
fod[1] = true;
for (long long i = 2; i <= n; i++) even(i);
for (long long i = 1; i < n; i++) cout << i + ev[1 + i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long flag[500000];
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> adj(2 * n, -1);
vector<int> v(n, 0);
vector<long long> res(2 * n, -2);
for (int i = 1; i < n; ++i) {
cin >> v[i];
if (i + v[i] < n) adj[i << 1] = ((i + v[i]) << 1) + 1;
if (i - v[i] >= 0) adj[(i << 1) + 1] = (i - v[i]) << 1;
}
for (int i = 1; i < n; i++) {
adj[0] = (i << 1) + 1;
v[0] = i;
flag[0] = i;
stack<int> S;
S.push(0);
bool found = false;
long long ans;
while (!S.empty()) {
if (!found) {
int cur = S.top();
if (res[cur] != -2) {
ans = res[cur];
found = true;
continue;
}
if (adj[cur] != -1) {
if (flag[adj[cur]] != i) {
S.push(adj[cur]);
flag[adj[cur]] = i;
} else {
found = true;
ans = -1;
}
} else {
found = true;
ans = 0;
}
} else {
int cur = S.top();
if (cur >= 2) {
res[cur] = ans;
}
if (ans != -1) {
ans += v[cur >> 1];
}
S.pop();
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[210000];
long long dp[210000][2];
void init() {
for (int i = 0; i < 210000; i++) dp[i][0] = dp[i][1] = -2;
}
long long solve(int x, bool t) {
if (x < 1 || x > n) return 0;
if (dp[x][t] != -2) return dp[x][t];
dp[x][t] = -1;
int xt = x;
if (t)
xt += a[x];
else
xt -= a[x];
long long tmp = solve(xt, !t);
if (tmp == -1) return dp[x][t] = -1;
return dp[x][t] = tmp + a[x];
}
int main() {
cin >> n;
for (int i = 2; i <= n; i++) cin >> a[i];
init();
for (int i = 1; i < n; i++) {
long long ret = solve(1 + i, 0);
if (~ret) ret += i;
cout << ret << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
const long long inf = 2e16;
bool mk[N], vis[N][2];
long long n, a[N], res[N], dp[N][2];
long long dfs(int u, int st) {
if (u <= 0 || u > n) return 0;
if (vis[u][st]) return dp[u][st];
vis[u][st] = true;
long long num = 1;
if (st == 0) num = -1;
long long val = a[u] + dfs(u + num * a[u], 1 - st);
return dp[u][st] = val;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) dp[i][0] = dp[i][1] = inf;
vis[1][1] = true;
for (int i = 2; i <= n; i++) cin >> a[i];
for (int i = 2; i <= n; i++) {
a[1] = i - 1;
res[i] = a[i] + dfs(i - a[i], 1);
}
for (int i = 2; i <= n; i++) {
res[i] += i - 1;
if (res[i] >= inf) res[i] = -1;
cout << res[i] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct m1 {
int step;
long long int val;
int index;
} m1;
long long int arr[1000001];
m1 m[1000001];
long long int answer[1000001];
int main() {
long long int n, x, y, i;
int step = 1;
cin >> n;
for (i = 1; i < n; i++) {
cin >> arr[i];
m[i].step = 0;
m[i].index = -1;
}
for (i = 1; i <= n - 1; i++) {
arr[0] = i;
x = 1;
y = 0;
step = 1;
while (1) {
if (x <= 0 || x > n) {
answer[i] = y;
cout << y << endl;
break;
} else if (step == 1) {
if (m[x - 1].step == 1 && m[x - 1].index == i) {
cout << "-1" << endl;
answer[i] = -1;
break;
} else if (m[x - 1].step == 1 && x != 1) {
if (answer[m[x - 1].index] == -1) {
answer[i] = -1;
} else {
answer[i] = y + answer[m[x - 1].index] - m[x - 1].val;
}
cout << answer[i] << endl;
break;
} else {
m[x - 1].step = 1;
m[x - 1].index = i;
m[x - 1].val = y;
}
y += arr[x - 1];
x += arr[x - 1];
step = 2;
} else if (step == 2) {
if (m[x - 1].step == 2 && m[x - 1].index == i) {
cout << "-1" << endl;
answer[i] = -1;
break;
} else if (m[x - 1].step == 2 && x != 1) {
if (answer[m[x - 1].index] == -1) {
answer[i] = -1;
} else {
answer[i] = y + answer[m[x - 1].index] - m[x - 1].val;
}
cout << answer[i] << endl;
break;
} else {
m[x - 1].step = 2;
m[x - 1].index = i;
m[x - 1].val = y;
}
y += arr[x - 1];
x -= arr[x - 1];
step = 1;
}
}
}
return 0;
}
|
#include <bits/stdc++.h>
long long delta[2][200100];
int niz[200100];
int visited[2][200100];
int n;
long long dfs(int x, int m) {
if (x <= 0 || x > n) {
return 0;
}
int state = m & 1;
if (visited[state][x]) {
if (!delta[state][x]) return -1;
return delta[state][x];
}
visited[state][x] = 1;
int next;
if (state) {
next = x - niz[x];
} else {
next = x + niz[x];
}
long long t = dfs(next, m + 1);
if (t == -1) {
delta[state][x] = -1;
} else {
delta[state][x] = t + niz[x];
}
return delta[state][x];
}
int main() {
int i, j, x, y, m;
scanf("%d", &n);
for (i = 2; i <= n; i++) {
scanf("%d", niz + i);
}
visited[1][1] = 1;
visited[0][1] = 1;
for (i = 2; i <= n; i++) {
if (!visited[1][i]) {
dfs(i, 1);
}
}
for (i = 2; i <= n; i++) {
if (delta[1][i] == -1) {
printf("-1\n");
} else {
printf("%I64d\n", delta[1][i] + i - 1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int NMax = 200001;
const int cntTree = 262145;
const double eps = 1e-9;
const long long MD = (long long)1e16;
int a[NMax];
int n;
long long dp[NMax][2];
bool status[NMax][2];
long long solve(int x, int flag) {
if (x > n || x < 1) return 0;
if (status[x][flag] == true) return MD;
if (dp[x][flag] != -1) return dp[x][flag];
status[x][flag] = true;
int t = a[x];
if (flag == 0)
dp[x][flag] = solve(x + a[x], 1) + t;
else
dp[x][flag] = solve(x - a[x], 0) + t;
return dp[x][flag];
}
void dfs(int x, int flag) {
status[x][flag] = false;
if (flag == 0)
if (x + a[x] <= n && x + a[x] > 0 && status[x + a[x]][1] == true)
dfs(x + a[x], 1);
if (flag == 1)
if (x - a[x] <= n && x - a[x] > 0 && status[x - a[x]][0] == true)
dfs(x - a[x], 0);
}
int main() {
cin >> n;
for (int i = 2; i <= n; i++) scanf("%i", &a[i]);
for (int i = 1; i <= n; i++) {
dp[i][0] = dp[i][1] = -1;
status[i][0] = status[i][1] = false;
}
for (int i = 1; i < n; i++) {
a[1] = i;
long long t = solve(i + 1, 1) + i;
if (t > MD)
cout << -1 << endl;
else
cout << t << endl;
dfs(1, 0);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000002;
const long long INFLL = 100000000000000000ll;
const long long MOD = 1000000007;
const int MAX = 200005;
bool Mark[MAX][2];
int Good[MAX][2];
int N, A[MAX];
long long D[MAX][2], End;
int dfs(int i, int step, long long sum) {
End = max(End, sum);
if (i < 1 || i > N) return 1;
if (i == 1) {
if (step == 0)
return 0;
else
return 2;
}
if (Good[i][step]) {
End = max(End, D[i][step] + sum);
return Good[i][step];
}
if (Mark[i][step]) return Good[i][step] = 0;
Mark[i][step] = true;
if (step) {
bool val = dfs(i - A[i], 1 - step, sum + A[i]);
if (val) D[i][step] = End - sum;
return Good[i][step] = val;
} else {
bool val = dfs(i + A[i], 1 - step, sum + A[i]);
if (val) D[i][step] = End - sum;
return Good[i][step] = val;
}
}
int main() {
cin >> N;
for (int i = (2); i <= (N); i++) scanf("%d", &A[i]);
for (int i = (1); i <= (N - 1); i++)
if (!Mark[i + 1][1]) {
End = 0;
dfs(i + 1, 1, i);
}
for (int i = (1); i <= (N - 1); i++) {
if (Good[i + 1][1] == 1)
printf("%I64d\n", D[i + 1][1] + i);
else if (Good[i + 1][1] == 2)
printf("%I64d\n", D[i + 1][1] + i + i);
else
printf("-1\n");
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[200005], ans[200005];
map<long long, long long> mp;
long long dpdfs(long long x) {
long long xc = x;
if (x < 0 || x >= n - 1) return 0;
if (mp[x] > 1) return -1;
mp[x]++;
if (ans[x] != -5) return ans[x];
long long y = a[x];
if (x - a[x] == -1) return -1;
if (x - a[x] < 0) return y;
x -= a[x];
y += a[x];
x += a[x];
long long zz = dpdfs(x);
if (zz == -1) {
ans[xc] = -1;
return -1;
}
return ans[xc] = y + zz;
}
signed main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (long long i = 0; i < n - 1; i++) cin >> a[i];
for (long long i = 0; i < 200005; i++) ans[i] = -5;
for (long long i = 0; i < n - 1; i++)
if (ans[i] == -5) {
mp.clear();
ans[i] = dpdfs(i);
}
for (long long i = 0; i < n - 1; i++) {
if (ans[i] == -1)
cout << -1 << endl;
else
cout << ans[i] + i + 1 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200100;
int n;
int a[MAXN];
int g[2 * MAXN];
int deg[2 * MAXN];
int was[2 * MAXN];
long long sum[2 * MAXN];
void addEdge(int a, int b) {
++deg[b];
g[a] = b;
}
inline bool dfs(int v) {
was[v] = 1;
if (v == 1) return true;
if (g[v] != -1) {
if (was[g[v]] == 1) {
return true;
}
if (!was[g[v]] && dfs(g[v])) {
return true;
}
sum[v] = sum[g[v]];
}
sum[v] += a[(v - 1) % n + 1];
was[v] = 2;
return false;
}
void bfs(int v) {
queue<int> q;
sum[v] = -1;
while (!q.empty()) {
v = q.front();
q.pop();
if (g[v] != -1 && sum[g[v]] != -1) {
sum[g[v]] = -1;
q.push(g[v]);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) {
scanf("%d", a + i);
}
memset(g, 0xff, sizeof g);
for (int i = 2; i <= n; ++i) {
if (i + a[i] <= n) {
addEdge(i, n + i + a[i]);
}
if (i - a[i] > 0) {
addEdge(n + i, i - a[i]);
}
}
for (int i = 2; i <= n; ++i) {
if (deg[i] == 0) {
if (dfs(i)) {
bfs(i);
}
}
if (deg[i + n] == 0) {
if (dfs(i + n)) {
bfs(i + n);
}
}
}
for (int i = 2; i <= n; ++i) {
if (sum[i] == 0) sum[i] = -1;
if (sum[i + n] == 0) sum[i + n] = -1;
}
for (int i = 1; i < n; ++i) {
if (sum[1 + i + n] == -1) {
puts("-1");
} else {
printf("%lld\n", i + sum[1 + i + n]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
int ary[200005];
int vis[200005][2];
long long dp[200005][2];
int n;
pair<int, long long> solve(int x, int st) {
if (vis[x][st] != 0) return make_pair(vis[x][st], dp[x][st]);
vis[x][st] = 3;
int nx = x + (st == 0 ? 1 : -1) * ary[x];
int ny = ary[x];
int nst = (st + 1) % 2;
pair<int, long long> res;
if (nx <= 0 or nx > n)
res = make_pair(4, ny);
else if (nx == 1)
res = make_pair(nst == 0 ? 2 : 1, ny);
else {
res = solve(nx, (st + 1) % 2);
res.second += ny;
}
vis[x][st] = res.first;
dp[x][st] = res.second;
return res;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) scanf("%d", &ary[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < 2; ++j) vis[i][j] = 0;
for (int i = 1; i < n; ++i)
for (int j = 0; j < 2; ++j) solve(i, j);
for (int i = 1; i < n; ++i) {
long long ans = i;
auto res = solve(1 + i, 1);
if (res.first == 3 or res.first == 2)
ans = -1;
else if (res.first == 4)
ans += res.second;
else if (res.first == 1) {
ans += res.second;
ans += i;
}
printf("%lld\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200002];
long long dp[200002][2];
long long dfs(int root, int flag, int v[][2]) {
if (root <= 0 || root > n) return 0;
bool bit;
flag == 1 ? bit = 1 : bit = 0;
if (v[root][bit] == 1) return dp[root][bit];
if (v[root][bit] == 0) return -1;
v[root][bit] = 0;
dp[root][bit] = dfs(root + flag * a[root], flag * -1, v);
if (dp[root][bit] != -1) dp[root][bit] += (long long)a[root];
v[root][bit] = 1;
return dp[root][bit];
}
int main() {
ios_base::sync_with_stdio(false);
int i, j, temp;
int v[200002][2];
long long ans;
memset(v, -1, sizeof(v));
cin >> n;
for (i = 2; i < n + 1; i++) cin >> a[i];
for (i = 1; i < n; i++) {
a[1] = i;
v[1][0] = v[1][1] = -1;
ans = dfs(1, 1, v);
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[210000];
long long dp[210000][2];
const long long INF = 1LL << 60;
int N;
void init() {
for (int i = 0; i < 210000; i++)
for (int j = 0; j < 2; j++) dp[i][j] = INF;
}
long long solve(int x, bool t) {
if (x <= 0 || x > N) return 0;
if (x == 1) return -1;
if (dp[x][t] == -INF) return dp[x][t] = -1;
if (dp[x][t] != INF) return dp[x][t];
dp[x][t] = -INF;
int x2 = x;
if (t) {
x2 += a[x];
} else {
x2 -= a[x];
}
long long tmp = solve(x2, !t);
if (tmp == -1) return dp[x][t] = -1;
return dp[x][t] = a[x] + tmp;
}
int main() {
cin >> N;
for (int i = 2; i <= N; i++) cin >> a[i];
init();
for (int i = 1; i < N; i++) {
long long ret = solve(1 + i, false);
if (~ret) ret += i;
cout << ret << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long n;
long long a[N];
long long cache[N][2];
long long dp(long long x, long long sign) {
if (x <= 0 || x > n) return 0;
long long &ans = cache[x][sign];
if (ans != -1) return ans;
ans = -1e13;
if (!sign)
ans = a[x] + dp(x + a[x], sign ^ 1);
else
ans = a[x] + dp(x - a[x], sign ^ 1);
return ans;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
memset(cache, -1, sizeof(cache));
cin >> n;
for (long long i = 2; i <= n; i++) cin >> a[i];
for (long long i = 1; i <= n - 1; i++) {
long long ans = i + dp(i + 1, 1);
if (ans < 0) ans = -1;
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:200000000")
using namespace std;
template <typename T>
inline T Abs(T x) {
return (x >= 0) ? x : -x;
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
template <typename T>
string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
inline int nextInt() {
int x;
if (scanf("%d", &x) != 1) throw;
return x;
}
inline long long nextInt64() {
long long x;
if (scanf("%I64d", &x) != 1) throw;
return x;
}
inline double nextDouble() {
double x;
if (scanf("%lf", &x) != 1) throw;
return x;
}
const int INF = (int)1E9;
const long long INF64 = (long long)1E18;
const long double EPS = 1E-9;
const long double PI = 3.1415926535897932384626433832795;
const int MAXN = 300100;
vector<int> g[MAXN], gt[MAXN], w[MAXN], bad;
int n, a[MAXN], used[MAXN];
long long d[MAXN];
void add(int v, int u, int value) {
w[v].push_back(value);
gt[u].push_back(v);
g[v].push_back(u);
}
void DFS(int v) {
used[v] = 1;
for (int i = 0; i < (int)(g[v].size()); i++) {
int u = g[v][i];
if (used[u] == 1) bad.push_back(u);
if (used[u] == 0) DFS(u);
}
used[v] = 2;
}
void DFS2(int v) {
used[v] = 1;
for (int i = 0; i < (int)(gt[v].size()); i++) {
int u = gt[v][i];
if (used[u] == 0) DFS2(u);
}
}
long long get(int v) {
long long &ans = d[v];
if (ans != -1) return ans;
ans = 0;
for (int i = 0; i < (int)(g[v].size()); i++) {
int u = g[v][i];
ans = max(ans, w[v][i] + get(u));
}
return ans;
}
int main() {
n = nextInt();
for (int i = 2; i <= n; i++) a[i] = nextInt();
for (int i = 2; i <= n; i++) {
int xx = i + a[i];
if (xx <= n) {
int xxx = xx - a[xx];
if (1 <= xxx && xxx <= n)
add(i, xxx, a[xx] + a[i]);
else
add(i, n + 1, a[xx] + a[i]);
} else
add(i, n + 1, a[i]);
}
bad.push_back(1);
for (int i = 2; i <= n; i++)
if (used[i] == 0) DFS(i);
memset(used, 0, sizeof used);
for (int i = 0; i < (int)(bad.size()); i++) {
int v = bad[i];
if (used[v] == 0) DFS2(v);
}
memset(d, 255, sizeof d);
for (int i = 1; i < n; i++) {
a[1] = i;
int x = 1 + a[1];
long long ans = a[1];
if (x <= n) {
ans += a[x];
x -= a[x];
if (1 <= x && x <= n) {
if (used[x] != 0)
ans = -1;
else
ans += get(x);
}
}
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long int> g[200005];
long long int n, a[200005];
vector<vector<long long int> > ans(200005, vector<long long int>(2));
vector<vector<bool> > vis(200005, vector<bool>(2, false));
long long int dfs(long long int s, long long int t) {
if (s == 0 || s == n + 1) return 0;
if (vis[s][t]) {
if (ans[s][t]) return ans[s][t];
return -1;
}
vis[s][t] = true;
ans[s][t] = dfs(g[s][t], 1 - t);
if (ans[s][t] == -1) return -1;
ans[s][t] += a[s - 2];
return ans[s][t];
}
void solve() {
cin >> n;
for (__typeof(n - 1) i = 0; i < n - 1; i++) cin >> a[i];
for (__typeof(n - 1) i = 0; i < n - 1; i++) {
g[i + 2].emplace_back(min(n + 1, i + a[i] + 2));
g[i + 2].emplace_back(max((long long int)0, i - a[i] + 2));
}
vis[1][0] = true;
for (__typeof(n + 1) i = 2; i < n + 1; i++)
if (!vis[i][0]) ans[i][0] = dfs(i, 0);
for (__typeof(n + 1) i = 2; i < n + 1; i++)
if (!vis[i][1]) ans[i][1] = dfs(i, 1);
for (__typeof(n) i = 1; i < n; i++) {
if (ans[1 + i][1] == -1)
cout << -1 << endl;
else
cout << ans[1 + i][1] + i << endl;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 200008;
long long dp[MAX][2];
int A[MAX], n, vis[MAX][2];
long long rec(int idx, int move) {
long long &ret = dp[idx][move], here = 0;
if (vis[idx][move] == 2)
return -1;
else if (vis[idx][move] == 1)
return ret;
vis[idx][move] = 2;
ret = A[idx];
if (move == 0 && idx + A[idx] <= n)
here = rec(idx + A[idx], move ^ 1);
else if (move == 1 && idx - A[idx] >= 1)
here = rec(idx - A[idx], move ^ 1);
if (here != -1)
ret += here;
else
ret = -1;
vis[idx][move] = 1;
return ret;
}
int main() {
cin >> n;
for (int i = 2; i <= n; i++) cin >> A[i];
memset(dp, -1, sizeof dp);
long long ans;
vis[0][0] = 2;
for (int a1 = 1; a1 <= n - 1; a1++) {
ans = rec(1 + a1, 1);
if (ans != -1) ans += a1;
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long f[200003];
int a[200003], n, vis[200003];
bool ans[200003];
bool s3(int x) {
if (vis[x] == a[1]) return 0;
if (ans[x]) return f[x] != -1LL;
vis[x] = a[1];
ans[x] = 1;
int X = x;
f[X] += (long long)(a[x]);
x -= a[x];
if (x < 1) return 1;
f[X] += (long long)(a[x]);
x += a[x];
if (x > n) return 1;
if (!s3(x)) {
f[X] = -1LL;
return 0;
} else {
f[X] += f[x];
return 1;
}
}
int main() {
std::ios::sync_with_stdio(false);
int i, j, k, m;
cin >> n;
for (i = 2; i <= n; ++i) cin >> a[i];
for (a[1] = 1; a[1] < n; ++a[1]) {
if (s3(1 + a[1]))
cout << ((long long)(a[1]) + f[1 + a[1]]) << endl;
else
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
long long a[maxn], mem[maxn];
int pos = 1;
int used[maxn];
long long n;
void read() {
scanf("%lld", &n);
for (int i = 2; i <= n; ++i) scanf("%lld", &a[i]);
}
long long go(long long k) {
if (used[k] == pos) {
mem[k] = -1;
return -1;
}
if (mem[k] != 0) return mem[k];
if (k <= 0LL || k > n) return 0;
used[k] = pos;
long long ret = 0LL;
long long p = k;
ret += a[p];
p += a[p];
if (p > n) {
mem[k] = ret;
return ret;
}
long long tmp;
ret += a[p];
p -= a[p];
if (p <= 0 || p > n) {
mem[k] = ret;
return ret;
} else {
tmp = go(p);
if (tmp != -1) {
mem[k] = ret + tmp;
return mem[k];
} else {
mem[k] = -1;
return -1;
}
}
}
void solve() {
for (long long i = 2; i <= n; ++i) {
used[1] = 1;
if (mem[i] == 0) go(i);
++pos;
}
mem[1] = -1;
long long x = 1LL, y = 0LL, p;
for (long long i = 1; i < n; ++i) {
a[1] = i;
x = 1LL;
y = 0LL;
p = x;
y += a[p];
p += a[p];
if (p > n) {
printf("%I64d\n", y);
} else {
y += a[p];
p -= a[p];
if (p <= 0 || p > n) {
printf("%I64d\n", y);
} else {
if (mem[p] != -1)
printf("%I64d\n", (long long)(y + mem[p]));
else
printf("-1\n");
}
}
}
}
int main() {
read();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979;
long long n;
long long A[200001];
long long sum[200001];
long long used[200001];
long long step = 1;
long long dfs(long long v) {
if (used[v]) {
if (step == used[v]) return -1;
return sum[v];
}
used[v] = step;
long long next = v - A[v];
sum[v] += A[v];
if (next > 0 && next <= n) {
if (next == 1) {
sum[v] = -1;
} else {
sum[v] += A[next];
next += A[next];
if (next > 0 && next <= n) {
long long get = dfs(next);
if (get == -1) {
sum[v] = -1;
} else {
sum[v] += get;
}
}
}
}
return sum[v];
}
int main() {
scanf("%I64d", &n);
for (long long i = 2; i <= n; ++i) {
scanf("%I64d", &A[i]);
}
for (long long i = 2; i <= n; ++i) {
++step;
long long ans = dfs(i);
if (ans >= 0) ans += i - 1;
printf("%I64d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
int n;
int a[200001];
long long dp[200001][2];
bool visit[200001][2];
long long dfs(int step, int direct) {
if (step <= 0 || step > n)
return 0;
else if (dp[step][direct])
return dp[step][direct];
else if (visit[step][direct])
return dp[step][direct] = -1;
else {
visit[step][direct] = true;
long long temp = a[step];
long long ans =
dfs(step + ((direct == 0) ? a[step] : -a[step]), direct ^ 1);
temp = (ans == -1) ? -1 : temp + ans;
dp[step][direct] = temp;
visit[step][direct] = false;
return dp[step][direct];
}
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
a[1] = i;
dp[1][0] = dp[1][1] = 0;
printf("%I64d\n", dfs(1, 0));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200013;
int n, i, l, a[maxn], h[maxn][2];
bool s[maxn][2];
long long sum[maxn][2];
void Search(int u, bool st) {
if (h[u][st] >= i) {
sum[u][st] = -1;
return;
} else {
h[u][st] = i;
}
int v = u;
if (st)
v -= a[u];
else
v += a[u];
if (v <= 0 || v > n) {
if (u > 1) sum[u][st] = a[u];
return;
}
if (!sum[v][!st]) Search(v, !st);
if (sum[v][!st] >= 0) {
if (u > 1) sum[u][st] = a[u];
sum[u][st] += sum[v][!st];
s[u][st] = s[u][st] || s[v][!st];
} else
sum[u][st] = -1;
}
int main() {
scanf("%d", &n);
s[1][1] = 1;
h[1][0] = n;
sum[1][0] = -1;
for (i = 2; i <= n; i++) scanf("%d", &a[i]);
for (i = 2; i <= n; i++) {
a[1] = i - 1;
if (!sum[i][1]) Search(i, 1);
if (sum[i][1] >= 0) {
if (s[i][1])
printf("%I64d\n", sum[i][1] + a[1] * 2);
else
printf("%I64d\n", sum[i][1] + a[1]);
} else {
printf("-1\n");
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 2 * 1e5 + 5;
int ans = 0;
int i, j, n, m, k, z, y, x, t, mi, ma;
long long a[N];
long long dp[N][2], d[N][2];
char st[N];
long long poisk(int x, int t) {
if (dp[x][t] != 0) return dp[x][t];
long long y = x;
d[x][t]++;
if (d[x][t] > 1) {
d[x][t] = -1;
return d[x][t];
}
if (t == 0)
y += a[x];
else
y -= a[x];
if (y < 1 || y > n) {
dp[x][t] = a[x];
return dp[x][t];
}
long long z = poisk(y, 1 - t);
if (z > 0)
dp[x][t] = a[x] + z;
else
dp[x][t] = -1;
return dp[x][t];
}
int main() {
scanf("%d", &n);
for (i = 2; i <= n; i++) scanf("%I64d", &a[i]);
for (i = 1; i < n; i++) {
a[1] = i;
d[1][0] = 0;
long long k = poisk(1 + i, 1);
if (k > 0) k += i;
printf("%I64d\n", k);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int M = 2e5 + 10;
const long long int mod = 1e9 + 7;
const long long int infi = LLONG_MAX;
long long int ans, k, n, m, mymax = LLONG_MIN, mymin = LLONG_MAX, b, c, z, sum;
vector<long long int> v[M];
long long int visit[M], visit2[M];
long long int x[M], y[M], a[M];
long long int start_time[M], end_time[M], curr_time;
pair<long long int, long long int> next(long long int node) {
long long int tempx = node + a[node], tempy = a[node];
;
;
if (tempx > n || tempx <= 0) {
return {-1, tempy};
}
tempy += a[tempx];
tempx -= a[tempx];
return {tempx, tempy};
}
long long int dfs(long long int node) {
long long int tempx, tempy;
visit[node] = 1;
start_time[node] = curr_time++;
pair<long long int, long long int> temp = next(node);
tempx = temp.first;
tempy = temp.second;
if (tempx <= 0) {
y[node] = tempy;
end_time[node] = curr_time;
return 0;
};
;
if (visit[tempx] != 1)
dfs(tempx);
else if (start_time[tempx] <= start_time[node] &&
end_time[tempx] >= end_time[node]) {
end_time[node] = curr_time;
y[node] = -1;
return 0;
}
end_time[node] = curr_time;
if (y[tempx] == -1) {
y[node] = -1;
return 0;
}
tempy += y[tempx];
y[node] = tempy;
return 0;
}
int main() {
long long int i, j;
scanf("%lld", &n);
for (i = 1; i < n; i++) scanf("%lld", &a[i + 1]), end_time[i] = mymin;
for (i = 2; i < n + 1; i++) {
if (visit[i] == 0) dfs(i);
}
visit[1] = 1;
y[1] = -1;
for (i = 1; i < n; i++) {
long long int tempx = 1 + i - a[i + 1], tempy = i + a[i + 1];
;
;
if (tempx <= 0 || tempx > n) {
printf("%lld\n", tempy);
} else if (y[tempx] != -1)
printf("%lld\n", y[tempx] + tempy);
else
printf("%s", "-1\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)2e5 + 10;
map<pair<int, int>, int> mp;
map<pair<int, int>, long long> sum;
long long n, a[N] = {};
long long dfs(int x, int id, int add) {
if (x <= 0 || x > n) return 0;
if (mp.count({x, add}) && mp[{x, add}] == id) return -(long long)1e16;
if (mp.count({x, add})) return sum[{x, add}];
mp[{x, add}] = id;
long long y = dfs(x + add * a[x], id, add == -1 ? 1 : -1) + a[x];
sum[{x, add}] = y;
return y;
}
int main() {
ios::sync_with_stdio(0), ios_base::sync_with_stdio(0), cin.tie(0),
cout.tie(0);
;
cin >> n;
for (long long i = 2; i <= (int)n; ++i) cin >> a[i];
for (long long i = 1; i <= (int)n - 1; ++i) {
a[1] = i;
mp.erase({1, 1});
mp.erase({1, -1});
long long o = dfs(1, i, 1);
if (o < 0)
cout << -1 << "\n";
else
cout << o << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
long long dp[MAXN][2];
int b[MAXN][2], a[MAXN];
int n;
long long dfs(int x, int op, int cur) {
if (x <= 0 || x > n) {
return 0;
}
if (dp[x][op] != 0) {
return dp[x][op];
}
if (b[x][op] == cur) {
return -1;
}
b[x][op] = cur;
int delta = op == 0 ? a[x] : -a[x];
long long ret = dfs(x + delta, 1 - op, cur);
if (ret == -1) {
return dp[x][op] = -1;
}
return dp[x][op] = ret + a[x];
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; ++i) {
scanf("%d", a + i);
}
for (int i = 1; i < n; ++i) {
a[1] = i;
dp[1][0] = 0;
long long ret = dfs(1, 0, i);
cout << ret << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(200050);
int n, a[MAXN];
bool visited[MAXN][2];
long long b[MAXN][2];
long long DFS(int x, long long y, int c) {
if (x <= 0 || x > n) return y;
if (x == 1) return -1;
if (visited[x][c]) {
if (b[x][c] == -1)
return -1;
else
return y + b[x][c];
}
visited[x][c] = 1;
if (c) {
long long num = DFS(x + a[x], y + a[x], !c);
if (num == -1)
b[x][c] = -1;
else
b[x][c] = num - y;
return num;
} else {
long long num = DFS(x - a[x], y + a[x], !c);
if (num == -1)
b[x][c] = -1;
else
b[x][c] = num - y;
return num;
}
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) scanf("%d", &a[i]);
for (int i = 2; i <= n; i++) b[i][0] = b[i][1] = -1;
for (int i = 2; i <= n; i++)
if (!visited[i][0]) DFS(i, 0, 0);
for (int i = 2; i <= n; i++)
if (b[i][0] == -1)
printf("-1\n");
else
printf("%I64d\n", b[i][0] + (i - 1));
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200100;
int n;
int a[N];
long long dp[N];
bool vis[N];
bool fin[N];
long long DP(int cur) {
if (cur <= 0 || cur > n) return 0;
if (cur == 1) return -1;
if (vis[cur]) {
if (!fin[cur]) return -1;
return dp[cur];
}
vis[cur] = true;
long long nxt = cur - a[cur];
if (nxt <= 0 || nxt > n) {
fin[cur] = true;
return dp[cur] = a[cur];
}
long long res = DP(nxt + a[nxt]);
fin[cur] = true;
if (res == -1) return dp[cur] = -1;
return dp[cur] = res + a[cur] + a[nxt];
}
int main() {
while (cin >> n) {
for (int i = 2; i <= n; ++i) cin >> a[i];
memset(vis, 0, sizeof(vis));
memset(fin, 0, sizeof(fin));
for (int i = 1; i < n; ++i) {
a[1] = i;
long long ans = DP(1 + i);
if (ans == -1)
cout << (-1) << endl;
else
cout << (i + ans) << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int a[210000];
long long dp[210000][2];
const long long INF = 1LL << 60;
int N;
long long solve(int x, bool t) {
if (x <= 0 || x > N) return 0;
if (x == 1) return -1;
if (dp[x][t] != INF) return dp[x][t];
dp[x][t] = -1;
int i2 = x;
if (t)
i2 += a[x];
else
i2 -= a[x];
long long r = solve(i2, !t);
long long res;
if (r == -1)
res = -1;
else
res = a[x] + r;
dp[x][t] = res;
return res;
}
int main() {
for (int i = 0; i < 210000; i++)
for (int j = 0; j < 2; j++) dp[i][j] = INF;
cin >> N;
for (int i = 0; i < N - 1; i++) cin >> a[i + 2];
for (int i = 1; i < N; i++) {
long long r = solve(1 + i, 0);
if (r != -1) r += i;
cout << r << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
long long mem[MAXN + 1][2];
int visited[MAXN + 1][2];
int b[MAXN + 1][2];
int a[MAXN + 1];
int n;
int input() {
int i;
scanf("%d", &n);
for (i = 2; i <= n; i++) scanf("%d", &a[i]);
return 0;
}
int search(int x, int k) {
int i, tx;
if (visited[x][k] == 1) {
mem[x][k] = -1;
return 0;
}
if (visited[x][k] == 2) {
return 0;
}
if (x == 1 && k == 1) {
b[x][k] = 1;
mem[x][k] = 0;
return 0;
}
mem[x][k] += a[x];
visited[x][k] = 1;
tx = x;
if (k)
tx -= a[x];
else
tx += a[x];
if (tx >= 1 && tx <= n) {
search(tx, k ^ 1);
if (mem[tx][k ^ 1] != -1) {
mem[x][k] += mem[tx][k ^ 1];
b[x][k] = b[tx][k ^ 1];
} else
mem[x][k] = -1;
}
visited[x][k] = 2;
return 0;
}
int solve() {
int i;
memset(visited, 0, sizeof(visited));
memset(mem, 0, sizeof(mem));
memset(b, 0, sizeof(b));
visited[1][0] = 1;
for (i = 2; i <= n; i++)
if (!visited[i][1]) search(i, 1);
for (i = 1; i < n; i++) {
a[1] = i;
a[0] = 0;
if (mem[i + 1][1] == -1)
printf("-1\n");
else
printf("%I64d\n", mem[i + 1][1] + i + a[b[i + 1][1]]);
}
return 0;
}
int main() {
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 29;
int vis[200010][2];
long long dp[200010][2];
int n, a[200010];
long long dfs(int x, int k) {
if (x <= 0 || x > n) return 0;
if (x == 1) return -1;
if (vis[x][k]) return dp[x][k];
vis[x][k] = 1;
long long ans = a[x];
int y;
if (k)
y = x - a[x];
else
y = x + a[x];
long long t = dfs(y, k ^ 1);
if (t == -1)
ans = -1;
else
ans += t;
return dp[x][k] = ans;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) scanf("%d", &a[i]);
memset(dp, -1, sizeof(dp));
for (int i = 2; i <= n; i++) {
if (!vis[i][0]) {
dfs(i, 0);
}
if (!vis[i][1]) {
dfs(i, 1);
}
}
for (int i = 1; i <= n - 1; i++) {
if (dp[i + 1][1] == -1)
printf("%d\n", -1);
else
printf("%I64d\n", dp[i + 1][1] + i);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 7;
long long int num[maxn];
long long int dp[maxn][3];
bool vis[maxn][3];
int n;
int dfs(int now, int flag) {
if (vis[now][flag] == 0) {
vis[now][flag] = 1;
long long nextt = 0;
if (flag == 1)
nextt = now * 1ll - num[now];
else
nextt = now * 1ll + num[now];
if (nextt <= 0 || nextt > n * 1ll)
dp[now][flag] = num[now];
else {
dfs(nextt, flag ^ 1);
if (dp[nextt][flag ^ 1] != -1)
dp[now][flag] = dp[nextt][flag ^ 1] + num[now];
else
return 0;
}
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) {
scanf("%lld", &num[i]);
}
vis[1][0] = vis[1][1] = 1;
long long y = 0;
memset(dp, -1, sizeof(dp));
dp[1][1] = 0;
int x = 1;
int flag = 1;
int pre = 1;
for (int i = 2; i <= n; i++) {
dfs(i, flag);
}
for (int i = 2; i <= n; i++) {
if (dp[i][1] != -1) dp[i][1] += (i - 1);
}
for (int i = 2; i <= n; i++) printf("%lld\n", dp[i][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
int Array[200005], N;
bool Visited[200005][2];
long long Sum[200005][2], Ans[200005];
set<pair<int, int> > S;
set<pair<int, int> >::iterator it;
bool dfs(int root, int Cur) {
if (Visited[root][Cur] == true) {
it = S.find(make_pair(root, Cur));
if (it != S.end()) {
Sum[root][Cur] = -1;
return false;
}
if (Sum[root][Cur] != -1)
return true;
else
return false;
}
S.insert(make_pair(root, Cur));
Visited[root][Cur] = true;
long long x;
if (Cur == 0)
x = root - Array[root];
else
x = root + Array[root];
if (x <= 0 || x > N) {
Sum[root][Cur] = Array[root];
return true;
}
bool Found = dfs(x, Cur ^ 1);
if (Found == true) {
Sum[root][Cur] = Array[root] + Sum[x][Cur ^ 1];
return true;
} else {
Sum[root][Cur] = -1;
return false;
}
}
int main() {
scanf("%d", &N);
for (int i = 2; i <= N; ++i) scanf("%d", Array + i);
Visited[1][1] = true;
Sum[1][1] = -1;
bool Found;
for (int i = 1; i < N; ++i) {
Array[1] = i;
Found = dfs(1 + i, 0);
if (Found == true)
Ans[i] = Array[1] + Sum[1 + i][0];
else
Ans[i] = -1;
S.clear();
}
for (int i = 1; i < N; ++i) printf("%lld\n", Ans[i]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long g[222222][2];
int f[222222], p[222222][2], n, i;
long long dfs(int x, int k, int z) {
if (x < 1 || x > n) return 0;
if (g[x][z] == -1 || p[x][z] == k) return -1;
if (p[x][z]) return g[x][z];
long long ans = 0;
p[x][z] = k;
if (z)
ans = dfs(x + f[x], k, z ^ 1);
else
ans = dfs(x - f[x], k, z ^ 1);
if (ans == -1)
return g[x][z] = -1;
else
return g[x][z] = ans + f[x];
}
int main() {
scanf("%d", &n);
for (i = 2; i <= n; i++) scanf("%d", f + i);
for (i = 1; i < n; i++) {
f[1] = i;
p[1][1] = 0;
g[1][1] = 0;
printf("%I64d\n", dfs(1, i, 1));
}
return 0;
}
|
#include <bits/stdc++.h>
long long mpow(long long a, long long n, long long mod) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
n >>= 1;
}
return (long long)ret;
}
using namespace std;
long long dp[200002][2];
int n, y = 0;
long long a[200005];
long long vis[200005][2];
long long dfs(int x, int q, int m) {
if (x <= 0 || x > n) return 0;
if (dp[x][q] != 0) return dp[x][q];
if (vis[x][q] == m) return -1e29;
long long ret = 0;
if (q == 0) {
vis[x][0] = m;
ret += a[x] + dfs(x + a[x], 1, m);
} else {
vis[x][1] = m;
ret += a[x] + dfs(x - a[x], 0, m);
}
return dp[x][q] = ret;
}
int main() {
memset(vis, 0, sizeof(vis));
memset(dp, 0, sizeof(dp));
cin >> n;
int i, j;
for (j = 2; j <= n; j++) cin >> a[j];
for (j = 1; j <= n - 1; j++) {
a[1] = j;
long long ans = dfs(1, 0, j);
if (ans < 0)
cout << -1 << endl;
else
cout << ans << endl;
dp[1][0] = 0;
y = 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[200005][2];
bool vst[200005][2];
long long A[200005], n;
long long go(long long v, bool b) {
if (vst[v][b]) return dp[v][b];
vst[v][b] = true;
long long val = 0;
if (!b) {
if ((v - A[v]) > 1)
val = go(v - A[v], b ^ 1);
else if ((v - A[v]) == 1)
val = -1;
} else {
if ((v + A[v]) <= n) val = go(v + A[v], b ^ 1);
}
if (val != -1)
dp[v][b] = A[v] + val;
else
dp[v][b] = -1;
return dp[v][b];
}
int main() {
long long i;
cin >> n;
for (i = (2); i <= (n); i++) {
cin >> A[i];
}
memset((vst), (0), sizeof(vst));
long long j;
memset((dp), (-1), sizeof(dp));
for (i = (2); i <= (n); i++) {
go(i, 0);
if (dp[i][0] != -1)
cout << dp[i][0] + i - 1 << endl;
else
cout << -1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
std::set<int> circle;
long long d[200100][2], a[200100];
int ok[200100][2], n;
long long cal(long long x, int state) {
if (x <= 0 || x > n) return 0;
if (circle.count(x * 2 + state)) {
ok[x][state] = 1;
return d[x][state] = -1;
}
circle.insert(x * 2 + state);
if (ok[x][state]) return d[x][state];
long long tmp;
if (state)
tmp = cal(x + a[x], !state);
else
tmp = cal(x - a[x], !state);
ok[x][state] = 1;
if (tmp == -1)
return d[x][state] = -1;
else
return d[x][state] = tmp + a[x];
}
int main() {
int i;
scanf("%d", &n);
for (i = 2; i <= n; i++) scanf("%I64d", a + i);
for (i = 1; i < n; i++) {
circle.clear();
long long tmp = cal(i + 1, 0);
if (tmp == -1)
puts("-1");
else
printf("%I64d\n", tmp + i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 2.0 * acos(0.0);
const double EPS = 1e-6;
int a[200005];
bitset<200005> visit[2];
long long dp[2][200005];
int n;
long long DFS(int x, int dir) {
if (x <= 0 || x > n) return 0LL;
if (visit[dir][x]) return dp[dir][x] > 0 ? dp[dir][x] : -1;
visit[dir][x] = true;
long long res = DFS(x + (dir == 0 ? -a[x] : a[x]), dir ^ 1);
if (res == -1)
return dp[dir][x] = -1;
else
return dp[dir][x] = a[x] + res;
}
int main() {
scanf("%d", &n);
for (int i = 2; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
a[1] = i;
visit[1][1] = false;
dp[1][1] = 0LL;
cout << DFS(1, 1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> adj(2 * n, -1);
vector<int> v(n, 0);
vector<long long> res(2 * n, -2);
for (int i = 1; i < n; ++i) {
cin >> v[i];
if (i + v[i] < n) adj[i << 1] = ((i + v[i]) << 1) + 1;
if (i - v[i] >= 0) adj[(i << 1) + 1] = (i - v[i]) << 1;
}
for (int i = 1; i < n; i++) {
adj[0] = (i << 1) + 1;
v[0] = i;
vector<bool> flag(2 * n, false);
flag[0] = true;
stack<int> S;
S.push(0);
bool found = false;
long long ans;
while (!S.empty()) {
if (!found) {
int cur = S.top();
if (res[cur] != -2) {
ans = res[cur];
found = true;
continue;
}
if (adj[cur] != -1) {
if (!flag[adj[cur]]) {
S.push(adj[cur]);
flag[adj[cur]] = true;
} else {
found = true;
ans = -1;
}
} else {
found = true;
ans = 0;
}
} else {
int cur = S.top();
if (cur >= 2) {
res[cur] = ans;
}
if (ans != -1) {
ans += v[cur >> 1];
}
S.pop();
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[200005] = {0}, dp[2][200005] = {0};
long long dpf(int idx, int inc) {
if (idx == 1) return -1;
if (idx > n || idx < 2) return 0LL;
long long &res = dp[inc][idx];
if (res != 0) return res;
res = -1LL;
if (inc)
res = dpf(idx + a[idx], inc ^ 1);
else
res = dpf(idx - a[idx], inc ^ 1);
if (res == -1) return res;
return res = res + a[idx];
}
int main(int argc, char **argv) {
std::ios::sync_with_stdio(false);
scanf("%I64d", &n);
for (int i = 2; i <= n; i++) scanf("%I64d", &a[i]);
for (int i = 2; i <= n; i++) dpf(i, 0);
for (int i = 1; i < n; i++) {
if (dp[0][i + 1] == -1LL)
printf("%I64d\n", -1LL);
else
printf("%I64d\n", dp[0][i + 1] + i);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.