solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int num, n, arr[1000000], count = 1;
cin >> num;
for (int x = 0; x < num; x++) {
count = 1;
cin >> n;
for (int z = 0; z < n; z++) cin >> arr[z];
sort(arr, arr + n);
for (int z = 0; z < n - 1; z++) {
if (arr[z] != arr[z + 1]) count++;
}
cout << count << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct FastIO {
inline FastIO& operator>>(long long& x) {
x = 0;
char f = 0, ch = getchar();
while (ch > '9' || ch < '0') f |= (ch == '-'), ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
return x = (f ? -x : x), *this;
}
inline FastIO& operator>>(double& x) {
x = 0;
char f = 0, ch = getchar();
double d = 0.1;
while (ch > '9' || ch < '0') f |= (ch == '-'), ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
if (ch == '.') {
ch = getchar();
while (ch <= '9' && ch >= '0')
x += d * (ch ^ 48), d *= 0.1, ch = getchar();
}
return x = (f ? -x : x), *this;
}
} read;
void file() {}
inline long long mul(long long a, long long b) {
long long d = (long long)(a * (double)b / 998244353 + 0.5);
long long ret = a * b - d * 998244353;
if (ret < 0) ret += 998244353;
return ret;
}
long long dp[2][233][2];
long long sum[2][233][2];
long long a[100020];
long long n;
void getsum(long long n) {
for (long long k = 0; k < 2; k++)
for (long long i = 1; i <= 200; i++)
(sum[n][i][k] = sum[n][i - 1][k] + dp[n][i][k]) %= 998244353;
}
signed main() {
file();
long long i;
read >> n;
for (i = 1; i <= n; i++) read >> a[i];
if (a[1] == -1)
for (i = 1; i <= 200; i++) dp[1][i][0] = 1;
else
dp[1][a[1]][0] = 1;
getsum(1);
for (i = 2; i <= n; i++) {
long long c = i & 1, cc = c ^ 1;
memset(dp[c], 0, sizeof(dp[c]));
if (a[i] != -1) {
dp[c][a[i]][0] =
(sum[cc][a[i] - 1][0] + sum[cc][a[i] - 1][1]) % 998244353;
dp[c][a[i]][1] = (sum[cc][200][1] - sum[cc][a[i] - 1][1]) % 998244353;
(dp[c][a[i]][1] += dp[cc][a[i]][0]) %= 998244353;
} else
for (a[i] = 1; a[i] <= 200; a[i]++) {
dp[c][a[i]][0] =
(sum[cc][a[i] - 1][0] + sum[cc][a[i] - 1][1]) % 998244353;
dp[c][a[i]][1] = (sum[cc][200][1] - sum[cc][a[i] - 1][1]) % 998244353;
(dp[c][a[i]][1] += dp[cc][a[i]][0]) %= 998244353;
}
getsum(c);
}
long long ans = sum[n & 1][200][1];
cout << (ans % 998244353 + 998244353) % 998244353;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int a[N], b[N];
vector<pair<int, long long> > d;
vector<long long> v;
bool check(int n, int m, int k, int s) {
int ma = 1e9, mb = 1e9;
for (int i = 0; i < m; ++i) {
ma = min(ma, a[i]);
mb = min(mb, b[i]);
}
v.clear();
for (auto x : d) {
if (x.first - 1) {
v.push_back(mb * x.second);
} else {
v.push_back(ma * x.second);
}
}
sort(v.begin(), v.end());
for (int i = 0; i < k; ++i) {
if (v[i] > s) return false;
s -= v[i];
}
return (s >= 0);
}
void print(int n, int m, int k, int s) {
cout << m << endl;
int ma = 1e9, mb = 1e9;
int da, db;
for (int i = 0; i < m; ++i) {
if (a[i] < ma) {
da = i + 1, ma = a[i];
}
if (b[i] < mb) {
db = i + 1, mb = b[i];
}
}
int cnt = 0;
vector<pair<long long, int> > vv;
for (auto x : d) {
++cnt;
if (x.first - 1) {
vv.push_back({mb * x.second, cnt});
} else {
vv.push_back({ma * x.second, cnt});
}
}
sort(vv.begin(), vv.end());
for (int i = 0; i < k; ++i) {
cout << vv[i].second << ' ';
if (d[vv[i].second - 1].first - 1) {
cout << db << endl;
} else {
cout << da << endl;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, k, s;
cin >> n >> m >> k >> s;
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n; ++i) {
cin >> b[i];
}
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
d.push_back({a, b});
}
int l = 0, r = n + 1;
while (r - l > 1) {
int m = (r + l) >> 1;
if (check(n, m, k, s)) {
r = m;
} else {
l = m;
}
}
if (r == n + 1) {
cout << -1;
} else {
print(n, r, k, s);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &res) {
char c;
int f = 1;
res = 0;
c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
res = (res << 1) + (res << 3) + c - 48, c = getchar();
res *= f;
}
int T, n, m;
int ans, cnt;
int mp[405][405];
int hqz[405][405];
int sqz[405][405];
char c[405];
int main() {
read(T);
while (T--) {
read(n);
read(m);
ans = 1e9;
for (int i = 1; i <= n; i++) {
scanf("%s", c + 1);
for (int j = 1; j <= m; j++) {
mp[i][j] = c[j] - '0';
hqz[i][j] = hqz[i][j - 1] + mp[i][j];
sqz[i][j] = sqz[i - 1][j] + mp[i][j];
}
}
for (int i = 1; i + 4 <= n; i++) {
for (int j = 1; j + 3 <= m; j++) {
for (int k = i + 4; k <= n; k++) {
cnt = sqz[k - 1][j] - sqz[i][j];
cnt = (k - i - 1) - cnt;
cnt += 1 - hqz[i][j + 1] + hqz[i][j];
cnt += sqz[k - 1][j + 1] - sqz[i][j + 1];
if (cnt >= ans) break;
cnt += 1 - hqz[k][j + 1] + hqz[k][j];
for (int l = j + 3; l <= m; l++) {
cnt += mp[i][l - 1] ^ 1;
cnt += mp[k][l - 1] ^ 1;
cnt += sqz[k - 1][l - 1] - sqz[i][l - 1];
if (cnt >= ans) break;
if (cnt + (k - i - 1) - sqz[k - 1][l] + sqz[i][l] < ans)
ans = cnt + (k - i - 1) - sqz[k - 1][l] + sqz[i][l];
}
}
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
;
int n;
cin >> n;
vector<double> p(n);
bool flag = 0;
for (auto &i : p) cin >> i, flag |= i > 1 - 1e-9;
if (flag) {
cout << 1 << endl;
return 0;
}
sort(p.begin(), p.end());
long double ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j < n; j++) {
long double prima = 1, cur = 0;
for (int k = i; k <= j; k++) prima *= (1 - p[k]);
for (int k = i; k <= j; k++) cur += prima * (p[k] / (1 - p[k]));
ans = max(ans, cur);
}
}
cout << fixed << setprecision(9) << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100000;
int n, c[N], t[N], dc[N], dt[N];
bool solve() {
if (c[0] != t[0]) return false;
for (int i = 0; i < n - 1; i++) {
dc[i] = c[i + 1] - c[i];
dt[i] = t[i + 1] - t[i];
}
sort(dc, dc + n - 1);
sort(dt, dt + n - 1);
for (int i = 0; i < n - 1; i++)
if (dc[i] != dt[i]) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) cin >> c[i];
for (int i = 0; i < n; i++) cin >> t[i];
if (solve())
cout << "Yes" << endl;
else
cout << "No" << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int B, G, N;
cin >> B >> G >> N;
int ans = 0;
for (int b = 0; b <= B; b++) {
int g = N - b;
if (g >= 0 && g <= G) ans++;
}
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void qmax(int &x, int y) {
if (x < y) x = y;
}
void qmin(int &x, int y) {
if (x > y) x = y;
}
inline long long read() {
char s;
long long k = 0, base = 1;
while ((s = getchar()) != '-' && s != EOF && !(isdigit(s)))
;
if (s == EOF) exit(0);
if (s == '-') base = -1, s = getchar();
while (isdigit(s)) {
k = k * 10 + (s ^ '0');
s = getchar();
}
return k * base;
}
inline void write(int x) {
static char cnt, num[15];
cnt = 0;
if (!x) {
printf("0");
return;
}
for (; x; x /= 10) num[++cnt] = x % 10;
for (; cnt; putchar(num[cnt--] + 48))
;
}
const int maxn = 5e3 + 100;
const int maxm = 2e4 + 100;
int n, m, k;
int cnt[maxn];
int a[maxn];
vector<int> G[maxn];
int main() {
n = read(), m = read();
for (int i = 1, x, y; i <= m; i++) {
x = read();
y = read();
if (y < x) y = y + n;
G[x].push_back(y);
cnt[x]++;
if (!a[x]) a[x] = 1e9;
a[x] = min(a[x], y);
}
for (int i = 1; i <= n; i++) {
sort(G[i].begin(), G[i].end());
k = max(cnt[i], k);
}
k--;
long long sum = 0, Max = 0;
for (int s = 1; s <= n; s++) {
Max = 0;
sum = (long long)k * n;
for (int j = s; j <= n; j++) {
if (a[j] && cnt[j] == k + 1) {
Max = max(Max, (long long)a[j]);
if (G[j].size() >= 2) Max = max(Max, (long long)G[j][1] - n);
}
if (cnt[j] == k && G[j].size() > 0)
Max = max(Max, (long long)G[j][0] - n);
}
for (int j = 1; j < s; j++) {
if (a[j] && cnt[j] == k + 1) {
Max = max(Max, (long long)a[j] + n);
if (G[j].size() >= 2) Max = max(Max, (long long)G[j][1]);
}
if (cnt[j] == k && G[j].size() > 0)
Max = max((long long)Max, (long long)G[j][0]);
}
sum += Max - s;
printf("%lld ", sum);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int dx[] = {0, 1, -1, 0, 1, -1, 1, -1, -2, 2, 0, 0},
dy[] = {1, 0, 0, -1, -1, 1, 1, -1, 0, 0, -2, 2};
using namespace std;
long long N[200005], D[200005];
const int M = 1e9 + 7;
long long dp[3000];
long long POWER(int b, int e) {
if (e == 0) return 1;
if (e & 1)
return (POWER(b, e - 1) % M * b) % M;
else {
long long t = POWER(b, e / 2) % M;
return t * t % M;
}
}
long long C(int n, int r) {
if (n == r) return 1;
return N[n] * ((D[r] * D[n - r]) % M) % M;
}
int main() {
N[1] = 1, D[1] = 1;
N[0] = D[0] = 1;
for (int i = 2; i < 200004; i++) {
N[i] = (N[i - 1] * i) % M;
D[i] = POWER(N[i], M - 2);
}
int h, w, n;
cin >> h >> w >> n;
long long ans = C(h + w - 2, h - 1);
vector<pair<int, int> > black;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
black.push_back(make_pair(a, b));
}
black.push_back(make_pair(h, w));
sort(black.begin(), black.end());
for (int i = 0; i < black.size(); i++) {
int x = black[i].first, y = black[i].second;
dp[i] = C(x + y - 2, x - 1);
for (int j = 0; j < i; j++) {
int a = black[j].first, b = black[j].second;
if (y >= b) {
dp[i] -= (dp[j] * C(x - a + y - b, x - a) % M);
dp[i] = (dp[i] + M) % M;
}
}
}
cout << dp[black.size() - 1] << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int pos = 0;
bool cond = true;
for (int i = 0; i < n; i++) {
int dist;
string dir;
cin >> dist >> dir;
if (dir != "North" && dir != "South") {
if (pos == 20000) cond = false;
if (pos == 0) cond = false;
}
if (dir == "North") {
pos -= dist;
} else if (dir == "South") {
pos += dist;
}
if (pos > 20000 || pos < 0) cond = false;
}
if (cond == false || pos != 0) {
cout << "NO" << endl;
} else {
cout << "YES" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long long;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
vector<int> v(n), sv(n);
vector<vector<int>> g(31, vector<int>(n));
for (int j = 0; j < n; j++) {
int x;
cin >> x;
sv[j] = x;
int cnt = 0;
for (int i = 29; i >= 0; i--) {
cnt += (x >> i) & 1;
g[i][j] = ((x >> i) & 1) ? -1 : 1;
}
v[j] = cnt;
}
map<vector<int>, int> d;
for (int mask = 0; mask < (1 << 15); mask++) {
vector<int> curSum(n);
for (int i = 0; i < 15; i++) {
if ((mask >> i) & 1) {
for (int j = 0; j < n; j++) {
curSum[j] += g[i][j];
}
}
}
d[curSum] = mask;
}
for (int mask = 0; mask < (1 << 15); mask++) {
vector<int> curSum(n);
for (int i = 0; i < 15; i++) {
if ((mask >> i) & 1) {
for (int j = 0; j < n; j++) {
curSum[j] += g[i + 15][j];
}
}
}
for (int t = 0; t <= 30; t++) {
vector<int> needSum(n);
for (int i = 0; i < n; i++) {
needSum[i] = (t - (v[i] + curSum[i]));
}
if (d.count(needSum)) {
ll ans = (mask << 15) | d[needSum];
cout << ans;
return 0;
}
}
}
cout << -1;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b;
int x[(50 + 1)][(50 + 1)];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> x[i][j];
cin >> a >> b;
int min = n * m + 1;
for (int i = 0; i < n - a + 1; i++, cout << endl)
for (int j = 0; j < m - b + 1; j++) {
int t = 0;
for (int k = i; k < i + a; k++)
for (int l = j; l < j + b; l++)
if (x[k][l]) t++;
min = std::min(min, t);
}
for (int i = 0; i < n - b + 1; i++, cout << endl)
for (int j = 0; j < m - a + 1; j++) {
int t = 0;
for (int k = i; k < i + b; k++)
for (int l = j; l < j + a; l++)
if (x[k][l]) t++;
min = std::min(min, t);
}
cout << min << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void solve() {
long long int n;
cin >> n;
long long int ans = 1;
long long int A = 0, B = 0;
for (long long int i = 0; i < n; i++) {
long long int a, b;
cin >> a >> b;
if (A == B) {
ans += min(a, b) - A;
} else if (A > B) {
if (b >= A) {
ans++;
}
ans += max(0ll, min(a, b) - A);
} else {
if (a >= B) {
ans++;
}
ans += max(0ll, min(a, b) - B);
}
A = a;
B = b;
}
cout << ans << '\n';
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
cerr << "Time : "
<< 1000 * ((long double)clock()) / (long double)CLOCKS_PER_SEC << "ms\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, x, y;
cin >> a >> b;
if (a % 2 == 0)
x = a / 2;
else
x = ceil(a / 2.0);
if (a < b)
printf("-1\n");
else {
if (x % b == 0)
printf("%d\n", x);
else {
y = ((x / b) + 1) * b;
if (y <= a) printf("%d\n", y);
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
long long d[21] = {0}, c = 0, i, k, m;
cin >> n;
for (i = 0; i < n; i++) {
cin >> k;
d[k + 10]++;
}
for (i = 0; i < 10; i++) {
c += (d[i] * d[20 - i]);
}
c += ((d[10] * (d[10] - 1)) / 2);
cout << c;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, arr1[200005], arr2[200005], num;
int main() {
ios_base::sync_with_stdio(), cin.tie(nullptr), cout.tie(nullptr);
cin >> n;
for (int i = 0; i < n; ++i) cin >> arr1[i];
for (int i = 0; i < n; ++i) cin >> num, arr2[num] = i;
for (int i = 0; i < n; ++i) arr1[i] = arr2[arr1[i]];
int i = 0;
for (; i < n; ++i) {
if (i && arr1[i] < arr1[i - 1]) break;
}
cout << n - i << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long pow_mod(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) {
ans *= a;
ans %= mod;
}
a *= a;
a %= mod;
b >>= 1;
}
return ans;
}
int main() {
long long x, k;
cin >> x >> k;
if (x == 0) {
cout << 0 << endl;
return 0;
}
long long ans1 = pow_mod(2, k + 1);
x %= mod;
ans1 *= x;
ans1 %= mod;
long long ans2 = pow_mod(2, k) - 1;
if (ans2 < 0) ans2 += mod;
long long ans = ans1 - ans2;
if (ans < 0) ans += mod;
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 21, INF = 1e8;
int N, M;
char str[MAXN][MAXN];
int a[MAXN][MAXN];
int dp[1 << MAXN];
void init() {
scanf("%d%d", &N, &M);
for (int i = 0; i < N; i++) scanf("%s", str[i]);
for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++) scanf("%d", &a[i][j]);
}
void solve() {
for (int mask = 1; mask < (1 << N); mask++) dp[mask] = INF;
for (int i = 0; i < M; i++) {
vector<int> t[26];
for (int j = 0; j < N; j++) t[str[j][i] - 'a'].push_back(j);
vector<pair<int, int> > v;
for (int c = 0; c < 26; c++)
if (t[c].size() > 0) {
int mx = 0, sum = 0, mask = 0;
for (auto &x : t[c]) {
sum += a[x][i];
mx = max(mx, a[x][i]);
mask |= 1 << x;
}
v.push_back(pair<int, int>(mask, sum - mx));
}
for (int j = 0; j < N; j++) v.push_back(pair<int, int>(1 << j, a[j][i]));
for (int mask = 0; mask < (1 << N); mask++)
if (dp[mask] < INF) {
for (auto &x : v) {
int mm = mask | x.first;
dp[mm] = min(dp[mm], dp[mask] + x.second);
}
}
}
printf("%d\n", dp[(1 << N) - 1]);
}
int main() {
init();
solve();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int normalize(vector<pair<int, int> > &H, int N) {
sort(H.begin(), H.end());
int tocut = 0;
int lastcut = 0;
for (auto &segment : H) {
if (segment.first > lastcut) lastcut = segment.first;
if (segment.second > lastcut) {
tocut += segment.second - lastcut;
lastcut = segment.second;
}
}
return N - tocut;
}
int solve(map<int, vector<pair<int, int> > > &H, int N, int M) {
int answer = 0;
for (map<int, vector<pair<int, int> > >::iterator it = H.begin();
it != H.end(); ++it) {
int realsize = normalize(it->second, N);
answer ^= realsize;
}
if ((M - 1 - H.size()) % 2) answer ^= N;
return answer;
}
pair<int, int> remove(int left, vector<pair<int, int> > &H, int N) {
sort(H.begin(), H.end());
int lastcut = 0;
int toerase = N - left;
for (auto &segment : H) {
if (segment.first > lastcut) lastcut = segment.first;
if (segment.second > lastcut) {
if (lastcut < toerase) toerase += segment.second - lastcut;
lastcut = segment.second;
}
}
return {0, toerase};
}
bool find(map<int, vector<pair<int, int> > > &H, int N, int M, int V,
bool reverse = false) {
for (map<int, vector<pair<int, int> > >::iterator it = H.begin();
it != H.end(); ++it) {
int realsize = normalize(it->second, N);
if ((realsize xor V) <= realsize) {
auto segment = remove(realsize xor V, it->second, realsize);
if (reverse)
cout << it->first << " " << segment.first << " " << it->first << " "
<< segment.second << "\n";
else
cout << segment.first << " " << it->first << " " << segment.second
<< " " << it->first << "\n";
return true;
}
}
for (int i = 1; i < M; ++i)
if (H.find(i) == H.end()) {
if ((N xor V) <= N) {
if (reverse)
cout << i << " " << 0 << " " << i << " " << N - (N xor V) << "\n";
else
cout << 0 << " " << i << " " << N - (N xor V) << " " << i << "\n";
return true;
} else {
break;
}
}
return false;
}
int main() {
int N, M, K;
cin >> N >> M >> K;
map<int, vector<pair<int, int> > > H, V;
for (int i = 0; i < K; ++i) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (x1 == x2) {
if (y1 > y2) swap(y1, y2);
V[x1].push_back({y1, y2});
}
if (y1 == y2) {
if (x1 > x2) swap(x1, x2);
H[y1].push_back({x1, x2});
}
}
int answer = solve(H, N, M);
answer ^= solve(V, M, N);
if (answer == 0) {
cout << "SECOND\n";
} else {
cout << "FIRST\n";
if (find(H, N, M, answer)) return 0;
find(V, M, N, answer, true);
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int q, l, r, res;
cin >> q;
vector<int> ans;
for (int i = 0; i < q; i++) {
cin >> l >> r;
if (l % 2 == 1) {
res = (r - l + 1) / 2;
if (r % 2 == 1) {
res = res - r;
}
} else {
res = -(r - l + 1) / 2;
if (r % 2 == 0) {
res += r;
}
}
ans.push_back(res);
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int T;
long long a, b, c, d;
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(nullptr);
std::cin >> T;
while (T--) {
std::cin >> a >> b >> c >> d;
if (a - b * c > 0)
std::cout << "-1\n";
else {
long long k = a / b / d;
std::cout << std::max((k + 1) * a - (d * k * (k + 1) >> 1) * b, a)
<< std::endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
template <typename T>
inline T max(T a, T b) {
return a > b ? a : b;
}
template <typename T>
inline T min(T a, T b) {
return a < b ? a : b;
}
template <typename T>
inline T abs(T a) {
return a > 0 ? a : -a;
}
template <typename T>
inline bool repr(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool repl(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <typename T>
inline T gcd(T a, T b) {
T t;
if (a < b) {
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
} else {
while (b) {
t = b;
b = a % b;
a = t;
}
return a;
}
}
template <typename T>
inline T sqr(T x) {
return x * x;
}
inline int mulmod(int a, int b, int c) { return (long long)a * b % c; }
inline unsigned int mod(unsigned int x, unsigned int y) {
if (x >= y) return x - y;
return x;
}
struct Cg {
inline char operator()() { return getchar(); }
};
struct Cp {
inline void operator()(char x) { putchar(x); }
};
inline bool IS(char x) { return x == 10 || x == 13 || x == ' '; }
template <typename T>
struct Fr {
T P;
inline Fr &operator,(int &x) {
x = 0;
char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (f) x = -x;
return *this;
}
inline operator int() {
int x;
*this, x;
return x;
}
inline Fr &operator,(long long &x) {
x = 0;
char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (f) x = -x;
return *this;
}
inline operator long long() {
long long x;
*this, x;
return x;
}
inline Fr &operator,(char &x) {
for (x = P(); IS(x); x = P())
;
return *this;
}
inline operator char() {
char x;
*this, x;
return x;
}
inline Fr &operator,(char *x) {
char t = P();
for (; IS(t); t = P())
;
if (~t) {
for (; !IS(t) && ~t; t = P()) *x++ = t;
}
*x++ = 0;
return *this;
}
inline Fr &operator,(double &x) {
x = 0;
char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (t == '.') {
double u = 0.1;
for (t = P(); t >= '0' && t <= '9'; t = P(), u *= 0.1) x += u * (t - '0');
}
if (f) x = -x;
return *this;
}
inline operator double() {
double x;
*this, x;
return x;
}
inline Fr &operator,(long double &x) {
x = 0;
char t = P();
while ((t < '0' || t > '9') && t != '-') t = P();
bool f = 0;
if (t == '-') t = P(), f = 1;
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
if (t == '.') {
double u = 0.1;
for (t = P(); t >= '0' && t <= '9'; t = P(), u *= 0.1) x += u * (t - '0');
}
if (f) x = -x;
return *this;
}
inline operator long double() {
long double x;
*this, x;
return x;
}
inline Fr &operator,(unsigned int &x) {
x = 0;
char t = P();
while (t < '0' || t > '9') t = P();
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
return *this;
}
inline operator unsigned int() {
unsigned int x;
*this, x;
return x;
}
inline Fr &operator,(unsigned long long &x) {
x = 0;
char t = P();
while (t < '0' || t > '9') t = P();
x = t - '0';
for (t = P(); t >= '0' && t <= '9'; t = P()) x = x * 10 + t - '0';
return *this;
}
inline operator unsigned long long() {
unsigned long long x;
*this, x;
return x;
}
};
Fr<Cg> in;
template <typename T>
struct Fw {
T P;
inline Fw &operator,(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(unsigned int x) {
if (x) {
char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(unsigned int x) {
if (x) {
char s[10], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(unsigned long long x) {
if (x) {
char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator()(unsigned long long x) {
if (x) {
char s[19], c = 0;
while (x) s[c++] = x % 10 + '0', x /= 10;
while (c--) P(s[c]);
} else
P('0');
return *this;
}
inline Fw &operator,(char x) {
P(x);
return *this;
}
inline Fw &operator()(char x) {
P(x);
return *this;
}
inline Fw &operator,(const char *x) {
while (*x) P(*x++);
return *this;
}
inline Fw &operator()(const char *x) {
while (*x) P(*x++);
return *this;
}
inline Fw &operator()(double x, int y) {
if (y) {
double t = 0.5;
for (int i = y; i--;) t *= 0.1;
if (x >= 0)
x += t;
else
x -= t, P('-');
*this, (long long)(abs(x));
P('.');
if (x < 0) x = -x;
while (y--) {
x *= 10;
x -= floor(x * 0.1) * 10;
P(((int)x) % 10 + '0');
}
} else if (x >= 0)
*this, (long long)(x + 0.5);
else
*this, (long long)(x - 0.5);
;
return *this;
}
inline Fw &operator()(long double x, int y) {
if (y) {
double t = 0.5;
for (int i = y; i--;) t *= 0.1;
if (x >= 0)
x += t;
else
x -= t, P('-');
*this, (long long)(abs(x));
P('.');
if (x < 0) x = -x;
while (y--) {
x *= 10;
x -= floor(x * 0.1) * 10;
P(((int)x) % 10 + '0');
}
} else if (x >= 0)
*this, (long long)(x + 0.5);
else
*this, (long long)(x - 0.5);
;
return *this;
}
};
Fw<Cp> out;
const int N = 1000007;
int k, n, s[N], _g[N * 2 + 1], *g = _g + N, q[N * 2];
int main() {
in, k, n;
for (int i = 0, iend = n; i < iend; i++) in, s[i];
for (int i = 0, iend = n; i < iend; i++) s[i] -= k;
std::sort(s, s + n);
n = std::unique(s, s + n) - s;
int qe = 0;
for (int i = 0, iend = n; i < iend; i++) q[qe++] = s[i], g[s[i]] = 1;
for (int i = 0; i < qe; i++) {
int k = q[i], t;
if (k == 0) return printf("%d\n", g[0]), 0;
for (int j = 0, jend = n; j < jend; j++) {
t = k + s[j];
if (t > N || t < -N) continue;
if (!g[t]) {
g[t] = g[k] + 1;
q[qe++] = t;
}
}
}
out, "-1";
}
| 7 |
#include <bits/stdc++.h>
long long c[101][101];
long long dp[11][101];
int main() {
int n, m = 1000000007, p = 0, i, j, k, l, r;
long long sum = 0;
int a[10];
scanf("%d", &n);
for (i = 0; i < 10; i++) scanf("%d", &a[i]);
for (i = 0; i < 10; i++) p += a[i];
if (p == 0) p = 1;
c[0][0] = 1;
for (i = 1; i <= 100; i++) {
c[i][0] = c[i][i] = 1;
for (j = 1; j < i; j++) c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % m;
}
for (i = p; i <= n; i++) {
for (j = 1; j <= 9; j++) {
for (k = 0; k <= 10; k++) {
for (l = 0; l <= n; l++) {
dp[k][l] = -1;
}
}
dp[0][1] = 1;
for (k = 0; k < 10; k++) {
for (l = 1; l <= i; l++) {
if (dp[k][l] == -1) continue;
for (r = a[k] - (j == k); l + r <= i; r++) {
if (r < 0) continue;
if (dp[k + 1][l + r] == -1) dp[k + 1][l + r] = 0;
dp[k + 1][l + r] =
(dp[k + 1][l + r] + dp[k][l] * c[i - l][r] % m) % m;
}
}
}
if (dp[10][i] >= 0) sum = (sum + dp[10][i]) % m;
}
}
printf("%d\n", (int)sum);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return b < a ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int oo = 0x3f3f3f3f;
const int maxn = 110, maxm = 1110, maxk = 1010;
int n, m, K;
int en = 0;
int col[maxm + 5];
vector<pair<int, int> > adj[maxn + 5];
vector<pair<int, int> > cur[maxn + 5];
inline void add_edge(int first, int second) {
adj[first].push_back(make_pair(second, en));
adj[second].push_back(make_pair(first, en));
++en;
}
int cnt, col0, col1;
bool vis[maxm + 5];
void dfs(int first) {
while (!cur[first].empty()) {
auto u = cur[first].back();
cur[first].pop_back();
if (!vis[u.second]) {
vis[u.second] = 1;
dfs(u.first);
col[u.second] = cnt ? col0 : col1;
cnt ^= 1;
}
}
}
void work(int _col0, int _col1) {
memset(vis, 0, sizeof vis);
col0 = _col0;
col1 = _col1;
for (int i = (0), i_end_ = (n); i < i_end_; ++i) {
cur[i].clear();
for (auto j : adj[i])
if (col[j.second] == col0 || col[j.second] == col1) cur[i].push_back(j);
}
int tmp = en;
for (int i = (0), i_end_ = (n); i < i_end_; ++i)
if ((int((cur[i]).size())) & 1) {
cur[i].push_back(make_pair(n, tmp));
cur[n].push_back(make_pair(i, tmp));
++tmp;
}
cnt = 0;
for (int i = n; i >= 0; --i)
if (!cur[i].empty()) dfs(i);
}
int main() {
scanf("%d%d%d", &n, &m, &K);
for (int i = (0), i_end_ = (n); i < i_end_; ++i) scanf("%*d");
for (int i = (0), i_end_ = (m); i < i_end_; ++i) {
int u, v;
scanf("%d%d", &u, &v), --u, --v;
add_edge(u, v);
}
memset(col, 0, sizeof col);
for (int i = (0), i_end_ = (n); i < i_end_; ++i) {
while (1) {
static int num[maxk + 5];
memset(num, 0, sizeof num);
for (auto j : adj[i]) ++num[col[j.second]];
int Min = 0, Max = 0;
for (int j = (1), j_end_ = (K); j < j_end_; ++j) {
if (num[j] > num[Max]) Max = j;
if (num[j] < num[Min]) Min = j;
}
if (num[Max] - num[Min] > 2)
work(Min, Max);
else
break;
}
}
for (int i = (0), i_end_ = (m); i < i_end_; ++i) printf("%d\n", col[i] + 1);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
int n, m;
long long k, f[N], d[N], h[N], qy[2][2];
string pre[2], nxt[2], str[17], suf[N * 10], ans;
inline bool cmp(string a, string b) {
for (int i = 0; i < min(a.length(), b.length()); i++) {
if (a[i] == b[i]) continue;
if (a[i] < b[i])
return 1;
else
return 0;
}
return a.length() < b.length();
}
int count(string a) {
int res = 0;
for (int i = 0; i < a.length(); i++) {
if (i + ans.length() - 1 >= a.length()) break;
bool flag = 1;
for (int j = 0; j < ans.length(); j++)
if (a[i + j] != ans[j]) flag = 0;
res += flag;
}
return res;
}
long long solve() {
int len = ans.length();
pre[0].clear();
pre[1].clear();
nxt[0].clear();
nxt[1].clear();
d[14] = h[14] = 0;
d[15] = h[15] = 1;
for (int i = 0; i < len - 1; i++)
pre[0].push_back(str[14][i]), pre[1].push_back(str[15][i]);
for (int i = 1; i <= len - 1; i++)
nxt[0].push_back(str[14][str[14].length() - len + i]);
for (int i = 1; i <= len - 1; i++)
nxt[1].push_back(str[15][str[15].length() - len + i]);
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) qy[i][j] = count(nxt[j] + pre[i]);
f[14] = count(str[14]);
f[15] = count(str[15]);
for (int i = 16; i <= n; i++) {
h[i] = h[i - 1];
d[i] = d[i - 2];
f[i] = f[i - 1] + f[i - 2];
f[i] += qy[d[i]][h[i]];
if (f[i] > 1e18) return f[i];
}
return f[n];
}
int main() {
scanf("%d%lld%d", &n, &k, &m);
str[0] = "0";
str[1] = "1";
for (int i = 2; i <= 15; i++) str[i] = str[i - 2] + str[i - 1];
if (n <= 15) {
for (int i = 0; i < str[n].length(); i++)
for (int j = i; j < str[n].length(); j++) suf[i + 1].push_back(str[n][j]);
sort(suf + 1, suf + str[n].length() + 1, cmp);
for (int i = 0; i < min(m, (int)suf[k].length()); i++)
printf("%c", suf[k][i]);
return 0;
}
for (int i = 1; i <= m; i++) {
ans.push_back('0');
long long z = solve();
if (z < k) {
k -= z;
ans.pop_back();
ans.push_back('1');
}
int flag = 1;
for (int l = suf[n].length() - ans.length(), j = 0; j < suf[n].length();
l++) {
if (ans[j] != suf[n][l]) flag = false;
j++;
}
k -= flag;
if (k == 0) {
for (int i = 0; i < ans.length(); i++) printf("%c", ans[i]);
return 0;
}
}
for (int i = 0; i < ans.length(); i++) printf("%c", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int INF = (-1u) / 2;
const long long int INF2 = (-1ull) / 2;
int a, b, i, d[1011000], j, k, n, m, timer = 0, l, r, x, y;
int c[1011000], cnt = 0, fl = 0, a2, a3 = -1000000, ans = 0;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
if (n > m) swap(n, m);
if (n == 1) {
cout << m << endl;
} else if (n == 2) {
cout << 2 * (2 * (m / 4) + min(m % 4, 2)) << endl;
} else {
cout << (n * m + 1) / 2 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long ans = -1e9;
map<string, int> mymap;
int main() {
set<string> s;
int n;
cin >> n;
string s1, s2, s3;
mymap["polycarp"] = 1;
for (int i = 0; i < (int)(n); ++i) {
cin >> s1 >> s2 >> s3;
std::transform(s3.begin(), s3.end(), s3.begin(), ::tolower);
std::transform(s1.begin(), s1.end(), s1.begin(), ::tolower);
mymap[s1] = mymap[s3] + 1;
ans = max(ans, 1ll * mymap[s1]);
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int main() {
bool mp[2005][2005] = {};
int n;
cin >> n;
pair<int, int> arr[3002];
for (int i = 0; i < n; i++) {
cin >> arr[i].first >> arr[i].second;
mp[arr[i].first + 1001][arr[i].second + 1001] = 1;
}
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
pair<int, int> mid;
mid.first = (arr[i].first + arr[j].first) / 2;
mid.second = (arr[i].second + arr[j].second) / 2;
if ((arr[i].first + arr[j].first) % 2 == 0 &&
(arr[i].second + arr[j].second) % 2 == 0 &&
mp[mid.first + 1001][mid.second + 1001] == 1)
ans++;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[3][2], as[2][3], zs = 0;
pair<long long, long long> sq[2069];
int main() {
long long i, j, ii;
for (i = 0; i < 3; i++) {
for (ii = 0; ii < 2; ii++) {
scanf("%lld", &a[i][ii]);
as[ii][i] = a[i][ii];
}
}
for (ii = 0; ii < 2; ii++) {
sort(as[ii], as[ii] + 3);
}
for (i = as[0][0]; i <= as[0][2]; i++) {
zs++;
sq[zs] = {i, as[1][1]};
}
for (i = 0; i < 3; i++) {
for (j = min(a[i][1], as[1][1]); j <= max(a[i][1], as[1][1]); j++) {
if (j != as[1][1]) {
zs++;
sq[zs] = {a[i][0], j};
}
}
}
printf("%lld\n", zs);
for (i = 1; i <= zs; i++) {
printf("%lld %lld\n", sq[i].first, sq[i].second);
}
}
| 4 |
#include <bits/stdc++.h>
const int maxn = 200005;
char c[maxn];
int zky[maxn], yky[maxn];
int main() {
int n;
scanf("%d", &n);
getchar();
gets(c + 1);
if (c[1] == '<')
zky[1] = 1;
else
zky[1] = -1;
for (int i = 2; i <= n; i++) {
if (c[i] == '<' && zky[i - 1] == 1)
zky[i] = 1;
else
zky[i] = -1;
}
if (c[n] == '>')
yky[n] = 1;
else
yky[n] = -1;
for (int i = n - 1; i >= 1; i--) {
if (c[i] == '>' && yky[i + 1] == 1)
yky[i] = 1;
else
yky[i] = -1;
}
int cou = 0;
for (int i = 1; i <= n; i++) {
if (zky[i] == 1 || yky[i] == 1) {
cou++;
}
}
printf("%d\n", cou);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 150010;
int a[2100];
int pre[2100];
int n, m;
char s[1100][1100];
vector<int> v[2100];
int in[2100];
int f(int x) { return x == pre[x] ? x : pre[x] = f(pre[x]); }
int main() {
int ans = 0;
scanf("%d%d", &n, &m);
for (int i = 1; i <= 2000; i++) pre[i] = i;
for (int i = 1; i <= n; i++) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= m; j++) {
if (s[i][j] == '=') {
int xx = f(i);
int yy = f(j + 1000);
if (xx == yy) continue;
pre[yy] = xx;
ans++;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (s[i][j] == '=') continue;
int xx = f(i);
int yy = f(j + 1000);
if (s[i][j] == '<') {
v[xx].push_back(yy);
in[yy]++;
} else {
v[yy].push_back(xx);
in[xx]++;
}
}
}
queue<int> q;
for (int i = 1; i <= n; i++) {
if (pre[i] == i && in[i] == 0) {
q.push(i);
a[i] = 1;
ans++;
}
}
for (int i = 1001; i <= m + 1000; i++) {
if (pre[i] == i && in[i] == 0) {
q.push(i);
a[i] = 1;
ans++;
}
}
if (q.empty())
printf("No\n");
else {
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < v[u].size(); i++) {
int to = v[u][i];
in[to]--;
if (a[to] == 0)
a[to] = a[u] + 1;
else
a[to] = max(a[to], a[u] + 1);
if (in[to] == 0) {
ans++;
q.push(to);
}
}
}
if (ans != n + m) {
printf("No\n");
return 0;
}
printf("Yes\n");
for (int i = 1; i <= n; i++) {
if (pre[i] != i) a[i] = a[f(i)];
printf("%d%c", a[i], " \n"[i == n]);
}
for (int i = 1001; i <= m + 1000; i++) {
if (pre[i] != i) a[i] = a[f(i)];
printf("%d%c", a[i], " \n"[i == m + 1000]);
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int p = 0, k = 0;
int b[2];
for (int i = 0; i < n; i++) {
if (a[i] % 2 == 0) {
k++;
cout << "1" << endl;
cout << i + 1 << endl;
break;
}
if (a[i] % 2 != 0) {
p++;
b[p - 1] = i + 1;
if (p == 2) {
cout << p << endl;
cout << b[0] << " " << b[1] << endl;
break;
}
}
}
if (p < 2 && k == 0) {
cout << "-1" << endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5;
int n, arr[maxn + 5], sum[maxn + 5];
int dp[maxn + 5][2];
vector<int> g[maxn + 5];
long long res;
void dfs(int u, int father, long long& ans) {
int now = sum[u];
dp[u][now] = 1;
dp[u][now ^ 1] = 0;
long long cnt = 0;
for (int i = 0; i < g[u].size(); ++i) {
int v = g[u][i];
if (v == father) continue;
dfs(v, u, ans);
cnt += 1ll * dp[u][0] * dp[v][1] + 1ll * dp[u][1] * dp[v][0];
dp[u][now ^ 0] += dp[v][0];
dp[u][now ^ 1] += dp[v][1];
}
ans += cnt;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &arr[i]), res += arr[i];
for (int i = 1, u, v; i < n; ++i) {
scanf("%d %d", &u, &v);
g[u].push_back(v);
g[v].push_back(u);
}
for (int i = 0; i < 20; ++i) {
for (int j = 1; j <= n; ++j) {
if (arr[j] & (1 << i))
sum[j] = 1;
else
sum[j] = 0;
}
long long ans = 0;
dfs(1, 0, ans);
res += ans * (1 << i);
}
printf("%lld\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:336777216")
using namespace std;
int IT_MAX = 1 << 19;
const long long MOD = 998244353;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1);
const double ERR = 1e-10;
int main() {
int n, a[109];
deque<int> d;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
for (int i = 0; i < n; i++)
if (i % 2 == 0)
d.push_back(a[i]);
else
d.push_front(a[i]);
for (long long x : d) cout << x << " ";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>;
using vi = vector<int>;
using vc = vector<char>;
using vb = vector<bool>;
using vs = vector<string>;
using vll = vector<long long>;
using vp = vector<pair<int, int>>;
using vvi = vector<vector<int>>;
using vvc = vector<vector<char>>;
using vvll = vector<vector<long long>>;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T>
inline bool chmin(T &a, T b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll n, m;
cin >> n >> m;
ll ans = 0;
for (int i = 0; i < (int)(m); i++) {
ll x, d;
cin >> x >> d;
ans += x * n;
if (d >= 0) {
ans += n * (n - 1) / 2 * d;
} else if (n & 1) {
ll l = n / 2;
ans += l * (l + 1) * d;
} else {
ll l = n / 2;
ans += l * l * d;
}
}
cout << fixed << setprecision(15) << (double)ans / n << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, bool MIN>
struct ConvexHullTrickAddMonotone {
using Line = pair<T, T>;
deque<Line> deq;
inline bool check(const Line &a, const Line &b, const Line &c) {
return (b.first - a.first) * (c.second - b.second) >=
(b.second - a.second) * (c.first - b.first);
}
inline T f(const Line &a, const T x) { return a.first * x + a.second; }
void add_line(T a, T b) {
if (!MIN) a = -a, b = -b;
Line line(a, b);
if (deq.empty()) return (void)deq.emplace_back(line);
if (deq.front().first <= a) {
if (deq.front().first == a) {
if (deq.front().second <= b) return;
deq.pop_front();
}
while (deq.size() >= 2 && check(line, deq.front(), deq[1]))
deq.pop_front();
deq.emplace_front(line);
} else {
if (deq.back().first == a) {
if (deq.back().second <= b) return;
deq.pop_back();
}
while (deq.size() >= 2 && check(deq[deq.size() - 2], deq.back(), line))
deq.pop_back();
deq.emplace_back(line);
}
}
T query(T x) {
int l = -1, r = deq.size() - 1;
while (l + 1 < r) {
int m = (l + r) >> 1;
(f(deq[m], x) >= f(deq[m + 1], x) ? l : r) = m;
}
return MIN ? f(deq[r], x) : -f(deq[r], x);
}
T query_monotone_inc(T x) {
while (deq.size() >= 2 && f(deq.front(), x) >= f(deq[1], x))
deq.pop_front();
return MIN ? f(deq.front(), x) : -f(deq.front(), x);
}
T query_monotone_dec(T x) {
while (deq.size() >= 2 && f(deq.back(), x) >= f(deq[deq.size() - 2], x))
deq.pop_back();
return MIN ? f(deq.back(), x) : -f(deq.back(), x);
}
};
const long long INF = 1LL << 60;
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
int main() {
int n, m;
cin >> n >> m;
int p;
cin >> p;
vector<int> d(n);
for (int i = 0; i < n - 1; i++) {
int x;
cin >> x;
d[i + 1] = d[i] + x;
}
vector<long long> x(m + 1);
for (int i = 0; i < m; i++) {
int h, t;
cin >> h >> t;
h--;
x[i + 1] = t - d[h] + 1e9;
}
sort(begin(x), end(x));
vector<vector<long long>> dp(p + 1, vector<long long>(m + 1, INF));
for (int i = 0; i <= p; i++) dp[i][0] = 0;
for (int i = 0; i < p; i++) {
ConvexHullTrickAddMonotone<long long, true> cht;
for (int j = 1; j <= m; j++) {
cht.add_line(-(j - 1), dp[i][j - 1]);
dp[i + 1][j] = cht.query(x[j]) + x[j] * j;
}
}
long long ans = dp[p][m];
for (int i = 0; i <= m; i++) ans -= x[i];
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int d1, d2, d3, a, b, c, d;
cin >> d1 >> d2 >> d3;
a = d1 + d3 + d2;
b = 2 * (d1 + d2);
c = 2 * (d1 + d3);
d = 2 * (d2 + d3);
if (a <= b && a <= c && a <= d) {
cout << a << endl;
} else if (b <= a && b <= c && b <= d) {
cout << b << endl;
} else if (c <= b && c <= a && c <= d) {
cout << c << endl;
} else if (d <= b && d <= c && d <= a) {
cout << d << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int Mod = 1000000007;
struct point {
int x, y;
point(){};
point(int x, int y) {
this->x = x;
this->y = y;
};
point operator-(const point &pt) {
return point(pt.x - this->x, pt.y - this->y);
}
point operator+(const point &pt) {
return point(pt.x + this->x, pt.y + this->y);
}
int operator*(const point &pt) { return this->x * pt.x + this->y * pt.y; }
int operator^(const point &pt) { return this->x * pt.y - this->y * pt.x; }
};
int main() {
int x, y;
scanf("%d %d", &x, &y);
point a(x, y);
scanf("%d %d", &x, &y);
point b(x, y);
scanf("%d %d", &x, &y);
point c(x, y);
point aa = b + (c - a);
point bb = c + (a - b);
point cc = a + (b - c);
puts("3");
printf("%d %d\n", aa.x, aa.y);
printf("%d %d\n", bb.x, bb.y);
printf("%d %d\n", cc.x, cc.y);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300005;
int a[maxn];
stack<int> s;
int main() {
int n;
scanf("%d", &n);
long long ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
ans += a[i] / 2;
if (a[i] % 2 == 0) continue;
if (!s.size() || s.top() == (i % 2))
s.push(i % 2);
else {
s.pop();
ans++;
}
}
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char A[100][50];
int ispal(int r, int l, int m) {
for (int i = 0, j = m - 1; i < m && j >= 0; i++, j--) {
if (A[r][i] != A[l][j]) return 0;
}
return 1;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> A[i];
int a = 0, ans = 0;
int B[1000], bcount = 0;
for (int i = 0; i < n; i++) {
int x = 0;
x = ispal(i, i, m);
if (x == 1)
a = i + 1;
else {
x = 0;
for (int j = i + 1; j < n; j++) {
x = ispal(i, j, m);
if (x == 1) break;
}
if (x == 1) {
B[bcount] = i;
bcount++;
}
}
}
if (a > 0)
cout << 2 * m * bcount + m;
else
cout << 2 * m * bcount;
cout << "\n";
for (int i = 0; i < bcount; i++) {
for (int j = 0; j < m; j++) cout << A[B[i]][j];
}
if (a > 0)
for (int j = 0; j < m; j++) cout << A[a - 1][j];
for (int i = bcount - 1; i >= 0; i--) {
for (int j = m - 1; j >= 0; j--) cout << A[B[i]][j];
}
cout << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
scanf("%i%i", &n, &m);
vector<long long> arr(n);
for (auto &x : arr) scanf("%lli", &x);
sort(arr.rbegin(), arr.rend());
int l = 1, r = n;
while (l <= r) {
int mid = l + r >> 1;
long long pag = 0;
for (int x = 0; x < n; x++) pag += max(0LL, arr[x] - x / mid);
if (pag >= m)
r = mid - 1;
else
l = mid + 1;
}
printf("%i\n", l > n ? -1 : l);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using lli = long long;
using lld = long double;
using ulli = unsigned long long int;
using pll = pair<lli, lli>;
using ttt = pair<lli, pll>;
using vttt = vector<ttt>;
using vll = vector<pll>;
using vl = vector<lli>;
using vi = vector<int>;
using vvi = vector<vector<int>>;
using cd = complex<lld>;
const double PI = acos(-1);
lli fen[2][2][1010][1010];
lli query(int x, int y) {
lli res = 0;
int px = x % 2, py = y % 2;
for (int i = x + 2; i > 0; i -= (i & -i))
for (int j = y + 2; j > 0; j -= (j & -j)) res ^= fen[px][py][i][j];
return res;
}
void update(int x, int y, long long val) {
int px = x % 2, py = y % 2;
for (int i = x + 2; i < 1010; i += (i & -i))
for (int j = y + 2; j < 1010; j += (j & -j)) fen[px][py][i][j] ^= val;
}
int tejas_919(int kkkk) {
lli n, m, k, q, u, v, temp = 0, ans = 0;
cin >> n >> q;
while (q--) {
lli typ, x0, x1, y0, y1, val = 0;
cin >> typ >> x0 >> y0 >> x1 >> y1;
if (typ == 1) {
x0--;
y0--;
val ^= query(x1, y1);
val ^= query(x0, y1);
val ^= query(x1, y0);
val ^= query(x0, y0);
cout << val << '\n';
} else {
cin >> val;
x1++;
y1++;
update(x0, y0, val);
update(x0, y1, val);
update(x1, y0, val);
update(x1, y1, val);
}
}
return 0;
}
signed main() {
if (!0) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
cout << fixed << setprecision(10);
int t = 1;
for (int i = 0; i < t; i++) {
tejas_919(i + 1);
}
{};
}
| 8 |
#include <bits/stdc++.h>
#pragma GCC optimize "O3"
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = 0x3f3f3f3f3f3f3f3f;
int n, r, ans, lans;
vector<pair<int, int> > spoko, nie;
int dp[60010];
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
return a.first + a.second > b.first + b.second;
}
void solve() {
int a, b;
cin >> n >> r;
for (int i = 1; i <= n; i++) {
cin >> a >> b;
a = max(a, -b);
if (b >= 0)
spoko.push_back({a, b});
else
nie.push_back({a, b});
}
sort(spoko.begin(), spoko.end());
sort(nie.begin(), nie.end(), cmp);
for (auto &x : spoko)
if (r >= x.first) r += x.second, ans++;
memset(dp, -inf, sizeof(dp));
dp[r] = 0;
for (auto &x : nie)
for (int j = x.first; j <= r; j++)
dp[j + x.second] = max(dp[j + x.second], dp[j] + 1);
cout << ans + *max_element(dp, dp + sizeof(dp) / sizeof(int)) << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, k;
cin >> n >> k;
vector<vector<int> > a(n, vector<int>(n));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i == j) {
cout << k << " ";
} else {
cout << 0 << " ";
}
}
cout << '\n';
}
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
vector<long long int> primes;
long long int MOD = 1e9 + 7;
void Sieve(long long int n) {
vector<bool> prime(n + 1, true);
for (long long int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (long long int p = 2; p <= n; p++)
if (prime[p]) primes.push_back(p);
}
long long int dnc(long long int bas, long long int power, long long int mod) {
if (power == 0) return 1;
if (power % 2 == 0) {
int res = dnc(bas, power / 2, mod);
return 1LL * res * res % mod;
}
return 1LL * bas * dnc(bas, power - 1, mod) % mod;
}
long long int f[2 * 300010 + 1], inv[2 * 300010 + 1];
void precalc() {
f[0] = inv[0] = 1;
for (long long int temp = 1; temp <= 2 * 300010; temp++) {
f[temp] = 1ll * temp * f[temp - 1] % MOD;
inv[temp] = dnc(temp, MOD - 2, MOD) * inv[temp - 1] % MOD;
}
}
long long int comb(long long int n, long long int k) {
if (k > n || k < 0) return 0;
return f[n] * inv[k] % MOD * inv[n - k] % MOD;
}
long long int n, k;
vector<vector<vector<long long int>>> dp;
void solve2(long long int i, long long int j) {
long long int mask = j;
if (!(mask & (1 << 0))) {
mask += 2;
if (mask >= pow(2, k)) {
mask ^= (1 << k);
dp[i][mask][1] += dp[i - 1][j][0] + dp[i - 1][j][1];
dp[i][mask][1] %= MOD;
} else {
dp[i][mask][1] += dp[i - 1][j][1];
dp[i][mask][0] += dp[i - 1][j][0];
dp[i][mask][1] %= MOD;
dp[i][mask][0] %= MOD;
}
}
}
void solve4(long long int i, long long int j) {
long long int mask = j;
if (!(mask & (1 << 0))) {
if ((mask & (1 << 1))) {
dp[i][4][0] += dp[i - 1][j][0];
dp[i][4][1] += dp[i - 1][j][1];
dp[i][4][0] %= MOD;
dp[i][4][1] %= MOD;
} else {
mask += 4;
if (mask >= pow(2, k)) {
mask ^= (1 << k);
dp[i][mask][1] += dp[i - 1][j][0] + dp[i - 1][j][1];
dp[i][mask][1] %= MOD;
} else {
dp[i][mask][0] += dp[i - 1][j][0];
dp[i][mask][1] += dp[i - 1][j][1];
dp[i][mask][0] %= MOD;
dp[i][mask][1] %= MOD;
}
}
}
}
int main() {
cin >> n;
cin >> k;
vector<long long int> a(n + 1);
for (long long int i = 0; i < n; i++) cin >> a[i + 1];
dp = vector<vector<vector<long long int>>>(
n + 1,
vector<vector<long long int>>(1 << k, vector<long long int>(2, 0)));
dp[0][0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < (1 << k); j++) {
if (a[i] == 2) solve2(i, j);
if (a[i] == 4) solve4(i, j);
if (a[i] == 0) {
solve2(i, j);
solve4(i, j);
}
}
}
long long int ans = 0;
for (int j = 0; j < (1 << k); j++) {
ans += dp[n][j][1];
ans %= MOD;
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, max = 0;
cin >> a >> b;
int *mas = new int[a];
cin >> mas[0];
for (int i = 1; i < a; ++i) {
cin >> mas[i];
if (max < mas[i - 1] - mas[i] - b) {
max = mas[i - 1] - mas[i] - b;
}
}
cout << max << endl;
delete[] mas;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
void solve() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long ar[n];
for (long long i = 0; i < n; i++) cin >> ar[i];
vector<long long> inc;
vector<long long> dec;
long long mn = INT_MIN;
long long mx = INT_MAX;
vector<long long> ans(n, -1);
for (long long i = 0; i < n; i++) {
if (ar[i] >= mx && ar[i] <= mn) {
cout << "NO" << endl;
return;
}
if (ar[i] <= mn) {
mx = ar[i];
ans[i] = 1;
} else if (ar[i] >= mx) {
mn = ar[i];
ans[i] = 0;
} else {
if (i + 1 == n) {
ans[i] = 0;
} else {
if (ar[i + 1] == ar[i]) {
mn = ar[i];
ans[i] = 0;
} else if (ar[i + 1] > ar[i]) {
mn = ar[i];
ans[i] = 0;
} else {
mx = ar[i];
ans[i] = 1;
}
}
}
}
cout << "YES" << endl;
for (long long i = 0; i < n; i++) cout << ans[i] << " ";
}
int32_t main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s[55];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
bool same = 1, flag = 1;
for (int k = 0; k < m; k++) {
if (s[i][k] != s[j][k]) same = 0;
if (s[i][k] == '#' && s[j][k] == '#') flag = 0;
}
if (!same && !flag) return cout << "No\n", 0;
}
}
cout << "Yes\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main() {
long long a(0), b(0), k(0);
std::cin >> a >> b;
while (a && b) {
if (a < b) {
k += b / a;
b %= a;
} else {
k += a / b;
a %= b;
}
}
std::cout << k;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> g[2000];
bool been[2000];
void visit(int node) {
been[node] = true;
for (int i = 0; i < g[node].size(); i++) {
if (!been[g[node][i]]) {
visit(g[node][i]);
}
}
}
int main(void) {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i + k - 1 < n; i++) {
for (int j = 0; j < k; j++) {
g[i + j].push_back(i + k - 1 - j);
}
}
int sol = 1;
for (int i = 0; i < n; i++) {
if (!been[i]) {
visit(i);
sol = ((long long)sol * m) % 1000000007;
}
}
printf("%d\n", sol);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005, K = 2400005, E = 3000005;
int tp, n, q, c, e, a, b, z, x, y, tot, toa, tob, toc, tod, toe, ind, ine, fr;
struct node {
int x, y, z, t;
} na[N], nb[N], nc[N], nd[N], ne[N], nm[N];
int out[N], lc[K], rc[K], fro[K], lt[E], rt[E], now[E];
bool cmpt(node a, node b) { return abs(a.t) < abs(b.t); }
bool cmpa(node a, node b) { return a.x < b.x; }
bool cmpb(node a, node b) { return a.x < b.x; }
bool cmpc(node a, node b) { return a.x > b.x; }
bool cmpd(node a, node b) { return a.x > b.x; }
inline void get(int &a) {
char c = getchar();
a = 0;
for (; c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) a = a * 10 + c - '0';
}
void add(int &p, int l, int r, int q, int x) {
if (p == 0) {
p = ++ine;
lt[p] = rt[p] = now[p] = 0;
}
now[p] += x;
if (l == r) return;
if (q <= ((l + r) >> 1))
add(lt[p], l, ((l + r) >> 1), q, x);
else
add(rt[p], ((l + r) >> 1) + 1, r, q, x);
}
void add(int &p, int l, int r, int el, int er, int q, int s, int x) {
if (!(l <= q && q <= r) || !(el <= s && s <= er)) return;
if (p == 0) {
p = ++ind;
lc[p] = rc[p] = fro[p] = 0;
}
add(fro[p], el, er, s, x);
if (l == r) return;
if (q <= ((l + r) >> 1))
add(lc[p], l, ((l + r) >> 1), el, er, q, s, x);
else
add(rc[p], ((l + r) >> 1) + 1, r, el, er, q, s, x);
}
int query(int p, int l, int r, int ql, int qr) {
if (p == 0) return 0;
if (ql <= l && r <= qr) return now[p];
int ans = 0;
if (l <= qr && ql <= ((l + r) >> 1))
ans += query(lt[p], l, ((l + r) >> 1), ql, qr);
if (((l + r) >> 1) + 1 <= qr && ql <= r)
ans += query(rt[p], ((l + r) >> 1) + 1, r, ql, qr);
return ans;
}
int query(int p, int l, int r, int el, int er, int ql, int qr, int sl, int sr) {
if (p == 0) return 0;
ql = max(l, ql);
qr = min(r, qr);
sl = max(sl, el);
sr = min(sr, er);
if (ql > qr || sl > sr) return 0;
if (ql <= l && r <= qr) return query(fro[p], el, er, sl, sr);
int ans = 0;
if (l <= qr && ql <= ((l + r) >> 1))
ans += query(lc[p], l, ((l + r) >> 1), el, er, ql, qr, sl, sr);
if (((l + r) >> 1) + 1 <= qr && ql <= r)
ans += query(rc[p], ((l + r) >> 1) + 1, r, el, er, ql, qr, sl, sr);
return ans;
}
void worka(int l, int r) {
if (l == r) return;
int mid = (l + r) / 2;
worka(l, mid);
worka(mid + 1, r);
sort(nm + l, nm + 1 + mid, cmpa);
sort(nm + 1 + mid, nm + 1 + r, cmpa);
ind = ine = fr = 0;
for (int i = l, j = mid + 1; j <= r; j++) {
while (i <= mid && nm[i].x <= nm[j].x) {
if (nm[i].t < 0) {
i++;
continue;
}
add(fr, 1, n, 2, 2 * n, nm[i].y, nm[i].z, 1);
i++;
}
if (nm[j].t < 0)
out[-nm[j].t] += query(fr, 1, n, 2, 2 * n, 1, nm[j].y, nm[j].z, 2 * n);
}
}
void workb(int l, int r) {
if (l == r) return;
int mid = (l + r) / 2;
workb(l, mid);
workb(mid + 1, r);
sort(nm + l, nm + 1 + mid, cmpb);
sort(nm + 1 + mid, nm + 1 + r, cmpb);
ind = ine = fr = 0;
for (int i = l, j = mid + 1; j <= r; j++) {
while (i <= mid && nm[i].x <= nm[j].x) {
if (nm[i].t < 0) {
i++;
continue;
}
add(fr, 1, n, -n + 1, n - 1, nm[i].y, nm[i].z, 1);
i++;
}
if (nm[j].t < 0)
out[-nm[j].t] +=
query(fr, 1, n, -n + 1, n - 1, nm[j].y, n, nm[j].z, n - 1);
}
}
void workc(int l, int r) {
if (l == r) return;
int mid = (l + r) / 2;
workc(l, mid);
workc(mid + 1, r);
sort(nm + l, nm + 1 + mid, cmpc);
sort(nm + 1 + mid, nm + 1 + r, cmpc);
ind = ine = fr = 0;
for (int i = l, j = mid + 1; j <= r; j++) {
while (i <= mid && nm[i].x >= nm[j].x) {
if (nm[i].t < 0) {
i++;
continue;
}
add(fr, 1, n, -n + 1, n - 1, nm[i].y, nm[i].z, 1);
i++;
}
if (nm[j].t < 0)
out[-nm[j].t] +=
query(fr, 1, n, -n + 1, n - 1, 1, nm[j].y, -n + 1, nm[j].z);
}
}
void workd(int l, int r) {
if (l == r) return;
int mid = (l + r) / 2;
workd(l, mid);
workd(mid + 1, r);
sort(nm + l, nm + 1 + mid, cmpd);
sort(nm + 1 + mid, nm + 1 + r, cmpd);
ind = ine = fr = 0;
for (int i = l, j = mid + 1; j <= r; j++) {
while (i <= mid && nm[i].x >= nm[j].x) {
if (nm[i].t < 0) {
i++;
continue;
}
add(fr, 1, n, 2, 2 * n, nm[i].y, nm[i].z, 1);
i++;
}
if (nm[j].t < 0)
out[-nm[j].t] += query(fr, 1, n, 2, 2 * n, nm[j].y, n, 2, nm[j].z);
}
}
int main() {
get(n);
get(q);
for (int i = 1; i <= q; i++) {
get(c);
if (c == 1) {
get(tp);
get(a);
get(b);
get(z);
switch (tp) {
case 1:
na[++toa] = (node){a, b, a + b + z, i};
break;
case 2:
nb[++tob] = (node){a, b, a - b + z, i};
break;
case 3:
nc[++toc] = (node){a, b, a - b - z, i};
break;
case 4:
nd[++tod] = (node){a, b, a + b - z, i};
break;
}
} else {
get(x);
get(y);
ne[++toe] = (node){x, y, 0, i};
}
}
tot = 0;
for (int i = 1; i <= toa; i++) nm[++tot] = na[i];
for (int i = 1; i <= toe; i++)
nm[++tot] = (node){ne[i].x, ne[i].y, ne[i].x + ne[i].y, -ne[i].t};
sort(nm + 1, nm + 1 + tot, cmpt);
worka(1, tot);
tot = 0;
for (int i = 1; i <= tob; i++) nm[++tot] = nb[i];
for (int i = 1; i <= toe; i++)
nm[++tot] = (node){ne[i].x, ne[i].y, ne[i].x - ne[i].y, -ne[i].t};
sort(nm + 1, nm + 1 + tot, cmpt);
workb(1, tot);
tot = 0;
for (int i = 1; i <= toc; i++) nm[++tot] = nc[i];
for (int i = 1; i <= toe; i++)
nm[++tot] = (node){ne[i].x, ne[i].y, ne[i].x - ne[i].y, -ne[i].t};
sort(nm + 1, nm + 1 + tot, cmpt);
workc(1, tot);
tot = 0;
for (int i = 1; i <= tod; i++) nm[++tot] = nd[i];
for (int i = 1; i <= toe; i++)
nm[++tot] = (node){ne[i].x, ne[i].y, ne[i].x + ne[i].y, -ne[i].t};
sort(nm + 1, nm + 1 + tot, cmpt);
workd(1, tot);
for (int i = 1; i <= toe; i++) printf("%d\n", out[ne[i].t]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e6 + 10;
const int MAXK = 1e5 + 3;
const int Candy = 1e7;
const int mod = 1e9 + 7;
const long long inf = 1ll << 55;
const long double pi = 3.1415926535897932384626433;
const long double eps = 1e-12;
int fast_pow(int a, int b) {
int res = a, ret = 1;
while (b > 0) {
if (b % 2) ret = (ret * res) % mod;
res = (res * res) % mod;
b /= 2;
}
return ret;
}
int a[N], n, k, j;
string s;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> s;
if (k == 1)
cout << 1;
else
cout << 0;
for (long long i = (1); i <= (n - 1); ++i) {
while (j && s[i] != s[j]) j = a[j];
if (s[i] == s[j]) j++;
a[i + 1] = j;
int l = i + 1, a = l - j;
if (l % a == 0) {
l /= a;
if (l / k >= l % k)
cout << 1;
else
cout << 0;
} else {
l /= a;
if (l / k > l % k)
cout << 1;
else
cout << 0;
}
}
return (!false && !true) || ((long long)((long long)(1713 + 2377 + 1464) *
(long long)(1713 + 2377 + 1464) *
(long long)(1713 + 2377 + 1464)) !=
(long long)(171323771464));
}
| 7 |
#include <bits/stdc++.h>
const int N = 100005;
int n, w1[N * 2], w2[N * 2], tot;
bool vis[N];
struct data {
int x, op, id;
} p[N * 2];
struct pts {
int x1, y1, x2, y2;
} a[N];
struct Queue {
std::priority_queue<int> a, b;
void work() {
while (!b.empty() && a.top() == b.top()) a.pop(), b.pop();
}
int top() {
work();
return a.top();
}
bool empty() {
work();
return a.empty();
}
void push(int x) { a.push(x); }
void erase(int x) { b.push(x); }
};
struct tree {
int mx, mn;
Queue col;
} t[N * 8];
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;
}
bool cmp(data a, data b) { return a.x > b.x || a.x == b.x && a.op < b.op; }
void updata(int d, int l, int r) {
if (l != r) {
t[d].mn = std::min(t[d * 2].mn, t[d * 2 + 1].mn);
t[d].mx = std::max(t[d * 2].mx, t[d * 2 + 1].mx);
} else
t[d].mn = t[d].mx = 0;
if (!t[d].col.empty()) {
int x = t[d].col.top();
if (vis[x])
t[d].mn = std::max(t[d].mn, x);
else
t[d].mx = std::max(t[d].mx, x);
if (t[d].mn > t[d].mx) t[d].mx = 0;
}
}
void ins(int d, int l, int r, int x, int y, int z) {
if (x <= l && r <= y) {
if (z > 0)
t[d].col.push(z);
else if (z < 0)
t[d].col.erase(-z);
updata(d, l, r);
return;
}
int mid = (l + r) / 2;
if (x <= mid) ins(d * 2, l, mid, x, y, z);
if (y > mid) ins(d * 2 + 1, mid + 1, r, x, y, z);
updata(d, l, r);
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i].x1 = read();
a[i].y1 = read();
a[i].x2 = read();
a[i].y2 = read();
w1[i * 2 - 1] = a[i].x1;
w1[i * 2] = a[i].x2;
w2[i * 2 - 1] = a[i].y1;
w2[i * 2] = a[i].y2;
}
std::sort(w1 + 1, w1 + n * 2 + 1);
std::sort(w2 + 1, w2 + n * 2 + 1);
for (int i = 1; i <= n; i++) {
a[i].x1 = std::lower_bound(w1 + 1, w1 + n * 2 + 1, a[i].x1) - w1;
a[i].x2 = std::lower_bound(w1 + 1, w1 + n * 2 + 1, a[i].x2) - w1;
a[i].y1 = std::lower_bound(w2 + 1, w2 + n * 2 + 1, a[i].y1) - w2;
a[i].y2 = std::lower_bound(w2 + 1, w2 + n * 2 + 1, a[i].y2) - w2 - 1;
p[++tot].x = a[i].x2;
p[tot].op = 0;
p[tot].id = i;
p[++tot].x = a[i].x1;
p[tot].op = 1;
p[tot].id = i;
}
std::sort(p + 1, p + tot + 1, cmp);
int l = 1, ans = 0;
while (l <= tot) {
int r = l;
while (r < tot && p[r + 1].x == p[l].x) r++;
while (l <= r) {
if (!p[l].op)
ins(1, 1, n * 2, a[p[l].id].y1, a[p[l].id].y2, p[l].id);
else
ins(1, 1, n * 2, a[p[l].id].y1, a[p[l].id].y2, -p[l].id);
l++;
}
while (t[1].mx) {
ans++;
int x = t[1].mx;
vis[x] = 1;
ins(1, 1, n * 2, a[x].y1, a[x].y2, 0);
}
}
printf("%d", ans + 1);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T in() {
char ch;
T n = 0;
bool ng = false;
while (1) {
ch = getchar();
if (ch == '-') {
ng = true;
ch = getchar();
break;
}
if (ch >= '0' && ch <= '9') break;
}
while (1) {
n = n * 10 + (ch - '0');
ch = getchar();
if (ch < '0' || ch > '9') break;
}
return (ng ? -n : n);
}
template <typename T>
inline T POW(T B, T P) {
if (P == 0) return 1;
if (P & 1)
return B * POW(B, P - 1);
else
return (POW(B, P / 2) * POW(B, P / 2));
}
template <typename T>
inline T Gcd(T a, T b) {
if (a < 0) return Gcd(-a, b);
if (b < 0) return Gcd(a, -b);
return (b == 0) ? a : Gcd(b, a % b);
}
template <typename T>
inline T Lcm(T a, T b) {
if (a < 0) return Lcm(-a, b);
if (b < 0) return Lcm(a, -b);
return a * (b / Gcd(a, b));
}
long long Bigmod(long long base, long long power, long long MOD) {
long long ret = 1;
while (power) {
if (power & 1) ret = (ret * base) % MOD;
base = (base * base) % MOD;
power >>= 1;
}
return ret;
}
bool isVowel(char ch) {
ch = toupper(ch);
if (ch == 'A' || ch == 'U' || ch == 'I' || ch == 'O' || ch == 'E')
return true;
return false;
}
template <typename T>
long long int isLeft(T a, T b, T c) {
return (a.x - b.x) * (b.y - c.y) - (b.x - c.x) * (a.y - b.y);
}
long long ModInverse(long long number, long long MOD) {
return Bigmod(number, MOD - 2, MOD);
}
bool isConst(char ch) {
if (isalpha(ch) && !isVowel(ch)) return true;
return false;
}
int toInt(string s) {
int sm;
stringstream second(s);
second >> sm;
return sm;
}
long long int sm[200007];
int a[200007], n;
long long int Tree[200007];
void Update(int id, long long int v) {
while (id <= n) {
Tree[id] = max(Tree[id], v);
id += id & -id;
}
}
long long int Query(int id) {
long long int ans = -2000000000;
while (id > 0) {
ans = max(ans, Tree[id]);
id -= id & -id;
}
return ans;
}
int main() {
n = in<int>();
for (int i = 1; i < n + 1; i++) Tree[i] = -2000000000;
for (int i = 1; i < n + 1; i++) {
a[i] = in<int>();
sm[i] = sm[i - 1] + a[i];
}
Update(n, sm[n]);
long long int ans;
for (int i = n - 1; i >= 1; i--) {
long long int an = Query(n);
ans = an;
an = -an + sm[i];
Update(i, an);
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000010;
long long deg[N];
int main() {
memset(deg, 0, sizeof(deg));
int n, m, x, y;
ios::sync_with_stdio(false);
cin >> n >> m;
while (m--) {
cin >> x >> y;
deg[x]++;
deg[y]++;
}
long long ans = 0;
for (int i = 1; i <= n; i++) ans += deg[i] * (n - deg[i] - 1);
ans = 1LL * n * (n - 1) * (n - 2) / 6 - ans / 2;
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void print(int cnt7, int cnt4) {
for (int i = 0; i < cnt4; ++i) {
cout << 4;
}
for (int i = 0; i < cnt7; ++i) {
cout << 7;
}
cout << endl;
}
int main() {
int n;
scanf("%d", &n);
int end = n / 7;
if (n % 7) end++;
int begin = n / 4;
for (int i = end; i <= begin; i++) {
int cnt7 = i;
int cnt4 = 0;
while (cnt7 * 7 + cnt4 * 4 >= n) {
cnt7--, cnt4++;
}
cnt7++, cnt4--;
if (cnt7 >= 0 && cnt4 >= 0 && cnt7 * 7 + cnt4 * 4 == n) {
print(cnt7, cnt4);
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool test(const vector<long long>& a) {
set<long long> seen;
for (long long i = 1; i < a.size(); i++) {
if (seen.count(a[i])) return true;
seen.insert(a[i - 1]);
}
return false;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
for (long long nr = 0; nr < t; nr++) {
long long n;
cin >> n;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
cout << (test(a) ? "YES" : "NO") << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long tok[100010];
int main() {
long long n, a, b;
cin >> n >> a >> b;
for (int i = 0; i < n; i++) {
cin >> tok[i];
cout << (((tok[i] * a) % b) / a) << ' ';
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
int long long t, n, m, x, sm;
cin >> t;
while (t--) {
cin >> n >> m;
m--;
sm = 0;
for (long long i = 0; i < n - 1; i++) cin >> x, x--, sm += x;
sm %= n;
cout << (m - sm + n) % n + 1 << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 29;
int n;
vector<string> g;
vector<int> v;
void dfs(int id, int prev = -1) {
v[id] = 1;
for (int i = 0; i < n; ++i)
if (g[id][i] == '1') {
if (v[i] == 0)
dfs(i, id);
else if (prev != -1 && g[i][prev] == '1') {
cout << prev + 1 << ' ' << id + 1 << ' ' << i + 1;
exit(0);
}
}
}
void task() {
ios_base::sync_with_stdio(0);
cin >> n;
g.resize(n);
v.resize(n, 0);
for (int i = 0; i < n; ++i) cin >> g[i];
for (int i = 0; i < n; ++i) dfs(i);
cout << -1;
}
int main() {
task();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
const long long mas = 3010;
long long kp[mas][mas], pred[mas][mas];
long long dp[mas][mas];
long long usdp[mas][mas];
long long n;
vector<long long> tree[mas];
long long us[mas];
long long in[mas];
long long timer = 0;
long long ans = 0;
void dfs(long long nac, long long u, long long v) {
us[v] = 1;
pred[nac][v] = u;
in[v] = ++timer;
for (auto i : tree[v]) {
if (!us[i]) {
dfs(nac, v, i);
}
}
kp[nac][v] = 1 + timer - in[v];
}
void new_dp(long long u, long long v) {
if (!usdp[pred[v][u]][v]) new_dp(pred[v][u], v);
if (!usdp[u][pred[u][v]]) new_dp(u, pred[u][v]);
dp[u][v] = max(dp[pred[v][u]][v], dp[u][pred[u][v]]) + kp[u][v] * kp[v][u];
ans = max(ans, dp[u][v]);
usdp[u][v] = 1;
}
int main() {
fast();
cin >> n;
long long u, v;
for (int i = 1; i <= n; ++i) {
cin >> u >> v;
tree[u].push_back(v);
tree[v].push_back(u);
}
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) us[j] = 0;
dfs(i, 0, i);
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j) dp[i][j] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j) usdp[i][j] = 0;
}
for (int i = 1; i <= n; ++i) usdp[i][i] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= n; ++j)
if (!usdp[i][j]) new_dp(i, j);
}
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
string d;
long long int n, x = 0, b = 0, f = 0;
vector<long long int> s;
bool ch(long long int z, long long int y) {
if (z <= y)
return 1;
else
return 0;
}
int main() {
cin >> n;
cin >> d;
if (n == 0 && d[0] == '0' && d.size() == 1) {
cout << "OK";
return 0;
}
if (d[0] == '0') {
cout << "WRONG_ANSWER";
return 0;
}
for (int i = 0; i < d.size(); i++) {
b *= 10;
b += (d[i] - '0');
}
while (n > 0) {
if (n % 10 == 0) f++;
s.push_back(n % 10);
n /= 10;
}
sort(s.begin(), s.end(), ch);
x = 0;
if (s.size() > 1) swap(s[0], s[f]);
for (int i = 0; i < s.size(); i++) {
x *= 10;
x += s[i];
}
if (b == x)
cout << "OK";
else
cout << "WRONG_ANSWER";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const ll mod = 1e9 + 7;
ll mod_pow(ll b, ll e) {
ll r = 1;
for (; e; e >>= 1, b = b * b % mod) {
if (e & 1) r = r * b % mod;
}
return r;
}
void solve() {
int n, m;
cin >> n >> m;
vector<int> a(n);
for (int &x : a) cin >> x;
map<int, int> cnt;
for (int x : a) cnt[-x]++;
for (auto it = cnt.begin(); it != cnt.end();) {
if (it->second % m) break;
cnt[it->first + 1] += it->second / m;
auto it2 = it;
it++;
cnt.erase(it2);
}
ll p = accumulate((a).begin(), (a).end(), 0ll);
if (!cnt.empty() && cnt.begin()->first < 0) p += cnt.begin()->first;
cout << mod_pow(m, p);
}
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int tcs = 1;
for (int tc = 1; tc <= tcs; tc++) {
solve();
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long a, b, c, d;
cin >> a >> b >> c >> d;
if (a > b * c) {
cout << -1 << endl;
continue;
}
if (c < d) {
cout << a << endl;
continue;
}
if (c >= d) {
cout << (a / b / d) * a + a - d * b * (a / b / d) * (a / b / d + 1) / 2
<< endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long A[110000], N, i, j, k, x, y;
char S[110000], C;
int main() {
cin >> N;
cin >> x;
cin >> y;
k = y - N + 1;
if (k < 1 || k * k + N - 1 < x) {
printf("-1\n");
return 0;
} else {
cout << k << "\n";
for (i = 1; i < N; i++) printf("1\n");
return 0;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin>>t;
while(t--)
{
int n,k,i,count=0,f,l;
cin>>n>>k;
string s;
cin>>s;
n=s.length();
for(i=0;i<n;i++)
{
if(s[i]=='*')
{
f=i;
count++;
break;
}
}
for(i=n-1;i>f;i--)
{
if(s[i]=='*')
{
l=i;
count++;
break;
}
}
if(count==1||l-f<=k)
{
cout<<count<<endl;
continue;
}
i=f+k;
while(i<l)
{
if(s[i]=='.')
{
i--;
}
else if(s[i]=='*')
{
i+=k;
count++;
}
}
cout<<count<<endl;
}
// your code goes here
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int mod, b, n, m;
int arr[509];
int dp[2][509][509];
int main() {
int i, j, k, a;
cin >> n >> m >> b >> mod;
for (i = 1; i <= n; i++) {
scanf("%d", &arr[i]);
}
long long int ans = 0;
dp[0][0][0] = 1;
for (i = 1; i <= n; i++) {
a = i % 2;
for (j = 0; j <= m; j++) {
for (k = 0; k <= b; k++) {
dp[a][j][k] = dp[1 - a][j][k];
if (k - arr[i] >= 0 && j > 0)
dp[a][j][k] = (dp[a][j][k] + dp[a][j - 1][k - arr[i]]) % mod;
}
}
}
for (i = 0; i <= b; i++) ans = (ans + dp[n % 2][m][i]) % mod;
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void read(_T &x) {
x = 0;
long long f = 1;
char s = getchar();
while (s < '0' || s > '9') {
f = 1;
if (s == '-') f = -1;
s = getchar();
}
while ('0' <= s && s <= '9') {
x = (x << 3) + (x << 1) + s - '0';
s = getchar();
}
x *= f;
}
long long n, m, k, p;
long long dp[233][233][233];
long long c[233][233], k_;
long long fac[23333];
signed main() {
read(n), read(m), read(k_), read(p);
const long long mod = p;
c[0][0] = 1;
fac[0] = 1;
for (long long i = 1; i <= 100; i++) fac[i] = fac[i - 1] * i, fac[i] %= mod;
for (long long i = 1; i <= 100; i++) {
c[i][0] = 1;
for (long long j = 1; j <= i; j++)
c[i][j] = c[i - 1][j - 1] + c[i - 1][j], c[i][j] %= mod;
}
for (long long i = 0; i <= n; i++) dp[0][i][0] = 1;
for (long long i = 1; i <= n; i++) dp[i][1][1] = fac[i];
for (long long i = 1; i <= n; i++)
for (long long j = i + 1; j <= n; j++) dp[i][j][0] = fac[i];
for (register long long i = 2; i <= n; i++) {
for (register long long j = 1; j <= m && j <= i; j++) {
for (register long long k = 0; k <= i - j + 1 && k <= k_; k++) {
register long long tmp = dp[i][j][k];
for (register long long a = 0; a <= i - 1; a++) {
register long long tmp_ = 0;
for (register long long b = 0; b <= k; b++) {
if (dp[a][j - 1][b] && dp[i - 1 - a][j - 1][k - b - (j == 1)]) {
tmp_ +=
((dp[a][j - 1][b] * dp[i - 1 - a][j - 1][k - b - (j == 1)]) %
mod);
tmp_ -= tmp_ >= mod ? mod : 0;
}
}
tmp_ *= c[i - 1][a];
tmp_ %= mod;
tmp += tmp_;
tmp -= tmp >= mod ? mod : 0;
}
dp[i][j][k] = tmp;
}
}
}
printf("%lld", dp[n][m][k_]);
}
| 9 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
const long long N = 2e5 + 5;
vector<int> g[N];
long long a[N], dp[N], sum[N], ans = 0;
void precalc(int v, int p) {
for (auto to : g[v]) {
if (to == p) {
continue;
}
precalc(to, v);
dp[v] += dp[to] + sum[to];
sum[v] += sum[to];
}
sum[v] += a[v];
}
void dfs(int v, int p) {
ans = max(ans, dp[v]);
for (auto to : g[v]) {
if (to == p) {
continue;
}
dp[v] = dp[v] - (dp[to] + sum[to]);
sum[v] -= sum[to];
sum[to] += sum[v];
dp[to] = dp[to] + dp[v] + sum[v];
dfs(to, v);
dp[to] = dp[to] - (dp[v] + sum[v]);
sum[to] -= sum[v];
sum[v] += sum[to];
dp[v] = dp[v] + dp[to] + sum[to];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 1; i < n; i++) {
int u, v;
cin >> u >> v;
v--;
u--;
g[u].push_back(v);
g[v].push_back(u);
}
precalc(0, 0);
dfs(0, 0);
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, h;
cin >> n >> h;
vector<vector<long long> > dp(n + 1, vector<long long>(n + 1));
long long p1, p2;
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= i; k++) {
p1 = p2 = 0;
for (int l = 0; l < j - 1; l++) p1 += dp[k - 1][l];
p1 *= dp[i - k][j - 1];
for (int l = 0; l < j; l++) p2 += dp[i - k][l];
p2 *= dp[k - 1][j - 1];
dp[i][j] += p1 + p2;
}
}
}
long long ans = 0;
for (int i = h; i <= n; i++) ans += dp[n][i];
cout << ans << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long int Maxn = 1e5 + 5, Mod = 1e9 + 7, Inf = 1e9;
int n, m, comp_sz, cnt[Maxn], ans = Inf;
vector<int> adj[Maxn], Lucky_Numbers;
vector<pair<int, int> > arr;
set<int> st;
set<int>::iterator it;
bool mr[Maxn];
void Dfs(int v) {
mr[v] = 1;
comp_sz++;
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (!mr[u]) {
Dfs(u);
}
}
return;
}
void Dfs_All() {
for (int i = 1; i <= n; i++) {
if (!mr[i]) {
comp_sz = 0;
Dfs(i);
cnt[comp_sz]++;
st.insert(comp_sz);
}
}
return;
}
void Copy() {
it = st.begin();
int ind = 0;
while (it != st.end()) {
int x = cnt[(*it)], power = 1;
while (power <= x) {
x -= power;
arr.push_back({(*it) * power, power});
power *= 2;
}
if (x) {
arr.push_back({(*it) * x, x});
}
it++;
}
return;
}
int dp[2][Maxn];
void Knapsak() {
for (int i = 1; i < Maxn; i++) {
dp[0][i] = dp[1][i] = Inf;
}
dp[0][0] = dp[1][0] = 0;
dp[0][arr[0].first] = arr[0].second;
for (int i = 1; i < arr.size(); i++) {
int x = arr[i].first, y = arr[i].second;
for (int j = 1; j <= n; j++) {
dp[i % 2][j] = dp[1 - (i % 2)][j];
if (x <= j) {
dp[i % 2][j] = min(dp[i % 2][j], dp[1 - i % 2][j - x] + y);
}
}
}
return;
}
queue<int> q;
bool mrk[Maxn];
void Find_Lucky_Numbers() {
int sz = arr.size() - 1;
if (4 <= n) {
q.push(4);
mrk[4] = 1;
ans = min(ans, dp[sz % 2][4]);
}
if (7 <= n) {
q.push(7);
mrk[7] = 1;
ans = min(ans, dp[sz % 2][7]);
}
while (q.size()) {
int v = q.front();
q.pop();
if (v * 10 + 4 <= n) {
q.push(v * 10 + 4);
mrk[v * 10 + 4] = 1;
ans = min(ans, dp[sz % 2][v * 10 + 4]);
}
if (v * 10 + 7 <= n) {
q.push(v * 10 + 7);
mrk[v * 10 + 7] = 1;
ans = min(ans, dp[sz % 2][v * 10 + 7]);
}
}
return;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
adj[u].push_back(v), adj[v].push_back(u);
}
Dfs_All();
Copy();
Knapsak();
Find_Lucky_Numbers();
if (ans == Inf) ans = 0;
cout << ans - 1 << '\n';
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int a[100100];
int ans[100100];
int main() {
int n;
cin >> n;
a[0] = INT_MAX;
stack<int> stack_;
int result = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = n; i >= 1; i--) {
ans[i] = 0;
while (stack_.size() && a[stack_.top()] < a[i]) {
ans[i]++;
ans[i] = max(ans[i], ans[stack_.top()]);
stack_.pop();
}
stack_.push(i);
}
for (int i = 1; i <= n; i++) {
result = max(result, ans[i]);
}
cout << result << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 5 * 1e3;
const int MOD = 998244353;
int a, b, c;
int pab, pbc, pca;
int comb[1 + NMAX][1 + NMAX];
int fact[1 + NMAX];
int res = 1;
void compute_comb() {
comb[0][0] = 1;
for (int i = 1; i <= NMAX; i++) {
comb[i][0] = 1;
for (int j = 1; j <= i; j++)
comb[i][j] = (comb[i - 1][j - 1] + comb[i - 1][j]) % MOD;
}
}
void compute_fact() {
fact[0] = fact[1] = 1;
for (int i = 2; i <= NMAX; i++) fact[i] = (1LL * fact[i - 1] * i) % MOD;
}
inline int get_val(int n, int m, int k) {
int sol = 1;
sol = (1LL * sol * comb[n][k]) % MOD;
sol = (1LL * sol * comb[m][k]) % MOD;
sol = (1LL * sol * fact[k]) % MOD;
return sol;
}
int solve(int n, int m) {
long long sol = 0;
for (int i = 0; i <= min(n, m); i++) sol = (sol + get_val(n, m, i)) % MOD;
return sol;
}
int main() {
ios::sync_with_stdio(false);
compute_comb();
compute_fact();
cin >> a >> b >> c;
pab = solve(a, b);
pbc = solve(b, c);
pca = solve(c, a);
res = (1LL * res * pab) % MOD;
res = (1LL * res * pbc) % MOD;
res = (1LL * res * pca) % MOD;
cout << res << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n, temp;
cin >> n;
vector<long int> a, b;
long long int s1 = 0, s2 = 0;
for (long int i = 0; i < n; i++) {
cin >> temp;
a.push_back(temp);
}
for (long int i = 0; i < n; i++) {
cin >> temp;
b.push_back(temp);
}
sort(a.rbegin(), a.rend());
sort(b.rbegin(), b.rend());
long int i = 0, j = 0;
while (i < n || j < n) {
if (i < n && j < n) {
if (a[i] > b[j]) {
s1 += a[i];
i++;
} else {
j++;
}
} else if (i == n)
j++;
else {
s1 += a[i];
i++;
}
if (i < n && j < n) {
if (b[j] > a[i]) {
s2 += b[j];
j++;
} else {
i++;
}
} else if (j == n)
i++;
else {
s2 += b[j];
j++;
}
}
cout << s1 - s2;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e3 + 10;
set<int> v, nv, tv;
int a[M];
int main() {
int k, n;
scanf("%d%d", &k, &n);
for (int i = 0; i < k; i++) {
scanf("%d", &a[i]);
if (i) a[i] += a[i - 1];
}
for (int i = 0; i < n; i++) {
int b;
scanf("%d", &b);
for (int j = 0; j < k; j++) {
if (!i)
nv.insert(b - a[j]);
else
v.insert(b - a[j]);
}
if (!i) continue;
for (int x : nv) {
if (v.count(x)) {
tv.insert(x);
}
}
nv = tv;
v.clear();
tv.clear();
}
printf("%d\n", nv.size());
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using vi = vector<int>;
using vll = vector<ll>;
template <typename T>
istream& operator>>(istream& is, vector<T>& v) {
for (auto& i : v) is >> i;
return is;
}
template <typename T>
ostream& operator<<(ostream& os, vector<T> v) {
for (auto& i : v) os << i << ' ';
return os;
}
const ll N = 1e5 + 5;
const ll mod = 1e9 + 7;
vector<ll> fact(ll n) {
vector<ll> x;
ll i;
for (i = 1; i <= n; i++) {
if (n % i == 0) x.push_back(i);
}
return x;
}
ll factorial(ll x) {
ll i = 1;
while (x) {
i *= x;
i = i % mod;
x--;
}
return i;
}
ll power(ll x, ll y, ll p = mod) {
ll res = 1;
x %= p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
ll nCr(ll n, ll r, ll m = mod) {
if (r > n) return 0;
ll a = 1, b = 1;
while (r) {
a = (a * n) % m;
--n;
b = (b * r) % m;
--r;
}
return (a * power(b, m - 2, m)) % m;
}
bool bysec(pair<ll, ll>& a, pair<ll, ll>& b) { return a.second < b.second; }
void solve() {
ll x;
cin >> x;
string s;
cin >> s;
long long ans = 0, n = s.size();
ans = s.size();
for (int i = 0; i < x; i++) {
ll z = (s[i] - '0');
if (s.size() < x) {
for (int j = 1; j < z; j++)
if (s.size() < x) {
for (int l = i + 1; l < ans; l++)
if (s.size() < x) s += s[l];
}
}
int le = (ans - i - 1 + mod) % mod;
ans = ((i + 1) + 1LL * le * z) % mod;
}
cout << ans % mod;
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
ll n = 1;
cin >> n;
while (n--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
char st[maxn], c[maxn];
char b[maxn][maxn];
int n;
bool flag[maxn];
bool cmp(int a, int b, char s1[], char s2[], int n) {
for (int i = 0; i < n; i++) {
char c1 = s1[a + i];
if (c1 >= 'A' && c1 <= 'Z') c1 = c1 - 'A' + 'a';
char c2 = s2[b + i];
if (c2 >= 'A' && c2 <= 'Z') c2 = c2 - 'A' + 'a';
if (c1 != c2) return 0;
}
return 1;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%s", b[i]);
scanf("%s", st);
scanf("%s", c);
for (int i = 0; st[i]; i++) {
bool ok = 0;
for (int k = 0; !ok && k < n; k++) {
int len = strlen(b[k]);
for (int j = 0; !ok && j <= i; j++)
if (j + len - 1 >= i) ok |= cmp(j, 0, st, b[k], len);
}
flag[i] = ok;
}
if (c[0] >= 'a' && c[0] <= 'z') c[0] = c[0] - 'a' + 'A';
for (int i = 0; st[i]; i++)
if (flag[i]) {
if (st[i] >= 'A' && st[i] <= 'Z') {
if (st[i] == c[0]) {
if (st[i] == 'A')
st[i] = 'B';
else
st[i] = 'A';
} else
st[i] = c[0];
} else {
if (st[i] == c[0] - 'A' + 'a') {
if (st[i] == 'a')
st[i] = 'b';
else
st[i] = 'a';
} else
st[i] = c[0] - 'A' + 'a';
}
}
printf("%s", st);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> arr(n, 0);
for (auto &itr : arr) {
cin >> itr;
}
vector<long long> temp;
for (long long i = 0; i < n - 1; i++) {
long long x;
x = arr[i] * arr[i + 1];
temp.push_back(x);
}
sort(temp.begin(), temp.end());
cout << temp[n - 2] << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int MAXN = 1e5 + 10;
struct edge {
int t, next;
long long w;
} edges[MAXN << 5];
int head[MAXN << 5];
int top;
void add(int f, int t, long long w = 0) {
edges[++top].next = head[f];
edges[top].t = t;
edges[top].w = w;
head[f] = top;
}
int n, m;
int cnt;
int in[MAXN << 5], out[MAXN << 5];
void build(int k, int l, int r) {
if (l == r) {
in[k] = out[k] = l;
return;
}
int mid = l + r >> 1;
in[k] = ++cnt;
out[k] = ++cnt;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
add(in[k], in[k << 1]);
add(in[k], in[k << 1 | 1]);
add(out[k << 1], out[k]);
add(out[k << 1 | 1], out[k]);
}
void query(int k, int l, int r, int p, int x, int y, long long w, int op) {
if (x <= l && y >= r) {
if (op == 2) add(p, in[k], w);
if (op == 3) add(out[k], p, w);
return;
}
int mid = l + r >> 1;
if (x <= mid) query(k << 1, l, mid, p, x, y, w, op);
if (y > mid) query(k << 1 | 1, mid + 1, r, p, x, y, w, op);
}
long long dis[MAXN << 4];
void dijkstra(int s) {
priority_queue<pair<long long, int>, vector<pair<long long, int> >,
greater<pair<long long, int> > >
q;
q.push(make_pair(0, s));
memset(dis, 0x3f, sizeof(dis));
dis[s] = 0;
while (!q.empty()) {
int top = q.top().second;
q.pop();
for (int i = head[top]; i; i = edges[i].next) {
int t = edges[i].t;
if (dis[t] > dis[top] + edges[i].w) {
dis[t] = dis[top] + edges[i].w;
q.push(make_pair(dis[t], t));
}
}
}
}
int main() {
int s;
cin >> n >> m >> s;
cnt = n;
int op, l, r, f, w;
build(1, 1, n);
for (int i = 1; i <= m; i++) {
cin >> op;
if (op == 1) {
cin >> f >> r >> w;
add(f, r, w);
} else {
cin >> f >> l >> r >> w;
query(1, 1, n, f, l, r, w, op);
}
}
dijkstra(s);
for (int i = 1; i <= n; i++) cout << (dis[i] == INF ? -1 : dis[i]) << ' ';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int n, k, dp[N][N][N];
string s, t;
int solve(int ind, int rem, int prev) {
if (ind == n) return 0;
int &ret = dp[ind][rem][prev];
if (~ret) return ret;
int c1 = 0, c2 = 0, c3 = 0;
c1 = solve(ind + 1, rem, prev + (s[ind] == t[0]));
if (s[ind] == t[1]) c1 += prev;
if (rem > 0) {
c2 = solve(ind + 1, rem - 1, prev + 1);
if (t[0] == t[1]) c2 += prev;
c3 = solve(ind + 1, rem - 1, prev);
c3 += prev;
}
ret = max({c1, c2, c3});
return ret;
}
int main() {
memset(dp, -1, sizeof dp);
cin >> n >> k >> s >> t;
cout << solve(0, k, 0);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> t;
if (t < 10) {
for (int i = 0; i < n; i++) cout << t;
} else {
if (n == 1)
cout << -1;
else {
cout << 1;
for (int i = 0; i < n - 1; i++) cout << 0;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
map<pair<int, int>, int> mymap;
int n;
string s[100];
int ok(int i, int j, int c) {
if (i < 0) return false;
if (j < 0) return false;
if (i >= n) return false;
if (j >= n) return false;
return s[i][j] == c;
}
int get(int i, int mask) {
if (mymap.find(make_pair(i, mask)) != mymap.end())
return mymap[make_pair(i, mask)];
if (i == 2 * n - 2) return mymap[make_pair(i, mask)] = 0;
int t = i % 2;
int ret = (t ? -1000 : 1000);
for (char c = 'a'; c <= 'z'; ++c) {
int nm = 0;
for (int j = 0; j < n; ++j) {
int k = i - j;
if (k >= n) continue;
if (k < 0) continue;
if ((1 << j) & mask) {
if (ok(j + 1, k, c)) nm |= 1 << (j + 1);
if (ok(j, k + 1, c)) nm |= 1 << j;
}
}
if (nm) {
int now = get(i + 1, nm) + (c == 'a') - (c == 'b');
if (t)
ret = max(ret, now);
else
ret = min(ret, now);
}
}
return mymap[make_pair(i, mask)] = ret;
}
int main() {
while (cin >> n) {
mymap.clear();
for (int i = 0; i < n; ++i) cin >> s[i];
int ret = get(0, 1) + (s[0][0] == 'a') - (s[0][0] == 'b');
if (ret > 0)
cout << "FIRST" << endl;
else if (ret < 0)
cout << "SECOND" << endl;
else
cout << "DRAW" << endl;
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
map<int, int> parent;
void make_set(int n) {
for (int i = 0; i < n; i++) {
parent[i] = i;
}
}
int getParent(int a) {
if (a == parent[a])
return a;
else
return parent[a] = getParent(parent[a]);
}
void join(int a, int b) {
a = getParent(a);
b = getParent(b);
if (a != b) {
parent[b] = a;
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
vector<int> ans(k, -1e9);
ans[0] = 0;
vector<int> v(m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> v[j];
}
vector<vector<int>> v1(m, vector<int>(k, -1e9));
v1[0][0] = 0;
for (int j = 0; j < m; ++j) {
for (int a = m / 2; a; --a) {
for (int b = 0; b < k; ++b) {
v1[a][b] = max(v1[a][b], v1[a - 1][((b - v[j]) % k + k) % k] + v[j]);
}
}
}
for (int a = 0; a < k; ++a) {
for (int b = 1; b <= m / 2; ++b) {
v1[0][a] = max(v1[0][a], v1[b][a]);
}
}
vector<int> dp(k, -1e9);
for (int a = 0; a < k; ++a) {
for (int b = 0; b < k; ++b) {
dp[(a + b) % k] = max(dp[(a + b) % k], ans[a] + v1[0][b]);
}
}
for (int a = 0; a < k; ++a) {
ans[a] = max(ans[a], dp[a]);
}
}
cout << ans[0] << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 10;
typedef int ar[MAXN];
namespace HABIT {
template <typename T>
inline T Max(T a) {
return a;
}
template <typename T, typename... Args>
inline T Max(T a, Args... args) {
T b = Max(args...);
return (a > b) ? a : b;
}
template <typename T>
inline T Min(T a) {
return a;
}
template <typename T, typename... Args>
inline T Min(T a, Args... args) {
T b = Min(args...);
return (a < b) ? a : b;
}
inline char gc() { return getchar(); }
inline int read() {
register int ans = 0;
register char c = gc();
register bool neg = 0;
while (c < 48 || c > 57) neg ^= !(c ^ '-'), c = gc();
while (c >= 48 && c <= 57) ans = (ans << 3) + (ans << 1) + (c ^ 48), c = gc();
return neg ? -ans : ans;
}
char Output_Ans[1 << 20 | 1], *Output_Cur = Output_Ans;
inline void output() {
Output_Cur -= fwrite(Output_Ans, 1, Output_Cur - Output_Ans, stdout);
}
inline void print(char c) {
if (Output_Cur - Output_Ans + 1 >> 20) output();
*(Output_Cur++) = c;
}
inline void print(char *s) {
while (*s) print(*(s++));
}
inline void print(unsigned long long int x) {
if (!x) {
print('0');
return;
}
char buf[30] = {0}, *p = buf + 28;
while (x) *(p--) = x % 10 + 48, x /= 10;
print(p + 1);
}
inline void print(unsigned int x) { print((unsigned long long int)x); }
inline void print(long long int x) {
if (x < 0) print('-'), x = -x;
print((unsigned long long int)x);
}
inline void print(int x) {
if (x < 0) print('-'), x = -x;
print((unsigned long long int)x);
}
} // namespace HABIT
using namespace HABIT;
ar ar_d_Num1, ar_d_Num2;
inline bool alw() {
int d_N = read();
for (register int i = 1, I = d_N; i <= I; i++) {
int d_Tmp = read();
ar_d_Num1[i] = d_Tmp - i + 1;
ar_d_Num2[i] = d_Tmp - d_N + i;
}
int d_Pos1 = 1, d_Pos2 = d_N;
while (ar_d_Num1[d_Pos1] >= 0 && d_Pos1 <= d_N) d_Pos1++;
while (ar_d_Num2[d_Pos2] >= 0 && d_Pos2 >= 1) d_Pos2--;
if (d_Pos1 > d_N || d_Pos2 < 1) return -1;
return d_Pos1 - d_Pos2 >= 2;
}
int main() {
for (register int i = 1, I = read(); i <= I; i++)
if (alw())
print("Yes\n");
else
print("No\n");
output();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
ostream cnull(NULL);
template <class TH>
void _dbg(const char *sdbg, TH h) {
cnull << sdbg << "=" << h << "\n";
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cnull << *sdbg++;
cnull << "=" << h << ",";
_dbg(sdbg + 1, a...);
}
const int MX = 2e5 + 7;
vector<int> G[MX];
int depth[MX];
int pomeg[MX];
int gut[MX];
int ans = 0;
void predfs(int u, int p) {
for (int v : G[u]) {
if (v != p) {
depth[v] = depth[u] + 1;
predfs(v, u);
}
}
if (pomeg[u] > 0) {
++ans;
gut[p] = 1;
} else if (!gut[u] && depth[u] > 2)
++pomeg[p];
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
for (int i = (0); i <= ((int)(n - 1) - 1); ++i) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
G[b].push_back(a);
}
predfs(1, 0);
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
long long int tc;
cin >> tc;
while (tc--) {
long long int n;
cin >> n;
while (n--) cout << 1 << ' ';
cout << '\n';
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
double ansv = 0, ansc = 0;
int a[10];
void dfs(int t) {
if (t == 0) {
for (int i = (1); i <= (n - 1); i++)
for (int j = (i + 1); j <= (n); j++)
if (a[i] > a[j]) ansv++;
ansc++;
return;
}
for (int i = (1); i <= (n); i++)
for (int j = (i); j <= (n); j++) {
reverse(a + i, a + j + 1);
dfs(t - 1);
reverse(a + i, a + j + 1);
}
}
void lemon() {
int m;
scanf("%d%d", &n, &m);
for (int i = (1); i <= (n); i++) scanf("%d", &a[i]);
dfs(m);
printf("%.15lf\n", ansv / ansc);
}
int main() {
ios::sync_with_stdio(true);
lemon();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(5e5) + 5;
const int inf = (int)1e9 + 7;
int a, b, c;
int main() {
scanf("%d %d %d", &a, &b, &c);
for (int a1 = 0; a1 <= a; ++a1) {
int a3 = a - a1;
int a2 = c - a3;
if (min({a1, a2, a3}) >= 0 && a1 + a3 == a && a1 + a2 == b &&
a2 + a3 == c) {
printf("%d %d %d\n", a1, a2, a3);
return 0;
}
}
printf("Impossible");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b, d, st, j, l, k, ans[100005], st1, sum, count[200000] = {0}, c,
xo, tot, p, q;
cin >> a >> b;
st = b;
j = 0;
k = 0;
d = 0;
while (st > 0) {
c = st % 2;
if (c == 1) {
ans[k] = pow(2, j);
count[ans[k]]++;
k++;
}
j++;
st = st / 2;
}
tot = k;
if (k >= a) {
j = 0;
k = 0;
while (j < a - 1) {
ans[k] = ans[k];
k++;
j++;
}
p = 0;
q = k;
j = k;
while (j < tot) {
p += ans[k];
k++;
j++;
}
ans[q] = p;
k = a;
}
st1 = a - k;
l = 1;
sum = 0;
xo = 0;
if (st1 == 1) {
ans[k] = 0;
k++;
} else {
while (st1 > 0) {
if (st1 == 2) {
ans[k] = pow(2, 19) + xo;
k++;
if (xo == 0) {
if (k <= 1) {
cout << "NO" << endl;
d = 1;
break;
}
ans[k - 2] += pow(2, 19);
ans[k] = 0;
k++;
} else {
ans[k] = pow(2, 19);
k++;
}
st1 -= 2;
} else if (count[l] == 0 && st1 > 0) {
xo = xo ^ l;
ans[k] = l;
k++;
l++;
st1--;
} else {
l++;
}
}
}
if (d == 0) {
cout << "YES" << endl;
for (j = 0; j < k; j++) {
if (j == k - 1)
cout << ans[j] << endl;
else
cout << ans[j] << " ";
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 1e6 + 1;
int a[mxn + mxn];
int main() {
int n, x, ret = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &x), a[x] = x;
for (int i = 1; i < 2 * mxn; i++) a[i] = max(a[i], a[i - 1]);
for (int i = 2; i < mxn; i++)
if (a[i] == i) {
for (int j = i + i; j < 2 * mxn; j += i) ret = max(ret, a[j - 1] % i);
}
printf("%d\n", ret);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long m = 998244353;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k, temp = 0, ans = 1;
cin >> n >> k;
vector<long long> v;
for (int x = 0; x < n; x++) {
int a;
cin >> a;
if (a >= n - k + 1) {
temp += a;
v.push_back(x);
}
}
for (int x = 0; x < v.size() - 1; x++) {
ans = ans * abs(v[x + 1] - v[x]);
ans = ans % m;
}
cout << temp << " " << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
int n, k;
int a;
int dp[6];
int ans;
int dpget(int num) {
if (num < 6) return dp[num];
if (num & 1) return 0;
return dpget(num / 2) == 1 ? 2 : 1;
}
int main() {
scanf("%d %d", &n, &k);
while (n--) {
scanf("%d", &a);
if (k & 1) {
dp[0] = dp[2] = dp[5] = 0;
dp[1] = dp[3] = 1;
dp[4] = 2;
if (a < 6)
ans ^= dp[a];
else
ans ^= a & 1 ? 0 : dpget(a);
} else {
dp[0] = dp[3] = 0;
dp[1] = dp[4] = 1;
dp[2] = 2;
if (a < 5)
ans ^= dp[a];
else
ans ^= a & 1 ? 0 : 1;
}
}
if (ans)
puts("Kevin");
else
puts("Nicky");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e6 + 120;
const long long maxx = 1e16;
const long long mod = 1e9 + 7;
const long long mod1 = 123456789;
long long a[maxn];
long long b[maxn];
long long f[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
if (fopen("SAMEBIT.INP", "r")) {
freopen("SAMEBIT.INP", "r", stdin);
freopen("SAMEBIT.OUT", "w", stdout);
}
f[1] = 0;
a[1] = 0;
b[1] = 1;
f[2] = 0;
a[2] = 1;
b[2] = 1;
for (int i = 3; i < maxn; i++) {
f[i] = (f[i - 3] + a[i - 1]) % mod;
long long p = b[i - 1];
long long h = (p + 2 * a[i - 1]) % mod;
a[i] = p;
b[i] = h;
}
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
cout << (f[n] * 4) % mod << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int a[n * 2];
for (int i = 0; i < n * 2; i++) cin >> a[i];
int b[n];
for (int i = 0; i < n; i++) b[i] = 0;
int k = 0, m = 0;
for (int i = 0; i < n * 2; i++) {
if (b[a[i] - 1] == 0)
k++;
else {
m = max(k, m);
k--;
}
b[a[i] - 1]++;
}
m = max(k, m);
cout << m;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 10;
const int mod = 1e9 + 7;
set<int> st;
vector<int> vt;
long long n, ans, cnt;
long long a[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t-- > 0) {
cin >> n;
string s, a, b;
cin >> s;
int g = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '2') {
if (g == 0) {
a.push_back('1');
b.push_back('1');
} else {
a.push_back('0');
b.push_back('2');
}
} else if (s[i] == '1') {
if (g == 0) {
a.push_back('1');
b.push_back('0');
g = 1;
} else {
b.push_back('1');
a.push_back('0');
}
} else if (s[i] == '0') {
a.push_back('0');
b.push_back('0');
}
}
cout << a << "\n" << b << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 10;
const int SECV = 31;
const int LOG = 19;
struct Suffix {
int a, b, idx;
bool operator<(const Suffix &aux) const {
if (a == aux.a) {
if (b == aux.b) return idx < aux.idx;
return b < aux.b;
}
return a < aux.a;
}
} v[MAXN];
int n, m, k, p[LOG][MAXN * 2], d[SECV][MAXN], ord[MAXN];
char s[MAXN], t[MAXN];
inline int longestCommonPrefix(int x, int y) {
int ans = 0;
for (int step = LOG - 1; step >= 0; step--)
if ((1 << step) <= m && p[step][x] == p[step][y])
ans += (1 << step), x += (1 << step), y += (1 << step);
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> (s + 1) >> m >> t >> k;
s[n + 1] = 'z' + 1;
strcpy(s + n + 2, t);
for (int i = 1; i <= n + m + 1; i++) p[0][i] = s[i];
for (int log = 1; (1 << log) <= n + m + 1; log++) {
for (int i = 1; i <= n + m + 1; i++) {
v[i].a = p[log - 1][i];
v[i].b = p[log - 1][i + (1 << (log - 1))];
v[i].idx = i;
}
sort(v, v + n + m + 1);
p[log][v[1].idx] = 1;
for (int i = 2; i <= 1 + n + m; i++)
if (v[i].a == v[i - 1].a && v[i].b == v[i - 1].b)
p[log][v[i].idx] = p[log][v[i - 1].idx];
else
p[log][v[i].idx] = p[log][v[i - 1].idx] + 1;
}
for (int i = 1; i <= n + m + 1; i++) ord[v[i].idx] = i;
int lcp, f = 0;
for (int j = 0; j <= k; j++) {
for (int i = 0; i <= n; i++) {
d[j][i + 1] = max(d[j][i + 1], d[j][i]);
lcp = longestCommonPrefix(i + 1, n + 1 + d[j][i] + 1);
if (d[j][i] == m) f = 1;
if (!lcp) continue;
d[j + 1][i + lcp] = max(d[j + 1][i + lcp], d[j][i] + lcp);
}
}
if (f)
cout << "YES";
else
cout << "NO";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
char dayType[20];
int sellDay[2001];
int dayWin[5000];
const int base10 = 1000 * 1000 * 1000;
void mul(vector<long long>& a, long long b) {
long long carry = 0;
for (size_t i = 0; i < a.size() || carry; ++i) {
if (i == a.size()) a.push_back(0);
long long cur = carry + a[i] * b;
a[i] = cur % base10;
carry = cur / base10;
}
while (a.size() > 1 && a.back() == 0) a.pop_back();
};
int main() {
int dayCount;
scanf("%d", &dayCount);
memset(sellDay, -1, sizeof(sellDay));
memset(dayWin, -1, sizeof(dayWin));
for (int i = 0; i < dayCount; i++) {
scanf("%s", &dayType);
int x;
scanf("%d", &x);
if (dayType[0] == 's') {
assert(x <= 2000);
sellDay[x] = i;
} else {
dayWin[i] = x;
}
}
vector<long long> res(1, 0);
for (int i = 2000; i >= 0; i--) {
bool canHave = false;
mul(res, 2);
if (sellDay[i] >= 0) {
for (int day = sellDay[i]; day >= 0; day--) {
if (dayWin[day] == -2) break;
if (dayWin[day] == i) {
canHave = true;
break;
}
}
if (canHave) {
for (int day = sellDay[i]; day >= 0; day--) {
if (dayWin[day] == i) {
dayWin[day] = -2;
break;
}
dayWin[day] = -2;
}
}
}
if (canHave) {
res[0]++;
}
}
printf("%d", res.empty() ? 0 : res.back());
for (int i = (int)res.size() - 2; i >= 0; --i) printf("%09d", (int)res[i]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d\n", &n);
if (n % 4 != 0) {
cout << "===";
} else {
int max = n / 4, q_count = 0, count = 0;
string g;
getline(cin, g);
unordered_map<char, int> map;
map['A'] = 0;
map['C'] = 0;
map['T'] = 0;
map['G'] = 0;
for (int i = 0; i < n; i++) {
if (g[i] == '?')
q_count++;
else
map[g[i]]++;
}
for (auto it = map.begin(); it != map.end(); it++) {
if (max - it->second < 0) {
cout << "===";
return 0;
} else {
count += max - it->second;
}
}
if (count != q_count) {
cout << "===";
} else {
auto it = map.begin();
for (int i = 0; i < n; i++) {
if (g[i] == '?') {
while (1) {
if (max - it->second == 0) {
it++;
continue;
} else {
cout << it->first;
map[it->first]++;
break;
}
}
} else {
cout << g[i];
}
}
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int modpow(long long int a, long long int b) {
if (b == 0) {
return 1;
}
long long int ans = modpow(a, b / 2);
ans = (ans * ans) % 1000000007;
if (b % 2) {
ans = (ans * a) % 1000000007;
}
return ans;
}
long long int en[10005][50];
long long int dn[10005][50];
long long int inver[1000];
pair<long long int, long long int> ad(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return {(a.first * b.second + b.first * a.second) % 1000000007,
(a.second * b.second) % 1000000007};
}
pair<long long int, long long int> mult(pair<long long int, long long int> a,
pair<long long int, long long int> b) {
return {(a.first * b.first) % 1000000007, (a.second * b.second) % 1000000007};
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int n, k;
cin >> n >> k;
map<long long int, int> div;
for (int i = 1; i <= 1000; i++) {
inver[i] = modpow(i, 1000000007 - 2);
}
for (long long int i = 2; i * i <= n; i++) {
while (n % i == 0) {
n /= i;
div[i]++;
}
}
if (n > 1) {
div[n]++;
}
pair<long long int, long long int> ans = {1, 1};
for (auto entr : div) {
long long int pr = entr.first % 1000000007;
long long int cn = entr.second;
vector<pair<long long int, long long int> > prob(cn + 2, {0, 1});
prob[cn] = {1, 1};
for (int i = 0; i < k; i++) {
vector<pair<long long int, long long int> > newprob(cn + 2, {0, 1});
newprob[0] = prob[0];
for (int i = 1; i <= cn; i++) {
prob[i].second = (prob[i].second * (i + 1)) % 1000000007;
for (int j = 0; j <= i; j++) {
newprob[j] = ad(newprob[j], prob[i]);
}
}
swap(newprob, prob);
}
pair<long long int, long long int> expec = {0, 1};
pair<long long int, long long int> currval = {1, 1};
for (int i = 0; i <= cn; i++) {
expec = ad(expec, mult(currval, prob[i]));
currval.first = (currval.first * pr) % 1000000007;
}
ans = mult(ans, expec);
}
cout << (ans.first * modpow(ans.second, 1000000007 - 2)) % 1000000007;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e18;
const int MAXN = 55;
long long a[MAXN], b[MAXN];
bool cmp(long long a, long long b) { return a > b; }
int main() {
int n, m;
while (scanf("%d%d", &n, &m) != EOF) {
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
}
for (int i = 1; i <= m; i++) {
scanf("%I64d", &b[i]);
}
long long ma = -INF;
int p = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (a[i] * b[j] > ma) {
ma = a[i] * b[j];
p = i;
}
}
}
ma = -INF;
for (int i = 1; i <= n; i++) {
if (i == p) continue;
for (int j = 1; j <= m; j++) {
if (a[i] * b[j] > ma) {
ma = a[i] * b[j];
}
}
}
printf("%I64d\n", ma);
}
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.