text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e6 + 10;
const long long mod = 1e9 + 7;
int t, n;
bool add[maxn];
long long cnt[maxn];
int main() {
add[1] = add[2] = false;
cnt[1] = cnt[2] = 0;
for (int i = 3; i <= maxn - 10; i++) {
cnt[i] = (2 * cnt[i - 2] + cnt[i - 1]) % mod;
if (!add[i - 2] && !add[i - 1])
cnt[i] += 1, add[i] = true;
else
add[i] = false;
}
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
printf("%lld\n", 4 * cnt[n] % mod);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2000001];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
dp[0] = 0;
dp[1] = 0;
dp[2] = 0;
dp[3] = 4;
for (long long i = 4; i <= 2000000; i++) {
dp[i] = max((4 * dp[i - 4] + 4 + 4 * dp[i - 3] + dp[i - 2]) % 1000000007,
(2 * dp[i - 2] + dp[i - 1]) % 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;
long long maxn = 2000000;
vector<long long> br(maxn + 1), ans(maxn + 1), sm(maxn + 1);
void preprocess() {
ans[1] = 0, br[1] = 0, sm[1] = 0;
ans[2] = 0, br[2] = 1, sm[2] = 0;
ans[3] = 1, br[3] = 1, sm[3] = 2;
for (long long i = 4; i <= maxn; i++) {
ans[i] = (ans[i - 3] + br[i - 1]) % 1000000007;
br[i] = (sm[i - 1] + br[i - 1]) % 1000000007;
sm[i] = (2 * br[i - 1]) % 1000000007;
}
}
void aksayushx() {
long long n;
cin >> n;
cout << (ans[n] * 4) % 1000000007 << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
preprocess();
cin >> t;
while (t--) aksayushx();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
void ran() { srand(chrono::steady_clock::now().time_since_epoch().count()); }
long long get_rand() {
long long a = rand();
long long b = rand();
return a * (RAND_MAX + 1ll) + b;
}
long long MOD = 1000 * 1000 * 1000 + 7;
const long long n = 2000000;
long long dp[n + 1];
signed main() {
ran();
fast();
dp[0] = 0;
dp[1] = 0;
dp[2] = 0;
dp[3] = 4;
dp[4] = 4;
for (long long i = 5; i <= n; i++) {
dp[i] = 1 * dp[i - 1] + 2 * dp[i - 2];
if (i % 3 == 0) dp[i] += 4;
dp[i] %= MOD;
}
long long t;
cin >> t;
while (t--) {
long long x;
cin >> x;
cout << dp[x] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int t, n;
const int M = 1e9 + 7;
long long N = 2000005;
long long dp[2000005];
void solve() {
dp[0] = 0;
dp[1] = 0;
dp[2] = 0;
for (int i = 3; i < N; i++) {
dp[i] = (2 * dp[i - 2] + dp[i - 1]) % M;
if (i % 3 == 0) dp[i] = (dp[i] + 4) % M;
}
}
int main() {
std::ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
solve();
cin >> t;
while (t--) {
cin >> n;
cout << dp[n] << endl;
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3", "unroll-loops")
#pragma GCC target("sse4.2")
using namespace std;
mt19937 gen(chrono::high_resolution_clock::now().time_since_epoch().count());
template <class T, class U>
inline bool chmax(T &x, U y) {
return x < y ? x = y, 1 : 0;
}
template <class T, class U>
inline bool chmin(T &x, U y) {
return x > y ? x = y, 1 : 0;
}
template <class T>
inline void sort(T &a) {
sort((a).begin(), (a).end());
}
template <class T>
inline void rsort(T &a) {
sort((a).rbegin(), (a).rend());
}
template <class T>
inline void reverse(T &a) {
reverse((a).begin(), (a).end());
}
template <class T, class U>
inline istream &operator>>(istream &str, pair<T, U> &p) {
return str >> p.first >> p.second;
}
template <class T>
inline istream &operator>>(istream &str, vector<T> &a) {
for (auto &i : a) str >> i;
return str;
}
template <class T>
inline T sorted(T a) {
sort(a);
return a;
}
void read() {}
void print() {}
void println() { cout << '\n'; }
template <class T, class... U>
void read(T &x, U &...u) {
cin >> x;
read(u...);
}
template <class T, class... U>
void print(const T &x, const U &...u) {
cout << x;
print(u...);
}
template <class T, class... U>
void println(const T &x, const U &...u) {
cout << x;
println(u...);
}
struct zet {
int val;
explicit operator int() const { return val; }
zet(long long x = 0) {
val = (x >= -1000000007 && x < 1000000007 ? x : x % 1000000007);
if (val < 0) val += 1000000007;
}
zet(long long a, long long b) {
*this += a;
*this /= b;
}
zet &operator+=(zet const &b) {
val += b.val;
if (val >= 1000000007) val -= 1000000007;
return *this;
}
zet &operator-=(zet const &b) {
val -= b.val;
if (val < 0) val += 1000000007;
return *this;
}
zet &operator*=(zet const &b) {
val = (val * (long long)b.val) % 1000000007;
return *this;
}
friend zet mypow(zet a, long long n) {
zet res = 1;
while (n) {
if (n & 1) res *= a;
a *= a;
n >>= 1;
}
return res;
}
friend zet inv(zet a) { return mypow(a, 1000000007 - 2); }
zet &operator/=(zet const &b) { return *this *= inv(b); }
friend zet operator+(zet a, const zet &b) { return a += b; }
friend zet operator-(zet a, const zet &b) { return a -= b; }
friend zet operator-(zet a) { return 0 - a; }
friend zet operator*(zet a, const zet &b) { return a *= b; }
friend zet operator/(zet a, const zet &b) { return a /= b; }
friend istream &operator>>(istream &stream, zet &a) {
return stream >> a.val;
}
friend ostream &operator<<(ostream &stream, const zet &a) {
return stream << a.val;
}
friend bool operator==(zet const &a, zet const &b) { return a.val == b.val; }
friend bool operator!=(zet const &a, zet const &b) { return a.val != b.val; }
friend bool operator<(zet const &a, zet const &b) { return a.val < b.val; }
};
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(12);
const int n = 2e6 + 10;
vector<zet> ans(n);
for (int i = 2; i < n; i += 6) ans[i] = 4;
for (int i = 3; i < n; i += 6) ans[i] = -4;
for (int i = 4; i < n; i += 6) ans[i] = 4;
for (int i = 1; i < n; ++i) ans[i] += 2 * ans[i - 1];
int t;
read(t);
while (t--) {
int N;
read(N);
println(ans[N - 1]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int pow(long long int x, long long int y, long long int m) {
long long int res = 1;
x = x % m;
while (y > 0) {
if (y & 1) res = ((res % m) * (x % m)) % m;
y = y >> 1;
x = ((x % m) * (x % m)) % m;
}
return res % m;
}
template <typename Arg1>
void ZZ(const char* name, Arg1&& arg1) {
std::cerr << name << " = " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void ZZ(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " = " << arg1;
ZZ(comma, args...);
}
const long long int INF = 0xFFFFFFFFFFFFFFFL;
long long int clz(unsigned long long N) {
return N ? 64LL - __builtin_clzll(N) : -INF;
}
clock_t time_p = clock();
void abhigyan10() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
long long int seed;
mt19937 rng(seed = chrono::steady_clock::now().time_since_epoch().count());
inline long long int rnd(long long int l = 0, long long int r = INF) {
return uniform_int_distribution<long long int>(l, r)(rng);
}
const long long int mod = 1000000007;
long long int modinv(long long int x) { return pow(x, mod - 2, mod); }
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, q, n;
vector<long long int> dp(2000006), cl(2000006);
dp[1] = 0, dp[2] = 0, dp[3] = 4;
cl[3] = 1;
cl[2] = 0;
cl[0] = 0;
for (i = 4; i <= 2000000; i++) {
cl[i] = cl[i - 1] + cl[i - 2] * 2;
cl[i] %= mod;
dp[i] = dp[i - 3] + (cl[i]) * 4;
dp[i] %= mod;
}
cin >> q;
while (q--) {
cin >> n;
cout << dp[n] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> a;
long long m = 1e9 + 7;
void fill() {
int mx = 2 * (1e6) + 1;
a.resize(mx);
a[0] = 0;
a[1] = 0;
a[2] = 0;
a[3] = 0;
for (int i = 3; i < mx; ++i)
a[i] = ((a[i - 2] * 2) % m + a[i - 1]) % m + (i % 3 == 0 ? 4 : 0);
}
int main() {
std::ios_base::sync_with_stdio(false);
int t, n;
cin >> t;
fill();
for (int x = 0; x < t; ++x) {
cin >> n;
long long sum = a[n];
cout << sum << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int t, n, ans[2000001], tag[2000001];
int main() {
cin >> t;
ans[1] = 0, ans[2] = 0, ans[3] = 4, ans[4] = 4, ans[5] = 12;
tag[1] = 0, tag[2] = 0, tag[3] = 1, tag[4] = 0, tag[5] = 0;
for (long long int i = 6; i <= 2000000; i += 1) {
ans[i] = ans[i - 1] + 2 * ans[i - 2];
ans[i] %= 1000000007;
if (tag[i - 1] || tag[i - 2]) {
tag[i] = 0;
continue;
}
tag[i] = 1;
ans[i] += 4;
ans[i] %= 1000000007;
}
while (t--) {
cin >> n;
cout << ans[n] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<long long> dp(2000005, 0);
dp[3] = 1;
dp[4] = 1;
for (long long i = 5; i < 2000005; i++) {
if (i % 3 != 0)
dp[i] = (dp[i - 1] + (2 * dp[i - 2]) % 1000000007) % 1000000007;
else
dp[i] = (dp[i - 1] + ((2 * dp[i - 2]) % 1000000007) + 1) % 1000000007;
}
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << (4 * dp[n]) % 1000000007 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323846;
long long mod = 1000000007;
long long dp[20000001];
long long fun(long long n) {
if (n <= 2) {
dp[n] = 0;
return dp[n];
}
if (n == 3) {
dp[n] = 4;
return dp[n];
}
if (dp[n] != -1) return dp[n] % mod;
dp[n] = ((fun(n - 1) % mod) + (2 * (fun(n - 2) % mod)) % mod) % mod;
if (n % 3 == 0) dp[n] = (dp[n] + 4) % mod;
return dp[n] % mod;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
cin >> t;
for (long long i = 0; i <= 20000000; i++) dp[i] = -1;
dp[1] = dp[2] = 0;
dp[3] = 4;
for (long long i = 4; i <= 2000000; i++) {
dp[i] = (dp[i - 1] + ((2 * (dp[i - 2] % mod)) % mod)) % mod;
if (i % 3 == 0) {
dp[i] = (dp[i] + 4) % mod;
}
}
while (t--) {
long long n, k;
cin >> n;
cout << dp[n] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mo = 1000000007;
int T, n;
long long f[2][2000005 + 2];
int main() {
for (int i = 3; i <= 2000005; i++) {
f[0][i] = f[1][i - 1] + f[1][i - 2] * 2;
f[1][i] = f[0][i - 1] + f[0][i - 2] * 2 + 1;
f[1][i] = max(f[1][i], f[0][i]);
f[0][i] %= mo;
f[1][i] %= mo;
}
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
printf("%lld\n", f[1][n] * 4 % mo);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> dp(2000005, 0);
void calc() {
dp[1] = dp[2] = 0;
dp[3] = dp[4] = 1;
for (long long i = 5; i <= 2000005; i++) {
dp[i] = max((1 + dp[i - 2] + 4 * dp[i - 3] + 4 * dp[i - 4]) % 1000000007,
(dp[i - 1] + 2 * dp[i - 2]) % 1000000007);
}
cout << endl;
}
void solve() {
long long n;
cin >> n;
cout << (dp[n] * 4) % 1000000007 << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
calc();
int t = 1, i;
if (1) cin >> t;
for (i = 1; i <= t; i++) solve();
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs"
<< "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
signed main() {
ll t;
cin >> t;
vector<ll> dp(2000005);
dp[1] = 0;
dp[2] = 0;
dp[3] = 1;
for (ll i = 4; i <= 2000005; i++) {
dp[i] = ((2 * dp[i - 2]) % 1000000007 + dp[i - 1] + (i % 3 == 0 ? 1 : 0)) %
1000000007;
}
while (t--) {
ll n;
cin >> n;
cout << (4 * dp[n]) % 1000000007 << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long countbit(long long a) {
long long c = 0;
while (a) {
if (a & 1) c++;
a >>= 1;
}
return (c);
}
long long power(long long a, long long p, long long m = 1000000007) {
a %= m;
long long val = 1;
while (p > 0) {
if (p & 1) {
val = (val * a) % m;
}
a = (a * a) % m;
p >>= 1;
}
return (val);
}
int count(unsigned long long a) {
int k = 0;
if (a == 0) return 0;
while (a) {
a >>= 1;
k++;
}
return k - 1;
}
bool comp1(pair<int, int>& a, pair<int, int>& b) {
if (a.first == b.first) return a.second < b.second;
return a.first > b.first;
}
bool comp2(pair<int, int>& a, pair<int, int>& b) {
if (a.second == b.second) return a.first > b.first;
return a.second < b.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, i, j;
std::vector<long long> sol(2000001);
sol[0] = sol[1] = sol[2] = 0;
sol[3] = 1;
long long fs = 3, fs2;
long long ss = 1, ss2;
for (i = 4; i <= 2000000; ++i) {
sol[i] = (sol[i - 3] + ss) % 1000000007;
fs2 = 2 * ss + fs;
ss2 = fs;
fs = fs2 % 1000000007;
ss = ss2 % 1000000007;
}
long long T = 1;
cin >> T;
while (T--) {
int n;
cin >> n;
if (n < 3) {
cout << "0\n";
} else {
long long p = sol[n];
p = (p + p) % 1000000007;
p = (p + p) % 1000000007;
cout << p << "\n";
}
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("unroll-loops")
#pragma GCC target("avx,avx2,fma")
using namespace std;
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
void _print() { cout << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
cout << t;
if (sizeof...(v)) cout << ", ";
_print(v...);
}
using ll = long long int;
using ld = long double;
template <typename T, typename V>
using P = pair<T, V>;
template <typename T>
using V = vector<T>;
constexpr ll MOD = 1e9 + 7;
constexpr ll INF = 0x3f3f3f3f;
constexpr ld PI = 3.1415926535897932384626;
constexpr ld EPS = 1e-9;
constexpr ll MAX = 2e6 + 5;
ll dp[MAX];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
for (ll i = (ll)(3); i < (ll)(MAX); i++)
dp[i] = (2 * dp[i - 2] + dp[i - 1] + 4 * (i % 3 == 0)) % MOD;
ll t, n;
cin >> t;
while (t--) {
cin >> n;
cout << dp[n] << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2000010], v[2000010];
int main() {
for (int i = 3; i <= 2000000; i++) {
dp[i] =
(dp[i - 1] + 2 * dp[i - 2] + 4 * (!v[i - 1] && !v[i - 2])) % 1000000007;
v[i] = !v[i - 1] && !v[i - 2];
}
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf(" %d", &n);
printf("%I64d\n", dp[n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2000001];
int sauske() {
int n;
cin >> n;
cout << dp[n] % 1000000007 << "\n";
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
dp[0] = 0;
dp[1] = 0;
dp[2] = 0;
dp[3] = 4;
dp[4] = 4;
for (int i = 5; i < 2000001; i++) {
dp[i] = (dp[i - 1] + (2 * dp[i - 2]) % 1000000007 + (i % 3 == 0 ? 4 : 0)) %
1000000007;
}
cin >> t;
while (t--) sauske();
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
const int MAXN = 2e6 + 5;
auto mult = [&](int a, int b) { return (int)((long long)a * b % MOD); };
vector<int> dp(MAXN);
for (int i = 2; i < MAXN; i++) {
dp[i] = mult(dp[i - 2], 2) + dp[i - 1];
if (i % 3 == 2) {
dp[i] += 4;
}
dp[i] %= MOD;
}
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
cout << dp[n - 1] << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int n, m, t, mod = 1000000007;
long long int dp[2000006][2];
int main() {
for (int i = 3; i <= 2000000; i++) {
dp[i][1] = (2 * dp[i - 2][0] + dp[i - 1][0] + 4) % mod;
dp[i][0] = (2 * max(dp[i - 2][1], dp[i - 2][0]) +
max(dp[i - 1][0], dp[i - 1][1])) %
mod;
}
cin >> t;
while (t--) {
cin >> n;
cout << max(dp[n][0], dp[n][1]) << endl;
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
void init() {}
void _print(long long int t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long int 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 << "]";
}
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 int round_up(long long int a, long long int b) {
return (a + b - 1) / b;
}
long long int gcd(long long int a, long long int b) {
if (b > a) {
return gcd(b, a);
}
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long int expo(long long int a, long long int b, long long int mod) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b = b >> 1;
}
return res;
}
void extendgcd(long long int a, long long int b, long long int *v) {
if (b == 0) {
v[0] = 1;
v[1] = 0;
v[2] = a;
return;
}
extendgcd(b, a % b, v);
long long int x = v[1];
v[1] = v[0] - v[1] * (a / b);
v[0] = x;
return;
}
long long int mminv(long long int a, long long int b) {
long long int arr[3];
extendgcd(a, b, arr);
return arr[0];
}
long long int mminvprime(long long int a, long long int b) {
return expo(a, b - 2, b);
}
bool revsort(long long int a, long long int b) { return a > b; }
void swap(int &x, int &y) {
int temp = x;
x = y;
y = temp;
}
long long int combination(long long int n, long long int r, long long int m,
long long int *fact, long long int *ifact) {
long long int val1 = fact[n];
long long int val2 = ifact[n - r];
long long int val3 = ifact[r];
return (((val1 * val2) % m) * val3) % m;
}
void google(int t) { cout << "Case #" << t << ": "; }
vector<long long int> sieve(int n) {
int *arr = new int[n + 1]();
vector<long long int> vect;
for (int i = 2; i <= n; i++)
if (arr[i] == 0) {
vect.push_back(i);
for (int j = 2 * i; j <= n; j += i) arr[j] = 1;
}
return vect;
}
long long int mod_add(long long int a, long long int b, long long int m) {
a = a % m;
b = b % m;
return (((a + b) % m) + m) % m;
}
long long int mod_mul(long long int a, long long int b, long long int m) {
a = a % m;
b = b % m;
return (((a * b) % m) + m) % m;
}
long long int mod_sub(long long int a, long long int b, long long int m) {
a = a % m;
b = b % m;
return (((a - b) % m) + m) % m;
}
long long int mod_div(long long int a, long long int b, long long int m) {
a = a % m;
b = b % m;
return (mod_mul(a, mminvprime(b, m), m) + m) % m;
}
void solve() {
int t;
cin >> t;
int const N = 2e6 + 10;
vector<long long int> dp(N, 0);
dp[3] = 1;
dp[4] = 1;
for (long long int i = 5; i <= 2e6; i++) {
long long int temp1 = mod_mul(2, dp[i - 2], 1000000007);
temp1 = mod_add(temp1, dp[i - 1], 1000000007);
if (i % 3 == 0) temp1 = mod_add(temp1, 1, 1000000007);
dp[i] = temp1;
}
while (t--) {
int n;
cin >> n;
cout << mod_mul(4, dp[n], 1000000007) << "\n";
}
}
int main() {
init();
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[2000001][2];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int tc;
cin >> tc;
for (int i = 3; i <= 2000000; i++) {
dp[i][0] = ((2 * max(dp[i - 2][0], dp[i - 2][1])) % 1000000007 +
max(dp[i - 1][0], dp[i - 1][1])) %
1000000007;
dp[i][1] =
(((2 * dp[i - 2][0]) % 1000000007 + dp[i - 1][0]) % 1000000007 + 1) %
1000000007;
}
while (tc--) {
int n;
cin >> n;
cout << (max(dp[n][0], dp[n][1]) * 4) % 1000000007 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 7;
const long long mod = 1e9 + 7;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
vector<long long> dp(N);
dp[0] = 0;
dp[1] = 0;
dp[2] = 0;
dp[3] = 4;
for (long long i = 4; i < N; i++) {
long long val = dp[i - 1];
val += 2 * dp[i - 2];
val += (i % 3 != 0 ? 0 : 4);
val %= mod;
dp[i] = val;
}
long long tt = 1;
cin >> tt;
while (tt--) {
long long n;
cin >> n;
cout << dp[n] % mod << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 2e6 + 5, M = 20 + 5, MOD = 1e9 + 7, OO = 0x3f3f3f3f;
int t, n;
long long ans[N];
int main() {
scanf("%d", &t);
ans[1] = 0;
ans[2] = 4;
for (int i = 3; i <= 2e6; i++)
ans[i] = (2 * ans[i - 2] + ans[i - 1] + (i % 3 == 2) * 4) % MOD;
while (t--) {
scanf("%d", &n);
printf("%I64d\n", ans[--n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
long long f[2000005], s[2000005];
void init() {
f[1] = s[1] = f[2] = s[2] = 1;
for (int i = 3; i < 2000005; i++)
f[i] = (f[i - 1] + f[i - 2] * 2) % ((long long)1e9 + 7);
for (int i = 3; i < 2000005; i++)
s[i] = (s[i - 3] + f[i]) % ((long long)1e9 + 7);
}
int main() {
init();
int T;
cin >> T;
while (T--) {
scanf("%d", &n);
if (n <= 2)
puts("0");
else
printf("%lld\n", s[n - 2] * 4 % ((long long)1e9 + 7));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int nt;
cin >> nt;
long long* ones = new long long[2000010];
long long* zeros = new long long[2000010];
long long* ans = new long long[2000010];
ones[0] = 0;
ones[1] = 0;
ones[2] = 1;
zeros[0] = 0;
zeros[1] = 1;
zeros[2] = 1;
ans[0] = 0;
ans[1] = 0;
ans[2] = 0;
ans[3] = 1;
for (int i = 3; i < 2000010; i++) {
zeros[i] = (2 * ones[i - 1] + zeros[i - 1]) % 1000000007;
ones[i] = zeros[i - 1];
ans[i] = (ans[i - 3] + zeros[i - 2]) % 1000000007;
}
while (nt--) {
int numn;
cin >> numn;
if (numn == 3) {
cout << 4 << endl;
continue;
}
int res = ((ans[numn]) * 4) % 1000000007;
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10, mod = 1e9 + 7;
long long dp[N][2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
for (int i = 3; i <= N; i++) {
int ans1, ans2;
ans1 = (dp[i - 1][1] + 4 + (2 * dp[i - 2][1]) % mod) % mod;
ans2 = (dp[i - 1][0] + (2 * dp[i - 2][0]) % mod) % mod;
dp[i][0] = max(ans1, ans2);
dp[i][1] = ans2;
}
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
cout << dp[n][0] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int dp[2000005];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, k, n, t;
cin >> t;
dp[3] = 1;
for (i = 4; i <= 2000000; i++) {
long long int temp1 =
(1 + (4 * dp[i - 4]) % mod + (4 * dp[i - 3]) % mod + dp[i - 2] % mod) %
mod;
long long int temp2 = ((2 * dp[i - 2]) % mod + dp[i - 1] % mod) % mod;
dp[i] = max(temp1, temp2);
}
while (t--) {
cin >> n;
cout << (4 * dp[n]) % mod << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
void solve() {
vector<long long> d(2 * 1000001);
d[0] = d[1] = d[2] = 0;
d[3] = 4;
for (int i = 4; i < d.size(); i++) {
d[i] = (i % 3 != 0 ? d[i - 1] + 2 * d[i - 2]
: 4 + (d[i - 2] + 2 * d[i - 3]) +
2 * (2 * d[i - 4] + d[i - 3])) %
mod;
}
int q;
cin >> q;
while (q--) {
int val;
cin >> val;
cout << d[val] << "\n";
}
}
int main() {
ios::sync_with_stdio(false);
int t;
t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_v = 2000000;
const long long mod = 1000000007LL;
long long dp[max_v + 5];
int n;
void solve(void);
void init(void);
int main(void) {
int t;
scanf("%d", &t);
init();
while (t--) solve();
return 0;
}
void solve(void) {
scanf("%d", &n);
printf("%lld\n", (4LL * dp[n]) % mod);
}
void init(void) {
dp[3] = 1LL;
dp[4] = 1LL;
int i;
for (i = 5; i <= max_v; i++) {
dp[i] = (dp[i - 1] + 2LL * dp[i - 2] + ((i % 3) ? 0 : 1LL)) % mod;
}
}
|
#include <bits/stdc++.h>
const long long DIV = 1e9 + 7;
using namespace std;
long long T, n, k;
long long born[2000001], sec1[2000001], sec2[2000001];
long long dp[2000001];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> T;
born[1] = 1;
for (int i = 2; i <= 2000000; i++) {
born[i] = (born[i - 1] + sec1[i - 1] * 2) % DIV;
sec1[i] = born[i - 1] % DIV;
sec2[i] = sec1[i - 1] % DIV;
}
for (int i = 3; i <= 2000000; i++) {
dp[i] = (dp[i - 3] + sec2[i] * 4) % DIV;
}
while (T--) {
cin >> n;
cout << dp[n] << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323846;
long long binpow(long long, long long);
long long mult(long long, long long);
long long add(long long, long long);
long long division(long long, long long);
long long nCr(long long, long long);
long long inv(long long);
void calc();
template <class T>
istream &operator>>(istream &is, vector<T> &v) {
for (T &x : v) is >> x;
return is;
}
template <class T>
ostream &operator<<(ostream &os, const vector<T> &v) {
if (!v.empty()) {
os << v.front();
for (int i = 1; i < v.size(); ++i) os << ' ' << v[i];
}
return os;
}
const int N = 1000005;
long long fact[N];
void solve() {
long long n;
cin >> n;
cout << (fact[n] - binpow(2, n - 1) + 1000000007) % 1000000007;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
calc();
for (long long i = 0; i < t; i++) {
solve();
cout << "\n";
}
return 0;
}
long long add(long long a, long long b) {
a += b;
while (a >= 1000000007) a -= 1000000007;
while (a < 0) a += 1000000007;
return a;
}
long long mult(long long a, long long b) { return (a * 1ll * b) % 1000000007; }
long long binpow(long long a, long long b) {
long long c = 1;
while (b > 0) {
if (b % 2 == 1) c = mult(c, a);
a = mult(a, a);
b /= 2;
}
return c;
}
long long inv(long long a) { return binpow(a, 1000000007 - 2); }
long long division(long long a, long long b) { return mult(a, inv(b)); }
void calc() {
fact[0] = 1;
for (long long i = 1; i <= N - 1; i++)
fact[i] = (i * 1ll * fact[i - 1]) % 1000000007;
}
|
#include <bits/stdc++.h>
using namespace std;
using lnt = long long;
using Real = long double;
constexpr int dx[] = {1, 0, -1, 0, 1, 1, -1, -1},
dy[] = {0, -1, 0, 1, 1, -1, 1, -1};
constexpr Real eps = 1e-9;
const Real pi = acosl(-1);
constexpr lnt BIG = INT_MAX / 10, BBIG = LLONG_MAX / 10;
template <class T>
inline T GCD(T a, T b) {
T c;
while (b != 0) {
c = a % b;
a = b;
b = c;
}
return a;
}
template <class T>
inline T LCM(T a, T b) {
T c = GCD(a, b);
a /= c;
return a * b;
}
template <class T>
inline T nCr(T a, T b) {
T i, r = 1;
for (i = 1; i <= b; i++) {
r *= (a + 1 - i);
r /= i;
}
return r;
}
template <class T>
inline T nHr(T a, T b) {
return nCr(a + b - 1, b);
}
template <class T>
inline bool chmax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using pint = pair<int, int>;
using plnt = pair<lnt, lnt>;
using vint = vector<int>;
using vlnt = vector<lnt>;
constexpr lnt MOD = 1e9 + 7;
lnt fact[1000010], invfact[1000010];
lnt invmod(lnt a, lnt p) {
lnt b = p, u = 1, v = 0;
while (b) {
lnt t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
u %= p;
if (u < 0) u += p;
return u;
}
void factmod(lnt m) {
fact[0] = invfact[0] = 1;
for (lnt i = 1; i < 1000010; i++) {
fact[i] = (fact[i - 1] * i) % m;
invfact[i] = (invfact[i - 1] * invmod(i, m)) % m;
}
}
lnt nCrmod(lnt n, lnt r, lnt m) {
return (((fact[n] * invfact[r]) % m) * invfact[n - r]) % m;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
lnt N;
cin >> N;
factmod(MOD);
lnt ans = fact[N];
lnt minus = 0;
for (lnt i = 0; i < (N); ++i) {
lnt num;
if (i == N - 1 - i) {
num = nCrmod(N - 1, i, MOD);
} else {
num = nCrmod(N - 1, i, MOD);
}
num %= MOD;
minus += num;
minus %= MOD;
}
ans += MOD;
ans -= minus;
ans %= MOD;
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cout << x; }
void __print(long x) { cout << x; }
void __print(long long x) { cout << x; }
void __print(unsigned x) { cout << x; }
void __print(unsigned long x) { cout << x; }
void __print(unsigned long long x) { cout << x; }
void __print(float x) { cout << x; }
void __print(double x) { cout << x; }
void __print(long double x) { cout << x; }
void __print(char x) { cout << '\'' << x << '\''; }
void __print(const char *x) { cout << '\"' << x << '\"'; }
void __print(const string &x) { cout << '\"' << x << '\"'; }
void __print(bool x) { cout << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cout << '{';
__print(x.first);
cout << ',';
__print(x.second);
cout << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cout << '{';
for (auto &i : x) cout << (f++ ? "," : ""), __print(i);
cout << "}";
}
void _print() { cout << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
while (T--) {
long long int n;
cin >> n;
long long int fac[n];
fac[0] = 1;
for (long long int i = 1; i <= (long long)n - 1; i++)
fac[i] = fac[i - 1] * i % 1000000007;
long long int a[n + 1];
memset(a, 0, sizeof a);
for (long long int i = 3; i <= (long long)n; i++)
a[i] =
((a[i - 1] * 2) % 1000000007 + ((i - 2) * fac[i - 1]) % 1000000007) %
1000000007;
cout << a[n];
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int DX[] = {1, 0, -1, 0, 1, -1, 1, -1};
const int DY[] = {0, 1, 0, -1, 1, -1, -1, 1};
const int md = (int)1e9 + 7;
inline void add(int &a, int b) {
a += b;
if (a >= md) a -= md;
}
inline void sub(int &a, int b) {
a -= b;
if (a < 0) a += md;
}
inline int mul(int a, int b) { return (int)((long long)a * b % md); }
inline int power(int a, long long b) {
int res = 1;
while (b > 0) {
if (b & 1) {
res = mul(res, a);
}
a = mul(a, a);
b >>= 1;
}
return res;
}
inline int inv(int a) {
a %= md;
if (a < 0) a += md;
int b = md, u = 0, v = 1;
while (a) {
int t = b / a;
b -= t * a;
swap(a, b);
u -= t * v;
swap(u, v);
}
assert(b == 1);
if (u < 0) u += md;
return u;
}
int N;
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.precision(10);
cout << fixed;
cin >> N;
int a = 6, b = 4;
for (int i = 4; i <= N; i++) {
a = mul(a, i);
b = mul(b, 2);
}
sub(a, b);
cout << a << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
ostream &operator<<(ostream &out, const pair<A, B> &a) {
return out << "(" << a.first << "," << a.second << ")";
}
template <class A>
ostream &operator<<(ostream &out, const vector<A> &a) {
for (const A &it : a) out << it << " ";
return out;
}
template <class A, class B>
istream &operator>>(istream &in, pair<A, B> &a) {
return in >> a.first >> a.second;
}
template <class A>
istream &operator>>(istream &in, vector<A> &a) {
for (A &i : a) in >> i;
return in;
}
ifstream cinn("in.txt");
ofstream coutt("out.txt");
long long poww(const long long &a, long long b,
const long long &m = 1000000007) {
if (b == 0) return 1;
long long first = poww(a, b / 2, m);
first = first * first % m;
if (b & 1) first = first * a % m;
return first;
}
long long gcd(long long a, long long b) {
if (a > b) swap(a, b);
if (a == 0) return b;
return gcd(b % a, a);
}
bool mod(long double a, long double b) { return a / b - floor(a / b); }
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long i, j, first, n;
cin >> n;
first = poww(2, n - 1);
long long f = 1;
for (i = 2; i < n + 1; i++) {
f = f * i;
f %= 1000000007;
}
cout << (f + 1000000007 - first) % 1000000007 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
long long n, a, b;
int main() {
scanf("%lld", &n);
a = 1, b = 1;
for (int i = 2; i <= n; ++i) a = a * i % mod, b = b * 2 % mod;
printf("%lld\n", (a - b + mod) % mod);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int m = 1000000007;
void solve() {
long long int n;
cin >> n;
long long int sum = 1, power[n + 1];
power[0] = 1;
power[1] = 2;
for (long long int i = 2; i < n + 1; i++) {
sum = (sum * i) % m;
power[i] = (power[i - 1] * 2) % m;
}
long long int ans = (sum - power[n - 1] + m) % m;
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long modFact(long long n, long long p) {
if (n >= p) return 0;
long long result = 1;
for (long long i = 1; i <= n; i++) result = ((result % p) * (i % p)) % p;
return result;
}
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;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n;
cin >> n;
long long p = 1000000007;
long long ans = (modFact(n, p) - power(2, n - 1, p) + p) % p;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int a[102][102];
const ll MOD = 1e9 + 7;
ll fact(ll x) {
if (x == 0) return 1;
ll ret = 1;
while (x > 0) {
ret *= x;
ret %= MOD;
x--;
}
return ret;
}
ll mypow(ll x) {
ll ret = 1;
while (x > 0) {
ret *= 2;
ret %= MOD;
x--;
}
return ret;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n;
cin >> n;
bool div2 = false;
bool div3 = false;
ll ret = fact(n);
ll p = mypow(n - 1);
ret += (MOD - p);
ret %= MOD;
cout << ret << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long int fact[1000005], pow2[1000005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
fact[0] = 1;
pow2[0] = 1;
for (int i = 1; i <= 1000005 - 1; i++) {
fact[i] = fact[i - 1] * i;
fact[i] %= 1000000007LL;
pow2[i] = 2 * pow2[i - 1];
pow2[i] %= 1000000007LL;
}
long long int x;
cin >> x;
cout << (fact[x] - pow2[x - 1] + 1000000007LL) % 1000000007LL << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long const M = 1000000007;
long long fpow(long long b, long long e) {
if (e == 0) return 1LL;
if (e == 1) return b;
if (e & 1LL) return b * fpow(b, e - 1) % M;
long long temp = fpow(b, e / 2LL);
return temp * temp % M;
}
void solvetask() {
long long n;
cin >> n;
long long ans = 1;
for (long long i = 2; i <= n; i++) ans = ans * i % M;
cout << (ans - fpow(2, n - 1) + M) % M << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t = 1;
while (t--) solvetask();
}
|
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i += 6) {
if ((n % i == 0) || (n % (i + 2) == 0)) return false;
}
return true;
}
long long mod = 1e9 + 7;
long long powermod(long long x, long long y) {
long long res = 1;
x = x % mod;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res;
}
int32_t main() {
long long t = 1;
while (t--) {
long long n;
cin >> n;
long long r = 1;
long long p = 1;
for (long long i = 2; i <= n; i++) {
r = (r * i) % mod;
p = (p * 2) % mod;
}
cout << (r - p + mod) % mod;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long qpow(long long _b, long long _e) {
return _e == 0 ? 1
: (_e & 1 ? _b : 1) * qpow(_b * _b % 1000000007, _e >> 1) %
1000000007;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long ans = 1;
for (long long i = 2; i <= n; ++i) {
ans = ans * i % 1000000007;
}
cout << (ans + 1000000007 - qpow(2, n - 1)) % 1000000007 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 1, mod = 1e9 + 7;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long ans = 1;
for (long long i = 1; i <= n; ++i) {
ans = (ans * i) % mod;
}
long long val = 1;
for (long long i = 1; i <= n - 1; ++i) {
val = (val * 2) % mod;
}
cout << (ans - val + mod * mod) % mod;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MAXN = 5e5 + 5;
const long long int mod = 1e9 + 7;
const long double pi = 3.141592653;
long long int fac[3000005];
long long int power(long long int x, long long int y, long long int p);
void solve() {
fac[0] = 1;
for (long long int i = 1; i < 3000005; i++) {
fac[i] = i * fac[i - 1];
fac[i] %= mod;
}
long long int n;
cin >> n;
long long int ans = fac[n];
ans -= power(2ll, n - 1, mod);
ans += mod;
ans %= mod;
cout << ans << endl;
return;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t = 1;
while (t--) {
solve();
}
cerr << "Time elapsed : " << clock() * 1000.0 / CLOCKS_PER_SEC << "ms"
<< '\n';
return 0;
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p);
}
long long int nCrModPFormat(long long int n, long long int r, long long int p) {
if (r == 0) return 1;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cout << *it << " " << a << " ";
err(++it, args...);
}
const double pi = 3.141592653589793;
const long long inf = 1e18 + 5;
const int MOD = 1e9 + 7;
const int maxn = 2e5 + 5;
const int mxn = 1e5 + 5;
const int mx = 1000;
int main() {
ios_base::sync_with_stdio(cin.tie(0) && 0);
;
int n;
cin >> n;
long long ans = 1;
for (int i = 2; i < n + 1; i++) {
(ans *= i) %= MOD;
}
long long temp = 1;
n--;
while (n--) (temp <<= 1) %= MOD;
cout << ((ans - temp) % MOD + MOD) % MOD << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool readn(T &x);
void rd();
const int N = 1e6 + 9;
const long long mod = 1e9 + 7;
int T, n, m, k;
long long fac[N], inv[N];
long long mod_pow(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 C(long long x, long long y) {
return fac[x] * inv[y] % mod * inv[x - y] % mod;
}
int main() {
rd();
fac[0] = inv[0] = 1;
for (int i = 1; i <= N; ++i) fac[i] = fac[i - 1] * i % mod;
for (int i = 1; i <= N; ++i) inv[i] = inv[i - 1] * 2 % mod;
for (T = 1; T; T--) {
readn(n);
printf("%lld\n", (fac[n] - inv[n - 1] + mod) % mod);
}
return 0;
}
template <typename T>
inline bool readn(T &x) {
bool op = 0;
char ch = getchar();
x = 0;
for (; !isdigit(ch) && ch != EOF; ch = getchar()) op ^= (ch == '-');
if (ch == EOF) return false;
for (; isdigit(ch); ch = getchar()) x = x * 10 + (ch ^ '0');
if (op) x = -x;
return true;
}
void rd() {}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
ll cur = 1, cf = 1;
for (int i = 1; i <= n; i++) {
cf = (cf * i) % MOD;
if (i > 1) cur = (cur + cur) % MOD;
}
cout << (cf - cur + MOD) % MOD << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
while (T--) {
long long int n, res, fact, i;
cin >> n;
res = 1;
fact = 1;
for (i = 1; i <= n - 1; i++) {
res = (res * 2) % 1000000007;
fact = (fact * i) % 1000000007;
}
fact = (fact * n) % 1000000007;
fact -= res;
if (fact < 0) fact += 1000000007;
cout << fact;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1000000007;
const long long int N = 1000001;
long long int fact[N];
void precalc() {
fact[0] = 1;
for (long long int i = 1; i < N; i++) fact[i] = (i * fact[i - 1]) % MOD;
}
int powmod(int n, long long int m) {
int ret = 1;
for (int i = 0; i < n; ++i) ret = ((ret % m) * (2 % m)) % m;
return ret;
}
void solve() {
int n;
cin >> n;
cout << (fact[n] - powmod(n - 1, MOD) + MOD) % MOD << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
precalc();
long long int z;
z = 1;
while (z--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, mod = 1e9 + 7, kq1 = 1, kq2 = 1;
cin >> n;
for (long long i = 2; i <= n; i++)
kq1 = (kq1 * i) % mod, kq2 = (kq2 * 2) % mod;
cout << (kq1 + mod - kq2) % mod;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main(void) {
long long n;
cin >> n;
vector<long long> f(n + 1);
f[0] = 1;
for (long long i = 1; i <= n; i++) f[i] = f[i - 1] * i % mod;
long long ans = f[n], sub = 1;
for (int i = 1; i <= n - 1; i++) sub = 2 * sub % mod;
ans = (ans - sub) % mod;
ans = ans < 0 ? ans + mod : ans;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
while (t--) {
int n;
cin >> n;
long long ans = 1;
long long c = 1;
for (long long i = n; i >= 2; i--) {
ans = ((ans % 1000000007) * (i % 1000000007)) % 1000000007;
c = ((c % 1000000007) * 2) % 1000000007;
}
ans %= 1000000007;
c %= 1000000007;
ans -= c;
if (ans < 0) {
ans += 1000000007;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using pll = pair<long long, long long>;
using vl = vector<long long>;
using vpll = vector<pll>;
using mll = map<long long, long long>;
using mcl = map<char, long long>;
using msl = map<string, long long>;
using sl = set<long long>;
using sc = set<char>;
using dl = deque<long long>;
const int N = 1e6 + 5;
long long mod = 1e9 + 7;
vl adj[N];
vpll adjc[N];
long long vis[N];
long long arr[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long a, b, c, d, n, m, p, x, y, z, i, j, k,
f = 0, tc, cnt = 0, sum = 0, mul = 1, mi = 1e18, ma = -1e18;
string str;
char ch;
double db;
long long l, r;
cin >> n;
p = 1;
for (i = 1; i <= n; i++) {
mul = (mul * i) % mod;
if (i != n) p = (p * 2) % mod;
}
mul = (mod + mul - p) % mod;
cout << mul << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long modInverse(long long a, long long m) {
long long m0 = m;
long long y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
long long q = a / m;
long long t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long power(long long x, long long y) {
long long temp;
if (y == 0) return 1ll;
temp = power(x, y / 2) % 1000000007;
;
if (y % 2 == 0)
return (temp * temp % 1000000007);
else {
if (y > 0)
return ((x * temp % 1000000007 * temp) % 1000000007);
else
return ((temp % 1000000007 * temp) % 1000000007) / x;
}
}
long long powerm(long long x, long long y) {
long long temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return (temp * temp);
else {
if (y > 0)
return (x * temp * temp);
else
return (temp * temp) / x;
}
}
bool prime[200000 + 1];
void SieveOfEratosthenes() {
memset(prime, true, sizeof(prime));
prime[1] = false;
for (int p = 2; p * p <= 200000; p++) {
if (prime[p] == true) {
for (int i = p * 2; i <= 200000; i += p) prime[i] = false;
}
}
}
vector<long long> bit;
void update(long long i, long long val, long long n) {
for (; i <= n;) {
bit[i] += val;
i = i + (i & -i);
}
}
long long gets(long long i, long long n) {
long long s = 0;
for (; i > 0;) {
s += bit[i];
i -= i & (-i);
}
return s;
}
vector<vector<long long> > dp, x;
long long f1(long long s, long long e, long long k) {
if (s == e) return 0;
if (dp[s][e] != -1) return dp[s][e];
long long mi = x[s][e], to = 0;
for (long long i = s; i < e; i++) {
to = f1(s, i, k) + f1(i + 1, e, k) + k;
mi = min(mi, to);
}
return dp[s][e] = mi;
}
long long fin(vector<long long>& v, long long n, long long k) {
vector<vector<long long> > emp(n, vector<long long>(n, -1));
dp = emp;
x = emp;
unordered_map<long long, long long> ma;
for (long long i = 0; i < n; i++) {
ma[v[i]]++;
}
long long to = k;
for (auto i : ma)
if (i.second > 1) to += i.second;
unordered_map<long long, long long> x;
unordered_map<long long, long long> emp2;
long long temp = 0;
for (__typeof(n) i = 0; i < n; i += 1) {
long long p = v[i];
if (x[p] > 2 && ma[p] > 2) {
temp += 0;
} else if (x[p] == 0 && ma[p] > 2) {
temp += 1;
} else if (x[p] == 0 && ma[p] == 2) {
temp += 2;
} else if (x[p] == 0 && ma[p] == 1) {
temp += 0;
} else if (x[p] == 1 && ma[p] == 1) {
temp -= 1;
} else if (x[p] == 1 && ma[p] == 2) {
temp += 0;
} else if (x[p] == 1 && ma[p] > 2) {
temp -= 1;
} else if (x[p] == 2 && ma[p] == 1) {
temp -= 1;
} else if (x[p] == 2 && ma[p] == 2) {
temp++;
} else if (x[p] == 2 && ma[p] > 2) {
temp += 0;
}
if (temp >= k) {
to -= temp - k;
temp = 0;
x.clear();
} else
x[p]++;
ma[p]--;
}
return to;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
long long z = 1;
long long p1 = 1;
while (t--) {
long long n;
cin >> n;
long long z = power(2, n - 1);
long long p = 1;
for (__typeof(n) i = 0; i < n; i += 1) {
p *= (i + 1);
p %= 1000000007;
}
cout << (p - z + 2 * (1000000007)) % 1000000007 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
void solve() {
long long n;
cin >> n;
long long fact = 1, unimodal = 1;
for (long long i = 2; i <= n; i++) {
fact = (fact * i) % MOD;
unimodal = (unimodal * 2) % MOD;
}
cout << (fact - unimodal + MOD) % MOD << endl;
}
signed main() {
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
long long n, i, big = 1, small = 1;
int main(void) {
scanf("%lld", &n);
for (i = 2; i <= n; i++) {
big = (big * i) % 1000000007;
small = (small * 2) % 1000000007;
}
big -= small;
if (big < 0) big += 1000000007;
printf("%lld", big);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5;
const long long mod = 1e9 + 7;
long long power(long long x, long long y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod;
y >>= 1;
}
return res;
}
long long fac[N];
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
fac[0] = 1;
for (long long i = 1; i < N; i++) fac[i] = i * fac[i - 1] % mod;
long long T = 1;
while (T--) {
long long n;
cin >> n;
long long ans = (fac[n] - power(2, n - 1) + mod) % mod;
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long sum = 1;
for (int i = 2; i <= n; ++i) {
sum *= i;
sum %= 1000000007;
}
long long minus = 1;
for (int i = 1; i < n; ++i) {
minus *= 2;
minus %= 1000000007;
}
if (minus < sum)
cout << ((sum - minus) % 1000000007);
else
cout << ((sum - minus + 1000000007) % 1000000007);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod(long long int x, long long int m) { return (x % m + m) % m; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1, r, n, a, d, c, b, x, y, sum, cnt, i, j, k, m, l, q, maxx,
minn, temp, ans, flag, g, ts;
long long int mod = 1000000007;
char ch, chh;
double dans;
string str, ttr;
long long int arr[1000001];
arr[1] = 1;
for (i = 2; i < 1000001; i++) {
arr[i] = i * (arr[i - 1]);
arr[i] = (arr[i] % (mod));
}
for (ts = 1; ts <= t; ts++) {
flag = 0;
sum = 0;
cnt = 0;
ans = 0;
k = 0;
maxx = 0;
minn = 0;
a = 0;
b = 0;
temp = 0;
cin >> n;
temp = 1;
ans = 1;
cnt = 1;
for (i = 0; i < n - 1; i++) {
cnt = cnt * 2;
cnt = (cnt % mod);
}
ans = arr[n] - (cnt);
if (ans < 0) ans += mod;
cout << ans;
cout << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool umax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
string to_string(bool b) { return b ? "true" : "false"; }
string to_string(char c) { return string(1, c); }
string to_string(const char* second) { return string(second); }
string to_string(string second) { return second; }
template <class T>
string to_string(T v) {
bool first = 1;
string res;
for (auto& x : v) {
if (!first) res += ' ';
first = 0;
res += to_string(x);
}
return res;
}
template <class A>
void write(A x) {
cout << to_string(x);
}
void print() { write("\n"); }
template <class H, class... T>
void print(const H& h, const T&... t) {
write(h);
if (sizeof...(t)) write(' ');
print(t...);
}
const long long mod = 1e9 + 7;
const long long maxsize = 2e5 + 10;
const long long inf = 0x3f3f3f3f3f3f3f3f;
bool vis[maxsize];
long long n, m, nc;
long long a[maxsize], b[maxsize];
void solve() {
cin >> n;
long long fac = 1;
long long pote = 1;
for (long long i = 2; i <= n; i++) {
fac *= i;
pote *= 2ll;
fac %= mod;
pote %= mod;
}
cout << ((fac - pote) % mod + mod) % mod << "\n";
}
int main() {
{ ios_base::sync_with_stdio(false); }
{
cin.tie(NULL);
cout.tie(NULL);
}
int t = 1;
while (t--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int mod = 1000000007;
struct mint {
ll x;
mint(ll x = 0) : x((x % mod + mod) % mod) {}
mint operator-() const { return mint(-x); }
mint& operator+=(const mint a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint a) {
if ((x += mod - a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(ll t) const {
if (!t) return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1) a *= *this;
return a;
}
mint inv() const { return pow(mod - 2); }
mint& operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream& operator>>(istream& is, mint& a) { return is >> a.x; }
ostream& operator<<(ostream& os, const mint& a) { return os << a.x; }
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < mod);
fact[0] = 1;
for (int i = 1; i <= n; ++i) fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i) ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n) return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
int main() {
int N;
cin >> N;
combination comb = combination(N + 5);
mint ans = 1;
for (int i = 1; i <= N; i++) {
ans *= i;
}
for (int i = 0; i < N; i++) {
ans -= comb(N - 1, N - 1 - i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.14159265359;
inline long long add(long long a, long long b, long long m) {
if ((a + b) >= m) return (a + b) % m;
return a + b;
}
inline long long mul(long long a, long long b, long long m) {
if ((a * b) < m) return a * b;
return (a * b) % m;
}
long long power(long long x, long long y, long long m) {
long long res = 1;
x = x % m;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % m;
y = y >> 1;
x = (x * x) % m;
}
return res;
}
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
ios_base::sync_with_stdio;
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
long long n;
cin >> n;
vector<long long> fact(n + 1), inv(n + 1);
fact[0] = inv[0] = 1;
for (long long i = 1; i < n + 1; i++) {
fact[i] = (fact[i - 1] * i) % 1000000007;
inv[i] = power(fact[i], 1000000007 - 2, 1000000007);
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long x = inv[i];
x = (x * inv[n - 1 - i]) % 1000000007;
x = (x * fact[n - 1]) % 1000000007;
ans = (ans + x) % 1000000007;
}
cout << (fact[n] - ans + 1000000007) % 1000000007 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
const int MX = 2e5 + 7;
const int mod = 1e9 + 7;
const double pi = 3.1415926535897932384;
double isp = 1e-13;
using namespace std;
long long qpow(long long a, long long b, long long MOD = mod) {
for (long long ans = 1;; a = a * a % MOD, b >>= 1) {
if (b & 1) ans = ans * a % MOD;
if (!b) return ans;
}
}
long long inv(long long a, long long MOD = mod) {
return qpow(a, MOD - 2, MOD);
}
long long exgcd(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
long long ret = exgcd(b, a % b, y, x);
y -= a / b * x;
return ret;
}
long long getInv(int a, int mod) {
long long x, y;
long long d = exgcd(a, mod, x, y);
return d == 1 ? (x % mod + mod) % mod : -1;
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
long long n;
cin >> n;
long long ans = 1;
for (int i = 1; i <= n; i++) {
ans = ans * i % mod;
}
ans -= qpow(2, n - 1);
ans += mod;
cout << ans % mod << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int power(long long int num, long long int r) {
if (r == 0) return 1;
if (r == 1) return num % mod;
long long int ans = power(num, r / 2) % mod;
if (r % 2 == 0) {
return (ans * ans) % mod;
}
return (((ans * ans) % mod) * num) % mod;
}
void solve() {
long long int n;
cin >> n;
vector<long long int> fac(n + 1);
fac[0] = 1;
for (long long int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % mod;
cout << (fac[n] - power(2, n - 1) + mod) % mod << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void debug_out();
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T);
long long fact[1000005];
long long fact1[1000005];
void computeFactorial() {
fact[0] = 1;
for (long long i = 1; i < 1000005; i++)
fact[i] = (fact[i - 1] * i) % 1000000007;
fact1[0] = 1;
for (long long i = 1; i < 1000005; i++)
fact1[i] = (fact1[i - 1] * 2) % 1000000007;
}
long long run_test() {
long long n;
cin >> n;
if (n == 1 || n == 2) {
cout << 0 << "\n";
return 0;
}
long long t1 = fact[n];
long long t2 = fact1[n - 1];
long long ans = (t1 - t2 + 1000000007) % 1000000007;
cout << ans << "\n";
return 0;
}
int32_t main() {
computeFactorial();
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
long long t = 1;
for (long long tc = 1; tc < t + 1; tc++) {
long long stat = run_test();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writesp(long long a) {
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
printf(" ");
}
inline void writeln(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
write(a);
puts("");
}
long long fac[1000005], n, mo = 1e9 + 7;
long long miyun(long long x, long long y) {
long long kkk = 1, tt = x;
while (y > 0) {
if (y % 2 == 1) (kkk *= tt) %= mo;
(tt *= tt) %= mo;
y >>= 1;
}
return kkk;
}
signed main() {
fac[0] = 1;
for (long long i = 1; i <= 1000005; i++) fac[i] = fac[i - 1] * i % mo;
n = read();
writeln((fac[n] - miyun(2, n - 1) + mo) % mo);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, n, m, k, x, y, l1, l2, r1, r2, z, sum = 0, mx, mn, count,
flag = 0, pointer = 0;
cin >> n;
x = y = 1;
for (i = 1; i <= n; i++) {
x *= i;
x %= 1000000007;
}
for (i = 1; i < n; i++) {
y *= 2;
y %= 1000000007;
}
sum = x - y + 1000000007;
sum %= 1000000007;
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n;
cin >> n;
long long k1 = 1, k2 = 1, mod = 1e9 + 7;
for (long long i = 2; i <= n; i++) {
k1 = (k1 * i) % mod;
k2 = (k2 * 2) % mod;
}
cout << (k1 - k2 + mod) % mod << endl;
}
int main() {
long long t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long N = 200005;
int dx[] = {-1, 0, 1, 0, 1, 1, -1, -1};
int dy[] = {0, -1, 0, 1, 1, -1, 1, -1};
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long powb(long long a, long long b) {
long long res = 1;
a;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a;
a = a * a;
}
return res;
}
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int n;
cin >> n;
long long ans = 1, del = 1;
for (int i = 1; i <= n; i++) {
(ans *= i) %= mod;
}
del = powmod(2, n - 1);
cout << ((ans - del) % mod + mod) % mod << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dx[] = {0, 1, 0, -1};
long long int dy[] = {1, 0, -1, 0};
long long int dxx[] = {0, 1, 0, -1, 1, 1, -1, -1};
long long int dyy[] = {1, 0, -1, 0, 1, -1, 1, -1};
long long int solve() {
long long int cnt = 0;
return cnt;
}
bool cmp(long long int a, long long int b) { return a > b; }
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int t;
long long int n;
cin >> n;
long long int ans = n;
long long int ans1 = 1;
for (int i = 1; i < n; i++) {
ans *= i;
ans %= 1000000007;
ans1 *= 2;
ans1 %= 1000000007;
}
if (ans - ans1 < 0) {
cout << 1000000007 + (ans - ans1) % 1000000007 << endl;
} else
cout << (ans - ans1) % 1000000007 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int M = (long long int)2e5 + 5;
const long long int mod = (long long int)1e9 + 7;
long long int powM(long long int b, long long int p) {
long long int ans = 1;
while (p) {
if (p % 2LL) ans = (ans * b) % mod;
b = (b * b) % mod;
p /= 2LL;
}
return ans;
}
long long int fact(long long int n) {
long long int ans = 1;
for (long long int i = 1; i < n + 1; i++) ans = (ans * i) % mod;
return ans;
}
void solve() {
long long int n;
cin >> n;
long long int a = fact(n), b = powM(2, n - 1);
cout << ((a - b + mod) % mod + mod) % mod << "\n";
}
int32_t main() {
{
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long int t = 1;
for (long long int tno = 1; tno < t + 1; tno++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool hasCycle = false;
int VISITED = 2;
int UNVISITED = 0;
int VISITING = 1;
void dfs(int u, int p, vector<vector<int>>& g, vector<int>& vis) {
if (hasCycle) return;
vis[u] = VISITING;
for (int e : g[u]) {
if (e != p && vis[e] == VISITING) {
hasCycle = true;
return;
}
if (vis[e] == UNVISITED) {
dfs(e, u, g, vis);
}
}
vis[u] = VISITED;
}
bool cyclic(vector<int>& a) {
vector<vector<int>> g(a.size(), vector<int>());
for (int i = 0; i < a.size(); i++) {
for (int j = i - 1; j >= 0; j--) {
if (a[i] < a[j]) {
g[i].push_back(j);
g[j].push_back(i);
break;
}
}
for (int j = i + 1; j < a.size(); j++) {
if (a[i] < a[j]) {
g[i].push_back(j);
g[j].push_back(i);
break;
}
}
}
hasCycle = false;
vector<int> vis(a.size(), UNVISITED);
for (int i = 0; i < a.size(); i++) {
if (vis[i] == UNVISITED && !hasCycle) dfs(i, -1, g, vis);
}
bool ret = hasCycle;
hasCycle = false;
return ret;
}
const long long MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
long long f = 1;
long long p = 1;
for (int i = 2; i <= n; i++) {
f = (f * i) % MOD;
p = (2 * p) % MOD;
}
cout << (f - p + MOD) % MOD << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void start() {}
void solve() {
long long int n;
cin >> n;
long long int ans = 1, temp = 1;
for (int i = 1; i <= n; i++) {
ans = (ans * i) % 1000000007;
if (i != n - 1) {
temp *= 2;
}
temp = temp % 1000000007;
}
cout << (ans - temp + 1000000007) % 1000000007;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
start();
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1e9 + 7;
long long int casei(long long int tc) {
long long int n, i, trn = 1, fct = 1;
cin >> n;
for (i = 1; i <= n; i++) {
if (i < n) trn *= 2;
fct *= i;
trn %= mod;
fct %= mod;
}
long long int ans = fct - trn;
if (ans < 0) ans += mod;
cout << ans << "\n";
return 0;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int tc, x;
tc = 1;
while (tc--) casei(x - tc);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace cycperms {
int n;
long long mod = 1000000007;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
long long fac = 1;
for (long long i = 2; i <= n; i++) {
fac *= i;
fac %= mod;
}
long long pow = 1;
for (int i = 0; i < n - 1; i++) {
pow *= (2LL);
pow %= mod;
}
cout << (fac - pow + mod) % mod << endl;
return 0;
}
} // namespace cycperms
int main() {
cycperms::main();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long bin_to_integer(string s) {
long long r = 1, sum = 0;
for (long long i = s.length() - 1; i >= 0; i--) {
if (s[i] == '1') {
sum += r;
}
r *= 2;
}
return sum;
}
string to_binary(int n) {
string s;
while (n > 0) {
if (n & 1) {
s += '1';
} else {
s += '0';
}
n >>= 1;
}
reverse(s.begin(), s.end());
return s;
}
int compare(const void* a, const void* b) {
const long long* x = (long long*)a;
const long long* y = (long long*)b;
if (*x > *y)
return 1;
else if (*x < *y)
return -1;
return 0;
}
long long fact(long long int x) {
if (x == 1)
return 1;
else
return ((x * fact(x - 1)) % mod);
}
void solve() {
long long n;
cin >> n;
long long factril = 1, n2 = n, twopow = 1;
while (n2 > 0) {
factril = (factril * n2) % mod;
n2--;
}
n2 = n - 1;
while (n2--) {
twopow = twopow * 2 % mod;
}
long long ans = factril - twopow;
if (ans % mod < 0) ans += mod;
cout << ans % mod << endl;
return;
}
int main() {
int t = 1, z = 1;
while (z <= t) {
solve();
z++;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 20;
const int mod = 1e9 + 7;
long long fact[N], tavan[N], dp[N];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
fact[0] = 1;
tavan[0] = 1;
for (long long i = 1; i <= n; i++)
fact[i] = (((fact[i - 1] * i) % mod) + mod) % mod;
for (long long i = 1; i < n; i++)
tavan[i] = ((tavan[i - 1] * 2 * 1ll) % mod + mod) % mod;
cout << ((fact[n] - tavan[n - 1]) % mod + mod) % mod;
}
|
#include <bits/stdc++.h>
using namespace std;
bool isPrime(long long x) {
bool toreturn = 1;
for (long long i = 2; i * i <= x; ++i) {
if (x % i == 0) {
toreturn = 0;
break;
}
}
return toreturn;
}
long long mod = 1e9 + 7;
long long power(long long x, long long y, long long p) {
long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long fact(long long n) {
long long ans = 1;
for (long long i = 2; i <= n; i++) ans = (ans * i) % mod;
return ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
long long n;
cin >> n;
cout << (fact(n) - power(2, n - 1, mod) + mod) % mod << '\n';
}
}
|
#include <bits/stdc++.h>
const long long N = 1e6;
const long long P = 1e9 + 7;
long long fac[N + 10], n, ans;
long long qpow(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = res * a % P;
a = a * a % P;
b >>= 1;
}
return res;
}
signed main() {
scanf("%lld", &n);
long long ans = 1;
for (long long i = 1; i <= n; i++) ans = ans * i % P;
long long ans2 = qpow(2, n - 1);
printf("%lld\n", ((ans - ans2) % P + P) % P);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using ULL = unsigned long long;
using VI = vector<int>;
using VL = vector<LL>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
set<int> g[100];
bool buildG(vector<int> &a) {
int n = a.size();
for (int i = 0; i < a.size(); i++) g[i].clear();
for (int i = 0; i < n; i++) {
for (int j = i - 1; j >= 0; j--) {
if (a[i] < a[j]) {
g[i].insert(j);
g[j].insert(i);
break;
}
}
for (int j = i + 1; j < a.size(); j++) {
if (a[i] < a[j]) {
g[i].insert(j);
g[j].insert(i);
break;
}
}
}
for (int u = 0; u < n; u++) {
for (int v = 0; v < n; v++) {
for (int w = 0; w < n; w++) {
if (u != v && v != w && w != u && g[u].count(v) && g[v].count(w) &&
g[w].count(u))
return true;
}
}
}
return false;
}
const LL MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
LL n;
cin >> n;
LL res = 1;
for (int i = 1; i <= n; i++) {
res = (res * i) % MOD;
}
LL step = 1;
for (int i = 0; i < n - 1; i++) step = (step * 2) % MOD;
cout << (res - step + MOD) % MOD;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 20;
const int mod = 1e9 + 7;
long long fact[N], tavan[N], dp[N];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long n;
cin >> n;
fact[0] = 1;
dp[3] = 2;
for (int i = 1; i <= n; i++)
fact[i] = (((fact[i - 1] * i) % mod) + mod) % mod;
for (int i = 4; i <= n; i++) {
dp[i] = ((((dp[i - 1] * 2) + (i - 2) * fact[i - 1]) % mod) + mod) % mod;
}
cout << dp[n];
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long INF = 1e18 + 18;
const long long MOD = 1000000007;
template <class T>
bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &p) {
return s << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
istream &operator>>(istream &i, vector<T> &v) {
for (long long j = (0); j < (v.size()); j++) i >> v[j];
return i;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<T> &v) {
int len = v.size();
for (int i = 0; i < len; ++i) {
s << v[i];
if (i < len - 1) s << " ";
}
return s;
}
template <typename T>
ostream &operator<<(ostream &s, const vector<vector<T>> &vv) {
int len = vv.size();
for (int i = 0; i < len; ++i) {
s << vv[i] << endl;
}
return s;
}
struct mint {
long long x;
mint(long long x = 0) : x((x % MOD + MOD) % MOD) {}
mint operator-() const { return mint(-x); }
mint &operator+=(const mint a) {
if ((x += a.x) >= MOD) x -= MOD;
return *this;
}
mint &operator-=(const mint a) {
if ((x += MOD - a.x) >= MOD) x -= MOD;
return *this;
}
mint &operator*=(const mint a) {
(x *= a.x) %= MOD;
return *this;
}
mint operator+(const mint a) const { return mint(*this) += a; }
mint operator-(const mint a) const { return mint(*this) -= a; }
mint operator*(const mint a) const { return mint(*this) *= a; }
mint pow(long long t) const {
if (!t) return 1;
mint a = pow(t >> 1);
a *= a;
if (t & 1) a *= *this;
return a;
}
mint inv() const { return pow(MOD - 2); }
mint &operator/=(const mint a) { return *this *= a.inv(); }
mint operator/(const mint a) const { return mint(*this) /= a; }
};
istream &operator>>(istream &is, const mint &a) { return is >> a.x; }
ostream &operator<<(ostream &os, const mint &a) { return os << a.x; }
struct combination {
vector<mint> fact, ifact;
combination(int n) : fact(n + 1), ifact(n + 1) {
assert(n < MOD);
fact[0] = 1;
for (int i = 1; i <= n; ++i) fact[i] = fact[i - 1] * i;
ifact[n] = fact[n].inv();
for (int i = n; i >= 1; --i) ifact[i - 1] = ifact[i] * i;
}
mint operator()(int n, int k) {
if (k < 0 || k > n) return 0;
return fact[n] * ifact[k] * ifact[n - k];
}
};
int solve() {
long long n;
cin >> n;
;
vector<mint> f(n + 1);
f[0] = 1;
vector<mint> two(n + 1);
two[0] = 1;
for (long long i = (1); i < (n + 1); i++) {
f[i] = f[i - 1] * i;
two[i] = two[i - 1] * 2;
}
cout << f[n] - two[n - 1] << endl;
return 0;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << std::setprecision(10);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int N = 1e5 + 10;
const int mod = 1e9 + 7;
long long power(long long a, long long b) {
long long ans = 1;
if (b == 0) return 1;
while (b) {
if (b & 1) ans = ans * a % mod;
b >>= 1;
a = a * a % mod;
}
return ans % mod;
}
int main() {
int n;
cin >> n;
long long ans = 1;
for (int i = 1; i <= n; i++) ans = ans * i % mod;
ans = ((ans - power(2, n - 1)) % mod + mod) % mod;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long F[1000001];
long long power(long long a, long long n) {
long long res = 1;
while (n) {
if (n & 1) res = (res * a) % 1000000007, n--;
n = n / 2;
a = (a * a) % 1000000007;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
F[0] = F[1] = (long long)1;
for (long long i = 2; i <= 1000000; i++) {
F[i] = (F[i - 1] * i) % 1000000007;
}
long long ans = (F[n] - power(2, n - 1)) % 1000000007;
if (ans < 0) ans += 1000000007;
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e6 + 5, mod = 1e9 + 7;
int n, m, k;
int inv[Maxn] = {0, 1}, a[Maxn] = {1, 1}, b[Maxn] = {1, 1};
int C(int x, int y) {
if (y == 0) return 1;
if (x < 0 || y < 0 || y > x) return 0;
return (long long)a[x] * b[y] % mod * b[x - y] % mod;
}
void init() {
for (int i = 2; i <= n; i++) {
inv[i] = (long long)(mod - mod / i) * inv[mod % i] % mod;
a[i] = (long long)a[i - 1] * i % mod;
b[i] = (long long)b[i - 1] * inv[i] % mod;
}
}
int main() {
cin >> n;
init();
long long ans = 0;
for (int i = 0; i < n; i++) {
ans = (ans + C(n - 1, i)) % mod;
}
ans = (a[n] - ans + mod) % mod;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long modFact(long long n, long long p) {
if (n >= p) return 0;
long long result = 1;
for (int i = 1; i <= n; i++) result = (result * i) % p;
return result;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
t = 1;
while (t--) {
long long n;
cin >> n;
long long ans = 1, ans1 = 1;
for (long long i = 1; i <= n; i++) {
ans = ((ans) * (i)) % 1000000007;
}
for (long long i = 1; i <= n - 1; i++) {
ans1 = ((ans1)*2) % 1000000007;
}
cout << (ans - ans1 + 1000000007) % 1000000007 << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dx1[] = {1, 1, 0, -1, -1, -1, 0, 1};
long long int dy1[] = {0, 1, 1, 1, 0, -1, -1, -1};
long long int dx2[] = {1, 0, -1, 0};
long long int dy2[] = {0, 1, 0, -1};
long long int mul(long long int a, long long int b,
long long int p = 1000000007) {
return ((a % p) * (b % p)) % p;
}
long long int add(long long int a, long long int b,
long long int p = 1000000007) {
return (a % p + b % p) % p;
}
long long int power(long long int x, long long int y,
long long int p = 1000000007) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int modInverse(long long int n, long long int p = 1000000007) {
return power(n, p - 2, p);
}
long long int ncrMod(long long int n, long long int r,
long long int p = 1000000007) {
if (r == 0) return 1;
long long int fac[n + 1];
fac[0] = 1;
for (long long int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
long long int fact(long long int n, long long int p = 1000000007) {
long long int sum = 1;
for (int i = 1; i <= n; i++) {
sum = ((sum % p) * (i % p)) % p;
}
return (sum % p);
}
bool isPrime(long long int n) {
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
void solve() {
long long int n;
cin >> n;
long long int temp = fact(n);
long long int ans = power(2, n - 1);
cout << (temp + 1000000007 - ans) % 1000000007 << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, m, k;
long long t;
cin >> n;
long long fct = 1;
long long pw = 1;
for (long long i = 2; i <= n; i++) {
fct = ((fct % 1000000007) * (i % 1000000007)) % 1000000007;
pw = ((pw % 1000000007) * 2) % 1000000007;
}
cout << ((fct - pw) + 1000000007) % 1000000007 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int a, long long int b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
int binarySearch(int arr[], int l, int r, int x) {
while (l <= r) {
int m = l + (r - l) / 2;
if (arr[m] == x) {
return m;
}
if (arr[m] < x) {
l = m + 1;
} else {
r = m - 1;
}
}
return -1;
}
long long int binomialCoeff(long long int n, long long int k) {
long long int res = 1, i;
if (k > n - k) {
k = n - k;
}
for (i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
long long int power(long long int x, unsigned long long int y,
long long int p) {
long long int 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;
}
int factorial(int n) { return (n == 1 || n == 0) ? 1 : n * factorial(n - 1); }
long long int modFact(long long int n, long long int p) {
if (n >= p) return 0;
long long int result = 1, i;
for (i = 1; i <= n; i++) result = (result * i) % p;
return result;
}
int main() {
int t = 1;
while (t--) {
long long int n;
cin >> n;
long long int ans = (modFact(n, 1000000007) - power(2, n - 1, 1000000007));
if (ans >= 0) {
cout << ans << endl;
} else {
cout << ans + 1000000007 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000 * 1000 * 1000 + 7;
void test_case() {
int n;
cin >> n;
vector<long long int> fact(n);
fact[0] = 1;
for (int i = 1; i < n; i++) fact[i] = fact[i - 1] * i % MOD;
long long int res = 0, pw = 1;
for (int i = n - 1; i > 1; i--) {
res = (res + (fact[i] * (i - 1)) % MOD * pw) % MOD;
pw = pw * 2 % MOD;
}
cout << res << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
for (int i = 1; i <= t; i++) {
test_case();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename T>
using vec = vector<T>;
template <typename T>
using Prior = priority_queue<T>;
template <typename T>
using prior = priority_queue<T, vec<T>, greater<T>>;
const int INF = 1e9;
const ll LLINF = (ll)4 * 1e18;
const ll MOD = 1e9 + 7;
const double PI = 3.14159265358;
const double EPS = 1e-8;
const int xx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
const int yy[8] = {1, 0, -1, 0, 1, -1, -1, 1};
void pmod(ll &a, ll b) { a = (a + b) % MOD; }
void mmod(ll &a, ll b) { a = (a - b + MOD) % MOD; }
void tmod(ll &a, ll b) { a = (a * b) % MOD; }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
ll POW(ll a, ll b) {
ll res = 1;
do {
if (b % 2) tmod(res, a);
tmod(a, a);
} while (b >>= 1);
return res;
}
template <typename T>
void amax(T &a, T b) {
if (a < b) a = b;
}
template <typename T>
void amin(T &a, T b) {
if (a > b) a = b;
}
void solve() {
ll n, ans = 1;
cin >> n;
for (int i = 1; i <= (n); i++) tmod(ans, i);
ll k = 1;
for (int i = 1; i <= (n - 1); i++) tmod(k, 2);
mmod(ans, k);
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T = 1;
while (T--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000007;
vector<long long> prime(10000001, 1);
vector<long long> sdf(10000001, 1);
long long inf = 1000000000000000007;
int isprime(long long n) {
long long i;
for (i = 2; i * i <= n; i++) {
if (n % i == 0) {
return 0;
}
}
return 1;
}
long long modular_expo(long long x, long long y, long long mod) {
if (y == 0) return 1;
if (y % 2 == 0)
return modular_expo(((x % mod) * (x % mod)) % mod, y / 2, mod);
if (y % 2 == 1)
return ((x % mod) *
(modular_expo(((x % mod) * (x % mod)) % mod, (y - 1) / 2, mod)) %
mod) %
mod;
}
long long min3(long long a, long long b, long long c) {
long long m1 = min(a, b);
long long m2 = min(a, c);
return min(m1, m2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i;
long long n;
cin >> n;
long long ans = 1;
for (i = 2; i <= n; i++) {
ans = ((ans % mod) * (i % mod)) % mod;
}
ans = (ans - modular_expo(2, n - 1, mod));
ans = (ans + mod) % mod;
cout << (ans % mod);
}
|
#include <bits/stdc++.h>
using namespace std;
long long SET(long long N, long long pos) {
return N = N | ((long long)1 << pos);
}
long long RESET(long long N, long long pos) {
return N = N & ~((long long)1 << pos);
}
bool CHECK(long long N, long long pos) {
return (bool)(N & ((long long)1 << pos));
}
template <typename T>
inline T __lcm(T a, T b) {
return (a * b) / __gcd(a, b);
}
struct node {
long long i, x, y;
};
long long dx[] = {0, 1, 0, -1, -1, 1, -1, 1};
long long dy[] = {1, 0, -1, 0, 1, 1, -1, -1};
void solve() {
long long n;
cin >> n;
long long ans = 1;
for (long long i = 1; i <= n; i++) {
ans *= i;
ans %= 1000000007;
}
long long ans2 = 1;
for (long long i = 0; i < n - 1; i++) {
ans2 *= 2;
ans2 %= 1000000007;
}
ans = ans - ans2;
ans += 1000000007;
ans %= 1000000007;
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long MOD = 1e9 + 7;
vector<long long> factorial(1e7, 1);
unordered_map<long long, long long> inv;
long long power(long long a, long long x) {
if (x == 0) return 1;
long long res = power(a, x / 2);
res = (res * res) % MOD;
if (x % 2) res = (res * a) % MOD;
return res;
}
long long inverse(long long x) {
if (!inv.count(x)) inv[x] = power(x, MOD - 2);
return inv[x];
}
long long choose(long long n, long long k) {
long long x = factorial[n];
long long y = factorial[k];
long long z = factorial[n - k];
y = inverse(y);
z = inverse(z);
x = (x * y) % MOD;
x = (x * z) % MOD;
return x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
long long n;
cin >> n;
for (long long i = 2; i <= n; i++) {
factorial[i] = (factorial[i - 1] * i) % MOD;
}
long long res = factorial[n];
long long bad = power(2, n - 1);
res -= bad;
while (res < 0) res += MOD;
cout << res << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
long long expo(long long a, long long b) {
if (b == 0) return 1;
if (b % 2 == 0) {
long long ret = expo(a, b / 2);
ret = (ret * ret) % 1000000007;
return ret;
} else {
long long ret = expo(a, b / 2);
ret = (ret * ret) % 1000000007;
ret = (ret * a) % 1000000007;
return ret;
}
}
bool is_prime(int x) {
for (int i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return true;
}
long long inf = 1e18;
long long fac[1000001];
long long power[1000001];
int main() {
long long n;
cin >> n;
fac[0] = 1;
power[0] = 1;
for (int i = 1; i <= 1000000; i++) {
fac[i] = (fac[i - 1] * i) % 1000000007;
power[i] = (power[i - 1] * 2) % 1000000007;
}
cout << (fac[n] - power[n - 1] + 1000000007) % 1000000007;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
std::ios_base::sync_with_stdio(0);
std::cin.tie(0);
std::cout.tie(0);
long long n;
cin >> n;
const long long mod = 1e9 + 7;
long long perm = 1;
for (long long i = 1; i <= n; i++) {
perm = (perm * i) % mod;
};
perm = (perm - 1 + mod) % mod;
long long mn = 1;
for (int i = 1; i < n; i++) {
perm = (perm - mn + mod) % mod;
mn = (mn * 2) % mod;
}
cout << perm << '\n';
}
|
#include <bits/stdc++.h>
const int N = 1e6 + 4;
const int mod = 1e9 + 7;
using namespace std;
long long me(long long n, long long p) {
long long res = 1;
while (p) {
if (p % 2 == 1) res = (res * n) % mod;
n = (n * n) % mod;
p = p / 2;
}
return res;
}
int main() {
int t = 1;
long long fac[N];
fac[0] = 1;
for (int i = 1; i < N; i++) {
fac[i] = (i * fac[i - 1]) % mod;
}
while (t--) {
int n;
cin >> n;
long long ans = (fac[n] - me(2, n - 1) + mod) % mod;
cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long mod = 1e9 + 7;
int32_t main() {
vector<long long> powers(1e6 + 10, 1);
vector<long long> fact(1e6 + 10, 1);
for (long long i = 2; i <= 1e6 + 2; i++) {
powers[i] = (2 * powers[i - 1]) % mod;
fact[i] = (i * fact[i - 1]) % mod;
if (powers[i] < 0) powers[i] += mod;
if (fact[i] < 0) fact[i] += mod;
}
long long n;
cin >> n;
cout << (((fact[n] - powers[n]) % mod) + mod) % mod << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.