solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
namespace imzzy {
class fastin {
private:
int _ch, _f;
public:
inline fastin &operator>>(char &c) {
c = getchar();
return *this;
}
template <typename _Tp>
inline fastin &operator>>(_Tp &_x) {
_x = 0;
while (!isdigit(_ch)) _f |= (_ch == 45), _ch = getchar();
while (isdigit(_ch))
_x = (_x << 1) + (_x << 3) + (_ch ^ 48), _ch = getchar();
_f && (_x = -_x, _f = 0);
return *this;
}
fastin() { _ch = _f = 0; }
} fin;
} // namespace imzzy
using namespace imzzy;
const int maxn = 1004, maxm = 500004;
int nxt[maxn], pre[maxn], p[5];
bool g1[maxn][maxn], g2[maxn][maxn];
std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > ans1, ans2;
inline std::pair<std::pair<int, int>, std::pair<int, int> > rev(
int u, int v, int n, bool g[maxn][maxn]) {
int indx = 0;
for (register int i = 1; i <= n; ++i)
if (g[u][i] && g[v][i]) p[++indx] = i;
g[u][v] = g[v][u] = 0, g[p[1]][p[2]] = g[p[2]][p[1]] = 1;
return std::make_pair(std::make_pair(u, v), std::make_pair(p[1], p[2]));
}
inline void work(
int n, bool g[maxn][maxn],
std::vector<std::pair<std::pair<int, int>, std::pair<int, int> > > &res) {
for (register int i = 2; i <= n; ++i) {
for (register int j = n; j > 1; --j) {
if (j == i || j == pre[i] || j == nxt[i]) continue;
if (g[i][j]) res.push_back(rev(i, j, n, g));
}
}
}
signed main() {
int n, u, v;
fin >> n;
for (register int i = 1; i <= n; ++i) pre[i] = i - 1, nxt[i] = i + 1;
pre[1] = n, nxt[n] = 1;
for (register int i = 1; i <= n; ++i)
g1[i][pre[i]] = g1[i][nxt[i]] = g2[i][pre[i]] = g2[i][nxt[i]] = 1;
for (register int i = 1; i <= n - 3; ++i)
fin >> u >> v, g1[u][v] = g1[v][u] = 1;
for (register int i = 1; i <= n - 3; ++i)
fin >> u >> v, g2[u][v] = g2[v][u] = 1;
work(n, g1, ans1), work(n, g2, ans2);
std::cout << ans1.size() + ans2.size() << '\n';
for (register int i = 0; i < ans1.size(); ++i)
std::cout << ans1[i].first.first << ' ' << ans1[i].first.second << '\n';
for (register int i = ans2.size() - 1; i >= 0; --i)
std::cout << ans2[i].second.first << ' ' << ans2[i].second.second << '\n';
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e5 + 100;
vector<int> adj[MAXN];
int mark[MAXN];
pair<int, int> hd[MAXN];
int main() {
int n, m, h, t;
scanf("%d%d%d%d", &n, &m, &h, &t);
while (m--) {
int a, b;
scanf("%d %d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
for (int u = 1; u <= n; ++u) {
if (adj[u].size() < h + 1) continue;
for (int i = 0; i < adj[u].size(); ++i) mark[adj[u][i]] = u;
for (int X = 0; X < adj[u].size(); ++X) {
int v = adj[u][X];
if (adj[v].size() < t + 1) continue;
vector<int> heads, tails, both;
pair<int, int> CE = make_pair(u, v);
for (int i = 0; i < adj[v].size() && i < h + t && tails.size() < t; ++i)
if (adj[v][i] != u and mark[adj[v][i]] != u)
tails.push_back(adj[v][i]);
else if (adj[v][i] != u) {
both.push_back(adj[v][i]);
hd[adj[v][i]] = CE;
}
for (int i = 0; i < adj[u].size() && i < h + t && heads.size() < h; ++i)
if (adj[u][i] != v && hd[adj[u][i]] != CE) heads.push_back(adj[u][i]);
if (heads.size() + both.size() >= h and
tails.size() + both.size() >= t and
heads.size() + tails.size() + both.size() >= h + t) {
cout << "YES" << endl;
cout << u << " " << v << endl;
while (h--)
if (heads.size() != 0) {
cout << heads[heads.size() - 1] << " ";
heads.pop_back();
} else {
cout << both[both.size() - 1] << " ";
both.pop_back();
}
cout << endl;
while (t--)
if (tails.size() != 0) {
cout << tails[tails.size() - 1] << " ";
tails.pop_back();
} else {
cout << both[both.size() - 1] << " ";
both.pop_back();
}
return 0;
}
}
}
cout << "NO" << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int ar[1005][1005];
int main() {
int n, a, b, i, j, rem, c;
scanf("%d %d %d", &n, &a, &b);
if (min(a, b) != 1) {
printf("NO\n");
return 0;
}
c = max(a, b);
if (c == 1) {
if (n < 4 && n > 1) {
printf("NO\n");
return 0;
}
printf("YES\n");
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i + 1 == j || j + 1 == i)
printf("1");
else
printf("0");
}
printf("\n");
}
return 0;
}
printf("YES\n");
rem = n;
for (i = 2; i <= n; i++) {
if (rem == c) break;
ar[1][i] = 1;
ar[i][1] = 1;
rem--;
}
if (b > a) {
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) {
if (i == j) continue;
ar[i][j] = !ar[i][j];
}
}
}
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) printf("%d", ar[i][j]);
printf("\n");
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100002;
int n;
int a[5][5];
vector<int> v[N][5];
bool p[N];
char s[6];
void PreProcess() {
memset(p, true, sizeof(p));
int lim = (int)sqrt(99999.0);
for (int i = 2; i <= lim; i++)
if (p[i])
for (int j = i * i; j < 100000; j += i) p[j] = 0;
for (int i = 2; i < 100000; i++)
if (p[i])
for (int x = i, j = 1; j < 5; j++) v[x /= 10][j].push_back(i);
}
int Go(int row) {
int pre = 0, x, i, j;
for (i = 0; i < row; i++) pre = pre * 10 + a[row][i];
if (i == n - 1) return v[pre][1].size();
int ret = 0;
for (i = 0; i < v[pre][n - row].size(); i++) {
x = v[pre][n - row][i];
for (j = n - 1; j >= row; j--) {
a[row][j] = a[j][row] = x % 10;
x /= 10;
}
ret += Go(row + 1);
}
return ret;
}
int main() {
PreProcess();
int T;
cin >> T;
while (T--) {
scanf("%s", s);
n = strlen(s);
for (int i = 0; i < n; i++) a[i][0] = a[0][i] = s[i] - '0';
printf("%d\n", Go(1));
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
pair<int, int> edges[N];
int adj[N][2];
int conf[N];
int ass[N];
int main() {
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng_64(chrono::steady_clock::now().time_since_epoch().count());
uniform_int_distribution<int>(1, 1000 * 1000 * 1000)(rng);
vector<int> permutation;
shuffle(permutation.begin(), permutation.end(), rng);
ios::sync_with_stdio(0);
cin.tie(0);
int n, e;
cin >> n >> e;
for (int i = 1; i <= e; i++) {
cin >> edges[i].first >> edges[i].second;
}
shuffle(edges + 1, edges + e + 1, rng);
for (int i = 1; i < N; i++) {
conf[i] = uniform_int_distribution<int>(1, 2)(rng);
}
int T = 1;
for (int i = 1; i <= n; i++) {
int l;
cin >> l;
while (l--) {
int a;
cin >> a;
adj[i][conf[a]] = a;
T = max(T, a);
}
if (adj[i][1] == 0 or adj[i][2] == 0) {
ass[i] = adj[i][1] ^ adj[i][2];
}
}
for (int i = 1; i <= e; i++) {
int a = edges[i].first, b = edges[i].second;
if (ass[a] and ass[b])
;
else if (ass[a]) {
ass[b] = adj[b][3 - conf[ass[a]]];
} else if (ass[b]) {
ass[a] = adj[a][3 - conf[ass[b]]];
} else {
ass[a] = adj[a][uniform_int_distribution<int>(1, 2)(rng)];
ass[b] = adj[b][3 - conf[ass[a]]];
}
}
for (int i = 1; i <= n; i++) {
if (ass[i] == 0) {
ass[i] = adj[i][1];
}
cout << ass[i] << " ";
}
cout << "\n";
for (int i = 1; i <= T; i++) {
cout << conf[i] << " ";
}
cout << "\n";
return 0;
}
| 8 |
#include <bits/stdc++.h>
char map[55][55], sta[55];
int i, j, n, k;
void print() {
for (int k = 0; k < n; k++) {
for (int q = 0; q < n; q++) printf("%c", map[k][q]);
printf("\n");
}
}
void fillmap() {
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
if (j == i)
map[i][j] = 'X';
else if (sta[i] == '2')
map[i][j] = 'W';
}
for (i = 0; i < n; i++) {
if (sta[i] == '1') {
for (k = 0; k < n; k++)
if (k == i)
continue;
else if (map[i][k] != 'F') {
if (map[i][k] != 'E') map[i][k] = 'T';
} else
map[i][k] = 'E';
for (k = 0; k < n; k++)
if (k == i)
continue;
else if (map[k][i] != 'T') {
if (map[k][i] != 'E') map[k][i] = 'F';
} else
map[k][i] = 'E';
}
}
}
void remap() {
int count;
for (i = 0; i < n; i++) {
count = 0;
for (k = i + 1; k < n; k++) {
if (map[i][k] == 'W') {
if (count % 2)
map[i][k] = '+';
else
map[i][k] = '-';
count++;
} else if (map[i][k] == 'T' && sta[i] == '2')
map[i][k] = '+';
else if (map[i][k] == 'F' && sta[i] == '2')
map[i][k] = '-';
else
map[i][k] = '=';
}
}
for (i = 0; i < n; i++) {
for (k = i + 1; k < n; k++) {
if (map[i][k] == '+')
map[k][i] = '-';
else if (map[i][k] == '-')
map[k][i] = '+';
else
map[k][i] = '=';
}
}
}
void check() {
int count;
for (i = 0; i < n; i++) {
if (sta[i] == '2') {
count = 0;
for (k = 0; k < n; k++)
if (map[i][k] == '+') count++;
if (!count) {
printf("NO\n");
return;
}
}
}
printf("YES\n");
print();
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
memset(map, 0, sizeof(map));
scanf("%d", &n);
scanf("%s", sta);
fillmap();
remap();
check();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int ms = 100100;
int main() {
ios::sync_with_stdio(0), cin.tie(0);
int n, a, b;
cin >> n >> a >> b;
int v[n];
for (int i = 0; i < n; i++) cin >> v[i];
int ans = 0;
for (int i = 0; i < n / 2; i++) {
if (v[i] == 2 && v[n - i - 1] == 2) {
ans += 2 * min(a, b);
v[i] = v[n - i - 1] = -1;
} else if (v[i] == 2 && v[n - i - 1] != 2) {
if (v[n - i - 1] == 0)
ans += a;
else
ans += b;
v[i] = v[n - i - 1];
} else if (v[i] != 2 && v[n - i - 1] == 2) {
if (v[i] == 0)
ans += a;
else
ans += b;
v[n - i - 1] = v[i];
} else if (v[i] != 2 && v[n - i - 1] != 2 && v[i] != v[n - i - 1]) {
cout << -1;
return 0;
}
}
for (int i = 0; i < n; i++)
if (v[i] == 2) {
ans += min(a, b);
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 50010;
long long n, m, a[MAXN], b[MAXN], pre[MAXN], dp[MAXN];
struct NODE {
long long val, lazy, siz;
NODE() { val = lazy = siz = 0; }
} tr[MAXN * 10];
void Pushup(long long x) { tr[x].val = max(tr[2 * x].val, tr[2 * x + 1].val); }
void Pushdown(long long x) {
if (tr[x].lazy == 0) return;
tr[2 * x].val += tr[x].lazy;
tr[2 * x + 1].val += tr[x].lazy;
tr[2 * x].lazy += tr[x].lazy;
tr[2 * x + 1].lazy += tr[x].lazy;
tr[x].lazy = 0;
}
void Build(long long x, long long l, long long r) {
tr[x].lazy = 0;
if (l == r) {
tr[x].val = dp[l - 1];
return;
}
long long mid = (l + r) / 2;
Build(2 * x, l, mid);
Build(2 * x + 1, mid + 1, r);
Pushup(x);
}
void Update(long long x, long long l, long long r, long long al, long long ar,
long long t) {
if (al > r || ar < l) return;
if (al <= l && ar >= r) {
tr[x].val += t;
tr[x].lazy += t;
return;
}
Pushdown(x);
long long mid = (l + r) / 2;
Update(2 * x, l, mid, al, ar, t);
Update(2 * x + 1, mid + 1, r, al, ar, t);
Pushup(x);
}
long long Query(long long x, long long l, long long r, long long al,
long long ar) {
Pushdown(x);
if (ar < l || al > r) return -2000000;
if (ar >= r && al <= l) return tr[x].val;
long long mid = (l + r) / 2;
return max(Query(2 * x, l, mid, al, ar),
Query(2 * x + 1, mid + 1, r, al, ar));
}
signed main() {
while (scanf("%d%d", &n, &m) != EOF) {
memset(b, 0, sizeof(b));
memset(pre, 0, sizeof(pre));
memset(dp, 0, sizeof(dp));
for (long long i = 1; i <= n; i++) {
scanf("%d", &a[i]);
pre[i] = b[a[i]];
b[a[i]] = i;
}
for (long long k = 1; k <= m; k++) {
Build(1, 1, n);
for (long long i = k; i <= n; i++) {
Update(1, 1, n, pre[i] + 1, i, 1);
dp[i] = Query(1, 1, n, k, i);
}
}
printf("%d\n", dp[n]);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, p[200010], root[200010], a[200010];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) root[i] = 1;
for (int i = 2; i <= n; i++) {
cin >> p[i];
root[p[i]] = 0;
}
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
long long ans = -1;
for (int i = n; i >= 1; i--) {
ans = max(ans, a[i] / root[i] + (a[i] % root[i] ? 1 : 0));
root[p[i]] += root[i];
a[p[i]] += a[i];
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, b, cnt = 0;
long long tot;
char a[5][105][105];
int arr[5];
cin >> n;
for (int k = 0; k < 4; k++) {
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
cin >> a[k][i][j];
}
}
char h = '1';
for (int k = 0; k < 4; k++) {
h = '1';
for (i = 0; i < n; i++)
for (j = 0; j < n; j++) {
if (a[k][i][j] != h) cnt++;
if (h == '1')
h = '0';
else
h = '1';
}
arr[k] = cnt;
cnt = 0;
}
sort(arr, arr + 4);
tot = arr[0] + arr[1] + n * n * 2 - arr[2] - arr[3];
cout << tot;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long k, n, s, p;
cin >> k >> n >> s >> p;
cout << (k * ((s + n - 1) / s) + p - 1) / p;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char s[100010], t[100010];
int f[100010], g[100010];
int dp[100010], dp1[100010], dp2[100010];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
scanf("%s%s", s + 1, t + 1);
int n = strlen(s + 1), m = strlen(t + 1);
f[1] = 0;
for (int i = 2; i <= m; i++) {
f[i] = f[i - 1];
while (f[i] && t[f[i] + 1] != t[i]) f[i] = f[f[i]];
if (t[f[i] + 1] == t[i]) f[i]++;
}
g[0] = 0;
for (int i = 1; i <= n; i++) {
g[i] = g[i - 1];
while (g[i] && t[g[i] + 1] != s[i]) g[i] = f[g[i]];
if (t[g[i] + 1] == s[i]) g[i]++;
}
const int mod = 1e9 + 7;
dp[0] = dp1[0] = dp2[0] = 1;
int last = -1;
for (int i = 1; i <= n; i++) {
if (g[i] == m) last = i - m;
if (last == -1)
dp[i] = 0;
else
dp[i] = dp2[last];
dp1[i] = dp1[i - 1], dp2[i] = dp2[i - 1];
dp1[i] += dp[i];
if (dp1[i] >= mod) dp1[i] -= mod;
dp2[i] += dp1[i];
if (dp2[i] >= mod) dp2[i] -= mod;
}
int ans = dp1[n] - 1;
if (ans < 0) ans += mod;
cout << ans << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 10;
int dp[2][4 * maxn][2][2], n, treba, m;
int mod = 1e9 + 7;
void add(int &x, int y) { x = (x + y) % mod; }
void place2() {
for (int i = 2; i <= 4 * n; i++) {
if (i == treba) break;
add(dp[1][i][0][0], dp[0][i - 2][0][1]);
add(dp[1][i][0][1], dp[0][i - 2][0][0]);
add(dp[1][i][1][0], dp[0][i - 2][1][1]);
add(dp[1][i][1][1], dp[0][i - 2][1][0]);
}
for (int i = treba; i <= 4 * n; i++) {
add(dp[1][i][1][0], dp[0][i - 2][1][1]);
add(dp[1][i][1][1], dp[0][i - 2][1][0]);
add(dp[1][i][1][0], dp[0][i - 2][0][1]);
add(dp[1][i][1][1], dp[0][i - 2][0][0]);
}
}
void place4() {
for (int i = 4; i <= 4 * n; i++) {
if (i == treba) break;
add(dp[1][i][0][1], dp[0][i - 4][0][1]);
add(dp[1][i][1][1], dp[0][i - 4][1][1]);
}
for (int i = treba; i <= 4 * n; i++) {
add(dp[1][i][1][1], dp[0][i - 4][1][1]);
add(dp[1][i][1][1], dp[0][i - 4][0][1]);
}
int pom0 = 0;
int pom1 = 0;
for (int i = 0; i <= 4 * n; i++) {
add(pom0, dp[0][i][0][0]);
add(pom1, dp[0][i][1][0]);
}
add(dp[1][4][0][1], pom0);
add(dp[1][4][1][1], pom1);
}
void mov() {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k <= 4 * n; k++) {
dp[0][k][i][j] = dp[1][k][i][j];
dp[1][k][i][j] = 0;
}
}
int main() {
scanf("%d %d", &n, &m);
treba = (1 << m);
dp[0][0][0][1] = 1;
for (int i = 1; i <= n; i++) {
int a;
scanf("%d", &a);
if (a == 0) {
place2();
place4();
} else if (a == 2)
place2();
else
place4();
mov();
}
int rez = 0;
for (int i = 0; i <= 4 * n; i++) {
for (int j = 0; j < 2; j++) {
add(rez, dp[0][i][1][j]);
}
}
printf("%d\n", rez);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int debug = 0;
const int N = 7e5;
int n, mn_bal, pos, cnt, cur_bal, mx_cnt, cnt_one, cnt_two, lst, lst_two;
int a[N], bal[N], pre[N];
string s;
array<int, 2> ans;
int get_cnt(int n, string t) {
int cnt = 0;
int cur_bal = 0, mn_bal = 0;
for (int i = 0; i < n; ++i) {
cur_bal += (t[i] == '(') ? 1 : -1;
if (cur_bal < mn_bal) {
mn_bal = cur_bal;
cnt = 0;
}
if (cur_bal == mn_bal) {
cnt++;
}
}
return cnt;
}
int stress(int n, string ss) {
int res = get_cnt(n, ss);
for (int i = 0; i < n; ++i)
for (int j = i + 1; j < n; ++j) {
string t = ss;
swap(t[i], t[j]);
int cur = get_cnt(n, t);
res = max(res, cur);
if (debug) {
cerr << t << ' ' << cur << '\n';
}
}
return res;
}
int main() {
cin >> n >> s;
if (debug) {
cerr << " cor_ans = " << stress(n, s) << '\n';
}
for (int i = 0; i < n; ++i) {
a[i] = (s[i] == '(') ? 1 : -1;
a[i + n] = a[i];
}
mn_bal = 0;
pos = 0;
cur_bal = 0;
for (int i = 0; i < n; ++i) {
cur_bal += a[i];
if (cur_bal < mn_bal) {
mn_bal = cur_bal;
pos = i + 1;
}
}
if (cur_bal != 0) {
cout << 0 << '\n';
cout << 1 << ' ' << 1 << '\n';
return 0;
}
ans = {{0, 0}};
cur_bal = 0;
cnt = 0;
for (int i = pos; i < pos + n; ++i) {
cur_bal += a[i];
cnt += (cur_bal == 0);
}
mx_cnt = cnt;
cur_bal = 0;
cnt_one = 0;
cnt_two = 0;
lst = pos;
lst_two = pos + 1;
for (int i = pos; i < pos + n; ++i) {
cur_bal += a[i];
if (debug) {
cerr << " i=" << i << " cbal=" << cur_bal << " ";
cerr << " cnt_two = " << cnt_two << " cnt=" << cnt << '\n';
}
if (cur_bal == 1) {
cnt_one++;
if (cnt_two + cnt > mx_cnt) {
if (debug) {
cerr << " keks\n";
}
mx_cnt = cnt_two + cnt;
ans = {{lst_two % n, i % n}};
}
cnt_two = 0;
lst_two = i + 1;
}
if (cur_bal == 2) {
cnt_two++;
}
if (cur_bal == 0) {
if (cnt_one > mx_cnt) {
mx_cnt = cnt_one;
ans = {{lst % n, i % n}};
}
cnt_one = 0;
cnt_two = 0;
lst = i + 1;
lst_two = i + 1;
}
}
cout << mx_cnt << '\n';
cout << ans[0] + 1 << ' ' << ans[1] + 1 << '\n';
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int NMAX = 2005;
char s[NMAX];
long long sum;
void print(long long sum) {
int v[30];
long long nr = 0;
long long intreg = sum;
while (intreg > 0) {
v[++nr] = intreg % 10;
intreg /= 10;
}
long long rest = sum % 100;
if (sum < 100) cout << 0;
for (int i = nr; i > 2; --i) {
if ((i - 2) % 3 == 0 && i != nr)
cout << '.' << v[i];
else
cout << v[i];
}
if (rest != 0) {
cout << '.';
if (rest < 10) cout << 0;
cout << rest;
}
cout << '\n';
}
int main() {
cin >> s;
int n = strlen(s);
int p = 0;
while (p < n) {
while (p < n && s[p] >= 'a' && s[p] <= 'z') ++p;
long long x = 0;
int cnt = -100;
while (p < n && !(s[p] >= 'a' && s[p] <= 'z')) {
if (s[p] == '.') {
cnt = 0;
++p;
} else {
x = x * 10 + s[p] - '0';
++cnt;
++p;
}
}
if (cnt == 2)
sum += x;
else
sum += x * 100;
}
print(sum);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
set<int>::iterator my_find(int val, set<int>& tar) {
set<int>::iterator it = tar.lower_bound(val);
if (!tar.empty()) {
if (it == tar.end())
it--;
else {
if (it == tar.begin())
it = tar.end();
else
it--;
}
}
return it;
}
set<int> sp;
map<int, int> deep;
int N;
int main(int argc, char* argv[]) {
scanf("%d", &N);
for (int i = 1; i <= N; ++i) {
int x;
scanf("%d", &x);
if (i == 1) {
sp.insert(x);
deep[x] = 1;
} else {
int fa;
set<int>::iterator a = sp.lower_bound(x), b = my_find(x, sp);
if (a == sp.end() || b == sp.end()) {
if (a == sp.end()) a = b;
} else if (deep[*a] < deep[*b])
a = b;
fa = *a;
deep[x] = deep[fa] + 1;
sp.insert(x);
printf("%d ", fa);
}
}
printf("\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void fast(int &x) {
register int c = getchar();
x = 0;
int neg = 0;
for (; ((c < 48 || c > 57) && c != '-'); c = getchar())
;
if (c == '-') {
neg = 1;
c = getchar();
}
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (neg) x = -x;
}
int main() {
int n, x;
cin >> n;
cin >> x;
int y = n % 6;
if (n % 2 == 0) {
if (y == 0) {
if (x == 0) {
cout << "0";
return 0;
} else if (x == 1) {
cout << "1";
return 0;
} else {
cout << "2";
return 0;
}
}
if (y == 2) {
if (x == 0) {
cout << "1";
return 0;
} else if (x == 1) {
cout << "2";
return 0;
} else {
cout << "0";
return 0;
}
}
if (y == 4) {
if (x == 0) {
cout << "2";
return 0;
} else if (x == 1) {
cout << "0";
return 0;
} else {
cout << "1";
return 0;
}
}
} else {
if (y == 1) {
if (x == 0) {
cout << "1";
return 0;
} else if (x == 1) {
cout << "0";
return 0;
} else {
cout << "2";
return 0;
}
}
if (y == 3) {
if (x == 0) {
cout << "2";
return 0;
} else if (x == 1) {
cout << "1";
return 0;
} else {
cout << "0";
return 0;
}
}
if (y == 5) {
if (x == 0) {
cout << "0";
return 0;
} else if (x == 1) {
cout << "2";
return 0;
} else {
cout << "1";
return 0;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<int> graf[100010];
vector<string> str[100010];
int n, m;
string needle, haystack;
int P[1000001];
int matches = 0;
void initFailureFunc() {
for (int i = 0; i < needle.size(); i++) P[i] = -1;
for (int i = 0, j = -1; i < needle.size();) {
while (j > -1 && needle[i] != needle[j]) j = P[j];
i++;
j++;
P[i] = j;
}
}
void DFS(int u, int j) {
int oj = j;
for (int x = 0; x < graf[u].size(); x++) {
string edge = str[u][x];
j = oj;
int v = graf[u][x];
for (int i = 0; i < edge.size();) {
while (j > -1 && edge[i] != needle[j]) j = P[j];
i++;
j++;
if (j == needle.size()) {
matches++;
j = P[j];
}
}
DFS(v, j);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int p;
string s;
scanf("%d", &p);
cin >> s;
graf[p].push_back(i + 2);
str[p].push_back(s);
}
cin >> needle;
initFailureFunc();
DFS(1, 0);
printf("%d\n", matches);
return 0;
}
| 6 |
#include <bits/stdc++.h>
const int N = 100001;
int sz[N], tp[N], v[N], pre[N];
int f[N], ml[N], cnt;
bool mem[N];
struct Edge {
int to, next, w;
} eg[N << 1];
void add(int x, int y) {
eg[cnt].to = y;
eg[cnt].next = v[x];
v[x] = cnt++;
}
void dfs(int x) {
int i;
mem[x] = 1;
if (tp[x] == 1 && (ml[x] = 1)) return;
if (sz[x] != 1) return;
for (i = v[x]; i != -1; i = eg[i].next) {
if (!mem[eg[i].to]) dfs(eg[i].to);
if (ml[eg[i].to] && ml[eg[i].to] + 1 > ml[x])
ml[x] = ml[eg[i].to] + 1, f[x] = eg[i].to;
}
}
int main() {
int n, m, i, j, k, x, y, t, rl, rx;
while (~scanf("%d", &n)) {
memset(sz, 0, sizeof(sz));
memset(v, -1, sizeof(v));
memset(mem, 0, sizeof(mem));
memset(ml, 0, sizeof(ml));
memset(f, 0, sizeof(f));
for (i = 1; i <= n; i++) scanf("%d", &tp[i]);
for (cnt = 0, i = 1; i <= n; i++) {
scanf("%d", &x);
sz[x]++;
add(x, i);
}
for (rl = rx = 0, i = 1; i <= n; i++) {
dfs(i);
if (ml[i] > rl) rx = i, rl = ml[i];
}
printf("%d\n", rl);
for (i = rx; i != 0; i = f[i]) printf("%d ", i);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<pair<long long, long long>, int> m;
pair<long long, long long> pos[112345];
set<int> down[112345];
set<int> up[112345];
int dx[] = {-1, 0, 1};
bool puedosacar(int i) {
for (auto x : up[i])
if (down[x].size() == 1) return false;
return true;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n;
cin >> n;
for (int i = (0); i < (n); i++) {
int x, y;
cin >> x >> y;
m[{x, y}] = i;
pos[i] = {x, y};
}
for (int i = (0); i < (n); i++) {
auto p = pos[i];
int x = p.first, y = p.second;
for (int k = (0); k < (3); k++) {
if (m.count({x + dx[k], y - 1})) {
int u = m[{x + dx[k], y - 1}];
down[i].insert(u);
up[u].insert(i);
}
}
}
set<int> sacar;
for (int i = (0); i < (n); i++)
if (puedosacar(i)) sacar.insert(i);
int t = 0;
long long res = 0;
while (sacar.size()) {
long long act;
if ((t & 1) == 0) {
auto it = sacar.end();
--it;
act = *it;
} else {
act = *sacar.begin();
}
sacar.erase(act);
for (auto x : down[act]) {
up[x].erase(act);
if (puedosacar(x)) sacar.insert(x);
}
for (auto x : up[act]) {
down[x].erase(act);
if (down[x].size() == 1) {
auto y = *down[x].begin();
sacar.erase(y);
}
}
res *= n;
res %= 1000000009;
res += act;
res %= 1000000009;
t = 1 - t;
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
class keep {
public:
int l, r, j;
bool operator<(const keep &x) { return (l < x.l || (l == x.l && r < x.r)); }
} a[109];
int n, b[109];
void dh(int k, int n) {
keep t = a[k];
for (int c; k <= n / 2; k = c) {
c = k * 2 + 1;
if ((c <= n && a[c - 1] < a[c]) || c > n) c--;
if (t < a[c]) break;
a[k] = a[c];
}
a[k] = t;
}
int main() {
scanf("%d", &n);
int c = 0, m = n, i;
for (i = 1; i <= n; i++) {
scanf("%d %d", &a[i].l, &a[i].r);
a[i].j = i;
}
int h;
for (i = n; i > 0;) {
for (h = i / 2; h > 0; h--) dh(h, i);
c = a[1].l;
b[a[1].j] = c;
{
keep t = a[1];
a[1] = a[i];
a[i] = a[1];
};
for (h = 1; h < i; h++)
if (a[h].l == c) a[h].l++;
i--;
dh(1, i);
}
printf("\n");
for (i = 1; i <= m; i++) printf("%d ", b[i]);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = int(1e9 + 7);
int n, k, ans;
string s;
vector<int> choco;
bool check(int ans) {
int l = 0, r = 1;
vector<int> v;
v.push_back(0);
while (r < choco.size()) {
while (choco[r] - choco[l] - 1 <= ans && r < choco.size()) r++;
if (r - 1 == l) return false;
l = r - 1;
v.push_back(l);
}
if (v.back() + 1 == choco.size()) return v.size() <= k;
return false;
}
int main() {
cin >> n >> k >> s;
for (int i = 0; i < s.size(); i++)
if (s[i] == '0') choco.push_back(i);
int l = 0, r = n;
while (l <= r) {
int mid = (l + r) >> 1;
if (check(mid)) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 3.141592653589793;
const int N = 20 + 5;
bool sign;
int n, m;
int r[N];
int w[N];
int f[N];
int ans[N];
int g[N];
int q[N];
bool v[21][32][170000];
int countg(int k) {
int cnt = 0;
bool pre, now;
pre = false;
for (int i = 0; i < n; i++) {
now = (f[i] & k) > 0 ? true : false;
if (!pre && now) cnt++;
pre = now;
}
return cnt;
}
bool check(int k, int state) {
int cnt, now;
for (cnt = 1; cnt <= n; cnt++) {
now = state % 11;
if (now > r[cnt] || now + (m - k + 1) / 2 < r[cnt]) return false;
state = state / 11;
}
return true;
}
void dfs(int k, int pre, int state) {
if (k == m + 1) {
sign = true;
return;
}
if (sign) return;
v[k - 1][pre][state] = true;
int now;
for (int i = 0; i < f[n]; i++)
if (g[i] == w[k]) {
now = state;
for (int j = 0; j < n; j++) {
if ((i & f[j]) > 0 && (pre & f[j]) == 0) {
now += q[j];
}
}
if (check(k, now) && (k == m + 1 || !v[k][i][now])) {
ans[k] = i;
dfs(k + 1, i, now);
}
if (sign) return;
}
}
void init() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &r[i]);
for (int i = 1; i <= m; i++) scanf("%d", &w[i]);
f[0] = q[0] = 1;
for (int i = 1; i <= n; i++) f[i] = f[i - 1] << 1, q[i] = q[i - 1] * 11;
for (int i = 0; i < f[n]; i++) g[i] = countg(i);
}
void work() {
dfs(1, 0, 0);
if (sign) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (f[i - 1] & ans[j])
putchar('*');
else
putchar('.');
putchar('\n');
}
}
}
int main() {
init();
work();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int mo = 1000000007;
const int N = 200005;
int power(int x, int y) {
int s = 1;
for (; y; y /= 2, x = 1ll * x * x % mo)
if (y & 1) s = 1ll * s * x % mo;
return s;
}
int T;
struct Tarr {
int s[N * 4], t[N * 4], vis[N * 4];
void add(int x, int v) {
x += N * 2;
for (; x < N * 4; x += x & (-x)) {
if (vis[x] != T) {
vis[x] = T;
s[x] = 0;
t[x] = 1;
}
s[x]++;
t[x] = 1ll * t[x] * v % mo;
}
}
void mul(int x, int &v1, int &v2) {
x += N * 2;
for (; x; x -= x & (-x))
if (vis[x] == T) {
v1 = 1ll * v1 * t[x] % mo;
v2 += s[x];
}
}
} T0, T1;
struct edge {
int to, next, v, c;
} e[N * 2];
int head[N], tot;
void add(int x, int y, int v, int c) {
e[++tot] = (edge){y, head[x], v, c};
head[x] = tot;
}
int sz[N], vis[N];
int frt, rt, Sz, mn, n, ans;
void getrt(int x, int fa) {
sz[x] = 1;
int mx = 0;
for (int i = head[x]; i; i = e[i].next)
if (!vis[e[i].to] && e[i].to != fa) {
getrt(e[i].to, x);
sz[x] += sz[e[i].to];
mx = max(mx, sz[e[i].to]);
}
mx = max(mx, Sz - sz[x]);
if (mx < mn) mn = mx, rt = x, frt = fa;
}
struct data {
int a, b, val;
} q[N];
int top;
void dfs2(int x, int fa, int a, int b, int v) {
q[++top] = (data){a * 2 - b, b * 2 - a, v};
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa && !vis[e[i].to])
dfs2(e[i].to, x, a + e[i].c, b + (!e[i].c), 1ll * v * e[i].v % mo);
}
void solve(int x) {
vis[x] = 1;
T++;
T0.add(0, 1);
T1.add(0, 1);
for (int i = head[x]; i; i = e[i].next)
if (!vis[e[i].to]) {
top = 0;
dfs2(e[i].to, 0, e[i].c, !e[i].c, e[i].v);
for (int j = (int)(1); j <= (int)(top); j++) {
int pi = 1, t = 0, s = 0;
T0.mul(q[j].a, ans, s);
T1.mul(-q[j].b - 1, pi, t);
ans = 1ll * ans * power(pi, mo - 2) % mo;
ans = 1ll * ans * power(q[j].val, s - t) % mo;
}
for (int j = (int)(1); j <= (int)(top); j++)
T0.add(-q[j].a, q[j].val), T1.add(q[j].b, q[j].val);
}
for (int i = head[x]; i; i = e[i].next)
if (!vis[e[i].to]) {
mn = 1e9;
Sz = sz[e[i].to];
getrt(e[i].to, x);
sz[frt] = Sz - sz[rt];
solve(rt);
}
}
int main() {
scanf("%d", &n);
for (int i = (int)(1); i <= (int)(n - 1); i++) {
int x, y, v, c;
scanf("%d%d%d%d", &x, &y, &v, &c);
add(x, y, v, c);
add(y, x, v, c);
}
ans = 1;
mn = 1e9;
Sz = n;
getrt(1, 0);
sz[frt] = Sz - sz[rt];
solve(rt);
printf("%d\n", ans);
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
double r;
cin >> n >> r;
double x[n];
for (int i = 0; i < n; i++) cin >> x[i];
pair<double, double> arr[n];
int s = 0;
double res;
for (int i = 0; i < n; i++) {
double f = 0;
double m = r;
for (int j = 0; j < s; j++) {
if (abs(x[i] - arr[j].first) > 2 * r) {
res = r;
} else {
double x1 = arr[j].first;
double y1 = arr[j].second;
double x2 = x[i];
double t = pow(2 * r, 2) - pow((x1 - x2), 2);
t = sqrt(t);
res = t + y1;
}
m = max(m, res);
}
{ arr[s++] = make_pair(x[i], m); }
}
for (int i = 0; i < n; i++) printf("%lf ", arr[i].second);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4000;
const int MAXK = 100;
int n, a[MAXN + 1];
unordered_map<int, int> dp[MAXK + 1];
inline int getId(int lef, int rig) { return lef * 4001 + rig; }
int solve2(const int& lef, const int& rig, const int& k);
int solve(const int& lef = 0, const int& rig = 0, const int& k = 1) {
int ll = lef + k;
int newlen = ll + rig;
if (newlen > n) {
return a[lef] - a[n] + a[n - rig];
}
auto p = dp[k].insert({getId(lef, rig), 0});
if (!p.second) {
return p.first->second;
}
if (newlen == n) {
return (p.first->second = solve2(ll, rig, k));
}
return (p.first->second =
max(solve2(ll, rig, k), solve2(ll + 1, rig, k + 1)));
}
int solve2(const int& lef, const int& rig, const int& k) {
int rr = rig + k;
int newlen = lef + rr;
if (newlen > n) {
return a[lef] - a[n] + a[n - rig];
}
auto p = dp[k].insert({getId(lef, rig), 0});
if (!p.second) {
return p.first->second;
}
if (newlen == n) {
return (p.first->second = solve(lef, rr, k));
}
return (p.first->second = min(solve(lef, rr, k), solve(lef, rr + 1, k + 1)));
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i), a[i] = a[i] + a[i - 1];
printf("%d\n", solve());
fflush(stdout);
_Exit(0);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
int res = -1, pos = -1, j = 0;
for (int i = 0; i < b.size(); i++) {
if (a[j] != b[i]) {
pos = j;
if (res != -1 || a[j + 1] != b[i]) {
res = 0;
break;
}
res = 1;
j++;
}
j++;
}
if (res == -1) res = 1, pos = a.size() - 1;
if (res) {
vector<int> v;
v.push_back(pos);
while (pos > 0 && a[--pos] == a[v[0]]) v.push_back(pos);
cout << v.size() << endl;
for (int i = v.size() - 1; i >= 0; i--) cout << v[i] + 1 << ' ';
cout << endl;
} else
cout << 0 << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 8131, md = 1e9 + 7;
int R, a1, a2, a3, a4, A[N][N], id[171][171], n, B[N];
inline int pow(int a, int b) {
int ret = 1;
for (; b; b >>= 1, a = (long long)a * a % md)
if (b & 1) ret = (long long)ret * a % md;
return ret;
}
void gauss() {
for (int i = 1; i <= n; ++i) {
int id = 0;
for (int j = i; j <= n && !id; ++j)
if (A[j][i] != 0) id = j;
if (i != id) swap(A[i], A[id]), swap(B[i], B[id]);
vector<int> pos;
for (int j = i; j <= n; ++j)
if (A[i][j]) pos.push_back(j);
const int iv = pow(A[i][i], md - 2);
for (int j = i + 1; j <= n; ++j)
if (A[j][i]) {
int dlt = md - (long long)A[j][i] * iv % md;
for (int k : pos) A[j][k] = (A[j][k] + (long long)A[i][k] * dlt) % md;
B[j] = (B[j] + (long long)B[i] * dlt) % md;
}
}
for (int i = n; i; --i) {
B[i] = (long long)B[i] * pow(A[i][i], md - 2) % md;
for (int j = i - 1; j; --j)
B[j] = (B[j] - (long long)B[i] * A[j][i] % md + md) % md;
}
}
int main() {
scanf("%d%d%d%d%d", &R, &a1, &a2, &a3, &a4);
const int pp = pow(a1 + a2 + a3 + a4, md - 2);
a1 = (long long)a1 * pp % md, a2 = (long long)a2 * pp % md,
a3 = (long long)a3 * pp % md, a4 = (long long)a4 * pp % md;
for (int i = -R - 1; i <= R + 1; ++i)
for (int j = -R - 1; j <= R + 1; ++j) {
int x = abs(i), y = abs(j);
if (x * x + y * y <= R * R || (x - 1) * (x - 1) + y * y <= R * R ||
x * x + (y - 1) * (y - 1) <= R * R)
id[i + 72][j + 72] = ++n;
}
for (int i = -R - 1; i <= R + 1; ++i)
for (int j = -R - 1; j <= R + 1; ++j)
if (id[i + 72][j + 72]) {
int* a = A[id[i + 72][j + 72]];
if (i * i + j * j <= R * R) {
a[id[i + 72][j + 72]] = md - 1;
a[id[i + 71][j + 72]] = a1;
a[id[i + 72][j + 71]] = a2;
a[id[i + 73][j + 72]] = a3;
a[id[i + 72][j + 73]] = a4;
B[id[i + 72][j + 72]] = md - 1;
} else {
a[id[i + 72][j + 72]] = 1;
B[id[i + 72][j + 72]] = 0;
}
}
gauss();
printf("%d\n", B[id[72][72]]);
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int n;
bool adj[567][567];
struct Matching {
int n;
vector<int> matchL, matchR, dist;
vector<bool> seen;
vector<vector<int> > ke;
Matching(int n)
: n(n),
matchL(n + 1),
matchR(n + 1),
dist(n + 1),
seen(n + 1, false),
ke(n + 1) {}
void addEdge(int u, int v) { ke[u].push_back(v); }
bool bfs() {
queue<int> qu;
for (int u = 1; u <= n; ++u)
if (!matchL[u]) {
dist[u] = 0;
qu.push(u);
} else
dist[u] = INT_MAX;
dist[0] = INT_MAX;
while (!qu.empty()) {
int u = qu.front();
qu.pop();
for (__typeof(ke[u].begin()) v = ke[u].begin(); v != ke[u].end(); ++v)
if (dist[matchR[*v]] == INT_MAX) {
dist[matchR[*v]] = dist[u] + 1;
qu.push(matchR[*v]);
}
}
return dist[0] != INT_MAX;
}
bool dfs(int u) {
if (u) {
for (__typeof(ke[u].begin()) v = ke[u].begin(); v != ke[u].end(); ++v)
if (dist[matchR[*v]] == dist[u] + 1 && dfs(matchR[*v])) {
matchL[u] = *v;
matchR[*v] = u;
return true;
}
dist[u] = INT_MAX;
return false;
}
return true;
}
int match() {
int res = 0;
while (bfs()) {
for (int u = 1; u <= n; ++u)
if (!matchL[u])
if (dfs(u)) ++res;
}
return res;
}
};
int magic(int v, Matching& g) {
int ans = 0;
for (int i = 1; i <= n; ++i) ans += 2 - adj[i][v] - adj[v][i];
if (!adj[v][v]) ans--;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i != v && j != v && adj[i][j]) g.addEdge(i, j + n);
return ans;
}
int main() {
ios::sync_with_stdio(0);
int m;
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int u, v;
cin >> u >> v;
adj[u][v] = true;
}
int ans = INT_MAX;
for (int i = 1; i <= n; ++i) {
Matching g(2 * n + 1);
int x = magic(i, g);
x += n - 1 + m - (2 * n - 1 - x) - 2 * g.match();
ans = min(ans, x);
}
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
int n, t, len;
char s[500005];
bool check(int x) {
int num = x, End = 0;
for (int i = 0; i < n; i++) {
if (s[i] == 'H')
num--, End = i;
else if (s[i] == 'S') {
num++;
if (!num) End = i;
}
}
if (num < 0) return 0;
int last = -1, ans = 0;
num = x;
for (int i = 0; i <= End; i++) {
ans++;
if (s[i] == 'H') {
num--;
if (num == -1) {
if (ans + ((End - i) << 1) <= t) return 1;
last = i;
}
} else if (s[i] == 'S') {
num++;
if (!num) {
ans += ((i - last) << 1);
last = -1;
}
}
}
if (ans <= t)
return 1;
else
return 0;
}
int main() {
scanf("%d %d %s", &n, &t, s);
int l = 0, r = n;
while (l < r) {
int mid = (l + r) >> 1;
if (check(mid))
r = mid;
else
l = mid + 1;
}
if (check(l))
printf("%d", l);
else
printf("-1");
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
int a[5000 + 10], b[5000 + 10], c[5000 + 10];
vector<vector<int>> E;
int sumb[5000 + 10], canuse[5000 + 10];
int trashpos[5000 + 10];
int main() {
cin >> n >> m >> k;
E.resize(n);
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
E[u].push_back(v);
}
for (int i = 0; i < n; i++) trashpos[i] = i;
for (int i = 0; i < n; i++) {
for (int j = 0; j < E[i].size(); j++) {
trashpos[E[i][j]] = max(trashpos[E[i][j]], i);
}
}
sumb[0] = k;
for (int i = 1; i <= n; i++) {
if (sumb[i - 1] < a[i - 1]) {
cout << "-1" << endl;
return 0;
}
canuse[i - 1] = sumb[i - 1] - a[i - 1];
sumb[i] = sumb[i - 1] + b[i - 1];
}
canuse[n] = n;
vector<pair<int, int>> sortlist;
for (int i = 0; i < n; i++) sortlist.push_back(make_pair(c[i], trashpos[i]));
sort(sortlist.begin(), sortlist.end(), greater<pair<int, int>>());
int ans = 0;
for (int i = 0; i < n; i++) {
bool isok = true;
for (int j = sortlist[i].second + 1; j <= n; j++) {
if (canuse[j] == 0) isok = false;
}
if (isok) {
ans += sortlist[i].first;
for (int j = sortlist[i].second + 1; j <= n; j++) canuse[j]--;
}
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 100 * 1000 + 100;
long long a[maxn];
long long n, t = 1, m;
int main() {
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
cin >> m;
for (long long i = 0; i < m; i++) {
long long w, h, c = a[0];
cin >> w >> h;
for (long long j = t; j < w; j++) c = max(c, a[j]);
cout << c << endl;
a[0] = c + h;
t = max(t, w);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int month[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool f(int a, int b, int c, int d, int m, int y) {
bool f1, res;
if (y % 4 == 0) month[2] = 29;
f1 = (d <= month[m] && m <= 12);
month[2] = 28;
if (!f1) return 0;
if (c - y >= 19)
res = 1;
else if (c - y <= 17)
res = 0;
else {
if (b > m)
res = 1;
else if (b < m)
res = 0;
else {
if (a >= d)
res = 1;
else
res = 0;
}
}
return res;
}
int main() {
int a1, b1, c1, d1, m1, y1;
scanf("%d.%d.%d", &a1, &b1, &c1);
scanf("%d.%d.%d", &d1, &m1, &y1);
if (f(a1, b1, c1, d1, m1, y1) || f(a1, b1, c1, d1, y1, m1) ||
f(a1, b1, c1, m1, d1, y1) || f(a1, b1, c1, m1, y1, d1) ||
f(a1, b1, c1, y1, d1, m1) || f(a1, b1, c1, y1, m1, d1))
printf("YES");
else
printf("NO");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
int x[101];
for (int i = 0; i < n; ++i) cin >> x[i];
sort(x, x + n);
cout << x[n - 1] << ' ';
for (int i = 1; i < n - 1; ++i) cout << x[i] << ' ';
cout << x[0] << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> s;
n = s.length();
map<char, int> mp;
for (int i = 0; i < n; ++i) {
mp[s[i]]++;
}
if (mp.size() == 2 && n > 3) {
for (char c = 'a'; c <= 'z'; ++c) {
if (mp[c] == 0) continue;
if (mp[c] < 2) {
cout << "No";
return 0;
}
}
cout << "Yes";
return 0;
}
if (mp.size() == 4) {
cout << "Yes";
return 0;
}
if (mp.size() == 3 && n > 3) {
cout << "Yes";
return 0;
}
cout << "No";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k, n;
cin >> n;
k = n / 2;
for (i = 1; i <= n; i++) {
cout << (i - 1) * k + 1;
for (j = (i - 1) * k + 2; j <= i * k; j++) cout << " " << j;
for (j = n * n - (i - 1) * k; j > n * n - i * k; j--) cout << " " << j;
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[22];
long long f[17][17][2][2];
inline void upd(long long& x, long long y) { x += y; }
void init(char* s) {
memset(a, 0, sizeof(a));
memset(f, 0, sizeof(f));
int n = strlen(s + 1);
for (int i = 1; i <= n; i++)
a[i] = (s[i] >= '0' && s[i] <= '9') ? s[i] - '0' : (s[i] - 'a' + 10);
for (int i = 1; i <= n / 2; i++) swap(a[i], a[n - i + 1]);
}
long long solve(char* s) {
init(s);
int n = strlen(s + 1);
long long ans = 0;
for (int i = 0; i <= 15; i++) f[0][i][0][0] = 1;
for (int i = 0; i <= 14; i++) {
for (int mx = 0; mx <= 15; mx++) {
int in = 0;
if (mx < 4 * (i + 1) && mx >= 4 * i) in = (1 << (mx - 4 * i));
for (int been = 0; been <= 1; been++) {
long long tmp_0 = f[i][mx][been][0];
long long tmp_1 = f[i][mx][been][1];
if (!tmp_0 && !tmp_1) continue;
for (int ne = 0; ne <= mx; ne++) {
if (in && !(ne & in)) continue;
int op = 0;
if (ne == mx) op = 1;
long long& goal0 = f[i + 1][mx][op | been][0];
long long& goal1 = f[i + 1][mx][op | been][1];
upd(goal0, tmp_0);
if (ne < a[i + 1]) {
upd(goal1, tmp_0);
} else if (ne == a[i + 1]) {
upd(goal1, tmp_1);
}
}
}
}
}
for (int i = 0; i <= 15; i++) upd(ans, f[15][i][1][1]);
return ans;
}
int pan(char* s) {
init(s);
int n = strlen(s + 1);
int mx = 0;
for (int i = 1; i <= n; i++) mx = max(mx, a[i]);
for (int i = 1; i <= n; i++)
if (mx < 4 * i && mx >= 4 * (i - 1)) {
int in = (1 << (mx - 4 * (i - 1)));
if (!(a[i] & in))
return 0;
else
return 1;
}
return 0;
}
char s1[22], s2[33];
int T;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%s%s", s1 + 1, s2 + 1);
long long ans1 = solve(s1);
long long ans2 = solve(s2);
int ok = pan(s2);
printf("%I64d\n", ans2 - ans1 + ok);
}
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int N = 120 + 77;
const int inf = 1000000000 + 77;
int n, k, C[N], A[N];
int dp[N][N][2];
int Par[N][N][2];
vector<int> adj[N];
void dfs(int v, int prev = -1) {
vector<int> Ch;
for (int u : adj[v])
if (u != prev) dfs(u, v), Ch.push_back(u);
dp[v][0][1] = k;
for (int u : Ch) dp[v][0][1] += min(dp[u][0][1], dp[u][1][1]);
dp[v][0][0] = dp[v][0][1];
for (int i = 1; i < n; ++i) {
dp[v][i][1] = C[i];
int tot = 0;
bool good = 1, ff = 1;
for (int u : Ch) {
dp[v][i][1] += min(min(dp[u][i + 1][1], dp[u][i][0]), dp[u][i - 1][0]),
tot += min(min(dp[u][i - 1][0], dp[u][i][0]), dp[u][i + 1][1]);
if (min(min(dp[u][i - 1][0], dp[u][i][0]), dp[u][i + 1][1]) > 1e8)
good = 0;
if (min(min(dp[u][i + 1][1], dp[u][i][0]), dp[u][i - 1][0]) > 1e8) ff = 0;
}
if (!ff) dp[v][i][1] = inf;
if (!good) continue;
for (int u : Ch) {
int val = dp[u][i - 1][0] + tot -
min(min(dp[u][i - 1][0], dp[u][i][0]), dp[u][i + 1][1]);
if (val < dp[v][i][0]) Par[v][i][0] = u, dp[v][i][0] = val;
}
dp[v][i][0] += C[i];
}
}
void Solve(int v, int d, int t, int prev = -1) {
if (d == 0)
A[v] = v;
else if (t == 1)
A[v] = A[prev];
else {
int x = Par[v][d][t];
Solve(x, d - 1, t, v);
A[v] = A[x];
for (int u : adj[v])
if (u != prev && u != x) {
int f = min(min(dp[u][d - 1][0], dp[u][d][0]), dp[u][d + 1][1]);
if (f == dp[u][d - 1][0])
Solve(u, d - 1, 0, v);
else if (f == dp[u][d][0])
Solve(u, d, 0, v);
else
Solve(u, d + 1, 1, v);
}
return;
}
if (t == 1) {
for (int u : adj[v]) {
if (u != prev) {
int f = min(min(dp[u][d + 1][1], dp[u][d][0]), dp[u][d - 1][0]);
if (f == dp[u][d + 1][1])
Solve(u, d + 1, 1, v);
else if (f == dp[u][d][0])
Solve(u, d, 0, v);
else
Solve(u, d - 1, 0, v);
}
}
return;
}
for (int u : adj[v]) {
if (u == prev) continue;
int f = min(dp[u][0][1], dp[u][1][1]);
if (f == dp[u][0][0])
Solve(u, 0, 0, v);
else
Solve(u, 1, 1, v);
}
}
int main() {
memset(dp, 63, sizeof(dp));
scanf("%d %d", &n, &k);
for (int i = 1; i < n; ++i) scanf("%d", C + i);
for (int v, u, i = 1; i < n; ++i) {
scanf("%d %d", &v, &u);
adj[v].push_back(u);
adj[u].push_back(v);
}
dfs(1);
int best = 0;
int val = dp[1][0][0];
for (int i = 1; i < n; ++i)
if (dp[1][i][0] < val) best = i, val = dp[1][i][0];
printf("%d\n", val);
Solve(1, best, 0);
for (int i = 1; i <= n; ++i) printf("%d ", A[i]);
printf("\n");
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
char a[201][201], A[201][201];
char s[10010];
int main() {
int r, c, i, j, x, flag = 0, g;
char ch;
while (scanf("%d%d", &r, &c) == 2) {
s[0] = '\0';
flag = 0;
for (i = 0; i < r; i++) {
scanf("%s", a[i]);
strcpy(A[i], a[i]);
}
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++) {
ch = a[i][j];
flag = 0;
for (x = j + 1; x < c; x++) {
if (ch == a[i][x]) {
A[i][x] = '#';
flag = 1;
}
}
if (flag) A[i][j] = '#';
}
}
for (j = 0; j < c; j++) {
for (i = 0; i < r; i++) {
ch = a[i][j];
flag = 0;
for (x = i + 1; x < r; x++) {
if (ch == a[x][j]) {
A[x][j] = '#';
flag = 1;
}
}
if (flag) A[i][j] = '#';
}
}
x = 0;
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++) {
if (A[i][j] != '#') s[x++] = A[i][j];
}
}
s[x] = '\0';
puts(s);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int MOD = 1e9 + 7;
template <typename S, typename T>
inline bool Min(S &a, const T &b) {
return a > b ? a = b, true : false;
}
template <typename S, typename T>
inline bool Max(S &a, const T &b) {
return a < b ? a = b, true : false;
}
template <typename S, typename T>
inline void Adm(S &a, const T &b) {
a = (a + b) % MOD;
if (a < 0) a += MOD;
}
const int N = 1e6 + 100;
int d[N], r[N];
int main() {
vector<pair<int, int>> e, p;
int n, m, cnt = 0;
cin >> n >> m;
for (int i = 1; i <= m; ++i) {
int u, v;
scanf("%d%d", &u, &v);
e.push_back({u, v}), ++d[u], ++d[v];
}
srand(time(NULL));
random_shuffle((e).begin(), (e).end());
for (int i = 0; i < m; ++i) {
int u = e[i].first, v = e[i].second;
if (d[u] - r[u] - 1 >= (d[u] + 1) / 2 && d[v] - r[v] - 1 >= (d[v] + 1) / 2)
++r[u], ++r[v];
else
p.push_back(e[i]);
}
cout << ((int)(p).size()) << endl;
for (auto it : p) printf("%d %d\n", it.first, it.second);
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
uint64_t rnd_data = 0xDEADBEEFDULL;
inline void my_srand(int seed) { rnd_data = ((uint64_t)seed << 16) | 0x330E; }
inline int my_rand() {
rnd_data = rnd_data * 0x5DEECE66DULL + 0xB;
return (rnd_data >> 17) & 0x7FFFFFFF;
}
template <typename T>
void my_random_shuffle(T b, T e) {
for (int i = (1); i <= (int)((int)(e - b) - 1); i++) {
swap(b[i], b[my_rand() % (i + 1)]);
}
}
template <class _T>
inline _T sqr(const _T &x) {
return x * x;
}
template <typename type_t, typename less_t = std::less<type_t>>
inline bool uin(type_t &a, const type_t &b, const less_t &ls = less_t()) {
return ls(b, a) ? a = b, true : false;
}
template <typename type_t, typename less_t = std::less<type_t>>
inline bool uax(type_t &a, const type_t &b, const less_t &ls = less_t()) {
return ls(a, b) ? a = b, true : false;
}
const long double PI = 3.1415926535897932384626433832795L;
const long double EPS = 1e-9;
char s[2000];
int main() {
int p[10];
for (int i = 0; i < (int)(10); i++) {
p[i] = i;
}
int cnt = 0;
for (int ii = 0; ii < (int)(10); ii++) {
int i = p[ii];
printf("%d\n", i);
fflush(stdout);
fgets(s, sizeof(s), stdin);
s[strlen(s) - 1] = '\0';
int len = strlen(s);
string h;
for (int i = 0; i < (int)(len); i++) {
if (isalpha(s[i])) h += s[i];
}
strcpy(s, h.c_str());
if (!strcmp(s, "no")) {
cnt++;
if (cnt > 3) {
puts("normal");
return 0;
}
continue;
}
if (!strcmp(s, "great") || !strcmp(s, "dontthinkso") ||
!strcmp(s, "notbad") || !strcmp(s, "cool") ||
!strcmp(s, "donttouchme")) {
puts("normal");
} else if (!strcmp(s, "areyouserious") || !strcmp(s, "donteven") ||
!strcmp(s, "worse") || !strcmp(s, "terrible") ||
!strcmp(s, "godieinahole") || !strcmp(s, "noway")) {
puts("grumpy");
} else {
for (;;)
;
}
return 0;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
for (int q = 0; q < T; q++) {
int n;
cin >> n;
vector<int> h(n), t(n);
for (int i = 0; i < n; i++) cin >> h[i];
for (int i = 0; i < n; i++) cin >> t[i];
int wanted_index = 0;
while (true) {
int required_initially = h[wanted_index] - t[wanted_index];
int forwarded = 0;
bool flag = true;
bool goku = false;
for (int i = (wanted_index + 1) % n; i != wanted_index; i = (i + 1) % n) {
if (forwarded + t[i] < h[i]) {
if (wanted_index > i) {
cout << "NO" << endl;
goku = true;
break;
}
wanted_index = i;
flag = false;
break;
} else {
forwarded = min(t[i], forwarded + t[i] - h[i]);
}
}
if (goku) {
break;
}
if (flag) {
if (forwarded >= required_initially) {
cout << "YES" << endl;
break;
} else {
cout << "NO" << endl;
break;
}
}
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000 + 10;
int k;
int n;
bool cmp(int a, int b) { return a > b; }
vector<int> vec;
string a, b;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cin >> k;
while (k) {
cin >> n >> a >> b;
vec.clear();
bool no = 0;
int dif = 0;
for (int i = 0; i < n; i++) {
if (a[i] != b[i]) {
dif++;
if (dif > 2)
no = 1;
else
vec.push_back(i);
}
}
if (dif != 2)
cout << "No\n";
else {
if ((a[vec[0]] == a[vec[1]] && b[vec[1]] == b[vec[0]]) ||
(a[vec[0]] == b[vec[0]] && a[vec[1]] == b[vec[1]]))
cout << "Yes\n";
else
cout << "No\n";
}
k--;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void read() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
int n, k;
deque<int> dq;
vector<long long> q;
vector<pair<int, int> > t;
void solve() {
int maxx = -1;
for (int i = 0; i < n; i++) {
maxx = max(maxx, dq[i]);
}
int c = 0;
while (1) {
if (dq.front() == maxx) break;
t.push_back(make_pair(dq[0], dq[1]));
c++;
int a = dq.front();
dq.pop_front();
int b = dq.front();
dq.pop_front();
if (a > b) {
dq.push_back(b);
dq.push_front(a);
} else {
dq.push_back(a);
dq.push_front(b);
}
}
for (int i = 0; i < k; i++) {
if (q[i] <= c) {
cout << t[q[i] - 1].first << " " << t[q[i] - 1].second << "\n";
} else {
long long t1 = (q[i] - c) % (n - 1);
if (t1 == 0) t1 = n - 1;
cout << dq[0] << " " << dq[t1] << "\n";
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n >> k;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
dq.push_back(a);
}
for (int i = 0; i < k; i++) {
long long a;
cin >> a;
q.push_back(a);
}
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> best;
long long mm;
long long cube(long long x) { return x * x * x; }
void f(long long m, long long c, long long s) {
if (m == 0) {
best = max(best, {c, s});
return;
}
long long x = 0;
while (cube(x) <= m) x++;
x--;
f(m - cube(x), c + 1, s + cube(x));
if (x > 1) f(cube(x) - 1 - cube(x - 1), c + 1, s + cube(x - 1));
}
int main() {
scanf("%I64d", &mm);
f(mm, 0, 0);
printf("%I64d %I64d", best.first, best.second);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll base = 1000000007;
int n;
ll p2[1000000];
class reimu {
public:
ll sum, sum2;
int sz;
ll ans = 0;
void operator+=(reimu x) {
(sum2 += x.sum2) %= base;
(sum += x.sum) %= base;
sz += x.sz;
}
void operator-=(reimu x) {
(sum2 -= x.sum2) %= base;
(sum -= x.sum) %= base;
sz -= x.sz;
}
void cal() {
(ans = sum2 * p2[sz - 1] +
((sz == 1) ? 0 : ((sum * sum - sum2) % base) * p2[sz - 2])) %= base;
}
} f[1000000];
ll pre[64];
int main() {
p2[0] = 1;
for (int i = 1; i < 1000000; i++) (p2[i] = p2[i - 1] * 2) %= base;
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < 64; i++) {
for (int d = 0, p10 = 1; d < 6; d++, p10 *= 10)
if (i & (1 << d)) {
pre[i] += p10;
}
}
for (int i = 0; i < n; i++) {
ll a;
cin >> a;
reimu temp;
temp.sum = a;
(temp.sum2 = a * a) %= base;
temp.sz = 1;
f[a] += temp;
}
for (int x = 999999; x >= 0; x--) {
int mask = 0;
for (int d = 0, p10 = 1; d < 6; d++, p10 *= 10) {
if ((x / p10) % 10 != 9) mask |= 1 << d;
}
for (int sub = mask; sub; (sub -= 1) &= mask) {
if (__builtin_popcount(sub) % 2 == 1)
f[x] += f[x + pre[sub]];
else
f[x] -= f[x + pre[sub]];
}
}
for (int i = 0; i <= 999999; i++) f[i].cal();
ll ans = 0;
for (int x = 0; x <= 999999; x++) {
int mask = 0;
for (int d = 0, p10 = 1; d < 6; d++, p10 *= 10) {
if ((x / p10) % 10 != 9) mask |= 1 << d;
}
ll res = f[x].ans;
for (int sub = mask; sub; (sub -= 1) &= mask) {
if (__builtin_popcount(sub) % 2 == 0)
res += f[x + pre[sub]].ans;
else
res -= f[x + pre[sub]].ans;
}
((res %= base) += base) %= base;
(res *= x);
ans ^= res;
}
cout << ans << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int a[333], res, n;
vector<int> e[333], ae[333];
int bfs[1000000];
void dfs(int i, int& r, int now, int need[], int get[]) {
get[i] = 1;
r--;
for (int j = 0; j < ae[i].size(); j++) {
need[ae[i][j]]--;
if (need[ae[i][j]] == 0 && a[ae[i][j]] == now)
dfs(ae[i][j], r, now, need, get);
}
}
void go(int now) {
int r = n, i, j;
int get[333] = {};
int need[333];
for (i = 1; i <= n; i++) need[i] = e[i].size();
int yo = 0;
while (r) {
for (i = 1; i <= n; i++) {
if (a[i] == now && need[i] == 0 && get[i] == 0) {
dfs(i, r, now, need, get);
}
}
now = now % 3 + 1;
if (r) yo++;
}
res = min(res, yo);
}
int main() {
res = 1000000000;
int i, j, k;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (j = 1; j <= n; j++) {
int m;
scanf("%d", &m);
for (k = 0; k < m; k++) {
int x;
scanf("%d", &x);
e[j].push_back(x);
ae[x].push_back(j);
}
}
for (i = 1; i <= 3; i++) go(i);
printf("%d\n", res + n);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n, x, y, c;
long long cal(long long n, long long m, long long t) {
if (n < m) swap(n, m);
if (t <= m)
return ((t + 1) * t) / 2;
else {
long long v = ((m - 1) * m) / 2;
t -= (m - 1);
if (t <= n - m + 1)
return v + t * m;
else {
v += (n - m + 1) * m;
t -= (n - m + 1);
if (t <= m - 1)
v += ((2 * m - 1 - t) * t) / 2;
else
v += ((m - 1) * m) / 2;
}
return v;
}
}
bool check(long long t) {
long long sum =
(long long)1 - (min(x, t + 1) + min(t + 1, y) + min(n - x + 1, t + 1) +
min(n - y + 1, t + 1));
sum += cal(x, y, t + 1);
sum += cal(n - x + 1, n - y + 1, t + 1);
sum += cal(n - x + 1, y, t + 1);
sum += cal(x, n - y + 1, t + 1);
return sum >= c;
}
int main() {
cin >> n >> x >> y >> c;
long long l = 0, r = 2 * n;
while (r >= l) {
long long mid = (l + r) / 2;
if (check(mid))
r = mid - 1;
else
l = mid + 1;
}
cout << r + 1 << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int dp[105][105][11];
int n, m, k;
vector<string> v;
int val;
string z = "";
void rec(int i, int j, int r, int ans) {
if (i == n - 1) {
return;
}
int x = v[i][j] - '0';
if (j - 1 >= 0) {
for (int ri = 0; ri < k; ri++) {
if ((((ri + x) % k) == r) && (dp[i + 1][j - 1][ri] == ans - x)) {
val = j - 1;
rec(i + 1, j - 1, ri, ans - x);
z += 'R';
return;
}
}
}
if (j + 1 < m) {
for (int ri = 0; ri < k; ri++) {
if ((((ri + x) % k) == r) && (dp[i + 1][j + 1][ri] == ans - x)) {
val = j + 1;
rec(i + 1, j + 1, ri, ans - x);
z += 'L';
return;
}
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> m >> k;
k++;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
v.push_back(s);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int r = 0; r < k; r++) {
dp[i][j][r] = -1e6;
}
}
}
for (int j = 0; j < m; j++) {
int x = v[n - 1][j] - '0';
dp[n - 1][j][x % k] = x;
}
for (int i = n - 2; i >= 0; i--) {
for (int j = 0; j < m; j++) {
for (int r = 0; r < k; r++) {
int x = v[i][j] - '0';
if (j - 1 >= 0)
dp[i][j][(r + x) % k] =
max(dp[i][j][(r + x) % k], dp[i + 1][j - 1][r] + x);
if (j + 1 < m)
dp[i][j][(r + x) % k] =
max(dp[i][j][(r + x) % k], dp[i + 1][j + 1][r] + x);
}
}
}
int ans = -1e6;
for (int j = 0; j < m; j++) {
ans = max(ans, dp[0][j][0]);
}
if (ans < 0) {
ans = -1;
}
cout << ans << '\n';
if (ans >= 0) {
for (int j = 0; j < m; j++) {
if (dp[0][j][0] == ans) {
rec(0, j, 0, ans);
cout << val + 1 << '\n' << z;
return 0;
}
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
mt19937 gen(time(0));
int n, m;
vector<int> from;
vector<long long> dis;
vector<bool> v;
vector<vector<pair<int, long long>>> edge;
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
greater<pair<long long, int>>>
pq;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
dis.resize(n, 1e15);
from.resize(n, 0);
v.resize(n, 0);
edge.resize(n);
int a, b;
long long c;
for (int i = 0; i < m; i++) {
cin >> a >> b >> c;
--a, --b;
edge[b].push_back({a, c});
edge[a].push_back({b, c});
}
dis[0] = 0;
pq.push({dis[0], 0});
while (!pq.empty()) {
auto u = pq.top();
pq.pop();
if (v[u.second]) continue;
v[u.second] = 1;
for (auto i : edge[u.second]) {
if (dis[i.first] > u.first + i.second) {
dis[i.first] = u.first + i.second;
from[i.first] = u.second;
pq.push({dis[i.first], i.first});
}
}
}
if (dis[n - 1] == 1e15) {
cout << -1 << '\n';
return 0;
}
vector<int> ans;
int x = n - 1;
while (x != 0) {
ans.push_back(x);
x = from[x];
}
ans.push_back(x);
reverse(ans.begin(), ans.end());
for (auto i : ans) cout << i + 1 << " ";
cout << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
long long a[n], b[n];
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) cin >> b[i];
long long neg = 0, pos = 0, res = 1;
for (long long i = 0; i < n; i++) {
if (a[i] < b[i] && pos == 0) res = 0;
if (a[i] > b[i] && neg == 0) res = 0;
if (a[i] == 1) pos++;
if (a[i] == -1) neg++;
}
if (res)
cout << "YES" << endl;
else
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct E {
int x, y;
};
E map1[1010], map2[1010], map3[1010];
int vis[1010];
int n, flag;
void dfs(int k) {
if (k == n + 1) {
cout << map3[n].x << " " << map3[n].y;
flag = 1;
return;
} else {
for (int i = 1; i <= n; i++) {
if (!vis[i]) {
if (map1[k].x + map2[i].x == map3[k - 1].x &&
map1[k].y + map2[i].y == map3[k - 1].y) {
vis[i] = 1;
map3[k].x = map1[k].x + map2[i].x;
map3[k].y = map1[k].y + map2[i].y;
dfs(k + 1);
if (flag) {
break;
}
vis[i] = 0;
}
}
}
}
}
int main(int argc, char *argv[]) {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> map1[i].x >> map1[i].y;
}
for (int i = 1; i <= n; i++) {
cin >> map2[i].x >> map2[i].y;
}
for (int i = 1; i <= n; i++) {
map3[1].x = map1[1].x + map2[i].x;
map3[1].y = map1[1].y + map2[i].y;
vis[i] = 1;
dfs(2);
vis[i] = 0;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
#define ll long long
#define all(x) (x).begin(), (x).end()
#define allr(x) (x).rbegin(), (x).rend()
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
set<int> st;
while(n) {
if(st.count(n%m))
return cout << "NO", 0;
st.insert(n%m);
n /= m;
}
cout << "YES";
return 0;
} | 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
string s;
cin >> s;
int ans = 0, cnt = 0, knt = 0;
for (int i = 0; i < s.size(); i++) {
if ((s[i] - '0') % 3 == 0) {
cnt++;
ans = 0;
knt = 0;
} else {
ans += (s[i] - '0') % 3;
knt++;
if (ans % 3 == 0) {
cnt++;
ans = 0;
knt = 0;
} else if (knt == 3) {
cnt++;
ans = 0;
knt = 0;
}
}
}
cout << cnt << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
int print_value(A title, B val) {
cout << title << " = " << val << "\n";
return 1;
}
int break_point() {
char c;
while ((c = getchar()) != '\n')
;
return 0;
}
template <typename A>
int logg(A v) {
cout << v << "\n";
return 0;
}
template <typename T>
void read_integer(T &r) {
bool sign = 0;
r = 0;
char c;
while (1) {
c = getchar();
if (c == '-') {
sign = 1;
break;
}
if (c != ' ' && c != '\n') {
r = c - '0';
break;
}
}
while (1) {
c = getchar();
if (c == ' ' || c == '\n') break;
r = r * 10 + (c - '0');
}
if (sign) r = -r;
}
void run();
int main() {
srand(time(NULL));
do {
run();
if (0) {
0 ? printf("-------------------------------\n") : 0;
0 ? printf("-------------------------------\n") : 0;
}
} while (0);
return 0;
}
long long binpow(long long a, long long b) {
if (b == 0) return 1;
long long c = binpow(a, b >> 1);
if (b & 1)
return (((c * c) % 1000000007) * a) % 1000000007;
else
return (c * c) % 1000000007;
}
void run() {
int p, k;
scanf("%d%d", &p, &k);
int res = 0;
if (k == 0)
res = binpow(p, p - 1);
else if (k == 1)
res = binpow(p, p);
else {
int m = 1, K = k;
while (K != 1) {
m++;
K = (1ll * K * k) % p;
}
res = binpow(p, (p - 1) / m);
}
printf("%d", res);
putchar('\n');
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int a, b, c;
cin >> a >> b >> c;
for (int i = 0; i * a <= c; ++i) {
if ((c - a * i) % b) continue;
puts("Yes");
return 0;
}
puts("No");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double n, k, l, v1, v2, x;
cin >> n >> l >> v1 >> v2 >> k;
n = ceil(n / k);
x = n / (v2 - v1) + (n - 1) / (v2 + v1);
printf("%.12lf", l / (v1 + 1 / x));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
string s;
cin >> s;
long long ans1 = 0;
long long ans0 = 0;
for (int i = 0; i < n - 1; i++) {
if (s[i] == s[i + 1]) {
if (s[i] == '1')
ans1++;
else
ans0++;
}
}
cout << max(ans1, ans0) << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 405;
const int mod = 1e9 + 7;
int n, m, ans;
int a[N][N], p[N * N], l[N][N], r[N][N], R[N], pos;
int main() {
scanf("%d%d", &n, &m);
for (int i = (1); i < (n + 1); i++)
for (int j = (1); j < (m + 1); j++) scanf("%d", &a[i][j]), r[i][j] = m + 1;
for (int i = (1); i < (n + 1); i++) {
for (int j = (1); j < (m + 1); j++) {
p[a[i][j]] = j;
for (int k = (1); k < (i); k++) l[k][j] = max(l[k][j], p[a[k][j]]);
}
for (int j = (1); j < (m + 1); j++) p[a[i][j]] = 0;
for (int j = m; j >= 1; j--) {
p[a[i][j]] = j;
for (int k = (1); k < (i); k++)
if (p[a[k][j]]) r[k][j] = min(r[k][j], p[a[k][j]]);
}
for (int j = (1); j < (m + 1); j++) R[j] = m;
for (int j = (1); j < (m + 1); j++) p[a[i][j]] = 0;
for (int j = (1); j < (m + 1); j++) l[i][j] = p[a[i][j]], p[a[i][j]] = j;
for (int j = (1); j < (m + 1); j++) p[a[i][j]] = m + 1;
for (int j = m; j >= 1; j--) r[i][j] = p[a[i][j]], p[a[i][j]] = j;
for (int j = (1); j < (m + 1); j++) p[a[i][j]] = 0;
for (int k = i; k >= 1; k--) {
for (int j = (1); j < (m + 1); j++) {
R[l[k][j]] = min(R[l[k][j]], j - 1);
R[j] = min(R[j], r[k][j] - 1);
}
for (int j = m - 1; j >= 1; j--) R[j] = min(R[j], R[j + 1]);
for (int j = (1); j < (m + 1); j++)
ans = max(ans, (i - k + 1) * (R[j] - j + 1));
}
}
printf("%d", ans);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1.0e-11;
const double pi = acos(-1.0);
struct point {
double x, y;
point() {}
point(double a, double b) : x(a), y(b) {}
void rot(double alpha) {
double nx = x * cos(alpha) - y * sin(alpha);
double ny = x * sin(alpha) + y * cos(alpha);
x = nx, y = ny;
}
double dist(point a) {
return sqrt(((x - a.x) * (x - a.x)) + ((y - a.y) * (y - a.y)));
}
};
double area(point a, point b, point c) {
double x = a.dist(b);
double y = b.dist(c);
double z = a.dist(c);
double p = (x + y + z) / 2;
return sqrt(p * (p - x) * (p - y) * (p - z));
}
int main() {
double w, h, alpha;
cin >> w >> h >> alpha;
if (alpha == 0 || alpha == 180) {
printf("%.7lf", w * h);
return 0;
}
if (h > w) {
swap(h, w);
}
if (alpha > 90) alpha = 180 - alpha;
alpha = alpha * pi / 180;
double res;
if (alpha < 2 * atan(h / w)) {
point p1(w / 2, -h / 2);
point p2(-w / 2, -h / 2);
p1.rot(alpha);
p2.rot(alpha);
double x = w / 2;
point q1(x, (x - p1.x) / (p2.x - p1.x) * (p2.y - p1.y) + p1.y);
double y = -h / 2;
point q2((y - p1.y) / (p2.y - p1.y) * (p2.x - p1.x) + p1.x, y);
res = w * h - 2 * area(q1, q2, point(w / 2, -h / 2));
res -= p1.dist(q1) * p1.dist(q1) / tan(alpha);
} else {
point p1(w / 2, -h / 2);
point p2(w / 2, h / 2);
point p3(-w / 2, h / 2);
point p4(-w / 2, -h / 2);
p1.rot(alpha);
p2.rot(alpha);
p3.rot(alpha);
p4.rot(alpha);
double y = h / 2;
point q1((y - p1.y) / (p4.y - p1.y) * (p4.x - p1.x) + p1.x, y);
point q2((y - p2.y) / (p3.y - p2.y) * (p3.x - p2.x) + p2.x, y);
res = w * h - 2 * area(q1, q2, p2) - 2 * area(p1, p2, q1);
}
printf("%.7lf\n", res);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int x;
scanf("%d", &x);
return x;
}
const int mod = 998244353;
int Base;
int pw[1000005], Pre[1000005], A[1000005], Aft[1000005], Num[1000005], n, m;
set<int> Ans;
inline bool Judge(int l, int r) {
if (l > r) return true;
int s_pre = Pre[r] - 1ll * pw[r - l + 1] * Pre[l - 1] % mod;
int s_aft = Aft[l] - 1ll * pw[r - l + 1] * Aft[r + 1] % mod;
return (s_pre + mod) % mod == (s_aft + mod) % mod;
}
inline int Get(int l, int r) {
int len = (r - l + 1);
if (len % 2 == 1)
return 2 * Num[l + len / 2];
else if (len % 2 == 0)
return Num[l + len / 2] + Num[l + len / 2 - 1];
}
int main() {
n = gi();
m = gi();
for (int i = 1; i <= n; i++) Num[i] = gi();
sort(A + 1, A + n + 1);
for (int i = 1; i <= n - 1; i++) A[i] = Num[i + 1] - Num[i];
Base = 1989;
pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = 1ll * pw[i - 1] * Base % mod;
Pre[0] = 0;
for (int i = 1; i <= n - 1; i++)
Pre[i] = (1ll * Pre[i - 1] * Base % mod + A[i]) % mod;
Aft[n] = 0;
for (int i = n - 1; i >= 1; i--)
Aft[i] = (1ll * Aft[i + 1] * Base % mod + A[i]) % mod;
Ans.clear();
if (Judge(1, n - 1)) Ans.insert(Get(1, n) % m);
int D = (Num[1] + Num[1]) % mod;
for (int i = 1; i <= n; i++) {
if (2 * Num[i] % m != D) break;
if (i == n) Ans.insert(2 * Num[i] % m);
}
int l1, l2, r1, r2;
for (int r = 1; r <= n - 1; r++) {
l1 = 1;
r1 = r;
l2 = r + 1;
r2 = n;
if (Get(l1, r1) + m == Get(l2, r2) && Judge(l1, r1 - 1) &&
Judge(l2, r2 - 1))
Ans.insert(Get(l1, r1) % m);
}
cout << (int)(Ans.size()) << endl;
for (set<int>::iterator it = Ans.begin(); it != Ans.end(); it++)
cout << (*it) << " ";
cout << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 10;
int n, m, a[MAXN], b[MAXN];
int t[4 * MAXN];
int X[MAXN], Y[MAXN];
int lg() {
int l = 1;
while (l <= n) l *= 2;
return l;
}
void push(int v, int l, int r) {
if (l != r) {
t[2 * v + 1] = t[v];
t[2 * v + 2] = t[v];
t[v] = 0;
}
}
int get(int v, int l, int r, int pos) {
lg();
if (t[v] != 0) {
push(v, l, r);
}
if (l == r) {
return t[v];
} else {
int mid = (l + r) / 2;
if (pos <= mid)
return get(2 * v + 1, l, mid, pos);
else
return get(2 * v + 2, mid + 1, r, pos);
}
}
void update(int v, int l, int r, int ql, int qr, int val) {
lg();
if (t[v] != 0) {
push(v, l, r);
}
if (ql <= l && r <= qr) {
t[v] = val;
} else if (ql > r || l > qr) {
return;
} else {
int mid = (l + r) / 2;
update(2 * v + 1, l, mid, ql, qr, val);
update(2 * v + 2, mid + 1, r, ql, qr, val);
}
}
int main() {
for (int i = 0; i < 4 * MAXN; ++i) {
t[i] = 0;
}
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
scanf("%d", a + i);
}
for (int i = 0; i < n; ++i) {
scanf("%d", b + i);
}
int op, i, x, y, k;
int upd_ind = 1;
ostringstream ss;
for (int mm = 0; mm < m; ++mm) {
scanf("%d", &op);
switch (op) {
case 1:
scanf("%d%d%d", &x, &y, &k);
x--, y--;
X[upd_ind] = x;
Y[upd_ind] = y;
update(0, 0, n - 1, y, y + k - 1, upd_ind);
upd_ind++;
break;
case 2:
scanf("%d", &i);
i--;
int q = get(0, 0, n - 1, i);
if (q == 0) {
ss << b[i] << "\n";
} else {
ss << a[i - Y[q] + X[q]] << "\n";
}
break;
}
}
cout << ss.str();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int l[n], r[n];
for (int i = 0; i < n; i++) cin >> l[i] >> r[i];
int lsum = 0, rsum = 0;
for (int i = 0; i < n; i++) {
lsum += l[i];
rsum += r[i];
}
int maxdiff = abs(lsum - rsum), maxdiffindex = 0;
bool ispossible = false;
for (int i = 0; i < n; i++) {
int t1 = lsum + r[i] - l[i];
int t2 = rsum + l[i] - r[i];
if (maxdiff < abs(t1 - t2)) {
ispossible = true;
maxdiff = abs(t1 - t2);
maxdiffindex = i;
}
}
if (ispossible)
cout << (maxdiffindex + 1) << "\n";
else
cout << 0 << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main(int argc, const char* argv[]) {
long long n;
std::cin >> n;
long long cpt = (n + 1) / 2.0 + n / 6.0;
std::cout << cpt << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1000000000000000000;
long long mod = 1000000000;
long double pi = 3.141592653589793238;
void pls() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const long long N = 2e2 + 5;
long long n, k;
vector<long long> val;
vector<long long> g[N];
long long dp[N][N];
void dfs(int ix = 0, int p = -1) {
dp[ix][0] = val[ix];
for (auto x : g[ix]) {
if (x == p) continue;
dfs(x, ix);
dp[ix][0] += dp[x][k - 1];
}
for (int j = 0; j < k; j++) {
for (auto x : g[ix]) {
if (x == p) continue;
long long sum = 0;
sum += dp[x][j];
int mn = j;
int tak;
for (auto y : g[ix]) {
if (y == p || y == x) continue;
tak = max(k - mn - 2, j * 1LL);
sum += dp[y][tak];
mn = min(tak, mn);
}
dp[ix][j + 1] = max(dp[ix][j + 1], sum);
}
}
for (int j = k - 1; j >= 0; j--) dp[ix][j] = max(dp[ix][j], dp[ix][j + 1]);
}
void solve() {
cin >> n >> k;
k++;
val.resize(n);
for (int i = 0; i < n; i++) {
cin >> val[i];
}
for (int j = 0; j < n - 1; j++) {
int u, v;
cin >> u >> v;
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
dfs();
cout << dp[0][0] << endl;
}
int main() {
pls();
solve();
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct atype {
int ty, v;
char ch;
};
atype op[100010];
int depth2[100010], lg2[100010], depth1[100010];
long long hash2[100010][20], p[100010][20];
long long ex[100010];
char upedge[100010];
int cmp(int x, int y) {
if (x == y) return 0;
for (int k = (19); k >= (0); k--) {
if ((1 << k) > depth2[x] || (1 << k) > depth2[y]) continue;
if (hash2[x][k] == hash2[y][k]) x = p[x][k], y = p[y][k];
}
if (x == 1 && y == 1) return 0;
if (x == 1) return 1;
if (y == 1) return 0;
return upedge[x] < upedge[y];
}
int movedep(int x, int y) {
while (y) x = p[x][lg2[y & -y]], y -= y & -y;
return x;
}
int sa[100010], where[100010];
int l[100010], r[100010];
struct treearray {
int n;
int ta[100010];
void clear(int _n) {
n = _n;
memset(ta, 0, sizeof ta);
}
void serere(int x, int y) {
while (x <= n) ta[x] += y, x += x & -x;
}
int query(int x) {
int res = 0;
while (x) res += ta[x], x -= x & -x;
return res;
}
int query(int x, int y) { return query(y) - query(x - 1); }
};
void lemon() {
ex[0] = 1;
for (int i = (1); i <= (100010 - 1); i++) ex[i] = ex[i - 1] * 1684593863;
lg2[1] = 0;
for (int i = (2); i <= (100010 - 1); i++) lg2[i] = lg2[i >> 1] + 1;
int qa;
scanf("%d", &qa);
int t1 = 1, t2 = 1;
depth2[1] = 0;
for (int i = (1); i <= (qa); i++) {
static char buf[100];
int x, y;
scanf("%d%d%s", &x, &y, buf);
op[i].ty = x;
op[i].v = y;
op[i].ch = buf[0];
if (x == 2) {
t2++;
depth2[t2] = depth2[y] + 1;
upedge[t2] = op[i].ch;
p[t2][0] = y;
hash2[t2][0] = op[i].ch;
for (int k = (1); k <= (lg2[depth2[t2]]); k++) {
p[t2][k] = p[p[t2][k - 1]][k - 1];
hash2[t2][k] =
hash2[p[t2][k - 1]][k - 1] * ex[1 << (k - 1)] + hash2[t2][k - 1];
}
}
}
for (int i = (1); i <= (t2); i++) sa[i] = i;
stable_sort(sa + 1, sa + t2 + 1, cmp);
for (int i = (1); i <= (t2); i++) where[sa[i]] = i;
static treearray ta, tb;
ta.clear(t2);
ta.serere(where[1], 1);
tb.clear(t2);
tb.serere(1, 1);
long long final = 1;
int t3 = 1;
l[1] = 1;
r[1] = t2;
depth1[1] = 0;
for (int cq = (1); cq <= (qa); cq++) {
int ty = op[cq].ty, v = op[cq].v;
char ch = op[cq].ch;
if (ty == 1) {
t1++;
depth1[t1] = depth1[v] + 1;
if (l[v] > r[v]) {
l[t1] = l[v];
r[t1] = r[v];
} else {
{
if (upedge[movedep(sa[l[v]], depth1[t1] - 1)] > ch)
r[t1] = l[v] - 1;
else {
int left = l[v], right = r[v];
while (left != right) {
int mid = (left + right + 1) / 2;
if (upedge[movedep(sa[mid], depth1[t1] - 1)] <= ch)
left = mid;
else
right = mid - 1;
}
r[t1] = left;
}
}
{
if (upedge[movedep(sa[r[v]], depth1[t1] - 1)] < ch)
l[t1] = r[v] + 1;
else {
int left = l[v], right = r[v];
while (left != right) {
int mid = (left + right) / 2;
if (upedge[movedep(sa[mid], depth1[t1] - 1)] >= ch)
right = mid;
else
left = mid + 1;
}
l[t1] = left;
}
}
}
if (l[t1] <= r[t1]) {
final += ta.query(l[t1], r[t1]);
tb.serere(l[t1], 1);
tb.serere(r[t1] + 1, -1);
}
} else {
t3++;
ta.serere(where[t3], 1);
final += tb.query(where[t3]);
}
printf("%I64d\n", final);
}
}
int main() {
ios::sync_with_stdio(true);
lemon();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const double PI = 4 * atan(1);
int T, N;
int A[100013];
bool used[100013];
int pre[100013], rep[100013];
vector<vector<int> > ans;
int getk(int n) {
int k = 1;
while (k * (k + 1) / 2 <= n) ++k;
return k - 1;
}
vector<int> lis() {
vector<int> v;
for (int i = 0; i < N; i++) {
if (used[A[i]]) continue;
auto it = lower_bound(v.begin(), v.end(), A[i]);
pre[A[i]] = (it == v.begin() ? -1 : it[-1]);
if (it == v.end())
rep[A[i]] = -1, v.push_back(A[i]);
else
rep[A[i]] = *it, *it = A[i];
}
return v;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> T;
while (T--) {
cin >> N;
for (int i = 0; i < N; i++) cin >> A[i];
memset(used, 0, sizeof used);
ans.clear();
int total = 0;
while (total < N) {
int k = getk(N - total);
auto v = lis();
if (v.size() <= k) {
for (int x : v) {
vector<int> cur;
for (int j = x; j != -1; j = rep[j]) cur.push_back(j);
reverse(cur.begin(), cur.end());
ans.push_back(move(cur));
}
total = N;
} else {
vector<int> cur;
for (int j = v.back(); j != -1; j = pre[j])
cur.push_back(j), used[j] = true;
reverse(cur.begin(), cur.end());
total += cur.size();
ans.push_back(move(cur));
}
}
cout << ans.size() << '\n';
for (auto& seq : ans) {
cout << seq.size();
for (int x : seq) cout << ' ' << x;
cout << '\n';
}
}
cout.flush();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1010;
const int M = 105;
int n, m, c0, d0, a[M], b[M], c[M], d[M];
int ct, f[N], v[N << 1], cost[N << 1];
int main() {
int i, j, tmp, tmp2;
scanf("%d%d%d%d", &n, &m, &c0, &d0);
for (i = 0; i < m; i++) scanf("%d%d%d%d", a + i, b + i, c + i, d + i);
ct = 0;
tmp = n;
while (tmp >= c0) {
v[ct] = d0;
cost[ct++] = c0;
tmp -= c0;
}
for (i = 0; i < m; i++) {
tmp = n;
tmp2 = a[i];
while (tmp >= c[i] && tmp2 >= b[i]) {
v[ct] = d[i];
cost[ct++] = c[i];
tmp -= c[i];
tmp2 -= b[i];
}
}
memset(f, 0, sizeof(f));
for (i = 0; i < ct; i++)
for (j = n; j >= cost[i]; j--) f[j] = max(f[j], f[j - cost[i]] + v[i]);
printf("%d\n", f[n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int sum, ans, i, num[110], now;
char ch, mk[110];
while (cin >> ch) {
sum = 0;
mk[0] = '+';
while (cin >> mk[++sum]) {
if (mk[sum] == '=') {
cin >> ans;
break;
} else
cin >> ch;
}
for (i = 0; i < sum; i++) num[i] = 1;
now = 0;
for (i = 0; i < sum; i++) {
if (mk[i] == '+')
now++;
else
now--;
}
now -= ans;
for (i = 0; i < sum; i++) {
if (mk[i] == '+') {
if (!now) continue;
if (now < 0) {
if (ans - num[i] >= -now) {
num[i] += -now;
now = 0;
} else {
now += ans - num[i];
num[i] = ans;
}
}
} else {
if (!now) continue;
if (now > 0) {
if (ans - num[i] >= now) {
num[i] += now;
now = 0;
} else {
now -= ans - num[i];
num[i] = ans;
}
}
}
}
if (now == 0) {
cout << "Possible" << endl;
cout << num[0] << ' ';
for (i = 1; i < sum; i++) {
cout << mk[i] << " " << num[i] << " ";
}
cout << "= " << ans << endl;
} else
cout << "Impossible" << endl;
}
}
| 5 |
#include <bits/stdc++.h>
int main() {
int i, j, k, count, p, n, m;
scanf("%d", &n);
for (i = 5, m = 0; i <= n; i++) {
for (j = 2, count = 0; j <= i / 2; j++) {
if (i % j == 0) {
for (k = 2, p = 1; k <= j / 2; k++) {
if (j % k == 0) {
p = 0;
break;
}
}
if (p == 1) count++;
}
}
if (count == 2) m++;
}
printf("%d\n", m);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
string n, k;
bool isvowel(char x) {
return (x == 'a' || x == 'e' || x == 'u' || x == 'i' || x == 'o');
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
if (n.size() == k.size()) {
for (int i = 0; i < n.size(); i++) {
if (isvowel(n[i]) && !isvowel(k[i])) {
cout << "No";
return 0;
}
if (isvowel(k[i]) && !isvowel(n[i])) {
cout << "No";
return 0;
}
}
cout << "Yes";
} else
cout << "No";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005;
struct data {
int x, y, Y, v;
bool operator<(const data &a) const { return x < a.x; }
} a[N];
int b[N], cnt[N], n, x, y, t, m;
long long ans[N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d%d", &x, &y);
a[i] = {x, y, y + m, 1};
a[i + n] = {x + m, y, y + m, -1};
b[i] = y;
b[i + n] = y + m;
}
sort(b + 1, b + 2 * n + 1);
t = unique(b + 1, b + 2 * n + 1) - b - 1;
for (int i = 1; i <= 2 * n; ++i) {
a[i].y = lower_bound(b + 1, b + 1 + t, a[i].y) - b + 1;
a[i].Y = lower_bound(b + 1, b + 1 + t, a[i].Y) - b;
}
sort(a + 1, a + 2 * n + 1);
for (int i = 1; i <= 2 * n; ++i)
for (int j = a[i].y; j <= a[i].Y; ++j) {
ans[cnt[j]] += 1ll * (b[j] - b[j - 1]) * a[i].x;
cnt[j] += a[i].v;
ans[cnt[j]] -= 1ll * (b[j] - b[j - 1]) * a[i].x;
}
for (int i = 1; i <= n; ++i) cout << ans[i] << ' ';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
const int MaxN = 200001;
int a[MaxN];
int dp[MaxN];
int main() {
int n, k;
scanf("%d %d", &n, &k);
int v;
int last = -1;
long long ans = 1;
long long tmp = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &v);
if (v >= n - k + 1) {
tmp += v;
if (last == -1) {
last = i;
} else {
ans *= (i - last);
ans %= P;
last = i;
}
}
}
printf("%lld %lld\n", tmp, ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long double inf = 1e18;
bool valid(int n, long double l, long double u, long double v, int k,
long double t) {
if (n <= k) {
long double ti = l / v;
if (ti <= t)
return true;
else
return false;
}
if (t >= (l / u)) return true;
if (t < 0) return false;
long double l1 = l - u * t;
l1 = l1 * v;
l1 = l1 / (v - u);
long double tim1 = (l1) / (v);
long double d = (l1 - u * tim1);
long double tim2 = d / (v + u);
long double tim = tim1 + tim2;
t -= tim;
long double newl = l - l1 + v * tim2;
return valid(n - k, newl, u, v, k, t);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n1, l1, u1, v1, k1;
cin >> n1 >> l1 >> u1 >> v1 >> k1;
long double n, l, u, v, k;
n = n1;
l = l1;
u = u1;
v = v1;
k = k1;
long double ans = inf;
long double lo = 0, hi = (l / u);
for (int i = 1; i <= 100; i++) {
long double mid = (lo + hi) / 2.0;
if (valid(n1, l, u, v, k1, mid)) {
ans = min(ans, mid);
hi = mid;
} else
lo = mid;
}
cout << setprecision(20) << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i;
cin >> n;
long long int A[n], B[3];
for (i = 0; i < n; i++) cin >> A[i];
B[0] = B[1] = B[2] = 0;
for (i = 0; i < n; i++) B[A[i] % 3]++;
cout << B[0] / 2 + min(B[1], B[2]) << endl;
return (0);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long binpow(long long int a, long long int b) {
a %= 1000000007;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
b >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string n;
cin >> n;
long long int ans = 0;
long long int aux[100002], k = n.length();
for (long long int i = 0; i < 100002; i++) {
aux[i] = ((i + 1) * binpow(10, i)) % 1000000007;
if (i != 0) aux[i] = (aux[i] + aux[i - 1]) % 1000000007;
}
for (long long int i = 0; i < n.length(); i++) {
int p = int(n[i]) - 48;
if (i != k - 1)
ans = (ans + (p * aux[k - 2 - i]) % 1000000007) % 1000000007;
long long int u = k - 1 - i, v;
long long int g = ((i * (i + 1)) / 2) % 1000000007;
if (i != 0) {
v = (g * binpow(10, u)) % 1000000007;
ans = (ans + (p * v) % 1000000007) % 1000000007;
}
}
cout << ans << "\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, x, y, b, tx, ty;
cin >> x >> y;
if (x > 0 && y > 0) {
tx = abs(x);
ty = abs(y);
b = tx + ty;
cout << "0 " << b << " " << b << " 0" << endl;
return 0;
}
if (x < 0 && y > 0) {
tx = abs(x);
ty = abs(y);
b = tx + ty;
cout << "-" << b << " 0 0 " << b << endl;
return 0;
}
if (x < 0 && y < 0) {
tx = abs(x);
ty = abs(y);
b = tx + ty;
cout << "-" << b << " 0 0 -" << b << endl;
return 0;
} else {
tx = abs(x);
ty = abs(y);
b = tx + ty;
cout << "0 -" << b << " " << b << " 0" << endl;
return 0;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, sum = 0;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
sum += v[i];
}
vector<int> num(5);
for (int i = 0; i < 5; i++) num[i] = i + 1;
int count = 0;
for (int i = 0; i < 5; i++) {
if ((sum + num[i]) % (n + 1) != 1) count++;
}
cout << count;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, rs = 100000, t, S = 2001;
int k, w, i, j, ans = 0, tmp = 0, r = 0, u, x = 0, y = 0;
char ch;
int an = 0;
list<int> l;
queue<int> q;
vector<vector<int> > v2;
vector<int> v1;
void dfs(int node, int sz) {
v1[node] = 1;
for (int b = 0; b < sz; b++) {
if (v2[node][b] && !v1[b]) {
dfs(b, sz);
}
}
}
int main() {
ifstream fin("input.txt");
cin >> n;
v1 = vector<int>(n);
for (i = 0; i < n; i++) {
cin >> v1[i];
}
sort(v1.begin(), v1.end());
t = v1[0];
v1[0] = v1[n - 1];
v1[n - 1] = t;
for (i = 0; i < n; i++) {
cout << v1[i] << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e5 + 10;
void input() {
int n;
cin >> n;
vector<int> ans(n);
ans[0] = n;
for (int i = 1; i < n; ++i) {
ans[i] = i;
}
for (int i = 0; i < n; ++i) cout << ans[i] << " ";
cout << endl;
}
int main() {
input();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, n;
cin >> n >> a >> b;
if (b >= 0) {
int mod_b = (a + b) % n;
if (mod_b == 0) {
cout << n;
} else {
cout << mod_b;
}
} else {
int c = abs(b);
int mod_c = c % n;
if (mod_c == 0) {
cout << a;
} else {
if ((a + (n - mod_c)) % n == 0) {
cout << n;
} else {
cout << (a + (n - mod_c)) % n;
}
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Max = 300100;
vector<int> E[Max];
int pre[Max], Big[Max], num[Max];
int ans[Max];
void dfs1(int u) {
num[u] = 1;
Big[u] = 0;
for (int i = 0; i < E[u].size(); i++) {
pre[E[u][i]] = u;
dfs1(E[u][i]);
num[u] += num[E[u][i]];
Big[u] = max(Big[u], num[E[u][i]]);
}
}
bool Judge(int u, int v) {
if (num[v] * 2 >= num[u] && Big[v] * 2 <= num[u]) return true;
return false;
}
void dfs2(int u) {
if (num[u] == 1) {
ans[u] = u;
return;
}
int M = 0;
for (int i = 0; i < E[u].size(); i++) {
dfs2(E[u][i]);
if (num[E[u][M]] < num[E[u][i]]) {
M = i;
}
}
int c = ans[E[u][M]];
while (!Judge(u, c)) {
c = pre[c];
}
ans[u] = c;
}
int main() {
int n, q, u;
scanf("%d %d", &n, &q);
for (int i = 2; i <= n; i++) {
scanf("%d", &u);
E[u].push_back(i);
}
pre[1] = 1;
dfs1(1);
dfs2(1);
for (int i = 0; i < q; i++) {
scanf("%d", &u);
printf("%d\n", ans[u]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool prime(int n) {
if (n < 1) return false;
for (int x = 2; x * x <= n; x++) {
if (n % x == 0) return false;
}
return true;
}
struct node {
int value;
node* right;
node* left;
};
bool contine8(long long a) {
while (true) {
if (a % 10 == 8) return true;
a /= 10;
if (a == 0) break;
}
return false;
}
int n = 105, m = 105;
vector<int> v[300];
bool visited[300];
void DFS(int a) {
if (visited[a]) return;
visited[a] = true;
for (auto u : v[a]) {
DFS(u);
}
}
vector<pair<char, int>> split(string s) {
char c = s[0];
int count = 1;
vector<pair<char, int>> res;
auto ss = s.c_str();
for (int i = 1; i <= s.length(); i++) {
if (ss[i] != c) {
res.push_back({c, count});
c = s[i];
count = 1;
} else {
count++;
}
}
return res;
}
const int MAX = 2 * 1e5 + 2;
int main() {
int n, a, b;
cin >> n >> a >> b;
string s;
cin >> s;
a--;
b--;
if (s[a] == s[b])
return cout << 0, 0;
else
return cout << 1, 0;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e9 + 5;
vector<long long> v, u, vv;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long a = 2, b = 3;
vv.push_back(1);
while (a <= M) {
v.push_back(a);
vv.push_back(a);
a <<= 1LL;
}
while (b <= M) {
u.push_back(b);
vv.push_back(b);
b *= 3LL;
}
for (auto i : v)
for (auto j : u) vv.push_back(i * j);
sort(vv.begin(), vv.end());
unique(vv.begin(), vv.end());
int l, r;
cin >> l >> r;
int x = lower_bound(vv.begin(), vv.end(), l) - vv.begin();
int y = upper_bound(vv.begin(), vv.end(), r) - vv.begin();
cout << y - x;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using std::min;
const int oo = 2139062143;
int ones[1 << 15];
int n, m, k, ans1, ans2;
char s[15][100], t[100];
int f[1 << 15];
int main() {
ones[0] = 0;
for (int i = 1; i < 1 << 15; ++i) ones[i] = ones[i >> 1] + (i & 1);
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%s", s[i]);
ans1 = oo, ans2 = 0;
scanf("%d", &m);
for (int i = 1, x, pre; i <= m; ++i) {
scanf("%d", &k);
memset(f, 0x7F, sizeof(f));
f[0] = 0;
pre = 0;
while (k--) {
scanf("%s", t);
for (x = 0; x < n && strcmp(s[x], t); ++x)
;
if (x == n || (pre & (1 << x))) continue;
pre = (pre & ((1 << x) - 1)) | (1 << x);
for (int st = (1 << n) - 1; st >= 0; --st)
if (f[st] < oo && (st & (1 << x)) == 0)
f[st | (1 << x)] =
min(f[st | (1 << x)], f[st] + ones[st & ~((1 << x) - 1)]);
}
if (f[(1 << n) - 1] < ans1) {
ans1 = f[(1 << n) - 1];
ans2 = i;
}
}
if (ans2 == 0)
puts("Brand new problem!");
else {
printf("%d\n[:", ans2);
for (int i = 0; i < n * (n - 1) / 2 - ans1 + 1; ++i) putchar('|');
puts(":]");
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
template <typename T_container, typename T = typename enable_if<
!is_same<T_container, string>::value,
typename T_container::value_type>::type>
ostream &operator<<(ostream &os, const T_container &v) {
os << '{';
string sep;
for (const T &x : v) os << sep << x, sep = ", ";
return os << '}';
}
void dbg_out() { cerr << endl; }
template <typename Head, typename... Tail>
void dbg_out(Head H, Tail... T) {
cerr << ' ' << H;
dbg_out(T...);
}
using ll = long long;
using ull = unsigned long long;
mt19937 rng(
(unsigned int)chrono::steady_clock::now().time_since_epoch().count());
const int mod = 998244353;
const int inf = 0x3f3f3f3f;
const int maxn = 3e5 + 10;
ll qpow(ll a, int b) {
ll ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
const int G = 3;
namespace NTT {
ll wn[maxn << 2], rev[maxn << 2];
int init(int n_) {
int step = 0;
int n = 1;
for (; n < n_; n <<= 1) ++step;
for (int i = int(1); i <= (int)(n - 1); i++)
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (step - 1));
int g = qpow(G, (mod - 1) / n);
wn[0] = 1;
for (int i = 1; i <= n; ++i) wn[i] = wn[i - 1] * g % mod;
return n;
}
void NTT(ll a[], int n, int f) {
for (int i = int(0); i <= (int)(n - 1); i++)
if (i < rev[i]) std::swap(a[i], a[rev[i]]);
for (int k = 1; k < n; k <<= 1) {
for (int i = 0; i < n; i += (k << 1)) {
int t = n / (k << 1);
for (int j = int(0); j <= (int)(k - 1); j++) {
ll w = f == 1 ? wn[t * j] : wn[n - t * j];
ll x = a[i + j];
ll y = a[i + j + k] * w % mod;
a[i + j] = (x + y) % mod;
a[i + j + k] = (x - y + mod) % mod;
}
}
}
if (f == -1) {
ll ninv = qpow(n, mod - 2);
for (int i = int(0); i <= (int)(n - 1); i++) a[i] = a[i] * ninv % mod;
}
}
ll tmp1[maxn << 2], tmp2[maxn << 2];
void mul(ll a[], ll b[], int lena, int lenb) {
int len = init(lena + lenb + 2);
for (int i = int(0); i <= (int)(lena - 1); i++) tmp1[i] = a[i];
for (int i = int(lena); i <= (int)(len - 1); i++) tmp1[i] = 0;
for (int i = int(0); i <= (int)(lenb - 1); i++) tmp2[i] = b[i];
for (int i = int(lenb); i <= (int)(len - 1); i++) tmp2[i] = 0;
NTT(tmp1, len, 1);
NTT(tmp2, len, 1);
for (int i = int(0); i <= (int)(len - 1); i++) a[i] = tmp1[i] * tmp2[i] % mod;
NTT(a, len, -1);
}
void mul(ll a[], ll b[], ll c[], int lena, int lenb) {
int len = init(lena + lenb + 2);
for (int i = int(0); i <= (int)(lena - 1); i++) tmp1[i] = a[i];
for (int i = int(lena); i <= (int)(len - 1); i++) tmp1[i] = 0;
for (int i = int(0); i <= (int)(lenb - 1); i++) tmp2[i] = b[i];
for (int i = int(lenb); i <= (int)(len - 1); i++) tmp2[i] = 0;
NTT(tmp1, len, 1);
NTT(tmp2, len, 1);
for (int i = int(0); i <= (int)(len - 1); i++) c[i] = tmp1[i] * tmp2[i] % mod;
NTT(c, len, -1);
}
ll P[20][maxn << 2];
void solve(ll *a, int l, int r, int dep) {
if (l == r) {
P[dep][2 * l] = 1;
P[dep][2 * l + 1] = a[l];
return;
}
int mid = (l + r) >> 1;
solve(a, l, mid, dep + 1);
solve(a, mid + 1, r, dep + 1);
int lenl = mid - l + 1, lenr = r - mid;
mul(P[dep + 1] + 2 * l, P[dep + 1] + 2 * mid + 2, P[dep] + l * 2, lenl + 1,
lenr + 1);
}
} // namespace NTT
ll du[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = int(1); i <= (int)(n - 1); i++) {
int u, v;
cin >> u >> v;
u--;
v--;
du[u]++;
du[v]++;
}
for (int i = int(1); i <= (int)(n - 1); i++) {
du[i]--;
}
NTT::solve(du, 0, n - 1, 0);
vector<ll> jc(n + 1);
jc[0] = 1;
for (int i = int(1); i <= (int)(n); i++) {
jc[i] = jc[i - 1] * i % mod;
}
ll ans = 0;
for (int i = int(0); i <= (int)(n); i++) {
ll val = NTT::P[0][i] * jc[n - i] % mod;
if (i & 1)
ans = (ans + mod - val) % mod;
else
ans = (ans + val) % mod;
}
cout << ans << '\n';
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
ostream &operator<<(ostream &cout, pair<A, B> const &p) {
return cout << "(" << p.first << ", " << p.second << ")";
}
template <typename A>
ostream &operator<<(ostream &cout, vector<A> const &v) {
cout << "[";
for (int i = 0; i < v.size(); i++) {
if (i) cout << ", ";
cout << v[i];
}
return cout << "]";
}
long long T, n, ans, ind[100005], sub[100005];
vector<long long> e[100005], rr, ord;
void dfs(long long g, long long p) {
sub[g] = 1;
ind[g] = (int)ord.size();
ord.push_back(g);
for (auto u : e[g]) {
if (u == p) continue;
dfs(u, g);
ans += 2LL * min(sub[u], n - sub[u]);
sub[g] += sub[u];
}
}
void solve() {
cin >> n;
for (int i = 1; i <= n - 1; i++) {
long long t1, t2;
cin >> t1 >> t2;
e[t1].push_back(t2);
e[t2].push_back(t1);
}
dfs(1, 0);
cout << ans << '\n';
for (int i = 1; i <= n; i++) cout << ord[(ind[i] + n / 2) % n] << ' ';
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
T = 1;
for (int t = 1; t <= T; t++) solve();
cout.flush();
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e12;
void solve() {
long long n, p;
cin >> n >> p;
long long ans = inf;
for (long long cnt = 1; cnt < 1e5; ++cnt) {
if (n - cnt * p <= 0) continue;
long long cur = n - cnt * p;
long long t = cur;
long long CNTbit = 0;
while (cur != 0) {
CNTbit += cur % 2;
cur /= 2;
}
if (CNTbit <= cnt && cnt <= t) ans = min(ans, cnt);
}
if (ans == inf)
cout << -1;
else
cout << ans;
}
int32_t main() {
long long q = 1;
while (q--) solve();
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long a[110];
long long b[50][70];
int main() {
long long n, m, t;
scanf("%lld", &t);
while (t--) {
memset(b, 0, sizeof(b));
scanf("%lld%lld", &n, &m);
int flag = 0;
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
long long x = a[i];
int k = 0;
while (x) {
b[i][k++] = x % m;
if (x % m != 0 && x % m != 1) {
flag = 1;
}
x /= m;
}
}
for (int i = 0; i < 64; i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
sum += b[j][i];
}
if (sum != 0 && sum != 1) {
flag = 1;
}
}
if (flag == 1) {
printf("NO\n");
} else {
printf("YES\n");
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename Arg1>
void __f(const char* name, Arg1&& arg1) {
std::cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " : " << arg1 << " | ";
__f(comma + 1, args...);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int T = 1;
while (T--) {
long long int n, k;
cin >> n >> k;
long long int a[n + 1];
std::vector<long long int> v;
long long int sum = 0;
for (long long int i = 0; i < n; i = i + 1) {
cin >> a[i];
sum += a[i];
v.push_back(a[i]);
}
if (sum < k) {
cout << "-1\n";
return 0;
}
sort(v.begin(), v.end());
;
long long int ans = 0, rem = n, times = 0;
for (long long int i = 0; i < n; i++) {
long long int y = v[i] - times;
if (y <= 0) {
rem--;
continue;
}
long long int cost = ans + (y * rem);
if (cost <= k) {
ans = ans + (y * rem);
rem--;
times += y;
} else {
long long int left = k - ans;
long long int z = left / rem;
times += z;
break;
}
}
deque<long long int> q;
long long int z = k;
for (long long int i = 0; i < n; i++) {
long long int y = a[i] - times;
if (y <= 0) {
z = z - a[i];
} else {
a[i] = a[i] - times;
q.push_back(i + 1);
z = z - times;
}
}
for (long long int i = 0; i < z; i++) {
long long int tmp = q.front();
q.pop_front();
a[tmp - 1] = a[tmp - 1] - 1;
if (a[tmp - 1] > 0) {
q.push_back(tmp);
}
}
while (!q.empty()) {
long long int tmp = q.front();
cout << tmp << " ";
q.pop_front();
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using std::cin;
using std::cout;
using std::endl;
using std::pair;
using std::string;
using std::swap;
using std::vector;
void doit(int& xk, int& yk, int w, int h, int x, int y, int z) {
for (int i = 0; i < x; ++i) {
swap(xk, yk);
swap(w, h);
xk = w - xk + 1;
}
if (y) {
xk = w - xk + 1;
}
for (int i = 0; i < z; ++i) {
swap(xk, yk);
swap(w, h);
yk = h - yk + 1;
}
}
int main() {
int n, m, x, y, z, p;
scanf("%d %d %d %d %d %d", &n, &m, &x, &y, &z, &p);
x %= 4;
y = y & 1;
z %= 4;
while (p--) {
int xk, yk;
scanf("\n%d %d", &yk, &xk);
doit(xk, yk, m, n, x, y, z);
printf("%d %d\n", yk, xk);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b;
cin >> a >> b;
for (int i = 0; i < a.size(); i++) {
if (a[i] == b[i]) {
cout << 0;
} else
cout << 1;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = (long long)1e9 + 7;
const int N = 1e5 + 5, inf = 1e9 + 5;
long long add(long long x, long long y) {
x += y;
if (x >= MOD) return x - MOD;
return x;
}
long long sub(long long x, long long y) {
x -= y;
if (x < 0) return x + MOD;
return x;
}
long long mult(long long x, long long y) { return (x * y) % MOD; }
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<long long> a(n);
for (__typeof(n) i = (0) - ((0) > (n)); i != (n) - ((0) > (n));
i += 1 - 2 * ((0) > (n)))
cin >> a[i];
long long sum = accumulate(begin(a), end(a), 0LL);
long long maxx1 = 0, maxxi1 = 0;
long long maxx2 = 0;
for (int i = 0; i < n; ++i) {
if (a[i] > maxx1) {
maxx2 = maxx1;
maxx1 = a[i];
maxxi1 = i;
} else if (a[i] > maxx2) {
maxx2 = a[i];
}
}
vector<long long> ans;
for (int i = 0; i < n; ++i) {
if (i == maxxi1) {
if (sum - a[i] - maxx2 == maxx2) ans.push_back(i);
} else {
if (sum - a[i] - maxx1 == maxx1) ans.push_back(i);
}
}
cout << ans.size() << "\n";
for (long long x : ans) cout << x + 1 << " ";
cout << "\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[5000][5002];
int sum[5001][5000] = {0};
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) scanf("%s", s[i] + 1);
for (int i = 0; i < n; ++i)
for (int j = 1; j <= m; ++j) {
if (s[i][j] == '1') sum[j][i] = sum[j - 1][i] + 1;
}
int ans = 0;
for (int i = 1; i <= m; ++i) {
sort(sum[i], sum[i] + n);
int mi = m;
for (int j = n - 1; j >= 0; --j) {
if (sum[i][j] < mi) mi = sum[i][j];
if (mi * (n - j) > ans) ans = mi * (n - j);
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
long long qm(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
b >>= 1;
a = a * a % mod;
}
return (ans % mod + mod) % mod;
}
const int maxn = 2e5 + 10;
long long dp[2005];
int a[maxn];
struct nobe {
int x, y;
bool operator<(const nobe& xx) const {
if (x == xx.x) return y > xx.y;
return x < xx.x;
}
} b[maxn];
int pos[maxn];
bool visit[maxn];
long long sum[maxn];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= m; ++i) cin >> b[i].x >> b[i].y;
sort(a + 1, a + 1 + n);
sort(b + 1, b + 1 + m);
int cnt = 0;
for (int i = 1; i <= m; ++i) {
if (b[i].x <= k && visit[b[i].x] == 0) {
++cnt;
pos[cnt] = i;
visit[b[i].x] = 1;
}
if (b[i].x > k) break;
}
sum[0] = 0;
dp[0] = 0;
for (int i = 1; i <= k; ++i) {
sum[i] = sum[i - 1] + a[i];
dp[i] = sum[i];
}
for (int j = 1; j <= k; ++j) {
for (int i = 1; i <= cnt; ++i) {
int cnt = b[pos[i]].x - b[pos[i]].y;
if (j >= b[pos[i]].x)
dp[j] = min(dp[j], dp[j - b[pos[i]].x] + sum[j] - sum[j - cnt]);
}
}
cout << dp[k] << endl;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, b, k, x, num[100], way[100][2];
int cur = 1, pre = 0, power10 = 10;
void add(int& a, int const b) {
if ((a += b) >= 1000000007) a -= 1000000007;
}
int mul(int const a, int const b) { return (1ll * a * b) % 1000000007; }
void calc(int b) {
if (b == 1) return;
calc(b >> 1);
swap(cur, pre);
for (int i = 0; i <= x - 1; i++) way[i][cur] = 0;
for (int i = 0; i <= x - 1; i++)
for (int j = 0; j <= x - 1; j++) {
int k = (i * power10 + j) % x;
add(way[k][cur], mul(way[i][pre], way[j][pre]));
}
power10 = (power10 * power10) % x;
if (b & 1) {
swap(cur, pre);
for (int i = 0; i <= x - 1; i++) way[i][cur] = 0;
for (int i = 0; i <= x - 1; i++)
for (int j = 0; j <= x - 1; j++) {
int k = (i * 10 + j) % x;
add(way[k][cur], mul(way[i][pre], num[j]));
}
power10 = (power10 * 10) % x;
}
}
void setup() {
cin >> n >> b >> k >> x;
int a;
for (int i = 1; i <= n; i++) {
cin >> a;
num[a]++;
way[a % x][cur]++;
}
calc(b);
cout << way[k][cur];
}
void xuly() {}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
setup();
xuly();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
char str[1000005] = {0};
int main() {
int n;
scanf("%d", &n);
scanf("%s", &str);
int m = n - 11;
if (m < 0) {
printf("NO\n");
return 0;
}
int sum = 0;
for (int i = 0; i < n - 10; i++) {
if (str[i] == '8') sum++;
}
if (sum <= (m / 2))
printf("NO\n");
else
printf("YES\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
const double pi = acos(-1);
const long long INF = 1e18 + 5;
const long long mod = 1e9 + 7;
const int N = 1e5 + 5, M = 505;
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string s;
cin >> s;
if (s.size() == 1) {
cout << 0;
return 0;
}
long long n = 0, c = 1;
for (int i = 0; i < s.size(); i++) {
n += s[i] - '0';
}
while (n / 10 > 0) {
long long m = 0;
while (n % 10 >= 0) {
if (!n) break;
m += n % 10;
n /= 10;
}
c++;
n = m;
}
cout << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int girl = 1, qu = -1;
char str[1000010];
int main() {
scanf("%s", str + 1);
int sol = 0;
int n = strlen(str + 1);
for (int c = 1; c <= n; c++) {
if (str[c] == 'F') {
if (qu != -1) {
sol = max(sol, c - girl + qu);
girl++;
qu++;
} else {
girl++;
}
} else {
if (qu == -1) qu = 0;
if (qu != 0) qu--;
}
}
printf("%d", sol);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, ans = 1;
scanf("%d", &n);
string s;
cin >> s;
for (i = 1; i < n; i++) {
if (s[i] != s[i - 1]) {
ans++;
}
}
ans = min(ans + 2, n);
printf("%d", ans);
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.