text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
if (c == '-') f = -1, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return f * x;
}
const int maxn = 2e5 + 7;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int n;
int a[maxn], b[maxn], pos[maxn], rpos[maxn];
vector<int> in[maxn], out[maxn];
int main() {
n = read();
for (int i = 1; i <= n; ++i) {
a[i] = read(), b[i] = read();
in[a[i]].push_back(i);
}
set<pair<int, int> > s;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < in[i].size(); ++j)
s.insert(pair<int, int>(b[in[i][j]], in[i][j]));
pair<int, int> now = *s.begin();
s.erase(s.begin());
pos[rpos[i] = now.second] = i;
}
vector<int> v1, v2;
for (int i = 1; i <= n; ++i) v1.push_back(pos[i]);
s.clear();
for (int i = 1; i <= n; ++i) out[b[i]].push_back(i);
for (int i = 1; i <= n; ++i) assert(b[i] >= pos[i]);
for (int i = 1; i <= n; ++i) {
if (s.size()) {
if (s.rbegin()->first >= a[rpos[i]]) {
swap(pos[s.rbegin()->second], pos[rpos[i]]);
break;
}
}
s.insert(pair<int, int>(i, rpos[i]));
for (int j = 0; j < out[i].size(); ++j) {
assert(s.find(pair<int, int>(pos[out[i][j]], out[i][j])) != s.end());
s.erase(s.find(pair<int, int>(pos[out[i][j]], out[i][j])));
}
}
for (int i = 1; i <= n; ++i) v2.push_back(pos[i]);
if (v1 != v2) {
printf("NO\n");
for (int i = 0; i < v1.size(); ++i) printf("%d ", v1[i]);
puts("");
for (int i = 0; i < v2.size(); ++i) printf("%d ", v2[i]);
puts("");
} else {
printf("YES\n");
for (int i = 0; i < v1.size(); ++i) printf("%d ", v1[i]);
puts("");
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
using vec = std::vector<T>;
bool __hack = std::ios::sync_with_stdio(false);
auto __hack1 = cin.tie(nullptr);
namespace template_util {
constexpr int bytecount(uint64_t x) { return x ? 1 + bytecount(x >> 8) : 0; }
template <int N>
struct bytetype {};
template <uint64_t N>
struct minimal_uint : bytetype<bytecount(N)> {};
} // namespace template_util
template <class T>
T next(istream& in) {
T ret;
in >> ret;
return ret;
}
template <class T>
void outVec(ostream& out, const vector<T>& v) {
if (v.empty()) {
out << "\n";
return;
}
out << v[0];
for (size_t i = 1; i < v.size(); ++i) {
out << ' ' << v[i];
}
out << "\n";
}
const int INF = numeric_limits<int>::max() / 2;
template <class T>
vec<T> incOne(const vec<T>& v) {
vec<T> res(v.begin(), v.end());
for (int i = 0; i < (res.size()); ++i) {
++res[i];
}
return res;
}
struct SegmentTree {
vec<pair<int, int>> tree;
int n;
SegmentTree(int n, const vec<int>& values) : n(n) {
tree = vec<pair<int, int>>(4 * n);
build(1, 0, n, values);
}
void build(int v, int le, int ri, const vec<int>& values) {
if (le + 1 == ri) {
tree[v] = {values[le], le};
return;
}
int mid = (le + ri) / 2;
build(2 * v, le, mid, values);
build(2 * v + 1, mid, ri, values);
tree[v] = min(tree[2 * v], tree[2 * v + 1]);
}
pair<int, int> get(int le, int ri) { return internalGet(1, le, ri, 0, n); }
pair<int, int> internalGet(int v, int l, int r, int ll, int rr) {
if (l >= rr || ll >= r) return {INF, INF};
if (l <= ll && rr <= r) {
return tree[v];
}
int m = (ll + rr) / 2;
auto res = internalGet(2 * v, l, r, ll, m);
res = min(res, internalGet(2 * v + 1, l, r, m, rr));
return res;
}
};
void solve(istream& in, ostream& out) {
auto n = next<int>(in);
vec<int> le(n), ri(n), idx(n);
for (int i = 0; i < (n); ++i) {
le[i] = next<int>(in) - 1;
ri[i] = next<int>(in) - 1;
idx[i] = i;
}
sort(idx.begin(), idx.end(), [&](int a, int b) -> bool {
return le[a] < le[b] || (le[a] == le[b] && ri[a] < ri[b]);
});
set<pair<int, int>> Q;
vec<int> assignments(n), lefts(n), revAssign(n);
int ptr = 0;
for (int i = 0; i < (n); ++i) {
while (ptr < n && le[idx[ptr]] <= i) {
Q.insert({ri[idx[ptr]], idx[ptr]});
++ptr;
}
auto p = *Q.begin();
Q.erase(Q.begin());
int id = p.second;
assignments[i] = id;
revAssign[id] = i;
lefts[i] = le[id];
}
SegmentTree st(n, lefts);
for (int i = 0; i < (n); ++i) {
int whoIsThere = assignments[i];
int from = i + 1;
int to = ri[whoIsThere];
auto p = st.get(from, to + 1);
if (p.first >= from) {
continue;
}
out << "NO\n";
outVec(out, incOne(revAssign));
swap(revAssign[assignments[i]], revAssign[assignments[p.second]]);
outVec(out, incOne(revAssign));
return;
}
out << "YES\n";
outVec(out, incOne(revAssign));
}
int main() {
solve(cin, cout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N;
cin >> N;
vector<int> L(N), R(N);
vector<vector<int>> adds(N);
for (int i = 0; i < N; ++i) {
cin >> L[i] >> R[i];
--L[i], --R[i];
adds[L[i]].emplace_back(i);
}
multiset<pair<int, int>> ms;
auto print = [&](vector<int> ord) {
vector<int> perm(N);
for (int i = 0; i < N; ++i) perm[ord[i]] = i;
for (int v : perm) cout << v + 1 << " ";
cout << "\n";
};
vector<int> ord(N);
for (int l = 0; l < N; ++l) {
for (int i : adds[l]) ms.emplace(R[i], i);
ord[l] = ms.begin()->second;
ms.erase(ms.begin());
}
vector<int> perm(N);
for (int i = 0; i < N; ++i) perm[ord[i]] = i;
vector<int> last(N);
for (int i = 0; i < N; ++i) {
if (i == 0 || R[ord[i - 1]] == i - 1) {
last[i] = i;
} else {
last[i] = last[i - 1];
}
}
for (int l = 0; l < N; ++l) {
for (int i : adds[l]) ms.emplace(R[i], i);
if (ms.size() >= 2) {
int x = ms.begin()->second;
int y = next(ms.begin())->second;
if (last[perm[y]] <= R[x]) {
vector<int> neword = ord;
neword[l] = y;
ms.erase(next(ms.begin()));
for (++l; l < N; ++l) {
for (int i : adds[l]) ms.emplace(R[i], i);
neword[l] = ms.begin()->second;
ms.erase(ms.begin());
}
cout << "NO\n";
print(ord);
print(neword);
return 0;
}
}
ms.erase(ms.begin());
}
cout << "YES\n";
print(ord);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
int solve();
void precomp();
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int t = 1;
if (0) cin >> t;
precomp();
while (t--) solve();
}
void precomp() { return; }
int n;
vector<pair<int, int> > v[200005];
int l[200005], r[200005], ans[200005];
priority_queue<pair<int, int> > pq;
vector<pair<int, int> > swp;
int solve() {
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
l[i] = a, r[i] = b;
v[a].push_back({b, i});
}
for (int i = 1; i <= n; i++) {
for (pair<int, int> j : v[i]) pq.push({-j.first, j.second});
int nw = pq.top().second;
pq.pop();
ans[nw] = i;
if (!pq.empty()) swp.push_back({nw, pq.top().second});
}
for (pair<int, int> i : swp) {
swap(ans[i.first], ans[i.second]);
if (l[i.first] <= ans[i.first] && ans[i.first] <= r[i.first] &&
l[i.second] <= ans[i.second] && ans[i.second] <= r[i.second]) {
cout << "NO\n";
for (int j = 0; j < n; j++) cout << ans[j] << " ";
cout << endl;
swap(ans[i.first], ans[i.second]);
for (int j = 0; j < n; j++) cout << ans[j] << " ";
cout << endl;
return 0;
}
swap(ans[i.first], ans[i.second]);
}
cout << "YES\n";
for (int i = 0; i < n; i++) cout << ans[i] << " ";
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long n;
vector<vector<pair<long long, long long> > > g(N);
pair<long long, long long> f[N];
long long match[N], match2[N];
long long vis[N], nxt[N];
set<long long> active;
vector<long long> genPerfect() {
vector<long long> ret(n);
priority_queue<pair<long long, long long>,
vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
pq;
for (long long i = (long long)1; i <= (long long)n; i++) {
for (auto it : g[i]) pq.push(it);
while (!pq.empty() && pq.top().first < i) pq.pop();
ret[pq.top().second - 1] = i;
pq.pop();
}
return ret;
}
void foundCycle(long long root) {
cout << "NO" << '\n';
vector<long long> ans1(n + 1), ans2(n + 1);
for (long long i = (long long)1; i <= (long long)n; i++) ans1[i] = match[i];
long long u = root;
while (true) {
match[u] = ans1[nxt[u]];
u = nxt[u];
if (u == root) break;
}
for (long long i = (long long)1; i <= (long long)n; i++) ans2[i] = match[i];
for (long long i = (long long)1; i <= (long long)n; i++)
cout << ans1[i] << ' ';
cout << '\n';
for (long long i = (long long)1; i <= (long long)n; i++)
cout << ans2[i] << ' ';
cout << '\n';
exit(0);
}
void dfs(long long u) {
vector<long long> done;
vis[u] = 1;
while (true) {
auto it = active.lower_bound(f[u].first);
if (it != active.end() && *it == match[u]) {
done.push_back(*it);
it++;
}
if (it == active.end() || *it > f[u].second) break;
long long v = *it;
done.push_back(v);
assert(vis[match2[v]] != 2);
nxt[u] = match2[v];
if (vis[match2[v]] == 1) {
foundCycle(match2[v]);
exit(0);
}
dfs(match2[v]);
}
vis[u] = 2;
for (auto it : done)
if (active.find(it) != active.end()) active.erase(it);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (long long i = (long long)1; i <= (long long)n; i++) {
long long l, r;
cin >> l >> r;
g[l].push_back({r, i});
f[i] = {l, r};
}
auto rec1 = genPerfect();
for (long long i = (long long)0; i <= (long long)n - 1; i++) {
match[i + 1] = rec1[i];
match2[rec1[i]] = i + 1;
}
for (long long i = (long long)1; i <= (long long)n; i++) active.insert(i);
for (long long i = (long long)1; i <= (long long)n; i++) {
if (vis[i] == 0) dfs(i);
}
cout << "YES" << '\n';
for (auto it : rec1) cout << it << ' ';
cout << '\n';
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class T>
inline void amin(T &x, const T &y) {
if (y < x) x = y;
}
template <class T>
inline void amax(T &x, const T &y) {
if (x < y) x = y;
}
template <class Iter>
void rprintf(const char *fmt, Iter begin, Iter end) {
for (bool sp = 0; begin != end; ++begin) {
if (sp)
putchar(' ');
else
sp = true;
printf(fmt, *begin);
}
putchar('\n');
}
int N;
int A[200011];
int B[200011];
int ans[200011];
vector<int> H[200011];
pair<int, int> pa[200011];
void MAIN() {
scanf("%d", &N);
for (int i = 0, i_len = (N); i < i_len; ++i)
scanf("%d%d", A + i, B + i), A[i]--;
for (int i = 0, i_len = (N); i < i_len; ++i) H[A[i]].push_back(i);
priority_queue<pair<int, int> > Q;
for (int i = 0, i_len = (N); i < i_len; ++i) {
for (__typeof((H[i]).begin()) e = (H[i]).begin(), e_end = (H[i]).end();
e != e_end; ++e)
Q.emplace(-B[*e], *e);
assert(Q.size());
assert(i < -Q.top().first);
auto a = Q.top();
Q.pop();
ans[a.second] = i;
}
int x = -1, y = -1;
for (int i = 0, i_len = (N); i < i_len; ++i) {
for (__typeof((H[i]).begin()) e = (H[i]).begin(), e_end = (H[i]).end();
e != e_end; ++e)
Q.emplace(-B[*e], *e);
auto a = Q.top();
Q.pop();
if (Q.size()) {
auto b = Q.top();
if (A[b.second] <= i && i < B[b.second] && A[a.second] <= ans[b.second] &&
ans[b.second] < B[a.second]) {
x = a.second;
y = b.second;
break;
}
}
}
for (int i = 0, i_len = (N); i < i_len; ++i) ans[i]++;
if (x == -1) {
puts("YES");
rprintf("%d", ans, ans + N);
} else {
puts("NO");
rprintf("%d", ans, ans + N);
swap(ans[x], ans[y]);
rprintf("%d", ans, ans + N);
}
}
int main() {
int TC = 1;
for (int tc = 0, tc_len = (TC); tc < tc_len; ++tc) MAIN();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
template <typename first, typename second>
ostream& operator<<(ostream& os, const pair<first, second>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream& operator<<(ostream& os, const vector<T>& v) {
os << "{";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream& operator<<(ostream& os, const set<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ",";
os << *it;
}
return os << "]";
}
template <typename T>
ostream& operator<<(ostream& os, const multiset<T>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename first, typename second>
ostream& operator<<(ostream& os, const map<first, second>& v) {
os << "[";
for (auto it = v.begin(); it != v.end(); ++it) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
void faltu() { cerr << '\n'; }
template <typename T>
void faltu(T a[], int n) {
for (int i = 0; i < n; ++i) cerr << a[i] << ' ';
cerr << '\n';
}
template <typename T, typename... hello>
void faltu(T arg, const hello&... rest) {
cerr << arg << ' ';
faltu(rest...);
}
const int mx = 2e5 + 5;
int n;
int a[mx], b[mx];
int arr[mx], rev[mx];
pair<int, int> tree[mx * 4];
int rev2[mx];
void init(int node, int l, int r) {
if (l == r) {
tree[node] = make_pair(a[arr[l]], l);
return;
}
int mid = (l + r) / 2;
init(2 * node, l, mid);
init(2 * node + 1, mid + 1, r);
tree[node] = min(tree[2 * node], tree[2 * node + 1]);
}
pair<int, int> query(int node, int l, int r, int b, int e) {
if (l > e || r < b) return make_pair(inf, 0);
if (l >= b && r <= e) return tree[node];
int mid = (l + r) / 2;
return min(query(2 * node, l, mid, b, e),
query(2 * node + 1, mid + 1, r, b, e));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n;
for (int i = 1; i <= n; ++i) cin >> a[i] >> b[i];
vector<pair<pair<int, int>, int> > vec;
for (int i = 1; i <= n; ++i)
vec.push_back(make_pair(make_pair(a[i], b[i]), i));
sort(vec.begin(), vec.end());
multiset<pair<pair<int, int>, int> > mst;
for (int i = 0, j = 1; j <= n; ++j) {
while (i < (int)vec.size() && vec[i].first.first <= j) {
mst.insert(make_pair(make_pair(vec[i].first.second, vec[i].first.first),
vec[i].second));
++i;
}
auto x = *mst.begin();
mst.erase(x);
swap(x.first.first, x.first.second);
int le = j;
arr[le] = x.second;
rev[x.second] = le;
}
for (int i = 1; i <= n; ++i) rev2[i] = rev[i];
init(1, 1, n);
bool ok = 0;
for (int i = 1; i <= n; ++i) {
pair<int, int> temp = query(1, 1, n, i + 1, b[arr[i]]);
if (temp.first <= i) {
ok = 1;
swap(rev2[arr[i]], rev2[arr[temp.second]]);
break;
}
}
if (!ok) {
cout << "YES" << '\n';
for (int i = 1; i <= n; ++i) cout << rev[i] << " ";
cout << '\n';
} else {
cout << "NO" << '\n';
for (int i = 1; i <= n; ++i) cout << rev[i] << " ";
cout << '\n';
for (int i = 1; i <= n; ++i) cout << rev2[i] << " ";
cout << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 200000;
int n;
int a[mxn], b[mxn], first[mxn], ff[mxn];
vector<int> v[mxn];
auto cmp = [](int x, int y) { return b[x] > b[y]; };
priority_queue<int, vector<int>, decltype(cmp)> pq(cmp);
map<int, int> second;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
a[i]--, b[i]--;
v[a[i]].push_back(i);
}
int p = -1, q = -1;
for (int i = 0; i < n; i++) {
for (int j : v[i]) pq.push(j);
int x = pq.top();
pq.pop();
first[i] = x, ff[x] = i + 1;
if (!~p) {
auto it = second.lower_bound(i);
if (it != second.end() && it->second >= a[x]) {
p = first[it->second], q = x;
} else {
it = second.insert({b[x], i}).first;
if (it->second <= i) {
it->second = i;
if (next(it) != second.end() && i <= next(it)->second)
it = second.erase(it);
while (it != second.begin() && (--it)->second <= i)
it = second.erase(it);
}
}
}
}
cout << (!~p ? "YES" : "NO") << '\n';
for (int i = 0; i < 1 + !!~p; i++) {
cout << ff[0];
for (int i = 1; i < n; i++) cout << " " << ff[i];
cout << '\n';
if (~p) swap(ff[p], ff[q]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f, N = 2e5 + 7;
int l[N], r[N];
int bit[N];
void add(int pos, int val) {
for (; pos < N; pos += pos & -pos) bit[pos] = min(bit[pos], val);
}
int qry(int pos) {
int mn = INF;
for (; pos; pos -= pos & -pos) mn = min(mn, bit[pos]);
return mn;
}
signed main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
;
int n;
cin >> n;
vector<array<int, 3>> v;
for (int i = 0; i < n; i++) {
cin >> l[i] >> r[i];
v.push_back({l[i], r[i], i});
}
sort((v).begin(), (v).end());
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
pq;
vector<int> p;
for (int i = 1, j = 0; i <= n; i++) {
while (j < v.size() && v[j][0] <= i) {
pq.push({v[j][1], v[j][2]});
j++;
}
assert(pq.size());
pair<int, int> pp = pq.top();
pq.pop();
p.push_back(pp.second);
}
auto print = [&]() {
vector<int> ans(n);
for (int i = 0; i < n; i++) ans[p[i]] = i + 1;
for (int i : ans) cout << i << " ";
cout << endl;
};
memset(bit, 0x3f, sizeof bit);
for (int i = n - 1; i >= 0; i--) {
int qq = qry(i + 1);
if (qq <= r[p[i]]) {
cout << "NO" << endl;
print();
swap(p[i], p[qq - 1]);
print();
return 0;
}
add(l[p[i]], i + 1);
}
cout << "YES" << endl;
print();
}
|
#include <bits/stdc++.h>
using ll = long long;
const int MN = 2e5 + 100;
int N;
struct endpt {
public:
int i, r;
bool operator<(endpt o) const { return r < o.r || !(o.r < r) && i < o.i; }
};
std::vector<endpt> a[MN];
int ib[MN], b[MN], s1 = -1, s2;
const int MS = 1 << 19;
ll v[MS];
void upd(int n, int l, int r, int x, ll k) {
if (r - l > 1) {
int m = l + (r - l) / 2;
if (x < m)
upd(n << 1, l, m, x, k);
else
upd(n << 1 | 1, m, r, x, k);
v[n] = std::max(v[n << 1], v[n << 1 | 1]);
} else
v[n] = k;
}
ll qry(int n, int l, int r, int ql, int qr) {
if (ql <= l && r <= qr)
return v[n];
else {
int m = l + (r - l) / 2;
ll f = -1;
if (ql < m) f = std::max(f, qry(n << 1, l, m, ql, qr));
if (m < qr) f = std::max(f, qry(n << 1 | 1, m, r, ql, qr));
return f;
}
}
std::set<endpt> active;
int main(void) {
scanf("%d", &N);
for (int i = 0, x, y; i < N; ++i) {
scanf("%d%d", &x, &y);
a[x].push_back({i, ++y});
}
for (int i = 1; i <= N; ++i) {
for (auto x : a[i]) active.insert(x);
auto it = active.begin();
auto y = *it;
active.erase(it);
b[y.i] = i;
ib[i] = y.i;
}
memset(v, 0xff, sizeof(v));
for (int i = 1; i <= N; ++i)
for (auto x : a[i]) {
ll z = qry(1, 1, N + 1, i, x.r), k = b[x.i];
if (z >> 32 > k) {
s1 = x.i, s2 = (int)(z & 0xffffffff);
goto done;
}
upd(1, 1, N + 1, k, (ll)x.r << 32 | x.i);
}
done:
if (!~s1) {
printf("YES\n");
for (int i = 0; i < N; ++i) printf("%d%c", b[i], " \n"[i + 1 == N]);
} else {
printf("NO\n");
for (int i = 0; i < N; ++i) printf("%d%c", b[i], " \n"[i + 1 == N]);
std::swap(b[s1], b[s2]);
for (int i = 0; i < N; ++i) printf("%d%c", b[i], " \n"[i + 1 == N]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > str[200005];
int a[200005];
int b[200005];
int ans[200005];
int p[200005];
pair<int, int> seg[400005];
int inf = 1e9;
void out() {
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
cout << "\n";
}
pair<int, int> q(int l, int r) {
l--;
pair<int, int> res{inf, inf};
for (l += n, r += n; l < r; l /= 2, r /= 2) {
if (l % 2 == 1) res = min(res, seg[l++]);
if (r % 2 == 1) res = min(res, seg[--r]);
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i];
str[a[i]].push_back({b[i], i});
}
set<pair<int, int> > ac;
for (int i = 1; i <= n; i++) {
ac.insert(str[i].begin(), str[i].end());
ans[ac.begin()->second] = i;
p[i] = ac.begin()->second;
ac.erase(ac.begin());
}
for (int i = 0; i < n; i++) {
seg[i + n] = {a[p[i + 1]], i + 1};
}
for (int i = n - 1; i > 0; i--) {
seg[i] = min(seg[2 * i], seg[2 * i + 1]);
}
for (int i = 1; i <= n; i++) {
pair<int, int> j = q(i + 1, b[p[i]]);
if (j.first == inf) continue;
if (j.first <= i) {
cout << "NO\n";
out();
swap(ans[p[i]], ans[p[j.second]]);
out();
return 0;
}
}
cout << "YES\n";
out();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long INF = 1e17;
const int INFi = 2e7;
const int Y = 200100;
const long long m = 1000000007;
template <typename T>
inline T getint() {
T val = 0;
char c;
bool neg = false;
while ((c = getchar()) && !(c >= '0' && c <= '9')) {
neg |= c == '-';
}
do {
val = (val * 10) + c - '0';
} while ((c = getchar()) && (c >= '0' && c <= '9'));
return val * (neg ? -1 : 1);
}
struct Cyst {
int l;
int r;
Cyst(long long L = 0, long long R = 0) {
l = L;
r = R;
}
};
vector<pair<int, int>> End[Y];
vector<int> BG[Y];
bool vis[Y];
int ID[Y];
int ans1[Y];
int ans2[Y];
int main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
int n;
cin >> n;
bool aa = true;
for (int i = 1; i <= n; ++i) {
int l, r;
cin >> l >> r;
End[l].push_back({r, i});
}
set<pair<int, int>> sp;
for (int i = 1; i <= n; ++i) {
for (auto x : End[i]) {
sp.insert(x);
}
pair<int, int> T = *sp.begin();
sp.erase(sp.begin());
ans1[T.second] = i;
ID[i] = T.second;
}
int id1 = -1, id2 = -1;
for (int i = 1; i <= n; ++i) {
ans2[i] = ans1[i];
for (auto x : End[i]) {
sp.insert(x);
}
pair<int, int> T = *sp.begin();
sp.erase(sp.begin());
if (aa && !sp.empty()) {
pair<int, int> T1 = *sp.begin();
if (ans1[T1.second] <= T.first) {
aa = false;
id1 = T1.second;
id2 = T.second;
}
}
}
if (aa) {
cout << "YES\n";
for (int i = 1; i <= n; ++i) {
cout << ans1[i] << " ";
}
} else {
swap(ans2[id1], ans2[id2]);
cout << "NO\n";
for (int i = 1; i <= n; ++i) cout << ans1[i] << " ";
cout << endl;
for (int i = 1; i <= n; ++i) cout << ans2[i] << " ";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N;
pair<int, int> A[200005];
int Res[200005], Place[200005], Tree[800005];
set<pair<int, int> > X;
vector<int> V[200005];
void Read() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d%d", &A[i].first, &A[i].second);
V[A[i].first].push_back(i);
}
}
void findPerfectMatching() {
for (int i = 1; i <= N; i++) {
for (int j = 0; j < V[i].size(); j++) {
int friendIndex = V[i][j];
X.insert(make_pair(A[friendIndex].second, friendIndex));
}
int index = X.begin()->second;
Res[index] = i;
Place[i] = index;
X.erase(X.begin());
}
}
void buildTree(int K, int L, int R) {
if (L == R) {
Tree[K] = A[Place[L]].first;
return;
}
buildTree(K * 2, L, (L + R) / 2);
buildTree(K * 2 + 1, (L + R) / 2 + 1, R);
Tree[K] = min(Tree[K * 2], Tree[K * 2 + 1]);
}
int Query(int K, int L, int R, int x, int y) {
if (L > R || L > y || R < x) return N + 5;
if (L >= x && R <= y) {
return Tree[K];
}
return min(Query(K * 2, L, (L + R) / 2, x, y),
Query(K * 2 + 1, (L + R) / 2 + 1, R, x, y));
}
void print2Solutions(int left) {
int right;
for (int i = left + 1; i <= A[Place[left]].second; i++) {
if (A[Place[i]].first <= left) {
right = i;
break;
}
}
printf("NO\n");
for (int i = 1; i <= N; i++) printf("%d ", Res[i]);
printf("\n");
swap(Res[Place[left]], Res[Place[right]]);
for (int i = 1; i <= N; i++) printf("%d ", Res[i]);
printf("\n");
}
void print1Solution() {
printf("YES\n");
for (int i = 1; i <= N; i++) printf("%d ", Res[i]);
printf("\n");
}
void Solve() {
for (int i = 1; i <= N; i++) {
int last = A[Place[i]].second;
int minLeftHead = Query(1, 1, N, i + 1, last);
if (minLeftHead > i) continue;
print2Solutions(i);
return;
}
print1Solution();
}
int main() {
Read();
findPerfectMatching();
buildTree(1, 1, N);
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[200005], b[200005];
int ret[200005];
vector<int> getRet(int n) {
set<pair<int, int> > s;
priority_queue<pair<int, pair<int, int> >,
vector<pair<int, pair<int, int> > >,
greater<pair<int, pair<int, int> > > >
pq;
set<int> rem;
for (int i = 0; i < n; ++i) {
pq.push(make_pair(b[i], make_pair(a[i], i)));
s.insert(make_pair(a[i], i));
rem.insert(i + 1);
}
while (!pq.empty()) {
pair<int, int> tmp = pq.top().second;
pq.pop();
s.erase(tmp);
int ind = *rem.lower_bound(tmp.first);
ret[tmp.second] = ind;
rem.erase(ind);
}
vector<int> out;
for (int i = 0; i < n; ++i) {
out.push_back(ret[i]);
}
return out;
}
int mapping[200005];
pair<int, int> seg[200005 * 4];
void init(int pos, int l, int r) {
if (l == r) {
seg[pos] = {a[mapping[l]], mapping[l]};
return;
}
int mid = (l + r) / 2;
init(pos * 2, l, mid);
init(pos * 2 + 1, mid + 1, r);
seg[pos] = min(seg[pos * 2], seg[pos * 2 + 1]);
}
pair<int, int> query(int pos, int l, int r, int ql, int qr) {
if (r < ql || qr < l) {
return {1e9, -1};
}
if (ql <= l && r <= qr) {
return seg[pos];
}
int mid = (l + r) / 2;
return min(query(pos * 2, l, mid, ql, qr),
query(pos * 2 + 1, mid + 1, r, ql, qr));
}
void solve() {
int n;
scanf("%d ", &n);
for (int i = 0; i < n; ++i) {
scanf("%d %d ", &a[i], &b[i]);
}
vector<int> rr = getRet(n);
for (int i = 0; i < n; ++i) {
mapping[rr[i]] = i;
}
init(1, 1, n);
vector<int> vv;
for (int i = 1; i <= n; ++i) {
int mr = b[mapping[i]];
if (i + 1 <= mr) {
pair<int, int> q = query(1, 1, n, i + 1, mr);
if (q.first <= i) {
vv = rr;
swap(vv[q.second], vv[mapping[i]]);
break;
}
}
}
if (vv.size() == 0) {
printf("YES\n");
for (int x : rr) {
printf("%d ", x);
}
} else {
printf("NO\n");
for (int x : rr) {
printf("%d ", x);
}
putchar('\n');
for (int x : vv) {
printf("%d ", x);
}
}
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
const int MOD = 1000000007;
const int inf = (1 << 30) - 1;
const ll INF = (1LL << 60) - 1;
template <typename T>
bool chmax(T &x, const T &y) {
return (x < y) ? (x = y, true) : false;
};
template <typename T>
bool chmin(T &x, const T &y) {
return (x > y) ? (x = y, true) : false;
};
struct io_setup {
io_setup() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed << setprecision(15);
}
} io_setup;
template <typename Monoid>
struct Segment_Tree {
using F = function<Monoid(Monoid, Monoid)>;
int n;
vector<Monoid> seg;
const F f;
const Monoid e1;
Segment_Tree(const vector<Monoid> &v, const F &f, const Monoid &e1)
: f(f), e1(e1) {
int m = (int)v.size();
n = 1;
while (n < m) n <<= 1;
seg.assign(2 * n, e1);
copy(v.begin(), v.end(), seg.begin() + n);
for (int i = n - 1; i > 0; i--) seg[i] = f(seg[2 * i], seg[2 * i + 1]);
}
void change(int i, const Monoid &x) {
seg[i += n] = x;
while (i >>= 1) {
seg[i] = f(seg[2 * i], seg[2 * i + 1]);
}
}
Monoid query(int l, int r) const {
Monoid L = e1, R = e1;
l += n, r += n;
while (l < r) {
if (l & 1) L = f(L, seg[l++]);
if (r & 1) R = f(seg[--r], R);
l >>= 1, r >>= 1;
}
return f(L, R);
}
Monoid operator[](int i) const { return seg[n + i]; }
template <typename C>
int find_subtree(int i, const C &check, const Monoid &x, Monoid &M,
bool type) const {
while (i < n) {
Monoid nxt = type ? f(seg[2 * i + type], M) : f(M, seg[2 * i + type]);
if (check(nxt, x))
i = 2 * i + type;
else
M = nxt, i = 2 * i + (type ^ 1);
}
return i - n;
}
template <typename C>
int find_first(int l, const C &check, const Monoid &x) const {
Monoid L = e1;
int a = l + n, b = n + n;
while (a < b) {
if (a & 1) {
Monoid nxt = f(L, seg[a]);
if (check(nxt, x)) return find_subtree(a, check, x, L, false);
L = nxt, a++;
}
a >>= 1, b >>= 1;
}
return n;
}
template <typename C>
int find_last(int r, const C &check, const Monoid &x) const {
Monoid R = e1;
int a = n, b = r + n;
while (a < b) {
if (b & 1 || a == 1) {
Monoid nxt = f(seg[--b], R);
if (check(nxt, x)) return find_subtree(b, check, x, R, true);
R = nxt;
}
a >>= 1, b >>= 1;
}
return -1;
}
};
int main() {
int N;
cin >> N;
vector<int> a(N), b(N);
vector<vector<int>> ids(N);
for (int i = 0; i < N; i++) {
cin >> a[i] >> b[i];
a[i]--, b[i]--;
ids[a[i]].emplace_back(i);
}
vector<int> ans(N), p(N);
priority_queue<pii, vector<pii>, greater<pii>> que;
for (int i = 0; i < N; i++) {
for (auto &e : ids[i]) {
que.emplace(b[e], e);
}
ans[que.top().second] = i;
que.pop();
}
for (int i = 0; i < N; i++) p[ans[i]] = i;
auto f = [](int a, int b) { return min(a, b); };
vector<int> v(N);
for (int i = 0; i < N; i++) v[i] = a[p[i]];
Segment_Tree<int> seg(v, f, inf);
for (int i = 0; i < N; i++) {
int L = i + 1, R = b[p[i]] + 1;
if (seg.query(L, R) <= i) {
for (int j = L; j <= R - 1; j++) {
if (a[p[j]] <= i) {
cout << "NO\n";
for (auto &e : ans) cout << e + 1 << ' ';
cout << '\n';
swap(ans[p[i]], ans[p[j]]);
for (auto &e : ans) cout << e + 1 << ' ';
cout << '\n';
return 0;
}
}
}
}
cout << "YES\n";
for (auto &e : ans) cout << e + 1 << ' ';
cout << '\n';
}
|
#include <bits/stdc++.h>
const long long mod = 1000000007;
using namespace std;
vector<long long> child0, child1, claw;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<long long> a(n);
long long max = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (a[i] > max) max = a[i];
}
child0.resize(max + 1);
child1.resize(max + 1);
claw.resize(max + 1);
child0[0] = 1;
child0[1] = 1;
child0[2] = 3;
child1[0] = 0;
child1[1] = 1;
child1[2] = 1;
claw[0] = 0;
claw[1] = 0;
claw[2] = 1;
for (int i = 3; i < max; i++) {
claw[i] = (child1[i - 1] + claw[i - 3]) % mod;
child0[i] = (child0[i - 1] + 2 * child1[i - 1]) % mod;
child1[i] = (child0[i - 1]) % mod;
}
for (int i = 0; i < n; i++) {
cout << (4 * claw[a[i] - 1]) % mod << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.1415926536;
int days[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
template <typename T>
ostream& operator<<(ostream& out, const vector<T>& mas) {
for (const auto& x : mas) {
out << x << ' ';
}
return out;
}
void ok() { cout << "YES" << '\n'; }
void no() { cout << "NO" << '\n'; }
inline long long nxt() {
long long x;
cin >> x;
return x;
}
template <int mod>
struct Modular {
int val;
Modular(long long _val = 0) {
if (_val < 0 || _val >= mod) {
val = _val % mod;
if (val < 0) {
val += mod;
}
} else {
val = _val;
}
}
Modular operator+(const Modular& ot) const {
int res = val + ot.val;
if (res >= mod) {
res -= mod;
}
return {res};
}
Modular operator-(const Modular& ot) const {
int res = val - ot.val;
if (res < 0) {
res += mod;
}
return {res};
}
Modular operator*(const Modular& ot) const { return {1ll * val * ot.val}; }
Modular& operator++() {
val += 1;
if (val == mod) {
val = 0;
}
return *this;
}
Modular operator++(int) {
Modular tmp(*this);
operator++();
return tmp;
}
void operator+=(const Modular& ot) {
val += ot.val;
if (val >= mod) {
val -= mod;
}
}
void operator-=(const Modular& ot) {
val -= ot.val;
if (val < 0) {
val += mod;
}
}
void operator*=(const Modular& ot) { val = 1ll * val * ot.val % mod; }
bool operator==(const Modular& ot) const { return val == ot.val; }
bool operator!=(const Modular& ot) const { return val != ot.val; }
};
template <int mod>
ostream& operator<<(ostream& ostr, const Modular<mod>& x) {
return ostr << x.val;
}
const int mod = 1000000007;
using Mint = Modular<mod>;
const int N = 2e6 + 10;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr), cout.tie(nullptr);
int t = nxt();
vector<Mint> dp(N);
Mint huita = 0;
dp[0] = 1;
for (int i = 1; i < N; i++) {
Mint tmp_huita = huita;
huita = dp[i - 1] * 2;
dp[i] = dp[i - 1] + tmp_huita;
}
vector<Mint> ans(N);
for (int i = 0; i < N; i++) {
if (i < 3) {
ans[i] = dp[i];
} else {
ans[i] = dp[i] + ans[i - 3];
}
}
while (t--) {
int n = nxt();
if (n <= 2) {
cout << 0 << '\n';
continue;
}
n -= 2;
cout << ans[n - 1] * 4 << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 10, mod = 1e9 + 7;
int t, n, k;
long long dp[maxn];
int main() {
dp[1] = dp[2];
dp[3] = 4;
dp[4] = 4, dp[5] = 12;
for (int i = 6; i < maxn; ++i) {
if (i % 3 == 0)
dp[i] = (dp[i - 1] + 2 * dp[i - 2] + 4) % mod;
else
dp[i] = (dp[i - 1] + 2 * dp[i - 2]) % mod;
}
cin >> t;
while (t--) {
cin >> n;
cout << dp[n] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2000006][3], p3[2000006], T, n;
signed main() {
dp[1][0] = 0;
dp[1][1] = 1;
dp[2][0] = 1;
dp[2][1] = 1;
p3[0] = 1;
for (long long i = 1; i <= 2000005; i++)
(p3[i] = p3[i - 1] * 3) %= 1000000007;
for (long long i = 3; i <= 2000005; i++) {
(dp[i][1] += dp[i - 1][0]) %= 1000000007;
(dp[i][1] += 2 * dp[i - 2][0]) %= 1000000007;
(dp[i][1] += 1) %= 1000000007;
(dp[i][0] += max(dp[i - 1][0], dp[i - 1][1])) %= 1000000007;
(dp[i][0] += max(dp[i - 2][0], dp[i - 2][1]) * 2) %= 1000000007;
}
cin >> T;
while (T--) {
cin >> n;
if (n <= 2)
cout << 0 << endl;
else if (n == 3)
cout << 4 << endl;
else
cout << (max(dp[n - 2][0], dp[n - 2][1])) * 4 % 1000000007 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
const int mod = 1e9 + 7;
int _;
int dp[N];
void init() {
dp[1] = dp[2] = 0;
dp[3] = dp[4] = 1;
for (int i = 5; i < N; ++i)
dp[i] = (2LL * dp[i - 2] + dp[i - 1] + (i % 3 == 0)) % mod;
}
void solve() {
int n;
cin >> n;
cout << 4LL * dp[n] % mod << endl;
}
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
init();
for (cin >> _; _--;) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int32_t INFint = 1e9;
const long long INFll = 1e18;
const long long INF = 9e18;
const long double PI = acos(-1);
long long powersOfTwo[31] = {
1, 2, 4, 8, 16, 32, 64,
128, 256, 512, 1024, 2048, 4096, 8192,
16384, 32768, 65536, 131072, 262144, 524288, 1048576,
2097152, 4194304, 8388608, 16777216, 33554432, 67108864, 134217728,
268435456, 536870912, 1073741824};
long long power(long long x, long long y) {
long long r = 1;
while (y > 0) {
if (y & 1) r = r * x;
y = y >> 1;
x = x * x;
}
return r;
}
long long powerMod(long long x, long long y, long long p) {
long long res = 1;
x %= p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long gcd(long long a, long long b) {
if (!b) return a;
return gcd(b, a % b);
}
long long lcm(long long a, long long b) { return (a * b) / gcd(a, b); }
vector<vector<long long> > dp(2000005, vector<long long>(2));
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
for (long long i = 3; i < 2000005; i++) {
dp[i][1] = 4 + dp[i - 1][0] + dp[i - 2][0] + dp[i - 2][0];
dp[i][0] = max({dp[i - 1][1] + dp[i - 2][1] + dp[i - 2][1],
dp[i - 1][1] + dp[i - 2][0] + dp[i - 2][0],
dp[i - 1][0] + dp[i - 2][1] + dp[i - 2][1]});
dp[i][1] %= 1000000007;
dp[i][0] %= 1000000007;
}
long long tt = 1;
cin >> tt;
while (tt--) {
long long n;
cin >> n;
cout << max(dp[n][0], dp[n][1]) << '\n';
}
cerr << "Time : " << 1000 * (long double)clock() / (long double)CLOCKS_PER_SEC
<< "ms\n";
;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 7;
const long long nmax = (long long)2e6 + 10;
long long cnt[nmax];
long long sum[nmax];
long long pre[nmax];
void solve() {
cnt[0] = 0;
cnt[1] = 1;
cnt[2] = 1;
sum[0] = 0;
sum[1] = 0;
sum[2] = 0;
pre[0] = 0;
pre[1] = 4;
pre[2] = 4;
for (long long i = 3; i < nmax - 9; i++) {
cnt[i] = (cnt[i - 1] + (cnt[i - 2] * 2) % mod) % mod;
pre[i] = (pre[i - 3] + (cnt[i] * 4) % mod) % mod;
sum[i] = pre[i - 2];
}
}
signed main() {
ios_base ::sync_with_stdio(false);
cin.tie(0);
solve();
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << sum[n] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e6 + 2;
const int MOD = 1e9 + 7;
long long int dp[MAXN];
void init() {
dp[1] = dp[2] = 0;
dp[3] = dp[4] = 4;
dp[5] = 12;
dp[6] = 24;
dp[7] = 48;
for (int i = 8; i <= 2e6; ++i) {
if (i % 3 == 0) {
dp[i] = ((dp[i - 1] + dp[i - 2] * 2 + 4) % MOD + MOD) % MOD;
} else if (i % 3 == 1) {
dp[i] = (dp[i - 1] + dp[i - 2] * 2) % MOD;
} else {
dp[i] = (dp[i - 1] + dp[i - 2] * 2) % MOD;
}
}
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
init();
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << dp[n] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2000005];
void solve() {
long long n;
cin >> n;
cout << dp[n] << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long t;
cin >> t;
dp[1] = 0;
dp[2] = 0;
dp[3] = 4;
dp[4] = 4;
dp[5] = 12;
dp[6] = 24;
for (long long i = 7; i <= 2000002; i++) {
dp[i] = (dp[i - 1] + 2 * (dp[i - 2]) + (i % 3 == 0) * 4) % 1000000007;
}
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 2e6 + 100;
const int N = 1e5 + 100;
const int INF = 0x3f3f3f3f;
const int mod = 1e9 + 7;
int n, m, t, k;
vector<int> ans(M);
int main() {
int T = 1;
scanf("%d", &T);
for (int i = 3; i < M; i++)
ans[i] = (long long)(ans[i - 1] % mod + ans[i - 2] * 2 % mod +
4 * (i % 3 == 0)) %
mod;
while (T--) {
scanf("%d", &n);
printf("%d\n", ans[n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 10;
int mod = 1e9 + 7;
long long dp[3000000];
int main() {
int t, n;
cin >> t;
dp[1] = 0;
dp[2] = 0;
for (int i = 3; i < maxn; ++i)
dp[i] = (dp[i - 1] + dp[i - 2] * 2 + (!(i % 3) ? 4 : 0)) % mod;
while (t--) {
scanf("%d", &n);
printf("%lld\n", dp[n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 2000005, p = 1e9 + 7;
int T, n;
long long f[Maxn][2];
int main() {
for (int i = 3; i <= 2000000; i++) {
f[i][0] = f[i][1] = (f[i - 1][1] + 2 * f[i - 2][1]) % p;
if ((i % 3) != 2) f[i][1] = (f[i - 1][0] + 2 * f[i - 2][0] + 1) % p;
}
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
printf("%lld\n", max(f[n][0], f[n][1]) * 4 % p);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long ans[2000005];
int main() {
ans[1] = ans[2] = 0;
ans[3] = ans[4] = 4;
for (int i = 5; i <= 2000000; i++)
ans[i] = (2 * ans[i - 2] + ans[i - 1] + (i % 3 == 0) * 4) % 1000000007;
int T;
cin >> T;
while (T--) {
int n;
scanf("%d", &n);
printf("%lld\n", ans[n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2 * 1000000 + 1];
int32_t main() {
dp[1] = 0;
dp[2] = 0;
for (long long i = 3; i <= 2 * 1000000; i++) {
if (i % 3 == 0)
dp[i] = (dp[i - 1] + 2 * dp[i - 2] + 1) % 1000000007;
else
dp[i] = (dp[i - 1] + 2 * dp[i - 2]) % 1000000007;
}
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << (dp[n] * 4) % 1000000007 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<long long>;
using vpi = vector<pair<long long, long long>>;
using pi = pair<long long, long long>;
const long long nax = 2e6 + 7;
const long long mod = 1e9 + 7;
const long long inf = numeric_limits<long long>::max() - (long long)9e6;
long long n;
long long dp[nax];
void test() {
dp[3] = dp[4] = 4;
dp[5] = 12;
for (long long i = 6; i < nax; i++) {
dp[i] = (2 * dp[i - 2]) + dp[i - 1] + (i % 3 == 0) * 4;
dp[i] %= mod;
}
long long T;
cin >> T;
while (T--) {
cin >> n;
cout << dp[n] << '\n';
}
}
signed main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
long long T = 1;
while (T--) {
test();
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power_mod(long long int a, long long int x) {
if (x == 0) return 1;
long long int y = power_mod(a, x / 2);
long long int ans = (y * y) % 1000000007;
if (x % 2) ans = (ans * a) % 1000000007;
return ans;
}
long long int inv(long long int a) { return power_mod(a, 1000000007 - 2); }
long long int power(long long int a, long long int x) {
if (x == 0) return 1;
long long int y = power(a, x / 2);
long long int ans = (y * y);
if (x % 2) ans *= a;
return ans;
}
long long int f[2000001][3] = {};
long long int dp[2000001] = {};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
memset(f, 0, sizeof(f));
memset(dp, 0, sizeof(dp));
f[1][0] = 1;
for (long long int i = 2; i < 2000001; i++) {
f[i][0] = (f[i - 1][0] + (2ll * f[i - 1][1]) % 1000000007) % 1000000007;
f[i][1] = (f[i - 1][0]);
f[i][2] = (f[i - 1][2] + f[i - 1][1]) % 1000000007;
}
for (long long int i = 3; i < 2000001; i++) {
dp[i] = (dp[i - 3] + (f[i][2] - f[i - 1][2] + 1000000007) % 1000000007) %
1000000007;
}
while (t--) {
long long int n;
cin >> n;
cout << (4ll * dp[n]) % 1000000007 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long inf = 1e9 + 7;
long long modexp(long long base, long long power) {
if (power == 0) return 1;
if (power & 1) return base * modexp(base, power - 1) % inf;
return modexp(base * base % inf, power / 2);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long N = 2e6;
vector<long long> claws(N + 1, 0), r(N + 1, 0);
claws[1] = 0;
r[1] = 1;
claws[2] = 0;
r[2] = 1;
for (long long i = 3; i <= N; i++) {
long long x = r[i - 2] & r[i - 1];
claws[i] =
((2 * claws[i - 2]) % inf + (claws[i - 1] % inf) + x % inf) % inf;
r[i] = !x;
}
long long t = 1;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long ans = (claws[n] % inf * 4 % inf) % inf;
cout << ans % inf << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace mine {
long long qread() {
long long ans = 0, f = 1;
char c = getchar();
while (c < '0' or c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while ('0' <= c and c <= '9') ans = ans * 10 + c - '0', c = getchar();
return ans * f;
}
void write(long long num) {
if (num < 0) putchar('-'), num = -num;
if (num >= 10) write(num / 10);
putchar('0' + num % 10);
}
void write1(long long num) {
write(num);
putchar(' ');
}
void write2(long long num) {
write(num);
putchar('\n');
}
template <typename T>
inline bool chmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool chmin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
long long gcd(long long x, long long y) { return y ? gcd(y, x % y) : x; }
bool IN(long long x, long long l, long long r) { return l <= x and x <= r; }
void GG() {
puts("-1");
exit(0);
}
const double eps = 1e-8;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int mm(const int x) { return x >= MOD ? x - MOD : x; }
template <typename T>
void add(T &x, const int &y) {
x = (x + y >= MOD ? x + y - MOD : x + y);
}
long long qpower(long long x, long long e, int mod = MOD) {
long long ans = 1;
while (e) {
if (e & 1) ans = ans * x % mod;
x = x * x % mod;
e >>= 1;
}
return ans;
}
long long invm(long long x) { return qpower(x, MOD - 2); }
const int MM = 4e6 + 10;
long long fac[MM], facinv[MM], Inv[MM];
long long Comb(int n, int m) {
return n < 0 or m < 0 or n < m
? 0
: fac[n] * facinv[m] % MOD * facinv[n - m] % MOD;
}
void PRE() {
fac[0] = 1;
for (int i = (1), I = (MM - 1); i <= I; i++) fac[i] = fac[i - 1] * i % MOD;
facinv[MM - 1] = invm(fac[MM - 1]);
for (int i = (MM - 1), I = (1); i >= I; i--)
facinv[i - 1] = facinv[i] * i % MOD;
Inv[1] = 1;
for (int i = (2), I = (MM - 1); i <= I; i++)
Inv[i] = (MOD - MOD / i) * Inv[MOD % i] % MOD;
}
const int N = 2e6 + 10;
long long f[N], g[N];
void main() {
for (int i = (3), I = (N - 1); i <= I; i++) {
g[i] = (g[i - 1] == 0 and g[i - 2] == 0);
f[i] = (f[i - 1] + 2 * f[i - 2] + g[i]) % MOD;
}
for (int T = (1), I = (qread()); T <= I; T++) write2(f[qread()] * 4 % MOD);
}
}; // namespace mine
signed main() {
srand(time(0));
mine::main();
printf("");
}
|
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long int n) {
if (n == 1 || n == 0) return false;
for (long long int i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
vector<long long int> dp(2 * 1000009);
void pre() {
dp[0] = dp[1] = dp[2] = 0;
for (long long int i = 3; i < 2 * 1000009; i++) {
if (i % 3 == 0)
dp[i] = (dp[i - 1] + 2 * dp[i - 2] + 1) % 1000000007;
else
dp[i] = (dp[i - 1] + 2 * dp[i - 2]) % 1000000007;
}
}
void solve() {
long long int n;
cin >> n;
long long int ans = (dp[n] * 4) % 1000000007;
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
pre();
long long int t;
cin >> t;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (2 * 1e6) + 10;
const int mod = 1e9 + 7;
long long dp[maxn], i, t, n;
void solve() {
dp[0] = 0;
dp[1] = 0;
dp[2] = 0;
for (int i = 3; i < maxn; i++) {
dp[i] = (dp[i - 1] + 2 * dp[i - 2]) % mod;
if (i % 3 == 0) {
dp[i] += 4;
dp[i] %= mod;
}
}
}
int main() {
solve();
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << dp[n] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
void run() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int32_t main() {
run();
vector<long long> dp((long long)(3e6), 0);
dp[3] = 4;
for (long long i = 4; i < (long long)(3e6); i++) {
long long temp1 = (2 * dp[i - 2] + dp[i - 1]);
long long temp2 = 4 + (4 * dp[i - 4] + 4 * dp[i - 3] + dp[i - 2]);
if (i % 3 == 0) {
dp[i] = temp2;
} else {
dp[i] = temp1;
}
dp[i] %= (long long)(1e9 + 7);
}
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << dp[n] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2000005];
void solve() {
int n;
cin >> n;
cout << (4 * dp[n]) % 1000000007 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
dp[1] = dp[2] = 0;
for (int i = 3; i <= 2000000; ++i) {
dp[i] = (dp[i - 1] + 2 * dp[i - 2]) % 1000000007;
if (i % 3 == 0) {
dp[i] = (dp[i] + 1) % 1000000007;
}
}
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e6 + 5;
int T, n;
long long f[MAXN];
signed main() {
f[0] = f[1] = f[2] = 0;
for (int i = 3; i <= MAXN - 5; i++) {
if (i % 3 == 0)
f[i] = f[i - 1] + f[i - 2] * 2 + 4;
else
f[i] = f[i - 1] + f[i - 2] * 2;
f[i] %= 1000000007;
}
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
printf("%lld\n", f[n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
long long POW(long long x, long long y) {
long long ans = 1;
long long base = x;
while (y) {
if (y & 1) {
ans *= base;
}
base = base * base;
y = y >> 1;
}
return ans;
}
const long long M = 2e6 + 1;
long long a[M], b[M], c[M], gen[M], ans[M], leaf[M], dp[M];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, i, j, k, t, temp, tc;
a[1] = 1;
b[1] = 0;
c[1] = 0;
a[0] = 0;
b[0] = 0;
c[0] = 0;
gen[1] = 1;
gen[0] = 1;
ans[0] = 0;
ans[1] = 0;
ans[2] = 0;
leaf[0] = 0;
dp[0] = 0;
dp[1] = 0;
dp[2] = 0;
dp[3] = 2;
for (i = 2; i <= M - 1; i++) {
a[i] = (a[i - 1] + 2 * b[i - 1]) % MOD;
b[i] = a[i - 1];
c[i] = b[i - 1];
gen[i] = ((a[i] - c[i]) + 100 * MOD) % MOD;
leaf[i] = (2 * c[i]) % MOD;
}
for (i = 4; i <= M - 1; i++) {
dp[i] = (leaf[i] + dp[i - 3]) % MOD;
}
cin >> tc;
while (tc--) {
cin >> n;
long long final = (2 * dp[n]) % MOD;
cout << final << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MAXN = 2e6 + 5;
long long dp[MAXN];
int t;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
dp[1] = (long long)0, dp[2] = (long long)0, dp[3] = (long long)4,
dp[4] = (long long)4, dp[5] = (long long)12;
for (int i = 6; i <= MAXN - 2; i++) {
if (i % 3 == 0)
dp[i] = (4 + ((((4 * dp[i - 4]) % MOD) + ((4 * dp[i - 3]) % MOD)) % MOD) +
dp[i - 2]) %
MOD;
else
dp[i] = (((2 * dp[i - 2]) % MOD) + dp[i - 1]) % MOD;
}
cin >> t;
while (t) {
t--;
int n;
cin >> n;
cerr << "ANS" << endl;
cout << dp[n] % MOD << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int a = 1e9 + 7;
long long int dp[2000005];
int main() {
dp[1] = 0;
dp[2] = 0;
dp[3] = 4;
dp[4] = 4;
for (int i = 5; i <= 2000000; i++) {
dp[i] = (2 * dp[i - 2] + dp[i - 1] + 4 * (i % 3 == 0)) % a;
}
long long int t;
cin >> t;
while (t-- > 0) {
long long int n;
cin >> n;
cout << dp[n] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,sse4.2,popcnt,abm,mmx,avx")
using namespace std;
template <class U, class V>
istream& operator>>(istream& is, pair<U, V>& p) {
is >> p.first >> p.second;
return is;
}
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto& x : v) {
is >> x;
}
return is;
}
template <class T>
ostream& operator<<(ostream& os, vector<T>& v) {
for (auto& x : v) {
os << x << " ";
}
return os;
}
const int N = 2e6 + 5;
const int MOD = round(1e9 + 7);
int memo[N][2];
int solve(int n, bool yellow) {
if (n <= 2) return 0;
if (n == 3) return 4 * !yellow;
int& res = memo[n][yellow];
if (res != -1) return res;
if (yellow || n % 3 != 0) {
res = (solve(n - 1, false) + 2LL * solve(n - 2, false)) % MOD;
return res;
}
res = (4 + solve(n - 1, true) + 2LL * solve(n - 2, true)) % MOD;
return res;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
memset(memo, -1, sizeof memo);
for (int i = 1; i < N; ++i) solve(i, true), solve(i, false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << solve(n, false) << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long ool = 1e18 + 9;
const int oo = 1e9 + 9, base = 1e9 + 7;
const double eps = 1e-7;
const int N = 2e6 + 6;
long long d[N][2];
void solve() {
int n;
cin >> n;
cout << 4ll * max(d[n][0], d[n][1]) % base << "\n";
}
void clear() {}
int main() {
ios_base ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
for (int i = 3; i <= N - 1; ++i) {
d[i][0] = ((max(d[i - 2][1], d[i - 2][0]) * 2 % base) +
max(d[i - 1][1], d[i - 1][0]) % base);
d[i][1] = ((d[i - 2][0] * 2 % base) + d[i - 1][0] % base) + 1;
}
int T = 1;
cin >> T;
while (T--) {
solve();
clear();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 5;
const int mod = 1e9 + 7;
int n, k;
long long a[maxn];
template <class T>
inline void read(T &res) {
res = 0;
T f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
res = res * 10 + c - '0';
c = getchar();
}
res *= f;
}
long long cal(int n) { return a[n]; }
int nn = 4, mm = 12;
long long call(int i) {
if (i % 3) return (a[i - 1] + 2 * a[i - 2]) % mod;
return (a[i - 1] + 2 * a[i - 2] + 4) % mod;
}
void init() {
a[3] = a[4] = nn;
a[5] = mm;
for (int i = 6; i <= maxn; ++i) {
a[i] = call(i);
}
}
int main() {
int qwq;
init();
read(qwq);
while (qwq--) {
read(n);
long long ans = cal(n);
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
const double PI = atan(1.0) * 4;
const int di[4] = {-1, 0, 1, 0};
const int dj[4] = {0, -1, 0, 1};
const long long INF = (long long)2e18 + 50;
const int maximum = numeric_limits<int>::min();
const int minimum = numeric_limits<int>::max();
long long dp[2000050];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
for (long long i = 3; i <= 2e6; i++)
dp[i] = (dp[i - 1] + dp[i - 2] * 2 + (i % 3 == 0) * 4) % 1000000007;
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << dp[n] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000010;
const long long mod = 1000000007L;
long long p[maxn][2];
int main() {
ios::sync_with_stdio(0);
int t;
cin >> t;
p[3][0] = 0;
p[3][1] = 1;
for (int i = 4; i < maxn; ++i) {
p[i][0] = (p[i - 2][1] * 2 % mod + p[i - 1][1]) % mod;
p[i][1] = (1 + p[i - 2][0] * 2 % mod + p[i - 1][0]) % mod;
if (i >= 5 && (i - 5) % 3 == 0) p[i][1] = p[i][0];
}
for (int T = 0; T < t; ++T) {
int n;
cin >> n;
long long ans = p[n][1] * 4 % mod;
printf("%lld\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long NINF = 0xc0c0c0c0c0c0c0c0;
inline void read(long long &x) {
bool flag = false;
x = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') flag = true;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + c - '0';
c = getchar();
}
x = flag ? -x : x;
}
inline void write(long long x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
const long long mod = 1e9 + 7;
const long long maxn = (2e6 + 5);
long long f1[maxn], f2[maxn], f3[maxn], sum[maxn];
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long t;
cin >> t;
f1[1] = 1;
f2[1] = 0;
f3[1] = 0;
for (long long i = (2); i <= (2000000); ++i) {
f1[i] = (f2[i - 1] * 2 + f1[i - 1]) % mod;
f2[i] = f1[i - 1];
f3[i] = (f3[i - 1] + f2[i - 1]) % mod;
}
for (long long i = 4; i <= 2000000; i += 3) {
sum[i] = (sum[i - 3] + f2[i]) % mod;
}
for (long long i = 3; i <= 2000000; i += 3) {
sum[i] = (sum[i - 3] + f2[i]) % mod;
}
sum[2] = 1;
for (long long i = 5; i <= 2000000; i += 3) {
sum[i] = (sum[i - 3] + f2[i]) % mod;
}
while (t--) {
long long n;
cin >> n;
cout << sum[n - 1] * 4 % mod;
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 5, mod = 1e9 + 7;
long long dp[maxn][2];
int main() {
for (int i = 3; i < maxn; i++) {
dp[i][1] = (dp[i - 2][0] * 2 + dp[i - 1][0] + 1) % mod;
dp[i][0] = dp[i][1] + i % 3 - 1;
}
int t, n;
cin >> t;
while (t--) cin >> n, cout << max(dp[n][0], dp[n][1]) * 4 % mod << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, flag;
long long p[2000009], a[2000009];
void init() {
p[3] = p[4] = 1;
a[3] = 1;
a[4] = 0;
for (int i = 5; i < 2000009; i++) {
if (a[i - 1] == 0 && a[i - 2] == 0) {
a[i] = 1;
p[i] = (2 * p[i - 2] + p[i - 1] + 1) % 1000000007;
} else
p[i] = (2 * p[i - 2] + p[i - 1]) % 1000000007;
}
}
int main() {
std::ios::sync_with_stdio(false);
init();
cin >> k;
while (k--) {
cin >> n;
printf("%lld\n", 4 * p[n] % 1000000007);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const long long infll = 0x7fffffffffffffff;
const int mod = (int)(1e9) + 7;
const int inf = 0x7fffffff;
const int maxn = (int)(2e6) + 7;
const int maxm = 300;
int _;
long long n, f[maxn];
int main() {
for (int i = 3; i <= (long long)(2e6); i++) {
f[i] = (f[i - 1] + f[i - 2] * 2 % mod + (i % 3 ? 0 : 1)) % mod;
}
for (scanf("%d", &_); _; _--) {
scanf("%lld", &n);
printf("%lld\n", f[n] * 4 % mod);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pii = pair<long long, long long>;
const long long INF = 1e18;
template <class A, class B>
ostream& operator<<(ostream& os, const pair<A, B> p) {
return os << "(" << p.first << "," << p.second << ")";
}
void dprint(string s) { cout << "\n"; }
template <class T, class... U>
void dprint(string s, T t, U... u) {
long long w = s.find(',');
cout << "[" << s.substr(0, w) << ": " << t << "] ";
dprint(s.substr(w + 1, (long long)s.size() - w), u...);
}
const long long N = 2000005;
const long long mod = 1e9 + 7;
long long arr[N], sum[N] = {};
void precompute() {
arr[0] = 0, arr[1] = 1, arr[2] = 1;
for (long long i = 3; i < N; i++)
arr[i] = arr[i - 1] + 2 * arr[i - 2], arr[i] %= mod;
sum[0] = 0, sum[1] = 0, sum[2] = 0;
for (long long i = 3; i < N; i++) {
sum[i] += arr[i - 2];
sum[i] += sum[i - 3];
sum[i] %= mod;
}
}
void solve() {
long long n;
cin >> n;
long long ans = (4 * sum[n]) % mod;
cout << ans << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long T;
cin >> T;
precompute();
for (long long tc = 1; tc <= T; tc++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2000006];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
dp[1] = 0;
dp[2] = 0;
for (long long int i = 3; i < 2000006; i++) {
long long p = (dp[i - 1] % 1000000007);
p += ((2 * dp[i - 2]) % 1000000007);
if (i % 3 == 0) p += 1;
dp[i] = p % 1000000007;
}
int T = 1;
cin >> T;
while (T--) {
long long n;
cin >> n;
cout << (dp[n] * 4) % 1000000007 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double PI = acos(-1.0);
const int MAXN = 2000005;
const long long mod = 1e9 + 7;
const long long llinf = (long long)(1e18) + 500;
const int inf = 0x3f3f3f3f;
long long a[MAXN];
int main() {
a[1] = 0;
a[2] = 0;
for (int i = 3; i <= 2000000; i++) {
a[i] = (a[i - 1] + a[i - 2] * 2) % mod;
if (i % 3 == 0) a[i] = (a[i] + 4) % mod;
}
int T;
scanf("%d", &T);
while (T--) {
long long n;
cin >> n;
cout << a[n] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long MAX = 2e6;
long long MOD = 1e9 + 7;
long long LEVEL[2000010];
int main() {
ios::sync_with_stdio(false);
cin.tie();
cout.tie();
LEVEL[1] = 0;
LEVEL[2] = 0;
LEVEL[3] = 4;
for (int i = 4; i <= MAX; i++) {
if (i % 3)
LEVEL[i] = (LEVEL[i - 1] + 2 * LEVEL[i - 2]) % MOD;
else
LEVEL[i] = (LEVEL[i - 1] + 2 * LEVEL[i - 2] + 4) % MOD;
}
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << LEVEL[n] % MOD << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, po = 1000000000 + 7;
cin >> t;
vector<long long> dp(2000000 + 1);
dp[1] = 0;
dp[2] = 0;
dp[3] = 4;
dp[4] = 4;
for (int i = 5; i <= 2000000 + 1; i++) {
dp[i] = (dp[i - 1] + (dp[i - 2] * 2));
if (i % 3 == 0) {
dp[i] += 4;
}
dp[i] = dp[i] % po;
}
while (t--) {
cin >> n;
cout << dp[n] % po << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 5e6 + 105;
const int mod = 1e9 + 7;
const double Pi = acos(-1.0);
const long long INF = 1e9;
const int G = 3, Gi = 332748118;
long long qpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
bool cmp(int a, int b) { return a > b; }
int n, T;
long long dp[N];
int main() {
scanf("%d", &T);
dp[1] = dp[2] = 0;
dp[3] = dp[4] = 4;
for (int i = 5; i < N; ++i) {
dp[i] = (dp[i - 1] + 2 * dp[i - 2] % mod) % mod;
if (i % 3 == 0) dp[i] = (dp[i] + 4) % mod;
}
while (T--) {
scanf("%d", &n);
printf("%lld\n", dp[n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> nclaws(2000001, 0);
void solve() {
int n;
cin >> n;
cout << ((nclaws[n] * 4) % 1000000007) << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
nclaws[1] = 0;
nclaws[2] = 0;
nclaws[3] = 1;
nclaws[4] = 1;
for (int i = 5; i < 2000001; i++) {
nclaws[i] = nclaws[i - 1] + 2 * nclaws[i - 2];
if (i % 3 == 0) nclaws[i]++;
nclaws[i] = nclaws[i] % 1000000007;
}
int t = 1;
cin >> t;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
mt19937 rnd(1);
long long bit(long long mask, long long i) { return ((mask >> i) & 1); }
vector<long long> ans((long long)2e6 + 1);
void solve() {
ans[2] = ans[1] = 0;
long long a = 1, b = 0;
long long ex = 0;
long long add = 0;
unordered_map<long long, long long> cnt;
cnt.rehash((long long)2e6);
cnt[2 * a + 5 * b + ex] = 0;
for (long long i = 2; i < (long long)2e6; ++i) {
long long c = a;
long long d = b;
b += c;
a -= c;
a += 2 * d;
ex += d;
a %= MOD;
b %= MOD;
ex %= MOD;
add = cnt[ex];
cnt[(2 * a + 5 * b + ex) % MOD] = (b + add) % MOD;
ans[i + 1] = (4 * (b + add)) % MOD;
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
solve();
for (long long num_test = 0; num_test < t; ++num_test) {
long long n;
cin >> n;
cout << ans[n] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int moder = (int)1e9 + 7;
int child[2000005][3];
int max_val[2000005];
void prepare() {
int limit = (int)2e6;
child[1][0] = 1;
for (int i = 2; i <= limit; i++) {
child[i][0] =
((long long)child[i - 1][0] + (long long)2 * child[i - 1][1]) % moder;
child[i][1] = child[i - 1][0];
}
for (int i = 3; i <= limit; i++)
max_val[i] =
((long long)max_val[i - 3] + (long long)child[i - 1][1] * 4) % moder;
}
void solve() {
int num;
scanf("%d", &num);
printf("%d\n", max_val[num]);
}
int main() {
prepare();
int tester;
scanf("%d", &tester);
while (tester--) solve();
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
long long dp[2000005], mod = 1000000007;
int main() {
long long i, n, t;
scanf("%lld", &t);
dp[1] = dp[2] = 0;
dp[3] = dp[4] = 4;
for (i = 5; i <= 2000000; i++)
dp[i] = (2 * dp[i - 2] + dp[i - 1] + 4 * (i % 3 == 0)) % mod;
while (t--) {
scanf("%lld", &n);
printf("%lld\n", dp[n]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double pi = acos(-1.0);
const int mod = 1e9 + 7;
const int inf = 0x7fffffff;
const ll INF = 0x7fffffffffffffff;
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
ll z[2000006];
ll x[2000006];
ll mod0[2000006];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll a, b, c, d, e, f, g, T;
z[0] = 0;
z[1] = 0;
z[2] = 1;
z[3] = 1;
for (int i = 4; i <= 2000000; i++) {
z[i] = z[i - 2] * 3 + z[i - 3] * 2;
z[i] %= mod;
}
mod0[2] = 1;
for (int i = 3; i <= 2000000; i++) {
mod0[i] = mod0[i - 3] + z[i];
mod0[i] %= mod;
}
cin >> T;
while (T--) {
cin >> a;
cout << mod0[a - 1] * 4 % mod << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e6 + 120;
const long long maxx = 1e16;
const long long mod = 1e9 + 7;
const long long mod1 = 123456789;
long long a[maxn];
long long b[maxn];
long long f[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (fopen("SAMEBIT.INP", "r")) {
freopen("SAMEBIT.INP", "r", stdin);
freopen("SAMEBIT.OUT", "w", stdout);
}
f[1] = 0;
a[1] = 0;
b[1] = 1;
f[2] = 0;
a[2] = 1;
b[2] = 1;
for (int i = 3; i < maxn; i++) {
f[i] = (f[i - 3] + a[i - 1]) % mod;
long long p = b[i - 1];
long long h = (p + 2 * a[i - 1]) % mod;
a[i] = p;
b[i] = h;
}
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << (f[n] * 4) % mod << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long dp[20000009];
int main() {
dp[1] = 0;
dp[2] = 0;
for (int i = 3; i < 2000009; i++) {
dp[i] =
(2ll * dp[i - 2] % mod + dp[i - 1] % mod + (i % 3 == 0 ? 4 : 0) % mod) %
mod;
}
int t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << dp[n] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[2000005];
int main() {
dp[3] = 1;
dp[2] = 0;
dp[1] = 0;
for (int i = 4; i < 2e6 + 5; i++) {
dp[i] = (dp[i - 1] + 2 * dp[i - 2]) % 1000000007ll;
if (i % 3 == 0) dp[i]++;
dp[i] %= 1000000007ll;
}
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << (dp[n] * 4) % 1000000007ll << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void print(vector<int> v) {
vector<int>::iterator it = v.begin();
while (it != v.end()) {
cout << *it << " ";
it++;
}
cout << endl;
}
long long hcf(long long n, long long m) {
if (m == 0) return n;
if (n < m) swap(n, m);
return hcf(m, n % m);
}
int main() {
vector<long long> v(2000001);
v[1] = 1;
v[2] = 2;
v[3] = 5;
for (int i = 4; i <= 2000000; i++) {
v[i] = (v[i - 1] + ((v[i - 1] - v[i - 2] + 1000000007) % 1000000007) +
2 * ((v[i - 2] - v[i - 3] + 1000000007) % 1000000007)) %
1000000007;
}
vector<long long> ans(2000001);
ans[1] = 0;
ans[2] = 0;
ans[3] = 1;
for (int i = 4; i <= 2000000; i++) {
ans[i] = ((v[i - 2] - v[i - 3] + 1000000007) % 1000000007 + ans[i - 3]) %
1000000007;
}
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long f = (ans[n] * 4) % 1000000007;
cout << f << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[3];
long long d[2000005] = {0};
int main() {
long long t = 1, n, m, k, x1, x2, x3, x, y, y1, y2, y3;
memset(dp, 0, sizeof(dp));
dp[0] = 1;
long long c1 = 0, c2 = 0, c3 = 0, i1, i2, i3;
for (int i = 2; i <= 2000004; i++) {
i1 = dp[0];
i2 = dp[1];
i3 = dp[2];
dp[1] = i1;
dp[2] = i2;
dp[0] = 2 * i2 + i1;
dp[0] %= 1000000007;
dp[1] %= 1000000007;
dp[2] %= 1000000007;
if (i % 3 == 1) {
c1 += dp[2] % 1000000007;
c1 %= 1000000007;
} else if (i % 3 == 2) {
c2 += dp[2] % 1000000007;
c2 %= 1000000007;
} else {
c3 += dp[2] % 1000000007;
c3 %= 1000000007;
}
if (i % 3 == 0) {
d[i] = c3;
} else if (i % 3 == 1) {
d[i] = c1;
} else
d[i] = c2;
}
cin >> t;
while (t--) {
cin >> n;
long long ma = 0;
ma = d[n];
ma = ((ma % 1000000007) * 4) % 1000000007;
cout << ma << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 5;
const long long mod = 1e9 + 7;
long long dp[N];
void pre() {
dp[3] = 4;
dp[4] = 4;
dp[5] = 12;
for (long long i = 6; i < N; i++) {
dp[i] = 4;
dp[i] += dp[i - 2];
dp[i] %= mod;
dp[i] += dp[i - 3];
dp[i] %= mod;
dp[i] += dp[i - 3];
dp[i] %= mod;
dp[i] += dp[i - 3];
dp[i] %= mod;
dp[i] += dp[i - 4];
dp[i] %= mod;
dp[i] += dp[i - 4];
dp[i] %= mod;
dp[i] += dp[i - 3];
dp[i] %= mod;
dp[i] += dp[i - 4];
dp[i] %= mod;
dp[i] += dp[i - 4];
dp[i] %= mod;
dp[i] = max(dp[i], ((2 * dp[i - 2]) % mod + dp[i - 1]) % mod);
}
}
int main() {
long long t;
pre();
cin >> t;
for (long long i = 0; i < t; i++) {
long long n;
cin >> n;
cout << dp[n] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int p[2000005], q[2000005], r[2000005], ans[2000005];
void shikhar7s(long long int cas) {
long long int n, a;
cin >> n;
if (n < 3) {
cout << 0 << "\n";
return;
} else {
a = ans[n];
a = (a * 4) % 1000000007;
cout << a << "\n";
}
}
signed main() {
std::ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long int t = 1;
p[1] = 1;
q[1] = 0;
r[1] = 0;
for (t = 2; t < 2000005; t++) {
r[t] = (r[t - 1] + q[t - 1]) % 1000000007;
q[t] = p[t - 1];
p[t] = (2 * q[t - 1]) % 1000000007;
p[t] = (p[t] + p[t - 1]) % 1000000007;
}
for (t = 3; t < 2000005; t++) {
ans[t] = (ans[t - 3] + q[t - 1]) % 1000000007;
}
cin >> t;
long long int cas = 1;
while (cas <= t) {
shikhar7s(cas);
cas++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 10;
const int N = 2e6;
const int mod = 1e9 + 7;
int t, dp[maxn][2], n;
int main() {
for (int i = 3; i <= N; i++) {
dp[i][0] = (2ll * max(dp[i - 2][0], dp[i - 2][1]) +
max(dp[i - 1][0], dp[i - 1][1])) %
mod;
dp[i][1] = (2ll * dp[i - 2][0] + dp[i - 1][0] + 4) % mod;
}
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
printf("%d\n", max(dp[n][0], dp[n][1]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const double pi = acos(-1.0);
const double eps = 1e-8;
const int mod = 1e9 + 7;
long long dp[2000005], t, n;
;
int main() {
dp[0] = dp[1] = 0;
dp[2] = 4;
for (int i = 3; i < 2000005; ++i) {
long long a = dp[i - 1];
a += 2 * dp[i - 2] + (i % 3 == 2) * 4;
a %= mod;
dp[i] = a;
}
scanf("%lld", &t);
while (t--) {
scanf("%lld", &n);
printf("%lld\n", dp[n - 1] % mod);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int fac[999377];
long long int dp[2000005];
const long long int mod = 1e9 + 7;
void faster() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
void inout() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
int main() {
faster();
long long int i;
dp[0] = 0;
dp[1] = 0;
dp[2] = 0;
dp[3] = 1;
for (i = 4; i <= 2000000; i++) {
dp[i] = ((2 * dp[i - 2]) % mod + dp[i - 1] % mod) % mod;
if (i % 3 == 0) dp[i] = (dp[i] + 1) % mod;
}
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
cout << (4 * dp[n]) % mod << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
constexpr long long mod = 1e9 + 7;
long long data[2000006][2];
int dlt[2000006];
long long get(int n) {
if (dlt[n] > 0) {
return data[n][1];
} else {
return data[n][0];
}
}
void solve() {
int n;
std::cin >> n;
std::cout << ((get(n) * 4LL) % mod) << '\n';
}
signed main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
data[3][1] = 1;
dlt[3] = 1;
data[4][0] = data[4][1] = 1;
dlt[4] = 0;
for (int i = 5; i <= (2e6); i++) {
data[i][1] = (2 * data[i - 2][0]) + data[i - 1][0] + 1;
{
int d(1);
if (dlt[i - 2] > 0) {
d -= 2 * dlt[i - 2];
}
if (dlt[i - 2] > 0) {
d -= dlt[i - 1];
}
dlt[i] = d;
}
data[i][0] = (2 * get(i - 2)) + get(i - 1);
data[i][0] %= mod;
data[i][1] %= mod;
}
int t(1);
std::cin >> t;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[2000001], t, n;
const int p = 1e9 + 7;
int main() {
scanf("%d", &t);
f[1] = f[2] = 0;
f[3] = 4;
for (int i = 4; i <= 2e6; ++i)
f[i] = ((2ll * f[i - 2] % p + f[i - 1]) % p + 4 * (!(i % 3))) % p;
while (t--) {
scanf("%d", &n);
printf("%d\n", f[n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
n = 2e6 + 1;
int mod = 1e9 + 7;
int en[n + 1], cn[n + 1], in[n + 1], re[n + 1];
en[1] = 0;
cn[1] = 0;
in[1] = 1;
re[1] = 0;
re[0] = 0;
cn[0] = 0;
for (int i = 2; i <= n; i++) {
in[i] = (((2 * 1LL * en[i - 1]) % mod + in[i - 1] % mod) % mod) % mod;
cn[i] = en[i - 1];
en[i] = in[i - 1];
if (i > 3) {
re[i] = (re[i - 3] + cn[i]) % mod;
} else {
re[i] = cn[i];
}
}
int t;
cin >> t;
while (t--) {
int k;
cin >> k;
cout << (4 * 1LL * re[k]) % mod << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t, n;
vector<vector<long long>> dp;
long long solve(long long x, long long y) {
if (dp[x][y] == -1) {
if (y == 1) {
dp[x][y] = max(2 * solve(x - 2, 1) + solve(x - 1, 1),
4 + 2 * solve(x - 2, 0) + solve(x - 1, 0)) %
((int)(1e9 + 7));
} else {
dp[x][y] = (2 * solve(x - 2, 1) + solve(x - 1, 1)) % ((int)(1e9 + 7));
}
}
return dp[x][y];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
dp = vector<vector<long long>>((int)(2e6 + 5), vector<long long>(2, -1));
dp[1][0] = dp[1][1] = dp[2][0] = dp[2][1] = dp[3][0] = 0;
dp[3][1] = 4;
for (int i = 4; i <= (int)(2e6); ++i) {
solve(i, 0);
solve(i, 1);
}
cin >> t;
for (; t; --t) {
cin >> n;
cout << solve(n, 1) << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2000000 + 1, mod = 1000000007;
int n;
long long dp[maxn] = {};
int main() {
int T;
scanf("%d", &T);
for (int i = 3; i < maxn; ++i)
dp[i] = (dp[i - 1] + dp[i - 2] * 2 + (!(i % 3) ? 4 : 0)) % mod;
while (T--) {
scanf("%d", &n);
printf("%d\n", dp[n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void wenjian() {
freopen("concatenation.in", "r", stdin);
freopen("concatenation.out", "w", stdout);
}
void tempwj() {
freopen("hash.in", "r", stdin);
freopen("hash.out", "w", stdout);
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long qpow(long long a, long long b, long long mod) {
a %= mod;
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
struct cmp {
bool operator()(const pair<int, long long>& a,
const pair<int, long long>& b) {
return a.second > b.second;
}
};
int lb(int x) { return x & -x; }
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const long long mod = 1e9 + 7;
const int maxn = 2e6 + 5;
long long dp[maxn];
int main() {
int T;
scanf("%d", &T);
dp[1] = 0;
dp[2] = 0;
dp[3] = 1;
for (int i = 4; i <= 2000000; i++) {
dp[i] = (2 * dp[i - 2] % mod + dp[i - 1]) % mod;
if (i % 3 == 0) dp[i] = (dp[i] + 1) % mod;
}
while (T--) {
int n;
scanf("%d", &n);
printf("%lld\n", dp[n] * 4 % mod);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 10;
const int M = 1e9 + 7;
long long ans[maxn], f[maxn];
int main() {
ans[1] = ans[2] = 0;
for (long long i = (3); i < (maxn); (i)++) {
ans[i] = (ans[i - 1] + 2 * ans[i - 2]) % M;
if (!f[i - 1] && !f[i - 2]) {
ans[i] = (ans[i] + 1) % M;
f[i] = 1;
}
}
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << ans[n] * 4 % M << endl;
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize "03"
using namespace std;
const long long int N = 2e6 + 5;
const long long int mod = 1e9 + 7;
const long long int inf = 1e9 + 9;
long long int f[N];
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
f[3] = 4;
for (long long int i = 4; i < N; i++) {
long long int a = (f[i - 1] + 2 * f[i - 2]) % mod;
long long int b = (f[i - 2] + 4 * f[i - 3] + 4 * f[i - 4] + 4) % mod;
f[i] = max(a, b);
}
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
cout << f[n] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
long long mod = 1000000007;
void normalize(long long &a) { a = (a + mod) % mod; }
long long modmul(long long a, long long b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a * b) % mod;
}
long long modadd(long long a, long long b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a + b) % mod;
}
long long modsub(long long a, long long b) {
a = a % mod;
b = b % mod;
normalize(a);
normalize(b);
return (a - b + mod) % mod;
}
long long me(long long x, long long n) {
x %= mod;
if (n == 0) return 1;
long long u = me(x, n / 2) % mod;
u = (u * u) % mod;
if (n % 2) u = (u * x) % mod;
return u;
}
long long ipow(long long a, long long b) {
long long c = 1;
while (b--) c *= a;
return c;
}
long long logb(long long a, long long b) {
long long ans = 0;
while (a >= b) {
a /= b;
ans++;
}
return ans;
}
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; }
bool isprime(long long n) {
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
return false;
}
}
if (n == 1) return false;
return true;
}
using namespace std;
long long a[200005];
void solve() {
long long ar[20001][2];
long long a, b, c;
a = 0;
b = 0;
c = 0;
for (long long i = 3; i < 2000001; i++) {
a = b;
b = c;
c = (b + (2 * a) % 1000000007) % 1000000007;
if (i % 3 == 0) c = (c + 4) % 1000000007;
if (i % 100 == 0) {
ar[i / 100][0] = c;
ar[i / 100][1] = b;
}
}
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
;
long long index = n / 100;
long long cc = ar[index][0];
long long bb = ar[index][1];
long long aa;
for (long long j = index * 100 + 1; j <= n; j++) {
aa = bb;
bb = cc;
cc = (bb + (2 * aa) % 1000000007) % 1000000007;
if (j % 3 == 0) cc = (cc + 4) % 1000000007;
}
cout << cc << "\n";
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long s[2000005];
long long a[2000005];
long long ans[2000005];
long long mod = 1e9 + 7;
long long tru(long long t) {
long long res = -t;
while (res < 0) res += mod;
res %= mod;
return res;
}
int main() {
s[2] = 1;
s[3] = 1;
a[3] = 3;
ans[3] = 1;
for (int i = 4; i <= 2e6 + 1; i++) {
s[i] = a[i - 1] % mod;
a[i] = (s[i - 1] * 2 % mod + a[i - 1] % mod) % mod;
ans[i] = (ans[i - 3] % mod + s[i - 1] % mod) % mod;
}
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
if (n < 3)
cout << 0 << endl;
else
cout << (ans[n] * 4) % mod << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using i64 = unsigned long long;
using ld = long double;
template <typename T>
inline T Min(T a, T b, T c) {
return min(a, min(b, c));
}
template <typename T>
inline T Min(T a, T b, T c, T d) {
return min(a, min(b, min(c, d)));
}
template <typename T>
inline T Ceil(T a, T b) {
return ((a % b == 0) ? (a / b) : (a / b + 1));
}
template <typename T>
inline T Floor(T a, T b) {
return a / b;
}
template <typename T>
inline T Power(T a, T p) {
T res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
template <typename T>
inline T gcd(T a, T b) {
a = abs(a);
b = abs(b);
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
template <typename T>
inline T lcm(T x, T y) {
return (((x) / gcd((x), (y))) * (y));
}
template <typename T1, typename T2, typename T3>
struct Pair {
T1 first;
T2 second;
T3 third;
};
template <typename T1, typename T2, typename T3, typename T4>
struct Pair4 {
T1 first;
T2 second;
T3 third;
T4 fourth;
};
using ii = pair<int, int>;
using iii = Pair<int, int, int>;
using iiii = Pair4<int, int, int, int>;
const double EPS = 1e-7;
const double PI = acos(-1.0);
const ll LLINF = (ll)1e18 + 1;
const int INF = (int)1e9 + 1;
const int MOD = (int)1e9 + 7;
const int N = (int)2e6 + 10;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
vector<int> dp(N + 10);
dp[3] = 4, dp[4] = 4;
for (int i = 5; i <= N; ++i) {
dp[i] = ((dp[i - 1] % MOD) + (2 * dp[i - 2] % MOD)) % MOD;
if (i % 3 == 0) {
dp[i] += 4;
dp[i] %= MOD;
}
}
int tc;
cin >> tc;
while (tc--) {
function<void(void)> Solve = [&]() {
int n;
cin >> n;
if (n < 3) {
cout << "0\n";
} else {
cout << dp[n] << '\n';
}
};
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
long long int power(long long int x, long long int y,
long long int mod = 1000000007) {
long long int ret = 1;
x = x % mod;
while (y) {
if (y & 1) ret = (ret * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return ret % mod;
}
void solve() {
long long int t;
cin >> t;
long long int N = 2 * 1000 * 1000 + 5;
vector<long long int> single(N);
vector<long long int> nochild(N);
vector<long long int> claw(N);
single[0] = 0;
single[1] = 1;
nochild[0] = 0;
nochild[1] = 1;
claw[0] = 0;
claw[1] = 0;
for (long long int i = 2; i <= N; i++) {
nochild[i] =
((2 * single[i - 1]) % 1000000007 + nochild[i - 1]) % 1000000007;
single[i] = nochild[i - 1];
claw[i] = ((single[i - 1] * 4) % 1000000007 + claw[i - 3] * (i >= 3)) %
1000000007;
}
for (long long int i = 0; i < t; i++) {
long long int x;
cin >> x;
cout << claw[x - 1] << endl;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
for (long long int test = 1; test <= t; test++) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 10;
const int mod = 1e9 + 7;
long long a[maxn];
int main() {
int t;
cin >> t;
a[1] = 0;
a[2] = 0;
a[3] = 1;
a[4] = 1;
for (int i = 5; i <= maxn - 10; i++) {
a[i] = (2 * a[i - 2] % mod + a[i - 1] % mod) % mod;
if (i % 3 == 0) a[i]++;
}
while (t--) {
int n;
cin >> n;
cout << (4 * a[n]) % mod << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int N = 2e6 + 10;
long long n, dp[N];
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(0);
int t;
cin >> t;
dp[1] = dp[2] = 0;
for (int i = 3; i <= 2e6; i++)
dp[i] = (dp[i - 1] + 2 * dp[i - 2] + (i % 3 == 0)) % MOD;
while (t--) {
cin >> n;
cout << (dp[n] * 4) % MOD << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2123456][2];
int main() {
long long t, n;
cin >> t;
dp[2][0] = 0;
dp[2][1] = 0;
dp[3][0] = 4;
dp[3][1] = 0;
for (int i = 4; i <= 2000000; i++) {
dp[i][0] = (4 + 2 * dp[i - 2][1] + dp[i - 1][1]) % 1000000007;
if (i % 3 == 0) {
dp[i][1] = (2 * dp[i - 2][0] + dp[i - 1][1]) % 1000000007;
}
if (i % 3 == 1) {
dp[i][1] = (2 * dp[i - 2][1] + dp[i - 1][0]) % 1000000007;
}
if (i % 3 == 2) {
dp[i][1] = (2 * dp[i - 2][0] + dp[i - 1][1]) % 1000000007;
}
}
while (t--) {
cin >> n;
if (n % 3 == 0) {
cout << dp[n][0] << endl;
} else {
cout << dp[n][1] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1000000007;
long long dp[2][2000005] = {0};
int main() {
long long T, n;
dp[0][1] = 0;
dp[1][1] = 0;
dp[0][2] = 0;
dp[1][2] = 0;
dp[0][3] = 1;
dp[1][3] = 0;
dp[0][4] = 1;
dp[1][4] = 1;
for (long long i = 5; i <= 2000000; i++) {
dp[1][i] = (dp[0][i - 1] + 2 * dp[0][i - 2]) % M;
dp[0][i] = dp[1][i];
if (i % 3 == 0) dp[0][i] = (dp[1][i - 1] + 2 * dp[1][i - 2] + 1) % M;
}
for (long long i = 1; i <= 2000000; i++) dp[0][i] = (dp[0][i] * 4) % M;
cin >> T;
while (T--) {
cin >> n;
cout << dp[0][n] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
~debug() { cerr << endl; }
template <class c>
typename enable_if<sizeof dud<c>(0) != 1, debug&>::type operator<<(c i) {
cerr << boolalpha << i;
return *this;
}
template <class c>
typename enable_if<sizeof dud<c>(0) == 1, debug&>::type operator<<(c i) {
return *this << range(begin(i), end(i));
}
template <class c, class b>
debug& operator<<(pair<b, c> d) {
return *this << "(" << d.first << ", " << d.second << ")";
}
template <class c>
debug& operator<<(rge<c> d) {
*this << "[";
for (auto it = d.b; it != d.e; ++it) *this << ", " + 2 * (it == d.b) << *it;
return *this << "]";
}
};
long double eps = (long double)1 / 1e6;
const long double pi = 3.14159265359;
long long inf = 1e18, mod1 = 1e9 + 7, mod2 = -1;
long long sqr(long long a) { return a * a; }
long long qb(long long a) { return a * a * a; }
long long gcd(long long a, long long b) { return !a ? b : gcd(b % a, a); }
long long binpow(long long a, long long b, long long mod) {
return b ? (b % 2 ? (a * (sqr(binpow(a, b / 2, mod)) % mod)) % mod
: sqr(binpow(a, b / 2, mod)) % mod)
: 1;
}
long long binmult(long long a, long long b, long long mod) {
return b ? (b % 2 ? (2 * binmult(a, b / 2, mod) + a) % mod
: (2 * binmult(a, b / 2, mod)) % mod)
: 0;
}
const long long R = 1e4;
const long long tx[4] = {0, 0, -1, 1};
const long long ty[4] = {-1, 1, 0, 0};
const char rev_to[4] = {'E', 'W', 'N', 'S'};
const int N = 1e6 + 1;
struct triple {
long long a, b, c;
};
vector<triple> lol;
void solve() {
long long n = 2 * 1e6 + 1;
lol.resize(n);
lol[1] = {1, 0, 0};
for (int i = 2; i <= n - 1; i++) {
lol[i].b = lol[i - 1].a;
lol[i].a = (lol[i - 1].b * 2 + lol[i - 1].a) % mod1;
lol[i].c = ((i > 3 ? lol[i - 3].c : 0) + lol[i - 1].b) % mod1;
}
}
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(0);
;
int t;
solve();
t = 1;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << (lol[n].c * 4) % mod1 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
const long long int mod = 1e9 + 7;
const int s = 2e6 + 10;
long long int dp[s];
int main() {
srand(chrono::steady_clock::now().time_since_epoch().count());
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (long long int i = 3; i <= s; i++) {
dp[i] = (dp[i - 1] + 2 * dp[i - 2] % mod) % mod;
if (i % 3 == 0) dp[i] = (dp[i] + 1) % mod;
}
int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int ans = dp[n] * 4 % mod;
cout << ans << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 2e6 + 10;
const long long MOD = 1e9 + 7;
long long dp[3][MAX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
dp[0][3] = 4, dp[1][3] = 4, dp[2][3] = 4;
for (int i = 4; i < MAX; i++) {
dp[0][i] = (dp[2][i - 1] + 2 * dp[2][i - 2]) % MOD;
dp[1][i] = (dp[2][i - 2] + 2 * dp[2][i - 3] + 2 * dp[2][i - 3] +
4 * dp[2][i - 4] + 4) %
MOD;
dp[2][i] = max(dp[0][i], dp[1][i]);
}
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << dp[2][n] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
long long inf = 1e18;
long long m_inf = INT_MIN;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
std::cout.unsetf(std::ios::fixed);
std::cout.precision(9);
long long t = 1;
cin >> t;
vector<long long> ans(2e6 + 1);
long long sz = 2e6 + 1;
ans[1] = ans[2] = 0;
for (long long i = 3; i < sz; i++) {
ans[i] = (ans[i - 1] + 2 * ans[i - 2]) % mod;
;
if (i % 3 == 0) ans[i] = (ans[i] + 4) % mod;
}
while (t--) {
long long n;
cin >> n;
cout << ans[n] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
void FileIO() {}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int T, n;
const int N = 2001000;
const long long mod = 1e9 + 7;
long long dp[N], flag[N];
int main(void) {
dp[1] = 0, dp[2] = 0, dp[3] = 4, dp[4] = 4;
flag[1] = 0, flag[2] = 0, flag[3] = 1, flag[4] = 0;
for (int i = 5; i <= 2000000; i++) {
dp[i] = (2ll * dp[i - 2] + dp[i - 1]) % mod;
if (!flag[i - 2] && !flag[i - 1]) dp[i] = (dp[i] + 4) % mod, flag[i] = 1;
}
ios::sync_with_stdio(0);
cin.tie(0);
cin >> T;
while (T--) {
cin >> n;
cout << dp[n] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e18;
const int inf = 1e9 + 10;
const int maxN = 2e6 + 10;
const int maxD = 15;
const int maxH = 100;
const int MOD = 1e9 + 7;
int T;
long long F[maxN][3];
long long getmax(long long x, long long y) {
long long d = x - y;
d = (d + MOD) % MOD;
if (d <= 100) {
return x;
} else {
return y;
}
}
int main() {
scanf("%d", &T);
for (int i = 1; i <= 2; i++) {
F[i][0] = F[i][1] = 0;
}
for (int i = 3; i <= 2000000; i++) {
F[i][0] = (getmax(F[i - 1][0], F[i - 1][1]) +
getmax(F[i - 2][0], F[i - 2][1]) * 2 % MOD) %
MOD;
F[i][1] = (4 + F[i - 1][0] + F[i - 2][0] * 2 % MOD) % MOD;
}
while (T--) {
int n;
scanf("%d", &n);
long long ans = getmax(F[n][0], F[n][1]);
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr size_t MAX_N = 2000001;
constexpr long long MODULUS = (1e9 + 7);
int memoT[MAX_N];
int memoF[MAX_N];
int ans(int i, bool disallow_occupy) {
if (i <= 2) return 0;
if (i == 3) {
if (disallow_occupy) return 0;
return 4;
}
if (i == 4) return 4;
if (disallow_occupy && memoT[i] != -1) return memoT[i];
if (!disallow_occupy && memoF[i] != -1) return memoF[i];
int choice1 = (2LL * ans(i - 2, true) + ans(i - 1, true) + 4) % MODULUS;
if (disallow_occupy) choice1 = -999;
int choice2 = (2LL * ans(i - 2, false) + ans(i - 1, false)) % MODULUS;
choice2 = choice2 % MODULUS;
if (disallow_occupy) {
return memoT[i] = choice2;
} else {
return memoF[i] = max(choice1, choice2);
}
}
int main() {
for (int i = 0; i < MAX_N; i++) {
memoT[i] = -1;
memoF[i] = -1;
}
for (int i = 5; i < MAX_N; i++) {
ans(i, true);
ans(i, false);
}
int T;
cin >> T;
while (T-- > 0) {
int n;
cin >> n;
cout << " " << max(ans(n, true), ans(n, false)) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
long long g[2000001];
int main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
long long pprev, prev = 1, cur = 1;
g[0] = 0;
g[1] = 1;
g[2] = 1;
for (int i = 3; i < 2000001; i++) {
pprev = cur;
cur = (cur + 2 * prev) % INF;
prev = pprev;
g[i] = g[i - 3] + cur;
g[i] %= INF;
}
while (t--) {
int n;
cin >> n;
long long ans = (g[n - 2] * 4LL) % INF;
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 2000000 + 5;
const long long mod = 1000000000 + 7;
const long long LMT = 100000000;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long binpow(long long a, long long b, long long m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
long long f[MAX], in[MAX], iff[MAX];
void fact() {
f[0] = f[1] = 1;
for (long long i = 2; i < MAX; i++) f[i] = (f[i - 1] * i) % mod;
in[0] = 1, in[1] = 1;
for (long long i = 2; i < MAX; i++)
in[i] = mod - (mod / i) * in[mod % i] % mod;
iff[0] = 1;
for (long long i = 1; i < MAX; i++) iff[i] = (in[i] * iff[i - 1]) % mod;
}
long long dp[MAX];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
cin >> t;
dp[0] = dp[1] = dp[2] = 0;
dp[3] = 4;
for (long long i = 4; i < MAX; i++) {
dp[i] = (2 * dp[i - 2] + dp[i - 1]) % mod;
if (i % 3 == 0) dp[i] = (dp[i] + 4) % mod;
}
while (t--) {
long long n;
cin >> n;
cout << dp[n] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
long long res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y = y / 2;
if (y != 0) x = (x * x) % 1000000007;
}
return res;
}
long long ans[2000005], n0[2000005], n1[2000005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t, n, i, j;
cin >> t;
n0[1] = 1, n1[1] = 0, ans[0] = ans[1] = ans[2] = 0, ans[3] = 1;
for (i = 2; i <= 2000000; i++) {
n0[i] = 2 * n1[i - 1] + n0[i - 1];
n0[i] = n0[i] % 1000000007;
n1[i] = n0[i - 1];
if (i >= 4) {
ans[i] = n1[i - 1] + ans[i - 3];
ans[i] = ans[i] % 1000000007;
}
}
while (t--) {
cin >> n;
cout << (4 * ans[n]) % 1000000007 << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
inline int qread() {
register char c =
(p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
register int x = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + c - 48;
c = (p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2)
? EOF
: *p1++);
}
return x * f;
}
inline int Abs(const int& x) { return (x > 0 ? x : -x); }
inline int Max(const int& x, const int& y) { return (x > y ? x : y); }
inline int Min(const int& x, const int& y) { return (x < y ? x : y); }
const long long mod = 1000000007;
int n, t;
long long f[2000050];
inline void Prefix() {
f[3] = 4;
f[4] = 4;
f[5] = 12;
for (register int i = 5; i <= 2000020; i += 6) {
f[i + 1] = f[i] * 2 % mod;
f[i + 2] = f[i + 1] * 2 % mod;
f[i + 3] = f[i + 2] * 2 % mod;
f[i + 4] = (f[i + 3] * 2 + 4) % mod;
f[i + 5] = (f[i + 3] * 4 + 4) % mod;
f[i + 6] = (f[i + 3] * 8 + 12) % mod;
}
}
int main() {
Prefix();
t = qread();
while (t--) {
n = qread();
printf("%lld\n", f[n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mx = 2000002;
long long dp[mx];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
cin >> t;
dp[3] = 4;
dp[4] = 4;
long long mod = pow(10, 9) + 7;
for (long long i = 5; i < mx; i++) {
long long x = 4 * dp[i - 3];
x %= mod;
x += (4 * dp[i - 4]) % mod;
x %= mod;
x += dp[i - 2];
x %= mod;
x += 4;
x %= mod;
dp[i] = x;
x = 2 * dp[i - 2] + dp[i - 1];
x %= mod;
dp[i] = max(dp[i], x);
}
while (t--) {
long long n;
cin >> n;
cout << dp[n] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 5, mod = 1e9 + 7;
long long t, n, dp[N], res[N], gg[N];
int main() {
cin.tie(0);
cout.tie(0);
ios_base ::sync_with_stdio();
dp[1] = dp[2] = 1;
for (int i = 3; i <= 2000000; i++) {
dp[i] = 2 * dp[i - 2] + dp[i - 1];
dp[i] %= mod;
}
res[1] = res[2] = 0;
res[3] = res[4] = 4;
res[5] = 12;
gg[1] = dp[1] * 4;
gg[2] = dp[2] * 4;
for (int i = 3; i <= 5; i++) gg[i] = gg[i - 3] + dp[i] * 4;
for (int i = 6; i <= 2000000; i++) {
res[i] = dp[i - 2] * 4 + gg[i - 5];
gg[i] = gg[i - 3] + dp[i] * 4;
res[i] %= mod;
}
cin >> t;
while (t--) {
cin >> n;
cout << res[n] << "\n";
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.