solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int n;
const int N = 101235;
int a[N], b[N];
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < m; i++) scanf("%d", &b[i]);
int up = 0, down = 0;
long long ans = 0;
long long sumU = 0, sumD = 0;
sumU += (long long)a[up++];
sumD += (long long)b[down++];
while (up < n && down < m) {
if (sumU == sumD) {
ans++;
sumD = sumU = 0;
sumU += (long long)a[up++];
sumD += (long long)b[down++];
} else if (sumU > sumD) {
sumD += (long long)b[down++];
} else if (sumU < sumD)
sumU += (long long)a[up++];
}
if (up < n) {
for (int i = up; i < n; i++) {
sumU += (long long)a[i];
}
if (sumU == sumD) {
ans++;
sumD = sumU = 0;
}
}
if (down < m) {
for (int i = down; i < m; i++) {
sumD += (long long)b[i];
}
if (sumU == sumD) {
ans++;
sumD = sumU = 0;
}
}
if (sumD == sumU && sumD) ans++;
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ss = stringstream;
using ul = unsigned long long;
template <typename T>
inline T LCM(T a, T b) {
return (a * b) / GCD(a, b);
}
template <typename T>
inline T GCD(T a, T b) {
ll t;
while (a) {
t = a;
a = b % a;
b = t;
}
return b;
}
template <typename T>
inline T _max(T a, T b, T c) {
return max(max(a, b), c);
}
template <typename T>
inline T _min(T a, T b, T c) {
return min(min(a, b), c);
}
template <typename T>
inline string toString(T a) {
return to_string(a);
}
template <typename T>
inline void toInt(string s, T &x) {
ss str(s);
str >> x;
}
inline void lower(string &s) {
for (__typeof((s).begin()) it = (s).begin(); it != (s).end(); ++it)
*it = tolower(*it);
}
inline void upper(string &s) {
for (__typeof((s).begin()) it = (s).begin(); it != (s).end(); ++it)
*it = toupper(*it);
}
const ll inf = 1e18 - 1;
const ll N = 7;
ll binary(ll n, ll k) {
ll ans = 1;
while (k > 0) {
if (k & 1) {
ans = (ans * n) % N;
}
n = (n * n) % N;
k >>= 1;
}
return ans;
}
ll divide(ll a, ll b) { return ((a % N) * (binary(b, N - 2) % N)) % N; }
ll mult(ll a, ll b) { return ((a % N) * (b % N)) % N; }
ll add(ll a, ll b) { return (a + b + N) % N; }
ll sub(ll a, ll b) { return (a - b + N) % N; }
bool palin(string s) {
string s1 = s;
reverse(s.begin(), s.end());
return (s == s1);
}
bool check(ll n) {
if (n == 1) return 0;
if (n == 2 or n == 3) return 1;
if (n % 2 == 0 or n % 3 == 0) return 0;
for (ll i = 5; i * i <= n; i += 6)
if (n % i == 0 or n % (i + 2) == 0) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
ll n;
cin >> n;
if (n < 3) {
cout << "-1";
} else {
if (n & 1) {
cout << (n * n + 1LL) / 2 << " " << (n * n - 1LL) / 2;
} else {
cout << (n * n / 4 + 1LL) << " " << (n * n / 4 - 1LL);
}
}
cout << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline void pisz(int n) { printf("%d\n", n); }
const int fx[4][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
const int fxx[8][2] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0},
{1, 1}, {1, -1}, {-1, 1}, {-1, -1}};
template <typename T, typename TT>
ostream& operator<<(ostream& s, pair<T, TT> t) {
return s << "(" << t.first << "," << t.second << ")";
}
template <typename T>
ostream& operator<<(ostream& s, vector<T> t) {
for (int i = 0; i < ((int)((t).size())); i++) s << t[i] << " ";
return s;
}
int main() {
{
long long maxx = -1, sum = 0;
int(n);
scanf("%d", &(n));
for (int i = 0; i < n; i++) {
int(t);
scanf("%d", &(t));
maxx = (t < maxx ? maxx : t);
sum += t;
}
pisz(2 * maxx - sum + 1);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > p;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
map<pair<int, int>, vector<pair<pair<int, int>, pair<int, int> > > > m;
double infi = 1000000005;
int main() {
int n;
scanf("%d", &n);
int x, y;
int x1 = 0, y1 = 0, y2, x2, x3, y3, x4, y4, mi;
int sol = 0;
for (int i = 0; i < n; i++) {
scanf("%d %d", &x, &y);
p.push_back(make_pair(x, y));
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (p[i].first == p[j].first) {
if (p[i] < p[j])
m[make_pair(infi, 0)].push_back(make_pair(p[i], p[j]));
else
m[make_pair(infi, 0)].push_back(make_pair(p[j], p[i]));
} else {
x1 = p[i].first;
y1 = p[i].second;
x2 = p[j].first;
y2 = p[j].second;
mi = 1;
if (y2 - y1 < 0 || x2 - x1 < 0) {
if (y2 - y1 < 0 && x2 - x1 < 0) {
} else
mi = -1;
}
if (p[i] < p[j])
m[make_pair(mi * abs(y2 - y1) / gcd(abs(y2 - y1), abs(x2 - x1)),
abs(x2 - x1) / gcd(abs(y2 - y1), abs(x2 - x1)))]
.push_back(make_pair(p[i], p[j]));
else
m[make_pair(mi * abs(y2 - y1) / gcd(abs(y2 - y1), abs(x2 - x1)),
abs(x2 - x1) / gcd(abs(y2 - y1), abs(x2 - x1)))]
.push_back(make_pair(p[j], p[i]));
}
}
}
for (map<pair<int, int>,
vector<pair<pair<int, int>, pair<int, int> > > >::iterator it =
m.begin();
it != m.end(); it++) {
sort(it->second.begin(), it->second.end());
}
for (map<pair<int, int>,
vector<pair<pair<int, int>, pair<int, int> > > >::iterator it =
m.begin();
it != m.end(); it++) {
if (it->second.size() >= 2) {
int ctr = 0;
for (int i = 0; i < it->second.size(); i++) {
for (int j = i + 1; j < it->second.size(); j++) {
x1 = it->second[i].first.first;
y1 = it->second[i].first.second;
x2 = it->second[i].second.first;
y2 = it->second[i].second.second;
x3 = it->second[j].first.first;
y3 = it->second[j].first.second;
x4 = it->second[j].second.first;
y4 = it->second[j].second.second;
if ((y2 - y1) * (x4 - x3) == (y4 - y3) * (x2 - x1) &&
(y4 - y2) * (x3 - x1) == (y3 - y1) * (x4 - x2)) {
sol++;
}
}
}
}
}
printf("%d\n", sol / 2);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int check(int a, int b) {
string x, y;
while (a) {
x.push_back(a % 10);
a /= 10;
}
while (b) {
y.push_back(b % 10);
b /= 10;
}
int ans(0);
while (!x.empty()) {
if (!y.empty() && x.back() == y.back())
y.pop_back(), x.pop_back();
else
ans++, x.pop_back();
}
if (!y.empty()) return 2e9;
return ans;
}
int main() {
int n;
int best(2e9);
cin >> n;
for (int i(1); 1ll * i * i <= 2e9; i++) best = min(best, check(n, i * i));
cout << (best == 2e9 ? -1 : best) << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n == 1)
cout << 1 << " " << 1 << "\n" << 1;
else
cout << (n - 1) * 2 << " " << 2 << endl << 1 << " " << 2;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, a1, a2, b1, b2, max1, max2;
cin >> t;
while (t > 0) {
cin >> a1 >> b1;
cin >> a2 >> b2;
max1 = max(a1, b1);
max2 = max(a2, b2);
if (max1 == max2) {
int min1, min2;
min1 = min(a1, b1);
min2 = min(a2, b2);
if ((min1 + min2) == max1) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
} else {
cout << "No" << endl;
}
t--;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 6000;
int t[maxn], l[maxn], r[maxn], d[maxn], a[maxn], b[maxn];
int n, m;
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) a[i] = 5e7;
for (int i = 1; i <= m; i++) cin >> t[i] >> l[i] >> r[i] >> d[i];
for (int i = m; i >= 1; i--) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) a[j] -= d[i];
} else {
for (int j = l[i]; j <= r[i]; j++) a[j] = min(a[j], d[i]);
}
}
for (int i = 1; i <= n; i++) b[i] = a[i];
for (int i = 1; i <= m; i++) {
if (t[i] == 1) {
for (int j = l[i]; j <= r[i]; j++) b[j] += d[i];
} else {
int flag = 0;
for (int j = l[i]; j <= r[i]; j++)
if (b[j] == d[i]) flag = 1;
if (!flag) {
cout << "NO" << endl;
return 0;
}
}
}
cout << "YES" << endl;
for (int i = 1; i <= n; i++) {
printf("%d", a[i]);
if (i != n)
printf(" ");
else
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int res = 0;
bool zf = 0;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
if (c == '-')
zf = 1;
else
res = c - '0';
while ((c = getchar()) >= '0' && c <= '9')
res = (res << 3) + (res << 1) + c - '0';
if (zf == 1) return -res;
return res;
}
int n, m, dta[15][2005];
inline int calc() {
int A = 0;
for (register int i = 1; i <= n; ++i) {
int s = -1;
for (register int j = 1; j <= m; ++j) {
s = max(s, dta[i][j]);
}
A += s;
}
return A;
}
signed main() {
int T = read();
while (T--) {
n = read(), m = read();
for (register int i = 1; i <= n; ++i) {
for (register int j = 1; j <= m; ++j) {
dta[i][j] = read();
}
}
int ans = calc();
double tt = 1e6;
while (tt > 1e-10) {
int x = rand() % m + 1;
int t = dta[1][x];
for (register int i = 1; i < n; ++i) {
dta[i][x] = dta[i + 1][x];
}
dta[n][x] = t;
int now = calc();
if (now > ans) {
ans = now;
} else {
if (exp((ans - now) / t) * RAND_MAX < rand()) {
t = dta[n][x];
for (register int i = n; i >= 2; --i) {
dta[i][x] = dta[i - 1][x];
}
dta[1][x] = t;
}
}
tt *= 0.999;
}
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
using namespace std;
long long n;
string second;
long long cnt1 = 0, cnt2 = 0;
vector<long long> v;
int32_t main() {
ios_base::sync_with_stdio();
cin.tie();
cout.tie();
;
cin >> n;
cin >> second;
for (long long i = 0; i < n; i++)
if (second[i] == '0') {
cnt1++;
} else
cnt2++;
if (cnt1 != cnt2) {
cout << 1 << endl;
cout << second;
} else {
cout << 2 << endl;
for (long long i = 0; i < n - 1; i++) cout << second[i];
cout << ' ';
cout << second[n - 1];
}
return 0;
}
| 1 |
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main()
{
vector<string> text;
while ( true )
{
string t;
getline( cin, t );
if ( t == "END_OF_TEXT" )
break;
text.push_back( t );
}
int cx = 0;
int cy = 0;
string buf;
while ( true )
{
char c;
cin >> c;
if ( c == '-' )
break;
switch ( c )
{
case 'a':
cx = 0;
break;
case 'e':
cx = (int)text[cy].length();
break;
case 'p':
if ( cy > 0 ) cy--;
cx = 0;
break;
case 'n':
if ( cy < (int)text.size()-1 ) cy++;
cx = 0;
break;
case 'f':
if ( cx != (int)text[cy].length() )
cx++;
else if ( cy < (int)text.size()-1 )
cy++,
cx = 0;
break;
case 'b':
if ( cx > 0 )
cx--;
else if ( cy > 0 )
cy--,
cx = (int)text[cy].size();
break;
case 'd':
if ( cx < (int)text[cy].size() )
text[cy].erase( text[cy].begin()+cx );
else if ( cy < (int)text.size()-1 )
text[cy] += text[cy+1],
text.erase( text.begin()+cy+1 );
break;
case 'k':
if ( cx == (int)text[cy].size() &&
cy < (int)text.size() - 1 )
{
buf = "\n";
text[cy] += text[cy+1],
text.erase( text.begin()+cy+1 );
}
else
{
buf = text[cy].substr( cx );
text[cy].erase( text[cy].begin()+cx, text[cy].end() );
}
break;
case 'y':
if ( buf == "" )
break;
else if ( buf == "\n" )
{
text.insert( text.begin()+cy+1, text[cy].substr(cx) );
text[cy] = text[cy].substr(0,cx);
cx = 0;
cy++;
}
else
{
text[cy] = text[cy].substr(0,cx) + buf + text[cy].substr(cx);
cx += (int)buf.length();
}
break;
}
//for ( int i=0; i<(int)text.size(); i++ )
// cout << text[i] << endl;
//cout << cx << "," << cy << endl;
//cout << "----" << endl;
}
for ( int i=0; i<(int)text.size(); i++ )
cout << text[i] << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define int int64_t
#define MOD 998244353
#define inf 9e18
#define tikoo (int) (1e9 + 7)
template<typename T, typename T1> T max(T a, T1 b) { if (b > a) a = b; return a; }
template<typename T, typename T1> T min(T a, T1 b) { if (b < a) a = b; return a; }
int fastpow(int a, int b, int m = tikoo) { int res = 1; a %= m;
while (b > 0) { if (b & 1) res = (res * a) % m; a = (a * a) % m; b >>= 1; } return res; }
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
cout << fastpow(n, k) << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e3 + 5;
char ch[3] = {'R', 'G', 'B'};
string str;
int main() {
int q;
cin >> q;
while (q--) {
int n, k;
cin >> n >> k;
cin >> str;
int tmp = 0;
int ans = maxn;
int cnt = 0;
for (int i = 0; i <= n - k; i++) {
for (int t = 0; t < 3; t++) {
cnt = 0;
tmp = t;
for (int j = 0; j < k; j++) {
if (ch[tmp] != str[i + j]) cnt++;
tmp++;
tmp %= 3;
}
ans = min(ans, cnt);
}
}
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, sum, rem, rem1, sum1;
scanf("%d", &n);
n = n + 1;
while (n > 0) {
int temp = n;
while (temp > 0) {
rem = temp % 10;
temp /= 10;
sum = temp % 10;
temp /= 10;
rem1 = temp % 10;
temp /= 10;
sum1 = temp % 10;
temp /= 10;
}
if (rem == sum || rem == rem1 || rem == sum1 || sum == rem1 ||
sum == sum1 || rem1 == sum1) {
n++;
} else
goto jump;
}
jump:
printf("%d", n);
return 0;
}
| 1 |
#include <iostream>
using namespace std;
int dn[33];
int main(){
int n=0;
dn[0]=1;
for(int i=0;i<30;i++){
for(int j=1;j<=3;j++){
dn[i+j]+=dn[i];
}
}
while(true){
cin >> n;
if(n==0)
break;
int l=dn[n]/(365*10);
if(dn[n]%(365*10)!=0)
l++;
cout << l << endl;
}
} | 0 |
#include <bits/stdc++.h>
#define inv(n) qpow(n, M-2)
using namespace std;
const long long M = 1000003;
typedef long long ll;
int fact[M];
int qpow(long long a, int n) {
return (n?(qpow(a*a%M, n/2)*(n%2?a:1)):1)%M;
}
int main() {
fact[0] = 1;
for (int i = 1; i < M; ++i)
fact[i] = (ll)fact[i-1]*i%M;
int q, x, d, n;
scanf("%d", &q);
while (q--) {
scanf("%d%d%d", &x, &d, &n);
if (d == 0) printf("%d\n", qpow(x, n));
else {
int l = (ll)x*inv(d)%M, r = l+(n-1);
if (r >= M) puts("0\n");
else printf("%lld\n", (ll)fact[r]*inv(fact[l-1])%M*qpow(d, n)%M);
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MB = 1 << 20;
struct FastIO {
char ib[MB + 100], *p, *q;
char ob[MB + 100], *r, stk[128];
int tp;
FastIO() { p = q = ib, r = ob, tp = 0; }
~FastIO() { fwrite(ob, 1, r - ob, stdout); }
char read_char() {
if (p == q) {
p = ib, q = ib + fread(ib, 1, MB, stdin);
if (p == q) return 0;
}
return *p++;
}
template <typename T>
void read_int(T& x) {
char c = read_char(), l = 0;
for (x = 0; !isdigit(c); c = read_char()) l = c;
for (; isdigit(c); c = read_char()) x = x * 10 - '0' + c;
if (l == '-') x = -x;
}
void write_char(char c) {
if (r - ob == MB) r = ob, fwrite(ob, 1, MB, stdout);
*r++ = c;
}
template <typename T>
void write_int(T x) {
if (x < 0) write_char('-'), x = -x;
do stk[++tp] = x % 10 + '0';
while (x /= 10);
while (tp) write_char(stk[tp--]);
}
} IO;
const int N = 200010;
int T, n, m, k;
int main() {
scanf("%d", &T);
while (T--) {
scanf("%d%d%d", &n, &m, &k);
int k1 = n / m;
int k2 = (n - m * k1), nex = 1, kk = 1;
k1 = m - k2;
for (int i = 1; i <= k; i++) {
for (int o = 1; o <= m; o++) {
if (o <= k1) {
printf("%d ", n / m);
for (int p = 1; p <= n / m; p++) {
printf("%d ", nex++);
if (nex > n) nex -= n;
}
printf("\n");
} else {
if (o == k1 + 1) kk = nex;
printf("%d ", n / m + 1);
for (int p = 1; p <= n / m + 1; p++) {
printf("%d ", kk++);
if (kk > n) kk -= n;
}
printf("\n");
}
}
}
}
return 0;
}
| 6 |
#include <stdio.h>
char a[500];
int main(){
scanf("%s",a);
printf("%s\n",a[0]=='S'?"Cloudy":(a[0]=='C'?"Rainy":"Sunny"));
} | 0 |
#include <bits/stdc++.h>
using namespace std;
bool same[50];
vector<int> ones[50], cero[50];
int main() {
int n, x, y;
scanf("%d %d %d", &n, &x, &y);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < int(10); j++)
if ((i & (1 << j)) != 0)
ones[j].push_back(i);
else
cero[j].push_back(i);
}
for (int i = 0; i < int(10); i++) {
if (!ones[i].empty()) {
printf("? %d\n", ones[i].size());
for (int j = 0; j < int(ones[i].size()); j++)
printf("%d%c", ones[i][j], j == (int)ones[i].size() - 1 ? '\n' : ' ');
fflush(stdout);
int val;
scanf("%d", &val);
if (val == 0 || val == x) same[i] = true;
} else
same[i] = true;
}
printf("\n");
int id;
for (int i = 0; i < int(10); i++)
if (!same[i]) id = i;
int l = 0, m, r = (int)ones[id].size() - 1;
while (l != r) {
m = (l + r) / 2;
printf("? %d\n", m + 1);
for (int i = 0; i <= m; i++)
printf("%d%c", ones[id][i], i == m ? '\n' : ' ');
fflush(stdout);
int val;
scanf("%d", &val);
if (val == y || val == (x ^ y))
r = m;
else
l = m + 1;
}
int p1 = ones[id][l], p2 = 0;
for (int i = 0; i < int(10); i++)
if (same[i])
p2 += (p1 & (1 << i));
else
p2 += ((p1 & (1 << i)) == 0 ? (1 << i) : 0);
if (p1 > p2) swap(p1, p2);
printf("! %d %d\n", p1, p2);
fflush(stdout);
}
| 5 |
#include <bits/stdc++.h>
int n, a, b, c, ans;
long long int t[110000][2];
int sum;
int main() {
scanf("%d", &n);
scanf("%d", &t[0][0]);
t[0][1] = 20;
sum = 20;
printf("20\n");
for (int i = 1; i < n; i++) {
scanf("%d", &t[i][0]);
a = sum + 20;
int whatever = std::max(0, i - 91);
b = 200000000;
for (int j = whatever; j < i; j++) {
if (t[i][0] - t[j][0] <= 89) {
if (j == 0)
b = 50;
else
b = t[j - 1][1] + 50;
break;
}
}
c = 200000000;
int another_whatever = std::max(0, i - 1441);
for (int j = another_whatever; j < i; j++) {
if (t[i][0] - t[j][0] <= 1439) {
if (j == 0)
c = 120;
else
c = t[j - 1][1] + 120;
break;
}
}
ans = std::min(a, b);
ans = std::min(ans, c);
if (i != 0) ans -= t[i - 1][1];
t[i][1] = sum + ans;
sum += ans;
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
using namespace std;
#define FOR(i,k,n) for(int i=(k); i<(int)n; ++i)
#define REP(i,n) FOR(i,0,n)
#define FORIT(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
template<class T> void debug(T begin, T end){ for(T i = begin; i != end; ++i) cout<<*i<<" "; cout<<endl; }
typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
int H, W;
void move(int& x, int& y, char c){
if(c == '8' && y - 1 >= 0) y--;
if(c == '6' && x + 1 < W) x++;
if(c == '4' && x - 1 >= 0) x--;
if(c == '2' && y + 1 < H) y++;
}
int main(){
while(cin>>H>>W && H){
vector<string> grid(H);
string pattern;
REP(y, H) cin>>grid[y];
cin>>pattern;
int N = pattern.size();
int sx, sy, gx, gy;
REP(y, H)REP(x, W){
if(grid[y][x] == 'A') sx = x, sy = y;
if(grid[y][x] == 'B') gx = x, gy = y;
}
queue<int> qx, qy;
int min_arrive[20][20];
REP(y, H)REP(x, W) min_arrive[y][x] = INF;
qx.push(sx), qy.push(sy);
min_arrive[sy][sx] = 0;
int max_arrive = -INF;
while(!qx.empty()){
int x = qx.front(), y = qy.front();
qx.pop(); qy.pop();
REP(r, 4){
int nx = x + dx[r];
int ny = y + dy[r];
if(nx >= 0 && ny >= 0 && nx < W && ny < H && min_arrive[ny][nx] == INF && grid[ny][nx] != '#'){
min_arrive[ny][nx] = min_arrive[y][x] + 1;
max_arrive = max(max_arrive, min_arrive[ny][nx]);
qx.push(nx), qy.push(ny);
}
}
}
/*
REP(y, H){
REP(x, W){
cout<<min_arrive[y][x]<< " ";
}
cout<<endl;
}
*/
int ans_t = INF, ans_x = INF, ans_y = INF;
bool used[10][20][20] = {};
for(int t = 0; ; t++){
if(used[t % N][gy][gx] && max_arrive < t) break;
used[t % N][gy][gx] = true;
if(min_arrive[gy][gx] <= t){
ans_t = t, ans_x = gx, ans_y = gy;
break;
}
move(gx, gy, pattern[t % N]);
}
if(ans_t != INF) printf("%d %d %d\n", ans_t, ans_y, ans_x);
else printf("impossible\n");
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N_DEL = 0, N_VAL = 0;
inline int mOp(int x, int y) { return x + y; }
inline int qOp(int lval, int rval) { return lval ^ rval; }
inline int dOnSeg(int d, int len) { return d == N_DEL ? N_DEL : d * len; }
inline int joinD(int d1, int d2) {
if (d1 == N_DEL) return d2;
if (d2 == N_DEL) return d1;
return mOp(d1, d2);
}
inline int joinVD(int v, int d) { return d == N_DEL ? v : mOp(v, d); }
struct Node_t {
int sz, nVal, tVal, d;
bool rev;
Node_t *c[2], *p;
Node_t(int v) : sz(1), nVal(v), tVal(v), d(N_DEL), rev(0), p(0) {
c[0] = c[1] = 0;
}
bool isRoot() { return !p || (p->c[0] != this && p->c[1] != this); }
void push() {
if (rev) {
rev = 0;
swap(c[0], c[1]);
for (int x = 0, ThxDem = 2; x < ThxDem; ++x)
if (c[x]) c[x]->rev ^= 1;
}
nVal = joinVD(nVal, d);
tVal = joinVD(tVal, dOnSeg(d, sz));
for (int x = 0, ThxDem = 2; x < ThxDem; ++x)
if (c[x]) c[x]->d = joinD(c[x]->d, d);
d = N_DEL;
}
void upd();
};
typedef Node_t* Node;
int getSize(Node r) { return r ? r->sz : 0; }
int getPV(Node r) { return r ? joinVD(r->tVal, dOnSeg(r->d, r->sz)) : N_VAL; }
void Node_t::upd() {
tVal = qOp(qOp(getPV(c[0]), joinVD(nVal, d)), getPV(c[1]));
sz = 1 + getSize(c[0]) + getSize(c[1]);
}
void conn(Node c, Node p, int il) {
if (c) c->p = p;
if (il >= 0) p->c[!il] = c;
}
void rotate(Node x) {
Node p = x->p, g = p->p;
bool gCh = p->isRoot(), isl = x == p->c[0];
conn(x->c[isl], p, isl);
conn(p, x, !isl);
conn(x, g, gCh ? -1 : (p == g->c[0]));
p->upd();
}
void spa(Node x) {
while (!x->isRoot()) {
Node p = x->p, g = p->p;
if (!p->isRoot()) g->push();
p->push();
x->push();
if (!p->isRoot()) rotate((x == p->c[0]) == (p == g->c[0]) ? p : x);
rotate(x);
}
x->push();
x->upd();
}
Node exv(Node x) {
Node last = 0;
for (Node y = x; y; y = y->p) spa(y), y->c[0] = last, y->upd(), last = y;
spa(x);
return last;
}
void mkR(Node x) {
exv(x);
x->rev ^= 1;
}
Node getR(Node x) {
exv(x);
while (x->c[1]) x = x->c[1];
spa(x);
return x;
}
Node lca(Node x, Node y) {
exv(x);
return exv(y);
}
bool connected(Node x, Node y) {
exv(x);
exv(y);
return x == y ? 1 : x->p != 0;
}
void link(Node x, Node y) {
mkR(x);
x->p = y;
}
void cut(Node x, Node y) {
mkR(x);
exv(y);
y->c[1]->p = 0;
y->c[1] = 0;
}
int query(Node x, Node y) {
mkR(x);
exv(y);
return getPV(y);
}
void modify(Node x, Node y, int d) {
mkR(x);
exv(y);
y->d = joinD(y->d, d);
}
map<int, Node> mp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int q, last = 0, l, r, x, idx = 0, t;
cin >> q;
while (q--) {
if (last < 0) last = 1;
cin >> t;
if (t == 1) {
cin >> l >> r >> x;
l ^= last;
r ^= last;
x ^= last;
if (l > r) swap(l, r);
r++;
if (!mp.count(l)) mp[l] = new Node_t(0);
if (!mp.count(r)) mp[r] = new Node_t(0);
auto le = mp[l], rr = mp[r];
if (connected(le, rr)) continue;
auto xx = new Node_t(x);
link(le, xx);
link(rr, xx);
} else {
cin >> l >> r;
l ^= last;
r ^= last;
if (l > r) swap(l, r);
r++;
int ans = -1;
if (mp.count(l) && mp.count(r)) {
auto le = mp[l], rr = mp[r];
if (connected(le, rr)) {
ans = query(le, rr);
}
}
cout << ans << "\n";
last = ans;
}
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
string type;
int val;
int left, right;
};
vector<int> vals;
vector<node> nodes;
vector<int> depths;
vector<list<int>> changes;
void dfs(int x, int depth) {
depths[x] = depth;
if (nodes[x].type == "IN")
vals[x] = nodes[x].val;
else {
dfs(nodes[x].left, depth + 1);
if (nodes[x].right >= 0) dfs(nodes[x].right, depth + 1);
if (nodes[x].type == "AND")
vals[x] = vals[nodes[x].left] & vals[nodes[x].right];
else if (nodes[x].type == "OR")
vals[x] = vals[nodes[x].left] | vals[nodes[x].right];
else if (nodes[x].type == "XOR")
vals[x] = vals[nodes[x].left] ^ vals[nodes[x].right];
else if (nodes[x].type == "NOT")
vals[x] = 1 - vals[nodes[x].left];
}
}
int main(int argc, char** argv) {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
if (argc == 2 && atoi(argv[1]) == 123456789)
freopen("d:\\code\\cpp\\stdin", "r", stdin);
int n;
cin >> n;
vals.resize(n);
nodes.resize(n);
depths.resize(n);
int nrleafs = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
nodes[i].type = s;
if (s == "IN") {
cin >> nodes[i].val;
nrleafs++;
} else if (s == "NOT") {
int li;
cin >> li;
li--;
nodes[i].left = li;
nodes[i].right = -1;
} else {
int li, ri;
cin >> li >> ri;
li--;
ri--;
nodes[i].left = li;
nodes[i].right = ri;
}
}
dfs(0, 0);
vector<pair<int, int>> order;
for (int i = 0; i < n; i++) order.push_back(make_pair(-depths[i], i));
sort(order.begin(), order.end());
changes.resize(n);
for (int i = 0; i < n; i++) {
int x = order[i].second;
if (nodes[x].type == "IN")
changes[x].push_back(x);
else {
if (nodes[x].type == "AND") {
if (((1 - vals[nodes[x].left]) & vals[nodes[x].right]) != vals[x])
changes[x].splice(changes[x].begin(), changes[nodes[x].left]);
if ((vals[nodes[x].left] & (1 - vals[nodes[x].right])) != vals[x])
changes[x].splice(changes[x].begin(), changes[nodes[x].right]);
} else if (nodes[x].type == "OR") {
if (((1 - vals[nodes[x].left]) | vals[nodes[x].right]) != vals[x])
changes[x].splice(changes[x].begin(), changes[nodes[x].left]);
if ((vals[nodes[x].left] | (1 - vals[nodes[x].right])) != vals[x])
changes[x].splice(changes[x].begin(), changes[nodes[x].right]);
} else if (nodes[x].type == "XOR") {
if (((1 - vals[nodes[x].left]) ^ vals[nodes[x].right]) != vals[x])
changes[x].splice(changes[x].begin(), changes[nodes[x].left]);
if ((vals[nodes[x].left] ^ (1 - vals[nodes[x].right])) != vals[x])
changes[x].splice(changes[x].begin(), changes[nodes[x].right]);
} else if (nodes[x].type == "NOT") {
changes[x].splice(changes[x].begin(), changes[nodes[x].left]);
}
}
}
vector<int> xx;
for (int x : changes[0]) xx.push_back(x);
sort(xx.begin(), xx.end());
int posx = 0;
for (int i = 0; i < n; i++)
if (nodes[i].type == "IN") {
if (posx < xx.size() && xx[posx] == i) {
cout << 1 - vals[0];
posx++;
} else
cout << vals[0];
}
cout << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3f;
const long long N = 5000;
long long n, m, s, t;
vector<pair<long long, pair<long long, long long> > > nei[N + 1];
vector<long long> rv[N + 1];
void ae(long long x, long long y, long long c, long long w) {
nei[x].push_back(make_pair(y, make_pair(c, w))),
nei[y].push_back(make_pair(x, make_pair(0, -w)));
rv[x].push_back(nei[y].size() - 1), rv[y].push_back(nei[x].size() - 1);
}
long long sumf[N + 1];
void ae(long long x, long long y, long long l, long long r, long long w) {
ae(x, y, r - l, w);
sumf[x] += l, sumf[y] -= l;
}
long long dis[N + 1], prv[N + 1];
bool inq[N + 1];
bool spfa() {
memset(dis, 0x3f, sizeof(dis));
memset(inq, 0, sizeof(inq));
dis[s] = 0;
queue<long long> q;
q.push(s), inq[s] = true;
while (q.size()) {
long long x = q.front();
q.pop(), inq[x] = false;
for (long long i = 0; i < nei[x].size(); i++) {
long long y = nei[x][i].first, &c = nei[x][i].second.first,
w = nei[x][i].second.second;
if (c && dis[x] + w < dis[y]) {
dis[y] = dis[x] + w, prv[y] = rv[x][i];
if (!inq[y]) q.push(y), inq[y] = true;
}
}
}
return dis[t] < inf;
}
pair<long long, long long> ek() {
long long resf = 0, resw = 0;
while (spfa()) {
long long flw = inf;
for (long long i = t; i != s; i = nei[i][prv[i]].first)
flw = min(flw, nei[nei[i][prv[i]].first][rv[i][prv[i]]].second.first);
for (long long i = t; i != s; i = nei[i][prv[i]].first)
nei[nei[i][prv[i]].first][rv[i][prv[i]]].second.first -= flw,
nei[i][prv[i]].second.first += flw;
resf += flw, resw += dis[t] * flw;
}
return make_pair(resf, resw);
}
long long a[N + 1];
long long nxt[N + 1];
long long id[N + 1];
signed main() {
cin >> n >> m;
for (long long i = 1; i <= n; i++) scanf("%lld", a + i);
s = 2 * n + 1, t = s + 2;
for (long long i = 1; i <= n; i++)
ae(s, i, inf, __builtin_popcount(a[i])), ae(i, i + n, 1, 1, 0),
ae(i + n, t, inf, 0);
for (long long i = 1; i <= n; i++)
for (long long j = i + 1; j <= n; j++)
ae(i + n, j, inf, a[i] == a[j] ? 0 : __builtin_popcount(a[j]));
s++;
ae(s, s - 1, m, 0);
ae(t, s, inf, 0);
s += 2, t += 2;
for (long long i = 1; i < s; i++)
if (sumf[i] < 0)
ae(s, i, -sumf[i], 0);
else
ae(i, t, sumf[i], 0);
pair<long long, long long> ans = ek();
long long otp = ans.second;
memset(prv, 0, sizeof(prv));
for (long long i = 1; i <= n; i++)
for (long long j = 0; j < nei[i + n].size(); j++)
if (i < nei[i + n][j].first && nei[i + n][j].first <= n &&
nei[i + n][j].second.first == inf - 1)
nxt[i] = nei[i + n][j].first, prv[nei[i + n][j].first] = i;
long long nowid = 0;
for (long long i = 1; i <= n; i++)
if (!prv[i]) {
nowid++;
for (long long j = i; j; j = nxt[j]) id[j] = nowid;
}
long long cnt = 0;
for (long long i = 1; i <= n; i++) {
if (!prv[i] || a[prv[i]] != a[i]) cnt++;
cnt++;
}
cout << cnt << " " << otp << "\n";
for (long long i = 1; i <= n; i++) {
if (!prv[i] || a[prv[i]] != a[i])
printf("%c=%lld\n", char('a' + id[i] - 1), a[i]);
printf("print(%c)\n", char('a' + id[i] - 1));
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long double pi = acos(-1);
const int MOD = 1e9 + 7;
const long long int LINF = 0x3f3f3f3f3f3f3f3f;
const int MAXSZ = 4000006;
const int MAXN = 100005;
int tr[MAXSZ], L[MAXSZ], R[MAXSZ], root[MAXSZ], ptr, n, q, a[MAXN], last[MAXN];
int m(int b, int e) { return (b + e) / 2; }
int build(int idx, int b, int e) {
int nd = ptr++;
if (b >= e) return nd;
L[nd] = build(idx, b, m(b, e));
R[nd] = build(idx, m(b, e) + 1, e);
return nd;
}
int update(int nd, int b, int e, int i, int v) {
int idx = ptr++;
L[idx] = L[nd];
R[idx] = R[nd];
if (b >= e) {
tr[idx] = v;
return idx;
}
int mid = m(b, e);
if (i <= mid)
L[idx] = update(L[nd], b, mid, i, v);
else
R[idx] = update(R[nd], mid + 1, e, i, v);
tr[idx] = tr[R[idx]] + tr[L[idx]];
return idx;
}
void process() {
root[0] = build(0, 1, n);
for (int i = 1; i <= n; i++) {
if (last[a[i]] == 0) {
root[i] = update(root[i - 1], 1, n, i, 1);
} else {
root[i] = update(root[i - 1], 1, n, last[a[i]], 0);
root[i] = update(root[i], 1, n, i, 1);
}
last[a[i]] = i;
}
}
int get(int nd, int b, int e, int k) {
if (b >= e) {
if (tr[nd] <= k) return b;
return b + 1;
}
int mid = m(b, e);
if (tr[R[nd]] > k) return get(R[nd], mid + 1, e, k);
return get(L[nd], b, mid, k - tr[R[nd]]);
}
int solve(int k) {
int r = n;
int ret = 0;
while (r > 0) {
ret++;
int l = get(root[r], 1, n, k);
r = l - 1;
;
}
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
process();
for (int k = 1; k <= n; k++) {
printf("%d ", solve(k));
}
printf("\n");
return 0;
}
| 5 |
#include <iostream>
#include <vector>
#include <string>
using namespace std;
using cat = long long;
cat pw(cat a, cat e, cat mod) {
if(e <= 0) return 1;
cat x = pw(a, e/2, mod);
x = x * x % mod;
return e&1 ? x * a % mod : x;
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int N, M;
cin >> N >> M;
vector<cat> invf(3*N+1, 1), inv2(N+1, 1), inv3(N+1, 1);
for(int i = 1; i <= 3*N; i++) invf[i] = invf[i-1] * pw(i, M-2, M) % M;
for(int i = 1; i <= N; i++) inv2[i] = inv2[i-1] * pw(2, M-2, M) % M;
for(int i = 1; i <= N; i++) inv3[i] = inv3[i-1] * pw(3, M-2, M) % M;
cat ans = 0;
for(int k3 = 0; k3 <= N; k3++) for(int k2 = 0; k2 <= N-k3; k2++) {
int k1 = 3*N-2*k2-3*k3;
ans += inv2[k2] * inv3[k3] % M * invf[k1] % M * invf[k2] % M * invf[k3] % M;
if(ans >= M) ans -= M;
}
for(int i = 1; i <= 3*N; i++) ans = ans * i % M;
cout << ans << "\n";
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 505;
int n, m, ret;
bool Map[N][N], tMap[N][N];
int LEFT[N][N], UP[N][N], UPLEFT[N][N], UPRIGHT[N][N];
string s;
void Rotate() {
for (int i = 1; i <= int(n); i++) {
for (int j = 1; j <= int(m); j++) {
tMap[j][i] = Map[i][j];
}
}
swap(n, m);
memset(Map, 0, sizeof Map);
for (int i = 1; i <= int(n); i++) {
for (int j = 1; j <= int(m); j++) {
Map[i][j] = tMap[i][m + 1 - j];
}
}
}
int Calc() {
memset(LEFT, 0, sizeof LEFT);
memset(UP, 0, sizeof UP);
memset(UPLEFT, 0, sizeof UPLEFT);
memset(UPRIGHT, 0, sizeof UPRIGHT);
for (int i = 1; i <= int(n); i++)
for (int j = int(m); j > 0; j--) {
if (Map[i][j]) {
UPLEFT[i][j] = UPLEFT[i - 1][j + 1] + 1;
UP[i][j] = UP[i][j + 1] + 1;
LEFT[i][j] = LEFT[i - 1][j] + 1;
}
}
for (int i = int(n); i > 0; i--)
for (int j = int(m); j > 0; j--) {
if (Map[i][j]) {
UPRIGHT[i][j] = UPRIGHT[i + 1][j + 1] + 1;
}
}
int ret = 0;
for (int i = 1; i <= int(n); i++) {
for (int j = 1; j <= int(m); j++) {
for (int d = 1;; d++) {
if (i - d < 1) break;
if (j - d < 1) break;
if (LEFT[i][j] < d + 1) continue;
if (UP[i][j - d] < d + 1) continue;
if (UPLEFT[i][j - d] < d + 1) continue;
ret++;
}
}
}
for (int i = 1; i <= int(n); i++) {
for (int j = 1; j <= int(m); j++) {
for (int d = 1;; d++) {
if (i - d < 1) break;
if (i + d > n) break;
if (j - d < 1) break;
if (LEFT[i + d][j] < 2 * d + 1) continue;
if (UPLEFT[i][j - d] < d + 1) continue;
if (UPRIGHT[i][j - d] < d + 1) continue;
ret++;
}
}
}
return ret;
}
int main() {
memset(Map, false, sizeof Map);
scanf("%d%d", &n, &m);
for (int i = 1; i <= int(n); i++) {
cin >> s;
s = " " + s;
for (int j = 1; j <= int(m); j++) {
if (s[j] == '0') Map[i][j] = true;
}
}
ret = 0;
ret += Calc();
Rotate();
ret += Calc();
Rotate();
ret += Calc();
Rotate();
ret += Calc();
printf("%d\n", ret);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, i, j, k, l, cnt, at;
int op[200002], oper[200002];
int a[200002];
char s[200002];
int v[200000];
long long sums[5][10000], ans;
int mod5[10000];
void recalc(int at) {
int i, j;
for (i = 0; i < 5; i++) sums[i][at] = 0;
j = 0;
for (i = k * at; i < k * (at + 1); i++)
if (v[i]) {
sums[j][at] += v[i];
j++;
if (j >= 5) j -= 5;
}
}
int main() {
scanf("%d\n", &m);
for (i = 0; i < m; i++) {
scanf("%s", s);
if (s[0] == 'a') {
op[i] = 1;
scanf("%d\n", &oper[i]);
a[n++] = oper[i];
}
if (s[0] == 'd') {
op[i] = 2;
scanf("%d\n", &oper[i]);
}
if (s[0] == 's') {
op[i] = 3;
scanf("\n");
}
}
sort(a, a + n);
n = unique(a, a + n) - a;
k = (int)sqrt(1.0 * n) + 5;
cnt = (n + k - 1) / k;
for (l = 0; l < m; l++)
if (op[l] == 1) {
i = lower_bound(a, a + n, oper[l]) - a;
int at = i / k;
v[i] = oper[l];
for (j = at + 1; j < cnt; j++) {
mod5[j]++;
if (mod5[j] >= 5) mod5[j] -= 5;
}
recalc(at);
} else if (op[l] == 2) {
i = lower_bound(a, a + n, oper[l]) - a;
int at = i / k;
v[i] = 0;
for (j = at + 1; j < cnt; j++) {
mod5[j]--;
if (mod5[j] < 0) mod5[j] += 5;
}
recalc(at);
} else {
ans = 0;
for (j = 0; j < cnt; j++) ans += sums[(7 - mod5[j]) % 5][j];
cout << ans << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10;
char ch[10][10];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
for (int i = 1; i <= 9; i++) {
char ch1;
for (int j = 1; j <= 9; j++) {
cin >> ch1;
if (ch1 == ' ') {
cin >> ch[i][j];
} else {
ch[i][j] = ch1;
}
}
}
int x, y;
cin >> x >> y;
int x1 = (x % 3), y1 = (y % 3);
if (y1 == 0) y1 = 3;
if (x1 == 0) x1 = 3;
bool flag = false;
for (int i = (x1 - 1) * 3 + 1; i <= (x1 * 3); i++) {
for (int j = (y1 - 1) * 3 + 1; j <= (y1 * 3); j++) {
if (ch[i][j] == '.') {
flag = true;
ch[i][j] = '!';
}
}
}
for (int i = 1; i <= 9; i++) {
if (i % 3 == 1 && i != 1) cout << endl;
for (int j = 1; j <= 9; j++) {
if (j % 3 == 1 && j != 1) cout << ' ';
if (ch[i][j] == '.') {
if (!flag)
cout << '!';
else {
cout << ch[i][j];
}
} else {
cout << ch[i][j];
}
}
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
const int MAXN = 1e5 + 5;
int n, k;
bool vis[MAXN];
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
vis[a % k] = true;
}
int cur = 0;
for (int i = 0; i < k; i++)
if (vis[i]) cur = gcd(cur, gcd(i, k));
if (cur > 0) {
int j = 0;
for (int i = 0; i < 2 * k; i++) {
j = (j + cur) % k;
vis[j] = true;
}
}
int cnt = 0;
for (int i = 0; i < k; i++)
if (vis[i]) cnt++;
printf("%d\n", cnt);
for (int i = 0; i < k; i++)
if (vis[i]) printf("%d ", i);
printf("\n");
return 0;
}
| 5 |
#include "bits/stdc++.h"
using namespace std;
#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
#define rrep(i,n) for (int i=(n)-1;i>=0;i--)
#define rrep2(i,a,b) for (int i=(a)-1;i>=b;i--)
#define chmin(a,b) (a)=min((a),(b));
#define chmax(a,b) (a)=max((a),(b));
#define all(a) (a).begin(),(a).end()
#define rall(a) (a).rbegin(),(a).rend()
#define printV(v) cerr<<(#v)<<":";for(auto(x):(v)){cerr<<" "<<(x);}cerr<<endl;
#define printVS(vs) cerr<<(#vs)<<":"<<endl;for(auto(s):(vs)){cerr<<(s)<< endl;}
#define printVV(vv) cerr<<(#vv)<<":"<<endl;for(auto(v):(vv)){for(auto(x):(v)){cerr<<" "<<(x);}cerr<<endl;}
#define printP(p) cerr<<(#p)<<(p).first<<" "<<(p).second<<endl;
#define printVP(vp) cerr<<(#vp)<<":"<<endl;for(auto(p):(vp)){cerr<<(p).first<<" "<<(p).second<<endl;}
inline void output(){ cerr << endl; }
template<typename First, typename... Rest>
inline void output(const First& first, const Rest&... rest) {
cerr << first << " "; output(rest...);
}
using ll = long long;
using Pii = pair<int, int>;
using TUPLE = tuple<int, int, int>;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
const int inf = 2e9;
const int mod = 1e9 + 7;
using Graph = vector<vector<int>>;
class SuffixArray {
private:
string s;
int n;
vector<int> rank;
vector<int> sa;
public:
SuffixArray(string _s) : s(_s) {
n = s.size();
rank.resize(n + 1);
sa.resize(n + 1);
construct();
}
void construct() {
for (int i = 0; i <= n; ++i) {
sa[i] = i;
rank[i] = i < n ? s[i] : -1;
}
int k;
auto compare = [&](int i, int j) {
if (rank[i] != rank[j]) return rank[i] < rank[j];
else {
int ri = i + k <= n ? rank[i + k] : -1;
int rj = j + k <= n ? rank[j + k] : -1;
return ri < rj;
}
};
vector<int> tmp(n + 1);
for (k = 1; k <= n; k *= 2) {
sort(sa.begin(), sa.end(), compare);
tmp[sa[0]] = 0;
for (int i = 1; i <= n; ++i) {
tmp[sa[i]] = tmp[sa[i - 1]] + (compare(sa[i - 1], sa[i]) ? 1 : 0);
}
for (int i = 0; i <= n; ++i) {
rank[i] = tmp[i];
}
}
}
bool contain(string t) {
int l = 0, r = n;
while (r - l > 1) {
int m = (l + r) / 2;
if (s.substr(sa[m], t.size()) < t) l = m;
else r = m;
}
return s.substr(sa[r], t.size()) == t;
}
void print() {
for (int i = 0; i < n; ++i) {
cerr << s.substr(sa[i]) << endl;
}
}
};
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
string s;
cin >> s;
SuffixArray suf(s);
// suf.print();
int q;
cin >> q;
rep(i, q) {
string t;
cin >> t;
cout << suf.contain(t) << endl;
}
} | 0 |
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0; i<(int)(n); ++i)
#define FOR(i,k,n) for(int i=(k);i<(int)(n);++i)
typedef long long int ll;
using namespace std;
struct UnionFind {
vector<int> par;
vector<int> rank;
UnionFind(int n) : par(n), rank(n, 1) {
for(int i=0; i<n; ++i) par[i] = i;
}
int find(int x) {
if (x == par[x]) return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (rank[x] < rank[y]) swap(x, y);
par[y] = x;
rank[x] += rank[y];
}
bool same(int x, int y) {
return find(x) == find(y);
}
};
struct edge{
int src, dst;
double cost;
edge(int s, int t, double c) : src(s), dst(t), cost(c) {}
bool operator < (const edge &rhs) const {return cost > rhs.cost;}
};
int main(void) {
int n;
while(cin >> n && n) {
UnionFind uf(n);
vector<double> x(n), y(n), z(n), r(n);
vector<edge> edges;
REP(i, n) {
cin >> x[i] >> y[i] >> z[i] >> r[i];
}
REP(i, n) {
REP(j, n) {
if(i == j) continue;
double c = sqrt(pow(x[i]-x[j], 2.0) + pow(y[i]-y[j], 2.0) + pow(z[i]-z[j], 2.0)) - r[i] - r[j];
edges.push_back(edge(i, j, max(0.0, c)));
}
}
sort(edges.rbegin(), edges.rend());
double ans = 0;
for(auto e : edges) {
if(!uf.same(e.src, e.dst)) {
uf.unite(e.src, e.dst);
ans += e.cost;
}
}
printf("%.3f\n", ans);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int N, M, MAX, REG, ROUND;
int POW[1111], DMG[1111], Ret[1111], Res[1111];
bool ATTACK[1111];
int main() {
scanf("%d%d%d", &N, &MAX, ®);
for (int i = 1; i <= N; i++) scanf("%d%d", &POW[i], &DMG[i]);
int NOW = MAX;
for (int i = 0; i <= MAX + REG; i++) {
ROUND++;
int k = 0;
for (int j = 1; j <= N; j++)
if (NOW * 100 <= POW[j] * MAX && !ATTACK[j] && DMG[j] > DMG[k]) k = j;
if (k > 0) {
ATTACK[k] = true;
Ret[M] = i;
Res[M++] = k;
}
for (int j = 1; j <= N; j++)
if (ATTACK[j]) NOW -= DMG[j];
NOW += REG;
if (NOW >= MAX) NOW = MAX;
if (NOW <= 0) break;
}
if (NOW <= 0) {
printf("YES\n");
printf("%d %d\n", ROUND, M);
for (int i = 0; i < M; i++) printf("%d %d\n", Ret[i], Res[i]);
} else {
printf("NO\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, c[35], d[35], o;
while (cin >> a) {
int i, j;
int b[35][35];
for (i = 0; i < a; i++) {
for (j = 0; j < a; j++) {
cin >> b[i][j];
}
}
for (i = 0; i < a; i++) {
o = 0;
for (j = 0; j < a; j++) {
o += b[i][j];
}
c[i] = o;
}
for (j = 0; j < a; j++) {
o = 0;
for (i = 0; i < a; i++) {
o += b[i][j];
}
d[j] = o;
}
int m = 0;
for (i = 0; i < a; i++) {
for (j = 0; j < a; j++) {
if (c[i] < d[j]) {
m++;
}
}
}
cout << m << endl;
}
}
| 1 |
#include <bits/stdc++.h>
const int MAXN = 1024;
int n;
inline int LowBit(int x) { return x & -x; }
class C_TreeArray {
public:
C_TreeArray() { memset(tr, 0, sizeof(tr)); }
~C_TreeArray() {}
void Modify(int x, long long v) {
while (x <= n) {
tr[x] ^= v;
x += LowBit(x);
}
}
long long Sum(int x) {
long long ans = 0;
while (x) {
ans ^= tr[x];
x -= LowBit(x);
}
return ans;
}
long long tr[MAXN];
};
class C_Xor_TreeArray {
public:
void Modify(int x, long long v) { tr[x & 1].Modify(x, v); }
long long Sum(int x) { return tr[x & 1].Sum(x); }
C_TreeArray tr[2];
};
class C_2D_TreeArray {
public:
void Modify(int x, int y, long long v) {
while (x <= n) {
tr[x].Modify(y, v);
x += LowBit(x);
}
}
long long Sum(int x, int y) {
long long ans = 0;
while (x) {
ans ^= tr[x].Sum(y);
x -= LowBit(x);
}
return ans;
}
C_Xor_TreeArray tr[MAXN];
};
class C_2D_Xor_TreeArray {
public:
void Modify(int x, int y, long long v) { tr[x & 1].Modify(x, y, v); }
long long Sum(int x, int y) { return tr[x & 1].Sum(x, y); }
C_2D_TreeArray tr[2];
} tt;
int main() {
int m, x0, x1, y0, y1;
long long v;
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d", &x0);
if (x0 == 1) {
scanf("%d%d%d%d", &x0, &y0, &x1, &y1);
printf("%I64d\n", tt.Sum(x1, y1) ^ tt.Sum(x0 - 1, y1) ^
tt.Sum(x1, y0 - 1) ^ tt.Sum(x0 - 1, y0 - 1));
} else {
scanf("%d%d%d%d%I64d", &x0, &y0, &x1, &y1, &v);
tt.Modify(x0, y0, v);
tt.Modify(x1 + 1, y0, v);
tt.Modify(x0, y1 + 1, v);
tt.Modify(x1 + 1, y1 + 1, v);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
const long long INFL = 1e18;
const long long N = 1e5 + 7;
const long long hMod = 239017;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n;
cin >> n;
vector<long long> a;
for (long long i = 0, x; i < n; i++) {
cin >> x;
a.push_back(x);
}
long long z = (1 << 22) - 1;
vector<long long> f(z);
for (long long i = 0; i < n; i++) {
f[a[i]] = a[i];
}
for (long long mask = 1; mask < z; mask++) {
for (long long i = 0; i < 22; i++) {
if ((mask & (1 << i)) && f[mask - (1 << i)]) f[mask] = f[mask - (1 << i)];
}
}
for (long long i = 0; i < n; i++) {
long long x = a[i] ^ z;
if (f[x] == 0) f[x] = -1;
cout << f[x] << " ";
}
return 0;
}
| 5 |
#include <iostream>
using namespace std;
string s;
int main(){
while(1){
cin>>s;
if(s=="0") break;
int ans=0,S=s.size();
for(int i=0;i<S;i++) ans+=s[i]-'0';
cout<<ans<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int a[3000005], sum[3000005], b[3000005], i, num, allsum, x, y, n, q;
int main() {
scanf("%d%d", &n, &q);
while (q--) {
scanf("%d%d", &x, &y);
if (x == 1) {
a[++num] = y;
sum[y]++;
allsum++;
} else if (x == 2) {
allsum -= sum[y];
sum[y] = 0;
b[y] = num;
} else if (x == 3) {
while (i <= y) {
if (i > b[a[i]]) {
allsum--;
sum[a[i]]--;
}
i++;
}
}
printf("%d\n", allsum);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n;
int p[100005];
int main() {
cin >> n;
if (n % 4 > 1) {
cout << -1;
return 0;
}
p[(n + 1) / 2] = (n + 1) / 2;
for (int i = 0; i < n / 4; i++) {
p[1 + 2 * i] = (i + 1) * 2;
p[2 + 2 * i] = n - 2 * i;
p[n - 2 * i] = n - 1 - 2 * i;
p[n - 2 * i - 1] = i * 2 + 1;
}
for (int i = 1; i <= n; i++) {
cout << p[i] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
string s;
cin >> s;
long long int cnt = 0;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'a' || s[i] == 'e' || s[i] == 'i' || s[i] == 'o' ||
s[i] == 'u')
cnt++;
else if (s[i] == '1' || s[i] == '3' || s[i] == '5' || s[i] == '7' ||
s[i] == '9')
cnt++;
}
cout << cnt << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
int N, head[200001], next[399999], to[399999], id[399999], E, O, q[200001],
fa[200001], d[200001];
std::vector<int> V[200001];
int main() {
scanf("%d", &N);
for (int i = 1, u, v; i < N; i++) {
scanf("%d%d", &u, &v);
d[u]++;
d[v]++;
next[++E] = head[u], to[E] = v, id[E] = i, head[u] = E;
next[++E] = head[v], to[E] = u, id[E] = i, head[v] = E;
}
O = *std::max_element(d + 1, d + N + 1);
q[1] = 1;
d[1] = O;
int H = 0, T = 1, u;
while (H < T)
for (int e = head[u = q[++H]], z = d[u]; e; e = next[e])
if (to[e] != fa[u]) {
fa[q[++T] = to[e]] = u;
z = z == O ? 1 : z + 1;
d[to[e]] = z;
V[d[to[e]]].push_back(id[e]);
}
printf("%d\n", O);
for (int i = 1; i <= O; i++) {
printf("%d", int(V[i].size()));
for (int j : V[i]) printf(" %d", j);
putchar(10);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, C;
int none, mx;
int l[(1 << 19)], r[(1 << 19)], cost[(1 << 19)];
int id[(1 << 19)], pos[(1 << 19)];
int ans[(1 << 19)];
map<int, int> two[(1 << 19)];
int one[(1 << 19)];
int mx_with[(1 << 19)];
struct RMQ_Tree {
int n;
int mx[1 << 20];
void init(int _n) {
for (n = 1; n < _n; n <<= 1)
;
for (int i = n << 1; --i;) mx[i] = 0;
}
void insert(int p, int val) {
p += n - 1;
for (; p && val > mx[p]; p >>= 1) mx[p] = val;
}
int calc(int st, int ed) {
if (st > ed) return 0;
st += n - 1;
ed += n;
int ans = 0;
while (st < ed) {
if (st & 1) ans = max(ans, mx[st++]);
if (ed & 1) ans = max(ans, mx[ed ^ 1]);
st >>= 1;
ed >>= 1;
}
return ans;
}
} Tree;
int main() {
cin >> n >> C;
vector<pair<int, int> > vec;
for (int i = 1; i <= n; i++) {
scanf("%d %d %d", l + i, r + i, cost + i);
id[i] = i;
vec.push_back(pair<int, int>(l[i], i));
vec.push_back(pair<int, int>(r[i], -i));
}
sort(id + 1, id + n + 1, [](int u, int v) { return cost[u] < cost[v]; });
for (int i = 1; i <= n; i++) pos[id[i]] = i;
vec.push_back(pair<int, int>(2000000000, 0));
sort(vec.begin(), vec.end());
int m;
cin >> m;
vector<pair<int, int> > que;
for (int i = 0, p; i < m; i++) {
scanf("%d", &p);
que.push_back(pair<int, int>(p, i));
}
sort(que.begin(), que.end());
set<int> cloud;
Tree.init(n);
int now = 0, cur = 0;
for (pair<int, int> p : vec) {
int del = p.first - now;
now = p.first;
if (cloud.empty())
none += del;
else if (cloud.size() == 1) {
int first = *cloud.begin();
one[first] += del;
Tree.insert(pos[first], one[first]);
if (cost[first] <= C) {
mx = max(mx, one[first] + mx_with[first]);
int st = 0, ed = n + 1;
while (ed - st > 1) {
int mid = st + ed >> 1;
if (cost[id[mid]] + cost[first] <= C)
st = mid;
else
ed = mid;
}
mx = max(mx, one[first] + Tree.calc(1, min(st, pos[first] - 1)));
mx = max(mx, one[first] + Tree.calc(pos[first] + 1, st));
}
} else if (cloud.size() == 2) {
int first = *cloud.begin();
int second = *--cloud.end();
two[first][second] += del;
two[second][first] += del;
if (cost[first] + cost[second] <= C) {
mx_with[first] = max(mx_with[first], two[first][second] + one[second]);
mx_with[second] = max(mx_with[second], two[second][first] + one[first]);
mx = max(mx, one[first] + one[second] + two[first][second]);
}
}
while (cur < m && que[cur].first <= none + mx) {
ans[que[cur].second] = now - (none + mx - que[cur].first);
cur++;
}
if (p.second > 0)
cloud.insert(p.second);
else
cloud.erase(-p.second);
}
for (int i = 0; i < m; i++) printf("%d\n", ans[i]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
class Messenger {
const int MAGIC = 200;
vector<bool> isHeavy;
vector<bool> isOnline;
vector<set<int> > lightFriends;
vector<set<int> > heavyFriends;
vector<int> onlineLightFriendCount;
void makeHeavy(int u) {
assert(isHeavy[u] == false);
isHeavy[u] = true;
for (int v : lightFriends[u]) {
lightFriends[v].erase(u);
heavyFriends[v].insert(u);
onlineLightFriendCount[v] -= isOnline[u];
}
for (int v : heavyFriends[u]) {
lightFriends[v].erase(u);
heavyFriends[v].insert(u);
onlineLightFriendCount[v] -= isOnline[u];
}
}
void makeLight(int u) {
assert(isHeavy[u] == true);
isHeavy[u] = false;
for (int v : lightFriends[u]) {
heavyFriends[v].erase(u);
lightFriends[v].insert(u);
onlineLightFriendCount[v] += isOnline[u];
}
for (int v : heavyFriends[u]) {
heavyFriends[v].erase(u);
lightFriends[v].insert(u);
onlineLightFriendCount[v] += isOnline[u];
}
}
public:
Messenger(int n)
: isHeavy(n + 1, false),
isOnline(n + 1, false),
lightFriends(n + 1),
heavyFriends(n + 1),
onlineLightFriendCount(n + 1, 0) {}
void login(int u) {
assert(isOnline[u] == false);
isOnline[u] = true;
if (!isHeavy[u]) {
for (int v : heavyFriends[u]) onlineLightFriendCount[v]++;
for (int v : lightFriends[u]) onlineLightFriendCount[v]++;
}
}
void logout(int u) {
assert(isOnline[u] == true);
isOnline[u] = false;
if (!isHeavy[u]) {
for (int v : heavyFriends[u]) onlineLightFriendCount[v]--;
for (int v : lightFriends[u]) onlineLightFriendCount[v]--;
}
}
void add_friend(int u, int v) {
if (isHeavy[v])
heavyFriends[u].insert(v);
else {
lightFriends[u].insert(v);
onlineLightFriendCount[u] += isOnline[v];
}
if (isHeavy[u])
heavyFriends[v].insert(u);
else {
lightFriends[v].insert(u);
onlineLightFriendCount[v] += isOnline[u];
}
if (heavyFriends[u].size() + lightFriends[u].size() == MAGIC + 1)
makeHeavy(u);
if (heavyFriends[v].size() + lightFriends[v].size() == MAGIC + 1)
makeHeavy(v);
}
void del_friend(int u, int v) {
if (isHeavy[v])
heavyFriends[u].erase(v);
else {
lightFriends[u].erase(v);
onlineLightFriendCount[u] -= isOnline[v];
}
if (isHeavy[u])
heavyFriends[v].erase(u);
else {
lightFriends[v].erase(u);
onlineLightFriendCount[v] -= isOnline[u];
}
if (heavyFriends[u].size() + lightFriends[u].size() == MAGIC) makeLight(u);
if (heavyFriends[v].size() + lightFriends[v].size() == MAGIC) makeLight(v);
}
int count_online_friends(int u) {
int ans = onlineLightFriendCount[u];
for (int v : heavyFriends[u]) ans += isOnline[v];
return ans;
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m, q;
cin >> n >> m >> q;
Messenger msngr(n);
int o;
cin >> o;
for (int i = 1; i <= o; i++) {
int u;
cin >> u;
msngr.login(u);
}
while (m--) {
int u, v;
cin >> u >> v;
msngr.add_friend(u, v);
}
while (q--) {
char c;
cin >> c;
if (c == 'O') {
int u;
cin >> u;
msngr.login(u);
} else if (c == 'F') {
int u;
cin >> u;
msngr.logout(u);
} else if (c == 'A') {
int u, v;
cin >> u >> v;
msngr.add_friend(u, v);
} else if (c == 'D') {
int u, v;
cin >> u >> v;
msngr.del_friend(u, v);
} else {
assert(c == 'C');
int u;
cin >> u;
cout << msngr.count_online_friends(u) << "\n";
}
}
return 0;
}
| 4 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#define int long long
using namespace std;
signed main() {
int m; cin >> m;
int a[123456], p = m - 2;
for (int i = 0; i < m; i++)cin >> a[i]; sort(a, a + m, greater<int>());
for (int i = 0; i < m - 1; i++) {
if (a[i + 1] <= 0) {
p = i;
break;
}
}
int ans = a[p + 1];
for (int i = p; i > 0; i--) {
ans -= a[i];
}
ans = a[0] - ans;
for (int i = p + 2; i < m; i++)ans -= a[i];
cout << ans << endl;
ans = a[p + 1];
for (int i = p; i > 0; i--) {
cout << ans << ' ' << a[i] << endl;
ans -= a[i];
}
cout << a[0] << ' ' << ans << endl;
ans = a[0] - ans;
for (int i = p + 2; i < m; i++) {
cout << ans << ' ' << a[i] << endl;
ans -= a[i];
}
cin >> m;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const int inf = 1000000009;
int i, j, k, m, n, l;
int ans;
int a[601][601], b[601][601];
long long c[16][16], dp[16][1 << 16], path[16][1 << 16];
long long dist(int i, int j) {
long long ret = 0;
int div = 2;
for (int k = 0; k < n / div; k++) {
long long s1 = 0, s2 = 0;
for (int u = k * div; u < (k + 1) * div; u++) {
s1 += a[i][u];
s2 += a[j][u];
}
ret += abs(s1 - s2);
}
return ret;
}
int main() {
int tn;
cin >> tn;
while (tn--) {
cin >> m >> n >> k;
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) scanf("%d", &a[i][j]);
for (int i = 0; i < k; i++)
for (int j = 0; j < k; j++) {
c[i][j] = dist((i + 1) * (m / k) - 1, j * (m / k));
}
if (0)
for (int i = 0; i < k; i++) {
for (int j = 0; j < k; j++) cout << c[i][j] << " ";
cout << endl;
}
if (0) {
for (int i = 0; i < m - 1; i++) {
if ((i + 1) % (m / k) == 0)
cout << "-----------------------------" << endl;
cout << dist(i, i + 1) << endl;
}
cout << "Last: " << dist(m - 1, 0) << " " << c[2][0] << endl;
}
memset(dp, -1, sizeof(dp));
;
for (int i = 0; i < k; i++) {
dp[i][1 << i] = 0;
path[i][1 << i] = -1;
}
for (int j = 0; j < (1 << k); j++)
for (int i = 0; i < k; i++)
if (dp[i][j] != -1)
for (int p = 0; p < k; p++)
if (((1 << p) & j) == 0) {
if (dp[p][j ^ (1 << p)] == -1 ||
dp[p][j ^ (1 << p)] > dp[i][j] + c[i][p]) {
dp[p][j ^ (1 << p)] = dp[i][j] + c[i][p];
path[p][j ^ (1 << p)] = i;
}
}
int i = 0;
for (int j = 0; j < k; j++)
if (dp[j][(1 << k) - 1] < dp[i][(1 << k) - 1]) i = j;
vector<int> ret;
int j = (1 << k) - 1;
while (path[i][j] != -1) {
ret.push_back(i);
int newj = j ^ (1 << i);
i = path[i][j];
j = newj;
}
ret.push_back(i);
reverse(ret.begin(), ret.end());
vector<int> sol(k);
for (int i = 0; i < ((int)ret.size()); i++) sol[ret[i]] = i;
for (int i = 0; i < ((int)sol.size()); i++) cout << sol[i] + 1 << " ";
cout << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
n /= 1000;
if (n & 1)
cout << 2 << endl;
else
cout << 1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int get() {
char ch;
while (ch = getchar(), (ch < '0' || ch > '9') && ch != '-')
;
if (ch == '-') {
int s = 0;
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return -s;
}
int s = ch - '0';
while (ch = getchar(), ch >= '0' && ch <= '9') s = s * 10 + ch - '0';
return s;
}
const int N = 2e3 + 5;
const int mo = 998244353;
int n;
int a[N][N];
long long f[N][N];
long long add(long long x, long long y) {
return x + y >= mo ? x + y - mo : x + y;
}
long long dec(long long x, long long y) { return x < y ? x - y + mo : x - y; }
long long quickmi(long long x, long long tim) {
long long ret = 1;
for (; tim; tim /= 2, x = x * x % mo)
if (tim & 1) ret = ret * x % mo;
return ret;
}
int tree[2][N];
void add(int t, int x, int v) {
for (; x <= n; x += x & -x) tree[t][x] += v;
}
int query(int t, int x) {
int ret = 0;
for (; x; x -= x & -x) ret += tree[t][x];
return ret;
}
bool bz0[N], bz1[N];
int main() {
n = get();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++) a[i][j] = get();
f[0][0] = 1;
for (int i = 1; i <= n; i++) {
f[i][0] = f[i - 1][0] * i % mo;
for (int j = 1; j <= i; j++) f[i][j] = dec(f[i][j - 1], f[i - 1][j - 1]);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
for (int x = 0; x <= n; x++) bz0[x] = bz1[x] = tree[0][x] = tree[1][x] = 0;
int res = n;
long long r = 0;
if (i == 1) {
for (int j = 1; j <= n; j++) {
int x = a[i][j];
add(0, x, 1);
r = (r + f[n - j][0] * (x - query(0, x))) % mo;
}
} else {
for (int x = 1; x <= n; x++) add(0, x, 1), add(1, x, 1);
for (int j = 1; j <= n; j++) {
int x = a[i][j];
int y = a[i - 1][j];
int v0 = query(0, x - 1), v1 = query(1, x - 1);
if (x > y && !bz0[y]) v0--, v1--;
int r1 = !bz0[y] ? res - 1 : res;
r = (r + f[n - j][r1] * (v0 - v1) % mo +
(r1 ? f[n - j][r1 - 1] * v1 % mo : 0)) %
mo;
add(0, x, -1);
if (!bz1[x]) add(1, x, -1), res--;
if (!bz0[y]) add(1, y, -1), res--;
bz0[x] = bz1[y] = 1;
}
}
ans = (ans + r * quickmi(f[n][n], n - i)) % mo;
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define all(x) (x).begin(),(x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout<<#x" = "<<((x))<<endl
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
const int N = 20;
int ans[N+1][N+1];
int main(){
for(int i=2; i<=N; ++i){
vector<bool> vis(i+1);
vector<int> a(i+1);
a[0] = i;
vis[0] = true;
int t = 0;
while(!vis[i-1]){
++t;
vector<int> na(i+1);
rep(j,i){
na[j+1] += a[j]/2;
na[0] += a[j]/2;
na[j] += a[j]%2;
if(!vis[j] && na[j]>0){
vis[j] = true;
ans[i][j] = t;
}
}
a = na;
}
}
int C = 1;
int n,m;
while(scanf(" %d %d", &n, &m),n) printf("Case %d: %d\n", C++, ans[n][m]);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define fst(t) std::get<0>(t)
#define snd(t) std::get<1>(t)
#define thd(t) std::get<2>(t)
#define unless(p) if(!(p))
#define until(p) while(!(p))
using ll = long long;
using P = std::tuple<int,int>;
using ui = unsigned int;
const int dx[8] = {-1, 1, 0, 0, -1, -1, 1, 1}, dy[8] = {0, 0, -1, 1, -1, 1, -1, 1};
struct SegmentTree{
SegmentTree(int n){
size = 1;
while(size < n){
size *= 2;
}
for(int i=1;i<2*size;++i){
data[i] = D;
}
}
void propagate(int k){
if(delayed[k]){
data[k] = data2[k];
if(k < size){
data2[k*2] = data2[k*2+1] = data2[k];
delayed[k*2] = delayed[k*2+1] = true;
}
delayed[k] = false;
}
}
void update(ui x, int l, int r){
_update(1, 0, size, x, l, r);
}
inline void _update(int k, int a, int b, ui x, int l, int r){
propagate(k);
if(b <= l || r <= a){return;}
if(l <= a && b <= r){
data2[k] = x;
delayed[k] = true;
propagate(k);
}else{
int mid = (a + b) / 2;
_update(k * 2, a, mid, x, l, r);
_update(k * 2 + 1, mid, b, x, l, r);
data[k] = min(data[k*2], data[k*2+1]);
}
}
ui minimum(int l, int r){
return _minimum(1, 0, size, l, r);
}
inline ui _minimum(int k, int a, int b, int l, int r){
propagate(k);
if(b <= l || r <= a){return D;}
if(l <= a && b <= r){return data[k];}
int mid = (a + b) / 2;
ui vl = _minimum(k * 2, a, mid, l, r),
vr = _minimum(k * 2 + 1, mid, b, l, r);
return min(vl, vr);
}
int size;
bool delayed[400100]; // 伝搬されていないときtrue
ui data[400100], data2[400100];
const ui D = (1u << 31) - 1;
};
int N, Q;
SegmentTree segtree(100000);
int main(){
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
std::cin >> N >> Q;
for(int i=0;i<Q;++i){
int type, s, t;
std::cin >> type >> s >> t;
if(type == 0){
ui x;
std::cin >> x;
segtree.update(x, s, t + 1);
}else{
std::cout << segtree.minimum(s, t + 1) << std::endl;
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void maxi(T &x, T y) {
if (y > x) x = y;
}
template <class T>
inline void mini(T &x, T y) {
if (y < x) x = y;
}
const int N = 1e6 + 5, B = 0x7fffffff;
vector<string> si;
char s[N];
string ss = "";
vector<string> lvl[N];
bool vis[N];
int ma;
int tod(string s) {
int ret = 0;
int der = 1;
for (int i = (int)s.size() - 1; i >= 0; i--) {
ret += (der * (s[i] - '0'));
der *= 10;
}
return ret;
}
int rec(int wher, int lv) {
vis[wher] = 1;
maxi(ma, lv);
lvl[lv].push_back(si[wher]);
if (si[wher + 1] == "0") return wher + 2;
int dig = tod(si[wher + 1]);
int pq = wher + 2;
for (int i = 1; i <= dig; i++) {
int nas = rec(pq, lv + 1);
pq = nas;
}
return pq;
}
int main() {
scanf("%s", s);
int n = strlen(s);
for (int i = 0; i < n; i++) {
if (s[i] == ',' || i == n - 1) {
if (i == n - 1) ss += s[i];
si.push_back(ss);
ss = "";
} else
ss += s[i];
}
for (int i = 0; i < (int)si.size(); i++) {
if (si[i][0] == ',' || isdigit(si[i][0])) continue;
if (vis[i] == 0) rec(i, 1);
}
printf("%d\n", ma);
for (int i = 1; i <= ma; i++) {
for (string s : lvl[i]) cout << s << ' ';
puts("");
}
return !!0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[303], b[303];
int n;
int main() {
int i;
scanf("%d", &n);
for (i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (i = 1; i <= n; ++i) {
while (b[i] < a[i]) {
if (i == n) {
printf("P");
++b[i];
if (b[i] < a[i]) printf("LR");
continue;
}
printf("P");
++b[i];
if (b[i] < a[i]) {
printf("R");
if (b[i + 1] < a[i + 1]) {
++b[i + 1];
printf("P");
}
printf("L");
}
}
if (i != n) printf("R");
}
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e3;
int n, k, db;
vector<int> pr;
set<int> s;
bool p[maxn + 1];
void solve() {
cin >> n >> k;
for (int i = 2; i <= maxn; ++i) {
if (p[i]) continue;
pr.push_back(i);
s.insert(i);
for (int j = 2 * i; j <= maxn; j += i) {
p[j] = true;
}
}
for (int i = 2; i <= n; ++i) {
if (!s.count(i)) continue;
bool van = false;
for (int j = 0; j < pr.size() - 1; ++j) {
if (pr[j] + pr[j + 1] + 1 == i) {
van = true;
}
}
if (van) ++db;
}
if (db < k) {
cout << "NO\n";
} else {
cout << "YES\n";
}
}
int main() {
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
class SqrMatrix {
static int n;
static bool objectCreated;
T* values;
public:
SqrMatrix() {
values = new T[n * n];
objectCreated = true;
}
SqrMatrix(int n_) {
if (objectCreated) {
values = new T[n * n];
} else {
n = n_;
values = new T[n * n];
objectCreated = true;
}
}
SqrMatrix(const SqrMatrix& source) {
values = new T[n * n];
for (int i = 0; i < n * n; i++) {
values[i] = source.values[i];
}
}
~SqrMatrix() { delete values; }
SqrMatrix<T>& operator=(const SqrMatrix<T>& rhs) {
for (int i = 0; i < n * n; i++) {
values[i] = rhs.values[i];
}
return *this;
}
static int size() { return n; }
T* operator[](int ind) { return (values + (n * ind)); }
static SqrMatrix<T> Zero() {
SqrMatrix<T> result;
for (int i = 0; i < n * n; i++) {
result.values[i] = 0;
}
return result;
}
static SqrMatrix<T> One() {
SqrMatrix<T> result;
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (i == j) {
result[i][j] = 1;
} else {
result[i][j] = 0;
}
}
}
return result;
}
SqrMatrix<T> times(SqrMatrix<T>& multiplier) {
SqrMatrix<T> result;
int i, j, k;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
result[i][j] = 0;
for (k = 0; k < n; k++) {
result[i][j] += (*this)[i][k] * multiplier[k][j];
}
}
}
return result;
}
SqrMatrix<T> pwr(unsigned long long n) {
SqrMatrix<T> result;
SqrMatrix<T> currentPwr(*this);
result = SqrMatrix<T>::One();
while (n > 0) {
if (n % 2 == 1) {
result = result.times(currentPwr);
}
currentPwr = currentPwr.times(currentPwr);
n /= 2;
}
return result;
}
};
template <typename T>
bool SqrMatrix<T>::objectCreated = false;
template <typename T>
int SqrMatrix<T>::n = 2;
int main() {
int n, m, x, y, z, p;
int xi, yi;
int xi_, yi_;
SqrMatrix<int> Rotate(2);
SqrMatrix<int> Reflect;
SqrMatrix<int> Transform;
Rotate[0][0] = 0;
Rotate[0][1] = 1;
Rotate[1][0] = -1;
Rotate[1][1] = 0;
Reflect[0][0] = 1;
Reflect[0][1] = 0;
Reflect[1][0] = 0;
Reflect[1][1] = -1;
cin >> n >> m >> x >> y >> z >> p;
x %= 4;
y %= 2;
z %= 4;
x += 4 + (2 * y - 1) * z;
x %= 4;
Reflect = Reflect.pwr(y);
Rotate = Rotate.pwr(x);
Transform = Reflect.times(Rotate);
for (int i = 0; i < p; i++) {
cin >> xi >> yi;
xi_ = Transform[0][0] * xi + Transform[0][1] * yi;
xi_ += (Transform[0][0] < 0) * (n + 1) + (Transform[0][1] < 0) * (m + 1);
yi_ = Transform[1][0] * xi + Transform[1][1] * yi;
yi_ += (Transform[1][0] < 0) * (n + 1) + (Transform[1][1] < 0) * (m + 1);
cout << xi_ << " " << yi_ << endl;
}
return 0;
}
| 3 |
#include <iostream>
#include <string>
using namespace std;
int main() {
int N;
string S;
cin >> N >> S;
if (S.substr(0, N / 2) == S.substr(N / 2, N - N / 2))
cout << "Yes" << endl;
else
cout << "No" << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000010;
const long long INF = 10000000000000010LL;
const int mod = 1000000007;
const int MAXN = 200010, LOG = 20;
long long n, m, k, u, v, x, y, t, a, b, ans;
long long A[MAXN];
long long seg[MAXN << 2], lazy[MAXN << 2];
int Mn[MAXN << 2], Mx[MAXN << 2];
void Build(int id, int tl, int tr) {
if (tr - tl == 1) {
Mn[id] = Mx[id] = seg[id] = A[tl];
return;
}
int mid = (tl + tr) >> 1;
Build(id << 1, tl, mid);
Build(id << 1 | 1, mid, tr);
Mn[id] = min(Mn[id << 1], Mn[id << 1 | 1]);
Mx[id] = max(Mx[id << 1], Mx[id << 1 | 1]);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
inline void add_lazy(int id, int len, long long val) {
Mn[id] = val;
Mx[id] = val;
lazy[id] = val;
seg[id] = len * val;
}
inline void shift(int id, int tl, int tr) {
if (!lazy[id]) return;
int mid = (tl + tr) >> 1;
add_lazy(id << 1, mid - tl, lazy[id]);
add_lazy(id << 1 | 1, tr - mid, lazy[id]);
lazy[id] = 0;
}
void Maximize(int id, int tl, int tr, int pos, long long val) {
if (pos <= tl || val <= Mn[id]) return;
if (tr <= pos && Mx[id] <= val) {
add_lazy(id, tr - tl, val);
return;
}
shift(id, tl, tr);
int mid = (tl + tr) >> 1;
Maximize(id << 1, tl, mid, pos, val);
Maximize(id << 1 | 1, mid, tr, pos, val);
Mn[id] = min(Mn[id << 1], Mn[id << 1 | 1]);
Mx[id] = max(Mx[id << 1], Mx[id << 1 | 1]);
seg[id] = seg[id << 1] + seg[id << 1 | 1];
}
int BS1(int id, int tl, int tr, int pos, long long val) {
if (tr <= pos || val < Mn[id]) return tr;
if (tr - tl == 1) return tl;
shift(id, tl, tr);
int mid = (tl + tr) >> 1, tmp = BS1(id << 1, tl, mid, pos, val);
if (tmp == mid) return BS1(id << 1 | 1, mid, tr, pos, val);
return tmp;
}
int BS2(int id, int tl, int tr, long long val) {
if (seg[id] <= val) return tr;
if (tr - tl == 1) return tl;
shift(id, tl, tr);
int mid = (tl + tr) >> 1, tmp = BS2(id << 1, tl, mid, val);
if (tmp < mid) return tmp;
return BS2(id << 1 | 1, mid, tr, val - seg[id << 1]);
}
long long Get(int id, int tl, int tr, int l, int r) {
if (r <= tl || tr <= l) return 0;
if (l <= tl && tr <= r) return seg[id];
shift(id, tl, tr);
int mid = (tl + tr) >> 1;
return Get(id << 1, tl, mid, l, r) + Get(id << 1 | 1, mid, tr, l, r);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> A[i];
Build(1, 1, n + 1);
while (m--) {
cin >> t >> x >> y;
if (t == 1)
Maximize(1, 1, n + 1, x + 1, y);
else {
ans = 0;
while (1) {
x = BS1(1, 1, n + 1, x, y);
if (x == n + 1) break;
long long val = y + Get(1, 1, n + 1, 1, x);
int xx = BS2(1, 1, n + 1, val);
ans += xx - x;
y -= Get(1, 1, n + 1, x, xx);
x = xx;
}
cout << ans << "\n";
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n;
cin >> n;
vector<long> v(n + 1);
map<long, long> m;
for (int i = 1; i <= n; i++) {
cin >> v[i];
m[v[i]]++;
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long j = 0;
while (j <= 31) {
long long curr = pow(2, j);
if (curr - v[i] == v[i])
ans += m[curr - v[i]] - 1;
else
ans += m[curr - v[i]];
j++;
}
m[v[i]]--;
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 5;
int a, n, mn = N, Cnt[N], Brk[N], Rnk[N], Saa[N], Hgh[N];
char Str[N];
void Init() {
int m = 0;
for (int i = 1; i <= n; ++i) m = max(m, Rnk[i] = Str[i]);
for (int i = 1; i <= n; ++i) ++Cnt[Rnk[i]];
for (int i = 1; i <= m; ++i) Cnt[i] += Cnt[i - 1];
for (int i = n; i >= 1; --i) Saa[Cnt[Rnk[i]]--] = i;
for (int k = 1; k <= n; k <<= 1) {
int p = 0;
for (int i = 1; i <= k; ++i) Brk[++p] = n - k + i;
for (int i = 1; i <= n; ++i)
if (Saa[i] > k) Brk[++p] = Saa[i] - k;
for (int i = 1; i <= m; ++i) Cnt[i] = 0;
for (int i = 1; i <= n; ++i) ++Cnt[Rnk[i]];
for (int i = 1; i <= m; ++i) Cnt[i] += Cnt[i - 1];
for (int i = n; i >= 1; --i) Saa[Cnt[Rnk[Brk[i]]]--] = Brk[i];
for (int i = 1; i <= n; ++i) Brk[i] = Rnk[i];
Rnk[Saa[1]] = m = 1;
for (int i = 2; i <= n; ++i)
Rnk[Saa[i]] = (Brk[Saa[i]] == Brk[Saa[i - 1]] &&
Brk[Saa[i] + k] == Brk[Saa[i - 1] + k])
? m
: ++m;
if (m == n) break;
}
for (int i = 1, j = 0; i <= n; ++i) {
if (Rnk[i] == 1) continue;
while (Str[i + j] == Str[Saa[Rnk[i] - 1] + j]) ++j;
Hgh[Rnk[i]] = j;
if (j) --j;
}
}
int main() {
scanf("%s", Str + 1);
a = n = strlen(Str + 1) + 1;
Str[n] = '$';
scanf("%s", Str + n + 1);
n = strlen(Str + 1);
Init();
for (int i = 2; i <= n; ++i)
if (Hgh[i] > Hgh[i - 1] && Hgh[i] > Hgh[i + 1] &&
((Saa[i] <= a) ^ (Saa[i - 1] <= a)))
mn = min(mn, max(Hgh[i - 1], Hgh[i + 1]) + 1);
printf("%d\n", (mn == N) ? -1 : mn);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 4e5 + 5;
int f[MAXN], u[MAXN], v[MAXN], con[MAXN];
pair<int, int> ans[MAXN];
bool ss[MAXN], tt[MAXN];
int n, m, tot;
int s, t, ds, dt, fa, fb;
int brg, both, now;
int find(int a) {
if (a != f[a]) f[a] = find(f[a]);
return f[a];
}
int main() {
while (~scanf("%d%d", &n, &m)) {
for (int i = 0; i < m; ++i) {
scanf("%d%d", u + i, v + i);
}
scanf("%d%d%d%d", &s, &t, &ds, &dt);
brg = both = tot = 0;
for (int i = 1; i <= n; ++i) f[i] = i;
bool flag = false;
memset(ss, false, sizeof(ss));
memset(tt, false, sizeof(tt));
memset(con, -1, sizeof(con));
for (int i = 0; i < m; ++i) {
if (v[i] == s) swap(u[i], v[i]);
if (u[i] == s) {
if (v[i] == t)
;
else {
ss[find(v[i])] = true;
}
} else {
if (v[i] == t) swap(u[i], v[i]);
if (u[i] == t) {
tt[find(v[i])] = true;
} else {
fa = find(u[i]);
fb = find(v[i]);
if (fa == fb) continue;
f[fb] = fa;
ss[fa] |= ss[fb];
tt[fa] |= tt[fb];
ans[tot++] = {u[i], v[i]};
}
}
}
--ds;
--dt;
for (int i = 1; i <= n; ++i)
if (i != s && i != t && i == find(i)) {
if (ss[i] && tt[i]) {
if (brg)
con[i] = 0, ++both;
else
brg = i;
} else if (ss[i]) {
--ds;
con[i] = s;
if (ds < 0) {
flag = true;
goto END;
}
} else if (tt[i]) {
--dt;
con[i] = t;
if (dt < 0) {
flag = true;
goto END;
}
}
}
if (both > ds + dt) {
flag = true;
goto END;
}
if (brg) {
now = 3;
for (int i = 0; i < m; ++i) {
if (now == 0) break;
if (u[i] == s && (now & 1) && brg == find(v[i])) {
now ^= 1;
ans[tot++] = {u[i], v[i]};
} else if (u[i] == t && (now & 2) && brg == find(v[i])) {
now ^= 2;
ans[tot++] = {u[i], v[i]};
}
}
} else
ans[tot++] = {s, t};
for (int i = 0; i < m; ++i) {
fa = find(u[i]);
fb = find(v[i]);
if (fb == s) swap(fa, fb);
if (fa == s) {
if (fb == t)
;
else if (con[fb] == s) {
f[fb] = s;
con[fb] = -1;
ans[tot++] = {u[i], v[i]};
} else if (con[fb] == 0 && ds) {
f[fb] = s;
con[fb] = -1;
ans[tot++] = {u[i], v[i]};
--ds;
}
} else {
if (fb == t) swap(fa, fb);
if (fa == t) {
if (con[fb] == t) {
f[fb] = t;
con[fb] = -1;
ans[tot++] = {u[i], v[i]};
} else if (con[fb] == 0 && dt) {
f[fb] = t;
con[fb] = -1;
ans[tot++] = {u[i], v[i]};
--dt;
}
}
}
}
END:
if (flag || tot != n - 1)
puts("No");
else {
puts("Yes");
for (int i = 0; i < tot; ++i)
printf("%d %d\n", ans[i].first, ans[i].second);
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int arr[200009];
int main() {
int n, a, b, i, z = 1000000009, k;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n - 1; i++) {
if (s[i] == 'R' && s[i + 1] == 'L') k = (arr[i + 1] - arr[i]) / 2;
z = min(z, k);
}
if (z == 1000000009)
cout << "-1" << endl;
else
cout << z << endl;
return 0;
}
| 1 |
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
int gi(){
int x=0,w=1;char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();
if(ch=='-')w=0,ch=getchar();
while(ch>='0'&&ch<='9')x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
return w?x:-x;
}
#define ll long long
const int N=1e5+5;
int n,k,l[N],r[N],o[N<<1],len,tag[N<<2];
ll tot,f[N],ans=1ll<<60;
int cost(int s,int t){return s<=t?t-s:t+k-s;}
void down(int x){if(tag[x])tag[x<<1]=tag[x<<1|1]=tag[x],tag[x]=0;}
void modify(int x,int l,int r,int ql,int qr,int c){
if(l>=ql&&r<=qr){tag[x]=c;return;}
down(x);int mid=l+r>>1;
if(ql<=mid)modify(x<<1,l,mid,ql,qr,c);
if(qr>mid)modify(x<<1|1,mid+1,r,ql,qr,c);
}
int query(int x,int l,int r,int p){
if(l==r)return tag[x];
down(x);int mid=l+r>>1;
if(p<=mid)return query(x<<1,l,mid,p);
else return query(x<<1|1,mid+1,r,p);
}
int main(){
n=gi();k=gi();
for(int i=1,las=0;i<=n;++i){
int a=gi(),b=gi();tot+=a;
if(b==1&&2*a>k)return puts("-1"),0;
a=(k-a%k<<1)%k;
if(b==1)l[i]=las,r[i]=(las+a)%k;
else l[i]=0,r[i]=k-1;
las=(las+a)%k;
}
o[++len]=0;o[++len]=k-1;
for(int i=1;i<=n;++i)o[++len]=l[i],o[++len]=r[i];
sort(o+1,o+len+1);len=unique(o+1,o+len+1)-o-1;
for(int i=n;i;--i){
l[i]=lower_bound(o+1,o+len+1,l[i])-o;
r[i]=lower_bound(o+1,o+len+1,r[i])-o;
int x=query(1,1,len,l[i]);
if(x)f[i]=f[x]+cost(o[l[i]],o[l[x]]);
if(l[i]<=r[i]){
if(l[i]>1)modify(1,1,len,1,l[i]-1,i);
if(r[i]<len)modify(1,1,len,r[i]+1,len,i);
}else if(r[i]+1<l[i])modify(1,1,len,r[i]+1,l[i]-1,i);
}
for(int i=1;i<=len;++i){
int x=query(1,1,len,i);
if(x)ans=min(ans,f[x]+cost(o[i],o[l[x]]));
else ans=0;
}
printf("%lld\n",ans+tot*2);
return 0;
}
| 0 |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
using ll = long long;
int ask(int x, int y) {
cout << "? " << x << ' ' << y << endl;
int r;
cin >> r;
return r;
}
int main() {
int n;
cin >> n;
vector<int> p(n + 1, -1);
vector<int> seen(n + 1, -1);
if (n == 1) {
cout << "! 1" << endl;
return 0;
}
auto guess = [&](int x, int y) {
int r1 = ask(x, y);
int r2 = ask(y, x);
if (r1 < r2)
return make_pair(r2, y);
else
return make_pair(r1, x);
};
for (int i = 1; i <= n - 1; i++) {
vector<int> t;
for (int j = 1; j <= n; j++) {
if (p[j] == -1) t.push_back(j);
if (t.size() >= 2) break;
}
auto it = guess(t[0], t[1]);
p[it.second] = it.first;
seen[it.first] = true;
}
int missing = -1;
for (int i = 1; i <= n; i++) {
if (seen[i] == -1) missing = i;
}
cout << "! ";
for (int i = 1; i <= n; i++) {
cout << (p[i] == -1 ? missing : p[i]) << ' ';
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int a, b;
scanf("%d", &a);
for (int i = 1;; ++i) {
a++;
b = a;
if (b < 0) b = -b;
while (b > 0) {
if (b % 10 == 8) {
printf("%d", i);
return 0;
}
b = b / 10;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int k = 0, cnt = 0;
string s;
cin >> s;
while (s.length() > 1) {
k = 0;
for (int i = 0; i < (int)s.length(); i++) k += (s[i] - '0');
s = to_string(k);
cnt++;
}
cout << cnt;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long N, L, c[32], l[32], better[32], rubles[32], i,
ans = 1000000000000000000, now, ultim;
int main() {
cin >> N >> L;
for (int i = 1; i <= N; i++) cin >> c[i];
l[1] = 1;
for (int i = 2; i <= N; i++) l[i] = 1LL * 2 * l[i - 1];
better[1] = c[1];
for (int i = 2; i <= N; i++) better[i] = min(c[i], 2 * better[i - 1]);
for (int i = N + 1; i <= 31; i++) better[i] = 1LL * 2 * better[i - 1];
for (int i = 1; i <= 31; i++)
if (L & (1 << (i - 1)))
rubles[i] = rubles[i - 1] + better[i], ultim = i;
else
rubles[i] = rubles[i - 1];
for (int i = 31; i >= 1; i--) {
if (L & (1 << (i - 1)))
now += better[i];
else
ans = min(ans, now + better[i]);
}
cout << min(ans, rubles[31]);
return 0;
}
| 3 |
#include <bits/stdc++.h>
const long long inf = 1e9 + 44;
const int MAX = 3e5 + 9;
const long long MOD = 1e9 + 7;
const double eps = 1e-10;
double const PI = 3.1415926535897931;
using namespace std;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
void _print(vector<int> v) {
cout << "[ ";
for (auto u : v) cout << u << " ";
cout << " ]" << endl;
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
set<pair<int, pair<int, int> > > st;
int arr[n + 6], l[n + 1], r[n + 1];
set<int> t;
for (int i = 0; i < n; i++) {
cin >> arr[i];
t.insert(i);
}
for (int i = 1; i < n; i++) {
if (s[i] != s[i - 1]) {
st.insert({abs(arr[i] - arr[i - 1]), {i, i - 1}});
}
}
int vis[n + 1];
memset(vis, 0, sizeof(vis));
vector<pair<int, int> > ans;
while (st.size()) {
pair<int, pair<int, int> > now = *st.begin();
st.erase(st.begin());
int u = now.second.first;
int v = now.second.second;
if (t.find(u) == t.end() || t.find(v) == t.end()) continue;
ans.push_back(now.second);
t.erase(u);
t.erase(v);
auto it = t.lower_bound(v);
if (it != t.end()) {
auto it1 = it;
if (it != t.begin()) it--;
if (s[*it] != s[*it1])
st.insert({abs(arr[*it] - arr[*it1]), {*it1, *it}});
}
}
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++)
cout << ans[i].second + 1 << " " << ans[i].first + 1 << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
int a[100010];
int rui[300010];
int rui2[300010];
int n, m;
int isOK(int num){
int ans = 0;
for(int i = 0;i < n;i++){
ans += rui[max(num-a[i], 0ll)];
}
return ans;
}
int solve(int num){
int ans = 0;
for(int i = 0;i < n;i++){
ans += rui2[max(num-a[i], 0ll)] + a[i] * rui[max(num-a[i], 0ll)];
}
return ans;
}
signed main(){
cin >> n >> m;
for(int i = 0;i < n;i++){
cin >> a[i];
rui[a[i]]++;
rui2[a[i]] += a[i];
}
for(int i = 100000;i >= 0;i--){
rui[i] += rui[i+1];
rui2[i] += rui2[i+1];
}
int l = 0, r = 300000;
while(r-l > 1){
int mid = (l+r) / 2;
if(isOK(mid) >= m){
l = mid;
}else{
r = mid;
}
}
int num = isOK(r);
cout << solve(r) + (m-num) * l << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long BIAS = 1e18;
long long Mo;
long long g[20], e[20];
void step() {
e[0] = 1;
for (int i = 1; i <= 18; i++) e[i] = e[i - 1] * 10 % Mo;
g[1] = 45 % Mo;
for (int i = 2; i <= 18; i++)
g[i] = (g[i - 1] * 10 % Mo + e[i - 1] * g[1] % Mo) % Mo;
}
int main() {
cin >> Mo;
step();
long long d = (Mo - g[18] - 1) % Mo;
cout << d + 1 << ' ' << d + BIAS << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
struct mint {
long long x;
mint() : x(0) {}
mint(long long x) : x((x % mod + mod) % mod) {}
mint& fix() {
x = (x % mod + mod) % mod;
return *this;
}
mint operator-() const { return mint(0) - *this; }
mint& operator+=(const mint& a) {
if ((x += a.x) >= mod) x -= mod;
return *this;
}
mint& operator-=(const mint& a) {
if ((x += mod - a.x) >= mod) x -= mod;
return *this;
}
mint& operator*=(const mint& a) {
(x *= a.x) %= mod;
return *this;
}
mint operator+(const mint& a) const { return mint(*this) += a; }
mint operator-(const mint& a) const { return mint(*this) -= a; }
mint operator*(const mint& a) const { return mint(*this) *= a; }
bool operator<(const mint& a) const { return x < a.x; }
bool operator==(const mint& a) const { return x == a.x; }
};
template <typename T>
void show(vector<T> v) {
for (auto it : v) {
cout << it << " ";
}
cout << "\n";
}
void solve() {
int r, l;
std::cin >> l >> r;
if (l == r) {
std::cout << 0 << "\n";
return;
}
int left = (r + 1) / 2;
if (left < l) left = l;
int remain = r % left;
int rr = (r - 1) % left;
std::cout << std::max(remain, rr) << "\n";
}
int main() {
int t = 1;
std::cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int find(vector<int> &w, int a) {
int i = 0;
int n = w.size() - 1;
while (i < n) {
int mid = (i + n) / 2;
if (a == w[mid]) {
return mid + 1;
} else if (a > w[mid]) {
i = mid + 1;
} else {
n = mid;
}
}
return i + 1;
}
int main() {
int n, m;
cin >> n;
vector<int> w(n, 0);
for (int i = 0; i < n; i++) {
cin >> w[i];
if (i > 0) {
w[i] += w[i - 1];
}
}
cin >> m;
int a;
for (int i = 0; i < m; i++) {
cin >> a;
cout << find(w, a) << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[10000000] = {0};
int main() {
long long int a, b, c, l;
scanf("%lld %lld %lld", &a, &b, &c);
long long int i, j, k, sum = 0;
for (i = 1; i <= a; i++) {
for (j = 1; j <= b; j++) {
for (k = 1; k <= c; k++) {
long long int num = i * j * k;
if (arr[num] != 0) {
sum = (arr[num] % 1073741824) + (sum % 1073741824);
continue;
}
long long int cnt = 0;
long long int r = sqrt(num * 1.0);
for (l = 1; l <= r; l++) {
if (num % l == 0) {
cnt++;
}
}
if (r * r == num) {
cnt = 2 * cnt - 1;
} else {
cnt = 2 * cnt;
}
arr[num] = cnt;
sum = (cnt % 1073741824) + (sum % 1073741824);
}
}
}
printf("%lld\n", sum % 1073741824);
return 0;
}
| 2 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <algorithm>
using namespace std;
int main(){
bool judge;
char tmp[7],tmp2[7];
int sta,sta2;
char num[7],num2[7];
cin >> sta;
sta2 = sta;
while(1){
sprintf(num,"%d",sta);
sprintf(num2,"%d",sta2);
if(strlen(num) == 1) break;
strcpy(tmp,num);
strcpy(tmp2,num2);
for(int i=0,j=strlen(tmp)-1;i<=j;i++,j--) swap(tmp[i],tmp[j]);
for(int i=0,j=strlen(tmp2)-1;i<=j;i++,j--) swap(tmp2[i],tmp2[j]);
if(strcmp(tmp2,num2) == 0){
judge = false;
break;
}
if(strcmp(tmp,num) == 0){
judge = true;
break;
}
sta = atoi(num);
sta2 = atoi(num2);
sta++;
sta2--;
}
if(judge) cout << num << endl;
else cout << num2 << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<pair<int, int> > a;
vector<int> lnum;
int e[100005];
vector<pair<int, int> > res;
int p[100005];
int tr[100005];
int des;
bool luck(int u) {
while (u > 0) {
if (u % 10 != 4 && u % 10 != 7) return false;
u /= 10;
}
return true;
}
void find(int u) {
int count = 0;
while (!e[u]) {
des = u;
e[u] = 1;
int v = tr[u];
if (e[v]) break;
res.push_back(make_pair(u, v));
u = v;
count++;
}
}
int main() {
cin >> n;
for (int i = 0; i != (n); i++) {
int x;
cin >> x;
a.push_back(make_pair(x, i));
if (luck(x)) lnum.push_back(i);
}
sort(a.begin(), a.end());
for (int i = 0; i != (n); i++) p[a[i].second] = i;
for (int i = 0; i != (n); i++) tr[p[i]] = i;
for (int i = 0; i != (n); i++)
if (p[i] == i) e[i] = 1;
for (int i = 0; i != (lnum.size()); i++) {
int x = lnum[i];
if (!e[x]) find(x);
}
for (int i = 0; i != (n); i++)
if (!e[i]) {
if (!lnum.size()) {
cout << -1 << endl;
return 0;
}
int lucktg = p[lnum[0]];
res.push_back(make_pair(lucktg, i));
find(i);
res.push_back(make_pair(lucktg, des));
}
if (res.size() > 2 * n)
cout << -1 << endl;
else {
cout << res.size() << endl;
for (int i = 0; i != (res.size()); i++)
cout << res[i].first + 1 << " " << res[i].second + 1 << endl;
}
return 0;
}
| 4 |
#include <iostream>
#include<bits/stdc++.h>
using namespace std;
int main() {
int n;
cin>>n;
int a[n],i,c=0;
for(i=0;i<n;i++)
{
cin>>a[i];
}
for(i=0;i<n;i++)
{
if(a[i]!=i+1)
c++;
}
if(c<=2)
cout<<"YES";
else
cout<<"NO";
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1000005, mod = 1e9 + 7;
int n, a[MAXN];
int p[MAXN];
long long sum[MAXN];
int f[MAXN], dp[MAXN];
inline long long gcd(long long a, long long b) {
return b == 0 ? a : gcd(b, a % b);
}
inline int read() {
int a = 0, c;
do c = getchar();
while (!isdigit(c));
while (isdigit(c)) {
a = a * 10 + c - '0';
c = getchar();
}
return a;
}
int main() {
n = read();
long long tot = 0;
for (int i = 1; i <= n; i++) sum[i] = a[i] = read(), tot += a[i];
for (int i = 2; i <= n; i++) p[i] = read();
for (int i = n; i >= 2; i--) sum[p[i]] += sum[i];
for (int i = 2; i <= n; i++) {
long long k = tot / gcd(tot, sum[i]);
if (k <= n) f[k]++;
}
for (int i = n; i >= 1; i--)
for (int j = i + i; j <= n; j += i) f[j] += f[i];
int ans = 0;
dp[1]++;
for (int i = 1; i <= n; i++) {
if (f[i] != i - 1) continue;
for (int j = i + i; j <= n; j += i)
if (f[j] == j - 1) dp[j] = (dp[j] + dp[i]) % mod;
ans = (ans + dp[i]) % mod;
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct DATA {
int num, va;
int p[205];
} d[205];
int a[205], ans[205];
bool cmp(DATA x, DATA y) { return x.num > y.num; }
int main() {
int i, j, n, num;
scanf("%d", &n);
for (i = 0; i <= 103; i++) d[i].num = 0, d[i].va = i;
for (i = 1; i <= 2 * n; i++) {
scanf("%d", &a[i]);
num = d[a[i]].num;
d[a[i]].num++;
d[a[i]].p[num] = i;
}
sort(d + 10, d + 100, cmp);
int now = 1, t1 = 0, t2 = 0, uu = 0;
for (i = 10; i <= 99; i++) {
if (d[i].num == 0) break;
if (now == 1) {
num = d[i].num;
if (num >= 2) {
uu += t1 + t2;
t1++, t2++;
uu++;
} else {
uu += t2;
t1++;
}
for (j = 0; j < d[i].num; j++) {
ans[d[i].p[j]] = now;
now = now % 2 + 1;
}
} else {
num = d[i].num;
if (num >= 2) {
uu += t1 + t2;
t1++, t2++;
uu++;
} else {
uu += t1;
t2++;
}
for (j = 0; j < d[i].num; j++) {
ans[d[i].p[j]] = now;
now = now % 2 + 1;
}
}
}
printf("%d\n", uu);
for (i = 1; i <= 2 * n; i++) printf("%d ", ans[i]);
puts("");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200010;
int sum[maxn];
long long a[maxn], b[maxn];
long long n, k;
bool solve(long long now) {
long long ans = 0;
memset(sum, 0, sizeof(sum));
if (now == 0) {
for (int i = 1; i <= n; i++) {
if (((b[i] + a[i] - 1) / b[i]) < (k - 1)) {
return 0;
}
}
return 1;
}
for (int i = 1; i <= n; i++) {
long long tmp = ((k - 1) * b[i] - a[i] + now - 1) / now;
ans += tmp;
if (ans >= k) return 0;
for (int j = 0; j < tmp; j++) {
long long tmp1 = (a[i] + j * now) / b[i] + 1;
sum[min(k - 1, (a[i] + j * now) / b[i] + 1)]++;
}
}
for (int i = 1; i < k; i++) {
sum[i] += sum[i - 1];
if (sum[i] > i) return 0;
}
return 1;
}
int main() {
scanf("%lld%lld", &n, &k);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &b[i]);
long long l = 0, r = 1e18;
while (l < r) {
long long mid = (l + r) >> 1;
if (solve(mid))
r = mid;
else
l = mid + 1;
}
if (l == 1e18)
printf("-1\n");
else
printf("%lld\n", l);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1000000000;
long long n, c, x, y;
long long dist(long long x1, long long y1, long long x2, long long y2) {
return abs(x1 - x2) + abs(y1 - y2);
}
long long cnt(long long t) {
if (t == 0) return 1;
long long sum = t * t + (t + 1) * (t + 1);
if (x - t < 1) sum -= (t - x + 1) * (t - x + 1);
if (x + t > n) sum -= (x + t - n) * (x + t - n);
if (y - t < 1) sum -= (t - y + 1) * (t - y + 1);
if (y + t > n) sum -= (y + t - n) * (y + t - n);
long long d;
d = dist(x, y, 1, 1);
if (d < t) sum += (t - d) * (t - d - 1) / 2;
d = dist(x, y, 1, n);
if (d < t) sum += (t - d) * (t - d - 1) / 2;
d = dist(x, y, n, 1);
if (d < t) sum += (t - d) * (t - d - 1) / 2;
d = dist(x, y, n, n);
if (d < t) sum += (t - d) * (t - d - 1) / 2;
return sum;
}
bool ok(long long t) {
if (cnt(t) >= (long long)c) return true;
return false;
}
int main() {
cin >> n >> x >> y >> c;
long long l = 0;
long long r = 2 * n;
long long ans = 2 * n;
long long mid;
while (l <= r) {
mid = (l + r) / 2;
if (ok(mid)) {
ans = min(ans, mid);
r = mid - 1;
} else
l = mid + 1;
}
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
if (n % 2 == 0) {
cout << a[(n / 2) - 1];
} else if (n % 2 == 1) {
cout << a[n / 2];
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define INF 1000000000
#define MAX_V 202
using namespace std;
typedef pair<int, int> P;
struct edge {
int to, cap, cost, rev;
edge(int to_, int cap_, int cost_, int rev_)
: to(to_), cap(cap_), cost(cost_), rev(rev_) {}
};
int V;
vector<edge> G[MAX_V];
int h[MAX_V];
int dist[MAX_V];
int prevv[MAX_V], preve[MAX_V];
void AddEdge(int from, int to, int cap, int cost) {
G[from].push_back(edge(to, cap, cost, G[to].size()));
G[to].push_back(edge(from, 0, -cost, G[from].size() - 1));
}
int MinimumCostFlow(int s, int t, int f) {
int res = 0;
fill(h, h + V, 0);
while (f > 0) {
priority_queue<P, vector<P>, greater<P>> que;
fill(dist, dist + V, INF);
dist[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top(); que.pop();
int v = p.second;
if (dist[v] < p.first) continue;
for (size_t i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push(P(dist[e.to], e.to));
}
}
}
if (dist[t] == INF) return -1;
for (int v = 0; v < V; v++)
h[v] += dist[v];
int d = f;
for (int v = t; v != s; v = prevv[v]) {
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
int main()
{
int n;
cin >> n;
V = n * 2 + 2;
vector<vector<int>> W(n, vector<int>(n)), E(n, vector<int>(n));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> W[i][j];
}
AddEdge(n * 2, i, 1, 0);
AddEdge(n + i, n * 2 + 1, 1, 0);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
cin >> E[i][j];
}
}
vector<string> s(n);
int def = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
for (int j = 0; j < n; j++) {
if (s[i][j] == '.') {
AddEdge(i, n + j, 1, W[i][j]);
}
else {
AddEdge(i, n + j, 1, -E[i][j]);
def += E[i][j];
}
}
}
cout << MinimumCostFlow(n * 2, n * 2 + 1, n) + def << endl;
int res = 0;
for (int i = 0; i < n; i++) {
for (auto & e : G[i]) {
if (e.cap == 1 && e.to - n < n && s[i][e.to - n] != '.') {
res++;
}
else if (e.cap == 0 && e.to - n < n && s[i][e.to - n] != 'o') {
res++;
}
}
}
cout << res << endl;
for (int i = 0; i < n; i++) {
for (auto & e : G[i]) {
if (e.cap == 1 && e.to - n < n && s[i][e.to - n] != '.') {
cout << i + 1 << ' ' << e.to - n + 1 << " erase" << endl;
}
else if (e.cap == 0 && e.to - n < n && s[i][e.to - n] != 'o') {
cout << i + 1 << ' ' << e.to - n + 1 << " write" << endl;
}
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, i, j, k;
cin >> n >> m;
vector<int> v1[505 * 2];
vector<int> v2[505 * 2];
int a, b, l1, l2;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> a;
v1[i + j].push_back(a);
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> b;
v2[i + j].push_back(b);
}
}
for (i = 0; i < 500 * 2; i++) {
sort(v1[i].begin(), v1[i].end());
sort(v2[i].begin(), v2[i].end());
if (v1[i] != v2[i]) {
cout << "NO" << endl;
return 0;
}
}
cout << "YES" << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#define ALL(x) x.begin(), x.end()
using namespace std;
typedef long long ll;
typedef vector<int> vi;
int mod = 1e9 + 7;
void mul(vector<vector<ll>>& A, vector<vector<ll>> B) {
int n = A.size();
vector<vector<ll>> C(n, vector<ll>(n));
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
for(int k = 0; k < n; k++) {
C[i][j] += A[i][k]*B[k][j];
C[i][j] %= mod;
}
}
}
A = C;
}
vector<vector<ll>> mpow(vector<vector<ll>>& A, ll x) {
if(x == 1) {
return A;
}
auto ans = mpow(A, x/2);
mul(ans, ans);
if(x % 2 == 1) {
mul(ans, A);
}
return ans;
}
void solve(void) {
int n;
ll k;
cin >> n >> k;
vector<vector<ll>> A(n, vector<ll>(n));
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
cin >> A[i][j];
}
}
A = mpow(A, k);
ll ans = 0;
for(int i = 0; i < n; i++) {
for(int j = 0; j < n; j++) {
ans += A[i][j];
ans %= mod;
}
}
cout << ans << '\n';
}
int main(void) {
solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int tt;
cin >> tt;
while (tt) {
string s;
cin >> s;
int t, b, l, r;
int t0, t1, b0, b1, l0, l1, r0, r1;
t = b = l = r = t0 = t1 = b0 = b1 = l0 = l1 = r0 = r1 = 0;
int x = 0, y = 0;
for (int i = 0; i < s.size(); i++) {
char c = s[i];
switch (c) {
case 'W':
y += 1;
if (y > t) {
t = y;
t0 = i;
t1 = 0;
} else if (y == t) {
t1 = i;
}
break;
case 'S':
y -= 1;
if (y < b) {
b = y;
b0 = i;
b1 = 0;
} else if (y == b) {
b1 = i;
}
break;
case 'A':
x -= 1;
if (x < l) {
l = x;
l0 = i;
l1 = 0;
} else if (x == l) {
l1 = i;
}
break;
case 'D':
x += 1;
if (x > r) {
r = x;
r0 = i;
r1 = 0;
} else if (x == r) {
r1 = i;
}
break;
}
}
long long sq = (t - b + 1) * (r - l + 1);
if (t - b > 1 && ((!t1 && !b1) || (t1 && !b1 && (t1 < b0 || t0 > b0)) ||
(b1 && !t1 && (b1 < t0 || b0 > t0)) ||
(b1 && t1 && (b1 < t0 || t1 < b0)))) {
sq = (long long)(t - b) * (r - l + 1);
}
if (r - l > 1 && ((!r1 && !l1) || (r1 && !l1 && (r1 < l0 || r0 > l0)) ||
(l1 && !r1 && (l1 < r0 || l0 > r0)) ||
(l1 && r1 && (l1 < r0 || r1 < l0)))) {
sq = min(sq, (long long)(t - b + 1) * (r - l));
}
cout << sq << '\n';
tt--;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a[800001], w[800001], q[800001][4], f[800001];
struct node {
int x, y, z, type, pos;
bool operator<(const node &A) const { return x < A.x; }
} c[2000001];
inline void add(int x, int y) {
for (; x <= n; x += x & (-x)) f[x] += y;
}
int calc(int x) {
int will = 0;
for (; x; x -= x & (-x)) will += f[x];
return will;
}
long long C(long long n) { return n * (n - 1) / 2; }
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
int cnt = 0, num = 0;
for (int i = 1; i <= m; i++) {
int xx1, yy1, xx2, yy2;
scanf("%d%d%d%d", &xx1, &yy1, &xx2, &yy2);
q[i][0] = xx1;
q[i][1] = yy1;
q[i][2] = xx2;
q[i][3] = yy2;
c[++cnt].x = xx1 - 1;
c[cnt].y = 1;
c[cnt].z = yy1 - 1;
c[cnt].type = 0;
c[cnt].pos = ++num;
c[++cnt].x = xx1 - 1;
c[cnt].y = yy2 + 1;
c[cnt].z = n;
c[cnt].type = 0;
c[cnt].pos = ++num;
c[++cnt].x = xx2;
c[cnt].y = 1;
c[cnt].z = yy1 - 1;
c[cnt].type = 1;
c[cnt].pos = ++num;
c[++cnt].x = n;
c[cnt].y = 1;
c[cnt].z = yy1 - 1;
c[cnt].type = 0;
c[cnt].pos = num;
c[++cnt].x = xx2;
c[cnt].y = yy2 + 1;
c[cnt].z = n;
c[cnt].type = 1;
c[cnt].pos = ++num;
c[++cnt].x = n;
c[cnt].y = yy2 + 1;
c[cnt].z = n;
c[cnt].type = 0;
c[cnt].pos = num;
}
sort(c + 1, c + cnt + 1);
int Left = 1;
for (; Left <= cnt && c[Left].x == 0; ++Left)
;
for (int i = 1; i <= n; i++) {
add(a[i], 1);
for (; Left <= cnt && c[Left].x == i; ++Left)
if (c[Left].type)
w[c[Left].pos] -= calc(c[Left].z) - calc(c[Left].y - 1);
else
w[c[Left].pos] += calc(c[Left].z) - calc(c[Left].y - 1);
}
for (int i = 1; i <= m; i++) {
long long ans = C(n);
ans -= C(q[i][0] - 1);
ans -= C(n - q[i][2]);
ans -= C(q[i][1] - 1);
ans -= C(n - q[i][3]);
for (int j = (i - 1) * 4 + 1; j <= i * 4; j++) ans += C(w[j]);
printf("%I64d\n", ans);
}
}
| 3 |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<stack>
#include<cstdio>
#include<sstream>
#include<iomanip>
#include<assert.h>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
using namespace std;
//kaewasuretyuui
typedef long long ll;
typedef ll Def;
typedef pair<Def,Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def,pii> pip;
typedef vector<pip>vip;
//#define mt make_tuple
//typedef tuple<double,int,double> tp;
//typedef vector<tp> vt;
const double PI=acos(-1);
const double EPS=1e-7;
const int inf=1e9;
const ll INF=2e18;
int dx[]={0,1,0,-1};
int dy[]={1,0,-1,0};
int main(){
int n,MOD=1000000007;
cin>>n;
vi in;
while(n--){
char c;cin>>c;
if(c=='U')in.pb(0);
if(c=='D')in.pb(1);
}
n=in.size();
vvi dp(n+1,vi(n+1));
dp[0][0]=1;
rep(i,n)rep(j,n)if(dp[i][j]){
if(in[i]){
(dp[i+1][j]+=dp[i][j]*j)%=MOD;
if(j)(dp[i+1][j-1]+=dp[i][j]*j*j)%=MOD;
}else{
(dp[i+1][j+1]+=dp[i][j])%=MOD;
(dp[i+1][j]+=dp[i][j]*j)%=MOD;
}
}
cout<<dp[n][0]<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k;
long long x[3005][3005], dp[3005][3005][4], ans;
int main() {
scanf("%d%d%d", &n, &m, &k);
while (k--) {
int ta, tb;
long long tc;
scanf("%d%d%lld", &ta, &tb, &tc);
x[ta][tb] += tc;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
for (int ii = 0; ii <= 3; ii++) {
dp[i][j][ii] = max(dp[i][j - 1][ii], dp[i - 1][j][3]);
if (ii)
dp[i][j][ii] = max(dp[i][j][ii], max(dp[i][j - 1][ii - 1], dp[i - 1][j][3]) + x[i][j]);
}
}
printf("%lld\n", dp[n][m][3]);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, B;
cin >> n >> B;
int a[n + 1];
a[0] = 0;
int* oddNum = new int[n + 1];
int* evenNum = new int[n + 1];
memset(evenNum, 0, n + 1);
memset(oddNum, 0, n + 1);
for (int i = 1; i < n + 1; i++) {
cin >> a[i];
if (a[i] % 2 == 0) {
evenNum[i] = evenNum[i - 1] + 1;
oddNum[i] = oddNum[i - 1];
}
if (a[i] % 2 != 0) {
evenNum[i] = evenNum[i - 1];
oddNum[i] = oddNum[i - 1] + 1;
}
}
std::vector<int> positions;
for (int i = 1; i < n; i++) {
if (evenNum[i] == oddNum[i] &&
evenNum[n] - evenNum[i] == oddNum[n] - oddNum[i])
positions.push_back(i);
}
std::vector<int> v;
for (int i = 0; i < positions.size(); i++) {
v.push_back(abs(a[positions[i] + 1] - a[positions[i]]));
}
sort(v.begin(), v.end());
int count = 0, sum = 0;
for (int i = 0; i < v.size(); i++) {
if (sum + v[i] <= B) {
sum += v[i];
count++;
}
}
cout << count;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
map<pair<pair<long long int, long long int>,
pair<long long int, long long int>>,
long long int>
pqr;
map<pair<long long int, long long int>, long long int> xyz;
map<long long int, long long int, greater<long long int>> yz;
vector<pair<long long int, string>> a1;
vector<pair<long long int, long long int>> a2;
vector<pair<long long int, pair<long long int, long long int>>> a3;
bool isSubSequence(string str1, string str2, long long int m, long long int n) {
if (m == 0) return true;
if (n == 0) return false;
if (str1[m - 1] == str2[n - 1])
return isSubSequence(str1, str2, m - 1, n - 1);
return isSubSequence(str1, str2, m, n - 1);
}
long long int fac[5005];
void output2(long long int t) {
if (t > 2) {
cout << "3"
<< " "
<< "1"
<< "\n";
cout << "3"
<< " "
<< "2"
<< "\n";
for (long long int i = 2; i < t - 1; i++) {
cout << "3"
<< " " << i + 2 << "\n";
}
} else {
for (long long int i = 0; i < t - 1; i++) {
cout << "1"
<< " " << i + 2 << "\n";
}
}
}
long long int power(long long int x, long long int y, long long int p) {
long long int res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long int modInverse(long long int n, long long int p) {
return power(n, p - 2, p);
}
long long int nCrModPFermat(long long int n, long long int r, long long int p,
long long int fac[]) {
if (r == 0) return 1;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n, s;
cin >> n >> s;
long long int arr[n + 2];
long long int sum = 0;
for (long long int i = 0; i < n; i++) {
cin >> arr[i];
sum = sum + arr[i];
}
if (sum < s) {
cout << "-1\n";
return 0;
}
sort(arr, arr + n);
long long int r = arr[0];
long long int sum1 = 0;
for (long long int i = 0; i < n; i++) {
sum1 = sum1 + abs(arr[i] - r);
}
if (sum1 >= s) {
cout << r << "\n";
return 0;
}
s = s - sum1;
long long int ans = (n * arr[0]) - s;
cout << ans / n;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, i, arr[200005];
cin >> n;
for (i = 0; i < n; i++) cin >> arr[i];
long long ans = 1, maxi = 1;
for (i = 1; i < n; i++) {
if (arr[i - 1] * 2 >= arr[i])
ans++;
else
ans = 1;
maxi = max(maxi, ans);
}
cout << maxi << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma optimize("O3")
using namespace std;
const int N = 1005;
int cnt[N];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int m, n;
cin >> n >> m;
int u, v;
for (int i = 0; i < m; i++) {
cin >> u >> v;
cnt[u]++;
cnt[v]++;
}
cout << n - 1 << "\n";
for (int i = 1; i <= n; i++) {
if (cnt[i] == 0) {
for (int j = 1; j <= n; j++) {
if (i != j) cout << i << " " << j << "\n";
}
return 0;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char buf[1 << 21], *p1 = buf, *p2 = buf;
template <class T>
void read(T &x) {
x = 0;
int c = getchar();
int flag = 0;
while (c < '0' || c > '9') flag |= (c == '-'), c = getchar();
while (c >= '0' && c <= '9')
x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (flag) x = -x;
}
template <class T>
T _max(T a, T b) {
return b < a ? a : b;
}
template <class T>
T _min(T a, T b) {
return a < b ? a : b;
}
template <class T>
bool checkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <class T>
bool checkmin(T &a, T b) {
return b < a ? a = b, 1 : 0;
}
int n, m;
int a[505][505], b[505][505];
void init() {
read(n);
read(m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) read(a[i][j]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) read(b[i][j]);
}
void solve() {
for (int i = 1; i < n; ++i) {
for (int j = 1; j < m; ++j) {
if (a[i][j] != b[i][j]) {
a[i][j] ^= 1, a[i][m] ^= 1;
a[n][j] ^= 1, a[n][m] ^= 1;
}
}
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (a[i][j] != b[i][j]) {
printf("No\n");
return;
}
printf("Yes\n");
}
int main() {
init();
solve();
return 0;
}
| 3 |
#include<iostream>
#include<iomanip>
using namespace std;
int main() {
double n, m, d;
cin>>n>>m>>d;
if(d==0){
cout<<setprecision(20)<<(m-1)/n<<endl;
}
else{
cout<<setprecision(20)<<(n-d)*2*(m-1)/(n*n)<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t; cin >> s >> t;
cout << (s == t.substr(0, ~-t.length()) ? "Yes" : "No") << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10, mod = 1e9 + 7;
long long qpow(long long x, int y) {
long long res = 1;
while (y) {
if (y & 1) res = res * x % mod;
x = x * x % mod;
y /= 2;
}
return res;
}
void add(long long &x, long long y) {
x += y;
if (x >= mod) x -= mod;
if (x < 0) x += mod;
}
int l[maxn], r[maxn];
long long sum[maxn];
long long calc(int i) {
if (i == 1) return 0;
long long a = max(0, min(r[i], r[i - 1]) - max(l[i], l[i - 1]));
long long b = 1ll * (r[i] - l[i]) * (r[i - 1] - l[i - 1]) % mod;
return a * qpow(b, mod - 2) % mod;
}
long long gao(int i) {
if (i == 2) {
long long tmp = calc(i);
tmp = (1 + mod - tmp) % mod;
return tmp;
}
long long res = 1ll - calc(i) - calc(i - 1);
add(res, mod);
int R = min(r[i], r[i - 1]);
int L = max(l[i], l[i - 1]);
R = min(R, r[i - 2]), L = max(L, l[i - 2]);
long long a = max(0, R - L);
long long b = 1ll * (r[i] - l[i]) * (r[i - 1] - l[i - 1]) % mod;
if (i > 2) b = b * (r[i - 2] - l[i - 2]) % mod;
add(res, a * qpow(b, mod - 2));
return res;
}
int main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> l[i];
for (int i = 1; i <= n; i++) cin >> r[i], r[i]++;
for (int i = 1; i <= n; i++) {
sum[i] = (1 + mod - calc(i)) % mod;
add(sum[i], sum[i - 1]);
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
long long res = (sum[i] - sum[i - 1] + mod) % mod;
long long tmp = 1;
if (i < n - 1) add(tmp, sum[n] - sum[i + 1]);
if (i > 2) add(tmp, sum[i - 2]);
add(ans, res * tmp % mod);
res = 0;
if (i < n) res += gao(i + 1);
if (i > 1) res += gao(i);
add(ans, res % mod);
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int T, n, i, j, k;
cin >> T;
string str;
for (i = 0; i < T; i++) {
cin >> n;
cin >> str;
for (j = 0, k = n - 1; j < n / 2; j++, k--) {
if (abs(str.at(j) - str.at(k)) != 2 && abs(str.at(j) - str.at(k)) != 0) {
cout << "NO" << endl;
goto abc;
}
}
cout << "YES" << endl;
abc:;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 1000005;
const double eps = 1e-8;
const double DINF = 1e100;
const int INF = 1000000006;
const long long LINF = 1000000000000000005ll;
struct Edge {
int a, b, c;
Edge() {}
Edge(int a, int b, int c) : a(a), b(b), c(c) {}
} edge[MaxN];
int fa[MaxN];
int n;
int get(int x) {
if (x == fa[x]) return x;
return fa[x] = get(fa[x]);
}
int x[MaxN];
int size[MaxN];
int sumx[MaxN];
int all = 0;
bool check(int w) {
for (int i = 1; i <= n; ++i) {
fa[i] = i;
size[i] = 1;
sumx[i] = x[i];
}
for (int i = 1; i < n; ++i) {
int u = edge[i].a;
int v = edge[i].b;
int c = edge[i].c;
if (c >= w) continue;
int a = get(u);
int b = get(v);
fa[a] = b;
size[b] += size[a];
sumx[b] += sumx[a];
}
for (int i = 1; i <= n; ++i)
if (fa[i] == i) {
if (size[i] > all - sumx[i]) return false;
}
return true;
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; ++i) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
edge[i] = Edge(a, b, c);
}
for (int i = 1; i <= n; ++i) {
scanf("%d", x + i);
all += x[i];
}
int l = 0, r = INF;
while (l + 1 < r) {
int mid = (l + r) >> 1;
if (check(mid))
l = mid;
else
r = mid;
}
printf("%d\n", l);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7, MAXN = 1e6 + 10, INF = 1e18;
long long n, ans[10], a = 1, ans1;
int main() {
cin >> n;
while (n) {
for (long long i = 0; i < n % 10; i++) {
ans[i] += a;
}
n /= 10;
a *= 10;
}
for (long long i = 0; i < 10; i++) {
if (ans[i] != 0) ans1++;
}
cout << ans1 << '\n';
for (long long i = 0; i < ans1; i++) {
cout << ans[i] << ' ';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s,w;
cin>>s>>w;
reverse(s.begin(), s.end());
if(s == w)puts("YES");
else puts("NO");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int base = 1e9;
const int maxn = 105;
const int logn = 20;
const int inf = 2e9;
const int alpha = 26;
const int my_hash = 29;
const int my_mod = 2495828519;
const long long l_inf = 4e18;
const long long mod = 1e9 + 7;
const double pi = acos(-1.0);
const double eps = 1e-9;
int main() {
int t;
scanf("%d", &t);
for (int i = 0; i < t; i++) {
long long n, l, r;
scanf("%I64d %I64d %I64d", &n, &l, &r);
if (n < l) printf("No\n");
if (l <= n && n <= r) printf("Yes\n");
if (n > r) printf(r * (n / l) < n ? "No\n" : "Yes\n");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 100;
string s;
int a[N];
int k;
int cnt = 0;
bool judge(int x) {
int num = 1;
int len = 0;
for (int i = 0; i < cnt; i++) {
if (len + a[i] <= x) {
len += a[i];
} else {
if (a[i] > x)
return 0;
else {
num++;
if (num > k) return 0;
len = a[i];
}
}
}
return 1;
}
int main() {
cin >> k;
int len;
int l = 1, r = 0;
while (cin >> s) {
len = s.size();
r += (len + 1);
for (int i = 0; i < s.size(); i++) {
if (s[i] == '-') {
a[cnt]++;
cnt++;
} else {
a[cnt]++;
}
}
a[cnt]++;
cnt++;
}
a[cnt - 1]--;
r--;
int mid;
int ans = r;
while (l <= r) {
mid = (l + r) / 2;
if (judge(mid)) {
ans = min(ans, mid);
r = mid - 1;
} else
l = mid + 1;
}
cout << ans << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct node {
long long u, v, next, w, p, c;
} edge[400005];
long long cnt, nxt[200005], sum[200005];
void link(long long u, long long v, long long w, long long p) {
edge[cnt] = {u, v, nxt[u], w, p, 0};
nxt[u] = cnt++;
}
void dfs(long long u) {
long long i, v, tmp;
for (i = nxt[u]; i != -1; i = edge[i].next) {
v = edge[i].v;
dfs(v);
sum[u] += sum[v];
tmp = min(min(edge[i].w - 1, edge[i].p), edge[i].p - sum[v]);
if (tmp < 0) {
puts("-1");
exit(0);
}
edge[i].w -= tmp;
edge[i].p -= tmp;
edge[i].c = tmp;
sum[u] += edge[i].w;
}
}
long long dfs2(long long u, long long x) {
long long use = 0, i, v, tmp, val;
for (i = nxt[u]; i != -1; i = edge[i].next) {
v = edge[i].v;
tmp = min(edge[i].c, x);
edge[i].w += tmp;
edge[i].p += tmp;
x -= tmp;
use += tmp;
val = dfs2(v, min(x, edge[i].p - sum[v]));
x -= val;
use += val;
}
return use;
}
int main() {
long long i, n, a, b, c, d;
cin >> n;
memset(nxt, -1, sizeof(nxt));
for (i = 1; i < n; i++) {
cin >> a >> b >> c >> d;
link(a, b, c, d);
}
dfs(1);
dfs2(1, 1ll << 60);
cout << n << endl;
for (i = 0; i < cnt; i++)
cout << edge[i].u << " " << edge[i].v << " " << edge[i].w << " "
<< edge[i].p << endl;
return 0;
};
| 5 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.