solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
char s[120];
gets(s);
int flag = 0;
int cnt = 0;
for (int i = 0; i < strlen(s) - 1; i++) {
if (s[i] == 'V' && s[i + 1] == 'K') cnt++;
if (s[i] == 'V' && s[i + 1] == 'V' &&
(i == strlen(s) - 2 || s[i + 2] == 'V'))
flag = 1;
if (s[i] == 'K' && s[i + 1] == 'K' && (i == 0 || s[i - 1] == 'K')) flag = 1;
}
if (flag) cnt++;
cout << cnt << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const long long inf = 0x3f3f3f3f;
using namespace std;
long long n, m, k;
bool check(long long x) {
long long sum = 0;
if (k > x)
sum += (1 + x) * x / 2 + k - x;
else
sum += (2 * x - k + 1) * k / 2;
long long tmp = n - k + 1;
if (tmp > x)
sum += (1 + x) * x / 2 + tmp - x;
else
sum += (2 * x - tmp + 1) * tmp / 2;
sum -= x;
if (m >= sum)
return true;
else
return false;
}
int main() {
cin >> n >> m >> k;
long long l = 1, r = m;
while (l < r) {
if (l + 1 == r) break;
long long mid = (l + r) / 2;
if (check(mid))
l = mid;
else
r = mid;
}
if (check(r))
cout << r << endl;
else
cout << l << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 + 10;
string inp[maxn];
int n;
string tostr(int x) {
string xx;
while (x > 0) {
xx.push_back(x % 10 + '0');
x /= 10;
}
reverse(xx.begin(), xx.end());
return xx;
}
int diff(string x, string y) {
int cc = 0;
for (int i = 0; i < x.size(); i++)
if (y[i] != x[i]) cc++;
return cc;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> inp[i];
int last = 1000;
bool done = false;
for (int i = 0; i < n; i++) {
done = false;
for (; last <= 2011; last++) {
if (diff(tostr(last), inp[i]) <= 1) {
inp[i] = tostr(last);
done = true;
break;
}
}
if (!done) break;
}
if (done)
for (int i = 0; i < n; i++) cout << inp[i] << endl;
else
cout << "No solution" << endl;
}
| 4 |
#include <cstdio>
using namespace std;
const int N = 505;
char s[N][N];
void solve() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
if (i % 3 == 0) {
for (int j = 0; j < m; ++j) {
s[i][j] = 'X';
}
}
}
for (int i = 2; i < n; i += 3) {
if (s[i - 1][1] == 'X' || s[i][1] == 'X') {
s[i - 1][1] = s[i][1] = 'X';
}
else {
s[i - 1][0] = s[i][0] = 'X';
}
}
if (n % 3 == 0) {
// printf("3");
for (int j = 0; j < m; ++j) {
if (s[n - 1][j] == 'X') {
// printf("%d\n", j);
s[n - 2][j] = 'X';
}
}
}
for (int i = 0; i < n; ++i) {
printf("%s\n", s[i]);
}
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
solve();
}
} | 7 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
register int n;
cin >> n;
for (register int i = (1); i <= (n); ++i) cin >> a[i];
sort(a + 1, a + n + 1);
register int m = n / 2;
long long s1 = 0, s2 = 0;
for (register int i = (1); i <= (m); ++i) s1 += a[i];
for (register int i = (m + 1); i <= (n); ++i) s2 += a[i];
cout << s1 * s1 + s2 * s2;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 7 + 200000;
int n, m, k, num;
vector<int> g[N];
int j, ans;
int main() {
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
scanf("%d", &num);
g[num].push_back(i);
}
for (int now = 1; now <= m; now++) {
j = 0;
for (int i = 0; i < g[now].size(); i++) {
for (; j < g[now].size(); j++) {
if (g[now][j] - g[now][i] + 1 - (j - i + 1) > k) {
break;
}
ans = max(ans, j - i + 1);
}
}
}
cout << ans;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, x[N], ans[N];
int a[N], b[N], c[N];
vector<int> v[N];
int main() {
cin >> n;
for (int i = 0; i < n - 2; i++) {
cin >> a[i] >> b[i] >> c[i];
v[a[i]].push_back(i);
v[b[i]].push_back(i);
v[c[i]].push_back(i);
}
int rem = 0;
for (int i = 1; i <= n; ++i) {
if (v[i].size() == 1) {
rem = i;
break;
}
}
for (int i = 1; i <= n; i++) sort(v[i].begin(), v[i].end());
for (int i = 0; i < n - 2; ++i) {
int now = v[rem][0];
ans[i] = rem;
v[rem].erase(v[rem].begin());
int x, y;
if (rem == a[now])
x = b[now], y = c[now];
else if (rem == b[now])
x = a[now], y = c[now];
else if (rem == c[now])
x = a[now], y = b[now];
v[x].erase(lower_bound(v[x].begin(), v[x].end(), now));
v[y].erase(lower_bound(v[y].begin(), v[y].end(), now));
if (ans[i + 1] == 0) {
if (v[x].size() == 1)
ans[i + 1] = x, ans[i + 2] = y;
else
ans[i + 1] = y, ans[i + 2] = x;
} else
ans[i + 2] = x + y - ans[i + 1];
rem = ans[i + 1];
}
for (int i = 0; i < n; i++) cout << ans[i] << ' ';
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string s1, s2, v, a;
char ch[110];
int cnt = 0;
vector<char> V1, V2;
int dp[102][102][102];
int pi[102];
int failureFunction(string pat) {
int i, shift = 0, len = pat.size();
for (i = 2; i < len; ++i) {
while (shift > 0 && pat[shift] != pat[i - 1]) shift = pi[shift];
if (pat[shift] == pat[i - 1]) shift++;
pi[i] = shift;
}
return i - 1;
}
int solve(int i, int j, int k) {
if (i == s1.size() || j == s2.size()) return 0;
if (dp[i][j][k] != -1) return dp[i][j][k];
int ret = 0;
if (s1[i] == s2[j]) {
if (k + 1 == v.size() && s1[i] == v[k])
;
else {
int shift = k;
while (shift > 0 && v[shift] != s1[i]) shift = pi[shift];
ret =
max(ret,
solve(i + 1, j + 1, (s1[i] == v[shift]) ? shift + 1 : shift) + 1);
}
}
ret = max(ret, solve(i + 1, j, k));
ret = max(ret, solve(i, j + 1, k));
return dp[i][j][k] = ret;
}
void print(int i, int j, int k) {
if (i == s1.size() || j == s2.size()) return;
int ret1 = 0, ret2 = 0, ret3 = 0;
if (s1[i] == s2[j]) {
if (k + 1 == v.size() && s1[i] == v[k])
;
else {
int shift = k;
while (shift > 0 && v[shift] != s1[i]) shift = pi[shift];
ret1 = solve(i + 1, j + 1, (s1[i] == v[shift]) ? shift + 1 : shift) + 1;
}
}
ret2 = solve(i + 1, j, k);
ret3 = solve(i, j + 1, k);
if (ret1 > ret2 && ret1 > ret3) {
if (k + 1 == v.size() && s1[i] == v[k])
;
else {
cout << s1[i];
int shift = k;
while (shift > 0 && v[shift] != s1[i]) shift = pi[shift];
print(i + 1, j + 1, (s1[i] == v[shift]) ? shift + 1 : shift);
return;
}
}
if (ret2 > ret3) {
print(i + 1, j, k);
return;
}
print(i, j + 1, k);
}
int main() {
cin >> s1 >> s2 >> v;
failureFunction(v);
memset(dp, -1, sizeof dp);
if (solve(0, 0, 0))
print(0, 0, 0);
else
printf("0");
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3010;
int n, m, a[MAXN];
double f[MAXN][2];
void lucky() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
}
int main() {
lucky();
for (int i = 1; i < n; i++) {
for (int j = i + 1; j <= n; j++)
if (a[i] > a[j]) m++;
}
printf("%d", (m & 1) ? 2 * m - 1 : 2 * m);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int maxn = 200010;
using namespace std;
int col[maxn], n, m, rely[maxn];
bool flag[maxn], bo[maxn];
vector<pair<int, int> > a[maxn], f[maxn];
bool dfs(int x) {
flag[x] = 1;
for (int i = 0; i < f[x].size(); i++) {
int nowv = f[x][i].first, nowx = f[x][i].second;
if (bo[nowx]) continue;
bo[nowx] = 1;
if (flag[nowv]) {
rely[x] = nowx;
return 1;
}
if (dfs(nowv)) {
rely[x] = nowx;
return 1;
}
rely[nowv] = nowx;
}
return 0;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, cnt, x; i <= n; i++) {
scanf("%d", &cnt);
while (cnt--)
scanf("%d", &x), a[abs(x)].push_back(make_pair(i, x < 0 ? 0 : 1));
}
for (int i = 1; i <= m; i++) {
if (a[i].size() == 0) continue;
if (a[i].size() == 1) col[i] = a[i][0].second, flag[a[i][0].first] = 1;
if (a[i].size() == 2) {
if (a[i][0].second == a[i][1].second)
col[i] = a[i][0].second, flag[a[i][0].first] = flag[a[i][1].first] = 1;
else
f[a[i][0].first].push_back(make_pair(a[i][1].first, i)),
f[a[i][1].first].push_back(make_pair(a[i][0].first, i));
}
}
for (int i = 1; i <= n; i++)
if (!flag[i])
if (!dfs(i)) {
puts("NO");
exit(0);
}
puts("YES");
for (int i = 1; i <= n; i++)
if (rely[i]) {
for (int j = 0; j < a[rely[i]].size(); j++)
if (a[rely[i]][j].first == i) col[rely[i]] = a[rely[i]][j].second;
}
for (int i = 1; i <= m; i++) putchar('0' + col[i]);
puts("");
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int ri() {
int r;
cin >> r;
return r;
}
unsigned int rui() {
unsigned int r;
cin >> r;
return r;
}
long long rl() {
long long r;
cin >> r;
return r;
}
unsigned long long rul() {
unsigned long long r;
cin >> r;
return r;
}
double rd() {
double r;
cin >> r;
return r;
}
string rss() {
string r;
cin >> r;
return r;
}
string rs() {
string r;
getline(cin, r);
return r;
}
vector<string> rvs(int n) {
assert(n);
vector<string> r;
for (int i = 0; i < n; ++i) {
string s = rs();
while (s.empty()) s = rs();
r.push_back(s);
}
return r;
}
vector<int> rvi(int n) {
assert(n);
vector<int> r;
for (int i = 0; i < n; ++i) r.push_back(ri());
return r;
}
vector<unsigned int> rvui(int n) {
assert(n);
vector<unsigned int> r;
for (int i = 0; i < n; ++i) r.push_back(rui());
return r;
}
vector<long long> rvl(int n) {
assert(n);
vector<long long> r;
for (int i = 0; i < n; ++i) r.push_back(rl());
return r;
}
vector<unsigned long long> rvul(int n) {
assert(n);
vector<unsigned long long> r;
for (int i = 0; i < n; ++i) r.push_back(rul());
return r;
}
vector<double> rvd(int n) {
assert(n);
vector<double> r;
for (int i = 0; i < n; ++i) r.push_back(rd());
return r;
}
int main() {
vector<string> v = rvs(6);
sort((v).begin(), (v).end());
vector<vector<string> > res;
do {
if (v[0].size() + v[2].size() != v[1].size() + 1) continue;
if (v[3].size() + v[5].size() != v[4].size() + 1) continue;
if (v[0].front() != v[3].front() || v[1].front() != v[3].back() ||
v[0].back() != v[4].front())
continue;
if (v[4].back() != v[2].front() || v[2].back() != v[5].back() ||
v[5].front() != v[1].back())
continue;
if (v[1][v[0].size() - 1] != v[4][v[3].size() - 1]) continue;
vector<string> cur(v[4].size(), string(v[1].size(), '.'));
copy((v[0]).begin(), (v[0]).end(), cur[0].begin());
copy((v[1]).begin(), (v[1]).end(), cur[v[3].size() - 1].begin());
copy((v[2]).begin(), (v[2]).end(), cur.back().begin() + v[0].size() - 1);
for (size_t i = 0; i < v[3].size(); ++i) cur[i][0] = v[3][i];
for (size_t i = 0; i < v[4].size(); ++i) cur[i][v[0].size() - 1] = v[4][i];
for (size_t i = 0; i < v[5].size(); ++i)
cur[v[3].size() - 1 + i].back() = v[5][i];
res.push_back(cur);
} while (next_permutation((v).begin(), (v).end()));
sort((res).begin(), (res).end());
if (res.empty()) {
cout << "Impossible" << endl;
} else {
for (size_t i = 0; i < res[0].size(); ++i) cout << res[0][i] << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, len;
char s[105], nm[55][55], x[4] = {'0', '1', '2', '3'};
bool isE(char* X) {
int newi = a, newj = b;
for (int i = 0; i < len; i++) {
if (s[i] == X[0]) {
newi -= 1;
}
if (s[i] == X[1]) {
newi += 1;
}
if (s[i] == X[2]) {
newj -= 1;
}
if (s[i] == X[3]) {
newj += 1;
}
if (newi >= n || newi < 0 || newj >= m || newj < 0 ||
nm[newi][newj] == '#') {
return false;
}
if (nm[newi][newj] == 'E') {
return true;
}
if (i == len - 1 && nm[newi][newj] != 'E') {
return false;
}
}
}
int main() {
int count = 0;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> nm[i][j];
if (nm[i][j] == 'S') {
a = i;
b = j;
}
}
}
cin >> s;
len = strlen(s);
if (isE(x)) {
count += 1;
}
while (next_permutation(x, x + 4)) {
if (isE(x)) {
count += 1;
}
}
cout << count << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000;
const int prime = 9241;
long long c[40][40];
int main() {
c[0][0] = 1;
for (int i = 1; i < 40; i++) {
c[i][0] = 1;
for (int j = 1; j < 40; j++) c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
}
int n, m, t;
cin >> n >> m >> t;
long long ans = 0;
for (int i = 4; i <= n; i++) {
int j = t - i;
if (j < 1 || j > m) continue;
ans += c[n][i] * c[m][j];
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
long long x1, y1;
cin >> x1 >> y1;
long long x2, y2;
cin >> x2 >> y2;
long long n;
cin >> n;
long long ans = 0;
for (long long i = 0; i < n; i++) {
long long a, b, c;
cin >> a >> b >> c;
long long x = a * x1 + b * y1 + c;
long long y = a * x2 + b * y2 + c;
if ((x > 0 && y < 0) || (x < 0 && y > 0)) ans++;
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long pow2[100005], wool[100005];
long long mod = 1000000009;
int main() {
pow2[0] = 1;
for (int i = 1; i < 100001; i++) {
pow2[i] = (pow2[i - 1] * 2) % mod;
}
long long n, m;
cin >> n >> m;
if (n >= pow2[m]) {
cout << 0;
return 0;
}
long long ans = 1;
long long k = pow2[m] - 1;
for (int i = m; i > 0 && n > 0;) {
n--;
ans = (ans * k) % mod;
k--;
}
cout << ans << endl;
cin >> ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1 * 1000 + 10;
int ans[MAXN][MAXN];
int main() {
ios::sync_with_stdio(false);
int n, d, k;
cin >> n >> k >> d;
long long tmp = 1;
bool check = false;
for (int i = 0; i < d; i++) {
tmp *= k;
if (tmp >= n) {
check = true;
break;
}
}
if (!check) {
cout << -1 << endl;
return 0;
}
for (int i = 1; i < n; i++) {
for (int j = 0; j < d; j++) ans[i][j] = ans[i - 1][j];
for (int j = d - 1; j >= 0; j--) {
ans[i][j] = (ans[i][j] + 1) % k;
if (ans[i][j]) break;
}
}
for (int i = 0; i < d; i++, cout << endl)
for (int j = 0; j < n; j++) cout << ans[j][i] + 1 << ' ';
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int inf = 0x3f3f3f3f;
using namespace std;
const int maxn = 3e5 + 10;
int a[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int ans = inf;
for (int i = 1; i <= n; i++) {
if (i > 1) ans = min(ans, a[i] / (i - 1));
if (i < n) ans = min(ans, a[i] / (n - i));
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MAXN = 2e3 + 5;
const int INF = 200000000;
const double EPS = 1e-6;
string a;
int wton(int l, int r) {
int num(0);
int p = r - l + 1;
while (p) {
num += ((a[l] - '0') * pow(10, p - 1));
p--;
l++;
}
return num;
}
void solve() {
set<int> puk;
vector<int> num;
cin >> a;
int l = 0;
for (int i = 0; i < a.size(); i++) {
if (a[i] == ',') {
puk.insert(wton(l, i - 1));
l = i + 1;
}
}
puk.insert(wton(l, a.size() - 1));
set<int>::iterator it = puk.begin();
for (; it != puk.end(); it++) num.push_back(*it);
cout << num[0];
for (int i = 1; i < num.size(); i++) {
if (num[i] - num[i - 1] <= 1 && num[i + 1] - num[i] > 1)
cout << "-" << num[i];
else if (i == num.size() - 1 && num[i] - num[i - 1] > 1) {
cout << "," << num[i];
} else if (num[i] - num[i - 1] > 1 && num[i + 1] - num[i] <= 1)
cout << "," << num[i];
else if (i == num.size() - 1 && num[i] - num[i - 1] <= 1) {
cout << "-" << num[i];
} else if (num[i] - num[i - 1] > 1 && num[i + 1] - num[i] > 1)
cout << "," << num[i];
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 7;
bool deleted[N];
struct UF {
int f[N];
void init(int n) {
for (int i = 1; i < n + 1; i++) f[i] = i;
}
int getf(int d) { return f[d] == d ? d : f[d] = getf(f[d]); }
void comb(int a, int b) {
a = getf(a);
b = getf(b);
if (a == b) return;
f[a] = b;
}
} uf;
int ans[N];
void solve() {
int n;
cin >> n;
uf.init(n);
ans[n + 1] = (n >> 1);
int sum = n;
for (int i = n; i >= 2; i--) {
ans[i] = ans[i + 1];
while (ans[i] > 1) {
for (int j = ans[i] * 2; j <= n; j += ans[i]) {
uf.comb(ans[i], j);
if (!deleted[j]) {
deleted[j] = true;
sum--;
}
}
if (sum >= i) {
ans[i]--;
} else {
break;
}
}
}
for (int i = 2; i < n + 1; i++) {
cout << ans[i] << " \n"[i == n];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 102;
int a[2][maxn];
void solve(int n, int k) {
if (n == 1) {
a[k][0] = 1;
return;
}
if (n == 2) {
a[k][0] = 3;
a[k][1] = 4;
return;
}
for (int i = 0; i < n - 1; ++i) a[k][i] = 2;
a[k][n - 1] = n - 2;
}
int main() {
int n, m;
int i, j;
scanf("%d%d", &n, &m);
solve(n, 0);
solve(m, 1);
for (i = 0; i < n; ++i) {
for (j = 0; j < m - 1; ++j) printf("%d ", a[0][i] * a[1][j]);
printf("%d\n", a[0][i] * a[1][j]);
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long x[3], y[3];
long long ctr = 0;
char ch;
long long num1, num2;
long long min(long long a, long long b) { return a + b - max(a, b); }
bool possible(long long arr[3]) {
if (arr[0] == arr[1] && arr[1] == arr[2]) return true;
return false;
}
long long last;
void possible1(long long arr[3]) {
if (arr[0] == arr[1] || arr[1] == arr[2] || arr[2] == arr[0]) {
if (arr[0] == x[0]) {
ch = 'x';
if (arr[0] == arr[1]) {
num1 = y[0];
num2 = y[1];
last = y[2];
} else if (arr[1] == arr[2]) {
num1 = y[1];
num2 = y[2];
last = y[0];
} else {
num1 = y[2];
num2 = y[0];
last = y[1];
}
} else {
if (arr[0] == y[0]) {
ch = 'x';
if (arr[0] == arr[1]) {
num1 = x[0];
num2 = x[1];
last = x[2];
} else if (arr[1] == arr[2]) {
num1 = x[1];
num2 = x[2];
last = x[0];
} else {
num1 = x[2];
num2 = x[0];
last = x[1];
}
}
}
ctr++;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> x[0] >> y[0];
cin >> x[1] >> y[1];
cin >> x[2] >> y[2];
possible1(x);
possible1(y);
if (possible(x) || possible(y)) {
cout << 1;
return 0;
} else if (ctr >= 2)
cout << 2;
else if (ctr == 1) {
if ((last >= num1 && last <= num2) || last >= num2 && last <= num1)
cout << 3;
else
cout << 2;
return 0;
} else
cout << 3;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5;
double dp[N][N];
int num[N];
int n, m;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &num[i]);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++)
if (num[i] > num[j])
dp[i][j] = 1.0;
else
dp[i][j] = 0;
}
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
for (int i = 1; i <= n; i++) {
dp[a][i] = dp[b][i] = 0.5 * (dp[a][i] + dp[b][i]);
dp[i][a] = dp[i][b] = 1 - dp[a][i];
}
dp[a][b] = dp[b][a] = 0.5;
}
double ans = 0;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++) ans += dp[i][j];
printf("%.8lf", ans);
return 0;
}
| 9 |
#include<iostream>
#include<vector>
#include<algorithm>
#include<map>
#include<cstdio>
using namespace std;
int block=400;
int t,n,idx;
vector<int>a[210001];
map<int,int>num;
vector<int>mp[210001];
int lst[300001],tim[300001];
int l[210001];
bool vis[210001];
bool check(int x,int y)
{
int cnt=0;
for(int i=0;i<a[y].size();i++)
{
cnt+=vis[a[y][i]];
}
return (cnt>1);
}
int main()
{
cin>>t;
while(t--)
{
num.clear();
idx=0;
int ans1=0,ans2=0;
cin>>n;
for(int i=1;i<=n;i++)
{
scanf("%d",&l[i]);
a[i].clear();
for(int j=1;j<=l[i];j++)
{
int x;
scanf("%d",&x);
if(!num[x])num[x]=++idx,x=idx;
else x=num[x];
a[i].push_back(x);
}
sort(a[i].begin(),a[i].end());
}
for(int i=1;i<=idx;i++)
{
lst[i]=0;
tim[i]=0;
mp[i].clear();
}
for(int i=1;i<=n;i++)
{
if(l[i]>=block)
{
for(int j=1;j<=idx;j++)vis[j]=0;
for(int j=0;j<a[i].size();j++)
{
vis[a[i][j]]=1;
}
for(int j=1;j<=n;j++)
{
//cout<<i<<' '<<j<<' '<<check(i,j)<<endl;
if(i==j)continue;
if(check(i,j))ans1=i,ans2=j;
if(ans1)break;
}
}
else
{
for(int j=0;j<l[i];j++)
{
mp[a[i][j]].push_back(i);
}
}
if(ans1)break;
}
if(ans1)
{
cout<<ans1<<' '<<ans2<<endl;
continue;
}
for(int i=1;i<=idx;i++)
{
for(int j=0;j<mp[i].size();j++)
{
for(int k=0;k<a[mp[i][j]].size();k++)
{
if(a[mp[i][j]][k]==i)continue;
if(tim[a[mp[i][j]][k]]==i&&lst[a[mp[i][j]][k]])ans1=mp[i][j],ans2=lst[a[mp[i][j]][k]];
lst[a[mp[i][j]][k]]=mp[i][j],tim[a[mp[i][j]][k]]=i;
if(ans1)break;
}
if(ans1)break;
}
if(ans1)break;
}
if(!ans1)cout<<"-1\n";
else cout<<ans1<<' '<<ans2<<endl;
}
return 0;
} | 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int max_n = 400;
vector<int> ad_list[max_n], leaves[max_n];
vector<int> order;
int mark[max_n], ind = 0;
queue<int> ans;
void init(int v) {
mark[v] = 1;
if (ad_list[v].size() == 1 && v != 1) {
leaves[v].push_back(v);
return;
}
for (int i = 0; i < ad_list[v].size(); i++) {
if (mark[ad_list[v][i]]) continue;
init(ad_list[v][i]);
for (int j = 0; j < leaves[ad_list[v][i]].size(); j++)
leaves[v].push_back(leaves[ad_list[v][i]][j]);
}
}
void solve(int v) {
mark[v] = 2;
ans.push(v);
if (ad_list[v].size() == 1 && v != 1) {
ind++;
return;
}
for (int i = 0; i < ad_list[v].size(); i++) {
int temp = ad_list[v][i];
if (mark[temp] == 2) continue;
for (int j = 0; j < leaves[temp].size(); j++)
if (leaves[temp][j] == order[ind] || ind >= order.size()) {
solve(temp);
ans.push(v);
i = -1;
break;
}
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
{
cin >> n;
int a, b;
int t = n - 1;
while (t--) {
cin >> a >> b;
ad_list[a].push_back(b);
ad_list[b].push_back(a);
}
t = 2;
for (int i = 1; i <= n; i++)
if (ad_list[i].size() > 2) t += ad_list[i].size() - 2;
if (ad_list[1].size() == 1) t--;
while (t--) {
cin >> a;
order.push_back(a);
}
}
init(1);
solve(1);
if (ans.size() != 2 * n - 1) {
cout << -1 << endl;
return 0;
}
while (!ans.empty()) {
cout << ans.front() << " ";
ans.pop();
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y) {
long long int temp;
if (y == 0) return 1;
temp = power(x, y / 2);
if (y % 2 == 0)
return (temp * temp);
else {
if (y > 0)
return (((x * temp) % 1000000007) * temp);
else
return (temp * temp) / x;
}
}
long long int mul_inv(long long int n, long long int p, long long int m) {
if (p == 1) {
return n % m;
} else if (p % 2 == 0) {
long long int t = mul_inv(n, p / 2, m);
return ((t) * (t)) % m;
} else {
long long int t = mul_inv(n, p / 2, m);
return ((((n % m) * t) % m) * t) % m;
}
}
bool isprime(long long int n) {
if (n == 2) {
return true;
}
if (n % 2 == 0) {
return false;
}
for (long long int i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
double P[5005][5005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
P[0][0] = 1;
int n, T;
cin >> n >> T;
double ans = 0;
for (int i = 0; i < n; i++) {
int t;
double p;
cin >> p >> t;
p /= 100;
double q = pow(1 - p, t - 1);
double temp = 0;
for (int j = 1; j <= T; ++j) {
if (j < t) {
temp *= (1 - p);
temp += P[i][j - 1] * p;
P[i + 1][j] = temp;
} else {
temp *= (1 - p);
temp += P[i][j - 1] * p;
temp -= P[i][j - t] * p * q;
P[i + 1][j] = temp;
P[i + 1][j] += P[i][j - t] * q;
}
ans += P[i + 1][j];
}
}
cout << std::fixed;
cout << std::setprecision(9);
cout << ans;
return 0;
}
| 8 |
#include <bits/stdc++.h>
int main() {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
if (c == 0)
(a == b) ? printf("YES") : printf("NO");
else if (c > 0)
(a <= b && !((b - a) % c)) ? printf("YES") : printf("NO");
else
(a >= b && !((a - b) % c)) ? printf("YES") : printf("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using PP = pair<ll, P>;
const ll n_ = 4e5 + 100, inf = 1e18, mod = 1e9 + 7, sqrtN = 333, p = 27;
ll dy[4] = {-1, 0, 1, 0}, dx[4] = {0, 1, 0, -1};
ll n, m, k, tc = 1, a, b, c, d, sum, x, y, z, base, ans;
ll gcd(ll x, ll y) {
if (!y) return x;
return gcd(y, x % y);
}
ll A[220], B[120];
void solve() {
cin >> n >> k;
memset(A, 0, sizeof(A));
x = n - k;
n *= 2;
while (k--) {
cin >> a >> b;
A[a] = b;
A[b] = a;
}
vector<ll> v;
for (int i = 1; i <= n; i++) {
if (A[i]) continue;
v.push_back(i);
}
for (int i = 0; i < v.size() / 2; i++) {
A[v[i]] = v[i + v.size() / 2];
A[v[i + v.size() / 2]] = v[i];
}
ans = 0;
for (int i = 1; i <= n; i++) {
if (A[i] <= i) continue;
for (int j = i + 1; j <= n; j++) {
if (i == j || A[j] <= j || j > A[i]) continue;
if (A[i] < A[j]) {
ans++;
}
}
}
cout << ans << '\n';
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> tc;
while (tc--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const int nax = 1e5 + 3;
const int mod = 1e9 + 7;
const int inf = 1e9 + 7;
const int64_t infll = 1e18 + 7;
const long double PI = 3.1415926535897932384626433832795;
void solve() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int ans = 1, now = 1;
for (int i = 1; i < n; ++i) {
if (1ll * a[i] <= 2ll * a[i - 1]) {
++now;
} else {
ans = max(ans, now);
now = 1;
}
}
cout << max(ans, now) << "\n";
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(12);
int t = 1;
while (t--) {
solve();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10, mod = 1e9;
const int SS = 4 * maxn;
int t1[maxn], t2[maxn], ps1[maxn], ps2[maxn], n, q;
int seg[SS][2], lazy[SS];
inline int ad(int x, int y) { return (x + y) % mod; }
inline int Ad(int x, int y) { return ((x + y) % mod + mod) % mod; }
inline int mu(int x, int y) { return (1LL * x * y) % mod; }
void prep() {
t1[1] = 1;
t2[0] = t2[1] = 1;
for (int i = 2; i < maxn; i++) {
t1[i] = ad(t1[i - 1], t1[i - 2]);
t2[i] = ad(t2[i - 1], t2[i - 2]);
}
for (int i = 1; i < maxn; i++) {
ps1[i] = ad(ps1[i - 1], t1[i - 1]);
ps2[i] = ad(ps2[i - 1], t2[i - 1]);
}
}
inline void upd(int v, int l, int r, int val) {
lazy[v] = ad(val, lazy[v]);
seg[v][0] = ad(seg[v][0], mu(ps1[r - l], val));
seg[v][1] = ad(seg[v][1], mu(ps2[r - l], val));
}
inline void shift(int v, int l, int r) {
int mid = (r + l) / 2;
upd(2 * v + 0, l, mid, lazy[v]);
upd(2 * v + 1, mid, r, lazy[v]);
lazy[v] = 0;
}
void add(int x, int y, int val, int v = 1, int l = 0, int r = n) {
if (x >= r || y <= l) return;
if (x <= l && y >= r) {
upd(v, l, r, val);
return;
}
int mid = (r + l) / 2;
shift(v, l, r);
add(x, y, val, 2 * v + 0, l, mid);
add(x, y, val, 2 * v + 1, mid, r);
seg[v][0] = ad(seg[2 * v][0], ad(mu(seg[2 * v + 1][1], t2[mid - l - 1]),
mu(seg[2 * v + 1][0], t1[mid - l - 1])));
seg[v][1] = ad(seg[2 * v][1], ad(mu(seg[2 * v + 1][1], t2[mid - l - 0]),
mu(seg[2 * v + 1][0], t1[mid - l - 0])));
}
int get(int x, int y, int v = 1, int l = 0, int r = n) {
if (x >= r || y <= l) return 0;
if (x <= l && y >= r) {
if (l == x) return seg[v][1];
return ad(mu(seg[v][0], t1[l - x]), mu(seg[v][1], t2[l - x]));
}
int mid = (r + l) / 2;
shift(v, l, r);
int t1 = get(x, y, 2 * v + 0, l, mid);
int t2 = get(x, y, 2 * v + 1, mid, r);
return ad(t1, t2);
}
int main() {
prep();
scanf("%d%d", &n, &q);
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
add(i, i + 1, x);
}
while (q--) {
int tp, l, r, x;
scanf("%d%d%d", &tp, &l, &r);
l--;
if (tp == 1)
add(l, l + 1, Ad(r - get(l, l + 1), 0));
else if (tp == 2)
printf("%d\n", get(l, r));
else {
scanf("%d", &x);
add(l, r, x);
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = acosl(-1.);
const int N = 1000111;
int a[N], t[N], x[N], d[N];
unordered_map<int, int> q;
int sz = 0;
vector<int> sums[N];
vector<int> times[N];
inline int prev(int x) { return x & (x - 1); }
inline int next(int x) { return x + x - prev(x); }
void modify(vector<int>& a, size_t pos, int value) {
++pos;
while (pos < a.size()) {
a[pos] += value;
pos = next(pos);
}
}
int findsum(vector<int>& a, size_t pos) {
++pos;
int result = 0;
while (pos) {
result += a[pos];
pos = prev(pos);
}
return result;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d%d%d", a + i, t + i, x + i);
auto it = q.find(x[i]);
if (it == q.end()) {
q[x[i]] = sz++;
x[i] = sz - 1;
} else {
x[i] = it->second;
}
d[x[i]]++;
}
for (int i = 0; i < sz; ++i) {
sums[i].resize(d[i] + 3);
times[i].reserve(d[i] + 3);
}
for (int i = 0; i < n; ++i) {
times[x[i]].push_back(t[i]);
}
for (int i = 0; i < sz; ++i) {
sort(begin(times[i]), end(times[i]));
}
for (int i = 0; i < n; ++i) {
int pos = lower_bound(begin(times[x[i]]), end(times[x[i]]), t[i]) -
begin(times[x[i]]);
if (a[i] == 1) {
modify(sums[x[i]], pos, 1);
} else if (a[i] == 2) {
modify(sums[x[i]], pos, -1);
} else {
printf("%d\n", findsum(sums[x[i]], pos));
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long INF_ = LONG_LONG_MIN;
signed main() {
long long t;
cin >> t;
for (long long u = 0; u < t; ++u) {
long long n, max_ = -1, ans = 0;
cin >> n;
vector<long long> b(n);
for (long long i = 0; i < n; ++i) {
cin >> b[i];
max_ = max(max_, b[i]);
}
long long a = b[n - 1];
for (long long i = n - 2; i >= 0; --i) {
if (b[i] > a) {
a = b[i];
ans++;
}
if (a == max_) {
break;
}
}
if (a == max_) {
cout << ans << '\n';
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
unsigned long long a[11000];
unsigned long long b[11000];
unsigned long long c;
unsigned long long f(unsigned long long x) {
unsigned long long ans = n;
for (int i = 0; i < n; ++i) ans += a[i] * x / b[i];
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> c;
for (int i = 0; i < n; ++i) cin >> a[i] >> b[i];
unsigned long long ans = 0;
for (unsigned long long x = 1; x <= 100000; ++x)
if (f(x) == c) ans++;
if (ans == 100000)
cout << -1 << "\n";
else
cout << ans << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
cerr << name << " : " << arg1 << std::endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
vector<pair<int, int> > A;
vector<int> C;
vector<long long int> ans;
multiset<int> second;
int main() {
int n =
[]() {
int x;
scanf("%d", &x);
return x;
}(),
k = []() {
int x;
scanf("%d", &x);
return x;
}();
A.resize(n);
C.resize(n);
ans.resize(n);
for (int i = 0; i < n; i++)
A[i].first =
[]() {
int x;
scanf("%d", &x);
return x;
}(),
A[i].second = i;
for (int i = 0; i < n; i++)
C[i] = []() {
int x;
scanf("%d", &x);
return x;
}();
sort(A.begin(), A.end());
for (int i = 0; i < n; i++) {
long long int sum = C[A[i].second];
auto it = second.end();
for (int j = 0; j < k && it != second.begin(); j++) {
it--;
sum += *it;
}
second.insert(C[A[i].second]);
ans[A[i].second] = sum;
}
for (long long int& x : ans) printf("%lld ", x);
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const int inf = 0x3f3f3f3f;
int n, l[110], r[110];
bool checkl(int a, int b) {
if (l[b] == 0) {
return true;
}
if (l[b] == a) {
return false;
}
return checkl(a, l[b]);
}
bool checkr(int a, int b) {
if (r[b] == 0) {
return true;
}
if (r[b] == a) {
return false;
}
return checkr(a, r[b]);
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
int cnt = 0;
for (int i = 1; i <= n; i++) {
cin >> l[i] >> r[i];
if (l[i] == 0) {
cnt++;
}
}
for (int i = 1; i <= n; i++) {
if (l[i] == 0 && cnt > 1) {
for (int j = 1; j <= n; j++) {
if (r[j] == 0 && j != i && checkl(i, j)) {
l[i] = j, r[j] = i, cnt--;
break;
}
}
}
if (r[i] == 0 && cnt > 1) {
for (int j = 1; j <= n; j++) {
if (l[j] == 0 && i != j && checkr(i, j)) {
r[i] = j, l[j] = i, cnt--;
break;
}
}
}
}
for (int i = 1; i <= n; i++) {
cout << l[i] << " " << r[i] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s;
string a[500], nametaxi[500], namepiza[500], namegirl[500];
struct edge {
int taxi, piza, girl;
};
edge d[500];
int n, m, maxtaxi = -2147483647, maxpiza = -2147483647, maxgirl = -2147483647,
ktaxi, kpiza, kgirl;
void f(string s, int n) {
int k = 0;
if (s[0] == s[1] && s[0] == s[3] && s[0] == s[4] && s[0] == s[6] &&
s[0] == s[7] && k == 0) {
d[n].taxi++;
k = 1;
}
if (s[0] > s[1] && s[1] > s[3] && s[3] > s[4] && s[4] > s[6] && s[6] > s[7] &&
k == 0) {
d[n].piza++;
k = 1;
}
if (k == 0) {
d[n].girl++;
k = 1;
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> m >> a[i];
for (int j = 1; j <= m; j++) {
cin >> s;
f(s, i);
}
if (d[i].taxi > maxtaxi) {
maxtaxi = d[i].taxi;
}
if (d[i].piza > maxpiza) {
maxpiza = d[i].piza;
}
if (d[i].girl > maxgirl) {
maxgirl = d[i].girl;
}
}
for (int i = 1; i <= n; i++) {
if (d[i].taxi == maxtaxi) {
ktaxi++;
nametaxi[ktaxi] = a[i];
}
if (d[i].piza == maxpiza) {
kpiza++;
namepiza[kpiza] = a[i];
}
if (d[i].girl == maxgirl) {
kgirl++;
namegirl[kgirl] = a[i];
}
}
cout << "If you want to call a taxi, you should call: ";
for (int i = 1; i < ktaxi; i++) cout << nametaxi[i] << ", ";
cout << nametaxi[ktaxi] << "." << endl;
cout << "If you want to order a pizza, you should call: ";
for (int i = 1; i < kpiza; i++) cout << namepiza[i] << ", ";
cout << namepiza[kpiza] << "." << endl;
cout
<< "If you want to go to a cafe with a wonderful girl, you should call: ";
for (int i = 1; i < kgirl; i++) cout << namegirl[i] << ", ";
cout << namegirl[kgirl] << ".";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x >= 10) write(x / 10);
putchar(x % 10 + '0');
}
void writeln(long long x) {
write(x);
puts("");
}
const long long N = 2010;
double big[N][N], ans;
long long n, Q, a[N];
int main() {
n = read();
Q = read();
for (long long i = 1; i <= n; ++i) a[i] = read();
for (long long i = 1; i <= n; ++i)
for (long long j = 1; j <= n; ++j)
if (i ^ j) big[i][j] = a[i] > a[j];
while (Q--) {
long long x = read(), y = read();
big[x][y] = big[y][x] = 0.5;
for (long long i = 1; i <= n; ++i)
if ((x ^ i) && (y ^ i))
big[x][i] = big[y][i] = (big[x][i] + big[y][i]) / 2,
big[i][x] = big[i][y] = (big[i][x] + big[i][y]) / 2;
}
for (long long i = 1; i <= n; ++i)
for (long long j = i + 1; j <= n; ++j) ans += big[i][j];
printf("%lf", ans);
}
| 9 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::vector;
const int N = 200054;
int R, C, X;
int r[N], c[N];
vector<int> ins[N], del[N];
vector<std::pair<int, int> > qry[N];
struct data {
int u, v, w;
inline bool accept(const data &B) const {
return B.v <= u && u <= B.w && v <= B.u && B.u <= w;
}
inline void shrink(int x) { u -= x, v -= x, w -= x; }
} A[N], B[N];
inline void down(int &x, const int y) { x > y ? x = y : 0; }
namespace Cartesian {
int n, *a, root;
int stack[N], lc[N], rc[N];
data b[N];
inline void init(int n_, int *a_) { n = n_, a = a_; }
int dfs(int n, int L, int R) {
b[n].w = std::min(a[L - 1], a[R + 1]) - 1;
b[n].u = b[n].v = a[n];
if (~lc[n]) down(b[n].u, dfs(lc[n], L, n - 1));
if (~rc[n]) down(b[n].u, dfs(rc[n], n + 1, R));
return b[n].u;
}
void build() {
int i, top = 0;
memset(lc, -1, (n + 2) << 2), memset(rc, -1, (n + 2) << 2);
for (i = 0; i <= n + 1; ++i) {
for (; top && a[stack[top]] <= a[i]; --top) lc[i] = stack[top];
if (top) rc[stack[top]] = i;
stack[++top] = i;
}
}
void work(data *ret) {
int i;
build(), dfs(rc[0], 1, n);
for (i = 1; i <= n; ++i) ret[i] = b[i], ret[i].u = X - ret[i].u;
}
} // namespace Cartesian
namespace BIT {
const int N = 400054;
int x[N];
inline int sum(int h) {
int s = 0;
for (; h >= 0; h &= h + 1, --h) s += x[h];
return s;
}
inline void add(int h, int v) {
for (; h < N; h |= h + 1) x[h] += v;
}
inline int range(int l, int r) { return sum(r) - sum(l - 1); }
} // namespace BIT
int main() {
int i, j, t, min = 0;
long long ans = 0;
std::ios::sync_with_stdio(false), cin.tie(nullptr);
cin >> R >> C >> X, r[0] = r[R + 1] = c[0] = c[C + 1] = X + 2;
for (i = 1; i <= R; ++i) cin >> r[i], down(r[i], X + 1);
for (j = 1; j <= C; ++j) cin >> c[j], down(c[j], X + 1);
Cartesian::init(R, r), Cartesian::work(A), Cartesian::init(C, c),
Cartesian::work(B);
for (i = 1; i <= R; ++i) down(min, A[i].u);
for (j = 1; j <= C; ++j) down(min, B[j].u);
for (i = 1; i <= R; ++i) A[i].shrink(min);
for (j = 1; j <= C; ++j) B[j].shrink(min);
for (i = 1; i <= R; ++i)
ins[A[i].v].emplace_back(A[i].u), del[A[i].w + 1].emplace_back(A[i].u);
for (j = 1; j <= C; ++j) qry[B[j].u].emplace_back(B[j].v, B[j].w);
for (t = 0; t < N; ++t) {
for (int x : ins[t]) BIT::add(x, 1);
for (int x : del[t]) BIT::add(x, -1);
for (const std::pair<int, int> &e : qry[t])
ans += BIT::range(e.first, e.second);
}
cout << ans << '\n';
return 0;
}
| 13 |
#include <bits/stdc++.h>
const long long INF = 1e18;
long long pw[18];
std::vector<long long> v;
void init() {
pw[0] = 1;
for (int i = 1; i < 18; ++i) {
pw[i] = pw[i - 1] * 10;
}
for (int i = 0; i < 18; ++i) {
for (int x = 1; x < 10; ++x) {
v.push_back(x * pw[i]);
for (int j = 0; j < i; ++j) {
for (int y = 1; y < 10; ++y) {
v.push_back(x * pw[i] + y * pw[j]);
for (int k = 0; k < j; ++k) {
for (int z = 1; z < 10; ++z) {
v.push_back(x * pw[i] + y * pw[j] + z * pw[k]);
}
}
}
}
}
}
std::sort(v.begin(), v.end());
v.erase(std::unique(v.begin(), v.end()), v.end());
}
int solve(long long x) {
return std::upper_bound(v.begin(), v.end(), x) - v.begin() + (x == INF);
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
init();
int T = 1;
std::cin >> T;
while (T--) {
long long l, r;
std::cin >> l >> r;
std::cout << solve(r) - solve(l - 1) << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int cnt[105] = {0};
for (int i = 0; i < n; i++) {
int a;
cin >> a;
cnt[a]++;
}
int ansa, ansb;
int c = 0;
vector<int> v;
for (int i = 0; i <= 100; i++) {
if (cnt[i]) {
if (cnt[i] != n / 2) {
cout << "NO" << endl;
return 0;
}
v.push_back(i);
}
}
cout << "YES" << endl;
for (auto x : v) cout << x << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
void _print(long long t) { cerr << t; }
void _print(int t) { cerr << t; }
void _print(string t) { cerr << t; }
void _print(char t) { cerr << t; }
void _print(long double t) { cerr << t; }
void _print(double t) { cerr << t; }
void _print(unsigned long long t) { cerr << t; }
template <class T, class V>
void _print(pair<T, V> p);
template <class T>
void _print(vector<T> v);
template <class T>
void _print(set<T> v);
template <class T, class V>
void _print(map<T, V> v);
template <class T>
void _print(multiset<T> v);
template <class T, class V>
void _print(pair<T, V> p) {
cerr << "{";
_print(p.first);
cerr << ",";
_print(p.second);
cerr << "}";
}
template <class T>
void _print(vector<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(set<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T>
void _print(multiset<T> v) {
cerr << "[ ";
for (T i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
template <class T, class V>
void _print(map<T, V> v) {
cerr << "[ ";
for (auto i : v) {
_print(i);
cerr << " ";
}
cerr << "]";
}
void solve() {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
vector<int> arr(n);
for (auto &x : arr) cin >> x;
sort(arr.begin(), arr.end(), greater<int>());
int sum = 0;
for (int i = 0; i < k; i++) sum += arr[i + k] / arr[i];
for (int i = 2 * k; i < n; i++) sum += arr[i];
cout << sum << '\n';
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a;
cin >> b;
int res = 0;
do {
res++;
a = a * 3;
b = b * 2;
} while (a <= b);
cout << res << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
const long double PI = acos(-1.0);
const long double EPS = 1e-6;
const long long INF = 1e9;
const long long LINF = 1e18;
const long long mod = 1000000009;
const long long MAX = 5e3 + 47;
int magic = 50;
string s;
int cnt = 0;
pair<long long, int> hashes[10000000];
long long pow29[100001];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> s;
int n = s.size();
magic = min(magic, n);
for (int i = 0; i < s.size(); i++) s[i] -= 'a', s[i]++;
pow29[0] = 1;
for (int i = 1; i <= n; i++) pow29[i] = pow29[i - 1] * 37;
for (int i = 1; i <= magic; i++) {
long long hash = 0;
for (int j = 0; j < i; j++) {
hash *= 37;
hash += s[j];
}
hashes[cnt++] = {hash, 0};
for (int j = 0; j < n - i; j++) {
hash -= pow29[i - 1] * s[j];
hash *= 37;
hash += s[j + i];
hashes[cnt++] = {hash, j + 1};
}
}
sort(hashes, hashes + cnt);
int q;
cin >> q;
while (q--) {
int num = 0;
string query;
cin >> num >> query;
if (query.size() > n) {
cout << -1 << endl;
continue;
}
long long Hash1 = 0;
for (int i = 0; i < query.size(); i++) {
query[i] -= 'a';
query[i]++;
Hash1 *= 37;
Hash1 += query[i];
}
if (query.size() <= magic) {
int ans = INF;
auto it = lower_bound(hashes, hashes + cnt, make_pair(Hash1, 0));
if (it == hashes + cnt) {
cout << -1 << endl;
continue;
}
int pos = it - hashes;
for (int i = pos;
i < cnt - num + 1 && hashes[i + num - 1].first == Hash1 &&
hashes[i].first == Hash1;
i++) {
ans = min(ans, hashes[i + num - 1].second - hashes[i].second);
}
if (ans == INF)
cout << -1 << endl;
else
cout << ans + query.size() << endl;
} else {
vector<int> hashes;
int magic = query.size();
long long hash = 0;
for (int j = 0; j < magic; j++) {
hash *= 37;
hash += s[j];
}
if (Hash1 == hash) hashes.push_back(0);
for (int j = 0; j < n - magic; j++) {
hash -= pow29[magic - 1] * s[j];
hash *= 37;
hash += s[j + magic];
if (Hash1 == hash) hashes.push_back(j + 1);
}
int bestAns = INF;
for (int i = 0; i < (int)hashes.size() - num + 1; i++) {
bestAns = min(bestAns, hashes[i + num - 1] - hashes[i]);
}
if (bestAns == INF)
cout << -1 << endl;
else
cout << bestAns + query.size() << endl;
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
const int sqn = 350;
bool f[maxn];
int id[maxn], all, cnt[maxn][sqn], ct[maxn];
long long add[sqn], sum[sqn], a[maxn];
vector<int> G[maxn];
vector<int> have[maxn];
int main() {
int n, m, q;
while (scanf("%d%d%d", &n, &m, &q) == 3) {
for (int i = 0; i < n; i++) scanf("%I64d", &a[i]);
all = 0;
for (int i = 0; i < m; i++) {
scanf("%d", &ct[i]);
if (ct[i] >= sqn) {
f[i] = 1;
id[i] = all++;
} else
f[i] = 0;
for (int j = 0; j < ct[i]; j++) {
int t;
scanf("%d", &t);
t--;
G[i].push_back(t);
if (f[i]) {
have[t].push_back(all - 1);
sum[all - 1] += a[t];
}
}
}
for (int i = 0; i < m; i++)
for (int j = 0; j < G[i].size(); j++) {
int t = G[i][j];
for (int k = 0; k < have[t].size(); k++) {
int to = have[t][k];
cnt[i][to]++;
}
}
char s[10];
long long op, x;
while (q--) {
scanf("%s%I64d", s, &op);
op--;
if (s[0] == '?') {
long long ans = 0;
if (f[op])
ans += (long long)sum[id[op]];
else
for (int i = 0; i < G[op].size(); i++) ans += (long long)a[G[op][i]];
for (int i = 0; i < all; i++) ans += (long long)add[i] * cnt[op][i];
printf("%I64d\n", ans);
} else {
scanf("%I64d", &x);
if (f[op])
add[id[op]] += x;
else {
for (int i = 0; i < G[op].size(); i++) a[G[op][i]] += x;
for (int i = 0; i < all; i++) sum[i] += (long long)cnt[op][i] * x;
}
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010000;
struct node {
int x, y;
int ord;
} ch[maxn];
bool cmp(node a, node b) { return a.x < b.x; }
bool cmp1(node a, node b) { return a.y < b.y; }
bool cmp2(node a, node b) { return a.y > b.y; }
int cnt[maxn] = {0};
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d%d", &ch[i].x, &ch[i].y);
ch[i].ord = i + 1;
}
sort(ch, ch + n, cmp);
int quan = 1, j = 0;
for (int i = 0; i < n; i++) {
if (ch[i].x >= 1000 * quan) {
cnt[j++] = i;
quan++;
}
}
sort(ch, ch + cnt[0], cmp1);
for (int i = 1; i < j; i++) {
if (i % 2 == 0) {
sort(ch + cnt[i - 1], ch + cnt[i], cmp1);
} else {
sort(ch + cnt[i - 1], ch + cnt[i], cmp2);
}
}
for (int i = 0; i < n; i++) {
printf("%d ", ch[i].ord);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/STACK:336777216")
using namespace std;
inline long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
inline long long power(long long a, long long n, long long m) {
if (n == 0) return 1;
long long p = power(a, n / 2, m);
p = (p * p) % m;
if (n % 2)
return (p * a) % m;
else
return p;
}
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
const long long MOD = 1000000007;
int main() {
int n;
cin >> n;
long long ans = 0;
for (int i = 2; i <= n; i++) {
for (int j = 2 * i; j <= n; j += i) ans = ans + 4 * (j / i);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, M = 305;
int a[N], l[N], r[N], b[N], c[N];
int n, m, tot;
int mx[N], mn[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &l[i], &r[i]);
r[i]++;
b[++tot] = l[i];
b[++tot] = r[i];
}
b[++tot] = 1;
b[++tot] = n + 1;
sort(b + 1, b + tot + 1);
tot = unique(b + 1, b + tot + 1) - (b + 1);
for (int i = 1; i <= m; i++) {
l[i] = lower_bound(b + 1, b + tot + 1, l[i]) - b;
r[i] = lower_bound(b + 1, b + tot + 1, r[i]) - b;
}
int t1 = -0x3f3f3f3f, t2 = 0x3f3f3f3f;
for (int i = 1; i < tot; i++) {
mx[i] = mn[i] = a[b[i]];
for (int j = b[i] + 1; j < b[i + 1]; j++) {
mx[i] = max(mx[i], a[j]);
mn[i] = min(mn[i], a[j]);
}
t1 = max(t1, mx[i]);
t2 = min(t2, mn[i]);
}
vector<int> ans[N];
int Ans = t1 - t2, pos = 0;
for (int x = 1; x < tot; x++) {
memset(c, 0, sizeof(c));
for (int j = 1; j <= m; j++) {
if (l[j] <= x && r[j] > x) ans[x].push_back(j);
}
if (!ans[x].size()) continue;
for (auto v : ans[x]) {
c[l[v]]--;
c[r[v]]++;
}
int s = 0, minx = 0x3f3f3f3f, t = 0, maxx = -0x3f3f3f3f;
for (int i = 1; i < tot; i++) {
s += c[i];
if (!t || mn[i] + s < minx) minx = mn[t = i] + s;
}
s = 0;
for (int i = 1; i < tot; i++) {
s += c[i];
if (mx[i] + s > maxx) maxx = mx[i] + s;
}
if (maxx - minx > Ans) {
Ans = maxx - minx;
pos = x;
}
}
cout << Ans << endl << ans[pos].size() << endl;
for (auto v : ans[pos]) cout << v << " ";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int px[102] = {0}, py[102] = {0};
int main() {
long long int x, y, bx = 0, by = 0;
string s;
cin >> x >> y;
cin >> s;
for (long long int i = 1; i <= s.length(); i++) {
if (bx == x && by == y) {
cout << "Yes" << endl;
return 0;
}
if (s[i - 1] == 'U') {
by++;
}
if (s[i - 1] == 'D') {
by--;
}
if (s[i - 1] == 'L') {
bx--;
}
if (s[i - 1] == 'R') {
bx++;
}
px[i] = bx;
py[i] = by;
}
long long int flag = 0;
for (long long int i = 0; i <= s.length(); i++) {
long long int a = x - px[i];
long long int b = y - py[i];
long long int k = 0;
if (bx != 0) {
k = a / bx;
} else if (by != 0) {
k = b / by;
} else
k = 1;
if (k >= 0 && bx * k == a && k * by == b) {
flag = 1;
break;
}
}
if (flag)
cout << "Yes" << endl;
else
cout << "No" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[10001000], b[10001000], f[10001000];
int n, m, i, j, k, l, ans, c, d;
int find(int x, int y) {
int l, r, mid;
l = 0;
r = y - 1;
while (l != r) {
mid = (l + r) / 2 + 1;
if (f[mid] > x)
l = mid;
else
r = mid - 1;
}
return l;
}
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &c);
a[c] = i;
}
for (i = 1; i <= n; i++) {
scanf("%d", &c);
b[i] = a[c];
}
ans = 1;
f[0] = 100000086;
f[1] = b[1];
for (i = 2; i <= n; i++) {
c = find(b[i], i);
f[c + 1] = b[i];
ans = max(c + 1, ans);
}
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int N = 2e5 + 9;
int t, n, m, p[N], x;
char c[N];
int s[30];
using namespace std;
int main() {
scanf("%d", &t);
while (t--) {
memset(s, 0, sizeof s);
memset(p, 0, sizeof p);
scanf("%d %d\n", &n, &m);
for (int i = 0; i < n; i++) scanf("%c", &c[i]);
for (int i = 0; i < m; i++) {
scanf("%d", &x);
++p[x - 1];
}
for (int i = n - 2; i >= 0; --i) p[i] += p[i + 1];
for (int i = 0; i < n; i++) ++s[c[i] - 'a'];
for (int i = 0; i < n; i++) s[c[i] - 'a'] += p[i];
for (int i = 0; i < 26; i++) printf("%d ", s[i]);
puts("");
}
}
| 2 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
int n, m, t;
struct EVENT {
int x, t, type;
bool operator()(EVENT p, EVENT q) {
return make_pair(make_pair(p.t, p.type), p.x) <
make_pair(make_pair(q.t, q.type), q.x);
}
EVENT() {}
EVENT(int x, int t, int type) { this->x = x, this->t = t, this->type = type; }
};
vector<EVENT> events;
int a[30000][2];
int dat[30000];
set<int> alive;
int en[30000];
int num;
int main() {
int i, j, k;
cin >> n >> m >> t;
for (i = 0; i < n; i++) {
int x, y, z;
scanf("%d:%d:%d", &x, &y, &z);
int u = z + y * 60 + x * 3600;
a[i][0] = u, a[i][1] = u + t - 1;
events.push_back(EVENT(i, u, 0));
events.push_back(EVENT(i, u + t - 1, 1));
}
sort(events.begin(), events.end(), EVENT());
int last = -1;
int ma = 0;
for (auto e : events) {
if (e.type == 0) {
if (alive.size() == m) {
dat[e.x] = last;
en[last] = e.t + t - 1;
} else {
dat[e.x] = num++;
last = num - 1;
en[last] = e.t + t - 1;
alive.insert(num - 1);
}
} else {
if (en[dat[e.x]] != e.t) continue;
alive.erase(dat[e.x]);
}
ma = max(ma, (int)alive.size());
}
if (ma != m) return printf("No solution"), 0;
printf("%d\n", num);
for (i = 0; i < n; i++) printf("%d\n", dat[i] + 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <typename T>
void debug(T first) {
cout << first << "\n";
}
template <typename T, typename... Args>
void debug(T first, Args... args) {
cout << first << " ";
debug(args...);
}
int main() {
long long n, a, b;
cin >> n >> a >> b;
if (6 * n <= a * b) return !printf("%lld\n%lld %lld", a * b, a, b);
bool f = false;
long long mini = 1e18;
if (a > b) swap(a, b), f = true;
long long a_, b_;
for (long long i = a; i * i <= 6 * n; i++) {
long long tb = 6 * n / i;
if (tb * i != 6 * n) tb++;
if (tb < b) continue;
if (mini > tb * i) {
b_ = tb;
a_ = i;
mini = a_ * b_;
}
}
if (f) swap(a_, b_);
printf("%lld\n%lld %lld", a_ * b_, a_, b_);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
bool vis[100][100];
int tu[100][100], ls[100][100];
int x1, x2, Y1, y2, n;
int dir[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
bool pd(int x, int y) {
if (x > n || x <= 0 || y > n || y <= 0 || vis[x][y]) return 0;
return 1;
}
void dfs(int x, int y, int id) {
vis[x][y] = 1;
ls[x][y] = id;
int flag = tu[x][y];
for (int i = 0; i <= 3; i++) {
int nx = x + dir[i][0], ny = y + dir[i][1];
if (pd(nx, ny) && flag == tu[nx][ny]) dfs(nx, ny, id);
}
}
struct newt {
int x, y;
} dian1[maxn], dian2[maxn];
int cnt1 = 1, cnt2 = 1;
void dfs1(int x, int y) {
dian1[cnt1].x = x, dian1[cnt1++].y = y;
vis[x][y] = 1;
int flag = ls[x][y];
for (int i = 0; i <= 3; i++) {
int nx = x + dir[i][0], ny = y + dir[i][1];
if (pd(nx, ny) && ls[nx][ny] == flag) dfs1(nx, ny);
}
}
void dfs2(int x, int y) {
dian2[cnt2].x = x, dian2[cnt2++].y = y;
vis[x][y] = 1;
int flag = ls[x][y];
for (int i = 0; i <= 3; i++) {
int nx = x + dir[i][0], ny = y + dir[i][1];
if (pd(nx, ny) && ls[nx][ny] == flag) dfs2(nx, ny);
}
}
int main() {
cin >> n;
string s[100];
cin >> x1 >> Y1;
cin >> x2 >> y2;
for (int i = 1; i <= n; i++) {
cin >> s[i];
for (int j = 0; j < n; j++)
if (s[i][j] == '0')
tu[i][j + 1] = 0;
else
tu[i][j + 1] = 1;
}
int ys = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) {
if (vis[i][j] == 0) dfs(i, j, ++ys);
}
long long ans = 1e9;
if (ls[x1][Y1] == ls[x2][y2])
cout << "0" << endl;
else {
memset(vis, 0, sizeof(vis));
dfs1(x1, Y1);
memset(vis, 0, sizeof(vis));
dfs2(x2, y2);
for (int i = 1; i < cnt1; i++)
for (int j = 1; j < cnt2; j++)
if (1ll * (dian1[i].x - dian2[j].x) * (dian1[i].x - dian2[j].x) +
1ll * (dian1[i].y - dian2[j].y) * (dian1[i].y - dian2[j].y) <=
ans)
ans = 1ll * (dian1[i].x - dian2[j].x) * (dian1[i].x - dian2[j].x) +
1ll * (dian1[i].y - dian2[j].y) * (dian1[i].y - dian2[j].y);
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
long long d1[] = {0, 1, 1, 1, 0, -1, -1, -1};
long long d2[] = {1, 1, 0, -1, -1, -1, 0, 1};
char c[101][101];
bool isvalid(long long i, long long j) {
if (i >= 1 && i <= n && j >= 1 && j <= m) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long i, j;
cin >> n >> m;
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) cin >> c[i][j];
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= m; j++) {
if (c[i][j] == '.') {
for (long long k = 0; k < 8; k++) {
long long x1 = i + d1[k];
long long y1 = j + d2[k];
if (isvalid(x1, y1) && c[x1][y1] == '*') {
cout << "NO";
return 0;
}
}
} else if (c[i][j] != '*') {
long long s = c[i][j] - '0';
long long c1 = 0;
for (long long k = 0; k < 8; k++) {
long long x1 = i + d1[k];
long long y1 = j + d2[k];
if (c[x1][y1] == '*' && isvalid(x1, y1)) {
c1++;
}
}
if (c1 != s) {
cout << "NO";
return 0;
}
}
}
}
cout << "YES";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e6 + 5;
int a[N], s[N];
int main() {
int n, t;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
scanf("%d", &t);
while (t--) {
int x;
scanf("%d", &x);
a[x] *= -1;
}
int p = 0;
for (int i = n; i >= 1; --i) {
if (a[i] < 0)
s[++p] = a[i];
else {
if (p && a[i] + s[p] == 0)
--p;
else {
s[++p] = -a[i];
a[i] *= -1;
}
}
}
if (p)
printf("NO\n");
else {
printf("YES\n");
for (int i = 1; i < n; ++i) printf("%d ", a[i]);
printf("%d\n", a[n]);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_INT = std::numeric_limits<int>::max();
const int MIN_INT = std::numeric_limits<int>::min();
const int INF = MAX_INT;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a * (b / gcd(a, b)); }
int main() {
double a, b, mn = INF, n;
cin >> a >> b;
n = floor((a - b) / (2 * b));
if (n > 0) mn = (a - b) / n / 2;
n = floor((a + b) / (2 * b));
if (n > 0) mn = (mn < (a + b) / n / 2 ? mn : (a + b) / n / 2);
if (mn == INF)
printf("-1\n");
else
printf("%.12lf\n", mn);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void FAIL() {
cout << "Impossible\n";
exit(0);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
string S1, S2;
cin >> S1 >> S2;
int k = (int)S2.size();
int a = 0, b = 0, c = 0;
for (int i = 0; i < (int)S1.size(); i++) {
if (S1[i] == '|')
c = 1;
else if (c == 0)
a++;
else
b++;
}
int t = a - b;
if (t < 0) t = -t;
if (k < t) FAIL();
if ((k - t) % 2 == 1) FAIL();
int j = 0;
string SS1 = "", SS2 = "";
while (a < b) {
SS1 += S2[j];
a++;
j++;
}
while (a > b) {
SS2 += S2[j];
b++;
j++;
}
c = 0;
while (j < k) {
if (c == 0) {
SS1 += S2[j];
} else {
SS2 += S2[j];
}
c = (c + 1) % 2;
j++;
}
cout << SS1 << S1 << SS2 << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 2 * acos(0.0);
struct arr {
long long index, val;
};
struct query {
long long n, ind, index, ans;
};
bool compare(arr a1, arr a2) {
if (a1.val == a2.val) return (a1.index < a2.index);
return (a1.val > a2.val);
}
bool compare2(arr a1, arr a2) { return (a1.index < a2.index); }
bool compare1(query q1, query q2) { return (q1.n < q2.n); }
bool compare3(query q1, query q2) { return (q1.index < q2.index); }
int main() {
long long n, i;
cin >> n;
arr A[n];
for (i = 0; i < n; ++i) {
cin >> A[i].val;
A[i].index = i + 1;
}
sort(A, A + n, compare);
long long m;
cin >> m;
query q[m];
for (i = 0; i < m; ++i) {
cin >> q[i].n >> q[i].ind;
q[i].index = i;
}
sort(q, q + m, compare1);
for (i = 0; i < m; ++i) {
if (i != 0) {
if (q[i].n != q[i - 1].n) {
sort(A, A + q[i - 1].n, compare);
sort(A, A + q[i].n, compare2);
q[i].ans = A[q[i].ind - 1].val;
} else
q[i].ans = A[q[i].ind - 1].val;
} else {
sort(A, A + q[i].n, compare2);
q[i].ans = A[q[i].ind - 1].val;
}
}
sort(q, q + m, compare3);
for (i = 0; i < m; ++i) cout << q[i].ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int a[n + 5][m + 5];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> a[i][j];
for (int i = 1; i <= n; ++i) a[i][m + 1] = 1e9;
for (int j = 1; j <= m; ++j) a[n + 1][j] = 1e9;
for (int i = n; i >= 1; --i)
for (int j = m; j >= 1; --j)
if (a[i][j] == 0) a[i][j] = min(a[i + 1][j], a[i][j + 1]) - 1;
bool ok = true;
int sum = 0;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
sum += a[i][j];
ok &= (a[i][j] < a[i + 1][j]) && (a[i][j] < a[i][j + 1]);
}
cout << ((ok) ? sum : -1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string toBin(long long int a) { return bitset<64>(a).to_string(); }
void printArr(int* a, int n) {
for (int i = 0; i < n; i++) printf("%d ", a[i]);
printf("\n");
}
string intToString(long long int a) {
ostringstream temp;
temp << a;
return temp.str();
}
long long int pow(long long int base, long long int exponent) {
long long int result = 1;
while (exponent > 0) {
if (exponent % 2 == 1) result *= base;
exponent = exponent >> 1;
base *= base;
}
return result;
}
long long int powerWithMod(long long int base, long long int exponent,
long long int modulus) {
long long int result = 1;
base %= modulus;
while (exponent > 0) {
if (exponent % 2 == 1) result = (result * base) % modulus;
exponent = exponent >> 1;
base = (base * base) % modulus;
}
return result;
}
int main() {
int n, t;
cin >> n >> t;
vector<int> p(n), tt(n);
for (int i = 0; i < n; i++) cin >> p[i] >> tt[i];
double ans = 0;
vector<double> dp(t + 1, 0);
dp[0] = 1;
for (int i = 0; i < n; i++) {
vector<double> np(t, 0);
for (int j = 0; j < t; j++) {
if (dp[j] < 1e-15) dp[j] = 0;
np[j] = (dp[j] * p[i]) / 100.0;
if (j > 0) np[j] += np[j - 1] * (1.0 - p[i] / 100.0);
if (np[j] < 1e-15) np[j] = 0;
}
double ep = pow(1.0 - p[i] / 100.0, tt[i] - 1);
if (ep < 1e-15) ep = 0;
for (int j = t; j > 0; j--) {
if (j >= tt[i]) {
dp[j] = np[j - 1] - np[j - tt[i]] * ep;
dp[j] += (dp[j - tt[i]] * ep);
} else
dp[j] = np[j - 1];
if (dp[j] < 1e-15) dp[j] = 0;
ans += dp[j];
}
dp[0] = 0;
}
printf("%.9f\n", ans);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct dat {
int a, b, l;
};
int main() {
int n, m, k;
cin >> n >> m >> k;
int mi = 2000000000;
vector<dat> v(m);
for (int i = 0; i < m; i++) {
cin >> v[i].a >> v[i].b >> v[i].l;
}
vector<bool> fl(n + 1, false);
for (int i = 0; i < k; i++) {
int x;
cin >> x;
fl[x] = true;
}
for (int i = 0; i < m; i++) {
if (fl[v[i].a] == false && fl[v[i].b] == true) {
if (v[i].l < mi) {
mi = v[i].l;
}
}
if (fl[v[i].b] == false && fl[v[i].a] == true) {
if (v[i].l < mi) {
mi = v[i].l;
}
}
}
if (mi == 2000000000) {
cout << "-1\n";
} else {
cout << mi << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10000100;
int a[MAXN], b[MAXN], prim[MAXN], x[MAXN], y[MAXN];
void init() {
for (int i = 2; i * i <= MAXN; i++)
if (!prim[i])
for (int j = i; j <= MAXN; j += i) prim[j] = i;
for (int i = 2; i <= MAXN; i++)
if (!prim[i]) prim[i] = i;
}
void fac(int n, int num[], int cnt[]) {
for (int i = 0; i < n; i++)
for (int j = num[i]; j > 1; j /= prim[j]) cnt[prim[j]]++;
}
void solve(int n, int num[], int cnt[]) {
for (int i = 0; i < n; i++) {
int x = 1;
for (int j = num[i]; j > 1; j /= prim[j]) {
if (cnt[prim[j]] > 0)
cnt[prim[j]]--;
else
x *= prim[j];
}
printf("%d%c", x, i == n - 1 ? '\n' : ' ');
}
}
int main() {
int n, m;
init();
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) scanf("%d", &b[i]);
printf("%d %d\n", n, m);
fac(n, a, x), fac(m, b, y);
solve(n, a, y), solve(m, b, x);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, w;
vector<pair<int, int> > ans;
vector<pair<int, pair<int, int> > > v;
int parent[100001];
int rank1[100001];
string s[1000][10];
void make_set(int v) {
parent[v] = v;
rank1[v] = 1;
}
int find_set(int v) {
if (parent[v] == v) {
return v;
}
parent[v] = find_set(parent[v]);
return parent[v];
}
bool set_union(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a == b) {
return true;
}
if (rank1[a] >= rank1[b]) {
parent[b] = a;
rank1[a] = max(rank1[a], rank1[b] + 1);
} else {
parent[a] = b;
rank1[b] = max(rank1[b], rank1[a] + 1);
}
return false;
}
bool used[100000];
vector<int> v1[100000];
void dfs(int u) {
used[u] = true;
for (int j = 0; j < (int)v1[u].size(); j++) {
int h = v1[u][j];
if (!used[h]) {
ans.push_back(make_pair(h, u));
dfs(h);
}
}
}
int main() {
cin >> n >> m >> k >> w;
for (int i = 0; i < k; i++) {
for (int j = 0; j < n; j++) {
cin >> s[i][j];
}
}
for (int i = 1; i <= k; i++) {
v.push_back(make_pair(n * m, make_pair(0, i)));
}
for (int i = 0; i < k; i++) {
for (int j = i + 1; j < k; j++) {
int u = 0;
for (int g = 0; g < n; g++) {
for (int g1 = 0; g1 < m; g1++) {
if (s[i][g][g1] != s[j][g][g1]) {
u++;
}
}
}
v.push_back(make_pair(u * w, make_pair(i + 1, j + 1)));
}
}
for (int j = 0; j <= k; j++) {
make_set(j);
}
sort(v.begin(), v.end());
int sum = 0;
for (int i = 0; i < (int)v.size(); i++) {
int a = v[i].second.first;
int b = v[i].second.second;
if (!set_union(a, b)) {
sum += v[i].first;
v1[a].push_back(b);
v1[b].push_back(a);
}
}
dfs(0);
cout << sum << endl;
for (int i = 0; i < (int)ans.size(); i++) {
cout << ans[i].first << ' ' << ans[i].second << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-11;
int main() {
cout << setiosflags(ios::fixed) << setprecision(10);
int t = 13;
int n;
cin >> n;
if (n == 1)
cout << 1;
else {
int k = 24;
for (int i = 0; i < (n - 2); i++) {
t += k;
k += 12;
}
cout << t;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
int main() {
int n;
cin >> n;
vector<int> deg(n, 0);
vector<vector<int>> tree(n);
int u, v;
for (int i = 0; i < n - 1; i++) {
cin >> u >> v;
u--, v--;
deg[u]++;
deg[v]++;
tree[u].push_back(v);
tree[v].push_back(u);
}
if (n == 3) {
cout << "NO\n";
return 0;
}
for (int i = 0; i < n; i++) {
if (deg[i] == 2) {
cout << "NO\n";
return 0;
}
}
cout << "YES\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int g[101][101];
int cur;
pair<vector<int>, vector<int>> make_try(int cl) {
vector<int> col(m), row(n);
cur = 0;
for (int i = 0; i < n; i++) row[i] = g[i][0] - cl;
for (int i = 1; i < m; i++) col[i] = g[0][i] - row[0];
col[0] = cl;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (row[i] + col[j] != g[i][j]) row[0] = -1;
for (auto it : col) cur += it;
for (auto it : row) cur += it;
return {row, col};
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> g[i][j];
int mn = 1e9;
vector<int> row, col;
for (int col0 = 0; col0 <= 500; col0++) {
auto it = make_try(col0);
for (auto jt : it.first)
if (jt < 0) goto nxt;
for (auto jt : it.second)
if (jt < 0) goto nxt;
if (cur < mn) {
mn = cur;
row = it.first;
col = it.second;
}
nxt:;
}
if (mn == 1e9) {
cout << -1 << endl;
return 0;
}
cout << mn << endl;
for (int i = 0; i < n; i++)
for (int j = 0; j < row[i]; j++) cout << "row " << i + 1 << "\n";
for (int i = 0; i < m; i++)
for (int j = 0; j < col[i]; j++) cout << "col " << i + 1 << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int const INF = 2 * 10e5 + 123;
int simple(int n) {
int i, sq;
if (n % 2 == 0) {
return 0;
}
sq = (int)sqrt(n);
for (i = 3; i <= sq; i++) {
if ((n % i) == 0) {
return 0;
}
}
return 1;
}
long long gcd(long long a, long long b) {
if (a > b) swap(a, b);
if (!a) return b;
return gcd(b % a, a);
}
void solve() {
int n;
cin >> n;
int mn = 1000000000, mx = 0;
for (int j = 0; j < n; ++j) {
int l, r;
cin >> l >> r;
mn = min(mn, r);
mx = max(mx, l);
}
cout << max(0, mx - mn) << '\n';
}
int main() {
int T = 1;
cin >> T;
while (T--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4e5 + 10;
vector<pair<int, int> > ans;
int n, k, d;
int tot;
void dfs(int u, int curd, int maxd) {
if (curd == maxd) return;
for (int i = 1; i <= k - 1 - (curd == 0); ++i) {
if (tot == n) break;
ans.push_back(make_pair(u, ++tot));
dfs(tot, curd + 1, maxd);
}
}
int main() {
scanf("%d %d %d", &n, &d, &k);
if (n - 1 < d || (k == 1 && d > 1)) {
puts("NO");
return 0;
}
for (int i = 1; i <= d; ++i) {
ans.push_back(make_pair(i, i + 1));
}
tot += d + 1;
for (int i = 2; i <= d; ++i) {
dfs(i, 0, min(i - 1, d + 1 - i));
}
if (tot != n)
puts("NO");
else {
puts("YES");
for (vector<pair<int, int> >::size_type i = 0; i < ans.size(); ++i) {
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
const int LOG = 20;
const int cntsz = 101;
const int INF = 1e9;
const int mod = 998244353;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
vector<int> a(n);
long long ans = 0;
for (int i = 0; i < int(n); i++) cin >> a[i];
sort(a.begin(), a.end());
vector<vector<int> > dp(n + 1, vector<int>(k + 1));
for (int x = int(1); x < int(N / (k - 1) + 1); x++) {
dp[0][0] = 1;
int c = 0;
for (int i = 0; i < int(n); i++) {
while (a[i] - a[c] >= x) c++;
for (int j = 0; j < int(k + 1); j++) dp[i + 1][j] = dp[i][j];
for (int j = 0; j < int(k); j++) {
dp[i + 1][j + 1] += dp[c][j];
dp[i + 1][j + 1] %= mod;
}
}
ans += dp[n][k];
ans %= mod;
}
cout << ans << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a[100005], b[100005];
cin >> n;
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
a[i] = b[i] = x;
}
sort(b + 1, b + n + 1);
long long int v[100005], u[100005];
v[0] = u[0] = 0;
for (int i = 1; i <= n; i++) {
v[i] = v[i - 1] + a[i];
u[i] = u[i - 1] + b[i];
}
int q;
cin >> q;
while (q--) {
int w, l, r;
cin >> w;
cin >> l >> r;
if (w == 1) {
cout << v[r] - v[l - 1] << endl;
}
if (w == 2) {
cout << u[r] - u[l - 1] << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<pair<int, int> > q;
vector<pair<int, int> > ans;
int a[200200];
int main() {
int x, s, n, step = 0;
cin >> n >> s;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
if (x) q.push(make_pair(x, i));
}
while (!q.empty()) {
vector<pair<int, int> > processed;
pair<int, int> u = q.top();
q.pop();
step++;
for (int i = 0; i < u.first; i++) {
if (q.empty()) {
puts("No");
return 0;
}
pair<int, int> v = q.top();
q.pop();
v.first--;
ans.push_back(make_pair(u.second, v.second));
if (v.first) processed.push_back(v);
}
for (int i = 0; i < int(processed.size()); i++) q.push(processed[i]);
}
cout << "Yes" << endl << s / 2 << endl;
for (int i = 0; i < int(ans.size()); i++)
cout << ans[i].first << ' ' << ans[i].second << endl;
}
| 7 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::map;
using std::max;
using std::min;
using std::numeric_limits;
using std::set;
using std::stack;
using std::string;
using std::stringstream;
using std::vector;
using namespace std;
vector<int> DFS(vector<vector<int> >& graph, int start) {
stack<int> st;
vector<int> visited(graph.size(), false);
st.push(start);
while (st.size() > 0) {
int cur = st.top();
st.pop();
if (!visited[cur]) {
visited[cur] = true;
for (int i = 0; i < graph[cur].size(); ++i) {
st.push(graph[cur][i]);
}
}
}
return visited;
}
long long gcd(long long a, long long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
int num_bit(long long v) {
int ret = 0;
while (v != 0) {
ret += 1;
v = v >> 1;
}
return ret;
}
int main() {
std::cout.precision(10);
int n;
cin >> n;
set<int> a_set;
for (int i = 0; i < n; ++i) {
int v;
cin >> v;
a_set.insert(v);
}
int res = 0;
vector<int> a(a_set.begin(), a_set.end());
for (int i = 0; i < a.size() - 1; ++i) {
for (int k = 2;; ++k) {
int val = a[i] * k;
int idx = lower_bound(a.begin(), a.end(), val) - a.begin() - 1;
if (idx != i) {
res = max(res, a[idx] % a[i]);
}
if (val >= a.back()) {
break;
}
}
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long double pi = 3.14159265358979323846;
const long long mod = 1e9 + 7;
const long long N = 3e3;
long long n, k, cnt[2];
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
cin >> n >> k;
for (long long i = 1, x; i <= n; cin >> x, ++cnt[x & 1], ++i)
;
if (k == n) {
if (cnt[1] & 1)
cout << "Stannis";
else
cout << "Daenerys";
return 0;
}
long long x = n - k;
if (x / 2 >= cnt[1]) {
cout << "Daenerys";
return 0;
}
if (x & 1) {
if (x / 2 >= cnt[0]) {
if (k & 1)
cout << "Stannis";
else
cout << "Daenerys";
} else
cout << "Stannis";
} else if (x / 2 >= cnt[0]) {
if (k & 1)
cout << "Stannis";
else
cout << "Daenerys";
} else
cout << "Daenerys";
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
int n;
pair<int, int> a[maxn];
int t[maxn << 2];
void update(int now, int l, int r, int first) {
t[now]++;
int m = (l + r) >> 1;
if (l == r) return;
if (first <= m)
update(now * 2, l, m, first);
else
update(now * 2 + 1, m + 1, r, first);
}
int ask(int now, int l, int r, int L, int R) {
if (l > r || L > R) return 0;
if (l == L && r == R) return t[now];
int m = (l + r) >> 1;
return ask(now * 2, l, m, L, min(m, R)) +
ask(now * 2 + 1, m + 1, r, max(m + 1, L), R);
}
int c[maxn];
int main() {
scanf("%d", &n);
long long ans = 0;
for (int i = 1; i <= n; i++)
scanf("%d", &c[i]), a[i].first = min(c[i], n), a[i].second = i;
sort(a + 1, a + n + 1);
int k = 1;
for (int i = 1; i <= n; i++) {
while (k <= a[i].first) update(1, 1, n, c[k]), k++;
ans += 1LL * ask(1, 1, n, a[i].second, n);
if (a[i].second <= a[i].first) ans--;
}
printf("%lld", ans / 2);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool check(long long *a, long long *b, long long n) {
for (int i = 0; i < n; i++)
if (a[i] != b[i]) return false;
return true;
}
int main() {
long long n, m;
cin >> n >> m;
long long a[n], b[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
long long ans = INT_MAX;
sort(a, a + n);
sort(b, b + n);
long long x = 0;
for (int i = 0; i < n; i++) {
x = b[0] - a[i];
if (x < 0) x += m;
long long c[n];
for (int j = 0; j < n; j++) c[j] = (a[j] + x) % m;
sort(c, c + n);
if (check(c, b, n)) ans = min(ans, x);
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a[100005], cnt = 0, i, j, k, t, res = 0, cnt1 = 0, cnt2 = 0;
cin >> n >> k;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) {
if (a[i] <= k) {
cnt1++;
} else {
t = a[i] / (2 * k);
if (t == 0)
cnt2++;
else {
cnt2 = cnt2 + a[i] / (2 * k);
t = a[i] % (2 * k);
if (t != 0) {
if (t <= k)
cnt1++;
else
cnt2++;
}
}
}
}
res = cnt2 + (cnt1 + 1) / 2;
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400 + 10;
vector<int> vec[maxn];
vector<int> car[maxn];
int dist[maxn];
bool check[maxn];
bool way[maxn][maxn];
void BFS(int v) {
int y;
queue<int> q;
q.push(v);
while (!q.empty()) {
y = q.front();
check[y] = true;
for (int i = 0; i < vec[y].size(); i++) {
if (check[vec[y][i]] == false) {
q.push(vec[y][i]);
dist[vec[y][i]] = dist[y] + 1;
check[vec[y][i]] = true;
}
}
q.pop();
}
}
void BFSs(int v) {
int y;
queue<int> q;
q.push(v);
while (!q.empty()) {
y = q.front();
check[y] = true;
for (int i = 0; i < car[y].size(); i++) {
if (check[car[y][i]] == false) {
q.push(car[y][i]);
dist[car[y][i]] = dist[y] + 1;
check[car[y][i]] = true;
}
}
q.pop();
}
}
int main() {
int n, m, a, b;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
way[a][b] = true;
way[b][a] = true;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (way[i][j] && i != j) {
vec[i].push_back(j);
vec[j].push_back(i);
} else if (!way[i][j] && i != j) {
car[i].push_back(j);
car[j].push_back(i);
}
}
}
int maax;
BFS(0);
if (!check[n - 1]) {
cout << "-1";
return 0;
}
maax = dist[n - 1];
for (int i = 0; i < n; i++) {
dist[i] = 0;
check[i] = false;
}
BFSs(0);
if (!check[n - 1]) {
cout << "-1";
return 0;
}
cout << max(maax, dist[n - 1]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T& x) {
x = 0;
T w = 1, ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') w = 0;
for (; isdigit(ch); ch = getchar()) x = (x << 3) + (x << 1) + (ch ^ 48);
x = w ? x : -x;
}
template <class T, class... Args>
inline void read(T& t, Args&... args) {
read(t);
read(args...);
}
const int N = 1e3 + 5;
int n, m;
double g[N][N];
double f(int n, int m) {
if (!n) return 1.0 / (m + 1);
if (!m) return 1.0;
if (g[n][m]) return g[n][m];
long double A = (1.0 - f(m - 1, n)) * m / (m + 1), B = A + 1.0 / (m + 1),
C = 1.0 - f(m, n - 1), D = (C - 1.0) / (A - B + C - 1);
return g[n][m] = D * A + (1.0 - D);
}
int main() {
read(n, m);
printf("%.10lf %.10lf\n", f(n, m), 1.0 - f(n, m));
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 5;
const int maxm = 200000 + 5;
struct Edge {
int from, to, source, vis;
};
int ok[maxn], ans[maxm];
vector<Edge> edges;
vector<int> eff[maxm * 2], G[maxn];
int vis[maxn];
void dfs(int now) {
(void(0));
vis[now] = ok[now] = 1;
for (int i : G[now]) {
Edge& e = edges[i];
if (e.vis) continue;
e.vis = 1;
int to = e.from == now ? e.to : e.from, forans = e.from == now ? 0 : 1;
ans[e.source] = forans;
(void(0));
if (vis[to]) continue;
dfs(to);
}
}
vector<int> cycle;
int find_cycle(int now) {
(void(0));
vis[now] = 1;
for (int i : G[now]) {
Edge& e = edges[i];
if (e.vis) continue;
e.vis = 1;
int to = e.from == now ? e.to : e.from, forans = e.from == now ? 0 : 1;
(void(0));
if (vis[to]) {
cycle.push_back(to);
cycle.push_back(now);
ok[now] = 1;
ans[e.source] = forans;
(void(0));
return 2;
}
int res = find_cycle(to);
if (res == 2) {
cycle.push_back(now);
ok[now] = 1;
ans[e.source] = forans;
(void(0));
if (now == cycle[0]) return 1;
return 2;
} else if (res == 1) {
vis[now] = 0;
e.vis = 0;
return 1;
}
e.vis = 0;
}
vis[now] = 0;
return 0;
}
inline void AddEdge(int from, int to, int source) {
(void(0));
edges.push_back((Edge){from, to, source, 0});
G[from].push_back(edges.size() - 1);
G[to].push_back(edges.size() - 1);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0, cnt; i < n; i++) {
scanf("%d", &cnt);
for (int j = 0, x; j < cnt; j++) {
scanf("%d", &x);
if (x < 0)
eff[(-x - 1) * 2 + 1].push_back(i);
else
eff[(x - 1) * 2].push_back(i);
}
}
for (int i = 0; i < m; i++) {
if (eff[i * 2 + 1].size() == 0) {
ans[i] = 1;
for (int j : eff[i * 2]) ok[j] = 1;
(void(0));
} else if (eff[i * 2].size() == 0) {
ans[i] = 0;
for (int j : eff[i * 2 + 1]) ok[j] = 1;
(void(0));
} else
AddEdge(eff[i * 2][0], eff[i * 2 + 1][0], i);
}
for (int i = 0; i < n; i++)
if (ok[i] && !vis[i]) dfs(i);
for (int i = 0; i < n; i++)
if (!vis[i]) {
cycle.clear();
if (!find_cycle(i)) {
printf("NO\n");
return 0;
}
for (int now : cycle) {
(void(0));
dfs(now);
}
}
for (int i = 0; i < n; i++)
if (!ok[i]) {
printf("NO\n");
return 0;
}
printf("YES\n");
for (int i = 0; i < m; i++) printf("%d", ans[i]);
puts("");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
long long x, y;
Point() {}
Point(long long _x, long long _y) : x(_x), y(_y) {}
friend bool operator==(Point a, Point b) { return a.x == b.x && a.y == b.y; }
friend Point operator-(Point a, Point b) {
return Point(a.x - b.x, a.y - b.y);
}
friend Point operator+(Point a, Point b) {
return Point(a.x + b.x, a.y + b.y);
}
friend Point operator*(Point a, long long t) {
return Point(a.x * t, a.y * t);
}
friend Point operator/(Point a, long long t) {
return Point(a.x / t, a.y / t);
}
void rd() {
scanf("%I64d%I64d", &x, &y);
x *= 5;
y *= 5;
}
void od() { cout << x << " " << y << endl; }
void Od() { cout << x / 5 << " " << y / 5 << " "; }
};
long long det(Point a, Point b) { return a.x * b.y - a.y * b.x; }
long long det(Point a, Point b, Point o) { return det(a - o, b - o); }
long long dis2(Point a) { return a.x * a.x + a.y * a.y; }
long long dis2(Point a, Point b) { return dis2(a - b); }
long long dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
long long dot(Point a, Point b, Point o) { return dot(a - o, b - o); }
long long dcmp(long long x) {
if (x == 0) return 0;
return x > 0 ? 1 : -1;
}
bool seg(Point a, Point b, Point c, Point d) {
long long d1 = dcmp(det(a, b, c));
long long d2 = dcmp(det(a, b, d));
long long d3 = dcmp(det(c, d, a));
long long d4 = dcmp(det(c, d, b));
if (d1 * d2 < 0 && d3 * d4 < 0)
return true;
else if (d1 == 0 && dot(a, b, c) <= 0)
return true;
else if (d2 == 0 && dot(a, b, d) <= 0)
return true;
else if (d3 == 0 && dot(c, d, a) <= 0)
return true;
else if (d4 == 0 && dot(c, d, b) <= 0)
return true;
return false;
}
bool ok(Point a, Point b, Point c) {
Point lx = (a * 4 + b) / 5;
Point rx = (a + b * 4) / 5;
if (det(lx, rx, c) == 0 && dot(lx, rx, c) <= 0) return true;
return false;
}
bool cc(Point a[2], Point b[2], Point c[2]) {
if (a[0] == b[1] || a[1] == b[1]) swap(b[0], b[1]);
if (a[1] == b[0]) swap(a[0], a[1]);
if (!(a[0] == b[0])) return false;
if (det(a[1], b[1], a[0]) == 0) return false;
if (dis2(a[0], a[1]) + dis2(a[0], b[1]) < dis2(a[1], b[1])) return false;
return ok(a[0], a[1], c[0]) && ok(b[0], b[1], c[1]);
}
int main() {
int ncase;
scanf("%d", &ncase);
Point a[2], b[2], c[2];
while (ncase--) {
a[0].rd();
a[1].rd();
b[0].rd();
b[1].rd();
c[0].rd();
c[1].rd();
a[1] = a[1] - a[0];
b[0] = b[0] - a[0];
b[1] = b[1] - a[0];
c[0] = c[0] - a[0];
c[1] = c[1] - a[0];
a[0] = a[0] - a[0];
if (cc(a, b, c) || cc(a, c, b) || cc(b, c, a))
puts("YES");
else if (cc(b, a, c) || cc(c, a, b) || cc(c, b, a))
puts("YES");
else
puts("NO");
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
void readv(vector<long long> &a, long long n) {
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
a.push_back(x);
}
}
void outv(vector<long long> &a, long long n) {
for (int i = 0; i < n; i++) {
if (i > 0) cout << " ";
cout << a[i];
}
cout << "\n";
}
long long po(long long x, long long y) {
long long res = 1;
for (; y; y >>= 1) {
if (y & 1) res = res * x % 1000000007;
x = x * x % 1000000007;
}
return res;
}
long long gcd(long long a, long long b) { return (b ? gcd(b, a % b) : a); }
long long fac[200010], inv[200010], ivf[200010];
void initfac() {
fac[0] = ivf[0] = inv[1] = 1;
for (long long i = 1; i < 200010; i++) fac[i] = fac[i - 1] * i % 1000000007;
for (long long i = 1; i < 200010; i++) {
if (i > 1)
inv[i] =
(1000000007 - 1000000007 / i * inv[1000000007 % i] % 1000000007) %
1000000007;
ivf[i] = po(fac[i], 1000000007 - 2);
}
}
long long P(long long n, long long k) {
if (n < 0 || n < k) return 0;
return fac[n] * ivf[n - k] % 1000000007;
}
long long C(long long n, long long k) {
if (k < 0 || n < k) return 0;
return fac[n] * ivf[n - k] % 1000000007 * ivf[k] % 1000000007;
}
long long H(long long n, long long k) { return C(n + k - 1, k); }
long long n, k;
long long ans[1010][1010];
void solve(long long d, long long l, long long r) {
long long m = r - l + 1;
if (m <= 1) return;
vector<long long> cnt;
for (int i = 0; i < k; i++) cnt.push_back(0);
vector<long long> id;
for (int i = 0; i < m; i++) id.push_back(-1);
long long kk = 1;
while (m > kk) {
kk *= k;
}
kk /= k;
long long rem = m;
for (int i = 0; i < k; i++) {
cnt[i] = min(kk, rem);
rem -= cnt[i];
}
long long j = 0;
long long L = 0;
for (int i = 0; i < m; i++) {
id[i] = j;
cnt[j]--;
if (cnt[j] == 0) {
solve(d + 1, l + L, l + i);
L = i + 1;
j++;
}
}
for (int i = 0; i < m; i++) {
for (int j = i + 1; j < m; j++) {
if (id[i] != id[j]) ans[i + l][j + l] = d;
}
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
cin >> n >> k;
solve(1, 0, n - 1);
long long ma = 0;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) ma = max(ma, ans[i][j]);
cout << ma << endl;
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++) {
if (i == 0 && j == 1)
;
else
cout << " ";
cout << ans[i][j];
}
cout << endl;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
#define Int int
#define CT cin>>T;
#define endll "\n"
#pragma GCC optimize(1)
#pragma GCC optimize(2)
#pragma GCC optimize(3,"Ofast","inline")
#define rep(i,b) for(int i=0;i<b;i++)
#define For(i,a,b) for(int i=a;i<b;i++)
#define Rof(i,a,b) for(int i=a;i>b;i--)
#define rest(a, b) memset(a,b, sizeof(a));
#define IOS ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
//intt gcd(intt a, intt b) {while (b ^= a ^= b ^= a %= b);return a;}
//ll gcd(ll a, ll b) {while (b ^= a ^= b ^= a %= b);return a;}
const int inf = 0x3f3f3f3f;
const int mod = 1e9+7;
const int N=1e6+10;
const int maxn=1e9;
/*struct node{ll x,y;}num[N];
bool cmp(node a,node b){return a.y<b.y;}
bool cmp1(node a,node b){return a.x<b.x;}*/
int T,n,m;
int k,x,y,z,v,h,l,r,ans,cnt,sum;
double avg;
string s,s1,s2;
int a[N],b[N];
int vis[N];
int num[30]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26};
void cf() {
cin>>n>>m;
cin>>s;
v=1;
a[0]=0;
rep(i,n){
a[v++]+=a[v-1]+num[s[i]-'a'];
//cout<<a[v-1]<<" ";
}
//cout<<endll;
rep(i,m){
cin>>l>>r;
ans=a[r]-a[l-1];
cout<<ans<<endll;
}
}
signed main(){
IOS;
T=1;
while (T--){
cf();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 100000 + 5, M = 100000;
struct segm {
long long x1, y1, x2, y2;
};
struct coord {
long long x, y;
};
segm sg[N];
long long direction[N];
long long tx, ty;
long long sx[N];
long long sy[N];
bool cmpx(const long long &left, const long long &right) {
if (sg[left].x1 < sg[right].x1) return true;
if (sg[left].x1 > sg[right].x1) return false;
return (sg[left].y1 < sg[right].y1);
}
bool cmpy(const long long &left, const long long &right) {
if (sg[left].y1 < sg[right].y1) return true;
if (sg[left].y1 > sg[right].y1) return false;
return (sg[left].x1 < sg[right].x1);
}
long long t[4 * N];
long long top;
coord po[4 * N];
long long re[2 * N];
long long d1[4 * N];
long long get(long long x, long long y, long long di) {
long long res = 0;
long long s, f, md;
if (di % 2 != 0) {
if (di == 1) {
s = 1;
f = ty;
while (s <= f) {
md = (s + f) / 2;
if (sg[sy[md]].y1 < y) {
s = md + 1;
} else if (sg[sy[md]].y1 > y) {
f = md - 1;
} else {
if (sg[sy[md]].x2 < x) {
s = md + 1;
} else {
res = sy[md];
f = md - 1;
}
}
}
} else {
s = 1;
f = ty;
while (s <= f) {
md = (s + f) / 2;
if (sg[sy[md]].y1 < y) {
s = md + 1;
} else if (sg[sy[md]].y1 > y) {
f = md - 1;
} else {
if (sg[sy[md]].x1 > x) {
f = md - 1;
} else {
res = sy[md];
s = md + 1;
}
}
}
}
} else {
if (di == 2) {
s = 1;
f = tx;
while (s <= f) {
md = (s + f) / 2;
if (sg[sx[md]].x1 < x) {
s = md + 1;
} else if (sg[sx[md]].x1 > x) {
f = md - 1;
} else {
if (sg[sx[md]].y2 < y) {
s = md + 1;
} else {
res = sx[md];
f = md - 1;
}
}
}
} else {
s = 1;
f = tx;
while (s <= f) {
md = (s + f) / 2;
if (sg[sx[md]].x1 < x) {
s = md + 1;
} else if (sg[sx[md]].x1 > x) {
f = md - 1;
} else {
if (sg[sx[md]].y1 > y) {
f = md - 1;
} else {
res = sx[md];
s = md + 1;
}
}
}
}
}
return res;
}
coord a[N];
char ch[N][5];
long long ti[N];
long long in[2 * N];
long long top1, T, te, n, b, i;
long long f;
long long ab(long long x) {
if (x < 0) return -x;
return x;
}
bool cmp1(const long long &l, const long long &r) {
return (po[l].x < po[r].x);
}
bool cmp2(const long long &l, const long long &r) {
return (po[l].y < po[r].y);
}
void update(long long v, long long tl, long long tr, long long l, long long r,
long long co) {
long long tm;
if (tl == l && tr == r) {
t[v] = co;
return;
}
if (t[v] != -1) {
t[2 * v] = t[v];
t[2 * v + 1] = t[v];
t[v] = -1;
}
tm = (tl + tr) / 2;
if (r <= tm)
update(2 * v, tl, tm, l, r, co);
else if (l > tm)
update(2 * v + 1, tm + 1, tr, l, r, co);
else {
update(2 * v, tl, tm, l, tm, co);
update(2 * v + 1, tm + 1, tr, tm + 1, r, co);
}
}
long long getans(long long v, long long tl, long long tr, long long pos) {
long long tm;
if (tl == tr) return t[v];
if (t[v] != -1) {
t[2 * v] = t[v];
t[2 * v + 1] = t[v];
t[v] = -1;
}
tm = (tl + tr) / 2;
if (pos <= tm) return getans(2 * v, tl, tm, pos);
return getans(2 * v + 1, tm + 1, tr, pos);
}
void build() {
for (i = 1; i <= 4 * (M + 1); ++i) {
t[i] = 0;
}
top1 = 0;
for (i = 1; i <= top; ++i) {
if (d1[i] == 1) {
++top1;
in[top1] = i;
}
}
sort(in + 1, in + top1 + 1, cmp1);
f = top1;
for (i = tx; i >= 1; --i) {
update(1, 0, M, sg[sx[i]].y1, sg[sx[i]].y2, sx[i]);
if (sg[sx[i]].x1 != sg[sx[i - 1]].x1) {
while (f > 0) {
if (po[in[f]].x > sg[sx[i - 1]].x1) {
if (po[in[f]].x <= sg[sx[i]].x1) {
re[in[f]] = getans(1, 0, M, po[in[f]].y);
}
--f;
} else
break;
}
}
}
for (i = 1; i <= 4 * (M + 1); ++i) {
t[i] = 0;
}
top1 = 0;
for (i = 1; i <= top; ++i) {
if (d1[i] == 3) {
++top1;
in[top1] = i;
}
}
sort(in + 1, in + top1 + 1, cmp1);
f = 1;
for (i = 1; i <= tx; ++i) {
update(1, 0, M, sg[sx[i]].y1, sg[sx[i]].y2, sx[i]);
if (sg[sx[i]].x1 != sg[sx[i + 1]].x1) {
while (f <= top1) {
if (po[in[f]].x < sg[sx[i + 1]].x1) {
if (po[in[f]].x >= sg[sx[i]].x1) {
re[in[f]] = getans(1, 0, M, po[in[f]].y);
}
++f;
} else
break;
}
}
}
for (i = 1; i <= 4 * (M + 1); ++i) {
t[i] = 0;
}
top1 = 0;
for (i = 1; i <= top; ++i) {
if (d1[i] == 4) {
++top1;
in[top1] = i;
}
}
sort(in + 1, in + top1 + 1, cmp2);
f = 1;
for (i = 1; i <= ty; ++i) {
update(1, 0, M, sg[sy[i]].x1, sg[sy[i]].x2, sy[i]);
if (sg[sy[i]].y1 != sg[sy[i + 1]].y1) {
while (f <= top1) {
if (po[in[f]].y < sg[sy[i + 1]].y1) {
if (po[in[f]].y >= sg[sy[i]].y1) {
re[in[f]] = getans(1, 0, M, po[in[f]].x);
}
++f;
} else
break;
}
}
}
for (i = 1; i <= 4 * (M + 1); ++i) {
t[i] = 0;
}
top1 = 0;
for (i = 1; i <= top; ++i) {
if (d1[i] == 2) {
++top1;
in[top1] = i;
}
}
sort(in + 1, in + top1 + 1, cmp2);
f = top1;
for (i = ty; i >= 1; --i) {
update(1, 0, M, sg[sy[i]].x1, sg[sy[i]].x2, sy[i]);
if (sg[sy[i]].y1 != sg[sy[i - 1]].y1) {
while (f > 0) {
if (po[in[f]].y > sg[sy[i - 1]].y1) {
if (po[in[f]].y <= sg[sy[i]].y1) {
re[in[f]] = getans(1, 0, M, po[in[f]].x);
}
--f;
} else
break;
}
}
}
}
long long dx[10] = {0, 1, 0, -1, 0};
long long dy[10] = {0, 0, 1, 0, -1};
long long top2;
coord graph[4 * N];
void buildgraph() {
long long res1;
for (i = 1; i <= top; ++i) {
if (i <= n) {
res1 = get(po[i].x + dx[d1[i]], po[i].y + dy[d1[i]], d1[i]);
} else {
res1 = get(po[i].x, po[i].y, d1[i]);
}
if (res1 != 0) {
if (re[i] == 0) {
re[i] = res1;
} else {
if (d1[i] == 1) {
if (sg[res1].x1 < sg[re[i]].x1) re[i] = res1;
}
if (d1[i] == 2) {
if (sg[res1].y1 < sg[re[i]].y1) re[i] = res1;
}
if (d1[i] == 3) {
if (sg[res1].x2 > sg[re[i]].x2) re[i] = res1;
}
if (d1[i] == 4) {
if (sg[res1].y2 > sg[re[i]].y2) re[i] = res1;
}
}
}
}
top2 = top;
for (i = 1; i <= top2; ++i) {
if (re[i] != 0) {
if (d1[re[i]] % 2 == d1[i] % 2) {
if (d1[i] % 2 == 1) {
if (po[i].x <= po[re[i]].x)
d1[i] = 1;
else
d1[i] = 3;
} else {
if (po[i].y <= po[re[i]].y)
d1[i] = 2;
else
d1[i] = 4;
}
graph[i].x = re[i];
if (d1[re[i]] % 2 == 1)
graph[i].y = ab(po[i].x - po[re[i]].x);
else
graph[i].y = ab(po[i].y - po[re[i]].y);
} else {
++top;
graph[i].x = top;
graph[top].x = re[i];
d1[top] = d1[re[i]];
if (d1[i] % 2 == 1) {
graph[i].y = ab(po[i].x - po[re[i]].x);
graph[top].y = ab(po[i].y - po[re[i]].y);
po[top].x = po[re[i]].x;
po[top].y = po[i].y;
} else {
graph[i].y = ab(po[i].y - po[re[i]].y);
graph[top].y = ab(po[i].x - po[re[i]].x);
po[top].y = po[re[i]].y;
po[top].x = po[i].x;
}
}
} else {
if (d1[i] == 1) {
if (po[i].x != b) {
++top;
graph[i].x = top;
graph[i].y = b - po[i].x;
po[top].x = b;
po[top].y = po[i].y;
}
}
if (d1[i] == 2) {
if (po[i].y != b) {
++top;
graph[i].x = top;
graph[i].y = b - po[i].y;
po[top].x = po[i].x;
po[top].y = b;
}
}
if (d1[i] == 3) {
if (po[i].x != 0) {
++top;
graph[i].x = top;
graph[i].y = po[i].x;
po[top].x = 0;
po[top].y = po[i].y;
}
}
if (d1[i] == 4) {
if (po[i].y != 0) {
++top;
graph[i].x = top;
graph[i].y = po[i].y;
po[top].x = po[i].x;
po[top].y = 0;
}
}
}
}
}
void read() {
cin >> n >> b;
for (i = 1; i <= n; ++i) {
cin >> sg[i].x1 >> sg[i].y1 >> sg[i].x2 >> sg[i].y2;
}
cin >> T;
for (i = 1; i <= T; ++i) {
cin >> a[i].x >> a[i].y >> ch[i] >> ti[i];
}
}
long long cs, cf, L;
long long ro[4 * N];
long long cyer[4 * N], qcy;
long long cr, roo, ver, mar[4 * N];
long long top3, st[4 * N];
coord p[4 * N][20];
long long cy[4 * N];
long long qc[4 * N];
coord *dp[4 * N];
void dfs(long long v) {
while (1) {
++top3;
st[top3] = v;
mar[v] = cr;
if (graph[v].x == 0) break;
if (mar[graph[v].x] != 0) {
if (mar[graph[v].x] == cr) {
cs = graph[v].x;
break;
} else
break;
}
v = graph[v].x;
}
}
void markn(long long v) {
long long i;
while (1) {
--top3;
for (i = 0; i <= L; ++i) {
p[v][i].x = v;
p[v][i].y = 0;
}
mar[v] = -mar[v];
cy[v] = qc[cr];
++qc[cr];
if (mar[graph[v].x] < 0) {
break;
}
v = graph[v].x;
}
}
void makedp(long long v) {
long long i;
while (1) {
dp[cr][cy[v]].x = v;
dp[cr][cy[v] + qc[cr]].x = v;
v = graph[v].x;
if (cy[v] == 0) break;
}
dp[cr][0].y = 0;
for (i = 1; i < 2 * qc[cr]; ++i) {
dp[cr][i].y = dp[cr][i - 1].y + graph[dp[cr][i - 1].x].y;
}
cyer[cr] = dp[cr][qc[cr]].y;
}
void rootn() {
long long v, j, i;
for (i = top3; i >= 1; --i) {
v = st[i];
if (graph[v].x != 0)
p[v][0].x = graph[v].x;
else
p[v][0].x = v;
p[v][0].y = graph[v].y;
for (j = 1; j <= L; ++j) {
p[v][j].x = p[p[v][j - 1].x][j - 1].x;
p[v][j].y = p[p[v][j - 1].x][j - 1].y + p[v][j - 1].y;
}
}
}
long long t1;
long long rex[N], rey[N];
void solution() {
long long v, j, as = 1;
L = 0;
while (as < top) {
as = as * 2;
++L;
}
for (i = 1; i <= top; ++i) {
if (mar[i] == 0) {
top3 = 0;
cs = 0;
++cr;
dfs(i);
if (cs != 0) {
qc[cr] = 0;
qcy = cr;
markn(cs);
dp[cr] = new coord[2 * qc[cr]];
makedp(cs);
}
rootn();
}
}
for (i = n + 1; i <= n + T; ++i) {
t1 = ti[i - n];
if (p[i][L].y >= t1) {
v = i;
for (j = L; j >= 0; --j) {
if (p[v][j].y <= t1) {
t1 = t1 - p[v][j].y;
v = p[v][j].x;
}
}
if (t1 != 0) {
if (d1[v] == 1) {
rex[i - n] = po[v].x + t1;
rey[i - n] = po[v].y;
}
if (d1[v] == 2) {
rex[i - n] = po[v].x;
rey[i - n] = po[v].y + t1;
}
if (d1[v] == 3) {
rex[i - n] = po[v].x - t1;
rey[i - n] = po[v].y;
}
if (d1[v] == 4) {
rex[i - n] = po[v].x;
rey[i - n] = po[v].y - t1;
}
} else {
rex[i - n] = po[v].x;
rey[i - n] = po[v].y;
}
} else {
if (mar[p[i][L].x] < 0) {
t1 = t1 - p[i][L].y;
cr = ab(mar[p[i][L].x]);
v = cy[p[i][L].x];
t1 = t1 % cyer[cr];
long long s, f, md, re;
s = v;
f = 2 * qc[cr] - 1;
re = v;
while (s <= f) {
md = (s + f) / 2;
if (dp[cr][md].y - dp[cr][v].y <= t1) {
s = md + 1;
re = md;
} else {
f = md - 1;
}
}
t1 = t1 - (dp[cr][re].y - dp[cr][v].y);
v = dp[cr][re].x;
if (t1 == 0) {
rex[i - n] = po[v].x;
rey[i - n] = po[v].y;
} else {
if (d1[v] == 1) {
rex[i - n] = po[v].x + t1;
rey[i - n] = po[v].y;
}
if (d1[v] == 2) {
rex[i - n] = po[v].x;
rey[i - n] = po[v].y + t1;
}
if (d1[v] == 3) {
rex[i - n] = po[v].x - t1;
rey[i - n] = po[v].y;
}
if (d1[v] == 4) {
rex[i - n] = po[v].x;
rey[i - n] = po[v].y - t1;
}
}
} else {
rex[i - n] = po[p[i][L].x].x;
rey[i - n] = po[p[i][L].x].y;
}
}
}
for (i = 1; i <= T; ++i) {
cout << rex[i] << " " << rey[i] << endl;
}
}
long long X;
long long u, v;
long long mark[2000][2000];
void testgen() {}
long long res1[N];
int pr;
void checker();
int main() {
long long tst = 0, check = 0, inp = 0;
srand(time(NULL));
ios_base::sync_with_stdio(false);
if (inp) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
sg[0].x1 = -1;
sg[0].y1 = -1;
sg[0].x2 = 0;
sg[0].y2 = -1;
if (tst) {
testgen();
} else {
read();
}
sg[n + 1].x1 = M + 1;
sg[n + 1].y1 = M + 1;
sg[n + 1].x2 = M + 1;
sg[n + 1].y2 = M + 1;
for (i = 1; i <= n; ++i) {
++top;
po[top].x = sg[i].x2;
po[top].y = sg[i].y2;
if (sg[i].x1 == sg[i].x2) {
++tx;
sx[tx] = i;
if (sg[i].y1 < sg[i].y2)
d1[top] = 2;
else {
d1[top] = 4;
swap(sg[i].y1, sg[i].y2);
}
} else {
++ty;
sy[ty] = i;
if (sg[i].x1 < sg[i].x2)
d1[top] = 1;
else {
d1[top] = 3;
swap(sg[i].x1, sg[i].x2);
}
}
}
sort(sx + 1, sx + tx + 1, cmpx);
sort(sy + 1, sy + ty + 1, cmpy);
sx[tx + 1] = n + 1;
sy[ty + 1] = n + 1;
for (i = 1; i <= T; ++i) {
++top;
po[top].x = a[i].x;
po[top].y = a[i].y;
if (ch[i][0] == 'R') d1[top] = 1;
if (ch[i][0] == 'U') d1[top] = 2;
if (ch[i][0] == 'L') d1[top] = 3;
if (ch[i][0] == 'D') d1[top] = 4;
}
build();
buildgraph();
solution();
if (check) checker();
return 0;
}
void checker() {
long long j, de, d0, nx, ny;
X = b;
for (i = 1; i <= n; ++i) {
for (u = sg[i].x1; u <= sg[i].x2; ++u) {
for (v = sg[i].y1; v <= sg[i].y2; ++v) {
mark[u][v] = i;
}
}
}
i = n + T;
u = po[i].x;
v = po[i].y;
if (ch[i - n][0] == 'R') d0 = 1;
if (ch[i - n][0] == 'U') d0 = 2;
if (ch[i - n][0] == 'L') d0 = 3;
if (ch[i - n][0] == 'D') d0 = 4;
for (j = 1; j <= ti[i - n]; ++j) {
if (mark[u][v] != 0) {
d0 = d1[mark[u][v]];
}
nx = u + dx[d0];
ny = v + dy[d0];
if (nx <= X && nx >= 0 && ny <= X && ny >= 0) {
u = nx;
v = ny;
}
if (u != rex[j] || v != rey[j]) {
cout << "WA\n"
<< " " << j << "|" << u << " " << v << "[" << rex[j] << " " << rey[j]
<< endl;
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
const int maxn = 3e6 + 10, mod = 998244353;
int Pow(int x, int p) {
int r = 1;
while (p) {
if (p & 1) r = 1LL * x * r % mod;
x = 1LL * x * x % mod;
p >>= 1;
}
return r;
}
int rev[maxn], g[maxn], inv;
void init(int len) {
int z = __builtin_ctz(len);
for (int i = 0; i < len; ++i)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << z - 1);
int G = Pow(3, (mod - 1) / len);
g[0] = 1;
for (int i = 1; i <= len; ++i) g[i] = 1LL * g[i - 1] * G % mod;
inv = Pow(len, mod - 2);
}
void DFT(int *a, int len, int fg) {
for (int i = 0; i < len; ++i)
if (rev[i] > i) swap(a[rev[i]], a[i]);
for (int i = 2; i <= len; i <<= 1)
for (int j = 0; j < len; j += i)
for (int k = 0; k < (i >> 1); ++k) {
int y = 1LL * (fg ? g[len / i * k] : g[len - len / i * k]) *
a[j + k + (i >> 1)] % mod;
int x = a[j + k];
a[j + k] = (x + y) % mod;
a[j + k + (i >> 1)] = (x - y) % mod;
}
if (!fg)
for (int i = 0; i < len; ++i) a[i] = 1LL * a[i] * inv % mod;
}
int a[maxn], A[maxn], ans[maxn];
int main() {
int n = read(), m = read();
for (int i = 1; i <= n; ++i) {
int x = read();
a[x]++;
A[x]++;
}
a[0] = 1;
int len = 1;
while (len <= m + m) len <<= 1;
init(len);
DFT(a, len, 1);
for (int i = 0; i < len; ++i) a[i] = 1LL * a[i] * a[i] % mod;
DFT(a, len, 0);
for (int i = 0; i < len; ++i) a[i] = (a[i] + mod) % mod;
int tot = 0;
int fg = 1;
for (int i = 1; i <= m; ++i)
if (A[i] && a[i] == 2)
ans[++tot] = i;
else if (!A[i] && a[i])
fg = 0;
if (!fg) {
printf("NO\n");
return 0;
}
printf("YES\n");
cout << tot << endl;
for (int i = 1; i <= tot; ++i) printf("%d ", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5 * 1e6;
const int INF = 2147483647;
string x;
int t;
char ch;
map<long long, int> sum;
bool bit(int x, int i) { return (x & (1 << i)); }
void s(bool add) {
long long num = 0, pw = 1;
for (int i = x.length() - 1; i >= 0; i--) {
if (int(x[i] - 48) % 2 != 0) {
num = num + pw;
}
pw = pw * 2;
}
if (add)
sum[num]++;
else
sum[num]--;
}
void out() {
long long num = 0, pw = 1;
for (int i = x.length() - 1; i >= 0; i--) {
if (x[i] == '1') {
num = num + pw;
}
pw = pw * 2;
}
cout << sum[num] << "\n";
}
int main() {
scanf("%d\n", &t);
for (int i = 1; i <= t; i++) {
cin >> ch;
if (ch == '+' || ch == '-') {
cin >> x;
s(ch == '+');
} else {
cin >> x;
out();
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
int n, ans;
vector<int> adj[N], vec;
void dfs(int u = 1, int par = -1, int d = 0) {
for (int v : adj[u])
if (v ^ par) {
dfs(v, u, d + 1);
if (u == 1) {
sort(vec.rbegin(), vec.rend());
for (int i = 0; i < vec.size(); i++) ans = max(ans, vec[i] + i);
vec.clear();
}
}
if (adj[u].size() == 1 && u ^ 1) vec.push_back(d);
}
int main() {
cin >> n;
for (int i = 0, u, v; i < n - 1; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs();
cout << ans << endl;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, u, v, ans;
int d[N], p[N];
bool vis[N];
int cnt, head[N];
struct edge {
int next, to;
} e[N << 1];
inline void add(int u, int v) {
cnt++;
e[cnt].next = head[u];
e[cnt].to = v;
head[u] = cnt;
}
void dfs(int u, int fa) {
for (register int i = head[u]; i; i = e[i].next)
if (e[i].to != fa) {
p[e[i].to] = u;
d[e[i].to] = d[u] + 1;
dfs(e[i].to, u);
}
}
struct node {
int id, d;
inline bool operator<(const node &x) const { return x.d > d; }
};
priority_queue<node> q;
int main() {
scanf("%d", &n);
for (register int i = 1; i < n; ++i)
scanf("%d%d", &u, &v), add(u, v), add(v, u);
dfs(1, 0);
for (register int i = 1; i <= n; ++i)
if (d[i] > 2) q.push((node){i, d[i]});
while (q.size()) {
node x = q.top();
q.pop();
u = x.id;
if (vis[u]) continue;
ans++;
u = p[u];
vis[u] = true;
for (register int i = head[u]; i; i = e[i].next) vis[e[i].to] = true;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
struct Tree {
struct Node {
int delta;
int min_depth;
int max_depth;
int max_lv;
int max_rv;
int max_lvr;
static Node Empty() { return Node{0, 0, 0, 0, 0, 0}; }
static Node LeftParenthesis() { return Node{1, 0, 1, 0, 1, 1}; }
static Node RightParenthesis() { return Node{-1, -1, 0, 2, 1, 1}; }
static Node FromCharacter(char ch) {
if (ch == '(')
return LeftParenthesis();
else
return RightParenthesis();
}
Node ShiftHeight(int displacement) const {
return Node{delta + displacement, min_depth + displacement,
max_depth + displacement, max_lv - displacement,
max_rv - displacement, max_lvr};
}
static Node Merge(const Node &lhs, const Node &rhs) {
Node rhs_shifted = rhs.ShiftHeight(lhs.delta);
Node result;
result.delta = rhs_shifted.delta;
result.min_depth = min(lhs.min_depth, rhs_shifted.min_depth);
result.max_depth = max(lhs.max_depth, rhs_shifted.max_depth);
result.max_lv = max({lhs.max_lv, rhs_shifted.max_lv,
lhs.max_depth - 2 * rhs_shifted.min_depth});
result.max_rv = max({lhs.max_rv, rhs_shifted.max_rv,
rhs_shifted.max_depth - 2 * lhs.min_depth});
result.max_lvr = max({lhs.max_lvr, rhs_shifted.max_lvr,
lhs.max_lv + rhs_shifted.max_depth,
rhs_shifted.max_rv + lhs.max_depth});
return result;
}
};
vector<Node> data;
int Base;
Tree(int N) : Base(1) {
while (Base < N + 1) {
Base *= 2;
}
data.resize(Base * 2, Node::Empty());
}
void Replace(int pos, char ch) {
pos += Base;
data[pos] = Node::FromCharacter(ch);
pos /= 2;
while (pos) {
data[pos] = Node::Merge(data[pos * 2], data[pos * 2 + 1]);
pos /= 2;
}
}
int GetMaxPath() const { return data[1].max_lvr; }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int N, Q;
string paren_string;
cin >> N >> Q >> paren_string;
--N;
Tree path_tree(N * 2);
for (int i = 0; i < N * 2; ++i) {
path_tree.Replace(i, paren_string[i]);
}
cout << path_tree.GetMaxPath() << "\n";
for (int query_idx = 0; query_idx < Q; ++query_idx) {
int first_swap, second_swap;
cin >> first_swap >> second_swap;
--first_swap;
--second_swap;
const char next_first = paren_string[second_swap];
const char next_second = paren_string[first_swap];
assert(next_first != next_second);
path_tree.Replace(first_swap, next_first);
paren_string[first_swap] = next_first;
path_tree.Replace(second_swap, next_second);
paren_string[second_swap] = next_second;
cout << path_tree.GetMaxPath() << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> nm(n);
vector<int> idx, nm2;
vector<bool> cek(n + 1, false);
vector<int> ans(n, 0);
for (int i = 0; i < n; i++) {
cin >> nm[i];
if (nm[i] == 0) idx.push_back(i + 1);
cek[nm[i]] = true;
ans[i] = nm[i];
}
for (int i = 1; i <= n; i++)
if (!cek[i]) nm2.push_back(i);
for (int i = 0; i < idx.size() - 1; i++) {
if (nm2[i] == idx[i]) swap(nm2[i], nm2[i + 1]);
}
if (nm2[idx.size() - 1] == idx[idx.size() - 1])
swap(nm2[idx.size() - 1], nm2[idx.size() - 2]);
for (int i = 0; i < idx.size(); i++) ans[idx[i] - 1] = nm2[i];
for (int i = 0; i < n; i++)
(i != n - 1) ? cout << ans[i] << " " : cout << ans[i] << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300110;
const int mod = 1e9 + 9;
int n, m;
int sumv[maxn * 4];
int f1[maxn * 4];
int f2[maxn * 4];
int num[maxn];
int sum[maxn];
int f[maxn];
int addv(int a, int b, int n) {
return ((((long long)f[n + 1] * (long long)b) % mod +
((long long)f[n] * (long long)a) % mod) %
mod +
(mod - b) % mod) %
mod;
}
int get(int a, int b, int n) {
return ((long long)f[n - 1] * (long long)b +
((long long)f[n - 2] * (long long)a) % mod) %
mod;
}
void maintain(int o, int l, int r) {
int lc = o * 2, rc = lc + 1;
sumv[o] = 0;
if (r > l) sumv[o] = (sumv[lc] + sumv[rc]) % mod;
sumv[o] =
((sumv[o] + ((long long)f[r - l + 2] * (long long)(f2[o])) % mod) % mod +
((((long long)f[r - l + 1] * (long long)(f1[o])) % mod +
(mod - f2[o]) % mod) %
mod)) %
mod;
}
void update(int o, int l, int r, int yl, int yr) {
int lc = o * 2, rc = lc + 1;
int m = l + (r - l) / 2;
if (yl <= l && yr >= r) {
f1[o] = (f1[o] + f[l - yl + 1]) % mod;
f2[o] = (f2[o] + f[l - yl + 2]) % mod;
} else {
if (yl <= m) update(lc, l, m, yl, yr);
if (yr > m) update(rc, m + 1, r, yl, yr);
}
maintain(o, l, r);
}
int _sum;
void query(int o, int l, int r, int ql, int qr, int add_f1, int add_f2) {
int lc = o * 2, rc = lc + 1;
int m = l + (r - l) / 2;
if (ql <= l && qr >= r) {
_sum = ((_sum + sumv[o]) % mod + addv(add_f1, add_f2, r - l + 1)) % mod;
} else {
if (ql <= m)
query(lc, l, m, ql, qr, (add_f1 + f1[o]) % mod, (add_f2 + f2[o]) % mod);
if (qr > m)
query(rc, m + 1, r, ql, qr,
get((add_f1 + f1[o]) % mod, (add_f2 + f2[o]) % mod, m + 2 - l),
get((add_f1 + f1[o]) % mod, (add_f2 + f2[o]) % mod, m + 3 - l));
}
}
int main() {
memset(sumv, 0, sizeof(sumv));
memset(f1, 0, sizeof(f1));
memset(f2, 0, sizeof(f2));
f[0] = 0;
f[1] = 1;
f[2] = 1;
for (int i = 3; i < maxn; ++i) f[i] = (f[i - 1] + f[i - 2]) % mod;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%d", &num[i]);
sum[0] = 0;
for (int i = 1; i <= n; ++i) sum[i] = (sum[i - 1] + num[i]) % mod;
int x, y, z;
for (int i = 0; i < m; ++i) {
scanf("%d%d%d", &x, &y, &z);
if (x == 1)
update(1, 1, n, y, z);
else {
_sum = 0;
query(1, 1, n, y, z, 0, 0);
_sum = (_sum + (sum[z] - sum[y - 1] + mod) % mod) % mod;
printf("%d\n", _sum);
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n, m, k;
cin >> n >> m >> k;
long long a[n + 1];
for (long long i = 0; i < n; i++) cin >> a[i];
long long b[m + 1];
for (long long i = 0; i < m; i++) cin >> b[i];
a[n] = 0;
b[m] = 0;
vector<long long> aa;
vector<long long> bb;
long long cnt = 0;
long long id = a[0];
for (long long i = 0; i <= n; i++) {
if (a[i] == id && id == 1) {
cnt++;
}
if (a[i] == 0 && id == 1) {
aa.push_back(cnt);
id = 0;
cnt = 0;
}
if (a[i] == 1 && id == 0) {
id = 1;
cnt = 1;
}
}
cnt = 0;
id = b[0];
for (long long i = 0; i <= m; i++) {
if (b[i] == id && id == 1) {
cnt++;
}
if (b[i] == 0 && id == 1) {
bb.push_back(cnt);
id = 0;
cnt = 0;
}
if (b[i] == 1 && id == 0) {
id = 1;
cnt = 1;
}
}
if (aa.size() == 0 || bb.size() == 0) {
return cout << 0, 0;
}
sort(aa.begin(), aa.end());
sort(bb.begin(), bb.end());
vector<long long> kk;
for (long long i = 1; i * i <= k; i++) {
if (k % i == 0 && i * i != k) {
kk.push_back(i);
kk.push_back(k / i);
}
if (k % i == 0 && i * i == k) {
kk.push_back(i);
}
}
long long ans = 0;
for (long long i = 0; i < kk.size(); i++) {
long long ca = kk[i];
long long cb = k / ca;
if (ca > aa[aa.size() - 1] || cb > bb[bb.size() - 1]) {
continue;
}
long long id = lower_bound(aa.begin(), aa.end(), ca) - aa.begin();
long long cnta = 0;
long long cntb = 0;
for (long long j = id; j < aa.size(); j++) {
cnta += aa[j] - ca + 1;
}
id = lower_bound(bb.begin(), bb.end(), cb) - bb.begin();
for (long long j = id; j < bb.size(); j++) {
cntb += bb[j] - cb + 1;
}
ans += cnta * cntb;
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
static long long mn[100001];
static long long sm[100001];
long long ss;
vector<int> val;
int num;
cin >> num;
sm[0] = 0;
mn[0] = 0;
for (int i = 1; i <= num; ++i) {
cin >> ss;
sm[i] = sm[i - 1] + ss;
val.push_back(ss);
}
sort(val.begin(), val.end());
for (int i = 0; i < val.size(); ++i) mn[i + 1] = val[i] + mn[i];
cin >> num;
int l, r, mo;
for (int i = 1; i <= num; ++i) {
cin >> mo >> l >> r;
if (mo == 1)
cout << (sm[r] - sm[l - 1]) << endl;
else
cout << (mn[r] - mn[l - 1]) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1010;
const int maxm = 100010;
int n, m, ww;
int w[maxn], b[maxn];
vector<int> group[maxn];
int gpsumw[maxn], gpsumb[maxn];
int ppp = 1;
struct edge {
int v, nxt;
} E[maxm * 2];
int p[maxn], eid = 0;
void init() {
memset(p, -1, sizeof p);
memset(gpsumw, 0, sizeof gpsumw);
memset(gpsumb, 0, sizeof gpsumb);
eid = 0;
}
void insert(int u, int v) {
E[eid].v = v;
E[eid].nxt = p[u];
p[u] = eid++;
}
void insert2(int u, int v) {
insert(u, v);
insert(v, u);
}
bool vis[maxn];
void dfs(int u, int index) {
vis[u] = true;
group[index].push_back(u);
gpsumw[index] += w[u];
gpsumb[index] += b[u];
for (int i = p[u]; ~i; i = E[i].nxt) {
int v = E[i].v;
if (!vis[v]) {
dfs(v, index);
}
}
}
int dp[1000 * 1000 + 10];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m >> ww;
for (int i = 1; i <= n; i++) cin >> w[i];
for (int i = 1; i <= n; i++) cin >> b[i];
init();
for (int i = 1; i <= m; i++) {
int u, v;
cin >> u >> v;
insert2(u, v);
}
memset(vis, 0, sizeof vis);
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
dfs(i, ppp++);
}
}
ppp--;
memset(dp, 0, sizeof dp);
for (int i = 1; i <= ppp; i++) {
for (int j = ww; j >= 0; j--) {
if (j >= gpsumw[i]) dp[j] = max(dp[j], dp[j - gpsumw[i]] + gpsumb[i]);
for (int k = 0; k < group[i].size(); k++) {
int vv = group[i][k];
if (j >= w[vv]) dp[j] = max(dp[j], dp[j - w[vv]] + b[vv]);
}
}
}
cout << dp[ww] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char temp[1005];
char s1[1005], s2[1005];
scanf("%s", temp);
char *ptr;
ptr = strtok(temp, ".");
int x = 0;
while (ptr != NULL) {
strcpy(s2, ptr);
if (x == 0) strcpy(s1, s2);
x++;
ptr = strtok(NULL, ".");
}
int len = strlen(s1);
if (s1[len - 1] == '9')
puts("GOTO Vasilisa.");
else {
if (s2[0] >= '5') {
s1[len - 1]++;
puts(s1);
} else
puts(s1);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long x, y;
int id;
bool operator<(const node& b) const {
if (y != b.y)
return y < b.y;
else
return x < b.x;
}
} a[210000], b[210000], c, d[210000];
vector<node> q;
int n, num, last;
int ans[210000];
set<node> s;
int main() {
cin >> n;
for (int i = 1; i <= n; i++)
cin >> a[i].x >> a[i].y, a[i].id = i, d[i] = a[i];
sort(a + 1, a + 1 + n);
for (int i = n; i >= 1; i--)
if (a[i].x > last) last = a[i].x, b[++num] = a[i];
reverse(b + 1, b + 1 + num);
for (int i = 1; i <= num; i++) {
while (q.size() > 1) {
node c = q[q.size() - 1], d = q[q.size() - 2];
if ((c.y - d.y) * d.x * b[i].y * (c.x - b[i].x) <
(b[i].y - c.y) * b[i].x * d.y * (d.x - c.x))
q.pop_back();
else
break;
}
q.push_back(b[i]);
}
num = 0;
for (int i = 0; i < q.size(); i++) s.insert(q[i]);
for (int i = 1; i <= n; i++)
if (s.count(d[i])) printf("%d ", i);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
long long h, n, d;
long long go(long long ch, long long a, long long b, int com) {
long long ans = 0;
long long mid = (a + b - 1) / 2;
;
;
;
if (ch == 1) {
return 0;
}
if (com) {
if (d <= mid) {
return go(ch - 1, a, mid, !com) + 1;
} else {
return go(ch - 1, mid + 1, b, com) + (1ll << (ch - 1));
}
} else {
if (d > mid) {
return go(ch - 1, mid + 1, b, !com) + 1;
} else {
return go(ch - 1, a, mid, com) + (1ll << (ch - 1));
}
}
}
int main() {
cin >> h >> d;
cout << go(h + 1, 1, 1ll << (h), 1) << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
char a[10003] = "#", b[10003] = "#";
int main() {
int d = 1, p = 1;
long long t = 0;
char *A = a, *B = b;
cin >> n >> m >> B + 1;
B[m + 1] = '#';
for (int i = 1; i < n; ++i) {
swap(A, B);
cin >> B + 1;
B[m + 1] = '#';
int l = p, r = p;
if (B[p] == '.') {
++t;
continue;
}
while (B[l] != '.' && A[l] != '#') --l;
while (B[r] != '.' && A[r] != '#') ++r;
if (A[l] == '#' && A[r] == '#') {
t = -1;
break;
}
int ll = p, rr = p;
while (B[p] != '.') {
if (d == 1) {
while (A[rr] == '.' && rr <= r) ++rr;
t += rr - p;
p = rr - 1;
if (B[p] != '.') d = 1 - d;
if (A[rr] == '+') A[rr] = '.';
} else {
while (A[ll] == '.' && ll >= l) --ll;
t += p - ll;
p = ll + 1;
if (B[p] != '.') d = 1 - d;
if (A[ll] == '+') A[ll] = '.';
}
}
}
if (t == -1)
cout << "Never" << endl;
else
cout << t << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << '{';
for (int i = (0), __i = (((int)(vec).size())); i < __i; i++) {
os << vec[i];
if (i + 1 != ((int)(vec).size())) os << ',';
}
os << '}';
return os;
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &par) {
os << '(' << par.first << ',' << par.second << ')';
return os;
}
int gcd(int x, int y) { return y ? gcd(y, x % y) : abs(x); }
template <class T>
T sqr(T x) {
return x * x;
}
bool used[26];
int main() {
ios::sync_with_stdio(false);
int a, b, l, r;
cin >> a >> b >> l >> r;
int cycle = (a + b) * 2;
int rest1 = (l - 1) % cycle;
int rest2 = r % cycle;
if (rest2 == 0) rest2 = cycle;
int cnt = (r - 1) / cycle - (l - 1) / cycle;
rest2 += cnt * cycle;
if (cnt > 1) {
if (a <= b)
cout << a + 1;
else
cout << 2 * a - b;
return 0;
}
int xl = min(b, a - 1);
int yl = a - xl;
int zl = yl;
string x(xl, ' '), y(yl, ' '), z(zl, ' ');
for (int i = (0), __i = (xl); i < __i; i++) x[i] = 'a' + i;
for (int i = (0), __i = (yl); i < __i; i++) y[i] = 'a' + xl + i;
for (int i = (0), __i = (zl); i < __i; i++) z[i] = 'a' + xl + yl + i;
string s = x + y + string(b, ' ') + x + z + string(b, ' ');
s += s;
for (int i = (rest1), __i = (rest2); i < __i; i++)
if (s[i] != ' ') used[s[i] - 'a'] = true;
for (int i = (0), __i = (rest2); i < __i; i++) {
if (s[i] == ' ') {
int j = i - 1;
while (j >= i - yl) {
if (used[s[j] - 'a']) {
s[i] = s[j];
break;
}
j--;
}
if (j < i - yl) {
s[i] = s[i - 1];
if (i >= rest1) used[s[i] - 'a'] = true;
}
}
}
for (int i = (rest1), __i = (rest2); i < __i; i++)
if (s[i] != ' ') used[s[i] - 'a'] = true;
int res = 0;
for (int i = (0), __i = (26); i < __i; i++) res += used[i];
cout << res;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int a = 720720;
int m[20], r[20];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", m + i);
for (int i = 0; i < n; ++i) scanf("%d", r + i);
int ans = 0;
for (int i = 0; i < a; ++i) {
for (int j = 0; j < n; ++j) {
if (i % m[j] == r[j]) {
++ans;
break;
}
}
}
cout << (double)ans / a;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5009;
string s[MAX];
int n, m, b[MAX], ans, a[MAX];
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < m; i++) {
memset(a, 0, sizeof a);
for (int j = 0; j < n; j++)
if (s[j][i] == '1')
b[j]++, a[b[j]]++;
else
b[j] = 0;
for (int i = m; i >= 0; i--) a[i] += a[i + 1], ans = max(ans, a[i] * i);
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[1001];
long long b[2001];
int main() {
long long n, k, p;
cin >> n >> k >> p;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= k; i++) cin >> b[i];
sort(a + 1, a + n + 1);
sort(b + 1, b + k + 1);
long long ans = (long long)2e15 + 1;
for (int i = 1; i <= k - n + 1; i++) {
long long maks = 0;
for (int j = 1; j <= n; j++) {
maks = max(abs(a[j] - b[i + j - 1]) + abs(b[i + j - 1] - p), maks);
}
ans = min(maks, ans);
}
cout << ans;
return 0;
}
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.