solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long w, a[10], dp[200005];
int main() {
long long sum = 0;
cin >> w;
for (register int i = 1; i <= 8; ++i) scanf("%lld", &a[i]), sum += i * a[i];
if (sum <= w) {
cout << sum << endl;
return 0;
}
long long ans = 0;
long long res = w;
for (register int i = 1; i <= 8; ++i) {
long long add = min(a[i], res / i);
long long radd = max(0ll, add - 840);
ans += i * radd;
res -= i * radd;
a[i] -= radd;
}
for (register int i = 1; i <= 8; ++i) {
for (int j = res; j >= i; j--) {
for (int k = 1; k <= a[i]; k++) {
if (j - k * i >= 0)
dp[j] = max(dp[j], dp[j - k * i] + k * i);
else
break;
}
}
}
ans += dp[res];
cout << ans;
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int T = 1;
while (T--) {
long long n;
cin >> n;
if (n == 1 || n == 2) cout << 1, exit(0);
if (n == 3) cout << 0, exit(0);
if (n % 2 == 1) n -= 3;
int d = n / 2;
if (d % 2 == 0) {
cout << 0;
exit(0);
} else
cout << 1;
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int P = 998244353;
int main() {
cin.tie(0)->sync_with_stdio(0);
int n;
cin >> n;
vector<array<int, 3> > v(n);
for (array<int, 3> &i : v)
for (int &j : i) cin >> j;
vector<array<int, 2> > o(1, {0, 0});
long long ans = 1;
for (array<int, 3> i : v) {
ans += i[0] - o.back()[0];
int j =
upper_bound(o.begin(), o.end(), array<int, 2>({i[1], 0})) - o.begin();
int suba = (i[0] - i[1]) % P;
if (o[j][0] > i[1])
suba = ((long long)suba + o.back()[1] - o[j - 1][1] + P) % P;
if (i[2]) ans += suba;
o.push_back({i[0], (suba + o.back()[1]) % P});
}
ans %= P;
cout << ans << '\n';
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
cin >> n;
int i = 1;
for (; i * (i + 1) * (2 * i + 4) / 12 <= n; i++)
;
cout << i - 1;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6;
const long long mod = 1e9 + 7;
const long long INF = 10000000;
void flash() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(9);
}
void solve();
int32_t main() {
flash();
long long t;
t = 1;
cin >> t;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
void solve() {
long long a, b, c;
cin >> a >> b >> c;
long long d = a + c - b;
long long e = max(min((d / 2) + (d % 2 >= 1), c + 1), 0ll);
cout << e;
return;
}
| 5
|
#include <bits/stdc++.h>
int main() {
char a[1111];
int n;
scanf("%d", &n);
scanf("%s", a);
for (int i = 0; i < n;) {
if (a[i] == 'o' && a[i + 1] == 'g' && a[i + 2] == 'o') {
i += 3;
while (a[i] == 'g' && a[i + 1] == 'o') {
i += 2;
}
printf("***");
} else {
printf("%c", a[i]);
i++;
}
}
printf("\n");
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int a[N], b[N];
map<int, int> mp;
int main() {
int n, m, y1, y2, rec, temp, maxx;
map<int, int>::iterator it;
scanf("%d %d", &n, &y1);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
scanf("%d %d", &m, &y2);
for (int i = 1; i <= m; i++) scanf("%d", &b[i]);
rec = 1;
maxx = 2;
for (int i = 1; i <= 30; i++) {
mp.clear();
for (int j = 1; j <= n; j++) {
temp = a[j] % (rec << 1);
if (mp.count(temp))
mp[temp]++;
else
mp.insert(make_pair(temp, 1));
}
for (int j = 1; j <= m; j++) {
temp = (b[j] + rec) % (rec << 1);
if (mp.count(temp))
mp[temp]++;
else
mp.insert(make_pair(temp, 1));
}
for (it = mp.begin(); it != mp.end(); it++) maxx = max(maxx, it->second);
rec <<= 1;
}
printf("%d\n", maxx);
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
vector<unsigned long long int> v[100002];
vector<unsigned long long int>::iterator it;
set<unsigned long long int> s;
set<unsigned long long int>::iterator iter;
bool check[100005];
int main() {
unsigned long long int n = 0, m = 0, x = 0, y = 0, res = 0, i = 0, j = 0,
flag = 0, cont = 0, flag1 = 0, s = 0;
cin >> n >> m;
for (unsigned long long int i = 1; i < m + 1; i++) {
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
for (unsigned long long int i = 1; i < n + 1; i++) {
unsigned long long int sz = v[i].size();
if (sz == 2) {
cont++;
}
if (sz == m) {
flag = 1;
}
if (sz == 1) {
res++;
}
}
if (flag) {
cout << "star topology\n";
} else {
if (n == m && cont == m) {
cout << "ring topology\n";
} else if (m == n - 1 && (cont == m || n == res + cont)) {
cout << "bus topology\n";
} else {
cout << "unknown topology\n";
}
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
const int MAXN = 100000 + 10;
int T, N, cnt[30];
char name[30][100000], phone[30][1000][30];
std::map<std::string, int> mp;
int tot;
bool visited[MAXN];
inline int min(int x, int y) { return x < y ? x : y; }
int main() {
register int i, j, k, l;
std::string S;
int id;
scanf("%d", &T);
for (i = 1; i <= T; ++i) {
std::cin >> S;
if (!mp[S]) {
id = mp[S] = ++tot;
for (j = 0; j < S.size(); ++j) name[id][j + 1] = S[j];
} else
id = mp[S];
scanf("%d", &N);
for (j = 1; j <= N; ++j) scanf("%s", phone[id][++cnt[id]] + 1);
}
printf("%d\n", tot);
for (i = tot; i; --i) {
for (j = 1; j <= strlen(name[i] + 1); ++j) printf("%c", name[i][j]);
putchar(' ');
memset(visited, 0, sizeof(visited));
for (j = cnt[i]; j; --j)
for (k = cnt[i]; k; --k) {
int sj = strlen(phone[i][j] + 1), sk = strlen(phone[i][k] + 1);
if (j != k && (sj < sk || (sj == sk && j < k))) {
for (l = 0; l < min(sj, sk); ++l)
if (phone[i][j][sj - l] != phone[i][k][sk - l]) break;
if (l == min(sj, sk))
if (sj < sk)
visited[j] = 1;
else
visited[k] = 1;
}
}
int res = 0;
for (j = 1; j <= cnt[i]; ++j)
if (!visited[j]) ++res;
printf("%d", res);
for (j = cnt[i]; j; --j)
if (!visited[j]) {
putchar(' ');
for (k = 1; k <= strlen(phone[i][j] + 1); ++k)
printf("%c", phone[i][j][k]);
}
puts("");
}
return 0;
}
| 6
|
#include<bits/stdc++.h>
#include <iostream>
using namespace std;
#define rep(i,x,y) for(int i=x; i<=y; i++)
void task(){
int n,ans=0,sum=0,here;
cin>>n;
int a[n+2];
rep(i,1,n) cin>>a[i];
for(int i=1 ,j=n ;i<=j; i++,j--){
cout<<a[i]<<" ";
if(i!=j) cout<<a[j]<<" ";
}
cout<<" "<<endl;
// end of this
}
int main()
{
int l;
cin>>l;
for(int i=0;i<l;i++)
task();
}
| 0
|
#include <bits/stdc++.h>
#pragma GCC optimize("O2")
using namespace std;
struct debugger {
static void call(const char* it) {}
template <typename T, typename... valT>
static void call(const char* it, T val, valT... rest) {
string var = "";
for (; *it && *it != ','; it++)
if (*it != ' ') var += *it;
cerr << var << '=' << val << " ";
call(++it, rest...);
}
};
const int MAX = 1e5 + 10;
int A[MAX], cnt = 0;
map<int, map<int, int> > D;
vector<int> G[MAX];
bool V[MAX];
void dfs(int u, int p, long long cost) {
if (cost > A[u]) return;
cnt++;
for (auto v : G[u]) {
if (v != p) {
long long cc = D[u][v] + cost;
if (cc <= A[v]) {
dfs(v, u, max(cc, 0LL));
}
}
}
}
int main() {
int n, p, c;
scanf("%d", &n);
for (int i = 0; i < (int)n; i++) {
scanf("%d", &A[i + 1]);
}
for (int i = 0; i < (int)n - 1; i++) {
scanf("%d %d", &p, &c);
G[i + 2].push_back(p), G[p].push_back(i + 2);
D[p][i + 2] = D[i + 2][p] = c;
}
dfs(1, -1, 0);
printf("%d\n", n - cnt);
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0;
bool t = false;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = true, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
return t ? -x : x;
}
pair<long long, long long> p[300300];
int n, m, r = 1;
long long k = 0, b = 0;
double Slope(pair<long long, long long> a, pair<long long, long long> b) {
return 1.0 * (a.second - b.second) / (a.first - b.first);
}
long long calc(pair<long long, long long> x) {
return k * x.first + x.second + b;
}
int main() {
n = read();
m = read();
p[1] = make_pair(0, 0);
r = 1;
while (m--) {
int opt = read();
if (opt == 1)
r = 1, p[1] = make_pair(0, 0), k = b = 0, n += read();
else if (opt == 2) {
pair<long long, long long> now = make_pair(n, -(n * k + b));
while (r > 1 && Slope(now, p[r]) <= Slope(p[r], p[r - 1])) --r;
p[++r] = now;
n += read();
} else
b += read(), k += read();
while (r > 1 && calc(p[r]) >= calc(p[r - 1])) --r;
printf("%I64d %I64d\n", p[r].first + 1, calc(p[r]));
}
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9;
int N, M, s, cnt[55], DP[55][55][55][55];
vector<array<int, 2>> g[55];
int count(int v, int p) {
int ret = cnt[v];
for (array<int, 2>& e : g[v]) {
if (e[0] == p) continue;
ret += count(e[0], v);
}
return ret;
}
int solve(int u, int v, int nf, int nb) {
if (nf == 0 && nb == 0) return 0;
int& ret = DP[u][v][nf][nb];
if (~ret) return ret;
int nc = g[u].size();
if (nc == 1) {
if (nb == 0) return 0;
return solve(v, u, nb, 0) + g[u][0][1];
}
vector<vector<int>> f(nc + 1, vector<int>(nf + 1, 0));
f[0][0] = inf;
int c = 0;
for (int i = 0; i < nc; ++i) {
int nu = g[u][i][0], w = g[u][i][1];
if (nu != v) {
for (int j = 0; j <= nf; ++j) {
f[c + 1][j] = max(f[c + 1][j], f[c][j]);
for (int k = 1; k + j <= nf; ++k) {
f[c + 1][j + k] = max(f[c + 1][j + k],
min(f[c][j], w + solve(nu, u, k, nf + nb - k)));
}
}
++c;
}
}
ret = f[nc - 1][nf];
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> N;
for (int i = 1; i < N; ++i) {
int u, v, w;
cin >> u >> v >> w;
g[u].push_back({v, w});
g[v].push_back({u, w});
}
cin >> s;
cin >> M;
for (int i = 1; i <= M; ++i) {
int x;
cin >> x;
++cnt[x];
}
memset(DP, -1, sizeof(DP));
int ret = inf;
for (array<int, 2>& e : g[s]) {
int v = e[0], w = e[1], c = count(v, s) + cnt[s];
ret = min(ret, solve(v, s, c, M - c) + w);
}
cout << ret << endl;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
if (k % 2 == 0)
k = 2;
else
k = 1;
int a[n + 5], i, j;
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (j = 1; j <= k; j++) {
int max = *max_element(a, a + n);
for (i = 0; i < n; i++) {
a[i] = max - a[i];
}
}
for (i = 0; i < n; i++) {
cout << a[i];
if (i != n - 1) cout << ' ';
}
cout << endl;
std::fill_n(a, n, 0);
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
inline void make(char *buf, int *fal) {
static int i, j;
fal[0] = -1;
for (i = 1, j = -1; buf[i]; ++i) {
while (j >= 0 && buf[j + 1] != buf[i]) j = fal[j];
if (buf[j + 1] == buf[i]) ++j;
fal[i] = j;
}
}
inline int match(char *p, char *t, int *fal) {
static int i, j, re;
for (re = i = 0, j = -1; t[i]; ++i) {
while (j >= 0 && p[j + 1] != t[i]) j = fal[j];
if (p[j + 1] == t[i]) ++j;
if (!p[j + 1]) {
++re;
j = fal[j];
}
}
return re;
}
int n, i, j, k, l;
char s[222];
char p[13][222];
int inv[13][2];
int fal[222];
std::set<std::string> set;
int main() {
scanf("%s %d", s, &n);
for (i = 0; i < n; ++i) scanf("%s %d %d", p[i], inv[i], inv[i] + 1);
for (i = 0; s[i]; ++i) {
for (j = i; s[j]; ++j) {
static char t;
t = 0;
std::swap(s[j + 1], t);
make(s + i, fal);
for (k = 0; k < n; ++k) {
l = match(s + i, p[k], fal);
if (l < inv[k][0] || l > inv[k][1]) break;
}
if (k == n) set.insert(s + i);
std::swap(s[j + 1], t);
}
}
printf("%ld\n", set.size());
return 0;
}
| 9
|
#include<bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define pb push_back
#define mp make_pair
#define rep(n) for(int i=0;i<n;i++)
#define repit(x) for(auto it : x)
#define ll long long
#define vi vector<int>
#define vc vector<char>
#define vs vector<string>
#define mii map<int ,int>
#define mci map<char ,int>
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
int a;
ll sum=0;
rep(n)
{
cin>>a;
sum+=a;
}
ll x,y;
x=min(sum%n,n-sum%n);
y=max(sum%n,n-sum%n);
ll ans=x*y;
cout<<ans<<"\n";
}
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
vector<long long> vis, ways;
void solve() {
long long N, X, pos, ans = 1;
cin >> N >> X >> pos;
long long left = 0, right = N, way1 = N - X, way2 = X - 1;
while (left < right) {
long long mid = (left + right) / 2;
vis.push_back(mid);
if (mid <= pos)
left = mid + 1;
else
right = mid;
}
long long num = N - vis.size();
for (auto i : vis) {
if (i > pos)
ways.push_back(way1), way1--;
else if (i < pos)
ways.push_back(way2), way2--;
}
while (num > 1) {
ans *= num;
ans %= 1000000007;
if (ans < 0) ans += 1000000007;
num--;
}
for (auto i : ways) {
ans *= i;
ans %= 1000000007;
if (ans < 0) ans += 1000000007;
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
solve();
}
| 7
|
#include <bits/stdc++.h>
int n, m, k, ox[100010], oy[100010];
char map[60][60];
void add(int x, int y) {
ox[k] = x;
oy[k++] = y;
}
void fix_w(int x, int y);
void fix_h(int x, int y) {
if (map[x][y] == 'U') return;
fix_w(x + 1, y);
add(x + 1, y + 1);
map[x][y] = map[x][y + 1] = 'U';
map[x + 1][y] = map[x + 1][y + 1] = 'D';
}
void fix_w(int x, int y) {
if (map[x][y] == 'L') return;
fix_h(x, y + 1);
add(x + 1, y + 1);
map[x][y] = map[x + 1][y] = 'L';
map[x][y + 1] = map[x + 1][y + 1] = 'R';
}
void fix() {
if (n % 2 == 0)
for (int j = 0; j < m; j++)
for (int i = 0; i < n; i += 2) fix_h(i, j);
else
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j += 2) fix_w(i, j);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%s", map[i]);
fix();
for (int i = 0; i < n; i++) scanf("%s", map[i]);
int t = k;
fix();
printf("%d\n", k);
for (int i = 0; i < t; i++) printf("%d %d\n", ox[i], oy[i]);
for (int i = k; i-- > t;) printf("%d %d\n", ox[i], oy[i]);
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
using namespace rel_ops;
const double PI = acos((double)-1);
int ts, ts2, ts3, ts4;
int n, m, a[105], w, ady[105];
pair<int, int> a1[105];
long long gcd(long long x, long long y) {
long long t;
for (; y != 0;) {
t = x % y;
x = y;
y = t;
}
return x;
}
int asum, ans[200005], ans2;
int b[105];
void NOO() {
printf("No\n");
exit(0);
}
void YESS() {
printf("Yes\n");
for (int i = 1; i <= asum * 2; i++) ans[i] = ady[ans[i]];
for (int i = 1; i <= asum * 2; i++) printf("%d ", ans[i]);
exit(0);
}
inline void add(int x) {
ans[++ans2] = x;
b[x]--;
}
int main() {
long long i, j, k, l, t1, t2, t3, t4, t5, t6, t7, t8, t9, t, nw;
int tt1, tt2, tt3, tt4;
double u1, u2, u3, u4, u5, u6, u7, u8, u9;
char c1, c2, c3;
srand((unsigned)time(0));
scanf("%d%d", &n, &w);
t1 = 0;
for (i = 1; i <= n; i++)
scanf("%d", &a[i]), t1 += a[i], a1[i] = make_pair(a[i], i), asum += a[i];
if (w <= 0 || t1 < w) NOO();
sort(a1 + 1, a1 + n + 1, greater<pair<int, int> >());
for (i = 1; i <= n; i++)
a[i] = a1[i].first, ady[i] = a1[i].second, b[i] = a[i] * 2;
if (n == 1) {
if (a[1] == w) {
for (i = 1; i <= 2 * asum; i++) ans[i] = 1;
YESS();
} else
NOO();
}
if (w == 1) {
if (a[n] == 1) {
add(n);
for (i = 1; i <= n; i++)
for (; b[i]; add(i))
;
YESS();
} else
NOO();
}
if (w <= a[1] + 1) {
add(2);
for (i = 1; i <= a[1] - (w - 1); i++) add(1), add(1);
add(2), add(1);
for (i = 2; i <= n; i++)
for (; b[i]; add(i))
;
for (; b[1]; add(1))
;
YESS();
}
if (w > a[1] + 1) {
t1 = 0;
int is, js;
for (i = 1; i <= n; i++) {
if (t1 + a[i] >= w) break;
t1 += a[i];
}
is = i, js = w - t1;
add(1);
for (i = is; i <= n; i++) {
int lim = (i == is ? a[i] - js : a[i]) * 2;
for (; lim; lim--) add(i);
}
add(1);
for (i = is; i >= 1; i--)
for (; b[i];) add(i);
YESS();
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long n;
cin >> n;
for (long long i = 0; i <= (n / 1234567); i++) {
for (long long j = 0; j <= (n / 123456); j++) {
long long x = (i * 1234567ll) + (j * 123456ll);
long long p = n - x;
if (p >= 0) {
if (p % 1234 == 0) {
cout << "YES\n";
return 0;
}
}
}
}
cout << "NO\n";
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int x, y, p, r, n;
struct gripper {
int dis, m, p, r;
long long disori;
bool del = false;
} gp[250020];
int lshcnt, lshm[500050], lshmcnt;
long long lsh[500050];
priority_queue<pair<int, int> > c[500050];
queue<int> availgp;
inline int lowbit(int x) { return x & -x; }
inline void insert(int p, int x) {
for (; p <= lshcnt; p += lowbit(p)) {
c[p].push(make_pair(-gp[x].m, x));
}
}
inline int query(int r, int m) {
int res = 0;
for (; r; r -= lowbit(r)) {
while (c[r].size() && c[r].top().first >= -m) {
int x = c[r].top().second;
if (!gp[x].del) {
gp[x].del = true;
availgp.push(x);
++res;
}
c[r].pop();
}
}
return res;
}
signed main() {
ios::sync_with_stdio(false);
cin >> x >> y >> p >> r >> n;
lsh[1] = r;
lshm[1] = p;
for (int i = 1, xi, yi; i <= n; ++i) {
cin >> xi >> yi >> gp[i].m >> gp[i].p >> gp[i].r;
gp[i].disori =
ceil(sqrt(pow((double)(xi - x), 2) + pow((double)(yi - y), 2)));
lsh[i * 2] = gp[i].disori;
lsh[i * 2 + 1] = gp[i].r;
lshm[i * 2] = gp[i].p;
lshm[i * 2 + 1] = gp[i].m;
}
sort(lsh + 1, lsh + 1 + n * 2 + 1);
sort(lshm + 1, lshm + 1 + 2 * n + 1);
lshcnt = unique(lsh + 1, lsh + 1 + 2 * n + 1) - lsh - 1;
lshmcnt = unique(lshm + 1, lshm + 1 + 2 * n + 1) - lshm - 1;
for (int i = 1; i <= n; ++i) {
gp[i].dis = lower_bound(lsh + 1, lsh + 1 + lshcnt, gp[i].disori) - lsh;
gp[i].r = lower_bound(lsh + 1, lsh + 1 + lshcnt, gp[i].r) - lsh;
gp[i].m = lower_bound(lshm + 1, lshm + 1 + lshmcnt, gp[i].m) - lshm;
gp[i].p = lower_bound(lshm + 1, lshm + 1 + lshmcnt, gp[i].p) - lshm;
insert(gp[i].dis, i);
}
r = lower_bound(lsh + 1, lsh + 1 + lshcnt, r) - lsh;
p = lower_bound(lshm + 1, lshm + 1 + lshmcnt, p) - lshm;
int ans = query(r, p);
while (!availgp.empty()) {
int f = availgp.front();
availgp.pop();
ans += query(gp[f].r, gp[f].p);
}
cout << ans << endl;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 0;
cin >> t;
for (int q = 0; q < t; q++) {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
int cur = n - 1;
while (a[cur] <= a[cur - 1] && cur - 1 >= 0) cur--;
while (a[cur] >= a[cur - 1] && cur - 1 >= 0) cur--;
cout << cur << "\n";
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
long long int n, k, x[100007], maxx[100007];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k;
for (long long int i = 1; i <= k; ++i) {
long long int t;
cin >> t;
if (!x[t]) x[t] = i;
maxx[t] = i;
}
long long int ans = 0;
for (long long int i = 1; i <= n; ++i) {
if (!x[i]) {
ans += 3;
if (i == 1) ans--;
if (i == n) ans--;
} else {
if (x[i] > maxx[i - 1] && i > 1) ans++;
if (x[i] > maxx[i + 1] && i < n) ans++;
}
}
cout << ans << '\n';
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
using ui = unsigned int;
const double pi = acos(-1.0);
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const int limit = 5e5;
int read() {
int s = 0;
char c = getchar(), lc = '+';
while (c < '0' || '9' < c) lc = c, c = getchar();
while ('0' <= c && c <= '9') s = s * 10 + c - '0', c = getchar();
return lc == '-' ? -s : s;
}
void write(long long x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + '0');
else
write(x / 10), putchar(x % 10 + '0');
}
void print(long long x, char c = '\n') {
write(x);
putchar(c);
}
const long long mod = 998244353;
const int N = 1e6 + 5;
long long n, m, _;
int i, j, k;
vector<int> row, col;
int havex[N], havey[N];
map<pair<int, int>, int> mpx, mpy;
void clear() {
row.clear();
col.clear();
fill_n(havex, sizeof(havex) / sizeof(0), 0);
fill_n(havey, sizeof(havey) / sizeof(0), 0);
mpx.clear();
mpy.clear();
}
signed main() {
int T;
while (cin >> T)
while (T--) {
scanf("%d%d%d", &n, &m, &k);
for (int i = (1); i <= (n); i++) {
row.push_back(read());
}
for (int i = (1); i <= (m); i++) {
col.push_back(read());
}
long long ans = 0;
while (k-- > 0) {
int x, y;
scanf("%d%d", &x, &y);
auto nx = lower_bound(row.begin(), row.end(), x);
auto ny = lower_bound(col.begin(), col.end(), y);
if (x == *nx && y == *ny) continue;
if (x == *nx) {
ans += havey[*ny] - mpy[{*ny, *nx}];
havey[*ny]++;
mpy[{*ny, *nx}]++;
} else {
ans += havex[*nx] - mpx[{*nx, *ny}];
havex[*nx]++;
mpx[{*nx, *ny}]++;
}
}
pair<long long, long long>(ans);
clear();
}
return 0;
}
| 11
|
#include<bits/stdc++.h>
using namespace std;
const int N=2e5+5;
int main(){
ios::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
int t;cin>>t;
while(t--){
int n;
cin>>n;
vector<int>a(n);
for(int i=0;i<n;++i)cin>>a[i];
int l=0,r=n-1;
while(l<=r){
if(l==r)cout<<a[l];
else cout<<a[l]<<' '<<a[r]<<' ';
l++;r--;
}
cout<<'\n';
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int sum[400007];
int A[200007];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i <= n + 5; i++) {
sum[i] = 0;
A[i] = 0;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &A[i]);
sum[A[i]]++;
}
sort(A + 1, A + n + 1);
for (int i = 1; i <= 400002; i++) {
sum[i] += sum[i - 1];
}
long long ans = 0, ans1 = 0;
if (A[1] == 1) {
for (int i = 1; i <= n; i++) {
ans += A[i];
}
} else {
for (int i = 1; i <= n; i++) {
if (A[i] != A[i - 1]) {
ans1 = 0;
for (int j = A[i]; j <= 200000; j += A[i]) {
ans1 += (1LL) * (sum[min(200000, A[i] + j - 1)] - sum[j - 1]) * j;
}
ans = max(ans, ans1);
}
}
}
printf("%lld\n", ans);
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long i, j, flag = 0;
double n, an;
cin >> n >> an;
double p = (180) / n;
long long r = an / p;
if (r == 0) {
cout << "2 1 3\n";
return;
}
if (r >= n - 2) {
cout << "2 1 " << n << endl;
return;
}
if ((an - p * r) <= (p * (r + 1) - an)) {
cout << "2 1 " << r + 2 << endl;
} else {
cout << "2 1 " << r + 3 << endl;
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long t = 1;
while (t--) {
solve();
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int SIZE = 2e5 + 2;
long long a[SIZE], prefix[SIZE], suffix[SIZE];
int main() {
int n, k, x;
scanf("%d%d%d", &n, &k, &x);
long long mul = 1;
while (k--) mul *= x;
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (int i = 1; i <= n; i++) prefix[i] = prefix[i - 1] | a[i];
for (int i = n; i > 0; i--) suffix[i] = suffix[i + 1] | a[i];
long long ans = 0;
for (int i = 1; i <= n; i++)
ans = max(ans, prefix[i - 1] | (a[i] * mul) | suffix[i + 1]);
printf("%I64d\n", ans);
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x3f3f3f3f;
const long long inf = pow(10, 18);
long long modulo = pow(10, 9) + 7;
void deal() {
long long n, m, k;
cin >> n >> m >> k;
vector<set<long long> > all(m);
vector<vector<long long> > arr(n, vector<long long>(m));
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
long long ed;
cin >> ed;
arr[i][j] = ed;
if (ed != 2) {
all[j].insert(i);
}
}
}
for (long long i = 0; i < k; i++) {
long long y;
cin >> y;
long long x = -1;
--y;
while (1) {
auto it = all[y].lower_bound(x);
if (it == all[y].end()) {
break;
}
long long wh = (*it);
all[y].erase(it);
x = wh;
if (arr[x][y] == 1) {
++y;
} else {
--y;
}
}
cout << y + 1 << " ";
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
deal();
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
multiset<pair<string, int> > mul;
int main() {
string ss;
int k;
cin >> ss >> k;
for (int i = 0; i < ss.size(); i++) {
string temp;
temp += ss[i];
mul.insert({temp, i});
}
long long n = ss.size();
if (2 * k > n * (n + 1)) return !printf("No such line.\n");
pair<string, int> p, ans;
while (k--) {
ans = p = *mul.begin();
mul.erase(mul.begin());
if (p.second + 1 < n) {
p.first += ss[p.second + 1];
p.second += 1;
mul.insert(p);
}
}
cout << ans.first << endl;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010, M = 6 * N;
int n, m;
int h[N], e[M], ne[M], w[N], idx;
int top[N], id[N], sz[N], cnt;
int dep[N], son[N], fat[N], mp[N], nw[N];
int fa[N][17];
int dist[N];
struct Edge {
int a, b, w;
} edge[N];
struct Node {
int l, r;
int sum;
} tr[N << 2];
void add(int a, int b) { e[idx] = b, ne[idx] = h[a], h[a] = idx++; }
void bfs(int root) {
memset(dist, 0x3f, sizeof dist);
queue<int> q;
q.push(root);
dist[root] = 1;
dist[0] = 0;
while (!q.empty()) {
int t = q.front();
q.pop();
for (int i = h[t]; ~i; i = ne[i]) {
int j = e[i];
if (dist[j] > dist[t] + 1) {
q.push(j);
dist[j] = dist[t] + 1;
fa[j][0] = t;
for (int k = 1; k <= 16; k++) fa[j][k] = fa[fa[j][k - 1]][k - 1];
}
}
}
}
int lca(int a, int b) {
if (dist[a] < dist[b]) swap(a, b);
for (int k = 16; k >= 0; k--) {
if (dist[fa[a][k]] >= dist[b]) {
a = fa[a][k];
}
}
if (a == b) return a;
for (int k = 16; k >= 0; k--) {
if (fa[a][k] != fa[b][k]) {
a = fa[a][k];
b = fa[b][k];
}
}
return fa[a][0];
}
void dfs1(int u, int father, int depth) {
sz[u] = 1, fat[u] = father, dep[u] = depth;
for (int i = h[u]; ~i; i = ne[i]) {
int j = e[i];
if (j == father) continue;
dfs1(j, u, depth + 1);
sz[u] += sz[j];
if (sz[son[u]] < sz[j]) son[u] = j;
}
}
void dfs2(int u, int father, int t) {
id[u] = ++cnt, nw[cnt] = w[u], top[u] = t;
if (!son[u]) return;
dfs2(son[u], u, t);
for (int i = h[u]; ~i; i = ne[i]) {
int j = e[i];
if (j == father || j == son[u]) continue;
dfs2(j, u, j);
}
}
void pushup(int u) { tr[u].sum = tr[u << 1].sum + tr[u << 1 | 1].sum; }
void build(int u, int l, int r) {
tr[u].l = l, tr[u].r = r;
if (l == r) {
tr[u].sum = nw[l];
return;
}
int mid = l + r >> 1;
build(u << 1, l, mid), build(u << 1 | 1, mid + 1, r);
pushup(u);
}
void modify(int u, int x, int k) {
if (tr[u].l == x && tr[u].r == x) {
tr[u].sum = k;
return;
}
int mid = tr[u].l + tr[u].r >> 1;
if (x <= mid)
modify(u << 1, x, k);
else
modify(u << 1 | 1, x, k);
pushup(u);
}
int query(int u, int l, int r) {
if (tr[u].l >= l && tr[u].r <= r) {
return tr[u].sum;
}
int mid = tr[u].l + tr[u].r >> 1;
int res = 0;
if (l <= mid) res += query(u << 1, l, r);
if (r > mid) res += query(u << 1 | 1, l, r);
return res;
}
int query_path(int u, int v) {
int res = 0;
while (top[u] != top[v]) {
if (dep[top[u]] < dep[top[v]]) swap(u, v);
res += query(1, id[top[u]], id[u]);
u = fat[top[u]];
}
if (u != v) {
if (dep[u] < dep[v]) swap(u, v);
res += query(1, id[v] + 1, id[u]);
}
return res;
}
int main(void) {
memset(h, -1, sizeof h);
scanf("%d", &n);
for (int i = 1; i <= n - 1; i++) {
int a, b;
scanf("%d%d", &a, &b);
add(a, b), add(b, a);
edge[i] = {a, b, 1};
}
bfs(1);
dfs1(1, -1, 1);
for (int i = 1; i <= n - 1; i++) {
int a = edge[i].a, b = edge[i].b, ww = edge[i].w;
if (dep[a] < dep[b]) swap(a, b);
mp[i] = a;
w[a] = ww;
}
dfs2(1, -1, 1);
build(1, 1, n);
scanf("%d", &m);
while (m--) {
int op, u, v;
scanf("%d", &op);
if (op == 1) {
scanf("%d", &u);
int dot = mp[u];
modify(1, id[dot], 1);
} else if (op == 2) {
scanf("%d", &u);
int dot = mp[u];
modify(1, id[dot], 0);
} else {
scanf("%d%d", &u, &v);
int p = lca(u, v);
int d = dist[u] + dist[v] - 2 * dist[p];
int qu = query_path(u, v);
if (qu != d)
printf("-1\n");
else
printf("%d\n", d);
}
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
long long mod = pow(10, 9) + 7;
using namespace std;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
void go() {
long long n, a, x, b, y;
cin >> n >> a >> x >> b >> y;
long long c = n, i = a, j = b;
while (a != x && b != y) {
if (a == b) {
cout << "YES";
return;
}
a++;
b--;
if (b <= 0) b = n;
if (a == n + 1) a = 1;
}
if (a == b) {
cout << "YES";
return;
}
cout << "NO";
}
int main() {
int t;
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
go();
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
namespace sky_chen {
char buf[1 << 23], *p1 = buf, *p2 = buf, obuf[1 << 23], *O = obuf;
inline long long read() {
long long ans = 0, f = 1;
char a =
p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
while (a > '9' || a < '0') {
if (a == '-') f = -1;
a = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
}
while (a >= '0' && a <= '9')
ans = ans * 10 + (a ^ 48),
a = p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2)
? EOF
: *p1++;
return ans * f;
}
inline char red() {
long long ans = 0;
char a = getchar();
while (a > 'z' || a < 'a') a = getchar();
return a;
}
inline void p(long long x) {
if (x < 0) return (void)(*O++ = '-', p(-x));
if (x > 9) p(x / 10);
*O++ = x % 10 + '0';
}
inline void cadd(long long &x, long long y) { x = (x + y) % 998244353; }
inline void cmul(long long &x, long long y) { x = x * y % 998244353; }
inline void cmin(long long &x, long long y) { x = min(x, y); }
inline void cmax(long long &x, long long y) { x = max(x, y); }
long long qpow(long long n, long long base = 998244353 - 2) {
long long ans = 1;
while (base) {
if (base & 1) ans = ans * n % 998244353;
n = n * n % 998244353;
base >>= 1;
}
return ans;
}
void print(long long a, long long b) { p(b); }
const int maxn = 3e5 + 5;
long long n, csp = 1, first[maxn], dp[maxn][3];
struct edge {
long long to, nxt;
} e[2 * maxn];
void add(long long u, long long v) {
e[++csp] = edge{v, first[u]};
first[u] = csp;
}
void dfs(long long now, long long fa) {
dp[now][0] = dp[now][1] = dp[now][2] = 1;
for (int i = first[now]; i; i = e[i].nxt) {
long long v = e[i].to;
if (v == fa) continue;
dfs(v, now);
cmul(dp[now][0], dp[v][0]);
cmul(dp[now][1], dp[v][0] + dp[v][1] + dp[v][2]);
cmul(dp[now][2], dp[v][0] + dp[v][1]);
}
dp[now][0] = (dp[now][1] + dp[now][2] - dp[now][0] + 998244353) % 998244353;
}
int yyds() {
n = read();
for (int i = 1; i <= n - 1; i++) {
long long u = read(), v = read();
add(u, v);
add(v, u);
}
dfs(1, -1);
print(114514, (dp[1][0] - 1 + 998244353) % 998244353);
fwrite(obuf, 1, O - obuf, stdout);
return 0;
}
} // namespace sky_chen
int main() { return sky_chen::yyds(); }
| 17
|
#include <iostream>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
using namespace std;
#define ll long long
#define float long long double
#define pb push_back
void solve()
{
ll n;
cin>>n;
ll a[n];
for(int i=0; i<n; i++)
{
cin>>a[i];
}
for(int i=0; i<n-1; i++)
{
if(a[i] == a[i+1])
{
while(a[i] == a[i+1] && i<(n-1))
{
i++;
}
a[i] = a[i] + 1;
i--;
}
}
/*for(int i=0; i<n; i++)
{
cout<<a[i]<<" ";
}*/
ll count = 0;
for(int i=0; i<n-1 ; i++)
{
if(a[i] == a[i+1] )
{
count++;
}
}
cout<<n-count;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin>>t;
//t=1;
while(t--)
{
solve();
cout<<endl;
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
int main() {
long long A[7];
long long x = 1;
for (int i = 0; i < 6; ++i) {
scanf("%lld", &A[i]);
}
for (int i = 0; i < 3; ++i) {
if (A[i * 2] != 0) {
x *= A[i * 2];
}
}
long long INF = x * 2e9;
long long y = x;
bool inf = false;
for (int i = 0; i < 3; ++i) {
if (i == 2 && inf || A[2] == 0 && A[3] != 0) {
printf("Ron");
return 0;
}
if (A[i * 2] == 0) {
if (y != 0) {
y = INF;
inf = true;
}
} else {
y /= A[i * 2];
y *= A[i * 2 + 1];
}
if (A[i * 2 + 1] == 0) {
y = 0;
}
if (A[i * 2 + 1] == 0) {
inf = false;
}
}
if (y > x) {
printf("Ron");
} else {
printf("Hermione");
}
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a[] = {"ABC", "ACB", "BCA", "BAC", "CAB", "CBA"}, str[3];
;
string str1, str2, str3;
cin >> str[0] >> str[1] >> str[2];
for (int i = 0; i < 6; i++) {
int t[3];
t[a[i][0] - 'A'] = 0;
t[a[i][1] - 'A'] = 1;
t[a[i][2] - 'A'] = 2;
bool is = 1;
for (int j = 0; j < 3; j++) {
if (str[j][1] == '>' && t[str[j][0] - 'A'] < t[str[j][2] - 'A']) {
is = 0;
} else if (str[j][1] == '<' && t[str[j][0] - 'A'] > t[str[j][2] - 'A']) {
is = 0;
}
}
if (is) {
cout << a[i] << endl;
return 0;
}
}
cout << "Impossible\n";
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int test;
test = 1;
while (test--) {
int n;
cin >> n;
string a = "abcd";
for (int i = 0; i < n / 4; i++) cout << a;
for (int i = 0; i < n % 4; i++) cout << a[i];
cout << endl;
}
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
cout << 0 << " " << 0 << " " << n << "\n";
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int mod[] = {1224469897, 1503325967, 1336143462, 937397015};
const int inft = 1000000009;
const int MAXN = 10006;
vector<int> PR;
struct czt {
int t[4];
czt() {
for (int i = 0; i < (4); ++i) t[i] = 1;
}
inline czt &operator*=(const czt B) {
for (int i = 0; i < (4); ++i) {
t[i] = 1LL * t[i] * B.t[i] % mod[i];
}
return *this;
}
czt add(long long A) {
for (int i = 0; i < (4); ++i) t[i] = (t[i] + A) % mod[i];
return *this;
}
int wynik() {
for (typeof((PR).begin()) it = (PR).begin(); it != (PR).end(); ++it)
for (int i = 0; i < (4); ++i)
if (mod[i] % *it == 0 && t[i] % *it == 0) return *it;
return -1;
}
} CZT[MAXN];
inline bool operator==(const czt &A, const czt &B) {
for (int i = 0; i < (4); ++i)
if (A.t[i] != B.t[i]) return 0;
return 1;
}
long long A[MAXN];
map<string, czt> M[17];
string GORA[17];
string ZN = "0123456789ABCDEFGHIJK";
int CO[300];
string s;
int d;
czt go(int p, bool row) {
if (M[d].find(s) != M[d].end()) return M[d][s];
if (p == GORA[d].size()) {
int ret = 0;
for (int i = 0; i < (p); ++i) {
ret *= d;
ret += CO[(int)s[i]];
}
return M[d][s] = CZT[ret];
}
czt ret;
if (s[p] != '?') {
if (row && s[p] > GORA[d][p]) return M[d][s] = ret;
czt AA = go(p + 1, row & (s[p] == GORA[d][p]));
assert(M[d][s] == AA);
return M[d][s];
}
int up = d;
if (row) up = CO[(int)GORA[d][p]] + 1;
for (int i = 0; i < (up); ++i) {
s[p] = ZN[i];
ret *= go(p + 1, row & (i + 1 == up));
}
s[p] = '?';
return M[d][s] = ret;
}
czt solve() {
long long ADD;
cin >> d >> s >> ADD;
while (s.size() > GORA[d].size()) {
if (s[0] != '0' && s[0] != '?') return czt().add(ADD);
s.erase(s.begin());
}
while (s.size() < GORA[d].size()) s = "0" + s;
return go(0, 1).add(ADD);
}
string sys(int a, int bas) {
string ANS;
while (a) {
ANS = ZN[a % bas] + ANS;
a /= bas;
}
return ANS;
}
int main() {
for (int i = 2; i < 100; ++i) {
bool ok = 1;
for (int j = 2; j < i; ++j)
if (i % j == 0) ok = 0;
if (ok) PR.push_back(i);
}
for (int i = 0; i < (ZN.size()); ++i) CO[(int)ZN[i]] = i;
int n, m;
cin >> n;
for (int i = 0; i < (n); ++i) cin >> A[i];
cin >> m;
for (int i = 2; i <= 16; ++i) GORA[i] = sys(n - 1, i);
for (int i = 0; i < (n); ++i)
for (int j = 0; j < (4); ++j) CZT[i].t[j] = A[i] % mod[j];
for (int j = 0; j < (m); ++j) printf("%d\n", solve().wynik());
return 0;
}
| 22
|
#include <bits/stdc++.h>
long long num[10], a[10], c[10], ch[10];
long long com(long long x) {
long long to = 0;
for (long long k = 2; k <= sqrt(x); k++) {
if (x % k != 0) continue;
while (x % k == 0) {
x /= k;
to++;
}
}
if (x != 1) to++;
return to;
}
long long max, n;
void tru() {
long long k, flag = 1, to = 0, f2 = 1;
for (k = 1; k <= n; k++) c[k] = a[k];
for (k = 1; k < n; k++) {
if (ch[k] == k) {
f2 = 0;
continue;
}
if (c[ch[k]] % a[k] != 0) {
flag = 0;
break;
}
c[ch[k]] /= a[k];
to += num[k];
}
if (flag) {
if (f2) to++;
if (to > max) max = to;
}
return;
}
void dfs(long long x) {
if (x == n) {
tru();
return;
}
x++;
for (long long k = x; k <= n; k++) {
ch[x] = k;
dfs(x);
}
return;
}
int main() {
long long k, ans;
scanf("%I64d", &n);
ans = n + 1;
for (k = 1; k <= n; k++) {
scanf("%I64d", &a[k]);
}
std::sort(a + 1, a + n + 1);
for (k = 1; k <= n; k++) {
num[k] = com(a[k]);
ans += num[k];
if (num[k] == 1) ans--;
}
dfs(0);
printf("%I64d", ans - max);
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int T, n, cnt, now[100100], ans[100100];
char a[100100];
vector<int> A, B, C;
map<pair<int, int>, bool> mm;
inline void ask() {
int i, j;
if (!A.size()) return;
printf("Q %d ", (int)A.size());
for (i = 0; i < A.size(); i++) printf("%d %d ", A[i], B[i]);
puts("");
fflush(stdout);
scanf("%s", a + 1);
for (i = 1; i <= A.size(); i++)
mm[make_pair(A[i - 1], B[i - 1])] = (a[i] == '1');
}
int main() {
int i, j, t;
cin >> T;
while (T--) {
cnt = 0, mm.clear();
memset(ans, 0, sizeof(ans));
scanf("%d", &n);
A.clear(), B.clear();
for (i = 2; i <= n; i += 2) {
A.push_back(i - 1);
B.push_back(i);
}
ask();
A.clear(), B.clear();
for (i = 3; i <= n; i += 2) {
A.push_back(i - 1);
B.push_back(i);
}
ask();
now[++cnt] = 1;
for (i = 2; i <= n; i++)
if (!mm[make_pair(i - 1, i)]) now[++cnt] = i;
A.clear(), B.clear();
for (i = 3; i <= cnt; i += 4) A.push_back(now[i - 2]), B.push_back(now[i]);
for (i = 4; i <= cnt; i += 4) A.push_back(now[i - 2]), B.push_back(now[i]);
ask();
A.clear(), B.clear();
for (i = 5; i <= cnt; i += 4) A.push_back(now[i - 2]), B.push_back(now[i]);
for (i = 6; i <= cnt; i += 4) A.push_back(now[i - 2]), B.push_back(now[i]);
ask();
ans[now[1]] = 1;
if (cnt > 1) ans[now[2]] = 2;
for (i = 3; i <= cnt; i++) {
if (mm[make_pair(now[i - 2], now[i])])
ans[now[i]] = ans[now[i - 2]];
else
ans[now[i]] = 6 - ans[now[i - 2]] - ans[now[i - 1]];
}
A.clear(), B.clear(), C.clear();
for (i = 1; i <= n; i++) {
if (ans[i]) t = ans[i];
ans[i] = t;
if (ans[i] == 1)
A.push_back(i);
else if (ans[i] == 2)
B.push_back(i);
else if (ans[i] == 3)
C.push_back(i);
}
printf("A %d %d %d\n", (int)A.size(), (int)B.size(), (int)C.size());
for (i = 0; i < A.size(); i++) printf("%d ", A[i]);
puts("");
for (i = 0; i < B.size(); i++) printf("%d ", B[i]);
puts("");
for (i = 0; i < C.size(); i++) printf("%d ", C[i]);
puts("");
fflush(stdout);
}
}
| 22
|
#include <bits/stdc++.h>
struct node {
int link[4], go[4], suff, par, ch, maxlen;
node() {
memset(link, -1, sizeof link);
memset(go, -1, sizeof go);
suff = -1;
maxlen = 0;
}
} tr[320];
int m, dp[320][1310][21], u[120];
void add(int& x, int y) {
long long sum = (x * 1LL + y * 1LL) % 1000000009;
x = sum;
}
int alp(char c) { return c == 'A' ? 0 : c == 'C' ? 1 : c == 'G' ? 2 : 3; }
void add_string(char* s, int l) {
int v = 0;
for (int i = 0; i < l; i++) {
int& to = tr[v].link[alp(s[i])];
if (to == -1) to = ++m, tr[m].par = v, tr[m].ch = alp(s[i]);
v = to;
}
if (tr[v].maxlen < l) tr[v].maxlen = l;
}
int go(int v, int c);
int suffix_link(int v) {
if (tr[v].suff + 1) return tr[v].suff;
if (!v || !tr[v].par) return tr[v].suff = 0;
return tr[v].suff = go(suffix_link(tr[v].par), tr[v].ch);
}
int go(int v, int c) {
int& x = tr[v].go[c];
if (x + 1) return x;
if (tr[v].link[c] != -1) return x = tr[v].link[c];
return x = v ? go(suffix_link(v), c) : 0;
}
int getlen(int v) {
if (!v) return 0;
return tr[v].maxlen > 0 ? tr[v].maxlen : getlen(suffix_link(v));
}
int main() {
tr[0].suff = 0;
dp[0][0][0] = 1;
int n, m;
char s[20];
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%s", s);
add_string(s, strlen(s));
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= ::m; j++)
for (int last = 0; last <= (i < 10 ? i : 10); last++)
if (dp[j][i][last])
for (int c = 0; c < 4; c++) {
int to = go(j, c);
int s = last + 1;
if (getlen(to) >= s) s = 0;
add(dp[to][i + 1][s], dp[j][i][last]);
}
int ans = 0;
for (int i = 0; i <= ::m; i++) add(ans, dp[i][n][0]);
printf("%d\n", ans);
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
double l, p, q;
cin >> l >> p >> q;
cout << l * p / (q + p);
return 0;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int n, k, m, y, i, j;
long long c = 0;
cin >> n >> k >> m;
vector<long long> a(n + 1);
string s[n + 1], str[m + 1];
map<string, long long> mp;
for (int i = (0); i < n; i++) {
cin >> s[i];
}
for (int i = (0); i < n; i++) cin >> a[i];
vector<long long> v1(n + 1);
for (int i = (0); i < k; i++) {
long long x;
cin >> x;
long long min1 = N;
for (int j = (0); j < x; j++) {
cin >> y;
v1[j] = y - 1;
min1 = min(min1, a[y - 1]);
}
for (int j = (0); j < x; j++) a[v1[j]] = min1;
v1.clear();
}
for (int i = (0); i < m; i++) cin >> str[i];
string s1;
for (int i = (0); i < n; i++) mp[s[i]] = a[i];
for (int i = (0); i < m; i++) {
c += mp[str[i]];
}
cout << c;
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
long long n, p, ans;
int main() {
cin >> n >> p;
for (int i = 1; i <= n; i++) {
long long num = 1;
while (num <= i) {
num *= 10;
}
long long sum1 = (i * num) % p;
long long tmp = i;
long long sum2 = 0;
while (tmp) {
long long s = tmp % 10;
sum2 = sum2 * 10 + s;
tmp /= 10;
}
ans = (ans + (sum1 + sum2) % p) % p;
}
cout << ans % p;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, n;
cin >> A >> B >> n;
if (A == 0 && B == 0) {
cout << 0 << endl;
return 0;
}
if (A == 0) {
cout << "No solution" << endl;
return 0;
}
if (B == 0) {
cout << 0 << endl;
return 0;
}
if (B % A != 0) {
cout << "No solution" << endl;
return 0;
}
int R = B / A;
if (R == 0) {
cout << 0 << endl;
return 0;
}
for (int x = -1000; x < 1001; x++) {
if (x == 0) continue;
int r = R;
bool end = true;
for (int i = 0; i < n; i++) {
if (R % x != 0) {
end = false;
break;
} else
R /= x;
}
if (end && R == 1) {
cout << x << endl;
return 0;
}
R = r;
}
cout << "No solution" << endl;
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
struct Point {
long long x, y;
Point(long long xx = 0, long long yy = 0) { x = xx, y = yy; }
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
long long dot(Point p) { return x * p.x + y * p.y; }
long long det(Point p) { return x * p.y - y * p.x; }
} a[1005], p[9];
bool flag[1005], used[9];
vector<int> s[8][1005];
int n, k, st[10][1005], top[10], ans;
int c[1005], t;
bool dfs(int step) {
if (!top[step]) return 1;
if (top[step] > step) return 0;
int now = st[step][top[step]--];
for (int i = 1; i <= k; i++) {
if (used[i]) continue;
top[step - 1] = top[step];
for (int j = 1; j <= top[step]; j++) st[step - 1][j] = st[step][j];
int num = (int)s[i][now].size();
int tt = t;
for (int j = 0; j < num; j++) {
if (!flag[s[i][now][j]]) {
flag[s[i][now][j]] = 1;
st[step - 1][++top[step - 1]] = s[i][now][j];
c[++t] = s[i][now][j];
}
}
used[i] = 1;
if (dfs(step - 1)) return 1;
used[i] = 0;
while (t != tt) flag[c[t--]] = 0;
}
return 0;
}
int main() {
scanf("%d%d", &k, &n);
for (int i = 1; i <= k; i++) scanf("%lld%lld", &p[i].x, &p[i].y);
for (int i = 1; i <= n; i++) scanf("%lld%lld", &a[i].x, &a[i].y);
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= n; j++) {
for (int k = 1; k <= n; k++) {
if (k == j) continue;
if ((a[j] - a[k]).det(p[i] - a[k]) == 0 &&
(a[j] - a[k]).dot(p[i] - a[k]) < 0) {
s[i][j].push_back(k);
}
}
}
}
for (int i = 1; i <= n; i++) {
memset(flag, 0, sizeof(flag));
memset(used, 0, sizeof(used));
top[k] = 0;
st[k][++top[k]] = i;
flag[i] = 1;
if (dfs(k)) {
ans++;
}
}
printf("%d\n", ans);
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
long long a[n + 1];
for (long long i = 1; i <= n; ++i) cin >> a[i];
sort(a + 1, a + n + 1);
if (n % 2 == 0)
cout << n / 2 - 1 << '\n';
else
cout << n / 2 << '\n';
int s = 1, e = n, p = 1;
while (s <= e) {
if (p)
cout << a[e] << " ", --e;
else
cout << a[s] << " ", ++s;
p = 1 - p;
}
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int64_t N = 2e5 + 5e4 + 1e2;
bool mark[N], done;
int64_t n, m, k, d[N], par[N], s;
vector<int64_t> adj[N], leaf;
void path(int64_t v, int64_t u) {
while (v != u) {
cout << v << ' ';
v = par[v];
}
cout << u << '\n';
done = true;
}
void dfs(int64_t v) {
mark[v] = true;
if (d[v] >= n / k + (n % k != 0) && !done) {
cout << "PATH \n";
cout << d[v] + 1 << '\n';
path(v, s);
}
int64_t c = 0;
for (int64_t i = 0; i < adj[v].size(); i++) {
int64_t x = adj[v][i];
if (mark[x]) continue;
d[x] = d[v] + 1;
c++;
par[x] = v;
dfs(x);
}
if (c == 0) leaf.push_back(v);
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> k;
int64_t x, y;
for (int64_t i = 0; i < m; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
s = 1;
par[1] = 1;
dfs(1);
if (done) return 0;
cout << "CYCLES \n";
for (int64_t i = 0, j = 0; i < leaf.size(); i++) {
int64_t a = leaf[i], b = 0, c = 0;
for (int64_t l = 0; l < adj[a].size(); l++) {
int64_t x = adj[a][l];
if (x == par[a]) continue;
if (!b)
b = x;
else
c = x;
if (d[c] > d[b]) swap(b, c);
}
if ((d[b] - d[c] + 2) % 3 != 0) {
j++;
cout << d[b] - d[c] + 2 << '\n';
cout << a << ' ';
path(b, c);
if (j == k) return 0;
continue;
}
if ((d[a] - d[c] + 1) % 3 != 0) {
j++;
cout << d[a] - d[c] + 1 << '\n';
path(a, c);
if (j == k) return 0;
continue;
}
if ((d[a] - d[b] + 1) % 3 != 0) {
j++;
cout << d[a] - d[b] + 1 << '\n';
path(a, b);
if (j == k) return 0;
continue;
}
}
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, b;
} t[5005];
bool cmp(node x, node y) {
if (x.a != y.a) {
return x.a < y.a;
} else {
return x.b < y.b;
}
}
int main() {
int n;
while (~scanf("%d", &n)) {
for (int i = 0; i < n; i++) {
scanf("%d%d", &t[i].a, &t[i].b);
}
sort(t, t + n, cmp);
int ans = t[0].b, flag = 0;
for (int i = 1; i < n; i++) {
if (!flag) {
if (ans > t[i].b) {
ans = t[i].a;
flag = 1;
continue;
}
ans = t[i].b;
}
if (flag) {
if (t[i].b >= ans) {
ans = t[i].b;
flag = 0;
} else {
ans = t[i].a;
}
}
}
printf("%d\n", ans);
}
return 0;
}
| 6
|
#include <iostream>
#include <bits/stdc++.h>
#include <fstream>
using namespace std;
#define IOF \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(NULL);
#define ll long long int
#define M 1000000007
vector<int> primes;
bool vis[31624 + 1];
int factorize(int n)
{
int count = 0;
for (auto x : primes)
{
if (n < x)
break;
while (n % x == 0)
{
n = n / x;
count++;
}
}
if (n > 1)
count++;
return count;
}
void seive(int n)
{
for (int i = 2; i * i <= n; i++)
{
if (!vis[i])
{
for (int j = i * i; j <= n; j += i)
{
vis[j] = 1;
}
}
}
for (int i = 2; i <= n; i++)
{
if (!vis[i])
primes.push_back(i);
}
}
long long int calculatepower(long long int A, long long int B)
{
if (B == 0)
return 1;
else if (B % 2 == 0)
return calculatepower((A * A) % M, B >> 1) % M;
else
return (A * calculatepower((A * A) % M, B >> 1) % M);
}
long long int fastExp(ll a, ll b)
{
ll res = 1;
while (b > 0)
{
if (b & 1)
{
res = (res * a) % M;
}
a = (a * a) % M;
b = b >> 1;
}
return res;
}
#define min_heap priority_queue<int, vector<int>, greater<int>> // min heap
// ifstream fin("input.txt");
// ofstream fout("output.txt");
/*=======================================================================================*/
void solve()
{
ll n, k, x;
cin >> n >> k >> x;
ll ar[n];
for (auto &x : ar)
cin >> x;
sort(ar, ar + n);
vector<ll> g;
for (ll i = 1; i < n; i++)
{
if (ar[i] - ar[i - 1] > x)
g.push_back(ar[i] - ar[i - 1]);
}
ll mnGroups = g.size() + 1;
sort(g.begin(), g.end());
for (auto tt : g)
{
ll tmp;
if (tt % x == 0)
{
tmp = tt / x;
tmp--;
}
else
tmp = tt / x;
if (k >= tmp)
{
mnGroups--;
k -= tmp;
}
else
break;
}
cout << mnGroups;
}
int32_t main()
{
#ifndef ONLINE_JUDGE
freopen("inputf.in", "r", stdin);
freopen("outputf.in", "w", stdout);
#endif
ll t = 1;
//cin >> kk;
while (t--)
{
solve();
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
inline bool iseq(double x, double y) {
if (fabs(x - y) < 1e-8) return true;
return false;
}
template <typename T>
inline T hpt(T x1, T y1, T x2, T y2) {
return hypot(x1 - x2, y1 - y2);
}
template <typename T>
inline T gcd(T a, T b) {
if (!b)
return a;
else
return gcd(b, a % b);
}
template <typename T>
inline void extended_euclid(T a, T b, T &x, T &y) {
if (a % b == 0)
x = 0, y = 1;
else {
extended_euclid(b, a % b, x, y);
T temp = x;
x = y;
y = -y * (a / b) + temp;
}
}
template <typename T>
inline T bigmod(T b, T p, T m) {
if (!p)
return 1;
else if (!(p % 2)) {
T x = bigmod(b, p / 2, m);
return x * x;
} else
return ((b % m) * bigmod(b, p - 1, m)) % m;
}
int prime[5 / 32 + 1];
void setbit(int i) {
int p = i >> 5, q = i & 31;
prime[p] |= (1 << q);
}
bool checkbit(int i) {
int p = i >> 5, q = i & 31;
return prime[p] & (1 << q) ? true : false;
}
void buildprime(int n) {
int i, j, k = sqrt(double(n));
prime[0] = 3;
for (i = 4; i < n; i += 2) setbit(i);
for (i = 3; i <= k; i += 2) {
if (!checkbit(i)) {
int ii = i + i;
for (j = i * i; j < n; j += ii) setbit(j);
}
}
}
int sum, r, n, N, R, C, t, txt;
long long x, y, z, ans, k;
int main() {
int i, j;
while (cin >> x >> y >> z >> k) {
k = k + 3;
long long a[5];
long long b[5];
a[1] = x;
a[2] = y;
a[3] = z;
long long tem = k / 3;
b[1] = b[2] = b[3] = tem;
long long extra = k % 3;
long long flag = 3;
for (i = 1; i <= 3; i++) {
if (b[i] >= a[i]) {
long long dif = b[i] - a[i];
extra += dif;
b[i] = a[i];
flag--;
}
}
while (extra > 0 && flag > 0) {
long long ttem = extra / flag;
extra = extra % flag;
for (i = 1; i <= 3; i++) {
if (b[i] < a[i]) {
b[i] += ttem;
if (b[i] >= a[i]) {
extra += (b[i] - a[i]);
b[i] = a[i];
flag--;
}
}
if (extra >= 1 && b[i] < a[i]) {
extra--;
b[i]++;
if (b[i] == a[i]) flag--;
}
if (flag <= 0) break;
}
}
cout << b[1] * b[2] * b[3] << endl;
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int n, g, a[MAXN], Next[MAXN];
long long ans;
vector<int> s[MAXN];
inline void solve(register int L, register int R) {
for (register int i = L; i <= min(n, R); ++i)
if (Next[i] < R)
ans += 1LL * g * (R - Next[i]), Next[i] = R;
else
break;
}
int main() {
scanf("%d", &n);
for (register int i = 1; i <= n; ++i) {
scanf("%d", a + i);
Next[i] = i;
for (register int j = 1; j * j <= a[i]; ++j)
if (a[i] % j == 0) {
s[a[i] / j].push_back(i);
if (j * j != a[i]) s[j].push_back(i);
}
}
for (g = 200000; g; --g) {
if (s[g].size() < 2) continue;
solve(s[g][1] + 1, n + 1);
solve(s[g][0] + 1, s[g][s[g].size() - 1]);
solve(1, s[g][s[g].size() - 2]);
}
printf("%lld\n", ans);
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
cin >> t;
while (t--) {
long long n;
cin >> n;
vector<long long> a(n);
long long e = -1, s = -1;
for (long long i = 0; i < n; i++) {
cin >> a[i];
if (a[i]) {
if (s == -1) s = i;
e = i;
}
}
long long ans = 0;
for (long long i = s + 1; i < e; i++)
if (a[i] == 0) ans++;
cout << ans << "\n";
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
namespace fmt {
void print(...) {}
} // namespace fmt
using namespace std;
long long start[(50)];
long long succ[(2 * 500)], cap_orig[(2 * 500)], cap[(2 * 500)], to[(2 * 500)];
long long edge_counter = 0;
void _add_edge(long long u, long long v, long long c) {
cap_orig[edge_counter] = c;
cap[edge_counter] = c, to[edge_counter] = v;
succ[edge_counter] = start[u];
start[u] = edge_counter;
++edge_counter;
}
void add_edge(long long a, long long b, long long c) {
_add_edge(a, b, c);
_add_edge(b, a, 0);
}
long long n = (50), s = 0, t = 1;
long long lvl[(50)];
long long nextchld[(50)];
bool bfs() {
for (long long i = 0; i < n; i++) lvl[i] = -1;
queue<long long> q;
q.push(s);
lvl[s] = 0;
while (!q.empty()) {
long long u = q.front();
q.pop();
nextchld[u] = start[u];
for (long long e = start[u]; ~e; e = succ[e]) {
if (cap[e] > 0) {
long long nxt = to[e];
if (lvl[nxt] != -1) continue;
lvl[nxt] = lvl[u] + 1;
q.push(nxt);
}
}
}
return lvl[t] != -1;
}
long long aug(long long u, long long cflow) {
if (u == t) return cflow;
for (long long &i = nextchld[u]; i >= 0; i = succ[i]) {
if (cap[i] > 0) {
long long nxt = to[i];
if (lvl[nxt] != lvl[u] + 1) continue;
long long rf = aug(nxt, min(cflow, cap[i]));
if (rf > 0) {
cap[i] -= rf;
cap[i ^ 1] += rf;
return rf;
}
}
}
lvl[u] = -1;
return 0;
}
long long mf() {
long long tot = 0;
while (bfs())
for (long long x = aug(s, INT64_MAX); x; x = aug(s, INT64_MAX)) tot += x;
return tot;
}
void reset() {
fill(start, start + (50), -1);
fill(succ, succ + (2 * 500), 0);
fill(cap, cap + (2 * 500), 0);
fill(cap_orig, cap_orig + (2 * 500), 0);
fill(to, to + (2 * 500), 0);
fill(lvl, lvl + (50), 0);
fill(nextchld, nextchld + (50), 0);
}
void reset2() {
fill(lvl, lvl + (50), 0);
fill(nextchld, nextchld + (50), 0);
}
void cap_scale(long double factor) {
for (long long i = 0; i < (2 * 500); ++i) {
if (cap_orig[i] == 0)
cap[i] = 0;
else
cap[i] = static_cast<long long>(floor((cap_orig[i]) / factor));
}
}
long long qn, qm, qx;
bool decision(long double factor) {
reset2();
cap_scale(factor);
long long mff = mf();
fmt::print("mf({}) = {}\n", factor, mff);
return (mff >= qx);
}
long double binarysearch(void) {
long double l = 0.0;
long double r = 1000001.0;
long double eps = 1e-12;
while ((l + eps) < r) {
long double m = 0.5 * (l + r);
if (!decision(m))
r = m;
else
l = m;
}
return 0.5 * (l + r);
}
int32_t main(void) {
reset();
cin >> qn >> qm >> qx;
t = (qn - 1);
for (long long i = 0; i < qm; ++i) {
long long a, b, c;
cin >> a >> b >> c;
a -= 1;
b -= 1;
add_edge(a, b, c);
}
cout << fixed << setprecision(10);
long double bs = binarysearch();
fmt::print("bs = {}\n", bs);
cout << (qx * bs) << endl;
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 100111, inf = 1000111222;
const int max_d = 55;
int n, m, d, comp, used[max_n], eu[max_n], ev[max_n], root[max_n],
dp[max_n][max_d];
char s[max_n][max_d], can[max_n][max_d];
bitset<max_d> b1, b2;
vector<int> g[max_n], rg[max_n], order, order2;
vector<pair<int, int>> nxt[max_n];
void dfs1(int v) {
used[v] = 1;
for (int to : g[v]) {
if (!used[to]) {
dfs1(to);
}
}
order.push_back(v);
}
void dfs2(int v) {
used[v] = comp;
for (int to : rg[v]) {
if (used[to] == -1) {
dfs2(to);
}
}
}
void get_all_can() {
queue<pair<int, int>> q;
for (int i = 0; i < comp; ++i) {
q.push({root[i], 0});
can[root[i]][0] = 1;
}
while (!q.empty()) {
pair<int, int> p = q.front();
q.pop();
int v = p.first, t = p.second;
t = (t + 1) % d;
for (int to : g[v]) {
if (!can[to][t]) {
can[to][t] = 1;
q.push({to, t});
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &d);
for (int i = 0; i < m; ++i) {
scanf("%d%d", &eu[i], &ev[i]);
--eu[i];
--ev[i];
g[eu[i]].push_back(ev[i]);
rg[ev[i]].push_back(eu[i]);
}
for (int i = 0; i < n; ++i) {
scanf("%s", s[i]);
}
for (int i = 0; i < n; ++i) {
if (!used[i]) {
dfs1(i);
}
}
reverse(order.begin(), order.end());
memset(used, -1, sizeof(used));
for (int v : order) {
if (used[v] == -1) {
dfs2(v);
root[comp] = v;
++comp;
}
}
root[used[0]] = 0;
for (int i = 0; i < n; ++i) {
g[i].clear();
rg[i].clear();
}
for (int i = 0; i < m; ++i) {
if (used[eu[i]] == used[ev[i]]) {
g[eu[i]].push_back(ev[i]);
}
}
get_all_can();
for (int i = 0; i < n; ++i) {
for (int j = 0; j < d; ++j) {
b1[j] = s[i][j] - '0';
b2[j] = can[i][j];
}
for (int j = 0; j < d; ++j) {
if ((b1 & b2).count()) {
++dp[used[i]][j];
}
b2 <<= 1;
b2[0] = b2[d];
}
}
for (int i = 0; i < m; ++i) {
if (used[eu[i]] != used[ev[i]]) {
int v = eu[i], to = used[ev[i]];
for (int j = 0; j < d; ++j) {
if (can[v][j]) {
nxt[used[v]].push_back({to, (j + 1) % d});
}
}
}
}
for (int i = comp - 1; i >= 0; --i) {
for (int st = 0; st < d; ++st) {
int pl = 0;
for (const pair<int, int> &to : nxt[i]) {
pl = max(pl, dp[to.first][(st + to.second) % d]);
}
dp[i][st] += pl;
}
}
printf("%d\n", dp[used[0]][0]);
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ans[n];
for (int i = 0; i < n; i++) {
int a, b, z;
bool k = true;
cin >> a >> b >> z;
ans[i] = 0;
if (a > b) {
k = false;
}
while (a <= z && b <= z) {
if (k) {
a += b;
k = false;
} else {
b += a;
k = true;
}
ans[i]++;
}
}
for (int i = 0; i < n; i++) {
cout << ans[i] << endl;
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
template <typename X>
void MA(X& a, X b) {
a = max(a, b);
}
template <typename X>
void MI(X& a, X b) {
a = min(a, b);
}
template <typename X>
void clr(X& x, int a) {
memset(x, a, sizeof(a));
};
int cond = 0, multi = 0, gcj = 0;
struct solver_t;
solver_t* solver;
struct solver_t {
int N;
struct interval_t;
set<interval_t> all_int;
map<int, interval_t> m2i;
struct interval_t {
int val = 0, cnt = 0, pos = 0;
interval_t() {}
interval_t(int val, int cnt, int pos) : val(val), cnt(cnt), pos(pos) {}
bool operator<(const interval_t& rhs) const {
if (cnt != rhs.cnt) return cnt > rhs.cnt;
return pos < rhs.pos;
}
void unregister() {
solver->all_int.erase(*this);
solver->m2i.erase(pos);
}
void registerx() {
solver->m2i[pos] = *this;
solver->all_int.insert(*this);
}
};
solver_t() {}
void solve() {
cin >> N;
vector<int> A(N + 1);
for (auto i = (0); i < (N); ++i) cin >> A[i];
int last_val = A[0];
int last_cnt = 1;
for (auto i = (1); i <= (N); ++i) {
if (i == N || A[i] != A[i - 1]) {
interval_t(A[i - 1], last_cnt, i - 1).registerx();
last_val = A[i];
last_cnt = 1;
} else
last_cnt++;
if (i == N) break;
}
int res = 0;
while (!all_int.empty()) {
res++;
auto first_cur = all_int.begin();
auto first_val = *first_cur;
first_val.unregister();
m2i.erase(first_val.pos);
auto cur = m2i.lower_bound(first_val.pos);
if (cur != m2i.begin() && cur != m2i.end()) {
auto cur_prev = cur;
cur_prev--;
if (cur->second.val == cur_prev->second.val) {
auto v1 = cur_prev->second;
auto v2 = cur->second;
v1.unregister();
v2.unregister();
interval_t(v1.val, v1.cnt + v2.cnt, v1.pos).registerx();
}
}
}
cout << res << "\n";
}
};
int main(int argc, char** argv) {
ios::sync_with_stdio(false), cin.tie(0),
cond = argc >= 2 && argv[1][0] == 'q' ? 1 << 30 : 0;
cout.setf(ios::fixed), cout.precision(10);
int t;
if (multi || gcj)
cin >> t;
else
t = 1;
for (auto i = (1); i <= (t); ++i) {
if (cond) cerr << 102 << " " << i << endl;
if (gcj) cout << "Case #" << i << ": ";
solver = new solver_t();
solver->solve();
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
if (n == 0) {
cout << 0 << endl;
return 0;
}
if ((n + 1) & 1ll)
cout << (n + 1) << endl;
else
cout << ((n + 1) / 2ll) << endl;
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 8;
int n, m = -1, p = -1;
int L[maxn][maxn], H[maxn][maxn], A[maxn][maxn];
int B[maxn][maxn];
void input() {
scanf("%d", &n);
for (int i = 1; i <= n * (n - 1) / 2; i++) {
int u, v;
scanf("%d%d", &u, &v);
scanf("%d%d%d", &L[u][v], &H[u][v], &A[u][v]);
}
}
void caln() {
int cnt = 0, cost = 0;
for (int i = 2; i <= n; i++) cnt += B[1][i];
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
if (B[i][j] > 0) cost += A[i][j] + B[i][j] * B[i][j];
if (m == -1 || cnt < m || (cnt == m && cost > p)) {
m = cnt;
p = cost;
}
}
void search(int r, int c) {
if (r == 1 && c == n + 1) {
int cnt = 0;
for (int i = 2; i <= n; i++) cnt += B[1][i];
if (m != -1 && cnt > m) return;
}
if (r == n) {
caln();
return;
}
if (c == n + 1) {
search(r + 1, r + 2);
return;
}
if (r > 1 && c == n) {
int cnt = 0;
for (int i = 1; i < r; i++) cnt += B[i][r];
for (int i = r + 1; i < n; i++) cnt -= B[r][i];
if (L[r][c] <= cnt && cnt <= H[r][c]) {
B[r][c] = cnt;
search(r, c + 1);
}
return;
}
for (B[r][c] = L[r][c]; B[r][c] <= H[r][c]; B[r][c]++) search(r, c + 1);
}
void solve() {
search(1, 2);
printf("%d %d\n", m, p);
}
int main() {
input();
solve();
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, xi, xa, yi, ya, a0, a1, a2, a3;
while (~scanf("%d", &n)) {
int i, x, y, res = 0;
for (i = 0; i < n; i++) {
scanf("%d%d", &x, &y);
if (!i) {
xi = xa = x;
yi = ya = y;
a0 = a2 = y - x;
a1 = a3 = y + x;
}
if (x < xi)
xi = x;
else if (x > xa)
xa = x;
if (y < yi)
yi = y;
else if (y > ya)
ya = y;
if (a0 < y - x)
a0 = y - x;
else if (a2 > y - x)
a2 = y - x;
if (a1 < y + x)
a1 = y + x;
else if (a3 > y + x)
a3 = y + x;
}
xi--, xa++, yi--, ya++;
res = (ya - yi) * 2 + (xa - xi) * 2;
res -= (ya - a0 - 1) - xi;
res -= xa - (yi - a2 + 1);
res -= xa - (a1 + 1 - ya);
res -= (a3 - 1 - yi) - xi;
printf("%d\n", res);
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 110;
int pv[MAXN], nx[MAXN];
void del(int x) {
nx[pv[x]] = nx[x];
pv[nx[x]] = pv[x];
}
int main() {
int n, k;
scanf("%d%d", &n, &k);
int left = n;
for (int i = 1; i <= n; i++) {
pv[i] = i - 1;
nx[i] = i + 1;
}
pv[1] = n;
nx[n] = 1;
int cur = 1;
while (k--) {
int x;
scanf("%d", &x);
x %= left;
while (x--) cur = nx[cur];
printf("%d\n", cur);
del(cur);
cur = nx[cur];
left--;
}
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
long long count10 = 0;
long long ans = 1, x = 10;
string s;
int main() {
map<char, bool> letter;
letter['A'] = false, letter['B'] = false, letter['C'] = false;
letter['D'] = false, letter['E'] = false, letter['F'] = false;
letter['H'] = false, letter['I'] = false, letter['J'] = false;
letter['G'] = false;
cin >> s;
if (s[0] == 'A' || s[0] == 'B' || s[0] == 'C' || s[0] == 'D' || s[0] == 'E' ||
s[0] == 'F' || s[0] == 'G' || s[0] == 'H' || s[0] == 'I' || s[0] == 'J') {
letter[s[0]] = true;
ans = 9;
x = 9;
}
if (s[0] == '?') ans = 9;
for (int i = 1; i < s.size(); ++i) {
if (s[i] == 'A' || s[i] == 'B' || s[i] == 'C' || s[i] == 'D' ||
s[i] == 'E' || s[i] == 'F' || s[i] == 'G' || s[i] == 'H' ||
s[i] == 'I' || s[i] == 'J')
if (!letter[s[i]]) {
letter[s[i]] = true;
if (x == 10)
++count10;
else
ans *= x;
--x;
}
if (s[i] == '?') ++count10;
}
cout << ans;
for (int i = 0; i < count10; ++i) cout << '0';
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
void si(int &n) { scanf("%d", &n); }
void sii(int &n, int &m) { scanf("%d%d", &n, &m); }
constexpr long long int TEN(int n) { return (n == 0) ? 1 : 10 * TEN(n - 1); }
template <class T>
bool uin(T &a, T b) {
return a > b ? (a = b, true) : false;
}
template <class T>
bool uax(T &a, T b) {
return a < b ? (a = b, true) : false;
}
const int N = 1e5 + 8;
const int MOD = 1e9 + 7;
vector<pair<int, int> > ro, co, *temp;
int r, c, a[200][2000];
void go(bool earth) {
if (!earth) {
for (int i = 0; i < (int)(r); ++i) {
int mn = 100000;
for (int j = 0; j < (int)(c); ++j) mn = min(mn, a[i][j]);
if (mn) temp->push_back({i, mn});
for (int j = 0; j < (int)(c); ++j) a[i][j] -= mn;
}
} else {
for (int i = 0; i < (int)(c); ++i) {
int mn = 100000;
for (int j = 0; j < (int)(r); ++j) mn = min(mn, a[j][i]);
if (mn) temp->push_back({i, mn});
for (int j = 0; j < (int)(r); ++j) a[j][i] -= mn;
}
}
}
int main() {
sii(r, c);
for (int i = 0; i < (int)(r); ++i)
for (int j = 0; j < (int)(c); ++j) si(a[i][j]);
if (r <= c) {
temp = &ro;
go(0);
temp = &co;
go(1);
} else {
temp = &co;
go(1);
temp = &ro;
go(0);
}
for (int i = 0; i < (int)(r); ++i)
for (int j = 0; j < (int)(c); ++j)
if (a[i][j]) {
cout << -1;
return 0;
}
int ans = 0;
for (int i = 0; i < (int)(ro.size()); ++i) ans += ro[i].second;
for (int i = 0; i < (int)(co.size()); ++i) ans += co[i].second;
cout << ans << endl;
for (int i = 0; i < (int)(ro.size()); ++i)
for (int j = 0; j < (int)(ro[i].second); ++j)
cout << "row " << ro[i].first + 1 << endl;
for (int i = 0; i < (int)(co.size()); ++i)
for (int j = 0; j < (int)(co[i].second); ++j)
cout << "col " << co[i].first + 1 << endl;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int N;
vector<int> G[100005], S[100005], T[100005], C[100005];
int nodes;
void recon(int nod, int fat) {
for (int i = 0; i < G[nod].size(); ++i) {
int nnod = G[nod][i];
if (nnod != fat) {
S[nod].push_back(nnod);
recon(nnod, nod);
}
}
}
void baga(int nods, int nodt) {
for (int i = 0; i < S[nods].size(); ++i) {
int nnod = S[nods][i];
++nodes;
C[nodes].push_back(nods);
C[nodes].push_back(nnod);
T[nodt].push_back(nodes);
baga(nnod, nodes);
}
}
int main() {
scanf("%d", &N);
for (int i = 1; i < N; ++i) {
int a, b;
scanf("%d %d", &a, &b);
G[a].push_back(b);
G[b].push_back(a);
}
recon(1, 0);
baga(1, 0);
for (int i = 1; i < T[0].size(); ++i) T[1].push_back(T[0][i]);
T[0].clear();
printf("%d\n", nodes);
for (int i = 1; i <= nodes; ++i) {
printf("%d ", C[i].size());
for (int j = 0; j < C[i].size(); ++j) printf("%d ", C[i][j]);
printf("\n");
}
for (int i = 1; i <= nodes; ++i)
if (T[i].size())
for (int j = 0; j < T[i].size(); ++j) printf("%d %d\n", i, T[i][j]);
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int SI = 2e5 + 100;
char dp[5005][505];
int pre_x[5005][505], pre_y[5005][505];
bool vis[5005][505];
int mod, s;
struct node {
int sum, m;
};
void bfs() {
queue<node> q;
vis[0][0] = true;
pre_x[0][0] = -1;
pre_y[0][0] = -1;
int news, newm;
node ad, to;
ad.sum = 0;
ad.m = 0;
q.push(ad);
while (q.empty() == false) {
ad = q.front();
q.pop();
for (int i = 0; i <= 9; i++) {
if (i == 0 && ad.sum == 0) continue;
news = ad.sum + i;
newm = (ad.m * 10 + i) % mod;
if (news > s) continue;
if (vis[news][newm] == false) {
vis[news][newm] = true;
dp[news][newm] = i + '0';
pre_x[news][newm] = ad.sum;
pre_y[news][newm] = ad.m;
to.sum = news;
to.m = newm;
q.push(to);
}
}
}
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> mod >> s;
bfs();
string ans = "";
if (vis[s][0]) {
int x, y;
x = s;
y = 0;
while (pre_x[x][y] != -1) {
ans = dp[x][y] + ans;
int nx = pre_x[x][y];
int ny = pre_y[x][y];
x = nx;
y = ny;
}
cout << ans;
} else
cout << -1;
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int issq(int n) {
if (n < 0) return false;
int rt = sqrt(n);
return rt * rt == n;
}
int main() {
ios::sync_with_stdio(0);
int n;
cin >> n;
int ans = -1e9;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (!issq(x)) ans = max(ans, x);
}
cout << ans << endl;
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, t = 1;
register char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') t = -1, ch = getchar();
while (ch <= '9' && ch >= '0') x = x * 10 + ch - 48, ch = getchar();
return x * t;
}
int fpow(int a, int b) {
int s = 1;
while (b) {
if (b & 1) s = 1ll * s * a % 1000000007;
a = 1ll * a * a % 1000000007;
b >>= 1;
}
return s;
}
struct Line {
int v, next;
} e[222222 << 1];
int h[222222], cnt = 1;
inline void Add(int u, int v) {
e[cnt] = (Line){v, h[u]};
h[u] = cnt++;
}
int a[222222], b[222222], n;
int phi[222222], mu[222222], pri[222222], tot;
bool zs[222222];
void pre(int N) {
zs[1] = true;
phi[1] = mu[1] = 1;
for (int i = 2; i <= N; ++i) {
if (!zs[i]) pri[++tot] = i, mu[i] = -1, phi[i] = i - 1;
for (int j = 1; j <= tot && i * pri[j] <= N; ++j) {
zs[i * pri[j]] = true;
if (i % pri[j])
phi[i * pri[j]] = phi[i] * phi[pri[j]], mu[i * pri[j]] = -mu[i];
else {
mu[i * pri[j]] = 0, phi[i * pri[j]] = phi[i] * pri[j];
break;
}
}
}
}
int dfn[222222], low[222222], size[222222], hson[222222], top[222222],
fa[222222], tim, dep[222222];
void dfs1(int u, int ff) {
fa[u] = ff;
dep[u] = dep[ff] + 1;
size[u] = 1;
for (int i = h[u]; i; i = e[i].next) {
int v = e[i].v;
if (v == ff) continue;
dfs1(v, u);
size[u] += size[v];
if (size[v] > size[hson[u]]) hson[u] = v;
}
}
void dfs2(int u, int tp) {
top[u] = tp;
dfn[u] = ++tim;
if (hson[u]) dfs2(hson[u], tp);
for (int i = h[u]; i; i = e[i].next)
if (e[i].v != fa[u] && e[i].v != hson[u]) dfs2(e[i].v, e[i].v);
low[u] = tim;
}
int LCA(int u, int v) {
while (top[u] ^ top[v])
dep[top[u]] < dep[top[v]] ? v = fa[top[v]] : u = fa[top[u]];
return dep[u] < dep[v] ? u : v;
}
bool cmp(int a, int b) { return dfn[a] < dfn[b]; }
int ans = 0, K, p[222222 << 1], S[222222], f[222222];
bool vis[222222];
void Plus(int &x, int y) {
x += y;
if (x >= 1000000007) x -= 1000000007;
}
void DP(int u) {
f[u] = vis[u] ? phi[a[u]] : 0;
Plus(ans, 1000000007 - 1ll * f[u] * f[u] % 1000000007 * dep[u] % 1000000007);
for (int i = h[u]; i; i = e[i].next) {
DP(e[i].v);
Plus(ans, 1000000007 -
2ll * f[u] * f[e[i].v] % 1000000007 * dep[u] % 1000000007);
Plus(f[u], f[e[i].v]);
}
}
int F[222222], G[222222];
int main() {
n = read();
pre(n);
for (int i = 1; i <= n; ++i) a[i] = read(), b[a[i]] = i;
for (int i = 1; i < n; ++i) {
int u = read(), v = read();
Add(u, v);
Add(v, u);
}
dfs1(1, 0);
dfs2(1, 1);
memset(h, 0, sizeof(h));
for (int T = 1; T <= n; ++T) {
K = n / T;
int s1 = 0, s2 = 0;
cnt = 1;
for (int i = 1; i <= K; ++i) p[i] = b[i * T];
for (int i = 1; i <= K; ++i)
Plus(s1, phi[a[p[i]]]),
Plus(s2, 1ll * dep[p[i]] * phi[a[p[i]]] % 1000000007);
for (int i = 1; i <= K; ++i) vis[p[i]] = true;
sort(&p[1], &p[K + 1], cmp);
for (int i = K; i > 1; --i) p[++K] = LCA(p[i], p[i - 1]);
sort(&p[1], &p[K + 1], cmp);
K = unique(&p[1], &p[K + 1]) - p - 1;
for (int i = 1, tp = 0; i <= K; ++i) {
while (tp && low[S[tp]] < dfn[p[i]]) --tp;
Add(S[tp], p[i]);
S[++tp] = p[i];
}
DP(p[1]);
Plus(ans, ans);
Plus(ans, 2ll * s1 * s2 % 1000000007);
for (int i = 1; i <= K; ++i) h[p[i]] = 0, vis[p[i]] = false;
F[T] = ans;
ans = 0;
}
for (int i = 1; i <= n; ++i)
for (int j = i; j <= n; j += i)
if (mu[j / i] != 0)
Plus(G[i], (mu[j / i] == 1) ? F[j] : (1000000007 - F[j]));
for (int i = 1; i <= n; ++i)
G[i] =
1ll * G[i] * i % 1000000007 * fpow(phi[i], 1000000007 - 2) % 1000000007;
for (int i = 1; i <= n; ++i) Plus(ans, G[i]);
ans = 1ll * ans * fpow(n, 1000000007 - 2) % 1000000007 *
fpow(n - 1, 1000000007 - 2) % 1000000007;
printf("%d\n", ans);
return 0;
}
| 23
|
#include <bits/stdc++.h>
using namespace std;
int oo = 0x3f3f3f3f;
double inf = 1.0 / 0.0;
const double pi = 2 * acos(0.0);
const int MOD = 1e9 + 7;
const int MOD1 = 998244353;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> qq;
int xx, rr = 0, rr2 = 0;
for (int i = 1; i <= n; i++) {
cin >> xx;
qq.push_back(xx);
if (xx & 1)
rr = 1;
else
rr2 = 1;
}
if (rr * rr2 == 0) {
for (int i = 0; i < n; i++) cout << qq[i] << " ";
return 0;
}
sort(qq.begin(), qq.end());
for (int i = 0; i < n; i++) cout << qq[i] << " ";
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
long long t, n, i, j, k, x, y, z, l, r, mid, mod = 1e9 + 7, g, m, ans;
long long a[1001][1001], b[1005], c[1005], xx, yy;
char ch;
string s, st;
vector<int> v[300005], u;
long long f(long long x) { return x * x; }
int main() {
ios::sync_with_stdio(NULL);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) cin >> a[i][j], b[i] += a[i][j], c[j] += a[i][j];
x = y = 1e18;
for (i = 0; i <= n; i++) {
z = 0;
for (j = 1; j <= n; j++) z += b[j] * f(4 * i - 4 * j + 2);
if (z < x) {
x = z;
xx = i;
}
}
for (i = 0; i <= m; i++) {
z = 0;
for (j = 1; j <= m; j++) z += c[j] * f(4 * i - 4 * j + 2);
if (z < y) {
y = z;
yy = i;
}
}
cout << x + y << "\n" << xx << " " << yy;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T pr(T x) {
return --x;
}
template <class T>
inline T nx(T x) {
return ++x;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline void get(T &n) {
char c = getchar();
while (c != '-' && (c < '0' || c > '9')) c = getchar();
n = 0;
T s = 1;
if (c == '-') s = -1, c = getchar();
while (c >= '0' && c <= '9') n *= 10, n += c - '0', c = getchar();
n *= s;
}
const long long maxn = 300010;
long long a[3], sum, l, ans, s[maxn], ss[maxn];
inline long long S(long long i, long long j) {
return i ? s[j] - s[i - 1] : s[j];
}
inline long long SS(long long i, long long j) {
return i ? ss[j] - ss[i - 1] : ss[j];
}
int main() {
long long i, j, k, t, tt, x, y, z;
for (i = (1); i <= (maxn - 1); ++i) s[i] = s[i - 1] + i;
for (i = (1); i <= (maxn - 1); ++i) ss[i] = ss[i - 1] + i * i;
get(a[0]);
get(a[1]);
get(a[2]);
get(l);
sum = a[0] + a[1] + a[2];
for (t = (0); t <= (l); ++t) {
tt = 0;
for (i = (0); i <= (2); ++i) {
x = max((sum - 2 * a[i] + t + 1) / 2, 0ll);
if (x <= t) tt += s[t + 1 - x];
}
ans += (t + 2) * (t + 1) / 2 - tt;
}
cout << ans << endl;
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int findX(int A, int B) {
int j = 0, x = 0;
while (A || B) {
if ((A & 1) && (B & 1)) x += (1 << j);
A >>= 1;
B >>= 1;
j += 1;
}
return x;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
int a, b;
cin >> a >> b;
int x = findX(a, b);
cout << (a ^ x) + (b ^ x) << "\n";
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
char a[50][50];
char buf[1000000];
int dist[256], have[256];
const int INF = 0x7f7f7f7f;
int main() {
int n, m, limit;
while (scanf("%d%d%d", &n, &m, &limit) != EOF) {
vector<pair<int, int> > ps;
memset(dist, 0x7f, sizeof(dist));
memset(have, 0, sizeof(have));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf(" %c", &a[i][j]);
have[a[i][j]] = true;
if (a[i][j] == 'S') {
ps.push_back(make_pair(i, j));
}
}
}
for (int k = 0; k < ps.size(); ++k) {
int x = ps[k].first, y = ps[k].second;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int d = (i - x) * (i - x) + (j - y) * (j - y);
if (dist[a[i][j]] > d) {
dist[a[i][j]] = d;
}
}
}
}
scanf("%d%s", &n, buf);
int ans = 0;
for (int i = 0; i < n; ++i) {
if (isupper(buf[i])) {
buf[i] = tolower(buf[i]);
if (dist[buf[i]] == INF) {
ans = -1;
break;
} else if (dist[buf[i]] > limit * limit) {
++ans;
}
} else if (!have[buf[i]]) {
ans = -1;
break;
}
}
printf("%d\n", ans);
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
bool is_prime(long long x, long long p) {
for (int i = 2; i * i <= x && i <= p; i++) {
if (x % i == 0) {
return false;
}
}
return true;
}
int main() {
int p, y;
cin >> p >> y;
for (int i = y; i > p; i--) {
if (is_prime(i, p)) {
cout << i << endl;
return 0;
}
}
cout << -1 << endl;
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:60777216")
const int max_n = 100050;
int n;
vector<int> neigh[max_n];
int val[max_n];
int c;
int s[max_n], s_ed;
int b[2 * max_n], b_ed;
void run_dfs(int v) {
s[++s_ed] = v;
val[v] = s_ed;
b[++b_ed] = val[v];
for (int j = 0; j < int(neigh[v].size()); j++) {
int w = neigh[v][j];
if (val[w] == -1)
run_dfs(w);
else
while (val[w] < b[b_ed]) b_ed--;
}
if (val[v] == b[b_ed]) {
b_ed--;
c++;
while (val[v] <= s_ed) val[s[s_ed--]] = c;
}
}
void strong() {
s_ed = b_ed = -1;
for (int v = 0; v < n; v++) val[v] = -1;
c = n - 1;
for (int v = 0; v < n; v++)
if (val[v] == -1) run_dfs(v);
for (int v = 0; v < n; v++)
if (val[v] != -1) val[v] -= n;
}
const int inf = 1000000000;
int ans = inf;
int ans_v;
bool vis[max_n] = {false};
bool is_sink;
int dfs(int v) {
assert(vis[v] == false);
int sz = 1;
vis[v] = true;
for (int w : neigh[v]) {
if (val[w] == val[v] && !vis[w]) {
sz += dfs(w);
}
if (val[w] != val[v]) is_sink = false;
}
return sz;
}
void print(int v) {
assert(vis[v] == false);
printf("%d ", v + 1);
vis[v] = true;
for (int w : neigh[v])
if (!vis[w]) print(w);
}
void run() {
for (int i = 0; i < n; i++)
if (!vis[i]) {
is_sink = true;
int sz = dfs(i);
if (is_sink && ans > sz) {
ans = sz;
ans_v = i;
}
}
for (int i = 0; i < n; i++) vis[i] = false;
printf("%d\n", ans);
print(ans_v);
printf("\n");
}
int u[100050];
int c1[100050], c2[100050];
int main() {
scanf("%d", &n);
int m, h;
scanf("%d %d", &m, &h);
for (int i = 1; i <= n; i++) scanf("%d", &u[i]);
for (int i = 0; i < m; i++) scanf("%d %d", &c1[i], &c2[i]);
for (int i = 0; i < m; i++) {
if ((u[c1[i]] + 1) % h == u[c2[i]]) neigh[c1[i] - 1].push_back(c2[i] - 1);
if ((u[c2[i]] + 1) % h == u[c1[i]]) neigh[c2[i] - 1].push_back(c1[i] - 1);
}
strong();
run();
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int M, F, dp[1000 * 1000 + 100];
int main() {
string s;
cin >> s;
int HERE = 0;
for (int i = 0; i < s.size(); i++)
if (s[i] == 'M') {
HERE = i;
break;
}
for (int i = HERE; i < s.size(); i++)
if (s[i] == 'F') {
dp[i] = F;
F++;
} else {
F--;
F = max(F, 0);
}
int Max = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'F') {
if (M != 0) Max = max(Max, dp[i] + M);
} else
M++;
}
cout << Max;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
string input;
while (cin >> input) {
stack<int> chk;
int single[1000001] = {(0)}, maxi = 0, rept[1000001] = {(0)};
for (int i = 0; i < input.size(); i++) {
if (input[i] == '(') {
chk.push(i);
} else {
if (chk.empty()) {
single[i] = -1;
} else {
int indx = chk.top();
chk.pop();
single[i] = indx;
if (indx > 0 && input[indx - 1] == ')' && single[indx - 1] >= 0) {
single[i] = single[indx - 1];
}
int length = i - single[i] + 1;
rept[length]++;
maxi = max(length, maxi);
}
}
}
rept[0] = 1;
cout << maxi << " " << rept[maxi] << endl;
}
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool Max(T1& a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <typename T1, typename T2>
bool Min(T1& a, T2 b) {
return a > b ? a = b, 1 : 0;
}
const int N = 200000, M = 75000;
struct node {
node *l = 0, *r = 0;
long long a = 0, b = 0;
} nodes[60 * M];
node* newnode = nodes;
node* ver[M + 1];
node* add(node* p, int l, int r, int x, int a, int b) {
node* cur = newnode++;
if (p) *cur = *p;
cur->a += a;
cur->b += b;
if (l == r) {
return cur;
}
int m = l + r >> 1;
if (x <= m)
cur->l = add(cur->l, l, m, x, a, b);
else
cur->r = add(cur->r, m + 1, r, x, a, b);
return cur;
}
long long get(node* p, int l, int r, int x) {
if (!p) return 0;
if (x >= r) return p->a * x + p->b;
int m = l + r >> 1;
long long ret = get(p->l, l, m, x);
if (x > m) ret += get(p->r, m + 1, r, x);
return ret;
}
void solve() {
int n, m;
cin >> n;
for (int i = 1; i <= (n); ++i) {
int x1, x2, y1, a, b, y2;
cin >> x1 >> x2 >> y1 >> a >> b >> y2;
ver[i] = ver[i - 1];
ver[i] = add(ver[i], 0, N, 0, 0, y1);
ver[i] = add(ver[i], 0, N, x1 + 1, a, b - y1);
ver[i] = add(ver[i], 0, N, x2 + 1, -a, y2 - b);
}
cin >> m;
long long last = 0;
while (m--) {
int l, r, x;
cin >> l >> r >> x;
x = (x + last) % 1000000000;
last = get(ver[r], 0, N, x) - get(ver[l - 1], 0, N, x);
cout << last << '\n';
}
}
void init() {}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
init();
int TC = 1;
for (int TI = 1; TI <= (TC); ++TI) {
solve();
}
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
long int ff(long int n) { return (n * (n + 1)) / 2; }
int main() {
long int n, i = 1, j = 65, sum = 0;
cin >> n;
if (n == 0) {
cout << "a";
return 0;
}
while (n != 0) {
i = 1;
while (ff(i) <= n) {
i++;
}
n -= ff(i - 1);
while (i--) {
printf("%c", j + 32);
}
j++;
}
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int ar[n];
for (int i = 0; i < n; i++) cin >> ar[i];
map<int, int> m;
for (int i = 0; i < n; i++) m[ar[i]]++;
m[0] = 3;
map<int, int>::iterator it = m.begin(), tmp;
int ans = 0;
it++;
while (it != m.end()) {
int p = it->second, k = it->first;
tmp = m.find(k - 1);
if (tmp == m.end() or tmp->second == 0) {
p--;
m[k - 1]++;
m[k]--;
}
if (p > 1) {
m[k + 1]++;
m[k]--;
}
it++;
}
it = m.begin();
it++;
while (it != m.end()) {
if (it->second > 0) ans++;
it++;
}
cout << ans << endl;
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[1000005], ans = 0, inv[1000005], jc[1000005];
inline void init() {
inv[0] = inv[1] = 1;
for (long long i = 2; i <= n; i++)
inv[i] = ((1000000007LL - 1000000007LL / i) * inv[1000000007LL % i]) %
1000000007LL;
jc[0] = jc[1] = 1;
for (long long i = 2; i <= n; i++) jc[i] = (jc[i - 1] * i) % 1000000007LL;
}
int main() {
scanf("%lld", &n);
init();
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
sort(a + 1, a + n + 1);
long long pos = 1;
while (pos <= n) {
long long poss = upper_bound(a + 1, a + n + 1, a[pos]) - a;
if (poss <= n)
ans = (ans + jc[n] * inv[n - pos + 1] % 1000000007LL * a[pos] %
1000000007LL * (poss - pos) % 1000000007LL) %
1000000007LL;
pos = poss;
}
printf("%lld\n", ans);
return 0;
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
const int mod = 1e9 + 7;
int n, a, b, p[maxn], sum[maxn], nex[maxn][21], ans, l;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return x * f;
}
string s[maxn];
int main() {
n = read(), a = read(), b = read() + 1;
for (int i = 1; i <= n; i++) cin >> s[i], p[i] = s[i].size() + 1;
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + p[i];
for (int i = 1; i <= n; i++)
nex[i][0] = upper_bound(sum + 1, sum + n + 1, sum[i - 1] + b) - sum;
nex[n + 1][0] = n + 1;
for (int i = 1; i <= 20; i++)
for (int j = 1; j <= n + 1; j++) nex[j][i] = nex[nex[j][i - 1]][i - 1];
for (int i = 1; i <= n; i++) {
int r = i;
for (int j = 0; j <= 20; j++)
if (a >> j & 1) r = nex[r][j];
if (ans < r - i) ans = r - i, l = i;
}
while (ans) {
for (int i = l; i < nex[l][0]; i++)
cout << s[i] << (i == nex[l][0] - 1 ? '\n' : ' ');
ans -= nex[l][0] - l;
l = nex[l][0];
}
return 0;
}
| 13
|
#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")
#pragma comment(linker, "/stack:200000000")
using namespace std;
long long spf[301];
long long fac[301];
void sieve() {
spf[1] = 1;
for (long long i = 2; i < 301; i++) spf[i] = i;
for (long long i = 4; i < 301; i += 2) spf[i] = 2;
for (long long i = 3; i * i < 301; i++) {
if (spf[i] == i) {
for (long long j = i * i; j < 301; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
map<long long, long long> getfactor(long long a) {
map<long long, long long> m;
while (a > 1) {
m[spf[a]]++;
a /= spf[a];
}
return m;
}
long long power(long long x, long long y, long long p) {
long long res = 1;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long inverse(long long a, long long p) { return power(a, p - 2, p); }
long long ncr(long long n, long long r, long long p) {
if (r > n) return 0;
if (r == 0) return 1;
return (fac[n] * inverse(fac[r], p) % p * inverse(fac[n - r], p) % p) % p;
}
long long seg[4000009], lazy[4000009];
void push(long long v) {
seg[v * 2] = min(lazy[v], seg[v * 2]);
seg[v * 2 + 1] = min(lazy[v], seg[v * 2 + 1]);
lazy[v * 2] = min(lazy[v], lazy[v * 2]);
lazy[v * 2 + 1] = min(lazy[v], lazy[v * 2 + 1]);
lazy[v] = 1e18;
}
void updateseg(long long v, long long l, long long r, long long posl,
long long posr, long long val) {
if (l >= posl && r <= posr) {
seg[v] = min(val, seg[v]);
lazy[v] = min(val, lazy[v]);
return;
} else if (l > posr || r < posl)
return;
push(v);
long long mid = (l + r) / 2;
updateseg(v * 2, l, mid, posl, posr, val);
updateseg(v * 2 + 1, mid + 1, r, posl, posr, val);
seg[v] = min(seg[v * 2], seg[v * 2 + 1]);
}
long long query(long long v, long long l, long long r, long long posl,
long long posr) {
if (l >= posl && r <= posr)
return seg[v];
else if (l > posr || r < posl)
return 1e18;
push(v);
long long mid = (l + r) / 2;
return min(query(v * 2, l, mid, posl, posr),
query(v * 2 + 1, mid + 1, r, posl, posr));
}
void solve() {
for (long long i = 0; i <= 2000000; i++) {
seg[i] = 1e18;
lazy[i] = 1e18;
}
long long n, k;
cin >> n >> k;
string s;
cin >> s;
long long m = 2 * n;
for (long long i = 1; i <= n; i++) {
if (i == 1)
updateseg(1, 1, m, i, i, i);
else
updateseg(1, 1, m, i, i, query(1, 1, m, i - 1, i - 1) + i);
if (i <= k + 1 && s[i - 1] == '1')
updateseg(1, 1, m, i, i + k, i);
else if (s[i - 1] == '1') {
long long gg = query(1, 1, m, i - k - 1, i);
updateseg(1, 1, m, i, i + k, gg + i);
}
}
cout << query(1, 1, m, n, n) << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long test = 1;
while (test--) {
solve();
}
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int b, ans = 0, n;
int main() {
string a;
cin >> n >> a;
for (int i = 0; i < a.size(); ++i) {
if (a[i] == 'x') {
b++;
} else {
b = 0;
}
if (b > 2) {
ans++;
}
}
cout << ans;
}
| 0
|
#include <bits/stdc++.h>
const int N = 1005, u[4] = {1, 0, -1, 0}, v[4] = {0, 1, 0, -1};
int n, m, h, t, B, W, cnt, f[N * N], g[N * N], c[N], a[5], b[5];
char s[N][N], ch;
int get(int x, int y) {
if (x < 0 || x >= n || y < 0 || y >= m) return -1;
c[s[x][y]]++;
return s[x][y];
}
void check(int i, int j) {
if (get(i, j) < 0 || s[i][j] - 'B' && s[i][j] - 'W') return;
c['B'] = c['W'] = 0;
for (int k = 0; k < 4; k++) get(i + u[k], j + v[k]);
if (s[i][j] == 'B' && c['W'] < 4 || s[i][j] == 'W' && c['B'] == 1)
f[++t] = i, g[t] = j;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%s", s[i]);
for (int j = 0; j < m; j++)
if (s[i][j] == 'b')
s[i][j] = 'B', B++;
else if (s[i][j] == 'w')
s[i][j] = 'W', W++;
}
if (B * 2 != W) return puts("NO"), 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) check(i, j);
while (h < t) {
int x = f[++h], y = g[h];
if (s[x][y] > 'Z') continue;
a[0] = x, b[0] = y, a[1] = -1;
if (s[x][y] == 'W')
for (int k = 0; k < 4; k++)
if (get(x + u[k], y + v[k]) == 'B' &&
get(x + u[k] * 2, y + v[k] * 2) > 0)
a[1] = a[0], b[1] = b[0], a[0] = x + u[k], b[0] = y + v[k],
a[2] = x + u[k] * 2, b[2] = y + v[k] * 2;
if (s[x][y] == 'B')
if (get(x + 1, y) == 'W' && get(x - 1, y) == 'W')
a[1] = x + 1, a[2] = x - 1, b[1] = b[2] = y;
else
a[1] = a[2] = x, b[1] = y + 1, b[2] = y - 1;
if (a[1] < 0) break;
cnt++;
ch = (a[1] & 1) + (a[0] == a[1]) * 2 + 97;
for (int i = 0; i < 3; i++) s[a[i]][b[i]] = ch;
for (int i = 0; i < 3; i++)
for (int k = 0; k < 4; k++) check(a[i] + u[k], b[i] + v[k]);
}
if (cnt < B) return puts("NO"), 0;
puts("YES");
for (int i = 0; i < n; i++) puts(s[i]);
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, t, d, i;
cin >> n >> m;
int a[n], c[n];
for (i = 0; i < n; i++) {
cin >> a[i];
}
set<pair<int, int>> s;
for (i = 0; i < n; i++) {
cin >> c[i];
s.insert(make_pair(c[i], i));
}
while (m--) {
long long int cost = 0;
cin >> t >> d;
t--;
while (d > 0) {
if (s.empty()) break;
if (a[t] > d) {
cost += 1LL * d * c[t];
a[t] -= d;
d = 0;
} else if (a[t]) {
cost += 1LL * a[t] * c[t];
d -= a[t];
a[t] = 0;
s.erase(make_pair(c[t], t));
} else {
t = (*(s.begin())).second;
}
}
if (d > 0)
cout << "0\n";
else
cout << cost << "\n";
}
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int na, nb;
cin >> na >> nb;
int k, m;
cin >> k >> m;
vector<int> a;
vector<int> b;
int p;
for (int i = 0; i < na; i++) {
cin >> p;
a.push_back(p);
}
for (int i = 0; i < nb; i++) {
cin >> p;
b.push_back(p);
}
if (a[k - 1] < b[nb - m]) {
cout << "YES";
} else {
cout << "NO";
}
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200;
char s[N], ans[N];
int main() {
int tc;
scanf("%d", &tc);
while (tc--) {
int n;
scanf("%d", &n);
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
scanf("%s", s);
int cn = 0;
for (int i = 0; i < n; ++i) {
ans[i] = '!';
if (s[i] == 'R' && b) {
ans[i] = 'P';
--b;
}
if (s[i] == 'P' && c) {
ans[i] = 'S';
c--;
}
if (s[i] == 'S' && a) {
ans[i] = 'R';
--a;
}
if (ans[i] != '!') ++cn;
}
if (2 * cn >= n) {
puts("YES");
for (int i = 0; i < n; ++i) {
if (ans[i] != '!') continue;
if (a) {
ans[i] = 'R';
--a;
} else if (b) {
ans[i] = 'P';
--b;
} else {
ans[i] = 'S';
--c;
}
}
assert(a == 0 && b == 0 && c == 0);
for (int i = 0; i < n; ++i) printf("%c", ans[i]);
puts("");
} else {
puts("NO");
}
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int FFTMOD = 1007681537;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
struct PT {
long double x, y;
PT() : x(0), y(0) {}
PT(long double x, long double y) : x(x), y(y) {}
PT(const PT& p) : x(p.x), y(p.y) {}
int operator<(const PT& rhs) const {
if (sign(y, rhs.y)) return sign(y, rhs.y) < 0;
if (sign(x, rhs.x)) return sign(x, rhs.x) < 0;
return make_pair(y, x) < make_pair(rhs.y, rhs.x);
}
int operator==(const PT& rhs) const {
return make_pair(y, x) == make_pair(rhs.y, rhs.x);
}
PT operator+(const PT& p) const { return PT(x + p.x, y + p.y); }
PT operator-(const PT& p) const { return PT(x - p.x, y - p.y); }
PT operator*(long double c) const { return PT(x * c, y * c); }
PT operator/(long double c) const { return PT(x / c, y / c); }
};
inline long double sqr(long double x) { return x * x; }
long double cross(PT p, PT q) { return p.x * q.y - p.y * q.x; }
long double area(PT a, PT b, PT c) {
return fabs(cross(a, b) + cross(b, c) + cross(c, a)) / 2;
}
long double area2(PT a, PT b, PT c) {
return cross(a, b) + cross(b, c) + cross(c, a);
}
long double dot(PT p, PT q) { return p.x * q.x + p.y * q.y; }
long double dist(PT p, PT q) { return sqrt(dot(p - q, p - q)); }
long double dist2(PT p, PT q) { return dot(p - q, p - q); }
PT RotateCCW90(PT p) { return PT(-p.y, p.x); }
PT RotateCW90(PT p) { return PT(p.y, -p.x); }
PT RotateCCW(PT p, long double t) {
return PT(p.x * cos(t) - p.y * sin(t), p.x * sin(t) + p.y * cos(t));
}
vector<PT> CircleCircleIntersection(PT a, PT b, long double r, long double R) {
vector<PT> res;
long double d = sqrt(dist2(a, b));
long double x = (d * d - R * R + r * r) / (2 * d);
long double y = sqrt(max((long double)0.0, r * r - x * x));
PT v = (b - a) / d;
res.push_back(a + v * x + RotateCCW90(v) * y);
if (y > 0) res.push_back(a + v * x - RotateCCW90(v) * y);
return res;
}
const int maxn = 500 + 5;
int n;
int x[maxn];
int y[maxn];
int r[maxn];
int f[maxn];
vector<PT> pts[maxn];
int dj[maxn];
int find(int u) { return dj[u] == u ? dj[u] : dj[u] = find(dj[u]); }
void join(int u, int v) { dj[find(u)] = find(v); }
void chemthan() {
cin >> n;
for (int i = (0); i < (n); ++i) cin >> x[i] >> y[i] >> r[i];
for (int i = (0); i < (n); ++i) dj[i] = i;
vector<PT> tmp;
for (int i = (0); i < (n); ++i)
for (int j = (i + 1); j < (n); ++j) {
if (make_tuple(x[i], y[i], r[i]) == make_tuple(x[j], y[j], r[j])) {
f[j] = 1;
}
}
for (int i = (0); i < (n); ++i)
for (int j = (i + 1); j < (n); ++j)
if (!f[i] && !f[j]) {
auto isqr = [&](int x) { return (long long)x * x; };
long long d = isqr(x[i] - x[j]) + isqr(y[i] - y[j]);
if (isqr(r[i] - r[j]) <= d && d <= isqr(r[i] + r[j])) {
join(i, j);
vector<PT> vps = CircleCircleIntersection(PT(x[i], y[i]),
PT(x[j], y[j]), r[i], r[j]);
for (PT q : vps) {
pts[i].push_back(q);
pts[j].push_back(q);
tmp.push_back(q);
}
}
}
int res = 1;
sort((tmp).begin(), (tmp).end());
for (int i = (0); i < (int((tmp).size())); ++i) {
if (!i || sign(dist(tmp[i], tmp[i - 1]))) {
res--;
}
}
for (int i = (0); i < (n); ++i)
if (!f[i]) {
sort((pts[i]).begin(), (pts[i]).end());
for (int j = (0); j < (int((pts[i]).size())); ++j) {
if (!j || sign(dist(pts[i][j], pts[i][j - 1]))) {
res++;
}
}
}
for (int i = (0); i < (n); ++i)
if (!f[i] && dj[i] == i) {
res++;
}
cout << res << "\n";
}
int main(int argc, char* argv[]) {
ios_base::sync_with_stdio(0), cin.tie(0);
if (argc > 1) {
assert(freopen(argv[1], "r", stdin));
}
if (argc > 2) {
assert(freopen(argv[2], "wb", stdout));
}
chemthan();
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
int xDir[8] = {0, 0, -1, 1, 1, -1, -1, 1};
int yDir[8] = {1, -1, 0, 0, 1, -1, 1, -1};
int EPS = 1e-10;
int dComp(double d1, double d2) {
if (abs(d1 - d2) <= EPS) return 0;
if (d1 > d2)
return 1;
else
return -1;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long arr[100001], srted[100001];
int n, m, l, r, z;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
srted[i] = arr[i];
}
cin >> m;
sort(srted, srted + n);
for (int i = 1; i < n; i++) {
arr[i] = arr[i] + arr[i - 1];
srted[i] = srted[i] + srted[i - 1];
}
for (int i = 0; i < m; i++) {
cin >> z >> l >> r;
l--, r--;
if (z == 1) {
if (l == 0)
cout << arr[r] << endl;
else
cout << arr[r] - arr[l - 1] << endl;
} else {
if (l == 0)
cout << srted[r] << endl;
else
cout << srted[r] - srted[l - 1] << endl;
}
}
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
int k, e1, e2;
void make(int be, int kk, int dir) {
for (int i = be + 1; i <= kk; i++) printf("%d %d\n", be, i);
for (int i = be + 1; i <= kk - 1; i++)
for (int j = i + 1; j <= kk; j++) {
if ((i + dir) % 2 == 0 && j == i + 1) continue;
printf("%d %d\n", i, j);
}
for (int i = be + 1; i <= kk; i++) {
printf("%d %d\n%d %d\n", i, kk + 1, i, kk + 2);
}
printf("%d %d\n", kk + 1, kk + 2);
}
int main() {
scanf("%d", &k);
if (k == 1) {
printf("YES\n2 1\n1 2");
return 0;
}
if (k % 2 == 0) {
printf("NO");
return 0;
}
printf("YES\n");
printf("%d %d\n", (k + 2) * 2, k * (k + 2));
e1 = 1, e2 = k + 3;
make(e1, k, 0);
make(e2, 2 * k + 2, 1);
printf("%d %d\n", e1, e2);
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
void func() {
string s, ans;
cin >> s;
long long n = s.length(), cnt = 0, j = -1;
for (long long i = 0; i < n; ++i) {
if (s[i] == '2') {
j = i;
break;
}
}
if (j == -1) {
sort(s.begin(), s.end());
cout << s << "\n";
return;
}
for (long long i = 0; i < n; ++i) {
if (s[i] == '1') {
++cnt;
s.erase(i, 1);
n--;
--i;
}
}
for (long long i = 0; i < n; ++i) {
if (s[i] == '2') {
j = i;
break;
}
}
for (long long i = 0; i < n; ++i) {
if (i < j) {
ans.push_back(s[i]);
} else if (i == j) {
for (long long k = 0; k < cnt; ++k) {
ans.push_back('1');
}
ans.push_back(s[i]);
} else if (i > j) {
ans.push_back(s[i]);
}
}
cout << ans << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
func();
}
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
struct state {
int row, col, val;
state(int _r, int _c, int _v) : row(_r), col(_c), val(_v) {}
bool operator<(const state &s) const { return val > s.val; }
};
pair<int, int> p[1005];
int main() {
int n;
scanf("%d", &n);
int xx;
for (int i = 0; i < n; i++) {
scanf("%d", &xx);
p[i] = make_pair(xx, i + 1);
}
sort(p, p + n);
printf("%d %d\n", p[n - 1].second, p[n - 2].first);
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int dt = 2000010;
inline int read() {
int x = 0, f = 0, c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = 1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return f ? -x : x;
}
int tree[16 * dt], lazy[16 * dt];
struct Point {
int x, y, c;
Point(int xx = 0, int yy = 0, int cc = 0) : x(xx), y(yy), c(cc) {}
};
bool operator<(const Point &a, const Point &b) {
if (a.y != b.y) return a.y < b.y;
return a.c < b.c;
}
vector<Point> p;
inline void tran(int &x, int &y) {
int xx = x, yy = y;
x = xx - yy + dt;
y = xx + yy + dt;
}
inline void pushup(int x) { tree[x] = max(tree[x << 1], tree[x << 1 | 1]); }
inline void pushdown(int x) {
if (lazy[x]) {
lazy[x << 1] += lazy[x];
lazy[x << 1 | 1] += lazy[x];
tree[x << 1] += lazy[x];
tree[x << 1 | 1] += lazy[x];
lazy[x] = 0;
}
}
void update(int x, int l, int r, int L, int R, int val) {
if (L <= l && R >= r) {
tree[x] += val;
lazy[x] += val;
return;
}
pushdown(x);
int mid = (l + r) >> 1;
if (L <= mid) update(x << 1, l, mid, L, R, val);
if (R > mid) update(x << 1 | 1, mid + 1, r, L, R, val);
pushup(x);
}
int n, r, ans;
int main() {
n = read(), r = read();
for (int i = 1; i <= n; i++) {
int x = read(), y = read();
tran(x, y);
p.push_back(Point(x, y, 0));
p.push_back(Point(x + 2 * r, y + 2 * r, 1));
}
sort(p.begin(), p.end());
int sz = p.size();
for (register int i = 0; i < sz; i++) {
Point cur = p[i];
if (!cur.c) {
update(1, 0, 4 * dt, cur.x, cur.x + 2 * r, 1);
ans = max(ans, tree[1]);
} else {
update(1, 0, 4 * dt, cur.x - 2 * r, cur.x, -1);
ans = max(ans, tree[1]);
}
}
printf("%d", ans);
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int N = 11 * 100100;
const long long INFLL = 0x3f3f3f3f3f3f3f3f;
int ncnt = 1;
int nxt[N][4];
vector<vector<long long>> f[64];
long long n;
string s;
int dep;
vector<vector<long long>> get_res(long long init = 0) {
return vector<vector<long long>>(4, vector<long long>(4, init));
}
inline int ord(char c) { return c - 'A'; }
void insert(const string &t, int start, int finish) {
int u = 1;
for (int i = start; i < finish; ++i) {
if (!nxt[u][ord(t[i])]) {
nxt[u][ord(t[i])] = ++ncnt;
}
u = nxt[u][ord(t[i])];
}
}
void dfs(int u, int d, int h, int begin, int cur) {
if (u == 0) {
f[0][begin][cur] = min(f[0][begin][cur], (long long)d - 1);
}
if (d == h) return;
for (int i = 0; i < 4; ++i) {
dfs(nxt[u][i], d + 1, h, begin, i);
}
}
vector<vector<long long>> res_mul(const vector<vector<long long>> &a,
const vector<vector<long long>> &b) {
vector<vector<long long>> ans = get_res(INFLL);
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
for (int k = 0; k < 4; ++k) {
ans[i][j] = min(ans[i][j], a[i][k] + b[k][j]);
}
}
}
return ans;
}
long long smallest(const vector<vector<long long>> &x) {
long long ans = INFLL;
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
ans = min(ans, x[i][j]);
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n;
cin >> s;
dep = (33 - __builtin_clz(s.size() + 1)) / 2 + 2;
for (int i = 0; i < s.size(); ++i) {
insert(s, i, min(i + dep, (int)s.size()));
}
for (int i = 0; i < 64; ++i) {
f[i] = get_res(INFLL);
}
for (int i = 0; i < 4; ++i) {
dfs(nxt[1][i], 1, dep, i, i);
}
for (int l = 0; l < 63; ++l) {
f[l + 1] = res_mul(f[l], f[l]);
}
long long amt = 0;
vector<vector<long long>> cur = get_res();
for (int i = 62; i >= 0; --i) {
vector<vector<long long>> rm = res_mul(cur, f[i]);
if (smallest(rm) < n) {
amt += (1LL << i);
cur = rm;
}
}
assert(smallest(cur) < n);
cur = res_mul(cur, f[0]);
++amt;
assert(smallest(cur) >= n);
cout << amt << "\n";
return 0;
}
| 22
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main() {
string s;
cin >> s;
int n = s.size();
ll ans = 0;
for (int l = 0; l < n; l++) {
if (l + 8 < n) ans += n - (l + 8);
bool found = false;
for (int r = l + 1; r < min(n, l + 8); r++) {
for (int k = 1; 2 * k <= r - l; k++) {
if (s[r] == s[r - k] && s[r - k] == s[r - 2 * k]) found = true;
}
ans += found;
}
}
cout << ans << endl;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
long long C[3010][3010];
int main() {
int n, m, k, a, b;
cin >> n >> m >> k;
for (int i = 0; i < 3010; i++) {
for (int j = i; j < 3010; j++) {
if (i == 0)
C[i][j] = 1;
else
C[i][j] = (C[i - 1][j - 1] + C[i][j - 1]) % 1000000007ll;
}
}
cout << (C[2 * k][n - 1] * C[2 * k][m - 1]) % 1000000007ll;
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const int num = 100005;
int cnt[num];
int main() {
int n;
cin >> n;
int x;
int mx = 0;
for (int i = 1; i <= n; i++) {
cin >> x;
cnt[x] = 1;
if (x > 1) cnt[x] += cnt[x - 1];
if (cnt[x] > mx) mx = cnt[x];
}
cout << n - mx << endl;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int v, w, next;
} e[100 * 100 * 5];
int head[100 * 100 + 10];
int ecnt;
char mp[105][105];
int junc[30];
int g[30][30];
int dx[4] = {1, 0, 0, -1};
int dy[4] = {0, 1, -1, 0};
int dir[30][30];
bool in[10005];
const int INF = 200000000;
int n, m, k;
int dist[10005];
int pre[10005];
char s[1005];
queue<int> q;
void add_edge(int u, int v, int w) {
e[ecnt].v = v;
e[ecnt].next = head[u];
e[ecnt].w = w;
head[u] = ecnt++;
}
void SPFA(int x) {
for (int i = 0; i < n * m; i++) {
dist[i] = INF;
pre[i] = -1;
in[i] = false;
}
dist[x] = 0;
pre[x] = -1;
in[x] = true;
while (!q.empty()) q.pop();
q.push(x);
while (!q.empty()) {
int tmp = q.front();
q.pop();
in[tmp] = false;
for (int i = head[tmp]; i != -1; i = e[i].next) {
int v = e[i].v;
if (dist[tmp] + e[i].w < dist[v]) {
dist[v] = dist[tmp] + e[i].w;
pre[v] = tmp;
if (!in[v]) {
in[v] = true;
q.push(v);
}
}
}
}
}
int main() {
while (scanf("%d%d%d", &n, &m, &k) > 0) {
ecnt = 0;
for (int i = 0; i < n; i++) scanf("%s", mp[i]);
memset(junc, -1, sizeof(junc));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
if (mp[i][j] >= 'a' && mp[i][j] <= 'z')
junc[mp[i][j] - 'a'] = i * m + j;
for (int i = 0; i < 26; i++) {
if (junc[i] == -1) continue;
for (int j = 0; j < 4; j++) {
int px = junc[i] / m, py = junc[i] % m;
for (int k = 1;; k++) {
int tx = px + k * dx[j], ty = py + k * dy[j];
if (tx < 0 || tx >= n || ty < 0 || ty >= m)
break;
else if (mp[tx][ty] >= 'a' && mp[tx][ty] <= 'z') {
dir[i][mp[tx][ty] - 'a'] = j;
g[i][mp[tx][ty] - 'a'] = k;
break;
} else if (mp[tx][ty] == '#')
break;
}
}
}
int sx, sy, ex, ey;
scanf("%d%d%s%d%d", &sx, &sy, s, &ex, &ey);
sx--;
sy--;
ex--;
ey--;
int nowtime = 0;
int px = junc[s[0] - 'a'] / m, py = junc[s[0] - 'a'] % m;
int dd = 0;
if (px > sx) dd = 0;
if (px < sx) dd = 3;
if (py > sy) dd = 1;
if (py < sy) dd = 2;
bool flag = false;
while (px != sx || py != sy) {
if (mp[sx][sy] >= '1' && mp[sx][sy] <= '9')
nowtime += mp[sx][sy] - '0';
else
nowtime++;
sx += dx[dd];
sy += dy[dd];
if (nowtime > k) {
printf("%d %d\n", sx - dx[dd] + 1, sy - dy[dd] + 1);
flag = true;
break;
}
}
if (flag) continue;
int l1 = strlen(s);
for (int i = 0; i < l1 - 1; i++) {
dd = dir[s[i] - 'a'][s[i + 1] - 'a'];
px = junc[s[i + 1] - 'a'] / m, py = junc[s[i + 1] - 'a'] % m;
while (px != sx || py != sy) {
if (mp[sx][sy] >= '1' && mp[sx][sy] <= '9')
nowtime += mp[sx][sy] - '0';
else
nowtime++;
sx += dx[dd];
sy += dy[dd];
if (nowtime > k) {
printf("%d %d\n", sx - dx[dd] + 1, sy - dy[dd] + 1);
flag = true;
break;
}
}
if (flag) break;
}
if (flag) continue;
px = ex, py = ey;
dd = 0;
if (px > sx) dd = 0;
if (px < sx) dd = 3;
if (py > sy) dd = 1;
if (py < sy) dd = 2;
while (px != sx || py != sy) {
if (mp[sx][sy] >= '1' && mp[sx][sy] <= '9')
nowtime += mp[sx][sy] - '0';
else
nowtime++;
sx += dx[dd];
sy += dy[dd];
if (nowtime > k) {
printf("%d %d\n", sx - dx[dd] + 1, sy - dy[dd] + 1);
flag = true;
break;
}
}
if (!flag) printf("%d %d\n", ex + 1, ey + 1);
}
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int a[(int)(1e+6) * 2], b[10], c[10];
int main() {
int n, i;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
b[a[i]]++;
if (b[5] > 0 || b[7] > 0) {
cout << -1;
return 0;
}
}
b[2] -= b[4];
b[1] -= b[4];
if (b[2] < 0 || b[1] < 0) {
cout << -1;
return 0;
}
if (!(b[1] == b[6] && b[6] == b[2] + b[3])) {
cout << -1;
return 0;
}
for (i = 1; i <= b[4]; i++) cout << "1 2 4\n";
for (i = 1; i <= b[2]; i++) cout << "1 2 6\n";
for (i = 1; i <= b[3]; i++) cout << "1 3 6\n";
}
| 4
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.