solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
int main() {
int n;
scanf("%d", &n);
int r = 0, i, ara[100];
for (i = 0; i < n; i++) {
scanf("%d", &ara[i]);
if (ara[i] == 0) {
r++;
}
}
if (r == n)
printf("EASY\n");
else
printf("HARD\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int Maxn = 2e5 + 1;
int f1[ Maxn ], f2[ Maxn ], n, k, l;
std::map < std::pair < int, int >, int > mp;
int p, q;
int find( int *f, int x )
{
return f[ x ] == x ? x : f[ x ] = find( f, f[ x ] );
}
void merge( int *f, int x, int y )
{
int x1 = find( f, x ), y1 = find( f, y );
if( x1 == y1 )
return;
f[ y1 ] = x1;
return;
}
int main( )
{
std::ios::sync_with_stdio( false );
std::cin >> n >> k >> l;
for( int i = 1; i <= n; ++i )
f1[ i ] = f2[ i ] = i;
for( int i = 1; i <= k; ++i )
{
std::cin >> p >> q;
merge( f1, p, q );
}
for( int i = 1; i <= l; ++i )
{
std::cin >> p >> q;
merge( f2, p, q );
}
for( int i = 1; i <= n; ++i )
find( f1, i ),
find( f2, i );
for( int i = 1; i <= n; ++i )
mp[ std::make_pair( f1[ i ], f2[ i ] ) ]++;
for( int i = 1; i <= n; ++i )
std::cout << mp[ std::make_pair( f1[ i ], f2[ i ] ) ] << " ";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
long long x, y, a, b;
cin >> x >> y >> a >> b;
long long g = gcd(x, y);
long long gg = (x * y) / g;
long long ans1 = (a - 1) / gg;
long long ans2 = b / gg;
long long ans = ans2 - ans1;
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
string ans;
inline bool is_vowel(char x) {
return (x == 'a' || x == 'e' || x == 'i' || x == 'o' || x == 'u' || x == 'y');
}
void solve(int index, char last) {
if (index == n) {
return;
}
if (is_vowel(last) && is_vowel(s[index])) {
solve(index + 1, last);
} else {
ans += s[index];
solve(index + 1, s[index]);
}
}
int main() {
cin >> n >> s;
ans = s[0];
solve(1, s[0]);
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1111;
int t[MAXN][MAXN];
vector<pair<int, int> > V;
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) scanf("%d", &t[i][j]);
if (k == 1) reverse(t[i] + 1, t[i] + m + 1);
}
printf("%d\n", (m * (m - 1)) / 2);
if (k == 0) {
for (int i = 1; i <= m; i++)
for (int j = i + 1; j <= m; j++) printf("%d %d\n", i, j);
} else {
for (int i = 1; i <= m; i++)
for (int j = i + 1; j <= m; j++) printf("%d %d\n", j, i);
}
}
| 2 |
#include <iostream>
#include <string>
using namespace std;
int main() {
string input;
int ans = 0, last;
while (cin >> input) {
last = input.size();
for (int i = 0; i<last; i++) {
if (input[i] != input[last - i - 1]) { break; }
if (i == last - 1) { ans++; }
}
}
cout << ans << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long a, b;
while (~scanf("%I64d%I64d", &a, &b)) {
long long s = 0;
if (!a) {
s = -b * b;
printf("%I64d\n", s);
while (b--) printf("x");
printf("\n");
} else if (!b) {
s = a * a;
printf("%I64d\n", s);
while (a--) printf("o");
printf("\n");
} else {
long long temp = a * a - b * b, c, ans = 1;
int j;
for (int i = 1; i <= a; i++) {
if (b >= i + 1)
j = i + 1;
else
break;
c = ((a - i + 1) * (a - i + 1) + (i - 1)) -
((b / j + 1) * (b / j + 1) * (b % j) +
(b / j) * (b / j) * (j - b % j));
if (c > temp) {
temp = c;
ans = i;
}
}
printf("%I64d\n", temp);
int tb = b % (ans + 1);
int ta = ans - 1;
for (int i = 1; i <= ans * 2 + 1; i++) {
if (i & 1) {
if (tb) {
j = b / (ans + 1) + 1;
tb--;
} else
j = b / (ans + 1);
while (j--) printf("x");
} else {
if (ta) {
j = 1;
ta--;
} else
j = a - ans + 1;
while (j--) printf("o");
}
}
printf("\n");
}
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
#define cmin(a,b) (a>(b)?a=(b),1:0)
#define cmax(a,b) (a<(b)?a=(b),1:0)
#define dmin(a,b) ((a)<(b)?(a):(b))
#define dmax(a,b) ((a)>(b)?(a):(b))
namespace io
{
int F()
{
int F=1,n=0;
char ch;
while((ch=getchar())!='-'&&(ch<'0'||ch>'9'));
ch=='-'?F=0:n=ch-'0';
while((ch=getchar())>='0'&&ch<='9')n=n*10+ch-'0';
return F?n:-n;
}
long long G()
{
long long F=1,n=0;
char ch;
while((ch=getchar())!='-'&&(ch<'0'||ch>'9'));
ch=='-'?F=0:n=ch-'0';
while((ch=getchar())>='0'&&ch<='9')n=n*10+ch-'0';
return F?n:-n;
}
}
int R(int l,int r)
{
return (rand()<<15|rand())%(r-l+1)+l;
}
int a[1111111];
const int M=1000000007;
int f[1111111];
int sum[1111111];
int ss[1111111];
int la[1111111];
int s0[1111111];
int main()
{
int n=io::F();
for(int i=1;i<=n;++i)a[i]=io::F();
for(int i=1;i<=n;++i)a[i]^=a[i-1];
for(int i=1;i<=n;++i)s0[i]=s0[i-1]+(a[i]==0);
int c0=a[n]==0;
int ans=0;
for(int i=1;i<=n;++i)
{
if(a[i]==0)
{
if(i!=n)c0=c0*2%M;
}
else
{
f[i]=1;
int c=s0[i]-s0[la[a[i]]];
if(la[a[i]])ss[a[i]]=(ss[a[i]]+1ll*sum[a[i]]*c)%M,f[i]=(f[i]+ss[a[i]])%M;
sum[a[i]]=(sum[a[i]]+f[i])%M;
la[a[i]]=i;
if(i==n||a[n]==0)ans=(ans+f[i])%M;
}
}
printf("%d\n",(ans+c0)%M);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> a(n);
for (int i = 0; i < n; i++) cin >> a[i];
;
sort(a.begin(), a.end());
long long mm = a[n / 2];
for (int i = n / 2; i < n - 1; i++) {
long long r = a[i + 1] - a[i];
if (k >= r * (i - n / 2 + 1))
k -= r * (i - n / 2 + 1);
else if (k > 0) {
mm += k / (i - n / 2 + 1);
k = 0;
break;
} else
break;
mm = a[i + 1];
}
if (k > 0) mm += k / (n / 2 + 1);
cout << mm << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fll;
const long double pi = acos(-1);
const int MOD = 1e9 + 7;
const int N = 1e6;
int main() {
string s;
cin >> s;
string t;
t = s;
sort(t.begin(), t.end());
if (t != s) {
puts("NO");
return 0;
} else {
int na = 0, nb = 0, nc = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'a')
na++;
else if (s[i] == 'b')
nb++;
else
nc++;
}
if (na == 0 or nb == 0) {
puts("NO");
return 0;
}
if (nc == na or nc == nb) {
puts("YES");
return 0;
} else {
puts("NO");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
multiset<int> ss;
vector<int> ve[(300000 + 100)];
int p[(300000 + 100)] = {0}, a[(300000 + 100)] = {0};
int main() {
ss.clear();
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
p[a[i]] = i;
ve[i].clear();
}
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
x = p[x];
y = p[y];
if (y < x) swap(x, y);
ve[x].push_back(y);
ss.insert(y);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (ss.empty())
ans += n - i + 1;
else
ans += (*ss.begin()) - i;
for (auto it : ve[i]) ss.erase(ss.find(it));
}
cout << ans << endl;
}
| 3 |
#include<iostream>
#include<string.h>
using namespace std;
int main(){
int N,a[100050];
cin>>N;
for(int i=0;i<N;i++){
cin>>a[i];
}
int k=0;
for(int j=0;j<100010;j++){
k = a[k]-1;
if(k==1){
cout<<j+1<<endl;
return 0;
}
}
cout<<-1<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(long long)b;i++)
#define rep(i,n) REP(i,0,n)
int const MAX = 100000;
typedef long long ll;
bool isnp[MAX+1];
vector<int> primes;
int main() {
for(int i=2; (ll)i*i<=MAX; i++) {
if(isnp[i]) continue;
for(int j=i*i; j<=MAX; j+=i) { isnp[j] = 1; }
}
for(int i=2; i<=MAX; i++) if(!isnp[i]) { primes.push_back(i); }
/*
rep(i, 10) { cerr << primes[i] << endl; }
*/
int m, a, b;
while(cin >> m >> a >> b && (m|a|b)) {
ll mx = 0;
int ansp=-1, ansq=-1;
REP(q, 1, m) {
if(isnp[q]) continue;
double pu = (double)m/q;
//cerr << "pu: " << pu << endl;
int k = upper_bound(primes.begin(), primes.end(), pu)-primes.begin()-1;
REP(pi, max(k-10, 0), k+10) {
int p = primes[pi];
//cerr << p << ", " << q << endl;
if(p > q) continue;
if(a*q > b*p) continue;
if(mx < p*q && p*q <= m) { mx = p*q, ansp = p, ansq = q; }
}
}
cout << ansp << " " << ansq << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
int A[3600], p, a, len, n = 0;
char B[3600];
int f[3600][3600][2][2];
inline void reverse(int *a, int l) {
for (register int i = 1, j = l, tmp; i < j; i++, j--) {
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
}
inline void reverse(char *a, int l) {
register char tmp;
for (register int i = 1, j = l; i < j; i++, j--) {
tmp = a[i];
a[i] = a[j];
a[j] = tmp;
}
}
inline int div(char *a, int p) {
register int r = 0;
for (register int i = len; i; i--) {
register long long bak = r * 10LL + a[i];
r = bak % p;
a[i] = bak / p;
}
for (; len && !a[len]; len--)
;
return r;
}
inline int mul(int a, int b) { return a * 1ll * b % 1000000007; }
inline int dec(int a, int b) { return (a - b + 1000000007) % 1000000007; }
inline int gp(int c, int r, int nr) {
if (r) return dec(p, gp(c, 0, nr));
return c - nr + 1;
}
inline int gs(int c, int r, int nr) {
if (r) return dec(mul(c + 1, p), gs(c, 0, nr));
if (c & 1) return dec(mul(c + 2, (c + 1) >> 1), nr * (c + 1));
return dec(mul(c + 1, (c + 2) >> 1), nr * (c + 1));
}
inline int strlen(char *a) {
register int n = 0;
while (*a != '\0') {
n++;
a++;
}
return n;
}
inline void inc(int &a, int b) { a = (a + b) % 1000000007; }
int main() {
scanf("%d %d", &p, &a);
scanf("%s", B + 1);
len = strlen(B + 1);
for (register int i = 1; i <= len; i++) B[i] -= 48;
reverse(B, len);
for (; len;) A[++n] = div(B, p);
reverse(A, n);
if (a > n) {
printf("0\n");
return 0;
}
f[1][0][1][0] = 1;
for (int register i = 1; i <= n; i++)
for (int register j = 0; j <= a; j++)
for (int register eq = 0; eq < 2; eq++)
for (int register rem = 0; rem < 2; rem++)
if (f[i][j][eq][rem]) {
int cur = f[i][j][eq][rem];
for (int register nr = 0; nr < 2; nr++) {
int register nj = (((j + nr) < (a)) ? (j + nr) : (a));
if (!eq)
inc(f[i + 1][nj][eq][nr], mul(cur, gs(p - 1, rem, nr)));
else {
inc(f[i + 1][nj][eq][nr], mul(cur, gp(A[i], rem, nr)));
if (A[i])
inc(f[i + 1][nj][0][nr], mul(cur, gs(A[i] - 1, rem, nr)));
}
}
}
int ans = 0;
for (int register eq = 0; eq < 2; eq++) inc(ans, f[n + 1][a][eq][0]);
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long k, b, n, t;
cin >> k >> b >> n >> t;
long long res = b, k0 = 1;
long long ans = 0;
while (1) {
if (ans != 0 && res + k0 > t) {
--ans;
break;
} else {
if (ans != 0) res = res * k + b;
k0 *= k;
}
++ans;
}
if (n - ans < 0)
cout << "0";
else
cout << n - ans;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e9 + 1;
const double pi = 3.1415926535897932384626433832;
const long long M = 2e18 + 7;
long long bis(long long a[], long long l, long long r, long long x) {
while (l <= r) {
long long m = l + (r - l) / 2;
if (a[m] == x) return m;
if (a[m] < x)
l = m + 1;
else
r = m - 1;
}
return -1;
}
long long gcd(long long x, long long y) {
if (x == 0)
return y;
else
return gcd(y % x, x);
}
long long lcm(long long x, long long y) { return (x * y) / gcd(x, y); }
bool isPrime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6) {
if (n % i == 0 || n % (i + 2) == 0) {
return false;
}
}
return true;
}
bool pdrome(string s) {
long long n = s.length();
for (long long i = 0; i < n / 2; i++) {
if (s[i] != s[n - i - 1]) {
return false;
}
}
return true;
}
long long mindig(long long x) {
long long ans = 9;
long long t = x;
while (x) {
ans = min(ans, x % 10);
x /= 10;
}
x = t;
return ans;
}
long long maxdig(long long x) {
long long ans = 0;
long long t = x;
while (x) {
ans = max(ans, x % 10);
x /= 10;
}
x = t;
return ans;
}
long long modpow(long long x, long long n, long long M) {
if (n == 0) return 1 % M;
long long u = modpow(x, n / 2, M);
u = (u * u) % M;
if (n % 2 == 1) u = (u * x) % M;
return u;
}
long long sumdigits(long long a) {
long long result = 0;
while (a > 0) {
result += a % 10;
a /= 10;
}
return result;
}
long long digits(long long n) { return floor(log10(n) + 1); }
const long long Node = 1e5 + 7;
vector<long long> adj[Node];
bool vis[Node];
void addedge(long long u, long long v) {
adj[u].push_back(v);
adj[v].push_back(u);
}
void bfs(long long u) {
vis[u] = true;
list<long long> q;
q.push_back(u);
while (!q.empty()) {
q.pop_front();
for (auto x : adj[u]) {
if (!vis[x]) {
vis[x] = true;
q.push_back(x);
}
}
}
}
void dfs(long long u) {
vis[u] = true;
for (auto x : adj[u]) {
if (!vis[x]) {
dfs(x);
}
}
}
long long con1(string s) {
long long res = 0;
stringstream geek(s);
geek >> res;
return res;
}
string con2(long long num) {
string stri = to_string(num);
return stri;
}
const long long N = 1e9 + 7;
char c[2005][2005];
long long dp[2005][2005];
void solve() {
long long n, m;
cin >> n >> m;
for (long long i = 2; i < n + 2; i++) {
for (long long j = 1; j < m + 1; j++) {
cin >> c[i][j];
}
}
long long ans = 0;
for (long long i = 2; i < n + 2; i++) {
for (long long j = 1; j < m + 1; j++) {
if (c[i][j] == c[i - 1][j] && c[i][j] == c[i - 1][j - 1] &&
c[i][j] == c[i - 2][j] && c[i][j] == c[i - 1][j + 1])
dp[i][j] = (long long)1 +
min(min(dp[i - 1][j - 1], dp[i - 1][j + 1]), dp[i - 2][j]);
else
dp[i][j] = 1;
ans += 1LL * dp[i][j];
}
}
cout << ans;
return;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
bool lcs(string a, string b) {
long long m = a.length();
long long n = b.length();
long long L[m + 1][n + 1];
memset(L, 0, sizeof(L));
long long i, j;
for (i = 0; i <= m; i++) {
for (j = 0; j <= n; j++) {
if (i == 0 || j == 0)
L[i][j] = 0;
else if (a[i - 1] == b[j - 1])
L[i][j] = L[i - 1][j - 1] + 1;
else
L[i][j] = max(L[i - 1][j], L[i][j - 1]);
}
}
return (L[m][n] == m);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long q;
cin >> q;
while (q--) {
string s, t, p;
cin >> s >> t >> p;
long long f[26], f1[26];
memset(f, 0, sizeof(f));
memset(f1, 0, sizeof(f1));
for (long long i = 0; i < s.length(); i++) {
f[s[i] - 'a']++;
}
for (long long i = 0; i < t.length(); i++) {
f1[t[i] - 'a']++;
}
for (long long i = 0; i < p.length(); i++) {
f[p[i] - 'a']++;
}
bool flg = true;
for (long long i = 0; i < 26; i++) {
if (f[i] < f1[i]) {
flg = false;
}
}
if (flg and lcs(s, t))
cout << "YES\n";
else
cout << "NO\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, k, c, l;
int a[100001];
priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>>
que;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
l = c = 0;
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] != 100)
que.push({10 - (a[i] % 10), i});
else
++c;
l += a[i] / 10;
}
while (c < n && k) {
pair<int, int> p = que.top();
que.pop();
if (k >= p.first) {
++l;
k -= p.first;
a[p.second] += p.first;
if (a[p.second] != 100)
que.push({10, p.second});
else
++c;
} else
k = 0;
}
cout << l << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/stack:200000000")
long long int ans, t, n, m, i, j, k, a, b, c, d, e, f, g;
string s, s2, s3, s4;
long long int ar[(int)(1e6 + 10)];
vector<long long int> v;
map<long long int, long long int> mp;
void brainfuck();
int main() {
ios_base::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
brainfuck();
return 0;
}
void brainfuck() {
cin >> n;
for (i = 0; i < n; i++) {
cin >> a;
mp[a]++;
v.push_back(a);
}
sort(v.begin(), v.end());
if (v[0] != v[1] && v[2] != v[1]) {
a = mp[v[0]];
b = mp[v[1]];
c = mp[v[2]];
ans = a * b * c;
} else if (v[0] == v[1] && v[1] == v[2]) {
a = mp[v[0]];
for (i = 1; i < a - 1; i++) {
b = a - i;
ans += b * (b - 1) / 2;
}
} else if (v[0] == v[1] && v[1] != v[2]) {
c = mp[v[2]];
a = mp[v[0]];
ans = (a * (a - 1) / 2) * c;
} else if (v[0] != v[1] && v[1] == v[2]) {
a = mp[v[0]];
b = mp[v[1]];
ans = (b * (b - 1) / 2) * a;
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j, sum = 0;
cin >> n;
int a[n][n];
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
cin >> a[i][j];
if (i == (n + 1) / 2 - 1 || j == (n + 1) / 2 - 1) {
sum += a[i][j];
}
}
}
if (n > 1) {
sum += a[0][n - 1] + a[n - 1][0] + a[0][0] + a[n - 1][n - 1];
}
if (n > 3) {
sum += a[1][1] + a[1][n - 2] + a[n - 2][1] + a[n - 2][n - 2];
}
cout << sum;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long n, d, cost[1 << 20], q, dp[30100][1050];
long actual;
long ans;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> d;
for (int i = 1; i <= n; i++) {
cin >> q;
cost[q]++;
}
for (int i = 0; i <= 30000; i++)
for (int j = 0; j <= 1005; j++) dp[i][j] = -1000000000;
dp[d][500] = cost[d];
for (int i = d; i <= 30000; i++) {
for (int last = 1; last <= 1000; last++) {
ans = max(ans, dp[i][last]);
actual = d + (last - 500);
if (actual > 1 && i + actual - 1 <= 30000)
dp[i + actual - 1][last - 1] = max(dp[i + actual - 1][last - 1],
dp[i][last] + cost[i + actual - 1]);
if (actual > 0 && i + actual <= 30000)
dp[i + actual][last] =
max(dp[i + actual][last], dp[i][last] + cost[i + actual]);
if (actual > 0 && i + actual + 1 <= 30000)
dp[i + actual + 1][last + 1] =
max(dp[i + actual + 1][last], dp[i][last] + cost[i + actual + 1]);
}
}
cout << ans << endl;
cin.get();
cin.get();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int arr[10][10];
int pos[10];
int n, k;
int main() {
int ans = 1000000000;
scanf("%d %d\n", &n, &k);
for (int i = 0; i < n; i++) {
for (int j = 0; j < k; j++) {
char c;
scanf("%c", &c);
arr[i][j] = c - '0';
}
scanf("\n");
}
for (int i = 0; i < k; i++) pos[i] = i;
do {
int mini = 1000000000, maxi = -1000000000;
for (int i = 0; i < n; i++) {
int x = 0;
for (int j = 0; j < k; j++) (x *= 10) += arr[i][pos[j]];
maxi = max(maxi, x);
mini = min(mini, x);
}
ans = min(ans, maxi - mini);
} while (next_permutation(pos, pos + k));
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
char s[100100];
int d[100100];
bool was[100100];
int main() {
int n;
while (scanf("%d", &n) == 1) {
scanf("%s", s);
for (int i = 0; i < n; i++) {
scanf("%d", &d[i]);
}
for (int i = 0; i < n; i++) {
was[i] = false;
}
int pos = 0;
bool cycle = false;
while (0 <= pos && pos < n) {
if (was[pos]) {
cycle = true;
break;
}
was[pos] = true;
pos += d[pos] * (s[pos] == '>' ? 1 : -1);
}
puts(cycle ? "INFINITE" : "FINITE");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
string n;
int main() {
cin >> n;
int ans = 0;
for (int i = 0; i < n.size(); i++) {
ans += 1 << (i + (n[n.size() - i - 1] - '0') / 7);
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000003;
char in[500010];
inline int pow(int a, int b) {
if (b == 0) return 1;
if (b == 1) return a % mod;
long long r = pow(a, b / 2);
r = (r * r) % mod;
if (b % 2) r = (r * a) % mod;
return r;
}
int n, m;
inline char f(int x, int y) { return in[x * m + y]; }
int main() {
int i, j;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) scanf("%s", &in[i * m]);
int ans = 1;
for (i = 0; i < n; i++) {
int f1 = 0, f2 = 0;
for (j = 0; j < m; j++) {
char c = f(i, j);
if (c == '1' || c == '2') {
if (j % 2 == 0)
f1 = 1;
else
f2 = 1;
} else if (c == '3' || c == '4') {
if (j % 2 == 0)
f2 = 1;
else
f1 = 1;
}
}
if (f1 && f2)
ans = 0;
else if (!f1 && !f2)
ans = (ans * 2) % mod;
}
for (j = 0; j < m; j++) {
int f1 = 0, f2 = 0;
for (i = 0; i < n; i++) {
char c = f(i, j);
if (c == '1' || c == '4') {
if (i % 2 == 0)
f1 = 1;
else
f2 = 1;
} else if (c == '2' || c == '3') {
if (i % 2 == 0)
f2 = 1;
else
f1 = 1;
}
}
if (f1 && f2)
ans = 0;
else if (!f1 && !f2)
ans = (ans * 2) % mod;
}
printf("%d\n", ans);
}
| 5 |
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
const int inf = 1012345678;
int main() {
int N;
while (cin >> N, N) {
vector<int> A(N);
for (int i = 0; i < N; ++i) cin >> A[i];
vector<pair<int, int> > dp = { make_pair(0, 0) };
for (int i = 0; i < N; ++i) {
vector<pair<int, int> > ndp((i + 1) * 1000 + 1, make_pair(-inf, inf));
for (int j = 0; j <= i * 1000; ++j) {
ndp[j] = max(ndp[j], dp[j]);
int reward = (500 - A[i] % 500) % 500;
ndp[j + reward] = max(ndp[j + reward], make_pair(dp[j].first, dp[j].second - A[i]));
int loss = 500 - (1000 - A[i] % 1000) % 1000;
if (j >= loss) ndp[j - loss] = max(ndp[j - loss], make_pair(dp[j].first + 1, dp[j].second - A[i]));
}
dp = ndp;
}
pair<int, int> ans = *max_element(dp.begin(), dp.end());
cout << ans.first << ' ' << -ans.second << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<map>
#include<cstring>
#include<string>
#include <math.h>
#include<algorithm>
// #include <boost/multiprecision/cpp_int.hpp>
#include<functional>
#define int long long
#define inf 1000000007
#define pa pair<int,int>
#define ll long long
#define pal pair<double,pa>
#define ppa pair<int,int>
#define ppap pair<int,pa>
#define ssa pair<string,int>
#define mp make_pair
#define pb push_back
#define EPS (1e-10)
#define equals(a,b) (fabs((a)-(b))<EPS)
using namespace std;
class Point{
public:
double x,y;
Point(double x=0,double y=0):x(x),y(y) {}
Point operator + (Point p) {return Point(x+p.x,y+p.y);}
Point operator - (Point p) {return Point(x-p.x,y-p.y);}
Point operator * (double a) {return Point(x*a,y*a);}
Point operator / (double a) {return Point(x/a,y/a);}
double absv() {return sqrt(norm());}
double norm() {return x*x+y*y;}
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 Point Vector;
struct Segment{
Point p1,p2;
};
double dot(Vector a,Vector b){
return a.x*b.x+a.y*b.y;
}
double cross(Vector a,Vector b){
return a.x*b.y-a.y*b.x;
}
bool parareru(Point a,Point b,Point c,Point d){
// if(abs(cross(a-b,d-c))<EPS)cout<<"dd "<<cross(a-b,d-c)<<endl;
return abs(cross(a-b,d-c))<EPS;
}
double distance_ls_p(Point a, Point b, Point c) {
if ( dot(b-a, c-a) < EPS ) return (c-a).absv();
if ( dot(a-b, c-b) < EPS ) return (c-b).absv();
return abs(cross(b-a, c-a)) / (b-a).absv();
}
bool is_intersected_ls(Segment a,Segment b) {
if(a.p1==b.p1||a.p2==b.p1||a.p1==b.p2||a.p2==b.p2) return false;
if(parareru((a.p2),(a.p1),(a.p1),(b.p2))&¶reru((a.p2),(a.p1),(a.p1),(b.p1))){
// cout<<"sss"<<endl;
if(dot(a.p1-b.p1,a.p1-b.p2)<EPS) return true;
if(dot(a.p2-b.p1,a.p2-b.p2)<EPS) return true;
if(dot(a.p1-b.p1,a.p2-b.p1)<EPS) return true;
if(dot(a.p1-b.p2,a.p2-b.p2)<EPS) return true;
return false;
}
else return ( cross(a.p2-a.p1, b.p1-a.p1) * cross(a.p2-a.p1, b.p2-a.p1) < EPS ) && ( cross(b.p2-b.p1, a.p1-b.p1) * cross(b.p2-b.p1, a.p2-b.p1) < EPS );
}
double segment_dis(Segment a,Segment b){
if(is_intersected_ls(a,b))return 0;
double r=distance_ls_p(a.p1, a.p2, b.p1);
r=min(r,distance_ls_p(a.p1, a.p2, b.p2));
r=min(r,distance_ls_p(b.p1, b.p2, a.p2));
r=min(r,distance_ls_p(b.p1, b.p2, a.p1));
return r;
}
Point intersection_ls(Segment a, Segment b) {
Point ba = b.p2-b.p1;
double d1 = abs(cross(ba, a.p1-b.p1));
double d2 = abs(cross(ba, a.p2-b.p1));
double t = d1 / (d1 + d2);
return a.p1 + (a.p2-a.p1) * t;
}
string itos( int i ) {
ostringstream s ;
s << i ;
return s.str() ;
}
int gcd(int v,int b){
if(v>b) return gcd(b,v);
if(v==b) return b;
if(b%v==0) return v;
return gcd(v,b%v);
}
double distans(double x1,double y1,double x2,double y2){
double rr=(x1-x2)*(x1-x2)+(y1-y2)*(y1-y2);
return sqrt(rr);
}
/*
int pr[100010];
//int inv[100010];
*/
int beki(int wa,int rr,int warukazu){
if(rr==0) return 1ll;
if(rr==1) return wa%warukazu;
if(rr%2==1) return (beki(wa,rr-1,warukazu)*wa)%warukazu;
int zx=beki(wa,rr/2,warukazu);
return (zx*zx)%warukazu;
}
/*
void gya(){
pr[0]=1;
for(int i=1;i<100010;i++){
pr[i]=(pr[i-1]*i)%inf;
}
for(int i=0;i<100010;i++) inv[i]=beki(pr[i],inf-2);
}
*/
//----------------kokomade tenpure------------
vector<int> G[100030];
vector<int> G2[100030];
map<pa,int> ma;
int n;
void saiki2(int u,int oya){
for(auto v:G[u]){
if(v==oya) continue;
G2[u].pb(v);
saiki2(v,u);
}
}
int s[100030];
int ans[100030]={0};
int ko[100030]={0};
int saizu(int u){
if(G2[u].size()==0){
ko[u]=1;
}
else{
int r=1;
for(auto v:G2[u]){
r+=saizu(v);
}
ko[u]=r;
}
return ko[u];
}
void saiki(int u){
for(auto v:G2[u]){
int ednum=ma[mp(u,v)];
int r=ko[v],rr=n-ko[v];
if(r==rr) ans[ednum]=-1;
else{
ans[ednum]=abs(s[u]-s[v])/abs(r-rr);
}
saiki(v);
}
}
int fukasa[100020];
int er[100030];
void ch(int u,int fuka,int dame){
fukasa[u]=fuka;
er[u]=dame;
for(auto v:G2[u]){
int ednu=ma[mp(u,v)];
if(ans[ednu]==-1){
ch(v,fuka,1);
}
else{
ch(v,fuka+ans[ednu],dame);
}
}
}
int eda[100020];
signed main(){
cin>>n;
for(int i=1;i<=n-1;i++){
int y,yy;
cin>>y>>yy;
G[y].pb(yy);
G[yy].pb(y);
//eda
ma[mp(y,yy)]=i;
ma[mp(yy,y)]=i;
}
saiki2(1,-1);
saizu(1);
for(int i=1;i<=n;i++) cin>>s[i];
saiki(1);
bool b=true;
int i1;
for(int i=1;i<=n-1;i++)if(ans[i]==-1) b=false,i1=i;
if(!b){
ch(1,0,0);
int ok=0,da=0,kazu=0;
for(int i=1;i<=n;i++){
if(er[i]) {
da+=fukasa[i];
kazu++;
}
else ok+=fukasa[i];
}
int r=s[1]-ok-da;
ans[i1]=r/kazu;
}
for(int i=1;i<=n-1;i++) cout<<ans[i]<<endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
long long n, k, dp[200000], a[200000];
int main()
{
cin >> n >> k;
for (int i = 1; i <= n; i ++) cin >> a[i];
for (int i = 1; i <= k; i ++)
{
for (int j = 1; j <= n; j ++)
{
if (i - a[j] >= 0 && dp[i-a[j]] == 0) {
dp[i] = 1;
break;
}
}
}
if (dp[k] == 1)
cout << "First";
else
cout << "Second";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> A;
int n, i, l;
cin >> n;
for (i = 0; i < n; i++) {
cin >> l;
A.push_back(l);
}
sort(A.begin(), A.end());
for (i = 1; i < n; i++) {
if (A[i] % A[0] != 0) {
cout << "-1";
return 0;
}
}
cout << A[0];
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
stack<char> st;
string con;
cin >> con;
for (int i = 0; i < con.length(); i++) {
if (st.size() == 0 || st.top() != con[i]) {
st.push(con[i]);
} else {
st.pop();
}
}
if (st.size() == 0) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a, b, c, d, e, f;
long long res, ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> a >> b >> c >> d >> e >> f;
int set1 = min(a, d);
int set2 = min(b, c);
int set3 = min(set2, d);
res = 1ll * f * set3;
res += 1ll * min(a, d - set3) * e;
ans = 1ll * set1 * e;
ans += 1ll * min(set2, d - set1) * f;
cout << max(res, ans);
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
//INSERT ABOVE HERE
signed main(){
int n,q;
cin>>n>>q;
vector<stack<int> > s(n);
for(int i=0;i<q;i++){
int t,a;
cin>>t>>a;
if(t==0){
int x;
cin>>x;
s[a].emplace(x);
}
if(t==1) if(!s[a].empty()) cout<<s[a].top()<<endl;
if(t==2) if(!s[a].empty()) s[a].pop();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
int n, k;
int devLast;
inline void oil_read(std::istream& r) { r >> n >> k; }
inline int oil_eval(int v) {
int result = 0;
int dev = v;
while (dev > 0) {
result += dev;
dev /= k;
}
return result;
}
inline void oil_print(std::ostream& w, int i) { w << i << std::endl; }
inline void oil_solve(std::istream& r, std::ostream& w) {
int high, low, mid;
int result = 0;
oil_read(r);
if (n < k) {
oil_print(w, n);
return;
}
high = n + 1;
low = k - 1;
while (result != n) {
if (mid == low) {
oil_print(w, mid);
break;
}
mid = (high - low) / 2 + low;
result = oil_eval(mid);
if (result == n) {
oil_print(w, mid);
break;
} else if (result > n) {
high = mid - 1;
} else if (result < n) {
low = mid + 1;
}
}
return;
}
int main() {
using namespace std;
oil_solve(cin, cout);
return 0;
}
| 2 |
#include <iostream>
#define N 20
using namespace std;
int n,k,s,C;
void Ess(int,int,int);
int main(){
bool r;
while(1){
cin >> n >> k >> s;
if(n==0&&k==0&&s==0) break;
C=0;
Ess(0,0,0);
cout << C << endl;
}
return 0;
}
void Ess(int x,int sum,int cnt){
if(n==x){
if(cnt==k&&sum==s) C++;
return ;
}
Ess(x+1,sum,cnt);
Ess(x+1,sum+x+1,cnt+1);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[10], flag[200];
int main() {
int sum = 0;
for (int i = 1; i <= 5; i++) {
cin >> a[i];
sum += a[i];
flag[a[i]]++;
}
int ans = sum;
for (int i = 1; i <= 5; i++) {
if (flag[a[i]] > 1 && flag[a[i]] < 4)
ans = min(ans, sum - flag[a[i]] * a[i]);
else if (flag[a[i]] > 3) {
ans = min(ans, sum - 3 * a[i]);
}
}
cout << ans << "\n";
return 0;
}
| 1 |
#include<iostream>
#include<cstdio>
#include<string>
using std::cin;
using std::cout;
using std::endl;
using std::string;
//using std::stdin;
//using std::stdout;
//using std::freopen;
const int MXN=100010;
const int MXL=400060;
const int M=26;
int trie[MXL][M],sum[MXL],len[MXL],equal[MXL],tot=1;
bool end[MXL];
int n,q;
string str[MXN];
inline void ins(const string &s)
{
int p=0;
//++sum[p];
for(string::size_type i=0;i!=s.size();++i)
{
if(trie[p][s[i]-'a']==0)
trie[p][s[i]-'a'] = ++tot;
p=trie[p][s[i]-'a'];
++sum[p];
len[p]=i+1;
equal[p]=p;
}
end[p]=true;
}
void clean(int p)
{
for(int i=0;i!=M;++i)
if(trie[p][i]!=0)
{
clean(trie[p][i]);
if(sum[trie[p][i]]==sum[p])
equal[p]=equal[trie[p][i]];
}
}
inline int find(const string &s,const string &o)
{
int p=0,res=0;
for(string::size_type i=0;i<s.size();)
{
for(string::size_type j=0;o[j]!=s[i];++j)
res+=sum[trie[p][o[j]-'a']];
res+=(int)end[p];
p=equal[trie[p][s[i]-'a']];
i=len[p];
}
return res;
}
int main()
{
cin>>n;
for(int i=0;i!=n;++i)
cin>>str[i];
for(int i=0;i!=n;++i)
ins(str[i]);
clean(0);
cin>>q;
while(q--)
{
int k;string order;
cin>>k>>order;
cout<<find(str[k-1],order)+1<<endl;
}
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
double x1,y1,x2,y2,x3,y3;
double px,py;
int n;
cin >> n;
for(int i=0; i<n; i++){
cin >> x1>>y1>>x2>>y2>>x3>>y3;
px = ( (y1-y3)*(y1*y1-y2*y2 + x1*x1-x2*x2)-(y1-y2)*(y1*y1-y3*y3+x1*x1-x3*x3))/(2*(y1-y3)*(x1-x2)-2*(y1-y2)*(x1-x3));
py = ( (x1-x3)*(x1*x1-x2*x2 + y1*y1-y2*y2)-(x1-x2)*(x1*x1-x3*x3+y1*y1-y3*y3))/(2*(x1-x3)*(y1-y2)-2*(x1-x2)*(y1-y3));
printf("%.3f %.3f %.3f\n", px,py,sqrt((px-x1)*(px-x1)+(py-y1)*(py-y1)));
}
return 0;
} | 0 |
#include<iostream>
using namespace std;
int main()
{
int N,ans;
while(cin>>N,N){
ans=0;
for(int i=1;i<N;i++){
int s=0;
for(int j=i;j<N;j++){
s+=j;
if(s<N)continue;
if(s>N)break;
ans++;
break;
}
}
cout<<ans<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void robot() {
int n;
int m;
int rb;
int cb;
int rd;
int cd;
cin >> n;
cin >> m;
cin >> rb;
cin >> cb;
cin >> rd;
cin >> cd;
int answer = 0;
int st = 1;
int st2 = 1;
while (!false) {
if (cb + st2 > m || cb + st2 < 1) st2 *= -1;
if (rb == rd || cb == cd) break;
if (rb + st > n || rb + st < 1) st *= -1;
cb += st2;
answer++;
rb += st;
}
cout << answer << endl;
}
int main() {
cout.tie(0);
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t;
cin >> t;
while (t--) {
robot();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, d, i, j;
cin >> k >> d;
if (d == 0 && k > 1)
cout << "No solution\n";
else {
cout << d;
for (i = 1; i < k; i++) cout << 0;
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
const int maxn = int(1e5) + 7, mod = int(1e9) + 7;
bool not_prime[maxn];
std::vector<int> factor[maxn], prime_factor[maxn];
int f[maxn], m;
long long qpow(long long p, long long q) {
long long ret = 1;
while (q) {
if (q & 1) ret = ret * p % mod;
p = p * p % mod;
q >>= 1;
}
return ret;
}
void init() {
for (int i = 2; i < maxn; i++) {
for (int j = 2; i * j < maxn; j++) factor[i * j].push_back(i);
if (!not_prime[i]) {
for (int j = 1; i * j < maxn; j++) {
int num = i * j;
not_prime[num] = true;
prime_factor[num].push_back(i);
}
}
}
}
int __calc(int a, int b) {
int ret = b;
std::vector<int> buf;
for (int &it : prime_factor[a]) buf.push_back(it);
int len = int(buf.size());
for (int i = 1; i < 1 << len; i++) {
int tmp = 1;
for (int j = 0; j < len; j++) {
if ((i >> j) & 1) {
tmp = -tmp * buf[j];
}
}
ret += b / tmp;
}
return ret;
}
int calc(int x, int y) { return __calc(x / y, m / y); }
int main() {
init();
std::cin >> m;
int inv_m = int(qpow(m, mod - 2)), ans = 1;
for (int i = 2; i <= m; i++) {
f[i] = 1;
for (auto &k : factor[i]) {
f[i] = int((f[i] + 1ll * calc(i, k) * f[k] % mod * inv_m % mod) % mod);
}
f[i] =
int(1ll * f[i] *
qpow((1 - 1ll * (m / i) * inv_m % mod + mod) % mod, mod - 2) % mod);
ans = int((ans + 1ll * f[i] * inv_m % mod) % mod);
}
std::cout << ans << std::endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
long long res = 1;
x = x % 998244353;
while (y > 0) {
if (y & 1) res = (res * x) % 998244353;
y = y >> 1;
x = (x * x) % 998244353;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long n;
cin >> n;
;
vector<long long> v(2 * n);
for (int i = (long long)0; i < 2 * n; i++) cin >> v[i];
long long total = 1;
for (int i = (long long)1; i <= 2 * n; i++) total = (total * i) % 998244353;
long long need = 1;
for (int i = (long long)1; i <= n; i++) need = (need * i) % 998244353;
need = (need * need) % 998244353;
long long ans = power(need, 998244353 - 2);
ans = (ans * total) % 998244353;
long long sum = 0;
sort(v.begin(), v.end());
for (long long i = 0, j = 2 * n - 1; i < j; i++, j--)
sum = (sum + abs(v[i] - v[j])) % 998244353;
ans = (ans * sum) % 998244353;
cout << ans % 998244353;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char x[200005];
int a[200005];
int b[200005];
int c[200005];
int n, m;
int cnt = 1;
bool judge(int x) {
for (int i = 0; i < m; i++) {
b[i + 1] = a[i];
}
b[m] += x;
for (int i = m; i >= cnt; i--) {
if (b[1] > 9) {
cnt = 0;
}
if (b[i] > 9) {
b[i - 1] += b[i] / (9 + 1);
b[i] = b[i] % (9 + 1);
}
}
for (int i = cnt; i <= n; i++) {
int h;
if (cnt == 1) {
h = i % m;
if (h == 0) {
h = m;
}
} else {
if (i == 0) {
h = 0;
}
}
c[i] = b[h];
}
if (cnt == 0) {
return true;
}
int s = cnt;
for (int i = 0; i < n; i++) {
if (c[s] > a[i]) {
return true;
}
if (c[s] < a[i]) {
return false;
}
s++;
}
return true;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> m;
cin >> x;
for (int i = 0; i < n; i++) {
a[i] = x[i] - '0';
}
for (int i = 0; i < m; i++) {
b[i + 1] = a[i];
}
int ans = 0;
for (int i = 0;; i++) {
if (judge(i)) {
break;
}
}
if (cnt == 1) {
cout << n << "\n";
} else {
cout << n + 1 << "\n";
}
for (int i = cnt; i <= n; i++) {
cout << c[i];
}
cout << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, can[256], fx, fy, sx, sy;
int d[] = {0, 1, 1, 0, -1, 0, 0, -1};
int a[70][70], ans = (1 << 30);
char Map[70][70];
bool u[70][70];
queue<int> qx, qy, Qx[2], Qy[2];
string strans, str;
bool check(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
void path(int steps) {
str = "";
steps--;
int x, y, dx, dy, mn;
char want;
Qx[steps & 1].push(sx);
Qy[steps & 1].push(sy);
for (; steps >= 0; steps--) {
queue<int> &qX = Qx[steps & 1], &qY = Qy[steps & 1],
&nx = Qx[(steps + 1) & 1], &ny = Qy[(steps + 1) & 1];
want = 'z' + 1;
memset(u, 0, sizeof u);
while (!qX.empty()) {
x = qX.front();
y = qY.front();
qX.pop();
qY.pop();
for (int i = 0; i < 8; i += 2) {
dx = x + d[i];
dy = y + d[i + 1];
if (!check(dx, dy)) continue;
if (a[dx][dy] != a[x][y] - 1) continue;
if (Map[dx][dy] < want) {
while (!nx.empty()) nx.pop(), ny.pop();
want = Map[dx][dy];
}
if (Map[dx][dy] == want && !u[dx][dy])
nx.push(dx), ny.push(dy), u[dx][dy] = 1;
}
}
if (want == 'T') break;
str.push_back(want);
}
}
void solve() {
int x, y, dx, dy;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = (1 << 30);
}
}
qx.push(fx);
qy.push(fy);
a[fx][fy] = 0;
while (!qx.empty()) {
x = qx.front();
y = qy.front();
qx.pop();
qy.pop();
for (int i = 0; i < 8; i += 2) {
dx = x + d[i];
dy = y + d[i + 1];
if (check(dx, dy) && a[dx][dy] > a[x][y] + 1 && can[Map[dx][dy]]) {
a[dx][dy] = a[x][y] + 1;
qx.push(dx);
qy.push(dy);
}
}
}
if (a[sx][sy] == (1 << 30)) return;
if (a[sx][sy] < ans) {
ans = a[sx][sy];
path(a[sx][sy]);
strans = str;
} else if (a[sx][sy] == ans) {
path(a[sx][sy]);
if (str < strans) strans = str;
}
}
void rec(int d, int i = 0) {
if (d == k) {
solve();
return;
}
for (; i < 27; i++) {
can['a' + i] = 1;
rec(d + 1, i + 1);
can['a' + i] = 0;
}
}
int main() {
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < n; i++) {
scanf("%s", Map[i]);
for (int j = 0; j < m; j++) {
if (Map[i][j] == 'S') sx = i, sy = j;
if (Map[i][j] == 'T') fx = i, fy = j;
}
}
can['S'] = can['T'] = 1;
rec(0);
if (ans < (1 << 30))
printf("%s\n", strans.c_str());
else
printf("-1\n");
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
int main() {
int n, k, c, t;
int a[400];
memset(a, 0, sizeof(a));
a[0] = 1;
cin >> n >> k >> c;
for (int i = 0; i < c; i++) {
cin >> t;
a[t] = 1;
}
int ans = c;
t = 0;
for (int i = 0; i <= n; i++) {
if (a[i] == 1) {
t = 0;
} else {
t++;
if (t == k) {
ans++;
t = 0;
}
}
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
template <typename T>
void alert(const T& t) {
cout << t << endl;
exit(0);
}
bool cmd(const pair<int, int>& a, const pair<int, int>& b) {
return a.second < b.second;
}
long long prime(long long n) {
for (long long i = 2; i <= sqrt(n); i++)
if (n % i == 0) return n / i;
return 1;
}
int main() {
{}
int n;
cin >> n;
long long res = n;
while (n > 1) {
int k = prime(n);
res += k;
n = k;
}
cout << res << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k, n, i, x;
int j = 0;
int ara[50];
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> ara[i];
}
for (int p = 0; p < n; p++) {
if (ara[p] >= ara[k - 1] && ara[p] > 0) {
j++;
}
}
cout << j << endl;
}
| 1 |
#include<iostream>
using namespace std;
int main()
{
int n;
while(cin>>n){
if(n==0) break;
int mx=0,mi=500;
for(int i=0;i<n;i++){
int temp=0;
for(int j=0;j<5;j++){
int t;
cin>>t;
temp+=t;
}
mx=max(mx,temp);
mi=min(mi,temp);
}
cout<<mx<<" "<<mi<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int A[3];
int main() {
int n, t;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &t);
A[t % 3]++;
}
printf("%d\n", A[0] / 2 + min(A[1], A[2]));
return 0;
}
| 3 |
#include <bits/stdc++.h>
int a_, b_, c_, n;
int p[100007];
int gcd(int p, int q) {
int r;
while (q != 0) {
r = p % q;
p = q;
q = r;
}
return p;
}
void init() {
int i, j;
for (i = 0; i < 100007; i++) {
p[i] = 1;
}
for (i = 2; i < 100007; i++) {
if (p[i] == 1) {
for (j = i + i; j < 100007; j += i) {
p[j] = 0;
}
}
}
}
int cat(int x) {
int i, j, k, x_;
if (x == 1) {
return 1;
}
if (x == 2) {
return 2;
}
k = 1;
for (i = 2; i * i <= x; i++) {
if (x % i != 0) {
continue;
}
if (p[i] == 1) {
j = 0;
x_ = x;
while (x_ > 0 && x_ % i == 0) {
j++;
x_ /= i;
}
k *= j + 1;
}
if (i >= x / i) {
break;
}
i = x / i;
if (p[i] == 1) {
j = 0;
x_ = x;
while (x_ > 0 && x_ % i == 0) {
j++;
x_ /= i;
}
k *= j + 1;
}
i = x / i;
}
return k + (p[x] == 1 ? 1 : 0);
}
void test() {
long long a, b, c, ab, bc, ca, abc;
long long r;
a = cat(a_);
b = cat(b_);
c = cat(c_);
ab = cat(gcd(a_, b_));
bc = cat(gcd(b_, c_));
ca = cat(gcd(c_, a_));
abc = cat(gcd(gcd(a_, b_), c_));
r = (a - ab - ca + abc) * (bc * (bc + 1) / 2 + (b - bc) * c + (c - bc) * bc);
r += (ab - abc) *
(bc * (bc + 1) / 2 + (b - (ab - abc) - bc) * c + (c - bc) * bc) +
(ab - abc) * (ab - abc + 1) / 2 * c;
r += (ca - abc) *
(bc * (bc + 1) / 2 + (c - (ca - abc) - bc) * b + (b - bc) * bc) +
(ca - abc) * (ca - abc + 1) / 2 * b - (ca - abc) * (ab - abc) * bc;
r += abc * ((bc - abc) * (bc - abc + 1) / 2 +
((b - ab) - (bc - abc)) * (c - ca) +
((c - ca) - (bc - abc)) * (bc - abc)) +
(abc * (abc + 1) / 2) * (c - ca) +
(abc * (abc + 1) / 2) * (b - ab - bc + abc) +
(abc * (abc + 1) * (2 * abc + 1) + 3 * abc * (abc + 1)) / 12;
printf(
"%lld"
"\n",
r);
}
void run() {
int i;
init();
while (scanf("%d", &n) != EOF) {
for (i = 0; i < n; i++) {
scanf("%d%d%d", &a_, &b_, &c_);
test();
}
}
}
int main() {
run();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> ans;
int main() {
int t, n;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
ans.clear();
for (int i = 1; i * i <= n; i++) {
ans.push_back(n / i);
ans.push_back(i);
}
ans.push_back(0);
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++) printf("%d ", ans[i]);
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int a = 0;
char c = getchar();
bool f = 0;
while (!isdigit(c)) {
if (c == '-') f = 1;
c = getchar();
}
while (isdigit(c)) {
a = (a << 3) + (a << 1) + (c ^ '0');
c = getchar();
}
return f ? -a : a;
}
const int MAXN = 1e5 + 10;
struct Edge {
int end, upEd;
} Ed[MAXN << 1];
bool vis[MAXN];
int head[MAXN], d[MAXN], in[MAXN], N, M, cntEd;
vector<int> v[3];
inline void addEd(int a, int b) {
Ed[++cntEd].end = b;
Ed[cntEd].upEd = head[a];
head[a] = cntEd;
++in[b];
}
bool dfs1(int x, int p) {
vis[x] = 1;
for (int i = head[x]; i; i = Ed[i].upEd)
if (!vis[Ed[i].end]) {
if (dfs1(Ed[i].end, x)) return 1;
} else if (Ed[i].end != p)
return 1;
return 0;
}
void mark(int x) {
vis[x] = 0;
if (!d[x]) d[x] = 1;
for (int i = head[x]; i; i = Ed[i].upEd)
if (vis[Ed[i].end]) mark(Ed[i].end);
}
bool dfs2(int x, int p) {
if (p && in[x] == 3) {
d[x] = 2;
return 1;
}
for (int i = head[x]; i; i = Ed[i].upEd)
if (Ed[i].end != p)
if (dfs2(Ed[i].end, x)) {
d[x] = 2;
return 1;
}
return 0;
}
void dfs3(int x, int p, vector<int>& v) {
v.push_back(x);
for (int i = head[x]; i; i = Ed[i].upEd)
if (Ed[i].end != p) dfs3(Ed[i].end, x, v);
}
int main() {
for (int T = read(); T; --T) {
N = read();
M = read();
memset(head, 0, sizeof(int) * (N + 1));
memset(vis, 0, sizeof(bool) * (N + 1));
memset(d, 0, sizeof(int) * (N + 1));
memset(in, 0, sizeof(int) * (N + 1));
cntEd = 0;
for (int i = 1; i <= M; ++i) {
int a = read(), b = read();
addEd(a, b);
addEd(b, a);
}
bool f = 0;
for (int i = 1; !f && i <= N; ++i)
if (!vis[i])
if (f = dfs1(i, 0)) mark(i);
for (int i = 1; !f && i <= N; ++i)
if (in[i] >= 4) {
d[i] = 2;
mark(i);
f = 1;
}
for (int i = 1; !f && i <= N; ++i)
if (in[i] == 3)
if (f = dfs2(i, 0)) {
memset(vis, 1, sizeof(vis));
mark(i);
}
for (int i = 1; !f && i <= N; ++i)
if (in[i] == 3) {
int cnt = 0;
v[0].clear();
v[1].clear();
v[2].clear();
for (int j = head[i]; j; j = Ed[j].upEd) dfs3(Ed[j].end, i, v[cnt++]);
if (v[0].size() > v[1].size()) swap(v[0], v[1]);
if (v[0].size() > v[2].size()) swap(v[0], v[2]);
if (v[1].size() > v[2].size()) swap(v[1], v[2]);
if (v[1].size() == 1 ||
v[0].size() == 1 && v[1].size() == 2 && v[2].size() < 5)
continue;
f = 1;
if (v[2].size() >= 5) {
d[i] = 6;
d[v[0][0]] = 3;
d[v[1][0]] = 4;
d[v[1][1]] = 2;
for (int j = 0; j < 5; ++j) d[v[2][j]] = 5 - j;
} else {
d[i] = (v[0].size() + 1) * (v[1].size() + 1) * (v[2].size() + 1);
for (int j = 0; j < 3; ++j)
for (int k = 0; k < v[j].size(); ++k)
d[v[j][k]] = (d[i]) / (v[j].size() + 1) * (v[j].size() - k);
}
}
if (f) {
puts("YES");
for (int i = 1; i <= N; ++i) printf("%d ", d[i]);
putchar('\n');
continue;
} else
puts("NO");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200000;
int n;
int a[MAXN], b[MAXN];
vector<int> q;
vector<int> ed[MAXN];
int dfs(int u, int a1, int a2, int pred = -1) {
int ret = ((a1 ^ a[u]) == b[u]) ? 0 : 1;
if (ret) {
q.push_back(u + 1);
a1 ^= 1;
}
for (int i = 0; i < (int((ed[u]).size())); i++) {
int v = ed[u][i];
if (v == pred) continue;
ret += dfs(v, a2, a1, u);
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
ed[u - 1].push_back(v - 1);
ed[v - 1].push_back(u - 1);
}
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
}
for (int i = 0; i < n; i++) {
scanf("%d", b + i);
}
printf("%d\n", dfs(0, 0, 0));
for (int i = 0; i < (int((q).size())); i++) {
printf("%d\n", q[i]);
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
bool mat[3][3] = {1, 1, 1, 1, 1, 1, 1, 1, 1};
int tog[3][3];
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
cin >> tog[i][j];
tog[i][j] = tog[i][j] % 2;
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
if (tog[i][j] == 1) {
mat[i][j] = !mat[i][j];
if (i - 1 >= 0) mat[i - 1][j] = !mat[i - 1][j];
if (i + 1 < 3) mat[i + 1][j] = !mat[i + 1][j];
if (j - 1 >= 0) mat[i][j - 1] = !mat[i][j - 1];
if (j + 1 < 3) mat[i][j + 1] = !mat[i][j + 1];
}
}
}
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
cout << mat[i][j];
}
cout << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
long long x[100005], y[100005];
int nxt[100005];
vector<int> mp[100005];
int p[100005][20], d[100005];
void init() {
for (int j = 1; (1 << j) <= n; j++)
for (int i = 1; i <= n; i++) p[i][j] = p[p[i][j - 1]][j - 1];
}
int lca(int a, int b) {
if (d[a] > d[b]) swap(a, b);
int f = d[b] - d[a];
for (int i = 0; (1 << i) <= f; i++)
if ((1 << i) & f) b = p[b][i];
if (a != b) {
for (int i = (int)log2(n); i >= 0; i--)
if (p[a][i] != p[b][i]) {
a = p[a][i];
b = p[b][i];
}
a = p[a][0];
}
return a;
}
void dfs(int x, int pa, int dp) {
d[x] = dp;
p[x][0] = pa;
for (int c : mp[x]) dfs(c, x, dp + 1);
}
void cal() {
for (int(i) = 1; (i) <= (int)(n - 1); (i)++) {
mp[nxt[i]].push_back(i);
}
dfs(n, 0, 1);
init();
scanf("%d", &m);
for (int a, b, i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
printf("%d ", lca(a, b));
}
}
int main() {
scanf("%d", &n);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%lld%lld", x + i, y + i);
}
nxt[n] = n;
for (int i = n - 1; i; i--) {
nxt[i] = i + 1;
while (1) {
int p = nxt[i];
if (p == n) break;
int q = nxt[p];
long long l =
(y[q] - y[i]) * x[p] + y[i] * (x[q] - x[i]) - x[i] * (y[q] - y[i]);
long long r = (x[q] - x[i]) * y[p];
if (l > r) {
nxt[i] = q;
} else
break;
}
}
cal();
return 0;
}
| 4 |
#include <bits/stdc++.h>
int map[1001][1001];
int n, m;
int dx[4] = {1, -1, 0, 0};
int dy[4] = {0, 0, -1, 1};
inline bool check(int x, int y) {
return (x >= 1 && x <= n && y >= 1 && y <= m);
}
void dfs(int x, int y) {
for (int i = 0; i < 4; i++)
if (check(x + dx[i], y + dy[i]) && map[x + dx[i]][y + dy[i]]) {
map[x + dx[i]][y + dy[i]] = 0;
dfs(x + dx[i], y + dy[i]);
}
}
int main() {
scanf("%d %d\n", &n, &m);
char c;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%c", &c);
if (c == '#')
map[i][j] = 1;
else
map[i][j] = 0;
}
scanf("%c", &c);
}
bool check = true;
bool checks = true;
bool check1 = true, check2 = true;
for (int i = 1; i <= n; i++) {
int jugde = 0;
bool check1s = true;
for (int j = 1; j <= m; j++) {
if (map[i][j] == 1) check1s = false, checks = false;
if (!jugde && map[i][j] == 1) jugde = 1;
if (jugde == 1 && map[i][j] == 0) jugde = 2;
if (jugde == 2 && map[i][j] == 1) check = false;
}
if (check1s) check1 = false;
}
for (int j = 1; j <= m; j++) {
int jugde = 0;
bool check2s = true;
for (int i = 1; i <= n; i++) {
if (map[i][j] == 1) check2s = false;
if (!jugde && map[i][j] == 1) jugde = 1;
if (jugde == 1 && map[i][j] == 0) jugde = 2;
if (jugde == 2 && map[i][j] == 1) check = false;
}
if (check2s) check2 = false;
}
if ((!check || (check1 ^ check2)) && !checks) {
printf("-1");
return 0;
}
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
if (map[i][j]) {
ans++;
dfs(i, j);
}
}
printf("%d", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chmax(T &m, const T &v) {
if (v > m) return m = v, true;
return false;
}
template <typename T>
bool chmin(T &m, const T &v) {
if (v < m) return m = v, true;
return false;
}
template <typename T>
bool chinc(T &v1, T &v2) {
if (v1 > v2) return swap(v1, v2), true;
return false;
}
template <typename T>
bool chdec(T &v1, T &v2) {
if (v1 < v2) return swap(v1, v2), true;
return false;
}
namespace fio {
static const char eof = '\xff';
struct Cg {
inline char operator()() {
char c = (char)getchar();
if (c == eof) valid = false;
return c;
};
bool valid = true;
};
struct Cp {
inline void operator()(int x) { putchar(x); }
};
struct Ce {
inline void operator()(int x) { putc(x, stderr); }
};
inline bool IS(char x) {
return x == ' ' || x == '\r' || x == '\n' || x == '\t';
}
template <class T>
struct Fr {
T P;
inline Fr &operator,(int &x) {
x = 0;
int c = P();
while ((c < '0' || c > '9') && c != '-') c = P();
bool h = false;
if (c == '-') h = true, c = P();
for (; c >= '0' && c <= '9'; c = P()) x = x * 10 + c - '0';
if (h) x = -x;
return *this;
}
inline Fr &operator,(long &x) {
x = 0;
int c = P();
while ((c < '0' || c > '9') && c != '-') c = P();
bool h = false;
if (c == '-') h = true, c = P();
for (; c >= '0' && c <= '9'; c = P()) x = x * 10 + c - '0';
if (h) x = -x;
return *this;
}
inline Fr &operator,(long long &x) {
x = 0;
int c = P();
while ((c < '0' || c > '9') && c != '-') c = P();
bool h = false;
if (c == '-') h = true, c = P();
for (; c >= '0' && c <= '9'; c = P()) x = x * 10 + c - '0';
if (h) x = -x;
return *this;
}
inline Fr &operator,(unsigned &x) {
x = 0;
int c = P();
while ((c < '0' || c > '9') && c != '-') c = P();
bool h = false;
if (c == '-') h = true, c = P();
for (; c >= '0' && c <= '9'; c = P()) x = x * 10 + c - '0';
if (h) x = -x;
return *this;
}
inline Fr &operator,(unsigned long &x) {
x = 0;
int c = P();
while ((c < '0' || c > '9') && c != '-') c = P();
bool h = false;
if (c == '-') h = true, c = P();
for (; c >= '0' && c <= '9'; c = P()) x = x * 10 + c - '0';
if (h) x = -x;
return *this;
}
inline Fr &operator,(unsigned long long &x) {
x = 0;
int c = P();
while ((c < '0' || c > '9') && c != '-') c = P();
bool h = false;
if (c == '-') h = true, c = P();
for (; c >= '0' && c <= '9'; c = P()) x = x * 10 + c - '0';
if (h) x = -x;
return *this;
}
inline Fr &operator,(float &x) {
x = 0;
int c = P();
while ((c < '0' || c > '9') && c != '-') c = P();
bool h = false;
if (c == '-') h = true, c = P();
for (; c >= '0' && c <= '9'; c = P()) x = x * 10 + c - '0';
if (c == '.') {
double u = 0.1;
for (c = P(); c >= '0' && c <= '9'; c = P(), u *= 0.1) x += u * (c - '0');
};
if (h) x = -x;
return *this;
}
inline Fr &operator,(double &x) {
x = 0;
int c = P();
while ((c < '0' || c > '9') && c != '-') c = P();
bool h = false;
if (c == '-') h = true, c = P();
for (; c >= '0' && c <= '9'; c = P()) x = x * 10 + c - '0';
if (c == '.') {
double u = 0.1;
for (c = P(); c >= '0' && c <= '9'; c = P(), u *= 0.1) x += u * (c - '0');
};
if (h) x = -x;
return *this;
}
inline Fr &operator,(long double &x) {
x = 0;
int c = P();
while ((c < '0' || c > '9') && c != '-') c = P();
bool h = false;
if (c == '-') h = true, c = P();
for (; c >= '0' && c <= '9'; c = P()) x = x * 10 + c - '0';
if (c == '.') {
double u = 0.1;
for (c = P(); c >= '0' && c <= '9'; c = P(), u *= 0.1) x += u * (c - '0');
};
if (h) x = -x;
return *this;
}
inline Fr &operator,(char &x) {
for (x = P(); IS(x);) x = P();
return *this;
}
inline Fr &operator,(char *s) {
for (*s = P(); IS(*s) && P.valid;) *s = P();
for (; !IS(*s) && P.valid;) *++s = P();
*s = 0;
return *this;
}
inline Fr &operator,(string &s) {
s.clear();
char c = P();
for (; IS(c) && P.valid;) c = P();
for (; !IS(c) && P.valid;) s.push_back(c), c = P();
return *this;
}
inline operator bool() { return P.valid; }
};
template <class T>
struct Fw {
T P;
char B[32];
inline Fw &operator,(int x) {
if (x) {
if (x < 0) P('-'), x = -x;
int p = 0;
while (x) B[p++] = x % 10 + '0', x /= 10;
while (p--) P(B[p]);
} else
P('0');
return *this;
}
inline Fw &operator,(long x) {
if (x) {
if (x < 0) P('-'), x = -x;
int p = 0;
while (x) B[p++] = x % 10 + '0', x /= 10;
while (p--) P(B[p]);
} else
P('0');
return *this;
}
inline Fw &operator,(long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
int p = 0;
while (x) B[p++] = x % 10 + '0', x /= 10;
while (p--) P(B[p]);
} else
P('0');
return *this;
}
inline Fw &operator,(unsigned x) {
if (x) {
if (x < 0) P('-'), x = -x;
int p = 0;
while (x) B[p++] = x % 10 + '0', x /= 10;
while (p--) P(B[p]);
} else
P('0');
return *this;
}
inline Fw &operator,(unsigned long x) {
if (x) {
if (x < 0) P('-'), x = -x;
int p = 0;
while (x) B[p++] = x % 10 + '0', x /= 10;
while (p--) P(B[p]);
} else
P('0');
return *this;
}
inline Fw &operator,(unsigned long long x) {
if (x) {
if (x < 0) P('-'), x = -x;
int p = 0;
while (x) B[p++] = x % 10 + '0', x /= 10;
while (p--) P(B[p]);
} else
P('0');
return *this;
}
inline Fw &operator()(float g, int d) {
if (d) {
double t = 0.5;
for (int i = d; i--;) t *= 0.1;
if (g < 0) P('-'), g = -g;
g += t;
*this, (long long)(g);
P('.');
g -= floor(g);
while (d--) {
g *= 10;
int i = (int)floor(g);
P(i + '0');
g -= i;
}
} else
*this, (g > 0 ? (long long)(g + 0.5) : (long long)(g - 0.5));
return *this;
}
inline Fw &operator()(double g, int d) {
if (d) {
double t = 0.5;
for (int i = d; i--;) t *= 0.1;
if (g < 0) P('-'), g = -g;
g += t;
*this, (long long)(g);
P('.');
g -= floor(g);
while (d--) {
g *= 10;
int i = (int)floor(g);
P(i + '0');
g -= i;
}
} else
*this, (g > 0 ? (long long)(g + 0.5) : (long long)(g - 0.5));
return *this;
}
inline Fw &operator()(long double g, int d) {
if (d) {
double t = 0.5;
for (int i = d; i--;) t *= 0.1;
if (g < 0) P('-'), g = -g;
g += t;
*this, (long long)(g);
P('.');
g -= floor(g);
while (d--) {
g *= 10;
int i = (int)floor(g);
P(i + '0');
g -= i;
}
} else
*this, (g > 0 ? (long long)(g + 0.5) : (long long)(g - 0.5));
return *this;
}
inline Fw &operator,(char x) {
P(x);
return *this;
}
typedef basic_ostream<char, char_traits<char>> &OS;
typedef basic_istream<char, char_traits<char>> &IS;
inline Fw &operator,(OS &(*func)(OS)) {
if (func == static_cast<OS &(*)(OS)>(endl<char, char_traits<char>>))
P('\n');
return *this;
}
inline Fw &operator,(IS &(*func)(IS)) {
if (func == static_cast<IS &(*)(IS)>(ws<char, char_traits<char>>)) P(' ');
return *this;
}
inline Fw &operator,(const char *s) {
for (; *s; ++s) P(*s);
return *this;
}
inline Fw &operator,(const string &s) {
(*this), s.c_str();
return *this;
}
template <class C>
inline Fw &all(const C &v, char sep = ' ', char nl = '\n') {
auto it = v.begin();
for (int i = 0; i < (int)v.size(); ++i, ++it) {
if (i && sep) P(sep);
(*this), *it;
}
if (nl) P(nl);
return *this;
}
template <class U>
inline Fw &print(U x) {
(*this), x;
P('\n');
return *this;
}
template <class U, class... Us>
inline Fw &print(U x, Us... args) {
(*this), x;
P(' ');
print(args...);
return *this;
}
};
} // namespace fio
fio::Fr<fio::Cg> fin;
fio::Fw<fio::Cp> fout;
fio::Fw<fio::Ce> ferr;
template <typename Int>
Int gcd(Int a, Int b) {
while (a != 0) {
b %= a;
if (b == 0) return a;
a %= b;
}
return b;
}
template <typename Int, typename RInt = Int>
Int lcm(Int a, Int b) {
return a / gcd(a, b) * static_cast<RInt>(b);
}
template <typename Int, typename XInt>
Int extended_gcd(Int a, Int b, XInt &x, XInt &y) {
static_assert(std::numeric_limits<XInt>::is_signed, "x, y must be signed");
if (b == 0) {
x = 1;
y = 0;
return a;
}
Int g = extended_gcd(b, a % b, y, x);
y -= (a / b) * x;
return g;
}
template <typename Int>
Int mul_mod(Int a, Int b, Int m) {
static_assert(2 * std::numeric_limits<Int>::digits <=
std::numeric_limits<int64_t>::digits,
"multiplication will overflow!");
int64_t p = a;
p = (p * b) % m;
return (Int)p;
}
template <>
int64_t mul_mod<int64_t>(int64_t a, int64_t b, int64_t m) {
__int128_t p = __int128_t(a) * b;
return (int64_t)(p % m);
}
template <typename Int, typename PInt>
Int pow_mod(Int a, PInt p, Int m) {
Int r;
a %= m;
for (r = 1; p; p >>= 1) {
if (p & 1) r = mul_mod(r, a, m);
a = mul_mod(a, a, m);
}
return r;
}
template <typename Int, typename XInt = typename std::make_signed<Int>::type>
Int inv_mod(Int a, Int m) {
XInt x, y;
extended_gcd(a, m, x, y);
if (x < 0) return x + m;
return x;
}
template <typename Int>
Int addx_mod(Int u, Int v, Int m) {
Int r = u + v;
if (r >= m) r -= m;
return r;
}
template <typename Int>
Int subx_mod(Int u, Int v, Int m) {
Int r = u - v;
if (r < 0) r += m;
return r;
}
template <typename Int>
Int div_mod(Int u, Int v, Int m) {
Int g = gcd(v, m);
assert(u % g == 0);
Int mm = m / g;
return mul_mod(u / g, inv_mod(v / g, mm), mm);
}
template <typename Int>
Int div_pos_r(Int a, Int b, Int &r) {
Int q = a / b;
r = a % b;
if (r < 0) {
if (b < 0)
q += 1, r -= b;
else
q -= 1, r += b;
}
return q;
}
static const int maxn = 100005;
int n, m, seed, vmax;
int64_t a[maxn];
struct node_t {
int len;
int64_t v;
};
map<int, node_t> mp;
int rnd() {
int ret = seed;
seed = (1LL * seed * 7 + 13) % 1000000007;
return ret;
}
void add(int l, int r, int x) {
auto it = mp.lower_bound(l);
if (it == mp.end() || it->first > l) --it;
assert(it->first <= l);
int curx = it->first;
while (curx <= r) {
it = mp.lower_bound(curx);
curx += it->second.len;
if (it->first >= l && it->first + it->second.len - 1 <= r) {
it->second.v += x;
++it;
} else {
int start = it->first;
node_t cur = it->second;
it = mp.erase(it);
if (l > start) {
mp[start] = node_t{l - start, cur.v};
}
if (r < start + cur.len - 1) {
mp[r + 1] = node_t{start + cur.len - r - 1, cur.v};
}
int b = max(l, start), e = min(r, start + cur.len - 1);
if (e >= b) mp[b] = node_t{e - b + 1, cur.v + x};
}
}
}
void assign(int l, int r, int x) {
auto it = mp.lower_bound(l);
if (it == mp.end() || it->first > l) --it;
int curx = it->first;
while (curx <= r) {
it = mp.lower_bound(curx);
curx += it->second.len;
if (it->first >= l && it->first + it->second.len - 1 <= r) {
it = mp.erase(it);
} else {
int start = it->first;
node_t cur = it->second;
it = mp.erase(it);
if (l > start) {
mp[start] = node_t{l - start, cur.v};
}
if (r < start + cur.len - 1) {
mp[r + 1] = node_t{start + cur.len - r - 1, cur.v};
}
}
}
mp[l] = node_t{r - l + 1, x};
}
int64_t kth(int l, int r, int x) {
auto it = mp.lower_bound(l);
if (it == mp.end() || it->first > l) --it;
vector<pair<int64_t, int>> vec;
while (it != mp.end() && it->first <= r) {
if (it->first >= l && it->first + it->second.len - 1 <= r) {
vec.push_back(make_pair(it->second.v, it->second.len));
++it;
} else {
int start = it->first;
node_t cur = it->second;
int b = max(l, start), e = min(r, start + cur.len - 1);
vec.push_back(make_pair(cur.v, e - b + 1));
++it;
}
}
int tot = 0;
for (auto kv : vec) {
tot += kv.second;
}
assert(tot == r - l + 1);
sort(begin(vec), end(vec));
for (auto kv : vec) {
if (x < kv.second) return kv.first;
x -= kv.second;
}
throw 0;
}
int64_t psum(int l, int r, int x, int y) {
auto it = mp.lower_bound(l);
if (it == mp.end() || it->first > l) --it;
vector<pair<int64_t, int>> vec;
while (it != mp.end() && it->first <= r) {
if (it->first >= l && it->first + it->second.len - 1 <= r) {
vec.push_back(make_pair(it->second.v, it->second.len));
++it;
} else {
int start = it->first;
node_t cur = it->second;
int b = max(l, start), e = min(r, start + cur.len - 1);
vec.push_back(make_pair(cur.v, e - b + 1));
++it;
}
}
int tot = 0;
for (auto kv : vec) {
tot += kv.second;
}
assert(tot == r - l + 1);
int ans = 0;
for (auto kv : vec) {
ans += 1LL * pow_mod(int(kv.first % y), x, y) * kv.second % y;
ans %= y;
}
return ans;
}
void check() {
int cur = 1;
auto it = mp.begin();
while (it != mp.end()) {
assert(it->first == cur);
cur += it->second.len;
assert(it->second.len > 0);
++it;
}
assert(cur == n + 1);
}
int main() {
fin, n, m, seed, vmax;
for (int i = 1, iend = n; i <= iend; i++) {
a[i] = (rnd() % vmax) + 1;
mp[i] = node_t{1, 1LL * a[i]};
}
for (int i = 1, iend = m; i <= iend; i++) {
int op = (rnd() % 4) + 1;
int l = (rnd() % n) + 1;
int r = (rnd() % n) + 1;
int x, y = 0;
if (l > r) swap(l, r);
if (op == 3)
x = (rnd() % (r - l + 1)) + 1;
else
x = (rnd() % vmax) + 1;
if (op == 4) y = (rnd() % vmax) + 1;
if (op == 1) {
add(l, r, x);
} else if (op == 2) {
assign(l, r, x);
} else if (op == 3) {
int64_t ans = kth(l, r, x - 1);
fout, ans, endl;
} else {
assert(op == 4);
int64_t ans = psum(l, r, x, y);
fout, ans, endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
int a[n], i, max = 0, f;
for (i = 0; i < n; i++) scanf("%d", &a[i]);
stack<int> s;
for (i = 0; i < n; i++) {
while (!s.empty()) {
if (s.top() < a[i]) {
f = s.top() ^ a[i];
s.pop();
if (f > max) max = f;
} else {
f = s.top() ^ a[i];
if (f > max) max = f;
break;
}
}
s.push(a[i]);
}
printf("%d", max);
return 0;
}
| 4 |
#include <bits/stdc++.h>
int mat[1000][1000], n, end, snc, syc;
int main() {
FILE *in = fopen("hobbit.in", "r");
scanf("%d", &n);
while (snc <= n) {
end++;
snc += end;
}
snc -= end;
end--;
for (int r = 0; r < end; r++) {
for (int i = r; i < end; i++) {
mat[r][i] = syc + 1;
mat[i + 1][r] = syc + 1;
syc++;
}
}
printf("%d\n", end + 1);
for (int i = 0; i <= end; i++, printf("\n"))
for (int j = 0; j < end; j++) printf("%d ", mat[i][j]);
getchar();
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 10010;
int main() {
int f = 0, g = 0;
for (int i = 0; i <= 9; i++) {
cout << i << "\n";
string s;
getline(cin, s);
if (s == "no") f++;
if (s == "don't touch me!" || s == "great!" || s == "don't think so" ||
s == "not bad" || s == "cool") {
g = 1;
break;
}
if (s == "don't even" || s == "are you serious?" || s == "no way" ||
s == "go die in a hole" || s == "worse" || s == "terrible") {
g = 2;
break;
}
if (f > 3) {
g = 1;
break;
}
}
if (g == 1)
cout << "normal\n";
else
cout << "grumpy\n";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int ans[maxn], num[maxn];
pair<int, int> pr[maxn];
int main() {
int n, i, j, a, mx;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a;
pr[i] = make_pair(a, i + 1);
num[a]++;
}
sort(pr, pr + n);
for (i = 2; i <= 100000; i++)
if (num[i] > num[i - 1]) {
printf("-1");
return 0;
}
mx = 0;
for (i = 0; i < n; i += j) {
for (j = 0; i + j < n && pr[i + j].first == pr[i].first; j++)
ans[pr[i + j].second] = j + 1;
if (j > mx) mx = j;
}
cout << mx << endl;
for (i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-8;
const int INF = 0x3F3F3F3F;
const long long LINF = 4611686018427387903;
const int MOD = 1e9 + 7;
const int MAXN = 2e5 + 9;
signed main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
long long r, w;
cin >> r >> w;
vector<vector<long long>> arr(r, vector<long long>(w));
if (r == 1 && w == 1) return cout << 0 << '\n', 0;
if (w == 1) {
for (long long i = 0; i < r; i++) {
cout << i + 2 << '\n';
}
return 0;
}
for (long long i = 0; i < w; i++) {
arr[0][i] = i + r + 1;
cout << arr[0][i] << ' ';
}
cout << '\n';
for (long long i = 1; i < r; i++) {
for (long long j = 0; j < w; j++) {
arr[i][j] = arr[0][j] * (i + 1);
cout << arr[i][j] << ' ';
}
cout << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC target("sse4,avx")
void printOne(const std::vector<int>& as, int idxOne, int w,
std::ostream& out) {
int sum = std::accumulate(as.begin(), as.end(), 0);
int inside = sum - w;
out << (idxOne + 1) << " ";
for (size_t i = 0; i < as.size(); i++) {
if (i == idxOne) {
continue;
}
for (int j = 0; j < as[i]; j++) {
if (inside == 0) {
out << (idxOne + 1) << " ";
}
out << (i + 1) << " " << (i + 1) << " ";
inside--;
}
}
if (inside == 0) {
out << (idxOne + 1) << " ";
}
}
void run(std::istream& in, std::ostream& out) {
int n, w;
in >> n >> w;
std::vector<int> as(n);
for (int i = 0; i < n; i++) {
in >> as[i];
}
int all = std::accumulate(as.begin(), as.end(), 0);
if (w < 0 || w > all) {
out << "No" << std::endl;
return;
}
if (n == 1) {
if (w != all) {
out << "No" << std::endl;
return;
}
out << "Yes" << std::endl;
for (int i = 0; i < all; i++) {
out << 1 << " " << 1 << " ";
}
out << std::endl;
return;
}
int one = std::distance(as.begin(), std::find(as.begin(), as.end(), 1));
if (one < n) {
if (w < 1) {
out << "No" << std::endl;
return;
}
out << "Yes" << std::endl;
printOne(as, one, w, out);
out << std::endl;
return;
}
if (w < 2) {
out << "No" << std::endl;
return;
}
out << "Yes" << std::endl;
int prev = as[0];
as[0] = 1;
as[1]--;
int all1 = all - prev;
int w1 = std::min(w - 1, all1);
int w2 = w - w1;
printOne(as, 0, w1, out);
std::fill(as.begin(), as.end(), 0);
as[1] = 1;
as[0] = prev - 1;
printOne(as, 1, w2, out);
out << std::endl;
}
int main() {
std::cin.sync_with_stdio(false);
std::cin.tie(nullptr);
run(std::cin, std::cout);
return 0;
}
| 5 |
#include <iostream>
#include <algorithm>
#include <functional>
using namespace std;
bool isstraight(int *n){
for(int i=0;i<4;i++){
if(n[i+1] - n[i] != 1){
if(n[4] == 13 && n[0] == 1 && n[1] == 10 && n[2] == 11 && n[3] == 12){
return true;
}
return false;
}
}
return true;
}
int main(){
int card[5];
char tmp[4];
while(cin >> card[0] >> tmp[0] >> card[1] >> tmp[1] >> card[2] >> tmp[2] >> card[3] >> tmp[3] >> card[4]){
int n[14] = {0};
for(int i=0;i<5;i++){
n[card[i]]++;
}
sort(n,n+14,greater<int>());
sort(card,card+5);
if(isstraight(card)){
cout << "straight" << endl;
}
else{
if(n[0] == 4){
cout << "four card" << endl;
}
else if(n[0] == 3){
if(n[1] == 2){
cout << "full house" << endl;
}
else{
cout << "three card" << endl;
}
}
else if(n[0] == 2){
if(n[1] == 2){
cout << "two pair" << endl;
}
else {
cout << "one pair" << endl;
}
}
else cout << "null" << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int c[105];
int a[105], b[105];
int main() {
cin >> n >> s;
for (int i = 0; i < n; i++) c[i] = s[i] - '0';
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
int ans = 0;
for (int i = 0; i <= 10000; i++) {
int cnt = 0;
for (int j = 0; j < n; j++) {
if (i >= b[j] && (i - b[j]) % a[j] == 0) {
c[j] = 1 - c[j];
}
cnt += c[j];
}
ans = max(ans, cnt);
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[1000005];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
sort(a + 1, a + n + 1);
long long num = 0, k = 0, tmp;
int i = 0;
while (k < 3 && i <= n) {
i++;
tmp = 1;
while (a[i + 1] == a[i]) {
tmp++;
i++;
}
num = 3 - k;
k += tmp;
}
if (num == 1) {
cout << tmp;
} else if (num == 2) {
cout << (tmp * (tmp - 1)) / 2;
} else if (num == 3) {
cout << (tmp * (tmp - 1) * (tmp - 2)) / 6;
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
typedef complex<double> P;
struct S{
P p,q;
S(P p,P q): p(p),q(q) {}
};
P calc(P a,P b,P c,P d){
a-=d;b-=d;c-=d;
return d+a+(b-a)*imag(a/c)/imag(a/c-b/c);
}
P calc( S a, S b){
return calc( a.p , a.q , b.p , b.q );
}
double cross(P a,P b){
return imag( b * conj(a) );
}
double calcArea(P a,P b,P c,P d){
b-=a;c-=a;d-=a;
double res=0;
res+= abs( cross(b,c) )*0.5;
res+= abs( cross(c,d) )*0.5;
return res;
}
int main(){
int n;
while(1){
cin>>n;
if(n==0)break;
vector< P > top,right,left,bottom;
for(int i=0;i<n;i++){
double k;
cin>>k;
bottom.push_back( P(k,0) );
}
for(int i=0;i<n;i++){
double k;
cin>>k;
top.push_back( P(k,1) );
}
for(int i=0;i<n;i++){
double k;
cin>>k;
left.push_back( P(0,k) );
}
for(int i=0;i<n;i++){
double k;
cin>>k;
right.push_back( P(1,k) );
}
vector< S > sh,sw;
sh.push_back( S( P(0,0) , P(0,1) ) );
for(int i=0;i<n;i++){
sh.push_back( S( bottom[i],top[i] ) );
}
sh.push_back( S( P(1,0) , P(1,1) ) );
sw.push_back( S( P(0,0) , P(1,0) ) );
for(int i=0;i<n;i++){
sw.push_back( S( left[i],right[i] ) );
}
sw.push_back( S( P(0,1) , P(1,1) ) );
double ans=-1;
for(int i=0;i<=n;i++){
for(int j=0;j<=n;j++){
P ld = calc( sh[i], sw[j] );
P lu = calc( sh[i+1], sw[j] );
P rd = calc( sh[i], sw[j+1] );
P ru = calc( sh[i+1], sw[j+1] );
ans=max(ans, calcArea(ld,rd,ru,lu) );
}
}
printf("%.6f\n",ans);
}
return 0;
} | 0 |
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
int a[5];
int x,y;
while(cin>>x>>y,x|y){
a[0]=x+y;
for(int i=1;i<5;i++)cin>>x>>y,a[i]=x+y;
int *p=max_element(a,a+5);
cout<<(char)(p-a+'A')<<' '<<*p<<endl;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=2e5+10;
int q[N];
ll h[N],dp[N];
ll calcx(int P,int Q){return h[Q]-h[P];}
ll calcy(int P,int Q){return (dp[Q]+h[Q]*h[Q])-(dp[P]+h[P]*h[P]);}
int main()
{
int n;ll C;scanf("%d%lld",&n,&C);
for (register int i=1;i<=n;++i) scanf("%lld",&h[i]);
int head=1,tail=1;q[1]=1;dp[1]=0;
for (register int i=2;i<=n;++i)
{
while (head<tail&&calcy(q[head],q[head+1])<=2*h[i]*calcx(q[head],q[head+1])) head++;
dp[i]=dp[q[head]]+(h[i]-h[q[head]])*(h[i]-h[q[head]])+C;
while (head<tail&&calcy(q[tail],i)*calcx(q[tail-1],q[tail])<=calcy(q[tail-1],q[tail])*calcx(q[tail],i)) tail--;
q[++tail]=i;
}
printf("%lld\n",dp[n]);
return 0;
} | 0 |
#include <bits/stdc++.h>
void read(int &x) {
x = 0;
int flag = 1;
char ch = ' ';
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= flag;
}
void read(long long &x) {
x = 0;
int flag = 1;
char ch = ' ';
while (ch < '0' || ch > '9') {
if (ch == '-') flag = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= flag;
}
using namespace std;
char s[15];
int n, m;
struct AC_Automaton {
int tot, mod, trie[1010][4], tag[1010], fail[1010];
long long dp[1005][105][11];
AC_Automaton() {
memset(trie, -1, sizeof(trie));
mod = 1e9 + 9;
}
int id(char ch) {
if (ch == 'A') return 0;
if (ch == 'C') return 1;
if (ch == 'G') return 2;
return 3;
}
void add(char *s, int len) {
int u = 0;
for (int i = 1; i <= len; i++)
if (~trie[u][id(s[i])])
u = trie[u][id(s[i])];
else {
trie[u][id(s[i])] = ++tot;
u = tot;
}
tag[u] = len;
}
void build_AC() {
queue<int> q;
fail[0] = 0;
for (int i = 0; i <= 3; i++)
if (~trie[0][i]) {
fail[trie[0][i]] = 0;
q.push(trie[0][i]);
} else
trie[0][i] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
tag[u] = max(tag[u], tag[fail[u]]);
for (int i = 0; i <= 3; i++)
if (~trie[u][i]) {
fail[trie[u][i]] = trie[fail[u]][i];
q.push(trie[u][i]);
} else
trie[u][i] = trie[fail[u]][i];
}
}
long long DP() {
dp[0][0][0] = 1;
for (int i = 0; i <= n - 1; i++)
for (int j = 0; j <= tot; j++)
for (int k = 0; k <= 10; k++) {
if (dp[i][j][k] == 0) continue;
for (int l = 0; l <= 3; l++) {
int tmp = trie[j][l];
if (tag[tmp] > k)
dp[i + 1][tmp][0] = (dp[i + 1][tmp][0] + dp[i][j][k]) % mod;
else if (k + 1 <= 10)
dp[i + 1][tmp][k + 1] =
(dp[i + 1][tmp][k + 1] + dp[i][j][k]) % mod;
}
}
long long ret = 0;
for (int i = 0; i <= tot; i++) ret = (ret + dp[n][i][0]) % mod;
return ret;
}
} ac;
int main() {
read(n), read(m);
for (int i = 1; i <= m; i++) {
scanf("%s", s + 1);
int len = strlen(s + 1);
ac.add(s, len);
}
ac.build_AC();
printf("%lld\n", ac.DP());
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
typedef pair<ll,ll> P;
#define M 1000000007
int main(){
ll n;
cin>>n;
vector<ll> a(n);
bool f=true;
for(int i=0;i<n;i++){
cin>>a[i];
if(a[i]<0){f=!f;a[i]*=-1;}
}
ll c=0;
sort(a.begin(),a.end());
for(int i=1;i<n;i++) c+=a[i];
if(f) cout<<c+a[0];
else cout<<c-a[0];
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int a[5][5];
bool f[5][5];
int main()
{
int n,i,j,x;
for(i=1;i<4;i++)
for(j=1;j<4;j++)
cin>>a[i][j];
cin>>n;
while(n--)
{
cin>>x;
for(i=1;i<4;i++)
for(j=1;j<4;j++)
if(a[i][j]==x)
f[i][j]=true;
}
if(f[1][1]&&f[1][2]&&f[1][3]||f[2][1]&&f[2][2]&&f[2][3]||f[3][1]&&f[3][2]&&f[3][3]||f[1][1]&&f[2][1]&&f[3][1]||f[1][2]&&f[2][2]&&f[3][2]||f[1][3]&&f[2][3]&&f[3][3]||f[1][1]&&f[2][2]&&f[3][3]||f[1][3]&&f[2][2]&&f[3][1])
cout<<"Yes";
else
cout<<"No";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e3 + 5;
long long A[N][N], ID[N][N], IND[N][N], n, m, k, q, l, r, x, y, xx, yy, w,
ST[N];
long long rt;
char s[N];
struct fen {
long long D[N];
inline fen() { memset(D, 0, sizeof(D)); }
void add(long long ind, long long d) {
for (ind++; ind < N; ind += ind & -ind) D[ind] += d;
}
long long get(long long ind) {
return (!ind ? 0 : D[ind] + get(ind -= ind & -ind));
}
long long get(long long l, long long r) { return (get(r + 1) - get(l)); }
};
struct gar {
fen f;
long long x, y, ln;
long long sm = 0;
} G[N];
int32_t main() {
fill(ST, ST + N, 1);
scanf("%d %d %d", &n, &m, &k);
for (long long i = 1; i <= k; i++) {
scanf("%lld", &G[i].ln);
for (long long j = 0; j < G[i].ln; j++) {
scanf("%lld %ld %lld", &x, &y, &w);
G[i].sm += w;
A[x][y] = w, ID[x][y] = i, IND[x][y] = j;
G[i].f.add(j, w);
}
G[i].x = x, G[i].y = y;
}
scanf("%lld", &q);
for (long long Q = 0; Q < q; Q++) {
scanf("%s", s);
if (s[0] == 'S') {
scanf("%lld", &x), ST[x] ^= 1;
continue;
}
scanf("%lld %lld %lld %lld", &x, &y, &xx, &yy);
vector<pair<long long, bool> > v[N];
for (long long i = x; i <= xx; i++) {
if (ID[i][y] && ID[i][y] == ID[i][y - 1]) {
if (IND[i][y] + 1 == IND[i][y - 1])
v[ID[i][y]].push_back({IND[i][y], 1});
else if (IND[i][y] - 1 == IND[i][y - 1])
v[ID[i][y]].push_back({IND[i][y], 0});
}
if (ID[i][yy] && ID[i][yy] == ID[i][yy + 1]) {
if (IND[i][yy] + 1 == IND[i][yy + 1])
v[ID[i][yy]].push_back({IND[i][yy], 1});
else if (IND[i][yy] - 1 == IND[i][yy + 1])
v[ID[i][yy]].push_back({IND[i][yy], 0});
}
}
for (long long i = y; i <= yy; i++) {
if (ID[x][i] && ID[x][i] == ID[x - 1][i]) {
if (IND[x][i] + 1 == IND[x - 1][i])
v[ID[x][i]].push_back({IND[x][i], 1});
else if (IND[x][i] - 1 == IND[x - 1][i])
v[ID[x][i]].push_back({IND[x][i], 0});
}
if (ID[xx][i] && ID[xx][i] == ID[xx + 1][i]) {
if (IND[xx][i] + 1 == IND[xx + 1][i])
v[ID[xx][i]].push_back({IND[xx][i], 1});
else if (IND[xx][i] - 1 == IND[xx + 1][i])
v[ID[xx][i]].push_back({IND[xx][i], 0});
}
}
rt = 0;
for (long long i = 1; i <= k; i++)
if (ST[i]) {
sort(v[i].begin(), v[i].end());
if (v[i].empty()) {
if (G[i].x >= x && G[i].x <= xx && G[i].y >= y && G[i].y <= yy)
rt += G[i].sm;
continue;
}
if (v[i][0].second) rt += G[i].f.get(0, v[i][0].first);
if (v[i].back().second == 0) v[i].push_back({G[i].ln - 1, 1});
for (long long j = (long long)v[i].size() & 1;
j < (long long)v[i].size(); j += 2) {
rt += G[i].f.get(v[i][j].first, v[i][j + 1].first);
}
}
printf("%lld\n", rt);
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int cnt[1000010];
vector<int> edge[1000010];
int n, m, odd;
bool vis[1000010];
void DFS(int now) {
if (cnt[now] % 2 == 1) odd++;
int i, lm = cnt[now];
for (i = 0; i < lm; i++) {
int ti = edge[now][i];
if (!vis[ti]) {
vis[ti] = true;
DFS(ti);
}
}
}
void go() {
int i, gp = 0;
memset(vis, false, sizeof(vis));
int extra = 0, all = 0;
for (i = 1; i <= n; i++) {
if (!vis[i] && (i == 1 || cnt[i] != 0)) {
gp++;
vis[i] = true;
odd = 0;
DFS(i);
if (odd != 0) {
all += odd / 2;
extra++;
}
}
}
if (gp > 1) {
all += gp;
printf("%d\n", all - extra);
} else {
printf("%d\n", all);
}
}
int main() {
while (~scanf("%d%d", &n, &m)) {
int i;
for (i = 1; i <= m; i++) {
int xi, yi;
scanf("%d%d", &xi, &yi);
edge[xi].push_back(yi);
edge[yi].push_back(xi);
cnt[xi]++;
cnt[yi]++;
}
go();
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200500];
int mrc[200500];
void dfs(int a) {
mrc[a] = 1;
for (int i = 0; i < v[a].size(); i++) {
if (mrc[v[a][i]] == 0) dfs(v[a][i]);
}
}
int main(void) {
int n;
scanf("%d", &n);
memset(mrc, 0, sizeof(int) * 200500);
int x;
for (int i = 1; i <= n; i++) {
scanf("%d", &x);
v[i].push_back(x);
}
long long int ch = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &x);
ch += (long long int)x;
}
long long int qt = 0;
for (int i = 1; i <= n; i++) {
if (mrc[i] == 0) {
qt++;
dfs(i);
}
}
long long int ans;
if (qt == 1)
ans = 0;
else
ans = qt;
if (ch % 2 == 0) ans++;
cout << ans << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i, x, y) for (int i = x; i <= y; i++)
#define per(i, x, y) for (int i = x; i >= y; i--)
using namespace std;
const int N = 1e5 + 10;
typedef long long ll;
ll n, m, K, pos[N], a[N], b[N], vis[N], p[N], ans[N];
int main() {
cin >> n;
rep(i, 1, n) scanf("%lld", &pos[i]), b[i] = i;
per(i, n, 1) pos[i] -= pos[i - 1];
cin >> m >> K;
rep(i, 1, m) scanf("%lld", &a[i]), swap(b[a[i]], b[a[i] + 1]);
rep(i, 1, n) if (!vis[i]) {
int cnt = 0;
int j = i;
for (; !vis[j]; j = b[j]) {
vis[j] = 1;
p[++cnt] = j;
}
rep(j, 1, cnt) ans[p[j]] = pos[p[(j + K % cnt - 1) % cnt + 1]];
}
rep(i, 1, n) ans[i] += ans[i - 1], printf("%lld.0\n", ans[i]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, a[2005], b[2005], n1, n2, f[2][2005][13], g[2][2005][13],
c[2005][2005], pw[2005], t;
long long calc(long long n, long long m) {
if (m == 0) return (n == 0);
return pw[n] * c[n + m - 1][m - 1] % 998244353;
}
signed main() {
pw[0] = 1;
c[0][0] = 1;
for (long long i = 1; i <= 2000; i++)
pw[i] = pw[i - 1] * i % 998244353, c[i][0] = 1;
for (long long i = 1; i <= 2000; i++)
for (long long j = 1; j <= 2000; j++)
c[i][j] = (c[i - 1][j] + c[i - 1][j - 1]) % 998244353;
scanf("%lld", &t);
while (t--) {
scanf("%lld", &n);
n1 = n2 = 0;
for (long long i = 1; i <= n; i++) {
long long x, p = 0;
scanf("%lld", &x);
for (long long j = x; j; j /= 10) p ^= 1;
if (p)
a[++n1] = x % 11;
else
b[++n2] = x % 11;
}
memset(f, 0, sizeof f), memset(g, 0, sizeof g);
f[0][0][0] = g[0][0][0] = 1;
for (long long i = 1; i <= n1; i++) {
memset(f[i & 1], 0, sizeof f[i & 1]);
for (long long j = 0; j <= i; j++)
for (long long k = 0; k < 11; k++) {
long long p = (k - a[i] + 11) % 11, q = (k + a[i]) % 11;
f[i & 1][j][k] = (f[i & 1][j][k] + f[(i - 1) & 1][j][p]) % 998244353;
if (j)
f[i & 1][j][k] =
(f[i & 1][j][k] + f[(i - 1) & 1][j - 1][q]) % 998244353;
}
}
for (long long i = 1; i <= n2; i++) {
memset(g[i & 1], 0, sizeof g[i & 1]);
for (long long j = 0; j <= i; j++)
for (long long k = 0; k < 11; k++) {
long long p = (k - b[i] + 11) % 11, q = (k + b[i]) % 11;
g[i & 1][j][k] = (g[i & 1][j][k] + g[(i - 1) & 1][j][p]) % 998244353;
if (j)
g[i & 1][j][k] =
(g[i & 1][j][k] + g[(i - 1) & 1][j - 1][q]) % 998244353;
}
}
long long ans = 0;
for (long long i = 0; i <= n2; i++)
for (long long j = 0; j < 11; j++) {
ans = (ans + g[n2 & 1][i][j] * f[n1 & 1][n1 / 2][(11 - j) % 11] %
998244353 * pw[n1 / 2] % 998244353 * pw[n1 - n1 / 2] %
998244353 * calc(i, n1 - n1 / 2) % 998244353 *
calc(n2 - i, n1 / 2 + 1) % 998244353) %
998244353;
}
printf("%lld\n", ans);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
vector<int> vals;
int spares[1005];
vector<pair<int, int> > edges;
int main() {
int N;
cin >> N;
for (int i = 1; i < N; i++) {
int x, y;
cin >> x >> y;
if (x == N) {
int t = y;
y = x;
x = t;
}
if (x == N || y != N) {
cout << "NO" << endl;
return 0;
}
vals.push_back(x);
}
sort(vals.begin(), vals.end());
int lo = 0;
int hi = 0;
int last = 1;
for (int i = 0; i < N - 1; i++) {
int path = 0;
while (i + 1 < N - 1 && vals[i] == vals[i + 1]) {
i++;
path++;
}
if (vals[i] < i + 1) {
cout << "NO" << endl;
return 0;
}
while (last < vals[i]) {
spares[hi++] = last++;
}
last = vals[i] + 1;
int start = N;
for (int k = 0; k < path; k++) {
int v = spares[lo++];
edges.push_back({start, v});
start = v;
}
edges.push_back({start, vals[i]});
}
cout << "YES" << endl;
for (int i = 0; i < N - 1; i++) {
cout << edges[i].first << " " << edges[i].second << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = (2e4)+1;
int n, p[MAX], b[MAX];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for(int i = 1; i <= n; i++) cin >> p[i];
b[p[1]] = n*n;
for(int i = 2; i <= n; i++) b[p[i]] = b[p[i-1]]-n*(p[i]-p[i-1])+1;
for(int i = 1; i <= n; i++) cout << n*i << ' ';
cout << endl;
for(int i = 1; i <= n; i++) cout << b[i] << ' ';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int M = 1507;
const long long mod = 1e9 + 7;
const long double esl = 1e-5;
int t[M];
int n;
int a[M];
void swapp(int l, int r) {
for (int i = 0; i <= (r - l) / 2; i++) swap(a[i + l], a[r - i]);
}
int getBIT(int m) {
int result = 0;
for (; m > 0; m &= m - 1) {
result += t[m];
}
return result;
}
void updateBIT(int m, int value) {
for (; m <= n; m += m & -m) {
t[m] += value;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int kq = 0;
for (int i = 0; i <= n; i++) t[i] = 0;
for (int i = n; i >= 1; i--) {
kq += getBIT(a[i]);
updateBIT(a[i] + 1, 1);
}
bool x = kq & 1;
int m, l, r;
cin >> m;
while (m--) {
cin >> l >> r;
int t = r - l + 1;
t = t * (t - 1) / 2;
if (t & 1) x = !x;
if (x & 1)
cout << "odd\n";
else
cout << "even\n";
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100001], g[100001], h[100001], m;
set<int> events[100001];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) events[i].clear();
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), events[a[i]].insert(i);
m = 0;
bool ok = true;
for (int i = 1; i <= n; ++i)
if (!events[i].empty())
if (events[i].find(i) == events[i].end()) {
ok = false;
break;
}
if (!ok) {
printf("-1\n");
return 0;
}
for (int i = 1; i <= n; i++)
if (!events[i].empty()) {
h[++m] = i;
for (set<int>::iterator itr = events[i].begin(); itr != events[i].end();
++itr)
g[*itr] = m;
}
printf("%d\n", m);
for (int i = 1; i <= n; i++) printf("%d ", g[i]);
printf("\n");
for (int i = 1; i <= m; i++) printf("%d ", h[i]);
printf("\n");
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long mod = 998244353;
long long perm(int a) {
long long ret = 1;
for (int i = 1; i <= a; i++) {
ret *= i;
ret %= mod;
}
return ret;
}
int main() {
int n;
long long rez = 1, cr = 1, rc = 1, cc = 1;
cin >> n;
rez = perm(n);
vector<pair<int, int> > a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].first >> a[i].second;
}
sort(a.begin(), a.end());
for (int i = 0, j = 0; i < n; i = j) {
for (j = i; j < n && a[i].first == a[j].first; j++)
;
int sz = j - i;
cr *= perm(sz);
cr %= mod;
}
for (int i = 0; i < n; i++) {
swap(a[i].first, a[i].second);
}
sort(a.begin(), a.end());
for (int i = 0, j = 0; i < n; i = j) {
for (j = i; j < n && a[i].first == a[j].first; j++)
;
int sz = j - i;
rc *= perm(sz);
rc %= mod;
}
for (int i = 0, j = 0; i < n; i = j) {
for (j = i; j < n && a[i] == a[j]; j++)
;
int sz = j - i;
cc *= perm(sz);
cc %= mod;
}
for (int i = 1; i < n; i++) {
if (a[i].second < a[i - 1].second) cc = 0;
}
rez = (rez - cr - rc + cc) % mod;
rez += mod;
rez %= mod;
cout << rez;
}
| 4 |
#include <cstdio>
#include <vector>
static const int MAXN = 1e5 + 4;
static const int LOGN = 18;
int n;
std::vector<int> e[MAXN];
int ans = 0;
int f[MAXN];
void dfs_dp(int u, int p = -1)
{
int mask = 0, label = 0;
for (int v : e[u]) if (v != p) {
dfs_dp(v, u);
for (int i = label + 1; i < LOGN; ++i)
if ((f[v] & (1 << i)) && (mask & (1 << i))) label = i;
mask |= f[v];
}
//int label = 8 * sizeof(int) - __builtin_clz(f[u]) - 1;
while (mask & (1 << label)) ++label;
f[u] = (1 << label);
for (int i = label + 1; i < LOGN; ++i)
if (mask & (1 << i)) f[u] |= (1 << i);
if (ans < label) ans = label;
}
int main()
{
scanf("%d", &n);
int u, v;
for (int i = 0; i < n - 1; ++i) {
scanf("%d%d", &u, &v); --u, --v;
e[u].push_back(v);
e[v].push_back(u);
}
dfs_dp(0);
printf("%d\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
const int M = 100005;
const int N = 2005;
const int MOD = (int)1e9 + 7;
int r[N], c[N], vt[N];
long long f[N];
long long gt[M * 2], igt[M * 2];
bool compare(int i, int j) {
return r[i] < r[j] || (r[i] == r[j] && c[i] < c[j]);
}
long long tru(long long a, long long b) {
if (a < b)
return a - b + MOD;
else
return a - b;
}
long long power(long long a, int b) {
if (b == 0) return 1LL;
if (b == 1) return a;
long long tmp = power(a, b >> 1);
tmp = tmp * tmp % MOD;
if (b & 1)
return tmp * a % MOD;
else
return tmp;
}
void init(int n) {
gt[0] = 1;
igt[0] = 1;
for (int i = 1; i <= n; i++) {
gt[i] = gt[i - 1] * i % MOD;
igt[i] = power(gt[i], MOD - 2);
}
}
long long calc(int x, int y, int xx, int yy) {
y = xx - x + yy - y;
x = xx - x;
return (gt[y] * igt[x] % MOD * igt[y - x] % MOD);
}
int main() {
int h, w, n;
scanf("%d%d%d", &h, &w, &n);
init(h + w);
for (int i = 0; i < n; i++) {
scanf("%d%d", r + i, c + i);
vt[i] = i;
}
r[n] = h;
c[n] = w;
vt[n] = n;
n++;
std::sort(vt, vt + n, compare);
f[0] = calc(1, 1, r[vt[0]], c[vt[0]]);
for (int i = 1; i < n; i++) {
f[i] = 0;
for (int j = 0; j < i; j++)
if (r[vt[j]] <= r[vt[i]] && c[vt[j]] <= c[vt[i]]) {
long long tmp = calc(r[vt[j]], c[vt[j]], r[vt[i]], c[vt[i]]);
tmp = tmp * f[j] % MOD;
f[i] = (f[i] + tmp) % MOD;
}
f[i] = tru(calc(1, 1, r[vt[i]], c[vt[i]]), f[i]);
}
printf("%I64d\n", f[n - 1]);
return 0;
}
| 3 |
#include <iostream>
#include <vector>
#include <queue>
#include <cstdio>
#include <algorithm>
using namespace std;
int DP[60][30][60][30], w, h;
const int INF = (1e9);
char S[60][30];
struct state{int lx, ly, rx, ry;};
bool operator<(const state &x, const state &y){ return x.lx < y.lx;}
bool in_range(int a, int b){ return a >= 0 && a < b;}
int solve(){
priority_queue< pair<int, state> > wait;
for(int i = 0; i < h; ++i){
for(int j = 0; j < w; ++j){
if(S[i][j] == 'S'){
wait.emplace(0,(state){i,j,-1,-1});
wait.emplace(0,(state){-1,-1,i,j});
}
}
}
while(!wait.empty()){
state s = wait.top().second;
int t = -wait.top().first, lx = s.lx, ly = s.ly, rx = s.rx, ry = s.ry;
wait.pop();
//printf("%d %d %d %d %d\n",lx,ly,rx,ry,t);
if(lx >= 0 && rx >= 0 && DP[s.lx][s.ly][s.rx][s.ry] < t) continue;
if(lx >= 0 && ly >= 0){
for(int i = -2; i < 3; ++i){
for(int j = 0; j < 3; ++j){
int rx_ = lx + i, ry_ = ly + j + 1;
if((!in_range(rx_,h)) || (!in_range(ry_,w)) ||
(abs(j)+abs(i) > 2) || (S[rx_][ry_] == 'X')) continue;
int t_;
if(S[rx_][ry_] > '9' || S[rx_][ry_] < '0') t_ = t;
else t_ = t + S[rx_][ry_] - '0';
if(t_ >= DP[lx][ly][rx_][ry_]) continue;
DP[lx][ly][rx_][ry_] = t_;
wait.emplace(-t_,(state){lx,ly,rx_,ry_});
}
}
}
if(rx >= 0 && ry >= 0){
for(int i = -2; i < 3; ++i){
for(int j = 0; j < 3; ++j){
int lx_ = rx + i, ly_ = ry - j - 1;
if((!in_range(lx_,h)) || (!in_range(ly_,w)) ||
(abs(j)+abs(i) > 2) || (S[lx_][ly_] == 'X')) continue;
int t_;
if(S[lx_][ly_] > '9' || S[lx_][ly_] < '0') t_ = t;
else t_ = t + S[lx_][ly_] - '0';
if(t_ >= DP[lx_][ly_][rx][ry]) continue;
DP[lx_][ly_][rx][ry] = t_;
wait.emplace(-t_,(state){lx_,ly_,rx,ry});
}
}
}
}
// cout << "while loop finished" << endl;
int ret = INF;
for(int i = 0; i < h; ++i){
for(int j = 0; j < w; ++j){
if(S[i][j] != 'T') continue;
for(int k = 0; k < h; ++k)
for(int l = 0; l < w; ++l)
ret = min({ret, DP[i][j][k][l], DP[k][l][i][j]});
}
}
return ret;
}
int main(){
while(cin >> w >> h, w){
for(int i = 0; i < h; ++i)
for(int j = 0; j < w; ++j)
cin >> S[i][j];
for(int i = 0; i < h; ++i)
for(int j = 0; j < w; ++j)
for(int k = 0; k < h; ++k)
for(int l = 0; l < w; ++l)
DP[i][j][k][l] = INF;
int ans = solve();
if(ans >= INF) ans = -1;
cout << ans << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC optimize(2)
#pragma GCC optimize(3)
using namespace std;
const int N = 300005;
int n, m, s, num, sz[N];
long long ans;
struct node {
int x, y, r;
} d[N];
pair<int, int> q[N * 10];
vector<pair<int, int> > b[N], c[N];
map<pair<pair<int, int>, int>, int> a;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + (ch ^ 48), ch = getchar();
return f ? x : -x;
}
inline int gcd(int a, int b) {
while (b) {
int x = a;
a = b, b = x % b;
}
return a;
}
int main() {
n = read(), m = read();
for (int i = 1; i <= n; i++) {
int x = read(), y = read(), u = read(), v = read(), g;
pair<pair<int, int>, int> z =
make_pair(make_pair(y - v, u - x), x * v - u * y);
g = gcd(gcd(z.first.first, z.first.second), z.second);
if (z.first.first / g < 0 || !z.first.first && z.first.second / g < 0)
g = -g;
z.first.first /= g, z.first.second /= g, z.second /= g;
if (!a[z]) a[z] = ++num;
if (x == u) swap(x, y), swap(u, v);
if (x > u) swap(x, u);
g = a[z], b[g].push_back(make_pair(x * 2, 0)),
b[g].push_back(make_pair(u * 2, 0)),
c[g].push_back(make_pair(x * 2, u * 2));
}
for (int i = 1; i <= m; i++) {
d[i].x = read(), d[i].y = read(), d[i].r = read();
for (int j = 1; j < i; j++) {
if (d[i].r != d[j].r ||
d[i].r * d[i].r * 4 >= (d[i].x - d[j].x) * (d[i].x - d[j].x) +
(d[i].y - d[j].y) * (d[i].y - d[j].y))
continue;
pair<pair<int, int>, int> z =
make_pair(make_pair((d[i].x - d[j].x) * 2, (d[i].y - d[j].y) * 2),
d[j].x * d[j].x + d[j].y * d[j].y - d[i].x * d[i].x -
d[i].y * d[i].y);
int g = gcd(gcd(z.first.first, z.first.second), z.second), x;
if (z.first.first / g < 0 || !z.first.first && z.first.second / g < 0)
g = -g;
z.first.first /= g, z.first.second /= g, z.second /= g, g = a[z];
if (!g) continue;
if (d[i].y == d[j].y)
x = d[i].y * 2;
else
x = d[i].x + d[j].x;
b[g].push_back(make_pair(x, 0)), q[++s] = make_pair(g, x);
}
}
for (int i = 1; i <= num; i++) {
sort(b[i].begin(), b[i].end()),
sz[i] = unique(b[i].begin(), b[i].end()) - b[i].begin();
for (int j = c[i].size() - 1; j >= 0; j--) {
b[i][lower_bound(b[i].begin(), b[i].begin() + sz[i],
make_pair(c[i][j].first, -n)) -
b[i].begin()]
.second++;
if (c[i][j].second != b[i][sz[i] - 1].first)
b[i][lower_bound(b[i].begin(), b[i].begin() + sz[i],
make_pair(c[i][j].second, -n)) -
b[i].begin() + 1]
.second--;
}
for (int j = 1; j < sz[i]; j++) b[i][j].second += b[i][j - 1].second;
}
for (int i = 1; i <= s; i++) {
int g = q[i].first, x = q[i].second;
ans += (*lower_bound(b[g].begin(), b[g].begin() + sz[g], make_pair(x, -n)))
.second;
}
printf("%lld", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
const int MAXN = 300010;
const int INF = 0x3f3f3f3f;
struct Tree {
int tree[MAXN << 2];
void modify(int u, int l, int r, int tar, int v) {
if (l == r) return (void)(tree[u] = v);
int mid = l + r >> 1;
if (tar <= mid)
modify(u << 1, l, mid, tar, v);
else
modify(u << 1 | 1, mid + 1, r, tar, v);
tree[u] = std::max(tree[u << 1], tree[u << 1 | 1]);
}
int query(int u, int l, int r, int L, int R) {
if (L <= l && r <= R) return tree[u];
int mid = l + r >> 1, res = -INF;
if (L <= mid) res = std::max(res, query(u << 1, l, mid, L, R));
if (mid < R) res = std::max(res, query(u << 1 | 1, mid + 1, r, L, R));
return res;
}
void print(int u, int l, int r, int R) {
if (l == r) {
printf("%d%c", tree[u], " \n"[r == R]);
return;
}
int mid = l + r >> 1;
print(u << 1, l, mid, R);
print(u << 1 | 1, mid + 1, r, R);
}
} tval, tt2;
int n, m, hi[MAXN], hiat[MAXN * 2 + 5];
std::set<int> trees;
int li[20], bak;
int main() {
std::cin >> n >> m;
const int R = m + 21;
for (int T = 1; T <= m; ++T) {
int opt, at, hs;
std::cin >> opt >> at;
if (opt == 1) {
std::cin >> hs;
hs += m - T + 10;
hiat[hi[at] = hs] = at;
trees.insert(at);
for (int i = hs; i >= hs - 10; --i)
if (int r = hiat[i]) {
tt2.modify(1, 1, R, i, 0);
tval.modify(1, 1, n, r, 0);
}
for (int i = hs; i >= hs - 10; --i)
if (int r = hiat[i]) {
int v = r + 1 <= n ? tval.query(1, 1, n, r + 1, n) : 0;
tval.modify(1, 1, n, r, ++v);
tt2.modify(1, 1, R, i, v);
}
} else {
bak = 0;
auto t = trees.begin();
while (at-- > 0) {
li[++bak] = *t;
if (at != 0) ++t;
}
trees.erase(t);
for (int i = 1; i <= bak; ++i) {
tt2.modify(1, 1, R, hi[li[i]], 0);
tval.modify(1, 1, n, li[i], 0);
}
for (int i = bak - 1; i; --i) {
int v = tt2.query(1, 1, R, hi[li[i]] + 1, R) + 1;
tt2.modify(1, 1, R, hi[li[i]], v);
tval.modify(1, 1, n, li[i], v);
}
hiat[hi[li[bak]]] = 0;
hi[li[bak]] = 0;
}
std::cout << tval.tree[1] << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, ar[1000][100];
int mt[10000];
int l = 0, sure, count = 0;
cin >> n >> m >> k;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> ar[i][j];
}
}
if (k == 0) {
for (int i = m - 1; i >= 0; i--) {
for (int j = 0; j < i; j++) {
sure = 0;
for (int k = 0; k < n; k++) {
if (ar[k][j] > ar[k][i]) {
sure = 1;
swap(ar[k][j], ar[k][i]);
}
}
if (sure) {
count++;
mt[l] = j + 1;
l++;
mt[l] = i + 1;
l++;
}
}
}
} else {
for (int i = m - 1; i >= 0; i--) {
for (int j = 0; j < i; j++) {
sure = 0;
for (int k = 0; k < n; k++) {
if (ar[k][j] < ar[k][i]) {
sure = 1;
swap(ar[k][j], ar[k][i]);
}
}
if (sure) {
count++;
mt[l] = i + 1;
l++;
mt[l] = j + 1;
l++;
}
}
}
}
cout << count << endl;
for (int i = 0; i < l; i++) {
cout << mt[i] << " ";
i++;
cout << mt[i] << "\n";
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, *x, id, vis[2001][2001], m;
bool dp[2001][2001];
vector<int> v;
bool solve(int i = 0, int sum = 0) {
if (sum == n) return 1;
if (i == m) return 0;
bool &ret = dp[i][sum];
if (vis[i][sum] == id) return ret;
vis[i][sum] = id;
return ret = solve(i + 1, sum + v[i]) || solve(i + 1, sum);
}
int main() {
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
id++;
cin >> n;
x = new int[2 * n];
for (int i = 0; i < 2 * n; i++) cin >> x[i];
for (int i = 2 * n; i;) {
int mx = 0;
for (int j = 1; j < i; j++)
if (x[j] > x[mx]) mx = j;
v.push_back(i - mx);
i = mx;
}
m = v.size();
cout << (solve() ? "YES" : "NO") << '\n';
delete[] x;
v.clear();
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
ll n, x, y;
vector<pair<ll, ll>> v;
scanf("%lld", &n);
for(ll i = 0; i< n; i++){
scanf("%lld %lld", &x, &y);
v.push_back(make_pair(x, y));
}
sort(v.begin(), v.end());
for(auto i = v.begin(); i != v.end(); i++){
printf("%lld %lld\n", i->first, i->second);
}
return 0;
}
| 0 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(void){
vector<int> v;
int flg;
for (int i=0; i<12; i++){
int t;
cin >> t;
v.push_back(t);
}
sort(v.begin(), v.end());
flg = true;
for (int i=0; i<3; i++){
for (int j=0; j<3; j++){
if (v[j*4+i]!=v[j*4+i+1]) flg = false;
}
}
cout << (flg?"yes":"no") << endl;
return 0;
}
| 0 |
#include<iostream>
using namespace std;
int main()
{
while (true){
int n;
cin >> n;
if (!n) break;
for (int i = 0; i < n; i++){
int pm, pe, pj;
cin >> pm >> pe >> pj;
if (pm == 100 || pe == 100 || pj == 100 || (pm + pe) / 2 >= 90 || (pm + pe + pj) / 3 >= 80) cout << "A" << endl;
else if ((pm + pe + pj) / 3 >= 70 || ((pm + pe + pj) / 3 >= 50) && (pm >= 80 || pe >= 80)) cout << "B" << endl;
else cout << "C" << endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool comp(long long a, long long b) { return a > b; }
std::vector<long long> fac(500000);
void pre() {
fac[0] = 1;
for (int i = 1; i < 500000; i++) {
fac[i] = i * fac[i - 1];
fac[i] %= 998244353;
}
}
long long power(long long x, long long y, long long p) {
long long 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 modInverse(long long n, long long p) { return power(n, p - 2, p); }
long long nCrModPFermat(long long n, long long r) {
if (n <= 0 || n < r) return 0;
if (r == 0) return 1;
long long a = (fac[n] * modInverse(fac[r], 998244353) % 998244353 *
modInverse(fac[n - r], 998244353) % 998244353) %
998244353;
return a;
}
void solve() {
long long k, x, y, n;
cin >> n >> k;
std::vector<pair<long long, long long>> ar;
long long ans = 0;
for (int i = 0; i < n; i++) {
long long l, r;
cin >> l >> r;
ar.push_back(make_pair(l, r));
}
if (k == 1) {
cout << n << "\n";
return;
}
sort(ar.begin(), ar.end());
multiset<long long> q;
long long cnt;
for (int i = 0; i < n; i++) {
while (!q.empty() && *q.begin() < ar[i].first) {
q.erase(q.begin());
}
cnt = q.size();
ans += (nCrModPFermat(cnt, k - 1));
ans %= 998244353;
q.insert(ar[i].second);
}
cout << ans << "\n";
}
int main() {
pre();
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int t = 1;
while (t--) solve();
return 0;
}
| 4 |
#include"bits/stdc++.h"
#include"math.h"
using namespace std;
int main(){
int a;scanf("%d",&a);
int L=a/100;
int R=a%100;
if(1<=L&&L<=12){
if(1<=R&&R<=12)printf("AMBIGUOUS\n");
else printf("MMYY\n");
}else{
if(1<=R&&R<=12)printf("YYMM\n");
else printf("NA\n");
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, m;
cin >> n >> m;
cout << (24 - n) * 60 - m << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int car[n];
for (int i = 0; i < n; i++) {
car[i] = 2;
}
int temp;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> temp;
if (temp == 1) {
car[i] = 1;
} else if (temp == 2) {
car[j] = 1;
} else if (temp == 3) {
car[i] = 1;
car[j] = 1;
}
}
}
int count = 0;
for (int i = 0; i < n; i++) {
if (car[i] == 2) {
count++;
}
}
cout << count << endl;
for (int i = 0; i < n; i++) {
if (car[i] == 2) {
cout << i + 1 << " ";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
long long t;
t = 1;
while (t--) {
long long n, q;
cin >> n >> q;
long long a[n + 1];
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
long long ans = 0, sum = 0;
while (q--) {
long long l, r;
cin >> l >> r;
for (int i = l; i <= r; i++) {
sum += a[i];
}
if (sum > 0) {
ans += sum;
sum = 0;
} else {
sum = 0;
}
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int n;
string tmp;
while (cin >> n, n) {
vector<string> v;
v.reserve(n);
for (int i = 0; i < n; i++) {
cin >> tmp;
v.push_back(tmp);
}
int del = 0;
int flag = 0;
while (flag != 5) {
flag = 0;
int length = 0;
for (int i = del;i < v.size();i++) {
length += v[i].size();
if (length == 5 || length == 12 || length == 17 || length == 24 || length == 31)
flag++;
}
del++;
}
cout << del << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool isp(long long x) {
if (x <= 1) return false;
for (long long j = 2; j * j <= x; j++)
if (x % j == 0) return false;
return true;
}
int main(void) {
ios::sync_with_stdio(false);
long long n;
cin >> n;
if (isp(n))
cout << "1\n";
else if (n % 2 == 0)
cout << "2\n";
else {
if (isp(n - 2))
cout << "2\n";
else
cout << "3\n";
}
return 0;
}
| 2 |
#include <iostream>
#include <utility>
#include <algorithm>
#include <string>
#include <vector>
#include <cstdio>
#include <cmath>
typedef long long int ll;
using namespace std;
string s;
bool is_agari_s(vector<int> h,int len);
bool is_agari_k(vector<int> h,int len);
bool is_agari_k(vector<int> h,int len){//koutu
if(len==0)return true;
for(int i=0; i<len-2; i++){
if(h[i]==h[i+1]&&h[i+1]==h[i+2]){
vector<int> h2;
for(int j=0; j<len; j++){
h2.push_back(h[j]);
if(j==i||j==i+1||j==i+2){
h2.pop_back();
}
}
return (is_agari_k(h2,len-3)||is_agari_s(h2,len-3));
}
}
return false;
}
bool is_agari_s(vector<int> h,int len){//shuntu
if(len==0)return true;
for(int i=0; i<len-2; i++){
for(int j=i; j<len-1; j++){
if(h[j]==h[i]+1){
for(int k=j; k<len; k++){
if(h[k]==h[j]+1){
vector<int> h2;
for(int l=0; l<len; l++){
h2.push_back(h[l]);
if(l==i||l==j||l==k){
h2.pop_back();
}
}
return (is_agari_k(h2,len-3)||is_agari_s(h2,len-3));
}
}
}
}
}
return false;
}
int main(){
while(cin>>s){
vector<char> t(14,0);
vector<int> cnt(10,0);
for(int j=0; j<13; j++){
t[j]=s[j]-'0';
cnt[t[j]]+=1;
}
bool zeflag=true;
bool spflag=false;
for(int i=1; i<=9; i++){//agarihai=i;
if(cnt[i]>=4)continue;
for(int k=1; k<=9; k++){
vector<int> u(14,0);
vector<int> cnt2=cnt;
for(int j=0; j<13; j++){
u[j]=t[j];
}
u[13]=i;
cnt2[i]+=1;
sort(u.begin(),u.end());
if(cnt2[k]>=2){//toitu=k;
cnt2[k]-=2;
for(int l=0; l<14; l++){
if(u[l]==k){
u[l]=100;
u[l+1]=100;
break;
}
}
sort(u.begin(),u.end());
if(is_agari_k(u,12)||is_agari_s(u,12)){
zeflag=false;
if(spflag)printf(" ");
cout<<i;
spflag=true;
break;
}
}
}
}
if(zeflag)cout<<"0";
cout<<endl;
}
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.