solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void CLR(T& A) {
A.clear();
}
inline bool insize(int c, int l, int r) {
if (c >= l && c <= r) return true;
return false;
}
template <class T>
inline void checkmin(T& a, T b) {
if (a == -1 || a > b) a = b;
}
template <class T>
inline void checkmax(T& a, T b) {
if (a < b) a = b;
}
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[] = {1, 0, -1, 0, 1, -1, 1, -1};
int sig(double x) { return fabs(x - 0) < 1e-8 ? 0 : x > 0 ? 1 : -1; }
template <class T>
inline void sf(T& x) {
char c;
int mul = 1;
while ((c = getchar()) != EOF) {
if (c == '-') mul = -1;
if (c >= '0' && c <= '9') {
x = c - '0';
break;
}
}
if (c == EOF) {
x = EOF;
return;
}
while ((c = getchar())) {
if (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c - '0');
} else
break;
}
x *= mul;
}
template <class T0, class T1>
inline void sf(T0& x, T1& y) {
sf(x);
sf(y);
}
template <class T0, class T1, class T2>
inline void sf(T0& x, T1& y, T2& z) {
sf(x);
sf(y);
sf(z);
}
const int N = 1000005;
const int E = 200055;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3F3F3F3F3F3F3F3FLL;
int n, sum, c1, c2, c3, c4, ans;
int main() {
sf(n);
ans = sum = c1 = c2 = c3 = c4 = 0;
for (int i = 0; i < n; i++) {
int x;
sf(x);
;
if (x == 1)
c1++;
else if (x == 2)
c2++;
else if (x == 4)
c4++;
else if (x == 3)
c3++;
sum += x;
}
if (sum == 1 || sum == 2 || sum == 5) {
puts("-1");
return 0;
}
ans = min(c1, c2);
c1 -= ans;
c2 -= ans;
c3 += ans;
if (c1 > 0) {
int t = c1 / 3;
ans += t * 2;
c3 += t;
c1 = c1 % 3;
if (c1 == 1) {
if (c3 > 0)
ans++;
else
ans += 2;
} else if (c1 == 2) {
ans += 2;
}
} else if (c2 > 0) {
ans += ((c2 - 1) / 3 + 1) * 2;
if ((c2 - 1) % 3 == 0 && c4 > 0) ans--;
}
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int> > > divs(100006);
vector<vector<int> > ans(100006);
int dp[100006];
int rec(int n) {
int &ret = dp[n];
if (ret != -1) return ret;
if (divs[n].size() == 0) return ret = 0;
int i, g = 0, st, nd;
set<int> G;
G.clear();
for (i = 0; i < divs[n].size(); ++i) {
st = divs[n][i].first, nd = divs[n][i].second;
g = dp[nd] ^ dp[st - 1];
G.insert(g);
if (g == 0) ans[n].push_back(nd - st + 1);
}
g = 0;
while (G.find(g) != G.end()) ++g;
return ret = g;
}
void initialize() {
int i, j, s, N = 100000;
for (i = 1; i <= N; ++i) {
divs[i].clear();
ans[i].clear();
}
for (i = 1; i <= N; ++i) {
s = i;
for (j = i + 1; j <= N; ++j) {
s += j;
if (s > N) break;
divs[s].push_back(make_pair(i, j));
}
}
memset(dp, -1, sizeof(dp));
dp[0] = dp[1] = dp[2] = 0;
for (i = 3; i <= N; ++i) {
dp[i] = rec(i);
dp[i] ^= dp[i - 1];
}
}
int main() {
initialize();
int N;
while (scanf("%d", &N) != EOF) {
sort(ans[N].begin(), ans[N].end());
if (ans[N].size() == 0)
puts("-1");
else
printf("%d\n", ans[N][0]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N=2e3+7;
int n,k,A,B,x[N],y[N],f[N],g[N],xf[N<<1],yf[N<<1]; bool fl[N]; double F[N];
inline bool cmp(int a,int b){
return atan2(y[a]-B,x[a]-A)<atan2(y[b]-B,x[b]-A);
}
inline bool check(int a,int b){
memset(fl,0,sizeof(fl));
while(!fl[a]) fl[a]=1,a=f[a];
if(!fl[b]) return 1; return 0;
}
inline void upd(int a,int b){
k++,xf[k]=a,yf[k]=b,swap(f[a],f[b]);
}
int main(){
cin>>n; int p=0;
for(int i=1;i<=n;i++) scanf("%d%d%d",&x[i],&y[i],&f[i]);
for(int i=1;i<=n;i++) if(f[i]!=i) p=i;
if(!p) {puts("0"); return 0;}
for(int i=1;i<=n;i++) if(i!=p) g[++g[0]]=i; A=x[p],B=y[p];
sort(g+1,g+g[0]+1,cmp); g[g[0]+1]=g[1];
double pi=acos(-1.0);
for(int i=1;i<=g[0]+1;i++) F[i]=atan2(y[g[i]]-B,x[g[i]]-A);
for(int i=1;i<=g[0];i++){
double w=F[i+1]-F[i];
if(w<=0) w+=2*pi;
if(w>=2*pi) w-=2*pi;
if(check(g[i],g[i+1])&&w<=pi) upd(g[i],g[i+1]);
}
for(int i=1;i<n;i++) upd(f[p],p);
cout<<k<<endl;
for(int i=1;i<=k;i++) printf("%d %d\n",xf[i],yf[i]);
return 0;
} | 11 |
#include <bits/stdc++.h>
using namespace std;
void cnt_pref(vector<int> &a) {
for (int i = 1; i < a.size(); ++i) a[i] = a[i - 1] + a[i];
}
void solve(void) {
int n, m;
cin >> n >> m;
string s;
cin >> s;
vector<string> tp = {"abc", "acb", "bac", "bca", "cab", "cba"};
vector<int> nota0(n + 1, 0), nota1(n + 1, 0), nota2(n + 1, 0);
vector<int> notb0(n + 1, 0), notb1(n + 1, 0), notb2(n + 1, 0);
vector<int> notc0(n + 1, 0), notc1(n + 1, 0), notc2(n + 1, 0);
for (int i = 0; i < n; ++i) {
if (s[i] != 'a') {
if (i % 3 == 0) ++nota0[i + 1];
if (i % 3 == 1) ++nota1[i + 1];
if (i % 3 == 2) ++nota2[i + 1];
}
if (s[i] != 'b') {
if (i % 3 == 0) ++notb0[i + 1];
if (i % 3 == 1) ++notb1[i + 1];
if (i % 3 == 2) ++notb2[i + 1];
}
if (s[i] != 'c') {
if (i % 3 == 0) ++notc0[i + 1];
if (i % 3 == 1) ++notc1[i + 1];
if (i % 3 == 2) ++notc2[i + 1];
}
}
cnt_pref(nota0);
cnt_pref(nota1);
cnt_pref(nota2);
cnt_pref(notb0);
cnt_pref(notb1);
cnt_pref(notb2);
cnt_pref(notc0);
cnt_pref(notc1);
cnt_pref(notc2);
for (int i = 0; i < m; ++i) {
int l, r;
cin >> l >> r;
--l;
--r;
if (r - l == 0)
cout << "0\n";
else if (r - l == 1)
cout << (s[l] == s[r]) << '\n';
else {
int ans = n;
for (string str : tp) {
int ansnw = 0;
if (str[0] == 'a') {
if (l % 3 == 0) ansnw += nota0[r + 1] - nota0[l];
if (l % 3 == 1) ansnw += nota1[r + 1] - nota1[l];
if (l % 3 == 2) ansnw += nota2[r + 1] - nota2[l];
}
if (str[0] == 'b') {
if (l % 3 == 0) ansnw += notb0[r + 1] - notb0[l];
if (l % 3 == 1) ansnw += notb1[r + 1] - notb1[l];
if (l % 3 == 2) ansnw += notb2[r + 1] - notb2[l];
}
if (str[0] == 'c') {
if (l % 3 == 0) ansnw += notc0[r + 1] - notc0[l];
if (l % 3 == 1) ansnw += notc1[r + 1] - notc1[l];
if (l % 3 == 2) ansnw += notc2[r + 1] - notc2[l];
}
if (str[1] == 'a') {
if ((l + 1) % 3 == 0) ansnw += nota0[r + 1] - nota0[l];
if ((l + 1) % 3 == 1) ansnw += nota1[r + 1] - nota1[l];
if ((l + 1) % 3 == 2) ansnw += nota2[r + 1] - nota2[l];
}
if (str[1] == 'b') {
if ((l + 1) % 3 == 0) ansnw += notb0[r + 1] - notb0[l];
if ((l + 1) % 3 == 1) ansnw += notb1[r + 1] - notb1[l];
if ((l + 1) % 3 == 2) ansnw += notb2[r + 1] - notb2[l];
}
if (str[1] == 'c') {
if ((l + 1) % 3 == 0) ansnw += notc0[r + 1] - notc0[l];
if ((l + 1) % 3 == 1) ansnw += notc1[r + 1] - notc1[l];
if ((l + 1) % 3 == 2) ansnw += notc2[r + 1] - notc2[l];
}
if (str[2] == 'a') {
if ((l + 2) % 3 == 0) ansnw += nota0[r + 1] - nota0[l];
if ((l + 2) % 3 == 1) ansnw += nota1[r + 1] - nota1[l];
if ((l + 2) % 3 == 2) ansnw += nota2[r + 1] - nota2[l];
}
if (str[2] == 'b') {
if ((l + 2) % 3 == 0) ansnw += notb0[r + 1] - notb0[l];
if ((l + 2) % 3 == 1) ansnw += notb1[r + 1] - notb1[l];
if ((l + 2) % 3 == 2) ansnw += notb2[r + 1] - notb2[l];
}
if (str[2] == 'c') {
if ((l + 2) % 3 == 0) ansnw += notc0[r + 1] - notc0[l];
if ((l + 2) % 3 == 1) ansnw += notc1[r + 1] - notc1[l];
if ((l + 2) % 3 == 2) ansnw += notc2[r + 1] - notc2[l];
}
ans = min(ans, ansnw);
}
cout << ans << '\n';
}
}
}
int main(void) {
cout << fixed << setprecision(20);
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
srand(time(NULL));
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int v1, v2, t, d, ans = 0, temp;
cin >> v1 >> v2 >> t >> d;
if (v1 > v2) swap(v1, v2);
ans = v1;
temp = v1;
if (d == 0) {
ans = v2 * t;
} else
for (int i = 2; i <= t; i++) {
for (int j = d; j >= -d; j--) {
if ((abs(temp + j - v2) + d - 1) / d + i <= t) {
temp += j;
break;
}
}
ans += temp;
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 113;
int go[N][26], dp[N][N][N];
struct Triple {
int first, second, third;
};
Triple anc[N][N][N];
vector<int> prf(string s) {
int n = s.size();
vector<int> ans(n);
for (int i = 1; i < n; i++) {
int t = ans[i - 1];
while (t > 0 && s[t] != s[i]) t = ans[t - 1];
if (s[t] == s[i]) t++;
ans[i] = t;
}
return ans;
}
void build(string s) {
vector<int> p = prf(s);
for (int i = 0; i < s.size(); i++) {
for (int j = 0; j < 26; j++) {
if (s[i] == 'A' + j)
go[i][j] = i + 1;
else {
if (i)
go[i][j] = go[p[i - 1]][j];
else
go[i][j] = 0;
}
}
}
}
signed main() {
string s, t, virus;
cin >> s >> t >> virus;
int n = s.size(), m = t.size(), k = virus.size();
build(virus);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int g = 0; g < k; g++) {
if (s[i] == t[j] &&
dp[i + 1][j + 1][go[g][s[i] - 'A']] < dp[i][j][g] + 1) {
dp[i + 1][j + 1][go[g][s[i] - 'A']] = dp[i][j][g] + 1;
anc[i + 1][j + 1][go[g][s[i] - 'A']] = {i, j, g};
}
if (dp[i + 1][j][g] < dp[i][j][g])
dp[i + 1][j][g] = dp[i][j][g], anc[i + 1][j][g] = {i, j, g};
if (dp[i][j + 1][g] < dp[i][j][g])
dp[i][j + 1][g] = dp[i][j][g], anc[i][j + 1][g] = {i, j, g};
if (dp[i + 1][j + 1][g] < dp[i][j][g])
dp[i + 1][j + 1][g] = dp[i][j][g], anc[i + 1][j + 1][g] = {i, j, g};
}
}
for (int g = 0; g < k; g++) {
if (dp[i + 1][m][g] < dp[i][m][g])
dp[i + 1][m][g] = dp[i][m][g], anc[i + 1][m][g] = {i, m, g};
}
}
int ans = 0;
for (int i = 0; i < k; i++) {
for (int j = 0; j < m; j++) {
if (dp[n][j][i] > dp[n][j + 1][i])
dp[n][j + 1][i] = dp[n][j][i], anc[n][j + 1][i] = {n, j, i};
}
}
for (int i = 0; i < k; i++) ans = max(ans, dp[n][m][i]);
Triple tr = {0, 0, 0};
for (int i = 0; i < k; i++) {
if (dp[n][m][i] == ans) tr = {n, m, i};
}
if (!ans) {
cout << ans << endl;
return 0;
}
string a;
while (tr.first || tr.second) {
Triple ancestor = anc[tr.first][tr.second][tr.third];
if (dp[ancestor.first][ancestor.second][ancestor.third] + 1 ==
dp[tr.first][tr.second][tr.third])
a.push_back(s[tr.first - 1]);
tr = ancestor;
}
reverse(a.begin(), a.end());
cout << a << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int n;
cin >> n;
string s;
cin >> s;
string ans = "z";
for (int i = 0; i < s.length(); i++) {
string a = "", b = "";
for (int j = 0; j < i; j++) {
int x = ((s[j] - s[i]) + 10) % 10;
b += (char)(x + '0');
}
for (int j = i; j < s.length(); j++) {
int x = ((s[j] - s[i]) + 10) % 10;
a += (char)(x + '0');
}
ans = min(ans, a + b);
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000 + 7;
const long long LL_INF = 1ll * INF * INF;
const int MAX_N = 300000 + 7;
template <typename T>
inline void addmod(T& a, const long long& b, const int& MOD = INF) {
a = (a + b) % MOD;
if (a < 0) a += MOD;
}
int n;
int a[MAX_N];
int sum[MAX_N];
void solve() {
cin >> n;
for (int i = 1; i <= n; ++i) {
long long u;
cin >> u;
a[i] = __builtin_popcountll(u);
;
sum[i] = (a[i] + sum[i - 1]) & 1;
}
long long res = 0;
const int M = 120;
int cnt[2] = {0, 0};
for (int i = 1; i <= n; ++i) {
if (i >= M) {
cnt[sum[i - M] & 1]++;
res += cnt[sum[i] & 1];
}
auto range = make_pair(a[i], a[i]);
for (int j = 1; j + 1 < M && i - j > 0; ++j) {
int lhs = range.first - a[i - j];
if (lhs < 0) {
lhs = range.second - a[i - j];
if (lhs < 0) {
lhs = -lhs;
} else {
lhs = (range.second + a[i - j]) & 1;
}
}
int rhs = range.second + a[i - j];
range = {lhs, rhs};
if (range.second % 2 == 0 && range.first <= 0) {
++res;
}
}
}
cout << res << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
const bool multiple_test = false;
int test = 1;
if (multiple_test) cin >> test;
for (int i = 0; i < test; ++i) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool bit(int n, int k) { return ((1 << k) & n) != 0; }
int main() {
int n, m;
cin >> n >> m;
int mmax = 0;
if (m * n <= 16) {
for (int k = 0; k < 1 << (m * n); ++k) {
bool ok = true;
for (int i1 = 0; i1 < n; ++i1)
for (int j1 = 0; j1 < m; ++j1)
for (int i2 = 0; i2 < n; ++i2)
for (int j2 = 0; j2 < m; ++j2)
if ((i1 - i2) * (i1 - i2) + (j1 - j2) * (j1 - j2) == 5)
if (bit(k, m * i1 + j1) && bit(k, m * i2 + j2)) ok = false;
if (ok) {
int c = 0;
for (int i = 0; i < m * n; ++i) {
if (bit(k, i)) ++c;
}
mmax = max(mmax, c);
}
}
}
mmax = max(mmax, (n + 2) / 3 * m);
mmax = max(mmax, (m + 2) / 3 * n);
mmax = max(mmax, (n + 1) / 2 * ((m + 1) / 2) + (n / 2) * (m / 2));
mmax = max(mmax,
(n / 2 + (n % 4 != 0 ? 1 : 0)) * (m / 2 + (m % 4 != 0 ? 1 : 0)));
cout << mmax << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int N = (int)1e5;
int arr[2][N];
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
int n, q, bad = 0;
std::cin >> n >> q;
while (q--) {
int x, y;
std::cin >> x >> y;
--x, --y;
arr[x][y] ^= 1;
for (int j = std::max(0, y - 1); j <= std::min(n - 1, y + 1); j++)
if (arr[x ^ 1][j]) bad += arr[x][y] ? 1 : -1;
std::cout << (bad ? "No\n" : "Yes\n");
}
}
| 3 |
#include <bits/stdc++.h>
template <typename T>
T gcd(T a, T b) {
if (!b) return a;
return gcd(b, a % b);
}
template <typename T>
T lcm(T a, T b) {
return a * b / gcd(a, b);
}
template <typename T>
void chmin(T& a, T b) {
a = (a > b) ? b : a;
}
template <typename T>
void chmax(T& a, T b) {
a = (a < b) ? b : a;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
using namespace std;
const int MAXN = 550;
int N, M, B;
long long MOD;
int P[MAXN];
long long dp[2][MAXN][MAXN];
int main(void) {
cin >> N >> M >> B >> MOD;
for (int i = 1; i <= N; i++) {
cin >> P[i];
}
long long ans = 0LL;
dp[0][0][0] = 1;
for (int i = 1; i <= N; i++) {
int pos = (i % 2);
for (int j = 0; j <= M; j++) {
for (int k = 0; k <= B; k++) {
dp[pos][j][k] = dp[pos ^ 1][j][k];
if (k - P[i] >= 0 && j - 1 >= 0) {
dp[pos][j][k] += dp[pos][j - 1][k - P[i]] % MOD;
}
dp[pos][j][k] %= MOD;
}
}
}
for (int i = 0; i <= B; i++) {
ans += dp[(N % 2)][M][i] % MOD;
ans %= MOD;
}
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int DP_HI = 10000;
long long a[9], w, w0;
bool dp[DP_HI];
bool dodaj(int x) {
bool nesto = 0;
for (int i = DP_HI - 1; i >= x; i--) {
if (dp[i - x] && !dp[i]) nesto = dp[i] = 1;
}
return nesto;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> w;
w0 = w;
dp[0] = 1;
for (int i = 1; i <= 8; i++) cin >> a[i];
for (int i = 1; i <= 8; i++) {
long long amt = min(64ll, a[i]);
a[i] -= amt;
while (amt--) dodaj(i);
}
for (int i = 8; i >= 1; i--) {
long long r = max(0ll, w - 256);
long long amt = min(a[i], r / i);
a[i] -= amt;
w -= amt * i;
}
for (int i = 1; i <= 8; i++) {
while (a[i] > 0) {
if (dodaj(i)) {
a[i]--;
} else {
break;
}
}
}
for (int i = DP_HI - 1; i >= 0; i--) {
if (i <= w && dp[i]) {
cout << w0 - (w - i) << '\n';
return 0;
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = 1e9 + 7;
const long long int cmod = 998244353;
const long long int N = 2e5 + 10;
const long long int inf = 1e16 + 2;
vector<vector<pair<long long int, long long int>>> store;
long long int sz;
long long int cal(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return (abs(a.first - b.first) + abs(a.second - b.second));
}
long long int cache[N][2];
long long int dp(long long int idx, long long int cur) {
long long int &ans = cache[idx][cur];
if (ans != -1) return ans;
ans = cal(store[idx][0], store[idx].back());
if (idx == sz - 1) return ans;
if (!cur) {
ans += min(cal(store[idx][0], store[idx + 1][0]) + dp(idx + 1, 1),
cal(store[idx][0], store[idx + 1].back()) + dp(idx + 1, 0));
} else {
ans += min(cal(store[idx].back(), store[idx + 1][0]) + dp(idx + 1, 1),
cal(store[idx].back(), store[idx + 1].back()) + dp(idx + 1, 0));
}
return ans;
}
void solve(long long int Case) {
memset(cache, -1, sizeof cache);
long long int n;
cin >> n;
vector<pair<long long int, long long int>> v(n);
for (long long int i = 0; i < n; i++) cin >> v[i].first >> v[i].second;
sort(v.begin(), v.end(),
[&](pair<long long int, long long int> u,
pair<long long int, long long int> v) {
if (max(u.first, u.second) == max(v.first, v.second)) {
if (u.second == v.second) return (u.first > v.first);
return u.second < v.second;
}
return max(u.first, u.second) < max(v.first, v.second);
});
store.push_back({{0, 0}});
for (long long int i = 0; i < n;) {
vector<pair<long long int, long long int>> temp;
long long int j = i;
temp.push_back(v[i]);
while (j < n and
max(v[j].first, v[j].second) == max(v[i].first, v[i].second)) {
j++;
}
temp.push_back(v[j - 1]);
i = j;
store.push_back(temp);
}
sz = store.size();
cout << min(dp(0, 0), dp(0, 1)) << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int testcase = 1;
long long int Case = 1;
while (testcase--) {
solve(Case++);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k, x, n1 = 1, m1 = 1;
char ch;
struct item {
long long len, pr, su, mx;
} a[777777], b[777777];
void upd1(long long pos) {
a[pos].su = 0;
pos /= 2;
while (pos) {
a[pos].pr = a[pos * 2].pr;
if (a[pos].pr == a[pos * 2].len && a[pos * 2].su > 0)
a[pos].pr += a[pos * 2 + 1].pr;
a[pos].su = a[pos * 2 + 1].su;
if (a[pos].su == a[pos * 2 + 1].len) a[pos].su += a[pos * 2].su;
a[pos].mx = max(a[pos * 2].mx, a[pos * 2 + 1].mx);
a[pos].mx = max(a[pos].mx, a[pos * 2].su + a[pos * 2 + 1].pr);
pos /= 2;
}
}
void upd2(long long pos) {
b[pos].su = 0;
pos /= 2;
while (pos) {
b[pos].pr = b[pos * 2].pr;
if (b[pos].pr == b[pos * 2].len && b[pos * 2].su > 0)
b[pos].pr += b[pos * 2 + 1].pr;
b[pos].su = b[pos * 2 + 1].su;
if (b[pos].su == b[pos * 2 + 1].len) b[pos].su += b[pos * 2].su;
b[pos].mx = max(b[pos * 2].mx, b[pos * 2 + 1].mx);
b[pos].mx = max(b[pos].mx, b[pos * 2].su + b[pos * 2 + 1].pr);
pos /= 2;
}
}
int main() {
cin >> m >> n >> k;
while (n1 < n) n1 *= 2;
n1--;
while (m1 < m) m1 *= 2;
m1--;
for (long long i = 1; i <= n; i++)
a[i + n1].len = a[i + n1].pr = a[i + n1].su = a[i + n1].mx = 1;
for (long long i = n1; i >= 1; i--)
a[i].len = a[i].pr = a[i].su = a[i].mx = a[i * 2].len + a[i * 2 + 1].len;
for (long long i = 1; i <= m; i++)
b[i + m1].len = b[i + m1].pr = b[i + m1].su = b[i + m1].mx = 1;
for (long long i = m1; i >= 1; i--)
b[i].len = b[i].pr = b[i].su = b[i].mx = b[i * 2].len + b[i * 2 + 1].len;
for (long long i = 1; i <= k; i++) {
scanf("\n%c%d", &ch, &x);
if (ch == 'V')
upd2(x + m1);
else
upd1(x + n1);
printf("%I64d\n", a[1].mx * b[1].mx);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, a, b;
bool check(long long x) {
long long l = 0, r = 1000000;
while (l != r) {
long long m = (l + r + 1) / 2;
if (m * m * m > x) {
r = m - 1;
} else {
l = m;
}
}
bool ok = (l * l * l == a * b);
return (ok && !(a % l) && !(b % l));
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
while (n--) {
cin >> a >> b;
if (check(a * b)) {
cout << "Yes\n";
} else {
cout << "No\n";
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
unordered_map<string, vector<vector<int>>> mp;
unordered_map<string, int> tp, tk;
vector<int> v;
int main() {
int n;
stringstream ss;
string s, t, u;
tp["int"] = 1;
tp["double"] = 2;
tp["string"] = 3;
tp["T"] = -1;
cin >> n;
getchar();
for (int i = 0; i < n; i++) {
ss.clear();
ss.str("");
v.clear();
getline(cin, s);
for (int i = 0; i < s.size(); i++)
if (s[i] == '(' || s[i] == ',' || s[i] == ')') s[i] = ' ';
ss << s;
for (int i = 0; ss >> t; i++) {
if (i == 1)
u = t;
else if (i > 1)
v.push_back(tp[t]);
}
mp[u].push_back(v);
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s >> t;
tk[t] = tp[s];
}
cin >> n;
getchar();
for (int i = 0; i < n; i++) {
ss.clear();
ss.str("");
v.clear();
getline(cin, s);
for (int i = 0; i < s.size(); i++)
if (s[i] == '(' || s[i] == ',' || s[i] == ')') s[i] = ' ';
ss << s;
for (int i = 0; ss >> t; i++) {
if (i == 0)
u = t;
else
v.push_back(tk[t]);
}
int ans = 0;
if (mp.count(u)) {
vector<vector<int>>& w = mp[u];
for (int i = 0; i < w.size(); i++) {
if (w[i].size() != v.size()) continue;
bool f = 1;
for (int j = 0; j < v.size(); j++)
if (w[i][j] != v[j] && w[i][j] != -1) {
f = 0;
break;
}
if (f) ++ans;
}
}
printf("%d\n", ans);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[200001];
int n;
double f(double x) {
double sum = 0, min_sum = 0, max_sum = 0, res = -1e18;
for (int i = 1; i <= n; i++) {
sum += a[i] - x;
res = max(res, fabs(sum - min_sum));
res = max(res, fabs(sum - max_sum));
min_sum = min(min_sum, sum);
max_sum = max(max_sum, sum);
}
return res;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
double l = -1e5, r = 1e5;
for (int i = 1; i <= 100; i++) {
double m1 = l + (r - l) / 3;
double m2 = r - (r - l) / 3;
if (f(m1) < f(m2))
r = m2;
else
l = m1;
}
printf("%.10f", f(l));
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<pair<int, int>> vec;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
if (a > b) swap(a, b);
vec.push_back({a, b});
}
vector<int> sum;
sort(vec.begin(), vec.end());
int a = vec[0].first, b = vec[0].second, x = vec[0].second;
for (int i = 1; i < n; i++) {
if (vec[i].first > x) {
sum.push_back((a + b) / 2);
a = vec[i].first;
b = vec[i].second;
x = b;
} else {
a = vec[i].first;
b = min(b, vec[i].second);
x = b;
}
}
sum.push_back((a + b) / 2);
cout << sum.size() << endl;
for (auto v : sum) cout << v << " ";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long int n, i, j, ans;
cin >> n;
long long int l[n];
long long int r[n];
for (i = 0; i < n; i++) {
cin >> l[i] >> r[i];
}
long long int lans = *max_element(l, l + n);
long long int rans = *min_element(r, r + n);
ans = lans - rans;
if (ans > 0)
std::cout << ans << std::endl;
else
cout << 0 << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
int p;
cin >> n >> k >> p;
for (int ctr1 = 0; ctr1 < p; ctr1++) {
bool ok = false;
long long t;
cin >> t;
if (k == 0)
cout << ".";
else if (k == n)
cout << "X";
else if (t == n)
cout << "X";
else if (n % 2 == 0) {
if (k <= n / 2) {
if (t % 2)
cout << ".";
else if (n / 2 - t / 2 >= k)
cout << ".";
else
cout << "X";
} else {
if (t % 2 == 0)
cout << "X";
else if (n / 2 - t / 2 > k - (n / 2))
cout << ".";
else
cout << "X";
}
} else {
long long k1 = k - 1;
long long n1 = n - 1;
if (k1 <= n1 / 2) {
if (t % 2)
cout << ".";
else if (n1 / 2 - t / 2 >= k1)
cout << ".";
else
cout << "X";
} else {
if (t % 2 == 0)
cout << "X";
else if (n1 / 2 - t / 2 > k1 - (n1 / 2))
cout << ".";
else
cout << "X";
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] += i;
}
sort(begin(a), end(a));
for (int i = 0; i < n - 1; i++) {
if (a[i] + 1 > a[i + 1]) {
cout << ":(" << endl;
return 0;
}
}
for (int i = 0; i < n; i++) cout << a[i] - i << " ";
cout << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
bool prime[100005];
void sieve() {
memset(prime, true, sizeof(prime));
for (long long p = 2; p * p < 100005; p++) {
if (prime[p] == true) {
for (long long i = p * p; i < 100005; i += p) prime[i] = false;
}
}
}
long long powmod(long long x, long long y, long long mod) {
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;
}
signed main() {
long long n, m, k;
cin >> n >> m >> k;
long long dp[n], a[n];
for (long long i = 0; i < n; i++) {
cin >> a[i];
}
long long ans = 0;
for (long long i = 0; i < n; i++) {
dp[i] = a[i] - k;
long long sum = a[i];
for (long long j = i - 1; j >= 0 && (i - j) <= m; j--) {
dp[i] = max(dp[i], dp[j] - k + sum);
sum += a[j];
}
if (i < m) {
dp[i] = max(dp[i], sum - k);
}
dp[i] = max(dp[i], 0LL);
ans = max(dp[i], ans);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void vin(vector<int>& v) {
int i, p;
int n = (int)v.size();
for (i = 0; i < n; i++) {
scanf("%d", &v[i]);
}
}
void vin(vector<long long>& v) {
long long i, p;
int n = v.size();
for (i = 0; i < n; i++) {
scanf("%lld", &v[i]);
}
}
void vout(const vector<int>& v) {
for (auto q : v) printf("%d ", q);
printf("\n");
}
void vout(const vector<long long>& v) {
for (auto q : v) printf("%lld ", q);
printf("\n");
}
struct typ {
int tp = -1;
long long a = 0, b = 0;
};
struct comp {
bool operator()(typ const& a, typ const& b) { return a.a < b.a; }
};
int main(int argc, char const* argv[]) {
int t = 1;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<string> v(n);
int i;
for (i = 0; i < n; i++) cin >> v[i];
bool ans = 0;
int a, b, c, d;
a = v[0][1] - '0';
b = v[1][0] - '0';
c = v[n - 1][n - 2] - '0';
d = v[n - 2][n - 1] - '0';
vector<pair<int, int>> out;
if (a == b && b == c && c == d) {
out.push_back({1, 2});
out.push_back({2, 1});
} else {
if (a == b) {
if (c != d) {
if (c == a)
out.push_back({n, n - 1});
else
out.push_back({n - 1, n});
}
} else if (c == d) {
if (a == c) {
out.push_back({1, 2});
} else {
out.push_back({2, 1});
}
} else {
if (a == c) {
out.push_back({1, 2});
out.push_back({n - 1, n});
} else {
out.push_back({1, 2});
out.push_back({n, n - 1});
}
}
}
printf("%d\n", (int)out.size());
for (auto q : out) printf("%d %d\n", q.first, q.second);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:65536000")
using namespace std;
const double eps = 1e-8;
void solve() {
string s, t, p;
cin >> s >> t >> p;
int t_pos = 0;
vector<int> a(26);
for (int i = 0; i < (int)(s.size()); ++i) {
while (t_pos < t.size() && s[i] != t[t_pos]) a[t[t_pos] - 'a']++, t_pos++;
if (t_pos >= t.size()) {
t_pos = -1;
break;
}
t_pos++;
}
if (t_pos == -1) {
cout << "NO";
return;
}
while (t_pos < t.size()) a[t[t_pos++] - 'a']++;
for (auto ch : p) a[ch - 'a']--;
for (int i = 0; i < (int)(26); ++i)
if (a[i] > 0) {
cout << "NO";
return;
}
cout << "YES";
}
void solve_multiple() {
int t;
cin >> t;
for (int i = 0; i < t; ++i) {
solve();
cout << endl;
}
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.precision(20);
solve_multiple();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int A[10003];
int N, M;
vector<int> t[100000];
int found;
vector<int> init(int l, int r, int node) {
if (l == r) return t[node] = vector<int>({A[l]});
int mid = (l + r) / 2;
vector<int> L = init(l, mid, 2 * node);
vector<int> R = init(mid + 1, r, 2 * node + 1);
vector<int> ret;
int posl = 0;
int posr = 0;
while (posl < L.size() && posr < R.size()) {
if (L[posl] < R[posr])
ret.push_back(L[posl++]);
else
ret.push_back(R[posr++]);
}
for (; posl < L.size(); posl++) ret.push_back(L[posl]);
for (; posr < R.size(); posr++) ret.push_back(R[posr]);
return t[node] = ret;
}
int query(int nl, int nr, int l, int r, int node, int num) {
if (l <= nl && nr <= r) {
if (t[node][lower_bound(t[node].begin(), t[node].end(), num) -
t[node].begin()] == num)
found = 1;
return lower_bound(t[node].begin(), t[node].end(), num) - t[node].begin();
}
if (r < nl || nr < l) return 0;
int nm = (nl + nr) / 2;
return query(nl, nm, l, r, 2 * node, num) +
query(nm + 1, nr, l, r, 2 * node + 1, num);
}
int main() {
cin >> N >> M;
for (int i = 0; i < N; i++) cin >> A[i];
init(0, N - 1, 1);
for (int i = 0; i < M; i++) {
int l, r, x;
cin >> l >> r >> x;
found = 0;
int smaller = query(0, N - 1, l - 1, r - 1, 1, A[x - 1]);
if (!found)
cout << "Yes\n";
else {
if (smaller == x - l)
cout << "Yes\n";
else
cout << "No\n";
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int t;
long long l, r;
void solve() {
long long a = 2 * l;
if (a <= 2 * (r - l)) {
cout << "NO" << '\n';
return;
}
cout << "YES" << '\n';
}
int main() {
cin >> t;
for (int i = 1; i <= t; i++) {
cin >> l >> r;
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int fx[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
const int fxx[8][2] = {{0, 1}, {1, 1}, {1, 0}, {1, -1},
{0, -1}, {-1, -1}, {-1, 0}, {-1, 1}};
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
inline void print_f(int n) { printf("Case #%d: ", n); }
inline int bounds_4(int xi, int xj, int yi, int yj, int i, int j) {
return ((i >= xi) && (i <= xj) && (j >= yi) && (j <= yj));
}
inline int Bounds(int i, int j, int S) {
return bounds_4(0, 0, S - 1, S - 1, i, j);
}
vector<string> split(const string& s, char delim) {
stringstream ss(s);
string item;
vector<string> tokens;
while (getline(ss, item, delim)) {
tokens.push_back(item);
}
return tokens;
}
vector<vector<int> > edges;
void insert(int a, int b, bool dir) {
edges[a].push_back(b);
if (!dir) insert(b, a, true);
}
vector<int> color;
set<int> white;
set<int> black;
bool bfs(int src) {
color[src] = 1;
white.insert(src);
;
queue<int> q;
q.push(src);
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < edges[u].size(); i++) {
int v = edges[u][i];
if (color[v] != 0) {
if (color[v] == color[u])
return false;
else
continue;
} else {
if (color[u] == 1) {
color[v] = 2;
black.insert(v);
;
} else {
color[v] = 1;
white.insert(v);
;
}
q.push(v);
}
}
}
return true;
}
int main() {
int N, M;
cin >> N >> M;
edges.resize(N);
color.resize(N);
for (int i = 0; i < N; i++) color[i] = 0;
int u, v;
for (int i = 0; i < M; i++) {
cin >> u >> v;
u--;
v--;
insert(u, v, false);
}
bool possible = true;
for (int i = 0; i < N && possible; i++) {
if (color[i] == 0) {
possible = bfs(i);
}
}
if (!possible) {
cout << -1 << "\n";
;
} else {
cout << white.size() << "\n";
;
for (set<int>::iterator it = white.begin(); it != white.end(); it++)
cout << ((*it) + 1) << " ";
cout << "\n";
;
cout << black.size() << "\n";
;
for (set<int>::iterator it = black.begin(); it != black.end(); it++)
cout << ((*it) + 1) << " ";
cout << "\n";
;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T;
scanf("%d", &T);
while (T--) {
long long n;
scanf("%lld", &n);
int turn = 0;
long long me = 0;
while (n > 0) {
if (n & 1) {
--n;
if (!turn) me++;
} else {
if (n == 4 || ((n / 2) & 1)) {
n /= 2;
if (!turn) me += n;
} else {
--n;
if (!turn) me++;
}
}
turn = 1 - turn;
}
printf("%lld\n", me);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
map<int, int> dp, prime;
int get_mask(int mask, int sh) {
int nm = 0;
for (int i = 1; i <= 30; ++i) {
if (mask & (1 << i)) {
if (i < sh) nm |= (1 << i);
if (i > sh) nm |= (1 << (i - sh));
}
}
return nm;
}
int fn(int mask) {
if (mask == 0) return 0;
if (dp.count(mask)) return dp[mask];
int ans = 0;
map<int, int> grundy;
for (int i = 1; i <= 30; ++i) {
int nw = get_mask(mask, i);
if (nw == mask) break;
grundy[fn(nw)] = 1;
}
for (int i = 0;; ++i)
if (grundy[i] == 0) return dp[mask] = i;
}
void add(long long val) {
for (long long i = 2; i * i <= val; ++i) {
if (val % i == 0) {
int cnt = 0;
while (val % i == 0) {
val /= i;
cnt += 1;
}
prime[i] |= (1 << cnt);
}
}
if (val > 1) prime[val] |= (1 << 1);
}
int main() {
int val;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &val);
add(val);
}
int ans = 0;
for (auto it : prime) {
ans ^= fn(it.second);
}
if (ans)
printf("Mojtaba\n");
else
printf("Arpa\n");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string st;
getline(cin, st);
string s = "";
bool b = false;
for (int i = 0; i < (int)st.size(); i++) {
if (st[i] == '\"')
b = !b;
else if (b == false && st[i] == ' ') {
if (!s.empty() || (i > 0 && st[i - 1] == '\"')) {
cout << "<" << s << ">" << endl;
s = "";
}
} else
s += st[i];
}
int i = st.size();
if (!s.empty() || (i > 0 && st[i - 1] == '\"'))
cout << "<" << s << ">" << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3003;
const long long INF = (1LL << 60LL);
int n;
pair<int, int> a[MAXN];
long long dp[MAXN][MAXN];
int main() {
cin.sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i].first >> a[i].second;
sort(a + 1, a + n + 1);
dp[1][1] = a[1].second;
for (int i = 2; i <= n; i++) {
dp[i][i] = INF;
for (int j = 1; j < i; j++) {
dp[i][j] = dp[i - 1][j] + a[i].first - a[j].first;
dp[i][i] = min(dp[i][i], dp[i - 1][j] + a[i].second);
}
}
long long ans = INF;
for (int i = 1; i <= n; i++) ans = min(ans, dp[n][i]);
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, nr0 = 0, nr1 = 0, i;
char a[200005];
cin >> n;
cin >> a;
for (i = 0; i < n; i++) {
if (a[i] == '0') nr0++;
if (a[i] == '1') nr1++;
}
if (nr0 == nr1)
cout << 0 << " ";
else if (nr0 < nr1)
cout << n - 2 * nr0;
else
cout << n - 2 * nr1;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int s = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = 0;
c = getchar();
}
while (c >= '0' && c <= '9')
s = (s << 1) + (s << 3) + (c ^ 48), c = getchar();
return f ? s : -s;
}
const int N = 2e7 + 10;
int r, c, n, ans, fa[N], vis[3010][6010];
int Hash(int x, int y) { return (x - 1) * c * 2 + y; }
int getfa(int x) { return fa[x] == x ? x : fa[x] = getfa(fa[x]); }
int dx[8] = {1, 0, -1, 0, 1, 1, -1, -1}, dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
bool check(int x, int y) {
int sx = x, sy = y + c;
for (register int i = 0; i < 8; ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (ny < 1)
ny = c * 2;
else if (ny == c * 2 + 1)
ny = 1;
if (nx > 0 && nx <= r && vis[nx][ny]) {
for (register int j = 0; j < 8; ++j) {
int nx2 = sx + dx[j], ny2 = sy + dy[j];
if (ny2 < 1)
ny2 = c * 2;
else if (ny2 == c * 2 + 1)
ny2 = 1;
if (nx2 > 0 && nx2 <= r && vis[nx2][ny2]) {
if (getfa(Hash(nx, ny)) == getfa(Hash(nx2, ny2))) return 0;
}
}
}
}
return 1;
}
void Del(int x, int y) {
int sx = x, sy = y + c;
for (register int i = 0; i < 8; ++i) {
int nx = x + dx[i], ny = y + dy[i];
if (ny == 0)
ny = c * 2;
else if (ny == c * 2 + 1)
ny = 1;
if (nx > 0 && nx <= r && vis[nx][ny]) {
int fax = getfa(Hash(nx, ny)), fay = getfa(Hash(x, y));
fa[fay] = fax;
}
int nx2 = sx + dx[i], ny2 = sy + dy[i];
if (ny2 == 0)
ny2 = c * 2;
else if (ny2 == c * 2 + 1)
ny2 = 1;
if (nx2 > 0 && nx2 <= r && vis[nx2][ny2]) {
int fax = getfa(Hash(sx, sy)), fay = getfa(Hash(nx2, ny2));
fa[fax] = fay;
}
}
vis[x][y] = vis[sx][sy] = 1;
}
int main() {
r = read();
c = read();
n = read();
ans = 0;
if (c == 1)
puts("0");
else {
memset(vis, 0, sizeof vis);
int ans = 0;
for (register int i = 1; i <= r; ++i)
for (register int j = 1; j <= 2 * c; ++j) fa[Hash(i, j)] = Hash(i, j);
for (register int i = 1; i <= n; ++i) {
int x = read(), y = read();
if (check(x, y)) {
Del(x, y), ++ans;
}
}
printf("%d\n", ans);
}
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string number;
int c = 0;
scanf("%d", &n);
cin >> number;
for (int i = 0; i < number.size(); i++) {
if (number[i] == '8') ++c;
}
printf("%d\n", min(c, (n / 11)));
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double pi = acos(-1.0);
const double eps = 1e-9;
struct ppc {
long long l, res, r;
ppc() {
l = -(1ll << 50);
res = -(1ll << 50);
r = -(1ll << 50);
}
} t[4 * 200100], p1;
long long d[4 * 200100], h[4 * 200100], n, m, a, b, sum[4 * 200100];
void build(int v, int l, int r) {
if (l == r) {
t[v].res = 0;
t[v].l = 2 * h[r];
t[v].r = 2 * h[r];
return;
}
int tm = (l + r) / 2;
build(v + v, l, tm);
build(v + v + 1, tm + 1, r);
t[v].res = max(t[v + v].res,
max(t[v + v + 1].res, d[tm] + t[v + v].r + t[v + v + 1].l));
t[v].l = max(t[v + v].l, sum[tm] - sum[l - 1] + t[v + v + 1].l);
t[v].r = max(t[v + v + 1].r, sum[r - 1] - sum[tm - 1] + t[v + v].r);
}
ppc get(int v, int l, int r, int x, int y) {
if (l > y || r < x) return p1;
if (x <= l && r <= y) {
return t[v];
}
int tm = (l + r) / 2;
ppc r1 = get(v + v, l, tm, x, y);
ppc r2 = get(v + v + 1, tm + 1, r, x, y);
ppc res;
res.res = max(r1.res, max(r2.res, d[tm] + r1.r + r2.l));
res.l = max(r1.l, sum[tm] - sum[l - 1] + r2.l);
res.r = max(r2.r, sum[r - 1] - sum[tm - 1] + r1.r);
return res;
}
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cin >> d[i];
d[n + i] = d[i];
}
for (int i = 1; i <= n; i++) {
cin >> h[i];
h[n + i] = h[i];
}
for (int i = 1; i <= n + n; i++) sum[i] = sum[i - 1] + d[i];
build(1, 1, n + n);
for (int i = 1; i <= m; i++) {
cin >> a >> b;
if (a <= b) {
cout << get(1, 1, n + n, b + 1, n + a - 1).res << endl;
} else {
cout << get(1, 1, n + n, b + 1, a - 1).res << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int c1, c2, c3, c4, n, m, i, x, y;
scanf("%d", &c1);
scanf("%d", &c2);
scanf("%d", &c3);
scanf("%d", &c4);
scanf("%d", &n);
scanf("%d", &m);
int b1[n + 1];
int s1[m + 1];
for (i = 1; i <= n; i++) scanf("%d", &b1[i]);
for (i = 1; i <= m; i++) scanf("%d", &s1[i]);
int sum1 = 0, sum2 = 0, sum = 0;
for (i = 1; i <= n; i++) {
x = b1[i] * c1;
y = c2;
if (x >= y)
sum1 += y;
else
sum1 += x;
}
if (sum1 >= c3) sum1 = c3;
for (i = 1; i <= m; i++) {
x = s1[i] * c1;
y = c2;
if (x >= y)
sum2 += y;
else
sum2 += x;
}
if (sum2 >= c3) sum2 = c3;
sum = sum1 + sum2;
if (sum >= c4) sum = c4;
printf("%d\n", sum);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
map<pair<int, int>, bool> mark;
int vis[200009];
bool check(vector<int>& tmp) {
sort(tmp.begin(), tmp.end());
for (int i = 0; i < 5; i++)
for (int j = i + 1; j < 5; j++)
if (mark[{tmp[i], tmp[j]}]) return 0;
return 1;
}
bool good(vector<int> tmp) {
for (int i = 0; i < 5; i++)
for (int j = i + 1; j < 5; j++)
if (!mark[{tmp[i], tmp[j]}]) return 0;
return 1;
}
int T = 100;
int main() {
int n, m;
scanf("%d%d", &n, &m);
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
if (u > v) swap(u, v);
mark[{u, v}] = 1;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<int> dis(1, n);
if (n <= T) {
for (int i = 1; i < n; i++)
for (int j = i + 1; j < n; j++)
for (int k = j + 1; k <= n; k++)
for (int h = k + 1; h <= n; h++)
for (int l = h + 1; l <= n; l++)
if (good(vector<int>{i, j, k, h, l})) {
printf("%d %d %d %d %d\n", i, j, k, h, l);
return 0;
}
}
vector<int> v;
while (1.0 * clock() / CLOCKS_PER_SEC < 0.98) {
for (int i = 0, nd; i < 5; i++) {
nd = dis(rng);
while (vis[nd]) nd = dis(rng);
v.push_back(nd);
vis[nd] = 1;
}
if (check(v)) {
for (int i = 0; i < 5; i++) printf("%d ", v[i]);
puts("");
return 0;
}
for (int i = 0; i < 5; i++) vis[v[i]] = 0;
v.clear();
}
puts("-1");
return 0;
}
| 7 |
//W4P3R
/*
----------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------
--------------------------#############------------------#############------------------------------------
------------------------###############----------------###############------------------------------------
-----------------------####---------------------------####------------------------------------------------
----------------------####---------------------------####-------------------------------------------------
----------------------####---------------------------####-------------------------------------------------
----------------------####---------####--------------####---------####------------------------------------
----------------------####---------####--------------####---------####------------------------------------
----------------------####-----------##--------------####-----------##------------------------------------
-----------------------####----------##---------------####----------##------------------------------------
------------------------###############----------------###############------------------------------------
--------------------------#############------------------#############------------------------------------
----------------------------------------------------------------------------------------------------------
----------------------------------------------------------------------------------------------------------
-----------------------------------------------------------------------------------------------------------
GG
*/
#include<bits/stdc++.h>
#define inf 1e9
#define eps 1e-6
#define mp make_pair
#define pb push_back
#define fr first
#define sd second
#define pa pair<ll,ll>
#define FOR(i,a,b) for(ll i=a;i<=b;i++)
#define REP(i,a,b) for(ll i=a;i>=b;i--)
#define MEM(a) memset(a,0,sizeof(a))
#define N 100010
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef double db;
inline ll read()
{
char ch=getchar();
ll s=0,w=1;
while(ch<'0'||ch>'9'){if(ch=='-')w=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){s=s*10+ch-'0';ch=getchar();}
return s*w;
}
inline ll lowbit(ll x){return x&(-x);}
ll n;
struct node{ll a,c,id;}t[N];
inline ll cmp(node a,node b){return a.a<b.a;}
int main()
{
//ios::sync_with_stdio(false);
//freopen(".in","r",stdin);
//freopen(".out","w",stdout);
n=read();ll ans=0;
FOR(i,1,n)t[i].a=read(),t[i].c=read(),t[i].id=i,ans+=t[i].c;
sort(t+1,t+n+1,cmp);
ll id=0;
ll nowv=t[1].c+t[1].a;
FOR(i,1,n)
{
ans+=max(0LL,t[i].a-nowv);
nowv=max(nowv,t[i].a+t[i].c);
}
cout<<ans<<'\n';
return 0;
}
//gl
| 7 |
#include <bits/stdc++.h>
using namespace std;
template <class Read>
void in(Read &x) {
x = 0;
int f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
f |= (ch == '-');
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
x = f ? -x : x;
return;
}
int n, m, top;
long long f[1 << 20][25], d[25][25], a[1 << 20], k[1 << 20], ans;
inline int lowbit(int x) { return x & -x; }
int main() {
in(n);
in(m);
for (int i = 1; i <= m; i++) {
int x, y;
in(x);
in(y);
d[x][y] = d[y][x] = 1;
}
for (int i = 1; i <= n; i++) f[1 << i - 1][i] = 1;
for (int s = 1; s < (1 << n); s++) {
int i = 0;
while (!(s & (1 << i))) i++;
for (int j = 1; j <= n; j++) {
if (f[s][j] == 0) continue;
for (int k = i + 1; k <= n; k++) {
if (!d[j][k]) continue;
if (!(s & (1 << k - 1)))
f[s | (1 << k - 1)][k] = f[s | (1 << k - 1)][k] + f[s][j];
else if (k == i + 1)
ans += f[s][j];
}
}
}
cout << ((ans - m) >> 1) << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const double pi = acos(-1.0);
using namespace std;
int main() {
int a, b;
scanf("%d %d", &a, &b);
printf("%d\n", ((a - 1) * (6) + 5) * b);
for (int i = 0; i < a; ++i) {
printf("%d %d %d %d\n", (6 * i + 1) * b, (6 * i + 2) * b, (6 * i + 3) * b,
(6 * i + 5) * b);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, w1 = 0, w2 = 0, l;
string s;
cin >> s;
l = s.length();
for (int i = 0; i < l; ++i) {
if (s[i] == '^') {
a = i;
break;
}
}
for (int i = 0; i < l; ++i) {
if (isdigit(s[i])) {
if (i > a) {
w1 += (i - a) * (s[i] - '0');
}
if (i < a) {
w2 += (a - i) * (s[i] - '0');
}
}
}
if (w1 > w2)
cout << "right";
else if (w2 > w1)
cout << "left";
else
cout << "balance";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int x, i, s = 0, k = 0;
cin >> x;
long long n[x];
for (i = 0; i < x; i++) {
cin >> n[i];
s = s + n[i] * k;
k = k + 4;
}
cout << s << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int STALPH = 26;
struct STNode {
char *s;
int len;
int childs[STALPH];
int suffix;
STNode(char *s, int len) : s(s), len(len) {
memset(childs, -1, sizeof(childs));
suffix = -1;
}
};
struct SuffixTree {
int root;
vector<STNode> nodes;
int addnode(char *s, int len) {
nodes.push_back(STNode(s, len));
return ((int)(nodes).size()) - 1;
}
vector<int> build(char *s) {
nodes.clear();
root = addnode(NULL, 0);
int n = strlen(s), atnode = root, atedge = 0, atlen = 0, pint = -1,
pleaf = -1;
for (int i = (0); i <= (n); ++i) {
while (true) {
int tonode = atedge == n ? -1 : nodes[atnode].childs[s[atedge] - 'a'];
if (tonode != -1 && atlen >= nodes[tonode].len) {
atedge += nodes[tonode].len;
atlen -= nodes[tonode].len;
atnode = tonode;
continue;
}
if (tonode == -1) {
if (i != n) {
int leaf = addnode(s + i, n - i);
nodes[atnode].childs[nodes[leaf].s[0] - 'a'] = leaf;
if (pleaf != -1) nodes[pleaf].suffix = leaf;
pleaf = leaf;
} else {
if (pleaf != -1) nodes[pleaf].suffix = atnode;
pleaf = -1;
}
if (pint != -1) nodes[pint].suffix = atnode;
pint = -1;
} else if (i == n || nodes[tonode].s[atlen] != s[i]) {
int branch = addnode(nodes[tonode].s, atlen);
nodes[tonode].s += atlen, nodes[tonode].len -= atlen;
nodes[atnode].childs[nodes[branch].s[0] - 'a'] = branch;
nodes[branch].childs[nodes[tonode].s[0] - 'a'] = tonode;
if (i != n) {
int leaf = addnode(s + i, n - i);
nodes[branch].childs[nodes[leaf].s[0] - 'a'] = leaf;
if (pleaf != -1) nodes[pleaf].suffix = leaf;
pleaf = leaf;
} else {
if (pleaf != -1) nodes[pleaf].suffix = branch;
pleaf = -1;
}
if (pint != -1) nodes[pint].suffix = branch;
pint = branch;
} else {
if (pint != -1) assert(atlen == 0), nodes[pint].suffix = atnode;
pint = -1;
++atlen;
break;
}
if (atnode == root) {
atedge++;
if (atlen == 0) {
assert(pint == -1);
break;
} else
--atlen;
} else {
atnode = nodes[atnode].suffix;
}
}
}
vector<int> ret(n + 1, -1);
for (int at = 1, len = n; at != -1; at = nodes[at].suffix, --len)
ret[len] = at;
return ret;
}
void print(int at, int depth = 0) {
for (int i = (0); i < (depth); ++i) printf(" ");
if (nodes[at].s == NULL)
printf("<root>");
else
printf("'%.*s'", nodes[at].len, nodes[at].s);
printf(": id=%d", at);
if (nodes[at].suffix != -1) printf(" suffix=%d", nodes[at].suffix);
puts("");
for (int i = (0); i < (STALPH); ++i)
if (nodes[at].childs[i] != -1) print(nodes[at].childs[i], depth + 1);
}
};
struct TNode {
vector<int> ch;
int parlen;
int sz, heavy, par, pathid, pathidx, rootlen;
};
struct Tree {
int root;
vector<TNode> nodes;
};
struct HLPath {
vector<int> nodes;
};
struct HeavyLight {
Tree *t;
vector<int> prelst;
vector<HLPath> paths;
void dfspre(int at) {
prelst.push_back(at);
for (int i = (0); i < (((int)(t->nodes[at].ch).size())); ++i)
dfspre(t->nodes[at].ch[i]);
}
void build(Tree *_t) {
t = _t;
prelst.clear();
dfspre(t->root);
for (int i = ((int)(prelst).size()) - 1; i >= 0; --i) {
int at = prelst[i];
t->nodes[at].sz = 1, t->nodes[at].heavy = -1, t->nodes[at].par = -1;
for (int j = (0); j < (((int)(t->nodes[at].ch).size())); ++j) {
int to = t->nodes[at].ch[j];
t->nodes[to].par = at;
t->nodes[at].sz += t->nodes[to].sz;
if (t->nodes[at].heavy == -1 ||
t->nodes[to].sz > t->nodes[t->nodes[at].heavy].sz)
t->nodes[at].heavy = to;
}
}
paths.clear();
for (int i = (0); i < (((int)(prelst).size())); ++i) {
int at = prelst[i];
t->nodes[at].rootlen =
t->nodes[at].par == -1
? 0
: t->nodes[t->nodes[at].par].rootlen + t->nodes[at].parlen;
if (t->nodes[at].par != -1 && t->nodes[t->nodes[at].par].heavy == at)
continue;
HLPath path;
for (int x = at; x != -1; x = t->nodes[x].heavy)
t->nodes[x].pathid = ((int)(paths).size()),
t->nodes[x].pathidx = ((int)(path.nodes).size()),
path.nodes.push_back(x);
paths.push_back(path);
}
}
vector<pair<int, int>> decomposepathtoroot(int at) {
vector<pair<int, int>> ret;
while (at != -1) {
ret.push_back(make_pair(t->nodes[at].pathid, t->nodes[at].pathidx));
at = t->nodes[paths[t->nodes[at].pathid].nodes[0]].par;
}
reverse(ret.begin(), ret.end());
return ret;
}
void print() {
for (int i = (0); i < (((int)(paths).size())); ++i) {
printf("path%d:", i);
for (int j = (0); j < (((int)(paths[i].nodes).size())); ++j)
printf(" %d", paths[i].nodes[j]);
puts("");
}
}
};
const int MAXLEN = 200000;
const int MAXQ = 200000;
const int MAXLG = 20;
char s[MAXLEN + 1];
int slen;
int nq;
int ql[MAXQ], qr[MAXQ];
long long qans[MAXQ];
SuffixTree sufftree;
vector<int> suffixids;
Tree t;
HeavyLight heavylight;
struct BIT {
int n;
pair<int, long long> all;
vector<pair<int, long long>> bit;
BIT() {}
BIT(int _n) {
n = _n;
all = make_pair(0, 0LL);
bit = vector<pair<int, long long>>(n + 1, make_pair(0, 0LL));
}
void mod(int idx, int a, long long b) {
all.first += a;
all.second += b;
++idx;
while (idx <= n) {
bit[idx].first += a;
bit[idx].second += b;
idx += idx & -idx;
}
}
pair<int, long long> get(int idx) {
pair<int, long long> ret = make_pair(0, 0LL);
++idx;
while (idx > 0) {
ret.first += bit[idx].first;
ret.second += bit[idx].second;
idx -= idx & -idx;
}
return ret;
}
void reset(int _n) {
n = _n;
all = make_pair(0, 0LL);
for (int i = (1); i <= (n); ++i) bit[i] = make_pair(0, 0LL);
}
};
struct P {
int id, pathidx, len;
P(int id, int pathidx, int len) : id(id), pathidx(pathidx), len(len) {}
P() {}
};
struct Q {
int id, pathidx, len;
Q(int id, int pathidx, int len) : id(id), pathidx(pathidx), len(len) {}
Q() {}
};
struct E {
int kind, id, pathidx, key, val;
E(int kind, int id, int pathidx, int key, int val)
: kind(kind), id(id), pathidx(pathidx), key(key), val(val) {}
E() {}
};
bool operator<(const E &a, const E &b) {
if (2 * a.key + a.kind != 2 * b.key + b.kind)
return 2 * a.key + a.kind < 2 * b.key + b.kind;
return a.id < b.id;
}
BIT bit(2 * MAXLEN);
vector<vector<P>> plst1;
vector<vector<P>> plst2;
vector<vector<Q>> qlst1;
vector<vector<Q>> qlst2;
vector<vector<Q>> qlst3;
void precalc() {
auto tstart = std::chrono::system_clock::now();
plst1 = vector<vector<P>>(((int)(heavylight.paths).size()));
plst2 = vector<vector<P>>(((int)(heavylight.paths).size()));
vector<vector<pair<int, P>>> ptmp2(2 * slen);
for (int id = (0); id < (slen); ++id) {
int at = suffixids[slen - id];
while (at != -1) {
int pathid = t.nodes[at].pathid, pathidx = t.nodes[at].pathidx,
len = t.nodes[at].rootlen;
plst1[pathid].push_back(P(id, pathidx, len));
ptmp2[id + len].push_back(make_pair(pathid, P(id, pathidx, len)));
at = t.nodes[heavylight.paths[pathid].nodes[0]].par;
}
}
for (int i = (0); i < (((int)(ptmp2).size())); ++i)
for (int j = (0); j < (((int)(ptmp2[i]).size())); ++j) {
auto cur = ptmp2[i][j];
plst2[cur.first].push_back(cur.second);
}
fprintf(stderr, "\t%lld\n",
(long long)((std::chrono::system_clock::now() - tstart).count()));
qlst1 = vector<vector<Q>>(((int)(heavylight.paths).size()));
vector<vector<pair<int, Q>>> qtmp1(slen);
qlst2 = vector<vector<Q>>(((int)(heavylight.paths).size()));
vector<vector<pair<int, Q>>> qtmp2(slen);
qlst3 = vector<vector<Q>>(((int)(heavylight.paths).size()));
vector<vector<pair<int, Q>>> qtmp3(2 * slen);
for (int id = (0); id < (nq); ++id) {
int at = suffixids[slen - ql[id]];
while (at != -1) {
int pathid = t.nodes[at].pathid, pathidx = t.nodes[at].pathidx,
len = t.nodes[at].rootlen,
firstnode = heavylight.paths[pathid].nodes[0],
h = t.nodes[firstnode].rootlen - t.nodes[firstnode].parlen;
if (h < qr[id] - ql[id] + 1) {
{
int lo = 0, hi = pathidx + 1;
while (lo + 1 < hi) {
int mi = lo + (hi - lo) / 2;
if (t.nodes[heavylight.paths[pathid].nodes[mi - 1]].rootlen >=
qr[id] - ql[id] + 1)
hi = mi;
else
lo = mi;
}
pathidx = lo;
}
len = min(t.nodes[heavylight.paths[pathid].nodes[pathidx]].rootlen,
qr[id] - ql[id] + 1);
qtmp1[ql[id]].push_back(make_pair(pathid, Q(id, pathidx, len)));
qtmp2[qr[id]].push_back(make_pair(pathid, Q(id, pathidx, len)));
qtmp3[qr[id] - len + slen].push_back(
make_pair(pathid, Q(id, pathidx, len)));
}
at = t.nodes[firstnode].par;
}
}
for (int i = (0); i < (((int)(qtmp1).size())); ++i)
for (int j = (0); j < (((int)(qtmp1[i]).size())); ++j) {
auto cur = qtmp1[i][j];
qlst1[cur.first].push_back(cur.second);
}
for (int i = (0); i < (((int)(qtmp2).size())); ++i)
for (int j = (0); j < (((int)(qtmp2[i]).size())); ++j) {
auto cur = qtmp2[i][j];
qlst2[cur.first].push_back(cur.second);
}
for (int i = (0); i < (((int)(qtmp3).size())); ++i)
for (int j = (0); j < (((int)(qtmp3[i]).size())); ++j) {
auto cur = qtmp3[i][j];
qlst3[cur.first].push_back(cur.second);
}
fprintf(stderr, "\t%lld\n",
(long long)((std::chrono::system_clock::now() - tstart).count()));
}
void solve() {
suffixids = sufftree.build(s);
t.nodes.clear();
t.root = sufftree.root;
for (int i = (0); i < (((int)(sufftree.nodes).size())); ++i) {
TNode tnode;
tnode.parlen = sufftree.nodes[i].len;
for (int j = (0); j < (STALPH); ++j)
if (sufftree.nodes[i].childs[j] != -1)
tnode.ch.push_back(sufftree.nodes[i].childs[j]);
t.nodes.push_back(tnode);
}
heavylight.build(&t);
precalc();
for (int pathid = (0); pathid < (((int)(heavylight.paths).size()));
++pathid) {
int firstnode = heavylight.paths[pathid].nodes[0],
h = t.nodes[firstnode].rootlen - t.nodes[firstnode].parlen,
pathlen = ((int)(heavylight.paths[pathid].nodes).size());
vector<P> &cplst1 = plst1[pathid];
vector<P> &cplst2 = plst2[pathid];
vector<Q> &cqlst1 = qlst1[pathid];
vector<Q> &cqlst2 = qlst2[pathid];
vector<Q> &cqlst3 = qlst3[pathid];
{
int pidx = 0;
pair<int, long long> all = make_pair(0, 0LL);
for (int qidx = (0); qidx < (((int)(cqlst2).size())); ++qidx) {
while (pidx < ((int)(cplst1).size()) &&
cplst1[pidx].id + h <= qr[cqlst2[qidx].id] + 1)
all.first += 1, all.second -= cplst1[pidx].id + h, ++pidx;
qans[cqlst2[qidx].id] +=
(long long)(qr[cqlst2[qidx].id] + 1) * all.first + all.second;
}
}
{
int pidx = 0;
bit.reset(pathlen);
for (int qidx = (0); qidx < (((int)(cqlst2).size())); ++qidx) {
while (pidx < ((int)(cplst2).size()) &&
cplst2[pidx].id + cplst2[pidx].len <= qr[cqlst2[qidx].id] + 1)
bit.mod(cplst2[pidx].pathidx, +1, cplst2[pidx].id + cplst2[pidx].len),
++pidx;
pair<int, long long> pref = bit.get(cqlst2[qidx].pathidx - 1),
all = bit.all;
qans[cqlst2[qidx].id] +=
(long long)-(qr[cqlst2[qidx].id] + 1) * pref.first + pref.second;
}
}
{
int pidx = 0;
bit.reset(pathlen);
for (int qidx = (0); qidx < (((int)(cqlst3).size())); ++qidx) {
while (pidx < ((int)(cplst1).size()) &&
cplst1[pidx].id <= qr[cqlst3[qidx].id] + 1 - cqlst3[qidx].len)
bit.mod(cplst1[pidx].pathidx, +1, cplst1[pidx].id), ++pidx;
pair<int, long long> pref = bit.get(cqlst3[qidx].pathidx - 1),
all = bit.all;
qans[cqlst3[qidx].id] +=
(long long)-(qr[cqlst3[qidx].id] + 1 - cqlst3[qidx].len) *
(all.first - pref.first) +
(all.second - pref.second);
}
}
{
int pidx = 0;
bit.reset(pathlen);
for (int qidx = (0); qidx < (((int)(cqlst1).size())); ++qidx) {
while (pidx < ((int)(cplst1).size()) &&
cplst1[pidx].id <= ql[cqlst1[qidx].id] - 1)
bit.mod(cplst1[pidx].pathidx, +1, cplst1[pidx].len), ++pidx;
pair<int, long long> pref = bit.get(cqlst1[qidx].pathidx - 1),
all = bit.all;
qans[cqlst1[qidx].id] -= (long long)-(cqlst1[qidx].len) * pref.first +
pref.second +
(long long)(cqlst1[qidx].len - h) * all.first;
}
}
}
}
void run() {
scanf("%s", s);
slen = strlen(s);
scanf("%d", &nq);
for (int i = (0); i < (nq); ++i)
scanf("%d%d", &ql[i], &qr[i]), --ql[i], --qr[i];
solve();
for (int i = (0); i < (nq); ++i) printf("%lld\n", qans[i]);
}
void stress() {
std::mt19937 rng(231789);
for (int rep = (0); rep < (10); ++rep) {
slen = MAXLEN;
for (int i = (0); i < (slen); ++i) s[i] = 'a' + rng() % 2;
s[slen] = '\0';
nq = MAXQ;
for (int i = (0); i < (nq); ++i) {
ql[i] = rng() % slen, qr[i] = rng() % slen;
if (ql[i] > qr[i]) swap(ql[i], qr[i]);
}
auto tstart = std::chrono::system_clock::now();
solve();
long long chk = 0;
for (int i = (0); i < (nq); ++i) chk ^= qans[i];
auto tend = std::chrono::system_clock::now();
auto duration = (long long)((tend - tstart).count());
printf("duration: %lld (chk=%lld)\n", duration, chk);
}
}
int main() {
run();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout << fixed;
cout << setprecision(10);
int n;
cin >> n;
double angle[n];
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
angle[i] = atan2(y, x) * 180 / 3.14159265359;
}
sort(angle, angle + n);
double val = 360 - angle[n - 1] + angle[0];
for (int i = 0; i < n - 1; i++) val = max(val, angle[i + 1] - angle[i]);
cout << 360 - val << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
long long mullog(long long a, long long b, long long c) {
long long ret = 0ll;
while (b) {
if (b & 1ll) ret = (ret + a) % c;
a = (a + a) % c;
b >>= (1ll);
}
return ret;
}
long long powlog(long long a, long long b, long long c) {
long long ret = 1ll;
while (b) {
if (b & 1ll) ret = (ret * a) % c;
a = (a * a) % c;
b >>= (1ll);
}
return ret;
}
int powlog(int a, int b, int c) {
int ret = 1;
while (b) {
if (b & 1) ret = (ret * a) % c;
a = (a * a) % c;
b >>= (1);
}
return ret;
}
long long powLog(long long a, long long b, long long c) {
long long ret = 1ll;
while (b) {
if (b & 1ll) ret = mullog(ret, a, c);
a = mullog(a, a, c);
b >>= (1ll);
}
return ret;
}
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
int dirx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int diry[8] = {0, -1, 0, 1, 1, 1, -1, -1};
using namespace std;
bool a[1000010];
bool b[1000010];
int main() {
long long h1, y1, a1, x1, h2, y2, a2, x2, m;
scanf("%lld", &m);
scanf("%lld", &h1);
scanf("%lld", &a1);
scanf("%lld", &x1);
scanf("%lld", &y1);
scanf("%lld", &h2);
scanf("%lld", &a2);
scanf("%lld", &x2);
scanf("%lld", &y2);
long long cnt1, cnt2;
for (cnt1 = 0;; cnt1++) {
if (h1 == a1) break;
a[(int)h1] = true;
h1 = ((1ll * h1 * x1) % m + y1) % m;
if (a[(int)h1] == true) {
cnt1 = -1;
break;
}
}
for (cnt2 = 0;; cnt2++) {
if (h2 == a2) break;
b[(int)h2] = true;
h2 = ((1ll * h2 * x2) % m + y2) % m;
if (b[(int)h2] == true) {
cnt2 = -1;
break;
}
}
long long ans;
if (cnt1 == -1 || cnt2 == -1)
ans = -1;
else {
if (cnt1 == cnt2) {
cout << cnt1 << endl;
return 0;
}
h1 = ((1ll * h1 * x1) % m + y1) % m;
long long k1, k2, t1;
memset(a, 0, sizeof a);
for (k1 = 1;; k1++) {
if (h1 == a1) break;
a[h1] = true;
h1 = ((1ll * h1 * x1) % m + y1) % m;
if (a[h1] == true) {
if (h1 == a1) continue;
k1 = 0;
break;
}
}
memset(a, 0, sizeof a);
h2 = ((1ll * h2 * x2) % m + y2) % m;
for (k2 = 1;; k2++) {
if (h2 == a2) break;
a[h2] = true;
h2 = ((1ll * h2 * x2) % m + y2) % m;
if (a[h2] == true) {
if (h2 == a2) continue;
k2 = 0;
break;
}
}
if (cnt1 < cnt2) {
swap(cnt1, cnt2);
swap(k1, k2);
}
for (t1 = 0; t1 < k2; t1++)
if ((k1 * t1 + cnt1) % k2 == cnt2 % k2) break;
if (t1 == k2) {
ans = -1;
} else {
ans = k1 * t1 + cnt1;
}
}
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long prime[22] = {2, 3, 5, 7, 11, 13, 17, 19,
23, 29, 31, 37, 41, 43, 47, 53};
int n;
long long ans;
void dfs(int pos, long long tmp, long long num) {
if (num > n) return;
if (num == n && ans > tmp) {
ans = tmp;
return;
}
for (int i = 1; i <= 63; i++) {
if (ans / prime[pos] < tmp) break;
tmp *= prime[pos];
dfs(pos + 1, tmp, num * (i + 1));
}
}
int main() {
ans = 0x7fffffffffffffff;
scanf("%d", &n);
dfs(0, 1, 1);
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int al, br, bl, ar;
inline void read() {
cin >> al >> ar;
cin >> bl >> br;
}
inline int check(int a, int b) {
int maxx = (a + 1) << 1;
int minn = a - 1;
return (b >= minn && b <= maxx);
}
int main() {
read();
int ret = 0;
ret |= check(al, br);
ret |= check(ar, bl);
if (ret)
printf("YES\n");
else
printf("NO\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int y;
cin >> y;
int Y = y;
while (true) {
set<int> s;
Y = Y + 1;
int y = Y;
int a = y % 10;
y = y / 10;
s.insert(a);
int b = y % 10;
y = y / 10;
s.insert(b);
int c = y % 10;
y = y / 10;
s.insert(c);
int d = y % 10;
y = y / 10;
s.insert(d);
if (s.size() == 4) {
break;
}
}
cout << Y << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, n, k, d, i, l, j, min;
cin >> t;
while (t--) {
cin >> n >> k >> d;
min = 10000000;
long long a[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i <= n - d; i++) {
set<long long> s;
for (j = i; j < i + d; j++) {
s.insert(a[j]);
}
if (s.size() < min) {
min = s.size();
}
}
cout << min << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1001], k;
int main() {
scanf("%d%d", &n, &k);
n = 2 * n + 1;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 2; i < n; i += 2)
if (k && a[i - 1] + 1 < a[i] && a[i] > a[i + 1] + 1) {
a[i]--;
k--;
}
for (int i = 1; i <= n; ++i) printf("%d ", a[i]);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[100], k;
long long dp[100000][100];
long long f(long long x, int i) {
if (i == -1) return x;
long long cnt = x;
if (x < 100000 && dp[x][i] != -1) {
return dp[x][i];
}
for (int k = 0; k <= i && a[k] <= x; k++) cnt -= f(x / a[k], k - 1);
if (x < 100000) dp[x][i] = cnt;
return cnt;
}
int main() {
long long n;
int m;
cin >> n >> m;
for (int i = 0; i < m; i++) cin >> a[i];
long long ans = 0;
sort(a, a + m);
memset(dp, -1, sizeof dp);
for (int i = 0; i < m; i++) {
if (n >= a[i]) {
long long cnt = n / a[i];
cnt = f(cnt, i - 1);
ans += cnt;
}
}
ans = n - ans;
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 8e5 + 50;
int n, q;
char s[200005];
struct node {
int d, m1, m2, m3, m4, m5;
} a[maxn];
void pushup(int rt) {
a[rt].d = a[rt << 1].d + a[rt << 1 | 1].d;
a[rt].m1 = max(a[rt << 1].m1, a[rt << 1 | 1].m1 + a[rt << 1].d);
a[rt].m2 = max(a[rt << 1].m2, a[rt << 1 | 1].m2 - 2 * a[rt << 1].d);
a[rt].m3 = max(a[rt << 1].m1 - 2 * a[rt << 1].d + a[rt << 1 | 1].m2,
max(a[rt << 1].m3, a[rt << 1 | 1].m3 - a[rt << 1].d));
a[rt].m4 = max(a[rt << 1].m2 + a[rt << 1].d + a[rt << 1 | 1].m1,
max(a[rt << 1].m4, a[rt << 1 | 1].m4 - a[rt << 1].d));
a[rt].m5 = max(max(a[rt << 1].m5, a[rt << 1 | 1].m5),
max(a[rt << 1].m3 + a[rt << 1 | 1].m1 + a[rt << 1].d,
a[rt << 1].m1 - a[rt << 1].d + a[rt << 1 | 1].m4));
}
void se(int u, int x) {
if (s[x] == '(')
a[u] = (node){1, 1, 0, 0, 1, 1};
else
a[u] = (node){-1, 0, 2, 2, 1, 1};
}
void build(int u, int l, int r) {
if (l == r) {
se(u, l);
return;
}
int mid = (l + r) >> 1;
build(u << 1, l, mid);
build(u << 1 | 1, mid + 1, r);
pushup(u);
}
void update(int u, int l, int r, int x) {
if (l == r) {
if (s[x] == '(')
s[x] = ')';
else
s[x] = '(';
se(u, x);
return;
}
int mid = (l + r) >> 1;
if (x <= mid)
update(u << 1, l, mid, x);
else
update(u << 1 | 1, mid + 1, r, x);
pushup(u);
}
int main() {
while (~scanf("%d%d%s", &n, &q, s + 1)) {
build(1, 1, 2 * (n - 1));
printf("%d\n", a[1].m5);
for (int x, y, i = 1; i <= q; i++) {
scanf("%d%d", &x, &y);
update(1, 1, 2 * (n - 1), x);
update(1, 1, 2 * (n - 1), y);
printf("%d\n", a[1].m5);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
ostream& operator<<(ostream& out, const pair<A, B>& p) {
return out << "(" << p.first << ", " << p.second << ")";
}
template <class A>
ostream& operator<<(ostream& out, const vector<A>& v) {
out << "[";
for (int i = 0; i < int((v).size()); i++) {
if (i) out << ", ";
out << v[i];
}
return out << "]";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> arr(n);
for (int& i : arr) cin >> i;
bool on = 0;
int cnt = 0;
int prev = INT_MIN;
vector<int> seg;
for (int i = 0; i < n; i++) {
if (arr[i] == prev) {
if (!on) on = 1, cnt = 1;
cnt++;
}
if (arr[i] != prev || i == n - 1) {
if (on) seg.push_back(cnt), cnt = 0, on = 0;
}
prev = arr[i];
}
long long res = n;
for (int& i : seg) {
res += ((long long)i * (long long)(i - 1)) / (long long)2;
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string int2string(int x) {
stringstream ss;
ss << x;
string tmp;
ss >> tmp;
return tmp;
}
int string2int(string s) {
stringstream ss;
ss << s;
int x;
ss >> x;
return x;
}
long long power(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long bigpow(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 int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
long long int r = a / gcd(a, b) * b;
return r;
}
int main() {
cin.tie(NULL);
cout.tie(NULL);
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[2 * n];
for (int i = 0; i < 2 * n; i++) cin >> a[i];
set<int> s;
vector<int> v;
for (int i = 0; i < 2 * n; i++) {
if (s.find(a[i]) == s.end()) {
v.push_back(a[i]);
s.insert(a[i]);
}
}
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
cout << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3 + 3, M = 1e9 + 7, OO = 0x3f3f3f3f;
int n, m, x, y, mem[N][N][2];
int freq_dot[N], freq_tag[N];
string grid[N];
string origin[N];
int get_cost(int col, char ch) {
grid[0][col] = ch;
if (ch == '.' && freq_tag[col] != -1) return freq_tag[col];
if (ch == '#' && freq_dot[col] != -1) return freq_dot[col];
int ret = 0;
for (int i = 0; i < n; ++i) {
if (origin[i][col] != ch) ret++;
}
if (ch == '.') return freq_tag[col] = ret;
return freq_dot[col] = ret;
}
int dp(int c, int cont_length, bool white) {
if (c == m) return ((cont_length >= x && cont_length <= y) ? 0 : OO);
if (mem[c][cont_length][white] != -1) return mem[c][cont_length][white];
char prev = (c > 0) ? grid[0][c - 1] : '.';
int cost = get_cost(c, '.');
int opt1 =
((c == 0 || (prev == grid[0][c] && cont_length < y) ||
(prev != grid[0][c] && cont_length >= x))
? cost + dp(c + 1, ((prev == grid[0][c]) ? cont_length + 1 : 1), 1)
: OO);
cost = get_cost(c, '#');
int opt2 =
((c == 0 || (prev == grid[0][c] && cont_length < y) ||
(prev != grid[0][c] && cont_length >= x))
? cost + dp(c + 1, ((prev == grid[0][c]) ? cont_length + 1 : 1), 0)
: OO);
return mem[c][cont_length][white] = min(opt1, opt2);
}
int main() {
memset(mem, -1, sizeof mem);
memset(freq_dot, -1, sizeof freq_dot);
memset(freq_tag, -1, sizeof freq_tag);
scanf("%d%d%d%d", &n, &m, &x, &y);
string str;
for (int i = 0; i < n; ++i) {
cin >> str;
grid[i] = str, origin[i] = str;
}
printf("%d\n", dp(0, 0, 0));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int *a = new int[n];
int *b = new int[m];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < m; i++) {
cin >> b[i];
}
int c = 0, index = 0, j;
bool flag = false;
for (int i = 0; i < m; i++) {
for (j = index; j < n; j++) {
if (b[i] >= a[j]) {
index = j + 1;
c++;
break;
}
}
if (j == n) {
break;
}
}
cout << c;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
};
bool follow_y(const point& a, const point& b) { return a.y < b.y; }
bool follow_x(const point& a, const point& b) { return a.x < b.x; }
void push(int node, vector<int>& st, vector<int>& lazy) {
if (!lazy[node]) return;
st[node << 1] += lazy[node];
lazy[node << 1] += lazy[node];
st[node << 1 | 1] += lazy[node];
lazy[node << 1 | 1] += lazy[node];
lazy[node] = 0;
}
void update_tree(int node, int l, int r, int u, int v, int val, vector<int>& st,
vector<int>& lazy) {
if (v < l || r < u) return;
if (u <= l && r <= v) {
st[node] += val;
lazy[node] += val;
return;
}
int mid = (l + r) >> 1;
push(node, st, lazy);
update_tree(node << 1, l, mid, u, v, val, st, lazy);
update_tree(node << 1 | 1, mid + 1, r, u, v, val, st, lazy);
st[node] = max(st[node << 1], st[node << 1 | 1]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, r;
cin >> n >> r;
vector<point> a(n);
for (int i = 0; i < n; ++i) cin >> a[i].x >> a[i].y;
for (int i = 0; i < n; ++i) {
point tmp;
tmp.y = a[i].y - a[i].x;
tmp.x = a[i].x + a[i].y;
a[i] = tmp;
}
sort(a.begin(), a.end(), follow_y);
int cnt = 1;
for (int i = 1; i < n; ++i) cnt += (a[i].y != a[i - 1].y);
vector<int> o_y(cnt + 1), st(4 * cnt + 1, 0), lazy(4 * n + 1, 0);
o_y[1] = a[0].y;
for (int i = 1, j = 2; i < n; ++i)
if (a[i].y != a[i - 1].y) o_y[j++] = a[i].y;
sort(a.begin(), a.end(), follow_x);
r *= 2;
int ans = 1;
for (int i = 0, j = -1; i < n; ++i) {
if (i) {
int right =
lower_bound(o_y.begin() + 1, o_y.end(), a[i - 1].y) - o_y.begin();
int left =
lower_bound(o_y.begin() + 1, o_y.end(), a[i - 1].y - r) - o_y.begin();
update_tree(1, 1, cnt, left, right, -1, st, lazy);
}
int k = j + 1;
while (k < n && a[k].x - a[i].x <= r) ++k;
for (int u = j + 1; u < k; ++u) {
int right = lower_bound(o_y.begin() + 1, o_y.end(), a[u].y) - o_y.begin();
int left =
lower_bound(o_y.begin() + 1, o_y.end(), a[u].y - r) - o_y.begin();
update_tree(1, 1, cnt, left, right, 1, st, lazy);
}
ans = max(ans, st[1]);
j = k - 1;
}
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int A[n];
for (long long int i = 0; i < n; i++) cin >> A[i];
sort(A, A + n);
long long int first = 0, sec = 0, three = 0;
for (long long int i = 0; i < n; i++) {
if (A[i] == A[0]) first++;
}
for (long long int i = 1; i < n; i++) {
if (A[i] == A[1]) sec++;
}
for (long long int i = 2; i < n; i++) {
if (A[i] == A[2]) three++;
}
if (A[0] == A[1] && A[1] == A[2]) {
cout << first * (first - 1) * (first - 2) / 6;
return 0;
}
if (A[0] != A[1] && A[1] == A[2]) {
cout << sec * (sec - 1) / 2;
return 0;
}
if (A[0] == A[1] && A[1] != A[2])
;
{
cout << three;
return 0;
}
cout << 1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 2e4 + 5;
void solve() {
int n;
cin >> n;
string s;
cin >> s;
stack<char> st;
for (int i = 0; i < n; i++) {
if (!st.empty()) {
if (st.top() == '(' && s[i] == ')')
st.pop();
else
st.push(s[i]);
} else
st.push(s[i]);
}
cout << st.size() / 2 << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int T = 1;
cin >> T;
while (T--) {
solve();
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
#define ll long long
#define pb push_back
#define endl "\n"
#define super ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define cn cout<<"NO"<<endl;
#define cy cout<<"YES"<<endl;
using namespace std;
int main()
{
super;
int t=1;
//cin>>t;
while(t--)
{
ll n,q;
cin>>n>>q;
ll ones=0,zeros=0;
int arr[n];
for(int i=0;i<n;i++)
{
cin>>arr[i];
if(arr[i]==1)
{
ones++;
}
else
{
zeros++;
}
}
for(int i=0;i<q;i++)
{
int ty;
cin>>ty;
if(ty==1)
{
int pos;
cin>>pos;
if(arr[pos-1]==0)
{
arr[pos-1]=1;
ones++;
zeros--;
}
else
{
arr[pos-1]=0;
zeros++;
ones--;
}
}
else
{
int kth;
cin>>kth;
//cout<<zeros<<" "<<ones<<endl;
if(ones>=kth)
{
cout<<1<<endl;
}
else
{
cout<<0<<endl;
}
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 100000;
const int MMAX = 1000000;
const int MOD = 1000000007;
const int MOD1 = 402653189;
const int MOD2 = 1000000009;
const int BASE1 = 196613;
const int BASE2 = 786433;
vector<int> spell[MMAX];
int factorial[MMAX + 1];
int main(void) {
cin.tie(0);
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
while (x--) {
int y;
cin >> y;
spell[y - 1].emplace_back(i + 1);
}
}
factorial[0] = 1;
for (int i = 1; i <= MMAX; i++) {
factorial[i] = (1LL * factorial[i - 1] * i) % MOD;
}
map<pair<int, int>, int> freq;
int countEmpty = 0;
for (int i = 0; i < m; i++) {
if (spell[i].empty()) {
countEmpty++;
continue;
}
int code1 = 0, code2 = 0;
for (const int& x : spell[i]) {
code1 = (1LL * code1 * BASE1 + x) % MOD1;
code2 = (1LL * code2 * BASE2 + x) % MOD2;
}
freq[make_pair(code1, code2)]++;
}
int answer = factorial[countEmpty];
for (const auto& x : freq) {
answer = (1LL * answer * factorial[x.second]) % MOD;
}
cout << answer << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%d%d", &n, &m);
long long lo[1502] = {}, hi[1502] = {}, dp[1501];
fill(hi + 1, hi + 1502, -99999999999ll);
for (int i = 0; i < n; i++) {
long long sum = 0, me = 0;
dp[0] = -99999999999ll;
for (int j = 1; j <= m; j++) {
scanf("%I64d", &me);
sum += me;
if (~i & 1) dp[j] = lo[j - 1] + sum;
if (i & 1) dp[j] = hi[j + 1] + sum;
}
lo[0] = dp[0];
hi[m] = dp[m];
for (int j = 1; j <= m; j++) lo[j] = max(lo[j - 1], dp[j]);
for (int j = m - 1; ~j; j--) hi[j] = max(hi[j + 1], dp[j]);
}
printf("%I64d\n", *max_element(dp, dp + m + 1));
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> t[300005];
vector<int> tr[300005];
set<int> s[300005];
vector<pair<int, pair<int, int> > > all;
int n, m, a, b, w;
void update(int v, int r, int val) {
for (; r < (int)tr[v].size(); r = (r | (r + 1)))
tr[v][r] = max(tr[v][r], val);
}
int get(int v, int r) {
int res = 0;
for (; r >= 0; r = (r & (r + 1)) - 1) res = max(res, tr[v][r]);
return res;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &a, &b, &w);
all.push_back(make_pair(w, make_pair(a, b)));
s[a].insert(w);
s[b].insert(w);
}
for (int i = 1; i <= n; i++) {
int ind = 1;
for (set<int>::iterator it = s[i].begin(); it != s[i].end(); it++)
t[i][*it] = ind++;
tr[i].assign(ind + 3, 0);
}
sort(all.begin(), all.end());
for (int i = 0; i < m; i++) {
w = all[i].first, a = all[i].second.first, b = all[i].second.second;
int now_dp = get(a, t[a][w] - 1) + 1;
update(b, t[b][w], now_dp);
}
int best = 1;
for (int i = 1; i <= n; i++) best = max(best, get(i, (int)tr[i].size() - 1));
printf("%d\n", best);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct point {
double x, y, z;
inline bool operator<(const point t) const { return y * t.x - x * t.y > 0; }
inline bool operator>(const point t) const { return y * t.x - x * t.y < 0; }
inline bool operator==(const point t) const { return y * t.x - x * t.y == 0; }
inline point operator-(const point t) const {
return (point){x - t.x, y - t.y, 0};
}
};
inline bool cmp(point x, point y) {
if (x.x != y.x)
return x.x < y.x;
else
return x.y > y.y;
}
point p[300000];
vector<int> V[300000];
int q[300000];
int i, j, n, o, t;
double mx, my;
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++)
scanf("%lf%lf", &p[i].x, &p[i].y), p[i].x = 1 / p[i].x, p[i].y = 1 / p[i].y,
p[i].z = i;
sort(p + 1, p + n + 1, cmp);
p[0] = (point){0, 100000, 0}, p[n + 1] = (point){100000, 0, 0};
for (i = 0; i <= n + 1; i++) {
if ((i) && (p[i].x == p[q[t]].x) && (p[i].y == p[q[t]].y)) {
V[t].push_back(p[i].z);
continue;
}
for (; (t > 1) && (p[i] - p[q[t]] > p[q[t]] - p[q[t - 1]]); t--)
;
t++, V[t].clear(), q[t] = i, V[t].push_back(p[i].z);
}
for (i = 1; i <= t; i++)
for (j = 0; j < V[i].size(); j++)
if (V[i][j]) o++, q[o] = V[i][j];
sort(q + 1, q + o + 1);
for (i = 1; i <= o; i++) printf("%d ", q[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class F, class T>
T convert(F a, int p = -1) {
stringstream ss;
if (p >= 0) ss << fixed << setprecision(p);
ss << a;
T r;
ss >> r;
return r;
}
template <class T>
void db(T a, int p = -1) {
if (p >= 0) cout << fixed << setprecision(p);
cout << a << " ";
}
template <class T>
T gcd(T a, T b) {
T r;
while (b != 0) {
r = a % b;
a = b;
b = r;
}
return a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T sqr(T x) {
return x * x;
}
template <class T>
T cube(T x) {
return x * x * x;
}
template <class T>
struct Triple {
T x, y, z;
Triple() {}
Triple(T _x, T _y, T _z) : x(_x), y(_y), z(_z) {}
};
template <class T>
Triple<T> euclid(T a, T b) {
if (b == 0) return Triple<T>(1, 0, a);
Triple<T> r = euclid(b, a % b);
return Triple<T>(r.y, r.x - a / b * r.y, r.z);
}
template <class T>
int getbit(T s, int i) {
return (s >> i) & 1;
}
template <class T>
T onbit(T s, int i) {
return s | (T(1) << i);
}
template <class T>
T offbit(T s, int i) {
return s & (~(T(1) << i));
}
template <class T>
int cntbit(T s) {
return s == 0 ? 0 : cntbit(s >> 1) + (s & 1);
}
const int bfsz = 1 << 16;
char bf[bfsz + 5];
int rsz = 0;
int ptr = 0;
char gc() {
if (rsz <= 0) {
ptr = 0;
rsz = fread(bf, 1, bfsz, stdin);
if (rsz <= 0) return EOF;
}
--rsz;
return bf[ptr++];
}
void ga(char &c) {
c = EOF;
while (!isalpha(c)) c = gc();
}
int gs(char s[]) {
int l = 0;
char c = gc();
while (isspace(c)) c = gc();
while (c != EOF && !isspace(c)) {
s[l++] = c;
c = gc();
}
s[l] = '\0';
return l;
}
template <class T>
bool gi(T &v) {
v = 0;
char c = gc();
while (c != EOF && c != '-' && !isdigit(c)) c = gc();
if (c == EOF) return false;
bool neg = c == '-';
if (neg) c = gc();
while (isdigit(c)) {
v = v * 10 + c - '0';
c = gc();
}
if (neg) v = -v;
return true;
}
const double PI = 2 * acos(0);
const string months[] = {"January", "February", "March", "April",
"May", "June", "July", "August",
"September", "October", "November", "December"};
const int days[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int dr[] = {0, 0, -1, +1};
const int dc[] = {-1, +1, 0, 0};
const int inf = (int)1e9 + 5;
const long long linf = (long long)1e16 + 5;
const double eps = double(1e-9);
int n, a[5005];
int f[5005], g[5005], sum[5005];
int main() {
cin >> n;
sum[0] = 0;
for (__typeof(n) i = (1); i <= (n); ++i) {
cin >> a[i];
sum[i] = sum[i - 1] + a[i];
}
f[0] = 0;
g[0] = 0;
for (__typeof(n) i = (1); i <= (n); ++i) {
f[i] = -1;
for (__typeof(i - 1) j = (0); j <= (i - 1); ++j)
if (sum[i] - sum[j] >= g[j] && f[j] + 1 >= f[i]) {
f[i] = f[j] + 1;
g[i] = sum[i] - sum[j];
}
}
cout << n - f[n] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = (2e5) + 5;
int n, ara[MAX];
void solve() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> ara[i];
sort(ara + 1, ara + n + 1);
reverse(ara + 1, ara + n + 1);
int p = 0;
for (int i = 1; i <= n; i++) {
if (ara[i] >= i) p = i;
}
cout << p << endl;
}
int main() {
ios::sync_with_stdio(false);
int tc;
cin >> tc;
for (int tt = 1; tt <= tc; tt++) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[210], ch[210][30], fail[210], cnt;
long long g[210], m;
char s[210];
queue<int> q;
struct zx {
long long a[210][210];
zx() { memset(a, -127 / 3, sizeof(a)); }
zx operator*(zx b) {
zx ret;
for (int i = 0; i <= cnt; ++i)
for (int j = 0; j <= cnt; ++j)
for (int k = 0; k <= cnt; ++k)
ret.a[i][j] = max(ret.a[i][j], a[i][k] + b.a[k][j]);
return ret;
}
};
int main() {
scanf("%d%lld", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) {
scanf("%s", s);
int now = 0;
for (int j = 0; s[j] != '\0'; ++j) {
if (!ch[now][s[j] - 'a']) ch[now][s[j] - 'a'] = ++cnt;
now = ch[now][s[j] - 'a'];
}
g[now] += a[i];
}
for (int i = 0; i < 26; ++i)
if (ch[0][i]) q.push(ch[0][i]);
while (!q.empty()) {
int x = q.front();
q.pop();
g[x] += g[fail[x]];
for (int i = 0; i < 26; ++i) {
if (!ch[x][i])
ch[x][i] = ch[fail[x]][i];
else
fail[ch[x][i]] = ch[fail[x]][i], q.push(ch[x][i]);
}
}
zx p, ans;
for (int i = 0; i <= cnt; ++i) {
ans.a[i][i] = 0;
for (int j = 0; j < 26; ++j) p.a[i][ch[i][j]] = g[ch[i][j]];
}
while (m) {
if (m & 1LL) ans = ans * p;
p = p * p;
m >>= 1;
}
long long anss = 0;
for (int i = 1; i <= cnt; ++i) anss = max(anss, ans.a[0][i]);
printf("%lld", anss);
return 0;
}
| 8 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
template <class T>
void read(T &x) {
char c, mi = 0;
while (c = getchar(), c <= 32)
;
if (c == '-')
mi = 1, x = 0;
else if (c < 48 || c > 57)
return void(x = c);
else
x = c - 48;
while (c = getchar(), c > 32) x = 10 * x + c - 48;
if (mi == 1) x = -x;
}
template <class T>
void read(T &x, T &y) {
read(x);
read(y);
}
template <class T>
void read(T &x, T &y, T &z) {
read(x, y);
read(z);
}
template <class T>
void reada(T *a, int n) {
for (int i = 0; i < n; ++i) read(a[i]);
}
template <class T>
void write(T x) {
static char s[20];
char pt = 0, mi = (x < 0);
if (mi == 1) x = -x;
while (!pt || x > 0) {
s[++pt] = (char)(x % 10 + '0');
x /= 10;
}
if (mi == 1) putchar('-');
while (pt > 0) putchar(s[pt--]);
}
template <class T>
void write(T x, T y) {
write(x);
putchar(' ');
write(y);
}
template <class T>
void write(T x, T y, T z) {
write(x, y);
putchar(' ');
write(z);
}
template <class T>
void writeln(T x) {
write(x);
puts("");
}
template <class T>
void writea(T *a, int n) {
for (int i = 0; i < n; ++i) {
write(a[i]);
putchar(i + 1 == n ? '\n' : ' ');
}
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T qpom(T a, T b, T mod = 1000000007) {
T r = 1;
while (b > 0) {
if (b & 1) r = r * a % mod;
a = a * a % mod;
b /= 2;
}
return r;
}
template <class T>
T qpow(T a, T b) {
T r = 1;
while (b > 0) {
if (b & 1) r *= a;
a *= a;
b /= 2;
}
return r;
}
template <class T>
T imin(T a, T b) {
return a < b ? a : b;
}
template <class T>
T imax(T a, T b) {
return a > b ? a : b;
}
template <class T>
inline void rmin(T &a, const T &b) {
if (a > b) a = b;
}
template <class T>
inline void rmax(T &a, const T &b) {
if (a < b) a = b;
}
template <class T>
T sqr(const T &a) {
return a * a;
}
int n;
int s[200010], r[200010];
vector<pair<pair<int, int>, int> > V, U, D;
set<pair<int, int> > all;
bool ccw(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
pair<int, int> ab = make_pair(a.first * (b.second - a.second),
a.second * (b.first - a.first));
pair<int, int> cb = make_pair(c.first * (b.second - c.second),
c.second * (b.first - c.first));
return 1LL * ab.first * cb.second - 1LL * ab.second * cb.first > 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &s[i], &r[i]);
V.push_back(make_pair(make_pair(s[i], r[i]), i));
}
sort(V.begin(), V.end());
for (int i = 0; i < V.size(); ++i) {
while (!U.empty() && U.back().first.second <= V[i].first.second) {
U.pop_back();
}
U.push_back(V[i]);
}
V.swap(U);
U.clear();
for (int i = 0; i < V.size(); ++i) {
while (U.size() >= 2 &&
ccw(U[U.size() - 2].first, U[U.size() - 1].first, V[i].first)) {
U.pop_back();
}
U.push_back(V[i]);
}
vector<int> ans;
V.swap(U);
for (int i = 0; i < V.size(); ++i) {
all.insert(V[i].first);
}
for (int i = 1; i <= n; ++i) {
if (all.count(make_pair(s[i], r[i]))) {
ans.push_back(i);
}
}
writea(&ans[0], ans.size());
getchar();
getchar();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, k, n, m, x, y, T, ans, big, cas, num, len;
bool flag;
stack<char> tt;
stack<long long> an;
char ss[5005];
char s[5005];
long long calc(long long l, long long r) {
long long i, j;
while (!tt.empty()) tt.pop();
long long nn = 0;
for (i = 0; i < len; i++) {
if (i == r) {
char c = tt.top();
while (c != '(') {
ss[nn++] = c;
tt.pop();
c = tt.top();
}
tt.pop();
}
if (s[i] == '*')
tt.push(s[i]);
else if (s[i] == '+') {
while (!tt.empty() && tt.top() == '*') {
ss[nn++] = '*';
tt.pop();
}
tt.push(s[i]);
} else if (s[i] >= '0' && s[i] <= '9') {
ss[nn++] = s[i];
}
if (i == l) {
tt.push('(');
}
}
while (!tt.empty()) {
ss[nn++] = tt.top();
tt.pop();
}
while (!an.empty()) an.pop();
for (i = 0; i < nn; i++) {
if (ss[i] == '+') {
long long u = an.top();
an.pop();
long long v = an.top();
an.pop();
an.push(u + v);
} else if (ss[i] == '*') {
long long u = an.top();
an.pop();
long long v = an.top();
an.pop();
an.push(u * v);
} else {
an.push(ss[i] - '0');
}
}
return an.top();
}
vector<long long> mul;
int main() {
scanf("%s", s + 2);
s[0] = '1';
s[1] = '*';
len = strlen(s);
s[len] = '*';
s[len + 1] = '1';
s[len + 2] = 0;
len = strlen(s);
mul.clear();
for (i = 0; i < len; i++) {
if (s[i] == '*') mul.push_back(i);
}
ans = 0;
for (i = 0; i < mul.size(); i++) {
for (j = i + 1; j < mul.size(); j++) {
long long tmp = calc(mul[i], mul[j]);
ans = max(ans, tmp);
}
}
printf("%I64d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using i64 = long long;
using Pii = pair<int, int>;
constexpr int MAX = 16;
int ch[MAX], adj[MAX];
vector<int> sub[1 << MAX], lca[MAX];
i64 dp[MAX][1 << MAX];
bool Check(int x, int y, int mask) {
if ((mask & ch[y]) != ch[y]) return false;
if (((mask | (1 << x)) & adj[y]) != adj[y]) return false;
if ((mask & adj[x]) & ~(1 << y)) return false;
for (const auto& uv : lca[x]) {
if ((mask & uv) == uv) return false;
}
return true;
}
i64 Dfs(int n, int x, int mask) {
if ((mask & ch[x]) != ch[x]) return 0;
if (!(mask ^ (1 << x))) return 1;
if (~dp[x][mask]) return dp[x][mask];
i64 ret = 0;
int cur = (mask ^ (1 << x)), b = (cur & -cur);
for (const auto& k : sub[cur ^ b]) {
int nxt = (k | b);
for (int y = 0; y < n; ++y) {
if (((nxt >> y) & 1) && Check(x, y, nxt)) {
int chx = ch[x];
ch[x] &= (mask ^ nxt);
ret += Dfs(n, y, nxt) * Dfs(n, x, mask ^ nxt);
ch[x] = chx;
}
}
}
return dp[x][mask] = ret;
}
int main() {
int n, m, q;
for (int i = 0; i < (1 << 13); ++i) {
sub[i].clear();
for (int j = 0; j <= i; ++j) {
if ((i & j) == j) sub[i].push_back(j);
}
}
while (~scanf("%d%d%d", &n, &m, &q)) {
memset(dp, -1, sizeof(dp));
memset(ch, 0, sizeof(ch));
memset(adj, 0, sizeof(adj));
for (int i = 0; i < n; ++i) lca[i].clear();
for (int i = 0; i < n; ++i) ch[i] |= (1 << i);
int a, b, c;
for (int i = 0; i < m; ++i) {
scanf("%d%d", &a, &b);
--a;
--b;
adj[a] |= (1 << b);
adj[b] |= (1 << a);
}
for (int i = 0; i < q; ++i) {
scanf("%d%d%d", &a, &b, &c);
--a;
--b;
--c;
ch[c] |= (1 << a) | (1 << b);
lca[c].push_back((1 << a) | (1 << b));
}
cout << Dfs(n, 0, (1 << n) - 1) << endl;
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> input[1010];
int Set[1010];
int findSet(int x) {
if (x == Set[x])
return x;
else
return Set[x] = findSet(Set[x]);
}
bool check(int n, int m, int index) {
for (int i = 1; i <= n; i++) Set[i] = i;
for (int i = 1; i <= m; i++) {
if (i != index) {
int u = input[i].first, v = input[i].second;
int fx = findSet(u), fy = findSet(v);
if (fx != fy) Set[fx] = fy;
}
}
for (int i = 1; i <= n; i++) Set[i] = findSet(i);
for (int i = 1; i <= n; i++) {
if (Set[i] != Set[1]) return false;
}
return true;
}
bool isConnected(int n, int m) {
int i, j;
for (i = 1; i <= n; i++) Set[i] = i;
for (i = 1; i <= m; i++) {
int u = input[i].first, v = input[i].second;
int fx = findSet(u), fy = findSet(v);
if (fx != fy) Set[fx] = fy;
}
for (i = 1; i <= n; i++) {
Set[i] = findSet(i);
if (Set[i] != Set[1]) return false;
}
return true;
}
int main() {
int i, j, n, m;
while (scanf("%d%d", &n, &m) != EOF) {
for (i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
input[i].first = u;
input[i].second = v;
}
if (isConnected(n, m)) {
bool ok = true;
for (i = 1; i <= m; i++) {
if (check(n, m, i)) ok = false;
}
if (ok)
printf("yes\n");
else
printf("no\n");
} else
printf("no\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
if (e == 0) return 1;
if (e % 2 == 0) {
long long t = bigmod(p, e / 2, M);
return (T)((t * t) % M);
}
return (T)((long long)bigmod(p, e - 1, M) * (long long)p) % M;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
int ar[101][101], sz[101];
int tmp[101];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long a = 0, b = 0, c, d, e = 0, f = 0, g, h = 0, x, y, z;
cin >> a;
for (int i = (0); i < (a); ++i) {
cin >> sz[i];
for (int j = (0); j < (sz[i]); ++j) cin >> ar[i][j];
c = sz[i] / 2;
for (int j = (0); j < (c); ++j) e += ar[i][j];
for (int j = sz[i] - 1; j >= sz[i] - c; j--) f += ar[i][j];
if (sz[i] % 2 == 0)
tmp[i] = 0;
else {
tmp[i] = ar[i][sz[i] - c - 1];
b++;
}
}
sort(tmp, tmp + a);
reverse(tmp, tmp + a);
for (int i = 0; i < a; i++) {
if (i % 2 == 0)
e += tmp[i];
else
f += tmp[i];
}
cout << e << " " << f << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int n;
int w[200020];
int h[200020];
int h2[200020];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d", w + i, h + i);
h2[i] = h[i];
}
sort(&h2[0], &h2[n]);
ll w_ = 0;
ll h_ = h[0] == h2[n - 1] ? h2[n - 2] : h2[n - 1];
for (int i = 1; i < n; i++) {
w_ += w[i];
}
printf("%I64d ", w_ * h_);
int p = 0;
for (int i = 1; i < n; i++) {
w_ -= w[i];
w_ += w[p];
h_ = h[i] == h2[n - 1] ? h2[n - 2] : h2[n - 1];
printf("%I64d ", w_ * h_);
p = i;
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class X, class Y>
void minimize(X& x, const Y& y) {
if (x > y) x = y;
}
template <class X, class Y>
void maximize(X& x, const Y& y) {
if (x < y) x = y;
}
const int MAXN = 160;
const int INF = (int)1E9 + 10;
int n, k, s;
int a[MAXN], f[2][151][5626];
int main() {
scanf("%d%d%d", &n, &k, &s);
for (int i = (1); i <= (int)(n); i++) scanf("%d", &a[i]);
s = min(s, (n * n) / 4);
int now = 0, last = 1;
for (int j = (1); j <= (int)(k); j++)
for (int l = (0); l <= (int)(s); l++) {
f[now][j][l] = INF;
f[last][j][l] = INF;
}
for (int i = (1); i <= (int)(n); i++) {
last = now;
now = 1 - now;
for (int j = (1); j <= (int)(min(i, k)); j++)
for (int l = (0); l <= (int)(s); l++) {
f[now][j][l] = f[last][j][l];
if (l >= i - j)
minimize(f[now][j][l], f[last][j - 1][l - (i - j)] + a[i]);
}
}
int ans = INF;
for (int i = (0); i <= (int)(s); i++) minimize(ans, f[now][k][i]);
printf("%d", ans);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int kmp(char needle[10000], char haystack[10000]) {
int counter = 0;
int m = strlen(needle);
vector<int> border(m + 1);
border[0] = -1;
for (__typeof(m) i = 0; i < m; i++) {
border[i + 1] = border[i];
while (border[i + 1] > -1 && needle[border[i + 1]] != needle[i]) {
border[i + 1] = border[border[i + 1]];
}
border[i + 1]++;
}
int n = strlen(haystack);
int seen = 0;
for (__typeof(n) i = 0; i < n; i++) {
while (seen > -1 && needle[seen] != haystack[i]) {
seen = border[seen];
}
if (++seen == m) {
counter++;
seen = border[m];
}
}
return counter;
}
char p[50000][300];
int main() {
char s[1000], rule[10][1000], needle[1000];
int n, l[100], r[100], ans = 0;
scanf("%s%d", s, &n);
for (__typeof(n) i = 0; i < n; i++) scanf("%s %d %d", rule[i], &l[i], &r[i]);
int len = strlen(s);
for (__typeof(len) i = 0; i < len; i++) {
for (int j = i; j < len; j++) {
char x = s[j + 1];
s[j + 1] = 0;
strcpy(needle, s + i);
s[j + 1] = x;
int flag = 1, curr;
for (int k = 0; k < n && (flag); k++) {
if (strlen(needle) > strlen(rule[k]))
curr = 0;
else
curr = kmp(needle, rule[k]);
if ((curr >= l[k] && curr <= r[k]))
flag = 1;
else
flag = 0;
}
ans = ans + flag;
if (flag) strcpy(p[ans - 1], needle);
}
}
int c[1000] = {0};
for (__typeof(ans) i = 0; i < ans; i++) c[kmp(p[i], s)]++;
ans = 0;
for (int i = 1; i < 1000; i++) ans = ans + c[i] / i;
printf("%d\n", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream& operator>>(std::istream& i, pair<T, U>& p) {
i >> p.first >> p.second;
return i;
}
template <typename T>
std::istream& operator>>(std::istream& i, vector<T>& t) {
for (auto& v : t) {
i >> v;
}
return i;
}
template <typename T, typename U>
std::ostream& operator<<(std::ostream& o, const pair<T, U>& p) {
o << p.first << ' ' << p.second;
return o;
}
template <typename T>
std::ostream& operator<<(std::ostream& o, const vector<T>& t) {
if (t.empty()) o << '\n';
for (size_t i = 0; i < t.size(); ++i) {
o << t[i] << " \n"[i == t.size() - 1];
}
return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
template <typename T>
bool in(T a, T b, T c) {
return a <= b && b < c;
}
unsigned int logceil(int first) {
return 8 * sizeof(int) - __builtin_clz(first);
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
hash<T> t;
hash<U> u;
size_t operator()(const pair<T, U>& p) const {
return t(p.first) ^ (u(p.second) << 7);
}
};
} // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
l = m + 1;
r = m;
} else {
h = m - 1;
}
}
return r;
}
template <typename F>
double bshd(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
l = m;
} else {
h = m;
}
}
return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F& f) {
T r = -1, m;
while (l <= h) {
m = (l + h) / 2;
if (f(m)) {
h = m - 1;
r = m;
} else {
l = m + 1;
}
}
return r;
}
template <typename F>
double bsld(double l, double h, const F& f, double p = 1e-9) {
unsigned int r = 3 + (unsigned int)log2((h - l) / p);
while (r--) {
double m = (l + h) / 2;
if (f(m)) {
h = m;
} else {
l = m;
}
}
return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
if (a < b) swap(a, b);
return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
public:
vector2() {}
vector2(size_t a, size_t b, T t = T())
: vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
public:
vector3() {}
vector3(size_t a, size_t b, size_t c, T t = T())
: vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
public:
vector4() {}
vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
: vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
public:
vector5() {}
vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
: vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
template <unsigned int N>
class Field {
inline unsigned int pow(unsigned int a, unsigned int p) {
unsigned int r = 1, e = a;
while (p) {
if (p & 1) {
r = ((unsigned long long)r * e) % N;
}
e = ((unsigned long long)e * e) % N;
p >>= 1;
}
return r;
}
inline unsigned int inv(unsigned int a) { return pow(a, N - 2); }
public:
inline Field(int first = 0) : v(first) {}
inline Field<N> pow(int p) { return (*this) ^ p; }
inline Field<N> operator^(int p) { return {(int)pow(v, (unsigned int)p)}; }
inline Field<N>& operator+=(const Field<N>& o) {
if ((long long)v + o.v >= N)
v += o.v - N;
else
v += o.v;
return *this;
}
inline Field<N>& operator-=(const Field<N>& o) {
if (v < o.v)
v -= o.v - N;
else
v -= o.v;
return *this;
}
inline Field<N>& operator*=(const Field<N>& o) {
v = (unsigned long long)v * o.v % N;
return *this;
}
inline Field<N>& operator/=(const Field<N>& o) { return *this *= inv(o.v); }
inline Field<N> operator+(const Field<N>& o) const {
Field<N> r{*this};
return r += o;
}
inline Field<N> operator-(const Field<N>& o) const {
Field<N> r{*this};
return r -= o;
}
inline Field<N> operator*(const Field<N>& o) const {
Field<N> r{*this};
return r *= o;
}
inline Field<N> operator/(const Field<N>& o) const {
Field<N> r{*this};
return r /= o;
}
inline Field<N> operator-() {
if (v)
return {(int)(N - v)};
else
return {0};
};
inline Field<N>& operator++() {
++v;
if (v == N) v = 0;
return *this;
}
inline Field<N> operator++(int) {
Field<N> r{*this};
++*this;
return r;
}
inline Field<N>& operator--() {
--v;
if (v == -1) v = N - 1;
return *this;
}
inline Field<N> operator--(int) {
Field<N> r{*this};
--*this;
return r;
}
inline bool operator==(const Field<N>& o) const { return o.v == v; }
inline bool operator!=(const Field<N>& o) const { return o.v != v; }
inline explicit operator unsigned int() const { return v; }
inline static vector<Field<N>> fact(int t) {
vector<Field<N>> F(t + 1, 1);
for (int i = 2; i <= t; ++i) {
F[i] = F[i - 1] * i;
}
return F;
}
inline static vector<Field<N>> invfact(int t) {
vector<Field<N>> F(t + 1, 1);
Field<N> X{1};
for (int i = 2; i <= t; ++i) {
X = X * i;
}
F[t] = 1 / X;
for (int i = t - 1; i >= 2; --i) {
F[i] = F[i + 1] * (i + 1);
}
return F;
}
private:
unsigned int v;
};
template <unsigned int N>
istream& operator>>(std::istream& is, Field<N>& f) {
unsigned int v;
is >> v;
f = v;
return is;
}
template <unsigned int N>
ostream& operator<<(std::ostream& os, const Field<N>& f) {
return os << (unsigned int)f;
}
template <unsigned int N>
Field<N> operator+(int i, const Field<N>& f) {
return Field<N>(i) + f;
}
template <unsigned int N>
Field<N> operator-(int i, const Field<N>& f) {
return Field<N>(i) - f;
}
template <unsigned int N>
Field<N> operator*(int i, const Field<N>& f) {
return Field<N>(i) * f;
}
template <unsigned int N>
Field<N> operator/(int i, const Field<N>& f) {
return Field<N>(i) / f;
}
struct Ring {
static int div(int p, int q, int N) {
long long t = 0, nt = 1, r = N, nr = q;
while (nr) {
long long q = r / nr;
t -= q * nt;
r -= q * nr;
swap(t, nt);
swap(r, nr);
}
t = (t < 0) ? t + N : t;
r = (r < 0) ? r + N : r;
if (gcd(p, N) % r) {
return 0;
}
return (int)(((long long)t * (long long)p / r) % N);
}
};
class gameswithrectangle {
public:
void solve(istream& cin, ostream& cout) {
int N, M, K;
cin >> N >> M >> K;
N -= 2 * K;
M -= 2 * K;
if (N < 0 || M < 0) {
cout << "0\n";
return;
}
auto F = Field<1000000007>::fact(2001);
auto I = Field<1000000007>::invfact(2001);
Field<1000000007> ans = 0;
for (int w = 0; w < N; ++w) {
for (int h = 0; h < M; ++h) {
Field<1000000007> a = F[w + K - 1] * I[K - 1] * I[w];
Field<1000000007> b = F[h + K - 1] * I[K - 1] * I[h];
Field<1000000007> c = F[N - w + K - 1] * I[K] * I[N - w - 1];
Field<1000000007> d = F[M - h + K - 1] * I[K] * I[M - h - 1];
ans += a * b * c * d;
}
}
cout << ans << '\n';
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
gameswithrectangle solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
;
int tt;
cin >> tt;
while (tt--) {
int n, k;
cin >> n >> k;
int ans = k, to_add = k / n;
int rem = (n - k % n) % n;
if (to_add < rem) {
ans += to_add;
} else {
ans += rem;
to_add -= rem > 0 ? (rem - 1) : 0;
ans += (to_add / (n - 1)) * n + (to_add % (n - 1));
if (ans % n == 0) --ans;
}
cout << ans << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<vector<char>> v(n, vector<char>(m, '.'));
bool tes = true;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
for (int j = 0; j < m; j++) v[i][j] = '#';
} else {
if (tes)
v[i][m - 1] = '#';
else
v[i][0] = '#';
tes = !tes;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << v[i][j];
}
cout << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int main() {
int n, i, j, a[101][101], b[101], p, k = 0, f;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
scanf("%d", &a[i][j]);
}
}
if (n == 1) {
printf("1\n1\n");
} else {
for (j = 1; j <= n; j++) {
for (i = 1; i <= n; i++) {
if (i != j) {
if (a[i][j] == 3 || a[i][j] == 2) {
f = 0;
break;
} else {
f = 1;
}
}
}
if (f == 1) {
b[k] = j;
k++;
}
}
printf("%d\n", k);
for (i = 0; i < k; i++) {
printf("%d", b[i]);
if (i < k - 1) {
printf(" ");
}
}
if (k > 0) {
printf("\n");
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int nax = 1000000 + 10;
int n, arr[nax];
int main() {
ios::sync_with_stdio(0);
string s;
cin >> s;
string s1 = s;
reverse(s1.begin(), s1.end());
cout << s << s1 << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int dr[]{-1, -1, 0, 1, 1, 1, 0, -1};
const int dc[]{0, 1, 1, 1, 0, -1, -1, -1};
void run() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int sqrtQ = 250;
class suffix_array {
const static int alpha = 128;
int getOrder(int a) const { return (a < (int)order.size() ? order[a] : 0); }
public:
int n;
string s;
vector<int> suf, order, lcp;
suffix_array() {}
suffix_array(const string &s) : n(s.size() + 1), s(s) {
suf = order = lcp = vector<int>(n);
vector<int> bucket_idx(n), newOrder(n), newsuff(n);
{
vector<int> prev(n), head(alpha, -1);
for (int i = 0; i < n; i++) {
prev[i] = head[s[i]];
head[s[i]] = i;
}
int buc = -1, idx = 0;
for (int i = 0; i < alpha; i++) {
if (head[i] == -1) continue;
bucket_idx[++buc] = idx;
for (int j = head[i]; ~j; j = prev[j]) suf[idx++] = j, order[j] = buc;
}
}
int len = 1;
do {
auto cmp = [&](int a, int b) {
if (order[a] != order[b]) return order[a] < order[b];
return getOrder(a + len) < getOrder(b + len);
};
for (int i = 0; i < n; i++) {
int j = suf[i] - len;
if (j < 0) continue;
newsuff[bucket_idx[order[j]]++] = j;
}
for (int i = 1; i < n; i++) {
suf[i] = newsuff[i];
bool cmpres = cmp(suf[i - 1], suf[i]);
newOrder[suf[i]] = newOrder[suf[i - 1]] + cmpres;
if (cmpres) bucket_idx[newOrder[suf[i]]] = i;
}
order = newOrder;
len <<= 1;
} while (order[suf[n - 1]] != n - 1);
}
int count(const string &x) {
int st = 0, ed = n;
for (int i = 0; i < (int)(x.size()) && st < ed; i++) {
auto cmp = [&](int a, int b) {
if (a == -1) return x[i] < s[b + i];
return s[a + i] < x[i];
};
st = lower_bound(suf.begin() + st, suf.begin() + ed, -1, cmp) -
suf.begin();
ed = upper_bound(suf.begin() + st, suf.begin() + ed, -1, cmp) -
suf.begin();
}
return max(0, ed - st);
}
} SA[(int)1e4];
string y;
vector<int> longestPrefix;
vector<int> Fail[26];
int fail(int k, char nxt) {
int &rt = Fail[nxt - 'a'][k];
if (~rt) return rt;
while (k > 0 && y[k] != nxt) k = longestPrefix[k - 1];
if (nxt == y[k]) k++;
return rt = k;
}
void failure_function() {
int n = y.size();
longestPrefix = vector<int>(n);
for (int i = 0; i < 26; i++) Fail[i] = vector<int>(n + 1, -1);
for (int i = 1, k = 0; i < n; i++) longestPrefix[i] = k = fail(k, y[i]);
}
int main() {
run();
string s;
int q;
cin >> s >> q;
for (int i = 0; i < (int)(s.size()); i += sqrtQ)
SA[i / sqrtQ] = suffix_array(s.substr(i, sqrtQ));
auto solve = [&](int l, int r) {
int match = 0, cnt = 0;
for (int i = l; i <= r; i++) {
match = fail(match, s[i]);
if (match == (int)(y.size())) {
cnt++;
match = longestPrefix[match - 1];
}
}
return cnt;
};
while (q--) {
int t;
cin >> t;
if (t == 1) {
int idx;
char ch;
cin >> idx >> ch;
idx--;
s[idx] = ch;
SA[idx / sqrtQ] = suffix_array(s.substr(idx / sqrtQ * sqrtQ, sqrtQ));
} else {
int l, r;
cin >> l >> r >> y;
l--, r--;
failure_function();
if ((int)(y.size()) >= sqrtQ || r - l <= 2 * sqrtQ) {
cout << solve(l, r) << "\n";
continue;
}
int ans = 0, len = (int)(y.size());
int st = l / sqrtQ, ed = r / sqrtQ;
ans += solve(l, (st + 1) * sqrtQ + len - 2);
ans += solve(ed * sqrtQ - len + 1, r);
for (int i = st + 1; i < ed; i++) ans += SA[i].count(y);
for (int i = st + 2; i < ed; i++)
ans += solve(i * sqrtQ - len + 1, i * sqrtQ + len - 2);
cout << ans << "\n";
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010, inf = 1e9;
int n, m, a[maxn], b[maxn], minn[maxn << 2][2], tag[maxn << 2][2];
void pushup(int o) {
minn[o][0] = min(minn[o * 2][0], minn[o * 2 + 1][0]);
minn[o][1] = min(minn[o * 2][1], minn[o * 2 + 1][1]);
}
void pushdown(int o) {
for (int i = 0; i < 2; i++) {
if (tag[o][i]) {
minn[o * 2][i] += tag[o][i];
minn[o * 2 + 1][i] += tag[o][i];
tag[o * 2][i] += tag[o][i];
tag[o * 2 + 1][i] += tag[o][i];
tag[o][i] = 0;
}
}
}
void build(int o, int l, int r) {
if (l == r) {
minn[o][l & 1] = b[l];
minn[o][l & 1 ^ 1] = inf;
return;
}
int mid = (l + r) >> 1;
build(o * 2, l, mid);
build(o * 2 + 1, mid + 1, r);
pushup(o);
}
void update(int o, int l, int r, int x, int y, int v, int id) {
if (x > y) return;
if (x <= l && r <= y) {
tag[o][id] += v;
minn[o][id] += v;
return;
}
pushdown(o);
int mid = (l + r) >> 1;
if (x <= mid) update(o * 2, l, mid, x, y, v, id);
if (y > mid) update(o * 2 + 1, mid + 1, r, x, y, v, id);
pushup(o);
}
int query1(int o, int l, int r, int cur, int id) {
if (cur == 0) return 0;
if (l == r) return minn[o][id];
pushdown(o);
int mid = (l + r) >> 1;
if (cur <= mid) return query1(o * 2, l, mid, cur, id);
if (cur > mid) return query1(o * 2 + 1, mid + 1, r, cur, id);
}
int query2(int o, int l, int r, int x, int y, int id) {
if (x <= l && r <= y) return minn[o][id];
pushdown(o);
int mid = (l + r) >> 1, res = inf;
if (x <= mid) res = min(res, query2(o * 2, l, mid, x, y, id));
if (y > mid) res = min(res, query2(o * 2 + 1, mid + 1, r, x, y, id));
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) b[i] = a[i] - b[i - 1];
build(1, 1, n);
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int id, a, b, k;
scanf("%d", &id);
if (id == 1) {
scanf("%d%d%d", &a, &b, &k);
a++;
b++;
update(1, 1, n, a, b, k, a & 1);
if ((b - a + 1) & 1) {
update(1, 1, n, b + 1, n, k, a & 1);
update(1, 1, n, b + 1, n, -k, a & 1 ^ 1);
}
} else {
scanf("%d%d", &a, &b);
a++;
b++;
if ((b - a + 1) & 1) {
int temp1 = query1(1, 1, n, a - 1, (a - 1) & 1);
int temp2 = query2(1, 1, n, a, b, b & 1) + temp1;
int temp3 = query2(1, 1, n, a, b, b & 1 ^ 1) - temp1;
int temp4 = query1(1, 1, n, b, b & 1) + temp1;
if (temp4 == 1 && temp2 >= 1 && temp3 >= 0)
puts("1");
else
puts("0");
} else {
int temp1 = query1(1, 1, n, a - 1, (a - 1) & 1);
int temp2 = query2(1, 1, n, a, b, b & 1) - temp1;
int temp3 = query2(1, 1, n, a, b, b & 1 ^ 1) + temp1;
int temp4 = query1(1, 1, n, b, b & 1) - temp1;
if (temp4 == 0 && temp2 >= 0 && temp3 >= 1)
puts("1");
else
puts("0");
}
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
struct event {
int x, t, p;
event(int _x = 0, int _t = 0, int _p = 0) {
x = _x;
t = _t;
p = _p;
}
bool operator<(const event &a) const {
if (a.x != x) return x < a.x;
if (a.t != t) return t > a.t;
return p < a.p;
}
};
long long sol;
int d, n, sz;
multiset<int> s;
event a[maxn * 2];
int main(void) {
ios::sync_with_stdio(false);
cin >> d >> sz >> n;
for (int i = 0; i < n; i++) {
int x, p;
cin >> x >> p;
a[i * 2] = event(x, 1, p);
a[i * 2 + 1] = event(x + sz, 0, p);
}
n *= 2;
a[n] = event(0, 1, 0);
a[n + 1] = event(sz, 0, 0);
a[n + 2] = event(d, 0, 0);
n += 3;
sort(a, a + n);
int prev = 0;
for (int i = 0; i < n; i++) {
if (a[i].x != prev && s.empty()) {
cout << -1 << endl;
return 0;
}
sol += (long long)(a[i].x - prev) * (*s.begin());
if (a[i].x == d) break;
if (a[i].t == 1) s.insert(a[i].p);
if (a[i].t == 0) s.erase(s.find(a[i].p));
prev = a[i].x;
}
cout << sol << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 7;
string s;
void out(int cnt) {
if (cnt % 2)
cout << '1';
else
cout << '0';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> s;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '(') {
cnt++;
out(cnt);
} else {
out(cnt);
cnt--;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MAXN = 1e6 + 10;
inline long long pow(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % MOD;
b >>= 1;
a = a * a % MOD;
}
return ans;
}
long long n, k;
long long fact[MAXN], antifact[MAXN], D[MAXN], pre_D[MAXN];
void Init() {
fact[0] = fact[1] = 1;
for (int i = 2; i <= MAXN - 10; i++) fact[i] = fact[i - 1] * i % MOD;
for (int i = 0; i <= MAXN - 10; i++) antifact[i] = pow(fact[i], MOD - 2);
}
int main() {
ios::sync_with_stdio(false);
Init();
cin >> n >> k;
if (k >= n) {
cout << 0 << endl;
return 0;
}
memset(D, 0, sizeof(D));
memset(pre_D, 0, sizeof(pre_D));
D[k + 2] = fact[k];
pre_D[k + 2] = D[k + 2] * antifact[k + 1] % MOD;
for (int i = k + 3; i <= n; i++) {
D[i] = (i - k - 1) * fact[i - 2] % MOD +
fact[i - 2] * (pre_D[i - 1] - pre_D[i - k - 1]) % MOD;
D[i] %= MOD;
if (D[i] < 0) D[i] += MOD;
pre_D[i] = (pre_D[i - 1] + D[i] * antifact[i - 1] % MOD) % MOD;
if (pre_D[i] < 0) pre_D[i] += MOD;
}
long long ans = fact[n - 1] * pre_D[n] % MOD;
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1000000], b[1000000];
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n - 1; ++i) b[i] = a[i] + a[i + 1];
b[n - 1] = a[n - 1];
for (int i = 0; i < n; ++i) cout << b[i] << ' ';
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
const int maxm = 2e5 + 7;
const int mod = 1e9 + 7;
int n;
long long a[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
long long ans = 0;
for (int i = (1); i <= (n); ++i) {
cin >> a[i];
if (a[i] < a[i - 1]) ans += a[i - 1] - a[i];
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long int gcd(long long int x, long long int y) {
if (y > x) {
return gcd(y, x);
}
if (y == 0) {
return x;
}
return gcd(y, x % y);
}
bool prime(long long int x) {
for (long long int i = 2; i <= sqrt(x); i++) {
if (x % i == 0) {
return 0;
}
}
return 1;
}
long long int fact(long long int n) {
if (n == 0) {
return 1;
}
return n * fact(n - 1);
}
bool powerOf2(long long int n) {
if (n == 0) {
return 0;
}
return (ceil(log2(n)) == floor(log2(n)));
}
void solve() {
long long int n;
cin >> n;
string s;
cin >> s;
long long int i;
for (i = n - 2; i >= 0; i = i - 2) cout << s[i];
if (n % 2 == 0)
i = 1;
else
i = 0;
for (; i < n; i = i + 2) cout << s[i];
cout << endl;
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
long long int t = 1;
while (t--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55;
const int MOD = 1000000000 + 7;
int dp[N][N][N][N];
int c[N];
long long ceven[N];
long long codd[N];
long long fact[N];
long long inv_fact[N];
long long pow2[N];
long long power(long long s, long long p) {
long long base = s;
long long val = 1;
long long tmp = p;
while (tmp > 0) {
if (tmp & 1) val = (val * base) % MOD;
base = (base * base) % MOD;
tmp >>= 1;
}
return val;
}
void init() {
fact[0] = 1;
pow2[0] = 1;
for (int i = 1; i < N; i += 1) {
fact[i] = (i * fact[i - 1]) % MOD;
pow2[i] = (2 * pow2[i - 1]) % MOD;
}
inv_fact[N - 1] = power(fact[N - 1], MOD - 2);
for (int i = N - 2; i >= 0; i--)
inv_fact[i] = (inv_fact[i + 1] * (i + 1)) % MOD;
for (int i = 0; i < N; i += 1) {
for (int j = 0; j <= i; j += 2) {
ceven[i] += (((fact[i] * inv_fact[j]) % MOD) * inv_fact[i - j]) % MOD;
ceven[i] %= MOD;
}
for (int j = 1; j <= i; j += 2) {
codd[i] += (((fact[i] * inv_fact[j]) % MOD) * inv_fact[i - j]) % MOD;
codd[i] %= MOD;
}
}
}
int main() {
int n, p;
cin >> n >> p;
for (int i = 0; i < n; i += 1) cin >> c[i];
init();
long long ans = 0;
dp[0][0][0][0] = 1;
for (int i = 1; i <= n; i += 1) {
for (int w1 = 0; w1 <= i; w1 += 1) {
for (int w2 = 0; w2 + w1 <= i; w2 += 1) {
for (int b1 = 0; b1 + w2 + w1 <= i; b1 += 1) {
int b2 = i - w1 - w2 - b1;
if (c[i - 1] == 0 || c[i - 1] == -1) {
if (b1 > 0) {
dp[i][w1][w2][b1] +=
(dp[i - 1][w1][w2][b1 - 1] * ceven[w1] % MOD) *
pow2[w2 + b1 - 1 + b2] % MOD;
dp[i][w1][w2][b1] %= MOD;
}
if (b2 > 0) {
dp[i][w1][w2][b1] += (dp[i - 1][w1][w2][b1] * codd[w1] % MOD) *
pow2[w2 + b1 - 1 + b2] % MOD;
dp[i][w1][w2][b1] %= MOD;
}
}
if (c[i - 1] == 1 || c[i - 1] == -1) {
if (w1 > 0) {
dp[i][w1][w2][b1] +=
(dp[i - 1][w1 - 1][w2][b1] * ceven[b1] % MOD) *
pow2[w1 - 1 + w2 + b2] % MOD;
dp[i][w1][w2][b1] %= MOD;
}
if (w2 > 0) {
dp[i][w1][w2][b1] +=
(dp[i - 1][w1][w2 - 1][b1] * codd[b1] % MOD) *
pow2[w1 + w2 - 1 + b2] % MOD;
dp[i][w1][w2][b1] %= MOD;
}
}
if (i == n && ((w1 + b1) & 1) == p) {
ans += dp[i][w1][w2][b1];
ans %= MOD;
}
}
}
}
}
cout << ans << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, j, x;
bool yes = true;
vector<long long> myv;
int main() {
cin >> n;
for (i = 0; i < n; i++) {
yes = true;
for (j = 0; j < n; j++) {
cin >> x;
if (x == 1 || x == 3) yes = false;
}
if (yes) myv.push_back(i + 1);
}
cout << myv.size() << endl;
for (i = 0; i < myv.size(); i++) cout << myv[i] << " ";
cout << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char a[1000010];
long long sum[1000010];
int main() {
scanf("%s", a);
if (strlen(a) < 5) {
printf("0\n");
return 0;
}
for (long long i = 1; i < strlen(a); i++) {
if (i > 0 && a[i] == 'v' && a[i - 1] == 'v') {
sum[i] = sum[i - 1] + 1;
} else {
sum[i] = sum[i - 1];
}
}
long long ans = 0;
for (long long i = 0; i < strlen(a); i++) {
if (a[i] == 'o') {
ans = ans + sum[i] * (sum[strlen(a) - 1] - sum[i]);
}
}
printf("%lld\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t) {
int n;
cin >> n;
string s;
while (n) {
if (n % 2 == 1) {
s += '7';
n -= 3;
} else {
s += '1';
n -= 2;
}
}
cout << s << endl;
t--;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct al {
int s, a;
};
bool cmp1(const al& a, const al& b) { return a.s < b.s; }
bool cmp2(const al& a, const al& b) { return a.a < b.a; }
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, d;
cin >> n >> d;
vector<al> t1, t2;
for (int i = 0; i < n; i++) {
al a;
cin >> a.s >> a.a;
if (a.s < d) continue;
if (a.a <= a.s)
t1.push_back(a);
else
t2.push_back(a);
}
sort(t1.begin(), t1.end(), cmp1);
sort(t2.begin(), t2.end(), cmp2);
int ans = t1.size();
for (int i1 = 0, i2 = 0; i2 < t2.size(); i2++) {
while (i1 < t1.size() && t1[i1].s < t2[i2].a) d = max(d, t1[i1].a), i1++;
if (d <= t2[i2].s) d = max(d, t2[i2].a), ans++;
}
cout << ans << "\n";
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (T i : v) os << i << ' ';
return os;
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& v) {
for (T i : v) os << i << ' ';
return os;
}
template <class T, class S>
ostream& operator<<(ostream& os, const pair<T, S>& v) {
os << v.first << ' ' << v.second;
return os;
}
template <class T, class S>
ostream& operator<<(ostream& os, const unordered_map<T, S>& v) {
for (auto i : v) os << '(' << i.first << "=>" << i.second << ')' << ' ';
return os;
}
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#pragma GCC target( \
"avx2,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
const long long N = 1e5;
vector<pair<pair<long long, long long>, long long>> v;
long long dp[N] = {0};
vector<long long> adj[N];
long long vis[N] = {0};
long long arr[N];
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
clock_t time_p = clock();
void starboy1299() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
bool isPrime(long long n) {
long long cnt = 1;
for (long long i = 2; i * i <= n; i++) {
if (n % i == 0) {
cnt = 0;
}
}
return cnt;
}
void solve() {
long long n;
cin >> n;
if (n == 2 or n == 3) {
cout << 1 << '\n';
return;
}
if (isPrime(n)) {
cout << 1 << '\n';
return;
}
if (n % 2 == 0) {
cout << 2 << '\n';
return;
}
if (isPrime(n - 2)) {
cout << 2 << '\n';
return;
}
if (isPrime(n - 3)) {
cout << 2 << '\n';
return;
}
cout << 3 << '\n';
}
int32_t main() {
fast();
long long t = 1;
while (t--) solve();
starboy1299();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, q, root[200005];
int sum[4000005], son[4000005][2], node;
int newnode(int x) {
sum[++node] = sum[x];
son[node][0] = son[x][0];
son[node][1] = son[x][1];
return node;
}
void insert(int &z, int x, int l, int r, int pos) {
z = newnode(x);
sum[z]++;
if (l == r) return;
int mid = (l + r) >> 1;
if (pos <= mid)
insert(son[z][0], son[x][0], l, mid, pos);
else
insert(son[z][1], son[x][1], mid + 1, r, pos);
}
int query(int rs, int ls, int l, int r, int ql, int qr) {
if (ql > qr) return 0;
if (ql <= l && r <= qr) return sum[rs] - sum[ls];
int mid = (l + r) >> 1, ret = 0;
if (ql <= mid) ret += query(son[rs][0], son[ls][0], l, mid, ql, qr);
if (qr > mid) ret += query(son[rs][1], son[ls][1], mid + 1, r, ql, qr);
return ret;
}
int main() {
n = read();
q = read();
for (int i = 1; i <= n; i++) {
int x = read();
insert(root[i], root[i - 1], 1, n, x);
}
int l, r, u, d;
for (int i = 1; i <= q; i++) {
l = read();
d = read();
r = read();
u = read();
int cnt1 = query(root[l - 1], root[0], 1, n, u + 1, n);
int cnt2 = query(root[r], root[l - 1], 1, n, u + 1, n);
int cnt3 = query(root[n], root[r], 1, n, u + 1, n);
int cnt4 = query(root[l - 1], root[0], 1, n, d, u);
int cnt5 = query(root[r], root[l - 1], 1, n, d, u);
int cnt6 = query(root[n], root[r], 1, n, d, u);
int cnt7 = query(root[l - 1], root[0], 1, n, 1, d - 1);
int cnt8 = query(root[r], root[l - 1], 1, n, 1, d - 1);
int cnt9 = query(root[n], root[r], 1, n, 1, d - 1);
long long ans = 0;
ans += 1ll * cnt1 * (cnt5 + cnt6 + cnt8 + cnt9);
ans += 1ll * cnt2 * (cnt4 + cnt5 + cnt6 + cnt7 + cnt8 + cnt9);
ans += 1ll * cnt3 * (cnt4 + cnt5 + cnt7 + cnt8);
ans += 1ll * cnt4 * (cnt2 + cnt3 + cnt5 + cnt6 + cnt8 + cnt9);
ans += 1ll * cnt5 * (n - 1);
ans += 1ll * cnt6 * (cnt1 + cnt2 + cnt4 + cnt5 + cnt7 + cnt8);
ans += 1ll * cnt7 * (cnt2 + cnt3 + cnt5 + cnt6);
ans += 1ll * cnt8 * (cnt1 + cnt2 + cnt3 + cnt4 + cnt5 + cnt6);
ans += 1ll * cnt9 * (cnt1 + cnt2 + cnt4 + cnt5);
printf("%I64d\n", ans / 2);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, sum1, sum2, maxx;
int a[1010], b[1010];
cin >> n;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) cin >> b[i];
maxx = -1;
for (i = 1; i <= n; i++) {
sum1 = a[i];
sum2 = b[i];
maxx = max(maxx, sum1 + sum2);
for (j = i + 1; j <= n; j++) {
sum1 |= a[j];
sum2 |= b[j];
maxx = max(maxx, sum1 + sum2);
}
}
cout << maxx << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
long long x, y, z, a, b, c, sum, ans, total, t, cnt, n, m, k, p, kase;
string s1, s2;
map<long long, long long> mp;
set<long long> s;
map<long long, long long>::iterator itr1, ptr1;
set<long long>::iterator itr, ptr;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> t;
while (t--) {
cin >> n >> x;
sum = 0;
while (n--) {
cin >> p;
s.insert(p);
sum += p - x;
}
if (s.size() == 1 && s.count(x))
cout << 0 << endl;
else if (s.count(x) || sum == 0)
cout << 1 << endl;
else
cout << 2 << endl;
s.clear();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
if (m % n != 0) {
cout << "-1" << endl;
return 0;
}
int mul = m / n, total = 0;
while (mul != 1) {
if (mul % 3 == 0) {
mul /= 3;
total++;
} else if (mul % 3 != 0 && mul % 2 == 0) {
mul /= 2;
total++;
} else {
cout << "-1" << endl;
return 0;
}
}
cout << total << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long f[55];
int n;
long long k;
void solve(int x, long long last) {
if (x > n) return;
if (f[n - x] >= last) {
printf("%d ", x);
solve(x + 1, last);
} else {
printf("%d %d ", x + 1, x);
solve(x + 2, last - f[n - x]);
}
}
int main() {
scanf("%d%I64d", &n, &k);
f[0] = 1;
f[1] = 1;
f[2] = 2;
for (int i = 3; i <= n; i++) {
f[i] = f[i - 1] + f[i - 2];
}
solve(1, k);
return 0;
}
| 5 |
#include<bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
typedef long long LL;
typedef pair<int,int> pii;
typedef pair<LL,LL> pLL;
typedef pair<double,double> pdd;
const int N=1e6+5;
const int M=3e3+5;
const int mod=998244353;
const int inf=0x3f3f3f3f;
#define fi first
#define se second
#define ls (i<<1)
#define rs (i<<1|1)
#define mem(a,b) memset(a,b,sizeof(a))
#define print(a) printf("%lld\n",a)
#define eb emplace_back
#define mk make_pair
LL read()
{
LL x=0,t=1;
char ch=getchar();
while(ch<'0'||ch>'9'){ if(ch=='-') t=-1; ch=getchar(); }
while(ch>='0'&&ch<='9'){ x=(x<<3)+(x<<1)+ch-'0'; ch=getchar(); }
return x*t;
}
int a[N],b[N],cnt[N][2];
int main()
{
int T=read();
while(T--)
{
int n=read();
int m=1e5;
for(int i=1;i<=m;i++) cnt[i][0]=cnt[i][1]=0;
for(int i=1;i<=n;i++) a[i]=b[i]=read();
sort(b+1,b+n+1);
for(int i=1;i<=n;i++)
cnt[a[i]][i&1]++,cnt[b[i]][i&1]--;
int flag=0;
for(int i=1;i<=m;i++)
if(cnt[i][0]||cnt[i][1]) flag=1;
if(flag) printf("NO\n");
else printf("YES\n");
}
return 0;
}
/*
1
6
2 1 2 1 2 1
*/
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.