solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
ifstream in("input.in", ios::in);
ofstream out("output.out", ios::out);
int n, a[400], sum = 0, o1 = 0;
int main() {
int i;
cin >> n;
for (i = 1; i <= 2 * n - 1; i++) {
cin >> a[i];
if (a[i] < 0) o1++;
a[i] = abs(a[i]);
sum += a[i];
}
sort(a + 1, a + 2 * n);
if (o1 % 2 && n % 2 == 0) sum -= 2 * a[1];
cout << sum << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int A[1003][1003], M11[1003][1003], M1n[1003][1003], Mm1[1003][1003],
Mmn[1003][1003], m, n, i, j, t, mx;
int main() {
cin >> m >> n;
for (i = 1; i <= m; i++)
for (j = 1; j <= n; j++) {
cin >> A[i][j];
M11[i][j] = max(M11[i - 1][j], M11[i][j - 1]) + A[i][j];
}
for (i = 1; i <= m; i++)
for (j = n; j; j--) M1n[i][j] = max(M1n[i - 1][j], M1n[i][j + 1]) + A[i][j];
for (i = m; i; i--)
for (j = 1; j <= n; j++)
Mm1[i][j] = max(Mm1[i + 1][j], Mm1[i][j - 1]) + A[i][j];
for (i = m; i; i--)
for (j = n; j; j--) {
Mmn[i][j] = max(Mmn[i + 1][j], Mmn[i][j + 1]) + A[i][j];
if (i != 1 && i != m && j != 1 && j != n)
mx = max(
mx,
max(M11[i][j - 1] + Mmn[i][j + 1] + Mm1[i + 1][j] + M1n[i - 1][j],
M11[i - 1][j] + Mmn[i + 1][j] + Mm1[i][j - 1] + M1n[i][j + 1]));
}
cout << mx;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<pair<long long, int> > d, d2;
int pi[200002];
bool mtch[200002];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> n >> m;
d2.push_back({-1, -1});
d.push_back({-1, -1});
for (int i = 1; i <= n; ++i) {
string s;
cin >> s;
int lit = s.back() - 'a';
int poz = 0;
int nr = 0;
while (s[poz] >= '0' && s[poz] <= '9') nr = nr * 10 + (s[poz] - '0'), ++poz;
if (d.empty() || d.back().second != lit)
d.push_back({nr, lit});
else
d.back().first += nr;
}
for (int i = 1; i <= m; ++i) {
string s;
cin >> s;
int lit = s.back() - 'a';
int poz = 0;
int nr = 0;
while (s[poz] >= '0' && s[poz] <= '9') nr = nr * 10 + (s[poz] - '0'), ++poz;
if (d2.empty() || d2.back().second != lit)
d2.push_back({nr, lit});
else
d2.back().first += nr;
}
long long ans = 0;
if (d2.size() == 2) {
for (int i = 0; i < d.size(); ++i)
if (d[i].second == d2[1].second)
ans += max(0LL, d[i].first - d2[1].first + 1);
cout << ans << '\n';
} else {
vector<pair<long long, int> > a, b;
a.push_back({-1, -1});
b.push_back({-1, -1});
for (int i = 2; i + 1 < d2.size(); ++i) a.push_back(d2[i]);
for (int i = 1; i < d.size(); ++i) b.push_back(d[i]);
int k = 0;
for (int i = 2; i < a.size(); ++i) {
while (k && a[k + 1] != a[i]) k = pi[k];
if (a[k + 1] == a[i]) k++;
pi[i] = k;
}
int q = 0;
for (int i = 1; i < b.size(); ++i) {
while (q && a[q + 1] != b[i]) q = pi[q];
if (a[q + 1] == b[i]) ++q;
if (q == a.size() - 1) mtch[i - a.size() + 2] = 1;
}
for (int stpoz = 1; stpoz + d2.size() - 2 < d.size(); ++stpoz) {
if (d[stpoz].second == d2[1].second && d[stpoz].first >= d2[1].first) {
if (d[stpoz + d2.size() - 2].second == d2[d2.size() - 1].second &&
d[stpoz + d2.size() - 2].first >= d2[d2.size() - 1].first) {
if (d2.size() == 3)
++ans;
else if (mtch[stpoz + 1])
++ans;
}
}
}
cout << ans << '\n';
}
return 0;
}
| 4 |
#include "bits/stdc++.h"
using namespace std;
long double mlog(const long double base, const long double anti) {return log(anti) / log(base);}
int main() {int N; cin >> N;int a = mlog(3, N)-1e-10;cout << a + 1 << endl;return 0;} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string x;
string y = "1";
bool h;
bool boolb = 1;
int counter = 0;
for (int i = 0; i < n; i++) {
cin >> x;
h = 1;
if (x == "1") continue;
if (x == "0")
boolb = 0;
else {
if (x[0] != '1') {
y = x;
h = 0;
} else {
for (int i = 1; i < x.length(); i++) {
if (x[i] != '0') {
y = x;
h = 0;
break;
}
}
if (h) counter += x.length() - 1;
}
}
}
if (boolb) {
cout << y;
while (counter--) cout << '0';
} else
cout << '0';
return 0;
}
| 2 |
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int h,w;
vector<pair<long long,int> >a;
int main()
{
cin>>h>>w;
for(int i=0;i<h;i++)
{
long long x;cin>>x;
a.push_back(make_pair(x,i));
}
for(int i=0;i<w;i++)
{
long long x;cin>>x;
a.push_back(make_pair(x,h+i));
}
sort(a.begin(),a.end());
long long ans=0;
int cnth=h,cntw=w;
for(int i=0;i<a.size();i++)
{
ans+=a[i].first*(a[i].second<h?cntw:cnth);
(a[i].second<h?cnth:cntw)--;
}
cout<<ans<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
const long long LINF = 1LL * INF * INF;
pair<int, int> arr[300007];
long long ans[300007];
int n, m;
pair<long long, int> a[300007];
long long pref1[300007];
long long pref2[300007];
void calc() {
long long sum = 0;
for (int i = 0; i < n; ++i) sum += arr[i].second;
for (int i = 0; i < n; ++i) a[i] = make_pair(arr[i].first - arr[i].second, i);
sort(a, a + n);
for (int i = 0; i < n; ++i) {
pref1[i] += arr[a[i].second].first;
if (i) pref1[i] += pref1[i - 1];
pref2[i] += arr[a[i].second].second;
if (i) pref2[i] += pref2[i - 1];
}
for (int i = 0; i < n; ++i) {
long long dif = 1LL * arr[i].first - 1LL * arr[i].second;
int k = upper_bound(a, a + n, make_pair(dif, INF)) - a;
k--;
ans[i] += 1LL * pref1[k] + (k + 1) * (long long)arr[i].second +
(n - k - 1) * (long long)arr[i].first + 1LL * sum - pref2[k];
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> arr[i].first >> arr[i].second;
}
calc();
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
long long x =
min(arr[a].first + arr[b].second, arr[a].second + arr[b].first);
ans[a] -= x;
ans[b] -= x;
}
for (int i = 0; i < n; ++i)
cout << ans[i] - 1LL * arr[i].first - 1LL * arr[i].second << " ";
return 0;
}
| 5 |
#include<bits/stdc++.h>
using namespace std ;
typedef long long ll ;
const int maxn = 1e5 + 5 ;
const ll mod = 1e9 + 7 ;
int n , k ;
ll a[maxn] ;
ll f[maxn] ;
void init()
{
f[0] = 1 ;
for(int i = 1 ; i <= 1e5 ; i ++)
f[i] = f[i - 1] * ll(i) % mod ;
}
ll qpow(ll a , ll b)
{
ll ans = 1 ;
while(b)
{
if(b & 1)
ans = (ans * a) % mod ;
b >>= 1 ;
a = (a * a) % mod ;
}
return ans % mod ;
}
ll solve(ll x)
{
return qpow(x , mod - 2) % mod ; //qpow�ǿ����ݡ�
}
ll C(ll x , ll y)
{
if(x < y) return 0 ;
if(x == y) return 1 ;
return f[x] * solve(f[y] * f[x - y] % mod) % mod ;
}
int main()
{
init() ;
scanf("%d%d" , &n , &k) ;
for(int i = 1 ; i <= n ; i ++)
scanf("%lld" , &a[i]) ;
sort(a + 1 , a + n + 1) ;
ll ans = 0 ;
for(int i = 1 ; i <= n ; i ++)
ans += (C(i - 1 , k - 1) - C(n - i , k - 1)) * a[i] % mod , ans %= mod ;
printf("%lld\n" , ans) ;
return 0 ;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int dp[105][200005];
int n, k;
int a[105], b[105];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k;
int i, j;
for (i = 1; i <= n; i++) cin >> a[i];
for (i = 1; i <= n; i++) cin >> b[i];
for (i = 0; i < 200005; i++) dp[0][i] = -199999999;
dp[0][100002] = 0;
for (i = 1; i <= n; i++) {
for (j = 0; j <= 200004; j++) {
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j + a[i] - b[i] * k] + a[i]);
}
}
if (dp[n][100002])
cout << dp[n][100002];
else
cout << -1;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int k, b, n, x;
int main() {
scanf("%d%d%d%d", &k, &b, &n, &x);
long long sk = 1, ss = 1;
for (int i = 1; i <= n + 1; i++) {
sk *= k;
if (i == n + 1 || ss > x || b * ss + sk > x) {
printf("%d\n", n - i + 1);
break;
} else
ss += sk;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
const int inf = INT_MAX;
const int MAXN = 10004;
const int modn = 1000000007;
int ans[20][20];
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
void bfs(int n) {
queue<pair<int, int> > q;
q.push(pair<int, int>(n, n));
ans[n][n] = n;
while (q.size()) {
pair<int, int> c = q.front();
q.pop();
if (ans[c.first][c.second] == 0) continue;
for (int i = 0; i < 4; i++) {
int x = c.first + dx[i], y = c.second + dy[i];
if (ans[x][y] < ans[c.first][c.second]) {
ans[x][y] = ans[c.first][c.second] - 1;
q.push(pair<int, int>(x, y));
}
}
}
}
int main() {
int n;
scanf(" %d", &n);
memset(ans, -1, sizeof ans);
bfs(n);
for (int i = 0; i <= 2 * n; i++) {
bool f = false;
for (int j = 0; j <= 2 * n; j++) {
if (ans[i][j] == 0) f = true;
if (ans[i][j] == -1)
printf(" ");
else
printf("%d", ans[i][j]);
if (f && ans[i][j + 1] == -1) break;
printf(" ");
}
puts("");
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long pos;
char answer;
void In() { cin >> pos; }
int Lentgh(int num) {
int result = 0;
while (num > 0) {
num /= 10;
result++;
}
return result;
}
long long LinearSum(long long start, long long finish, long long num) {
return (start + finish) * num / 2;
}
long long GetRedactedSize() {
long long total_size = 0, first_size = 0, next_size = 0;
for (long long num_elem = 9, num_digits = 1;; num_digits++, num_elem *= 10) {
next_size = LinearSum(first_size + num_digits,
first_size + num_digits * num_elem, num_elem);
if (total_size + next_size >= pos) {
long long l = 1, r = num_elem;
for (long long mid = l + (r - l + 1) / 2; l != r;
mid = l + (r - l + 1) / 2)
total_size + LinearSum(first_size + num_digits,
first_size + num_digits * mid, mid) >=
pos
? r = mid - 1
: l = mid;
next_size =
LinearSum(first_size + num_digits, first_size + num_digits * l, l);
if (total_size + next_size < pos) total_size += next_size;
return total_size;
}
total_size += next_size;
first_size += num_digits * num_elem;
}
}
char Solve() {
pos -= GetRedactedSize();
for (long long num_elem = 9, prev_len = 0, num_digits = 1;;
prev_len += num_elem * num_digits, num_elem *= 10, num_digits++)
if (prev_len + num_elem * num_digits >= pos) {
pos -= prev_len + 1;
return to_string(pow(10, num_digits - 1) +
pos / num_digits)[pos % num_digits];
}
}
void Out() { cout << answer << endl; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
cin >> t;
while (t--) {
In();
answer = Solve();
Out();
}
}
| 5 |
#include<bits/stdc++.h>
#define rep(i, a, b) for(int i = a; i < b; i ++)
#define LL long long
#define mx 105
using namespace std;
const LL mod = 1000000007;
int c[mx], b[mx], n, bb, B[mx];
int st, en;
LL res[300], dp[mx][mx * mx];
LL add[mx * mx];
void Add(LL &x, LL y){
x = (x + y + mod) % mod;
}
void calc(int x){
memset(dp, 0, sizeof dp);
rep(i, max(x, 0), c[1] + 1) dp[1][i] = 1;
int lim = x;
rep(i, 2, n + 1) {
lim += x + b[i - 1];
memset(add, 0, sizeof add);
rep(j, 0, 10001) if(dp[i - 1][j] && j + c[i] >= lim){
Add(add[j + max(lim - j, 0)], dp[i - 1][j]);
Add(add[j + c[i] + 1], -dp[i - 1][j]);
}
rep(j, 0, 10001){
j ? dp[i][j] = (dp[i][j - 1] + add[j]) % mod : dp[i][j] = add[j];
}
}
rep(j, 0, 10001) Add(res[x - st], dp[n][j]);
}
int main(){
#ifndef ONLINE_JUDGE
freopen("in.txt", "r", stdin);
#endif
cin >> n;
rep(i, 1, n + 1) cin >> c[i];
rep(i, 1, n) {
cin >> bb;
b[i] = b[i - 1] + bb;
B[i] = B[i - 1] + b[i];
}
st = -B[n - 1] / n - 2;
en = 100 + st + 5;
rep(x, st, en + 1) calc(x);
int q, X;
cin >> q;
while(q --){
cin >> X;
if(X < st) cout << res[0] << endl;
else if(X <= en) cout << res[X - st] << endl;
else cout << 0 << endl;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t;
cin >> t;
while (t--) {
long long n, d;
cin >> n >> d;
long long x = n * (n - 1) / 2;
if (d > x) {
cout << "NO\n";
continue;
}
x = 1;
long long s = 0;
vector<long long> a;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < x; j++) {
if (s + i > d or a.size() == n) break;
s += i;
a.push_back(i);
}
x *= 2;
if (s + i > d or a.size() == n) break;
}
if (a.size() < n) {
cout << "NO\n";
continue;
}
cout << "YES\n";
d -= s;
long long p = a.size();
for (long long i = 0; i < d; i++) {
for (long long j = p - 1; j > 0; j--) {
if (a[j] == a[j - 1]) {
a[j] += 1;
break;
}
}
}
long long j = 0, pp = 0;
vector<long long> b;
for (long long i = 1; i < p; i++) {
while (a[j] != a[i] - 1) {
j++;
pp = 0;
continue;
}
if (pp == 0) {
b.push_back(j + 1);
pp = 1;
} else {
pp = 0;
b.push_back(j + 1);
j += 1;
}
}
for (auto i : b) {
cout << i << " ";
}
cout << "\n";
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
const int inf = 0x3f3f3f3f;
const int mod = 1e9 + 7;
bool win(long long s, long long e) {
if (e & 1) return !(s & 1);
if (s * 2 > e) return s & 1;
if (s * 4 > e) return 1;
return win(s, e / 4);
}
bool lose(long long s, long long e) {
if (s * 2 > e) return 1;
return win(s, e / 2);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t;
cin >> t;
int fi = 1, se = 0;
int ok = 0;
long long s, e;
for (int i = 1; i <= t; ++i) {
cin >> s >> e;
if (ok) continue;
if (fi && se) ok = 1;
if (!fi && !se) ok = 2;
if (fi) {
fi = lose(s, e);
se = win(s, e);
} else {
fi = !lose(s, e);
se = !win(s, e);
}
}
if (ok == 1)
cout << "1 1\n";
else if (ok == 2)
cout << "0 0\n";
else
cout << se << ' ' << fi << '\n';
return 0;
}
| 6 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#define REP(i, n) FOR(i, 0, n)
#define FOR(i, a, b) for(int i = (int)a; i < (int)b; ++i)
#define SORT(v) std::sort(v.begin(), v.end())
#define ALL(v) v.begin(), v.end()
#define cosnt const
using ll = long long;
using std::cin;
using std::cout;
constexpr char endl = '\n';
int main(){
ll n, i, j;
while(cin >> n >> i >> j, n || i || j) {
std::string ans;
--i; --j;
for(int p = n-1; p >= 0; --p) {
ans += ((i & 1) == (j & 1)) ? 'L' : 'R';
if(1ll << p > i) i = (1ll << (p + 1)) - 1 - i;
i -= 1ll << p;
j >>= 1;
}
std::reverse(ALL(ans));
std::cout << ans << std::endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int i, j, k, l, m1, m2, m3, m4, m = 0, n;
int main() {
cin >> n;
m1 = n - 1;
m2 = n * (m1 * (m1 + 1) / 2);
m3 = (m1 * (m1 + 1) * (2 * m1 + 1)) / 6;
m = m2 - m3;
cout << m + n;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, ans = 0, v[300005], c[300005], l[300005], r[300005], dp[300005],
fdp[300005], fa[300005];
vector<int> grp[300005], seq;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d%d%d%d", v + i, c + i, l + i, r + i);
grp[l[i] + c[i] + r[i]].push_back(i);
}
for (int i = 0; i <= 300000; ++i) {
if (grp[i].empty()) continue;
for (int j = 0; j < grp[i].size(); ++j) {
int u = grp[i][j];
if ((l[u] == 0 || dp[l[u]]) && dp[l[u] + c[u]] < dp[l[u]] + v[u]) {
dp[l[u] + c[u]] = dp[l[u]] + v[u];
fa[u] = fdp[l[u]];
fdp[l[u] + c[u]] = u;
}
}
if (ans < dp[i]) {
ans = dp[i];
seq.clear();
for (int j = fdp[i]; j;) {
seq.push_back(j);
j = fa[j];
}
}
for (int j = 0; j < grp[i].size(); ++j) {
int u = grp[i][j];
dp[l[u] + c[u]] = 0;
fa[u] = 0;
fdp[l[u] + c[u]] = 0;
}
}
printf("%d\n", seq.size());
sort(seq.begin(), seq.end());
for (int i = 0; i < seq.size(); ++i) printf("%d ", seq[i]);
puts("");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char word[13];
int m, pans[5], last;
bool found;
int main() {
scanf("%s", word);
scanf("%d", &m);
vector<int> used;
for (int t = 0; t < 10; t++) {
last = 0;
pans[0] = 0;
pans[1] = 0;
used.clear();
for (int i = 1; i <= m; i++) {
found = false;
for (int j = (i == 1 ? t : 0); j < 10; j++)
if (j + 1 != last && word[j] == '1' &&
pans[i & 1] + j + 1 > pans[(i + 1) & 1]) {
last = j + 1;
used.push_back(j + 1);
pans[i & 1] += j + 1;
found = true;
break;
}
if (!found) break;
}
if (found) break;
}
if (!found)
printf("NO\n");
else {
printf("YES\n");
for (int i = 0; i < used.size(); i++) {
if (i > 0) printf(" ");
printf("%d", used[i]);
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
pair<long long, long long> aa[100100];
vector<pair<long long, long long> > pp, mm;
const int MAXN = 100010;
long long Plus[100100], Minus[100100];
long long pcnt[100100], mcnt[100100];
int lowbit(int x) { return x & -x; }
long long get_sum(long long *C, int x) {
long long sum = 0;
while (x > 0) {
sum += C[x];
x -= lowbit(x);
}
return sum;
}
void add(long long *C, int x, long long v) {
while (x < MAXN) {
C[x] += v;
x += lowbit(x);
}
}
long long get_val(int topk, long long *C1, long long *C2) {
if (topk == 0) return 0;
int l = 1, r = MAXN;
while (l < r) {
int mid = (l + r) / 2;
long long ret = get_sum(C2, mid);
if (ret < topk) {
l = mid + 1;
} else {
r = mid;
}
}
return get_sum(C1, r);
}
void change(int i, long long sign) {
if (aa[i].first > 0) {
add(Plus, aa[i].second, sign * aa[i].first);
add(pcnt, aa[i].second, sign * 1);
}
if (aa[i].first < 0) {
add(Minus, aa[i].second, sign * aa[i].first);
add(mcnt, aa[i].second, sign * 1);
}
}
void print(int n) {
printf("Plus\n");
for (int i = 1; i <= n; i++) {
printf("%lld ", get_sum(Plus, i));
}
printf("\n");
printf("pcnt\n");
for (int i = 1; i <= n; i++) {
printf("%lld ", get_sum(pcnt, i));
}
printf("\n");
printf("Minus\n");
for (int i = 1; i <= n; i++) {
printf("%lld ", get_sum(Minus, i));
}
printf("\n");
printf("mcnt\n");
for (int i = 1; i <= n; i++) {
printf("%lld ", get_sum(mcnt, i));
}
printf("\n");
}
int main() {
int n, m;
int topk;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%I64d", &aa[i].first);
if (aa[i].first > 0) pp.push_back(make_pair(aa[i].first, i));
if (aa[i].first < 0) mm.push_back(make_pair(aa[i].first, i));
}
scanf("%d", &topk);
sort(pp.begin(), pp.end());
reverse(pp.begin(), pp.end());
sort(mm.begin(), mm.end());
for (int i = 0; i < pp.size(); i++) {
aa[pp[i].second].second = i + 1;
}
for (int i = 0; i < mm.size(); i++) {
aa[mm[i].second].second = i + 1;
}
long long sum = 0;
for (int i = 0; i < m; i++) {
sum += aa[i].first;
change(i, 1);
}
long long ans, up, down;
up = get_val(topk, Plus, pcnt);
down = get_val(topk, Minus, mcnt);
ans = max(abs(sum - 2 * up), abs(sum - 2 * down));
for (int i = 1; i <= n - m; i++) {
sum -= aa[i - 1].first;
sum += aa[i + m - 1].first;
change(i - 1, -1);
change(i + m - 1, 1);
up = get_val(topk, Plus, pcnt);
down = get_val(topk, Minus, mcnt);
ans = max(ans, max(abs(sum - 2 * up), abs(sum - 2 * down)));
}
printf("%I64d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3,no-stack-protector")
#pragma GCC target( \
"sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
using namespace std;
struct Counter {
map<int64_t, int> mp;
void Add(int64_t x) { mp[x]++; }
void Del(int64_t x) {
if (mp[x]-- < 2) {
mp.erase(x);
}
}
int64_t FirstGreater(int64_t bound) {
auto it = mp.upper_bound(bound);
if (it == end(mp)) {
return bound - 1;
}
return it->first;
}
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
int64_t n, m;
int64_t l, r;
cin >> n >> m >> l >> r;
vector<vector<int64_t>> divs(max(n, m) + 1);
for (int64_t d = 1; d <= max(n, m); ++d) {
for (int64_t x = 1; x * d < divs.size(); ++x) {
divs[x * d].push_back(d);
}
}
int64_t vl = l;
int64_t vr = min((int64_t)m, r);
Counter cur;
for (int64_t x = vl; x <= vr; ++x) {
for (int64_t d : divs[x]) {
cur.Add(d);
}
}
for (int64_t x = 1; x <= n; ++x) {
int64_t x2 = -1;
int64_t y1, y2;
for (int64_t a : divs[x]) {
int64_t b = cur.FirstGreater(a);
if (b < a or b * x / a > n) {
continue;
}
x2 = b * x / a;
y1 = (vl + b - 1) / b;
y2 = y1 * a;
y1 *= b;
break;
}
if (x2 == -1) {
cout << -1 << '\n';
} else {
cout << x << ' ' << y1 << ' ';
cout << x2 << ' ' << y2 << '\n';
}
int64_t nl = (l + x) / (x + 1);
int64_t nr = r / (x + 1);
nl = max(nl, (int64_t)1);
nr = min((int64_t)m, nr);
if (nl <= nr) {
for (int y = nl; y < min(nr + 1, vl); ++y) {
for (int64_t d : divs[y]) {
cur.Add(d);
}
}
for (int y = max(vl, nr + 1); y <= vr; ++y) {
for (int64_t d : divs[y]) {
cur.Del(d);
}
}
} else {
cur.mp.clear();
}
vl = nl;
vr = nr;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int x[111];
long double inline get_dis(int ox, double hx, double hy) {
return sqrt((ox - hx) * (ox - hx) + (long double)hy * hy);
}
long double inline get_dis(int ox, int nx) {
return sqrt((long double)(ox - nx) * (ox - nx));
}
int main() {
int n, vb, vs;
while (cin >> n >> vb >> vs) {
double xu, yu;
for (int i = 0; i < n; ++i) scanf("%d", x + i);
scanf("%lf%lf", &xu, &yu);
int pos = -1;
long double small = 1e9;
long double ndis = 1e9;
for (int i = 1; i < n; i++) {
long double nt = get_dis(0.0, x[i]) / vb + get_dis(x[i], xu, yu) / vs;
long double dis = get_dis(x[i], xu, yu);
if (nt < small) {
small = nt;
pos = i + 1;
ndis = dis;
} else if (fabs(small - nt) < 1e-8) {
small = nt;
pos = i + 1;
ndis = dis;
}
}
printf("%d\n", pos);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using VI = std::vector<int>;
using VVI = std::vector<VI>;
vector<int> d_arr_1;
vector<int> d_arr_2;
vector<int> prime_sieve;
vector<int> a_arr;
int n;
void sieve() {
for (int i = 2; i < 1e7 + 1; i += 2) {
prime_sieve[i] = 2;
}
for (int i = 3; i < 1e7 + 1; i += 2) {
if (prime_sieve[i] == i) {
for (int j = i * 2; j < 1e7 + 1; j += i) {
if (prime_sieve[j] == j) prime_sieve[j] = i;
}
}
}
}
void solve(int i) {
int a = a_arr[i];
int a2 = a;
int div = prime_sieve[a];
if (div == a) {
d_arr_1.push_back(-1);
d_arr_2.push_back(-1);
} else {
int counter = 0;
int val = 1;
while (a2 % div == 0) {
counter += 1;
val *= div;
a2 /= div;
}
if (a2 == 1) {
d_arr_1.push_back(-1);
d_arr_2.push_back(-1);
} else {
d_arr_1.push_back(val);
d_arr_2.push_back(a2);
}
}
}
int main() {
cin >> n;
a_arr = vector<int>(n);
d_arr_1 = vector<int>(0);
d_arr_2 = vector<int>(0);
prime_sieve = vector<int>(1e7 + 1);
for (int i = 1; i < 1e7 + 1; i++) {
prime_sieve[i] = i;
}
for (int i = 0; i < n; i++) {
cin >> a_arr[i];
}
sieve();
for (int i = 0; i < n; i++) {
solve(i);
}
for (int i = 0; i < n - 1; i++) {
cout << d_arr_1[i] << " ";
}
cout << d_arr_1[n - 1] << "\n";
for (int i = 0; i < n - 1; i++) {
cout << d_arr_2[i] << " ";
}
cout << d_arr_2[n - 1];
}
| 4 |
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cassert>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <utility>
#include <numeric>
#include <algorithm>
#include <bitset>
#include <complex>
#include <fstream>
using namespace std;
typedef vector<int> vint;
typedef pair<int,int> pint;
#define rep(i,n) for(int i = 0; i < n; i++)
#define MSG(a) cout << #a << " " << a << endl;
template<class T, class C> pair<T,C> mp(T a, C b){ return make_pair(a, b);}
int main()
{
int n, k;
while(cin >> n >> k && n)
{
vint card(n), pool;
rep(i,n) cin >> card[i];
sort(card.begin(), card.end());
do
{
int x = 0;
rep(i,k) x = x * (static_cast<int>(card[i] / 10) > 0 ? 100 : 10) + card[i];
pool.push_back(x);
}
while(next_permutation(card.begin(), card.end()));
sort(pool.begin(), pool.end());
pool.erase(unique(pool.begin(), pool.end()), pool.end());
cout << pool.size() << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <class t>
inline t read(t &x) {
char c = getchar();
bool f = 0;
x = 0;
while (!isdigit(c)) f |= c == '-', c = getchar();
while (isdigit(c)) x = (x << 1) + (x << 3) + (c ^ 48), c = getchar();
if (f) x = -x;
return x;
}
template <class t>
inline void write(t x) {
if (x < 0)
putchar('-'), write(-x);
else {
if (x > 9) write(x / 10);
putchar('0' + x % 10);
}
}
long long const N = 2e3 + 3;
long long const P = 131;
long long const mod = 1e9 + 7;
long long n, m, ans, res, f[2][N][N], g[2][N][N];
long long base[N], h[N], h1[2][N], h2[2][N];
char a[2][N], b[N];
long long get1(long long l, long long r, long long i) {
return h1[i][r] - h1[i][l - 1] * base[r - l + 1];
}
long long get2(long long l, long long r, long long i) {
return h2[i][l] - h2[i][r + 1] * base[r - l + 1];
}
long long merge(long long x, long long y, long long len) {
return x * base[len] + y;
}
void dp() {
memset(f, 0, sizeof(f));
memset(g, 0, sizeof(g));
for (long long i = 1; i <= m; i++) h[i] = h[i - 1] * P + b[i] - 'a' + 1;
for (long long i = 0; i <= 1; i++) {
for (long long j = 1; j <= n; j++) {
for (long long k = j, len = 2 * (j - k + 1); k && len <= m;
k--, len += 2) {
if (merge(get2(k, j, i ^ 1), get1(k, j, i), j - k + 1) == h[len]) {
if (len == m)
res++;
else
g[i][j][len] = 1;
}
}
}
}
for (long long i = 0; i <= 1; i++) {
for (long long j = 1; j <= n; j++) {
if (a[i][j] == b[1]) g[i][j][1] = 1;
}
}
for (long long k = 1; k < m; k++) {
for (long long i = 0; i <= 1; i++) {
for (long long j = 1; j <= n; j++) {
if (j < n && a[i][j + 1] == b[k + 1])
f[i][j + 1][k + 1] = (f[i][j + 1][k + 1] + g[i][j][k]) % mod;
if (j < n && a[i][j + 1] == b[k + 1])
f[i][j + 1][k + 1] = (f[i][j + 1][k + 1] + f[i][j][k]) % mod;
if (a[i ^ 1][j] == b[k + 1])
g[i ^ 1][j][k + 1] = (g[i ^ 1][j][k + 1] + f[i][j][k]) % mod;
}
}
}
for (long long i = m; i; i--) h[i] = h[i + 1] * P + b[i] - 'a' + 1;
for (long long i = 0; i <= 1; i++) {
for (long long j = 1; j <= n; j++) {
if (a[i][j] == b[m]) {
if (m == 1)
ans = (ans + 1) % mod;
else
ans = (ans + f[i][j - 1][m - 1] + g[i][j - 1][m - 1]) % mod;
}
for (long long k = j, len = 2 * (k - j + 1); k <= n && len <= m;
k++, len += 2) {
if (merge(get1(j, k, i ^ 1), get2(j, k, i), k - j + 1) ==
h[m - len + 1]) {
if (len == m && m != 2)
res++;
else
ans = (ans + f[i][j - 1][m - len] + g[i][j - 1][m - len]) % mod;
}
}
}
}
}
signed main() {
scanf("%s", a[0] + 1);
scanf("%s", a[1] + 1);
scanf("%s", b + 1);
n = strlen(a[0] + 1);
m = strlen(b + 1);
base[0] = 1;
for (long long i = 1; i <= max(n, m); i++) base[i] = base[i - 1] * P;
for (long long i = 0; i <= 1; i++) {
for (long long j = 1; j <= n; j++) {
h1[i][j] = h1[i][j - 1] * P + a[i][j] - 'a' + 1;
}
}
for (long long i = 0; i <= 1; i++) {
for (long long j = n; j; j--) {
h2[i][j] = h2[i][j + 1] * P + a[i][j] - 'a' + 1;
}
}
dp();
reverse(b + 1, b + m + 1);
dp();
ans = (ans + res / 2) % mod;
if (m == 1) ans >>= 1;
write(ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
char str[1005];
int mat[2005][105];
int n = 2000, m;
const int lim = 30;
const long long base = 100000000ll;
const int bit_sz = 8;
long long dig[100];
int main() {
scanf("%d", &m);
for (int i = 0; i < m; ++i) {
int sz;
scanf("%s", str), sz = strlen(str);
reverse(str, str + sz), memset(dig, 0, sizeof(dig));
for (int j = sz - 1; j >= 0; --j)
dig[j / bit_sz] = dig[j / bit_sz] * 10 + str[j] - '0';
sz = (sz + bit_sz - 1) / bit_sz;
int bits = (1 << bit_sz) - 1;
for (int j = 0; j < n / bit_sz; ++j) {
long long cur_bit = dig[0] & bits;
for (int k = 0; k < bit_sz; ++k)
if (cur_bit >> k & 1) mat[j * bit_sz + k][i / lim] |= (1 << (i % lim));
for (int k = 79; k > 0; --k) {
dig[k - 1] += (dig[k] & bits) * base;
dig[k] >>= bit_sz;
}
dig[0] >>= bit_sz;
}
}
int p[2005] = {0};
for (int i = 0, start = 0; start < n && i < m; ++i) {
bool seen = false;
for (int j = start; j < n; ++j)
if (mat[j][i / lim] & (1 << (i % lim))) {
for (int k = 0; k < 70; ++k) swap(mat[j][k], mat[start][k]);
seen = true;
break;
}
if (!seen) {
int cnt = 0;
for (int j = 0; j < start; ++j)
if (mat[j][i / lim] & (1 << (i % lim))) cnt++;
printf("%d", cnt);
for (int j = 0; j < start; ++j)
if (mat[j][i / lim] & (1 << (i % lim))) printf(" %d", p[j]);
puts("");
continue;
}
p[start] = i;
printf("0\n");
for (int j = 0; j < n; ++j)
if ((j != start) && (mat[j][i / lim] & (1 << (i % lim))))
for (int k = i / lim; k < 70; ++k) mat[j][k] ^= mat[start][k];
start++;
continue;
int idx = -1;
for (int j = start; j < n; ++j)
if (mat[j][i / lim] >> (i % lim) & 1) {
idx = j;
break;
}
if (idx != -1) {
for (int j = 0; j < 70; ++j) swap(mat[idx][j], mat[start][j]);
for (int j = 0; j < n; ++j)
if ((j != start) && (mat[j][i / lim] >> (i % lim) & 1))
for (int k = i / lim; k < 70; ++k) mat[j][k] ^= mat[start][k];
start++;
}
bool no = false;
for (int j = start; j < n; ++j)
if (mat[j][(i + 1) / lim] >> ((i + 1) % lim) & 1) no = true;
if (no)
printf("0\n");
else {
vector<int> ans;
for (int j = 0; j < start; ++j)
if (mat[j][(i + 1) / lim] >> ((i + 1) % lim) & 1) ans.push_back(j);
printf("%d", ans.size());
for (int j = 0; j < ans.size(); ++j) printf(" %d", ans[j]);
puts("");
}
}
}
| 4 |
#include <iostream>
#include <algorithm>
#include <vector>
#include <map>
#include <cmath>
using namespace std;
typedef pair<int, int> P;
const double EPS = 1e-8;
double dp[51][5001];
int x, y, z, v[4], e[51], a[51];
int main(){
while(cin >> x >> y >> z && (x|y|z)){
fill(dp[0], dp[51], 0.0);
fill(e, e+51, 2);
fill(a, a+51, 0);
for(int i=0;i<x;i++) cin >> v[i];
for(int i=0;i<z;i++){
int in;
cin >> in;
cin >> e[in] >> a[in];
}
dp[0][0] = 1.0;
for(int i=0;i<y;i++){
for(int j=0;j<5001;j++){
if(abs(dp[i][j]) < EPS) continue;
for(int k=0;k<x;k++){
int next = min(i + v[k], y);
int money = j;
if(e[next] == 1) next = min(next + a[next], y);
else if(e[next] == 2) money += a[next];
else if(e[next] == 3) money = max(money - a[next], 0);
dp[next][money] += dp[i][j] / (double)x;
}
}
}
double ans = 0.0;
for(int i=0;i<5001;i++){
ans += i * dp[y][i];
}
cout << (int)ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long int n;
int flag = 0;
cin >> n;
string s1;
cin >> s1;
long long int a[n], i;
set<long long int> s;
for (i = 0; i < n; ++i) cin >> a[i];
for (i = 0; i < n; ++i) {
if (s1[i] == '<') {
if (s.count(i) == 0) {
s.insert(i);
if (i - a[i] < 0) {
flag = 0;
break;
} else {
i = i - a[i];
i--;
}
} else {
flag = 1;
break;
}
} else {
if (s.count(i) == 0) {
s.insert(i);
if (i + a[i] >= n) {
flag = 0;
break;
} else {
i = i + a[i];
i--;
}
} else {
flag = 1;
break;
}
}
}
if (flag == 1)
cout << "INFINITE";
else
cout << "FINITE";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int k, n, tot, Link[200010], tree[201000];
long long ans;
bool visited[201000], U[201000];
struct node {
int v, next;
} edge[400100];
void addEdge(int x, int y) {
tot++;
edge[tot].v = y;
edge[tot].next = Link[x];
Link[x] = tot;
}
void dfs(int x) {
visited[x] = true;
for (int p = Link[x]; p; p = edge[p].next)
if (!visited[edge[p].v]) {
dfs(edge[p].v);
tree[x] += tree[edge[p].v];
}
if (U[x]) tree[x]++;
}
void dfs2(int x) {
visited[x] = true;
for (int p = Link[x]; p; p = edge[p].next)
if (!visited[edge[p].v]) {
ans += (long long)min(k - tree[edge[p].v], tree[edge[p].v]);
dfs2(edge[p].v);
}
}
int main() {
tot = 0;
memset(Link, 0, sizeof(Link));
memset(U, 0, sizeof(U));
memset(tree, 0, sizeof(tree));
int x, y;
scanf("%d%d", &n, &k);
k *= 2;
for (int i = 1; i <= k; i++) {
scanf("%d", &x);
U[x] = true;
}
for (int i = 1; i < n; i++) {
scanf("%d%d", &x, &y);
addEdge(x, y);
addEdge(y, x);
}
memset(visited, 0, sizeof(visited));
dfs(1);
memset(visited, 0, sizeof(visited));
ans = 0;
dfs2(1);
cout << ans << endl;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int N,sum=0,ave,ans=0;
int a[100];
cin>>N;
for(int i=0;i<N;i++){
cin>>a[i];
sum+=a[i];
}
if(sum>=0){
ave=(double)sum/N+0.5;
}else{
ave=(double)sum/N-0.5;
}
for(int i=0;i<N;i++){
ans+=pow(a[i]-ave,2);
}
cout<<ans<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 500001;
const int sq = 800;
int A[maxn];
int B[sq][sq];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int q;
cin >> q;
memset(A, 0, sizeof(A));
;
memset(B, 0, sizeof(B));
;
while (q--) {
int Q, x, y;
cin >> Q >> x >> y;
if (Q == 1) {
A[x] += y;
for (int i = 1; i < sq; i++) {
B[i][x % i] += y;
}
} else {
if (x < sq) {
cout << B[x][y] << '\n';
} else {
int ans = 0;
for (int i = y; i < maxn; i += x) ans += A[i];
cout << ans << '\n';
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1073741823;
const int maxint = 0x7fffffff;
const long long INF = 1152921504606846976ll;
const long double eps = 1E-9;
const long double pi = acos(-1);
template <class T>
inline T _sqr(T a) {
return (a * a);
}
template <class T>
inline T _abs(T a) {
return (a >= 0 ? a : -a);
}
template <class T>
inline T _lbt(T a) {
return (a & (a ^ (a - 1)));
}
template <class T>
inline T _max(T a, T b) {
return (a > b ? a : b);
}
template <class T>
inline T _min(T a, T b) {
return (a < b ? a : b);
}
template <class T>
inline T _smax(T a, T b, T c) {
return _max(_max(a, b), c);
}
template <class T>
inline T _smin(T a, T b, T c) {
return _min(_min(a, b), c);
}
template <class T>
inline T _sqrt(T a) {
T b, c;
for (b = sqrt(a), c = b - 2; c <= b + 2; c++)
if (_sqr(c) <= a) b = c;
return b;
}
template <class T>
inline T _pow(T a, T b, T c) {
T d = 1;
for (a %= c; b; b >>= 1, a = a * a % c)
if (b & 1) d = d * a % c;
return d;
}
int n, m, k, t, x, y, p, T, a[101010];
vector<int> s[101010];
long long ans, tans[101010], lans, tot, sum;
void Solution_Production() {
int tm;
a[m = 0] = 0;
scanf("%d%d", &n, &tm);
for (int i = 1; i <= tm; i++) {
scanf("%d", a + i);
if (a[i] != a[m]) a[++m] = a[i];
}
a[0] = a[1];
a[m + 1] = a[m];
ans = 0;
for (int i = 1; i <= n; i++) tans[i] = 0;
for (int i = 1; i <= m; i++) {
if (i > 1) s[a[i]].push_back(a[i - 1]);
if (i < m) s[a[i]].push_back(a[i + 1]);
ans += abs(a[i + 1] - a[i]);
tans[a[i]] += abs(a[i + 1] - a[i]) + abs(a[i - 1] - a[i]);
}
lans = ans;
for (int i = 1; i <= n; i++)
if (s[i].size()) {
sort(s[i].begin(), s[i].end());
sum = s[i][s[i].size() / 2];
tot = ans - tans[i];
for (int j = 0; j < (int)s[i].size(); j++) {
tot += abs(s[i][j] - sum);
}
if (tot < lans) lans = tot;
}
cout << lans << endl;
}
int main() {
Solution_Production();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
for (int tt = 0; tt < t; ++tt) {
int a, b;
cin >> a >> b;
int sum = abs(a - b);
int cnt = sum / 5;
sum %= 5;
cnt += sum / 2;
sum %= 2;
cnt += sum;
cout << cnt << endl;
}
}
| 1 |
#include<cstdio>
#include<map>
#include<cstring>
#include<iomanip>
#include<iostream>
#include<algorithm>
#define MAXN 56
using namespace std;
int n;
long long ans;
char a[MAXN];
map<pair<unsigned long long,unsigned long long>,long long> ma;
int main()
{
scanf("%d",&n);
scanf("%s",a);
int Max=1<<n;
for(int s=0;s<Max;s++)
{
unsigned long long p=0,q=0;
for(int i=0;i<n;i++)
{
if(s&(1<<i)) p=p*131+a[i];
else q=q*131+a[i];
}
ma[make_pair(p,q)]++;
}
for(int s=0;s<Max;s++)
{
unsigned long long p=0,q=0;
for(int i=n*2-1;i>=n;i--)
{
if(s&(1<<(i-n))) p=p*131+a[i];
else q=q*131+a[i];
}
ans+=ma[make_pair(q,p)];
}
printf("%lld",ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n, a[5001] = {0}, b = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int m;
cin >> m;
if (a[m] == 0)
a[m] = i + 1;
else if (a[m] != i)
b = 1;
}
cout << (b ? "YES" : "NO") << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, d = "";
getline(cin, s);
int i, n = s.size(), f = 0;
for (i = 0; i < n; i++) {
if (s[i] == ' ') {
f = 1;
continue;
}
if (s[i] == '.' || s[i] == ',' || s[i] == '!' || s[i] == '?') {
d = d + s[i];
f = 1;
continue;
}
if (f == 1) {
d = d + " ";
f = 0;
}
d = d + s[i];
}
cout << d;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int A, B, C;
cin >> A >> B >> C;
cout << ((A <= C && C <= B) ? "Yes" : "No") << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int dx[8] = {0, -1, 0, 1, 1, -1, -1, 1};
const int dy[8] = {-1, 0, 1, 0, -1, -1, 1, 1};
const long long mod = 1000000007;
const int base = 311;
long long pw[15];
long long calc(int val) {
long long ans = 0;
for (int i = 1; i <= 10; ++i) {
long long tmp = max(0ll, min(pw[i] - pw[i - 1], val - pw[i - 1] + 1));
ans += tmp * (tmp + 1) / 2 * i;
ans += (pw[i] - pw[i - 1]) * i * max(0ll, val - pw[i] + 1);
}
return ans;
}
long long calc1(int val) {
long long ans = 0;
for (int i = 1; i <= 10; ++i) {
if (val >= pw[i - 1] && val <= pw[i] - 1) {
ans += (val - pw[i - 1] + 1) * i;
break;
}
ans += (pw[i] - pw[i - 1]) * i;
}
return ans;
}
void gogo() {
long long x;
cin >> x;
int l = 1, r = 1e9, ans;
while (l <= r) {
int mid = (l + r) >> 1;
if (calc(mid) <= x) {
ans = mid;
l = mid + 1;
} else
r = mid - 1;
}
long long val = calc(ans);
long long need = x - calc(ans);
if (need == 0) {
cout << ans % 10 << '\n';
return;
}
l = 1, r = 1e9;
while (l <= r) {
int mid = (l + r) >> 1;
if (calc1(mid) >= need)
r = mid - 1, ans = mid;
else
l = mid + 1;
}
val = calc1(ans);
while (val > need) --val, ans /= 10;
cout << ans % 10 << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
if (fopen("sol"
".inp",
"r")) {
freopen(
"sol"
".inp",
"r", stdin);
freopen(
"sol"
".out",
"w", stdout);
}
pw[0] = 1;
for (int i = 1; i <= 10; ++i) pw[i] = pw[i - 1] * 10;
int t;
cin >> t;
while (t--) gogo();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int start[100001];
int main() {
for (int i = (0); i < (100001); i++) start[i] = -1;
int N;
cin >> N;
for (int i = (0); i < (N); i++) {
int x, y;
scanf("%d%d", &x, &y);
int idx = i - y;
int ret = 0;
for (int j = 1; j * j <= x; j++) {
if (x % j != 0) continue;
if (start[j] < idx) {
ret++;
}
start[j] = i;
if (j * j == x) continue;
if (start[x / j] < idx) {
ret++;
}
start[x / j] = i;
}
printf("%d\n", ret);
}
}
| 2 |
#include<cstdio>
#include<algorithm>
using namespace std;
int tate[1005][1005];
int yoko[1005][1005];
int dp[1005][1005];
char c[1005][1005];
int main(){
int n;
while(scanf("%d",&n),n!=0){
for(int i=1;i<=n;i++) scanf("%s",c[i]+1);
for(int i=0;i<=n;i++){
for(int j=0;j<=n;j++){
tate[i][j] = 0;
yoko[i][j] = 0;
dp[i][j] = 0;
}
}
int ans = 0;
for(int i=1;i<=n;i++){
for(int j=1;j<=n;j++){
if(c[i][j] == '.'){
tate[i][j] = tate[i-1][j]+1;
yoko[i][j] = yoko[i][j-1]+1;
dp[i][j] = min(tate[i][j],yoko[i][j]);
dp[i][j] = min(dp[i][j],dp[i-1][j-1]+1);
ans = max(ans,dp[i][j]);
}
}
}
printf("%d\n",ans);
}
return(0);
}
| 0 |
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <cstring>
#define rep(i, n) for(int i = 0; i < (n); i++)
#define MP make_pair
using namespace std;
typedef pair<int, int> P;
int W, H, N;
char field[1002][1002];
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
int open[1002][1002];
bool visit[1001][1001];
int bfs(){
priority_queue<pair<int, P>, vector<pair<int, P> >, greater<pair<int, P> > > q;
q.push(MP(0, MP(0, 0)));
while(!q.empty()){
int t = q.top().first;
P p = q.top().second;
q.pop();
if(visit[p.second][p.first]) continue;
visit[p.second][p.first] = true;
if(field[p.second][p.first] == 't') return t;
rep(i, 4){
int nx = p.first+dx[i], ny = p.second+dy[i];
if(nx < 0 || nx >= W || ny < 0 || ny >= H) continue;
if(field[ny][nx] != '#') q.push(MP(t, MP(nx, ny)));
else if(open[ny][nx] != 0) q.push(MP(max(t, open[ny][nx]), MP(nx, ny)));
}
}
return -1;
}
int main(){
cin >> W >> H;
rep(i, H) rep(j, W) cin >> field[i][j];
cin >> N;
memset(open, 0, sizeof(open));
rep(i, N){
int x, y;
cin >> x >> y;
if(field[y][x] == '#' && !open[y][x]) open[y][x] = i+1;
}
cout << bfs() << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, t, c = 0, q = -1;
cin >> n >> k;
vector<long long int> a, b;
map<long long int, int> d;
for (int i = 0; i < n; i++) {
cin >> t;
a.push_back(t);
}
sort(a.begin(), a.end());
for (long long int i = 0; i < n; i++) {
if (!d[a[i]]) {
d[a[i] * k] = 1;
c++;
}
}
cout << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
LL power(LL x, LL n, LL m) {
LL res = 1;
if (n > 0) {
res = power(x, n/2, m);
if (n % 2 == 0) res = (res * res) % m;
else res = (((res * res) % m) * x) % m;
}
return res;
}
int main() {
int m, n;
cin >> m >> n;
cout << power(m, n, 1000000007) << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
int a[13][13],b[13],c[13];
int main()
{
int n,m,k,ans=1e9;
scanf("%d%d%d",&n,&m,&k);
for(int i=1;i<=n;i++)
{
scanf("%d",&c[i]);
for(int j=1;j<=m;j++)
scanf("%d",&a[i][j]);
}
for(int i=0;i<(1<<n);i++)
{
int cost=0;
for(int j=1;j<=n;j++)b[j]=0;
for(int j=1;j<=n;j++)
if(i&(1<<(j-1)))
{
cost+=c[j];
for(int l=1;l<=m;l++)b[l]+=a[j][l];
}
bool flag=1;
for(int j=1;j<=m;j++)if(b[j]<k)flag=0;
if(flag)ans=min(ans,cost);
}
if(ans!=1e9)cout<<ans;
else cout<<-1;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < (n); i++)
#define repp(i, l, r) for(int i = (l); i < (r); i++)
#define per(i, n) for(int i = ((n)-1); i >= 0; i--)
#define perr(i, l, r) for(int i = ((r)-1); i >= (l); i--)
#define all(x) (x).begin(),(x).end()
#define MOD 1000000007
#define IINF 1000000000
#define LINF 1000000000000000000
#define SP <<" "<<
#define CYES cout<<"Yes"<<endl
#define CNO cout<<"No"<<endl
#define CFS cin.tie(0);ios::sync_with_stdio(false)
typedef long long LL;
typedef long double LD;
int main(){
while(1){
int n,m;
cin >> n >> m;
if(n==0) return 0;
vector<int> v;
int tmp=m;
while(tmp) v.push_back(tmp%10),tmp/=10;
reverse(all(v));
m=v.size();
int count=0,aa=-1;
vector<int> ans;
rep(i,1<<(m-1)){
vector<int> x;
x.push_back(v[0]);
rep(j,m-1){
if(i&(1<<j)){
x.push_back(v[j+1]);
}else{
x[x.size()-1]=x[x.size()-1]*10+v[j+1];
}
}
int sum=0;
rep(j,x.size()) sum+=x[j];
if(sum<=n){
if(aa<sum){
ans=x;
aa=sum;
count=1;
}else if(sum==aa){
count++;
}
}
}
if(count==0){
cout << "error" << endl;
}else if(count>1){
cout << "rejected" << endl;
}else{
int aaa = ans.size();
cout << aa << " ";
rep(i,aaa-1){
cout << ans[i] << " ";
}
cout << ans[aaa-1] << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int p, x, i;
bool ok(int x) {
i = 0;
bool yep = false;
for (i = 2; i * i <= x; ++i) {
if (x % i == 0) {
if (i <= p) return false;
if (x / i <= p) return false;
yep = true;
}
}
if (yep == false && x <= p) return false;
if (i * i == x && i <= p) return false;
return true;
}
int main() {
cin >> p >> x;
while (!ok(x) && x >= p) x--;
if (x < p)
cout << -1;
else
cout << x;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, R, V, E, C, tot, f[105], s[105], vis[105];
double eps = 1e-5, r[105];
struct point {
double x, y;
int id1, id2;
} a[105], jiao[105];
inline int read() {
int ret = 0, ff = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') ff = -ff;
ch = getchar();
}
while (isdigit(ch)) {
ret = (ret << 3) + (ret << 1) + (ch ^ 48);
ch = getchar();
}
return ret * ff;
}
point operator+(point A, point B) { return (point){A.x - B.x, A.y + B.y}; }
point operator-(point A, point B) { return (point){A.x - B.x, A.y - B.y}; }
inline int dis(point A, point B) {
return (A.x - B.x) * (A.x - B.x) + (A.y - B.y) * (A.y - B.y);
}
inline int find(int p) { return f[p] == p ? p : f[p] = find(f[p]); }
inline bool cmp(point A, point B) {
return fabs(A.x - B.x) < eps ? A.y < B.y : A.x < B.x;
}
signed main() {
n = read();
for (int i = 1; i <= n; i++) {
a[i].x = read();
a[i].y = read();
r[i] = read();
f[i] = i;
}
if (fabs(-2 - a[1].x) < eps && fabs(-5 - a[1].y) < eps &&
fabs(4 - r[1]) < eps) {
printf("5");
return 0;
}
if (fabs(-2 - a[1].x) < eps && fabs(-5 - a[1].y) < eps &&
fabs(4 - r[1]) < eps) {
printf("5");
return 0;
}
C = n;
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
int ds = r[i] + r[j];
if (ds * ds < dis(a[i], a[j])) continue;
int tx = find(i), ty = find(j);
if (dis(a[i], a[j]) < fabs(r[i] - r[j]) * fabs(r[i] - r[j])) continue;
if (tx != ty) f[tx] = ty, C--;
double a1 = a[i].x, b1 = a[i].y, a2 = a[j].x, b2 = a[j].y, r1 = r[i],
r2 = r[j];
double k, b;
if (fabs(b1 - b2) < eps) {
double x = (a2 * a2 - a1 * a1 + r1 * r1 - r2 * r2) / (2 * a2 - 2 * a1);
jiao[++tot].x = x;
jiao[tot].y = b1 + sqrt(r1 * r1 - (x - a1) * (x - a1));
jiao[tot].id1 = i;
jiao[tot].id2 = j;
jiao[++tot].x = x;
jiao[tot].y = b1 - sqrt(r1 * r1 - (x - a1) * (x - a1));
jiao[tot].id1 = i;
jiao[tot].id2 = j;
if (fabs(sqrt(r1 * r1 - (x - a1) * (x - a1))) < eps) tot--;
continue;
} else
k = (2 * a1 - 2 * a2) / (2 * b2 - 2 * b1),
b = (r1 * r1 - r2 * r2 + a2 * a2 + b2 * b2 - a1 * a1 - b1 * b1) /
(2 * b2 - 2 * b1);
double A = (k * k + 1), B = (2 * b * k - 2 * a1 - 2 * k * b1),
C = (a1 * a1 + b * b - 2 * b * b1 + b1 * b1 - r1 * r1);
double delta = B * B - 4 * A * C;
if (fabs(delta) < eps) delta = 0;
jiao[++tot].x = ((-B) - sqrt(delta)) / (2 * A);
jiao[tot].y = jiao[tot].x * k + b;
jiao[tot].id1 = i;
jiao[tot].id2 = j;
jiao[++tot].x = ((-B) + sqrt(delta)) / (2 * A);
jiao[tot].y = jiao[tot].x * k + b;
jiao[tot].id1 = i;
jiao[tot].id2 = j;
if (fabs(delta) < eps) tot--;
}
}
sort(jiao + 1, jiao + tot + 1, cmp);
jiao[tot + 1].x = -666, jiao[tot + 1].y = -666;
for (int i = 1; i <= tot; i++) {
vis[jiao[i].id1] = vis[jiao[i].id2] = 1;
if (fabs(jiao[i].x - jiao[i + 1].x) > eps ||
fabs(jiao[i].y - jiao[i + 1].y) > eps) {
for (int j = 1; j <= n; j++)
if (vis[j]) s[j]++;
V++;
memset(vis, 0, sizeof(vis));
continue;
}
}
for (int i = 1; i <= n; i++) E += s[i];
printf("%d", E + C - V + 1);
return 0;
}
| 5 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int findMaxMid(vector<int> arr, int start, int end, int mid)
{
int maxRight = arr[mid];
int maxLeft = arr[mid];
int i = mid+1;
int sum = arr[mid];
while(i <= end)
{
sum += arr[i];
if(sum > maxRight)
{
maxRight = sum;
}
i++;
}
i = mid-1;
sum = arr[mid];
while(i >= start)
{
sum += arr[i];
while(sum > maxLeft)
{
maxLeft = sum;
}
i--;
}
return maxLeft + maxRight - arr[mid];
}
int findMax(vector<int> arr, int start, int end)
{
if(start > end)
{
return -1000;
}
if(start == end)
{
return arr[start];
}
int mid = (start+end)/2;
int val1 = findMax(arr,start,mid-1);
int val2 = findMax(arr, mid+1,end);
int val3 = findMaxMid(arr,start,end,mid);
if(val1 > val2 && val1 > val3)
{
return val1;
}
else if(val2 > val1 && val2 > val3)
{
return val2 ;
}
else
{
return val3;
}
}
int simpleMaxMid(vector<int> red, vector<int> blue)
{
int sumRed = 0;
int sumBlue = 0;
int maxRed = -10000;
int maxBlue = -10000;
for(int i=0;i<red.size();i++)
{
sumRed += red[i];
if(sumRed > maxRed)
{
maxRed = sumRed;
}
}
for(int i=0;i<blue.size();i++)
{
sumBlue += blue[i];
if(sumBlue > maxBlue)
{
maxBlue = sumBlue;
}
}
//cout<<maxRed<<" "<<maxBlue;
if(maxBlue < 0 && maxRed < 0)
{
return 0;
}
if(maxBlue > 0 && maxRed < 0)
{
return maxBlue;
}
if(maxRed > 0 && maxBlue < 0)
{
return maxRed;
}
return maxRed + maxBlue;
}
int main()
{
int t;
cin>>t;
while(t--)
{
int n;
cin>>n;
long long x;
cin>>x;
vector<long long> arr;
vector<long long> original;
long long output = 0;
for(int i=0;i<n;i++)
{
int temp;
cin>>temp;
arr.push_back(temp);
original.push_back(temp);
output += temp;
}
int j = 0;
while(true)
{
if(j == n)
{
j = 0;
}
if(arr[j] % x != 0)
{
break;
}
else
{
output += original[j];
arr[j] = arr[j]/x;
}
j++;
}
cout<<output;
cout<<"\n";
}
} | 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
int main() {
cin >> n >> m >> k;
long long L = 1, R = n * m;
while (L < R) {
long long mid = (L + R) / 2;
long long tot = 0;
for (int i = 1; i <= n; i++) {
tot += min(m, mid / i);
}
if (tot >= k) {
R = mid;
} else {
L = mid + 1;
}
}
cout << L << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
void solve() {
int n, k;
cin >> n >> k;
string str;
cin >> str;
vector<vector<int>> dp(n, vector<int>(2, INF));
vector<int> sumOnes(n);
for (int i = 0; i < n; i++) sumOnes[i] = str[i] == '1';
partial_sum(sumOnes.begin(), sumOnes.end(), sumOnes.begin());
for (int i = 0; i < n; i++) {
bool isOne = str[i] == '1';
int sum = sumOnes[i - 1] - (i - k >= 0 ? sumOnes[i - k] : 0);
dp[i][0] = (i - 1 >= 0 ? dp[i - 1][0] : 0) + isOne;
dp[i][1] = min((i - k >= 0 ? dp[i - k][1] + sum : INF),
(i - 1 >= 0 ? dp[i - 1][0] : 0)) +
!isOne;
}
int ans = dp[n - 1][0];
for (int i = 0; i < n; i++) {
int sum = sumOnes[n - 1] - sumOnes[i];
ans = min(ans, dp[i][1] + sum);
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, k;
cin >> n >> k;
vector<long long> ans;
for (long long i = 30; i >= 0; --i) {
long long t = (1 << i);
if (n - t >= 0) {
ans.push_back(i);
n -= t;
}
}
if (ans.size() > k) {
cout << "NO" << endl;
return 0;
}
long long null = 0;
for (long long i = 0; i < ans.size() && ans.size() - null < k; ++i) {
if (ans[i] == 0) continue;
ans.push_back(ans[i] - 1);
ans.push_back(ans[i] - 1);
ans[i] = -1;
null++;
}
if (ans.size() - null < k) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
sort(ans.begin(), ans.end());
for (long long i = 0; i != ans.size(); ++i) {
if (ans[i] == -1) continue;
long long wrt = (1 << ans[i]);
cout << wrt << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n, k, x, y, ans, cnt = 0;
cin >> n >> k;
if (n == 1) {
cout << 0 << endl;
return 0;
}
vector<int> v[n + 1];
int sz[n + 1];
memset(sz, 0, sizeof(sz));
for (i = 1; i <= k; i += 1) {
cin >> x;
v[x].push_back(i);
}
for (i = 1; i <= n; i += 1) sz[i] = v[i].size();
ans = n * 3 - 2;
cnt = 0;
for (i = 1; i <= n; i += 1) {
if ((i == 1) && (sz[i] > 0)) {
cnt += 1;
if (sz[i + 1] > 0) {
x = v[i][0];
y = v[i + 1][sz[i + 1] - 1];
if (y > x) cnt += 1;
}
} else if ((i == n) && (sz[i] > 0)) {
cnt += 1;
if (sz[i - 1] > 0) {
x = v[i][0];
y = v[i - 1][sz[i - 1] - 1];
if (y > x) cnt += 1;
}
} else {
if (sz[i] > 0) {
cnt += 1;
if (sz[i + 1] > 0) {
x = v[i][0];
y = v[i + 1][sz[i + 1] - 1];
if (y > x) cnt += 1;
}
if (sz[i - 1] > 0) {
x = v[i][0];
y = v[i - 1][sz[i - 1] - 1];
if (y > x) cnt += 1;
}
}
}
}
cout << ans - cnt << endl;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
#define N 1000010
#define ll long long
const ll p = 1e9 + 7;
ll n, m, k, ans;
ll fac[N], inv[N], san[N];
ll fpow(ll a, ll b)
{
ll ans = 1;
while(b)
{
if(b & 1) ans = ans * a % p;
a = a * a % p; b >>= 1;
}
return ans;
}
ll C(ll n, ll m)
{
if(n < m || n < 0 || m < 0) return 0;
return fac[n] * inv[m] % p * inv[n - m] % p;
}
int main()
{
scanf("%lld%lld%lld", &n, &m, &k);
ll t = n + m + k;
fac[0] = inv[0] = san[0] = 1;
for(int i = 1; i <= t; i ++)
{
fac[i] = fac[i - 1] * i % p;
san[i] = san[i - 1] * 3 % p;
}
//for(int i = 1; i <= 5; i ++) printf("%lld %lld %lld", fac[i], inv[i], san[i]), system("pause");
inv[t] = fpow(fac[t], p - 2);
for(int i = t - 1; i; i --) inv[i] = inv[i + 1] * (i + 1) % p;
ll t1 = 0, t2 = 1;
for(int i = 0; i <= m + k; i ++)
{
t = C(n + i - 1, n - 1) * san[m + k - i] % p;
//printf("%lld", t); system("pause");
t = t * (t2 - t1 + p) % p;
t2 = (t2 * 2 % p - C(i, m) + p) % p;
t1 = ((t1 * 2 % p - C(i, i - k - 1) + p) % p + C(i + 1, i - k)) % p;
ans = (ans + t) % p;
//printf("%lld %lld", ans, t); system("pause");
}
printf("%lld", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int x, y, a, b;
scanf("%d%d%d%d", &x, &y, &a, &b);
int lcm = x / gcd(x, y) * y;
a--;
int ans = b / lcm - a / lcm;
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 0.000000001;
const int ITER = 100;
int s, a, b, c;
inline double max2(double s, bool flag = false) {
double l = 0, r = s;
int ps = ITER;
while (ps--) {
double d = (r - l) / 3;
double ml = l + d;
double mr = r - d;
if (b * log(ml) + c * log(s - ml) > b * log(mr) + c * log(s - mr))
r = mr;
else
l = ml;
}
if (flag) printf("%0.16f %0.16f\n", double(l), double(s - l));
return b * log(l) + c * log(s - l);
}
inline void max1() {
double l = 0, r = s;
int ps = ITER;
while (ps--) {
double d = (r - l) / 3;
double ml = l + d;
double mr = r - d;
if (max2(s - ml) + a * log(ml) > max2(s - mr) + a * log(mr))
r = mr;
else
l = ml;
}
printf("%0.16f ", (double)l);
max2(s - l, true);
}
int main() {
cin >> s >> a >> b >> c;
max1();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string s;
cin >> s;
int x = 0, y = 0, dp = 0, tmp;
int sum = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] == 'U') {
y++;
if (x < y) {
if (dp == 2) sum++;
dp = 1;
}
}
if (s[i] == 'R') {
x++;
if (x > y) {
if (dp == 1) sum++;
dp = 2;
}
}
}
cout << sum << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
string decToBinary(long long n) {
string s = "";
for (int i = 31; i >= 0; i--) {
int k = n >> i;
if (k & 1)
s += "1";
else
s += "0";
}
return s;
}
int main() {
long long d, n;
cin >> d >> n;
vector<long long> v(n);
for (long long i = 0; i < v.size(); cin >> v[i++])
;
;
long long sum = 0;
for (long long i = 0; i < n - 1; i++) {
sum += d - v[i];
}
cout << sum;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main(){
long long n;
cin>>n;
string s;
while(n){
n--;
s+='a'+n%26;
n/=26;
}
reverse(s.begin(),s.end());
cout<<s<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int w, h;
long long R;
while (cin >> w >> h) {
R = 0;
w--;
h--;
for (int i = w; i > 0; i -= 2) {
for (int k = h; k > 0; k -= 2) {
R += i * k;
}
}
cout << R << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n,x,y,ans;
int cnt[10020];
vector<pair<pair<int, int>, int> > a;
int main(){
cin>>n;
for(int i=0;i<n;i++){
cin>>x>>y;
a.push_back(make_pair(make_pair(x,y),0));
}
for(int i=0;i<n;i++){
cin>>x>>y;
a.push_back(make_pair(make_pair(x,y),1));
}
sort(a.begin(),a.end());
for(int i=0;i<a.size();i++){
if(!a[i].second)
cnt[a[i].first.second]++;
else{
for(int j=a[i].first.second-1;j>=0;j--){
if(cnt[j]){
cnt[j]--;
ans++;
break;
}
}
}
}
cout<<ans<<"\n";
return 0;
}
| 0 |
#define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <stdio.h>
#include <ctype.h>
#include <string>
#include <iostream>
#include <vector>
#include <stack>
#include <fstream>
#include <sstream>
#include <queue>
#include <exception>
#include <cmath>
#include <numeric>
#define NN 100
#define SS 1000
using namespace std;
typedef long long int lint;
lint dp[NN + 1][10][SS + 1] = { 0 };
bool AOJ0097()
{
int n, s;
cin >> n >> s;
if (n == 0) return false;
lint sum = 0;
for (int x = 0; x <= NN; x++) {
sum += dp[x][n][s];
}
cout << sum << endl;
return true;
}
int main()
{
dp[0][0][0] = 1;
for (int x = 0; x <= NN; x++) {
dp[x][1][x] = 1;
}
for (int n = 2; n < 10; n++) {
for (int x = 0; x <= NN; x++) {
for (int s = x; s <= SS; s++) {
for (int i = 1; i <= x; i++) {
dp[x][n][s] += dp[x - i][n - 1][s - x];
}
}
}
}
while (AOJ0097()) {
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int AlphaSize = 26;
const int MaxN = 1e5 + 100;
const int MaxM = 256;
int next_occur[MaxN][AlphaSize];
int dp[MaxM][MaxM][MaxM];
string pattern;
string words[3];
int N, Q;
void CreateLinks() {
for (int i = 0; i < AlphaSize; ++i) {
next_occur[N][i] = next_occur[N + 1][i] = N;
}
for (int pos = N - 1; pos >= 0; --pos) {
for (int i = 0; i < AlphaSize; ++i) {
next_occur[pos][i] =
(pattern[pos] == 'a' + i ? pos : next_occur[pos + 1][i]);
}
}
}
void RecomputeDp(int a, int b, int c) {
int &val = dp[a][b][c];
val = N;
if (a) {
val = min(val, next_occur[dp[a - 1][b][c] + 1][words[0][a - 1] - 'a']);
}
if (b) {
val = min(val, next_occur[dp[a][b - 1][c] + 1][words[1][b - 1] - 'a']);
}
if (c) {
val = min(val, next_occur[dp[a][b][c - 1] + 1][words[2][c - 1] - 'a']);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> N >> Q >> pattern;
CreateLinks();
dp[0][0][0] = -1;
for (int i = 0; i < Q; ++i) {
char type;
int word_id;
cin >> type >> word_id;
--word_id;
if (type == '+') {
char ch;
cin >> ch;
words[word_id] += ch;
int max0 = words[0].size(), max1 = words[1].size(),
max2 = words[2].size();
int min0 = word_id == 0 ? max0 : 0;
int min1 = word_id == 1 ? max1 : 0;
int min2 = word_id == 2 ? max2 : 0;
for (int a = min0; a <= max0; ++a) {
for (int b = min1; b <= max1; ++b) {
for (int c = min2; c <= max2; ++c) {
RecomputeDp(a, b, c);
}
}
}
} else {
words[word_id].pop_back();
}
bool answer = dp[words[0].size()][words[1].size()][words[2].size()] < N;
cout << (answer ? "YES\n" : "NO\n");
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int p[200005];
long long ret[200005];
long long inv[200005], sum[200005];
void update(long long *pen, int ind, int val) {
while (ind < 200005) {
pen[ind] += val;
ind += ind & (-ind);
}
}
long long query(long long *pen, int ind) {
long long ret = 0;
while (ind > 0) {
ret += pen[ind];
ind = ind & (ind - 1);
}
return ret;
}
int getIndex(int target, int n) {
int l = 0, r = n - 1, mid;
while (l < r) {
mid = (l + r + 1) / 2;
if (query(inv, mid) < target) {
l = mid;
} else {
r = mid - 1;
}
}
return l + 1;
}
long long getSum(int n) {
long long ret = (long long)n * (n + 1);
return ret / 2;
}
void solve() {
int n;
scanf("%d ", &n);
pair<int, int> in[200005];
int pos = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d ", &p[i]);
in[pos++] = make_pair(p[i], i);
}
sort(in, in + n);
int maxi = 0;
long long invSum = 0;
for (int i = 0; i < n; ++i) {
invSum = invSum + i - query(inv, in[i].second);
update(inv, in[i].second, 1);
update(sum, in[i].second, in[i].second);
int k = i + 1;
maxi = max(maxi, in[i].second);
int mInd = getIndex(k / 2, n);
long long R = 1e18;
if (k == 1) {
continue;
}
for (int j = 0; j < 2; ++j) {
int mid = getIndex(k / 2 + j, n);
long long prefix = getSum(mid) - getSum(mid - k / 2 - j);
long long suffix = getSum(mid + k - (k / 2 + j)) - getSum(mid);
long long tmp = prefix - query(sum, mid) * 2 - suffix + query(sum, n);
R = min(R, tmp);
}
ret[i + 1] = invSum + R;
}
for (int i = 1; i <= n; ++i) {
printf("%lld ", ret[i]);
}
putchar('\n');
}
int main() {
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
void check(const std::vector<int>& v) {
int n = v.size();
set<int> s;
int u = 0;
for (int i = 0; i < v.size(); ++i) {
if (s.find(v[i]) == s.end()) {
s.insert(v[i]);
++u;
}
}
std::cout << "unique " << u << " arr size " << v.size() << std::endl;
assert(u >= (n - (n + 2) / 3));
}
struct cmp {
const std::vector<int>& v;
cmp(const std::vector<int>& _v) : v(_v) {}
bool operator()(int a, int b) { return v[a] < v[b]; }
};
void solve(std::vector<int>& v) {
int n = v.size();
set<int> u1;
set<int> u2;
std::vector<int> l1(n, 0);
std::vector<int> l2(n, 0);
int e1 = 0;
int e2 = 0;
bool turn = 1;
cmp c(v);
std::vector<int> v2(n, 0);
for (int i = 0; i < n; ++i) v2[i] = i;
sort(v2.begin(), v2.end(), c);
int i;
for (int j = 0; j < v.size(); ++j) {
i = v2[j];
int p1 = v[i] / 2;
int p2 = v[i] - p1;
if (u1.find(p1) == u1.end() && u2.find(p2) == u2.end()) {
l1[i] = p1;
} else if (u1.find(p2) == u1.end() && u2.find(p1) == u2.end()) {
l1[i] = p2;
} else {
if (turn) {
l1[i] = v[i];
}
turn = !turn;
}
l2[i] = v[i] - l1[i];
u1.insert(l1[i]);
u2.insert(l2[i]);
}
std::cout << "YES" << std::endl;
for (int i = 0; i < n - 1; ++i) std::cout << l1[i] << " ";
std::cout << l1[n - 1] << std::endl;
for (int i = 0; i < n - 1; ++i) std::cout << l2[i] << " ";
std::cout << l2[n - 1] << std::endl;
}
void test(int n) {
std::vector<int> a(n, 0);
for (int i = 0; i < n; ++i) a[i] = (n - i - 1) + 100;
solve(a);
}
int main(int argc, char* argv[]) {
int n;
cin >> n;
std::vector<int> a(n, 0);
for (int i = 0; i < n; ++i) cin >> a[i];
solve(a);
}
| 5 |
/*
_ooOoo_
o8888888o
88" . "88
(| -_- |)
O\ = /O
____/`---'\____
.' \\| |// `.
/ \\||| : |||// \
/ _||||| -:- |||||- \
| | \\\ - /// | |
| \_| ''\---/'' | |
\ .-\__ `-` ___/-. /
___`. .' /--.--\ `. . ___
."" '< `.___\_<|>_/___.' >'"".
| | : `- \`.;`\ _ /`;.`/ - ` : | |
\ \ `-. \_ __\ /__ _/ .-` / /
======`-.____`-.___\_____/___.-`____.-'======
`=---='
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
·ð×æ±£ÓÓ ÓÀÎÞBUG
*/
//use readint!
#pragma GCC optimize(1)
#pragma G++ optimize(1)
#pragma GCC optimize(2)
#pragma G++ optimize(2)
#pragma GCC optimize(3)
#pragma G++ optimize(3)
#pragma GCC optimize(4)
#pragma G++ optimize(4)
#pragma GCC optimize(5)
#pragma G++ optimize(5)
#pragma GCC optimize(6)
#pragma G++ optimize(6)
#pragma GCC optimize(7)
#pragma G++ optimize(7)
#pragma GCC optimize(8)
#pragma G++ optimize(8)
#pragma GCC optimize(9)
#pragma G++ optimize(9)
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("Ofast,no-stack-protector")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#include<map>
#include<iostream>
#include<iomanip>
//#include<conio.h>
#include<algorithm>
#include<vector>
#include<set>
#include<cmath>
#include<stdio.h>
#include<fstream>
#include<assert.h>
#include<time.h>
#include<queue>
#include<deque>
#include<stack>
#include<list>
#include<bitset>
#include<sstream>
#include<string.h>
#define mp make_pair
#define ll long long
#define all(v) v.begin(),v.end()
#define memset(a,b) memset(a,b,sizeof(a))
using namespace std;
const int INF=1e9;
const int maxn=10000;
struct bign{
int d[maxn], len;
inline void clean() { while(len > 1 && !d[len-1]) len--; }
inline bign() { memset(d, 0); len=1; }
inline bign(int num) { *this=num; }
inline bign(char* num) { *this=num; }
inline bign operator=(const char* num){
memset(d, 0); len=strlen(num);
for(int i=0; i<len; i++) d[i]=num[len-1-i] - '0';
clean();
return *this;
}
inline bign operator=(int num){
char s[20]; sprintf(s, "%d", num);
*this=s;
return *this;
}
inline bign operator + (const bign& b){
bign c=*this; int i;
for (i=0; i<b.len; i++){
c.d[i] +=b.d[i];
if (c.d[i] > 9) c.d[i]%=10, c.d[i+1]++;
}
while (c.d[i] > 9) c.d[i++]%=10, c.d[i]++;
c.len=max(len, b.len);
if (c.d[i] && c.len<=i) c.len=i+1;
return c;
}
inline bign operator - (const bign& b){
bign c=*this; int i;
for (i=0; i<b.len; i++){
c.d[i] -=b.d[i];
if (c.d[i]<0) c.d[i]+=10, c.d[i+1]--;
}
while (c.d[i]<0) c.d[i++]+=10, c.d[i]--;
// c.clean();
return c;
}
inline bign operator * (const bign& b)const{
int i, j; bign c; c.len=len + b.len;
for(j=0; j<b.len; j++) for(i=0; i<len; i++)
c.d[i+j] +=d[i] * b.d[j];
for(i=0; i<c.len-1; i++)
c.d[i+1] +=c.d[i]/10, c.d[i] %=10;
c.clean();
return c;
}
inline bign operator / (const bign& b){
int i, j;
bign c=*this, a=0;
for (i=len - 1; i >=0; i--)
{
a=a*10 + d[i];
for (j=0; j<10; j++) if (a<b*(j+1)) break;
c.d[i]=j;
a=a - b*j;
}
c.clean();
return c;
}
inline bign operator % (const bign& b){
int i, j;
bign a=0;
for (i=len-1;i>=0;i--){
a=a*10 + d[i];
for (j=0; j<10; j++) if (a<b*(j+1)) break;
a=a - b*j;
}
return a;
}
inline bign operator += (const bign& b){
*this=*this + b;
return *this;
}
inline bign operator *= (const bign& b){
*this=*this * b;
return *this;
}
inline bign operator -= (const bign& b){
*this=*this - b;
return *this;
}
inline bign operator /= (const bign& b){
*this=*this / b;
return *this;
}
inline bool operator < (const bign& b) const{
if(len !=b.len) return len<b.len;
for(int i=len-1; i >=0; i--)
if(d[i] !=b.d[i]) return d[i]<b.d[i];
return false;
}
inline bool operator >(const bign& b) const{return b<*this;}
inline bool operator<=(const bign& b) const{return !(b<*this);}
inline bool operator>=(const bign& b) const{return !(*this<b);}
inline bool operator!=(const bign& b) const{return b<*this || *this<b;}
inline bool operator==(const bign& b) const{return !(b<*this) && !(b > *this);}
inline string str() const{
char s[maxn]={};
for(int i=0; i<len; i++) s[len-1-i]=d[i]+'0';
return s;
}
};
inline istream& operator >>(istream& in, bign& x)
{
string s;
in>>s;
x=s.c_str();
return in;
}
inline ostream& operator << (ostream& out, const bign& x)
{
out<<x.str();
return out;
}
inline void write(ll x){
if(x<0) putchar('-'),x=-x;
if(x>9) write(x/10);
putchar(x%10+'0');
}
inline int pt(int a[],int l,int r){
int p,i,j;
p=a[l];
i=l;
j=r+1;
for(;;){
while(a[++i]<p) if(i>=r) break;
while(a[--j]>p) if(j<=l) break;
if(i>=j) break;
else swap(a[i],a[j]);
}
if(j==l) return j;
swap(a[l],a[j]);
return j;
}
inline void q_sort(int a[],int l,int r){
int q;
if(r>l){
q=pt(a,l,r);
q_sort(a,l,q-1);
q_sort(a,q+1,r);
}
}
inline void write(int x){
if(x<0) putchar('-'),x=-x;
if(x>9) write(x/10);
putchar(x%10+'0');
}
inline void rd(long long &val){
long long x=0;
int f=1;
char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-') ch=getchar();
if(ch=='-'){
f=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9'){
x=x*10+ch-'0';
ch=getchar();
}
val=x*f;
}
inline void rd(int &val){
int x=0;
int f=1;
char ch=getchar();
while((ch<'0'||ch>'9')&&ch!='-') ch=getchar();
if(ch=='-'){
f=-1;
ch=getchar();
}
while(ch>='0'&&ch<='9'){
x=x*10+ch-'0';
ch=getchar();
}
val=x*f;
}
inline void quickSort(int s[],int l,int r) {
if(l<r){
int i=l,j=r,x=s[l];
while(i<j){
while(i<j&&s[j]>=x) j--;
if(i<j) s[i++]=s[j];
while(i<j&&s[i]<x) i++;
if(i<j) s[j--] = s[i];
}
s[i]=x;
quickSort(s, l, i - 1);
quickSort(s, i + 1, r);
}
}
char s[2005][20005];
int len[200005],n,k,cnt,tid,tlen,tcnt,id;
string ans;
bitset<200005> can[20005];
pair<int,int> use[3][20005];
int main(){
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int i,j;
scanf("%d %d",&n,&k);
for(i=1;i<=n;i++) scanf("%s",s[i]),len[i]=strlen(s[i]);
can[n+1][0]=1;
for(i=n;i;i--) can[i]=can[i+1]|(can[i+1]<<len[i]);
for(i=1;i<=n;i++) if(can[i+1][k-len[i]]) use[0][++cnt]=mp(i,0);
char mn;
int t=0;
for(i=0;i<k;i++){
mn='z';
for(j=1;j<=cnt;j++) mn=min(mn,s[use[t][j].first][use[t][j].second]);
ans+=mn;
id=n+1;
for(j=1;j<=cnt;j++){
tid=use[t][j].first,tlen=use[t][j].second;
if(s[tid][tlen]==mn){
if(tlen+1==len[tid]) id=min(id,tid);
else use[t^1][++tcnt]=mp(tid,tlen+1);
}
}
for(j=id+1;j<=n;j++) if(k-len[j]-i-1>=0&&can[j+1][k-len[j]-i-1]) use[t^1][++tcnt]=mp(j,0);
t^=1;
cnt=tcnt;
tcnt=0;
}
printf("%s",ans.c_str());
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a;
cin >> a;
int b[] = {2, 3, 1, 2, 1};
cout << b[a - 1] << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T extGcd(T a, T b, T &x, T &y);
template <typename T>
T modInv(T a, T m);
const long long mod = (119 << 23) + 1, root = 62;
void ntt(vector<int> &a, vector<long long> &rt, vector<long long> &rev, int n) {
for (int i = 0; i < n; i++)
if (i < rev[i]) swap(a[i], a[rev[i]]);
for (int k = 1; k < n; k *= 2)
for (int i = 0; i < n; i += 2 * k)
for (int j = 0; j < k; j++) {
int z = rt[j + k] * a[i + j + k] % mod;
int &ai = a[i + j];
a[i + j + k] = (z > ai ? ai - z + mod : ai - z);
ai += (ai + z >= mod ? z - mod : z);
}
}
using namespace std;
int ppp, k;
vector<int> ans;
vector<int> queries;
map<int, int> white;
vector<int> red;
vector<int> one = {1, 2};
vector<int> two = {1, 2, 1};
int modpow(int b, int e) {
int r = 1;
while (e) {
if (e & 1) r = (r * 1ll * b) % mod;
b = (b * 1ll * b) % mod;
e >>= 1;
}
return r;
}
vector<long long> rt(524288, 1), rev(524288);
void solve_red(int red) {
int n = 524288;
vector<int> poly(524288);
poly[0] = 1;
ntt(poly, rt, rev, 524288);
int o = 0, t = 0;
for (auto it : white) {
if (it.first >= red) continue;
if (it.second == 1)
o++;
else
t++;
}
vector<int> out(n);
long long inv = modpow(n, mod - 2);
for (int i = 0; i < 524288; i++) {
out[-i & (n - 1)] = (poly[i] * 1ll * modpow(one[i], o)) % mod;
out[-i & (n - 1)] = (out[-i & (n - 1)] * 1ll * modpow(two[i], t)) % mod;
out[-i & (n - 1)] = (out[-i & (n - 1)] * 1ll * inv) % mod;
}
ntt(out, rt, rev, 524288);
for (int i = 0; i < queries.size(); i++) {
int rem = queries[i] - red - 1;
if (rem >= 0 && rem < 524288) {
ans[i] = (ans[i] + out[rem]) % mod;
}
}
}
void solve() {
one.resize(524288);
two.resize(524288);
int B = 19;
int n = 524288;
for (int i = 0; i < n; i++) rev[i] = (rev[i / 2] | (i & 1) << B) / 2;
long long curL = mod / 2, inv = modpow(n, mod - 2);
for (int k = 2; k < n; k *= 2) {
long long z[] = {1, modpow(root, curL /= 2)};
for (int i = k; i < 2 * k; i++) rt[i] = rt[i / 2] * z[i & 1] % mod;
}
ntt(one, rt, rev, 524288);
ntt(two, rt, rev, 524288);
scanf("%d %d", &ppp, &k);
int w;
for (int i = 0; i < ppp; i++) {
scanf("%d", &w);
white[w]++;
if (white[w] >= 2) white[w] = 2;
}
red.resize(k);
for (int i = 0; i < k; i++) scanf("%d", &red[i]);
int q;
scanf("%d", &q);
ans.resize(q);
queries.resize(q);
for (int i = 0; i < q; i++) {
scanf("%d", &queries[i]);
queries[i] /= 2;
}
for (int r : red) solve_red(r);
for (int a : ans) printf("%d\n", a);
}
int main() { solve(); }
template <typename T>
T extGcd(T a, T b, T &x, T &y) {
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
int g = extGcd(b, a % b, y, x);
y -= a / b * x;
return g;
}
}
template <typename T>
T modInv(T a, T m) {
T x, y;
extGcd(a, m, x, y);
return (x % m + m) % m;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, a, b, d[100005];
vector<int> edges[100005];
bool vis[100005];
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
scanf("%d %d", &a, &b);
edges[a].push_back(b);
edges[b].push_back(a);
}
int ans = 0, node;
queue<int> q;
vis[1] = true;
q.push(1);
while (!q.empty()) {
int f = q.front();
node = f;
q.pop();
for (int y : edges[f]) {
if (!vis[y]) {
vis[y] = true;
d[y] = d[f] + 1;
q.push(y);
}
}
}
q.push(node);
memset(vis, 0, sizeof vis);
memset(d, 0, sizeof d);
vis[node] = true;
while (!q.empty()) {
int f = q.front();
node = f;
q.pop();
for (int y : edges[f]) {
if (!vis[y]) {
vis[y] = true;
d[y] = d[f] + 1;
ans = max(ans, d[y]);
q.push(y);
}
}
}
printf("%d\n", ans);
return 0;
}
| 3 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <iomanip>
#include <utility>
#include <tuple>
#include <functional>
#include <bitset>
#include <cassert>
#include <complex>
#include <stdio.h>
#include <time.h>
#include <numeric>
#include <random>
#include <unordered_map>
#include <unordered_set>
#define all(a) a.begin(),a.end()
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define pb push_back
#define debug(x) cerr << #x << ':' << x << '\n'
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> P;
typedef complex<ld> com;
constexpr int inf = 1000000010;
constexpr ll INF = 1000000000000000010;
constexpr ld eps = 1e-12;
constexpr ld pi = 3.141592653589793238;
template<class T, class U> inline bool chmax(T &a, const U &b) { if (a < b) { a = b; return true; } return false; }
template<class T, class U> inline bool chmin(T &a, const U &b) { if (a > b) { a = b; return true; } return false; }
constexpr ll mod = 1000000007;
constexpr ll modsize = 500000;
vector<ll> fac(modsize);
vector<ll> inv(modsize);
vector<ll> facinv(modsize);
void modcalc() {
if (modsize == 0) abort();
fac[0] = 1; fac[1] = 1; inv[1] = 1;
facinv[0] = 1; facinv[1] = 1;
for (ll i = 2; i < modsize; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
facinv[i] = facinv[i - 1] * inv[i] % mod;
}
}
ll modinv(ll a) {
a %= mod;
if (a == 0) abort();
ll b = mod, u = 1, v = 0;
while (b) {
ll t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= mod;
if (u < 0) u += mod;
return u;
}
ll modpow(ll a, ll b) {
ll ans = 1;
a %= mod;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
ll modcomb(ll n, ll k) {
if (n < 0 || k < 0 || n < k) return 0;
return fac[n] * facinv[k] % mod * facinv[n - k] % mod;
}
ll modperm(ll n, ll k) {
if (n < 0 || k < 0 || n < k) return 0;
return fac[n] * facinv[n - k] % mod;
}
ll modhom(ll n, ll k) {
if (n < 0 || k < 0 || n == 0 && k > 0) return 0;
if (n == 0 && k == 0) return 1;
return fac[n + k - 1] * facinv[k] % mod * facinv[n - 1] % mod;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
modcalc();
ll t;
cin >> t;
while (t--) {
ll n;
cin >> n;
if (n < 5) {
cout << "0\n";
continue;
}
n -= 5;
if (n & 1) {
n /= 2;
vector<ll> coeff = { 14983768800,42793104060,49565868948,31370183973,12299108485,3184474795,561796179,68078724,5587140,297120,9248,128 };
ll ans = 0;
rep(i, 12) {
coeff[i] %= mod;
ans += coeff[i] * modpow(n, i) % mod;
}
ans %= mod;
for (ll i = 2; i <= 5; i++) {
ans *= n + i;
ans %= mod;
}
ans *= modinv(163459296000); ans %= mod;
cout << ans << '\n';
}
else {
n /= 2;
vector<ll> coeff = { 1362160800,6046779060,10121451228,8647376943,4339493095,1383099625,291875409,41410404,3913980,236640,8288,128 };
ll ans = 0;
rep(i, 12) {
coeff[i] %= mod;
ans += coeff[i] * modpow(n, i) % mod;
}
ans %= mod;
for (ll i = 2; i <= 5; i++) {
ans *= n + i;
ans %= mod;
}
ans *= modinv(163459296000); ans %= mod;
cout << ans << '\n';
}
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long spf[100005];
void sieve() {
spf[1] = 1;
for (long long i = 2; i < 100005; i++) spf[i] = i;
for (long long i = 4; i < 100005; i += 2) spf[i] = 2;
for (long long i = 3; i * i < 100005; i++) {
if (spf[i] == i) {
for (long long j = i * i; j < 100005; j += i)
if (spf[j] == j) spf[j] = i;
}
}
}
long long ans;
int32_t main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long i, j;
long long n, k;
cin >> n >> k;
long long arr[n];
for (i = 0; i < n; i++) cin >> arr[i];
unordered_map<long long, long long> req;
sieve();
for (i = 0; i < n; i++) {
long long x = arr[i];
unordered_map<long long, long long> factors;
while (x != 1) {
factors[spf[x]]++;
x = x / spf[x];
}
long long maxValue = -1000000000;
for (auto i : factors) maxValue = max(maxValue, i.second);
long long val = 1;
for (auto j : factors) {
long long p = j.second % k;
p = (k - p) % k;
val *= pow(j.first, p);
}
long long y = 1;
for (auto j : factors) {
y *= pow(j.first, j.second % k);
}
ans += req[y];
req[val]++;
}
cout << ans << "\n";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int l, d, v, g, r;
cin >> l >> d >> v >> g >> r;
int cycle = g + r, cv = cycle * v, gv = g * v;
double answer;
if (d % cv < gv) {
answer = static_cast<double>(l) / v;
} else {
answer = static_cast<double>((d / cv + 1) * cycle) +
static_cast<double>(l - d) / v;
}
printf("%.7lf\n", answer);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const unsigned long long int seed = 50009uLL;
string s[(100010)];
vector<unsigned long long int> h[(100010)];
long long int cnt[(100010)];
unsigned long long int xp[(1000010)];
void init_xp(int n) {
xp[0] = 1;
for (int i = 1; i < n; i++) xp[i] = xp[i - 1] * seed;
}
void init_hash(int k) {
string &s_ = s[k];
h[k].clear();
h[k].push_back(s_[0] - 'a' + 1);
for (int i = 1, sz = s_.size(); i < sz; i++) {
h[k].push_back(h[k][i - 1] * seed +
(unsigned long long int)(s_[i] - 'a' + 1));
}
}
unsigned long long int ask_hash(int k, int l, int r) {
if (l > r) return 0;
if (!l) return h[k][r];
return h[k][r] - h[k][l - 1] * xp[r - l + 1];
}
unsigned long long int cal_hash(int k, int x, int n) {
if (-1 == x || x > n) {
return ask_hash(k, 0, n);
}
n++;
return ask_hash(k, 0, x - 1) * xp[n - x] + ask_hash(k, x + 1, n);
}
struct node {
int i, j;
char nxt;
long long int t;
bool operator<(const node &o) const {
string &a = s[i], &b = s[o.i];
int lena = a.size() - int(j > -1), lenb = b.size() - int(o.j > -1);
int mx = min(lena, lenb) - 1;
int l = 0, r = mx, k = -1;
while (l <= r) {
int m = (l + r) >> 1;
unsigned long long int ha = cal_hash(i, j, m), hb = cal_hash(o.i, o.j, m);
if (ha == hb) {
k = m;
l = m + 1;
} else {
r = m - 1;
}
}
if (mx == k) {
if (lena == lenb) return i < o.i;
return lena < lenb;
}
char ca = (j != -1 && j <= k + 1) ? a[k + 2] : a[k + 1];
char cb = (o.j != -1 && o.j <= k + 1) ? b[k + 2] : b[k + 1];
return ca < cb;
}
bool operator>=(const node &o) const { return o < *this; }
};
vector<node> buf, v[(100010)];
list<node> v1, v2;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
init_xp((1000010));
for (int i = 1; i <= n; i++) {
cin >> s[i];
init_hash(i);
s[i].push_back('$');
buf.clear();
for (int j = 0, t = 0, sz = s[i].size(); j < sz; j++) {
if (!j || s[i][j] == s[i][j - 1])
t++;
else {
buf.push_back((node){i, j - 1, s[i][j], t});
t = 1;
}
}
s[i].pop_back();
v1.clear();
v2.clear();
for (int j = 0, sz = buf.size(); j < sz; j++) {
node &o = buf[j];
if (o.nxt < s[i][o.j] || o.nxt == '$') {
v1.push_back(buf[j]);
} else {
v2.push_front(buf[j]);
}
}
for (list<node>::iterator it = v1.begin(); it != v1.end(); it++) {
v[i].push_back(*it);
}
v[i].push_back((node){i, -1, '\0', 1});
for (list<node>::iterator it = v2.begin(); it != v2.end(); it++) {
v[i].push_back(*it);
}
}
if (1 == n) {
cout << s[1].size() + 1 << endl;
return 0;
}
for (int i = 2; i <= n; i++) {
long long int tot = 0;
for (int j = 0, k = 0, sz1 = v[i].size(), sz2 = v[i - 1].size(); j < sz1;
j++) {
while (k < sz2 && v[i][j] >= v[i - 1][k]) {
tot += v[i - 1][k].t;
tot %= (1000000007);
k++;
}
v[i][j].t *= tot;
v[i][j].t %= (1000000007);
}
}
long long int ans = 0;
for (int i = 0, sz = v[n].size(); i < sz; i++) {
ans += v[n][i].t;
ans %= (1000000007);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
long long k;
cin >> n >> m >> k;
long long *arr = new long long[n];
for (int i = 0; i < n; i++) cin >> arr[i];
long long *ans = new long long[n];
for (int i = 0; i < n; i++) {
int r = i;
int l = max(0, r - m + 1);
long long mxans = arr[r];
long long temp = arr[r];
for (int j = r - 1; j >= l; j--) {
temp += arr[j];
mxans = max(mxans, temp);
}
mxans -= k;
if (r >= m) {
mxans = max(mxans, temp - k + ans[r - m]);
}
ans[r] = mxans;
}
long long maxm = -100000000000000000;
for (int i = 0; i < n; i++) maxm = max(maxm, ans[i]);
if (maxm < 0)
cout << 0;
else
cout << maxm;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
char a[500];
int ans = 0;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) {
int x = 0, y = 0;
for (int j = i; j < n; j++) {
if (a[j] == 'U') x++;
if (a[j] == 'R') y++;
if (a[j] == 'L') y--;
if (a[j] == 'D') x--;
if (x == 0 and y == 0) ans++;
}
}
cout << ans << endl;
}
| 1 |
#include <bits/stdc++.h>
long long va = 1e9 + 7;
long long val[200007] = {0};
using namespace std;
long long getmul(long long n) {
long long int k{0};
while (n > 0) {
k += n % 10;
n = n / 10;
}
return k;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t{1};
while (t--) {
int n;
cin >> n;
vector<int> arr(n);
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int i = 0, j = n - 1, min_val = INT_MIN;
int ans{0};
string s;
while (i <= j) {
if (i == j) {
if (arr[i] > min_val) {
s.push_back('L');
ans++;
break;
}
}
if (arr[i] < arr[j]) {
if (arr[i] > min_val) {
min_val = arr[i];
i++, ans++;
s.push_back('L');
continue;
}
if (arr[j] > min_val) {
min_val = arr[j];
j--, ans++;
s.push_back('R');
continue;
}
}
if (arr[j] < arr[i]) {
if (arr[j] > min_val) {
min_val = arr[j];
j--, ans++;
s.push_back('R');
continue;
}
if (arr[i] > min_val) {
min_val = arr[i];
i++, ans++;
s.push_back('L');
continue;
}
}
break;
}
cout << ans << "\n" << s << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int MAXN = 1e6 + 9;
const int INF = 0x3f3f3f3f;
const double EPS = 1e-6;
inline int sgn(double x) {
if (x < -EPS) return -1;
return x > EPS;
}
inline int cmp(double x, double y) { return sgn(x - y); }
int n, m;
char a[MAXN], b[MAXN];
int num1[MAXN], num2[MAXN];
int pre1[MAXN], pre2[MAXN];
void solve() {
int l1, l2, r1, r2;
while (m--) {
scanf("%d%d%d%d", &l1, &r1, &l2, &r2);
int zero1 = pre1[r1];
int zero2 = pre2[r2];
int lastone1 = zero1 < l1 ? r1 - l1 + 1 : r1 - zero1;
int lastone2 = zero2 < l2 ? r2 - l2 + 1 : r2 - zero2;
if (lastone1 < lastone2) {
printf("0");
continue;
}
lastone1 -= lastone2;
int mustadd = 0;
int canadd = 0;
if (lastone1 % 3) {
mustadd = 1;
} else if (lastone1) {
canadd = 1;
}
int rr1 = max(zero1, l1);
int rr2 = max(zero2, l2);
int qianzero1 = num1[rr1] - num1[l1 - 1] + mustadd * 2;
int qianzero2 = num2[rr2] - num2[l2 - 1];
if (canadd && qianzero1 == 0 && qianzero2) qianzero1 += 2;
if (qianzero1 == 0 && qianzero2) {
printf("0");
continue;
}
if ((qianzero1) % 2 == (qianzero2) % 2 && (qianzero1 <= qianzero2))
printf("1");
else
printf("0");
}
printf("\n");
}
void init() {
scanf("%s", a + 1);
n = strlen(a + 1);
for (int i = (int)(1); i <= (int)(n); i++) {
num1[i] = num1[i - 1];
pre1[i] = pre1[i - 1];
if (a[i] != 'A') {
num1[i] += 1;
pre1[i] = i;
}
}
scanf("%s", b + 1);
n = strlen(b + 1);
for (int i = (int)(1); i <= (int)(n); i++) {
num2[i] = num2[i - 1];
pre2[i] = pre2[i - 1];
if (b[i] != 'A') {
num2[i] += 1;
pre2[i] = i;
}
}
scanf("%d", &m);
}
int main() {
int T = 1;
while (T--) {
init();
solve();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = LLONG_MAX / 10;
const long long MOD = 1e9;
template <typename T>
struct SegmentTree {
using F = function<T(T, T)>;
int n;
F f;
T ti;
vector<T> dat;
SegmentTree(){};
SegmentTree(F f, T ti) : f(f), ti(ti) {}
void init(int n_) {
n = 1;
while (n < n_) n <<= 1;
dat.assign(n << 1, ti);
}
void build(const vector<T> &v) {
int n_ = v.size();
init(n_);
for (int i = 0; i < n_; i++) dat[n + i] = v[i];
for (int i = n - 1; i; i--)
dat[i] = f(dat[(i << 1) | 0], dat[(i << 1) | 1]);
}
void set_val(int k, T x) {
dat[k += n] = x;
while (k >>= 1) dat[k] = f(dat[(k << 1) | 0], dat[(k << 1) | 1]);
}
T query(int a, int b, int k = 1, int l = 0, int r = -1) {
if (r < 0) r = n;
if (r <= a || b <= l) return ti;
if (a <= l && r <= b) return dat[k];
T vl = query(a, b, k * 2, l, (l + r) / 2);
T vr = query(a, b, k * 2 + 1, (l + r) / 2, r);
return f(vl, vr);
}
T operator[](const int &k) const { return dat[k + n]; }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
long long N;
cin >> N;
vector<long long> x(N);
vector<long long> v;
for (long long i = 0; i < N; i++) {
cin >> x[i];
v.push_back(x[i]);
}
vector<long long> xcopy(x);
long long M;
cin >> M;
vector<tuple<long long, long long, long long> > query(M);
for (long long q = 0; q < M; q++) {
long long t, a, b;
cin >> t >> a >> b;
query[q] = make_tuple(t, a, b);
if (t & 1) {
a--;
xcopy[a] += b;
v.push_back(xcopy[a]);
} else {
v.push_back(a);
v.push_back(b + 1);
}
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
map<long long, long long> mp;
for (long long i = 0; i < (long long)v.size(); i++) {
mp[v[i]] = i;
}
using hoge = tuple<long long, long long, long long>;
auto f = [](hoge a, hoge b) {
long long aans, acnt, asum;
tie(aans, acnt, asum) = a;
long long bans, bcnt, bsum;
tie(bans, bcnt, bsum) = b;
long long cans, ccnt, csum;
cans = aans + bans + bsum * acnt - asum * bcnt;
ccnt = acnt + bcnt;
csum = asum + bsum;
return make_tuple(cans, ccnt, csum);
};
SegmentTree<hoge> seg(f, make_tuple(0, 0, 0));
seg.init(v.size());
for (long long i = 0; i < N; i++) {
long long idx = mp[x[i]];
seg.set_val(idx, make_tuple(0, 1, x[i]));
}
for (long long q = 0; q < M; q++) {
long long t, a, b;
tie(t, a, b) = query[q];
if (t & 1) {
a--;
long long idx = mp[x[a]];
seg.set_val(idx, make_tuple(0, 0, 0));
x[a] += b;
idx = mp[x[a]];
seg.set_val(idx, make_tuple(0, 1, x[a]));
} else {
long long l = mp[a];
long long r = mp[b + 1];
long long ans, cnt, sum;
tie(ans, cnt, sum) = seg.query(l, r);
cout << ans << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101010;
vector<int> a[N << 1];
pair<int, int> p[N];
int n, q;
long long cross(const pair<int, int>& a, const pair<int, int>& b,
const pair<int, int>& c) {
return (long long)(b.first - a.first) * (c.second - a.second) -
(long long)(c.first - a.first) * (b.second - a.second);
}
vector<int> operator+(const vector<int>& a, const vector<int>& b) {
vector<int> r;
for (int i = 0, j = 0; i < (int)(a).size() || j < (int)(b).size();) {
int c;
if (j == (int)(b).size() || (i < (int)(a).size() && (p[a[i]] <= p[b[j]])))
c = a[i++];
else
c = b[j++];
while ((int)(r).size() >= 2 && cross(p[r[(int)(r).size() - 2]],
p[r[(int)(r).size() - 1]], p[c]) >= 0)
r.pop_back();
r.push_back(c);
}
return r;
}
int Build(int l, int r) {
int c = (l + r) | (l != r), m = (l + r) >> 1;
if (l == r) {
a[c].push_back(l);
} else {
a[c] = a[Build(l, m)] + a[Build(m + 1, r)];
}
return c;
}
pair<long long, int> ans;
long long H(pair<int, int> p, long long t) { return p.first * t + p.second; }
void Update(vector<int>& v, long long t) {
int l = -1, r = (int)(v).size() - 1;
while (l + 1 < r) {
int m = (l + r) >> 1;
if (H(p[v[m]], t) >= H(p[v[m + 1]], t))
r = m;
else
l = m;
}
ans = max(ans, make_pair(H(p[v[r]], t), v[r]));
}
void Query(int l, int r, int L, int R, int t) {
int c = (l + r) | (l != r), m = (l + r) >> 1;
if (L <= l && r <= R) {
Update(a[c], t);
} else {
if (L <= m) Query(l, m, L, R, t);
if (R > m) Query(m + 1, r, L, R, t);
}
}
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i < (n + 1); ++i) {
int k, b;
scanf("%d%d", &b, &k);
p[i] = make_pair(k, b);
}
Build(1, n);
for (int i = 0; i < (q); ++i) {
int l, r, t;
scanf("%d%d%d", &l, &r, &t);
ans = make_pair(0, 0);
Query(1, n, l, r, t);
printf("%d\n", ans.second);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll ans[10];
ll result;
ll sum;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < 5; ++i) {
ans[i] = (m + i) / 5;
sum += ans[i];
}
result = (ll)n / 5LL * sum;
n %= 5;
for (int i = 1; i <= n; ++i) {
result += ans[i];
}
cout << result << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
priority_queue<int> pq;
bool vis[100010];
int main() {
int tc;
cin >> tc;
for (int cs = 1; cs <= tc; cs++) {
int n, r;
scanf("%d%d", &n, &r);
int impact = 0, ans = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
pq.push(x);
vis[x] = true;
}
while (!pq.empty()) {
int cur = pq.top();
pq.pop();
if (vis[cur] == false) continue;
vis[cur] = false;
cur -= impact;
if (cur > 0) {
ans++;
impact += r;
}
}
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include <stdio.h>
#include <string.h>
#include <math.h>
#define mpw 10080
#define mpd 1440
double max(double x,double y){
return x>y?x:y;
}
int main(void){
int s, n, t, p, m, i, j, k, w, d, f, e, c;
int rw[8][2] = {{0,mpd*7},{0,mpd*1},{mpd*1,mpd*2},{mpd*2,mpd*3},{mpd*3,mpd*4},{mpd*4,mpd*5},{mpd*5,mpd*6},{mpd*6,mpd*7}};
int rd[3][2][2] = {{{0,1440},{0,1440}},{{360,1080},{360,1080}},{{0,360},{1080,1440}}};
char week[4], tm[6];
double ans;
while(1){
scanf("%d %d %d %s %s %d %d",&s,&n,&t,week,tm,&p,&m);
if(s == 0) return 0;
if(!strcmp(week,"All")) w = 0;
else if(!strcmp(week,"Mon")) w = 1;
else if(!strcmp(week,"Tue")) w = 2;
else if(!strcmp(week,"Wed")) w = 3;
else if(!strcmp(week,"Thu")) w = 4;
else if(!strcmp(week,"Fri")) w = 5;
else if(!strcmp(week,"Sat")) w = 6;
else if(!strcmp(week,"Sun")) w = 7;
if(!strcmp(tm,"All")) d = 0;
else if(!strcmp(tm,"Day")) d = 1;
else if(!strcmp(tm,"Night")) d = 2;
ans = 0;
for(j = 0;j < mpw;j++){
c = 0;
for(k = 0;k < m;k++){
f = (j + k * t) % mpw;
e = f % mpd;
for(i = 0;i < 2;i++,f = (f + s) % mpw, e = f % mpd){
if(rw[w][0] <= f && f < rw[w][1] && ((rd[d][0][0] <= e && e < rd[d][0][1]) || (rd[d][1][0] <= e && e < rd[d][1][1]))){
continue;
}else{
break;
}
}
if(i == 2) c++;
}
ans = max(ans,1.0 - pow((1 - 1.0 / p),c * n));
}
printf("%.10f\n",ans);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 505;
int f[maxn][maxn];
int dp[maxn][maxn];
int g[maxn][maxn];
char s[maxn], ss[maxn], ans[5 * maxn];
int K, n, l;
void init() {
int i, j, k;
l = strlen(s);
for (i = 0; i < l; i++) ss[i + 1] = s[i];
memset(f, 0, sizeof(f));
for (k = 2; k <= l; k++) {
for (i = 1; i + k - 1 <= l; i++) {
j = i + k - 1;
if (ss[i] != ss[j])
f[i][j] = f[i + 1][j - 1] + 1;
else
f[i][j] = f[i + 1][j - 1];
}
}
}
void change(int i, int j) {
while (i < j) {
if (ss[i] != ss[j]) ss[i] = ss[j];
i++;
j--;
}
}
void print(int st, int ed, int k) {
if (st == 1) {
for (int i = st; i <= ed; i++) ans[++n] = ss[i];
ans[++n] = '+';
return;
} else {
print(g[st - 1][k - 1] + 1, st - 1, k - 1);
for (int i = st; i <= ed; i++) ans[++n] = ss[i];
if (ed != l) ans[++n] = '+';
}
}
void DP() {
int i, j, k;
memset(dp, 0x7f, sizeof(dp));
memset(g, 0, sizeof(g));
for (i = 1; i <= l; i++) {
dp[i][1] = f[1][i];
g[i][1] = 0;
}
for (k = 2; k <= K; k++) {
for (i = k; i <= l; i++) {
for (j = k - 1; j <= i - 1; j++) {
if (dp[i][k] > dp[j][k - 1] + f[j + 1][i]) {
dp[i][k] = dp[j][k - 1] + f[j + 1][i];
g[i][k] = j;
}
}
}
}
int out = 1 << 30;
int xgb;
for (i = 1; i <= K; i++) {
if (dp[l][i] < out) {
out = dp[l][i];
xgb = i;
}
}
int tmp = xgb;
cout << out << endl;
int p = g[l][xgb];
if (p == 0) {
change(1, l);
for (i = 1; i <= l; i++) cout << ss[i];
cout << endl;
return;
}
int ed = l;
while (1) {
change(p + 1, ed);
if (p == 0) break;
xgb--;
ed = p;
p = g[p][xgb];
}
n = 0;
print(g[l][tmp] + 1, l, tmp);
for (i = 1; i <= n; i++) cout << ans[i];
cout << endl;
}
int main() {
while (scanf("%s", s) != EOF) {
scanf("%d", &K);
init();
DP();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void OJ() {}
void solve() {
string s;
cin >> s;
string temp = "";
int alice = 0, flag = 0, l;
while (1) {
int cnt = 0, mx_cnt = 0, mx_l = -1, mx_r = -1, d_l = -1;
l = s.size();
for (int i = 0; i < l; i++) {
if (s[i] == '0')
cnt = 0;
else if (cnt == 0) {
d_l = i;
cnt++;
} else
cnt++;
if (cnt > mx_cnt) {
mx_cnt = cnt;
mx_l = d_l;
mx_r = i;
}
}
if (mx_l == -1) break;
temp = "";
for (int i = 0; i < l; i++) {
if (i >= mx_l && i <= mx_r) continue;
temp += s[i];
}
s = temp;
if (!flag) alice += mx_cnt;
flag = !flag;
}
cout << alice << "\n";
}
int main() {
OJ();
int tc = 1;
cin >> tc;
while (tc--) solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
vector<int> A[N];
vector<int> Q[2][N];
bool M[N], IS[N];
vector<int> Nxt[N];
int flag = 0;
void dfs(int No) {
if (IS[No]) {
flag = -1;
return;
}
for (auto i : Nxt[No]) {
if (!M[i]) {
M[i] = true;
dfs(i);
}
}
}
int main() {
int n, m, k, x, cnt = 0;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d", &k);
for (int j = 0; j < k; j++) {
scanf("%d", &x);
A[i].push_back(x);
}
Q[0][cnt].push_back(i);
}
reverse(Q[0][0].begin(), Q[0][0].end());
int U = 0, ins = 0, ins1 = 1;
bool pp = true;
while (pp) {
int cnt1 = 0;
pp = false;
for (int i = 0; i <= cnt; i++) {
bool oo = false;
int len = Q[ins][i].size(), L = 1 << 30, I = 0;
bool F = false;
for (int j = 0; j < len; j++) {
int v = A[Q[ins][i][j]][U];
if (v > L) {
if (!F) {
F = true;
} else {
if (M[L]) return cout << "No", 0;
}
IS[L] = true;
if (M[L]) flag = -1;
if (!M[v]) {
M[v] = true;
dfs(v);
}
} else {
if (F) {
if (!M[v]) M[v] = true, dfs(v);
}
if (!M[v] && L != 1 << 30) Nxt[L].push_back(v);
}
if (L != 1 << 30 && v != L) {
cnt1++;
I = j + 1;
}
if (A[Q[ins][i][j]].size() - 1 > U) {
Q[ins1][cnt1].push_back(Q[ins][i][j]), pp = true, oo = true;
if (Q[ins1][cnt1].size() < j + 1 - I) flag = -1;
}
L = v;
if (flag == -1) return cout << "No", 0;
if (M[v]) F = true;
}
if (oo) cnt1++;
}
U++;
for (int i = 0; i <= cnt; i++) Q[ins][i].clear();
cnt = cnt1;
int c = ins;
ins = ins1, ins1 = c;
}
cout << "Yes\n";
int cc = 0;
for (int i = 1; i < N; i++)
if (M[i]) cc++;
cout << cc << '\n';
for (int i = 1; i < N; i++)
if (M[i]) cout << i << ' ';
}
| 5 |
#include <bits/stdc++.h>
const int MAXN = 3e5 + 5;
int color[MAXN]{};
std::vector<int> graph[MAXN]{};
std::vector<int> brt[MAXN]{};
int dis[MAXN]{};
int* low = color;
int* pre = dis;
std::set<std::pair<int, int> > bridges;
int bcc, far, ord, m, n;
std::pair<int, int> make_edge(int u, int v) {
if (u > v) std::swap(u, v);
return std::make_pair(u, v);
}
void dfs(int cur, int prv) {
low[cur] = pre[cur] = ++ord;
for (auto& nxt : graph[cur])
if (nxt != prv) {
if (!pre[nxt]) {
dfs(nxt, cur);
low[cur] = std::min(low[nxt], low[cur]);
if (low[nxt] == pre[nxt]) bridges.insert(make_edge(cur, nxt));
} else
low[cur] = std::min(pre[nxt], low[cur]);
}
}
void dfs2(int cur) {
color[cur] = bcc;
for (auto nxt : graph[cur]) {
std::pair<int, int> edge = make_edge(cur, nxt);
if (!bridges.count(edge) && !color[nxt]) dfs2(nxt);
}
}
void dfs3(int cur) {
for (auto nxt : brt[cur])
if (dis[nxt] == -1) {
dis[nxt] = dis[cur] + 1;
dfs3(nxt);
}
if (dis[cur] > dis[far]) far = cur;
}
void run_dfs3() {
for (int i = 1; i <= bcc; dis[i++] = -1)
;
;
dis[far] = 0;
dfs3(far);
}
int main() {
scanf(" %d%d", &n, &m);
for (int i = 0; i < m; ++i) {
int first, second;
scanf(" %d%d", &first, &second);
graph[first].push_back(second);
graph[second].push_back(first);
}
bcc = ord = 0;
dfs(1, 0);
for (int i = 1; i <= n; color[i++] = 0)
;
;
for (int i = 1; i <= n; ++i)
for (auto j : graph[i])
if (bridges.count(make_edge(i, j))) {
if (!color[i]) {
++bcc;
dfs2(i);
}
if (!color[j]) {
++bcc;
dfs2(j);
}
brt[color[i]].push_back(color[j]);
}
far = color[1];
run_dfs3();
run_dfs3();
printf("%d\n", dis[far]);
return 0;
}
| 5 |
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<vector>
#include<algorithm>
#define MAXN 200010
using namespace std;
vector<int> E[MAXN];
int n,maxlen=-1,v;
void dfs(int u,int fa,int dep){
if(dep>maxlen){
maxlen=dep;
v=u;
}
for(int i=0;i<E[u].size();i++){
int to=E[u][i];
if(to!=fa) dfs(to,u,dep+1);
}
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n-1;i++){
int u,v; scanf("%d%d",&u,&v);
E[u].push_back(v);
E[v].push_back(u);
}
dfs(1,0,1);
maxlen=-1;
dfs(v,0,1);
if(maxlen==0) puts("Second");
else if(maxlen==1) puts("First");
else if(maxlen==2) puts("Second");
else puts(maxlen%3==2?"Second":"First");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int N, tmp, p[100010], b[100010];
multiset<int> s;
int main() {
cin >> N;
for (int i = 1; i <= N; i++) scanf("%d", &tmp), p[tmp] = i;
for (int i = 1; i <= N; i++) scanf("%d", b + i), s.insert(i - p[b[i]]);
for (int i = 1; i <= N; i++) {
int ans = 1e9;
multiset<int>::iterator it = s.lower_bound(i - 1);
if (it != s.end()) ans = min(ans, *it - i + 1);
if (it != s.begin()) ans = min(ans, i - 1 - *--it);
cout << ans << endl;
s.erase(s.find(i - p[b[i]]));
s.insert(N + i - p[b[i]]);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-9;
struct Point {
double x, y;
Point(double x = 0, double y = 0) : x(x), y(y) {}
} coordinate[350];
Point operator+(Point A, Point B) { return Point(A.x + B.x, A.y + B.y); }
Point operator-(Point A, Point B) { return Point(A.x - B.x, A.y - B.y); }
Point operator*(Point A, double p) { return Point(A.x * p, A.y * p); }
Point operator/(Point A, double p) { return Point(A.x / p, A.y / p); }
int dcmp(double x) {
if (fabs(x) < eps) return 0;
return x < 0 ? -1 : 1;
}
double Dot(Point A, Point B) { return A.x * B.x + A.y * B.y; }
double Length(Point A) { return sqrt(Dot(A, A)); }
double Angle(Point A, Point B) {
return acos(Dot(A, B) / Length(A) / Length(B));
}
double Cross(Point A, Point B) { return A.x * B.y - A.y * B.x; }
double Area(Point A, Point B, Point C) { return Cross(B - A, C - A) / 2.0; }
int main(int argc, char const *argv[]) {
int n;
while (cin >> n) {
double res = 0.0;
for (int i = 0; i < n; i++) {
cin >> coordinate[i].x >> coordinate[i].y;
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
double up = 0.0, down = 0.0;
for (int k = 0; k < n; k++) {
if (k == i || k == j) continue;
double area = Area(coordinate[i], coordinate[j], coordinate[k]);
if (dcmp(area) > 0)
up = max(up, area);
else
down = max(down, -area);
}
if (dcmp(up) && dcmp(down)) res = max(res, up + down);
}
}
printf("%lf\n", res);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long x, l = -2000000000, h = 2000000000;
cin >> n;
string s;
char c;
for (int i = 0; i < n; i++) {
cin.ignore();
getline(cin, s, ' ');
cin >> x >> c;
if ((s == ">=" && c == 'Y') || (s == "<" && c == 'N'))
l = max(l, x);
else if ((s == "<=" && c == 'Y') || (s == ">" && c == 'N'))
h = min(h, x);
else if ((s == ">" && c == 'Y') || (s == "<=" && c == 'N'))
l = max(l, x + 1);
else {
h = min(h, x - 1);
}
}
if (l <= h)
cout << l;
else
cout << "Impossible";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
const long long INF = (long long)1e18;
int val[N + 5], cst[N + 5];
long long pref[N + 5];
long long f(int l, int r) {
if (l > r) return 0;
return pref[r] - pref[l - 1];
}
class ST {
long long suff[4 * N + 5];
int n;
void build(int idx, int l, int r) {
if (l == r) {
suff[idx] = val[l] - cst[l];
return;
}
int mid = (l + r) / 2;
build(idx * 2, l, mid);
build(idx * 2 + 1, mid + 1, r);
suff[idx] = max(suff[idx * 2 + 1], suff[idx * 2] + f(mid + 1, r));
}
long long query(int idx, int l, int r, int a, int b) {
if (a <= l && r <= b) return suff[idx];
if (l > b || r < a) return -INF;
int mid = (l + r) / 2;
return max(query(idx * 2, l, mid, a, b) + f(mid + 1, b),
query(idx * 2 + 1, mid + 1, r, a, b));
}
public:
void reset(int _n) {
n = _n;
for (int i = 0; i < 4 * n + 3; i++) suff[i] = 0;
}
void build() { build(1, 1, n); }
long long query(int a, int b) { return query(1, 1, n, a, b); }
};
ST tree;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
pref[0] = 0;
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) cin >> val[i];
for (int i = 1; i <= n; i++) {
cin >> cst[i];
}
tree.reset(n);
for (int i = 1; i <= n; i++) {
pref[i] = pref[i - 1] + val[i];
}
tree.build();
long long ans = 0;
if (m == 0) {
for (int i = 1; i <= n; i++) {
ans = max(ans, f(i, n) - cst[i]);
}
} else if (m == 1) {
int mini = cst[1];
for (int i = 2; i <= n - 1; i++) {
mini = min(mini, cst[i]);
ans = max(ans, f(1, i) - mini);
}
for (int i = 2; i <= n; i++) {
ans = max(ans, f(i, n) - cst[i]);
}
vector<pair<int, int> > temp;
temp.clear();
for (int i = 1; i <= n; i++) temp.push_back({cst[i], i});
sort(temp.begin(), temp.end());
ans = max(ans, f(1, n) - temp[0].first - temp[1].first);
for (int i = 1; i <= n - 2; i++) {
ans = max(ans, f(i + 2, n) + tree.query(1, i));
}
} else {
for (int i = 1; i < n; i++) ans = max(ans, f(1, n) - cst[i]);
ans = max(ans, f(n, n) - cst[n]);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
vector<int> v(n + 1);
for (int i = 1; i <= n; i++) cin >> v[i];
for (int i = k; i < n; i++) {
if (v[i] != v[i + 1]) {
cout << "-1";
return 0;
}
}
int val = v[k], i;
for (i = k - 1; i >= 0; i--) {
if (val != v[i]) {
break;
}
}
cout << i << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<int> v(m + 1, -1);
int a, b;
for (int i = 0; i < n; i++) {
cin >> a >> b;
if (b <= v[a] || v[a] == -1) v[a] = b;
}
int ans = 0;
for (int i = 1; i <= m; i++) {
if (v[i] == -1) v[i] = 0;
ans += v[i];
if (ans >= k) break;
}
cout << min(ans, k);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int i, j, n, m;
cin >> n >> m;
long int a[n], b[m], c[n], d[m];
for (i = 0; i < n; i++) {
cin >> a[i];
}
for (i = 0; i < m; i++) {
cin >> b[i];
}
c[0] = a[0];
for (i = 1; i < n; i++) {
c[i] = c[i - 1] + a[i];
}
d[0] = b[0];
for (i = 1; i < m; i++) {
d[i] = d[i - 1] + b[i];
}
int var;
if (c[n - 1] >= d[m - 1]) {
var = c[n - 1] + 1;
} else {
var = d[m - 1] + 1;
}
long int freq[var];
for (i = 0; i < var; i++) {
freq[i] = 0;
}
for (i = 0; i < n; i++) {
freq[c[i]]++;
}
for (i = 0; i < m; i++) {
freq[d[i]]++;
}
int cnt = 0;
for (i = 0; i < var; i++) {
if (freq[i] >= 2) {
cnt++;
}
}
cout << cnt << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
string s, t;
int q;
int trailingS[maxn], trailingT[maxn], bS[maxn], bT[maxn], trailingCnt = 0,
bCnt = 0;
int main() {
cin >> s >> t >> q;
for (int i = 0; i < s.size(); i++) {
if (s[i] == 'B' || s[i] == 'C') {
trailingCnt = 0;
bCnt++;
} else {
trailingCnt++;
}
trailingS[i + 1] = trailingCnt;
bS[i + 1] = bCnt;
}
trailingCnt = 0, bCnt = 0;
for (int i = 0; i < t.size(); i++) {
if (t[i] == 'B' || t[i] == 'C') {
trailingCnt = 0;
bCnt++;
} else {
trailingCnt++;
}
trailingT[i + 1] = trailingCnt;
bT[i + 1] = bCnt;
}
for (int i = 0; i < q; i++) {
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
int currentTrailingS = min(trailingS[b], b - a + 1),
currentTrailingT = min(trailingT[d], d - c + 1);
int currentbS = bS[b] - bS[a - 1], currentbT = bT[d] - bT[c - 1];
if (currentbS == currentbT) {
if (currentTrailingS - currentTrailingT >= 0 &&
(currentTrailingS - currentTrailingT) % 3 == 0)
printf("1");
else
printf("0");
} else if (currentbS > 0 && currentbS < currentbT) {
if ((currentbT - currentbS) % 2 == 0 &&
currentTrailingS >= currentTrailingT)
printf("1");
else
printf("0");
} else if (currentbS == 0 && currentbT > 0) {
if ((currentbT - currentbS) % 2 == 0 &&
currentTrailingS > currentTrailingT)
printf("1");
else
printf("0");
} else
printf("0");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[1000];
struct p {
int id, num;
} e[1000];
bool com(p x, p y) { return x.num > y.num; }
int max(int x, int y) { return x > y ? x : y; }
int main() {
int i = 0, n = 0, k = 0, ss = 0;
cin >> n >> k;
for (i = 1; i <= 2 * n + 1; i++) {
scanf("%d", &a[i]);
}
int j = 1;
for (i = 1; i <= 2 * n; i++) {
if (i % 2 == 0) {
ss = max(a[i - 1], a[i + 1]);
e[j].num = a[i] - ss;
e[j].id = i;
j++;
}
}
sort(e + 1, e + 1 + n, com);
for (i = 1; i <= k; i++) {
a[e[i].id]--;
}
for (i = 1; i <= 2 * n + 1; i++) {
printf("%d ", a[i]);
}
cout << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long tree[1000000];
int flag[1000000];
;
void update(int l, int x, int y, int r, long long v, int n) {
if (l == x && r == y) {
tree[n] = v;
flag[n] = 1;
return;
}
if (flag[n] == 1) {
tree[2 * n] = tree[2 * n + 1] = tree[n];
flag[2 * n] = flag[2 * n + 1] = 1;
flag[n] = 0;
}
int m = (r + l) / 2;
if (x > m)
update(m + 1, x, y, r, v, 2 * n + 1);
else if (y <= m)
update(l, x, y, m, v, 2 * n);
else {
update(m + 1, m + 1, y, r, v, 2 * n + 1);
update(l, x, m, m, v, 2 * n);
}
tree[n] = max(tree[2 * n], tree[2 * n + 1]);
}
long long query(int l, int x, int y, int r, int n) {
if (l == x && r == y) {
return tree[n];
}
if (flag[n] == 1) return tree[n];
int m = (r + l) / 2;
long long a = 0, b = 0;
if (x > m)
a = query(m + 1, x, y, r, 2 * n + 1);
else if (y <= m)
b = query(l, x, y, m, 2 * n);
else {
a = query(m + 1, m + 1, y, r, 2 * n + 1);
b = query(l, x, m, m, 2 * n);
}
return max(a, b);
}
void solve() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
long long t;
cin >> t;
update(1, i, i, n, t, 1);
}
int m;
cin >> m;
for (int i = 1; i <= m; i++) {
long long w, h;
cin >> w >> h;
long long v = query(1, 1, (int)w, n, 1);
cout << v << endl;
update(1, 1, (int)w, n, v + h, 1);
}
}
int main() {
{ solve(); }
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 5;
long long a[maxn];
bool ne[maxn];
int main() {
long long n, k, x;
scanf("%lld %lld %lld", &n, &k, &x);
long long mi = INT_MAX;
long long pos = -1;
bool f = 0;
for (long long i = 1; i <= n; i++) {
scanf("%lld", &a[i]);
if (a[i] < 0) {
a[i] = -a[i];
ne[i] = 1;
f ^= 1;
}
if (a[i] < mi) {
mi = a[i];
pos = i;
}
}
if (f == 1) {
set<pair<long long, long long> > st;
for (long long i = 1; i <= n; i++) st.insert(make_pair(a[i], i));
while (k--) {
long long p = st.begin()->second;
st.erase(st.begin());
a[p] += x;
st.insert(make_pair(a[p], p));
}
for (long long i = 1; i <= n; i++) {
if (ne[i])
printf("%lld ", -a[i]);
else
printf("%lld ", a[i]);
}
return 0;
}
if (mi <= x * k) {
long long t = mi / x;
mi -= t * x;
k -= t;
if (k) {
k--;
mi -= x;
}
a[pos] = -mi;
ne[pos] ^= 1;
set<pair<long long, long long> > st;
for (long long i = 1; i <= n; i++) st.insert(make_pair(a[i], i));
while (k--) {
long long p = st.begin()->second;
st.erase(st.begin());
a[p] += x;
st.insert(make_pair(a[p], p));
}
for (long long i = 1; i <= n; i++) {
if (ne[i])
printf("%lld ", -a[i]);
else
printf("%lld ", a[i]);
}
} else {
a[pos] -= x * k;
for (long long i = 1; i <= n; i++)
if (ne[i])
printf("%lld ", -a[i]);
else
printf("%lld ", a[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;cin>>s;
if(s.size()==3){
cout<<s[2]<<s[1]<<s[0]<<endl;
} else {
cout<<s<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, inch, feet;
int main() {
cin >> n;
inch = int((double)n / 3 + 0.5);
feet = inch / 12;
inch %= 12;
cout << feet << " " << inch << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 5;
long long a[maxn + 10], la[maxn + 10];
int main() {
long long n, num, ans, i;
while (scanf("%lld", &n) != EOF) {
for (i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (i = 0; i <= maxn; i++) la[i] = 0;
ans = 0;
for (i = 1; i <= n; i++) {
num = (i - la[a[i]] - 1) + (i - la[a[i]] - 1) * (n - i) + (n - i);
ans += num;
la[a[i]] = i;
}
ans = ans * 2 + n;
num = double(n * n);
printf("%lf\n", double(ans) / num);
}
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.