solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int a[2005][2005], f[2005][2005], n, m, k, tx, ty;
int myabs(int x) {
if (x < 0)
return -x;
else
return x;
}
bool work(int u, int v, int w) {
int i, j, l, r;
l = u - w;
if (l < 1) l = 1;
r = u + w;
if (r > n) r = n;
for (i = l; i <= r; i++) {
j = w - abs(i - u);
if (v - j >= 1 && !a[i][v - j]) {
tx = i;
ty = v - j;
return 0;
}
if (v + j <= m && !a[i][v + j]) {
tx = i;
ty = v + j;
return 0;
}
}
return 1;
}
int main() {
int i, j, l, x, y;
scanf("%d%d%d", &n, &m, &k);
for (l = 1; l <= k; l++) {
scanf("%d%d", &x, &y);
for (i = -5; i <= 5; i++) {
for (j = -5; j <= 5; j++) {
if (x + i >= 1 && x + i <= n && y + j >= 1 && y + j <= m &&
f[x + i][y + j] - myabs(i) - myabs(j) > f[x][y])
f[x][y] = f[x + i][y + j] - myabs(i) - myabs(j);
}
}
for (; work(x, y, f[x][y]); f[x][y]++)
;
a[tx][ty] = 1;
printf("%d %d\n", tx, ty);
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s1, s2, s;
cin >> s1 >> s2 >> s;
map<char, char> m;
for (int i = 0; i < 26; i++) {
m[s1[i]] = s2[i];
}
for (int i = 0; i < s.length(); i++) {
if (isupper(s[i])) {
char t = tolower(s[i]);
s[i] = toupper(m[t]);
} else if (islower(s[i])) {
s[i] = m[s[i]];
}
}
cout << s;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
long long N;
int dp[10][10];
int nval[10][10];
int pm[1000010];
long long ndp[10][10];
int nnval[10][10];
int mdig(long long x) {
return ((x == 0) ? 0 : max(x % 10, (long long)mdig(x / 10)));
}
inline int fmdig(long long x) { return max(pm[x / 1000000], pm[x % 1000000]); }
void sdp(int x, int y) {
int yold = y;
y += 999990;
int res = 0;
while (y >= 0) {
y -= max(pm[y], x);
res++;
}
dp[x][yold] = res;
nval[x][yold] = y + 10;
}
void sndp(int x, int y) {
int yold = y;
long long res = 0;
for (int i = 999999; i >= 0; i--) {
int xval = max(pm[i], x);
res += dp[xval][y];
y = nval[xval][y];
}
ndp[x][yold] = res;
nnval[x][yold] = y;
}
int solve(int x) {
int count = 0;
while (x) {
count++;
x -= pm[x];
}
return count;
}
int main() {
pm[0] = 0;
for (int i = 1; i <= 1000000; i++) pm[i] = mdig(i);
cin >> N;
for (int i = 1; i < 10; i++)
for (int j = 0; j < 10; j++) {
sdp(i, j);
}
for (int i = 1; i < 10; i++)
for (int j = 0; j < 10; j++) sndp(i, j);
long long ans = 0;
if (N < (int)1e6) {
cout << solve(N) << "\n";
return 0;
}
while ((N % (int)1e6) < 999990) {
N -= mdig(N);
ans++;
}
if (N < 2e12) {
while (N > (int)1e6) {
int x = fmdig(N / (int)1e6), y = N % 10;
ans += dp[x][y];
N -= (int)1e6 + N % 10;
N += nval[x][y];
}
cout << ans + solve(N) << "\n";
return 0;
}
while ((N / (int)1e6) % (int)1e6 != 999999) {
int x = fmdig(N / (int)1e6), y = N % 10;
ans += dp[x][y];
N -= (int)1e6 + N % 10;
N += nval[x][y];
}
while (N > (long long)1e12) {
int x = pm[(int)(N / ((long long)1e12))], y = N % 10;
ans += ndp[x][y];
N -= (long long)1e12 + N % 10;
N += nnval[x][y];
}
while (N > (int)1e6) {
int x = fmdig(N / (int)1e6), y = N % 10;
ans += dp[x][y];
N -= (int)1e6 + N % 10;
N += nval[x][y];
}
cout << ans + solve(N) << "\n";
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i;
cin >> n;
for (i = 2; i * i <= n; i++) {
while (n % (i * i) == 0) {
n = n / i;
}
}
cout << n << endl;
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
template <class T, class V>
ostream& operator<<(ostream& s, pair<T, V> a) {
s << a.first << ' ' << a.second;
return s;
}
long long int ask(long long int a, long long int b) {
cout << "? " << a << ' ' << b << endl;
long long int x;
cin >> x;
return x;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
long long int T = 1;
for (long long int qq = 1; qq <= T; qq++) {
long long int n;
cin >> n;
vector<pair<pair<long long int, long long int>, long long int> > v;
vector<long long int> a;
for (int i = 0; i < n; i++) {
v.push_back(pair<pair<long long int, long long int>, long long int>(
pair<long long int, long long int>(i, (i + 1) % n),
ask(i, (i + 1) % n)));
long long int x = v.back().second;
v.push_back(pair<pair<long long int, long long int>, long long int>(
pair<long long int, long long int>((i + 1) % n, (i + 1) % n),
ask((i + 1) % n, (i + 1) % n)));
a.push_back(x ^ (v.back().second));
}
long long int cnt = 0;
vector<long long int> ans;
vector<long long int> temp, temp2(n, 0);
for (int i = 0; i < n; i++) {
temp.clear();
temp.push_back(i);
temp2[i] = 0;
for (int j = 0; j < n - 1; j++) {
temp.push_back((temp.back()) ^ a[j]);
if (temp.back() >= n) break;
temp2[temp.back()] = (int)temp.size() - 1;
}
if (temp.back() >= n) continue;
bool ok = true;
for (auto x : v)
if ((temp[x.first.first] ^ temp2[x.first.second]) != x.second)
ok = false;
if (ok) {
cnt++;
if (cnt == 1) ans = temp;
}
}
cout << "!" << endl;
cout << cnt << endl;
for (auto x : ans) cout << x << ' ';
cout << endl;
}
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1009;
const long long MAXN = 1000005;
const double pi = acos(-1);
long long rev[4 * MAXN];
void fft(complex<double> *a, long long n, long long opt) {
long long bit = 0;
while ((1 << bit) < n) bit++;
for (long long i = 0; i < n; i++) {
rev[i] = (rev[i >> 1] >> 1) | ((i & 1) << (bit - 1));
if (i < rev[i]) swap(a[i], a[rev[i]]);
}
for (long long mid = 1; mid < n; mid <<= 1) {
complex<double> temp(cos(pi / mid), opt * sin(pi / mid));
for (long long i = 0; i < n; i += mid + mid) {
complex<double> omega(1, 0);
for (long long j = 0; j < mid; j++, omega *= temp) {
complex<double> x = a[i + j], y = omega * a[i + j + mid];
a[i + j] = x + y, a[i + j + mid] = x - y;
}
}
}
if (opt == -1)
for (long long i = 0; i < n; i++) a[i] /= n;
}
complex<double> a[4 * MAXN], b[4 * MAXN];
long long c[200005];
long long num[200005];
vector<long long> v[200005];
struct node {
long long id;
friend bool operator<(const node &a, const node &b) {
return v[a.id].size() > v[b.id].size();
}
};
priority_queue<node> q;
void Merge(long long id1, long long id2) {
long long sz1 = v[id1].size();
long long sz2 = v[id2].size();
long long nsiz = sz1 + sz2 - 1;
long long len = 1;
while (len <= nsiz) len <<= 1;
for (long long i = 0; i < sz1; i++) a[i] = v[id1][i];
for (long long i = sz1; i <= len; i++) a[i] = 0;
for (long long i = 0; i < sz2; i++) b[i] = v[id2][i];
for (long long i = sz2; i <= len; i++) b[i] = 0;
fft(a, len, 1);
fft(b, len, 1);
for (long long i = 0; i <= len; i++) a[i] = a[i] * b[i];
fft(a, len, -1);
v[id1].clear();
v[id2].clear();
for (long long i = 0; i <= nsiz; i++) {
v[id1].push_back(((long long)(a[i].real() + 0.5)) % 1009);
}
}
vector<long long> bb;
int main() {
long long n, m, k;
scanf("%lld%lld%lld", &n, &m, &k);
for (long long i = 1; i <= n; i++) {
long long x;
scanf("%lld", &x);
c[x]++;
}
for (long long i = 1; i <= n; i++) num[c[i]]++;
bb.push_back(1);
long long nn = 0;
v[nn] = bb;
q.push(node{nn});
nn++;
for (long long i = 1; i <= n; i++) {
bb.push_back(1);
if (num[i] == 0) continue;
for (long long k = 1; k <= num[i]; k++) {
v[nn] = bb;
q.push(node{nn});
nn++;
}
}
long long siz = q.size() - 1;
while (siz--) {
long long id1 = q.top().id;
q.pop();
long long id2 = q.top().id;
q.pop();
Merge(id1, id2);
q.push(node{id1});
}
printf("%lld\n", (v[q.top().id][k] + 1009) % 1009);
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
//first second
//memset(dp, -1, sizeof(dp));
//string binary =bitset<8>(n).to_string();
//(mod)->(10*mod+currentmodulo)%m
// bool compare(pos x,pos y)
// {
// return x.a < y.a;
// }
struct keycompare {
bool operator()(const pair<ll, ll>& v, const ll& k) {
return (v.first < k);
}
bool operator()(const ll& k, const pair<ll, ll>& v) {
return (k < v.first);
}
};
ll mod1=998244353,mod2=1000000007,limit=9223372036854775807;
long double pi=3.1415926535897932;
ll modpow(ll x, ll n, ll m) {
if(x>m){
x%=m;
}
if (n == 0) return 1%m;
ll u = modpow(x,n/2,m);
u = (u*u)%m;
if (n%2 == 1) u = (u*x)%m;
return u;
}
ll gcd(ll a, ll b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
bool isprime(ll n){
if(n==2)
return true;
for(ll i=2;i*i<=n;i++){
if(n%i==0)
return false;
}
return true;
}
ll power(ll x,ll n){
if(n<0){
return 0;
}
ll x_n=1;
for(ll i=0;i<n;i++){
x_n*=x;
}
return x_n;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
ll t; cin>>t;
while(t--){
ll n; cin>>n;
ll arr[n];
for(ll i=0;i<n;i++){
cin>>arr[i];
}
bool flag=true;
for(ll i=1;i<n;i++){
ll extra=arr[i-1]-(i-1);
arr[i-1]-=extra;
arr[i]+=extra;
if(arr[i]<i){
flag=false;
}
}
if(flag){
cout<<"YES\n";
}else{
cout<<"NO\n";
}
}
}
| 1
|
#include <bits/stdc++.h>
using namespace std;
int T, n, m, memo[105][105], retuser[105];
string name[105], message[105];
bool dp[105][105];
bool isok(char c) {
if ((c >= '0' && c <= '9') || (c >= 'a' && c <= 'z') ||
(c >= 'A' && c <= 'Z'))
return true;
return false;
}
int cal(int id, int bef) {
if (id > m) return memo[id][bef] = 1;
int &ret = memo[id][bef];
if (ret != -1) return ret;
ret = 0;
for (int i = 1; i <= n; i++) {
if (!dp[id][i] && bef != i) {
ret = max(ret, cal(id + 1, i));
}
}
return ret;
}
int main() {
scanf("%d", &T);
while (T--) {
memset(dp, 0, sizeof(dp));
scanf("%d", &n);
map<string, int> mp;
for (int i = 1; i <= n; i++) {
cin >> name[i];
mp[name[i]] = i;
}
scanf("%d", &m);
getchar();
for (int i = 1; i <= m; i++) {
getline(cin, message[i]);
int len = message[i].length();
string temp = "";
if (message[i][0] != '?') {
for (int k = 0; k < len; k++) {
if (isok(message[i][k]))
temp += message[i][k];
else
break;
}
for (int k = 1; k <= n; k++) dp[i][k] = true;
dp[i][mp[temp]] = false;
} else {
for (int k = 0; k < len; k++) {
if (isok(message[i][k]))
temp += message[i][k];
else {
int id = 0;
if (mp.count(temp)) id = mp[temp];
dp[i][id] = true;
temp.clear();
}
}
int id = 0;
if (mp.count(temp)) id = mp[temp];
dp[i][id] = true;
}
}
memset(memo, -1, sizeof(memo));
int ret = cal(1, 0);
if (ret != 1)
puts("Impossible");
else {
int user;
for (int i = 1; i <= n; i++) {
if (memo[m + 1][i] == 1) {
user = i;
break;
}
}
int id = m;
while (1) {
retuser[id] = user;
if (id == 1) break;
for (int i = 1; i <= n; i++) {
if (user != i && memo[id][i] == 1) {
user = i;
break;
}
}
id--;
}
for (int i = 1; i <= m; i++) {
cout << name[retuser[i]];
int j;
for (j = 0; j < message[i].size(); j++)
if (message[i][j] == ':') break;
while (j < message[i].size()) putchar(message[i][j++]);
puts("");
}
}
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
std::mt19937_64 mersenne_twister(
std::chrono::steady_clock::now().time_since_epoch().count());
namespace McDicCP {
int ask(int ai, int bi) {
std::cout << "? " << ai << ' ' << bi << std::endl;
int ret;
std::cin >> ret;
if (ret == -1) exit(0);
return ret;
}
void answer(int undigsh, std::vector<int> perm) {
std::cout << "!\n" << undigsh << '\n';
for (int num : perm) std::cout << num << ' ';
std::cout << std::endl;
}
bool verify(int n, const std::vector<int> &a, const std::vector<int> &b) {
std::vector<bool> appeared(n, false);
for (int num : a) {
if (num < 0 || num >= n) return false;
appeared[num] = true;
}
for (bool app : appeared)
if (!app) return false;
for (int num : b) {
if (num < 0 || num >= n) return false;
appeared[num] = false;
}
for (bool app : appeared)
if (app) return false;
for (int i = 0; i < n; i++)
if (a[b[i]] != i || b[a[i]] != i) return false;
return true;
}
void solve() {
int n;
std::cin >> n;
std::vector<int> zero_answers, inverse_answers;
for (int i = 0; i < n; i++) {
zero_answers.push_back(ask(0, i));
inverse_answers.push_back(ask(i, 0));
}
std::vector<int> a0_candidates;
for (int i = 0; i < n; i++)
if (zero_answers[i] == i) a0_candidates.push_back(i);
int ans_count = 0;
std::vector<int> ans_a;
for (int t : a0_candidates) {
std::vector<int> a(n, -1), b(n, -1);
for (int i = 0; i < n; i++) b[i] = zero_answers[i] ^ t;
for (int i = 0; i < n; i++) a[i] = inverse_answers[i] ^ b[0];
if (verify(n, a, b)) ans_count++, ans_a = a;
}
answer(ans_count, ans_a);
}
} // namespace McDicCP
int main(int argc, char **argv) {
int testcases = 1;
for (int t = 1; t <= testcases; t++) McDicCP::solve();
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 998244353;
long long expo_pow(long long x, long long y) {
if (y == 0) return 1;
y = y % (mod - 1);
x %= mod;
if (y == 0) y = mod - 1;
long long res = 1;
while (y) {
if (y & 1) res = (res * x) % mod;
x = (x * x) % mod;
y >>= 1;
}
return res;
}
long long add() { return 0; }
template <typename T, typename... Types>
T add(T var1, Types... var2) {
return (((((long long)(var1)) % mod + (long long)(add(var2...))) % mod) +
mod) %
mod;
}
long long mul() { return 1; }
template <typename T, typename... Types>
T mul(T var1, Types... var2) {
return (((long long)(var1)) % mod * (long long)(mul(var2...))) % mod;
}
const long long mx = 3e5;
long long fact[mx];
long long inv_fact[mx];
long long inv(long long x) { return expo_pow(x, mod - 2); }
void compute() {
fact[0] = 1;
for (long long i = 1; i < mx; ++i) fact[i] = mul(fact[i - 1], i);
for (long long i = 0; i < mx; ++i) inv_fact[i] = inv(fact[i]);
}
void solve() {
compute();
long long n;
cin >> n;
long long a[2 * n];
for (long long i = 0; i < 2 * n; ++i) cin >> a[i];
sort(a, a + 2 * n);
long long tmp = mul(fact[2 * n - 1], inv_fact[n], inv_fact[n - 1]);
long long ans = 0;
for (long long i = 0; i < n; ++i) {
ans = add(ans, a[2 * n - 1 - i] - a[i]);
}
ans = mul(ans, tmp, 2);
cout << ans << "\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long test = 1;
long long i = 1;
while (test--) {
solve();
}
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
int d[5010], mp[5010];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
mp[a]++;
int t = b > a ? b - a : b - a + n;
if (!d[a]) {
d[a] = t;
} else
d[a] = min(d[a], t);
}
for (int i = 1; i <= n; i++) {
if (mp[i]) {
mp[i] = (mp[i] - 1) * n + d[i];
}
}
for (int i = 1; i <= n; i++) {
int ans = 0;
for (int j = 1; j <= n; j++) {
if (!mp[j]) continue;
int dis = j < i ? j + n - i : j - i;
ans = max(mp[j] + dis, ans);
}
printf("%d ", ans);
}
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 505;
int N, M;
vector<int> adj[MAXN];
pair<int, int> bt[MAXN][MAXN][2];
queue<tuple<int, int, int> > Q;
deque<pair<int, int> > ans;
void go(int a, int b, int c) {
if (!c) ans.push_back(pair<int, int>(a, b));
pair<int, int>& x = bt[a][b][c];
if (x.first != a || x.second != b) go(x.first, x.second, c ^ 1);
}
int main(int argc, char* argv[]) {
scanf("%d%d", &N, &M);
for (int i = 0, _i = M; i < _i; ++i) {
int a, b;
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
}
Q.push(tuple<int, int, int>(N, 1, 0));
bt[N][1][0] = pair<int, int>(N, 1);
while (!Q.empty()) {
int a, b, c;
tie(a, b, c) = Q.front();
Q.pop();
if (c == 0) {
for (decltype((adj[a]).begin()) it = (adj[a]).begin(),
_it = (adj[a]).end();
it != _it; ++it) {
if (!bt[*it][b][1].first) {
bt[*it][b][1] = pair<int, int>(a, b);
Q.push(tuple<int, int, int>(*it, b, 1));
}
}
} else {
for (decltype((adj[b]).begin()) it = (adj[b]).begin(),
_it = (adj[b]).end();
it != _it; ++it) {
if (!bt[a][*it][0].first && *it != a) {
bt[a][*it][0] = pair<int, int>(a, b);
Q.push(tuple<int, int, int>(a, *it, 0));
}
}
}
}
if (!bt[1][N][0].first) return puts("-1") & 0;
go(1, N, 0);
printf("%d\n", ans.size() - 1);
for (decltype((ans).begin()) it = (ans).begin(), _it = (ans).end(); it != _it;
++it)
printf("%d ", it->first);
puts("");
for (decltype((ans).begin()) it = (ans).begin(), _it = (ans).end(); it != _it;
++it)
printf("%d ", it->second);
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, vx, vy;
long long k, t, p, q, c;
long long gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int abss(int a) { return a < 0 ? -a : a; }
void exgcd(long long &x, long long &y, int a, int b) {
if (b == 0)
x = 1, y = 0;
else {
exgcd(y, x, b, a % b);
y -= a / b * x;
}
}
int main() {
scanf("%d%d%d%d%d%d", &n, &m, &x, &y, &vx, &vy);
if (vx == 0) {
if (vy == -1) {
if (x == 0) {
printf("0 0\n");
return 0;
}
if (x == n) {
printf("%d 0\n", n);
return 0;
}
} else {
if (x == 0) {
printf("0 %d\n", m);
return 0;
}
if (x == n) {
printf("%d %d\n", n, m);
return 0;
}
}
printf("-1");
return 0;
}
if (vy == 0) {
if (vx == -1) {
if (y == 0) {
printf("0 0\n");
return 0;
}
if (y == m) {
printf("0 %d\n", m);
return 0;
}
} else {
if (y == 0) {
printf("%d 0\n", n);
return 0;
}
if (y == m) {
printf("%d %d\n", n, m);
return 0;
}
}
printf("-1");
return 0;
}
x *= vx;
y *= vy;
t = gcd(n, m);
if (abss(x - y) % t != 0) {
printf("-1");
} else {
exgcd(p, q, n, m);
p *= 1LL * (x - y) / t;
q *= 1LL * (x - y) / t;
if (x >= 0)
c = max(0, (x % n) == 0 ? x / n : x / n + 1);
else
c = 0;
k = (p - c) >= 0 ? (p - c) / (m / t)
: (((p - c) % (m / t) == 0) ? (p - c) / (m / t)
: (p - c) / (m / t) - 1);
p -= k * (m / t);
q += k * (n / t);
if ((p & 1) && (q & 1)) printf("%d %d\n", n, m);
if (((p & 1) ^ 1) && (q & 1)) printf("0 %d\n", m);
if ((p & 1) && ((q & 1) ^ 1)) printf("%d 0\n", n);
if (((p & 1) ^ 1) && ((q & 1) ^ 1)) printf("0 0\n");
}
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
struct P {
double first, second;
bool sp;
P(double first, double second, bool sp)
: first(first), second(second), sp(sp) {}
};
int n, m;
int x[4000], y[4000];
int sx, sy, tx, ty;
long long a, b, c;
vector<pair<double, double> > p;
vector<bool> sp;
vector<P> pp;
const double EPS = 1e-9;
inline bool cmpX(const P &lhs, const P &rhs) { return lhs.first < rhs.first; }
inline bool cmpY(const P &lhs, const P &rhs) { return lhs.second < rhs.second; }
int sgn(long long x, long long y, long long xx, long long yy) {
long long val = x * yy - xx * y;
if (val > 0) return 1;
if (val < 0) return -1;
return 0;
}
void readNumber(int &x) {
double d;
scanf("%lf", &d);
x = abs(d) * 100 + 0.5;
if (d < 0) x *= -1;
}
bool check(long long x, long long y, long long xx, long long yy, long long xxx,
long long yyy) {
int sg = sgn(x, y, xxx, yyy);
return !sg || sgn(x, y, xx, yy) == sg && sgn(xx, yy, xxx, yyy) == sg;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < (int)(n); ++i) readNumber(x[i]), readNumber(y[i]);
for (int i = 0; i < (int)(3 * n); ++i) x[n + i] = x[i], y[n + i] = y[i];
for (int query = 0; query < (int)(m); ++query) {
readNumber(sx), readNumber(sy);
readNumber(tx), readNumber(ty);
a = sy - ty;
b = tx - sx;
c = a * sx + b * sy;
p.clear();
sp.clear();
for (int i = 0; i < (int)(n); ++i)
if (a * x[i] + b * y[i] == c && a * x[i + 1] + b * y[i + 1] == c) {
p.push_back(make_pair(x[i], y[i]));
p.push_back(make_pair(x[i + 1], y[i + 1]));
sp.push_back(true), sp.push_back(true);
} else if (a * x[i] + b * y[i] != c && a * x[i + 1] + b * y[i + 1] != c) {
long long aa = y[i + 1] - y[i];
long long bb = x[i] - x[i + 1];
long long cc = aa * x[i] + bb * y[i];
long long det = a * bb - aa * b;
if (det == 0) continue;
double ix = ((double)c * bb - (double)cc * b) / det;
double iy = ((double)a * cc - (double)aa * c) / det;
int minX = min(x[i], x[i + 1]);
int maxX = max(x[i], x[i + 1]);
int minY = min(y[i], y[i + 1]);
int maxY = max(y[i], y[i + 1]);
if (ix > minX - EPS && ix < maxX + EPS && iy > minY - EPS &&
iy < maxY + EPS) {
p.push_back(make_pair(ix, iy));
sp.push_back(false);
}
}
for (int i = 1; i <= n; ++i)
if (a * x[i] + b * y[i] == c && a * x[i - 1] + b * y[i - 1] != c &&
a * x[i + 1] + b * y[i + 1] != c) {
if (check(x[i - 1] - x[i], y[i - 1] - y[i], -b, a, x[i + 1] - x[i],
y[i + 1] - y[i]) ||
check(x[i - 1] - x[i], y[i - 1] - y[i], b, -a, x[i + 1] - x[i],
y[i + 1] - y[i])) {
p.push_back(make_pair(x[i], y[i]));
sp.push_back(false);
}
}
int ed = -1;
for (int beg = n; beg < 2 * n;)
if (a * x[beg] + b * y[beg] == c) {
int end = beg + 1;
while (a * x[beg - 1] + b * y[beg - 1] == c) --beg;
while (a * x[end] + b * y[end] == c) ++end;
--end;
if (ed != -1 && end == ed + n) break;
if (sgn(x[beg] - x[beg - 1], y[beg] - y[beg - 1], x[beg + 1] - x[beg],
y[beg + 1] - y[beg]) *
sgn(x[end] - x[end - 1], y[end] - y[end - 1],
x[end + 1] - x[end], y[end + 1] - y[end]) <
0) {
p.push_back(make_pair(x[end], y[end]));
sp.push_back(false);
}
if (ed == -1) ed = end;
beg = end + 1;
} else {
++beg;
}
pp.clear();
for (int i = 0; i < (int)(p.size()); ++i)
pp.push_back(P(p[i].first, p[i].second, sp[i]));
if (b == 0)
sort(pp.begin(), pp.end(), cmpY);
else
sort(pp.begin(), pp.end(), cmpX);
for (int i = 0; i < (int)(p.size()); ++i)
p[i].first = pp[i].first, p[i].second = pp[i].second, sp[i] = pp[i].sp;
double ans = 0;
bool curSp = false;
pair<double, double> spPoint;
for (int i = 0; i < (int)(p.size()); ++i) {
if (!curSp && (i & 1)) {
ans += sqrt(
(p[i].first - p[i - 1].first) * (p[i].first - p[i - 1].first) +
(p[i].second - p[i - 1].second) * (p[i].second - p[i - 1].second));
}
if (sp[i]) {
if (curSp) {
ans += sqrt(
(spPoint.first - p[i].first) * (spPoint.first - p[i].first) +
(spPoint.second - p[i].second) * (spPoint.second - p[i].second));
} else {
spPoint = p[i];
}
curSp = !curSp;
}
}
printf("%.18f\n", ans * 0.01);
}
return 0;
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
int suffix_array_build_rank(int N, const int suffix[], const T equality[],
int new_rank[], int len) {
int cur_rank = 0;
int base = suffix[cur_rank];
new_rank[base] = cur_rank;
for (int i = 1; i < N; ++i) {
int cur = suffix[i];
if (!(base + len < N && cur + len < N && equality[cur] == equality[base] &&
equality[cur + len] == equality[base + len])) {
++cur_rank;
base = cur;
}
new_rank[cur] = cur_rank;
}
return ++cur_rank;
}
template <typename T>
void build_suffix_array(int N, T str[], int suffix[], int suffix_rank[],
int lcp[], int tmp[]) {
for (int i = 0; i < N; i++) {
suffix[i] = i;
}
sort(suffix, suffix + N, [str](int a, int b) { return str[a] < str[b]; });
int len = 1;
int *const cnt = lcp;
int *coor = tmp;
int *rank = suffix_rank;
int rank_size = suffix_array_build_rank(N, suffix, str, rank, 0);
while (rank_size != N && len < N) {
int cur = 0;
coor[cur++] = N - len;
for (int i = 0; i < N; i++) {
if (suffix[i] >= len) {
coor[cur++] = suffix[i] - len;
}
}
memset(cnt, 0, rank_size * sizeof(int));
for (int i = 0; i < N; i++) {
++cnt[rank[i]];
}
for (int i = 1; i < rank_size; i++) {
cnt[i] += cnt[i - 1];
}
for (int i = N - len; i >= 0; --i) {
int cur = coor[i];
suffix[--cnt[rank[cur]]] = cur;
}
int *old_rank = rank;
rank = coor;
coor = old_rank;
rank_size = suffix_array_build_rank(N, suffix, old_rank, rank, len);
len <<= 1;
}
if (suffix_rank != rank) {
memcpy(suffix_rank, rank, N * sizeof(int));
}
len = 0;
for (int i = 0; i < N; i++) {
if (rank[i] == 0) {
continue;
}
if (len != 0) {
--len;
}
int prev = suffix[rank[i] - 1];
while (i + len < N && prev + len < N && str[i + len] == str[prev + len]) {
++len;
}
lcp[rank[i]] = len;
}
lcp[0] = 0;
}
struct set_node {
set_node *father;
int rank;
int left, right;
} set_nodes[(100000 << 1)];
void set_init(set_node set_nodes[], int T) {
for (int i = 0; i < T; i++) {
set_nodes[i].father = set_nodes + i;
set_nodes[i].rank = 0;
set_nodes[i].left = set_nodes[i].right = i;
}
}
set_node *set_find(set_node *x) {
while (x->father != x) {
set_node *father = x->father;
x->father = father->father;
x = father;
}
return x;
}
set_node *set_union(set_node *x, set_node *y) {
set_node *x_root = set_find(x);
set_node *y_root = set_find(y);
if (x_root == y_root) {
return x_root;
}
set_node *father = x_root->rank > y_root->rank ? x_root : y_root;
x_root->father = y_root->father = father;
father->rank += x_root->rank == y_root->rank;
father->left = min(x_root->left, y_root->left);
father->right = max(x_root->right, y_root->right);
return father;
}
int suffix_rank[(100000 << 1)];
int suffix[(100000 << 1)];
int lcp[(100000 << 1)];
int tmp[(100000 << 1)];
int N;
int height[100000];
int diff[(100000 << 1)];
int sum[(100000 << 1)];
int ans[100000];
struct query {
int len;
int start;
int sub;
int x, y;
int first, second;
} queries[100000];
bool operator<(const query &a, const query &b) { return a.len > b.len; }
pair<int, int> lcp_values[(100000 << 1)];
pair<int, pair<bool, query *>> ranges[100000 << 1];
int base[100000 + 1];
void tree_array_add(int pos, int val) {
while (pos <= 100000) {
base[pos] += val;
pos += ((pos) & (-pos));
}
}
int tree_array_sum(int pos) {
int val = 0;
while (pos) {
val += base[pos];
pos -= ((pos) & (-pos));
}
return val;
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%d", height + i);
}
int L = N - 1;
for (int i = 0; i < N - 1; ++i) {
diff[i] = height[i] - height[i + 1];
}
for (int i = 0; i < N - 1; ++i) {
diff[L + i] = height[i + 1] - height[i];
}
L <<= 1;
build_suffix_array(L, diff, suffix, suffix_rank, lcp, tmp);
int count = 0;
for (int i = 0; i < L; ++i) {
if (suffix[i] >= N - 1) {
++count;
}
sum[i] = count;
}
for (int i = 0; i < L; ++i) {
lcp_values[i].first = lcp[i];
lcp_values[i].second = i;
}
int Q;
scanf("%d", &Q);
int XQ = 0;
for (int i = 0; i < Q; ++i) {
int l, r;
scanf("%d %d", &l, &r);
if (l == r) {
ans[i] = N - 1;
} else {
queries[XQ].len = r - l;
queries[XQ].start = suffix_rank[l - 1];
queries[XQ].x = l;
queries[XQ].y = r;
queries[XQ].sub = i;
++XQ;
}
}
sort(queries, queries + XQ);
sort(lcp_values, lcp_values + L, greater<pair<int, int>>());
set_init(set_nodes, L);
int lcp_cnt = 0;
for (int i = 0; i < XQ; i++) {
while (lcp_values[lcp_cnt].first >= queries[i].len) {
int rank = lcp_values[lcp_cnt].second;
set_union(set_nodes + rank - 1, set_nodes + rank);
++lcp_cnt;
}
set_node *node = set_find(queries[i].start + set_nodes);
ranges[i << 1].first = node->left - 1;
ranges[i << 1].second.first = true;
ranges[i << 1].second.second = queries + i;
ranges[(i << 1) + 1].first = node->right;
ranges[(i << 1) + 1].second.first = false;
ranges[(i << 1) + 1].second.second = queries + i;
ans[queries[i].sub] =
sum[node->right] - sum[node->left] + (suffix[node->left] >= N - 1);
}
int XR = XQ << 1;
sort(ranges, ranges + XR);
memset(base, 0, sizeof(int) * (N + 1));
int suf_cnt = 0;
for (int i = 0; i < XR; ++i) {
while (suf_cnt <= ranges[i].first) {
if (suffix[suf_cnt] >= N - 1) {
tree_array_add(suffix[suf_cnt] - N + 2, 1);
}
++suf_cnt;
}
const query *q = ranges[i].second.second;
int start = max(0, q->x * 2 - q->y - 1);
int end = q->y;
int sum = tree_array_sum(end) - tree_array_sum(start);
if (ranges[i].second.first) {
ans[q->sub] += sum;
} else {
ans[q->sub] -= sum;
}
}
for (int i = 0; i < Q; ++i) {
printf("%d\n", ans[i]);
}
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 100005;
const long long inf = 1e18;
long long pow(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) {
res = res * a;
}
a = a * a;
b >>= 1;
}
return res;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
long long g = 1;
g = 2520;
cout << n / g;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int A[100000];
int abs(int x) {
if (x < 0) return -1 * x;
return x;
}
int main() {
int n, i, sum1 = 0, sum2 = 0;
cin >> n;
for (i = 0; i < n / 2; i++) {
cin >> A[i];
A[i]--;
}
sort(A, A + n / 2);
int w = n - 1;
int b = n - 2;
for (i = n / 2 - 1; i >= 0; i--) {
sum1 += abs(A[i] - w);
w -= 2;
sum2 += abs(A[i] - b);
b -= 2;
}
cout << min(sum1, sum2) << endl;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
char s[2], t[2], aux, sc, tc, v[100];
int ss, tt, k = 0;
void RD() {
while (ss > tt && sc < tc) {
ss--;
sc++;
k++;
strcpy(v + strlen(v), "RD");
}
}
void LD() {
while (ss > tt && sc > tc) {
ss--;
sc--;
k++;
strcpy(v + strlen(v), "LD");
}
}
void RU() {
while (ss < tt && sc < tc) {
ss++;
sc++;
k++;
strcpy(v + strlen(v), "RU");
}
}
void LU() {
while (ss < tt && sc > tc) {
ss++;
sc--;
k++;
strcpy(v + strlen(v), "LU");
}
}
void D() {
while (ss > tt) {
k++;
ss--;
strcpy(v + strlen(v), "D!");
}
}
void U() {
while (ss < tt) {
k++;
ss++;
strcpy(v + strlen(v), "U!");
}
}
void L() {
while (sc > tc) {
k++;
sc--;
strcpy(v + strlen(v), "L!");
}
}
void R() {
while (sc < tc) {
k++;
sc++;
strcpy(v + strlen(v), "R!");
}
}
int main() {
cin >> s;
sc = s[0];
cin >> t;
aux = s[1];
ss = aux - 48;
aux = t[1];
tt = aux - 48;
tc = t[0];
while (!(ss == tt && sc == tc)) {
if (ss > tt && sc < tc) RD();
if (ss > tt && sc > tc) LD();
if (ss < tt && sc < tc) RU();
if (ss < tt && sc > tc) LU();
if (ss > tt) D();
if (ss < tt) U();
if (sc > tc) L();
if (sc < tc) R();
}
cout << k << endl;
for (int i = 0; i < strlen(v); i = i + 2) {
cout << v[i];
if (v[i + 1] >= 'A' && v[i + 1] <= 'Z') cout << v[i + 1];
cout << endl;
}
return 0;
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
inline void rdl(int &x) {
x = 0;
bool check = false;
register int c;
do {
c = getchar();
if (c == '-') check = true;
} while (c < 48 || c > 57);
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
if (check) x = -x;
}
inline void rd(int &x) {
x = 0;
bool check = false;
register int c = getchar();
for (; c < 48 || c > 57; c = getchar())
;
for (; c > 47 && c < 58; c = getchar()) {
x = (x << 1) + (x << 3) + c - 48;
}
}
inline void pd(int x) {
char c[11];
bool check = false;
int k = -1;
if (x < 0) check = true, x = -x;
do {
c[++k] = x % 10 + 48;
x /= 10;
} while (x);
if (check) c[++k] = '-';
while (k >= 0) putchar(c[k--]);
putchar('\n');
}
inline void pdl(long long int x) {
char c[21];
bool check = false;
int k = -1;
if (x < 0) check = true, x = -x;
do {
c[++k] = x % 10 + 48;
x /= 10;
} while (x);
if (check) c[++k] = '-';
while (k >= 0) putchar(c[k--]);
putchar('\n');
}
bool cmp(int a, int b) { return a > b; }
int main() {
char c[3];
int i, j, k, l;
scanf("%s", c);
l = strlen(c);
if (l == 1) {
i = c[0] - '0';
if (i == 0)
printf("zero\n");
else if (i == 1)
printf("one\n");
else if (i == 2)
printf("two\n");
else if (i == 3)
printf("three\n");
else if (i == 4)
printf("four\n");
else if (i == 5)
printf("five\n");
else if (i == 6)
printf("six\n");
else if (i == 7)
printf("seven\n");
else if (i == 8)
printf("eight\n");
else
printf("nine\n");
} else {
if (c[0] == '1') {
if (c[1] == '0')
printf("ten\n");
else if (c[1] == '1')
printf("eleven\n");
else if (c[1] == '2')
printf("twelve\n");
else if (c[1] == '3')
printf("thirteen\n");
else if (c[1] == '4')
printf("fourteen\n");
else if (c[1] == '5')
printf("fifteen\n");
else if (c[1] == '6')
printf("sixteen\n");
else if (c[1] == '7')
printf("seventeen\n");
else if (c[1] == '8')
printf("eighteen\n");
else
printf("nineteen\n");
} else if (c[0] == '0') {
i = c[1] - '0';
if (i == 0)
printf("zero\n");
else if (i == 1)
printf("one\n");
else if (i == 2)
printf("two\n");
else if (i == 3)
printf("three\n");
else if (i == 4)
printf("four\n");
else if (i == 5)
printf("five\n");
else if (i == 6)
printf("six\n");
else if (i == 7)
printf("seven\n");
else if (i == 8)
printf("eight\n");
else
printf("nine\n");
} else {
i = c[0] - '0';
if (i == 2)
printf("twenty");
else if (i == 3)
printf("thirty");
else if (i == 4)
printf("forty");
else if (i == 5)
printf("fifty");
else if (i == 6)
printf("sixty");
else if (i == 7)
printf("seventy");
else if (i == 8)
printf("eighty");
else
printf("ninety");
i = c[1] - '0';
if (i == 0)
printf("\n");
else if (i == 1)
printf("-one\n");
else if (i == 2)
printf("-two\n");
else if (i == 3)
printf("-three\n");
else if (i == 4)
printf("-four\n");
else if (i == 5)
printf("-five\n");
else if (i == 6)
printf("-six\n");
else if (i == 7)
printf("-seven\n");
else if (i == 8)
printf("-eight\n");
else
printf("-nine\n");
}
}
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
template <class S, class T>
ostream& operator<<(ostream& os, const pair<S, T>& p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const unordered_set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream& operator<<(ostream& os, const unordered_map<S, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
ostream& operator<<(ostream& os, const multiset<T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class S, class T>
ostream& operator<<(ostream& os, const map<S, T>& p) {
os << "[ ";
for (auto& it : p) os << it << " ";
return os << "]";
}
template <class T>
void dbs(string str, T t) {
cerr << str << " : " << t << "\n";
}
template <class T, class... S>
void dbs(string str, T t, S... s) {
long long idx = str.find(',');
cerr << str.substr(0, idx) << " : " << t << ",";
dbs(str.substr(idx + 1), s...);
}
template <class T>
void prc(T a, T b) {
cerr << "[";
for (T i = a; i != b; ++i) {
if (i != a) cerr << ", ";
cerr << *i;
}
cerr << "]\n";
}
long long n, m;
vector<vector<pair<long long, long long> > > arr(200001);
vector<vector<long long> > cycle(50);
long long visited[200001];
long long cnt = 0;
long long dp[45][200001];
template <int MOD>
struct mod_int {
static const int mod = MOD;
unsigned x;
mod_int() : x(0) {}
mod_int(int sig) {
int sigt = sig % MOD;
if (sigt < 0) sigt += MOD;
x = sigt;
}
mod_int(long long sig) {
int sigt = sig % MOD;
if (sigt < 0) sigt += MOD;
x = sigt;
}
int get() const { return (int)x; }
mod_int& operator+=(mod_int that) {
if ((x += that.x) >= MOD) x -= MOD;
return *this;
}
mod_int& operator-=(mod_int that) {
if ((x += MOD - that.x) >= MOD) x -= MOD;
return *this;
}
mod_int& operator*=(mod_int that) {
x = (unsigned long long)x * that.x % MOD;
return *this;
}
mod_int& operator/=(mod_int that) { return *this *= that.inverse(); }
mod_int operator+(mod_int that) const { return mod_int(*this) += that; }
mod_int operator-(mod_int that) const { return mod_int(*this) -= that; }
mod_int operator*(mod_int that) const { return mod_int(*this) *= that; }
mod_int operator/(mod_int that) const { return mod_int(*this) /= that; }
mod_int inverse() const {
long long a = x, b = MOD, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return mod_int(u);
}
};
template <int MOD>
istream& operator>>(istream& is, mod_int<MOD>& val) {
long long x;
is >> x;
val = x;
return is;
}
template <int MOD>
ostream& operator<<(ostream& os, const mod_int<MOD>& val) {
os << val.get();
return os;
}
using mint7 = mod_int<1000000007>;
using mint21 = mod_int<1000000021>;
template <typename T>
vector<T> xor_convolution(vector<T> a, vector<T> b) {
int n = a.size();
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
T x = a[j], y = a[j | i];
a[j] = x + y, a[j | i] = x - y;
}
}
}
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
T x = b[j], y = b[j | i];
b[j] = x + y, b[j | i] = x - y;
}
}
}
for (int i = 0; i < n; i++) {
a[i] *= b[i];
}
T inv2 = T(1) / T(2);
for (int i = 1; i < n; i <<= 1) {
for (int j = 0; j < n; j++) {
if ((j & i) == 0) {
T x = a[j], y = a[j | i];
a[j] = (x + y) * inv2, a[j | i] = (x - y) * inv2;
}
}
}
return a;
}
bool cyclefinding(long long u, long long v, long long par) {
long long p = visited[u];
visited[u] = 3;
for (auto x : arr[u]) {
if (x.first != par and visited[x.first] == 2) {
if (x.first == v) {
cycle[cnt].push_back(x.second);
visited[u] = p;
return 1;
}
if (cyclefinding(x.first, v, u)) {
cycle[cnt].push_back(x.second);
visited[u] = p;
return 1;
}
}
}
visited[u] = p;
return 0;
}
void dfs(long long u, long long par) {
visited[u] = 2;
for (auto v : arr[u]) {
if (v.first != par) {
if (visited[v.first] == 2) {
cycle[cnt].push_back(v.second);
cyclefinding(v.first, u, 0);
cnt++;
} else if (visited[v.first] == 0) {
dfs(v.first, u);
}
}
}
visited[u] = 1;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
long long i;
long long xorr = 0;
for (i = 0; i < m; i++) {
long long u, v, w;
cin >> u >> v >> w;
arr[u].push_back(make_pair(v, w));
arr[v].push_back(make_pair(u, w));
xorr ^= w;
}
if (m == n - 1) {
cout << xorr << " 1";
return 0;
}
dfs(1, 0);
vector<vector<long long> > temp(cnt);
for (i = 0; i < cnt; i++) {
long long x = 0;
for (auto v : cycle[i]) x ^= v, xorr ^= v;
for (auto v : cycle[i]) temp[i].push_back(x ^ v);
}
vector<mint7> freq7;
vector<mint21> freq21;
for (i = 0; i < (1LL << 17); i++) freq7.push_back(0), freq21.push_back(0);
freq7[xorr] = 1;
freq21[xorr] = 1;
for (i = 0; i < cnt; i++) {
vector<mint7> temp7((1LL << 17), 0);
vector<mint21> temp21((1LL << 17), 0);
for (auto v : temp[i]) temp7[v] += 1, temp21[v] += 1;
freq7 = xor_convolution(freq7, temp7);
freq21 = xor_convolution(freq21, temp21);
}
for (i = 0; i < (1LL << 17); i++) {
if (freq7[i].x == 0 && freq21[i].x == 0) {
continue;
} else {
cout << i << " " << freq7[i].x << endl;
return 0;
}
}
}
| 16
|
#include <bits/stdc++.h>
int main() {
int ind;
long mov;
scanf("%ld", &mov);
scanf("%d", &ind);
mov = mov % 6;
if ((mov == 0 && ind == 1) || (mov == 1 && ind == 0) ||
(mov == 2 && ind == 0) || (mov == 3 && ind == 1) ||
(mov == 4 && ind == 2) || (mov == 5 && ind == 2))
printf("1");
else if ((mov == 0 && ind == 0) || (mov == 1 && ind == 1) ||
(mov == 2 && ind == 2) || (mov == 3 && ind == 2) ||
(mov == 4 && ind == 1) || (mov == 5 && ind == 0))
printf("0");
else
printf("2");
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
void kehsihba() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
void solve() {
long long n;
cin >> n;
vector<long double> arr(n);
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
arr[i] = (atan2(y, x) * 180 / 3.1415926535897);
}
sort(arr.begin(), arr.end());
long double ans = arr[n - 1] - arr[0];
for (long long i = 1; i < n; i++) {
long double x = arr[i] - arr[(i - 1 + n) % n];
ans = min(ans, 360 - x);
}
cout << fixed << setprecision(10) << ans;
}
int32_t main() {
kehsihba();
long long t = 1;
for (long long k = 1; k <= t; k++) {
solve();
}
}
| 10
|
#include <bits/stdc++.h>
const int kN = 2e5 + 10;
const int kInf = 1e9 + 2077;
int n, m, q, e_num, val[kN], head[kN], v[kN << 1], ne[kN << 1];
int dfnnum, cnt, dfn[kN], low[kN];
int hld_dfnnum, hld_dfn[kN], s[kN];
int fa[kN];
std::vector<int> newv[kN];
std::stack<int> st;
std::multiset<int> minval[kN];
inline int read() {
int f = 1, w = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) w = (w << 3) + (w << 1) + (ch ^ '0');
return f * w;
}
void Chkmax(int &fir, int sec) {
if (sec > fir) fir = sec;
}
void Chkmin(int &fir, int sec) {
if (sec < fir) fir = sec;
}
void Add(int u_, int v_) {
v[++e_num] = v_, ne[e_num] = head[u_], head[u_] = e_num;
}
void Tarjan(int u_) {
dfn[u_] = low[u_] = ++dfnnum;
st.push(u_);
for (int i = head[u_]; i; i = ne[i]) {
int v_ = v[i];
if (!dfn[v_]) {
Tarjan(v_);
Chkmin(low[u_], low[v_]);
if (low[v_] >= dfn[u_]) {
++cnt;
newv[cnt].push_back(u_), newv[u_].push_back(cnt);
while (true) {
int top_ = st.top();
newv[cnt].push_back(top_), newv[top_].push_back(cnt);
st.pop();
if (top_ == v_) break;
}
}
} else {
Chkmin(low[u_], dfn[v_]);
}
}
}
namespace Seg {
int minv[kN << 2];
void Pushup(int now_) {
minv[now_] = std::min(minv[(now_ << 1)], minv[(now_ << 1 | 1)]);
}
void Build(int now_, int L_, int R_) {
if (L_ == R_) {
minv[now_] = val[s[L_]];
return;
}
Build((now_ << 1), L_, ((L_ + R_) >> 1)),
Build((now_ << 1 | 1), ((L_ + R_) >> 1) + 1, R_);
Pushup(now_);
}
void Modify(int now_, int L_, int R_, int pos_, int val_) {
if (L_ == R_) {
minv[now_] = val_;
return;
}
if (pos_ <= ((L_ + R_) >> 1))
Modify((now_ << 1), L_, ((L_ + R_) >> 1), pos_, val_);
else
Modify((now_ << 1 | 1), ((L_ + R_) >> 1) + 1, R_, pos_, val_);
Pushup(now_);
}
int Query(int now_, int L_, int R_, int l_, int r_) {
if (l_ <= L_ && R_ <= r_) return minv[now_];
int ret = kInf;
if (l_ <= ((L_ + R_) >> 1))
Chkmin(ret, Query((now_ << 1), L_, ((L_ + R_) >> 1), l_, r_));
if (r_ > ((L_ + R_) >> 1))
Chkmin(ret, Query((now_ << 1 | 1), ((L_ + R_) >> 1) + 1, R_, l_, r_));
return ret;
}
} // namespace Seg
namespace HLD {
int son[kN], dep[kN], sz[kN], top[kN];
void Dfs1(int u_, int fa_) {
fa[u_] = fa_;
sz[u_] = 1;
dep[u_] = dep[fa_] + 1;
for (int i = 0, lim = newv[u_].size(); i < lim; ++i) {
int v_ = newv[u_][i];
if (v_ == fa_) continue;
Dfs1(v_, u_);
if (sz[v_] > sz[son[u_]]) son[u_] = v_;
sz[u_] += sz[v_];
if (u_ > n) minval[u_].insert(val[v_]);
}
if (u_ > n) val[u_] = *minval[u_].begin();
}
void Dfs2(int u_, int top_) {
hld_dfn[u_] = ++hld_dfnnum;
s[hld_dfnnum] = u_;
top[u_] = top_;
if (son[u_]) Dfs2(son[u_], top_);
for (int i = 0, lim = newv[u_].size(); i < lim; ++i) {
int v_ = newv[u_][i];
if (v_ == fa[u_] || v_ == son[u_]) continue;
Dfs2(v_, v_);
}
}
int Query(int u_, int v_) {
int ret = kInf;
for (; top[u_] != top[v_]; u_ = fa[top[u_]]) {
if (dep[top[u_]] < dep[top[v_]]) {
std::swap(u_, v_);
}
Chkmin(ret, Seg::Query(1, 1, cnt, hld_dfn[top[u_]], hld_dfn[u_]));
}
int lca = dep[u_] < dep[v_] ? u_ : v_;
if (lca != v_) std::swap(u_, v_);
Chkmin(ret, Seg::Query(1, 1, cnt, hld_dfn[lca], hld_dfn[u_]));
if (lca > n) Chkmin(ret, val[fa[lca]]);
return ret;
}
} // namespace HLD
void Modify(int u_, int val_) {
int f = fa[u_];
if (f) minval[f].erase(val[u_]);
Seg::Modify(1, 1, cnt, hld_dfn[u_], val[u_] = val_);
if (f) {
minval[f].insert(val[u_]);
Seg::Modify(1, 1, cnt, hld_dfn[f], val[f] = *minval[f].begin());
}
}
int Query(int u_, int v_) { return HLD::Query(u_, v_); }
int main() {
cnt = n = read(), m = read(), q = read();
for (int i = 1; i <= n; ++i) val[i] = read();
for (int i = 1; i <= m; ++i) {
int u_ = read(), v_ = read();
Add(u_, v_), Add(v_, u_);
}
for (int i = 1; i <= n; ++i) {
if (!dfn[i]) {
Tarjan(i);
}
}
HLD::Dfs1(1, 0), HLD::Dfs2(1, 1);
Seg::Build(1, 1, cnt);
for (int i = 1; i <= q; ++i) {
char opt[5];
scanf("%s", opt);
if (opt[0] == 'C') {
int pos_ = read(), val_ = read();
Modify(pos_, val_);
} else {
int u_ = read(), v_ = read();
printf("%d\n", Query(u_, v_));
}
}
return 0;
}
| 24
|
#include <bits/stdc++.h>
using namespace std;
const long long P = 1000000007;
int n, m, cnt;
int to[210], nxt[210], head[110], siz[110];
long long f[110][110][110], g[110][110], c[110][110], h[110], bt[110];
void dfs(int x, int fa) {
f[x][1][0] = 1, siz[x] = 1;
for (int i = head[x], j, k, a, b, y; i != -1; i = nxt[i])
if (to[i] != fa) {
y = to[i], dfs(to[i], x);
memset(g, 0, sizeof(g));
for (j = 1; j <= siz[x]; j++)
for (k = 1; k <= siz[y]; k++) {
for (a = 0; a < siz[x]; a++)
for (b = 0; b < siz[y]; b++) {
g[j + k][a + b + 1] =
(g[j + k][a + b + 1] + f[x][j][a] * f[y][k][b]) % P;
g[j][a + b] = (g[j][a + b] + f[x][j][a] * f[y][k][b] % P * k) % P;
}
}
memcpy(f[x], g, sizeof(g));
siz[x] += siz[y];
}
}
inline void add(int a, int b) {
to[cnt] = b;
nxt[cnt] = head[a];
head[a] = cnt++;
}
int main() {
scanf("%d", &n);
int i, j, a, b;
memset(head, -1, sizeof(head));
for (i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
add(a, b);
add(b, a);
}
dfs(1, 0);
for (bt[0] = i = 1; i <= n; i++) bt[i] = bt[i - 1] * n % P;
for (i = 0; i <= n; i++)
for (c[i][0] = j = 1; j <= i; j++)
c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % P;
for (i = 1; i < n; i++)
for (j = 0; j < n; j++) h[j] = (h[j] + f[1][i][j] * i) % P;
h[n - 1] = 1;
for (i = 0; i < n - 1; i++) h[i] = h[i] * bt[n - i - 2] % P;
for (i = n - 1; i >= 0; i--) {
for (j = i + 1; j < n; j++) h[i] = (h[i] - c[j][i] * h[j]) % P;
h[i] = (h[i] + P) % P;
}
for (i = 0; i < n; i++) printf("%I64d ", h[i]);
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int t[5];
int a[5];
while (~scanf("%d%d%d%d%d", &t[0], &t[1], &t[2], &t[3], &t[4])) {
sort(t, t + 5);
int ans = 0, ma = 0, mark = 0;
int tim = 1;
int j = 0;
for (int i = 0; i < 4; i++) {
if (t[i] != t[i + 1]) {
a[j++] = tim;
tim = 0;
}
if (t[i] != t[i + 1] && i == 3) {
a[j++] = 1;
}
if (t[i] == t[i + 1] && i == 3) {
a[j++] = tim + 1;
}
tim++;
}
ma = 0;
tim = 0;
for (int i = 0; i < j; i++) {
tim += a[i];
if (a[i] <= 3 && a[i] > 1)
ma = max(ma, a[i] * t[tim - 1]);
else if (a[i] > 3)
ma = max(ma, 3 * t[tim - 1]);
}
printf("%d\n", t[0] + t[1] + t[2] + t[3] + t[4] - ma);
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
long long a[200005];
int n, m, k, x;
inline bool check(int mid, int s) {
return (a[s] - (long long)mid * k - 1) / (mid + 1) + 1 <= m;
}
int main() {
long long s = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
scanf("%d%d", &m, &k);
for (int i = 1; i <= n; i++) {
int l = 0, r = a[i], mid, ans = a[i];
while (l <= r)
check(mid = l + r >> 1, i) ? r = (ans = mid) - 1 : l = mid + 1;
s += ans;
}
printf("%I64d", s * k);
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
long n, p, temp, ans;
vector<long> vec[100], ovr;
vector<long> av;
long gdeg(long x) {
long r = 0;
while (x) {
r++;
x /= 2;
}
return r - 1;
}
long ar[200000];
int main() {
ios_base::sync_with_stdio(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> ar[i];
}
ans = -1;
for (int i = 30; i + 1; --i) {
temp = (1ll << 31) - 1;
for (int ii = 1; ii <= n; ii++)
if (ar[ii] & (1 << i)) temp &= ar[ii];
if (temp % (1 << i) == 0 && ans == -1) {
ans = max(ans, i + ans - ans);
av.clear();
for (int ii = 1; ii <= n; ii++)
if (ar[ii] & (1 << i)) av.push_back(ar[ii]);
}
}
if (ans >= 0) {
cout << av.size() << endl;
for (int i = 0; i < av.size(); i++) {
if (i) cout << " ";
cout << av[i];
}
cout << endl;
} else {
cout << n << endl;
for (int i = 0; i < ovr.size(); i++) {
if (i) cout << " ";
cout << ovr[i];
}
cout << endl;
}
cin.get();
cin.get();
return 0;
}
| 10
|
#include<iostream>
#include<stdio.h>
using namespace std;
#include <set>
#include<vector>
#include<algorithm>
#define ll long long
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cmath>
#include <cstring>
#include<queue>
#include<map>
#include<stack>
#include<bits/stdc++.h>
const int maxn = 3e5+7;
const ll mod = 1e9+7;
const ll INF=5e18+7;
const int inf=1e9+7;
const ll maxx=1e6+700;
int n;
int a[maxn];
int q;
ll w;
struct node{
int x;
int cnt;
}str[maxn];
map<int,int>mp;
void init(int x){
for(int i=2;i*i<=x;i++){
if(x%i==0){
int cnt1=0;
while(x%i==0){
cnt1++;
x/=i;
}
if(cnt1%2) x*=i;
}
}
mp[x]++;
}
int main(){
int t;
scanf("%d",&t);
while(t--){
mp.clear();
scanf("%d",&n);
for(int i=1;i<=n;i++){
scanf("%d",&a[i]);
init(a[i]);
}
int ans1=0,ans2=0;
map<int,int>::iterator it;
for(it=mp.begin();it!=mp.end();it++){
ans1=max(ans1,it->second);
if(it->second%2==0||it->first==1){
ans2+=it->second;
}
}
ans2=max(ans1,ans2);
scanf("%d",&q);
while(q--){
scanf("%lld",&w);
if(w==0){
printf("%d\n",ans1);
}
else{
printf("%d\n",ans2);
}
}
}
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
void testcase(int t) { cout << "Case #" << t << ": "; }
void online() {}
const int mod = 1e9 + 7;
void solve() {
int n;
cin >> n;
string a, b;
cin >> a >> b;
for (int i = 0; i < n; i++) {
if (a[i] > b[i]) {
cout << "-1" << endl;
return;
}
}
vector<int> arr[20];
int ans = 0;
for (int i = 0; i < n; i++) {
if (a[i] == b[i]) continue;
arr[a[i] - 'a'].push_back(i);
}
for (int i = 0; i < 20; i++) {
if (arr[i].empty()) continue;
vector<int> temp;
char mn = 'z';
for (auto j : arr[i]) {
if (a[j] != b[j]) {
temp.push_back(j);
mn = min(b[j], mn);
}
}
if (temp.empty()) continue;
for (auto j : temp) {
arr[mn - 'a'].push_back(j);
a[j] = mn;
}
ans++;
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int T;
cin >> T;
for (int t = 1; t <= T; t++) {
solve();
}
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2 * 1e5 + 10;
ll res, mx;
ll a[N], price[N];
std::vector<ll> con[N];
bool vis[N];
ll cal_dis(ll x, ll y, ll nx, ll ny) {
ll k = (nx - x) * (nx - x) + (ny - y) * (ny - y);
return ceil(sqrt(k));
}
void solve() {
ll r, x, y, nx, ny;
cin >> r >> x >> y >> nx >> ny;
ll k = cal_dis(x, y, nx, ny);
cout << ceil(k / (double)(2 * r));
}
int main(int argc, char const *argv[]) {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
ll t = 1;
while (t--) {
solve();
}
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
int n;
while (~scanf("%d", &n)) {
int sum1 = 0, sum2 = 0;
int x;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
sum1 += x;
}
for (int i = 0; i < n; i++) {
scanf("%d", &x);
sum2 += x;
}
if (sum1 >= sum2)
puts("Yes");
else
puts("No");
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int m, n, p = 0, i;
vector<int> v;
cin >> n >> m;
if (n > (m + 1)) {
cout << "-1";
} else if (n >= m) {
while (m > 0) {
cout << "01";
m -= 1;
n -= 1;
}
if (n > 0) {
cout << "0";
}
} else {
while (m > n && n > 0 && m > 1) {
v.push_back(1);
v.push_back(1);
v.push_back(0);
m -= 2;
n -= 1;
}
while (m > 0 && n > 0) {
v.push_back(1);
v.push_back(0);
m -= 1;
n -= 1;
}
if (n > 0) {
p = 1;
} else if (m > 0) {
if (m < 3) {
while (m--) {
v.push_back(1);
}
} else {
p = 1;
}
}
if (p == 1) {
cout << "-1";
} else {
for (i = 0; i < v.size(); i++) {
cout << v[i];
}
}
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
vector<pair<int, int> > v;
pair<int, int> m;
double Min = 10000000, x, y, z;
cin >> x >> y >> n;
for (int i = 1; i <= n; i++) {
int low = 0, high = 100000;
while (high - low > 1) {
int mid = (high + low) / 2;
z = double(mid) / i;
if (z > x / y) {
high = mid;
} else {
low = mid;
}
}
z = double(high) / i;
if (fabs(double(low) / i - x / y) <= fabs(z - x / y)) {
v.push_back({low, i});
} else {
v.push_back({high, i});
}
}
for (int i = 0; i < v.size(); i++) {
z = double(v[i].first) / v[i].second;
if (fabs(z - x / y) < Min) {
Min = fabs(z - x / y);
m = v[i];
}
}
cout << m.first << '/' << m.second;
return 0;
}
| 9
|
#include <bits/stdc++.h>
const int MaxN = 1000 + 5;
bool graph[MaxN][MaxN];
bool poss[MaxN][MaxN];
int main() {
int n, m, x, y;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
graph[i][j] = poss[i][j] = true;
}
while (m--) {
scanf("%d%d", &x, &y);
graph[x - 1][y - 1] = false;
}
int ans = 0;
for (int i = 1; i < n - 1; ++i) {
int j;
for (j = 0; j < n; ++j) {
if (!graph[i][j]) {
break;
}
}
if (j < n) {
poss[i][0] = false;
}
}
for (int j = 1; j < n - 1; ++j) {
int i;
for (i = 0; i < n; ++i) {
if (!graph[i][j]) {
break;
}
}
if (i < n) {
poss[0][j] = false;
}
}
for (int i = 1; i <= n / 2 - 1; ++i) {
if (poss[i][0]) {
ans++;
}
if (poss[0][n - 1 - i]) {
ans++;
}
if (poss[0][i]) {
ans++;
}
if (poss[n - 1 - i][0]) {
ans++;
}
}
if (n % 2 != 0) {
int i = n / 2;
if (poss[i][0] || poss[0][n - 1 - i] || poss[0][i] || poss[n - 1 - i][0]) {
ans++;
}
}
printf("%d\n", ans);
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
double binpow(double a, int n) {
double res = 1.;
while (n) {
if (n & 1) res *= a;
a *= a;
n >>= 1;
}
return res;
}
double n, m;
int main() {
cin >> m >> n;
double ans = 0;
for (double i = 1; i <= m; i += 1.)
ans += (1. - binpow((i - 1.) / m, (int)n));
printf("%.4lf", ans);
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int n, a[N], zero, v[N];
void rec(int neg) {
if (v[neg]) {
return;
}
v[neg]++;
for (int i = 0; i <= min(neg, n); i++) {
for (int j = 0; j <= min(zero, neg - i); j++) {
if (n - i - j <= 2 * n - 1 - neg - zero) {
rec(neg - i + n - i - j);
}
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
int neg = 0;
for (int i = 1; i <= n * 2 - 1; i++) {
cin >> a[i];
neg += a[i] < 0;
zero += !a[i];
a[i] = abs(a[i]);
}
rec(neg);
for (int i = 0;; i++) {
if (v[i]) {
int ans = 0;
sort(a + 1, a + n * 2 - 1 + 1);
for (int j = 1; j <= n * 2 - 1; j++) {
if (j < 1 + i) {
ans -= a[j];
} else {
ans += a[j];
}
}
cout << ans << "\n";
break;
}
}
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int n, m, x, y, z, q, cnt, p = 1000000007;
vector<int> a[100020];
int f[100020][17];
int dfn[100020];
int low[100020];
int d[100020];
int c[100020];
int r[100020];
int s[100020], ss;
void mk(int x) {
c[x] += c[f[x][0]];
for (__typeof(a[x].begin()) i = a[x].begin(); i != a[x].end(); i++)
if (f[*i][0] == x) mk(*i);
}
void dfs(int x, int y) {
d[x] = d[y] + 1;
f[x][0] = y;
s[ss++] = x;
dfn[x] = low[x] = ++cnt;
for (int i = 1; i < 17; i++) f[x][i] = f[f[x][i - 1]][i - 1];
for (__typeof(a[x].begin()) i = a[x].begin(); i != a[x].end(); i++)
if (*i != y) {
if (dfn[*i])
low[x] = min(low[x], dfn[*i]);
else
dfs(*i, x), low[x] = min(low[x], low[*i]);
}
if (low[x] == dfn[x]) {
int o = 0;
do r[s[--ss]] = x, o++;
while (s[ss] != x);
if (o > 2) c[x] = 1;
}
}
int lca(int x, int y) {
if (d[x] < d[y]) swap(x, y);
int w = d[x] - d[y];
for (int i = 17; i--;)
if (w >> i & 1) x = f[x][i];
if (x == y) return x;
for (int i = 17; i--;)
if (f[x][i] != f[y][i]) x = f[x][i], y = f[y][i];
return f[x][0];
}
int cal(int y) {
long long _ = 1, x = 2;
for (; y; y >>= 1, x = x * x % p) y& 1 ? _ = _ * x % p : 0;
return _;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++)
scanf("%d %d", &x, &y), a[x].push_back(y), a[y].push_back(x);
dfs(1, 0);
mk(1);
for (scanf("%d", &q); q--;) {
scanf("%d %d", &x, &y);
z = lca(x, y);
printf("%d\n", cal(c[x] + c[y] - 2 * c[z] + c[r[z]] - c[f[r[z]][0]]));
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e3 + 10;
char s[maxn];
int main() {
scanf("%s", s);
int len = strlen(s);
int k = 0, t = 0;
for (int i = 0; i < len; i++) {
if (s[i] == '0') {
if (k)
printf("3 1\n");
else
printf("1 1\n");
k ^= 1;
} else {
printf("%d 3\n", ++t);
if (t == 4) t = 0;
}
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> res[200009];
vector<pair<int, int> > path[200009];
int last[200009];
queue<pair<int, int> > Q;
int main() {
cin >> n;
int a, b;
for (int i = 1; i < n; i++) {
scanf("%d%d", &a, &b);
path[a].push_back({b, i});
path[b].push_back({a, i});
}
a = 0;
int poi = 0;
for (int i = 1; i <= n; i++) {
int sz = path[i].size();
if (sz > poi) {
poi = sz;
a = i;
}
}
Q.push({a, 0});
while (Q.size()) {
a = Q.front().first;
b = Q.front().second;
Q.pop();
int sz = path[a].size();
for (int i = 0; i < sz; i++) {
int aa = path[a][i].first;
int bb = path[a][i].second;
if (aa != b) {
res[last[a]].push_back(bb);
last[a]++;
last[a] %= poi;
last[aa] = last[a];
Q.push({aa, a});
}
}
}
printf("%d\n", poi);
for (int i = 0; i < poi; i++) {
int sz = res[i].size();
printf("%d ", sz);
for (int j = 0; j < sz; j++) printf("%d ", res[i][j]);
printf("\n");
}
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, m;
cin >> n >> m;
vector<string> vs;
for (long long i = 0; i < n; i++) {
string s;
cin >> s;
vs.push_back(s);
}
string first = vs[0];
bool f1 = 1;
long long cnt = 0;
for (long long i = 0; i < m; i++) {
char old = first[i];
for (char c = 'a'; c <= 'z'; c++) {
f1 = 1;
first[i] = c;
for (long long j = 0; j < n; j++) {
cnt = 0;
for (long long k = 0; k < m; k++) {
if (first[k] != vs[j][k]) {
cnt++;
}
if (cnt > 1) {
f1 = 0;
break;
}
}
}
if (f1) {
cout << first << endl;
return;
}
first[i] = old;
}
}
cout << "-1" << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long trials;
cin >> trials;
while (trials--) {
solve();
}
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int N = 100005;
const int mo = 1e9 + 7;
int k, n, m;
int key[N * 4], u;
struct section {
int l, r;
friend bool operator<(section a, section b) {
return a.l != b.l ? a.l < b.l : a.r < b.r;
}
} s1[N], s2[N];
void trs(section *s, int &n) {
if (!n) return;
sort(s + 1, s + 1 + n);
int n_ = 1;
for (int i = 2; i <= n; i++) {
if (s[i].l == s[i - 1].l) continue;
while (n_ && s[n_].r >= s[i].r) n_--;
s[++n_] = s[i];
}
n = n_;
}
int getw(int x) {
int ret = 0, l = 1, r = u;
while (l <= r) {
int mid = (l + r) / 2;
if (key[mid] >= x)
ret = mid, r = mid - 1;
else
l = mid + 1;
}
return ret;
}
int L1[N * 4], L2[N * 4], R1[N * 4], R2[N * 4];
long long f[N * 4], f1[N * 4], f2[N * 4];
long long quickmi(long long x, long long tim) {
long long ans = 1;
for (; tim; tim /= 2, x = x * x % mo)
if (tim & 1) ans = ans * x % mo;
return ans;
}
int main() {
k = get();
n = get();
m = get();
for (int i = 1; i <= n; i++) {
int l = get(), r = get();
key[++u] = l - 1;
key[++u] = r;
s1[i].l = l;
s1[i].r = r;
}
for (int i = 1; i <= m; i++) {
int l = get(), r = get();
key[++u] = l - 1;
key[++u] = r;
s2[i].l = l, s2[i].r = r;
}
sort(key + 1, key + 1 + u);
key[++u] = k;
int u1 = 1;
for (int i = 2; i <= u; i++)
if (key[i] > key[i - 1]) key[++u1] = key[i];
u = u1;
trs(s1, n);
trs(s2, m);
for (int i = 1; i <= n; i++) {
int L = getw(s1[i].l), R = getw(s1[i].r);
L1[R] = L;
R1[L] = R;
}
for (int i = 1; i <= m; i++) {
int L = getw(s2[i].l), R = getw(s2[i].r);
L2[R] = L;
R2[L] = R;
}
f[0] = 1;
for (int i = 1; i <= u; i++) {
f2[i] = f2[i - 1], f1[i] = f1[i - 1];
if (L1[i]) {
long long tmp = (f1[i] + mo - f1[L1[i] - 1] + f[L1[i] - 1]) % mo;
f[i] = (f[i] + mo - tmp) % mo;
f1[i] = (f1[i] + mo - tmp) % mo;
}
if (L2[i]) {
long long tmp = (f2[i] + mo - f2[L2[i] - 1] + f[L2[i] - 1]) % mo;
f[i] = (f[i] + mo - tmp) % mo;
f2[i] = (f2[i] + mo - tmp) % mo;
}
f[i] = (f[i] + f[i - 1] * quickmi(2, key[i] - key[i - 1]) % mo) % mo;
}
printf("%I64d\n", f[u]);
return 0;
}
| 21
|
#include<iostream>
#include<string>
#include<algorithm>
using namespace std;
long long MM = 998244353, ans;
int SA[200010], invSA[200010];
long long N, K;
string S;
long long f()
{
int i;
long long c = 1;
for (i = 0; i <= N; i++) invSA[SA[i]] = i;
for (i = 2; i <= N; i++)
{
if (invSA[SA[i] + 1] < invSA[SA[i - 1] + 1]) c++;
}
return c;
}
long long powmm(long long a, long long b)
{
if (b == 0) return 1;
long long ans = powmm(a, b / 2);
ans = (ans * ans) % MM;
if (b % 2 == 1) ans = (ans * a) % MM;
return ans;
}
int main()
{
int i, c;
cin >> N >> K;
SA[0] = N;
for (i = 1; i <= N; i++) { cin >> SA[i]; }
c = f();
if (c > K) { cout << 0 << endl; return 0; }
ans = 1;
for (i = 1; i <= K - c + N; i++) ans = (ans * i) % MM;
for (i = 1; i <= K - c; i++) ans = (ans * powmm(i, MM - 2)) % MM;
for (i = 1; i <= N; i++) ans = (ans * powmm(i, MM - 2)) % MM;
cout << ans;
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
void func() {
int n, k, tot = 0;
cin >> n >> k;
unordered_map<long long, vector<long long>> m;
unordered_map<long long, long long> mc;
long long a[n], ans[n];
fill(ans, ans + n, -1);
m.clear();
mc.clear();
for (int i = 0; i < n; i++) {
cin >> a[i];
m[a[i]].push_back(i);
}
for (auto &pr : m) {
if (pr.second.size() <= k)
tot += pr.second.size();
else
tot += k;
}
for (int i = 0; i < k; i++) {
mc[i + 1] = tot / k;
}
long long index = 1;
long long temp;
for (auto &pr : m) {
if (pr.second.size() > k) {
for (int i = 0; i < k; i++) {
temp = 0;
while (mc[index] == 0) {
index++;
temp++;
if (index > k) index = 1;
if (temp == k) break;
}
if (temp == k) break;
ans[pr.second[i]] = index;
mc[index]--;
index++;
if (index > k) index = 1;
}
} else {
for (int i = 0; i < pr.second.size(); i++) {
temp = 0;
while (mc[index] == 0) {
index++;
temp++;
if (index > k) index = 1;
if (temp == k) break;
}
if (temp == k) break;
ans[pr.second[i]] = index;
mc[index]--;
index++;
if (index > k) index = 1;
}
}
if (temp == k) break;
}
for (int i = 0; i < n; i++) {
if (ans[i] == -1) ans[i] = 0;
cout << ans[i] << " ";
}
cout << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
func();
}
}
| 6
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("sse4")
#pragma GCC optimize("unroll-loops")
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
vector<int> v;
int n, l = 0, i, k, pre;
cin >> n;
for (i = 1; i <= n; i++) v.push_back(i);
for (k = 2; k <= n; k++, l++) {
v.emplace_back();
pre = v[l];
for (i = l; i < (int)v.size() - 1; i += k)
swap(pre, v[min((int)v.size() - 1, i + k)]);
}
for (i = l; i < (int)v.size(); i++) cout << v[i] << " ";
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long temp;
cin >> temp;
long long inc = temp / 3ll;
long long rem = temp % 3ll;
if (rem == 2) inc++;
long long fit = inc / 12ll;
rem = inc % 12ll;
cout << fit << " " << rem << endl;
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int count = 0;
while (n > 0) {
count += n;
n /= 2;
}
cout << count << "\n";
}
}
| 6
|
#include <bits/stdc++.h>
#pragma GCC optimize(2)
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char op = getchar();
int F = 1;
while (!isdigit(op)) {
if (op == '-') F *= -1;
op = getchar();
}
while (isdigit(op)) {
x = (x << 1) + (x << 3) + op - '0';
op = getchar();
}
x *= F;
}
template <typename T, typename... Args>
void read(T &x, Args &...args) {
read(x);
read(args...);
}
template <typename T1, typename T2>
void ckmax(T1 &x, T2 y) {
if (x < y) x = y;
}
template <typename T1, typename T2>
void ckmin(T1 &x, T2 y) {
if (x > y) x = y;
}
string s;
char c;
int main() {
cin >> s;
for (auto v : s) {
for (; c != v; c--) {
puts("..");
puts("X.");
}
puts("X.");
}
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500005;
long long f[maxn], a[maxn], b[maxn], s[maxn];
struct Linear_basis {
long long p[70];
int cnt, flag;
void init() {
memset(p, 0, sizeof(p));
cnt = 0;
flag = 1;
}
void Insert(long long x) {
for (int i = 63; i >= 0; i--) {
if ((x >> i) & 1) {
if (!p[i]) {
p[i] = x;
break;
}
x ^= p[i];
}
}
if (x > 0)
cnt++;
else if (x == 0)
flag = 0;
}
long long check(long long x) {
for (int i = 63; i >= 0; i--) {
if ((x >> i) & 1) {
x ^= p[i];
}
}
return x;
}
} sol;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", &a[i], &b[i]);
f[i] = a[i] ^ b[i];
sol.Insert(f[i]);
}
for (int i = 1; i <= n; i++) s[i] = s[i - 1] ^ a[i];
if (sol.check(s[n]))
printf("1/1\n");
else {
long long ans = 1ll << sol.cnt;
printf("%lld/%lld\n", ans - 1ll, ans);
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const double err = 1e-10;
const double PI = 3.141592653589793;
const int N = 1e5 + 5;
void solve() {
int n, k;
cin >> n >> k;
vector<int> Q(n), second(n);
for (int i = 0; i < n; i++) cin >> Q[i];
for (int i = 0; i < n; i++) cin >> second[i];
vector<int> adj1(n), adj2(n);
for (int i = 0; i < n; i++) {
adj1[Q[i] - 1] = i;
adj2[i] = Q[i] - 1;
}
vector<int> v1(n), v2(n);
iota((v1).begin(), (v1).end(), 1);
iota((v2).begin(), (v2).end(), 1);
int mn1 = 200, mn2 = 200;
for (int i = 0; i <= k; i++) {
bool f1 = 1, f2 = 1;
for (int j = 0; j < n; j++) {
if (v1[j] != second[j]) f1 = 0;
if (v2[j] != second[j]) f2 = 0;
}
if (f1) mn1 = min(mn1, i);
if (f2) mn2 = min(mn2, i);
vector<int> nwv1(n), nwv2(n);
for (int i = 0; i < n; i++) {
nwv1[adj1[i]] = v1[i];
nwv2[adj2[i]] = v2[i];
}
v1 = nwv1;
v2 = nwv2;
}
if (min(mn1, mn2) == 0 || min(mn1, mn2) == 200)
cout << "NO\n";
else if (mn1 == k || mn2 == k)
cout << "YES\n";
else if (mn1 <= k && (k - mn1) % 2 == 0 && (mn2 >= 2 || mn1 >= 2))
cout << "YES\n";
else if (mn2 <= k && (k - mn2) % 2 == 0 && (mn2 >= 2 || mn1 >= 2))
cout << "YES\n";
else
cout << "NO\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int T = 1;
while (T--) solve();
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int a[1123456], cnt[1123456], lcm[1123456];
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (a[i] <= m) cnt[a[i]]++;
}
for (int i = 1; i <= m; ++i) {
for (int j = i; j <= m; j += i) {
lcm[j] += cnt[i];
}
}
int lc = 1, num = 0;
for (int i = 1; i <= m; ++i) {
if (lcm[i] > num) {
num = lcm[i];
lc = i;
}
}
cout << lc << " " << num << endl;
for (int i = 1; i <= n; ++i) {
if (lc % a[i] == 0) cout << i << " ";
}
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
struct rnxt {
template <class T>
operator T() {
T t;
cin >> t;
return t;
}
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int len = rnxt();
vector<int> masks;
for (int m = (1 << 7) - 1; m < (1 << 13); ++m) {
if (__builtin_popcount(m) == 7) {
masks.push_back(m);
}
if (masks.size() == len) {
break;
}
}
vector<vector<int>> queries(13);
for (int i = 0; i < len; ++i) {
for (int b = 0; b < 13; ++b) {
if (((1 << b) & masks[i]) != 0) {
queries[b].push_back(i);
}
}
}
vector<int64_t> ans(13, 0);
for (int q = 0; q < 13; ++q) {
if (not queries[q].empty()) {
cout << "? " << queries[q].size();
for (auto&& e : queries[q]) {
cout << ' ' << e + 1;
}
cout << endl;
cin >> ans[q];
}
}
vector<int64_t> res(len, 0);
for (int i = 0; i < len; ++i) {
for (int b = 0; b < 13; ++b) {
if (((1 << b) & masks[i]) == 0) {
res[i] |= ans[b];
}
}
}
cout << "!";
for (auto&& e : res) {
cout << ' ' << e;
}
cout << endl;
return 0;
}
| 20
|
#include <bits/stdc++.h>
using namespace std;
static const double EPS = 1e-5;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
double acc[10000];
int main() {
int n, k;
cin >> n >> k;
for (int i = 0; i < (int)n; ++i) cin >> acc[i];
double l = 0, r = 1000;
while (abs(r - l) > 0.0000001) {
double mid = (r + l) / 2;
double dec = 0, inc = 0;
for (int i = 0; i < (int)n; ++i) {
if (acc[i] > mid)
dec += acc[i] - mid;
else
inc += mid - acc[i];
}
if (100 * inc > (100 - k) * dec)
r = mid;
else
l = mid;
}
printf("%.8f\n", l);
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
const double eps = 1e-8;
const int inf = 1e9 + 7;
int a, b, c;
int n;
int x[maxn];
int main() {
cin >> a >> b >> c >> n;
int s = 0;
for (int i = 0; i < n; i++) {
cin >> x[i];
if (x[i] > b && x[i] < c) s++;
}
cout << s << endl;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
int arr[1010];
int dp[1010];
int n;
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> arr[i];
}
arr[0] = 0;
for (int i = 2; i <= n; ++i) {
arr[i] = min(max(arr[i - 1], arr[i - 2]), arr[i]);
}
cout << arr[n] << endl;
return 0;
}
| 3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
int res = 0;
while (n) {
if (n % 8 == 1) res++;
n /= 8;
}
cout << res << endl;
return 0;
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
T pow_mod(T a, U b, int mod) {
T r = 1;
for (; b > 0; b >>= 1) {
if (b & 1) r = (long long)r * a % mod;
a = (long long)a * a % mod;
}
return r;
}
namespace multihash {
const int D = 2, N = 25;
array<int, D> B[N], iB[N], M, Z;
array<int, D> operator+(array<int, D> lhs, const array<int, D> &rhs) {
for (int i = 0; i < D; ++i) {
lhs[i] += rhs[i];
if (lhs[i] >= M[i]) lhs[i] -= M[i];
}
return lhs;
}
array<int, D> operator-(array<int, D> lhs, const array<int, D> &rhs) {
for (int i = 0; i < D; ++i) {
lhs[i] -= rhs[i];
if (lhs[i] < 0) lhs[i] += M[i];
}
return lhs;
}
array<int, D> operator*(array<int, D> lhs, const array<int, D> &rhs) {
for (int i = 0; i < D; ++i) lhs[i] = (long long)lhs[i] * rhs[i] % M[i];
return lhs;
}
array<int, D> pow(array<int, D> lhs, long long b) {
array<int, D> x;
x.fill(1);
for (; b > 0; b >>= 1) {
if (b & 1) x = x * lhs;
lhs = lhs * lhs;
}
return x;
}
array<int, D> inv(array<int, D> lhs) {
for (int i = 0; i < D; ++i) lhs[i] = pow_mod(lhs[i], M[i] - 2, M[i]);
return lhs;
}
array<int, D> to_mhash(int x) {
array<int, D> m;
m.fill(x);
for (int i = 0; i < D; ++i) m[i] %= M[i];
return m;
}
void init(const array<int, D> &b, const array<int, D> &m) {
M = m, B[1] = b, iB[1] = inv(b), Z.fill(0), B[0].fill(1), iB[0].fill(1);
for (int i = 2; i < N; ++i) {
B[i] = B[i - 1] * B[1];
iB[i] = iB[i - 1] * iB[1];
}
}
} // namespace multihash
namespace merkle_tree {
using namespace multihash;
int solve(const vector<vector<int>> &adj) {
int n = adj.size();
vector<pair<int, bool>> d(n);
vector<int> mask(n);
vector<array<int, D>> h(n);
for (auto &i : mask) i = rand();
auto f = [&](int u, int p) {
h[u].fill(1);
for (auto v : adj[u])
if (v != p) h[u] = h[u] * (h[v] + to_mhash(mask[d[u].first]));
};
auto g = [&](int u, int p) {
d[u].first = 0, d[u].second = false;
for (auto v : adj[u])
if (v != p) {
if (d[v].first + 1 > d[u].first)
d[u].first = d[v].first + 1, d[u].second = true;
else if (d[v].first + 1 == d[u].first)
d[u].second = false;
}
};
function<void(int, int)> dfs1 = [&](int u, int p) {
for (auto v : adj[u])
if (v != p) dfs1(v, u);
g(u, p);
f(u, p);
};
dfs1(0, -1);
auto z = [&](array<int, D> x) { return (long long)x[0] << 32 | x[1]; };
map<long long, int> mp;
for (int u = 0; u < n; ++u) ++mp[z(h[u])];
int cnt = mp.size(), best = 0, node;
auto update = [&](array<int, D> u, int c) {
long long x = z(u);
cnt -= mp[x] > 0;
mp[x] += c;
cnt += mp[x] > 0;
};
function<void(int, int)> dfs2 = [&](int u, int p) {
if (cnt > best) best = cnt, node = u;
for (auto v : adj[u])
if (v != p) {
update(h[v], -1);
update(h[u], -1);
auto du = d[u];
auto dv = d[v];
array<int, D> hu = h[u];
array<int, D> hv = h[v];
if (d[u].first == d[v].first + 1 && d[u].second)
g(u, v), f(u, v);
else
h[u] = h[u] * inv(h[v] + to_mhash(mask[d[u].first]));
if (d[u].first + 1 > d[v].first)
d[v].first = d[u].first + 1, d[v].second = true;
else if (d[u].first + 1 == d[v].first)
d[v].second = false;
f(v, -1);
update(h[v], +1);
update(h[u], +1);
dfs2(v, u);
update(h[v], -1);
update(h[u], -1);
d[u] = du;
d[v] = dv;
h[u] = hu;
h[v] = hv;
update(h[v], +1);
update(h[u], +1);
}
};
dfs2(0, -1);
return node;
}
} // namespace merkle_tree
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
multihash::init({13, 47}, {(int)1e9 + 7, (int)1e9 + 9});
int n;
cin >> n;
vector<vector<int>> adj(n);
for (int i = 1, u, v; i < n; ++i) {
cin >> u >> v;
--u, --v;
adj[u].push_back(v);
adj[v].push_back(u);
}
cout << merkle_tree::solve(adj) + 1 << "\n";
return 0;
}
| 21
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int N, D;
cin >> N >> D;
vector<int> V;
for (int i = 0; i < N; i++) {
int X;
cin >> X;
V.push_back(X);
}
sort(V.begin(), V.end());
int Ans = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (i != j) {
if (abs(V[i] - V[j]) <= D) Ans++;
}
}
}
cout << Ans << endl;
return 0;
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
int DP[1010][4];
int A[] = {
1, 0, 3, 1, 4, 2, 5, 1, 7, 2,
9, 0, 13, 1, 15, 2, 19, 0, 27, 1,
39, 2, 40, 0, 57, 2, 58, 1, 81, 2,
85, 0, 120, 2, 121, 1, 174, 2, 179, 0,
255, 2, 260, 1, 363, 2, 382, 0, 537, 2,
544, 1, 780, 2, 805, 0, 1146, 2, 1169, 1,
1632, 2, 1718, 0, 2415, 2, 2447, 1, 3507, 2,
3622, 0, 5154, 2, 5260, 1, 7341, 2, 7730, 0,
10866, 2, 11011, 1, 15780, 2, 16298, 0, 23190, 2,
23669, 1, 33033, 2, 34784, 0, 48894, 2, 49549, 1,
71007, 2, 73340, 0, 104352, 2, 106510, 1, 148647, 2,
156527, 0, 220020, 2, 222970, 1, 319530, 2, 330029, 0,
469581, 2, 479294, 1, 668910, 2, 704371, 0, 990087, 2,
1003364, 1, 1437882, 2, 1485130, 0, 2113113, 2, 2156822, 1,
3010092, 2, 3169669, 0, 4455390, 2, 4515137, 1, 6470466, 2,
6683084, 0, 9509007, 2, 9705698, 1, 13545411, 2, 14263510, 0,
20049252, 2, 20318116, 1, 29117094, 2, 30073877, 0, 42790530, 2,
43675640, 1, 60954348, 2, 64185794, 0, 90221631, 2, 91431521, 1,
131026920, 2, 135332446, 0, 192557382, 2, 196540379, 1, 274294563, 2,
288836072, 0, 405997338, 2, 411441844, 1, 589621137, 2, 608996006, 0,
866508216, 2, 884431705, 1, 1000000001, -1,
};
int addm(int x, int y) {
x += y;
if (x >= 1000000007) x -= 1000000007;
return x;
}
int main() {
int N, P;
cin >> N >> P;
P--;
int num[4] = {0};
for (int i = 0; A[i] <= P; i += 2) {
int mx = min(P, A[i + 2] - 1);
num[A[i + 1]] =
addm(num[A[i + 1]], (1ll * (P - A[i] + 1) * (P - A[i] + 2) / 2 -
1ll * (P - mx) * (P - mx + 1) / 2) %
1000000007);
}
DP[0][0] = 1;
for (int i = 1; i <= N; i++) {
for (int j = 0; j < 4; j++) {
for (int k = 0; k < 4; k++) {
DP[i][j ^ k] =
addm(DP[i][j ^ k], (1ll * DP[i - 1][j] * num[k]) % 1000000007);
}
}
}
cout << addm(DP[N][1], addm(DP[N][2], DP[N][3])) << endl;
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
const int L = 100100;
const int LEN = 35;
const int R = 6;
const long long MAXN = 100001000010000ll;
int n, m, p;
int a[L][R], b[L][R];
long long f[2][LEN];
void init(void) {
cin >> n >> m;
int i, j;
for (i = 1; i < m; i++)
for (j = 0; j < n; j++) scanf("%d", &a[i][j]);
for (i = 0; i < m; i++)
for (j = 0; j < n; j++) scanf("%d", &b[i][j]);
p = 1 << n;
}
void update(long long &x, long long y) {
if (y < x) x = y;
}
void work(void) {
int now = 0, i, j, k, r;
long long tmp;
for (j = 1; j < p; j++) f[now][j] = MAXN;
for (i = 1; i < m; i++)
for (j = 0; j < n; j++) {
now ^= 1;
for (r = 0; r < p; r++) f[now][r] = MAXN;
for (r = 0; r < p; r++)
for (k = 0; k < 2; k++) {
tmp = 0;
if (k ^ ((r & (1 << j)) > 0)) tmp += a[i][j];
if (j && (k ^ ((r & (1 << j - 1)) > 0))) tmp += b[i][j - 1];
if (j == n - 1 && (k ^ ((r & 1) > 0))) tmp += b[i][n - 1];
update(f[now][(r & (~(1 << j))) | (k << j)], f[now ^ 1][r] + tmp);
}
}
cout << f[now][(1 << n) - 1] << endl;
}
int main(void) {
init();
work();
return 0;
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
namespace io {
template <typename Test, template <typename...> class Ref>
struct is_specialization : std::false_type {};
template <template <typename...> class Ref, typename... Args>
struct is_specialization<Ref<Args...>, Ref> : std::true_type {};
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void setIO(string s = "") {
ios_base::sync_with_stdio(0);
cin.tie(0);
if ((int)(s).size()) {
setIn(s + ".in"), setOut(s + ".out");
}
}
void re(double& x) {
string t;
cin >> t;
x = stod(t);
}
void re(long double& x) {
string t;
cin >> t;
x = stold(t);
}
template <class T>
void re(T& x) {
cin >> x;
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
re(first);
re(rest...);
}
template <class T1, class T2>
istream& operator>>(istream& is, pair<T1, T2>& p) {
is >> p.first >> p.second;
return is;
}
template <class T>
istream& operator>>(istream& is, vector<T>& a) {
for (auto i = (0) - ((0) > ((int)(a).size()));
i != ((int)(a).size()) - ((0) > ((int)(a).size()));
i += 1 - 2 * ((0) > ((int)(a).size())))
is >> a[i];
return is;
}
template <class T>
void pr(const T& x) {
cout << x << '\n';
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
cout << first << ' ';
pr(rest...);
}
template <class T1, class T2>
ostream& operator<<(ostream& os, const pair<T1, T2>& a) {
os << '{' << a.first << ", " << a.second << '}';
return os;
}
template <class K, class V>
ostream& operator<<(ostream& os, const map<K, V>& m) {
os << '{';
for (auto it = (m.begin()); (it) != (m.end()); (it)++) {
os << ", "[it == m.begin()] << *it;
}
os << " }";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const set<T>& s) {
os << '{';
for (auto it = (s.begin()); (it) != (s.end()); (it)++) {
os << ", "[it == s.begin()] << *it;
}
os << " }";
return os;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& a) {
os << '[';
for (auto i = (0) - ((0) > ((int)(a).size()));
i != ((int)(a).size()) - ((0) > ((int)(a).size()));
i += 1 - 2 * ((0) > ((int)(a).size()))) {
if (i) {
os << ", ";
if (is_specialization<T, vector>::value) os << '\n';
}
os << a[i];
}
os << ']';
return os;
}
} // namespace io
using namespace io;
inline void prep() {
ios::sync_with_stdio(0);
cin.tie(0);
}
void solve();
int main() {
prep();
int t = 1;
while (t--) {
solve();
}
return 0;
}
const int MOD = 1000000007;
const int MX = 101;
const double INF = 1e10;
void solve() {
int n, k;
re(n, k);
if (k == 1 || k == n)
pr(n * 3);
else
pr(n * 3 + min(n - k, k - 1));
}
| 2
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
using ll = long long;
using pii = pair<int, int>;
const int MOD = 1e9 + 7;
const int dx[] = {0, 0, 1, -1};
const int dy[] = {1, -1, 0, 0};
const char dir[] = {'R', 'L', 'D', 'U'};
ll add(ll a, ll b) {
a += b;
if (a >= MOD) {
a -= MOD;
}
return a;
}
int sub(int a, int b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
int mult(int a, int b) { return ((ll)a * b) % MOD; }
void setIO() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
int a, b, n;
int get(int groups) {
if (a < groups || b < groups) return 0;
int l = n / (groups + 1) + 1;
int r = n / groups;
int alo = (a + groups) / (groups + 1);
int ahi = a / groups;
int blo = (b + groups) / (groups + 1);
int bhi = b / groups;
if (alo <= ahi && blo <= bhi) {
return max(0, min(r, ahi + bhi) - max(l, alo + blo) + 1);
}
return 0;
}
int main() {
setIO();
cin >> a >> b;
n = a + b;
int ans = 0;
for (int groups = 1; groups * groups <= n; ++groups) {
ans += get(groups);
if (n / groups != groups) {
ans += get(n / groups);
}
}
cout << ans << "\n";
}
| 19
|
#include <bits/stdc++.h>
using namespace std;
long long N;
map<pair<long long, int>, pair<long long, int> > F;
pair<long long, int> dfs(long long x, int y) {
long long p = 1;
pair<long long, int> a, b, res;
if (!x) return res;
if (x < 10) return make_pair(1, max(y - x, 0ll));
if (F.count(b = make_pair(x, y))) return F[b];
for (; p <= x / 10; p *= 10)
;
for (long long t; x > 0;) {
a = dfs(x % p, t = max(1ll * y, x / p)), res.first += a.first,
x -= x % p + a.second;
if (!a.second && t) x -= t, res.first++;
}
res.second = -x;
return F[b] = res;
}
int main() {
scanf("%I64d", &N);
printf("%I64d\n", dfs(N, 0).first);
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, c, d;
cin >> a >> b >> c >> d;
int as, bs, cs, ds;
as = a.size() - 2;
bs = b.size() - 2;
cs = c.size() - 2;
ds = d.size() - 2;
int ba, bb, bc, bd;
ba = 0;
bb = 0;
bc = 0;
bd = 0;
if ((as >= bs * 2 && as >= cs * 2 && as >= ds * 2) ||
(as <= bs / 2 && as <= cs / 2 && as <= ds / 2))
ba = 1;
if ((bs >= as * 2 && bs >= cs * 2 && bs >= ds * 2) ||
(bs <= as / 2 && bs <= cs / 2 && bs <= ds / 2))
bb = 1;
if ((cs >= bs * 2 && cs >= ds * 2 && cs >= as * 2) ||
(cs <= bs / 2 && cs <= ds / 2 && cs <= as / 2))
bc = 1;
if ((ds >= bs * 2 && ds >= cs * 2 && ds >= as * 2) ||
(ds <= bs / 2 && ds <= cs / 2 && ds <= as / 2))
bd = 1;
if (ba + bb + bd + bc != 1 || (ba + bb + bc + bd == 1 && bc == 1)) {
cout << "C";
return 0;
} else if (ba == 1)
cout << "A";
else if (bb == 1)
cout << "B";
else if (bd == 1)
cout << "D";
return 0;
}
| 5
|
#include <bits/stdc++.h>
const int BUFFER_SIZE = 1 << 25 | 1;
struct InputOutputStream {
char ibuf[BUFFER_SIZE], *s;
InputOutputStream() : s(ibuf) {
ibuf[fread(ibuf, 1, BUFFER_SIZE, stdin)] = '\0';
}
template <typename T>
inline InputOutputStream &operator>>(T &x) {
while (!isdigit(*s)) ++s;
for (x = 0; isdigit(*s); ++s) x = x * 10 + (*s ^ '0');
return *this;
}
} IO;
template <typename lhs, typename rhs>
inline lhs min(const lhs &x, const rhs &y) {
return x < y ? x : y;
}
template <typename lhs, typename rhs>
inline lhs max(const lhs &x, const rhs &y) {
return x > y ? x : y;
}
const int N_MAX = 100003, T_MAX = 400003;
double val[N_MAX];
struct SegmentTree {
struct Data {
double prod, sum;
Data() : prod(1), sum(0) {}
Data(double prod, double sum) : prod(prod), sum(sum) {}
void operator+=(const Data &rhs) {
sum += prod * rhs.sum, prod *= rhs.prod;
}
friend Data operator+(Data lhs, const Data &rhs) {
lhs += rhs;
return lhs;
}
} node[T_MAX];
void build(int k, int l, int r) {
if (l == r) {
node[k] = Data(val[l], val[l]);
return;
}
build((k << 1), l, ((l + r) >> 1)),
build((k << 1 | 1), ((l + r) >> 1) + 1, r);
node[k] = node[(k << 1)] + node[(k << 1 | 1)];
}
void modify(int k, int l, int r, int x, double v) {
if (l == r) {
node[k] = Data(v, v);
return;
}
x <= ((l + r) >> 1) ? modify((k << 1), l, ((l + r) >> 1), x, v)
: modify((k << 1 | 1), ((l + r) >> 1) + 1, r, x, v);
node[k] = node[(k << 1)] + node[(k << 1 | 1)];
}
Data query(int k, int l, int r, int x, int y) {
if (x <= l && r <= y) return node[k];
Data o;
if (x <= ((l + r) >> 1)) o += query((k << 1), l, ((l + r) >> 1), x, y);
if (((l + r) >> 1) < y)
o += query((k << 1 | 1), ((l + r) >> 1) + 1, r, x, y);
return o;
}
} tree;
int main() {
int n, Q;
IO >> n >> Q;
for (int i = 1; i <= n; ++i) {
int a, b;
IO >> a >> b;
double p = (double)a / b;
val[i] = (1 - p) / p;
}
tree.build(1, 1, n);
for (int i = 1; i <= Q; ++i) {
int type;
IO >> type;
if (type == 1) {
int x, a, b;
IO >> x >> a >> b;
double p = (double)a / b;
tree.modify(1, 1, n, x, (1 - p) / p);
} else {
int l, r;
IO >> l >> r;
printf("%.10lf\n", (double)1 / (tree.query(1, 1, n, l, r).sum + 1));
}
}
return 0;
}
| 17
|
#include <bits/stdc++.h>
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
inline long long qmul(long long a, long long b, long long m) {
long long res = 0;
while (b) {
if (b & 1) res = (res + a) % m;
a = (a << 1) % m;
b = b >> 1;
}
return res;
}
inline long long qpow(long long a, long long b, long long m) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b = b >> 1;
}
return res;
}
inline long long inv(long long x, long long q) { return qpow(x, q - 2, q); }
using namespace std;
const int N = 300;
const int M = 1e4 + 10;
int dis[N];
struct edge {
int np, f, ne;
};
edge ed[M];
int head[N];
int si;
void add(int u, int v, int f) {
ed[si] = edge{v, f, head[u]};
head[u] = si;
si++;
}
bool bfs(int s, int tar) {
memset(dis, 0, sizeof dis);
queue<int> q;
q.push(s);
dis[s] = 1;
while (!q.empty()) {
int cur = q.front();
q.pop();
for (int i = head[cur]; i; i = ed[i].ne) {
int np = ed[i].np;
if (!dis[np] && ed[i].f) {
dis[np] = dis[cur] + 1;
q.push(np);
}
}
}
return dis[tar];
}
int dfs(int p, int flo, int tar) {
if (p == tar) return flo;
int delta = flo;
for (int i = head[p]; i; i = ed[i].ne) {
int np = ed[i].np;
if (dis[p] + 1 == dis[np] && (ed[i].f)) {
int d = dfs(np, min(delta, ed[i].f), tar);
ed[i].f -= d;
ed[i ^ 1].f += d;
delta -= d;
}
if (delta == 0) break;
}
return flo - delta;
}
int dini(int n) {
int ans = 0;
while (bfs(1, n)) {
ans += dfs(1, 0x3f3f3f3, n);
}
return ans;
}
bool ex[N];
struct node {
int p, c, l;
};
bool cmp(const node& a, const node& b) { return a.l < b.l; }
node arr[N];
bool is_not_prime[500000];
long long build(int n, int num) {
long long tot = 0;
si = 2;
memset(head, 0, sizeof head);
bool exo = false;
int onep = 0;
int cnt = 2;
for (int i = 1; i <= n; i++) {
if (arr[i].c % 2) {
if (arr[i].c == 1) {
onep = max(onep, arr[i].p);
exo = true;
continue;
} else {
tot += arr[i].p;
add(1, cnt, arr[i].p);
add(cnt, 1, 0);
}
} else {
tot += arr[i].p;
add(cnt, num + 2, arr[i].p);
add(num + 2, cnt, 0);
}
cnt++;
}
add(1, cnt, onep);
add(cnt, 1, 0);
tot += onep;
int p1 = 2;
for (int i = 1; i <= n; i++) {
if (arr[i].c == 1) continue;
int p2 = 2;
for (int j = 1; j <= n; j++) {
if (arr[j].c == 1) continue;
if (j > i) {
if (!is_not_prime[arr[i].c + arr[j].c]) {
int tp1 = p1, tp2 = p2;
if (arr[j].c % 2) swap(tp1, tp2);
add(tp1, tp2, 0x3f3f3f3);
add(tp2, tp1, 0);
}
}
p2++;
}
p1++;
}
if (exo) {
int p = 2;
for (int i = 1; i <= n; i++) {
if (arr[i].c == 1) continue;
if (!is_not_prime[arr[i].c + 1]) {
add(cnt, p, 0x3f3f3f3);
add(p, cnt, 0);
}
p++;
}
}
return tot;
}
void init() {
for (int i = 2; i < 500000; i++) {
if (is_not_prime[i]) continue;
for (int j = 2 * i; j < 500000; j += i) {
is_not_prime[j] = true;
}
}
}
int main() {
std::ios::sync_with_stdio(0);
init();
int n, k;
cin >> n >> k;
int cnt = 0;
for (int i = 1; i <= n; i++) {
int p, l, c;
cin >> p >> c >> l;
arr[i] = node{p, c, l};
}
sort(arr + 1, arr + n + 1, cmp);
int l = 1, r = n;
while (l <= r) {
int mid = (l + r) / 2;
int tot = build(mid, n);
if (tot - dini(n + 2) >= k)
r = mid - 1;
else
l = mid + 1;
}
if (l > n)
cout << -1 << endl;
else
cout << arr[l].l << endl;
}
| 16
|
#include <bits/stdc++.h>
const int MAXN = 55;
const int d[4][2] = {{-1, 0}, {0, -1}, {0, 1}, {1, 0}};
int n, m;
char map[MAXN][MAXN];
int last[MAXN][MAXN];
bool vis[MAXN][MAXN];
bool BFS(int x0, int y0) {
static int que[MAXN * MAXN][2];
char color = map[x0][y0];
int x, y;
memset(vis, 0, sizeof(vis));
que[0][0] = x0;
que[0][1] = y0;
vis[x0][y0] = true;
for (int l = 0, r = 1; l < r; ++l) {
x0 = que[l][0];
y0 = que[l][1];
for (int i = 0; i < 4; ++i) {
x = x0 + d[i][0];
y = y0 + d[i][1];
if (map[x][y] == color) {
if (!vis[x][y]) {
vis[x][y] = true;
last[x][y] = i;
que[r][0] = x;
que[r][1] = y;
++r;
} else if (i + last[x0][y0] != 3)
return true;
}
}
}
return false;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) scanf("%s", map[i] + 1);
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (!vis[i][j] && BFS(i, j)) {
puts("Yes");
return 0;
}
puts("No");
return 0;
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int ts;
cin >> ts;
while (ts--) {
int n;
cin >> n;
if (n % 4 == 0)
printf("YES\n");
else
printf("NO\n");
}
}
| 0
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e5 + 5;
vector<int> E[MAXN], rev[MAXN];
int n, d[MAXN], sol[MAXN];
void solve() {
for (int i = 0; i < n + 1; ++i) {
d[i] = 0;
E[i].clear();
rev[i].clear();
sol[i] = 0;
}
priority_queue<int> kju;
bool done = false;
cin >> n;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
if (x == -1)
x = i + 1;
else
x--;
while (!kju.empty() && -kju.top() <= i) kju.pop();
if (!kju.empty() && -kju.top() < x) done = true;
d[x]++;
E[i].push_back(x);
kju.push(-x);
}
if (done) {
cout << -1 << "\n";
return;
}
priority_queue<pair<int, int> > Q;
for (int i = 0; i < n; ++i)
if (d[i] == 0) {
Q.push(pair<int, int>(-E[i][0], i));
}
int cnt = 1;
while (!Q.empty()) {
pair<int, int> tmp = Q.top();
Q.pop();
int to = -tmp.first, from = tmp.second;
if (sol[from]) continue;
sol[from] = cnt++;
for (auto e : E[to]) {
d[e]--;
if (d[e] == 0) {
for (auto z : rev[e]) {
if (z == to) continue;
Q.push(pair<int, int>(-e, z));
}
}
Q.push(pair<int, int>(-e, to));
}
}
for (int i = 0; i < n; ++i) cout << sol[i] << " ";
cout << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) solve();
}
| 13
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int arr[100005];
vector<int> col[100005];
vector<int> edgeList[100005];
int Qard[100005];
map<int, bool> used;
int BestCol = -1;
int rep = -1;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d", &arr[i]), col[arr[i]].push_back(i);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
edgeList[u].push_back(v);
edgeList[v].push_back(u);
}
for (int i = 1; i <= 1e5; i++) {
if (col[i].size() == 0) continue;
set<int> f;
for (int j = 0; j < col[i].size(); j++) {
int Vertex = col[i][j];
for (int k = 0; k < edgeList[Vertex].size(); k++) {
int it = edgeList[Vertex][k];
if (arr[it] == i) continue;
f.insert(arr[it]);
}
}
int k = f.size();
if (k > rep) {
rep = k;
BestCol = i;
}
}
cout << BestCol;
return 0;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
signed main() {
int n;
cin >> n;
vector<int> h(n), s(n);
for (int i = 0; i < n; i++) cin >> h[i], s[i] = h[i];
unordered_multiset<int> req, avail;
int ans = 0;
int premax[n];
int sufmin[n];
premax[0] = h[0];
for (int i = 1; i < n; i++) {
premax[i] = max(premax[i - 1], h[i]);
}
sufmin[n - 1] = h[n - 1];
for (int i = n - 2; i >= 0; i--) {
sufmin[i] = min(sufmin[i + 1], h[i]);
}
for (int i = 0; i < n - 1; i++) {
ans += (premax[i] <= sufmin[i + 1]);
}
cout << ans + 1;
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
int P[200050][20], level[200050];
int n, a = 1, b = 2;
vector<int> edge[200050];
void init(int at, int par) {
level[at] = level[par] + 1;
P[at][0] = par;
for (int i = 1; i < 19; i++) {
P[at][i] = P[P[at][i - 1]][i - 1];
}
}
int lca(int x, int y) {
if (level[x] < level[y]) swap(x, y);
for (int i = 19; i >= 0; i--) {
if (level[x] - (1 << i) >= level[y]) {
x = P[x][i];
}
}
if (x == y) return x;
for (int i = 19; i >= 0; i--) {
if (P[x][i] != P[y][i]) {
x = P[x][i];
y = P[y][i];
}
}
return P[x][0];
}
int dist(int x, int y) { return level[x] + level[y] - level[lca(x, y)] * 2; }
int solve(int at) {
int r1 = dist(a, b);
int r2 = dist(a, at);
int r3 = dist(b, at);
int ret = max(r1, max(r2, r3));
if (r2 == ret) {
a = a;
b = at;
} else if (r3 == ret) {
a = b;
b = at;
}
return ret;
}
int main() {
int x, y;
scanf("%d", &n);
scanf("%d", &x);
init(2, x);
printf("1");
for (int i = 3; i <= n; i++) {
scanf("%d", &x);
init(i, x);
printf(" %d", solve(i));
}
printf("\n");
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
int a, b, l;
inline double sgn(double x) { return fabs(x) < eps ? 0 : x > 0 ? 1 : -1; }
double solve(double x, double w) {
double o, p, q;
if (sgn(x) == 0)
o = 1, p = 0, q = 0;
else if (sgn(x - asin(1)) > 0)
o = 0, p = 1, q = 0;
else
o = -tan(x), p = -1, q = l * sin(x) + w / cos(x);
return -(o * a + p * b + q) / sqrt(o * o + p * p);
}
double calc(double w) {
double x, y, s(0), e(asin(1));
while (sgn(e - s) > 0) {
x = s + (e - s) / 3;
y = e - (e - s) / 3;
if (solve(x, w) < solve(y, w))
e = y;
else
s = x;
}
return solve(s, w);
}
int main() {
cin >> a >> b >> l;
if (a > b) swap(a, b);
cout.setf(ios::fixed);
if (l <= a)
cout << setprecision(7) << l << endl;
else if (l <= b)
cout << setprecision(7) << a << endl;
else {
double s = 0, e = a, mi;
while (sgn(e - s) > 0) {
mi = (s + e) / 2;
if (sgn(calc(mi)) < 0)
e = mi;
else
s = mi;
}
if (sgn(calc(s)) < 0)
cout << "My poor head =(" << endl;
else
cout << setprecision(7) << s << endl;
}
return 0;
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
const double eps = 1e-7;
int n, k;
struct node {
long long a, b, d;
} a[maxn];
bool cmp(node& a, node& b) { return a.d < b.d; }
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].a);
}
for (int i = 0; i < n; i++) {
scanf("%d", &a[i].b);
}
for (int i = 0; i < n; i++) {
a[i].d = a[i].a - a[i].b;
}
sort(a, a + n, cmp);
long long ans = 0;
int i = 0;
for (; i < k; i++) {
ans += a[i].a;
}
for (; i < n; i++) {
if (a[i].d < 0)
ans += a[i].a;
else
ans += a[i].b;
}
printf("%I64d\n", ans);
return 0;
}
| 4
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
string to_string(string s) { return '"' + s + '"'; }
string to_string(char s) { return string(1, s); }
string to_string(const char *s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A>
string to_string(A);
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
bool f = 1;
string r = "{";
for (const auto &x : v) {
if (!f) r += ", ";
f = 0;
r += to_string(x);
}
return r + "}";
}
void debug_out() { cout << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cout << " " << to_string(H);
debug_out(T...);
}
inline int add(int a, int b) {
a += b;
if (a >= MOD) a -= MOD;
return a;
}
inline int sub(int a, int b) {
a -= b;
if (a < 0) a += MOD;
return a;
}
inline int mul(int a, int b) { return (int)((long long)a * b % MOD); }
inline int binpow(int a, int b) {
int res = 1;
while (b > 0) {
if (b & 1) res = mul(res, a);
a = mul(a, a);
b /= 2;
}
return res;
}
inline int inv(int a) { return binpow(a, MOD - 2); }
int gcd(int a, int b, int &x, int &y) {
if (a == 0) {
x = 0, y = 1;
return b;
}
int x1, y1;
int d = gcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
vector<int> a(n + 1), nxt(n + 1, -1), dp(n + 1);
map<int, int> m[n + 1];
for (int i = 0; i < n; ++i) cin >> a[i];
long long ans = 0;
for (int i = n - 1; i >= 0; --i) {
if (a[i] == a[i + 1])
nxt[i] = i + 1;
else
nxt[i] = (m[i + 1].count(a[i])) ? m[i + 1][a[i]] : -1;
if (nxt[i] == -1) continue;
int id = nxt[i] + 1;
swap(m[i], m[id]);
m[i][a[id]] = id;
dp[i] = 1 + dp[id];
ans += dp[i];
}
cout << ans << "\n";
}
return 0;
}
| 18
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
istream& operator>>(istream& in, vector<T>& a) {
for (long long i = 0; i < a.size(); i++) in >> a[i];
return in;
}
template <typename T>
ostream& operator<<(ostream& out, vector<T>& a) {
for (long long i = 0; i < a.size(); i++) out << a[i];
return out;
}
template <typename T, typename E>
istream& operator>>(istream& in, pair<T, E>& a) {
in >> a.first >> a.second;
return in;
}
long long gcd(long long a, long long b) {
long long c = 1;
while (b) {
c = a % b;
a = b;
b = c;
}
return a;
}
long long dx[8] = {-2, -1, 1, 2, 2, 1, -1, -2};
long long dy[8] = {1, 2, 2, 1, -1, -2, -2, -1};
vector<long long> nx = {0, 9, 189, 2889, 38889, 488889, 5888889, 68888889};
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
long long q;
cin >> q;
while (q--) {
long long k;
cin >> k;
long long l = 1, r = 1, cc = 1, u = 1, pow = 1, i = 1;
while (l < k) {
r += cc;
l += r;
i++;
if (u * 9 == r) {
pow *= 10;
cc++;
u += pow * cc;
}
}
long long z = k - (l - r);
long long cnt = 0, ww = 1;
pow = 1;
while ((cnt + pow * ww) * 9 < z) {
cnt += pow * ww;
ww++;
pow *= 10;
}
long long sym_cnt = (z - (cnt * 9)) - 1;
long long ok = (pow) + sym_cnt / ww;
string s = to_string(ok);
if (z < 10)
cout << z << endl;
else
cout << s[sym_cnt % ww] << endl;
z = z;
}
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O0")
#pragma GCC optimize("O1")
long long pw(int a, int b) {
long long ret = 1;
long long mul = a;
while (b > 0) {
if (b & 1) ret *= mul;
mul *= mul;
b /= 2;
}
return ret;
}
long long to_int(string s) {
long long ret = 0;
for (int(i) = (0); (i) < (s.size()); (i)++) {
ret += pw(10, s.size() - i - 1) * (long long)(s[i] - '0');
}
return ret;
}
const int MAXN = 5e5 + 55;
int n, s, a[MAXN], dp[MAXN], link[MAXN], segTree[4 * MAXN], rep[MAXN];
map<int, int> lst;
int get(int v, int tl, int tr, int pos) {
if (pos > tr or pos < tl) return -1;
if (tl == tr) return segTree[v];
int ret = segTree[v], mid = (tl + tr) / 2;
ret = max(ret, get(2 * v, tl, mid, pos)),
ret = max(ret, get(2 * v + 1, mid + 1, tr, pos));
return ret;
}
void upd(int v, int tl, int tr, int l, int r, int x) {
if (l > tr or r < tl) return;
if (l <= tl and r >= tr) {
segTree[v] = max(segTree[v], x);
return;
}
int mid = (tl + tr) / 2;
upd(2 * v, tl, mid, l, r, x), upd(2 * v + 1, mid + 1, tr, l, r, x);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
;
cin >> n;
s = pow(2, ceil(log2((n)) * 1.0));
;
for (int(i) = (0); (i) < (2 * s); (i)++) segTree[i] = -1;
for (int(i) = (0); (i) < (n); (i)++) cin >> a[i], lst[a[i]] = -1;
for (int(i) = (0); (i) < (n); (i)++) {
if (i) {
dp[i] = dp[i - 1], link[i] = i - 1;
}
if (lst[a[i]] >= 0) {
int idx = get(1, 0, s - 1, lst[a[i]]);
if (idx > -1) {
int tmp = 4;
if (idx) tmp += dp[idx - 1];
if (tmp > dp[i]) {
dp[i] = tmp, link[i] = idx;
}
}
}
if (lst[a[i]] >= 0 and rep[lst[a[i]]] >= 0) {
int idx = get(1, 0, s - 1, rep[lst[a[i]]]);
if (idx > -1) {
int tmp = 4;
if (idx) tmp += dp[idx - 1];
if (tmp > dp[i]) {
dp[i] = tmp, link[i] = idx;
}
}
}
if (lst[a[i]] >= 0 and rep[lst[a[i]]] >= 0) {
upd(1, 0, s - 1, lst[a[i]], lst[a[i]], rep[lst[a[i]]]);
}
if (lst[a[i]] >= 0 and lst[a[i]] < i - 1) {
upd(1, 0, s - 1, lst[a[i]] + 1, i - 1, lst[a[i]]);
}
rep[i] = lst[a[i]];
lst[a[i]] = i;
}
cout << dp[n - 1] << "\n";
vector<int> ans;
int idx = n - 1;
while (idx > 0) {
if (link[idx] == idx - 1) {
idx--;
continue;
}
ans.push_back(a[idx]), ans.push_back(a[link[idx]]), ans.push_back(a[idx]),
ans.push_back(a[link[idx]]);
idx = link[idx] - 1;
}
for (int(i) = (ans.size() - 1); (i) >= (0); (i)--) cout << ans[i] << " ";
cout << "\n";
}
| 15
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, a, b, c, cnt = 0;
cin >> n >> a >> b >> c;
long long ans = n / a;
long long y = n % a;
if (y >= b) ans += ((y - b) / (b - c)) + 1;
if (n >= b) {
cnt += (n - b) / (b - c) + 1;
n = n - (cnt) * (b - c);
}
cout << max(ans, cnt + n / a) << endl;
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
char en = '\n';
void fileIO() {}
const long long N = 1e12;
const long long MOD = 1e9 + 7;
void solve() {
long long n, t;
cin >> n >> t;
string second;
cin >> second;
long long dp[n + 1], i = n - 1, j;
dp[n] = N;
while (second[i] != '.') {
if (second[i] - '0' > 4)
dp[i] = 1;
else if (second[i] == '4')
dp[i] = dp[i + 1] + 1;
else
dp[i] = N;
i--;
}
i += 1;
while (i < n && dp[i] > t) i++;
if (i < n) {
i--;
while (second[i] == '9') i--;
j = i + 1;
if (second[i] == '.') {
j = i;
i--;
while (i >= 0 && second[i] == '9') {
second[i] = '0';
i--;
}
if (i < 0) {
j++;
second.insert(0, "1");
} else {
char u = char('0' + (second[i] - '0' + 1));
second[i] = u;
}
} else {
char u = char('0' + (second[i] - '0' + 1));
second[i] = u;
}
second = second.substr(0, j);
}
cout << second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
fileIO();
long long t = 1;
while (t--) {
solve();
cout << en;
}
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl;
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string a;
getline(cin, a);
for (int i = a.size() - 1; i >= 0; i--) {
if ((a[i] >= 'A' && a[i] <= 'Z') || (a[i] >= 'a' && a[i] <= 'z')) {
if (a[i] == 'A' || a[i] == 'O' || a[i] == 'U' || a[i] == 'Y' ||
a[i] == 'I' || a[i] == 'E' || a[i] == 'a' || a[i] == 'o' ||
a[i] == 'u' || a[i] == 'y' || a[i] == 's' || a[i] == 'e') {
cout << "YES";
return 0;
} else {
cout << "NO";
return 0;
}
}
}
return 0;
}
| 0
|
#include <bits/stdc++.h>
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
using namespace std;
int a[210000];
long long ans, n;
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
ans += a[i];
}
if (ans % 2 == 1) {
cout << "NO" << endl;
} else {
sort(a + 1, a + 1 + n);
ans -= a[n];
if (a[n] > ans)
cout << "NO" << endl;
else
cout << "YES" << endl;
}
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
ll x[1 << 18];
void safeout(long long sum, long long m) {
using ld = long double;
long long f = sum / m;
long double s = ld(sum % m) / (ld)m;
if (f >= 10) {
s += sum % 10;
cout << f / 10 << (ld)s / (ld)m << endl;
} else {
cout << (ld)sum / (ld)m << endl;
}
}
int main() {
ios::sync_with_stdio(false), cin.tie(0);
ll n, r;
cin >> n >> r;
ll m = 1 << n;
ll sum = 0;
for (int i = 0; i < m; i++) cin >> x[i], sum += x[i];
cout << fixed << setprecision(7);
safeout(sum, m);
for (int i = 0; i < r; i++) {
ll a, b;
cin >> a >> b;
sum -= x[a];
x[a] = b;
sum += x[a];
safeout(sum, m);
}
}
| 17
|
#include <bits/stdc++.h>
using namespace std;
double DP[210][210][2 * 210 + 10];
double P[210];
int Pakage[210];
int main() {
int N, K, L;
scanf("%d %d %d", &N, &L, &K);
for (int i = 1; i <= N; i++) {
scanf("%lf", &P[i]);
P[i] /= 100;
}
for (int i = 1; i <= N; i++) scanf("%d", &Pakage[i]);
DP[0][0][210 + K] = 1;
for (int i = 0; i < N; i++)
for (int j = 0; j <= i; j++)
for (int k = 0; k <= 210 * 2; k++)
if (DP[i][j][k] > 0) {
DP[i + 1][j][k] += DP[i][j][k] * (1 - P[i + 1]);
if (k + Pakage[i + 1] > 210 * 2)
DP[i + 1][j + 1][210 * 2] += DP[i][j][k] * P[i + 1];
else
DP[i + 1][j + 1][k + Pakage[i + 1]] += DP[i][j][k] * P[i + 1];
}
double Sum = 0;
for (int i = L; i <= N; i++)
for (int j = 210; j <= 210 * 2; j++) Sum += DP[N][i][j];
printf("%.12lf\n", Sum);
return 0;
}
| 10
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[10];
int t, n, i;
for (i = 0; i < 10; ++i) {
a[i] = 0;
}
scanf("%d", &n);
getchar();
vector<int> u;
for (i = 0; i < n; ++i) {
t = getchar() - '0';
switch (t) {
case (2):
a[2] += 1;
break;
case (3):
a[3] += 1;
a[2] += 1;
break;
case (4):
a[2] += 3;
a[3] += 1;
break;
case (5):
u.push_back(5);
break;
case (6):
u.push_back(5);
a[2] += 1;
a[3] += 1;
break;
case (7):
u.push_back(7);
break;
case (8):
u.push_back(7);
a[2] += 3;
break;
case (9):
u.push_back(7);
a[2] += 3;
a[3] += 2;
break;
}
}
a[2] -= a[3];
for (i = 0; i < a[3]; ++i) {
u.push_back(3);
}
for (i = 0; i < a[2]; ++i) {
u.push_back(2);
}
sort(u.begin(), u.end());
for (i = u.size() - 1; i > -1; --i) {
printf("%d", u[i]);
}
return 0;
}
| 6
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105, D = 100005;
const int oo = 1e9;
int n, k, a[N], b[N];
int dp[N][2 * D];
int f(int i, int val) {
if (i == n) return val == D ? 0 : -oo;
int &ans = dp[i][val];
if (~ans) return ans;
return ans = max(f(i + 1, val), f(i + 1, val + a[i] - b[i]) + a[i]);
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d %d", &n, &k);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n; i++) scanf("%d", b + i), b[i] *= k;
int ans = f(0, D);
if (ans == 0) ans = -1;
printf("%d\n", ans);
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
long long int colour[100002];
void dfs(long long int s, vector<long long int> g[], bool vis[],
long long int c) {
vis[s] = true;
colour[s] = c;
for (long long int i = 0; i < g[s].size(); i++) {
if (vis[g[s][i]] == false) {
if (c)
dfs(g[s][i], g, vis, 0);
else
dfs(g[s][i], g, vis, 1);
}
}
}
int main() {
long long int n;
cin >> n;
long long int e = n - 1;
vector<long long int> g[n + 1];
bool vis[n + 1];
for (long long int i = 1; i <= n; i++) vis[i] = false;
for (long long int i = 1; i <= e; i++) {
long long int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, g, vis, 0);
long long int one = 0, zero = 0;
for (long long int i = 1; i <= n; i++) {
if (colour[i] == 1)
one++;
else
zero++;
}
cout << one * zero - (e);
return 0;
}
| 5
|
#include <bits/stdc++.h>
using namespace std;
const int N = 16;
int mox[4] = {0, 0, -1, 1};
int moy[4] = {1, -1, 0, 0};
struct point {
int x, y, st, ans;
point() : x(0), y(0), st(0), ans(0) {}
point(int _x, int _y, int _st, int _ans) {
x = _x, y = _y, st = _st, ans = _ans;
}
} o;
queue<point> q;
int len;
char s[N][N];
int mp[N][N];
bool vis[N][N][1 << 16];
int X[10], Y[10];
inline void seter() {
X[1] = o.x, Y[1] = o.y;
for (int i = 2; i <= len; ++i) {
int now = ((o.st >> (2 * (i - 2))) & 3);
X[i] = X[i - 1] - mox[now], Y[i] = Y[i - 1] - moy[now];
}
for (int i = 1; i < len; ++i) mp[X[i]][Y[i]] = -1;
}
inline void puter() {
for (int i = 1; i <= len; ++i) mp[X[i]][Y[i]] = 1;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%s", s[i] + 1);
for (int j = 1; j <= m; ++j)
if (s[i][j] == '@')
mp[i][j] = 2;
else
mp[i][j] = ((s[i][j] == '.') || (s[i][j] >= '0' && s[i][j] <= '9'));
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (s[i][j] == '1')
o.x = i, o.y = j;
else if (s[i][j] >= '0' && s[i][j] <= '9') {
len = max(len, (int)s[i][j] - '0');
for (int k = 0; k < 4; ++k)
if (s[i + mox[k]][j + moy[k]] == s[i][j] - 1)
o.st |= (k << (2 * (s[i][j] - '2')));
}
q.push(o);
for (; !q.empty();) {
o = q.front();
q.pop();
seter();
for (int i = 0; i < 4; ++i) {
int xx = o.x + mox[i];
int yy = o.y + moy[i];
int now = (((o.st << 2) | i) & ((1 << (2 * (len - 1))) - 1));
if (mp[xx][yy] == 1 && !vis[xx][yy][now]) {
vis[xx][yy][now] = 1;
q.push(point(xx, yy, now, o.ans + 1));
} else if (mp[xx][yy] == 2) {
printf("%d", o.ans + 1);
return 0;
}
}
puter();
}
printf("-1");
return 0;
}
| 14
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
long long dp[N];
int main() {
long long n, m, sum, l, r, i, val;
scanf("%lld%lld", &n, &m);
dp[1] = 1;
sum = 1;
for (i = 2; i <= n; ++i) {
dp[i] += sum;
dp[i] = dp[i] % m;
val = i / 2, l = 2, r = i / val;
while (1) {
dp[i] = dp[i] + (((r - l + 1) % m) * dp[val]) % m;
dp[i] = dp[i] % m;
if (val == 1) break;
l = r + 1;
val = i / l;
r = i / val;
}
sum = sum + dp[i];
sum = sum % m;
}
printf("%lld\n", dp[n]);
return 0;
}
| 9
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[] = {4, 10, 20, 35, 56, 83, 116, 155, 198, 244, 292};
int main() {
cin >> n;
if (n <= 11)
cout << a[n - 1];
else
cout << a[10] + 49 * (n - 11);
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
int read(int& a) { return scanf("%d", &a); }
int read(long long& a) { return scanf("%lld", &a); }
int read(double& a) { return scanf("%lf", &a); }
static const int MOD = 1000000007;
static const double PI = acos(-1.0);
static const int N = 1 << 20;
int d[16] = {0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1};
int solve() {
int x, y, z, t;
cin >> x >> y >> z >> t;
int p = (x << 3) | (y << 2) | (z << 1) | t;
cout << d[p] << endl;
return 0;
}
int main(int argc, char* argv[]) {
::std::ios::sync_with_stdio(false);
::std::cin.tie(0);
::std::cout.tie(0);
solve();
return 0;
}
| 12
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 998244353;
long long n, m;
long long damage[200005];
long long prefix[200005];
long long powr(long long r, long long k) {
long long z = 1;
while (k) {
if (k & 1) z = (z * r) % MOD;
r = (r * r) % MOD;
k >>= 1;
}
return z;
}
long long divide(long long x, long long y) {
return ((x * powr(y, MOD - 2)) % MOD);
}
int main() {
cin >> n >> m;
for (long long i = 0; i < n; ++i) cin >> damage[i];
sort(damage, damage + n);
prefix[0] = 0;
for (long long i = 0; i < n; ++i) {
prefix[i + 1] = prefix[i] + damage[i];
prefix[i + 1] %= MOD;
}
for (long long i = 0; i < m; ++i) {
long long a, b;
cin >> a >> b;
long long low = 0;
long long high = n - 1;
while (low < high) {
long long mid = (low + high) / 2;
if (damage[mid] < b)
low = mid + 1;
else
high = mid;
}
long long gMon = n - low;
if (gMon < a) {
cout << 0 << endl;
continue;
}
long long ans = divide(gMon + 1 - a, gMon + 1);
ans *= prefix[low];
ans %= MOD;
long long nAdd = divide(gMon - a, gMon);
nAdd *= (MOD + prefix[n] - prefix[low]);
nAdd %= MOD;
ans += nAdd;
ans %= MOD;
cout << ans << endl;
}
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, c1 = 0, c2 = 0, x;
cin >> n;
for (i = 0; i < n; i++) {
cin >> x;
if (x == 5)
c1++;
else
c2++;
}
x = c1 / 9;
x = x * 9;
if (c2 == 0)
cout << -1;
else {
if (x != 0) {
for (i = 1; i <= x; i++) cout << 5;
for (i = 1; i <= c2; i++) cout << 0;
} else
cout << 0;
}
}
| 2
|
#include <bits/stdc++.h>
int a[100005];
int ans[100005];
int b[50005];
int main() {
int n, i, m, x, y, t;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
int j;
for (i = 1; i <= n; i++) {
for (j = 1; j <= n; j++) b[j] = 0;
int in, ma;
in = -1;
ma = 0;
for (j = i; j <= n; j++) {
b[a[j]]++;
if (b[a[j]] > ma) {
ma = b[a[j]];
in = a[j];
} else if (b[a[j]] == ma) {
if (a[j] < in) in = a[j];
}
ans[in]++;
}
}
for (i = 1; i <= n; i++) printf("%d ", ans[i]);
}
| 7
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 5050;
const int M = 6;
const int H = 90;
int lo[M], hi[M];
int pts[M];
int a[MAX][3];
int cur[MAX];
int cnt[3];
bool can[MAX][3];
int ac[3];
int main(void) {
int n;
scanf("%d", &n);
for (int m = M - 1; m >= 0; --m) {
hi[m] = n >> m;
lo[m] = m + 1 == M ? 0 : hi[m + 1] + 1;
pts[m] = (m + 1) * 500;
}
for (int i = (0); i < (n); ++i) {
for (int j = (0); j < (3); ++j) {
scanf("%d", &a[i][j]);
if (a[i][j] < 0) {
a[i][j] *= -1;
can[i][j] = true;
cnt[j]++;
}
if (a[i][j]) ac[j]++;
}
}
if (cnt[0] + cnt[1] + cnt[2] >= H) {
puts("1");
return 0;
}
int ans = n;
for (int x1 = (0); x1 < (M); ++x1)
for (int x2 = (0); x2 < (M); ++x2)
for (int x3 = (0); x3 < (M); ++x3) {
int x[3] = {x1, x2, x3};
int g[3];
bool ok = true;
for (int j = (0); j < (3); ++j) {
if (lo[x[j]] > hi[x[j]]) ok = false;
if (lo[x[j]] > ac[j]) ok = false;
g[j] = min(ac[j] - lo[x[j]], cnt[j]);
if (hi[x[j]] < ac[j] - g[j]) ok = false;
}
if (!ok) continue;
int h = g[0] + g[1] + g[2];
static int f[H][H][H];
static int nf[H][H][H];
const int inf = 1e9;
for (int g0 = (0); g0 < (g[0] + 1); ++g0)
for (int g1 = (0); g1 < (g[1] + 1); ++g1)
for (int g2 = (0); g2 < (g[2] + 1); ++g2) f[g0][g1][g2] = inf;
f[0][0][0] = 0;
int off = 0;
for (int i = (0); i < (n); ++i) {
cur[i] = 0;
for (int j = (0); j < (3); ++j)
if (a[i][j]) cur[i] += pts[x[j]] * (250 - a[i][j]);
}
cur[0] += h * 250 * 100;
for (int i = (1); i < (n); ++i) {
if (can[i][0] || can[i][1] || can[i][2]) {
for (int g0 = (0); g0 < (g[0] + 1); ++g0)
for (int g1 = (0); g1 < (g[1] + 1); ++g1)
for (int g2 = (0); g2 < (g[2] + 1); ++g2) nf[g0][g1][g2] = inf;
for (int s = (0); s < (1 << 3); ++s) {
bool ok = true;
int nscore = cur[i];
for (int j = (0); j < (3); ++j)
if (s & (1 << j)) {
if (!can[i][j]) ok = false;
nscore -= pts[x[j]] * (250 - a[i][j]);
}
if (!ok) continue;
for (int g0 = (0); g0 < (g[0] + 1); ++g0)
for (int g1 = (0); g1 < (g[1] + 1); ++g1)
for (int g2 = (0); g2 < (g[2] + 1); ++g2) {
if (f[g0][g1][g2] == inf) continue;
int ng0 = g0 + (s & 1);
int ng1 = g1 + ((s >> 1) & 1);
int ng2 = g2 + ((s >> 2) & 1);
if (ng0 <= g[0] && ng1 <= g[1] && ng2 <= g[2]) {
nf[ng0][ng1][ng2] = min(
nf[ng0][ng1][ng2], f[g0][g1][g2] + (nscore > cur[0]));
}
}
}
for (int g0 = (0); g0 < (g[0] + 1); ++g0)
for (int g1 = (0); g1 < (g[1] + 1); ++g1)
for (int g2 = (0); g2 < (g[2] + 1); ++g2)
f[g0][g1][g2] = nf[g0][g1][g2];
} else {
if (cur[0] < cur[i]) off++;
}
}
ans = min(ans, off + f[g[0]][g[1]][g[2]]);
}
printf("%d\n", ans + 1);
return 0;
}
| 23
|
#include <bits/stdc++.h>
using namespace std;
const int alpha = 26;
unordered_map<int, int> cnt;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
long long ans = 0;
for (int i = 0; i < (n); ++i) {
string s;
cin >> s;
int mask = 0;
for (auto& c : s) mask ^= (1 << (c - 'a'));
for (int k = 0; k < (26); ++k) ans += cnt[mask ^ (1 << k)];
ans += cnt[mask]++;
}
cout << ans << '\n';
}
| 8
|
#include <bits/stdc++.h>
using namespace std;
vector<int> x;
vector<int> dp;
int main() {
int n;
cin >> n;
x.resize(n);
dp.resize(n);
int sum = 0;
for (int i = 0; i < n; ++i) {
int u;
cin >> u;
sum += u;
x[i] = sum;
}
dp[n - 1] = x[n - 1];
for (int i = n - 2; i >= 0; --i) {
dp[i] = max(dp[i + 1], x[i] - dp[i + 1]);
}
cout << dp[1] << endl;
return 0;
}
| 14
|
#include <bits/stdc++.h>
typedef int arr[6][7];
int ans = 10000000, e[8], o[4][600005];
char chr[2] = {'a', 'b'};
arr a = {{1, 1, 0, 0, 0, 1, 0}, {1, 0, 1, 0, 1, 0, 0}, {1, 0, 0, 1, 1, 1, 0},
{0, 1, 1, 0, 1, 1, 0}, {0, 1, 0, 1, 1, 0, 0}, {0, 0, 1, 1, 0, 1, 0}};
int prt[7][4] = {{0, 1, 1, 1}, {1, 0, 1, 1}, {1, 1, 0, 1}, {1, 1, 1, 0},
{0, 0, 1, 1}, {0, 1, 0, 1}, {0, 1, 1, 0}};
void swap(int &x, int &y) {
int t = x;
x = y;
y = t;
}
void gauss(int x) {
arr c;
memcpy(c, a, sizeof(c));
c[0][6] -= x, c[1][6] -= x, c[4][6] -= x, c[5][6] -= x;
for (int i = 0; i < 6; i++) c[i][6] *= 2;
for (int i = 0; i < 6; i++) {
if (!c[i][i])
for (int j = i + 1; j < 6; j++)
if (c[j][i])
for (int k = i; k < 7; k++) swap(c[i][k], c[j][k]);
if (c[i][i] != 1)
for (int k = 6; k >= i; k--) c[i][k] /= c[i][i];
for (int j = i + 1; j < 6; j++)
if (c[j][i])
for (int k = 6; k >= i; k--) c[j][k] -= c[i][k] * c[j][i];
}
for (int i = 5; i; i--)
for (int j = i - 1; j >= 0; j--)
if (c[j][i])
for (int k = 6; k >= i; k--) c[j][k] -= c[j][i] * c[i][k];
int res = x;
for (int i = 0; i < 6; i++) {
if (c[i][6] < 0 || c[i][6] & 1) return;
res += c[i][6] / 2;
}
if (res < ans) {
ans = res, e[6] = x;
for (int i = 0; i < 6; i++) e[i] = c[i][6] / 2;
}
}
int main() {
for (int i = 0; i < 6; i++) scanf("%d", &a[i][6]);
for (int i = 0; i <= a[0][6] && i <= a[1][6] && i <= a[4][6] && i <= a[5][6];
i++)
gauss(i);
if (ans == 10000000) {
printf("-1\n");
return 0;
}
printf("%d\n", ans);
int l = 0;
for (int i = 0; i < 7; i++)
for (int j = 1; j <= e[i]; j++) {
l++;
for (int k = 0; k < 4; k++) o[k][l] = prt[i][k];
}
for (int i = 0; i < 4; i++) {
for (int j = 1; j <= ans; j++) printf("%c", chr[o[i][j]]);
printf("\n");
}
return 0;
}
| 16
|
#include <bits/stdc++.h>
using namespace std;
struct TT {
int u, v, w, next, ed;
} edge[10001];
int V[10011];
bool ed[10011];
int cntm = 1;
int k;
int MAX1 = -1;
int stt;
int MAX2 = 0;
bool vi[10101];
void adde(int a, int b) {
TT &e = edge[cntm];
e.v = b;
e.u = a;
e.w = 1;
e.ed = 0;
e.next = V[a];
V[a] = cntm++;
}
void DFS(int x, int deep) {
int uu, vv;
if (MAX1 < deep) {
MAX1 = deep;
stt = x;
}
for (int i = V[x]; ~i; i = edge[i].next) {
vv = edge[i].v;
if (ed[vv] == 0) {
ed[vv] = 1;
DFS(vv, deep + 1);
ed[vv] = 0;
}
}
}
void DFS2(int ax, int adeep) {
int u, v;
if (MAX2 < adeep) {
MAX2 = adeep;
}
for (int i = V[ax]; ~i; i = edge[i].next) {
v = edge[i].v;
if (0 == vi[v]) {
vi[v] = 1;
DFS2(v, adeep + 1);
vi[v] = 0;
}
}
}
int main() {
int N, M;
cin >> N;
cntm = 1;
int a, b;
int ans = 0;
memset(V, -1, sizeof(V));
for (long long i = 1; i <= N - 1; i++) {
scanf("%d%d", &a, &b);
adde(a, b);
adde(b, a);
}
for (long long il = 1; il <= N - 1; il++) {
memset(ed, 0, sizeof(ed));
memset(vi, 0, sizeof(vi));
k = (il * 2) - 1;
int u = edge[k].u;
int v = edge[k].v;
ed[v] = 1;
ed[u] = 1;
int ansa = 0;
MAX1 = 0;
DFS(u, 1);
vi[v] = 1;
vi[u] = 0;
MAX2 = 0;
vi[stt] = 1;
DFS2(stt, 0);
vi[stt] = 0;
vi[v] = 0;
ansa = MAX2;
int ansb = 0;
MAX1 = 0;
DFS(v, 1);
MAX2 = 0;
vi[stt] = 1;
vi[u] = 1;
vi[v] = 0;
DFS2(stt, 0);
vi[stt] = 0;
ansb = MAX2;
ed[v] = 0;
ed[u] = 0;
ans = max((ansa) * (ansb), ans);
}
printf("%d\n", ans);
return 0;
}
| 11
|
#include <bits/stdc++.h>
using namespace std;
using ii = long long;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int q;
cin >> q;
for (int it = 0; it < q; ++it) {
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
v[i]--;
}
vector<int> ci(n);
vector<int> sz(n + 1);
int c = 0;
for (int i = 0; i < n; ++i) {
if (ci[i]) continue;
c++;
int it = i;
int j = 0;
while (!ci[it]) {
ci[it] = c;
it = v[it];
++j;
}
sz[c] = j;
}
for (int i = 0; i < n; ++i) {
cout << sz[ci[i]] << " ";
}
cout << "\n";
}
}
| 2
|
#include <bits/stdc++.h>
using namespace std;
struct Seg {
int sum[4 * 200000 + 5];
bool inv[4 * 200000 + 5];
void down(int l, int r, int idx) {
if (inv[idx]) {
inv[idx] = 0;
int m = (l + r) / 2;
inv[idx << 1] ^= 1;
sum[idx << 1] = m + 1 - l - sum[idx << 1];
inv[idx << 1 | 1] ^= 1;
sum[idx << 1 | 1] = r - m - sum[idx << 1 | 1];
}
}
void up(int idx) { sum[idx] = sum[idx << 1] + sum[idx << 1 | 1]; }
void init(int *arr, int l, int r, int idx) {
inv[idx] = 0;
if (l == r) {
sum[idx] = arr[l];
return;
}
int m = (l + r) / 2;
init(arr, l, m, idx << 1);
init(arr, m + 1, r, idx << 1 | 1);
up(idx);
}
void update(int ql, int qr, int l, int r, int idx) {
if (l > qr || r < ql) return;
if (l >= ql && r <= qr) {
inv[idx] ^= 1;
sum[idx] = (r - l + 1) - sum[idx];
return;
}
int m = (l + r) / 2;
down(l, r, idx);
update(ql, qr, l, m, idx << 1);
update(ql, qr, m + 1, r, idx << 1 | 1);
up(idx);
}
int query(int ql, int qr, int l, int r, int idx) {
if (l > qr || r < ql) return 0;
if (l >= ql && r <= qr) {
return sum[idx];
}
int m = (l + r) / 2;
down(l, r, idx);
int q1 = query(ql, qr, l, m, idx << 1);
int q2 = query(ql, qr, m + 1, r, idx << 1 | 1);
return q1 + q2;
}
} tree;
int cnt = 1, n, l[200000 + 5], r[200000 + 5], arr[200000 + 5];
vector<int> child[200000 + 5];
void dfs(int v) {
l[v] = cnt++;
for (int u : child[v]) dfs(u);
r[v] = cnt - 1;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 2; i <= n; i++) {
int p;
cin >> p;
child[p].push_back(i);
}
dfs(1);
for (int i = 1; i <= n; i++) cin >> arr[l[i]];
tree.init(arr, 1, n, 1);
int Q;
cin >> Q;
while (Q--) {
int x;
char inst[5];
cin >> inst >> x;
if (strcmp(inst, "get") == 0) {
cout << tree.query(l[x], r[x], 1, n, 1) << '\n';
} else {
tree.update(l[x], r[x], 1, n, 1);
}
}
}
| 12
|
#include "bits/stdc++.h"
using namespace std;
#define int long long
#define pb push_back
#define ppb pop_back
#define pf push_front
#define ppf pop_front
#define all(x) (x).begin(),(x).end()
#define uniq(v) (v).erase(unique(all(v)),(v).end())
#define sz(x) (int)((x).size())
#define fr first
#define sc second
#define pii pair<int,int>
#define rep(i,a,b) for(int i=a;i<b;i++)
#define mem1(a) memset(a,-1,sizeof(a))
#define mem0(a) memset(a,0,sizeof(a))
#define ppc __builtin_popcount
#define ppcll __builtin_popcountll
template<typename T1,typename T2>istream& operator>>(istream& in,pair<T1,T2> &a){in>>a.fr>>a.sc;return in;}
template<typename T1,typename T2>ostream& operator<<(ostream& out,pair<T1,T2> a){out<<a.fr<<" "<<a.sc;return out;}
template<typename T,typename T1>T amax(T &a,T1 b){if(b>a)a=b;return a;}
template<typename T,typename T1>T amin(T &a,T1 b){if(b<a)a=b;return a;}
const long long INF=1e18;
const int32_t M=1e9+7;
const int32_t MM=998244353;
const int N=1e5+5;
int a[N];
int f[N];
void solve(){
int n;
cin >> n;
rep(i,1,n+1){
a[i] = f[i] = 0;
}
rep(i,1,n+1){
cin >> a[i];
f[a[i]]++;
}
int thresh = (n + 1) / 2;
rep(i,1,n+1){
if(f[i] > thresh){
cout << -1 << "\n";
return;
}
f[i] = 0;
}
vector<pii> v;
int s = -1, e = -1;
rep(i,1,n+1){
if(s == -1){
s = e = a[i];
continue;
}
if(e == a[i]){
v.pb({s,e});
if(s == e){
f[s]++;
}
s = e = a[i];
continue;
}
e = a[i];
}
if(s != -1){
v.pb({s,e});
if(s == e){
f[s]++;
}
}
int ans = sz(v) - 1;
int mx = 1;
rep(i,1,n+1){
if(f[mx] < f[i]) mx = i;
}
int cntmx = f[mx];
int cntnon = 0;
for(pii x:v){
// cout << x << "\n";
cntnon += (x.fr != mx && x.sc != mx);
}
// cout << cntmx << " " << cntnon << "\n";
ans += max(0LL,cntmx - cntnon - 1);
cout << ans << "\n";
}
signed main(){
ios_base::sync_with_stdio(false);
cin.tie(0);cout.tie(0);
//freopen("input.txt", "r", stdin);
//freopen("output.txt", "w", stdout);
#ifdef SIEVE
sieve();
#endif
#ifdef NCR
init();
#endif
int t=1;
cin>>t;
while(t--) solve();
return 0;
}
| 16
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.