solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2147483647;
const int M = 1000;
set<int> zb;
set<int>::iterator it;
int sp[M + 5], i, j, k, l, i1, j11, k1, d, suma, kk, m;
vector<int> liczby, znaki;
int odczytaj(int a, int z1, int b, int z2, int c, int z3, int d) {
int i, res, dod;
liczby.resize(0);
znaki.resize(0);
liczby.push_back(a);
if (z1 == 0)
liczby[liczby.size() - 1] = liczby[liczby.size() - 1] * 10 + b;
else {
liczby.push_back(b);
znaki.push_back(z1);
}
if (z2 == 0)
liczby[liczby.size() - 1] = liczby[liczby.size() - 1] * 10 + c;
else {
liczby.push_back(c);
znaki.push_back(z2);
}
if (z3 == 0)
liczby[liczby.size() - 1] = liczby[liczby.size() - 1] * 10 + d;
else {
liczby.push_back(d);
znaki.push_back(z3);
}
for (i = 0; i < znaki.size(); i++)
if (znaki[i] == 1) {
liczby[i + 1] *= liczby[i];
liczby[i] = 0;
}
res = liczby[0];
dod = 1;
for (i = 1; i < liczby.size(); i++) {
if (znaki[i - 1] == 2)
dod = 1;
else if (znaki[i - 1] == 3)
dod = -1;
res += liczby[i] * dod;
}
return res;
}
void wypisz(int a, int b, int c, int d, int e) {
printf("%d%d%d%d%d%d%d%d\n", a, b, c, d, e / 1000, (e / 100) % 10,
(e / 10) % 10, e % 10);
}
int main() {
scanf("%d %d", &kk, &m);
for (i = 0; i < 10; i++)
for (j = 0; j < 10; j++)
for (k = 0; k < 10; k++)
for (l = 0; l < 10; l++) {
zb.clear();
for (i1 = 0; i1 < 4; i1++)
for (j11 = 0; j11 < 4; j11++)
for (k1 = 0; k1 < 4; k1++) {
d = odczytaj(i, i1, j, j11, k, k1, l);
if (d >= 0 && d <= M && zb.find(d) == zb.end()) {
zb.insert(d);
if (kk + d < 10000 && kk + d >= 0 && m > 0) {
wypisz(i, j, k, l, kk + d);
m--;
} else if (kk - d < 10000 && kk - d >= 0 && m > 0) {
wypisz(i, j, k, l, kk - d);
m--;
}
}
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int n, k;
cin >> n >> k;
int ara[n + 1];
for (int i = 0; i < n; ++i) ara[i] = i + 1;
int sz = k, first = 0, last = n - 1, cnt = 0;
bool accf = 1, accl = 0;
while (sz--) {
if (accf) {
cout << ara[first] << " ";
++cnt;
++first;
accf = 0;
accl = 1;
} else if (accl) {
cout << ara[last] << " ";
++cnt;
--last;
accf = 1;
accl = 0;
}
}
if (!(cnt % 2)) {
for (int i = last; i >= first; --i) cout << ara[i] << " ";
} else {
for (int i = first; i <= last; ++i) cout << ara[i] << " ";
}
cout << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
const int32_t M = 1e9 + 7;
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> arr(n), temp(n);
for (auto &x : arr) cin >> x;
temp = arr;
sort((arr).begin(), (arr).end());
unordered_map<long long, long long> mp;
for (long long i = 0; i < n; i++) {
mp[arr[i]] = i;
}
long long nk = 1;
long long prev = temp[0];
for (long long i = 1; i < n; i++) {
long long ind = mp[prev] + 1;
if (ind == n || (ind != n && arr[ind] != temp[i])) nk++;
prev = temp[i];
}
if (nk <= k)
cout << "YES\n";
else
cout << "NO\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
cin >> t;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k;
cin >> k;
while (k--) {
int n;
cin >> n;
string s, t;
cin >> s >> t;
vector<int> cnt;
for (int i = 0; i < n; i++) {
if (s[i] != t[i]) cnt.push_back(i);
}
int cur = cnt.size();
if (cur == 0) {
puts("Yes");
continue;
}
if (cur == 2 and s[cnt[0]] == s[cnt[1]] and t[cnt[0]] == t[cnt[1]]) {
puts("Yes");
} else {
puts("No");
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
int n;
cin >> n;
if (n == 2) return cout << -1, 0;
cout << "385\n21\n165\n";
for (int i = 0; i < n - 3; i++) {
cout << 21 * (i + 100) << endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2010;
char mat[N][N];
int dp[N][N][4];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%s", mat[i] + 1);
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (mat[i][j] == '#') continue;
dp[i][j][0] = dp[i][j - 1][0] + 1, dp[i][j][1] = dp[i - 1][j][1] + 1;
}
}
for (int i = n; i; i--) {
for (int j = m; j; j--) {
if (mat[i][j] == '#') continue;
dp[i][j][2] = dp[i][j + 1][2] + 1, dp[i][j][3] = dp[i + 1][j][3] + 1;
}
}
long long ret = 0;
for (int i = 2; i < n; i++) {
if (dp[i][m][0] == m) ret++;
}
for (int i = 2; i < m; i++) {
if (dp[n][i][1] == n) ret++;
}
for (int i = 2; i < n; i++) {
for (int j = 2; j < m; j++) {
int cnt1 = 0, cnt2 = 0;
if (dp[i][j][0] == j) cnt1++;
if (dp[i][j][2] == m - j + 1) cnt1++;
if (dp[i][j][1] == i) cnt2++;
if (dp[i][j][3] == n - i + 1) cnt2++;
ret += cnt1 * cnt2;
}
};
for (int i = 2; i < n; i++) {
int cnt1 = 0, cnt2 = 0;
for (int j = 2; j < m; j++) {
if (dp[i][j][1] == i) {
ret += cnt1;
ret += cnt2;
if (j >= 3 && dp[i][j - 1][1] == i) ret--;
}
if (dp[i][j][3] == n - i + 1) {
ret += cnt1;
ret += cnt2;
if (j >= 3 && dp[i][j - 1][3] == n - i + 1) ret--;
}
if (dp[i][j][1] == i)
cnt1++;
else if ('#' == mat[i][j])
cnt1 = 0;
if (dp[i][j][3] == n - i + 1)
cnt2++;
else if ('#' == mat[i][j])
cnt2 = 0;
}
}
for (int j = 2; j < m; j++) {
int cnt1 = 0, cnt2 = 0;
for (int i = 2; i < n; i++) {
if (dp[i][j][0] == j) {
ret += cnt1;
ret += cnt2;
if (i >= 3 && dp[i - 1][j][0] == j) ret--;
}
if (dp[i][j][2] == m - j + 1) {
ret += cnt1;
ret += cnt2;
if (i >= 3 && dp[i - 1][j][2] == m - j + 1) ret--;
}
if (dp[i][j][0] == j)
cnt1++;
else if ('#' == mat[i][j])
cnt1 = 0;
if (dp[i][j][2] == m - j + 1)
cnt2++;
else if ('#' == mat[i][j])
cnt2 = 0;
}
}
cout << ret << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod=1000000007;
int n,x,y,z,dp[45][1<<17];
int main()
{
scanf("%d%d%d%d",&n,&x,&y,&z);
int mask=(1<<(x+y+z))-1;
int valid=(1<<(x+y+z-1))+(1<<(x+y-1))+(1<<(x-1));
dp[0][0]=1;
for (int i=1;i<=n;++i)
for (int j=1;j<=10;++j)
for (int k=0;k<=mask;++k) {
int t=mask&((k<<j)+(1<<(j-1)));
if ((t&valid)==valid) continue;
dp[i][t]=(dp[i][t]+dp[i-1][k])%mod;
}
int res=1;
for (int i=1;i<=n;++i)
res=10ll*res%mod;
for (int i=0;i<=mask;++i)
res=((res-dp[n][i])%mod+mod)%mod;
printf("%d\n",res);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int const N = 100 + 5;
int n, m, x, u, v, arr[N];
vector<int> adj[N];
set<int> my_set;
bool vis[N];
void dfs(int u) {
vis[u] = 1;
for (auto child : adj[u]) {
if (!vis[child]) {
dfs(child);
}
}
}
int main() {
ios_base::sync_with_stdio(false);
int c = -1;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> x;
if (x == 0) c++;
for (int j = 0; j < x; ++j) {
cin >> arr[j];
my_set.insert(arr[j]);
}
if (x > 1) {
for (int j = 1; j < x; ++j) {
adj[arr[0]].push_back(arr[j]);
adj[arr[j]].push_back(arr[0]);
}
}
}
if (my_set.empty()) c++;
for (auto x : my_set) {
if (!vis[x]) {
c++;
dfs(x);
}
}
cout << c;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
const int maxn=1e5+5;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll t,n,i,j,k,a[maxn],b[maxn],c[maxn],result,here;
cin>>t;
while (t--){
cin>>n;
result=0;
for(i=1;i<=n;i++){
cin>>c[i];
}
for(i=1;i<=n;i++){
cin>>a[i];
}
for(i=1;i<=n;i++){
cin>>b[i];
}
a[n+1]=b[n+1]=0;
here=0;
for(i=n-1;i>=1;i--){
if(a[i+1]==b[i+1]){
here=here+abs(a[i+1]-b[i+1])+c[i+1]-1-2*(abs(a[i+2]-b[i+2]))+2;
here=max(here,c[i+1]-1+abs(a[i+1]-b[i+1])+2);
result=max(result,here);
here=0;
} else{
here=here+abs(a[i+1]-b[i+1])+c[i+1]-1-2*(abs(a[i+2]-b[i+2]))+2;
here=max(here,c[i+1]-1+abs(a[i+1]-b[i+1])+2);
result=max(result,here);
}
}
printf("%lld\n",result);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const long long INF = 1e18;
long long dp[N][3];
long long val[N];
long long a, b;
int n;
vector<long long> gcd;
void init(long long x) {
for (long long i = 2; i * i <= x; i++) {
if (x % i == 0) gcd.push_back(i);
while (x % i == 0) x /= i;
}
if (x != 1) gcd.push_back(x);
}
long long solve(long long g) {
long long temp;
dp[0][0] = dp[0][1] = dp[0][2] = 0;
for (int i = 1; i <= n; i++) {
temp = 1e18;
if ((val[i] + 1) % g == 0 || (val[i] - 1) % g == 0) temp = b;
if (val[i] % g == 0) temp = 0;
dp[i][0] = dp[i - 1][0] + temp;
dp[i][0] = min(dp[i][0], INF);
dp[i][2] = min(dp[i - 1][1], dp[i - 1][2]) + temp;
dp[i][2] = min(dp[i][2], INF);
dp[i][1] = min(dp[i - 1][0], dp[i - 1][1]) + a;
dp[i][1] = min(dp[i][1], INF);
}
return min(dp[n][0], min(dp[n][1], dp[n][2]));
}
int main() {
scanf("%d%I64d%I64d", &n, &a, &b);
for (int i = 1; i <= n; i++) scanf("%I64d", &val[i]);
gcd.clear();
init(val[1]);
init(val[1] + 1);
init(val[1] - 1);
init(val[n]);
init(val[n] + 1);
init(val[n] - 1);
sort(gcd.begin(), gcd.end());
gcd.erase(unique(gcd.begin(), gcd.end()), gcd.end());
long long ans = 2e18;
for (int i = 0; i < gcd.size(); i++) {
ans = min(solve(gcd[i]), ans);
}
printf("%I64d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long bigmod(long long a, int p, long long int m) {
if (p == 0) return 1;
if (p & 1) {
return ((a % m) * (bigmod(a, p - 1, m))) % m;
} else {
long long tmp = bigmod(a, p / 2, m);
return (tmp * tmp) % m;
}
}
vector<long long int> v1;
void SieveOfEratosthenes(long long int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (long long int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (long long int p = 2; p <= n; p++)
if (prime[p]) v1.push_back(p);
}
string s;
long long int n;
char c;
long long int solve(long long int i, long long int len, char d) {
if (len == 1) {
if (s[i] == d)
return 0;
else
return 1;
}
long long int j;
long long int ct1 = 0, ct2 = 0;
for (j = i; j < i + len / 2; j++) {
if (s[j] != d) ct1++;
}
for (j = i + len / 2; j < i + len; j++) {
if (s[j] != d) ct2++;
}
long long int ans1 = ct1 + solve(i + len / 2, len / 2, d + 1);
long long int ans2 = ct2 + solve(i, len / 2, d + 1);
return min(ans1, ans2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int chu;
cin >> chu;
while (chu--) {
cin >> n >> s;
c = 'a';
cout << solve(0, n, 'a');
cout << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int n, m;
cin >> n >> m;
int x = 0;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
if (a > x) {
cout << "NO";
return 0;
}
x = max(x, b);
}
if (x == m)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, v[110], f[110], dp[11000][110], c[110][110];
int main() {
int cnt = 0, sum = 0, ans = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> v[i];
sum += v[i];
f[v[i]]++;
if (f[v[i]] == 1) cnt++;
}
c[0][0] = 1;
for (int i = 1; i <= n; i++) {
c[i][0] = c[i][i] = 1;
for (int j = 1; j < i; j++) {
c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
}
}
dp[0][0] = 1;
for (int i = 1; i <= n; i++) {
for (int j = sum - v[i]; j >= 0; j--)
for (int k = 0; k < i; k++) dp[j + v[i]][k + 1] += dp[j][k];
}
for (int i = 1; i <= 100; i++)
for (int j = 1; j <= f[i]; j++)
if (dp[i * j][j] == c[f[i]][j]) {
ans = max(ans, j);
if (j == f[i] && cnt == 2) ans = max(ans, n);
}
cout << ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int NICO = 1e6 + 7;
int n;
int pre[NICO], a[NICO];
long long dp[NICO];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int p = 1;
for (int i = 2; i <= n; i++) {
dp[i] = max(dp[p - 1] + abs(a[i] - a[p]), dp[p] + abs(a[i] - a[p + 1]));
if (a[i] <= a[i - 1] && a[i] <= a[i + 1]) p = i;
if (a[i] >= a[i - 1] && a[i] >= a[i + 1]) p = i;
}
cout << dp[n] << endl;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int k;
std::cin>>k;
int a[] = {1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51};
std::cout << a[k-1] << std::endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 200005, M = N - 5;
using ll = long long;
int n, m;
vector<int> g[N];
ll lp, rp;
int main() {
ios::sync_with_stdio(false);
cin >> n >> m >> lp >> rp;
for (int i = 1; i <= M; i++)
for (int j = i; j <= M; j += i) g[j].push_back(i);
int cl = m + 1, cr = m;
set<pair<int, int>> st;
for (int x = 1; x <= n; x++) {
ll l = lp / x, r = rp / x;
if (x * l < lp) ++l;
r = min(r, ll(m));
if (l > r) {
cout << "-1\n";
continue;
}
while (l < cl) {
--cl;
for (auto &i : g[cl]) st.insert({i, cl});
}
while (cr > r) {
for (auto &i : g[cr]) st.erase({i, cr});
--cr;
}
bool fl = 0;
for (auto &a : g[x]) {
auto it = st.upper_bound({a, INT_MAX});
if (it == st.end()) break;
int b = it->first, y = it->second;
if (ll(x / a) * b <= n) {
fl = 1;
cout << x << ' ' << y << ' ' << x / a * b << ' ' << y / b * a << '\n';
break;
}
}
if (!fl) {
cout << "-1\n";
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
char code[5][5];
for (int i = 0; i < 3; ++i) {
cin >> code[i];
}
if (code[0][0] == code[2][2] && code[0][2] == code[2][0] &&
code[0][1] == code[2][1] && code[1][0] == code[1][2]) {
cout << "YES\n";
} else {
cout << "NO\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
vector<long long int> x(n);
for (long long int i = 0; i < n; i++) cin >> x[i];
double ans = 0;
for (long long int i = 0; i < m; i++) {
long long int a, b, c;
cin >> a >> b >> c;
ans = max(ans, (double)(x[a - 1] + x[b - 1]) / c);
}
cout << fixed << setprecision(9) << ans << endl;
}
| 3 |
#include <iostream>
using namespace std;
int a[200005],qzh[200005];
int n,k;
inline bool pd(int x)
{
for(int i=1;i<=n;i++)
{
if(a[i]>=x) qzh[i]=qzh[i-1]+1;
else qzh[i]=qzh[i-1]-1;
}
int mn=n;
for(int i=k;i<=n;i++)
{
mn=min(mn,qzh[i-k]);
if(qzh[i]>mn) return 1;
}
return 0;
}
int main(int argc, char** argv) {
cin >> n >> k;
for(int i=1;i<=n;i++) cin >> a[i];
int l=1,r=n,ans=0;
while(l<=r)
{
int mid=(l+r)/2;
if(pd(mid)) ans=mid,l=mid+1;
else r=mid-1;
}
cout << ans;
return 0;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
vector<int> v(n, 0);
vector<int> cnt(33, 0);
int high = 0;
bool ans = true;
for (int i = 0; i < n; i++) {
cin >> v[i];
int j = 0;
int a = v[i];
while (a) {
if (a & 1) cnt[j]++;
j++;
a /= 2;
}
}
for (int i = 0; i < 33; i++) {
if (cnt[i] % 2) {
ans = false;
high = max(high, i);
}
}
if (ans) {
cout << "DRAW" << '\n';
continue;
}
int one = 0, zero = 0;
for (int i = 0; i < n; i++) {
if (v[i] & (1 << high))
one++;
else
zero++;
}
if (zero % 2 == 0 && one % 4 == 3) {
cout << "LOSE" << '\n';
} else
cout << "WIN" << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool isPrime(int n) {
if (n == 2 || n == 3 || n == 5) return true;
if (n % 2 == 0 || n % 3 == 0 || n % 5 == 0) return false;
for (int i = 7; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
void printA() { printf("Ashishgup\n"); }
void printB() { printf("FastestFinger\n"); }
int main() {
int T, n, m;
scanf("%d", &T);
while (T--) {
scanf("%d", &n);
switch (n) {
case 1:
printB();
break;
case 2:
printA();
break;
}
if (n <= 2) continue;
if (n & 1) {
printA();
continue;
}
m = 1;
while (n % 2 == 0) {
n /= 2;
m *= 2;
}
if (n == 1)
printB();
else if (m % 4 == 0)
printA();
else if (isPrime(n))
printB();
else
printA();
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string match = "abacaba";
string ans;
bool call(long long i, long long n, string s) {
long long j = i;
long long k = 0;
while (j < n && k < 7 && (s[j] == match[k] || s[j] == '?')) {
s[j] = match[k];
j++;
k++;
}
long long count = 0;
if (k == 7) {
for (long long i = 0; i < n; i++) {
if (s[i] == 'a') {
long long j = i;
long long k = 0;
while (j < n && k < 7 && s[j] == match[k]) {
j++;
k++;
}
if (k == 7) count++;
}
}
if (count > 1) return false;
for (long long i = 0; i < n; i++) {
if (s[i] == '?') s[i] = 'd';
}
cout << "YES\n";
cout << s << endl;
return true;
}
return false;
}
void solve() {
long long n;
cin >> n;
string s;
cin >> s;
long long count = 0;
for (long long i = 0; i < n; i++) {
if (s[i] == 'a') {
long long j = i;
long long k = 0;
while (j < n && k < 7 && s[j] == match[k]) {
j++;
k++;
}
if (k == 7) count++;
}
}
if (count > 1) {
cout << "NO" << endl;
return;
}
if (count == 1) {
for (long long i = 0; i < n; i++) {
if (s[i] == '?') s[i] = 'd';
}
cout << "YES\n" << s << endl;
return;
}
for (long long i = 0; i < n; i++) {
if (call(i, n, s)) {
return;
}
}
cout << "NO\n";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
cin >> t;
while (t--) {
solve();
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100100;
int f[maxn];
int main() {
int n, m, k;
while (scanf("%d%d%d", &n, &m, &k) != EOF) {
memset(f, 0, sizeof(f));
for (int i = 1; i <= n; i++) {
char ch;
scanf(" %c", &ch);
f[i] = ch - '0';
}
if ((f[m] + f[k]) % 2 == 0)
printf("0\n");
else
printf("1\n");
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct edg {
int from, to, next;
} b[500000 * 2 + 5], ob[500000 + 5], nb[500000 * 10 + 5];
int g[500000 + 5], cntb, n, m, k, group[500000 + 5], dis[500000 + 5], cntg,
cnte, belong[500000 + 5], ndis[500000 * 2 + 5];
int ng[500000 * 2 + 5], cntn;
long long ans;
bool ise[500000 + 5], chan[500000 + 5];
map<int, int> bh[500000 + 5];
map<int, int> xbh[500000 + 5];
set<int> ce[500000 + 5];
vector<int> bigb[500000 + 5];
vector<int> ning[500000 + 5];
void ade(int fr, int to) {
b[++cntb] = {fr, to, g[fr]};
g[fr] = cntb;
}
void ade2(int fr, int to) {
nb[++cntn] = {fr, to, ng[fr]};
ng[fr] = cntn;
}
bool ok;
void dfs(int now) {
for (int i = g[now]; i; i = b[i].next) {
if (group[b[i].to] != group[now]) continue;
if (dis[b[i].to] == -1)
dis[b[i].to] = dis[now] ^ 1, belong[b[i].to] = belong[now], dfs(b[i].to);
else if (dis[b[i].to] != (dis[now] ^ 1)) {
ok = false;
return;
}
if (!ok) return;
}
}
void dfs2(int now) {
for (int i = ng[now]; i; i = nb[i].next) {
if (ndis[nb[i].to] == -1)
ndis[nb[i].to] = ndis[now] ^ 1, dfs2(nb[i].to);
else if (ndis[nb[i].to] != (ndis[now] ^ 1)) {
ok = false;
return;
}
if (!ok) return;
}
}
void recov(int now) {
ndis[now] = -1;
for (int i = ng[now]; i; i = nb[i].next)
if (~ndis[nb[i].to]) recov(nb[i].to);
}
bool pd(int now) {
ok = true;
for (int i = 0; i < bigb[now].size(); i++) {
int xi = ob[bigb[now][i]].from, yi = ob[bigb[now][i]].to;
if (!ise[group[xi]] || !ise[group[yi]]) return false;
int bx = belong[xi], by = belong[yi];
ade2(bx + dis[xi] * 500000, by + dis[yi] * 500000);
ade2(by + dis[yi] * 500000, bx + dis[xi] * 500000);
ade2(bx, bx + 500000), ade2(bx + 500000, bx);
ade2(by, by + 500000), ade2(by + 500000, by);
}
for (int i = 0; i < bigb[now].size(); i++) {
int xi = ob[bigb[now][i]].from, yi = ob[bigb[now][i]].to;
int bx = belong[xi], by = belong[yi];
if (ndis[bx + dis[xi] * 500000] == -1)
ndis[bx + dis[xi] * 500000] = 0, dfs2(bx + dis[xi] * 500000);
if (ndis[by + dis[yi] * 500000] == -1)
ndis[by + dis[yi] * 500000] = 0, dfs2(by + dis[yi] * 500000);
}
for (int i = 0; i < bigb[now].size(); i++) {
int xi = ob[bigb[now][i]].from, yi = ob[bigb[now][i]].to;
int bx = belong[xi], by = belong[yi];
if (~ndis[bx + dis[xi] * 500000]) recov(bx + dis[xi] * 500000);
if (~ndis[by + dis[yi] * 500000]) recov(by + dis[yi] * 500000);
}
for (int i = 0; i < bigb[now].size(); i++) {
int xi = ob[bigb[now][i]].from, yi = ob[bigb[now][i]].to;
int bx = belong[xi], by = belong[yi];
ng[bx + 500000] = ng[bx] = ng[by] = ng[by + 500000] = 0;
}
cntn = 0;
return ok;
}
int main() {
memset(dis, -1, sizeof(dis));
memset(ndis, -1, sizeof(ndis));
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
scanf("%d", &group[i]);
ning[group[i]].push_back(i);
}
for (int i = 1, xi, yi; i <= m; i++) {
scanf("%d%d", &xi, &yi);
ade(xi, yi), ade(yi, xi);
if (group[xi] > group[yi]) swap(xi, yi);
ob[i].from = xi, ob[i].to = yi;
int gx = group[xi], gy = group[yi];
if (gx == gy) continue;
if (bh[gx].find(gy) == bh[gx].end()) bh[gx][gy] = ++cntg;
bigb[bh[gx][gy]].push_back(i);
}
for (int i = 1; i <= k; i++) {
ise[i] = true;
if (ning[i].size()) {
for (int j = 0; j < ning[i].size(); j++)
if (dis[ning[i][j]] == -1) {
ok = true;
dis[ning[i][j]] = 0;
belong[ning[i][j]] = ++belong[0];
dfs(ning[i][j]);
if (!ok) ise[i] = false;
}
}
if (ise[i]) ++cnte;
}
for (int i = 1, xi, yi; i <= m; i++) {
xi = ob[i].from, yi = ob[i].to;
int gx = group[xi], gy = group[yi];
if (!ise[gx] || !ise[gy] || gx == gy) continue;
ce[gx].insert(gy), ce[gy].insert(gx);
}
if (cnte) {
for (int i = 1; i <= k; i++)
if (ise[i]) ans += cnte - 1 - (int)ce[i].size();
}
ans >>= 1;
for (int i = 1; i <= cntg; i++)
if (pd(i)) ++ans;
printf("%lld", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
const int maxn = 2e5 + 10;
const int inf = 0x7fffffff;
const long long INF = 9E18;
const int mod = 1e9 + 7;
const long long mod2 = 1e9 + 9;
const int eps = 1e-7;
const double pi = acos(-1.0);
template <typename T>
inline void read(T &x) {
T f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-') f = -1;
for (x = 0; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
x *= f;
}
int tree[maxn << 2], kt[maxn];
void update(int x, int val) {
while (x <= maxn) {
tree[x] += val;
x += ((x) & (-x));
}
}
int query(int x) {
int ans = 0;
while (x > 0) {
ans += tree[x];
x -= ((x) & (-x));
}
return ans;
}
int main() {
int n;
scanf("%d", &n);
for (int num = 1; num <= 2; num++) {
for (int i = 1; i <= n; i++) update(i, 1);
for (int i = 1; i <= n; i++) {
int x;
read(x);
update(++x, -1);
kt[i] += query(x);
}
}
for (int i = n; i >= 1; i--) {
kt[i - 1] += kt[i] / (n - i + 1);
kt[i] %= (n - i + 1);
}
for (int i = 1; i <= n; i++) update(i, 1);
for (int i = 1; i <= n; i++) {
int l = 1, r = n;
int ans = -1;
while (l <= r) {
int mid = (l + r) >> 1;
if (query(mid) >= kt[i] + 1) {
ans = mid;
r = mid - 1;
} else
l = mid + 1;
}
update(ans, -1);
cout << ans - 1 << " ";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 202020;
int a[maxn];
int sol[maxn * 2][2];
int n, m, p;
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] == m) p = i;
}
memset(sol, 0, sizeof(sol));
int sum = 0;
sol[0 + n][0] = 1;
for (int i = p - 1; i >= 0; i--) {
if (a[i] > a[p])
sum--;
else
sum++;
sol[sum + n][0]++;
}
sum = 0;
sol[0 + n][1] = 1;
for (int i = p + 1; i < n; i++) {
if (a[i] > a[p])
sum++;
else
sum--;
sol[sum + n][1]++;
}
long long ans = 0;
for (int i = 0; i <= 2 * n; i++)
ans += (long long)sol[i][0] * (long long)(sol[i][1] + sol[i + 1][1]);
printf("%lld\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
while (cin >> n >> k) {
long long t[n];
for (int i = 0; i < (int)n; i++) cin >> t[i];
sort(t, t + n);
set<long long> S;
long long cnt = 0;
for (int i = 0; i < (int)n; i++) {
if (S.count(t[i])) continue;
cnt++;
S.insert(t[i] * k);
}
cout << cnt << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int t;
while(cin>>t&&t){
int n,s,f,sum=0;
cin>>n;
for(int i=0;i<n;i++){
cin>>s>>f;
sum+=f-s;
}
if(sum>=t)cout<<"OK"<<endl;
else cout<<t-sum<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v;
long long w;
};
long long MOD = 1000000007;
long long _MOD = 1000000009;
int INF = INT_MAX / 10;
double EPS = 1e-10;
int main() {
int N, M;
cin >> N >> M;
vector<vector<int> > G(N);
vector<vector<int> > d(N, vector<int>(N, INF));
for (int u = 0; u < N; u++) d[u][u] = 0;
while (M--) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
G[u].push_back(v);
G[v].push_back(u);
d[u][v] = d[v][u] = 1;
}
for (int k = 0; k < N; k++)
for (int u = 0; u < N; u++)
for (int v = 0; v < N; v++) d[u][v] = min(d[u][v], d[u][k] + d[k][v]);
double ans = 0;
for (int x = 0; x < N; x++) {
double sum = 0;
for (int k = 0; k < N; k++) {
vector<double> p(N);
bool ok = false;
for (int u = 0; u < N; u++)
if (d[x][u] == k)
for (int v : G[u]) ok = true, p[v] += 1.0 / N / G[u].size();
if (!ok) continue;
double ma = 1.0 / N;
vector<int> vs;
for (int u = 0; u < N; u++)
if (k - 1 <= d[x][u] && d[x][u] <= k + 1) vs.push_back(u);
vector<double> q(N);
for (int y = 0; y < N; y++) {
double sum = 0;
for (int u : vs) {
int _k = d[y][u];
if (p[u] > q[_k]) sum += p[u] - q[_k], q[_k] = p[u];
}
for (int u : vs) {
int _k = d[y][u];
q[_k] = 0;
}
ma = max(ma, sum);
}
sum += ma;
}
ans = max(ans, sum);
}
printf("%.10f\n", ans);
}
| 4 |
#include<map>
#include<set>
#include<cmath>
#include<deque>
#include<queue>
#include<stack>
#include<string>
#include<bitset>
#include<cstdio>
#include<vector>
#include<iomanip>
#include<cstring>
#include<sstream>
#include<iostream>
#include<algorithm>
#include<unordered_map>
//#include<bits/stdc++.h>
#define fi first
#define se second
#define eps 1e-8
#define ll long long
#define ull unsigned long long
#define pb push_back
#define inf 0x3f3f3f3f
#define INF 0x3f3f3f3f3f3f3f3f
#define P pair<ll, ll>
#define pi acos(-1)
#define lson l,mid,rt*2
#define rson mid+1,r,rt*2+1
#define lowbit(x) (x&(-x))
#define SZ(x) ((ll)(x).size())
#define met(a,x) memset(a,x,sizeof(a))
#define openin(x) freopen(x, "r", stdin)
#define openout(x) freopen(x, "w",stdout)
#define rep(i,a,b) for(int i = a;i <= b;i++)
#define bep(i,a,b) for(int i = a;i >= b;i--)
#define ios() ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
using namespace std;
ll mod = 998244353;
ll gcd(ll a, ll b) { return b == 0 ? a : gcd(b, a % b); }
ll lcm(ll a, ll b) { return a * b / gcd(a, b); }
int days[15] = { 0,31,28,31,30,31,30,31,31,30,31,30,31 };
int is_leapyear(int y) { return y % 400 == 0 || (y % 4 == 0 && y % 100 != 0); }
int dx[8] = { 0,0,1,-1,-1,-1,1,1 };
int dy[8] = { 1,-1,0,0,-1,1,-1,1 };
inline ll read() {
ll x = 0, sign = 1; char ch = getchar();
for (; !isdigit(ch); ch = getchar()) if (ch == '-') sign = -1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return sign * x;
}
inline void write(ll x) {
char r[30];
int t = 0;
if (x < 0) {
x = -x;
putchar('-');
}
do {
r[t++] = x % 10 + '0';
x /= 10;
} while (x);
while (t)putchar(r[--t]);
}
inline void writesp(ll x) { write(x); putchar(' '); }
inline void writeln(ll x) { write(x); putchar('\n'); }
ll qpow(ll a, ll b) {
ll ans = 1;
while (b) {
if (b & 1)ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
const int N = 300010;
int a[N],vis[N];
int f[N];
int main() {
int T;cin >> T;
while(T--){
int n;cin >> n;
rep(i,1,n)vis[i] = f[i] = 0;
int mx = 0;
int k = 0;
rep(i,1,n){
cin >> a[i];
vis[a[i]]++;
if(i > 1 && a[i] == a[i-1])f[a[i]] += 2,k++;
mx = max(mx,vis[a[i]]);
}
f[a[1]]++;f[a[n]]++;
a[n+1] = a[1];
int tot = 0;
rep(i,1,n){
if(a[i] == a[i+1]){
tot++;
}
}
if(mx > n - mx + 1)cout << -1 << endl;
else{
cout << k + max(0,*max_element(f+1,f+1+n) - k - 2) << endl;
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e8;
const long double pi = 3.141592653589793238;
int MOD = 998244353;
const int N = 1e6 + 22;
int n, k, p[N], q[N];
bool vis[N] = {0};
int seg[4 * N] = {0}, lazy[4 * N] = {0};
int fun(int a, int b) { return min(a, b); }
void rangeUpdate(int ind, int low, int high, int l, int r, int val) {
if (lazy[ind] != 0) {
seg[ind] += lazy[ind];
if (low != high) {
lazy[2 * ind + 1] += lazy[ind];
lazy[2 * ind + 2] += lazy[ind];
}
lazy[ind] = 0;
}
if (r < low || l > high || low > high) return;
if (low >= l && high <= r) {
seg[ind] += val;
if (low != high) {
lazy[2 * ind + 1] += val;
lazy[2 * ind + 2] += val;
}
return;
}
int mid = (low + high) / 2;
rangeUpdate(2 * ind + 1, low, mid, l, r, val);
rangeUpdate(2 * ind + 2, mid + 1, high, l, r, val);
seg[ind] = fun(seg[2 * ind + 1], seg[2 * ind + 2]);
}
int querylazy(int ind, int low, int high, int l, int r) {
if (lazy[ind] != 0) {
seg[ind] += lazy[ind];
if (low != high) {
lazy[2 * ind + 1] += lazy[ind];
lazy[2 * ind + 2] += lazy[ind];
}
lazy[ind] = 0;
}
if (r < low || l > high || low > high) return inf;
if (l <= low && high <= r) return seg[ind];
int mid = (low + high) / 2;
return fun(querylazy(2 * ind + 1, low, mid, l, r),
querylazy(2 * ind + 2, mid + 1, high, l, r));
}
void solve() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> p[i];
for (int i = 0; i < n; i++) cin >> q[i];
int cnt = 0;
for (int i = 0; i < n; i++) {
int mn = querylazy(0, 0, n, 0, n);
if (mn == 0) {
cnt++;
vis[i] = 1;
}
rangeUpdate(0, 0, n, p[i], p[i], 1);
rangeUpdate(0, 0, n, q[i], q[i], -1);
}
vector<char> ans(n + 1);
if (cnt >= k) {
cout << "YES" << '\n';
char ch = 'a' - 1;
for (int i = 0; i < n; i++) {
if (vis[i] && ch < 'z') ch++;
ans[p[i]] = ch;
}
for (int i = 1; i <= n; i++) cout << ans[i];
cout << '\n';
return;
}
cout << "NO" << '\n';
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int nega = 1;
while (!isdigit(ch)) {
if (ch == '-') nega = -1;
ch = getchar();
}
int ans = 0;
while (isdigit(ch)) {
ans = ans * 10 + ch - 48;
ch = getchar();
}
if (nega == -1) return -ans;
return ans;
}
int add(int x, int y) {
return x + y >= 1000000007 ? x + y - 1000000007 : x + y;
}
int sub(int x, int y) { return x - y < 0 ? x - y + 1000000007 : x - y; }
int mul(int x, int y) { return 1LL * x * y % 1000000007; }
int qpow(int x, int y) {
int ans = 1;
while (y) {
if (y & 1) ans = mul(ans, x);
x = mul(x, x);
y >>= 1;
}
return ans;
}
int inv(int x) { return qpow(x, 1000000007 - 2); }
int pw[600005], ipw[600005], i2 = 500000004;
int p[600005], pos[600005], val[600005], n, Q, cnt;
pair<int, int> v[600005];
struct Node {
int pw, l, r, val;
};
Node merge(Node x, Node y) {
Node ans;
ans.pw = mul(x.pw, y.pw);
ans.l = add(x.l, mul(x.pw, y.l));
ans.r = add(y.r, mul(y.pw, x.r));
ans.val = add(add(mul(x.pw, y.val), mul(x.val, y.pw)), mul(x.l, y.r));
return ans;
}
Node t[600005 * 4];
int d[600005];
void build(int u, int l, int r) {
if (l == r) {
t[u].pw = 1;
return;
}
int mid = (l + r) / 2;
build((u << 1), l, mid);
build((u << 1 | 1), mid + 1, r);
t[u] = merge(t[(u << 1)], t[(u << 1 | 1)]);
}
void update(int u, int l, int r, int p, int opt) {
if (l == r) {
if (opt == 1)
t[u] = (Node){2, d[l], d[l], 0};
else
t[u] = (Node){1, 0, 0, 0};
return;
}
int mid = (l + r) / 2;
if (p <= mid)
update((u << 1), l, mid, p, opt);
else
update((u << 1 | 1), mid + 1, r, p, opt);
t[u] = merge(t[(u << 1)], t[(u << 1 | 1)]);
}
void print() { printf("%d\n", mul(t[1].val, ipw[n])); }
signed main() {
pw[0] = 1;
for (int i = 1; i < 600005; i++) pw[i] = add(pw[i - 1], pw[i - 1]);
ipw[0] = 1;
for (int i = 1; i < 600005; i++) ipw[i] = mul(ipw[i - 1], i2);
cin >> n;
for (int i = 1; i <= n; i++) p[i] = read(), v[++cnt] = make_pair(p[i], i);
cin >> Q;
for (int i = 1; i <= Q; i++) {
pos[i] = read(), val[i] = read();
v[++cnt] = make_pair(val[i], i + n);
}
sort(v + 1, v + cnt + 1);
for (int i = 1; i <= n; i++)
p[i] = lower_bound(v + 1, v + cnt + 1, make_pair(p[i], i)) - v;
for (int i = 1; i <= Q; i++)
val[i] = lower_bound(v + 1, v + cnt + 1, make_pair(val[i], i + n)) - v;
for (int i = 1; i <= cnt; i++) d[i] = v[i].first;
build(1, 1, cnt);
for (int i = 1; i <= n; i++) update(1, 1, cnt, p[i], 1);
print();
for (int i = 1; i <= Q; i++) {
update(1, 1, cnt, p[pos[i]], 0);
p[pos[i]] = val[i];
update(1, 1, cnt, p[pos[i]], 1);
print();
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,x,y) for(int i=(x);i<(y);++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define show(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define show(x)
#endif
typedef long long int ll;
typedef pair<int,int> pii;
template<typename T> using vec=std::vector<T>;
const int inf=1<<30;
const long long int infll=1LL<<62;
const double eps=1e-9;
const int dx[]={1,0,-1,0},dy[]={0,1,0,-1};
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec){
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
void solve(){
int m,n;
cin >> m >> n;
vector<vector<double>> win(m,vector<double>(n));
rep(i,0,m) rep(j,0,n) cin >> win[i][j];
vector<vector<double>> memo(1<<m,vector<double>(n+1));
vector<vector<bool>> done(1<<m,vector<bool>(n+1));
function<double(int,int)> rec=[&](int s,int k){
if(done[s][k]) return memo[s][k];
done[s][k]=true;
if(k==n) return memo[s][k]=1;
double res=0;
bitset<16> bs(s);
rep(i,0,m){
if(bs[i]) continue;
bs[i].flip();
double p=1,tmp=0;
rep(j,k,n){
tmp+=rec(bs.to_ulong(),j)*p*(1-win[i][j]);
p*=win[i][j];
}
tmp+=rec(bs.to_ulong(),n)*p;
res=max(res,tmp);
bs[i].flip();
}
return memo[s][k]=res;
};
cout << rec(0,0) << endl;
}
int main(){
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
solve();
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-8;
vector<string> parse(string s, string c) {
int len = c.length(), p = -len, np;
vector<string> ans;
do {
np = s.find(c, p + len);
ans.push_back(s.substr(p + len, np - p - len));
p = np;
} while (p != string::npos);
return ans;
}
bool row_in[200009], col_in[200009];
int row_L[200009], row_R[200009];
int col_L[200009], col_R[200009];
int row, col, Q;
vector<pair<char, int> > query;
int main() {
cin >> col >> row >> Q;
query.resize(Q);
memset(row_in, 0, sizeof(row_in));
;
memset(col_in, 0, sizeof(col_in));
;
memset(row_R, -1, sizeof(row_R));
;
memset(row_L, -1, sizeof(row_L));
;
memset(col_L, -1, sizeof(col_L));
;
memset(col_R, -1, sizeof(col_R));
;
row_in[0] = row_in[row] = true;
col_in[0] = col_in[col] = true;
for (int i = 0; i < Q; i++) {
cin >> query[i].first >> query[i].second;
if (query[i].first == 'H')
row_in[query[i].second] = true;
else
col_in[query[i].second] = true;
}
int prev = -1;
for (int i = 0; i <= row; i++)
if (row_in[i]) {
if (prev != -1) {
row_L[i] = prev;
row_R[prev] = i;
}
prev = i;
}
prev = -1;
for (int i = 0; i <= col; i++)
if (col_in[i]) {
if (prev != -1) {
col_L[i] = prev;
col_R[prev] = i;
}
prev = i;
}
vector<long long> ans;
long long max_row = 0, max_col = 0;
for (int i = 1; i <= row; i++)
if (row_in[i]) {
max_row = max(max_row, (long long)(i - row_L[i]));
}
for (int i = 1; i <= col; i++)
if (col_in[i]) {
max_col = max(max_col, (long long)(i - col_L[i]));
}
ans.push_back(max_col * max_row);
for (int i = ((int)(query.size())) - 1; i > 0; i--) {
if (query[i].first == 'H') {
long long curr = query[i].second;
long long prev = row_L[curr];
long long next = row_R[curr];
max_row = max(max_row, next - prev);
row_L[next] = prev;
row_R[prev] = next;
} else {
long long curr = query[i].second;
long long prev = col_L[curr];
long long next = col_R[curr];
max_col = max(max_col, next - prev);
col_L[next] = prev;
col_R[prev] = next;
}
ans.push_back(max_col * max_row);
}
for (int i = ((int)(ans.size())) - 1; i >= 0; i--) cout << ans[i] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4005;
const int M = 998244353;
int ans, f[maxn], C[maxn][maxn], n, m, q, dx[maxn], dy[maxn], w, tmp[maxn], sx,
sy;
bool x[maxn], y[maxn];
void init() {
for (int i = 0; i < maxn; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % M;
}
f[0] = 1;
for (int i = 1; i < maxn; i++) f[i] = 1ll * f[i - 1] * i % M;
}
void add(int &x, int y) {
x += y;
if (x >= M) x -= M;
}
int main() {
init();
scanf("%d%d%d", &n, &m, &q);
q *= 2;
while (q--) {
int a, b;
scanf("%d%d", &a, &b);
x[a] = 1;
y[b] = 1;
}
x[n + 1] = y[m + 1] = 1;
dx[0] = 1;
w = 0;
for (int i = 1; i <= n + 1; i++) {
if (!x[i])
sx++, w++;
else if (w) {
for (int j = 0; j <= n / 2; j++) tmp[j] = dx[j], dx[j] = 0;
for (int j = 0; j <= n / 2; j++)
if (tmp[j])
for (int k = 0; k <= w / 2; k++) {
add(dx[j + k], 1ll * tmp[j] * C[w - k][k] % M);
}
w = 0;
}
}
dy[0] = 1;
w = 0;
for (int i = 1; i <= m + 1; i++) {
if (!y[i])
sy++, w++;
else if (w) {
for (int j = 0; j <= m / 2; j++) tmp[j] = dy[j], dy[j] = 0;
for (int j = 0; j <= m / 2; j++)
if (tmp[j])
for (int k = 0; k <= w / 2; k++) {
add(dy[j + k], 1ll * tmp[j] * C[w - k][k] % M);
}
w = 0;
}
}
for (int i = 0; i <= n / 2; i++) dx[i] = 1ll * dx[i] * f[i] % M;
for (int i = 0; i <= m / 2; i++) dy[i] = 1ll * dy[i] * f[i] % M;
for (int i = 0; i <= n / 2; i++)
if (dx[i])
for (int j = 0; j <= m / 2; j++)
if (dy[j]) {
add(ans, 1ll * dx[i] * dy[j] % M * C[sx - i * 2][j] % M *
C[sy - j * 2][i] % M);
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
map<pair<int,int>,long long >m;
vector<pair<int,int> >v;
int main(){
long long n,x,y,ans=0;
cin>>n;
for(long long i=0;i<n;i++){
cin>>x>>y;
v.push_back({x,y});
}
sort(v.begin(),v.end());
for(int i=0;i<n;i++){
for(int j=i+1;j<n;j++){
x=v[j].first-v[i].first;
y=v[j].second-v[i].second;
m[{x,y}]++;
ans=max(ans,m[{x,y}]);
}
}
cout<<n-ans;
}
| 0 |
#include <cstdio>
#include <cstring>
#include <vector>
#include <string>
#include <iostream>
using namespace std;
struct data{
int next[4],cnt;
data(int prx=-1,int nex=-1,int pry=-1,int ney=-1){
next[0]=prx;
next[2]=nex;
next[1]=pry;
next[3]=ney;
cnt=0;
}
};
int h,w;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
string dirchar="RDLU";
int fie[11][11];
int s,sdir;
int cnt;
string res;
void dfs(int v,int dir,vector<data> dat,string str){
if(str.size()==cnt-1){
res=str;
return;
}
for(int i=-1;i<=1;i++){
int ndir=(dir+4+i)%4;
if(dat[v].next[ndir]!=-1){
vector<data> nex;
nex=dat;
int f=nex[v].next[ndir];
int t=nex[v].next[(ndir+2)%4];
if(t!=-1){
nex[t].next[ndir]=f;
if(f==-1)nex[t].cnt--;
if(nex[t].cnt==0)continue;
}
if(f!=-1){
nex[f].next[(ndir+2)%4]=t;
if(t==-1)nex[f].cnt--;
}
int k=nex[v].next[(ndir+1)%4];
int l=nex[v].next[(ndir+3)%4];
if(k!=-1){
nex[k].next[(ndir+3)%4]=l;
if(l==-1)nex[k].cnt--;
if(nex[k].cnt==0)continue;
}
if(l!=-1){
nex[l].next[(ndir+1)%4]=k;
if(k==-1)nex[l].cnt--;
if(nex[l].cnt==0)continue;
}
dfs(f,ndir,nex,str+dirchar[ndir]);
}
}
}
int main(void){
scanf("%d %d",&h,&w);
vector<data> dat;
for(int i=0;i<h;i++){
string str;
cin >> str;
for(int j=0;j<w;j++){
if(str[j]=='.')fie[j][i]=-1;
for(int k=0;k<4;k++){
if(str[j]==dirchar[k]){
s=cnt;
sdir=k;
dat.push_back(data());
fie[j][i]=cnt++;
}
}
if(str[j]=='o'){
dat.push_back(data());
fie[j][i]=cnt++;
}
}
}
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(fie[j][i]==-1)continue;
int k=j+1;
while(k<w){
if(fie[k][i]>=0){
dat[fie[j][i]].next[0]=fie[k][i];
dat[fie[j][i]].cnt++;
break;
}
k++;
}
k=j-1;
while(k>=0){
if(fie[k][i]>=0){
dat[fie[j][i]].next[2]=fie[k][i];
dat[fie[j][i]].cnt++;
break;
}
k--;
}
}
}
for(int i=0;i<w;i++){
for(int j=0;j<h;j++){
if(fie[i][j]==-1)continue;
int k=j+1;
while(k<h){
if(fie[i][k]>=0){
dat[fie[i][j]].next[1]=fie[i][k];
dat[fie[i][j]].cnt++;
break;
}
k++;
}
k=j-1;
while(k>=0){
if(fie[i][k]>=0){
dat[fie[i][j]].next[3]=fie[i][k];
dat[fie[i][j]].cnt++;
break;
}
k--;
}
}
}
dfs(s,sdir,dat,"");
cout << res << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
int main() {
int i, n, l, r, c;
int a[100005] = {0}, b[100005] = {0};
scanf("%d %d %d", &n, &l, &r);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++) {
scanf("%d", &b[i]);
}
c = 0;
for (i = 1; i < l; i++) {
if (a[i] != b[i]) c = 1;
}
for (i = r + 1; i <= n; i++) {
if (a[i] != b[i]) c = 1;
}
if (c == 1) printf("LIE");
if (c == 0) printf("TRUTH");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
map<string, int> h, type;
int a[1010], b[1010][10], c[1010], d[1010], n, m, t, tot, i, j, k, tp,
ans[1010], nam;
char s[20], na[20];
void get(char s[20], char end) {
int n = 0;
char ch;
while (ch = getchar())
if (ch == end)
break;
else if (ch != ' ')
s[n++] = ch;
s[n] = 0;
}
bool get(char s[20], char end, char eoln) {
int n = 0;
char ch;
while (ch = getchar())
if (ch == end || ch == eoln)
break;
else if (ch != ' ')
s[n++] = ch;
s[n] = 0;
return ch == end;
}
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
scanf("\nvoid");
get(s, '(');
if (!h[s]) h[s] = ++tot;
a[i] = h[s];
while (get(s, ',', ')')) {
tp = 0;
if (s[0] == 'i') tp = 1;
if (s[0] == 's') tp = 2;
if (s[0] == 'd') tp = 3;
b[i][++c[i]] = tp;
}
tp = 0;
if (s[0] == 'i') tp = 1;
if (s[0] == 's') tp = 2;
if (s[0] == 'd') tp = 3;
b[i][++c[i]] = tp;
}
scanf("%d\n", &m);
for (i = 1; i <= m; i++) {
scanf("%s%s", s, na);
if (s[0] == 'i') tp = 1;
if (s[0] == 's') tp = 2;
if (s[0] == 'd') tp = 3;
type[na] = tp;
}
scanf("%d\n", &m);
for (i = 1; i <= m; i++) {
get(s, '(');
t = 0;
nam = h[s];
ans[i] = 0;
while (get(s, ',', ')')) d[++t] = type[s];
d[++t] = type[s];
for (j = 1; j <= n; j++)
if (nam == a[j] && t == c[j]) {
for (k = 1; k <= t; k++)
if (b[j][k] && b[j][k] != d[k]) break;
if (k <= t) continue;
ans[i]++;
}
scanf("\n");
}
for (i = 1; i <= m; i++) printf("%d\n", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std; namespace {
typedef long long T;
const int maxN = 3e5 + 5;
int n, a;
int cnt[maxN];
int ans;
void Solve(int test) {
for(int i = 1; i <= n * 2 + 5; i++)
cnt[i] = 0;
cin >> n, ans = 0;
for(int i = 1; i <= n; i++)
cin >> a, ans += cnt[a]++ == 0;
for(int i = n * 2; i >= 1; i--) {
if(cnt[i] && !cnt[i + 1]) {
ans += cnt[i] > 1;
cnt[i]--;
cnt[i + 1]++;
}
}
cout << ans << endl;
}
}
auto main() -> int {
cin.tie(nullptr)->sync_with_stdio(false);
int t(1); cin >> t;
for(int i = 1; i <= t; i++) Solve(i);
cout << flush;
return 0;
} | 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n + 1) / 2 - 1;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int dif[1010];
int K, N;
int main() {
while (scanf("%d%d", &N, &K) != EOF) {
int solve = K, ans = 0;
for (int i = 0; i < N; i++) scanf("%d", &dif[i]);
sort(dif, dif + N);
for (int i = 0; i < N; i++) {
if (2 * solve >= dif[i])
solve = max(dif[i], solve);
else {
while (dif[i] > 2 * solve && i < N) {
ans++;
solve *= 2;
}
solve = dif[i];
}
}
printf("%d\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
map<double, long long> ko;
int n, k;
cin >> n >> k;
double a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
double p[n];
for (int i = 0; i < n - k; i++) {
p[i] = abs(a[i + k] - a[i]) / 2;
ko[abs(a[i + k] - a[i]) / 2] = abs(a[i + k] + a[i]) / 2;
}
sort(p, p + n - k);
cout << ko[p[0]] << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
int k;
double v[300 + 1], d[300 + 1], aux[300 + 1];
void combina(double a[], double b[]) {
for (int i = 0; i <= k; i++) aux[i] = 0;
for (int i = 0; i <= k; i++)
for (int j = 0; j <= k; j++) aux[i ^ j] += a[i] * b[j];
for (int i = 0; i <= k; i++) a[i] = aux[i];
}
int main() {
int n, aux = 1;
bool f;
scanf("%d%d", &n, &k);
while (aux <= k) aux *= 2;
for (int i = 0; i <= k; i++) scanf("%lf", &v[i]);
k = aux;
f = 1;
while (n > 0) {
if (n % 2) {
if (f) {
f = 0;
for (int i = 0; i <= k; i++) d[i] = v[i];
} else
combina(d, v);
}
combina(v, v);
n /= 2;
}
printf("%.12lf\n", 1 - d[0]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000")
using namespace std;
int i, j, k, n;
vector<int> v[500000];
int ans[500000];
int q[500000];
int ma[500000];
int rF, rS;
void findQ(int i, int p) {
int j, k;
q[i] = 1;
for (k = 0; k < v[i].size(); k++) {
j = v[i][k];
if (j == p) continue;
findQ(j, i);
q[i] += q[j];
}
}
void findMa(int i, int p) {
int j, k;
ma[i] = 2 * q[i] <= n ? q[i] : 0;
for (k = 0; k < v[i].size(); k++) {
j = v[i][k];
if (j == p) continue;
findMa(j, i);
if (ma[j] > ma[i]) ma[i] = ma[j];
}
}
void rec(int i, int p, int curMa, int son) {
int j, k;
int lim = n / 2;
int maF = -1, maS = -1;
for (k = 0; k < v[i].size(); k++) {
j = v[i][k];
if (j == p) continue;
if (maF == -1)
maF = j;
else if (maS == -1) {
maS = j;
if (ma[maS] > ma[maF]) swap(maS, maF);
} else {
if (ma[maS] < ma[j]) maS = j;
if (ma[maS] > ma[maF]) swap(maS, maF);
}
}
for (k = 0; k < v[i].size(); k++) {
j = v[i][k];
if (j == p) continue;
vector<int> w;
if (n - q[j] <= lim) w.push_back(n - q[j]);
w.push_back(curMa);
if (maF != -1 && maF != j) w.push_back(ma[maF]);
if (maS != -1 && maS != j) w.push_back(ma[maS]);
sort(w.begin(), w.end());
rec(j, i, w.back(), son == -1 ? j : son);
}
for (k = 0; k < v[i].size(); k++) {
j = v[i][k];
if (j == p) continue;
if (q[j] > lim) break;
}
if (k < v[i].size()) {
ans[i] = ma[j] <= lim && q[j] - ma[j] <= lim;
return;
}
if (n - q[i] <= lim) {
ans[i] = 1;
return;
}
int someMa = curMa;
if (rF != -1 && rF != son) someMa = max(someMa, ma[rF]);
if (rS != -1 && rS != son) someMa = max(someMa, ma[rS]);
ans[i] = someMa <= lim && n - q[i] - someMa <= lim;
}
int main() {
scanf("%d", &n);
for (k = 1; k < n; k++) {
scanf("%d%d", &i, &j);
i--;
j--;
v[i].push_back(j);
v[j].push_back(i);
}
findQ(0, -1);
findMa(0, -1);
rF = rS = -1;
for (k = 0; k < v[0].size(); k++) {
j = v[0][k];
if (rF == -1)
rF = j;
else if (rS == -1) {
rS = j;
if (ma[rS] > ma[rF]) swap(rS, rF);
} else {
if (ma[rS] < ma[j]) rS = j;
if (ma[rS] > ma[rF]) swap(rS, rF);
}
}
rec(0, -1, 0, -1);
for (i = 0; i < n; i++) printf("%d%c", ans[i], i == n - 1 ? '\n' : ' ');
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int comb(int n) { return (n * (n - 1)) / 2; }
int main() {
int n;
cin >> n;
char a[n][n];
int ans = 0, count = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> a[i][j];
if (a[i][j] == 'C') {
count++;
}
}
if (count > 1) {
ans += comb(count);
}
count = 0;
}
for (int j = 0; j < n; j++) {
for (int i = 0; i < n; i++) {
if (a[i][j] == 'C') {
count++;
}
}
if (count > 1) {
ans += comb(count);
}
count = 0;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
const long long md = 1e9 + 7;
const int Inf = 1e9;
const long long Inf64 = 1e18;
const long long MaxN = 1e5 + 10;
const long long LogN = 21;
const long long MaxM = 5e5 + 10;
const long double eps = 1e-7;
const long long dx[4] = {0, 1, 0, -1};
const long long dy[4] = {1, 0, -1, 0};
const long long ddx[4] = {1, 1, -1, -1};
const long long ddy[4] = {1, -1, 1, -1};
const long double Pi = acos(-1);
using namespace std;
template <typename T>
istream &operator>>(istream &in, pair<T, T> &a) {
in >> a.first >> a.second;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, pair<T, T> a) {
out << a.first << ' ' << a.second;
return out;
}
template <typename T>
istream &operator>>(istream &in, vector<T> &Mt) {
for (T &a : Mt) in >> a;
return in;
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> Mt) {
for (int i = 0; i < Mt.size(); i++) {
out << Mt[i];
if (i != Mt.size()) out << ' ';
}
out << '\n';
return out;
}
inline long long Mod(long long &a, long long m = md) {
while (a >= m) a -= m;
return a;
}
inline long long gcd(long long a, long long b) {
while (a) {
b %= a;
swap(a, b);
}
return b;
}
inline long long gcdex(long long a, long long mod = md) {
long long g = mod, r = a, x = 0, y = 1;
while (r != 0) {
long long q = g / r;
g %= r;
swap(g, r);
x -= q * y;
swap(x, y);
}
return x < 0 ? x + mod : x;
}
inline long long binpow(long long a, long long n, long long m = md) {
long long res = 1;
while (n) {
if (n & 1) {
res *= a;
res %= m;
}
a *= a;
a %= m;
n >>= 1;
}
return res % md;
}
vector<long long> Gr[MaxN];
long long dep[MaxN];
long long dp[MaxN][LogN];
long long Size[MaxN];
long long dfs(long long v, long long p = 0) {
dp[v][0] = p;
for (int i = 1; i < LogN; i++) {
dp[v][i] = dp[dp[v][i - 1]][i - 1];
}
dep[v] = dep[p] + 1;
long long s = 1;
for (long long to : Gr[v]) {
if (to == p) continue;
s += dfs(to, v);
}
Size[v] = s;
return s;
}
long long LCA(long long a, long long b) {
if (dep[b] > dep[a]) swap(a, b);
for (int i = LogN - 1; i >= 0; i--) {
if (dep[dp[a][i]] >= dep[b]) {
a = dp[a][i];
}
}
if (a != b) {
for (int i = LogN - 1; i >= 0; i--) {
if (dp[a][i] != dp[b][i]) {
a = dp[a][i];
b = dp[b][i];
}
}
a = dp[a][0];
b = dp[b][0];
}
return b;
}
long long dist(long long a, long long b) { return dep[a] - dep[b]; }
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed, cout.precision(20);
{
long long N;
cin >> N;
for (int i = 0; i < N - 1; i++) {
long long a, b;
cin >> a >> b;
Gr[a].push_back(b);
Gr[b].push_back(a);
}
dfs(1, 0);
long long Q;
cin >> Q;
while (Q--) {
long long a, b;
cin >> a >> b;
if (a == b) {
cout << N << '\n';
continue;
}
long long l = LCA(a, b);
long long da = dist(a, l);
long long db = dist(b, l);
if ((da + db) & 1) {
cout << 0 << '\n';
continue;
}
if (da == db) {
da--;
db--;
long long t = a;
long long k = b;
for (int i = LogN - 1; i >= 0; i--) {
if ((1 << i) <= da) {
k = dp[k][i];
t = dp[t][i];
da -= 1 << i;
}
}
cout << N - Size[k] - Size[t] << '\n';
continue;
}
if (dep[a] < dep[b]) swap(a, b);
long long d = da + db;
long long t = d / 2;
long long k = d / 2 - 1;
long long v = a;
long long u = a;
for (int i = LogN - 1; i >= 0; i--) {
if ((1 << i) <= t) {
v = dp[v][i];
t -= (1 << i);
}
}
for (int i = LogN - 1; i >= 0; i--) {
if ((1 << i) <= k) {
u = dp[u][i];
k -= (1 << i);
}
}
cout << Size[v] - Size[u] << '\n';
}
}
END:
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
constexpr int N = 1e7 + 5;
int d[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int a, n;
cin >> a >> n;
int b = a + n - 1;
for (int i = 1; i * i <= b; i++) {
int x = i * i;
for (int j = a / x * x; j <= b; j += x) {
d[j] = x;
}
}
LL result = 0;
for (int i = a; i <= b; i++) {
result += i / d[i];
}
cout << result << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4000004;
int l, r, p;
int prime[111], js;
int n, a[N], f[N];
int b[N], ans;
bool cn[111];
void get_prime(int n) {
for (int i = 2; i <= n; ++i) {
if (!cn[i]) prime[++js] = i;
for (int j = 1; j <= js && prime[j] * i <= n; ++j) {
cn[prime[j] * i] = 1;
if (i % prime[j] == 0) break;
}
}
}
void dfs(int u, int v) {
a[++n] = u;
for (int i = v; i <= js; ++i)
if (u > r / prime[i])
return;
else
dfs(u * prime[i], i);
}
int main() {
scanf("%d%d%d", &l, &r, &p);
get_prime(p - 1);
dfs(1, 1);
sort(a + 1, a + n + 1);
memset(f, 55, sizeof(f));
f[1] = 0;
for (int i = 2; i <= p - 1; ++i)
for (int j = 1, down = 1; j <= n; ++j)
if (a[j] % i == 0) {
while (a[down] * i < a[j]) down++;
f[j] = min(f[j], f[down] + 1);
if (f[j] + i <= p) b[j] = 1;
}
for (int i = 1; i <= n; ++i)
if (b[i] && a[i] >= l) ans++;
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e10;
void bye() {
cout << "\n";
cin.get();
cin.get();
exit(0);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m;
cin >> n >> m;
vector<int> a(m);
for (auto& v : a) {
cin >> v;
}
vector<int> cnt(m + 1);
vector<int> pos(n + 1, -1);
for (int i = 0; i < m; i++) {
if (pos[a[i]] == -1) {
cnt[i] = 0;
} else {
cnt[i] = cnt[pos[a[i]]] + 1;
}
pos[a[i]] = i;
}
vector<int> abc(m + 1);
vector<int> ans;
for (int i = 0; i < m; i++) {
abc[cnt[i]]++;
if (abc[cnt[i]] == n) {
ans.push_back(1);
} else {
ans.push_back(0);
}
}
for (int i = 0; i < ans.size(); i++) {
cout << ans[i];
}
bye();
}
| 2 |
#include <bits/stdc++.h>
const int maxn = 2E+5 + 5;
int n, m, ind;
int dp[maxn], dfn[maxn], Max[maxn];
std::vector<int> to[maxn], E[maxn];
struct Edge {
int u, v, w;
} e[maxn];
namespace BIT {
int t[maxn];
inline int lowbit(int x) { return x & -x; }
inline void Add(int p, int v) {
while (p <= n) t[p] += v, p += lowbit(p);
}
inline int Sum(int p, int r = 0) {
while (p) r += t[p], p -= lowbit(p);
return r;
}
} // namespace BIT
int dep[maxn], jp[maxn][20];
inline int LCA(int u, int v) {
if (dep[u] < dep[v]) std::swap(u, v);
for (int i = 18; i >= 0; --i)
if (dep[jp[u][i]] >= dep[v]) u = jp[u][i];
if (u == v) return u;
for (int i = 18; i >= 0; --i)
if (jp[u][i] != jp[v][i]) u = jp[u][i], v = jp[v][i];
return jp[u][0];
}
inline void DFS1(int u, int fa) {
dfn[u] = ++ind, jp[u][0] = fa, dep[u] = dep[fa] + 1;
for (int i = 1; i <= 18; ++i) jp[u][i] = jp[jp[u][i - 1]][i - 1];
for (int v : to[u]) DFS1(v, u);
Max[u] = ind;
}
inline void DFS2(int u, int fa) {
int sum = 0;
for (int v : to[u]) DFS2(v, u), sum += dp[v];
dp[u] = sum;
for (int ed : E[u])
dp[u] = std::max(
dp[u], BIT::Sum(dfn[e[ed].u]) + BIT::Sum(dfn[e[ed].v]) + sum + e[ed].w);
BIT::Add(dfn[u], sum - dp[u]), BIT::Add(Max[u] + 1, dp[u] - sum);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 2, fa; i <= n; ++i) scanf("%d", &fa), to[fa].push_back(i);
DFS1(1, 0);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &e[i].u, &e[i].v, &e[i].w);
E[LCA(e[i].u, e[i].v)].push_back(i);
}
DFS2(1, 0);
printf("%d", dp[1]);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
string reverse(string s) {
string temp;
for (int i = s.size() - 1; i >= 0; --i) temp += s[i];
return temp;
}
bool isWordPalindrome(string s) {
for (int i = 0; i < s.size() / 2; ++i) {
if (s[i] != s[s.size() - i - 1]) return false;
}
return true;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n, w;
cin >> n >> w;
vector<string> words(n);
for (int i = 0; i < n; ++i) cin >> words[i];
string left, right, center;
for (int i = 0; i < n; ++i) {
bool entered = false;
for (int j = i + 1; j < n; ++j) {
if (words[i] == reverse(words[j])) {
left = words[i] + left;
right = right + words[j];
entered = true;
break;
}
}
if (!entered && isWordPalindrome(words[i])) {
if (words[i].size() > center.size()) center = words[i];
}
}
cout << left.size() + right.size() + center.size() << '\n';
cout << left + center + right << '\n';
}
| 2 |
#include <bits/stdc++.h>
const int N = 200005, mu = 998244353;
int f[N][4], n, x, y, a[N], d[N], pre[N], suf[N];
std::vector<int> e[N];
void dfs(int x, int y) {
int *dpx = f[x], id = 0, cnt = 0;
dpx[0] = dpx[1] = 1;
for (auto u : e[x])
if (u != y) dfs(u, x);
for (auto u : e[x]) {
int *dpu = f[u];
if (u == y) {
id = cnt;
continue;
}
cnt++;
pre[cnt] = (dpu[1] + dpu[2]) % mu;
suf[cnt] = ((long long)dpu[0] + dpu[2] + dpu[3]) % mu;
a[cnt] = (dpu[3] + dpu[0]) % mu;
}
suf[cnt + 1] = 1, pre[0] = 1;
for (int i = cnt; i >= 1; i--) suf[i] = (long long)suf[i + 1] * suf[i] % mu;
for (int i = 1; i <= cnt; i++) pre[i] = (long long)pre[i - 1] * pre[i] % mu;
if (x == 1) id = cnt;
dpx[0] = pre[cnt];
dpx[1] = (long long)pre[id] * suf[id + 1] % mu;
for (int i = 1; i <= cnt; i++) {
int t = (long long)pre[i - 1] * suf[i + 1] % mu * a[i] % mu;
if (i <= id)
dpx[2] = (dpx[2] + t) % mu;
else
dpx[3] = (dpx[3] + t) % mu;
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
d[x]++, d[y]++;
}
dfs(1, 0);
printf("%d\n", ((long long)f[1][0] + f[1][2] + f[1][3]) % mu);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int base = 500;
const int MAXN = 100000 + 10;
char a[MAXN][12];
int n, m, q;
int fx[MAXN][12], fy[MAXN][12];
void go(int index) {
int lo = index * base + 1;
int hi = min(n, (index + 1) * base);
for (int row = lo; row <= hi; row++) {
int l = 1;
while (l <= m && a[row][l] == '<') {
fx[row][l] = row;
fy[row][l] = 0;
l++;
}
int r = m;
while (r >= 1 && a[row][r] == '>') {
fx[row][r] = row;
fy[row][r] = m + 1;
r--;
}
for (int j = l; j <= r; j++) fx[row][j] = fy[row][j] = -1;
for (int j = l; j <= r; j++)
if (a[row][j] == '^') {
fx[row][j] = (row == lo ? row - 1 : fx[row - 1][j]);
fy[row][j] = (row == lo ? j : fy[row - 1][j]);
int left = j - 1, right = j + 1;
while (left >= 1 && a[row][left] == '>') {
fx[row][left] = fx[row][left + 1];
fy[row][left] = fy[row][left + 1];
left--;
}
while (right <= m && a[row][right] == '<') {
fx[row][right] = fx[row][right - 1];
fy[row][right] = fy[row][right - 1];
right++;
}
}
}
}
void get(int r, int c) {
while (r >= 1 && r <= n && c >= 1 && c <= m) {
int rr = fx[r][c];
int cc = fy[r][c];
r = rr;
c = cc;
}
if (r == -1)
cout << -1 << ' ' << -1 << endl;
else
cout << r << ' ' << c << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
memset(fx, -1, sizeof fx);
memset(fy, -1, sizeof fy);
for (int j = 1; j <= m; j++) fx[0][j] = 0, fy[0][j] = j;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= m + 1; j += m + 1) fx[i][j] = i, fy[i][j] = j;
for (int i = 1; i <= n; i += base) go((i - 1) / base);
for (int o = 0; o < q; o++) {
char ord;
cin >> ord;
if (ord == 'A') {
int r, c;
cin >> r >> c;
get(r, c);
} else {
int r, c;
char t;
cin >> r >> c >> t;
a[r][c] = t;
go((r - 1) / base);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500003;
template <typename T>
void rd(T &x) {
int ch = getchar();
x = 0;
for (; ch < '0' || ch > '9'; ch = getchar())
;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = x * 10 + ch - '0';
}
template <typename T>
bool chmin(T &a, const T &b) {
if (a > b) return a = b, 1;
return 0;
}
int T, n, m, rt, d[N], dep[N], fa[N], q[N], fr, re;
vector<int> G[N], ans, lef;
bool bfs(int S) {
memset(fa, 0, n + 1 << 2);
fa[q[fr = 0] = S] = -1;
re = 1;
while (fr < re) {
int u = q[fr++];
if (d[u] == 1 && u != S) {
for (int i = u; ~i; i = fa[i]) ans.emplace_back(i);
return true;
}
for (int v : G[u])
if (!fa[v]) fa[q[re++] = v] = u;
}
return false;
}
bool vis[N];
void dfs1(int x) {
vis[x] = true;
for (int v : G[x])
if (!vis[v] && d[v] == 2) {
dep[v] = dep[fa[v] = x] + 1;
dfs1(v);
}
}
void dfs2(int x) {
vis[x] = true;
for (int v : G[x])
if (!vis[v] && d[v] == 1) lef.emplace_back(x);
for (int v : G[x])
if (!vis[v] && d[v] == 2) dfs2(v);
}
void bfs2(int S, int T) {
memset(fa, 0, n + 1 << 2);
fa[q[fr = 0] = S] = -1;
re = 1;
while (fr < re) {
int u = q[fr++];
if (u == T) {
for (int i = u; ~i; i = fa[i]) ans.emplace_back(i);
return;
}
for (int v : G[u])
if (d[v] == 2 && !fa[v]) fa[q[re++] = v] = u;
}
}
void solve() {
rd(n);
rd(m);
ans.resize(0);
for (int i = 1; i <= n; ++i) G[i].resize(0);
for (int i = 1, u, v; i <= m; ++i) {
rd(u);
rd(v);
G[u].emplace_back(v);
G[v].emplace_back(u);
}
for (int i = 1; i <= n; ++i)
if (!(d[i] = G[i].size() % 3)) {
ans.emplace_back(i);
return;
}
for (int i = 1; i <= n; ++i)
if (d[i] == 1) {
rt = i;
break;
}
if (bfs(rt)) return;
memset(vis, 0, n + 1);
for (int i = 1; i <= n; ++i)
if (d[i] == 2 && !vis[i]) {
dep[i] = 0;
dfs1(i);
}
int len = n;
for (int i = 1; i <= n; ++i)
if (d[i] == 2)
for (int j : G[i])
if (d[j] == 2 && dep[i] - dep[j] > 1) chmin(len, dep[i] - dep[j]);
for (int i = 1; i <= n; ++i)
if (d[i] == 2)
for (int j : G[i])
if (d[j] == 2 && dep[i] - dep[j] > 1)
if (len == dep[i] - dep[j]) {
for (int p = i; p != j; p = fa[p]) ans.emplace_back(p);
ans.emplace_back(j);
return;
}
memset(vis, 0, n + 1);
int tmp = 2;
for (int i = 1; i <= n; ++i)
if (d[i] == 2 && !vis[i]) {
lef.resize(0);
dfs2(i);
bfs2(lef[0], lef[1]);
if (!--tmp) break;
}
ans.emplace_back(rt);
}
int main() {
rd(T);
while (T--) {
solve();
if (ans.size() == n)
puts("No");
else {
memset(vis, 0, n + 1);
printf("Yes\n%d\n", n - ans.size());
for (int u : ans) vis[u] = true;
for (int i = 1; i <= n; ++i)
if (!vis[i]) printf("%d ", i);
putchar('\n');
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 707406378;
const int maxn = 200005 * 4 + 3;
void read(long long &x) {
char ch;
bool flag = 0;
for (ch = getchar(); !isdigit(ch) && ((flag |= (ch == '-')) || 1);
ch = getchar())
;
for (x = 0; isdigit(ch); x = (x << 1) + (x << 3) + ch - 48, ch = getchar())
;
x *= 1 - 2 * flag;
}
int val[maxn];
map<int, int> mp;
char ans[maxn];
int vis[maxn];
int main() {
int n, one = 0, bigone = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> val[i], mp[val[i]]++;
for (int i = 0; i < n; i++) {
if (mp[val[i]] == 1)
one++;
else if (mp[val[i]] > 2)
bigone++;
}
if (one % 2 && bigone == 0) return 0 * printf("NO");
if (one % 2 == 0) {
int flag = 1;
for (int i = 0; i < n; i++) {
if (mp[val[i]] == 1) {
if (flag)
ans[i] = 'A';
else
ans[i] = 'B';
flag = 1 - flag;
} else
ans[i] = 'A';
}
} else {
int tmp = 0;
int flag = 1;
for (int i = 0; i < n; i++) {
if (mp[val[i]] == 1) {
if (flag)
ans[i] = 'A';
else
ans[i] = 'B';
flag = 1 - flag;
} else {
if (mp[val[i]] == 2) {
ans[i] = 'A';
continue;
}
if (tmp && !vis[val[i]]) {
ans[i] = 'A';
continue;
}
tmp = 1;
if (vis[val[i]] == 0)
ans[i] = 'B';
else
ans[i] = 'A';
vis[val[i]] = 1;
}
}
}
puts("YES");
puts(ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10, mod = 1e9 + 7;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
int a[n], b[m];
map<int, long long> mp[2];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < m; i++) cin >> b[i];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int mid = a[i] + b[j];
mp[0][mid] |= (1ll << i);
mp[1][mid] |= (1ll << j);
}
int ans = 0;
auto it = mp[0].begin(), it2 = mp[1].begin();
while (it != mp[0].end()) {
auto it3 = it, it4 = it2;
while (it3 != mp[0].end()) {
ans = max(ans, __builtin_popcountll(((*it).second) | (*it3).second) +
__builtin_popcountll(((*it2).second) | (*it4).second));
it3++;
it4++;
}
it++;
it2++;
}
cout << ans;
return 0;
}
| 3 |
#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
using namespace std;
//template
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define rrep(i,a,b) for(int i=(a);i>(b);i--)
#define ALL(v) (v).begin(),(v).end()
typedef long long int ll;
const int inf = 0x3fffffff; const ll INF = 0x1fffffffffffffff; const double eps=1e-12;
void tostr(ll x,string& res){while(x)res+=('0'+(x%10)),x/=10; reverse(ALL(res)); return;}
template<class T> inline bool chmax(T& a,T b){ if(a<b){a=b;return 1;}return 0; }
template<class T> inline bool chmin(T& a,T b){ if(a>b){a=b;return 1;}return 0; }
//end
template<unsigned mod=998244353>struct mint {
unsigned val;
static unsigned get_mod(){return mod;}
unsigned inv() const{
int tmp,a=val,b=mod,x=1,y=0;
while(b)tmp=a/b,a-=tmp*b,swap(a,b),x-=tmp*y,swap(x,y);
if(x<0)x+=mod; return x;
}
mint():val(0){}
mint(ll x):val(x>=0?x%mod:mod+(x%mod)){}
mint pow(ll t){mint res=1,b=*this; while(t){if(t&1)res*=b;b*=b;t>>=1;}return res;}
mint& operator+=(const mint& x){if((val+=x.val)>=mod)val-=mod;return *this;}
mint& operator-=(const mint& x){if((val+=mod-x.val)>=mod)val-=mod; return *this;}
mint& operator*=(const mint& x){val=ll(val)*x.val%mod; return *this;}
mint& operator/=(const mint& x){val=ll(val)*x.inv()%mod; return *this;}
mint operator+(const mint& x)const{return mint(*this)+=x;}
mint operator-(const mint& x)const{return mint(*this)-=x;}
mint operator*(const mint& x)const{return mint(*this)*=x;}
mint operator/(const mint& x)const{return mint(*this)/=x;}
bool operator==(const mint& x)const{return val==x.val;}
bool operator!=(const mint& x)const{return val!=x.val;}
};
template<unsigned mod=998244353>struct factorial {
using Mint=mint<mod>;
vector<Mint> Fact, Finv;
public:
factorial(int maxx){
Fact.resize(maxx+1),Finv.resize(maxx+1); Fact[0]=Mint(1); rep(i,0,maxx)Fact[i+1]=Fact[i]*(i+1);
Finv[maxx]=Mint(1)/Fact[maxx]; rrep(i,maxx,0)Finv[i-1]=Finv[i]*i;
}
Mint fact(int n,bool inv=0){if(inv)return Finv[n];else return Fact[n];}
Mint nPr(int n,int r){if(n<0||n<r||r<0)return Mint(0);else return Fact[n]*Finv[n-r];}
Mint nCr(int n,int r){if(n<0||n<r||r<0)return Mint(0);else return Fact[n]*Finv[r]*Finv[n-r];}
};
using Mint=mint<>;
Mint dp[510][1020];
int main(){
int n,x; scanf("%d%d",&n,&x);
int m=1; while(x>=m)m<<=1;
dp[0][0]=1;
rep(k,0,x+1)rep(i,0,n)rep(j,0,m)if(dp[i][j]!=0)dp[i+1][j^k]+=dp[i][j];
printf("%d\n",dp[n][x].val);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
vector<int> g[310];
int n, k, d[310], dp[310][310], dis[310][310], ans[310];
void dfs(int x, int fa = 0) {
for (int i = 1; i <= n; i++) dp[x][i] = d[dis[x][i]];
int nn = g[x].size() - 1;
for (int xx = 0; xx <= nn; xx++) {
int to = g[x][xx];
if (to != fa) {
dfs(to, x);
for (int i = 1; i <= n; i++) {
int mn = 0x3f3f3f3f;
for (int j = 1; j <= n; j++)
if (dis[x][i] <= dis[x][j] && dis[to][j] <= dis[to][i])
mn = min(mn, dp[to][j]);
dp[x][i] += mn;
}
}
}
}
void dfs1(int x, int i, int fa = 0) {
if (x == i) ans[x] = x;
int nn = g[x].size() - 1;
for (int xx = 0; xx <= nn; xx++) {
int to = g[x][xx];
if (to != fa) {
pair<int, int> mn = make_pair(0x3f3f3f3f, 0);
for (int j = 1; j <= n; j++)
if (dis[x][i] <= dis[x][j] && dis[to][j] <= dis[to][i])
mn = min(mn, make_pair(dp[to][j], j));
dfs1(to, mn.second, x);
}
}
}
int main() {
n = read();
k = read();
d[0] = k;
for (int i = 1; i <= n - 1; i++) d[i] = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) dis[i][j] = 0x3f3f3f3f;
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int i = 1; i <= n - 1; i++) {
int u = read();
int v = read();
g[u].push_back(v);
g[v].push_back(u);
dis[u][v] = dis[v][u] = 1;
}
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
dfs(1);
int t = min_element(dp[1] + 1, dp[1] + n + 1) - dp[1];
dfs1(1, t);
printf("%d\n", dp[1][t]);
for (int i = 1; i <= n; i++) {
if (!ans[i])
for (int j = 1; j <= n; j++)
if (ans[j] == j && (!ans[i] || dis[ans[i]][i] > dis[j][i])) ans[i] = j;
printf("%d ", ans[i]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
bool compFirst(pair<long long, long long> a, pair<long long, long long> b) {
return a.first < b.first;
}
int main() {
long long n, d;
vector<pair<long long, long long> > friends;
cin >> n >> d;
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
friends.push_back(make_pair(a, b));
}
sort(friends.begin(), friends.end(), compFirst);
vector<long long> sums;
sums.push_back(0);
for (int i = 0; i < n; ++i) sums.push_back(sums[i] + friends[i].second);
long long index = 0, max = 0;
for (int i = 0; i < n; ++i) {
for (; index == n - 1 || friends[index + 1].first < friends[i].first + d;
++index) {
if (index == n - 1) break;
}
if (sums[index + 1] - sums[i] > max) max = sums[index + 1] - sums[i];
}
cout << max << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main (){
long long n,m;cin>>n;
if (n%2==1) puts("0");
else{
long long ans=0;m=n;
while (m) ans+=(m/2)/5,m/=5;
printf ("%lld",ans);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,k,n) for(int i = (int)(k); i < (int)(n); i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(a) a.begin(), a.end()
#define MS(m,v) memset(m,v,sizeof(m))
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
const int MOD = 1000000007;
const int INF = MOD + 1;
const ld EPS = 1e-12;
template<class T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template<class T> T &chmax(T &a, const T &b) { return a = max(a, b); }
/*--------------------template--------------------*/
typedef int Weight;
struct Edge
{
int from, to; Weight cost;
bool operator < (const Edge& e) const { return cost < e.cost; }
bool operator > (const Edge& e) const { return cost > e.cost; }
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
typedef vector<Array> Matrix;
void add_edge(Graph &g, int from, int to, Weight cost)
{
g[from].push_back(Edge{ from, to, cost });
}
int dp[1111][1111][2];
int solve(int even, int odd, int edge)
{
if (even + odd == 1) return 1;
if (dp[even][odd][edge] >= 0) return dp[even][odd][edge];
int res = 1;
if (even >= 2) chmin(res, solve(even - 1, odd, 1 - edge));
if (odd >= 2) chmin(res, solve(even + 1, odd - 2, edge));
if (even >= 1 && odd >= 1) chmin(res, solve(even - 1, odd, 1 - edge));
if (edge == 1) chmin(res, solve(even, odd, 0));
return dp[even][odd][edge] = 1 - res;
}
int main()
{
cin.sync_with_stdio(false); cout << fixed << setprecision(10);
int V;
cin >> V;
Graph g(V);
REP(i, V)REP(j, V)
{
char a; cin >> a;
if (a == 'Y') add_edge(g, i, j, 0);
}
vector<bool> vis(V);
int even = 0, odd = 0, edge = 0;
REP(i, V)
{
if (vis[i]) continue;
vis[i] = true;
vi v;
v.push_back(i);
queue<int> que;
que.push(i);
while (!que.empty())
{
int t = que.front();
que.pop();
for (auto j : g[t])
{
int nx = j.to;
if (vis[nx]) continue;
vis[nx] = true;
v.push_back(nx);
que.push(nx);
}
}
if (v.size() % 2) odd++;
else even++;
int cnt = 0;
REP(j, v.size())
{
cnt += v.size() - g[v[j]].size() - 1;
}
cnt /= 2;
if (cnt % 2) edge++;
edge %= 2;
}
MS(dp, -1);
int ans = solve(even, odd, edge);
if (ans) cout << "Taro" << endl;
else cout << "Hanako" << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n = 1, x = 1;
cin >> n;
while (n > x) {
n = n - x;
x++;
}
cout << n << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> ed[100010], cost[100010];
long long ans;
long long sz[100010], m;
long long tp[100011];
bool done[100010];
map<long long, long long> downf, upf, downfl[100010], upfl[100010];
void dfs(long long n, long long p) {
sz[n] = 1;
for (long long i = 0; i < ed[n].size(); i++) {
long long v = ed[n][i];
if (v != p && done[v] == false) {
dfs(v, n);
sz[n] += sz[v];
}
}
}
long long s2, s1, t2, t1;
long long egcd(long long a, long long b) {
long long temp;
if (a % b == 0) {
return s1;
}
temp = s2 - (a / b) * s1;
s2 = s1;
s1 = temp;
temp = t2 - (a / b) * t1;
t2 = t1;
t1 = temp;
return egcd(b, a % b);
}
void ndfs(long long n, long long p, long long loc, long long down,
long long h) {
long long x = (-down) % m;
if (x < 0) x += m;
long long y = tp[h];
s2 = t1 = 1;
s1 = t2 = 0;
y = (egcd(y, m) % m + m) % m;
x = (x * y) % m;
ans += upf[x] - upfl[loc][x];
for (long long i = 0; i < ed[n].size(); i++) {
long long v = ed[n][i];
if (v != p && done[v] == false) {
ndfs(v, n, loc, ((down * 10) % m + cost[n][i]) % m, h + 1);
}
}
}
void adfs(long long n, long long p, long long loc, long long down, long long up,
long long h) {
downf[down]++;
upf[up]++;
downfl[loc][down]++;
upfl[loc][up]++;
if (!(up % m)) ans++;
for (long long i = 0; i < ed[n].size(); i++) {
long long v = ed[n][i];
if (v != p && done[v] == false) {
adfs(v, n, loc, ((down * 10) % m + cost[n][i]) % m,
(up + ((tp[h] * cost[n][i]) % m)) % m, h + 1);
}
}
}
long long decompose(long long cen) {
dfs(cen, -1);
long long target = sz[cen] / 2, p = -1;
bool ok = false;
while (!ok) {
ok = true;
for (long long i = 0; i < ed[cen].size(); i++) {
long long v = ed[cen][i];
if (p != v && done[v] == false && sz[v] > target) {
ok = false;
p = cen;
cen = v;
}
}
}
done[cen] = true;
downf.clear();
upf.clear();
upf[0]++;
for (long long i = 0; i < ed[cen].size(); i++) {
long long v = ed[cen][i];
upfl[v].clear();
downfl[v].clear();
if (!done[v]) {
adfs(v, cen, v, cost[cen][i] % m, cost[cen][i] % m, 1);
}
}
for (long long i = 0; i < ed[cen].size(); i++) {
long long v = ed[cen][i];
if (!done[v]) {
ndfs(v, cen, v, cost[cen][i] % m, 1);
}
}
for (long long i = 0; i < ed[cen].size(); i++) {
long long v = ed[cen][i];
if (!done[v]) {
decompose(v);
}
}
return cen;
}
int main() {
long long cs, ts, i, j, k, x, y, z, q, n;
tp[0] = 1;
scanf("%lld", &n);
scanf("%lld", &m);
for (long long i = 1; i <= n; i++) tp[i] = (10 * tp[i - 1]) % m;
for (i = 1; i < n; i++) {
scanf("%lld", &x);
scanf("%lld", &y);
scanf("%lld", &z);
x++;
y++;
ed[x].push_back(y);
ed[y].push_back(x);
cost[x].push_back(z);
cost[y].push_back(z);
}
ans = 0;
decompose(1);
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, k, d;
cin >> n >> t >> k >> d;
int time = 0;
while (true) {
if (time > d) break;
time += t;
n -= k;
}
if (n > 0)
puts("YES");
else
puts("NO");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
const int maxn = 1000 + 5;
int a[maxn], b[maxn];
int main() {
int n;
cin >> n;
int x = -1;
for (int i = 1; i * i <= n; i++)
if (!(n % i)) x = i;
cout << x << endl << n / x << endl;
return false;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 1e5 + 100;
bool used[MN];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
for (int i = 0; i < n; ++i) {
if (v[i] == i + 1) {
cout << "YES\n";
for (int j = 0; j < n; ++j) {
if (i != j) {
cout << i + 1 << ' ' << j + 1 << '\n';
}
}
return 0;
}
}
vector<vector<int> > c;
for (int i = 0; i < n; ++i) {
if (!used[i]) {
int pos = v[i] - 1;
c.push_back(vector<int>());
while (pos != i) {
c.back().push_back(pos);
used[pos] = 1;
pos = v[pos] - 1;
}
used[pos] = 1;
c.back().push_back(pos);
}
}
int mi = 1e9;
int ei = 0;
for (int i = 0; i < c.size(); ++i) {
mi = min((int)c[i].size(), mi);
if (c[i].size() % 2 != 0) {
ei = 1;
}
}
if (mi != 2 || ei) {
cout << "NO\n";
return 0;
}
memset(used, 0, sizeof used);
int a = 0;
int b = 0;
cout << "YES\n";
for (int i = 0; i < c.size(); ++i) {
if (c[i].size() == 2) {
used[i] = 1;
cout << c[i][0] + 1 << ' ' << c[i][1] + 1 << '\n';
a = c[i][0];
b = c[i][1];
break;
}
}
for (int i = 0; i < c.size(); ++i) {
if (used[i]) continue;
for (int j = 0; j < c[i].size(); ++j) {
if (j % 2 == 0) {
cout << a + 1 << ' ' << c[i][j] + 1 << '\n';
} else {
cout << b + 1 << ' ' << c[i][j] + 1 << '\n';
}
}
}
}
| 2 |
#include <bits/stdc++.h>
using Azir = int;
namespace fastIO {
bool IOerror = 0;
inline char nc() {
static char buf[100000], *p1 = buf + 100000, *pend = buf + 100000;
if (p1 == pend) {
p1 = buf;
pend = buf + fread(buf, 1, 100000, stdin);
if (pend == p1) {
IOerror = 1;
return -1;
}
}
return *p1++;
}
inline bool blank(char ch) {
return ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t';
}
template <class T>
inline bool read(T& x) {
bool sign = 0;
char ch = nc();
x = 0;
for (; blank(ch); ch = nc())
;
if (IOerror) return false;
if (ch == '-') sign = 1, ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc()) x = x * 10 + ch - '0';
if (sign) x = -x;
return true;
}
inline bool read(unsigned long long& x) {
char ch = nc();
x = 0;
for (; blank(ch); ch = nc())
;
if (IOerror) return false;
for (; ch >= '0' && ch <= '9'; ch = nc()) x = x * 10 + ch - '0';
return true;
}
inline bool read(unsigned int& x) {
char ch = nc();
x = 0;
for (; blank(ch); ch = nc())
;
if (IOerror) return false;
for (; ch >= '0' && ch <= '9'; ch = nc()) x = x * 10 + ch - '0';
return true;
}
inline bool read(double& x) {
bool sign = 0;
char ch = nc();
x = 0;
for (; blank(ch); ch = nc())
;
if (IOerror) return false;
if (ch == '-') sign = 1, ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc()) x = x * 10 + ch - '0';
if (ch == '.') {
double tmp = 1;
ch = nc();
for (; ch >= '0' && ch <= '9'; ch = nc())
tmp /= 10.0, x += tmp * (ch - '0');
}
if (sign) x = -x;
return true;
}
inline bool read(char* s) {
char ch = nc();
for (; blank(ch); ch = nc())
;
if (IOerror) return false;
for (; !blank(ch) && !IOerror; ch = nc()) *s++ = ch;
*s = 0;
return true;
}
inline bool read(char& c) {
for (c = nc(); blank(c); c = nc())
;
if (IOerror) {
c = -1;
return false;
}
return true;
}
inline bool read(std::string& s) {
s.clear();
char ch = nc();
for (; blank(ch); ch = nc())
;
if (IOerror) return false;
for (; !blank(ch) && !IOerror; ch = nc()) s += ch;
return true;
}
template <class T, class... U>
bool read(T& h, U&... t) {
return read(h) && read(t...);
}
struct Ostream_fwrite {
char *buf, *p1, *pend;
Ostream_fwrite() {
buf = new char[100000];
p1 = buf;
pend = buf + 100000;
}
inline void out(char ch) {
if (p1 == pend) {
fwrite(buf, 1, 100000, stdout);
p1 = buf;
}
*p1++ = ch;
}
template <class T>
inline void print(T x) {
static char s[41], *s1;
s1 = s;
if (!x) *s1++ = '0';
if (x < 0) out('-'), x = -x;
while (x) *s1++ = x % 10 + '0', x /= 10;
while (s1-- != s) out(*s1);
}
inline void print(char ch) { out(ch); }
inline void print(unsigned long long x) {
static char s[41], *s1;
s1 = s;
if (!x) *s1++ = '0';
while (x) *s1++ = x % 10 + '0', x /= 10;
while (s1-- != s) out(*s1);
}
inline void print(unsigned int x) {
static char s[41], *s1;
s1 = s;
if (!x) *s1++ = '0';
while (x) *s1++ = x % 10 + '0', x /= 10;
while (s1-- != s) out(*s1);
}
inline void print(double x, int y = 6) {
static long long mul[] = {1,
10,
100,
1000,
10000,
100000,
1000000,
10000000,
100000000,
1000000000,
10000000000LL,
100000000000LL,
1000000000000LL,
10000000000000LL,
100000000000000LL,
1000000000000000LL,
10000000000000000LL,
100000000000000000LL};
if (x < -1e-12) out('-'), x = -x;
x *= mul[y];
long long x1 = (long long)floor(x);
if (x - floor(x) >= 0.5) ++x1;
long long x2 = x1 / mul[y], x3 = x1 - x2 * mul[y];
print(x2);
if (y > 0) {
out('.');
for (size_t i = 1; i < y && x3 * mul[i] < mul[y]; out('0'), ++i)
;
print(x3);
}
}
inline void print(char* s) {
while (*s) out(*s++);
}
inline void print(const char* s) {
while (*s) out(*s++);
}
inline void print(std::string s) { print(s.c_str()); }
inline void flush() {
if (p1 != buf) {
fwrite(buf, 1, p1 - buf, stdout);
p1 = buf;
}
}
~Ostream_fwrite() { flush(); }
} Ostream;
template <class T>
inline void print(T x) {
Ostream.print(x);
}
template <class T>
inline void println(T x) {
Ostream.print(x);
Ostream.out('\n');
}
inline void print(double x, int y = 6) { Ostream.print(x, y); }
inline void println(double x, int y = 6) {
Ostream.print(x, y);
Ostream.out('\n');
;
}
template <class T, class... U>
void print(const T& h, const U&... t) {
print(h);
Ostream.out(' ');
;
print(t...);
}
template <class T, class... U>
void println(const T& h, const U&... t) {
print(h);
Ostream.out(' ');
;
println(t...);
}
inline void flush() { Ostream.flush(); }
}; // namespace fastIO
using namespace fastIO;
using namespace std;
const int32_t MAXN = 1e5 + 5;
int a[MAXN];
vector<pair<int, int> > ans;
Azir main() {
int n, m;
read(n, m);
int cnt = 0;
for (int i = 1; i <= m; i++) {
int siz;
read(siz);
for (int i = 1; i <= siz; i++) {
int x;
read(x);
a[x] = ++cnt;
}
}
for (int i = 1; i <= cnt; i++) {
if (a[i] == i) continue;
int j = -1;
for (j = i + 1;; j++) {
if (a[j] == i) {
break;
}
}
if (a[i] == 0) {
ans.push_back(make_pair(j, i));
a[i] = a[j];
a[j] = 0;
} else {
for (int k = i + 1;; k++) {
if (a[k] == 0) {
a[k] = a[i];
ans.push_back(make_pair(i, k));
a[i] = a[j];
ans.push_back(make_pair(j, i));
a[j] = 0;
break;
}
}
}
}
println(ans.size());
for (int i = 0; i < ans.size(); i++) {
println(ans[i].first, ans[i].second);
}
fastIO::flush();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m, k;
char mat[303][303];
void testcase() {
cin >> n >> m >> k;
for (long long int i = 1; i < n + 1; i++)
for (long long int j = 1; j < m + 1; j++) cin >> mat[i][j];
long long int cnt = 0;
for (long long int radii = 1; radii < n; radii++) {
for (long long int i = radii + 1; i < n + 1 - radii; i++) {
for (long long int j = radii + 1; j < m + 1 - radii; j++) {
long long int x = radii;
long long int r = radii;
if (mat[i][j] == '*' && mat[i + r][j] == '*' && mat[i][j + r] == '*' &&
mat[i - r][j] == '*' && mat[i][j - r] == '*') {
--k;
}
if (k == 0) {
cout << i << " " << j << "\n";
cout << i - x << " " << j << "\n";
cout << i + x << " " << j << "\n";
cout << i << " " << j - x << "\n";
cout << i << " " << j + x << "\n";
return;
}
}
}
}
cout << -1 << "\n";
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int t;
t = 1;
while (t--) testcase();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool RD(T &ret) {
char c;
int sgn;
if (c = getchar(), c == EOF) return 0;
while (c != '-' && (c < '0' || c > '9')) c = getchar();
sgn = (c == '-') ? -1 : 1, ret = (c == '-') ? 0 : (c - '0');
while (c = getchar(), c >= '0' && c <= '9') ret = ret * 10 + (c - '0');
ret *= sgn;
return 1;
}
template <class T>
inline void PT(T x) {
if (x < 0) putchar('-'), x = -x;
if (x > 9) PT(x / 10);
putchar(x % 10 + '0');
}
const int N = 2e5 + 100;
char s[N];
int n, Q, K;
struct node {
int cnt[10][10];
int lv, rv, lazy;
};
struct SegmentTree {
inline int get_id(int l, int r) { return (l + r) | (l != r); }
node a[2 * N];
void up(int l, int r) {
int mid = (l + r) >> 1;
int rt = get_id(l, r), ls = get_id(l, mid), rs = get_id(mid + 1, r);
for (int i = 0; i < int(K); i++)
for (int j = 0; j < int(K); j++)
a[rt].cnt[i][j] = a[ls].cnt[i][j] + a[rs].cnt[i][j];
a[rt].cnt[a[ls].rv][a[rs].lv]++;
a[rt].lv = a[ls].lv;
a[rt].rv = a[rs].rv;
}
void down(int l, int r) {
int mid = (l + r) >> 1;
int rt = get_id(l, r), ls = get_id(l, mid), rs = get_id(mid + 1, r);
if (a[rt].lazy == -1) return;
memset(a[ls].cnt, 0, sizeof(a[ls].cnt));
memset(a[rs].cnt, 0, sizeof(a[rs].cnt));
a[ls].lazy = a[ls].lv = a[ls].rv = a[rs].lazy = a[rs].lv = a[rs].rv =
a[rt].lazy;
a[rt].lazy = -1;
}
void build(int l, int r) {
int rt = get_id(l, r);
a[rt].lazy = -1;
if (l == r) {
a[rt].lv = a[rt].rv = s[l] - 'a';
return;
}
int mid = (l + r) >> 1;
build(l, mid);
build(mid + 1, r);
up(l, r);
}
void update(int L, int R, int val, int l, int r) {
int rt = get_id(l, r);
int mid = (l + r) >> 1;
if (L <= l && r <= R) {
memset(a[rt].cnt, 0, sizeof(a[rt].cnt));
a[rt].lazy = a[rt].lv = a[rt].rv = val;
return;
}
down(l, r);
if (L <= mid) update(L, R, val, l, mid);
if (R > mid) update(L, R, val, mid + 1, r);
up(l, r);
}
void debug(int pos, int l, int r) {
int rt = get_id(l, r);
if (l == r) {
printf("(%c %c)\n", a[rt].lv + 'a', a[rt].rv + 'a');
return;
}
down(l, r);
int mid = (l + r) >> 1;
if (pos <= mid)
debug(pos, l, mid);
else
debug(pos, mid + 1, r);
}
} A;
int main() {
cin >> n >> Q >> K;
scanf("%s", s + 1);
A.build(1, n);
for (int i = 1; i <= int(Q); i++) {
int op;
RD(op);
if (op == 1) {
int l, r;
char val[5];
RD(l), RD(r);
scanf("%s", val);
A.update(l, r, val[0] - 'a', 1, n);
} else {
scanf("%s", s);
int ans = n;
for (int i = 0; s[i]; i++)
for (int j = i + 1; s[j]; j++) {
ans -= A.a[A.get_id(1, n)].cnt[s[i] - 'a'][s[j] - 'a'];
}
printf("%d\n", ans);
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long i, j, n, m, k, t, l, r, x, y, s, a[1000009], d[100009];
bool ok, vis[1000009];
long long mn = -1000000009, mx = 1000000009;
vector<long long> g[100009];
string p, q;
queue<int> st;
int main() {
cin >> n;
a[1] = 1;
a[2] = 1;
d[1] = 1;
for (i = 3; i <= 10000; i++) {
a[i] = a[i - 1] + a[i - 2];
d[a[i]] = 1;
if (a[i] >= 10000) break;
}
for (i = 1; i <= n; i++) {
if (d[i])
p += 'O';
else
p += 'o';
}
cout << p;
}
| 1 |
#include<iostream>
#include<algorithm>
using namespace std;
int A[200001];
int main() {
int N;
cin >> N;
for (int i = 1; i <= N; i++)
cin >> A[i];
for (int i = 1; i <= N; i++)
A[i] -= i;
sort(A + 1, A + N + 1);
int b = A[N / 2 + 1];
long long sum = 0;
for (int i = 1; i <= N; i++)
sum += abs(A[i] - b);
cout << sum << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio( false );
const int N = 50021;
vector<bool> primes( N+1, true );
primes[0] = false;
primes[1] = false;
for( int i = 2; i*i <= N; ++i ) {
if( primes[i] ) {
for( int j = 2*i; j <= N; j += i ) {
if( j%i == 0 ) {
primes[j] = false;
}
}
}
}
int x;
while( cin >> x ) {
int i = x-1;
int j = x+1;
while( i >= 0 && !primes[i] ) { i -= 1; }
while( j <= N && !primes[j] ) { j += 1; }
cout << i << ' ' << j << '\n';
}
return 0;
}
| 0 |
#include<cstdio>
#include<algorithm>
#include<vector>
#include<utility>
#define mod 1000000007
using namespace std;
int main(){
int a[100000],b[100000];
vector<pair<int,int> > p;
long long ans=1LL,l=0LL,n,x=0,y=0;
scanf("%lld",&n);
for(int i=0;i<n;i++){
scanf("%d",&a[i]);
p.push_back(make_pair(a[i],1));
}
for(int i=0;i<n;i++){
scanf("%d",&b[i]);
p.push_back(make_pair(b[i],-1));
}
sort(p.begin(),p.end());
for(long long i=0;i<p.size();i++){
if(p[i].second==1){
if(y){
ans*=y;
ans%=mod;
y--;
}
else{
x++;
}
}
else{
if(x){
ans*=x;
ans%=mod;
x--;
}
else{
y++;
}
}
}
printf("%ld\n",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int d[100 * 1000];
int main() {
int n, m;
cin.sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--, v--;
d[u]++, d[v]++;
}
bool cir = true;
int leaf = 0;
for (int i = 0; i < n; i++) {
if (d[i] == 1) leaf++;
if (d[i] != 2) cir = false;
}
if (leaf == 2 && m == n - 1)
cout << "bus topology\n";
else if (leaf == n - 1)
cout << "star topology\n";
else if (cir)
cout << "ring topology\n";
else
cout << "unknown topology\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int a, b, t, i;
cin >> t;
for (i = 0; i < t; i++) {
cin >> a >> b;
cout << a + b << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e4 + 4;
const int M = 5e3 + 3;
const int MAX = 1e6 + 6;
int n, q;
int arr[N];
int l[M];
int r[M];
int ans[M];
int prexor[MAX];
int arr2[N];
int mx[N];
int main() {
prexor[0] = 0;
for (int i = 1; i < MAX; ++i) {
prexor[i] = prexor[i - 1] ^ i;
}
scanf("%d %d", &n, &q);
for (int i = 1; i <= n; ++i) {
scanf("%d", arr + i);
arr2[i] = prexor[arr[i]];
}
for (int i = 1; i <= q; ++i) {
scanf("%d %d", l + i, r + i);
ans[i] = 0;
}
for (int i = 1; i <= n; ++i) {
int mxval = 0;
for (int j = i; j <= n; ++j) {
mxval =
max(mxval, arr2[i] ^ arr2[j] ^ (arr[i] < arr[j] ? arr[i] : arr[j]));
mx[j] = mxval;
}
for (int j = 1; j <= q; ++j) {
if (l[j] <= i) {
ans[j] = max(ans[j], mx[r[j]]);
}
}
}
for (int i = 1; i <= q; ++i) {
printf("%d\n", ans[i]);
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
char s[N], res[N * 2];
int f[N * 2];
int fa(int c) { return c == f[c] ? c : f[c] = fa(f[c]); }
int main() {
for (int i = 0; i < N * 2; i++) f[i] = i;
int n, a, b;
int ma = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", s);
scanf("%d", &a);
int l = strlen(s);
for (int j = 0; j < a; j++) {
scanf("%d", &b);
ma = max(ma, l + b - 1);
int c = b;
while ((c = fa(c)) <= l + b - 1) {
res[c] = s[c - b];
f[c] = c + 1;
}
}
}
for (int i = 1; i <= ma; i++)
if (!res[i]) res[i] = 'a';
puts(res + 1);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int dx4[] = {0, 0, 1, -1};
int dy4[] = {1, -1, 0, 0};
int dx8[] = {0, 0, 1, 1, 1, -1, -1, -1};
int dy8[] = {1, -1, 1, -1, 0, 0, -1, 1};
const double pi = acos(-1.0);
const int mod = 1000000007;
const int maxn = 200100;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int d0, d1, d2, d3;
cin >> d0 >> d1 >> d2 >> d3;
if (d0 + 1 == d1 and d2 == 0 and d3 == 0) {
cout << "YES"
<< "\n";
for (int i = 0; i < d0; i++) {
cout << "1 0 ";
}
cout << "1"
<< "\n";
return 0;
}
if (d0 == d1 + 1 and d2 == 0 and d3 == 0) {
cout << "YES"
<< "\n";
for (int i = 0; i < d1; i++) {
cout << "0 1 ";
}
cout << "0"
<< "\n";
return 0;
}
if (d1 + 1 == d2 and d0 == 0 and d3 == 0) {
cout << "YES"
<< "\n";
for (int i = 0; i < d1; i++) {
cout << "2 1 ";
}
cout << "2"
<< "\n";
return 0;
}
if (d2 + 1 == d1 and d0 == 0 and d3 == 0) {
cout << "YES"
<< "\n";
for (int i = 0; i < d2; i++) {
cout << "1 2 ";
}
cout << 1 << "\n";
return 0;
}
if (d2 + 1 == d3 and d0 == 0 and d1 == 0) {
cout << "YES"
<< "\n";
for (int i = 0; i < d2; i++) {
cout << "3 2 ";
}
cout << "3"
<< "\n";
return 0;
}
if (d3 + 1 == d2 and d0 == 0 and d1 == 0) {
cout << "YES"
<< "\n";
for (int i = 0; i < d3; i++) {
cout << "2 3 ";
}
cout << "2"
<< "\n";
return 0;
}
int l1 = d1 - d0;
int l2 = d2 - d3;
if (l1 < 0 or l2 < 0) {
cout << "NO"
<< "\n";
return 0;
}
if (abs(l1 - l2) > 1) {
cout << "NO"
<< "\n";
return 0;
}
cout << "YES"
<< "\n";
if (l1 == l2 + 1) {
cout << "1 ";
}
for (int i = 0; i < d0; i++) {
cout << "0 1 ";
}
for (int i = 0; i < min(l1, l2); i++) {
cout << "2 1 ";
}
for (int i = 0; i < d3; i++) {
cout << "2 3 ";
}
if (l2 == l1 + 1) {
cout << "2";
}
cout << "\n";
return 0;
}
| 4 |
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
#ifndef EPS
#define EPS (1e-10)
#endif
struct Point {
double x, y;
Point(double x = 0, double y = 0) :x(x), y(y) {}
Point operator+(const Point&p)const { return Point(x + p.x, y + p.y); }
Point operator-(const Point&p)const { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(a*x, a*y); }
Point operator/(double a) { return Point(x / a, y / a); }
double norm() { return x*x + y*y; }
double abs() { return sqrt(norm()); }
double dot(const Point&p)const{
return x*p.x+y*p.y;
}
double det(const Point&p)const{
return x*p.y-y*p.x;
}
bool operator<(const Point&p)const {
return x != p.x ? x < p.x : y < p.y;
}
bool operator==(const Point&p)const {
return fabs(x - p.x) < EPS&&fabs(y - p.y) < EPS;
}
};
typedef pair<Point,int>P;
P p[100],q[100];
vector<P>convex_hull(P*ps,int n){
sort(ps,ps+n);
int k=0;
vector<P>qs(n*2);
rep(i,n){
while(k>1&&(qs[k-1].first-qs[k-2].first).det(ps[i].first-qs[k-1].first)<=0)k--;
qs[k++]=ps[i];
}
for(int i=n-2,t=k;i>=0;i--){
while(k>t&&(qs[k-1].first-qs[k-2].first).det(ps[i].first-qs[k-1].first)<=0)k--;
qs[k++]=ps[i];
}
qs.resize(k-1);
return qs;
}
int par[100];
int find(int x){
if(x==par[x])return x;
return par[x]=find(par[x]);
}
void unite(int x,int y){par[find(x)]=find(y);}
struct st{int a,b;double c;};
int main(){
int v,r;scanf("%d%d",&v,&r);
rep(i,v)scanf("%lf%lf",&p[i].first.x,&p[i].first.y),p[i].second=i,q[i]=p[i];
rep(i,v)par[i]=i;
vector<P>res=convex_hull(p,v);
double ans=0;
rep(i,res.size()){
ans+=(res[(i+1)%res.size()].first-res[i].first).abs();
unite(res[(i+1)%res.size()].second,res[i].second);
}
vector<st>u;
rep(i,r){
int a,b;scanf("%d%d",&a,&b);a--;b--;
u.push_back({a,b,(q[a].first-q[b].first).abs()});
}
sort(u.begin(),u.end(),[](st&a,st&b){return a.c<b.c;});
rep(i,u.size()){
if(find(u[i].a)==find(u[i].b))continue;
ans+=u[i].c;unite(u[i].a,u[i].b);
}
printf("%.7lf\n",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], dp[200005], vis[200005];
std::vector<int> v[200005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
dp[i] = n;
vis[i] = 0;
if (i - a[i] >= 0) v[i - a[i]].push_back(i);
if (i + a[i] < n) v[i + a[i]].push_back(i);
}
vector<int> v1, v2;
v1.clear();
v2.clear();
for (int i = 0; i < n; i++) {
if (i - a[i] >= 0 && a[i] % 2 != a[i - a[i]] % 2) {
dp[i] = 1;
v1.push_back(i);
} else if (i + a[i] < n && a[i] % 2 != a[i + a[i]] % 2) {
dp[i] = 1;
v1.push_back(i);
}
}
int cnt = 2;
while (!v1.empty()) {
for (int j : v1) {
for (int k : v[j]) {
if (dp[k] > cnt) {
dp[k] = cnt;
v2.push_back(k);
}
}
}
v1 = v2;
v2.clear();
cnt++;
}
for (int i = 0; i < n; i++) {
if (dp[i] >= n)
cout << "-1 ";
else
cout << dp[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int a, b, x, y;
cin >> a >> b >> x >> y;
int c = a - x - 1;
int d = b - y - 1;
int p = a - c - 1;
int q = b - d - 1;
int area3 = p * b;
int area4 = q * a;
int area1 = c * b;
int area2 = d * a;
int z = max(area3, area4);
int m = max(area1, area2);
cout << max(z, m) << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 100;
string str;
double ans;
int len, a[Maxn + 5], Pow[5] = {1, 10, 100, 1000, 10000};
int Len(int x) {
if (!x) return 1;
int l = 0;
while (x) {
l++;
x /= 10;
}
return l;
}
void Print(int x) {
if (x >= 1000) {
Print(x / 1000);
printf(".%03d", x % 1000);
} else {
printf("%d", x);
}
}
int main() {
cin >> str;
str.push_back('#');
int last = 0;
double num = 0, tot = 0;
for (int i = 0; i < (int)str.length(); i++) {
if ('0' <= str[i] && str[i] <= '9') {
tot = tot * 10 + str[i] - '0';
} else if (str[i] == '.') {
num = num * 1000 + tot;
tot = 0;
last = i;
} else {
if (num || tot) {
if (i - last == 4) {
num = num * 1000 + tot;
} else {
if (str[last] == '.')
num += tot * 1.0 / Pow[i - last - 1];
else
num = tot;
}
}
ans += num;
num = tot = 0;
last = i;
}
}
int n = (int)ans;
double xs = ans - n;
Print(n);
if (xs > 0) printf(".%02.0lf", xs * 100);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
if (n % 2) {
int i;
for (i = 0; i < n; i++) {
printf("%i", i);
printf("%c", ' ');
}
printf("%c", '\n');
for (i = 0; i < n; i++) {
printf("%i", i);
printf("%c", ' ');
}
printf("%c", '\n');
for (i = 0; i <= n / 2; i++) {
printf("%i", 2 * i);
printf("%c", ' ');
}
for (i = 1; i <= n / 2; i++) {
printf("%i", 2 * i - 1);
printf("%c", ' ');
}
} else {
printf("%i", -1);
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int solve(int n) {
int sum = 0;
while (n > 0) {
sum += (n % 10);
n /= 10;
}
return sum;
}
int main() {
int n, C = 0;
cin >> n;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
for (int i = 0; i < v.size(); i++) {
if (v[i] == -1) continue;
for (int j = 0; j < v.size(); j++) {
if (v[j] == -1 || j == i) continue;
if ((solve(v[i]) + solve(v[j])) % 3 == 0) {
C++;
v[i] = -1;
v[j] = -1;
break;
}
}
}
cout << C << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int xinc[] = {0, 0, 1, -1};
const int yinc[] = {1, -1, 0, 0};
const long double PI = acos(-1.0);
int n, m, possible;
vector<pair<int, string> > attempt;
bool check(string s) {
for (auto a : attempt) {
int corr = 0;
for (int i = 0; i < s.size(); i++)
if (s[i] == a.second[i]) corr++;
if (corr != a.first) return false;
}
return true;
}
void make(int cnt, vector<int> pos) {
if (cnt == attempt[0].first) {
string ans = attempt[0].second;
for (int i = 0; i < n; i++)
if (ans[i] == '1')
ans[i] = '0';
else
ans[i] = '1';
for (auto i : pos)
if (ans[i] == '1')
ans[i] = '0';
else
ans[i] = '1';
if (check(ans)) possible++;
return;
}
int st;
if (pos.empty())
st = 0;
else
st = pos.back() + 1;
for (int i = st; i < n; i++) {
vector<int> nw = pos;
nw.push_back(i);
make(cnt + 1, nw);
}
}
void solve() {
cin >> n >> m;
attempt.resize(m);
for (int i = 0; i < m; i++) {
cin >> attempt[i].second >> attempt[i].first;
}
sort((attempt).begin(), (attempt).end());
vector<int> pos;
make(0, pos);
cout << possible << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double pi = 3.14159265358979323846;
const int mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n][5];
int z = 0;
int cnt = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 5; j++) {
cin >> a[i][j];
}
}
bool y = false;
for (int i = 0; i < 5; i++) {
for (int j = i + 1; j < 5; j++) {
int d1 = 0, d2 = 0, d3 = 0;
for (int k = 0; k < n; k++) {
if (a[k][i] && a[k][j])
d3++;
else if (a[k][i])
d1++;
else if (a[k][j])
d2++;
}
if (d1 + d2 + d3 == n && d1 <= n / 2 && d2 <= n / 2) {
y = true;
}
}
}
if (y == true) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a, b;
int foo[500];
int main() {
cin >> a >> b;
if (b > 1) {
cout << "Yes";
return 0;
}
int point;
for (int i = 0; i < a; i++) {
cin >> foo[i];
if (foo[i] == 0) {
point = i;
}
}
cin >> b;
foo[point] = b;
for (int i = 1; i < a; i++) {
if (foo[i] < foo[i - 1]) {
cout << "Yes";
return 0;
}
}
cout << "No";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
char x[500][501];
int d[2][501][501], n, m;
int main() {
cin >> n >> m;
for (int i = 0; i < (n); i++) cin >> x[i];
for (int ei = 0; ei < (n); ei++)
for (int si = n; si--;)
for (int sj = m; sj--;) {
auto &c = d[ei & 1][si][sj] = 0, ej = n + m - 2 - si - sj - ei;
if (si <= ei && sj <= ej && x[si][sj] == x[ei][ej] &&
!(c = abs(si - ei) + abs(sj - ej) <= 1))
for (int i = 0; i < (2); i++)
for (int j = 0; j < (2); j++)
c = (c + d[ei - !j & 1][si + !i][sj + i]) % ((int)1e9 + 7);
}
cout << d[~n & 1][0][0] << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
char s[10];
scanf("%d%s", &n, s);
int a = (s[0] - '0') * 10 + (s[1] - '0');
int b = (s[3] - '0') * 10 + (s[4] - '0');
if (n == 12) {
if (a == 0)
s[1] = '1';
else if (a > 12) {
if (s[1] == '0')
s[0] = '1';
else
s[0] = '0';
}
} else if (a >= 24)
s[0] = '0';
if (b >= 60) s[3] = '0';
printf("%s\n", s);
return 0;
}
| 1 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<map>
#include<set>
#include<queue>
#include<cstdio>
#include<climits>
#include<cmath>
#include<cstring>
#include<string>
#include<sstream>
#include<complex>
#define f first
#define s second
#define mp make_pair
#define REP(i,n) for(int i=0; i<(int)(n); i++)
#define FOR(i,c) for(__typeof((c).begin()) i=(c).begin(); i!=(c).end(); i++)
#define ALL(c) (c).begin(), (c).end()
using namespace std;
typedef unsigned int uint;
typedef long long ll;
typedef complex<double> P;
int main(){
map<char,string> enc;
map<string,char> dec;
enc[' '] = "101";
enc['\''] = "000000";
enc[','] = "000011";
enc['-'] = "10010001";
enc['.'] = "010001";
enc['?'] = "000001";
enc['A'] = "100101";
enc['B'] = "10011010";
enc['C'] = "0101";
enc['D'] = "0001";
enc['E'] = "110";
enc['F'] = "01001";
enc['G'] = "10011011";
enc['H'] = "010000";
enc['I'] = "0111";
enc['J'] = "10011000";
enc['K'] = "0110";
enc['L'] = "00100";
enc['M'] = "10011001";
enc['N'] = "10011110";
enc['O'] = "00101";
enc['P'] = "111";
enc['Q'] = "10011111";
enc['R'] = "1000";
enc['S'] = "00110";
enc['T'] = "00111";
enc['U'] = "10011100";
enc['V'] = "10011101";
enc['W'] = "000010";
enc['X'] = "10010010";
enc['Y'] = "10010011";
enc['Z'] = "10010000";
dec["00000"] = 'A';
dec["00001"] = 'B';
dec["00010"] = 'C';
dec["00011"] = 'D';
dec["00100"] = 'E';
dec["00101"] = 'F';
dec["00110"] = 'G';
dec["00111"] = 'H';
dec["01000"] = 'I';
dec["01001"] = 'J';
dec["01010"] = 'K';
dec["01011"] = 'L';
dec["01100"] = 'M';
dec["01101"] = 'N';
dec["01110"] = 'O';
dec["01111"] = 'P';
dec["10000"] = 'Q';
dec["10001"] = 'R';
dec["10010"] = 'S';
dec["10011"] = 'T';
dec["10100"] = 'U';
dec["10101"] = 'V';
dec["10110"] = 'W';
dec["10111"] = 'X';
dec["11000"] = 'Y';
dec["11001"] = 'Z';
dec["11010"] = ' ';
dec["11011"] = '.';
dec["11100"] = ',';
dec["11101"] = '-';
dec["11110"] = '\'';
dec["11111"] = '?';
string input;
while(getline(cin, input)){
string buff = "";
REP(i, input.size()){
buff+=enc[input[i]];
while(buff.size() >= 5){
string tmp = buff.substr(0,5);
buff = buff.substr(5);
cout << dec[tmp];
}
}
if(buff.size() != 0){
while(buff.size() != 5) buff += "0";
cout << dec[buff];
}
cout << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
vector<vector<long long int> > v;
for (long long int i = 0; i <= n; i++) v.push_back(vector<long long int>());
for (long long int i = 0; i < 2 * n; i++) {
long long int x;
cin >> x;
v[x].push_back(i);
}
long long int ans1, ans2;
ans1 = v[1][0];
ans2 = v[1][1];
if (n == 1) {
cout << ans1 + ans2 << endl;
return 0;
}
for (long long int i = 2; i <= n; i++) {
ans1 += abs(v[i - 1][0] - v[i][0]);
ans2 += abs(v[i - 1][1] - v[i][1]);
}
cout << ans1 + ans2 << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int l, r;
int q, i, j, s, t;
cin >> q;
for (i = 0; i < q; i++) {
s = 0;
t = 0;
cin >> l >> r;
if (l == r) {
if (l % 2 == 0)
s += l;
else
s -= l;
cout << s << endl;
} else {
l--;
if (l % 2 == 0)
s += l / 2;
else
s -= (l / 2 + 1);
if (r % 2 == 0)
t += r / 2;
else
t -= (r / 2 + 1);
cout << t - s << endl;
}
}
}
| 2 |
#include <bits/stdc++.h>
//typedef
//-------------------------#include <bits/stdc++.h>
#define M_PI 3.14159265358979323846
using namespace std;
//conversion
//------------------------------------------
inline int toInt(string s) { int v; istringstream sin(s); sin >> v; return v; }
template<class T> inline string toString(T x) { ostringstream sout; sout << x; return sout.str(); }
inline int readInt() { int x; scanf("%d", &x); return x; }
//typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<long long, long long> PLL;
typedef pair<int, PII> TIII;
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
//container util
//------------------------------------------
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SQ(a) ((a)*(a))
#define EACH(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
//repetition
//------------------------------------------
#define FOR(i,s,n) for(int i=s;i<(int)n;++i)
#define REP(i,n) FOR(i,0,n)
#define MOD 1000000007
#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) x.begin(), x.end()
#define sz(x) (int)(x).size()
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
const double EPS = 1E-8;
#define chmin(x,y) x=min(x,y)
#define chmax(x,y) x=max(x,y)
class UnionFind {
public:
vector <ll> par;
vector <ll> siz;
vector <ll> maxv;
UnionFind(ll sz_): par(sz_), siz(sz_, 1LL) {
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
void init(ll sz_) {
par.resize(sz_);
siz.assign(sz_, 1LL);
for (ll i = 0; i < sz_; ++i) par[i] = i;
}
ll root(ll x) {
while (par[x] != x) {
x = par[x] = par[par[x]];
}
return x;
}
bool merge(ll x, ll y) {
x = root(x);
y = root(y);
if (x == y) return false;
if (siz[x] < siz[y]) swap(x, y);
siz[x] += siz[y];
par[y] = x;
return true;
}
bool issame(ll x, ll y) {
return root(x) == root(y);
}
ll size(ll x) {
return siz[root(x)];
}
};
ll mod_pow(ll x, ll n, ll mod){
ll res = 1;
while(n){
if(n&1) res = (res * x)%mod;
res %= mod;
x = x * x %mod;
n >>= 1;
}
return res;
}
#define SIEVE_SIZE 5000000+10
bool sieve[SIEVE_SIZE];
void make_sieve(){
for(int i=0; i<SIEVE_SIZE; ++i) sieve[i] = true;
sieve[0] = sieve[1] = false;
for(int i=2; i*i<SIEVE_SIZE; ++i) if(sieve[i]) for(int j=2; i*j<SIEVE_SIZE; ++j) sieve[i*j] = false;
}
bool isprime(ll n){
if(n == 0 || n == 1) return false;
for(ll i=2; i*i<=n; ++i) if(n%i==0) return false;
return true;
}
const int MAX = 2000010;
long long fac[MAX], finv[MAX], inv[MAX];
// ใใผใใซใไฝใๅๅฆ็
void COMinit() {
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (int i = 2; i < MAX; i++){
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD%i] * (MOD / i) % MOD;
finv[i] = finv[i - 1] * inv[i] % MOD;
}
}
// ไบ้
ไฟๆฐ่จ็ฎ
long long COM(int n, int k){
if (n < k) return 0;
if (n < 0 || k < 0) return 0;
return fac[n] * (finv[k] * finv[n - k] % MOD) % MOD;
}
long long extGCD(long long a, long long b, long long &x, long long &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
}
long long d = extGCD(b, a%b, y, x);
y -= a/b * x;
return d;
}
// ่ฒ ใฎๆฐใซใๅฏพๅฟใใ mod (a = -11 ใจใใงใ OK)
inline long long mod(long long a, long long m) {
return (a % m + m) % m;
}
// ้ๅ
่จ็ฎ (ใใใงใฏ a ใจ m ใไบใใซ็ด ใงใใใใจใๅฟ
่ฆ)
long long modinv(long long a, long long m) {
long long x, y;
extGCD(a, m, x, y);
return mod(x, m); // ๆฐๆใก็ใซใฏ x % m ใ ใใx ใ่ฒ ใใใใใชใใฎใง
}
ll GCD(ll a, ll b){
if(b == 0) return a;
return GCD(b, a%b);
}
struct LazySegmentTree {
private:
int n;
vector<ll> node, lazy;
public:
LazySegmentTree(vector<ll> v) {
int sz = (int)v.size();
n = 1; while(n < sz) n *= 2;
node.resize(2*n-1);
lazy.resize(2*n-1, 0);
for(int i=0; i<sz; i++) node[i+n-1] = v[i];
for(int i=n-2; i>=0; i--) node[i] = node[i*2+1] + node[i*2+2];
}
void eval(int k, int l, int r) {
if(lazy[k] != 0) {
node[k] += lazy[k];
if(r - l > 1) {
lazy[2*k+1] += lazy[k] / 2;
lazy[2*k+2] += lazy[k] / 2;
}
lazy[k] = 0;
}
}
void add(int a, int b, ll x, int k=0, int l=0, int r=-1) {
if(r < 0) r = n;
eval(k, l, r);
if(b <= l || r <= a) return;
if(a <= l && r <= b) {
lazy[k] += (r - l) * x;
eval(k, l, r);
}
else {
add(a, b, x, 2*k+1, l, (l+r)/2);
add(a, b, x, 2*k+2, (l+r)/2, r);
node[k] = node[2*k+1] + node[2*k+2];
}
}
ll getsum(int a, int b, int k=0, int l=0, int r=-1) {
if(r < 0) r = n;
eval(k, l, r);
if(b <= l || r <= a) return 0;
if(a <= l && r <= b) return node[k];
ll vl = getsum(a, b, 2*k+1, l, (l+r)/2);
ll vr = getsum(a, b, 2*k+2, (l+r)/2, r);
return vl + vr;
}
};
int const INF = INT_MAX;
struct SegmentTree {
private:
int n;
vector<int> node;
public:
SegmentTree(vector<int> v) {
int sz = v.size();
n = 1; while(n < sz) n *= 2;
node.resize(2*n-1, INF);
for(int i=0; i<sz; i++) node[i+n-1] = v[i];
for(int i=n-2; i>=0; i--) node[i] = min(node[2*i+1], node[2*i+2]);
}
void update(int x, int val) {
x += (n - 1);
node[x] = val;
while(x > 0) {
x = (x - 1) / 2;
node[x] = min(node[2*x+1], node[2*x+2]);
}
}
int getmin(int a, int b, int k=0, int l=0, int r=-1) {
if(r < 0) r = n;
if(r <= a || b <= l) return INF;
if(a <= l && r <= b) return node[k];
int vl = getmin(a, b, 2*k+1, l, (l+r)/2);
int vr = getmin(a, b, 2*k+2, (l+r)/2, r);
return min(vl, vr);
}
};
using Weight = int;
using Flow = int;
struct Edge {
int src, dst;
Weight weight;
Flow cap;
Edge() : src(0), dst(0), weight(0) {}
Edge(int s, int d, Weight w) : src(s), dst(d), weight(w) {}
};
using Edges = std::vector<Edge>;
using Graph = std::vector<Edges>;
using Array = std::vector<Weight>;
using Matrix = std::vector<Array>;
void add_edge(Graph &g, int a, int b, Weight w = 1) {
g[a].emplace_back(a, b, w);
g[b].emplace_back(b, a, w);
}
void add_arc(Graph &g, int a, int b, Weight w = 1) { g[a].emplace_back(a, b, w); }
// template<typename T> class basic_stopwatch: T {
// typedef typename T BaseTimer;
// public:
// explicit basic_stopwatch(bool start);
// explicit basic_stopwatch(char const* activity = "Stopwatch", bool start = true);
// basic_stopwatch(std::ostream& log, char const* activity = "Stopwatch", bool start = true);
// basic_stopwatch();
// unsigned LapGet() const;
// bool IsStarted() const;
// unsigned Show(char const* event = "show");
// unsigned Start(char const* event_name = "start");
// unsigned Stop(char const* event_name = "stop");
// private:
// char const* m_activity;
// unsigned m_lap;
// std::ostream& m_log;
// };
// #include <chrono>
// using namespace std::chrono;
// class TimerBase {
// public:
// // ใฟใคใใใฏใชใขใใ
// TimerBase(): m_start(system_clock::time_point::min()) {}
// void Clear(){
// m_start = system_clock::time_point::min();
// }
// bool IsStarted() const {
// return (m_start.time_since_epoch() != system_clock::duration(0));
// }
// void Start() {
// m_start = system_clock::now();
// }
// unsigned long GetMs(){
// if(IsStarted()) {
// system_clock::duration diff;
// diff = system_clock::now() - m_start;
// return (unsigned)(duration_cast<milliseconds>(diff).const();
// }
// return 0;
// }
// private:
// system_clock::time_point m_start;
// };
bool ok[110];
set<ll> makeable;
void dfs(ll idx, ll left, ll right, vector<ll>&a, vector<ll>&w){
if(idx == w.size()){
makeable.insert(left-right);
for(int i=0; i<a.size(); i++){
if(left+a[i] == right || left == right+a[i]){
ok[i] = true;
}
}
return;
}
dfs(idx+1, left+w[idx], right,a,w);
dfs(idx+1, left, right + w[idx],a,w);
dfs(idx+1, left, right,a,w);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
int n, m;
while(cin >> n >> m, n&&m){
makeable.clear();
vector<ll> a(n); REP(i,n) cin >> a[i];
vector<ll> w(m); REP(i,m) cin >> w[i];
for(int i=0; i<n; i++)ok[i] = false;
dfs(0, 0, 0, a, w);
bool check = true;
vector<ll> need;
for(int i=0; i<n; i++){
if(!ok[i]){
need.push_back(i);
check = false;
}else{
}
}
if(check){
cout << 0 << endl;
}else{
set<ll> cand;
/* ใจใใใใๅ่ฃใๅๆใใ */
for(auto e: makeable){
cand.insert(abs(e+a[need[0]]));
}
for(int i=1; i<need.size(); i++){
int idx = need[i];
set<ll> nxt;
for(auto e: makeable){
if(cand.find(abs(e+a[idx])) != cand.end()){
nxt.insert(abs(e+a[idx]));
}
}
cand = nxt;
}
ll mi = (1LL<<60);
for(auto e: cand){
mi = min(mi, e);
break;
}
if(cand.size() == 0){
cout << -1 << endl;
}
else{
cout << mi << endl;
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int inf = 1e18;
long long int mod = 1e9 + 7;
long double eps = 1e-9;
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int pwr(long long int x, long long int y) {
long long int res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x);
y = y >> 1;
x = (x * x);
}
return res;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p);
}
long long int gcd(long long int a, long long int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long int inter(long long int l1, long long int r1, long long int l2,
long long int r2) {
long long int val = std::min(r1, r2) - std::max(l1, l2) + 1;
return val;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int i, y, x, z, g, key, h, m, a, b, n, c, j, q, k;
long long int t2, t3, t4, t1, t5, t6;
string s, s2, s1;
long long int l, r;
long long int tc;
tc = 1;
while (tc--) {
long long int la, lb, ra, rb, ta, tb;
cin >> la >> ra >> ta;
cin >> lb >> rb >> tb;
if (la > lb) {
swap(la, lb);
swap(ra, rb);
swap(ta, tb);
}
long long int g = gcd(ta, tb);
long long int ans = 0;
t1 = (lb - la) % g;
t2 = g - t1;
ans = std::max(ans, inter(la, ra, la + t1, la + t1 + (rb - lb)));
ans = std::max(ans, inter(lb, rb, lb + t2, lb + t2 + (ra - la)));
cout << ans;
}
return 0;
}
| 3 |
#include <iostream>
using namespace std;
int main(void){
int length,high_jump;
cin>>length>>high_jump;
cout<<length/high_jump+length%high_jump<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int d[405][405];
int dg[405];
int n, m;
double u[405][405];
int ut[405][405];
double sm[405];
int st[405];
int T;
void clr() { T++; }
double &gu(int i, int j) {
if (ut[i][j] != T) {
u[i][j] = 0;
ut[i][j] = T;
}
return u[i][j];
}
double &gsm(int i) {
if (st[i] != T) {
sm[i] = 0;
st[i] = T;
}
return sm[i];
}
vector<int> l[405];
double pd[405];
int main() {
scanf("%d %d", &n, &m);
for (int i = (0); i < (n); i++)
for (int j = (0); j < (n); j++) d[i][j] = 1000;
for (int i = (0); i < (n); i++) d[i][i] = 0;
for (int i = (0); i < (m); i++) {
int a, b;
scanf("%d %d", &a, &b);
a--;
b--;
d[a][b] = d[b][a] = 1;
dg[a]++;
dg[b]++;
}
for (int i = (0); i < (n); i++)
for (int j = (0); j < (n); j++)
for (int k = (0); k < (n); k++) d[j][k] = min(d[j][k], d[j][i] + d[i][k]);
double bst = 0;
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (n); j++) l[j].clear();
for (int j = (0); j < (n); j++) l[d[i][j]].push_back(j);
double cans = 0;
for (int li = (0); li < (n); li++)
if (int(l[li].size())) {
double lb = 1. / int(l[li].size());
for (int j = (0); j < (n); j++) pd[j] = 0;
clr();
for (int j : l[li]) {
double du = 1. / dg[j] / int(l[li].size());
for (int k = (0); k < (n); k++)
if (d[j][k] == 1) {
pd[k] += du;
}
}
for (int j = (0); j < (n); j++)
if (pd[j] > 1e-5) {
for (int k = (0); k < (n); k++) {
double ov = gu(k, d[j][k]);
if (ov < pd[j]) {
double os = gsm(k);
os += pd[j] - ov;
gsm(k) = os;
ov = pd[j];
gu(k, d[j][k]) = ov;
}
}
}
for (int j = (0); j < (n); j++) lb = max(lb, gsm(j));
cans += lb * int(l[li].size()) / 1. / n;
}
bst = max(bst, cans);
}
printf("%.12lf\n", bst);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<int> > trie;
vector<int> val, qtd;
int tam, a[300010], b[300010];
int create() {
if (tam < trie.size()) return tam++;
trie.push_back({-1, -1});
val.push_back(-1);
qtd.push_back(0);
tam++;
return trie.size() - 1;
}
void bin(int num, string &res) {
do {
res += ('0' + num % 2);
num /= 2;
} while (num);
res += string(30 - res.size(), '0');
reverse(begin(res), end(res));
}
void insert(string &str, int v) {
int no = 0;
for (char c : str) {
int &nxt = trie[no][c - '0'];
if (nxt == -1) nxt = create();
no = nxt;
}
val[no] = v;
qtd[no]++;
}
int search(string &str) {
int no = 0;
for (char c : str) {
int x = c - '0';
if (trie[no][x] == -1) x ^= 1;
if (trie[no][x] == -1) return -1;
no = trie[no][x];
}
return val[no];
}
bool apaga(string &str, int id, int no) {
if (id == str.size()) return --qtd[no] == 0;
int x = str[id] - '0';
bool uniq = apaga(str, id + 1, trie[no][x]);
if (uniq) {
trie[no][x] = -1;
tam--;
}
return uniq && trie[no][x ^ 1] == -1;
}
int main() {
create();
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
string x = "";
bin(b[i], x);
insert(x, b[i]);
}
for (int i = 0; i < n; i++) {
string atu = "";
bin(a[i], atu);
int vmen = search(atu);
string choice = "";
bin(vmen, choice);
apaga(choice, 0, 0);
printf("%d ", vmen ^ a[i]);
}
puts("");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using ld = long double;
using ll = long long;
using uint = unsigned int;
using ull = unsigned long long;
using namespace std;
const int INTMAX = 2147483647;
const int INTMIN = -2147483647;
const ll LLMAX = 9223372036854775807;
const ll LLMIN = -9223372036854775807;
ll MOD = 1000000007;
ll MOD2 = 998224353;
void open(const string &s) {
string a = s + ".in";
string b = s + ".out";
freopen(a.c_str(), "r", stdin);
freopen(b.c_str(), "w", stdout);
}
template <typename A, typename B>
ostream &operator<<(ostream &out, pair<A, B> const &pair);
template <typename T>
ostream &operator<<(ostream &out, unordered_set<T> const &s);
template <typename T>
ostream &operator<<(ostream &out, set<T> const &s);
template <typename T>
ostream &operator<<(ostream &out, multiset<T> const &s);
template <typename T>
ostream &operator<<(ostream &out, unordered_multiset<T> const &s);
template <typename K, typename V>
ostream &operator<<(ostream &out, multimap<K, V> const &m);
template <typename K, typename V>
ostream &operator<<(ostream &out, unordered_multimap<K, V> const &m);
template <typename T>
ostream &operator<<(ostream &out, vector<T> const &v);
template <typename K, typename V>
ostream &operator<<(ostream &out, map<K, V> const &m);
template <typename K, typename V>
ostream &operator<<(ostream &out, unordered_map<K, V> const &m);
template <typename A, typename B>
ostream &operator<<(ostream &out, pair<A, B> const &pair) {
out << "(" << pair.first << ", " << pair.second;
return out << ")";
}
template <typename T>
ostream &operator<<(ostream &out, unordered_set<T> const &s) {
out << "[";
int c = 0;
for (T i : s) {
if (c) out << ", ";
out << i;
c++;
}
return out << "]";
}
template <typename T>
ostream &operator<<(ostream &out, set<T> const &s) {
out << "[";
int c = 0;
for (T i : s) {
if (c) out << ", ";
out << i;
c++;
}
return out << "]";
}
template <typename T>
ostream &operator<<(ostream &out, vector<T> const &v) {
out << "[";
for (int i = 0; i < v.size(); i++) {
if (i) out << ", ";
out << v[i];
}
return out << "]";
}
template <typename K, typename V>
ostream &operator<<(ostream &out, map<K, V> const &m) {
out << "{";
int c = 0;
for (const auto &pair : m) {
if (c) out << ", ";
out << pair.first << "=" << pair.second;
c++;
}
return out << "}";
}
template <typename K, typename V>
ostream &operator<<(ostream &out, unordered_map<K, V> const &m) {
out << "{";
int c = 0;
for (const auto &pair : m) {
if (c) out << ", ";
out << pair.first << "=" << pair.second;
c++;
}
return out << "}";
}
template <typename T>
ostream &operator<<(ostream &out, multiset<T> const &s) {
out << "[";
int c = 0;
for (T i : s) {
if (c) out << ", ";
out << i;
c++;
}
return out << "]";
}
template <typename T>
ostream &operator<<(ostream &out, unordered_multiset<T> const &s) {
out << "[";
int c = 0;
for (T i : s) {
if (c) out << ", ";
out << i;
c++;
}
return out << "]";
}
template <typename K, typename V>
ostream &operator<<(ostream &out, multimap<K, V> const &m) {
out << "{";
int c = 0;
for (const auto &pair : m) {
if (c) out << ", ";
out << pair.first << "=" << pair.second;
c++;
}
return out << "}";
}
template <typename K, typename V>
ostream &operator<<(ostream &out, unordered_multimap<K, V> const &m) {
out << "{";
int c = 0;
for (const auto &pair : m) {
if (c) out << ", ";
out << pair.first << "=" << pair.second;
c++;
}
return out << "}";
}
template <typename T>
void shuffle_array(T &arr, int l) {
unsigned seed = 0;
shuffle(arr, arr + l, default_random_engine(seed));
}
template <typename T>
void sort_array(T &arr, int l) {
shuffle_array(arr, l);
sort(arr, arr + l);
}
void reverse_array(int arr[], int l) {
for (int i = 0; i < l / 2; i++) {
int temp = arr[i];
arr[i] = arr[l - i - 1];
arr[l - i - 1] = temp;
}
}
vector<int> to_vec(const string &s) {
vector<int> list;
for (char i : s) {
list.push_back(i - '0');
}
return list;
}
template <typename T, typename K>
void next_vec(vector<T> &vec, K &l) {
vec.clear();
vec = vector<T>(l, 0);
for (int i = 0; i < l; i++) cin >> vec[i];
}
string join(vector<string> &vec, const string &t = " ") {
string s;
int l = vec.size();
for (int i = 0; i < l; i++) {
if (i == l - 1)
s += vec[i];
else
s += vec[i] + t;
}
return s;
}
template <typename K, typename V>
V get_or_default(map<K, V> &m, K key, V value) {
if (m.count(key)) {
return m[key];
}
return value;
}
ll combo(ll n, ll d) {
if (d > n) return 0;
if (d * 2 > n) d = n - d;
if (d == 0) return 1;
ll res = n;
for (ll i = 2; i <= d; i++) {
res *= (n - i + 1);
res /= i;
}
return res;
}
template <typename T>
ll sum(vector<T> &vec) {
return accumulate(vec.begin(), vec.end(), 0);
}
template <typename T>
void sort_vec(vector<T> &vec) {
sort(vec.begin(), vec.end());
}
template <typename T>
void shuffle_vec(vector<T> &vec) {
shuffle(vec.begin(), vec.end(), mt19937(random_device()()));
}
template <typename T>
bool contains(set<T> &s, T element) {
return s.find(element) != s.end();
}
ll gcd(ll a, ll b) {
ll mex = max(a, b);
ll men = min(a, b);
if (mex % men == 0) {
return men;
}
return gcd(men, mex % men);
}
ll lcm(ll a, ll b) { return (a * b) / gcd(a, b); }
vector<int> ll_to_vec(ll &n) { return to_vec(to_string(n)); }
vector<string> split(const string &str, const string &delim) {
vector<string> tokens;
size_t prev = 0, pos = 0;
do {
pos = str.find(delim, prev);
if (pos == string::npos) pos = str.length();
string token = str.substr(prev, pos - prev);
if (!token.empty()) tokens.push_back(token);
prev = pos + delim.length();
} while (pos < str.length() && prev < str.length());
return tokens;
}
template <typename T>
T vec_max(vector<T> &vec) {
if (vec.empty()) throw 20;
T mex = vec[0];
for (auto i : vec) mex = max(mex, i);
return mex;
}
template <typename T>
T vec_min(vector<T> &vec) {
if (vec.empty()) throw 20;
T men = vec[0];
for (auto i : vec) men = min(men, i);
return men;
}
ll pow(ll a, ll b) {
ll c = 1;
for (ll i = 0; i < b; i++) c *= a;
return c;
}
string get_next_line() {
string line;
while (getline(cin, line)) break;
return line;
}
vector<char> to_char_array(const string &s) {
int l = s.size();
vector<char> vec;
vec.reserve(l);
for (int i = 0; i < l; i++) vec.push_back(s[i]);
return vec;
}
inline void M998() { swap(MOD, MOD2); }
template <typename T>
int binary_search(vector<T> &vec, T n) {
int l = vec.size();
int left = 0;
int right = l - 1;
while (left != right) {
int mid = (left + right + 1) / 2;
if (vec[mid] > n)
right = mid - 1;
else
left = mid;
}
return vec[left] == n ? left : -1;
}
ll to_ll(const string &s) {
ll c = 0;
int l = s.size();
for (int i = 0; i < l; i++) {
c += pow(2, l - i - 1) * (s[i] - '0');
}
return c;
}
ll to_ll(vector<char> &vec) {
ll c = 0;
int l = vec.size();
for (int i = 0; i < l; i++) {
c += pow(2, l - i - 1) * (vec[i] - '0');
}
return c;
}
string change_base(ll n, ll base, ll cur = 10) {
ll a = 0;
if (cur != 10) {
string b = to_string(n);
int l = b.size();
for (int i = 0; i < l; i++) a += pow(cur, l - i - 1) * (b[i] - '0');
} else
a = n;
ll mpow = 0;
while (true) {
mpow++;
ll b = pow(base, mpow);
if (b > a) {
mpow--;
break;
} else if (b == a)
break;
}
string s;
for (int i = mpow; i >= 0; i--) {
ll p = pow(base, i);
ll m = a / p;
a -= m * p;
s += to_string(m);
}
return s;
}
void solve() {
int l;
cin >> l;
vector<ll> vec;
next_vec(vec, l);
ll sum = 0;
for (ll i : vec) sum += i;
ll x = vec[0];
for (int i = 1; i < l; i++) x = x ^ vec[i];
cout << 2 << endl;
cout << x << " " << sum + x << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
int MMR;
cin >> MMR;
for (int i = 0; i < MMR; i++) solve();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool realTable[310][310];
bool DP[35][8][310][310];
vector<pair<int, int>> mov{{1, 0}, {1, 1}, {0, 1}, {-1, 1},
{-1, 0}, {-1, -1}, {0, -1}, {1, -1}};
int main() {
int N;
cin >> N;
DP[1][0][155][155] = true;
for (int stage = 1; stage <= N; stage++) {
int lenght;
cin >> lenght;
for (int i = 0; i < 310; i++) {
for (int j = 0; j < 310; j++) {
for (int k = 0; k < 8; k++) {
if (DP[stage][k][i][j]) {
for (int l = 1; l <= lenght; l++) {
realTable[i + mov[k].first * l][j + mov[k].second * l] = true;
}
DP[stage + 1][(k + 1) % 8][i + mov[k].first * lenght]
[j + mov[k].second * lenght] = true;
DP[stage + 1][(k + 7) % 8][i + mov[k].first * lenght]
[j + mov[k].second * lenght] = true;
}
}
}
}
}
cout << count(realTable[0],
realTable[0] + sizeof(realTable) / sizeof(realTable[0][0]),
true);
}
| 4 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.