solution
stringlengths 53
181k
| difficulty
int64 0
13
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int a, b, lengthc, lengthd, record[110], dp[110];
char c[110], d[110];
void findcircle() {
for (int i = 0; i < lengthd; i++) {
int p = i;
for (int j = 0; j < lengthc; j++) {
if (d[p] == c[j]) p++;
if (p == lengthd) {
record[i]++;
p = 0;
}
}
dp[i] = p;
}
}
void solve() {
scanf("%d%d\n%s\n%s\n", &a, &b, c, d);
lengthc = strlen(c);
lengthd = strlen(d);
findcircle();
int total = 0, p = 0;
for (int i = 0; i < a; i++) {
total += record[p];
p = dp[p];
}
total /= b;
printf("%d\n", total);
}
int main() {
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int solucion(long long int n) {
long long int resp = 0;
switch (n % 4LL) {
case 0:
resp = n / 4LL;
break;
case 1:
if (n >= 9) {
n -= 9;
resp = 1;
resp += n / 4LL;
} else
resp = -1;
break;
case 2:
if (n >= 6) {
n -= 6;
resp = 1;
resp += n / 4LL;
} else
resp = -1;
break;
case 3:
if (n >= 15) {
n -= 15;
resp = 2;
resp += n / 4LL;
} else
resp = -1;
break;
}
return resp;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int Q;
cin >> Q;
long long int n;
while (Q--) {
cin >> n;
cout << solucion(n) << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXSIZE = 1e5 + 10;
set<int> A[MAXSIZE];
set<int> P[MAXSIZE];
set<int> usedN;
int sol[MAXSIZE];
int n;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n - 2; i++) {
for (int j = 0; j < 3; j++) {
int t;
cin >> t;
P[i].insert(t);
A[t].insert(i);
}
}
for (int i = 1; i <= n; i++) {
if (A[i].size() == 1) {
sol[0] = i;
for (auto e : P[*A[i].begin()]) {
if (A[e].size() == 2) {
sol[1] = e;
}
}
break;
}
}
for (int i = 0; i < 2; i++) {
usedN.insert(sol[i]);
}
int k = 2;
while (k <= n) {
int x = k - 2;
bool work = true;
for (auto p : A[sol[x]]) {
for (auto e : P[p]) {
if (usedN.insert(e).second == true) {
sol[k] = e;
work = false;
break;
}
}
if (!work) break;
}
k++;
}
for (int i = 0; i < n; i++) {
cout << sol[i] << " \n"[i == (n - 1)];
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
namespace NT {
int mod = 1e9 + 7;
vector<int> fact;
vector<int> inv_fact;
inline int norm(long long a) {
a %= mod;
if (a < 0) a += mod;
return a;
}
inline bool is_ok(long long x) { return (0 <= x and x < mod); }
inline int add(long long a, long long b) {
if (not is_ok(a)) a = norm(a);
if (not is_ok(b)) b = norm(b);
long long ret = a + b;
if (ret >= mod) ret -= mod;
return ret;
}
inline int sub(long long a, long long b) {
if (not is_ok(a)) a = norm(a);
if (not is_ok(b)) b = norm(b);
long long ret = a - b;
if (ret < 0) ret += mod;
return ret;
}
inline int mul(long long a, long long b) {
if (not is_ok(a)) a = norm(a);
if (not is_ok(b)) b = norm(b);
return (a * b) % mod;
}
int bin_pow(long long a, long long b) {
int ret = 1;
while (b) {
if (b & 1) ret = mul(ret, a);
a = mul(a, a);
b >>= 1;
}
return ret;
}
int inv(long long a) { return bin_pow(a, mod - 2); }
void preprocess_factorial(int n) {
fact.resize(n + 1);
inv_fact.resize(n + 1);
fact[0] = 1;
for (int i = 1; i <= n; i++) fact[i] = mul(fact[i - 1], i);
inv_fact[n] = inv(fact[n]);
for (int i = n - 1; i >= 0; i--) inv_fact[i] = mul(inv_fact[i + 1], i + 1);
}
int comb(int a, int b) {
if (a < b) return 0;
return mul(mul(fact[a], inv_fact[b]), inv_fact[a - b]);
}
} // namespace NT
void solve() {
int n;
cin >> n;
string a = "ROYGBIV", b = "GBIV";
cout << a;
for (int i = 0; i < n - 7; i++) {
cout << b[i % 4];
}
cout << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) solve();
}
| 2 |
#include<bits/stdc++.h>
#define int long long
#define ll long long
using namespace std;
const int N = 2e5+5, MOD = 1e9+7;
int fact[N];
ll exp(ll a,ll n){
if(n==0) return 1;
if(n==1) return a;
ll ans=exp(a,n/2);
ans*=ans;ans%=MOD;
if(n&1) ans*=a,ans%=MOD;
return ans;
}
int npr(int n,int r){
return (fact[n] * exp(fact[n-r], MOD-2)) % MOD;
}
void solve(){
fact[0] = 1;
for(int i=1;i<N;i++)
fact[i] = (fact[i-1] * i) % MOD;
int t;cin>>t;
while(t--){
int n;cin>>n;
int a[n];
for(int i=0;i<n;i++) cin>>a[i];
sort(a, a+n);
if(a[0] == a[n-1]){
cout<<fact[n]<<"\n";
continue;
}
int set[35]{};
int fail = 0;
for(int b=0;b<32;b++){
int count[2]{};
for(int i=0;i<n;i++){
int flag = (a[i]&(1ll<<b) ? 1:0);
count[flag]++;
}
// cout<<b<<" "<<count[0]<<" "<<count[1]<<"\n";
if(count[0] && count[1]){
if(count[0] < 2) fail = 1;
set[b] = 1;
// cout<<b<<" b";
}
}
// cout<<"\n";
int border = 0;
for(int i=0;i<n;i++){
int fail = 0;
for(int bi=0;bi<32;bi++){
int flag = (a[i]&(1ll<<bi) ? 1:0);
if(set[bi] && flag){
fail = 1;
break;
}
}
if(!fail) border+=1;
}
// cout<<border<<" check\n";
int ans = -1;
if(fail || border < 2) ans = 0;
else ans = (npr(border, 2) * fact[n-2]) % MOD;
cout<<ans<<"\n";
}
}
signed main(){
ios_base::sync_with_stdio(false);cin.tie(NULL);
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
char ch;
bool flag = false;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') flag = true;
for (x = 0; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
x = flag ? -x : x;
}
inline void write(int x) {
static const int maxlen = 100;
static char s[maxlen];
if (x < 0) {
putchar('-');
x = -x;
}
if (!x) {
putchar('0');
return;
}
int len = 0;
for (; x; x /= 10) s[len++] = x % 10 + '0';
for (int i = len - 1; i >= 0; --i) putchar(s[i]);
}
const int MAXN = 110;
int n;
int a[MAXN];
int f[MAXN][MAXN * MAXN];
int cnt[MAXN];
int main() {
read(n);
int sum = 0;
for (int i = 1; i <= n; i++) {
read(a[i]);
cnt[a[i]]++;
sum += a[i];
}
sort(a + 1, a + n + 1);
f[0][0] = 1;
for (int i = 1; i <= 100; i++) {
for (int num = n; num >= 1; num--)
for (int j = min(cnt[i], num); j >= 1; j--)
for (int k = j * i; k <= sum; k++)
f[num][k] = min(2, f[num][k] + f[num - j][k - j * i]);
}
int ans = 0;
if (cnt[a[1]] + cnt[a[n]] == n) ans = n;
for (int val = 1; val <= 100; val++)
for (int j = 1; j <= cnt[val]; j++) {
if (f[j][j * val] == 1) ans = max(ans, j);
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int a[30];
int main() {
string str;
while (cin >> str) {
memset(a, 0, sizeof a);
for (int i = 0; i < str.size(); i++) {
a[str[i] - 'a'] = i;
}
string s;
int k = 0;
for (int i = 'z' - 'a'; i >= 0; i--) {
if (i != 'z' - 'a') k = max(a[i + 1], k);
for (int j = k; j <= a[i]; j++) {
if (str[j] == i + 'a') s += str[j];
}
}
cout << s << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 2e9;
const int N = 300010;
const int MOD = 1e9 + 7;
int n;
int main() {
cin >> n;
int res = 0;
for (int i = 1; i <= n; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
res += (x2 - x1 + 1) * (y2 - y1 + 1);
}
cout << res;
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
using namespace std;
const long long MOD = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
long long n, m;
cin >> n >> m;
vector<long long> ar;
long long sum = 0;
for (long long i = 1; i <= 10; i++) {
long long x = m * i;
ar.push_back(x % 10);
sum += x % 10;
}
long long f = n / m;
sum *= (f / 10);
for (long long i = 0; i < f % 10; i++) sum += ar[i];
cout << sum << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e2;
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
char a;
cin >> a;
if (a == 'C' || a == 'M' || a == 'Y') {
cout << "#Color";
return 0;
}
}
}
cout << "#Black&White";
return 0;
}
| 0 |
#include <iostream>
#include <vector>
#include <queue>
#define NMAX 200000
using namespace std;
int t, vf, n, m, dist[NMAX+10], viz[NMAX+10], stiva[NMAX+10], ans[NMAX+10];
vector <int> nod1[NMAX+10], nod[NMAX+10], nod2[NMAX+10];
queue <int> Q;
void bfs(int x)
{ dist[x] = 0;
viz[x] = 1;
Q.push(x);
while(!Q.empty())
{ int x = Q.front();
Q.pop();
for(auto u : nod[x])
if(!viz[u])
{ viz[u] = 1;
dist[u] = dist[x] + 1;
Q.push(u);
}
}
}
void dfs(int x)
{ viz[x] = 1;
for(auto u : nod1[x])
if(!viz[u]) dfs(u);
stiva[++vf] = x;
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while(t--)
{ int n, m;
vf = 0;
cin >> n >> m;
for(int i=1; i<=n; i++)
{ nod[i].clear();
nod1[i].clear();
nod2[i].clear();
viz[i] = 0;
}
for(int i=1; i<=m; i++)
{ int nod1, nod2;
cin >> nod1 >> nod2;
nod[nod1].push_back(nod2);
}
bfs(1);
for(int i=1; i<=n; i++) ans[i] = dist[i];
for(int i=1; i<=n; i++)
for(auto u : nod[i])
{ if(dist[i] < dist[u]) nod1[i].push_back(u);
else nod2[i].push_back(u);
}
for(int i=1; i<=n; i++) viz[i] = 0;
dfs(1);
for(int i=1; i<=n; i++)
{ int x = stiva[i];
for(auto u : nod1[x]) ans[x] = min(ans[x], ans[u]);
for(auto u : nod2[x]) ans[x] = min(ans[x], dist[u]);
}
for(int i=1; i<=n; i++) cout << ans[i] << ' ';
cout << '\n';
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long double TL = 1.0;
bool is_tl = 0;
long long CALLS = 0;
inline bool IS() {
if (++CALLS == 1000) {
CALLS = 0;
is_tl |= clock() > (TL - 0.1) * CLOCKS_PER_SEC;
}
return is_tl;
}
template <typename T1, typename T2>
inline void amin(T1 &a, T2 b) {
if (a > b) a = b;
}
template <typename T1, typename T2>
inline bool amax(T1 &a, T2 b) {
if (a < b) {
a = b;
return 1;
} else
return 0;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, pair<T1, T2> &p) {
os << p.first << ' ' << p.second << endl;
return os;
}
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
is >> p.first >> p.second;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, vector<T> &v) {
for (auto &u : v) os << u << ' ';
os << endl;
return os;
}
mt19937 rnd(chrono::steady_clock::now().time_since_epoch().count());
const long long N = 1e6 + 7, NS = 2e3 + 7, lg = 20, sq = 550, inf = 2e9 + 7,
SM = 1e2 + 7;
const long double eps = 1e-9;
long long hash_mod[4] = {1000000007, 998244353, 1000000009, 999999937},
mod = hash_mod[rnd() % 4];
long long hash_pows[4] = {179, 239, 1007, 2003}, P = hash_pows[rnd() % 4];
map<vector<long long>, long long> mp;
long long cur = 0, used[N], c[N], mark[N], was = 3;
vector<long long> v[N], r[N];
void dfs(long long first, long long p) {
mark[first] = 1;
c[first] = was++;
for (auto u : r[first]) {
if (!mark[u])
dfs(u, first);
else if (u != p) {
cout << "NO\n";
exit(0);
}
}
}
void solve() {
long long n, m;
cin >> n >> m;
for (long long i = 0; i < m; i++) {
long long a, b;
cin >> a >> b;
a--, b--;
v[a].push_back(b);
v[b].push_back(a);
}
for (long long i = 0; i < n; i++) {
v[i].push_back(i);
sort((v[i]).begin(), (v[i]).end());
if (!mp.count(v[i])) mp[v[i]] = cur++;
used[i] = mp[v[i]];
}
for (long long i = 0; i < n; i++) {
for (auto u : v[i]) {
if (used[i] != used[u]) r[used[i]].push_back(used[u]);
}
}
for (long long i = 0; i < cur; i++) {
sort((r[i]).begin(), (r[i]).end());
r[i].erase(unique((r[i]).begin(), (r[i]).end()), r[i].end());
if (r[i].size() >= 3) {
cout << "NO";
return;
}
}
c[0] = 1;
for (long long i = 0; i < cur; i++) {
if (!mark[i] && r[i].size() == 1) {
was++;
dfs(i, -1);
}
}
for (long long i = 0; i < cur; i++) {
if (!mark[i] && r[i].size()) {
cout << "NO\n";
return;
}
}
cout << "YES\n";
for (long long i = 0; i < n; i++) cout << c[used[i]] << ' ';
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
| 8 |
#include<bits/stdc++.h>
#define LL long long
#define Pii pair<int,int>
#define MOD 998244353
#define MAXN 505
#define Val(x) (((LL)x) % MOD)
using namespace std;
char type[MAXN];
int arr[MAXN],dp[MAXN][MAXN];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
for(int i=1;i<=n;i++) {
cin >> type[i];
if(type[i] == '+') cin >> arr[i];
}
int ans = 0;
for(int i=1;i<=n;i++)
if(type[i] == '+') {
memset(dp, 0, sizeof dp);
dp[0][0] = 1;
for(int j=1;j < i;j++) {
for(int k=0;k<=j;k++)
dp[j][k] = dp[j - 1][k];
if(type[j] == '+') {
for(int k=0;k<=j;k++) {
if(arr[j] <= arr[i] && k > 0)
dp[j][k] = Val(dp[j][k] + dp[j - 1][k - 1]);
else if(arr[j] > arr[i])
dp[j][k] = Val(dp[j][k] + dp[j - 1][k]);
}
}
else {
dp[j][0] = Val(dp[j][0] + dp[j - 1][0]);
for(int k=0;k<=j;k++)
dp[j][k] = Val(dp[j][k] + dp[j - 1][k + 1]);
}
}
for(int j=0;j<=i;j++) dp[i][j] = dp[i - 1][j];
for(int j=i + 1;j<=n;j++) {
for(int k=0;k<=j;k++)
dp[j][k] = dp[j - 1][k];
if(type[j] == '+') {
for(int k=0;k<=j;k++) {
if(arr[j] < arr[i] && k > 0)
dp[j][k] = Val(dp[j][k] + dp[j - 1][k - 1]);
else if(arr[j] >= arr[i])
dp[j][k] = Val(dp[j][k] + dp[j - 1][k]);
}
}
else {
for(int k=0;k<=j;k++)
dp[j][k] = Val(dp[j][k] + dp[j - 1][k + 1]);
}
}
for(int j=0;j<=n;j++) ans = Val(arr[i] * dp[n][j] + ans);
}
cout << ans << endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e3 + 5;
int n, pos;
bool mat1[MAXN][MAXN];
bool mat2[MAXN][MAXN];
bool piv[MAXN][MAXN];
bool pat[MAXN];
vector<int> r, c;
bool check() {
bool can = true;
for (int i = 0; i < n; i++)
if (piv[pos][i] != mat2[pos][i]) {
c.push_back(i);
for (int j = 0; j < n; j++) piv[j][i] = piv[j][i] ^ pat[j];
}
for (int i = 0; i < n; i++) {
bool ok = true;
for (int j = 0; j < n; j++)
if (piv[i][j] != mat2[i][j]) ok = false;
if (!ok) {
r.push_back(i);
for (int j = 0; j < n; j++) piv[i][j] = piv[i][j] ^ pat[j];
ok = true;
for (int j = 0; j < n; j++)
if (piv[i][j] != mat2[i][j]) ok = false;
if (!ok) can = false;
}
}
return can;
}
void cop() {
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++) piv[i][j] = mat1[i][j];
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
bool can = true;
string s;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < n; j++) mat1[i][j] = (s[j] == '1');
}
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < n; j++) mat2[i][j] = (s[j] == '1');
}
pos = -1;
cin >> s;
for (int i = n - 1; i >= 0; i--) {
pat[i] = (s[i] == '1');
if (pat[i]) pos = i;
}
if (pos == -1) {
bool extra = true;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
if (piv[i][j] != mat2[i][j]) extra = false;
if (extra)
cout << 0;
else
cout << -1;
return 0;
}
cop();
if (check()) {
cout << r.size() + c.size() << '\n';
for (int v : r) cout << "row " << v << '\n';
for (int v : c) cout << "col " << v << '\n';
} else {
cop();
r.clear();
c.clear();
r.push_back(pos);
for (int i = 0; i < n; i++) piv[pos][i] = piv[pos][i] ^ pat[i];
if (check()) {
cout << r.size() + c.size() << '\n';
for (int v : r) cout << "row " << v << '\n';
for (int v : c) cout << "col " << v << '\n';
} else
cout << -1;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t, m, n, i, mi, sum, x;
bool f;
for (cin >> t; t > 0; t--) {
cin >> m >> n;
mi = 101;
f = 0;
sum = 0;
for (i = 0; i < m * n; i++) {
cin >> x;
if (x < 0) {
f = !f;
x = -x;
}
if (x < mi) mi = x;
sum += x;
}
if (f) sum -= 2 * mi;
cout << sum << '\n';
}
}
| 1 |
#include <bits/stdc++.h>
namespace Main {
namespace Sourse {
enum { N = 100, L = (const long unsigned int)1e8 };
using std::min;
using std::sort;
static inline const void amax(long unsigned int& a, const long unsigned int b) {
if (a < b) a = b;
}
} // namespace Sourse
using namespace Sourse;
struct spotlight {
long signed int a;
long unsigned int l;
spotlight() : a(-L), l(0) {}
inline const void input() { scanf("%ld%lu", &a, &l); }
friend inline const bool operator<(const spotlight& a, const spotlight& b) {
return a.a < b.a;
}
};
static short unsigned int n;
static spotlight s[N + 1];
static long unsigned int f[N + 1][N + 1][2];
static long unsigned int ans(0);
static inline const void begin() {
scanf("%hu", &n);
for (short unsigned int i(1); i <= n; ++i) s[i].input();
sort(s + 1, s + 1 + n);
}
static inline const void end() { printf("%lu\n", ans); }
static inline const void main() {
begin();
for (short unsigned int i(0); i <= n; ++i) {
for (short unsigned int j(0); j <= i; ++j) {
for (short unsigned int k(0); k < 2; ++k) {
amax(ans, f[i][j][k]);
long signed int r(s[j].a + s[j].l * k), max_r(r);
short unsigned int _j(j), _k(k);
for (short unsigned int l(i + 1); l <= n; ++l) {
for (short unsigned int m(0); m < 2; ++m) {
const long signed int _r(s[l].a + s[l].l * m);
if (_r >= max_r) max_r = _r, _j = l, _k = m;
if (_r < r) continue;
amax(f[l][_j][_k],
f[i][j][k] + min((const long unsigned int)(_r - r), s[l].l) +
(max_r - _r));
}
}
}
}
}
end();
}
} // namespace Main
signed int main() {
Main::main();
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
inline Point() {}
inline Point(int _x, int _y) {
x = _x;
y = _y;
}
} po[6000];
int n, r;
inline int sqr(int x) { return x * x; }
int dx[] = {1, -1, 0, 0}, dy[] = {0, 0, 1, -1};
inline bool ok(int x, int y) {
int a = sqr(x), b = sqr(y), c = sqr(r);
if (a + b > c) return 0;
if (a + b == c) return 1;
for (int i = 0; i < 4; ++i) {
int xx = x + dx[i], yy = y + dy[i];
if (sqr(xx) + sqr(yy) > c) return 1;
}
return 0;
}
int dp[10][505][505];
int p1[10][505][505], p2[10][505][505];
bool inq[10][505][505];
int V = 250;
struct Node {
int c, s1, s2;
inline Node() {}
inline Node(int _c, int _s1, int _s2) {
c = _c;
s1 = _s1;
s2 = _s2;
}
};
queue<Node> Q;
void output(int c, int s1, int s2) {
if (!c) return;
output(c - 1, p1[c][s1][s2], p2[c][s1][s2]);
printf("%d %d\n", s1 - p1[c][s1][s2], s2 - p2[c][s1][s2]);
}
int main() {
scanf("%d%d", &n, &r);
int cc = 0;
for (int i = -r; i <= r; ++i)
for (int j = -r; j <= r; ++j)
if (ok(i, j)) po[cc++] = Point(i, j);
memset(dp, -0x3f, sizeof(dp));
dp[0][V][V] = 0;
Q.push(Node(0, V, V));
Node u;
while (!Q.empty()) {
u = Q.front();
Q.pop();
if (u.c == n) continue;
inq[u.c][u.s1][u.s2] = 0;
for (int i = 0; i < cc; ++i) {
int sum1 = u.s1 + po[i].x, sum2 = u.s2 + po[i].y;
int val = dp[u.c][u.s1][u.s2] + n * (sqr(po[i].x) + sqr(po[i].y));
if (val > dp[u.c + 1][sum1][sum2]) {
dp[u.c + 1][sum1][sum2] = val;
p1[u.c + 1][sum1][sum2] = u.s1;
p2[u.c + 1][sum1][sum2] = u.s2;
if (!inq[u.c + 1][sum1][sum2]) {
inq[u.c + 1][sum1][sum2] = 1;
Q.push(Node(u.c + 1, sum1, sum2));
}
}
}
}
int ans = -0x3f3f3f3f, l, r;
for (int i = 0; i <= 500; ++i)
for (int j = 0; j <= 500; ++j) {
if (dp[n][i][j] < 0) continue;
int val = dp[n][i][j] - sqr(i - V) - sqr(j - V);
if (val > ans) {
ans = val;
l = i;
r = j;
}
}
printf("%d\n", ans);
output(n, l, r);
return 0;
}
| 9 |
#include <bits/stdc++.h>
const int maxn = 5000100;
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
char c;
while (!isdigit(c = getchar()))
;
do x = x * 10 + c - 48;
while (isdigit(c = getchar()));
}
int64_t q, n, a[maxn], b[maxn], f[maxn][4], res;
int main() {
read(q);
for (int iTest = 1; iTest <= q; iTest++) {
read(n);
res = LLONG_MAX;
for (int i = 1; i <= n; i++) {
read(a[i]);
read(b[i]);
}
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 2; j++) f[i][j] = LLONG_MAX;
for (int i = 0; i <= 2; i++) f[1][i] = b[1] * i;
for (int i = 2; i <= n; i++) {
for (int j = 0; j <= 2; j++) {
for (int k = 0; k <= 2; k++) {
if (f[i - 1][k] == LLONG_MAX) continue;
if (a[i] + j == a[i - 1] + k) continue;
f[i][j] = min(f[i][j], f[i - 1][k] + b[i] * j);
}
}
}
for (int i = 0; i <= 2; i++) res = min(res, f[n][i]);
cout << res << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
vector<vector<long long>> kmp(string s) {
long long n = s.size();
vector<long long> kmp(n);
vector<vector<long long>> nxt(n, vector<long long>(26));
for (long long i = 1; i < n; i++) {
long long j = kmp[i - 1];
while (j and s[j] != s[i]) j = kmp[j - 1];
if (s[j] == s[i]) j++;
kmp[i] = j;
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < 26; j++) {
long long k = i;
while (k > 0 and s[k] != 'A' + j) k = kmp[k - 1];
if (s[k] == 'A' + j) k++;
nxt[i][j] = k;
}
}
return nxt;
}
string s, t, v;
long long dp[102][102][102];
pair<pair<long long, long long>, long long> ptr[101][101][101];
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cin >> s >> t >> v;
auto nxt = kmp(v);
for (long long i = 0; i < 100; i++)
for (long long j = 0; j < 100; j++)
for (long long k = 0; k < 100; k++) dp[i][j][k] = -1000000000000000;
dp[0][0][0] = 0;
for (long long i = 0; i < (long long)s.size(); i++) {
for (long long j = 0; j < (long long)t.size(); j++) {
for (long long k = 0; k < (long long)v.size(); k++) {
if (s[i] == t[j]) {
if (dp[i + 1][j + 1][nxt[k][s[i] - 'A']] < dp[i][j][k] + 1) {
ptr[i + 1][j + 1][nxt[k][s[i] - 'A']] = {{i, j}, k};
}
dp[i + 1][j + 1][nxt[k][s[i] - 'A']] =
max(dp[i + 1][j + 1][nxt[k][s[i] - 'A']], dp[i][j][k] + 1);
}
if (dp[i + 1][j][k] < dp[i][j][k]) {
ptr[i + 1][j][k] = {{i, j}, k};
}
if (dp[i][j + 1][k] < dp[i][j][k]) {
ptr[i][j + 1][k] = {{i, j}, k};
}
dp[i + 1][j][k] = max(dp[i + 1][j][k], dp[i][j][k]);
dp[i][j + 1][k] = max(dp[i][j + 1][k], dp[i][j][k]);
}
}
}
long long maxlen = 0, x, y, z;
for (long long i = 1; i <= (long long)s.size(); i++)
for (long long j = 1; j <= (long long)t.size(); j++)
for (long long k = 0; k < (long long)v.size(); k++) {
if (maxlen < dp[i][j][k]) {
maxlen = dp[i][j][k];
x = i, y = j, z = k;
}
}
if (maxlen == 0) return cout << "0\n", 0;
string ans = "";
while (x and y) {
if (ptr[x][y][z].first.first == x - 1 and
ptr[x][y][z].first.second == y - 1) {
z = ptr[x][y][z].second;
x = x - 1, y = y - 1;
assert(s[x] == t[y]);
ans += s[x];
} else {
long long a = ptr[x][y][z].first.first, b = ptr[x][y][z].first.second,
c = ptr[x][y][z].second;
x = a, y = b, z = c;
}
}
reverse(ans.begin(), ans.end());
assert(ans.size() == maxlen);
cout << ans << '\n';
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e18;
int main(){
cin.tie(NULL);
ios_base::sync_with_stdio(false);
int t; cin >> t;
while(t--){
long long a, b, c, p; cin >> p >> a >> b >> c;
long long ans = inf;
ans = min((a - p % (a))%a, min( (b-p % (b))%b, (c-p % (c))%c));
cout << ans << "\n";
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t, a, b, c, d, i, j, k, l, n, m, x, y, z;
cin >> a >> b;
c = (b - a) + 1;
x = c / 2;
i = a;
j = i + 1;
cout << "YES" << endl;
while (x--) {
cout << i << " " << j << endl;
i += 2;
j += 2;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200000 + 10;
int a[maxn];
int b[maxn];
int c[maxn];
int s[maxn];
int Q[maxn * 3];
int n;
int sum(int x) {
int res = 0;
while (x) {
res += s[x];
x -= (x & -x);
}
return res;
}
void add(int x) {
while (x <= n) {
s[x] += 1;
x += (x & -x);
}
}
void Build(int w, int l, int r) {
if (l == r) {
Q[w] = 1;
return;
}
int mid = (l + r) >> 1;
Build(w << 1, l, mid);
Build((w << 1) ^ 1, mid + 1, r);
Q[w] = Q[w << 1] + Q[(w << 1) ^ 1];
}
int sea(int w, int l, int r, int k) {
if (l == r) {
Q[w] = 0;
return l;
}
int mid = (l + r) >> 1, x;
if (k <= Q[w << 1])
x = sea(w << 1, l, mid, k);
else
x = sea((w << 1) ^ 1, mid + 1, r, k - Q[w << 1]);
Q[w] = Q[w << 1] + Q[(w << 1) ^ 1];
return x;
}
int main() {
scanf("%d", &n);
for (int i = 0; i <= n; i++) s[i] = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
a[i] = x - sum(x + 1);
add(x + 1);
}
for (int i = 0; i <= n; i++) s[i] = 0;
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
b[i] = x - sum(x + 1);
add(x + 1);
}
int carry = 0;
for (int i = n - 1; i >= 0; i--) {
int top = n - i;
c[i] = a[i] + b[i] + carry;
carry = 0;
if (c[i] >= top) {
c[i] -= top;
carry = 1;
}
}
Build(1, 1, n);
for (int i = 0; i < n - 1; i++) {
int x = sea(1, 1, n, c[i] + 1);
printf("%d ", x - 1);
}
int x = sea(1, 1, n, c[n - 1] + 1);
printf("%d\n", x - 1);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> point[1010];
int vis[1010];
int main() {
int n, m, flag = 1;
cin >> n >> m;
memset(vis, 0, sizeof(vis));
for (int i = 1; i <= n; i++) point[i].clear();
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
point[a].push_back(b);
point[b].push_back(a);
}
if (m != n - 1)
flag = 0;
else {
queue<int> q;
q.push(1);
while (!q.empty()) {
int t = q.front();
vis[t] = 1;
q.pop();
while (!point[t].empty()) {
int k = point[t].back();
if (!vis[k]) q.push(k);
point[t].pop_back();
}
}
for (int i = 1; i <= n; i++) {
if (!vis[i]) flag = 0;
}
}
if (!flag)
printf("no\n");
else
printf("yes\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:134217728")
const int MOD = 1000000007;
const int INF = 1000000001;
const int MAXN = 17;
const double EPS = 1e-6;
const int HASH_POW = 31;
const double PI = acos(-1.0);
using namespace std;
void my_return(int code) { exit(code); }
int n, m;
char p[1010][1010];
const int foo = 1010;
char u[1010][1010];
int d[3][1010][1010];
deque<int> Q;
void bfs(char start) {
memset(u, 0, sizeof u);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (p[i][j] == start) {
u[i][j] = 1;
d[start - '1'][i][j] = 0;
Q.push_back(foo * i + j);
} else
d[start - '1'][i][j] = INF;
}
}
while (!Q.empty()) {
int v = Q.front();
Q.pop_front();
int x = v / foo, y = v % foo;
if (x > 1 && p[x - 1][y] != '#' && !u[x - 1][y]) {
u[x - 1][y] = 1;
if (p[x - 1][y] != '.') {
d[start - '1'][x - 1][y] = d[start - '1'][x][y];
Q.push_front(foo * (x - 1) + y);
} else {
d[start - '1'][x - 1][y] = d[start - '1'][x][y] + 1;
Q.push_back(foo * (x - 1) + y);
}
}
if (x < n && p[x + 1][y] != '#' && !u[x + 1][y]) {
u[x + 1][y] = 1;
if (p[x + 1][y] != '.') {
d[start - '1'][x + 1][y] = d[start - '1'][x][y];
Q.push_front(foo * (x + 1) + y);
} else {
d[start - '1'][x + 1][y] = d[start - '1'][x][y] + 1;
Q.push_back(foo * (x + 1) + y);
}
}
if (y > 1 && p[x][y - 1] != '#' && !u[x][y - 1]) {
u[x][y - 1] = 1;
if (p[x][y - 1] != '.') {
d[start - '1'][x][y - 1] = d[start - '1'][x][y];
Q.push_front(foo * x + y - 1);
} else {
d[start - '1'][x][y - 1] = d[start - '1'][x][y] + 1;
Q.push_back(foo * x + y - 1);
}
}
if (y < m && p[x][y + 1] != '#' && !u[x][y + 1]) {
u[x][y + 1] = 1;
if (p[x][y + 1] != '.') {
d[start - '1'][x][y + 1] = d[start - '1'][x][y];
Q.push_front(foo * x + y + 1);
} else {
d[start - '1'][x][y + 1] = d[start - '1'][x][y] + 1;
Q.push_back(foo * x + y + 1);
}
}
}
}
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
mt19937 mt_rand(time(NULL));
scanf("%d %d\n", &n, &m);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) p[i][j] = getchar();
getchar();
}
int d12 = INF, d13 = INF, d23 = INF;
bfs('1');
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (p[i][j] == '2') d12 = min(d12, d[0][i][j]);
if (p[i][j] == '3') d13 = min(d13, d[0][i][j]);
}
}
bfs('2');
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (p[i][j] == '1') d12 = min(d12, d[1][i][j]);
if (p[i][j] == '3') d23 = min(d23, d[1][i][j]);
}
}
bfs('3');
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (p[i][j] == '1') d13 = min(d13, d[2][i][j]);
if (p[i][j] == '2') d23 = min(d23, d[2][i][j]);
}
}
int ans = INF;
ans = min(ans, d12 + d13);
ans = min(ans, d12 + d23);
ans = min(ans, d13 + d23);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
if (p[i][j] == '.' && d[0][i][j] != INF && d[1][i][j] != INF &&
d[2][i][j] != INF)
ans = min(ans, d[0][i][j] + d[1][i][j] + d[2][i][j] - 2);
}
}
if (ans == INF)
printf("-1\n");
else
printf("%d\n", ans);
my_return(0);
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> g[100005];
vector<vector<int>> comps;
vector<int> counts;
bool visited[100005];
void dfs(int curr, bool first) {
visited[curr] = true;
if (first) {
comps.push_back(vector<int>());
counts.push_back(0);
}
comps[comps.size() - 1].push_back(curr);
for (auto u : g[curr]) {
counts[counts.size() - 1]++;
if (!visited[u]) dfs(u, false);
}
}
int main() {
int a, b;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
for (int i = 1; i < n; ++i) {
if (!visited[i]) dfs(i, true);
}
int c = 0;
for (int i = 0; i < comps.size(); ++i) {
if (counts[i] / 2 == comps[i].size() - 1)
c += counts[i] / 2;
else
c += comps[i].size();
}
cout << n - c << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
double l, d, v, g, r;
cin >> l >> d >> v >> g >> r;
double tm = d / v;
while (tm > (g + r)) {
tm -= (g + r);
}
if (tm < g)
tm = l / v;
else
tm = (d / v) + ((g + r) - tm) + ((l - d) / v);
printf("%.6f\n", tm);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = ~(1 << 31);
const double pi = acos(-1);
int main() {
cin.sync_with_stdio(false);
int n, k;
cin >> n >> k;
int mn = 0, mx = 0;
if (n > k && k >= 1) mn = 1;
int threetimes = n / 3;
int left = n % 3;
if (threetimes >= k) {
mx = k * 2;
} else {
mx = threetimes * 2;
k -= threetimes;
if (left == 1) {
k -= 1;
} else if (left == 2) {
mx += 1;
k -= 1;
}
mx -= k;
}
cout << mn << " " << mx << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m, k, a[110][110], ans = 1e9;
int main() {
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) scanf("%d", &a[i][j]);
if (k < m) {
for (int p = 1; p <= m; ++p) {
int cnt = 0;
for (int j = 1; j <= m; ++j)
if (p != j) {
int tmp = 0;
for (int i = 1; i <= n; ++i) tmp += (a[i][j] ^ a[i][p]);
cnt += min(tmp, n - tmp);
}
ans = min(ans, cnt);
}
} else {
for (int s = 0; s < (1 << m); ++s) {
int cnt = 0;
for (int i = 1; i <= n; ++i) {
int tmp = 0;
for (int j = 1; j <= m; ++j) tmp += ((s >> (j - 1)) & 1) ^ a[i][j];
cnt += min(tmp, m - tmp);
}
ans = min(ans, cnt);
}
}
if (ans > k)
cout << -1;
else
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long int max(long long int a, long long int b) {
if (a > b)
return a;
else
return b;
}
long long int min(long long int a, long long int b) {
if (a < b)
return a;
else
return b;
}
const int dx[4] = {-1, 1, 0, 0};
const int dy[4] = {0, 0, -1, 1};
int XX[] = {-1, -1, -1, 0, 0, 1, 1, 1};
int YY[] = {-1, 0, 1, -1, 1, -1, 0, 1};
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
long long int m, t, r, i, j, x, l, y, w, h, n, a, b, k, sum, limit;
cin >> n;
string str;
cin >> str;
if (n == 1) {
cout << "0";
return 0;
}
long long int flag = 0;
long long int c1 = 0, c2 = 0;
for (i = 0; i < str.length(); i++) {
long long int num = str[i] - '0';
if (num != flag) c1++;
flag = 1 - flag;
}
flag = 1;
for (i = 0; i < str.length(); i++) {
long long int num = str[i] - '0';
if (num != flag) c2++;
flag = 1 - flag;
}
cout << min(c1, c2);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int makeUnique(int *arr, int n) {
int cnt = 0, u, v;
for (int i = 0; i < n - 1; i++)
if (arr[i] == arr[i + 1]) {
cnt++;
if (arr[i] == 0 || cnt > 1) return 2;
if (i == 0 || arr[i - 1] + 1 != arr[i])
arr[i]--;
else
return 2;
}
return cnt;
}
bool solve(int *arr, int n) {
int diff = 0;
for (int i = 0; i < n; i++) diff += arr[i] - i;
return diff % 2;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int n;
cin >> n;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
sort(arr, arr + n);
int x = makeUnique(arr, n);
if (x != 2 && x ^ solve(arr, n))
cout << "sjfnb" << endl;
else
cout << "cslnb" << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int t;
int n, l;
int a[100005];
int main() {
scanf("%d", &t);
while (t--) {
scanf("%d%d", &n, &l);
a[0] = 0;
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
a[n + 1] = l;
double lb = 0, rb = l;
for (int i = 1; i <= 50; i++) {
double mid = (lb + rb) / 2;
double ldist = 0, rdist = l;
double tme = mid;
for (int j = 1; j <= n + 1; j++) {
if ((a[j] - ldist) / (double)j <= tme) {
tme -= (a[j] - ldist) / (double)j;
ldist = a[j];
} else {
ldist += j * tme;
tme = 0;
break;
}
}
tme = mid;
for (int j = n; j >= 0; j--) {
if ((rdist - a[j]) / (double)(n - j + 1) <= tme) {
tme -= (rdist - a[j]) / (double)(n - j + 1);
rdist = a[j];
} else {
rdist -= (n - j + 1) * tme;
tme = 0;
break;
}
}
if (ldist <= rdist) {
lb = mid;
} else {
rb = mid;
}
}
printf("%.7f\n", lb);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int64_t t;
cin >> t;
while (t--) {
map<char, int64_t> m;
string s;
cin >> s;
for (int64_t i = 0; i < s.size(); i++) m[s[i]]++;
int64_t a = min(m['L'], m['R']), b = min(m['U'], m['D']);
if ((a == 0 && b != 0) || (a != 0 && b == 0)) {
if (a == 0)
cout << "2\nUD";
else
cout << "2\nLR";
goto SKIP;
}
cout << a * 2 + b * 2 << '\n';
for (int64_t i = 0; i < a; i++) cout << "L";
for (int64_t i = 0; i < b; i++) cout << "U";
for (int64_t i = 0; i < a; i++) cout << "R";
for (int64_t i = 0; i < b; i++) cout << "D";
SKIP:;
cout << '\n';
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MAXN = 1e3 + 100;
int N, M, Q, a[MAXN][MAXN];
long long D[MAXN][MAXN];
void read() {
cin >> N >> M >> Q;
for (int i = 0; i < N; i++) {
string s;
cin >> s;
for (int j = 0; j < M; j++) {
a[i][j] = s[j] - '0';
}
}
}
int get(int x, int y, long long t) {
if (t < D[x][y]) return a[x][y];
return (((t - D[x][y]) % 2) ^ a[x][y]);
}
bool valid(int x, int y) {
if (x >= 0 && x < N && y >= 0 && y < M)
return true;
else
return false;
}
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
bool diff(int x, int y) {
for (int i = 0; i < 4; i++) {
int x2 = x + dx[i], y2 = y + dy[i];
if (valid(x2, y2) && a[x2][y2] == a[x][y]) {
return true;
}
}
return false;
}
struct pqueue {
long long dist;
int x, y;
bool operator<(const pqueue &other) const { return dist > other.dist; };
};
void bfs() {
priority_queue<pqueue> q;
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
D[i][j] = LLONG_MAX;
if (diff(i, j)) {
D[i][j] = 0;
q.push({D[i][j], i, j});
}
}
}
while (!q.empty()) {
int x = q.top().x;
int y = q.top().y;
q.pop();
for (int i = 0; i < 4; i++) {
int x2 = x + dx[i], y2 = y + dy[i];
if (valid(x2, y2) && get(x, y, D[x][y]) == a[x][y] &&
D[x2][y2] > D[x][y] + 1) {
D[x2][y2] = D[x][y] + 1;
q.push({D[x2][y2], x2, y2});
}
if (valid(x2, y2) && get(x, y, D[x][y] + 1) == a[x][y] &&
D[x2][y2] > D[x][y] + 2) {
D[x2][y2] = D[x][y] + 2;
q.push({D[x2][y2], x2, y2});
}
}
}
}
void solve() {
read();
bfs();
while (Q--) {
int x, y;
long long t;
cin >> x >> y >> t;
x--, y--;
cout << get(x, y, t) << "\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
solve();
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int x[10010], y[10010];
int main() {
int n, w, u, v;
scanf("%d%d%d%d", &n, &w, &v, &u);
bool flag = 1, p = 0, q = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d", &x[i], &y[i]);
if (x[i] < 0) p = 1;
if (x[i] > 0) q = 1;
}
if (p && q) flag = 0;
if (!p && q) {
for (int i = 0; i < n; i++)
if (1ll * x[i] * u < 1ll * y[i] * v) flag = 0;
}
double ans = 1.0 * w / u;
if (flag)
printf("%.8f\n", ans);
else {
for (int i = 0; i < n; i++)
ans = max(ans, 1.0 * (w - y[i]) / u + 1.0 * x[i] / v);
printf("%.8f\n", ans);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
const long long P = 1e9 + 7, INF = 2e9;
int n, m;
string s;
pair<int, int> t[N];
double f(double x) {
double maxl = 0;
for (int i = 1; i <= n; i++) {
maxl = max(maxl, fabs((double)t[i].first - x) / (double)t[i].second);
}
return maxl;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> t[i].first;
}
for (int i = 1; i <= n; i++) {
cin >> t[i].second;
}
double l = 1, r = 1e9;
for (int i = 1; i <= 100; i++) {
double m1 = l + ((r - l) / 3);
double m2 = r - ((r - l) / 3);
if (f(m1) > f(m2)) {
l = m1;
} else {
r = m2;
}
}
printf("%.10f", f(l));
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m, bsize;
int fa[100005], a[100005], fir[325][100005], cnt[100005], v[100005], tag[325],
mx[325], belong[100005];
int l[325], r[325];
int Read() {
int tmp = 0, flag = 1;
char c;
for (c = getchar(); !isdigit(c); c = getchar())
if (c == '-') flag = -flag;
for (; isdigit(c); c = getchar()) tmp = (tmp << 3) + (tmp << 1) + c - '0';
return tmp * flag;
}
int f(int rt) { return fa[rt] == rt ? rt : fa[rt] = f(fa[rt]); }
void update(int rt) {
while (!~fir[rt][mx[rt]]) --mx[rt];
return;
}
void build(int rt) {
for (int i = l[rt]; i <= r[rt]; i++) {
a[i] = v[f(i)];
fir[rt][a[i]] = -1;
}
for (int i = l[rt]; i <= r[rt]; i++) {
cnt[i] = 1;
fa[i] = i;
}
for (int i = l[rt]; i <= r[rt]; i++) {
if (~fir[rt][a[i]]) {
cnt[fir[rt][a[i]]] += cnt[i];
fa[i] = fir[rt][a[i]];
} else {
fir[rt][a[i]] = i;
v[i] = a[i];
}
}
return;
}
void chg(int rt, int ll, int rr, int x) {
for (int i = l[rt]; i <= r[rt]; i++) {
a[i] = v[f(i)];
}
for (int i = l[rt]; i <= r[rt]; i++) {
fir[rt][a[i]] = -1;
}
for (int i = ll; i <= rr; i++) {
if (a[i] - tag[rt] > x) a[i] -= x;
}
for (int i = l[rt]; i <= r[rt]; i++) {
v[i] = a[i];
fa[i] = i;
}
build(rt);
return;
}
void modify(int ll, int rr, int x) {
if (belong[ll] == belong[rr]) {
chg(belong[ll], ll, rr, x);
return;
}
chg(belong[ll], ll, r[belong[ll]], x);
chg(belong[rr], l[belong[rr]], rr, x);
for (int i = belong[ll] + 1; i < belong[rr]; i++) {
if (2 * x <= mx[i] - tag[i]) {
for (int j = tag[i] + 1; j <= x + tag[i]; j++) {
if (~fir[i][j]) {
if (~fir[i][j + x]) {
cnt[fir[i][j + x]] += cnt[fir[i][j]];
fa[fir[i][j]] = fir[i][j + x];
fir[i][j] = -1;
} else {
fir[i][j + x] = fir[i][j];
v[fir[i][j]] = x + j;
fir[i][j] = -1;
}
}
}
tag[i] += x;
} else {
for (int j = x + tag[i] + 1; j <= mx[i]; j++) {
if (~fir[i][j]) {
if (~fir[i][j - x]) {
cnt[fir[i][j - x]] += cnt[fir[i][j]];
fa[fir[i][j]] = fir[i][j - x];
fir[i][j] = -1;
} else {
fir[i][j - x] = fir[i][j];
v[fir[i][j]] = j - x;
fir[i][j] = -1;
}
}
}
update(i);
}
}
return;
}
int query(int ll, int rr, int x) {
int ans = 0;
if (belong[ll] == belong[rr]) {
for (int i = ll; i <= rr; i++) {
if (v[f(i)] - tag[belong[ll]] == x) {
ans++;
}
}
return ans;
}
for (int i = ll; i <= r[belong[ll]]; i++) {
if (v[f(i)] - tag[belong[ll]] == x) {
ans++;
}
}
for (int i = l[belong[rr]]; i <= rr; i++) {
if (v[f(i)] - tag[belong[rr]] == x) {
ans++;
}
}
for (int i = belong[ll] + 1; i < belong[rr]; i++) {
if (x + tag[i] <= 100000 && ~fir[i][x + tag[i]]) {
ans += cnt[fir[i][x + tag[i]]];
}
}
return ans;
}
int main() {
memset(fir, -1, sizeof(fir));
n = Read();
m = Read();
bsize = sqrt(n);
for (int i = 1; i <= n; i++) {
v[i] = a[i] = Read();
fa[i] = i;
belong[i] = (i - 1) / bsize + 1;
mx[belong[i]] = max(mx[belong[i]], a[i]);
}
for (int i = 1; i <= belong[n]; i++) {
l[i] = (i - 1) * bsize + 1;
r[i] = min(i * bsize, n);
build(i);
}
for (int i = 1; i <= m; i++) {
int op, ll, rr, x;
op = Read();
ll = Read();
rr = Read();
x = Read();
if (op == 1) {
modify(ll, rr, x);
} else {
printf("%d\n", query(ll, rr, x));
}
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
int len;
char str[1000010];
bool testBlock(int pos) {
int now = 0;
int left = 0;
bool isNewLeft = true;
for (int i = 0; str[i]; i++) {
if (str[i] == 'R') {
isNewLeft = false;
if (now + 1 == pos)
;
else
now++;
} else
now--;
if (now < left) {
left = now;
isNewLeft = true;
}
}
return isNewLeft;
}
int main() {
while (scanf("%s", str) != EOF) {
len = strlen(str);
if (str[len - 1] == 'R') {
for (int i = 0; str[i]; i++) {
if (str[i] == 'R')
str[i] = 'L';
else
str[i] = 'R';
}
}
if (testBlock(len + 5)) {
puts("1");
continue;
}
int l = 0;
int r = len + 5;
while (l < r) {
int mid = (l + r + 1) / 2;
if (testBlock(mid))
l = mid;
else
r = mid - 1;
}
printf("%d\n", l);
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, odc, evc;
cin >> n >> k;
if (n % 2 == 0) {
odc = evc = n / 2;
} else {
odc = n / 2 + 1;
evc = n / 2;
}
if (k <= odc) {
cout << 1 + (k - 1) * 2 << endl;
} else {
cout << 2 + (k - 1 - odc) * 2 << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
long long r = INT_MAX;
for (int i = 1; i <= sqrt(n); i++) {
long long value;
value = (i - 1) + (n - i) / i;
if ((n - i) % i != 0) value++;
if (r > value) r = value;
}
cout << r << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main(void) {
int i = 0, a = 0, b = 0, c = 0;
int save[3];
while (cin >> a >> b >> c) {
save[0] = a;
save[1] = b;
if (c == 1)
cout << save[1] << endl;
else {
for (i = 2; i <= c; i++) {
save[2] = save[1] + save[0];
save[0] = save[1];
save[1] = save[2];
}
cout << save[2] << endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
int n, m, t[100005];
std::vector<int> e[100005], ans;
bool v[100005];
void dfs(int x, int y) {
v[x] = true;
t[x] = t[y] ^ 3;
for (int i = 0; i < e[x].size(); i++)
if (!v[e[x][i]]) dfs(e[x][i], x);
}
bool impossible() {
for (int i = 1; i <= n; i++)
for (int j = 0; j < e[i].size(); j++)
if (t[i] == t[e[i][j]]) return true;
return false;
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d %d", &u, &v);
e[u].push_back(v);
e[v].push_back(u);
}
t[0] = 1;
v[0] = true;
for (int i = 1; i <= n; i++)
if (!v[i]) dfs(i, 0);
if (impossible())
printf("-1\n");
else {
ans.clear();
for (int i = 1; i <= n; i++)
if (t[i] == 1) ans.push_back(i);
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf("%d%c", ans[i], i == ans.size() - 1 ? '\n' : ' ');
ans.clear();
for (int i = 1; i <= n; i++)
if (t[i] == 2) ans.push_back(i);
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf("%d%c", ans[i], i == ans.size() - 1 ? '\n' : ' ');
}
scanf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
bool polin(string s) {
int len = s.size();
int i, j, many = 0;
for (i = 0, j = len - 1; (i < (len / 2)); i++, j--) {
if (s[i] != s[j]) {
many++;
}
}
if (many == 1) return true;
if (many == 0) {
if (len & 1) return true;
return false;
}
return false;
}
int main() {
string s;
cin >> s;
if (polin(s) == true)
puts("YES");
else
puts("NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int N = 1010;
const int mod = 998244353;
int dp[N][N][2];
string x, y;
void add(int& a, int b){
a += b;
if(a >= mod)
a -= mod;
}
int main(){
ios_base::sync_with_stdio(0);
cin.tie(0); cout.tie(0);
cin >> x >> y;
int n = x.size(), m = y.size();
for(int i = 0; i < n; i ++){
for(int j = i; j < n; j ++){
if(j > i && x[j] == x[j - 1])
break;
for(int k = 0; k < m; k ++){
if(x[j] != y[k])
dp[j][k][1] = max(dp[j][k][1], (j - i + 1));
}
}
}
for(int i = 0; i < m; i ++){
for(int j = i; j < m; j ++){
if(j > i && y[j] == y[j - 1])
break;
for(int k = 0; k < n; k ++){
if(y[j] != x[k])
dp[k][j][0] = max(dp[k][j][0], (j - i + 1));
}
}
}
// for(int i = 0; i < n; i ++)
// for(int j = 0; j < m; j ++)
// if(x[i] != y[j])
// dp[i][j][0] = dp[i][j][1] = 1;
for(int i = 0; i < n; i ++){
for(int j = 0; j < m; j ++){
if(i + 1 < n){
if(x[i + 1] != x[i])
add(dp[i + 1][j][0], dp[i][j][0]);
if(x[i + 1] != y[j])
add(dp[i + 1][j][0], dp[i][j][1]);
}
if(j + 1 < m){
if(y[j + 1] != y[j])
add(dp[i][j + 1][1], dp[i][j][1]);
if(y[j + 1] != x[i])
add(dp[i][j + 1][1], dp[i][j][0]);
}
}
}
int ans = 0;
for(int i = 0; i < n; i ++)
for(int j = 0; j < m; j ++)
for(int k = 0; k < 2; k ++)
add(ans, dp[i][j][k]);
cout << ans;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
map<int, int> cnt;
long long ans = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
vector<int> t(26);
for (int j = 0; j < s.length(); j++) {
t[s[j] - 'a']++;
}
int mask = 0;
for (int j = 0; j < 26; j++) {
if (t[j] % 2) {
mask += (1u << j);
}
}
ans += cnt[mask];
for (int j = 0; j < 26; j++) {
mask ^= (1u << j);
ans += cnt[mask];
mask ^= (1u << j);
}
cnt[mask]++;
}
cout << ans << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string a, b, s;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s;
if (s != "0") {
a += s;
a += '-';
}
}
a = a + a;
for (int i = 0; i < n; i++) {
cin >> s;
if (s != "0") {
b += s;
b += '-';
}
}
if (a.find(b) != std::string::npos) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 2 |
#include <bits/stdc++.h>
const double eps = 1e-7, PI = 3.1415926;
const int N = 5e5, M = 998244353;
using namespace std;
long long n, m, k = 1, x, y, a[N], mx = -1, mn = 1e9, sum;
char c[N];
string s;
map<int, bool> mp;
vector<int> vec;
int main() {
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &a[i]);
k = 1;
while (a[i]) {
sum += (n * (a[i] % 10) * (k % M)) % M;
k *= 10;
k %= M;
sum += (n * (a[i] % 10) * (k % M)) % M;
k *= 10;
k %= M;
a[i] /= 10;
}
}
cout << sum % M;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
int const N = 1 << 11;
int const M = 1e9 + 7;
bool has[N];
int p[N], f[N][N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", p + i);
if (p[i] != -1) has[p[i]] = true;
}
int n1 = 0, n2 = 0;
for (int i = 1; i <= n; ++i)
if (!has[i]) {
if (p[i] != -1)
++n1;
else
++n2;
}
f[0][0] = 1;
for (int i = 0; i <= n1; ++i)
for (int j = 0; j <= n2; ++j) {
if (i) {
f[i][j] = (f[i][j] + (ll)f[i - 1][j] * i) % M;
if (j) f[i][j] = (f[i][j] + (ll)f[i][j - 1] * j) % M;
} else {
if (j > 0) f[i][j] = (f[i][j] + (j - 1ll) * f[i][j - 1]) % M;
if (j > 1) f[i][j] = (f[i][j] + (j - 1ll) * f[i][j - 2]) % M;
}
}
printf("%d\n", f[n1][n2]);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int main() {
int n;
scanf("%d", &n);
a.resize(n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
sort(a.begin(), a.end());
int mex = 1;
for (int i = 0; i < n; ++i)
if (a[i] >= mex) ++mex;
printf("%d", mex);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool isPalindrome(string s) {
int i = 0;
int j = s.size() - 1;
while (i <= j) {
if (s[i] != s[j]) {
return false;
}
i++;
j--;
}
return true;
}
string helper(string &s) {
string ans;
for (int i = s.size() - 1; ~i; i--) {
if (isPalindrome(string(s.begin(), s.begin() + i + 1))) {
if (i - 0 + 1 > ans.size()) {
ans = string(s.begin(), s.begin() + i + 1);
}
}
}
return ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
string s;
cin >> s;
if (s.size() == 1) {
cout << s << endl;
continue;
}
string ans;
long long int i = 0;
long long int j = (int)s.size() - 1;
while (s[i] == s[j] && (i < j)) {
ans += s[i];
i++;
j--;
}
string addi;
if (i == j) {
addi = s[i];
}
string newString;
if (i < j) {
newString = string(s.begin() + i, s.begin() + j + 1);
}
string ans1 = helper(newString);
reverse(newString.begin(), newString.end());
string ans2 = helper(newString);
string x = ans;
reverse(x.begin(), x.end());
ans = ans + (ans1.size() > ans2.size() ? ans1 : ans2) + addi + x;
cout << ans << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[200007];
long long dist[200007];
vector<pair<long long, long long> > graph[200007];
priority_queue<pair<long long, long long>, vector<pair<long long, long long> >,
greater<pair<long long, long long> > >
q;
void dijkstra(int nodes) {
while (!q.empty()) {
long long from = q.top().second;
long long ccost = q.top().first;
q.pop();
if (dist[from] < ccost) {
continue;
}
for (auto i : graph[from]) {
long long to = i.first;
long long cost = i.second;
if (dist[from] + 2 * cost < dist[to]) {
dist[to] = dist[from] + 2 * cost;
q.push(make_pair(dist[to], to));
}
}
}
}
int main() {
int nodes, edges;
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> nodes >> edges;
long long u, v, w;
for (int i = 1; i <= edges; i++) {
cin >> u >> v >> w;
graph[u].push_back(make_pair(v, w));
graph[v].push_back(make_pair(u, w));
}
for (int i = 1; i <= nodes; i++) {
cin >> dist[i];
q.push(make_pair(dist[i], i));
}
dijkstra(nodes);
for (int i = 1; i <= nodes; i++) {
cout << dist[i] << " ";
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, flag = 1;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if ((i % 2) != 0) {
cout << '#';
if (j == 1) flag++;
} else {
if (j == m && (flag % 2 == 0)) {
{ cout << '#'; }
} else if (j == 1 && (flag % 2 != 0)) {
{ cout << '#'; }
} else {
cout << '.';
}
}
}
cout << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const double EPS = 1e-7;
const double PI = acos(-1.0);
const long long MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LL_INF = 0x3f3f3f3f3f3f3f3f;
int n;
int num1[1005], num2[1005];
int ans[1005];
int judge(int x, int y) {
if (ans[x] == num1[x] && ans[x] != num2[x] && ans[y] == num2[y] &&
ans[y] != num1[y])
return 1;
if (ans[x] == num2[x] && ans[x] != num1[x] && ans[y] == num1[y] &&
ans[y] != num2[y])
return 1;
return 0;
}
int main() {
while (scanf("%d", &n) != EOF) {
for (int i = 1; i <= n; i++) scanf("%d", &num1[i]);
for (int i = 1; i <= n; i++) scanf("%d", &num2[i]);
int dif = 0;
int pos1 = 0, pos2 = 0;
for (int i = 1; i <= n; i++) {
if (num1[i] != num2[i]) {
dif++;
if (pos1 == 0)
pos1 = i;
else
pos2 = i;
}
}
if (dif == 1) {
int used[1005];
memset(used, 0, sizeof(used));
for (int i = 1; i <= n; i++) {
if (i != pos1) {
ans[i] = num1[i];
used[num1[i]]++;
}
}
for (int i = 1; i <= n; i++) {
if (!used[i]) {
ans[pos1] = i;
break;
}
}
} else {
int used[1005];
memset(used, 0, sizeof(used));
for (int i = 1; i <= n; i++) {
if ((i != pos1) && (i != pos2)) {
ans[i] = num1[i];
used[num1[i]]++;
}
}
int temp1 = 0, temp2 = 0;
for (int i = 1; i <= n; i++) {
if (!used[i]) {
if (temp1 == 0)
temp1 = i;
else
temp2 = i;
}
}
ans[pos1] = temp1;
ans[pos2] = temp2;
if (!judge(pos1, pos2)) {
swap(ans[pos1], ans[pos2]);
}
}
for (int i = 1; i <= n; i++) printf("%d%c", ans[i], i == n ? '\n' : ' ');
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int start_up() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
return 0;
}
long long int static r = start_up();
void solve() {
long long int n;
cin >> n;
vector<long long int> a(n);
for (long long int i = 0; i < n; ++i) {
cin >> a[i];
}
vector<long long int> ans;
ans.push_back(a[0]);
for (long long int i = 1; i < n - 1; ++i) {
if (a[i] > a[i + 1] && a[i] > a[i - 1]) {
ans.push_back(a[i]);
} else if (a[i] < a[i + 1] && a[i] < a[i - 1]) {
ans.push_back(a[i]);
}
}
ans.push_back(a[n - 1]);
cout << ans.size() << endl;
for (long long int i : ans) {
cout << i << " ";
}
cout << endl;
}
signed main() {
long long int t;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, h, a, w = 0;
cin >> n >> h;
for (int i = 0; i < n; i++) {
cin >> a;
if (a <= h) w = w + 1;
if (a > h) w = w + 2;
}
cout << w << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e6 + 10;
int n, fa[MAXN], _maj[MAXN], _min[MAXN], dp[MAXN] = {0, 1};
int main() {
scanf("%d", &n);
for (int i = 2; i <= n + 1; ++i) {
scanf("%d", fa + i);
int x = i, y = fa[x];
dp[x] = 1;
while (y) {
if (dp[x] > _maj[y])
_min[y] = _maj[y], _maj[y] = dp[x];
else if (dp[x] > _min[y])
_min[y] = dp[x];
else
break;
if (dp[y] >= ((_maj[y]) > (_min[y] + 1) ? (_maj[y]) : (_min[y] + 1)))
break;
dp[y] = ((_maj[y]) > (_min[y] + 1) ? (_maj[y]) : (_min[y] + 1));
x = y, y = fa[x];
}
printf("%d\n", _maj[1]);
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 101110;
struct MAT {
int a[2][2];
MAT() { memset(a, 0, sizeof(MAT)); }
MAT(int x, int y, int u, int v) {
a[0][0] = x;
a[0][1] = y;
a[1][0] = u;
a[1][1] = v;
}
int* operator[](int i) { return a[i]; }
bool operator==(MAT x) {
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
if (a[i][j] != x[i][j]) return false;
return true;
}
MAT operator*(MAT x) {
MAT ans(0, 0, 0, 0);
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
ans[i][j] = (int)((ans[i][j] + (long long)a[i][k] * x[k][j]) %
(int)(1e9 + 7));
return ans;
}
MAT operator+(MAT x) {
MAT ans;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) {
ans[i][j] = a[i][j] + x[i][j];
ans[i][j] %= (int)(1e9 + 7);
}
return ans;
}
MAT operator^(int k) {
MAT x = *this;
MAT ans(1, 0, 0, 1);
while (k) {
if (k & 1) ans = ans * x;
x = x * x;
k >>= 1;
}
return ans;
}
};
int A[N], l[4 * N], h[4 * N];
MAT T[4 * N], Sum[4 * N];
int n, m;
void build(int x, int i, int j) {
l[x] = i;
h[x] = j;
T[x] = MAT(1, 0, 0, 1);
if (i == j)
Sum[x] = MAT(1, 1, 1, 0) ^ (A[i] - 1);
else {
int mid = (i + j) / 2;
build(2 * x, i, mid);
build(2 * x + 1, mid + 1, j);
Sum[x] = Sum[2 * x] + Sum[2 * x + 1];
}
}
void UP(int x) {
if (!(T[x] == MAT(1, 0, 0, 1))) {
Sum[x] = Sum[x] * T[x];
if (l[x] != h[x]) {
T[2 * x] = T[2 * x] * T[x];
T[2 * x + 1] = T[2 * x + 1] * T[x];
}
T[x] = MAT(1, 0, 0, 1);
}
}
void update(int x, int i, int j, MAT val) {
UP(x);
if (l[x] > j || h[x] < i) return;
if (l[x] >= i && h[x] <= j) {
T[x] = T[x] * val;
UP(x);
return;
}
update(2 * x, i, j, val);
update(2 * x + 1, i, j, val);
Sum[x] = Sum[2 * x] + Sum[2 * x + 1];
}
MAT cal(int x, int i, int j) {
UP(x);
if (l[x] > j || h[x] < i) return MAT();
if (l[x] >= i && h[x] <= j) return Sum[x];
return cal(2 * x, i, j) + cal(2 * x + 1, i, j);
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%d", &A[i]);
build(1, 1, n);
while (m--) {
int type, x, l, r, val;
scanf("%d", &type);
type++;
if (type == 1) {
scanf("%d%d", &x, &val);
if (val != 0) update(1, x, x, MAT(1, 1, 1, 0) ^ val);
}
if (type == 2) {
scanf("%d%d%d", &l, &r, &val);
if (val != 0) update(1, l, r, MAT(1, 1, 1, 0) ^ val);
}
if (type == 3) {
scanf("%d%d", &l, &r);
printf("%d\n", cal(1, l, r)[0][0]);
}
}
}
| 7 |
#include <bits/stdc++.h>
const int N = 1e6 + 10;
const int mod = 998244353;
using namespace std;
template <class T>
struct Dinic {
static const int N = 10101, M = N * 200;
int s, t, n, h[N], cur[N], lv[N], q[N], e, ne[M], to[M];
T cap[M], flow;
void liu(int u, int v, T w) {
to[e] = v, ne[e] = h[u], cap[e] = w;
h[u] = e++;
}
void link(int u, int v, T w) {
liu(u, v, w);
liu(v, u, 0);
}
void init(int _n = N) {
fill(h, h + (n = _n), -1);
e = 0;
}
bool bfs() {
int L = 0, R = 0;
fill(lv, lv + n, -1);
lv[q[R++] = s] = 0;
while (L < R && !~lv[t]) {
int c = q[L++];
for (int k = h[c]; ~k; k = ne[k]) {
if (cap[k] > 0 && !~lv[to[k]]) lv[q[R++] = to[k]] = lv[c] + 1;
}
}
return ~lv[t];
}
T dfs(int c, T mx) {
if (c == t) return mx;
T ret = 0;
for (int &k = cur[c]; ~k; k = ne[k]) {
if (lv[to[k]] == lv[c] + 1 && cap[k] > 0) {
T flow = dfs(to[k], min(mx, cap[k]));
ret += flow;
cap[k] -= flow;
cap[k ^ 1] += flow;
mx -= flow;
if (!mx) return ret;
}
}
lv[c] = -1;
return ret;
}
T run(int _s, int _t) {
s = _s, t = _t;
flow = 0;
while (bfs()) {
copy(h, h + n, cur);
flow += dfs(s, ~0U >> 1);
}
return flow;
}
};
Dinic<int> G;
int main() {
int n, m;
scanf("%d%d", &n, &m);
vector<int> xa(m), ya(m), xb(m), yb(m), xs = {0, n}, ys = {0, n};
for (int i = 0; i < m; ++i) {
scanf("%d%d%d%d", &xa[i], &ya[i], &xb[i], &yb[i]);
--xa[i], --ya[i];
xs.push_back(xa[i]), xs.push_back(xb[i]);
ys.push_back(ya[i]), ys.push_back(yb[i]);
}
sort(xs.begin(), xs.end());
sort(ys.begin(), ys.end());
xs.resize(unique(xs.begin(), xs.end()) - xs.begin());
ys.resize(unique(ys.begin(), ys.end()) - ys.begin());
int nx = xs.size() - 1, ny = ys.size() - 1, s = nx + ny, t = s + 1;
G.init();
for (int i = 0; i < nx; ++i) G.link(s, i, xs[i + 1] - xs[i]);
for (int i = 0; i < ny; ++i) G.link(nx + i, t, ys[i + 1] - ys[i]);
for (int i = 0; i < nx; ++i)
for (int j = 0; j < ny; ++j) {
bool f = 0;
for (int k = 0; k < m; ++k) {
if (xa[k] <= xs[i] && xs[i + 1] <= xb[k] && ya[k] <= ys[j] &&
ys[j + 1] <= yb[k])
f = 1, k = m;
}
if (f) G.link(i, j + nx, max(xs[i + 1] - xs[i], ys[i + 1] - ys[i]));
}
printf("%d\n", G.run(s, t));
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, const U &b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, const U &b) {
if (a < b) a = b;
}
template <class T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T1, class T2>
inline void gn(T1 &x1, T2 &x2) {
gn(x1), gn(x2);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
const int mod = 998244353;
int K, cnt[2][75];
vector<int> adj[4040];
int dp[4040][75];
int sum[4040][75];
int C[75][75];
inline void add(int &a, int b) {
a += b;
if (a >= mod) a -= mod;
}
void dfs(int u, int f = 0) {
for (int v : adj[u])
if (v != f) dfs(v, u);
int *sum = ::sum[u];
for (int i = 0; i <= K; i += 2) {
sum[i] = 0;
for (int v : adj[u])
if (v != f) add(sum[i], dp[v][i]);
}
dp[u][0] = 1;
for (int i = 2; i <= K; i += 2) {
dp[u][i] = 0;
for (int j = 2; j <= i; j += 2)
add(dp[u][i], (long long)dp[u][i - j] * sum[j - 2] % mod);
}
}
int pre[75];
void redfs(int u, int f = 0) {
dp[u][0] = 1;
for (int i = 2; i <= K; i += 2) {
dp[u][i] = 0;
for (int j = 2; j <= i; j += 2)
add(dp[u][i], (long long)dp[u][i - j] * sum[u][j - 2] % mod);
}
for (int v : adj[u])
if (v != f) {
pre[0] = 1;
for (int i = 2; i <= K; i += 2) {
pre[i] = 0;
for (int j = 2; j <= i; j += 2)
add(pre[i], (long long)pre[i - j] *
(sum[u][j - 2] - dp[v][j - 2] + mod) % mod);
}
for (int i = 0; i <= K; i += 2) add(sum[v][i], pre[i]);
redfs(v, u);
}
}
void solve(int n, int *cnt) {
for (int i = 1; i <= n; i++) adj[i].clear();
for (int i = 1; i < n; i++) {
int u, v;
gn(u, v);
adj[u].push_back(v), adj[v].push_back(u);
}
dfs(1);
redfs(1);
for (int u = 1; u <= n; u++)
for (int i = 0; i <= K; i += 2) add(cnt[i], dp[u][i]);
}
int main() {
int n, m;
cin >> n >> m >> K;
if (K & 1) return puts("0"), 0;
for (int i = 0; i <= K; i++) {
C[i][0] = C[i][i] = 1;
for (int j = 1; j < i; j++) C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % mod;
}
solve(n, cnt[0]);
solve(m, cnt[1]);
int ans = 0;
for (int i = 0; i <= K; i += 2) {
ans = (ans + (long long)C[K][i] * cnt[0][i] % mod * cnt[1][K - i]) % mod;
}
cout << ans << endl;
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000100;
int n, m, a[maxn], b[maxn], cnt;
vector<int> v;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d", &a[i]);
}
b[++cnt] = 0;
b[++cnt] = n;
int sum = 0;
for (int i = 1; i < m; ++i) {
sum += a[i];
b[++cnt] = sum % n;
}
sum += a[m];
sort(b + 1, b + cnt + 1);
for (int i = 2; i <= cnt; ++i) {
v.push_back(b[i] - b[i - 1]);
}
printf("%d\n", (sum + n - 1) / n);
for (int i = 0; i < v.size(); ++i) {
printf("%d ", v[i]);
}
putchar('\n');
int p = 0;
for (int i = 1; i <= m; ++i) {
while (a[i] > 0) {
a[i] -= v[p++];
printf("%d ", i);
if (p == m) {
p = 0;
putchar('\n');
}
}
}
while (p && p++ != m) {
printf("%d ", m);
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
struct edg {
int v, w;
edg() { v = w = 0; }
edg(const int _v, const int _w) {
v = _v;
w = _w;
}
};
int n, m, second, T;
int hei[100005];
char ans[100005];
bool vis[2][100005];
int64_t tar_dist;
int64_t dist[2][100005];
vector<edg> adj[3][100005];
vector<array<int, 3>> edges;
const int64_t inf = INT64_MAX >> 6;
inline void dijkstra(const int t, const int st) {
fill(dist[t], dist[t] + n + 3, inf);
dist[t][st] = 0;
priority_queue<pair<int64_t, int64_t>> pq;
pq.push({0, st});
while (!pq.empty()) {
auto p = pq.top();
pq.pop();
int v = p.second;
if (vis[t][v]) {
continue;
}
vis[t][v] = true;
int64_t d = dist[t][v];
for (auto x : adj[t][v]) {
int64_t rd = d + int64_t(x.w);
if (rd < dist[t][x.v]) {
dist[t][x.v] = rd;
pq.push({-rd, x.v});
}
}
}
}
int dfs1(int st, int pr, int h, int enm) {
if (hei[st]) {
return hei[st];
}
hei[st] = h;
int mnh = h;
for (auto x : adj[2][st]) {
if (x.v == pr && x.w == enm) {
continue;
}
mnh = min(mnh, dfs1(x.v, st, h + 1, x.w));
}
if (mnh == h) {
ans[enm] = 'M';
}
return mnh;
}
int main() {
scanf("%d%d%d%d", &n, &m, &second, &T);
for (int i = 1; i <= m; i++) {
int a, b, w;
scanf("%d%d%d", &a, &b, &w);
adj[0][a].push_back(edg(b, w));
adj[1][b].push_back(edg(a, w));
edges.push_back(array<int, 3>{a, b, w});
}
dijkstra(0, second);
dijkstra(1, T);
tar_dist = dist[0][T];
assert(tar_dist == dist[1][second]);
if (tar_dist >= inf) {
for (int i = 1; i <= m; i++) {
puts("NO");
}
return 0;
}
for (int i = 0; i < m; i++) {
const auto &e = edges[i];
int64_t d = dist[0][e[0]] + dist[1][e[1]] + e[2];
if (d == tar_dist) {
adj[2][e[0]].push_back(edg(e[1], i));
adj[2][e[1]].push_back(edg(e[0], i));
}
}
dfs1(second, 0, 1, 100005 - 1);
for (int i = 0; i < m; i++) {
if (ans[i] == 'M') {
puts("YES");
continue;
}
const auto &e = edges[i];
int64_t d = dist[0][e[0]] + dist[1][e[1]] + e[2];
if (d >= inf) {
puts("NO");
continue;
}
int64_t delta = d - tar_dist + 1;
if (delta < int64_t(e[2])) {
printf("CAN %lld\n", delta);
} else {
puts("NO");
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 123;
const long long INF = (long long)1e18 + 123;
const int inf = (int)1e9 + 123;
const int MOD = (int)1e9 + 7;
int n;
long long a[N];
long long pref[N], suff[N];
struct bor {
int to[3];
bor() { memset(to, -1, sizeof to); }
};
vector<bor> t;
bor new_bor() {
bor tmp;
return tmp;
}
int bit[60];
int cnt[N * 70];
int MAX_BIT = 40;
void add(long long x) {
memset(bit, 0, sizeof bit);
int ptr = 0;
while (x > 0) {
bit[ptr] = (x & 1);
x >>= 1ll, ptr++;
}
int now = 0;
cnt[now]++;
for (int i = MAX_BIT; i >= 0; i--) {
if (t[now].to[bit[i]] == -1) {
t[now].to[bit[i]] = (int)(t.size());
t.push_back(new_bor());
}
cnt[t[now].to[bit[i]]]++;
now = t[now].to[bit[i]];
}
}
void del(long long x) {
memset(bit, 0, sizeof bit);
int ptr = 0;
while (x > 0) {
bit[ptr] = (x & 1);
x >>= 1ll, ptr++;
}
int now = 0;
cnt[now]--;
for (int i = MAX_BIT; i >= 0; i--) {
int go = t[now].to[bit[i]];
cnt[go]--;
now = go;
}
}
long long get(long long x) {
memset(bit, 0, sizeof bit);
int ptr = 0;
while (x > 0) {
bit[ptr] = (x & 1);
x >>= 1ll, ptr++;
}
int now = 0;
long long res = 0;
for (int i = MAX_BIT; i >= 0; i--) {
int go1 = t[now].to[(bit[i] ^ 1)], go2 = t[now].to[bit[i]];
if (t[now].to[(bit[i] ^ 1)] != -1 && cnt[t[now].to[(bit[i] ^ 1)]] > 0) {
res += (1ll << i);
now = go1;
} else {
now = go2;
}
if (now == -1) exit(0);
}
return res;
}
int main() {
t.push_back(new_bor());
unsigned int FOR;
asm("rdtsc" : "=A"(FOR));
srand(FOR);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) pref[i] = (pref[i - 1] ^ a[i]);
for (int i = n; i >= 1; i--) suff[i] = (suff[i + 1] ^ a[i]);
for (int i = n + 1; i >= 1; i--) {
add(suff[i]);
}
long long mx = 0;
for (int i = 0; i <= n; i++) {
if (i > 0) del(suff[i]);
mx = max(mx, get(pref[i]));
}
cout << mx;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int getInp() {
int t;
cin >> t;
if (t == 0 || t == -1) {
exit(0);
}
return t;
}
template <typename T>
int test(const T &inp) {
cout << inp << endl;
return getInp();
}
int main() {
int n;
n = test('a') + 1;
int na = test(string(n - 1, 'b'));
int nb = n - na;
if (nb == 0) {
test(string(n, 'a'));
} else {
string t(n, 'a');
for (int i = 0; i < n - 1; ++i) {
t[i] = 'b';
int r = test(t);
if (r == nb + 1) {
t[i] = 'a';
--na;
} else {
--nb;
if (nb == 0) {
break;
}
}
}
t[n - 1] = 'b';
test(t);
}
return 1;
}
| 7 |
#include <bits/stdc++.h>
int a, b, c;
int x, y, z;
int ca = 0, cb = 0, cc = 0;
bool fa = false, fb = false, fc = false;
int tmp = 0;
int main() {
scanf("%d%d%d%d%d%d", &a, &b, &c, &x, &y, &z);
if (a - x > 0) {
tmp += (a - x) >> 1;
}
if (b - y > 0) {
tmp += (b - y) >> 1;
}
if (c - z > 0) {
tmp += (c - z) >> 1;
}
if (a - x < 0) tmp -= x - a;
if (tmp < 0) {
puts("No");
return 0;
}
if (b - y < 0) tmp -= y - b;
if (tmp < 0) {
puts("No");
return 0;
}
if (c - z < 0) tmp -= z - c;
if (tmp < 0) {
puts("No");
return 0;
}
puts("Yes");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#define fastio() ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops,fast-math,O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#define ll long long
#define int long long
#define ld long double
#define endl "\n"
#define pb push_back
#define fill(a,val) memset(a,val,sizeof(a))
#define ff first
#define ss second
#define test ll t; cin>>t; while(t--)
#define loop(i,a,b) for(ll i=a;i<b;i++)
#define loopr(i,a,b) for(ll i=a;i>=b;i--)
#define pii pair<ll,ll>
#define all(v) v.begin(),v.end()
istream& in(cin);
ostream& out(cout);
const ll mod = 1000 * 1000 * 1000;
const ll inf = 1ll*1000*1000*1000*1000*1000*1000 + 7;
const ll mod2 = 998244353;
const ll N = 1000 * 1000 +100;
const ld pi = 3.141592653589793;
ll power(ll x,ll y,ll p = LLONG_MAX ){ll res=1;x%=p;while(y>0){if(y&1)res=(res*x)%p;y=y>>1;x=(x*x)%p;}return res;}
void solve(){
ll n,x;
cin >> n >> x;
vector<ll>a;
vector<ll>fr;
for(ll i=0;i<n;i++){
ll y;
cin >> y;
a.pb(y);
fr.pb(1);
}
ll ans=0,i;
for(i=0;i<a.size();i++){
if(a[i]%x==0){
ll cnt=x*fr[i];
a.pb(a[i]/x);
fr.pb(cnt);
ans+=fr[i]*a[i];
}
else{
ans+=fr[i]*a[i];
break;
}
}
i++;
while(i<a.size()){
ans+=a[i]*fr[i];
i++;
}
cout << ans << endl;
}
signed main(){
fastio();
#ifndef ONLINE_JUDGE
freopen("input.txt","r",stdin);
freopen("output.txt","w",stdout);
#endif
test
solve();
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> v;
map<long long, long long> m;
bool ok(long long mid, long long k) {
v.clear();
for (auto x : m) {
long long sizeV = (long long)v.size();
for (long long i = 0; i < min(x.second / mid, k - sizeV); i++) {
v.push_back(x.first);
if ((long long)v.size() == k) return true;
}
if ((long long)v.size() == k) return true;
}
if ((long long)v.size() == k)
return true;
else
return false;
}
void solve() {
long long n, k;
cin >> n >> k;
vector<long long> a(n);
for (long long i = 0; i < n; i++) {
cin >> a[i];
m[a[i]]++;
}
long long l = 1, r = n;
vector<long long> ans;
long long best = 0;
while (l <= r) {
long long mid = l + (r - l) / 2;
if (ok(mid, k)) {
best = mid;
l = mid + 1;
v.clear();
} else {
r = mid - 1;
}
}
ok(best, k);
for (auto x : v) cout << x << " ";
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int vis[100001], color[100001];
vector<int> op1, op2;
struct node {
int idx;
char col;
node(int a, char b) {
idx = a;
col = b;
}
};
vector<vector<node>> graph;
int bfs(int n, char rb) {
queue<int> nodes;
vector<int> zero, one;
nodes.push(n);
zero.push_back(n);
vis[n] = 1;
while (!nodes.empty()) {
int centr = nodes.front();
nodes.pop();
for (int i = 0; i < graph[centr].size(); i++) {
int v = graph[centr][i].idx;
char c = graph[centr][i].col;
if (vis[v] == 0) {
vis[v] = 1;
nodes.push(v);
if (c == rb)
color[v] = color[centr];
else
color[v] = !color[centr];
if (color[v])
one.push_back(v);
else
zero.push_back(v);
} else {
if ((c == rb && color[v] != color[centr]) ||
(c != rb && color[v] == color[centr]))
return 0;
}
}
}
if (rb == 'R') {
if ((int)one.size() < (int)zero.size()) {
for (auto itr : one) op1.push_back(itr);
} else {
for (auto itr : zero) op1.push_back(itr);
}
} else {
if ((int)one.size() < (int)zero.size()) {
for (auto itr : one) op2.push_back(itr);
} else {
for (auto itr : zero) op2.push_back(itr);
}
}
return 1;
}
int main() {
int i, j, k;
int n, m;
char c;
scanf("%d %d", &n, &m);
graph.resize(n + 1);
for (i = 0; i < m; i++) {
scanf("%d %d %c", &j, &k, &c);
graph[j].emplace_back(k, c);
graph[k].emplace_back(j, c);
}
memset(vis, 0, sizeof vis);
memset(color, 0, sizeof color);
int sig1 = 1;
for (i = 1; i <= n; i++) {
if (vis[i] == 0) sig1 *= bfs(i, 'R');
}
memset(vis, 0, sizeof vis);
memset(color, 0, sizeof color);
int sig2 = 1;
for (i = 1; i <= n; i++) {
if (vis[i] == 0) sig2 *= bfs(i, 'B');
}
if (sig1 == 0 && sig2 == 0)
printf("-1");
else if (sig1 && !sig2) {
printf("%d\n", (int)op1.size());
for (auto itr : op1) printf("%d ", itr);
} else if (!sig1 && sig2) {
printf("%d\n", (int)op2.size());
for (auto itr : op2) printf("%d ", itr);
} else if ((int)op1.size() < (int)op2.size()) {
printf("%d\n", op1.size());
for (auto itr : op1) printf("%d ", itr);
} else {
printf("%d\n", (int)op2.size());
for (auto itr : op2) printf("%d ", itr);
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int n;
const int mod = 998244353;
int jc[1000010], inv[1000010];
int ksm(int a, int b) {
int sum = 1;
while (b) {
if (b & 1) sum = 1ll * sum * a % mod;
a = 1ll * a * a % mod;
b >>= 1;
}
return sum;
}
void pre() {
jc[0] = inv[0] = 1;
int t = 1000000;
for (int i = 1; i <= t; i++) jc[i] = 1ll * jc[i - 1] * i % mod;
inv[t] = ksm(jc[t], mod - 2);
for (int i = t - 1; i >= 1; i--) inv[i] = 1ll * inv[i + 1] * (i + 1) % mod;
}
int C(int a, int b) { return 1ll * jc[b] * inv[a] % mod * inv[b - a] % mod; }
int main() {
pre();
scanf("%d", &n);
int A = 0, B = 0;
for (int i = 1; i <= n; i++) {
int t = C(i, n);
int s = (1ll * n * (n - i) % (mod - 1) + i) % (mod - 1);
s = ksm(3, s);
s = 1ll * s * t % mod;
int T = ksm(3, n - i);
int ds = ksm((T - 1 + mod) % mod, n);
ds = (ds - ksm(T, n) + mod) % mod;
t = 1ll * t * ds % mod;
if (i % 2 == 0) t = mod - t, s = mod - s;
A = (A + t) % mod;
B = (B + s) % mod;
}
A = 3ll * A % mod;
B = 2ll * B % mod;
A = (A + B) % mod;
cout << A;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
map<string, bool> m;
string str[] = {"purple", "green", "blue", "orange", "red", "yellow"};
string ab[] = {"Power", "Time", "Space", "Soul", "Reality", "Mind"};
int main() {
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
string word;
cin >> word;
m[word] = true;
}
int count = 0;
for (int i = 0; i < 6; ++i) {
if (m[str[i]] == false) {
++count;
}
}
cout << count << endl;
for (int i = 0; i < 6; ++i) {
if (m[str[i]] == false) {
cout << ab[i] << endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int x[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, p = 0, q = 0;
long long k = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x[i];
int t = sqrt(x[i]) + 3;
while (t * t > x[i]) t--;
if (t * t == x[i]) {
p++;
if (!x[i]) q++;
x[i] = 2e9;
} else
x[i] = min(x[i] - t * t, (t + 1) * (t + 1) - x[i]);
}
if (p > n / 2) {
cout << p - n / 2 + max(q - n / 2, 0) << endl;
} else {
sort(x + 1, x + n + 1);
for (int i = 1; i <= n / 2 - p; i++) k += x[i];
cout << k << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const long double eps = 1e-9;
const double pi = acos(-1.0);
const long long inf = 1e18;
using namespace std;
struct tman {
int l;
long double p;
tman() : l(0), p(0){};
tman(int l, double p) : l(l), p(p){};
};
int n;
long double ans = 0.0;
tman man[50500];
bool cmp(tman m1, tman m2) {
if (m1.l * m1.p * (1.0 - m2.p) > m2.l * m2.p * (1.0 - m1.p)) return true;
return false;
}
int main(int argc, const char* argv[]) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
int l;
double p;
scanf("%d%lf", &l, &p);
p *= 0.01;
ans += 1.0 * l;
man[i] = tman(l, p);
}
sort(man, man + n, cmp);
long double cur = 0.0;
for (int i = 0; i < n; i++) {
ans += cur * (1.0 - man[i].p);
cur += man[i].p * man[i].l;
}
cout << fixed << setprecision(10) << ans << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 705;
const int N = 15;
int outbuf[9];
struct BigInt {
int len, v[N + 1];
BigInt() {
len = 0;
memset(v, 0, sizeof(v));
}
BigInt(int a) {
len = 1;
memset(v, 0, sizeof(v));
v[1] = a;
}
void print() {
cout << v[len];
for (int i = len - 1; i >= 1; i--) {
int x = v[i];
for (int j = 0; j < 8; ++j) {
outbuf[j] = x % 10;
x /= 10;
}
for (int j = 7; j >= 0; j--) {
cout << outbuf[j];
}
}
cout << endl;
}
};
BigInt operator*(const BigInt& a, const BigInt& b) {
BigInt c;
int x = 0, j, i;
long long now;
for (int i = 1; i < a.len + 1; ++i) {
x = 0;
for (int j = 1; j < b.len + 1; ++j) {
now = ((long long)a.v[i]) * b.v[j] + c.v[i + j - 1] + x;
x = now / 100000000;
c.v[i + j - 1] = now % 100000000;
}
c.v[i + b.len] = x;
}
c.len = a.len + b.len - 1;
if (c.v[c.len + 1] != 0) {
c.len++;
}
return c;
}
bool operator<(const BigInt& a, const BigInt& b) {
if (a.len != b.len) {
return a.len < b.len;
}
for (int i = a.len; i >= 1; i--) {
if (a.v[i] != b.v[i]) {
return a.v[i] < b.v[i];
}
}
return false;
}
struct edge {
int y, n;
};
int n, i, num[maxn], son[maxn];
edge t[2 * maxn];
BigInt f[maxn][maxn];
void dfs(int x) {
int e = num[x];
f[x][1].len = 1;
f[x][1].v[1] = 1;
son[x] = 1;
while (e != 0) {
if (t[e].y != 0) {
if (e % 2 == 0) {
t[e - 1].y = 0;
} else {
t[e + 1].y = 0;
}
dfs(t[e].y);
son[x] += son[t[e].y];
for (int i = son[x]; i >= 2; i--) {
f[x][i] = f[x][i] * f[t[e].y][0];
f[x][i] = max(f[x][i], f[x][1] * f[t[e].y][i - 1]);
f[x][i] = max(f[x][i], f[x][i - 1] * f[t[e].y][1]);
}
f[x][1] = f[x][1] * f[t[e].y][0];
}
e = t[e].n;
}
for (int i = 1; i < son[x] + 1; ++i) {
f[x][0] = max(f[x][0], f[x][i] * BigInt(i));
}
}
int main() {
cin >> n;
int x, y, e = 0;
for (int i = 1; i < n; ++i) {
cin >> x >> y;
t[++e].y = y;
t[e].n = num[x];
num[x] = e;
t[++e].y = x;
t[e].n = num[y];
num[y] = e;
}
dfs(1);
f[1][0].print();
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int val[2];
node *lef, *righ;
node() {
val[0] = val[1] = 0;
lef = righ = nullptr;
}
} * root;
int lef, righ, val, val1, pos, mij, ok;
void update(node *act, int st, int dr) {
if (st == dr) {
act->val[0] = val;
act->val[1] = val1;
return;
}
if (act->lef == nullptr) {
act->lef = new node;
act->righ = new node;
}
mij = (st + dr) / 2;
if (pos <= mij)
update(act->lef, st, mij);
else
update(act->righ, mij + 1, dr);
act->val[0] = act->lef->val[0] + act->righ->val[0];
act->val[1] = act->lef->val[1] + act->righ->val[1];
act->val[0] %= 1000000007;
act->val[1] %= 1000000007;
}
int query(node *act, int st, int dr) {
if (act->val[ok] == 0 || (lef <= st && dr <= righ)) return act->val[ok];
int mij = (st + dr) / 2, ans = 0;
if (lef <= mij) ans = query(act->lef, st, mij);
if (mij < righ) ans += query(act->righ, mij + 1, dr);
return ans % 1000000007;
}
int main() {
long long sum = 0, ans = 0, x;
int n, i;
root = new node;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x;
lef = 1;
righ = x;
ok = 0;
sum = (sum + x * (query(root, 1, 1000000000) + i)) % 1000000007;
lef = x;
righ = 1000000000;
ok = 1;
sum = (sum + query(root, 1, 1000000000)) % 1000000007;
ans = (ans + sum) % 1000000007;
pos = x;
val = i;
val1 = (i * x) % 1000000007;
update(root, 1, 1000000000);
}
cout << ans << '\n';
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int par[505];
int r[505];
int res, u[10005], v[10005];
inline void init(int n) {
res = n;
for (int i = 0; i < n; i++) {
par[i] = i;
r[i] = 0;
}
}
inline int f(int x) {
if (par[x] == x)
return x;
else
return par[x] = f(par[x]);
}
inline void unite(int x, int y) {
x = f(x);
y = f(y);
if (x == y) return;
res--;
if (r[x] < r[y])
par[x] = y;
else {
par[y] = x;
if (r[x] == r[y]) r[x]++;
}
}
int main() {
ios::sync_with_stdio(false);
int n, m, k, l, r;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u[i] >> v[i];
u[i]--;
v[i]--;
}
cin >> k;
for (int t = 1; t <= k; t++) {
cin >> l >> r;
l--;
r--;
init(n);
for (int i = 0; i < l; i++) unite(u[i], v[i]);
for (int i = r + 1; i < m; i++) unite(u[i], v[i]);
cout << res << endl;
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
char ch = getchar();
int x = 0, w = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
}
return x * w;
}
inline long long readl() {
char ch = getchar();
long long x = 0, w = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0', ch = getchar();
}
return x * w;
}
const int N = 5e5 + 7;
struct edge {
int u, v;
} e[N];
int n, m, hed[N], to[N << 1], nxt[N << 1], cnt = 0, tr[N << 2][2], lazy[N << 2],
W[N << 1];
int X, Y, dep[N], mx, Q[N], tim = 0, ru[N], rev[N], chu[N], ans[N], fa[N];
bool cla[N];
inline void add(int u, int v, int w) {
to[++cnt] = v, nxt[cnt] = hed[u], hed[u] = cnt, W[cnt] = w;
}
inline void dfs1(int u, int fat) {
dep[u] = dep[fat] + 1;
int v;
if (mx < dep[u]) X = u, mx = dep[u];
for (int i = hed[u]; i; i = nxt[i]) {
v = to[i];
if (v != fat) dfs1(v, u);
}
}
inline void dfs2(int u, int fat) {
dep[u] = dep[fat] + 1;
int v;
if (mx < dep[u]) Y = u, mx = dep[u];
for (int i = hed[u]; i; i = nxt[i]) {
v = to[i];
if (v != fat) dfs2(v, u);
}
}
inline void dfs(int u, int fat) {
int v;
ru[u] = ++tim;
rev[tim] = u;
for (int i = hed[u]; i; i = nxt[i]) {
v = to[i];
if (v != fat) {
fa[v] = u;
dep[v] = dep[u] + 1;
if (W[i])
cla[v] = cla[u] ^ 1;
else
cla[v] = cla[u];
dfs(v, u);
}
}
chu[u] = tim;
}
inline void up(int now, int h, int t) {
tr[now][0] = max(tr[now << 1][0], tr[now << 1 | 1][0]);
tr[now][1] = max(tr[now << 1][1], tr[now << 1 | 1][1]);
}
inline void build(int now, int h, int t) {
if (h == t) {
tr[now][cla[rev[h]]] = dep[rev[h]];
return;
}
build(now << 1, h, ((h + t) >> 1)),
build(now << 1 | 1, ((h + t) >> 1) + 1, t);
up(now, h, t);
}
inline void spread(int now, int h, int t) {
if (lazy[now]) {
(tr[now << 1][0] ^= tr[now << 1][1] ^= tr[now << 1][0] ^= tr[now << 1][1]);
(tr[now << 1 | 1][0] ^= tr[now << 1 | 1][1] ^= tr[now << 1 | 1][0] ^=
tr[now << 1 | 1][1]);
lazy[now << 1] ^= 1, lazy[now << 1 | 1] ^= 1;
lazy[now] = 0;
}
}
inline void updata(int now, int h, int t, int H, int T) {
if (h > T || H > t) return;
if (H <= h && t <= T) {
lazy[now] ^= 1;
(tr[now][0] ^= tr[now][1] ^= tr[now][0] ^= tr[now][1]);
return;
}
spread(now, h, t);
if (H <= ((h + t) >> 1)) updata(now << 1, h, ((h + t) >> 1), H, T);
if (((h + t) >> 1) + 1 <= T)
updata(now << 1 | 1, ((h + t) >> 1) + 1, t, H, T);
up(now, h, t);
}
inline void work(int rt) {
memset(dep, 0, sizeof(dep));
cla[rt] = 0;
memset(tr, 0, sizeof(tr));
memset(fa, 0, sizeof(fa));
tim = 0;
dfs(rt, 0);
memset(lazy, 0, sizeof(lazy));
build(1, 1, n);
int u, v;
for (int i = 1; i <= m; ++i) {
u = e[Q[i]].u;
v = e[Q[i]].v;
if (fa[u] == v) (u ^= v ^= u ^= v);
updata(1, 1, n, ru[v], chu[v]);
ans[i] = max(ans[i], tr[1][0]);
}
}
int main() {
n = read();
int u, v, w;
for (int i = 1; i <= n - 1; ++i) {
u = read(), v = read(), w = read();
add(u, v, w), add(v, u, w);
e[i] = (edge){u, v};
}
memset(dep, 0, sizeof(dep));
mx = -1;
dfs1(1, 0);
memset(dep, 0, sizeof(dep)), mx = -1, dep[0] = -1;
dfs2(X, 0);
m = read();
for (int i = 1; i <= m; ++i) Q[i] = read();
memset(ans, 0, sizeof(ans));
work(X), work(Y);
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
return 0;
}
| 10 |
#include <bits/stdc++.h>
const int p = 1000000007;
int edge[500000], pred[500000], next[500000], first[500000];
int b1[500000], b2[500000], d[500000], f[500000];
int i, n, t, sum_edge;
inline int power(int x, int y) {
if (!y) return 1;
int t = power(x, y / 2);
t = 1LL * t * t % p;
if (y & 1) t = 1LL * t * x % p;
return t;
}
inline void addedge(int x, int y) {
sum_edge++, edge[sum_edge] = y, next[sum_edge] = first[x],
pred[first[x]] = sum_edge, first[x] = sum_edge;
return;
}
inline void dfs1(int x, int y) {
f[x] = 1;
for (int i = first[x]; i != 0; i = next[i])
if (edge[i] != y) {
dfs1(edge[i], x);
f[x] = 1LL * f[x] * f[edge[i]] % p;
}
f[x] = (f[x] + 1) % p;
return;
}
inline void dfs2(int x, int y, int z) {
d[x] = 1LL * (f[x] + p - 1) % p * z % p;
int r, t = 0;
r = 0;
for (int i = first[x]; i != 0; i = next[i])
if (edge[i] != y) b1[edge[i]] = 1LL * b1[r] * f[r] % p, r = edge[i], t = i;
r = 0;
for (int i = t; i != 0; i = pred[i])
if (edge[i] != y) b2[edge[i]] = 1LL * b2[r] * f[r] % p, r = edge[i];
for (int i = first[x]; i != 0; i = next[i])
if (edge[i] != y)
dfs2(edge[i], x, (1LL * b1[edge[i]] * b2[edge[i]] % p * z % p + 1) % p);
return;
}
int main() {
scanf("%d", &n);
for (i = 2; i <= n; i++) {
scanf("%d", &t);
addedge(i, t), addedge(t, i);
}
dfs1(1, 0);
f[0] = 1, b1[0] = 1, b2[0] = 1;
dfs2(1, 0, 1);
for (i = 1; i <= n; i++) printf("%d ", d[i]);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, step;
node() {}
node(int X, int Y, int S) { x = X, y = Y, step = S; }
bool operator<(const node &u) const { return step > u.step; }
};
priority_queue<node> q;
int n, m, ans = 0x3f3f3f3f;
int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
char ch[1005][1005];
bool vis[1005][1005];
int dis1[1005][1005], dis2[1005][1005], dis3[1005][1005];
void bfs(int dis[1005][1005]) {
memset(vis, 0, sizeof(vis));
while (!q.empty()) {
node t = q.top();
q.pop();
for (int i = 0; i < 4; i++) {
int tx = t.x + dx[i], ty = t.y + dy[i];
if (tx < 1 || ty < 1 || tx > n || ty > m) continue;
if (vis[tx][ty]) continue;
if (ch[tx][ty] == '#') continue;
vis[tx][ty] = 1;
if (ch[tx][ty] == '.')
dis[tx][ty] = t.step + 1, q.push(node(tx, ty, t.step + 1));
else
dis[tx][ty] = t.step, q.push(node(tx, ty, t.step));
}
}
}
int main() {
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("\n");
for (int j = 1; j <= m; j++) scanf("%c", &ch[i][j]);
}
memset(dis1, 0x3f, sizeof(dis1));
memset(dis2, 0x3f, sizeof(dis2));
memset(dis3, 0x3f, sizeof(dis3));
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (ch[i][j] == '1') q.push(node(i, j, 0));
bfs(dis1);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (ch[i][j] == '2') q.push(node(i, j, 0));
bfs(dis2);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (ch[i][j] == '3') q.push(node(i, j, 0));
bfs(dis3);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (ch[i][j] == '.')
ans = min(1ll * ans, 1ll * dis1[i][j] + dis2[i][j] + dis3[i][j] - 2);
else
ans = min(1ll * ans, 1ll * dis1[i][j] + dis2[i][j] + dis3[i][j]);
printf("%d", (ans == 0x3f3f3f3f) ? -1 : ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
int main() {
char s[16];
scanf("%s", s);
int i = 0, n, t = 0;
n = strlen(s);
while (s[i] != '\0') {
if (s[i] != s[n - 1 - i]) t++;
if (t > 2) break;
i++;
}
if (t == 2 || (t == 0 && strlen(s) % 2 == 1))
printf("YES");
else
printf("NO");
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, cha, num;
long long count = 0;
cin >> n >> m;
for (int i = 1; i <= n; i++) {
cha = i / 5;
count += (m + i - 5 * cha) / 5;
}
cout << count;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int F(string s) {
long long int len = s.size();
long long int now = 0, sum = 0, last = 1;
for (int i = 0; i < len; i++) {
if (s[i] >= '0' && s[i] <= '9') now = now * 10 + (s[i] - '0');
if (s[i] == '+') {
if (last != -1)
sum += (last * now);
else
sum += now;
now = 0;
last = -1;
}
if (s[i] == '*') {
if (last == -1)
last = now;
else
last *= now;
now = 0;
}
}
if (last != -1) {
sum += (last * now);
now = 0;
}
if (now != 0) sum += now;
return (sum);
}
int main() {
string s;
cin >> s;
long long int ans = F(s);
vector<pair<long long int, long long int>> v;
long long int last = -1;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '+') last = i;
if (s[i] == '*') v.push_back({i, last});
}
for (int i = 0; i < v.size(); i++) {
long long int now, p = v[i].first, last = v[i].second;
string s1, s2, s3, s4, s5;
if (last != -1)
s1 = s.substr(0, last);
else
s1 = "0";
s2 = s.substr(last + 1, p - last - 1);
s3 = s.substr(p + 1);
long long int sums2 = F(s2), sums1 = F(s1);
now = sums1 + sums2 * F(s3);
ans = max(now, ans);
s4 = s.substr(0, p);
long long int now1 = F(s4);
s4 = "";
while (now1 != 0) {
s4 = char((now1 % 10) + '0') + s4;
now1 /= 10;
}
s5 = s.substr(p);
s5 = s4 + s5;
now = F(s5);
ans = max(ans, now);
for (int j = i + 1; j < v.size(); j++) {
long long int p2 = v[j].first;
s3 = s.substr(p + 1, p2 - p - 1);
long long int now1 = sums2 * F(s3);
s4 = "";
while (now1 != 0) {
s4 = char((now1 % 10) + '0') + s4;
now1 /= 10;
}
s5 = s.substr(p2);
s5 = s4 + s5;
now = sums1 + F(s5);
ans = max(ans, now);
}
}
cout << ans;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
class trio {
public:
long long first, second, third;
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n, x, t, u, c;
cin >> n;
long long arr[n + 1], len;
long long brr[20][20] = {0}, crr[20][20] = {0};
vector<long long> lent[20];
for (long long i = 0; i < n; ++i) {
cin >> arr[i];
x = arr[i];
t = 0;
while (x) {
x /= 10;
t++;
}
len = t;
lent[t].push_back(i);
for (long long j = 1; j < 20; ++j) {
x = arr[i];
c = 0;
t = 1;
while (x) {
u = x % 10;
x /= 10;
brr[len][j] += (t * u);
if (c == j)
t *= 10;
else {
t *= 100;
c++;
}
t %= 998244353;
brr[len][j] %= 998244353;
}
x = arr[i];
t = 10;
c = 1;
while (x) {
u = x % 10;
x /= 10;
crr[len][j] += (t * u);
if (c == j)
t *= 10;
else {
t *= 100;
c++;
}
t %= 998244353;
crr[len][j] %= 998244353;
}
}
}
long long ans = 0;
for (long long i = 1; i < 20; ++i) {
for (long long j = 1; j < 20; ++j) {
ans += (((brr[i][min(i, j)] * lent[j].size()) % 998244353) +
((crr[j][min(i, j)] * lent[i].size()) % 998244353)) %
998244353;
ans %= 998244353;
}
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void find(string s, long long n) {
int flag = 0;
string s1 = "", s2 = "";
for (long long i = 0; i < n; i++) {
if (s[i] == '2') {
s1 = s1 + '1';
s2 = s2 + '1';
}
if (s[i] == '1') {
s1 = s1 + '1';
s2 = s2 + '0';
break;
}
if (s[i] == '0') {
s1 = s1 + '0';
s2 = s2 + '0';
}
}
for (long long i = 0; i < s1.length(); i++) cout << s1[i];
for (long long i = s1.length(); i < s.length(); i++) cout << "0";
cout << "\n";
for (long long i = 0; i < s2.length(); i++) cout << s2[i];
for (long long i = s2.length(); i < s.length(); i++) cout << s[i];
}
void solve(int t) {
while (t--) {
long long n;
cin >> n;
string s;
cin >> s;
find(s, n);
if (t != 0) cout << "\n";
}
}
int main() {
int t;
cin >> t;
solve(t);
return 0;
}
| 2 |
#include <bits/stdc++.h>
int main(void) {
long long int n, len, x, c;
c = 0;
int i;
scanf("%lld %lld", &n, &len);
for (i = 0; i < n; i++) {
scanf("%lld", &x);
len -= (86400 - x);
c++;
if (len <= 0) break;
}
printf("%lld\n", c);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int up;
int down;
int top;
cin >> up >> down;
top = up + down + 1;
for (int i = 1; i <= up; i++) cout << i << " ";
cout << top;
for (int i = 1; i <= top - up - 1; i++) cout << " " << top - i;
cout << endl;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct ss {
int num, q;
} a[110];
int i, j, k, l, n, m;
int cmp(ss p, ss q) { return p.num < q.num; }
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d%d", &a[i].num, &a[i].q);
sort(a + 1, a + n + 1, cmp);
for (i = 1; i <= n; i++)
if (a[i].num > 0) break;
j = i - 1;
m = i;
while ((j <= n) && (i > 0)) {
i--;
if (i <= 0) break;
k += a[i].q;
j++;
if (j > n) break;
k += a[j].q;
}
if (k > l) l = k;
k = 0;
j = m - 1;
i = m;
while ((j <= n) && (i > 0)) {
j++;
if (j > n) break;
k += a[j].q;
i--;
if (i <= 0) break;
k += a[i].q;
}
if (k > l) l = k;
printf("%d\n", l);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1}, N = 50;
long long n, p3 = 1, mxa = -1e8, ansbit = -1, l[N], m[N], v[N];
map<pair<long long, long long>, pair<long long, long long> > mp;
void dfs(long long now, long long a, long long b, long long c, long long bit) {
if (now >= n / 2) {
auto it = mp.find({a - b, b - c});
if (it == mp.end())
mp.insert({{a - b, b - c}, {-a, bit}});
else {
if (it->second.first > -a) it->second = {-a, bit};
}
return;
}
dfs(now + 1, a + l[now], b + m[now], c, bit * 3 + 2);
dfs(now + 1, a + l[now], b, c + v[now], bit * 3 + 1);
dfs(now + 1, a, b + m[now], c + v[now], bit * 3);
}
void decode(long long x) {
while (x) {
cout << x % 3;
x /= 3;
}
cout << '\n';
return;
}
void dfs2(long long now, long long a, long long b, long long c, long long bit) {
if (now >= n) {
auto it = mp.lower_bound({b - a, c - b});
if (it->first != make_pair(b - a, c - b)) return;
pair<long long, long long> t = it->second;
if (-t.first + a > mxa) {
mxa = -t.first + a;
ansbit = t.second * p3 + bit;
}
return;
}
dfs2(now + 1, a + l[now], b + m[now], c, bit * 3 + 2);
dfs2(now + 1, a + l[now], b, c + v[now], bit * 3 + 1);
dfs2(now + 1, a, b + m[now], c + v[now], bit * 3);
}
signed main(void) {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) cin >> l[i] >> m[i] >> v[i];
dfs(0, 0, 0, 0, 0);
for (long long i = 0; i < (n + 1) / 2; i++) p3 *= 3;
dfs2(n / 2, 0, 0, 0, 0);
if (ansbit == -1)
cout << "Impossible\n";
else {
vector<long long> ans;
while (n--) {
long long t = ansbit % 3;
ans.emplace_back(t);
ansbit /= 3;
}
long long a = 0, b = 0, c = 0, st = 0;
for (long long i = (long long)(ans).size() - 1; i >= 0; i--, st++) {
a += l[st], b += m[st], c += v[st];
if (ans[i] == 0)
cout << "MW\n", a -= l[st];
else if (ans[i] == 1)
cout << "LW\n", b -= m[st];
else
cout << "LM\n", c -= v[st];
}
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int a[1401][1401];
bool u[401], u2[401];
int main() {
vector<int> je[450], o[450], d(450, 1000000000), d2(450, 1000000000);
queue<int> q;
int n, m;
cin >> n >> m;
int x, y;
for (int i = 1; i <= m; ++i) {
cin >> x >> y;
je[x].push_back(y);
je[y].push_back(x);
a[x][y] = 1;
a[y][x] = 1;
}
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j)
if (a[i][j] != 1) {
o[i].push_back(j);
o[j].push_back(i);
}
q.push(1);
d[1] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
u[v] = 1;
for (int i = 0; i < je[v].size(); ++i) {
int to = je[v][i];
if (!u[to] && d[to] > d[v] + 1) {
q.push(to);
d[to] = d[v] + 1;
}
}
}
q.push(1);
d2[1] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
u2[v] = 1;
for (int i = 0; i < o[v].size(); ++i) {
int to = o[v][i];
if (!u2[to] && d2[to] > d2[v] + 1) {
q.push(to);
d2[to] = d2[v] + 1;
}
}
}
if (d[n] == 1000000000 || d2[n] == 1000000000) {
cout << -1;
return 0;
}
cout << max(d[n], d2[n]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
int main() {
int n, a[101], i, max, x, pos, ans = 0;
scanf("%d", &n);
scanf("%d", &x);
n--;
max = -1;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] >= max) {
max = a[i];
pos = i;
}
}
while (x <= max) {
a[pos]--;
x++;
ans++;
max = -1;
for (i = 0; i < n; i++) {
if (a[i] > max) {
max = a[i];
pos = i;
}
}
}
printf("%d\n", ans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
cin >> s >> t;
reverse(t.begin(), t.end());
if (s.compare(t) == 0) {
cout << "YES" << endl;
} else {
cout << "NO" << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, q, x[105], y[105], a[105], b[105], c[105];
long long dp1[15][(1 << (15))], dp2[15][(1 << (15))];
void setup() {
cin >> n >> m >> q;
for (int i = 1; i <= m; i++) {
cin >> x[i] >> y[i];
x[i]--;
y[i]--;
}
for (int i = 1; i <= q; i++) {
cin >> a[i] >> b[i] >> c[i];
a[i]--;
b[i]--;
c[i]--;
}
memset(dp1, -1, sizeof(dp1));
memset(dp2, -1, sizeof(dp2));
}
long long calc(int u, int mask);
bool invalid(int u, int mask, int p, bool one) {
for (int i = 1; i <= m; i++)
if ((((mask) >> (x[i])) & 1) != (((mask) >> (y[i])) & 1)) {
if (one && ((x[i] != u && x[i] != p) || (y[i] != u && y[i] != p)))
return true;
if (!one && x[i] != u && y[i] != u) return true;
}
for (int i = 1; i <= q; i++) {
if (!(((mask) >> (c[i])) & 1)) {
if ((((mask) >> (a[i])) & 1) && (((mask) >> (b[i])) & 1)) return true;
} else {
if (one && (((mask) >> (a[i])) & 1) != (((mask) >> (b[i])) & 1))
return true;
if (!one && (!(((mask) >> (a[i])) & 1) || !(((mask) >> (b[i])) & 1)) &&
c[i] != u)
return true;
}
}
return false;
}
long long calc1(int u, int mask, int p) {
if (invalid(u, mask, p, true)) return 0;
if (dp1[u][mask] != -1) return dp1[u][mask];
return (dp1[u][mask] = calc(u, mask));
}
long long calc2(int u, int mask) {
if (invalid(u, mask, 0, false)) return 0;
if (dp2[u][mask] != -1) return dp2[u][mask];
return (dp2[u][mask] = calc(u, mask));
}
long long calc(int u, int mask) {
int newMask = mask ^ (1 << (u));
if (newMask == 0) return 1;
int low = 0;
for (int i = 0; i <= n - 1; i++)
if ((newMask & (1 << (i))) > 0) {
low = (1 << (i));
break;
}
long long re = 0;
for (int i = newMask; i > 0; i = ((i - 1) & newMask)) {
if ((i & low) == 0) continue;
for (int j = 0; j <= n - 1; j++)
if ((((i) >> (j)) & 1)) re += calc1(j, i, u) * calc2(u, mask ^ i);
}
return re;
}
void xuly() { cout << calc1(0, (1 << (n)) - 1, -1); }
int main() {
iostream::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
setup();
xuly();
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 1e1;
int n, m, k, a, sum;
string s[MAXN];
string binary(int x) {
string y;
for (int i = n - 1; i >= 0; i--) {
if (x >= pow(2, i)) {
y += "1";
x -= pow(2, i);
} else
y += "0";
}
return y;
}
int check(string x) {
int d = 0;
for (int i = 0; i < n; i++) {
if (s[m][i] != x[i]) {
d++;
}
}
if (d <= k) return 1;
return 0;
}
int main() {
cin >> n >> m >> k;
for (int i = 0; i <= m; i++) {
cin >> a;
s[i] = binary(a);
}
for (int i = 0; i < m; i++) sum += check(s[i]);
cout << sum << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
bool debug = false;
using namespace std;
int N;
vector<pair<int, int> > rating;
int ans[300005];
int main() {
scanf("%d", &N);
rating.resize(N);
for (int i = 0; i < N; ++i) {
scanf("%d", &(rating[i].first));
(rating[i].second) = i;
}
sort(rating.begin(), rating.end());
if (debug) {
for (int i = 0; i < N; ++i)
cout << (rating[i].first) << "(" << (rating[i].second) << ") ";
cout << endl;
}
int nowPresent = 1;
for (int i = 0; i < N; ++i) {
if ((rating[i].first) > nowPresent) nowPresent = (rating[i].first);
if (debug) {
cout << " > " << (rating[i].second) << ": " << nowPresent << endl;
}
ans[(rating[i].second)] = nowPresent++;
}
for (int i = 0; i < N; ++i) printf("%d ", ans[i]);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double i, j, h, l, num;
cin >> h >> l;
num = (l * l - h * h) / (2 * h);
cout << (fixed) << setprecision(12) << num;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-7;
const double PI = acos(-1);
const int MOD = 998244353;
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int N = 2e3 + 7;
int n, k;
int l[N], r[N], a[N];
long long d[N];
inline void solve() {
cin >> n >> k;
for (int i = 1; i <= n; ++i) cin >> l[i] >> r[i] >> a[i];
long long res = INF;
memset(d, 0x3f, sizeof d);
d[1] = 0;
for (int i = 1; i <= n; ++i) {
long long rem = k, tot = d[i];
for (int j = i; j <= n; ++j) {
long long t = (max(0ll, a[j] - rem) + k - 1) / k;
if (t > r[j] - l[j]) break;
rem = t * k + rem - a[j];
tot += a[j];
if (j == n)
res = min(res, tot);
else if (l[j] + t < l[j + 1])
d[j + 1] = min(d[j + 1], tot + rem);
}
}
cout << (res >= INF ? -1 : res) << endl;
}
signed main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T = 1;
for (int t = 1; t <= T; ++t) {
solve();
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
class test_data_generation {
int max_n, max_a, q, fft_size, *bit_reversal, *f[2], test_cases;
class complex_t : public complex<double>{
public : complex_t(double r = 0, double i = 0){real(r);
imag(i);
} int set(double r = 0, double i = 0) {
real(r);
imag(i);
return 1;
}
complex_t &operator=(const complex<double> &z) {
real(z.real());
imag(z.imag());
return *this;
}
}
*root, *d[3];
complex_t *new_fft_block() { return new complex_t[fft_size]; }
void fft_0(complex_t *a) {
for (int i = 0; i < fft_size; ++i) {
int j = bit_reversal[i];
if (i < j) swap(a[i], a[j]);
}
complex_t e;
for (int k = 1, l = 2; k < fft_size; k = l, l <<= 1)
for (int s = 0; s < fft_size; s += l)
for (int i = 0, j = s, m = k, n = j + k; i < k; ++i, ++j, ++m, ++n)
e = root[m] * a[n], a[n] = a[j] - e, a[j] += e;
}
void fft_1(complex_t *a) {
reverse(a + 1, a + fft_size);
fft_0(a);
}
void update(int &f1, complex_t &d1, int f2, long long w) {
int u = ((long long)(d1.real() / fft_size + 0.5) + f1) % q;
u += q, u -= w * f2 % q, f1 = u % q;
}
void solve(int k) {
if (k == 0) {
f[0][0] = 1;
return;
}
int l = k / 2;
solve(l);
for (int i = max_n + 1; i < fft_size; ++i)
d[0][i].set(), d[1][i].set(), d[2][i].set();
int b = l & 1, b1 = b ^ 0, b2 = b ^ 1;
for (int i = 0; i <= max_n; ++i)
d[0][i].set(f[0][i] + f[1][i]), d[1][i].set(f[b1][i]),
d[2][i].set(f[b2][i]);
fft_0(d[0]);
fft_0(d[1]);
fft_0(d[2]);
for (int i = 0; i < fft_size; ++i) d[1][i] *= d[0][i], d[2][i] *= d[0][i];
fft_1(d[1]);
fft_1(d[2]);
for (int i = max_n; i >= 0; --i) {
long long w = (long long)(f[0][i] + f[1][i]) % q;
update(f[0][i], d[1][i], f[b1][0], w);
update(f[1][i], d[2][i], f[b2][0], w);
}
if (k & 1)
for (int i = max_n, j = i - 1; i > 0; --i, --j)
f[1][i] += f[0][j] + f[1][j], f[1][i] %= q;
for (int i = 1; i <= max_n; i += 2) test_cases += f[1][i], test_cases %= q;
}
public:
test_data_generation() : fft_size(1), test_cases(0) {
cin >> max_n >> max_a >> q;
int p = 2 * max_n + 1, tl = 0;
while (fft_size < p) fft_size <<= 1, ++tl;
p = max_n + 1, bit_reversal = new int[fft_size], root = new_fft_block();
d[0] = new_fft_block(), d[1] = new_fft_block(), d[2] = new_fft_block();
for (int j = 0; j < 2; ++j) {
f[j] = new int[p];
for (int i = 0; i <= max_n; ++i) f[j][i] = 0;
}
for (int i = 0; i < fft_size; ++i) bit_reversal[i] = 0;
for (int i = 1, l, r; i < fft_size; bit_reversal[i++] = l | r)
l = bit_reversal[i >> 1] >> 1, r = (i & 1) << (tl - 1);
int b_size = fft_size >> 1;
double theta, delta = 2 * acos(-1.0) / fft_size;
for (int i = 0, j = b_size; i < b_size; ++i, ++j)
theta = delta * i, root[j].set(cos(theta), sin(theta));
for (int i = b_size - 1, j = i << 1; i > 0; --i, --j, --j) root[i] = root[j];
}
void solve() { solve(max_a / 2); }
void output_solution() { cout << test_cases; }
}
;
int main() {
test_data_generation problem;
problem.solve();
problem.output_solution();
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int n, i, x, y;
bool data[3][100];
int main() {
scanf("%d", &n);
for (i = 1; i <= n * n; i++) {
scanf("%d%d", &x, &y);
if ((!data[1][x]) && (!data[2][y])) {
printf("%d ", i);
data[1][x] = data[2][y] = true;
}
}
printf("\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = (long long)1e9 + 9;
const int N = (int)1e5 + 4;
int d[3] = {0, -1, 1};
struct cube {
int x, y, c[2][3], n;
cube() {}
cube(int x, int y, int n) : x(x), y(y), n(n) {}
};
const bool operator<(const cube &a, const cube &b) { return a.n < b.n; }
struct point {
int x, y, n;
point() {}
point(int x, int y, int n) : x(x), y(y), n(n) {}
};
const bool operator<(const point &a, const point &b) {
if (a.y == b.y) {
if (a.x == b.x) {
return a.n < b.n;
}
return a.x < b.x;
}
return a.y < b.y;
}
cube a[N];
bool u[N];
int main() {
int m;
scanf("%d", &m);
set<point> q;
for (int i = 0; i < m; ++i) {
int x, y;
scanf("%d %d", &x, &y);
a[i] = cube(x, y, i);
memset(a[i].c, -1, sizeof a[i].c);
for (int k = 0; k < 2; ++k) {
for (int j = 0; j < 3; ++j) {
point po = point(x + (1 - 2 * k) * d[j], y + 2 * k - 1, -1);
set<point>::iterator it = q.lower_bound(po);
if (it != q.end() && it->x == po.x && it->y == po.y) {
a[i].c[k][j] = it->n;
a[it->n].c[1 - k][j] = i;
}
}
}
q.insert(point(x, y, i));
}
set<cube> p;
for (int i = 0; i < m; ++i) {
bool f = 1;
for (int j = 0; j < 3; ++j) {
int v = a[i].c[1][j];
if (v != -1 && a[v].c[0][(j + 1) % 3] == -1 &&
a[v].c[0][(j + 2) % 3] == -1) {
f = 0;
}
}
if (f) {
p.insert(a[i]);
}
}
int x = 0;
long long ans = 0;
for (; (int)p.size() > 0; ++x) {
cube t = (x % 2 == 0 ? *p.rbegin() : *p.begin());
ans = (m * ans + t.n) % inf;
u[t.n] = 1;
vector<int> tp;
for (int k = 0; k < 2; ++k) {
for (int j = 0; j < 3; ++j) {
int i = t.c[k][j];
if (i != -1) {
a[i].c[1 - k][j] = -1;
}
}
}
for (int k = -2; k <= 2; ++k) {
for (int j = -2; j <= 2; ++j) {
point po = point(t.x + k, t.y + j, -1);
set<point>::iterator it = q.lower_bound(po);
if (it != q.end() && it->x == po.x && it->y == po.y) {
int i = it->n;
bool f = !u[i];
for (int h = 0; h < 3; ++h) {
int v = a[i].c[1][h];
if (v != -1 && a[v].c[0][(h + 1) % 3] == -1 &&
a[v].c[0][(h + 2) % 3] == -1) {
f = 0;
}
}
if (f) {
p.insert(a[i]);
} else {
p.erase(a[i]);
}
}
}
}
p.erase(t);
}
printf("%lld", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T, class U>
inline void chmin(T &t, U f) {
if (t > f) t = f;
}
template <class T, class U>
inline void chmax(T &t, U f) {
if (t < f) t = f;
}
long long N, K;
long long x[100000], y[100000];
long long ans[111111];
void execute(vector<pair<long long, long long> > &ev, long long w) {
long long cnt = 0;
for (long long i = 0; i + 1 < ev.size(); i++) {
long long h = ev[i + 1].first - ev[i].first;
cnt += ev[i].second;
ans[cnt] += h * w;
}
}
signed main() {
scanf("%lld%lld", &N, &K);
for (long long i = 0; i < (N); i++) scanf("%lld%lld", &x[i], &y[i]);
map<long long, vector<pair<long long, long long> > > ps;
for (long long i = 0; i < (N); i++) {
ps[x[i] - K].push_back(pair<long long, long long>(y[i] - K, 1));
ps[x[i] - K].push_back(pair<long long, long long>(y[i], -1));
ps[x[i]].push_back(pair<long long, long long>(y[i] - K, -1));
ps[x[i]].push_back(pair<long long, long long>(y[i], 1));
}
map<long long, vector<pair<long long, long long> > >::iterator it, jt;
it = jt = ps.begin();
jt++;
vector<pair<long long, long long> > ev;
for (; jt != ps.end(); it++, jt++) {
long long w = jt->first - it->first;
vector<pair<long long, long long> > &v = it->second;
sort((v).begin(), (v).end());
vector<pair<long long, long long> > ev_;
long long i = 0, j = 0;
while (i < ev.size() || j < v.size()) {
if (i < ev.size() && (j == v.size() || ev[i].first <= v[j].first)) {
ev_.push_back(ev[i++]);
} else {
if (ev_.size() && ev_.back().first == v[j].first)
ev_.back().second += v[j++].second;
else
ev_.push_back(v[j++]);
}
if (ev_.back().second == 0) ev_.pop_back();
}
ev = ev_;
execute(ev, w);
}
for (long long i = 1; i <= N; i++) printf("%lld ", ans[i]);
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
priority_queue<pair<int, int> > Q;
long long b = 0, p = 0, x, y, i;
cin >> str;
for (i = 0; i < str.size(); i++) {
if (str[i] == '(')
b++;
else if (str[i] == ')')
b--;
else {
b--;
cin >> x >> y;
p += y;
str[i] = ')';
Q.push(make_pair(y - x, i));
}
pair<int, int> t;
if (b < 0) {
if (Q.empty()) break;
t = Q.top();
Q.pop();
b += 2;
str[t.second] = '(';
p -= t.first;
}
}
if (b != 0)
cout << -1 << endl;
else {
cout << p << endl;
cout << str << endl;
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int M = 2e5 + 5;
int n, t[M], k;
long long ans;
struct node {
long long p;
int v;
} a[M];
struct BIT {
long long s[M];
void add(int i, long long x) {
for (; i <= k; i += i & -i) s[i] += x;
}
long long ask(int i) {
long long res = 0;
for (; i > 0; i -= i & -i) res += s[i];
return res;
}
} f1, f2;
inline int find(int x) {
int l = 1, r = k, mid;
while (l < r) {
mid = (l + r) >> 1;
if (t[mid] < x)
l = mid + 1;
else
r = mid;
}
return l;
}
int cmp(node x, node y) { return x.p < y.p; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) scanf("%lld", &a[i].p);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].v);
t[i] = a[i].v;
}
sort(a + 1, a + n + 1, cmp);
sort(t + 1, t + n + 1);
k++;
for (int i = 2; i <= n; i++)
if (t[i] != t[i - 1]) t[++k] = t[i];
for (int i = 1; i <= n; i++) {
int w = find(a[i].v);
ans += a[i].p * f1.ask(w) - f2.ask(w);
f1.add(w, 1);
f2.add(w, a[i].p);
}
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double a[1002], b[1002];
int main() {
int n;
double m, cm;
cin >> n >> m;
cm = m;
for (int i = 1; i <= n; i++) {
cin >> a[i];
if (a[i] <= 1.0 + 1e-9) {
cout << "-1";
return 0;
}
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
if (b[i] <= 1.0 + 1e-9) {
cout << "-1";
return 0;
}
}
m = m / (b[1] - 1.0) + m;
for (int i = n; i > 1; i--) {
m = m / (b[i] - 1.0) + m;
m = m / (a[i] - 1.0) + m;
}
m = m / (a[1] - 1.0) + m;
printf("%.10lf", m - cm);
return 0;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.