solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, n, k;
string s, f;
char ch;
cin >> t;
while (t--) {
cin >> n >> k;
map<char, int> m[k];
s = "";
for (int i = 0; i < n; i++) {
cin >> ch;
s += ch;
m[i % k][ch]++;
}
int ans = 0;
for (int i = 0; i < k / 2; i++) {
int pe = 1000000009;
for (int j = 0; j < 26; j++) {
int v = (n / k) - m[i][(char)'a' + j] + (n / k) -
m[k - 1 - i][(char)'a' + j];
pe = min(pe, v);
}
ans += pe;
}
if (k % 2 == 1) {
int pe = 1000000009;
for (int j = 0; j < 26; j++) {
int v = (n / k) - m[k / 2][(char)'a' + j];
pe = min(pe, v);
}
ans += pe;
}
cout << ans << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) {
long long res = 1;
if (!(a % b)) res = 0;
while (a % b) {
if (a < b) swap(a, b);
a %= b;
if (a < b) swap(a, b);
res++;
}
return res + a / b;
}
int main() {
long long n, m;
cin >> n >> m;
long long res = 0;
while (n && m) {
if (n < m) swap(n, m);
res += n / m;
n %= m;
}
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int a[1200], used[1200], pre[1201];
int dp[1200][1200][2], p[1200][1200][2];
vector<int> findMove(int l, int r, int c, int c2) {
if (pre[r + 1] - pre[l] == 0) return vector<int>();
if (c2 == -1) c2 = dp[l][r][1];
vector<int> v = findMove(l, p[l][p[l][r][c2] - 1][c2] - 1, c, -1);
if (!v.empty()) return v;
v = findMove(p[l][p[l][r][c2] - 1][c2] + 1, p[l][r][c2] - 1, c, -1);
if (!v.empty()) return v;
v = findMove(p[l][r][c2] + 1, p[p[l][r][c2] + 1][r][c2] - 1, c, -1);
if (!v.empty()) return v;
v = findMove(p[p[l][r][c2] + 1][r][c2] + 1, r, c, -1);
if (!v.empty()) return v;
if (pre[p[p[l][r][c2] + 1][r][c2] + 1] - pre[p[l][p[l][r][c2] - 1][c2]] ==
3) {
if (a[p[l][r][c2]] == c) {
vector<int> v;
v.push_back(p[l][p[l][r][c2] - 1][c2]);
v.push_back(p[l][r][c2]);
v.push_back(p[p[l][r][c2] + 1][r][c2]);
return v;
} else
return vector<int>();
} else
return vector<int>();
}
int main() {
int i;
int n, x;
scanf("%d", &n);
for (i = 0; i < 3 * n; i++) scanf("%d", &x), a[x - 1] = 1;
int j, k, l;
for (i = 1; i <= 6 * n; i++) {
for (j = 0; j <= 6 * n - i; j++) {
k = j + i - 1;
if ((i % 3) == 0) {
for (l = j + 1; l < k; l += 3) {
if (dp[j][l - 1][a[l]] && dp[l + 1][k][a[l]])
dp[j][k][a[l]] = 1, p[j][k][a[l]] = l;
}
} else if ((i % 3) == 1) {
if (i == 1)
dp[j][k][a[j]] = 1, p[j][k][a[j]] = j;
else {
for (l = j; l <= k; l += 3) {
if (((l == j) || dp[j][l - 1][0] || dp[j][l - 1][1]) &&
((l == k) || dp[l + 1][k][0] || dp[l + 1][k][1]))
dp[j][k][a[l]] = 1, p[j][k][a[l]] = l;
}
}
}
}
}
for (i = 1; i <= 6 * n; i++) pre[i] = i;
for (i = 1; i <= 2 * n; i++) {
vector<int> v = findMove(0, 6 * n - 1, i & 1, 0);
used[v[0]] = used[v[1]] = used[v[2]] = 1;
for (j = 0; j < 6 * n; j++) pre[j + 1] = pre[j] + !used[j];
printf("%d %d %d\n", v[0] + 1, v[1] + 1, v[2] + 1);
}
return 0;
}
| 6 |
#include<bits/stdc++.h>
using namespace std;
int main(){
while(1){
int n;
int t;
cin>>t;
if(!t) break;
cin>>n;
int a=0;
for(int i=0;i<n;++i){
int b,c;
cin>>b>>c;
a+=c-b;
}
if(a<t) cout<<t-a<<endl;
else cout<<"OK"<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
const long long linf = 1LL << 62;
const int MAX = 510000;
long long dy[8] = {0, 1, 0, -1, 1, -1, 1, -1};
long long dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const double pi = acos(-1);
const double eps = 1e-7;
template <typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {
if (a > b) {
a = b;
return true;
} else
return false;
}
template <typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {
if (a < b) {
a = b;
return true;
} else
return false;
}
template <typename T1, typename T2>
inline void print2(T1 a, T2 b) {
cout << a << " " << b << endl;
}
template <typename T1, typename T2, typename T3>
inline void print3(T1 a, T2 b, T3 c) {
cout << a << " " << b << " " << c << endl;
}
const int mod = 1e9 + 7;
void solve() {
long long n;
cin >> n;
vector<long long> p(n), c(n);
for (long long i = 0; i < (n); i++) cin >> p[i], p[i]--;
for (long long i = 0; i < (n); i++) cin >> c[i];
vector<bool> visit(n, false);
long long ans = n;
for (long long i = 0; i < (n); i++) {
if (visit[i]) continue;
long long now = i;
vector<long long> cycle;
while (!visit[now]) {
cycle.push_back(now);
visit[now] = true;
now = p[now];
}
long long m = cycle.size();
chmin(ans, m);
for (long long j = (1); j < (m); j++) {
if (m % j) continue;
for (long long k = 0; k < (j); k++) {
bool ok = true;
for (long long l = k; l + j < m; l += j) {
if (c[cycle[l]] != c[cycle[l + j]]) {
ok = false;
break;
}
}
if (ok) chmin(ans, j);
}
}
}
cout << ans << endl;
}
int main() {
int t;
cin >> t;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MX = 1e6 + 5;
const int INF = 0x3f3f3f3f;
int n;
char S[MX];
int U[MX], D[MX];
long long Usum[MX], Dsum[MX];
long long checkU(int pos, int num) {
int l = 1, r = pos, m;
while (l <= r) {
m = (l + r) >> 1;
if (U[pos] - U[m - 1] >= num)
l = m + 1;
else
r = m - 1;
}
return Usum[pos] - Usum[l - 2];
}
long long checkD(int pos, int num) {
int l = pos, r = n, m;
while (l <= r) {
m = (l + r) >> 1;
if (D[pos] - D[m + 1] >= num)
r = m - 1;
else
l = m + 1;
}
return Dsum[pos] - Dsum[r + 2];
}
long long solve(int pos) {
long long ret = 0;
if (S[pos] == 'U') {
if (U[pos] > D[pos]) {
long long Usum = checkU(pos, D[pos] + 1);
long long Dsum = ::Dsum[pos];
ret = 2 * Dsum - (2 * Usum - pos) + n + 1;
} else {
long long Usum = ::Usum[pos];
long long Dsum = checkD(pos, U[pos]);
ret = 2 * Dsum - (2 * Usum - pos);
}
} else {
if (D[pos] > U[pos]) {
long long Usum = ::Usum[pos];
long long Dsum = checkD(pos, U[pos] + 1);
ret = 2 * Dsum - pos - 2 * Usum;
} else {
long long Usum = checkU(pos, D[pos]);
long long Dsum = ::Dsum[pos];
ret = 2 * Dsum - pos + n + 1 - 2 * Usum;
}
}
return ret;
}
int main() {
scanf("%d%s", &n, S + 1);
for (int i = 1; i <= n; i++) {
if (S[i] == 'U') {
U[i] = U[i - 1] + 1;
Usum[i] = Usum[i - 1] + i;
} else
U[i] = U[i - 1], Usum[i] = Usum[i - 1];
}
for (int i = n; i >= 1; i--) {
if (S[i] == 'D') {
D[i] = D[i + 1] + 1;
Dsum[i] = Dsum[i + 1] + i;
} else
D[i] = D[i + 1], Dsum[i] = Dsum[i + 1];
}
for (int i = 1; i <= n; i++) {
printf("%I64d%c", solve(i), i == n ? '\n' : ' ');
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int mxn = 5005;
long long a[mxn], b[mxn], c[mxn], d[mxn], x[mxn], n, bg, ed;
bool use[mxn];
inline long long diff(long long i, long long j) {
if (x[i] < x[j])
return x[j] - x[i] + d[i] + a[j];
else
return x[i] - x[j] + c[i] + b[j];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
long long nw, ans = 0;
cin >> n >> bg >> ed;
for (int i = 1; i <= n; ++i) cin >> x[i];
for (int i = 1; i <= n; ++i) cin >> a[i];
for (int i = 1; i <= n; ++i) cin >> b[i];
for (int i = 1; i <= n; ++i) cin >> c[i];
for (int i = 1; i <= n; ++i) cin >> d[i];
vector<long long> pre;
pre.push_back(bg), pre.push_back(ed);
for (int i = 1; i <= n; ++i) {
if (i == bg or i == ed) continue;
long long t, wz = 0, mn = 1ll << 60;
for (int j = 1; j < pre.size(); ++j) {
if ((t = diff(pre[j - 1], i) + diff(i, pre[j]) -
diff(pre[j - 1], pre[j])) < mn) {
mn = t;
wz = j;
}
}
pre.insert(pre.begin() + wz, i);
}
for (int i = 1; i < pre.size(); ++i) ans += diff(pre[i - 1], pre[i]);
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
map<string, int> strmap;
pair<int, int> dp[maxn];
void solve(string &str, int loc, string last) {
if (dp[loc].first != -1 && dp[loc].second != -1) {
return;
}
if (last.length() == 2) {
dp[loc].first = 1;
} else {
dp[loc].second = 1;
}
if (loc - 2 > 4) {
string temp = str.substr(loc - 2, 2);
if (temp != last) {
strmap[temp] = 1;
solve(str, loc - 2, temp);
}
}
if (loc - 3 > 4) {
string temp = str.substr(loc - 3, 3);
if (temp != last) {
strmap[temp] = 1;
solve(str, loc - 3, temp);
}
}
}
int main() {
string str;
cin >> str;
for (int i = 0; i < maxn; ++i) {
dp[i].first = dp[i].second = -1;
}
solve(str, str.length(), "");
cout << strmap.size() << endl;
for (auto it = strmap.begin(); it != strmap.end(); ++it) {
cout << it->first << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int m,d;
cin>> m >> d;
int64_t cnt=0;
for(int i=1;i<=m;i++){
for(int j=22;j<=d;j++){
if(j-j/10*10<=1) continue;
else if(i==(j/10)*(j-j/10*10)) cnt++;
}
}
cout << cnt << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, ms[2222][2222], f[2222], A[2222], B[2222], ans[2222], k, u;
vector<int> v[2222];
void rec(int x, int o) {
if (f[x]) return;
f[x] = o;
for (int i = 0; i < v[x].size(); i++)
if (ms[x][v[x][i]]) rec(v[x][i], o);
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> a >> b;
a--;
b--;
v[a].push_back(b);
v[b].push_back(a);
ms[a][b] = ms[b][a] = 1;
}
cin >> k;
for (int i = 0; i < k; i++) cin >> A[i] >> B[i];
for (int x = 0; x < n; x++)
for (int y = 0; y < x; y++)
if (ms[x][y]) {
ms[x][y] = ms[y][x] = 0;
memset(f, 0, sizeof(f));
u = 0;
for (int i = 0; i < n; i++)
if (!f[i]) u++, rec(i, u);
for (int i = 0; i < k; i++)
if (f[A[i] - 1] != f[B[i] - 1]) ans[i]++;
ms[x][y] = ms[y][x] = 1;
}
for (int i = 0; i < k; i++) cout << (ans[i]) << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool ckmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool ckmax(T& a, const T& b) {
return a < b ? a = b, 1 : 0;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MOD = 1000000007;
const char nl = '\n';
const int MX = 100001;
bool is_prime(long long num) {
for (int i = 2; i <= sqrt(num); i++) {
if (num % i == 0) {
return false;
}
}
return true;
}
void solve() {
int n;
cin >> n;
char second[n];
cin >> second[0];
int flag = 0;
for (int i = 1; i < n; i++) {
cin >> second[i];
if (second[i] < second[i - 1]) {
flag = 1;
}
}
if (flag == 0) {
for (int i = 0; i < n - 1; i++) {
cout << second[i];
}
cout << endl;
return;
}
int store = 0;
char x = second[0];
for (int i = 1; i < n; i++) {
if (second[i] < second[i - 1]) {
store = i - 1;
break;
}
}
for (int i = 0; i < n; i++) {
if (i != store) {
cout << second[i];
}
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
bool valid(int x, int y) {
if (x >= 1 && x <= n && y >= 1 && y <= m)
return true;
else
return false;
}
int main() {
vector<pair<double, int> > vect;
double n, t1, t2, k, x, y;
cin >> n >> t1 >> t2 >> k;
for (int i = 1; i <= n; i++) {
cin >> x >> y;
double a = x * t1 - (x * t1 * (k / 100)) + y * t2;
double b = y * t1 - (y * t1 * (k / 100)) + x * t2;
if (a > b)
vect.push_back(make_pair(-1 * a, i));
else
vect.push_back(make_pair(-1 * b, i));
}
sort(vect.begin(), vect.end());
for (int i = 0; i < n; i++) {
cout << vect[i].second << " ";
cout << fixed << setprecision(2) << -1 * vect[i].first << endl;
}
return 0;
}
| 2 |
#ifdef _WIN32
#define getc_unlocked(stdin) getc(stdin)
#endif
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <string>
#include <list>
#include <bitset>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <cmath>
#include <cassert>
#include <ctime>
#include <numeric>
#include <functional>
#include <valarray>
#include <complex>
using namespace std;
const int dx[]={0,-1,0,1,-1,1, 1,-1};
const int dy[]={1,0,-1,0, 1,1,-1,-1};
const double eps=1e-8;
typedef long long LL;
typedef unsigned long long uLL;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vgraph;
typedef vector<pii> vpii;
typedef vector<LL> vLL;
typedef vector<string> vs;
#define sz(a) a.size()
#define fori(i,a,b) for(int i(a),_b(b);i<=_b;++i)
#define ford(i,a,b) for(int i(a),_b(b);i>=_b;--i)
#define forn(i,n) fori(i,0,n-1)
#define fora(i,a) forn(i,sz(a))
#define fore(it,c) for(typeof((c).begin()) it=(c).begin();it!=(c).end();++it)
#define all(a) a.begin(),a.end()
#define mp make_pair
#define pb push_back
#define clear0(a) memset(a,0,sizeof(a))
#define clearm1(a) memset(a,-1,sizeof(a))
#define maximum(a) (*max_element(all(a)))
#define minimum(a) (*min_element(all(a)))
#define findx(a,x) (find(all(a),x)-a.begin())
#define two(X) (1LL<<(X))
#define contain(S,X) ((S)&two(X))
#define setbit(S,X) ((S)|=two(X))
#define clearbit(S,X) ((S)&=~two(X))
#define togglebit(S,X) ((S)^=two(X))
#define sqr(a) ((a)*(a))
#define fi "input.inp"
#define fo "output.out"
#define nmax 100
#define mmax 100
#define kmax 10
#define modulo 1000000007
#define maxc 999999999
void go(int fr, int num)
{
vector<int> a;
while (num)
{
int u = fr++;
while (!a.empty()) a.clear();
while(u)
{
a.pb(u%10);
u/=10;
}
for(int i = a.size()-1; i >= 0; --i)
{
if (num == 0) return;
printf("%d",a[i]);
--num;
}
}
}
typedef long long int64;
const int64 c[] = {0,9,90,900,9000,90000,900000,9000000,90000000,900000000,9000000000};
const int st[] = {0,1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000};
int main()
{
#ifndef ONLINE_JUDGE
//freopen(fi,"r",stdin);
//freopen(fo,"w", stdout);
#endif
int n, k;
while(1)
{
scanf("%d %d", &n, &k);
if (n == 0 && k == 0) break;
if (n==0)
{
printf("0");
--k;
}
int uu = n, stt, du;
fori(i, 1, 9)
if (uu > c[i]*i) uu-=c[i]*i;
else
{
stt = st[i] + uu / i;
if (uu % i ==0)
{
stt--;
du = i;
}
else du = uu % i;
break;
}
int temp = stt;
vector<int> a;
while (!a.empty()) a.clear();
while(stt)
{
a.pb(stt%10);
stt/=10;
}
for(int i = a.size()-du; i>=0; --i)
{
if (k==0) break;
printf("%d", a[i]);
--k;
}
go(temp+1, k);
printf("\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 300010, M = 10000005;
long long t, n, a[N], f[N], b[N], fs[N], bs[N], B, F;
int solve() {
scanf("%lld", &t);
while (t--) {
scanf("%lld", &n);
bool pos = 0;
B = 0, F = 0;
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
f[i] = 0, b[i] = 0;
if (a[i] < i) f[i] = 1;
if (a[i] < n - 1 - i) b[i] = 1;
B += b[i];
}
for (int i = 0; i < n; i++) {
F += f[i];
bs[i] = B;
fs[i] = F;
B -= b[i];
}
for (int i = 0; i < n; i++) {
long long x = 0, y = 0;
if (i - 1 >= 0) x = fs[i - 1];
if (i + 1 < n) y = bs[i + 1];
if (x == 0 && y == 0 && a[i] >= i && a[i] >= n - i - 1) {
pos = 1;
break;
}
}
if (pos)
printf("Yes\n");
else
printf("No\n");
}
return 0;
}
int main() {
int ret = solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int pow(int a, int b) {
long long k = 1;
for (int i = 0; i < b; ++i) k = k * a % 1000000007;
return k;
}
int a[150];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
string s;
cin >> n >> s;
for (int i = 0; i < n; ++i) ++a[s[i]];
int mx = 0;
int mxa = 0;
for (int i = 'A'; i < 'Z'; ++i) {
if (a[i] == mx)
++mxa;
else if (a[i] > mx) {
mx = a[i];
mxa = 1;
}
}
cout << pow(mxa, n) << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const long long int INF = 1e18;
const long double PI =
3.141592653589793238462643383279502884197169399375105820974944;
int main() {
int q;
cin >> q;
while (q--) {
int i, n, m, j;
cin >> n;
long long int a[n];
int o1 = 0, e1 = 0, o2 = 0, e2 = 0;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] % 2)
o1++;
else
e1++;
}
cin >> m;
long long int b[m];
long long int count = 0;
for (i = 0; i < m; i++) {
cin >> b[i];
if (b[i] % 2)
count += o1;
else
count += e1;
}
cout << count << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline bool active (int etat, int i) {
return ((etat & (1 << i))!= 0);
}
inline bool est_ok (int nbDeja, int cote, int obj) {
if (nbDeja > obj)
return false;
int nbBlancsMin = (2-nbDeja);
int nbBlancsObj = cote-obj;
if (nbBlancsMin > nbBlancsObj)
return false;
return true;
}
int main() {
ios:: sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
int nbTests;
cin >> nbTests;
for (int iTest = 0; iTest < nbTests; iTest++) {
int cote, haut, droite, bas, gauche;
cin >> cote >> haut >> droite >> bas >> gauche;
bool okToutEtat = false;
for (int etat = 0; etat < pow(2, 4); etat++) {
int nbHaut = 0, nbBas = 0, nbGauche = 0, nbDroite = 0;
if (active(etat, 0)) {
nbGauche++;
nbHaut++;
}
if (active(etat, 1)) {
nbHaut++;
nbDroite++;
}
if (active(etat, 2)) {
nbDroite++;
nbBas++;
}
if (active(etat, 3)) {
nbBas++;
nbGauche++;
}
bool ok = true;
if (!est_ok(nbHaut, cote, haut))
ok = false;
if (!est_ok(nbBas, cote, bas))
ok = false;
if (!est_ok(nbDroite, cote, droite))
ok = false;
if (!est_ok(nbGauche, cote, gauche))
ok = false;
if (ok)
okToutEtat = true;
}
if (okToutEtat)
cout << "YES\n";
else
cout << "NO\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
int a[200020], b[200020], vis[200020], fa[2][200020], ans, rk[200020],
ed[200020], Ans[200020];
int find(int f, int x) {
return x != fa[f][x] && ed[a[x]] ? fa[f][x] = find(f, fa[f][x]) : x;
}
inline void solve() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]), vis[i] = ed[i] = 0, rk[a[i]] = i;
Ans[0] = 1, ans = 0;
for (int i = 1; i <= n; ++i) Ans[i] = 2ll * Ans[i - 1] % 998244353;
for (int i = 1; i <= k; ++i) scanf("%d", &b[i]), vis[b[i]] = 1;
for (int i = 2; i <= n; ++i) fa[0][i] = i - 1;
for (int i = 1; i < n; ++i) fa[1][i] = i + 1;
fa[0][1] = 1, fa[1][n] = n;
for (int i = 1; i <= k; ++i) {
int l = find(0, fa[0][rk[b[i]]]);
int r = find(1, fa[1][rk[b[i]]]);
if (vis[a[l]] + vis[a[r]] == 0) ++ans;
if (vis[a[l]] + vis[a[r]] > 1) {
puts("0");
return;
}
ed[b[i]] = 1;
}
printf("%d\n", Ans[ans]);
}
int main() {
int T = 1;
scanf("%d", &T);
while (T--) solve();
}
| 6 |
#include <bits/stdc++.h>
const int maxn = 60, inf = 0x3f3f3f3f;
int head[maxn], cnt = 1, deg[maxn];
struct Edge {
int to, nxt, w;
} e[maxn << 1];
inline void addedge(int a, int b, int c) {
e[++cnt] = (Edge){b, head[a], c};
head[a] = cnt;
e[++cnt] = (Edge){a, head[b], c};
head[b] = cnt;
++deg[a], ++deg[b];
}
int n, m, S, sz[maxn];
int f[maxn << 1][maxn][maxn];
void dfs(int u, int fa = 0) {
for (int i = head[u], v; i; i = e[i].nxt) {
v = e[i].to;
if (v != fa) dfs(v, u), sz[u] += sz[v];
}
}
int dp(int E, int x, int y) {
if (!x && !y) return 0;
int &F = f[E][x][y], u = e[E].to;
if (~F) return F;
if (deg[u] == 1) {
if (y == 0) return 0;
return F = dp(E ^ 1, y, 0) + e[E].w;
}
int g[maxn];
memset(g, 0, sizeof g), g[0] = inf;
for (int i = head[u], v; i; i = e[i].nxt)
if (i ^ E ^ 1) {
v = e[i].to;
for (int j = x; j; --j)
for (int k = j; k; --k)
g[j] =
std::max(g[j], std::min(g[j - k], dp(i, k, x + y - k) + e[i].w));
}
return F = g[x];
}
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(0), std::cout.tie(0);
std::cin >> n;
for (int i = 1, a, b, c; i < n; ++i) {
std::cin >> a >> b >> c;
addedge(a, b, c);
}
std::cin >> S >> m;
for (int i = 0, x; i < m; ++i) std::cin >> x, ++sz[x];
dfs(S), memset(f, -1, sizeof f);
int ans = inf;
for (int i = head[S], v; i; i = e[i].nxt) {
v = e[i].to;
ans = std::min(ans, dp(i, sz[v], m - sz[v]) + e[i].w);
}
std::cout << ans << '\n';
return 0;
}
| 5 |
#pragma GCC target("avx512f,avx512dq,avx512cd,avx512bw,avx512vl")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
#include <bits/stdc++.h>
int main() {
int n;
string s;
cin >> n >> s;
int64_t res = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < i; j++) {
if (s[i] == s[j]) continue;
for (int k = 0; k < j; k++) if (j - k != i - j && s[k] != s[i] && s[k] != s[j]) res++;
}
}
printf("%" PRId64 "\n", res);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int z;
cin >> z;
while (z--) {
int k;
cin >> k;
int row, col;
if (k == 1) {
cout << 1 << " " << 1 << endl;
continue;
}
int j;
for (int i = 1; i * i < k; i++) {
j = i;
}
int a = j * j;
int b = j + 1;
int c = a + b;
if (k <= c) {
col = b;
int p = a + 1;
int cnt = 1;
while (p < k) {
cnt++;
p++;
}
row = cnt;
cout << row << " " << col << endl;
} else {
row = j + 1;
int cnt = 1;
int q = c;
while (q < k) {
cnt++;
q++;
}
cnt--;
col = b - cnt;
cout << row << " " << col << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long long mod = 1000 * 1000 * 1000 + 7;
const int maxn = 100009;
using namespace std;
int c, n, m, q, used[maxn], usedd[maxn][4], com[maxn], dd[maxn], g[maxn][4],
maxlen[maxn];
vector<int> v[maxn], arr[maxn], sum[maxn];
map<pair<int, int>, double> mp;
void comp(int w, int nom) {
used[w] = true;
com[w] = nom;
for (int i = 0; i < v[w].size(); i++)
if (!used[v[w][i]]) comp(v[w][i], nom);
}
int d(int w, int len, int k) {
int nom = w;
usedd[w][k] = true;
g[w][k] = len;
dd[w] = max(len, dd[w]);
if (k == 3) arr[com[w]].push_back(dd[w]);
for (int i = 0; i < v[w].size(); i++)
if (!usedd[v[w][i]][k]) {
int maxy = d(v[w][i], len + 1, k);
if (g[maxy][k] > g[nom][k]) nom = maxy;
}
return nom;
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> m >> q;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
v[a].push_back(b);
v[b].push_back(a);
}
for (int i = 1; i <= n; i++)
if (!used[i]) {
int x, y;
c++;
comp(i, c);
arr[com[i]].push_back(0);
x = d(i, 0, 0);
y = d(x, 0, 1);
maxlen[com[i]] = g[y][1];
d(x, 0, 2);
d(y, 0, 3);
sum[com[i]].push_back(0);
sort(arr[com[i]].begin(), arr[com[i]].end());
for (int j = 1; j < arr[com[i]].size(); j++)
sum[com[i]].push_back(sum[com[i]][j - 1] + arr[com[i]][j]);
}
for (int i = 1; i <= q; i++) {
int a, b;
long long ans = 0;
cin >> a >> b;
a = com[a];
b = com[b];
if (arr[a].size() > arr[b].size()) swap(a, b);
if (mp[make_pair(a, b)] == 0) {
if (a == b) {
cout << -1 << endl;
mp[make_pair(a, b)] = -1;
} else {
int maxy = max(maxlen[a], maxlen[b]);
for (int j = 1; j < arr[a].size(); j++) {
int l = 0, r = arr[b].size();
while (r - l > 1) {
int m = (l + r) / 2;
if (arr[a][j] + arr[b][m] + 1 < maxy)
l = m;
else
r = m;
}
ans += (long long)l * maxy + (arr[b].size() - l - 1) +
(arr[b].size() - l - 1) * arr[a][j] +
sum[b][arr[b].size() - 1] - sum[b][l];
}
cout << fixed << setprecision(10)
<< (double)ans / (arr[a].size() - 1) / (arr[b].size() - 1) << endl;
mp[make_pair(a, b)] =
(double)ans / (arr[a].size() - 1) / (arr[b].size() - 1);
}
} else
cout << fixed << setprecision(10) << mp[make_pair(a, b)] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int len = 40;
int n;
long long a[N], l[N], r[N], res;
int tr[N * 41][2], cnt;
void add(long long x) {
int cur = 1;
for (int i = len; i >= 0; i--) {
int b = (x >> i) & 1;
if (tr[cur][b] == 0) tr[cur][b] = ++cnt;
cur = tr[cur][b];
}
}
long long get(long long x) {
int cur = 1;
for (int i = len; i >= 0; i--) {
int b = (x >> i) & 1;
if (tr[cur][1 - b] != 0) {
cur = tr[cur][1 - b];
x = x | (1LL << i);
} else {
cur = tr[cur][b];
x = x & (~(1LL << i));
}
}
return x;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%I64d", &a[i]);
for (int i = 1; i <= n; i++) {
l[i] = l[i - 1] ^ a[i];
r[n - i + 1] = r[n - i + 2] ^ a[n - i + 1];
}
cnt = 1;
add(0);
for (int i = 1; i <= n + 1; i++) {
long long x = get(r[i]);
res = max(res, x);
add(l[i]);
}
cout << res;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
const int M = 1e6 + 1;
const int mod = 1e9 + 7;
const int base = 41;
int n, sz[N];
string s[N];
vector<int> f[N], lcp[N];
long long g[M], h[M], t[M], w[M];
vector<long long> hashArr[N];
long long p[M];
long long getHash(int i, int l, int r) {
return ((hashArr[i][r] - hashArr[i][l - 1] * p[r - l + 1]) % mod + mod) % mod;
}
int getFirstDiff(int i, int l1, int r1, int l2, int r2) {
int r0 = min(r1 - l1, r2 - l2) + l1, v = l1 - 1;
int l = l1, r = r0;
while (l <= r) {
int mid = (l + r) >> 1;
if (getHash(i, l1, mid) == getHash(i + 1, l2, l2 + mid - l1)) {
v = mid;
l = mid + 1;
} else
r = mid - 1;
}
++v;
return v;
}
string getS(int i, int j) {
string tt = "";
for (int k = 0; k < sz[i]; ++k)
if (k + 1 != j) tt += s[i][k];
return tt;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> s[i];
sz[i] = s[i].size();
s[i] = s[i] + " ";
for (int j = 0; j <= sz[i]; ++j) f[i].push_back(0LL);
hashArr[i].push_back(0LL);
for (int j = 0; j < sz[i]; ++j) {
hashArr[i].push_back((hashArr[i].back() * base + s[i][j] - 'a' + 1) %
mod);
}
}
p[0] = 1;
for (int i = 1; i < M; ++i) p[i] = (p[i - 1] * base) % mod;
for (int i = 0; i <= s[1].size(); ++i) f[1][i] = 1;
for (int i = 1; i <= n; ++i) {
if (i >= n) break;
for (int j = 0; j <= sz[i + 1]; ++j) g[j] = h[j] = t[j] = w[j] = 0;
lcp[i + 1].resize(sz[i + 1] + 1);
lcp[i + 1][sz[i + 1]] = sz[i + 1];
for (int j = sz[i + 1] - 1; j >= 1; --j) {
if (s[i + 1][j - 1] == s[i + 1][j + 1 - 1])
lcp[i + 1][j] = lcp[i + 1][j + 1];
else
lcp[i + 1][j] = j;
}
int k = getFirstDiff(i, 1, sz[i], 1, sz[i + 1]);
for (int j = 0; j <= sz[i]; ++j) {
int k0 = k;
if (k0 >= j) k0 = getFirstDiff(i, j + 1, sz[i], max(j, 1), sz[i + 1]);
int k1 = max(1, j <= 0 ? k0 : (k0 < j ? k0 : k0 - 1));
if (s[i][k0 - 1] <= s[i + 1][k1 - 1]) {
f[i + 1][0] = (f[i + 1][0] + f[i][j]) % mod;
if (k1 < sz[i + 1]) {
for (int v = k1 + 1; v <= sz[i + 1]; ++v)
f[i + 1][v] = (f[i + 1][v] + f[i][j]) % mod;
}
}
int k2 = 0;
if (k0 > j)
k2 = getFirstDiff(i, k0, sz[i], k1 + 1, sz[i + 1]);
else {
k2 = getFirstDiff(i, k0, j - 1, k1 + 1, sz[i + 1]);
if (k2 >= j) {
k2 = getFirstDiff(i, j + 1, sz[i], j + 1, sz[i + 1]);
}
}
if (s[i][k2 - 1] <= s[i + 1][k2 + (k2 < j || j <= 0) - 1]) {
f[i + 1][k1] = (f[i + 1][k1] + f[i][j]) % mod;
}
if (k1 > 1) {
for (int v = 1; v <= sz[i + 1]; ++v) {
if (lcp[i + 1][v] < k1 &&
s[i + 1][lcp[i + 1][v] - 1] < s[i + 1][lcp[i + 1][v] + 1 - 1]) {
f[i + 1][v] = (f[i + 1][v] + f[i][j]) % mod;
}
}
}
if (s[i][k0 - 1] <= s[i + 1][k1 - 1]) {
for (int v = 1; v < k1; ++v)
if (lcp[i + 1][v] > k1) {
f[i + 1][v] = (f[i + 1][v] + f[i][j]) % mod;
}
}
if (s[i][k2 - 1] <= s[i + 1][k2 + (k2 < j || j <= 0) - 1]) {
for (int v = 1; v < k1; ++v)
if (lcp[i + 1][v] == k1) {
f[i + 1][v] = (f[i + 1][v] + f[i][j]) % mod;
}
}
}
}
int res = 0;
for (int i = 0; i <= sz[n]; ++i) res = (res + f[n][i]) % mod;
cout << res;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q, n, k;
cin >> q;
while (q--) {
cin >> n >> k;
string s;
cin >> s;
int ans = n, tmp = 0;
vector<int> dp(k, 0), cnt(k, 0);
for (int i = 0; i < n; i++) {
dp[i % k] = min(dp[i % k], 2 * cnt[i % k] - (i - i % k) / k);
if (s[i] == '1') {
tmp++;
cnt[i % k]++;
}
ans = min(ans, (i - i % k) / k + 1 - 2 * cnt[i % k] + dp[i % k]);
}
cout << min(ans + tmp, tmp) << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<int> rev;
int l[200002], r[200002], tim;
vector<int> g[200000];
void dfs(int u, int par) {
rev.push_back(u);
l[u] = tim;
tim++;
for (int i = 0; i < g[u].size(); i++) {
if (g[u][i] == par) continue;
dfs(g[u][i], u);
}
r[u] = tim - 1;
}
bool cmp(pair<pair<int, int>, int> x, pair<pair<int, int>, int> y) {
if (x.first.first / 333 != y.first.first / 333) {
return (x.first.first / 333) < (y.first.first / 333);
} else {
return (x.first.second) < (y.first.second);
}
}
int freq[200002], K[200002], ans[200002];
vector<pair<pair<int, int>, int> > v;
int col[200001];
int f2[200001];
int main() {
tim = 0;
int n, m;
cin >> n;
cin >> m;
for (int i = 0; i < n; i++) {
scanf("%d", &col[i + 1]);
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
dfs(1, -1);
for (int i = 0; i < m; i++) {
int vtx, k;
cin >> vtx >> k;
v.push_back(make_pair(make_pair(l[vtx] + 1, r[vtx] + 1), i));
K[i] = k;
}
sort(v.begin(), v.end(), cmp);
int CL = 1, CR = 0, idx;
int temp = 0;
for (int i = 0; i < v.size(); i++) {
int l = v[i].first.first;
int r = v[i].first.second;
int idx = v[i].second;
while (CL > l) {
CL--;
freq[col[rev[CL - 1]]]++;
f2[freq[col[rev[CL - 1]]]]++;
}
while (CR < r) {
CR++;
freq[col[rev[CR - 1]]]++;
f2[freq[col[rev[CR - 1]]]]++;
}
while (CL < l) {
freq[col[rev[CL - 1]]]--;
f2[freq[col[rev[CL - 1]]] + 1]--;
CL++;
}
while (CR > r) {
freq[col[rev[CR - 1]]]--;
f2[freq[col[rev[CR - 1]]] + 1]--;
CR--;
}
ans[idx] = f2[K[idx]];
}
for (int i = 0; i < m; i++) {
cout << ans[i] << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long fpm(long long b, long long e, long long m) {
long long t = 1;
for (; e; e >>= 1, b = b * b % m) e & 1 ? t = t * b % m : 0;
return t;
}
template <class T>
inline bool chkmin(T &a, T b) {
return a < b ? a = b, true : false;
}
template <class T>
inline bool chkmax(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class edge>
struct Graph {
vector<vector<edge> > adj;
Graph(int n) {
adj.clear();
adj.resize(n + 5);
}
void adde(int s, edge e) { adj[s].push_back(e); }
typename vector<edge>::iterator operator[](int t) { return adj[t].begin(); }
};
const int maxlen = 4400000, mod = 51123987;
char S[maxlen];
int f[maxlen], x[maxlen];
long long y[maxlen];
int main() {
ios_base::sync_with_stdio(false);
int n, len;
cin >> n >> (S + 1), len = n * 2 + 1;
for (int i = n; i >= 0; --i) S[i * 2 + 1] = '#', S[i * 2] = S[i];
f[1] = 1;
for (int i = 2, t = 1; i <= len; ++i) {
f[i] = min(f[t * 2 - i], t + f[t] - i);
for (; i != f[i] && S[i - f[i]] == S[i + f[i]]; ++f[i])
;
if (i + f[i] > t + f[t]) t = i;
}
for (int i = 2; i < len; ++i) {
++x[i - f[i] + 1], --x[i + 1];
++y[i - f[i] + 1], y[i + 1] -= 2, ++y[i + f[i] + 1];
}
for (int i = 1; i <= len; ++i) x[i] += x[i - 1], y[i] += y[i - 1];
for (int i = 1; i <= len; ++i) y[i] += y[i - 1];
long long ans = 0;
for (int i = 2; i <= len; i += 2)
ans +=
(long long)(y[i] - x[i] - 1) % mod * x[i] % mod * (mod - mod / 2) % mod;
cout << ans % mod << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long rr[] = {0, 1, 1, 1, 0, -1, -1, -1};
long long cc[] = {1, 1, 0, -1, -1, -1, 0, 1};
const long long mod = 1e9 + 7;
const long long N = 300050;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long test = 1;
cin >> test;
while (test--) {
long long n = 3;
long long a[n];
for (long long i = 0; i < n; ++i) {
cin >> a[i];
}
sort(a, a + n);
if (a[1] == a[2]) {
cout << "YES\n";
cout << a[0] << ' ' << a[0] << ' ' << a[1] << '\n';
} else
cout << "NO\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s[100000];
bool cmp(string a, string b) { return a + b < b + a; }
int main() {
int n;
while (cin >> n) {
for (int i = 0; i < n; ++i) cin >> s[i];
sort(s, s + n, cmp);
for (int i = 0; i < n; ++i) cout << s[i];
cout << endl;
}
return 0;
}
| 3 |
#include<iostream>
#include<cstdio>
int main(){
for(int i=1;i<10;i++){
for(int j=1;j<10;j++){
printf("%dx%d=%d\n",i,j,i*j);
}
}
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int A,B,C,D;
int main(){
cin>>A>>B>>C>>D;
if(A+B==C+D)cout<<"Balanced"<<endl;
else if(A+B>C+D)cout<<"Left"<<endl;
else cout<<"Right"<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 555250;
int a[N], c[N], h, vis[N];
vector<vector<int> > g;
map<int, int> ma;
void dfs(int u) {
if (vis[u]) return;
vis[u] = 1;
ma[c[u]]++;
for (int i = 0, to = g[u].size(); i < to; ++i) {
int v = g[u][i];
dfs(v);
}
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 0, to = n; i < to; ++i) scanf("%d", &c[i]);
g.resize(n);
for (int i = 0, to = m; i < to; ++i) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
g[u].push_back(v);
g[v].push_back(u);
}
int ans = 0;
for (int i = 0, to = n; i < to; ++i) {
if (!vis[i]) {
h = 0;
ma.clear();
dfs(i);
int s = 0, mx = 0;
for (map<int, int>::iterator it = ma.begin(); it != ma.end(); it++) {
mx = max(mx, it->second);
s += it->second;
}
ans += s - mx;
}
}
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int a[100000 + 10];
int p[100000 + 10];
int b[100000];
int po[100000 + 10];
int dp[100000 + 10];
int num;
void prime() {
memset(po, 0, sizeof(po));
memset(dp, 0, sizeof(dp));
memset(p, 0, sizeof(p));
int i = 0, sum = 0, x = 0;
p[0] = 1;
p[1] = 1;
for (i = 2; i <= 100000; i++) {
sum = i;
x = 2;
if (p[sum] == 1) continue;
sum = i * x;
while (sum <= 100000) {
p[sum] = 1;
x++;
sum = i * x;
}
}
num = 0;
for (i = 1; i <= 100000; i++) {
if (!p[i]) {
b[++num] = i;
}
}
}
int max(int a, int b) { return a > b ? a : b; }
int solve(int x, int p) {
int tmp = x, sum = 0;
int i, tru;
for (i = 1; i <= num; i++) {
if (tmp == 1) break;
if (b[i] > 316) {
sum = max(sum, dp[po[tmp]] + 1);
po[tmp] = p;
break;
}
tru = 0;
while (tmp % b[i] == 0) {
tru = 1;
tmp /= b[i];
sum = max(sum, dp[po[b[i]]] + 1);
}
if (tru) {
po[b[i]] = p;
}
}
return sum;
}
int main() {
prime();
int n, i;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
int ans = 1;
for (i = n; i >= 1; i--) {
dp[i] = solve(a[i], i);
if (dp[i] > ans) ans = dp[i];
}
printf("%d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const int mod = 1e9 + 7;
long long int powmod(long long int a, long long int b) {
long long int res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int nxt() {
int x;
scanf("%d", &x);
return x;
}
int main() {
int tc = nxt();
while (tc--) {
int row = nxt(), col = nxt();
vector<string> grid(row);
for (int i = 0; i < row; i++) cin >> grid[i];
int high = 0;
for (int i = 0; i < row; i++)
for (int j = 0; j < col; j++)
if (grid[i][j] != '.') high = max(high, grid[i][j] - 'a' + 1);
vector<pair<pair<int, int>, pair<int, int>>> ans;
for (int i = high - 1; i >= 0; i--) {
char ch = i + 'a';
vector<pair<int, int>> c;
for (int i = 0; i < row; i++)
for (int j = 0; j < col; j++) {
if (grid[i][j] == ch) c.push_back({i, j});
}
bool hori = true, vert = true;
sort((c).begin(), (c).end());
for (int j = 1; j < c.size(); j++) {
if (c[j].first != c[j - 1].first) hori = false;
if (c[j].second != c[j - 1].second) vert = false;
}
if (!hori && !vert) {
puts("NO");
goto end;
}
if (c.size() == 0) {
ans.push_back(ans.back());
} else if (hori) {
for (int j = c[0].second; j <= c[c.size() - 1].second; j++) {
if (grid[c[0].first][j] == ch)
grid[c[0].first][j] = '-';
else if (grid[c[0].first][j] != '-') {
puts("NO");
goto end;
}
}
ans.push_back({c[0], c[c.size() - 1]});
} else {
for (int j = c[0].first; j <= c[c.size() - 1].first; j++) {
if (grid[j][c[0].second] == ch)
grid[j][c[0].second] = '-';
else if (grid[j][c[0].second] != '-') {
puts("NO");
goto end;
}
}
ans.push_back({c[0], c[c.size() - 1]});
}
}
puts("YES");
reverse((ans).begin(), (ans).end());
printf("%d\n", (int)ans.size());
for (auto x : ans)
printf("%d %d %d %d\n", x.first.first + 1, x.first.second + 1,
x.second.first + 1, x.second.second + 1);
end:;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
const int Block = 400;
int l1, r1, l2, r2, n, m, cntB, Ans[N];
int F[N], s[N], v[N], A[N], B[N], q1[N], q2[N];
struct Query {
int l, r, id;
bool operator<(Query p) const {
return l / Block == p.l / Block ? r < p.r : l < p.l;
}
} Q[N];
inline int read() {
int x = 0, c = getchar(), f = 0;
for (; c > '9' || c < '0'; f = c == '-', c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) x = (x << 1) + (x << 3) + c - '0';
return f ? -x : x;
}
inline void write(int x) {
if (x > 9) write(x / 10);
putchar(x % 10 + 48);
return;
}
inline void Add(int x, int val) {
F[s[A[x]]]--;
s[A[x]] += val;
F[s[A[x]]]++;
}
inline int Get() {
return ((l1 <= r1 && q1[l1] < q2[l2]) || (l2 > r2)) ? q1[l1++] : q2[l2++];
}
inline int Solve() {
int last = 0, Res = 0, k, tmp;
l1 = 1, l2 = 1, r1 = 0, r2 = 0;
for (int i = 1; i <= cntB; i++)
if (s[B[i]] > Block) q1[++r1] = s[B[i]];
sort(q1 + 1, q1 + r1 + 1);
for (int i = 1; i <= Block; i++) v[i] = F[i];
for (int i = 1; i <= Block; i++) {
if (!v[i]) continue;
if (last) {
v[i]--;
Res += i + last;
if (i + last > Block)
q2[++r2] = i + last;
else
v[i + last]++;
last = 0;
}
if (v[i] & 1) last = i, v[i]--;
Res += v[i] * i;
if ((i << 1) > Block)
while (v[i]) q2[++r2] = i << 1, v[i] -= 2;
else
v[i << 1] += v[i] >> 1;
}
k = r1 + r2;
if (!k) return Res;
if (last) k++, q2[--l2] = last;
while (--k) {
tmp = Get() + Get();
Res += tmp;
q2[++r2] = tmp;
}
return Res;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
s[A[i] = read()]++;
if (s[A[i]] == Block) B[++cntB] = A[i];
}
m = read();
for (int i = 1; i <= m; i++) Q[i] = (Query){read(), read(), i};
sort(Q + 1, Q + m + 1);
int l = Q[1].l, r = l - 1;
memset(s, 0, sizeof s);
for (int i = 1; i <= m; i++) {
while (l > Q[i].l) Add(--l, 1);
while (r < Q[i].r) Add(++r, 1);
while (l < Q[i].l) Add(l++, -1);
while (r > Q[i].r) Add(r--, -1);
Ans[Q[i].id] = Solve();
}
for (int i = 1; i <= m; i++) write(Ans[i]), putchar(10);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1E-8;
const int dx4[4] = {1, 0, 0, -1};
const int dy4[4] = {0, -1, 1, 0};
const int inf = 0x3f3f3f3f;
const int N = 2E5 + 7;
struct Node {
int l, r;
int id;
} a[N];
int n;
int ans;
vector<int> ret;
bool cmp(Node x, Node y) {
if (x.l == y.l) return x.r > y.r;
return x.l < y.l;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d %d", &a[i].l, &a[i].r);
a[i].id = i;
}
sort(a + 1, a + n + 1, cmp);
ans = 0;
int mxR = -1;
int lsR = -1;
for (int i = 1; i <= n; i++) {
if (i >= 3) lsR = a[i - 2].r;
if (a[i].r <= mxR) {
ans++;
ret.push_back(a[i].id);
} else if (a[i].l >= mxR + 1) {
mxR = max(mxR, a[i].r);
} else if (lsR != -1 && a[i].l <= lsR + 1 && a[i].r) {
ans++;
ret.push_back(a[i - 1].id);
}
mxR = max(mxR, a[i].r);
}
if (ans == 0)
ans = -1;
else
ans = ret[0];
printf("%d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void __print(int x) { cerr << x; };
void __print(long x) { cerr << x; };
void __print(long long x) { cerr << x; };
void __print(unsigned x) { cerr << x; };
void __print(unsigned long x) { cerr << x; };
void __print(unsigned long long x) { cerr << x; };
void __print(float x) { cerr << x; };
void __print(double x) { cerr << x; };
void __print(long double x) { cerr << x; };
void __print(char x) { cerr << '\'' << x << '\''; };
void __print(const char *x) { cerr << '\"' << x << '\"'; };
void __print(const string &x) { cerr << '\"' << x << '\"'; };
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T &x) {
int f = 0;
cerr << '{';
for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
long long powmod(long long a, long long b) {
long long res = 1;
a %= 1000000007;
for (; b; b >>= 1) {
if (b & 1) res = res * a % 1000000007;
a = a * a % 1000000007;
}
return res;
}
long long fast_pow(long long a, long long b) {
if (b == 1) return a;
if (b == 0) return 1;
long long x = fast_pow(a, b / 2);
x *= x;
if (b & 1) x *= a;
return x;
}
class DisjointSet {
vector<long long> parent;
vector<long long> rank;
public:
DisjointSet(long long n) {
parent.resize(n + 1, -1);
rank.resize(n + 1, 1);
}
long long Find(long long x) {
if (parent[x] == -1) {
return x;
}
return parent[x] = Find(parent[x]);
}
void Union(long long x, long long y) {
long long s1 = Find(x);
long long s2 = Find(y);
if (s1 == s2) {
return;
}
if (rank[s1] > rank[s2]) {
parent[s2] = s1;
rank[s1] += rank[s2];
} else {
parent[s1] = s2;
rank[s2] += rank[s1];
}
}
};
const long long nax = 27;
vector<set<long long>> adj(nax);
vector<long long> visited(nax);
string ans = "";
void dfs(long long root) {
ans += (char)(root + 'a');
visited[root] = 1;
for (auto i : adj[root]) {
if (!visited[i]) {
dfs(i);
}
}
}
void solve() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
long long tc;
cin >> tc;
while (tc--) {
ans.clear();
adj.clear();
adj.resize(27);
visited.clear();
visited.resize(27);
string s;
cin >> s;
long long n = (long long)s.size();
bool checkcycle = 0;
DisjointSet dSet(27);
for (long long i = 0; i < n - 1; i++) {
long long nodea = s[i] - 'a';
long long nodeb = s[i + 1] - 'a';
long long prevsz = adj[nodea].size();
adj[nodea].insert(nodeb);
adj[nodeb].insert(nodea);
long long newsz = adj[nodea].size();
if (dSet.Find(nodea) != dSet.Find(nodeb)) {
dSet.Union(nodea, nodeb);
} else if ((newsz != prevsz)) {
checkcycle = 1;
}
}
for (long long i = 0; i < 26; i++) {
if (adj[i].size() > 2) {
checkcycle = 1;
break;
}
if (adj[i].size() == 0) {
ans += (char)(i + 'a');
} else if ((adj[i].size() == 1) && !visited[i]) {
dfs(i);
}
}
if (checkcycle) {
cout << "NO" << '\n';
continue;
}
cout << "YES" << '\n';
cout << ans << '\n';
}
}
int32_t main() {
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
int A, B;
char S[102];
bool possible;
inline int myabs(int x) { return (x < 0 ? -x : x); }
int main() {
cin >> A >> B >> S;
if (A == 0 && B == 0) {
cout << "Yes" << '\n';
return 0;
}
int gx = 0, gy = 0;
for (int i = 0; S[i] != 0; ++i)
if (S[i] == 'U')
++gy;
else if (S[i] == 'D')
--gy;
else if (S[i] == 'R')
++gx;
else
--gx;
int px = 0, py = 0;
for (int i = 0; S[i] != 0; ++i) {
if (S[i] == 'U')
++py;
else if (S[i] == 'D')
--py;
else if (S[i] == 'R')
++px;
else
--px;
int difx = A - px, dify = B - py;
if (difx == 0 && dify == 0) possible = true;
int needx, needy;
if (difx != 0 && gx == 0) continue;
if (dify != 0 && gy == 0) continue;
if (difx == 0 && gx == 0)
needx = -1;
else {
if (myabs(difx) % myabs(gx) != 0) continue;
needx = difx / gx;
if (needx < 0) continue;
}
if (dify == 0 && gy == 0)
needy = -1;
else {
if (myabs(dify) % myabs(gy) != 0) continue;
needy = dify / gy;
if (needy < 0) continue;
}
if (needx == -1 || needy == -1 || needx == needy) possible = true;
}
if (possible)
cout << "Yes" << '\n';
else
cout << "No" << '\n';
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string pal;
int num;
cin >> num;
cin.ignore();
cin >> pal;
int cant_total_t = 0;
for (int i = 0; i < pal.length(); i++) {
if (pal[i] == 'T') {
cant_total_t++;
}
}
int min_cant_h = 10000;
for (int i = 0; i < pal.length(); i++) {
int sum_h = 0;
for (int j = 0; j < cant_total_t; j++) {
if (pal[(i + j) % pal.length()] == 'H') {
sum_h++;
}
}
if (sum_h < min_cant_h) {
min_cant_h = sum_h;
}
}
cout << min_cant_h << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int t;
cin >> t;
for (int j = 0; j < (t); ++j) {
int n;
int p;
cin >> n >> p;
int skok = 1;
int potrzebne = 2 * n + p;
while (true) {
for (int i = 0; i < n - skok && potrzebne > 0; i++) {
cout << i + 1 << " " << i + 1 + skok << '\n';
potrzebne--;
}
skok++;
if (potrzebne == 0) {
break;
}
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string s[2005];
map<string, int> m;
int main() {
ios::sync_with_stdio(0);
int n, k, ans = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> s[i];
m[s[i]]++;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
string t;
for (int x = 0; x < k; x++) {
if (s[i][x] == s[j][x])
t += s[i][x];
else if ((s[i][x] == 'S' && s[j][x] == 'E') ||
(s[i][x] == 'E' && s[j][x] == 'S'))
t += "T";
else if ((s[i][x] == 'E' && s[j][x] == 'T') ||
(s[i][x] == 'T' && s[j][x] == 'E'))
t += "S";
else if ((s[i][x] == 'T' && s[j][x] == 'S') ||
(s[i][x] == 'S' && s[j][x] == 'T'))
t += "E";
}
ans += m[t];
}
}
cout << ans / 3 << endl;
return 0;
}
| 2 |
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <stdio.h>
#include <cstring>
#include <queue>
#include <stack>
#include <functional>
#include <math.h>
#include <iomanip>
using namespace std;
#define Would
#define you
const int INF = 999999999;
const int MOD = 1e9 + 7;
const double pi = 3.141592653589793238;
int main() {
string h;
while (getline(cin, h)) {
if (h == "END OF INPUT") { break; }
int mon = 0, cou;
while (mon < h.length()) {
cou = 0;
while (mon < h.length() && h[mon] != ' ') {
++mon;
++cou;
}
cout << cou;
++mon;
}
cout << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MAXX = 2e5 + 10, inf = 1e18 + 10;
long long T, n, a[MAXX], ans, mx;
int jump(int x) {
int l = x;
mx = -inf;
while (((a[x] < 0 && a[l] < 0) || (a[x] > 0 && a[l] > 0)) && l < n)
mx = max(a[l], mx), l++;
return l;
}
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> T;
while (T--) {
cin >> n;
ans = 0;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i = jump(i)) jump(i), ans += mx;
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int T, p[4][2], ans = 0x3f3f3f3f;
const int perm[24][4] = {
{0, 1, 2, 3}, {0, 1, 3, 2}, {0, 2, 1, 3}, {0, 2, 3, 1}, {0, 3, 1, 2},
{0, 3, 2, 1}, {1, 0, 2, 3}, {1, 0, 3, 2}, {1, 2, 0, 3}, {1, 2, 3, 0},
{1, 3, 0, 2}, {1, 3, 2, 0}, {2, 0, 1, 3}, {2, 0, 3, 1}, {2, 1, 0, 3},
{2, 1, 3, 0}, {2, 3, 0, 1}, {2, 3, 1, 0}, {3, 0, 1, 2}, {3, 0, 2, 1},
{3, 1, 0, 2}, {3, 1, 2, 0}, {3, 2, 0, 1}, {3, 2, 1, 0}};
vector<pair<int, int> > ret;
void update(int lx, int ly, int rx, int ry) {
vector<pair<int, int> > d({make_pair(lx, ly), make_pair(lx, ry),
make_pair(rx, ly), make_pair(rx, ry)});
for (int s = 0; s < 24; s++) {
bool flag = 0;
int vl = 0;
for (int i = 0; i < 4; i++) {
if (p[i][0] != d[perm[s][i]].first && p[i][1] != d[perm[s][i]].second) {
flag = 1;
break;
}
vl = max(vl, abs(p[i][0] - d[perm[s][i]].first) +
abs(p[i][1] - d[perm[s][i]].second));
}
if (!flag && vl < ans) {
ans = vl;
ret.clear();
for (int i = 0; i < 4; i++) ret.push_back(d[perm[s][i]]);
}
}
}
void solve() {
ret.clear();
ans = 0x3f3f3f3f;
for (int i = 0; i < 4; i++)
for (int j = 0; j < 2; j++) scanf("%d", &p[i][j]);
for (int S = 0; S < 16; S++) {
vector<int> X, Y;
for (int i = 0; i < 4; i++) {
if ((S >> i) & 1)
X.push_back(p[i][0]);
else
Y.push_back(p[i][1]);
}
sort(X.begin(), X.end());
X.erase(unique(X.begin(), X.end()), X.end());
sort(Y.begin(), Y.end());
Y.erase(unique(Y.begin(), Y.end()), Y.end());
if (X.size() == 2) {
if (Y.size() == 2) {
if (X[1] - X[0] == Y[1] - Y[0]) update(X[0], Y[0], X[1], Y[1]);
} else if (Y.size() == 1) {
int d = X[1] - X[0];
update(X[0], Y[0], X[1], Y[0] + d);
update(X[0], Y[0] - d, X[1], Y[0]);
} else if (Y.size() == 0) {
int d = X[1] - X[0];
vector<int> cur;
for (int s = 0; s < 24; s++) {
cur.clear();
for (int i = 0; i < 4; i++) {
if (i & 1)
cur.push_back(p[perm[s][i]][1] - d);
else
cur.push_back(p[perm[s][i]][1]);
}
sort(cur.begin(), cur.end());
int mid = (cur[0] + cur[3]) / 2;
update(X[0], mid, X[1], mid + d);
}
}
} else if (Y.size() == 2) {
if (X.size() == 1) {
int d = Y[1] - Y[0];
update(X[0], Y[0], X[0] + d, Y[1]);
update(X[0] - d, Y[0], X[0], Y[1]);
} else if (X.size() == 0) {
int d = Y[1] - Y[0];
vector<int> cur;
for (int s = 0; s < 24; s++) {
cur.clear();
for (int i = 0; i < 4; i++) {
if (i & 1)
cur.push_back(p[perm[s][i]][0] - d);
else
cur.push_back(p[perm[s][i]][0]);
}
sort(cur.begin(), cur.end());
int mid = (cur[0] + cur[3]) / 2;
update(mid, Y[0], mid + d, Y[1]);
}
}
}
}
if (ans == 0x3f3f3f3f)
puts("-1");
else {
printf("%d\n", ans);
for (auto &x : ret) printf("%d %d\n", x.first, x.second);
}
}
int main() {
scanf("%d", &T);
while (T--) solve();
return 0;
}
| 4 |
#include<iostream>
using namespace std;
int main(){
int dif,check=0;
int array[3][3];
for(int i=0;i<3;i++){
for(int j=0;j<3;j++)cin >>array[i][j];
if(i>=1){
dif=array[i][0]-array[0][0];
for(int k=0;k<3;k++){
if(dif!=array[i][k]-array[0][k])check=1;
}
}
}
if(check==1)cout<<"No"<<endl;
else cout<<"Yes"<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long cnt[3005][3005];
vector<int> G[3005], G_inv[3005];
int main() {
ios::sync_with_stdio(false), cin.tie(nullptr);
int N, M;
cin >> N >> M;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b, a--, b--;
G[a].push_back(b);
G_inv[b].push_back(a);
}
for (int i = 0; i < N; i++) {
for (auto u : G[i]) {
for (auto v : G[u]) {
if (i != v) cnt[i][v]++;
}
}
}
long long ans = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
if (i != j) ans += cnt[i][j] * (cnt[i][j] - 1) / 2;
}
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int i, L;
char s[100005];
int main() {
scanf("%s", &s);
L = strlen(s);
for (i = 0; i < L; i++) printf("%c", s[i]);
for (i = L - 1; i >= 0; i--) printf("%c", s[i]);
}
| 1 |
#include<iostream>
#include<cstring>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
string g[12];
bool vis[12][12];
bool clr[12][12];
const int dy[] = {-1,0,1,0}, dx[] = {0,1,0,-1};
int dfs(int y,int x,int col){
if(g[y][x] != col)return 0;
if(vis[y][x])return 0;
vis[y][x] = true;
int res = 1;
rep(i,4){
int ny = y+dy[i], nx = x+dx[i];
if(ny<0 || nx<0 || ny>=12 || nx>=6)continue;
res += dfs(ny,nx,col);
}
return res;
}
int chain(void){
memset(clr,0,sizeof(clr));
rep(i,12){
rep(j,6){
if(g[i][j] != '.' && g[i][j] != 'O' && !clr[i][j]){
memset(vis,0,sizeof(vis));
if(dfs(i,j,g[i][j])>=4){
rep(ii,12)rep(jj,6)clr[ii][jj] |= vis[ii][jj];
}
}
}
}
rep(i,12){
rep(j,6){
if(g[i][j] == 'O'){
rep(k,4){
int ny = i+dy[k], nx = j+dx[k];
if(ny<0 || nx<0 || ny>=12 || nx>=6)continue;
if(g[ny][nx] != 'O' && clr[ny][nx]){
clr[i][j] = true;
}
}
}
}
}
int num = 0;
rep(i,12){
rep(j,6){
if(clr[i][j])g[i][j] = '.', num++;
}
}
if(num==0)return 0;
rep(i,6){
for(int j=11;j>=0;j--){
if(g[j][i] != '.'){
for(int k=j+1;k<12;k++){
if(g[k][i] == '.')swap(g[k][i],g[k-1][i]);
else break;
}
}
}
}
return chain()+1;
}
int main(){
int n;
cin >> n;
while(n--){
rep(i,12)cin >> g[i];
cout << chain() << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
vector<int> v;
cin >> n;
if (n == 1) {
cout << "+";
return 0;
}
for (int i(0), _n(n); i < _n; ++i) {
int t1;
cin >> t1;
v.push_back(t1);
}
int cur = 0;
reverse(v.begin(), v.end());
string s = "";
for (int i(0), _n(n); i < _n; ++i) {
if (cur < 0) {
cur += v[i];
s += "+";
} else {
cur = cur - v[i];
s += "-";
}
}
reverse(s.begin(), s.end());
if (cur < 0) {
for (long i = 0; i < ((int)(s.size())); i++) {
if (s[i] == '+')
cout << "-";
else
cout << "+";
}
} else {
cout << s;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a,b,c,d;
cin>>a>>b>>c>>d;
int x=-max(a,c)+min(b,d);
if (x>=0)
cout<<x;
else
cout<<0;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, t;
cin >> n >> k >> t;
if (t <= k) {
cout << t;
} else {
if (t <= n) {
cout << k;
} else if (t > n && t <= n + k) {
cout << k - (t % n);
} else {
cout << "0";
}
}
}
| 1 |
#include <iostream>
int w, h, dp[101][101][16];
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define REP(i,j) FOR(i,0,j)
// 00: down
// 01: right
// 11: 初期状態用
int rec(int x, int y, int r){
if(x <= h && y <= w);
else{
return 0;
}
if(dp[x][y][r] != -1){
return dp[x][y][r];
}
if(x == h && y == w){
return 1;
}
int res = 0, first = r >> 2, second = r & 0x3;
//down
if(first == second || first != 0x0){
res = (res + rec(x, y+1, second << 2)) % 100000;
}
//right
if(first == second || first != 0x1){
res = (res + rec(x+1, y, ((second << 2) | 0x1))) % 100000;
}
return dp[x][y][r] = res;
}
int main(){
while(std::cin >> w >> h, w){
FOR(i, 1, h+1){
FOR(j, 1, w+1){
REP(k, 16){
dp[i][j][k] = -1;
}
}
}
std::cout << rec(1, 1, 0xf) << std::endl;
}
}
| 0 |
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
int main() {
int n, C;
int d[30][30], pre[3][30], c[505][505];
cin >> n >> C;
rep(i, C) rep(j, C) cin >> d[i][j];
rep(i, n) rep(j, n) cin >> c[i][j], c[i][j]--;
rep(col, C) rep(i, n) rep(j, n) pre[(i + j) % 3][col] += d[c[i][j]][col];
int ans = 1 << 30;
rep(c0, C) rep(c1, C) rep(c2, C) if (!(c0 == c1 || c0 == c2 || c1 == c2))
ans = min(ans, pre[0][c0] + pre[1][c1] + pre[2][c2]);
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int inf = 1e9, N = 25, M = 4e5 + 5, S = 4e6 + 5;
struct point {
int w, sum;
vector<int> t;
} a[N];
inline int read() {
int F = 1, ANS = 0;
char C = getchar();
while (C < '0' || C > '9') {
if (C == '-') F = -1;
C = getchar();
}
while (C >= '0' && C <= '9') {
ANS = ANS * 10 + C - '0';
C = getchar();
}
return F * ANS;
}
char s[M];
int dp[S], ans;
inline char readchar() {
char C = getchar();
while (C < 33 || C > 126) C = getchar();
return C;
}
inline int raed() { return read(); }
int main() {
n = read();
for (int i = 0; i < n; i++) {
scanf("%s", s + 1);
int len = strlen(s + 1);
int tot = 0, res = 0;
for (int j = 0; j <= len; j++) a[i].t.push_back(0);
for (int j = 1; j <= len; j++) {
if (s[j] == '(')
tot++;
else
tot--;
if (tot <= res) {
res = tot;
a[i].t[-tot]++;
}
}
a[i].w = -res;
a[i].sum = tot;
}
for (int i = 1; i <= (1 << n) - 1; i++) dp[i] = -inf;
dp[S] = 0;
for (int i = 1; i <= (1 << n) - 1; i++) {
int sum = 0;
for (int j = 0; j < n; j++) {
if (((1 << j) & i) == 0) continue;
sum += a[j].sum;
}
for (int j = 0; j < n; j++) {
if (((1 << j) & i) == 0) continue;
sum -= a[j].sum;
int k = ((1 << j) ^ i);
if (sum < 0) {
sum += a[j].sum;
continue;
}
if (dp[k] < 0) {
sum += a[j].sum;
continue;
}
if (sum > a[j].w) {
dp[i] = max(dp[i], dp[k]);
sum += a[j].sum;
continue;
}
if (sum == a[j].w) {
dp[i] = max(dp[i], dp[k] + a[j].t[sum]);
sum += a[j].sum;
continue;
}
ans = max(ans, dp[k] + a[j].t[sum]);
sum += a[j].sum;
}
ans = max(ans, dp[i]);
}
cout << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string a, b, c, d;
long long n;
cin >> a >> b;
cin >> n;
cout << a << " " << b << "\n";
while (n) {
n--;
cin >> c >> d;
if (c != a) {
cout << a << " " << d << "\n";
b = d;
} else {
cout << d << " " << b << "\n";
a = d;
}
}
return 0;
}
| 1 |
#include<cstdio>
#include<algorithm>
#define MN 210000
using namespace std;
int n,m,a,b;
long long c[MN],x[MN],mmh=1e18;
int main(){
scanf("%d%d",&n,&m);scanf("%d",&a);
for (int i=2;i<=n;i++){
scanf("%d",&b);
if (a<b){
c[1]+=b-a;
c[a+1]-=b-a;
c[b+1]+=b-a;
c[a+1]+=b+1;c[b+1]-=b+1;x[a+1]--;x[b+1]++;
}else{
c[b+1]+=m-a+b;c[a+1]-=m-a+b;
c[a+1]+=b+1+m;x[a+1]--;
c[1]+=b+1;c[b+1]-=b+1;x[1]--;x[b+1]++;
}
a=b;
}
for (int i=1;i<=m;i++) if (c[i]+=c[i-1],x[i]+=x[i-1],c[i]+x[i]*i<mmh) mmh=c[i]+x[i]*i;
printf("%lld\n",mmh);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3 * 1e5 + 10;
vector<int> IndSet, Match;
bool vis[maxn];
int main() {
int t;
scanf("%d", &t);
while (t--) {
memset(vis, 0, sizeof(vis));
IndSet.clear();
Match.clear();
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int u, v;
scanf("%d%d", &u, &v);
if (!vis[u] and !vis[v]) {
vis[u] = vis[v] = 1;
Match.push_back(i);
}
}
int cnt = 0;
for (int i = 1; i <= 3 * n; i++)
if (!vis[i]) IndSet.push_back(i);
if (IndSet.size() >= n) {
printf("IndSet\n");
for (int i = 0; i < n; i++) printf("%d ", IndSet[i]);
printf("\n");
} else {
printf("Matching\n");
for (int i = 0; i < n; i++) printf("%d ", Match[i]);
printf("\n");
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string n,ans="No";cin>>n;
if(n[0]==n[1]&&n[1]==n[2])ans="Yes";
if(n[1]==n[2]&&n[2]==n[3])ans="Yes";
cout <<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<char> line;
int len, jump, g, t;
cin >> len >> jump;
line.resize(len);
int i;
for (i = 0; i < len; ++i) {
cin >> line[i];
if (line[i] == 'G') g = i;
if (line[i] == 'T') t = i;
}
if (g > t) jump *= -1;
for (i = g; g > t ? i > t : i < t; i += jump) {
if (line[i] == '#') {
cout << "NO" << endl;
return 0;
}
}
if (i == t) {
cout << "YES" << endl;
return 0;
}
cout << "NO" << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
int n, m, k, nextInd, vRow[10007], vCol[10007], dis[50 * 10007];
map<pair<int, int>, int> vertex;
vector<pair<int, int> > g[50 * 10007];
bitset<50 * 10007> vis;
bitset<10007> lit[10007];
auto cmp = [](pair<int, int> &a, pair<int, int> &b) {
return (a.second > b.second);
};
auto pq =
priority_queue<pair<int, int>, vector<pair<int, int> >, decltype(cmp)>(cmp);
void dijkstra(int src) {
for (int i = 1; i <= (nextInd); ++i) dis[i] = 1000000007LL;
dis[src] = 0;
pq.emplace(src, 0);
while (!pq.empty()) {
pair<int, int> v = pq.top();
pq.pop();
if (vis[v.first]) continue;
vis[v.first] = 1;
for (auto u : g[v.first]) {
if ((!vis[u.first]) && (dis[u.first] > v.second + u.second)) {
dis[u.first] = v.second + u.second;
pq.emplace(u.first, dis[u.first]);
}
}
}
}
void buildGraph() {
for (int i = 1; i <= (n); ++i)
for (int j = 1; j <= (m); ++j) {
int v = 0;
if (lit[i][j]) v = vertex[make_pair(i, j)];
for (int dir = 0; dir < 4; ++dir) {
int ni = i + dx[dir], nj = j + dy[dir];
if (ni < 1 || ni > n || nj < 1 || nj > m) continue;
int u = 0;
if (lit[ni][nj]) u = vertex[make_pair(ni, nj)];
if (u) g[v].emplace_back(u, 0);
}
if (v) {
for (int q = -1; q <= 1; ++q) {
if (i + q >= 1 && i + q <= n)
g[v].emplace_back(vRow[i + q], 1),
g[vRow[i + q]].emplace_back(v, 1);
if (j + q >= 1 && j + q <= m)
g[v].emplace_back(vCol[j + q], 1),
g[vCol[j + q]].emplace_back(v, 1);
}
}
}
}
void solve() {
cin >> n >> m >> k;
for (int i = 1; i <= (k); ++i) {
int x, y;
cin >> x >> y;
lit[x][y] = 1;
vertex[make_pair(x, y)] = i;
nextInd = i;
}
for (int i = 1; i <= (n); ++i) vRow[i] = ++nextInd;
for (int j = 1; j <= (m); ++j) vCol[j] = ++nextInd;
buildGraph();
dijkstra(vertex[make_pair(1, 1)]);
int rst;
if (lit[n][m])
rst = dis[vertex[make_pair(n, m)]];
else
rst = min(dis[vRow[n]], dis[vCol[m]]);
if (rst >= 1000000007LL)
cout << "-1";
else
cout << (rst + 1) / 2;
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int nmax = 20;
const int inf = 1e9 + 7;
const int modulo = 1e9 + 7;
const double linf = 1e36;
int main() {
long long n;
scanf("%I64d", &n);
long long ret = 3 * n * (n + 1) + 1;
printf("%I64d\n", ret);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double a[100];
int main() {
int n;
double b, sum, m = 0, one;
cin >> n >> b;
sum = b;
for (int i = 0; i < n; i++) {
cin >> a[i];
sum += a[i];
m = max(m, a[i]);
}
one = sum / n;
if (m > one) {
cout << -1;
return 0;
}
for (int i = 0; i < n; i++) printf("%0.9lf\n", -a[i] + one);
}
| 1 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<queue>
using namespace std;
#define MAXN 100000
#define LL long long
int n,m;
vector<int> G[MAXN+5];
int du[MAXN+5],fa[MAXN+5];
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<n+m;i++)
{
int u,v;
scanf("%d%d",&u,&v);
G[u].push_back(v);
du[v]++;
}
queue<int> Q;
for(int i=1;i<=n;i++)if(!du[i])Q.push(i);
while(!Q.empty())
{
int x=Q.front();
Q.pop();
for(int i=0;i<G[x].size();i++)
{
int nxt=G[x][i];
du[nxt]--;
if(!du[nxt]){fa[nxt]=x;Q.push(nxt);}
}
}
for(int i=1;i<=n;i++)printf("%d\n",fa[i]);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, hc, hp;
cin >> n >> hp;
t = hp + 1;
n--;
while (n--) {
cin >> hc;
t += abs(hp - hc) + 2;
hp = hc;
}
cout << t;
}
| 2 |
// AOJ 0189 (http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0189)
#include<cstdio>
#include<algorithm>
#include<numeric>
#include<limits>
#define rep(i,a) for(int i=0;i<(a);++i)
typedef std::pair<int, int> P;
const int MAX_N = 10, INF = std::numeric_limits<int>::max()>>4;
int d[MAX_N][MAX_N];
int main()
{
int n;
while( scanf( "%d", &n ), n )
{
rep( i, MAX_N ) rep( j, MAX_N )
d[i][j] = i==j?0:INF;
rep( i, n )
{
int a, b, c;
scanf( "%d%d%d", &a, &b, &c );
d[a][b] = d[b][a] = c;
}
rep( k, MAX_N ) rep( i, MAX_N ) rep( j, MAX_N )
d[i][j] = std::min( d[i][j], d[i][k]+d[k][j] );
P ans( INF, INF );
rep( i, MAX_N )
{
int s = 0;
rep( j, MAX_N ) if( d[i][j] != INF )
s += d[i][j];
if( s )
ans = std::min( ans, P( s, i ) );
}
printf( "%d %d\n", ans.second, ans.first );
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct S {
long long s, a, b;
S(long long s, long long a, long long b) : s(s), a(a), b(b) {}
};
vector<S> v1, v2;
bool cmp1(S a, S b) { return abs(a.a - a.b) < abs(b.a - b.b); }
int main() {
long long N, S, i, s, a, b;
cin >> N >> S;
long long ans = 0;
long long A = 0, B = 0;
for (i = 1; i <= N; i++) {
cin >> s >> a >> b;
if (a > b) {
ans += a * s;
A += s;
v1.push_back({s, a, b});
} else {
ans += b * s;
B += s;
v2.push_back({s, a, b});
}
}
sort(v1.begin(), v1.end(), cmp1);
sort(v2.begin(), v2.end(), cmp1);
long long c = A % S, cc = B % S;
long long ans1 = ans, ans2 = ans;
if (A % S == 0 || B % S == 0 || c + cc > S) {
cout << ans << endl;
return 0;
}
for (auto it : v1) {
if (it.s >= c) {
ans1 -= c * (it.a - it.b);
break;
}
ans1 -= it.s * (it.a - it.b);
c -= it.s;
}
for (auto it : v2) {
if (it.s >= cc) {
ans2 -= cc * (it.b - it.a);
break;
}
ans2 -= it.s * (it.b - it.a);
cc -= it.s;
}
cout << max(ans1, ans2) << endl;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
const int INF = 1 << 28;
int main()
{
int N, T[50];
static int dp[2][2501][2501];
cin >> N;
for(int i = 0; i < N; i++) {
cin >> T[i];
}
fill_n(**dp, 2 * 2501 * 2501, INF);
dp[1][0][0] = 0;
for(int i = 0; i < N; i++) {
for(int j = 2500; j >= 0; j--) {
for(int k = 2500; k >= 0; k--) {
if(j >= T[i]) dp[i & 1][j][k] = min(dp[i & 1][j][k], dp[(i + 1) & 1][j - T[i]][k]);
if(k >= T[i]) dp[i & 1][j][k] = min(dp[i & 1][j][k], dp[(i + 1) & 1][j][k - T[i]]);
dp[i & 1][j][k] = min(dp[i & 1][j][k], dp[(i + 1) & 1][j][k] + T[i]);
}
}
fill_n(*dp[(i + 1) & 1], 2501 * 2501, INF);
}
int ret = INF;
for(int i = 0; i <= 2500; i++) {
for(int j = 0; j <= 2500; j++) {
ret = min(ret, max(i, max(j, dp[(N + 1) & 1][i][j])));
}
}
cout << ret << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
using vi = vector<int>;
using pii = pair<int, int>;
using vii = vector<pii>;
using ll = long long;
int solve();
int main(int argc, char* argv[]) {
::std::ios::sync_with_stdio(false);
::std::cin.tie(0);
::std::cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
constexpr int N = 500005;
int n, u, v, h[N], g[N], parent[N], ans[N * 2], val[N];
int mx = 0, ed = 0, child[N];
bool check[N];
pii f[N][2];
vi adj[N], eve[N];
void dfs(int u, int p) {
h[u] = h[p] + 1;
parent[u] = p;
f[u][0] = make_pair(0, u);
f[u][1] = make_pair(-1, 0);
for (int v : adj[u]) {
if (v != p) {
dfs(v, u);
auto temp = f[v][0];
temp.first++;
temp.second = v;
for (int i = 0; i < 2; ++i) {
if (temp > f[u][i]) {
swap(temp, f[u][i]);
}
}
}
}
}
void dfs_v2(int u, int p) {
eve[0].push_back(u);
if (p != 0) {
g[u] = max(g[p], f[p][0].second == u ? f[p][1].first : f[p][0].first) + 1;
eve[g[u]].push_back(u);
}
for (int v : adj[u]) {
if (v != p) {
eve[f[v][0].first + 1].push_back(u);
dfs_v2(v, u);
}
}
}
int solve() {
cin >> n;
for (int i = 1; i < n; i++) {
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1, 0);
dfs_v2(1, 0);
for (int i = n; i >= 0; i--) {
int ev = i * 2, od = i * 2 + 1;
ans[od] = mx;
for (int v : eve[i]) {
if (!check[v]) {
check[v] = true;
ans[od] = ::std::max(ans[od], val[v] + 1);
}
}
for (int v : eve[i]) {
check[v] = false;
mx = max(mx, ++val[v]);
ed = std::max(ed, val[v] + child[v] - 2);
if (v != 1) {
const int pv = parent[v];
child[pv] = max(child[pv], val[v]);
ed = std::max(ed, val[pv] + child[pv] - 2);
}
}
ans[ev] = max(mx, ed);
}
for (int i = 1; i <= n; i++) {
cout << ::std::max(ans[i], 1) << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[100];
int main() {
int t;
cin >> t;
while (t--) {
memset(a, 0, sizeof(a));
string s, s1;
cin >> s >> s1;
sort(s.begin(), s.end());
for (int i = 0; i < s.length(); i++) {
a[s[i] - 'a']++;
}
if (!(s1 == "abc" && a[0] && a[1] && a[2])) {
cout << s << endl;
continue;
}
int b, e;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'b') {
b = i;
break;
}
}
for (int i = s.length() - 1; i >= 0; i--) {
if (s[i] == 'c') {
e = i + 1;
break;
}
}
reverse(s.begin() + b, s.begin() + e);
cout << s << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
sort(a, a + n);
int m = 0;
for (int i = n - 1; i >= 0; i--) {
int k = min(a[i], n - i);
m = max(m, k);
}
cout << m << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
string s;
cin >> s;
long long int ob = -1, cb = -1;
long long int i, n = s.length();
for (i = 0; i < n; i++) {
if (s[i] == '[') {
ob = i;
break;
}
}
for (i = n - 1; i >= 0; i--) {
if (s[i] == ']') {
cb = i;
break;
}
}
if (ob == -1 || cb == -1) {
cout << "-1" << '\n';
return;
}
long long int cl = -1, cr = -1;
for (i = ob; i < cb; i++) {
if (s[i] == ':') {
cl = i;
break;
}
}
if (cl == -1) {
cout << "-1" << '\n';
return;
}
for (i = cb; i > cl; i--) {
if (s[i] == ':') {
cr = i;
break;
}
}
if (cr == -1) {
cout << "-1" << '\n';
return;
}
long long int v = 0;
for (i = cl; i < cr; i++) {
if (s[i] == '|') v++;
}
cout << v + 4 << '\n';
return;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int t = 1;
while (t--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long dp[110][110][110], pi[110];
vector<long long> trace[110][110][110];
bool valid[110][110][110];
string virus;
void kmpPreprocess() {
long long i = 0, j = -1;
pi[0] = -1;
while (i < virus.size()) {
while (j >= 0 && virus[i] != virus[j]) {
j = pi[j];
}
i++, j++;
pi[i] = j;
}
}
long long nextlen(long long pre, char next) {
long long j = pre;
while (j > 0 && virus[j] != next) {
j = pi[j];
}
if (virus[j] == next) {
return j + 1;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
string s1, s2;
cin >> s1 >> s2 >> virus;
s1 += '#';
s2 += '$';
kmpPreprocess();
for (int i = 0; i <= s1.size(); i++) {
valid[i][0][0] = 1;
}
for (int i = 0; i <= s2.size(); i++) {
valid[0][i][0] = 1;
}
for (int i = 0; i < s1.size(); i++) {
for (int j = 0; j < s2.size(); j++) {
for (int k = 0; k < virus.size(); k++) {
if (!valid[i][j][k]) continue;
if (s1[i] == s2[j]) {
if (s1[i] == virus[k]) {
valid[i + 1][j + 1][k + 1] = 1;
if (dp[i + 1][j + 1][k + 1] <= dp[i][j][k] + 1) {
dp[i + 1][j + 1][k + 1] = dp[i][j][k] + 1;
trace[i + 1][j + 1][k + 1] = {i, j, k, 1};
}
} else {
long long tmp = nextlen(k, s1[i]);
valid[i + 1][j + 1][tmp] = 1;
if (dp[i + 1][j + 1][tmp] <= dp[i][j][k] + 1) {
dp[i + 1][j + 1][tmp] = dp[i][j][k] + 1;
trace[i + 1][j + 1][tmp] = {i, j, k, 1};
}
}
}
valid[i + 1][j][k] = 1;
if (dp[i + 1][j][k] <= dp[i][j][k]) {
dp[i + 1][j][k] = dp[i][j][k];
trace[i + 1][j][k] = {i, j, k, 0};
}
valid[i][j + 1][k] = 1;
if (dp[i][j + 1][k] <= dp[i][j][k]) {
dp[i][j + 1][k] = dp[i][j][k];
trace[i][j + 1][k] = {i, j, k, 0};
}
valid[i + 1][j + 1][k] = 1;
if (dp[i + 1][j + 1][k] <= dp[i][j][k]) {
dp[i + 1][j + 1][k] = dp[i][j][k];
trace[i + 1][j + 1][k] = {i, j, k, 0};
}
}
}
}
long long mx = 0, nk = -1, ni = s1.size(), nj = s2.size();
for (int i = 0; i < virus.size(); i++) {
if (mx < dp[ni][nj][i]) {
mx = dp[ni][nj][i];
nk = i;
}
}
string ans;
if (mx == 0) {
cout << mx << '\n';
return 0;
}
while (ans.size() != mx) {
vector<long long> tmp = trace[ni][nj][nk];
ni = tmp[0], nj = tmp[1], nk = tmp[2];
if (tmp[3]) {
ans += s1[ni];
}
}
reverse(ans.begin(), ans.end());
cout << ans << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int mod = 1000000007;
long long int powmod(long long int a, long long int b) {
long long int res = 1;
a %= mod;
assert(b >= 0);
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) {
int n, d, flag = 1, m, ans = 0, k = 0, x, y, t;
cin >> n >> k >> t;
m = (t * n * k) / 100;
for (int i = (0); i < (n); i++) {
if (m >= k) {
cout << k << " ";
m -= k;
} else {
cout << m << " ";
m = 0;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char getc() {
char c = getchar();
while ((c < 'A' || c > 'Z') && (c < 'a' || c > 'z') && (c < '0' || c > '9'))
c = getchar();
return c;
}
int gcd(int n, int m) { return m == 0 ? n : gcd(m, n % m); }
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
return x * f;
}
int n, m, k, a[100010], b[100010], stk[100010], top;
long long ans;
signed main() {
n = read(), m = read(), k = read();
for (int i = 1; i <= n; i++) a[i] = read();
int u = 0;
int cnt = 0;
for (int i = 1; i <= n; i++) {
if (!top)
stk[++top] = a[i], cnt++;
else {
if (stk[top] == a[i])
cnt++;
else
cnt = 1;
stk[++top] = a[i];
}
if (cnt == m) {
top -= m;
ans += 1ll * k * m;
cnt = 0;
for (int j = top; j >= 0; j--)
if (stk[j] != stk[top]) {
cnt = top - j;
break;
}
}
}
u = top;
memcpy(b, stk, sizeof(b));
int nnn = n;
n = u;
memcpy(a, b, sizeof(a));
bool flag = 0;
for (int i = 2; i <= n; i++)
if (a[i] != a[1]) {
flag = 1;
break;
}
if (!flag) {
cout << 1ll * nnn * k % m;
return 0;
}
int l = 1, r = n;
while (l <= r) {
int x = l, y = r;
if (a[l] != a[r]) break;
while (a[x + 1] == a[l]) x++;
while (a[y - 1] == a[r]) y--;
if (x >= y) {
ans += (1ll * k * (r - l + 1) / m) * m;
if (1ll * k * (r - l + 1) % m == 0) ans += n - (r - l + 1);
break;
}
if (x - l + 1 + r - y + 1 >= m) {
ans += 1ll * (k - 1) * m;
if (x - l + 1 + r - y + 1 > m)
break;
else if (m == (x - l + 1 + r - y + 1))
l = x + 1, r = y - 1;
else
break;
} else
break;
}
ans = 1ll * nnn * k - ans;
cout << ans;
return 0;
}
| 2 |
#include <cstdio>
#include <cmath>
#include <complex>
using namespace std;
typedef complex<double> P;
void koch(int n, P p1, P p2)
{
if (n == 0)
return;
P s = p1 + (p2 - p1) / 3.0;
P t = p1 + (p2 - p1) / 3.0 * 2.0;
P u = s + (t - s) * polar(1.0, M_PI * 1 / 3);
koch(n - 1, p1, s);
printf("%.8f %.8f\n", s.real(), s.imag());
koch(n - 1, s, u);
printf("%.8f %.8f\n", u.real(), u.imag());
koch(n - 1, u, t);
printf("%.8f %.8f\n", t.real(), t.imag());
koch(n - 1, t, p2);
}
int main()
{
int n;
scanf("%d", &n);
printf("%.8f %.8f\n", 0., 0.);
koch(n, P(0, 0), P(100, 0));
printf("%.8f %.8f\n", 100., 0.);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5+20;
int n,a[N],c[N],d[N];
long long s1[N],s2[N],f[N];
int main(void)
{
scanf("%d",&n);
for (int i=1;i<=n;i++)
scanf("%d",&a[i]) , c[a[i]]++;
for (int i=1;i<=n;i++) d[c[i]]++;
for (int i=1;i<=n;i++)
s1[i] = s1[i-1] + 1LL * i * d[i],
s2[i] = s2[i-1] + d[i];
for (int i=1;i<=n;i++) f[i] = ( s1[i] + ( s2[n] - s2[i] ) * i ) / i;
for (int k=1;k<=n;k++)
{
int l = 1 , r = n;
while ( l + 1 < r )
{
int mid = l + r >> 1;
k <= f[mid] ? l = mid : r = mid;
}
if ( k <= f[r] ) printf("%d\n",r);
else if ( k <= f[l] ) printf("%d\n",l);
else puts("0");
}
return 0;
}
| 0 |
#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;
int main(){
int n,m;
long long a[60],b[60],c[60],d[60];
cin >> n >> m;
for(int i=0; i<n; i++){
cin >> a[i] >> b[i];
}
for(int i=0; i<m; i++){
cin >> c[i] >> d[i];
}
for(int i=0; i<n; i++){
int minnum=1e9,mini=51;
for(int k=0; k<m; k++){
int tmp =abs(a[i]-c[k])+abs(b[i]-d[k]);
if(tmp<minnum){
minnum=tmp;
mini=k;
}
}
cout << mini+1 << endl;
}
}
| 0 |
#include<iostream>
using namespace std;
int cntDivisor( int a )
{
int cnt = 0;
for( int i = 1; i <= a; i++ )
if( a % i == 0 )
cnt++;
return cnt;
}
int main()
{
int n;
cin >> n;
for( int i = n; i <= 1024; i++ )
{
if( n == cntDivisor( i ) )
{
cout << i << endl;
break;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
string p[n], s, ans;
for (int i = 0; i < n; i++) cin >> p[i];
cin >> s;
ans = s;
char ch;
cin >> ch;
if (ch < 'a') ch += char(32);
for (int i = 0; i < s.length(); i++) {
for (int j = 0; j < n; j++) {
if (i + p[j].length() <= s.length()) {
bool check = true;
for (int k = i; k < i + p[j].length(); k++) {
if (s[k] != p[j][k - i] && char(s[k] - 32) != p[j][k - i] &&
s[k] != char(p[j][k - i] - 32)) {
check = false;
}
}
if (check) {
for (int k = 0; k < p[j].length(); k++) {
if (s[i + k] == ch) {
ans[i + k] = 'a' + char((int)ch == 'a');
continue;
} else if (s[i + k] + char(32) == ch) {
ans[i + k] = 'A' + char((int)ch == 'a');
continue;
}
if (s[i + k] >= 'a')
ans[i + k] = ch;
else
ans[i + k] = ch - char(32);
}
}
}
}
}
cout << ans << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int n = 100002;
long long Vs[n], days[n], tooMuch[n];
int N;
int main() {
cin >> N;
for (int i = 0; i < N; ++i) cin >> Vs[i];
long long Tsum = 0;
for (int i = 0; i < N; ++i) {
cin >> days[i];
Vs[i] += Tsum;
tooMuch[i] = days[i] * (N - i - 1);
Tsum += days[i];
}
sort(Vs, Vs + N);
int i = 0;
long long res = 0, lastTsum = 0;
Tsum = 0;
for (int d = 0; d < N; ++d) {
lastTsum = Tsum;
Tsum += days[d];
res = 0;
while (i < N && Vs[i] < Tsum) {
res += Vs[i] - lastTsum;
i++;
}
res += (N - i) * days[d];
res -= tooMuch[d];
cout << res;
if (d != N - 1)
cout << " ";
else
cout << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
int larger(int m, int n) {
if (m > n)
return m;
else
return n;
}
int main() {
int a, b, c, c1, c2, c3, c4, c5, s1, s2, s3, s4;
scanf("%d%d%d", &a, &b, &c);
c1 = a + (b * c);
c2 = a * (b + c);
c3 = a * b * c;
c4 = (a + b) * c;
c5 = a + b + c;
s1 = larger(c1, c2);
s2 = larger(s1, c3);
s3 = larger(s2, c4);
s4 = larger(s3, c5);
printf("%d", s4);
return 0;
}
| 1 |
#include <bits/stdc++.h>
long long num[1000000], sum[4][1000000], f[4][1000000];
char str[1000000];
long long prime[1000], ex[1000];
long long NN;
void bf(long long id, long long pre) {
long long a, b, i;
if (id > *prime) {
if (pre > 0) {
b = NN / pre;
a = ((b - 1) * b) >> 1;
a = a * pre + b;
num[++(*num)] = a;
}
} else {
bf(id + 1, pre);
a = 1;
for (i = 1; i <= ex[id]; i++) {
a = a * prime[id];
b = pre * a;
bf(id + 1, b);
}
}
}
int main() {
long long i, j, k, a, b, c, ans1, ans2, ans3, n;
scanf("%lld", &n);
*prime = 0;
*num = 0;
NN = n;
for (i = 2; i <= 100000; i++) {
a = 0;
while (n % i == 0) {
n = n / i;
a += 1;
}
if (a > 0) {
prime[++(*prime)] = i;
ex[*prime] = a;
}
}
if (n > 1) {
prime[++(*prime)] = n;
ex[*prime] = 1;
}
bf(1, 1);
std::sort(num + 1, num + *num + 1);
num[*num + 1] = (long long)0xFFFFFFFFFFFF;
for (i = 1; i <= *num; i++) {
if (num[i] != num[i + 1]) {
printf("%lld ", num[i]);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename F, typename S>
ostream &operator<<(ostream &os, const pair<F, S> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
typename vector<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "}";
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &v) {
os << "[";
typename set<T>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << *it;
}
return os << "]";
}
template <typename F, typename S>
ostream &operator<<(ostream &os, const map<F, S> &v) {
os << "[";
typename map<F, S>::const_iterator it;
for (it = v.begin(); it != v.end(); it++) {
if (it != v.begin()) os << ", ";
os << it->first << " = " << it->second;
}
return os << "]";
}
bool check(vector<int64_t> &a, vector<int64_t> &b) {
for (int64_t i = 0; i < 3; i++) {
if (a[i] < b[i])
continue;
else
return false;
}
return true;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
int64_t t = 1;
while (t--) {
int64_t n;
cin >> n;
vector<int64_t> a(n);
map<int64_t, int64_t> mp;
for (int64_t i = 0; i < n; i++) {
cin >> a[i];
mp[a[i]]++;
}
int64_t ans = 0;
for (int64_t i = 1; i <= n; i++) {
if (mp.find(i) == mp.end()) ans++;
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int w, h;
while(cin >> w >> h, w || h){
int s[33][33], c[4];
for(int i = 0; i < h; i++){
for(int j = 0; j < w; j++) cin >> s[i][j];
}
for(int i = 0; i < 4; i++) cin >> c[i];
const int inf = (1 << 25);
int a[4][33][33];
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
fill(a[0][0], a[4][0], inf);
typedef pair<int, int> P;
typedef pair<P, P> PP;
priority_queue<PP, vector<PP>, greater<PP> > que;
que.push(PP(P(0, 0), P(0, 0)));
a[0][0][0] = 0;
while(!que.empty()){
PP p = que.top(); que.pop();
int l = p.first.first, d = p.first.second;
int x = p.second.first, y = p.second.second;
if(x == w-1 && y == h-1){
cout << l << endl;
break;
}
for(int i = 0; i < 4; i++){
int nd = (d+i) % 4, nx = x + dx[nd], ny = y + dy[nd], nl = l + (i == s[y][x] ? 0 : c[i]);
if(nx < 0 || w <= nx || ny < 0 || h <= ny) continue;
if(nl < a[nd][ny][nx]){
que.push(PP(P(nl, nd), P(nx, ny)));
a[nd][ny][nx] = nl;
}
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n];
bool pos = true;
for (int &i : a) cin >> i;
sort(a, a + n);
for (int i = 0; i < n - 1; i++) {
if (abs(a[i] - a[i + 1]) > 1) {
pos = false;
cout << "NO" << endl;
break;
}
}
if (pos) cout << "YES" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n + 1], i;
for (i = 1; i <= n; i++) cin >> a[i];
long long k = -1, ans = 0, cf = 0;
map<long long, long long> m;
m[0] = 0;
for (i = 1; i <= n; i++) {
cf += a[i];
if (m.find(cf) != m.end()) k = max(k, m[cf]);
ans += (i - k - 1);
m[cf] = i;
}
cout << ans << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
char grid[350][350];
int n, m, tot, k;
bool isvalid(int i, int j) { return (i >= 0 && j >= 0 && i < n && j < m); }
vector<pair<int, int> > star[350];
int main() {
scanf("%d", &n), scanf("%d", &m), scanf("%d", &k);
for (int i = 0; i < n; ++i) scanf(" %s", &grid[i]);
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
if (grid[i][j] == '.') continue;
for (int x = 1;; ++x) {
if (isvalid(i + x, j) && isvalid(i - x, j) && isvalid(i, j + x) &&
isvalid(i, j - x)) {
if (grid[i + x][j] == '*' && grid[i - x][j] == '*' &&
grid[i][j + x] == '*' && grid[i][j - x] == '*') {
star[x].push_back(pair<int, int>(i, j));
++tot;
}
} else
break;
}
}
if (k > tot) return puts("-1");
for (int x = 1;; ++x) {
if (k > star[x].size())
k -= star[x].size();
else {
sort(star[x].begin(), star[x].end());
--k;
printf("%d %d\n", star[x][k].first + 1, star[x][k].second + 1);
printf("%d %d\n", star[x][k].first + 1 - x, star[x][k].second + 1);
printf("%d %d\n", star[x][k].first + 1 + x, star[x][k].second + 1);
printf("%d %d\n", star[x][k].first + 1, star[x][k].second + 1 - x);
printf("%d %d\n", star[x][k].first + 1, star[x][k].second + 1 + x);
return 0;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, q, fa[N];
double a[N];
struct Tree {
int l, r, lz;
double val, mul, add;
} tr[N * 4];
void build(int l, int r, int t) {
tr[t].l = l;
tr[t].r = r;
tr[t].lz = tr[t].val = tr[t].add = 0;
tr[t].mul = 1;
if (l == r) {
fa[l] = t;
return;
}
int mid = (l + r) / 2;
build(l, mid, t << 1);
build(mid + 1, r, (t << 1) | 1);
}
void pushDown(int t) {
if (tr[t].lz) {
tr[t << 1].val = tr[t].add * (tr[t << 1].r - tr[t << 1].l + 1) +
tr[t << 1].val * tr[t].mul;
tr[t << 1].mul *= tr[t].mul;
tr[t << 1].add *= tr[t].mul;
tr[t << 1].add += tr[t].add;
tr[(t << 1) | 1].val =
tr[t].add * (tr[(t << 1) | 1].r - tr[(t << 1) | 1].l + 1) +
tr[(t << 1) | 1].val * tr[t].mul;
tr[(t << 1) | 1].mul *= tr[t].mul;
tr[(t << 1) | 1].add *= tr[t].mul;
tr[(t << 1) | 1].add += tr[t].add;
tr[t << 1].lz = tr[(t << 1) | 1].lz = 1;
tr[t].lz = tr[t].add = 0;
tr[t].mul = 1;
}
}
void pushUp(int t) { tr[t].val = tr[t << 1].val + tr[(t << 1) | 1].val; }
void update(int l, int r, int t, double mul, double add) {
if (l <= tr[t].l && tr[t].r <= r) {
tr[t].val = add * (tr[t].r - tr[t].l + 1) + tr[t].val * mul;
tr[t].lz = 1;
tr[t].mul *= mul;
tr[t].add *= mul;
tr[t].add += add;
return;
}
pushDown(t);
int mid = (tr[t].l + tr[t].r) / 2;
if (l <= mid) update(l, r, t << 1, mul, add);
if (r > mid) update(l, r, (t << 1) | 1, mul, add);
pushUp(t);
}
double query(int l, int r, int t) {
if (l <= tr[t].l && tr[t].r <= r) return tr[t].val;
pushDown(t);
double ret = 0;
int mid = (tr[t].l + tr[t].r) / 2;
if (l <= mid) ret += query(l, r, t << 1);
if (r > mid) ret += query(l, r, (t << 1) | 1);
return ret;
}
void solve() {
scanf("%d%d", &n, &q);
build(1, n, 1);
for (int i = 1; i <= n; i++) {
scanf("%lf", &a[i]);
update(i, i, 1, 1, a[i]);
}
while (q--) {
int ty;
scanf("%d", &ty);
if (ty == 1) {
int l1, r1, l2, r2;
scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
double avg1 = query(l1, r1, 1) / double(r1 - l1 + 1);
double avg2 = query(l2, r2, 1) / double(r2 - l2 + 1);
update(l1, r1, 1, double(r1 - l1) / double(r1 - l1 + 1),
avg2 / double(r1 - l1 + 1));
update(l2, r2, 1, double(r2 - l2) / double(r2 - l2 + 1),
avg1 / double(r2 - l2 + 1));
} else {
int l, r;
scanf("%d%d", &l, &r);
printf("%.7f\n", query(l, r, 1));
}
}
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
clock_t tstart = clock();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, k;
cin >> n >> k;
int ans = 0;
for (int i = 0; i < n; i++) {
int num;
cin >> num;
ans += num / k;
if (num % k) ans++;
}
cout << (ans + 1) / 2;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100005;
long long p26[MAX], p25[MAX], inv[MAX];
long long f[MAX], mod = 1e9 + 7;
int ans[500][MAX];
map<int, int> mp;
long long ny(long long x) {
int m = mod - 2;
long long rt = 1, now = x;
while (m) {
if (m & 1) rt = (rt * now) % mod;
now = (now * now) % mod;
m /= 2;
}
return rt;
}
void init() {
p26[0] = p25[0] = f[0] = inv[0] = 1;
for (int i = 1; i <= 100002; i++) {
p26[i] = (p26[i - 1] * 26) % mod;
p25[i] = (p25[i - 1] * 25) % mod;
f[i] = (f[i - 1] * i) % mod;
inv[i] = ny(f[i]);
}
}
void get_ans(int l) {
int t = mp[l];
memset(ans[t], 0, sizeof(ans[t]));
ans[t][l] = 1;
for (int i = l + 1; i <= 100002; i++) {
long long temp = (inv[l - 1] * inv[i - l]) % mod;
temp = (f[i - 1] * temp) % mod;
temp = (temp * p25[i - l]) % mod;
ans[t][i] = (1ll * ans[t][i - 1] * 26 + temp) % mod;
}
}
char s[MAX];
int main() {
init();
int l, n, m;
scanf("%d %s", &m, s);
l = strlen(s);
int count = 0;
while (m--) {
int t;
scanf("%d", &t);
if (t == 1) {
scanf("%s", s);
l = strlen(s);
} else {
if (!mp.count(l)) {
mp[l] = ++count;
get_ans(l);
}
scanf("%d", &n);
printf("%d\n", ans[mp[l]][n]);
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, p = 1;
bool OK = false;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (i % 2 != 0)
cout << "#";
else {
if (p % 2 != 0) {
if (j != m)
cout << ".";
else
cout << "#";
} else {
if (j == 1)
cout << "#";
else
cout << ".";
}
}
}
if (i % 2 == 0) p++;
cout << endl;
}
return 0;
}
| 1 |
#include <cstdio>
#include <cctype>
int main()
{
char s[1200];
scanf("%[^\n]", s);
for(int i = 0;s[i] != '\0'; i++){
if(isupper(s[i])) s[i] = tolower(s[i]);
else s[i] = toupper(s[i]);
}
printf("%s\n", s);
return 0;
}
| 0 |
#include<iostream>
using namespace std;
int main(){
int n;cin>>n;
if(n<105)cout<<0<<endl;
else if(n<135)cout<<1<<endl;
else if(n<165)cout<<2<<endl;
else if(n<189)cout<<3<<endl;
else if(n<195)cout<<4<<endl;
else cout<<5<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_FL_N = 110;
const int FL_INF = 1e9;
struct edge;
vector<edge> ve[MAX_FL_N];
struct edge {
int v, fl, r;
edge(int _v = 0, int _fl = 0, int _r = 0) : v(_v), fl(_fl), r(_r) {}
void add(int a) {
fl += a;
ve[v][r].fl -= a;
}
int cap() { return ve[v][r].fl; }
};
void add_edge(int v, int w, int c) {
ve[v].push_back(edge(w, 0, ((int)((ve[w]).size())) + (v == w ? 1 : 0)));
ve[w].push_back(edge(v, c, ((int)((ve[v]).size())) - 1));
}
int dist[MAX_FL_N], cur[MAX_FL_N], S, T, N;
int bfs() {
int v;
memset(dist, -1, sizeof(int) * (N + 1));
queue<int> Q;
dist[S] = 0;
Q.push(S);
while (!Q.empty()) {
v = Q.front();
Q.pop();
for (__typeof((ve[v]).begin()) it = (ve[v]).begin(); it != (ve[v]).end();
++it) {
if (it->cap() > 0 && dist[it->v] == -1) {
dist[it->v] = dist[v] + 1;
Q.push(it->v);
}
}
}
return dist[T] != -1;
}
int dfs(int v, int mn) {
if (v == T || mn == 0) return mn;
int &i = cur[v], k, y, res = 0;
for (; i < ((int)((ve[v]).size())); ++i) {
k = ve[v][i].v;
if (dist[k] == dist[v] + 1 && ve[v][i].cap() > 0) {
y = dfs(k, min(mn, ve[v][i].cap()));
mn -= y;
res += y;
ve[v][i].add(y);
if (mn == 0) break;
}
}
return res;
}
int flow() {
int res = 0;
while (bfs()) {
memset(cur, 0, sizeof(int) * (N + 1));
res += dfs(S, FL_INF);
}
return res;
}
int main(void) {
int n, m;
scanf("%d%d", &n, &m);
vector<int> a(n);
for (int i = 0; i < (n); ++i) {
scanf("%d", &a[i]);
}
vector<pair<int, int> > E(m);
for (int i = 0; i < (m); ++i) {
scanf("%d%d", &E[i].first, &E[i].second);
--E[i].first;
--E[i].second;
if (E[i].first % 2 == 1) {
swap(E[i].first, E[i].second);
}
}
set<int> P;
for (int i = 0; i < (n); ++i) {
int g = a[i];
for (int p = 2; p * p <= a[i]; ++p) {
int k = 0;
while (g % p == 0) {
g /= p;
++k;
}
if (k > 0) {
P.insert(p);
}
}
if (g > 1) {
P.insert(g);
}
}
int res = 0;
N = n + 2;
S = N - 1;
T = N - 2;
for (int p : P) {
for (int i = 0; i < (N); ++i) {
ve[i].clear();
}
for (int i = 0; i < (n); ++i) {
int k = 0;
while (a[i] % p == 0) {
a[i] /= p;
++k;
}
if (i % 2 == 0) {
add_edge(S, i, k);
} else {
add_edge(i, T, k);
}
}
for (const pair<int, int> &e : E) {
add_edge(e.first, e.second, 1000);
}
res += flow();
}
printf("%d\n", res);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x7fffffff;
const int MOD = 1000003;
template <typename tn>
inline tn read() {
char ch;
tn f = 1;
while (!isdigit(ch = getchar()))
if (ch == '-') f = -1;
tn x = ch - '0';
while (isdigit(ch = getchar())) x = x * 10 + ch - '0';
return x * f;
}
template <typename tn>
inline void cmax(tn &a, tn b) {
if (a < b) a = b;
}
template <typename tn>
inline void cmin(tn &a, tn b) {
if (a > b) a = b;
}
const int K = 100 + 5;
int n;
struct Matrix {
int n[K][K];
Matrix(int x) {
memset(n, 0, sizeof(n));
if (x)
for (int i = 0; i < (K); i++) n[i][i] = 1;
}
} a(0), Fir(0);
inline Matrix operator*(const Matrix a, const Matrix b) {
Matrix c(0);
for (int i = (1); i <= (n); i++)
for (int j = (1); j <= (n); j++)
for (int k = (1); k <= (n); k++)
c.n[i][k] = (c.n[i][k] + (long long)a.n[i][j] * b.n[j][k]) % MOD;
return c;
}
inline Matrix power(Matrix a, long long k) {
Matrix s(1);
for (; k; k >>= 1, a = a * a)
if (k & 1) s = s * a;
return s;
}
void prematrix() {}
int main() {
int k = read<int>();
n = read<int>() + 1;
int h = read<int>(), tmp = 1;
for (int i = (1); i <= (n - 1); i++) a.n[i][i + 1] = 1;
for (int i = (n); i >= (1); i--) {
a.n[n][i] = tmp;
tmp = tmp * h % MOD;
}
Matrix ans = power(a, k + 1);
cout << ans.n[n][n] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = res * x;
y = y >> 1;
x = x * x;
}
return res;
}
int main() {
long long int n, m;
cin >> n >> m;
set<long long int> rw, cm;
for (long long int i = 0; i < m; i++) {
long long int a, b;
cin >> a >> b;
rw.insert(a);
cm.insert(b);
}
long long int cnt = 0, j = n - 1;
for (long long int i = 2; i < n; i++) {
if (cm.find(j) == cm.end() && rw.find(i) == rw.end()) {
if (i != j)
cnt += 2;
else
cnt += 1;
} else if (cm.find(j) == cm.end() || rw.find(i) == rw.end())
cnt += 1;
j--;
}
cout << cnt << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
int p[N * N];
int f(int u) { return u == p[u] ? u : p[u] = f(p[u]); }
bool join(int a, int b) {
a = f(a), b = f(b);
if (a == b) return false;
p[a] = b;
return true;
}
int n, m;
char mat[N][N];
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
bool possible() {
int freer = 0, freec = 0;
for (int i = 0; i < n; i++) {
int j = 0;
while (j < m and mat[i][j] == '.') j++;
if (j == m) {
freer++;
} else {
while (j < m and mat[i][j] == '#') j++;
while (j < m and mat[i][j] == '.') j++;
if (j < m) return false;
}
}
for (int j = 0; j < m; j++) {
int i = 0;
while (i < n and mat[i][j] == '.') i++;
if (i == n) {
freec++;
} else {
while (i < n and mat[i][j] == '#') i++;
while (i < n and mat[i][j] == '.') i++;
if (i < n) return false;
}
}
if (freer == freec) return true;
if (!freer or !freec) return false;
return true;
return (freer > 0) == (freec > 0);
}
int main() {
iota(p, p + N * N, 0);
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) scanf(" %s", mat[i]);
int cnt = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (mat[i][j] != '#') continue;
cnt++;
for (int k = 0; k < 4; k++) {
int x = i + dx[k], y = j + dy[k];
if (x < 0 or x >= n or y < 0 or y >= m) continue;
if (mat[x][y] != '#') continue;
cnt -= join(i * N + j, x * N + y);
}
}
if (!possible()) {
printf("-1\n");
return 0;
}
printf("%d\n", cnt);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
map<string, int> q;
int n, m, cnt = 0;
cin >> n >> m;
int ans1 = n, ans2 = m;
while (n--) {
cin >> s;
q[s]++;
}
while (m--) {
cin >> s;
q[s]++;
if (q[s] > 1) cnt++;
}
if (cnt % 2 == 1) ans2 -= 1;
if (ans1 <= ans2)
cout << "NO" << endl;
else
cout << "YES" << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
const int LG = 21;
const int N = 400005;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFLL = 1e18;
using namespace std;
void solve(long long n) {
for (long long st = max(1LL, n / 3 - 3); st <= min(n, n / 3 + 3); st++) {
long long okay = 1;
for (long long c = 1; okay && c <= 1 && c <= n; c++) {
long long L = 0, R = n;
map<long long, long long> vis;
long long we = st, fl = 1;
vis[we] = 1;
while (L + 1 < R) {
long long M = (L + R) / 2;
if (fl == 1) {
we += M;
} else {
we -= M;
}
fl ^= 1;
if (vis[we] || !(1 <= we && we <= n)) {
okay = 0;
break;
}
vis[we] = 1;
if (M >= c)
R = M;
else
L = M;
}
}
for (long long c = max(1ll, n); okay && c <= n; c++) {
long long L = 0, R = n;
map<long long, long long> vis;
long long we = st, fl = 1;
vis[we] = 1;
while (L + 1 < R) {
long long M = (L + R) / 2;
if (fl == 1) {
we += M;
} else {
we -= M;
}
fl ^= 1;
if (vis[we] || !(1 <= we && we <= n)) {
okay = 0;
break;
}
vis[we] = 1;
if (M >= c)
R = M;
else
L = M;
}
}
if (okay) {
cout << "? " << st << endl;
long long x;
cin >> x;
long long fl = 1;
long long L = 0, R = n;
long long we = st;
long long anytime = 1;
while (L + 1 < R) {
long long M = (L + R) / 2;
if (fl == 1) {
we += M;
} else {
we -= M;
}
fl ^= 1;
cout << "? " << we << endl;
cin >> x;
if (x)
R = M, anytime = 1;
else
L = M;
}
cout << "= " << R << endl;
return;
}
}
cout << "bad " << n << endl;
}
signed main() {
long long t;
cin >> t;
while (t--) {
long long n;
cin >> n;
solve(n);
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool isOdd(int num) { return !(num % 2 == 0); }
int main() {
int n, allX = 0, allY = 0, oddDiff = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
allX += x;
allY += y;
int z = x - y;
if (isOdd(z)) oddDiff = z;
}
if (isOdd(allX) && isOdd(allY) && oddDiff != 0)
cout << 1;
else if (!isOdd(allX) && !isOdd(allY))
cout << 0;
else
cout << -1;
return 0;
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.