solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
using ld = long double;
using ll = long long;
using ull = unsigned long long;
const ll mod = 1004535809, mod_g = 3;
const int N = int(1e5 + 10);
template <typename T>
inline T read() {
T x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
template <typename T>
inline T print(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) print(x / 10);
putchar(x % 10 + '0');
}
const ld pi = acos(-1.0);
struct Complex {
ld r, i;
Complex(ld _r = 0, ld _i = 0) : r(_r), i(_i) {}
};
Complex operator+(const Complex &a, const Complex &b) {
return Complex(a.r + b.r, a.i + b.i);
}
Complex operator-(const Complex &a, const Complex &b) {
return Complex(a.r - b.r, a.i - b.i);
}
Complex operator*(const Complex &a, const Complex &b) {
return Complex(a.r * b.r - a.i * b.i, a.r * b.i + a.i * b.r);
}
Complex operator/(const Complex &a, const Complex &b) {
return Complex((a.r * b.r + a.i * b.i) / (b.r * b.r + b.i * b.i),
(a.i * b.r - a.r * b.i) / (b.r * b.r + b.i * b.i));
}
int R[int(1e6 + 10000)];
Complex x[int(1e6 + 10000)], y[int(1e6 + 10000)];
void get_R(int lim) {
for (int i = 0; i < lim; i++) {
R[i] = (i & 1) * (lim >> 1) + (R[i >> 1] >> 1);
}
}
void FFT(Complex *f, int lim, int rev) {
for (int i = 0; i < lim; i++) {
if (i < R[i]) swap(f[i], f[R[i]]);
}
for (int mid = 1; mid < lim; mid <<= 1) {
Complex wn = Complex(cos(pi / mid), rev * sin(pi / mid));
for (int len = mid << 1, cur = 0; cur < lim; cur += len) {
Complex w = Complex(1, 0);
for (int k = 0; k < mid; k++, w = w * wn) {
Complex x = f[cur + k], y = w * f[cur + mid + k];
f[cur + k] = x + y, f[cur + mid + k] = x - y;
}
}
}
if (rev == -1) {
for (int i = 0; i < lim; i++) {
f[i].r /= lim;
}
}
}
ll quick_pow(ll ans, ll p, ll res = 1) {
for (; p; p >>= 1, ans = ans * ans % mod)
if (p & 1) res = res * ans % mod;
return res % mod;
}
ll ans[200010];
inline void solve() {
int n, X;
cin >> n >> X;
for (int i = 1; i <= n; ++i) {
int xx;
cin >> xx;
ans[i] = ans[i - 1] + (xx < X);
x[ans[i]].r++;
y[200000 - ans[i]].r++;
x[i].i = y[i].i = 0;
}
x[0].r++, y[200000].r++;
int lim = 1;
while (lim <= 400000) lim <<= 1;
get_R(lim);
FFT(x, lim, 1);
FFT(y, lim, 1);
for (int i = 0; i < lim; i++) x[i] = x[i] * y[i];
FFT(x, lim, -1);
cout << (ll(x[200000].r + 0.5) - n - 1) / 2;
for (int i = 1; i <= n; ++i) cout << ' ' << ll(x[200000 + i].r + 0.5);
cout << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){
string s;
cin >> s;
bool isE=false;
for(int i = 1;i < s.size();i ++){
if(s[i]==s[i-1]) {cout << i << " " << i+1 << endl;isE=1;break;}
if(i-1&&s[i]==s[i-2]) {cout << i-1 << " " << i+1 << endl;isE=1;break;}
}
if(!isE) cout << -1 << " " << -1 << endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n,r,l,a=0; cin>>n;
for(int i=0; i<n; i++){
cin>>r>>l; a+=l-r+1;
}
cout<<a;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long cnt, ina, sa, in, aaaa, aaaaa, a, b, c, d, e, f, g, h, i, j, k, l, m,
n, o, p, q, r, s, t, u, v, w, x, y, z, sum, maxi, maxj, mini, minj, ser,
res;
long long aa[100007], aaa[17], bb[17];
string s0, s1, s2, s3, s4, s5, s6, s7, s8, s9, s10;
char c1, c2, c3, c4, c5, c6, c7, c8, c9, c0;
long double d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, dd;
queue<long long> qu;
vector<long long> ve, ve2;
stack<long long> st;
set<string> se;
map<string, long long> ma;
int main() {
cin >> n >> s1;
for (i = 0; i <= n - 1; i++) {
if (s1[i] == 'n') a++;
if (s1[i] == 'z') b++;
}
for (i = 1; i <= a; i++) {
cout << 1 << ' ';
}
for (i = 1; i <= b; i++) {
cout << 0 << ' ';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t ;
while(t--)
{
long long int x, y ;
cin >> x >> y ;
cin.ignore();
string path ;
int flagx=0 , flagy =0 ;
getline(cin,path);
if (x<0) {
x = x*(-1) ;
if (count(path.begin(),path.end(),'L')>=x){
flagx = 1;
}
}
else if (x>=0){
if (count(path.begin(),path.end(),'R')>=x)
{
flagx = 1;
}
}
if (y<0) {
y = y*(-1) ;
if (count(path.begin(),path.end(),'D')>=y){
flagy = 1;
}
}
else if (y>=0){
if (count(path.begin(),path.end(),'U')>=y)
{
flagy = 1;
}
}
if (flagx && flagy) cout << "YES\n" ;
else cout << "NO\n" ;
}
return 0;
} | 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void swaper(T &a, T &b) {
T c = a;
a = b;
b = c;
}
template <class T>
T GCD(T a, T b) {
if (b == 0)
return a;
else
return GCD(b, a % b);
}
template <class T>
T MulMod(T a, T b, T mod) {
T x, y;
x = 0;
y = a;
while (b > 0) {
if (b & 1) x = (x + y) % mod;
y = (y << 1) % mod;
b >>= 1;
}
return x;
}
template <class T>
T PowMod(T a, T b, T mod) {
T x, y;
x = 1;
y = a;
while (b > 0) {
if (b & 1) x = (x * y) % mod;
y = (y * y) % mod;
b >>= 1;
}
return x;
}
template <class T>
T Multiply(T a, T b) {
T x, y;
x = 0;
y = a;
while (b > 0) {
if (b & 1) x = (x + y);
y = (y << 1);
b >>= 1;
}
return x;
}
template <class T>
T Power(T a, T b) {
T x, y;
x = 1;
y = a;
while (b > 0) {
if (b & 1) x = (x * y);
y = (y * y);
b >>= 1;
}
return x;
}
const int MAX = 1e6 + 10;
const long long int MOD7 = 1e9 + 7;
const long long int MOD9 = 1e9 + 9;
int main() {
long long int w1, h1, w2, h2;
cin >> w1 >> h1 >> w2 >> h2;
long long int sum = 2 * (h1 + h2 + 2) + 2 * w1;
cout << sum << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int N, K;
vector<int64_t> V[200000];
priority_queue<int64_t> Q;
priority_queue<int64_t, vector<int64_t>, greater<int64_t>> P, R;
priority_queue<pair<int64_t, int>> T;
vector<int> c_order;
bitset<200000> c_used;
int co = 0;
int64_t irregular = 0;
int64_t pick(){
if(irregular){
int64_t ret = irregular;
R.push(2*ret);
for(int i=2; i<V[c_order[co]].size(); i++) Q.push(V[c_order[co]][i]);
c_used[c_order[co]] = 1;
while(T.size() && c_used[T.top().second]) T.pop();
co++;
irregular = 0;
return ret;
}
int64_t a = (Q.size() ? Q.top() : 0);
int64_t b = (co < K ? V[c_order[co]][0] : 0);
if(a > b){
Q.pop();
P.push(a);
return a;
}else{
irregular = b;
return b;
}
}
int main(){
cin >> N >> K;
for(int i=0; i<N; i++){
int c, v;
cin >> c >> v;
V[c-1].push_back(2*v);
}
for(int c=0; c<K; c++){
sort(V[c].rbegin(), V[c].rend());
V[c][0] = V[c][1] = (V[c][0] + V[c][1]) / 2;
}
for(int i=0; i<K; i++) c_order.push_back(i);
sort(c_order.begin(), c_order.end(), [&](int a, int b){return V[a][0] > V[b][0];});
c_used[c_order[0]] = 1;
for(int c=0; c<K; c++) if(V[c].size() >= 3) T.push({V[c][0] + V[c][1] + V[c][2], c});
int64_t sum = 0;
for(int i=0; i<N; i++){
int64_t add = pick();
int64_t ans;
if(irregular){
ans = -2;
if(Q.size()) ans = max(ans, sum + Q.top());
if(P.size()) ans = max(ans, sum - P.top() + 2*add);
if(R.size() && T.size()) ans = max(ans, sum - R.top() + T.top().first);
}else{
ans = sum + add;
}
cout << ans/2 << endl;
sum += add;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
void solve()
{
int n;
cin >> n;
long long a[n];
for (auto &it : a) cin >> it;
sort(a, a + n);
long long ans = a[n - 1], pref_sum = a[0];
for (int i = 1; i < n; i++) {
ans += -1 * 1LL * (1LL * i * a[i] - pref_sum);
pref_sum += a[i];
}
cout << ans << "\n";
return;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
int t = 1;
cin >> t;
while (t--)
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
map<int, int> mmp;
map<int, int>::iterator it;
int main() {
long long ans = 1;
int n, m, x;
cin >> n >> m;
for (int i = 1; i <= m; i++) cin >> x, mmp[x]++;
if (n > m)
cout << 0 << endl;
else if (n == m)
cout << 1 << endl;
else {
for (int i = 2; i <= m / n; i++) {
int cnt = 0;
for (it = mmp.begin(); it != mmp.end(); it++) cnt = cnt + it->second / i;
if (cnt >= n) ans = i;
}
cout << ans << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC target( \
"fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
os << '{';
string sep;
for (const auto &x : v) os << sep << x, sep = ", ";
return os << '}';
}
template <typename T, size_t size>
ostream &operator<<(ostream &os, const array<T, size> &arr) {
os << '{';
string sep;
for (const auto &x : arr) os << sep << x, sep = ", ";
return os << '}';
}
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
return os << '(' << p.first << ", " << p.second << ')';
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << ' ' << H;
debug_out(T...);
}
long long dp[151][18][11][11];
vector<int> lim;
int n, k;
int get_dig(int delta) {
int res = 0;
while (delta) {
res += (delta % 10);
delta /= 10;
}
return res;
}
long long solve(int p, int s, int p1, int p2, bool tight) {
if (s * k > 315) return 0;
if (s > 150) return 0;
if (p < 0) {
p2 = (p2 == 10 ? 0 : p2);
p1 = (p1 == 10 ? 0 : p1);
int total_sum = s * k - p2 * k - p1 * k;
int cur = p1 * 10 + p2;
for (int i = 0; i < k; i++) {
total_sum += get_dig(cur);
++cur;
}
return (total_sum == n);
}
if (tight && ~dp[s][p][p1][p2]) return dp[s][p][p1][p2];
long long res = 0;
for (int i = 0; i <= (tight ? 9 : lim[p]); i++) {
res += solve(p - 1, s + i, p2, i, tight | (i < lim[p]));
}
return (tight ? dp[s][p][p1][p2] = res : res);
}
long long get_solve(long long delta) {
lim.clear();
while (delta) {
lim.emplace_back(delta % 10);
delta /= 10;
}
return solve((int)lim.size() - 1, 0, 10, 10, false);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int t;
cin >> t;
while (t--) {
memset(dp, -1, sizeof(dp));
cin >> n >> k;
++k;
long long lo = 0, hi = 1e18;
while (lo < hi) {
long long mid = lo + (hi - lo) / 2;
if (get_solve(mid))
hi = mid;
else
lo = mid + 1;
}
cout << (hi >= 1e18 ? -1 : hi) << '\n';
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using lint = long long int;
using pint = pair<int, int>;
using plint = pair<lint, lint>;
struct fast_ios {
fast_ios() {
cin.tie(0);
ios::sync_with_stdio(false);
cout << fixed << setprecision(20);
};
} fast_ios_;
template <typename T>
void ndarray(vector<T> &vec, int len) {
vec.resize(len);
}
template <typename T, typename... Args>
void ndarray(vector<T> &vec, int len, Args... args) {
vec.resize(len);
for (auto &v : vec) ndarray(v, args...);
}
template <typename T>
bool mmax(T &m, const T q) {
if (m < q) {
m = q;
return true;
} else
return false;
}
template <typename T>
bool mmin(T &m, const T q) {
if (m > q) {
m = q;
return true;
} else
return false;
}
template <typename T1, typename T2>
pair<T1, T2> operator+(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first + r.first, l.second + r.second);
}
template <typename T1, typename T2>
pair<T1, T2> operator-(const pair<T1, T2> &l, const pair<T1, T2> &r) {
return make_pair(l.first - r.first, l.second - r.second);
}
template <typename T>
istream &operator>>(istream &is, vector<T> &vec) {
for (auto &v : vec) is >> v;
return is;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (auto v : vec) os << v << ",";
os << "]";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "deq[";
for (auto v : vec) os << v << ",";
os << "]";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const set<T> &vec) {
os << "{";
for (auto v : vec) os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_set<T> &vec) {
os << "{";
for (auto v : vec) os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &vec) {
os << "{";
for (auto v : vec) os << v << ",";
os << "}";
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const unordered_multiset<T> &vec) {
os << "{";
for (auto v : vec) os << v << ",";
os << "}";
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &pa) {
os << "(" << pa.first << "," << pa.second << ")";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const map<TK, TV> &mp) {
os << "{";
for (auto v : mp) os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
template <typename TK, typename TV>
ostream &operator<<(ostream &os, const unordered_map<TK, TV> &mp) {
os << "{";
for (auto v : mp) os << v.first << "=>" << v.second << ",";
os << "}";
return os;
}
constexpr lint MOD = 1000000007;
lint N, T;
vector<lint> fac, facInv, inv;
void facInit(int nmax) {
fac = facInv = inv = vector<lint>(nmax + 1, 1);
for (int i = 2; i <= nmax; i++) {
fac[i] = fac[i - 1] * i % MOD;
inv[i] = MOD - inv[MOD % i] * (MOD / i) % MOD;
facInv[i] = facInv[i - 1] * inv[i] % MOD;
}
}
lint nCr(int n, int r) {
if (n < r || r < 0) return 0;
if (n >= (int)fac.size()) facInit(n);
return (fac[n] * facInv[r] % MOD) * facInv[n - r] % MOD;
}
lint nPr(int n, int r) {
if (n < r || r < 0) return 0;
if (n >= (int)fac.size()) facInit(n);
return fac[n] * facInv[n - r] % MOD;
}
lint power(lint x, lint n, lint mod = MOD) {
lint ans = 1;
while (n > 0) {
if (n & 1) (ans *= x) %= mod;
(x *= x) %= mod;
n >>= 1;
}
return ans;
}
lint extgcd(lint a, lint b, lint &x, lint &y) {
lint d = a;
if (b != 0)
d = extgcd(b, a % b, y, x), y -= (a / b) * x;
else
x = 1, y = 0;
return d;
}
lint mod_inverse(lint a, lint m = MOD) {
lint x, y;
extgcd(a, m, x, y);
return (m + x % m) % m;
}
int main() {
cin >> N >> T;
vector<lint> t(N);
for (int i = (0), i_end_ = (N); i < i_end_; i++) cin >> t[i];
t.push_back(300000000000000LL);
N++;
facInit(N);
lint ret = 0;
lint acc_time = 0;
int i = 0;
lint prb = 0;
while (i < N and acc_time < T) acc_time += t[i], i++;
for (; i > 0; i--) {
if (acc_time + i <= T)
prb = 1;
else if (acc_time > T)
prb = 0;
else {
lint d = T - acc_time;
lint mip = mod_inverse(power(2, i + 1));
for (int j = (max<lint>(0, d - t[i] + 1)), j_end_ = (d + 1); j < j_end_;
j++)
prb += nCr(i, j) * mip % MOD;
for (int j = (max<lint>(0, d - (t[i] + 1) + 1)), j_end_ = (d + 1);
j < j_end_; j++)
prb += nCr(i, j) * mip % MOD;
}
acc_time -= t[i - 1];
ret += prb;
}
cout << ret % MOD << endl;
}
| 6 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
const int inf = 1e5 + 5;
const int MAXM = 1e5 + 5;
const int MAXN = 2e5 + 4;
long long s;
bool cal(long long x) {
long long xx = x, cnt = 0;
while (xx) {
cnt += (xx % 10);
xx /= 10;
}
return (x - cnt) >= s;
}
int main() {
long long n, i, j, k;
cin >> n >> s;
long long lo = s, hi = n, ret = -1;
while (lo <= hi) {
long long mid = lo + (hi - lo + 1) / 2;
if (cal(mid)) {
ret = mid;
hi = mid - 1;
} else {
lo = mid + 1;
}
}
if (ret == -1) {
cout << 0 << endl;
} else {
cout << n - ret + 1 << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int n, m;
int mat[110][10010];
char str[10010];
queue<int> que;
void bfs(int r) {
int cur, nxt;
while (!que.empty()) {
cur = que.front();
que.pop();
nxt = cur + 1;
if (nxt > m) nxt = 1;
if (mat[r][nxt] == -1) {
que.push(nxt);
mat[r][nxt] = mat[r][cur] + 1;
}
nxt = cur - 1;
if (nxt < 1) nxt = m;
if (mat[r][nxt] == -1) {
que.push(nxt);
mat[r][nxt] = mat[r][cur] + 1;
}
}
}
int main() {
while (scanf("%d %d", &n, &m) != EOF) {
for (int i = 1; i <= n; i++) {
while (!que.empty()) que.pop();
scanf("%s", str + 1);
for (int j = 1; j <= m; j++) {
if (str[j] == '1') {
que.push(j);
mat[i][j] = 0;
} else
mat[i][j] = -1;
}
if (!que.empty()) bfs(i);
}
int ans = inf;
bool flag = true;
for (int i = 1; i <= m && flag; i++) {
int sum = 0;
for (int j = 1; j <= n; j++) {
sum += mat[j][i];
if (mat[j][i] == -1) {
flag = false;
break;
}
}
ans = min(ans, sum);
}
if (flag)
printf("%d\n", ans);
else
puts("-1");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
long long dr[800000];
long long pr[800000];
long long sf[800000];
long long w[800000];
long long a[800000];
void bl(long long v, long long l, long long r) {
if (r == l + 1) {
dr[v] = w[l];
pr[v] = 0;
sf[v] = 0;
return;
}
bl(2 * v + 1, l, (l + r) / 2);
bl(2 * v + 2, (l + r) / 2, r);
dr[v] = dr[2 * v + 1] + dr[2 * v + 2];
pr[v] = pr[2 * v + 1] + pr[2 * v + 2] +
(a[r - 1] - (r - (l + r) / 2) - a[(r + l) / 2 - 1]) *
(dr[2 * v + 1] % MOD);
sf[v] = sf[2 * v + 1] + sf[2 * v + 2] +
(a[(r + l) / 2] - a[l] - ((r + l) / 2 - l)) * (dr[2 * v + 2] % MOD);
sf[v] %= MOD;
pr[v] %= MOD;
}
void ch(long long v, long long l, long long r, long long id, long long x) {
if (r == l + 1 && l == id) {
dr[v] = x;
pr[v] = 0;
sf[v] = 0;
return;
}
if (r <= id || l > id) {
return;
}
ch(2 * v + 1, l, (l + r) / 2, id, x);
ch(2 * v + 2, (l + r) / 2, r, id, x);
dr[v] = dr[2 * v + 1] + dr[2 * v + 2];
pr[v] = pr[2 * v + 1] + pr[2 * v + 2] +
(a[r - 1] - (r - (l + r) / 2) - a[(r + l) / 2 - 1]) *
(dr[2 * v + 1] % MOD);
sf[v] = sf[2 * v + 1] + sf[2 * v + 2] +
(a[(r + l) / 2] - a[l] - ((r + l) / 2 - l)) * (dr[2 * v + 2] % MOD);
sf[v] %= MOD;
pr[v] %= MOD;
}
long long sm(long long v, long long l, long long r, long long ln,
long long rn) {
if (ln >= r || rn <= l) {
return 0;
}
if (ln <= l && r <= rn) {
return dr[v];
}
return sm(2 * v + 1, l, (l + r) / 2, ln, rn) +
sm(2 * v + 2, (l + r) / 2, r, ln, rn);
}
pair<long long, long long> indd(long long v, long long l, long long r,
long long k, long long ln, long long rn) {
if (ln >= r || rn <= l) {
return {0, -1};
}
if (l == r - 1) {
return {dr[v], l};
}
if (ln <= l && r <= rn) {
if (dr[v] < k) return {dr[v], r};
}
pair<long long, long long> cr =
indd(2 * v + 1, l, (l + r) / 2, k, ln, min(rn, (l + r) / 2));
if (cr.first < k) {
pair<long long, long long> cr2 =
indd(2 * v + 2, (l + r) / 2, r, k - cr.first, max(ln, (l + r) / 2), rn);
return {cr2.first + cr.first, cr2.second};
} else {
return cr;
}
}
long long prr(long long v, long long l, long long r, long long ln,
long long k) {
if (ln >= r || k <= l) {
return 0;
}
if (ln <= l && r <= k) {
return (pr[v] + (a[k - 1] - (k - r) - a[r - 1]) * (dr[v] % MOD)) % MOD;
}
return (prr(2 * v + 1, l, (l + r) / 2, ln, k) +
prr(2 * v + 2, (l + r) / 2, r, ln, k)) %
MOD;
}
long long sff(long long v, long long l, long long r, long long k,
long long rn) {
if (k >= r || rn <= l) {
return 0;
}
if (k <= l && r <= rn) {
return (sf[v] + (a[l] - a[k] - (l - k)) * (dr[v] % MOD)) % MOD;
}
return (sff(2 * v + 1, l, (l + r) / 2, k, rn) +
sff(2 * v + 2, (l + r) / 2, r, k, rn)) %
MOD;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, q;
cin >> n >> q;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> w[i];
}
bl(0, 0, n);
for (int i = 0; i < q; i++) {
long long x, y;
cin >> x >> y;
if (x < 0) {
ch(0, 0, n, -x - 1, y);
} else {
x--;
long long aaa = (sm(0, 0, n, x, y) + 1) / 2;
long long L = indd(0, 0, n, aaa, x, y).second;
cout << (prr(0, 0, n, x, L + 1) + sff(0, 0, n, L, y)) % MOD << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string vow = "aeiou";
const int dxhorse[] = {-2, -2, -1, -1, 1, 1, 2, 2};
const int dyhorse[] = {1, -1, 2, -2, 2, -2, 1, -1};
const int dx[] = {-1, 0, 0, 1};
const int dy[] = {0, -1, 1, 0};
const long double pie = 3.14159265358979;
const long long mod = 1e9 + 7;
void bad() {
cout << "===";
exit(0);
}
void solve(int test_case) {
int n;
cin >> n;
if (n % 4) bad();
string s;
cin >> s;
map<char, int> h;
string temp = "AGTC";
int reqd = n >> 2;
for (auto i : temp) h[i] = reqd;
for (auto i : s) {
if (i == '?') continue;
;
h[i]--;
if (h[i] < 0) bad();
}
for (auto i : s) {
if (i != '?')
cout << i;
else {
for (auto j : h) {
if (j.second > 0) {
cout << j.first;
h[j.first]--;
break;
}
}
}
}
}
int main() {
int t = 1;
for (int i = 0; i < t; i++) solve(i);
return 0;
}
| 2 |
#include<cmath>
#include<cstdio>
using namespace std;
inline int read()
{
int x = 0, f = 1; char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar()) if (ch == '-') f = -1;
for (; ch >= '0' && ch <= '9'; ch = getchar()) x = (x << 1) + (x << 3) + ch - '0';
return x * f;
}
const double pi = acos(-1.0);
const int N = 3e3 + 5;
double t[N];
int main()
{
int n = read();
int L = read();
for (int i = 1; i <= n; ++i) t[i] = read();
double ansx = 0.0;
double ansy = 0.0;
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j)
{
double ang = 1.0 * (t[i] + t[j]) * pi / L;
double x = cos(ang);
double y = sin(ang);
ansx += x * (n - 2 * (j - i));
ansy += y * (n - 2 * (j - i));
}
long long m = 1LL * n * (n - 1) * (n - 2) / 6;
printf("%.12f %.12f\n", ansx / m, ansy / m);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
long long a[1011][1011] = {}, p;
long long sx[1011] = {}, sy[1011] = {};
long long heap[2011] = {}, num = 0;
long long prx[1000011] = {}, pry[1000011] = {};
void heap_add(long long x) {
heap[++num] = x;
long long i = num;
while (i > 1) {
if (heap[i] > heap[i / 2])
swap(heap[i], heap[i / 2]);
else
break;
i = i / 2;
}
}
long long heap_pop() {
long long tem = heap[1];
heap[1] = heap[num];
num--;
long long i = 1;
while (i * 2 <= num) {
i = i * 2;
if (i < num && heap[i] < heap[i + 1]) i++;
if (heap[i] > heap[i / 2])
swap(heap[i], heap[i / 2]);
else
break;
}
return tem;
}
void get() {
long long tem;
num = 0;
for (long long i = 1; i <= n; i++) heap_add(sx[i]);
for (long long i = 1; i <= k; i++) {
tem = heap_pop();
prx[i] = prx[i - 1] + tem;
heap_add(tem - p * m);
}
num = 0;
for (long long i = 1; i <= m; i++) heap_add(sy[i]);
for (long long i = 1; i <= k; i++) {
tem = heap_pop();
pry[i] = pry[i - 1] + tem;
heap_add(tem - p * n);
}
}
void init() {
scanf("%I64d%I64d%I64d%I64d", &n, &m, &k, &p);
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) scanf("%I64d", &a[i][j]);
for (long long i = 1; i <= n; i++)
for (long long j = 1; j <= m; j++) {
sx[i] += a[i][j];
sy[j] += a[i][j];
}
get();
long long ans = -1000000000000000ll;
for (long long i = 0; i <= k; i++) {
ans = max(ans, prx[i] + pry[k - i] - (long long)i * (k - i) * p);
}
printf("%I64d", ans);
}
int main() {
init();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, ans, t, pn, cnt;
long long a[200010], s[500050], num[1000010];
bool vis[200010];
void find_(long long n) {
pn = 0;
for (long long i = 2; i * i <= n; ++i) {
if (n % i == 0) {
s[pn++] = i;
while (n % i == 0) n /= i;
}
}
if (n != 1) s[pn++] = n;
}
long long ins() {
long long ret = 0;
for (long long i = 1; i < (1 << pn); ++i) {
long long mul = 1, c = 0;
for (int j = 0; j < pn; ++j)
if ((1 << j) & i) {
mul *= s[j];
++c;
}
if (c % 2 == 0)
ret -= num[mul];
else
ret += num[mul];
++num[mul];
}
ans += cnt - ret;
cnt++;
return ans;
}
long long era() {
long long ret = 0;
for (long long i = 1; i < (1 << pn); ++i) {
long long mul = 1, c = 0;
for (int j = 0; j < pn; ++j)
if ((1 << j) & i) {
mul *= s[j];
++c;
}
--num[mul];
if (c % 2 == 0)
ret -= num[mul];
else
ret += num[mul];
}
--cnt;
ans -= cnt - ret;
return ans;
}
int main() {
scanf("%I64d%I64d", &n, &t);
for (int i = 1; i <= n; ++i) scanf("%I64d", &a[i]);
while (t--) {
long long k;
scanf("%I64d", &k);
find_(a[k]);
if (!vis[k]) {
vis[k] = 1;
printf("%I64d\n", ins());
} else {
vis[k] = 0;
printf("%I64d\n", era());
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void fastIO() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
}
void solve() {
long long int l, r, d;
cin >> l >> r >> d;
if (d < l) {
cout << d << "\n";
return;
} else {
long long int rem = r % d;
rem = d - rem;
cout << r + rem << "\n";
return;
}
return;
}
int main() {
fastIO();
int q;
cin >> q;
while (q--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
int a[n], i;
for (i = 0; i < n; i++) {
cin >> a[i];
}
int l[n], r[n], ans = INT_MIN;
l[0] = 1;
r[n - 1] = 1;
for (i = 1; i < n; i++) {
if (a[i] > a[i - 1]) {
l[i] = l[i - 1] + 1;
} else {
l[i] = 1;
}
ans = max(ans, l[i]);
}
for (i = n - 2; i >= 0; i--) {
if (a[i] < a[i + 1]) {
r[i] = 1 + r[i + 1];
} else {
r[i] = 1;
}
}
for (i = 1; i < n - 1; i++) {
if (a[i + 1] > a[i - 1]) {
ans = max(ans, l[i - 1] + r[i + 1]);
}
}
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int a[100005];
int b[100005];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
b[i] = a[i];
}
sort(b + 1, b + 1 + n);
int ans = 0;
for (int i = 1; i <= n; i++) {
if (a[i] != b[i]) ans++;
}
if (ans == 0 || ans == 2)
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 10;
const double EPS = 1e-9;
const long long MOD = 1000 * 1000 * 1000 + 7;
int n, m;
void swap_columns(vector<vector<int> > &v, int a, int b) {
for (int i = 0; i < v.size(); ++i) {
swap(v[i][a], v[i][b]);
}
}
bool is_ok(vector<int> &a) {
for (int i = 0; i < a.size(); ++i) {
if (a[i] != i + 1) return false;
}
return true;
}
bool possible_sort(vector<vector<int> > &v, int a, int b) {
bool good = true;
for (int i = 0; i < v.size(); ++i) {
bool any = false;
auto tmp = v[i];
for (int i1 = 0; i1 < m; ++i1) {
for (int j1 = i1 + 1; j1 < m; ++j1) {
tmp = v[i];
swap(tmp[i1], tmp[j1]);
if (a != -1) swap(tmp[a], tmp[b]);
any |= is_ok(tmp);
tmp = v[i];
if (a != -1) swap(tmp[a], tmp[b]);
swap(tmp[i1], tmp[j1]);
any |= is_ok(tmp);
}
}
tmp = v[i];
if (a != -1) {
swap(tmp[a], tmp[b]);
any |= is_ok(tmp);
} else {
any |= is_ok(tmp);
}
if (!any) return false;
}
return true;
}
int main(int argc, char *argv[]) {
ios::sync_with_stdio(0);
cin >> n >> m;
vector<vector<int> > a(n, vector<int>(m));
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) cin >> a[i][j];
for (int i = 0; i < m; ++i) {
for (int j = i + 1; j < m; ++j) {
if (possible_sort(a, i, j)) {
cout << "YES";
return 0;
}
}
}
if (possible_sort(a, -1, -1)) {
cout << "YES";
return 0;
}
cout << "NO";
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
struct segmentTree {
int n = 0;
vector<long long> t;
vector<long long> lazy;
void build(int len) {
n = len + 1;
t.resize(len * 4);
lazy.resize(len * 4);
}
void push(int p, int l, int r) {
if (!lazy[p]) return;
if (l != r) lazy[p << 1] += lazy[p], lazy[p << 1 | 1] += lazy[p];
t[p] += lazy[p] * (r - l + 1);
lazy[p] = 0;
}
int ql, qr;
void update(long long val) { update(val, 1, 0, n - 1); }
void update(long long val, int p, int l, int r) {
push(p, l, r);
if (l > r || r < ql || l > qr) return;
if (l >= ql && r <= qr) {
lazy[p] += val;
push(p, l, r);
return;
}
update(val, p << 1, l, ((l + r) >> 1));
update(val, p << 1 | 1, ((l + r) >> 1) + 1, r);
t[p] = t[p << 1] + t[p << 1 | 1];
}
long long query() { return query(1, 0, n - 1); }
long long query(int p, int l, int r) {
push(p, l, r);
if (l > r || r < ql || l > qr) return 0;
if (l >= ql && r <= qr) return t[p];
return query(p << 1, l, ((l + r) >> 1)) +
query(p << 1 | 1, ((l + r) >> 1) + 1, r);
}
} every_one;
vector<int> adj[N];
void dfs(vector<int>& p, int v, int par) {
p.push_back(v);
for (auto u : adj[v])
if (u != par) {
dfs(p, u, v);
}
}
vector<int> branches[N];
long long root_num;
pair<int, int> node_place[N];
int main() {
int n, q;
scanf("%d %d", &n, &q);
every_one.build(n);
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d %d", &x, &y);
x--, y--;
adj[x].push_back(y);
adj[y].push_back(x);
}
int branch_count = 0;
for (auto x : adj[0]) {
dfs(branches[branch_count++], x, 0);
}
for (int b = 0; b < branch_count; b++) {
for (int i = 0; i < (int)branches[b].size(); i++) {
node_place[branches[b][i]] = {b, i};
}
}
vector<segmentTree> st(branch_count);
for (int i = 0; i < branch_count; i++) {
st[i].build(branches[i].size());
}
while (q--) {
int t;
scanf("%d", &t);
if (t == 0) {
int v, x, d;
scanf("%d %d %d", &v, &x, &d);
v--;
if (!v) {
root_num += x;
if (d) {
every_one.ql = 0;
every_one.qr = d - 1;
every_one.update(x);
}
continue;
}
int b = node_place[v].first;
int idx = node_place[v].second;
int l = max(0, idx - d);
int r = min(int(branches[b].size()) - 1, idx + d);
st[b].ql = l, st[b].qr = r;
st[b].update(x);
if (idx < d) {
root_num += x;
if (idx + 1 < d) {
int new_r = d - idx - 2;
every_one.ql = 0;
every_one.qr = new_r;
every_one.update(x);
st[b].ql = 0;
st[b].qr = min(st[b].n - 1, new_r);
st[b].update(-x);
}
}
} else {
int v;
scanf("%d", &v);
v--;
if (!v) {
printf("%I64d\n", root_num);
continue;
}
int b = node_place[v].first;
int idx = node_place[v].second;
st[b].ql = st[b].qr = every_one.ql = every_one.qr = idx;
long long ans = st[b].query();
long long added = every_one.query();
ans += added;
printf("%I64d\n", ans);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
int a, b, c;
int m[105][105];
int main() {
scanf("%d%d%d", &a, &b, &c);
for (int i = 0; i < a; i++)
for (int j = 0; j < b; j++) scanf("%d", &m[i][j]);
bool locked[105];
int used[105];
int out[105];
memset(locked, false, sizeof locked);
memset(out, 0, sizeof out);
for (int i = 0; i < b; i++) {
memset(used, 0, sizeof used);
for (int j = 0; j < a; j++)
if (!out[j] && m[j][i] != 0) used[m[j][i]]++;
for (int j = 0; j < a; j++)
if (!out[j] && m[j][i] != 0) {
if (used[m[j][i]] >= 2 || locked[m[j][i]]) {
locked[m[j][i]] = true;
out[j] = i + 1;
}
}
}
for (int i = 0; i < a; i++) printf("%d\n", out[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long ans[200050];
pair<long long, long long> A[200050];
queue<long long> q;
int n, s;
int main() {
scanf("%d%d", &n, &s);
long long free = 0;
for (int i = 0; i < n; ++i) {
scanf("%I64d %I64d", &A[i].first, &A[i].second);
if (A[i].first < free) {
if (q.size() == s)
ans[i] = -1;
else
q.push(i);
} else {
while (!q.empty() and free <= A[i].first) {
int temp = q.front();
q.pop();
free = max(free, A[temp].first) + A[temp].second;
ans[temp] = free;
}
assert(q.size() < s);
q.push(i);
}
}
assert(q.size() <= s);
while (!q.empty()) {
int temp = q.front();
q.pop();
free = max(free, A[temp].first) + A[temp].second;
ans[temp] = free;
}
for (int i = 0; i < n; ++i) printf("%I64d ", ans[i]);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) {
int x, y, z;
cin >> x >> y >> z;
if (x == y && y >= z) {
cout << "YES\n";
cout << x << " " << z << " " << z << "\n";
} else if (x == z && y <= x) {
cout << "YES\n";
cout << y << " " << x << " " << y << "\n";
} else if (y == z && x <= y) {
cout << "YES\n";
cout << x << " " << x << " " << z << "\n";
} else
cout << "NO\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, k, l;
int a[2000005], z[2000005];
long double d[2000005];
int resi() {
for (int i = 0; i < 2 * n; i++) z[i + 1] = z[i] + a[i];
long double lo = 1e-7, hi = l + 1;
int steps = 50, sol = 0;
while (steps--) {
long double mid = (lo + hi) / 2;
for (int i = l; i <= 2 * n; i++)
d[i] = max(d[i - 1], d[i - l] + (z[i] - z[i - l]) - mid);
int tkn = 0;
for (int i = 2 * n; i >= 1;) {
if (d[i] == d[i - 1]) {
i--;
} else {
i -= l;
tkn++;
}
}
if (tkn <= k) {
hi = mid;
} else {
lo = mid;
}
if (steps < 2) sol = max(sol, (int)round(d[2 * n] + k * mid));
}
return z[2 * n] - sol;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
cerr.tie(nullptr);
cin >> n >> k >> l;
string s;
cin >> s;
for (int i = 0; i < n; i++) a[i] = !!isupper(s[i]);
int sol1 = resi();
cerr << "upper = " << sol1 << '\n';
for (int i = 0; i < n; i++) a[i] = 1 - a[i];
int sol2 = resi();
cerr << "lower = " << sol2 << '\n';
cout << min(sol1, sol2) << '\n';
}
| 6 |
#include<bits/stdc++.h>
long long a[4] = {1};
char s[100005];
int main(){
scanf("%s", s);
for(char c:s) for(int j = 3; j >= 0; j--)
a[j] = (a[j]*(c-'?'?1:3) + (j&&!(c-'?'&&c-'A'-j+1)?a[j-1]:0))%1000000007;
printf("%lld\n", a[3]);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, j;
int a[101];
int ans, k;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
ans = 0;
for (i = 0; i < n; i++) {
k = 0;
for (j = i; j < n; j++) {
k ^= a[j];
ans = max(k, ans);
}
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
double c, d, e, f, r, v, g, h, i, j, k, l, m, n, o, p, q, t, x, y, z;
long long int mn = 8675435789, mx = -8675868757, md = 1000000007, aa = 0,
bb = 0, cc = 0;
string s, u, w;
long long int a[250002], b[250002];
map<long long int, long long int> mp, mq;
queue<long long int> qu, qe;
pair<long long int, long long int> pp[30030];
set<string> se, sa;
int main() {
{
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
cin >> d >> h >> v >> e;
r = d / 2.0;
p = 3.14159265359 * r * r * h;
x = 3.14159265359 * r * r * e;
n = v - x;
if (n <= 0) {
cout << "NO" << endl;
return 0;
}
cout << "YES" << endl;
y = p / n;
cout << fixed << setprecision(12) << y;
}
| 1 |
#include <bits/stdc++.h>
const int N = 2e5 + 10, Mod = 998244353;
namespace Fast_IO {
const int bufsize = 1 << 22;
inline char Getchar() {
static char buf[bufsize], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, bufsize, stdin), p1 == p2)
? EOF
: *p1++;
}
template <typename T = int>
inline T read() {
T x = 0, f = 0;
char ch = Getchar();
while (!isdigit(ch)) f |= ch == '-', ch = Getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = Getchar();
return f ? -x : x;
}
char Buf[bufsize], *fout = Buf;
inline void flush() { fwrite(Buf, 1, fout - Buf, stdout), fflush(stdout); }
inline void print(char *s) {
while (*s) *fout++ = *s++;
}
inline void print(char c) { *fout++ = c; }
template <typename T>
inline void Write(T u) {
u > 9 ? Write(u / 10), *fout++ = u % 10 + '0' : *fout++ = u + '0';
}
template <typename T>
inline void write(T u, char ch = ' ') {
if (u < 0) print('-'), u = -u;
Write(u), print(ch);
}
} // namespace Fast_IO
using namespace Fast_IO;
int tot = 1, fir[N], nex[N << 1], got[N << 1];
int idx = 0, par[N], dep[N], siz[N], son[N], top[N], dfn[N], tag[N];
inline int Pow(int a, int b) {
int res = 1;
for (; b; b >>= 1, a = 1LL * a * a % Mod)
if (b & 1) res = 1LL * res * a % Mod;
return res;
}
inline void AddEdge(int u, int v) {
nex[++tot] = fir[u], fir[u] = tot, got[tot] = v;
nex[++tot] = fir[v], fir[v] = tot, got[tot] = u;
}
inline void dfs(int u, int fa) {
dep[u] = dep[par[u] = fa] + 1, siz[u] = 1;
for (int i = fir[u]; i; i = nex[i])
if (got[i] != fa) {
dfs(got[i], u), siz[u] += siz[got[i]];
if (siz[got[i]] > siz[son[u]]) son[u] = got[i];
}
}
inline void Dfs(int u, int fa) {
dfn[u] = ++idx, top[u] = u == son[fa] ? top[fa] : u;
if (son[u]) Dfs(son[u], u);
for (int i = fir[u]; i; i = nex[i])
if (got[i] != fa && got[i] != son[u]) Dfs(got[i], u);
}
struct BIT {
int f[N];
inline void Add(int u, int dat) {
for (; u < N; u += ((u) & (-u))) (f[u] += dat) %= Mod;
}
inline int Ask(int u) {
int res = 0;
for (; u; u -= ((u) & (-u))) (res += f[u]) %= Mod;
return res;
}
inline int Ask(int l, int r) { return (Ask(r) - Ask(l - 1) + Mod) % Mod; }
} T;
int main() {
int n = read(), q = read(), invn = Pow(n, Mod - 2);
for (int i = 1; i < n; ++i) AddEdge(read(), read());
dfs(1, 0), Dfs(1, 0);
for (int Q = 1; Q <= q; ++Q) {
int opt = read(), u = read();
if (opt == 1) {
int d = read();
T.Add(1, 1LL * d * siz[u] % Mod);
if (u != 1) T.Add(dfn[u], 1LL * d * (n - siz[u]) % Mod);
if (son[u]) T.Add(dfn[son[u]], 1LL * d * (Mod - siz[son[u]]) % Mod);
(tag[u] += d) %= Mod;
} else {
int ans = 0;
for (int fu = top[u]; fu != 1; fu = top[u = par[fu]])
(ans += T.Ask(dfn[fu], dfn[u])) %= Mod,
(ans += 1LL * tag[par[fu]] * (Mod - siz[fu]) % Mod) %= Mod;
write(1LL * (ans + T.Ask(dfn[u])) * invn % Mod, '\n');
}
}
return flush(), 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
double d, h, v, e;
cin >> d >> h >> v >> e;
double decrease = v / ((d / 2) * (d / 2) * acos(-1));
double add = e;
if (decrease > add) {
cout << "YES" << endl;
printf("%.12f\n", h / (decrease - add));
} else {
cout << "NO" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef pair<int, int> pi;
int n, a[100005], b[100005];
int hs[100005], he[100005];
int main(){
cin >> n;
for(int i=1; i<=n; i++) scanf("%d",&a[i]);
for(int i=1; i<=n; i++) scanf("%d",&b[i]);
for(int i=1; i<=n; i++){
if(a[i] != a[i-1]){
hs[i] = he[i] = a[i];
}
else{
hs[i] = 1;
he[i] = a[i];
}
}
for(int i=n; i; i--){
if(b[i] != b[i+1]){
if(max(hs[i], b[i]) > min(he[i], b[i])){
puts("0");
return 0;
}
hs[i] = he[i] = b[i];
}
else{
he[i] = min(he[i], b[i]);
}
}
lint ret = 1;
for(int i=1; i<=n; i++){
if(hs[i] > he[i]) ret = 0;
ret *= he[i] - hs[i] + 1;
ret %= 1000000007;
}
cout << ret;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, p1, p2;
};
bool vis[100010];
int dp[100010][2][2][2];
vector<edge> G[100010];
const int md = 1e9 + 7;
int con[100010][2];
void add(int &x, int y) {
x += y;
if (x >= md) x -= md;
}
void dfs(int x) {
vis[x] = true;
bool f = false;
for (int i = 0; i < G[x].size(); i++) {
int y = G[x][i].to, p1 = G[x][i].p1, p2 = G[x][i].p2;
if (vis[y]) continue;
f = true;
dfs(y);
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
for (int l = 0; l < 2; l++) {
for (int m = 0; m < 2; m++) {
add(dp[x][j][l][m ^ ((p1 ^ j) | (p2 ^ k)) ^ con[x][j]],
dp[y][k][l][m]);
}
}
}
}
}
if (!f) dp[x][0][0][con[x][0]] = dp[x][1][1][con[x][1]] = 1;
}
int N, M;
int ans[2], tmp[2];
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; i++) {
int k;
scanf("%d", &k);
if (k == 1) {
int x;
scanf("%d", &x);
if (x < 0)
con[-x][0] ^= 1;
else
con[x][1] ^= 1;
} else {
int x, y;
int p1 = 0, p2 = 0;
scanf("%d%d", &x, &y);
if (x < 0) x = -x, p1 = 1;
if (y < 0) y = -y, p2 = 1;
G[x].push_back((edge){y, p1, p2});
G[y].push_back((edge){x, p2, p1});
}
}
ans[0] = 1;
for (int i = 1; i <= M; i++) {
if (vis[i]) continue;
if (G[i].size() <= 1) {
dfs(i);
tmp[0] = ans[0];
tmp[1] = ans[1];
ans[0] = ans[1] = 0;
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
for (int l = 0; l < 2; l++) {
for (int m = 0; m < 2; m++) {
add(ans[j ^ k], 1LL * tmp[j] * dp[i][l][m][k] % md);
}
}
}
}
}
}
for (int i = 1; i <= M; i++) {
if (vis[i]) continue;
dfs(i);
tmp[0] = ans[0];
tmp[1] = ans[1];
ans[0] = ans[1] = 0;
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
for (int l = 0; l < 2; l++) {
for (int m = 0; m < 2; m++) {
add(ans[j ^ k ^ ((G[i][1].p1 ^ l) | (G[i][1].p2 ^ m))],
1LL * tmp[j] * dp[i][l][m][k] % md);
}
}
}
}
}
printf("%d", ans[1]);
}
| 3 |
#include<iostream>
#include<vector>
#include<map>
#include<queue>
#include<algorithm>
using namespace std;
const int N = 13;
const vector<vector<int>> NEXT = {
{2},
{2, 5},
{0, 1, 3, 6},
{2, 7},
{5},
{1, 4, 6, 9},
{2, 5, 7, 10},
{3, 6, 8, 11},
{7},
{5, 10},
{6, 9, 11, 12},
{7, 10},
{10},
};
class Node {
public:
vector<int> puzzle;
int depth;
Node(const vector<int>& p, int d) :puzzle(p), depth(d) {}
};
map<vector<int>, int> memo1;
map<vector<int>, int> memo2;
void bfs(const vector<int>& puzzle, map<vector<int>, int>& memo) {
queue<Node> q;
q.push(Node(puzzle, 0));
while(!q.empty()) {
Node current(q.front()); q.pop();
if(current.depth > 10) continue;
if(memo.count(current.puzzle)) continue;
memo[current.puzzle] = current.depth;
for(int i = 0; i < N; ++i) {
if(current.puzzle[i] != 0) continue;
for(const auto& j: NEXT[i]) {
vector<int> next(current.puzzle);
swap(next[i], next[j]);
q.push(Node(next, current.depth + 1));
}
}
}
}
int main() {
bfs({0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 0}, memo1);
vector<int> puzzle(N);
while(cin >> puzzle[0], puzzle[0] != -1) {
for(int i = 1; i < N; ++i) cin >> puzzle[i];
memo2.clear();
bfs(puzzle, memo2);
int answer = 21;
for(auto& i: memo1) if(memo2.count(get<0>(i))) answer = min(answer, get<1>(i) + memo2[get<0>(i)]);
if(answer > 20) cout << "NA" << endl;
else cout << answer << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct edge {
int y;
edge* next;
};
edge* new_edge() {
static edge a[1000005];
static int top = 0;
return &a[top++];
}
edge* li[1000005];
void insert_edge(int x, int y) {
edge* t = new_edge();
t->y = y;
t->next = li[x];
li[x] = t;
}
long long sums[1000005];
int a[1000005];
int o23k[1000005];
const int modo = 1000000007;
void dfs1(int x) {
edge* t;
sums[x] = a[x];
for (t = li[x]; t != 0; t = t->next) {
dfs1(t->y);
sums[x] += sums[t->y];
}
}
bool dfs(int x, long long k) {
if (sums[x] < k) {
return 0;
}
if (sums[x] == k) {
return 0;
}
edge* t;
long long rest = sums[x] % k;
if (rest == 0) rest = k;
rest -= a[x];
for (t = li[x]; t != 0; t = t->next) {
if (rest < 0) return 1;
bool p = dfs(t->y, k);
if (p) return 1;
rest -= sums[t->y] % k;
}
if (rest < 0) {
return 1;
} else {
return 0;
}
}
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int ans[1000005];
map<long long, int> ma;
int main() {
int n;
scanf("%d", &n);
int i;
long long sum = 0;
int max_a = 0;
for (i = 0; i < n; i++) {
scanf("%d", &a[i]);
max_a = max(max_a, a[i]);
sum += a[i];
}
int gcd_val = 0;
for (i = 0; i < n; i++) {
gcd_val = gcd(gcd_val, a[i]);
}
for (i = 0; i < n; i++) {
a[i] /= gcd_val;
}
sum /= gcd_val;
max_a /= gcd_val;
for (i = 1; i < n; i++) {
int x;
scanf("%d", &x);
x--;
insert_edge(x, i);
}
int final_ans = 1;
dfs1(0);
int cnt = 0;
ans[1] = 1;
o23k[cnt++] = 1;
sort(sums, sums + n);
for (i = 0; i < n; i++) {
ma[sums[i]]++;
}
for (i = 2; i <= n; i++) {
if (sum % i == 0) {
if ((sums[n - 1] % i != 0) && (sums[n - 1] > i)) {
continue;
}
if (sum / i < max_a) {
break;
}
int cnts = 0;
long long p = sum / i;
long long pp;
for (pp = p; pp <= sum; pp += p) {
cnts += ma[pp];
if (cnts < pp / p) break;
}
if (cnts == i) {
int j;
for (j = 0; j < cnt; j++) {
if (i % o23k[j] == 0) {
ans[i] += ans[o23k[j]];
ans[i] %= modo;
}
}
o23k[cnt++] = i;
final_ans = (final_ans + ans[i]) % modo;
}
}
}
printf("%d\n", final_ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e3 + 50;
int f[maxn][maxn];
int mod[8], pos[100005], s[maxn];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &s[i]);
int ans = -1;
memset(f, 0, sizeof(f));
for (int i = 0; i < n; i++) {
memset(pos, 0, sizeof(pos));
memset(mod, 0, sizeof(mod));
for (int j = 1; j <= n; j++) {
if (j < i) {
mod[s[j] % 7] = max(mod[s[j] % 7], f[i][j]);
pos[s[j]] = max(pos[s[j]], f[i][j]);
continue;
}
if (j == i) continue;
f[i][j] = max(f[i][j], mod[s[j] % 7] + 1);
f[i][j] = max(f[i][j], pos[s[j] - 1] + 1);
f[i][j] = max(f[i][j], pos[s[j] + 1] + 1);
f[i][j] = max(f[i][j], f[i][0] + 1);
f[j][i] = f[i][j];
mod[s[j] % 7] = max(mod[s[j] % 7], f[i][j]);
pos[s[j]] = max(pos[s[j]], f[i][j]);
ans = max(ans, f[i][j]);
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long EPS = 1e-15;
int toInt(string s) {
int sm;
stringstream second(s);
second >> sm;
return sm;
}
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
int main() {
int n, k, remaining = 0, flag = 0;
std::cin >> n >> k;
char grid[5][n + 1];
for (int i = 0; i <= 4; ++i) {
for (int j = 0; j < n + 1; ++j) {
grid[i][j] = '.';
}
}
if (k % 2) remaining = 1, k--;
if (k % 2 == 0) {
for (int i = 2; i <= n / 2; ++i) {
if (k == 0) break;
grid[2][i] = grid[2][n - i + 1] = '#';
k -= 2;
}
}
if (k % 2 == 0) {
for (int i = 2; i <= n / 2; ++i) {
if (k == 0) break;
grid[3][i] = grid[3][n - i + 1] = '#';
k -= 2;
}
}
if (k % 2 == 0 && k > 0) {
grid[2][n / 2 + 1] = grid[3][n / 2 + 1] = '#';
k -= 2;
}
if (remaining) grid[2][n / 2 + 1] = '#';
cout << "YES\n";
for (int i = 1; i <= 4; ++i) {
for (int j = 1; j < n + 1; ++j) {
cout << grid[i][j];
}
cout << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int flag[10000010] = {0};
void init() {
for (int i = 4; i <= 10000010; i += 2) flag[i] = 2;
for (int i = 3; i <= 10000010 / i; i += 2) {
if (flag[i] == 0) {
for (int j = i * i; j < 10000010; j += i * 2) flag[j] = i;
}
}
}
void func(vector<int>& ans, vector<pair<int, int> > x) {
ans.clear();
for (int i = 0; i < x.size(); i++) {
if (i > 0 && x[i].first == x[i - 1].first)
ans[ans.size() - 1] *= x[i].second;
else
ans.push_back(x[i].second);
}
if (ans.size() == 0) ans.push_back(1);
}
void print(vector<int>& ans) {
for (int i = 0; i < ans.size(); i++) {
if (i) printf(" ");
printf("%d", ans[i]);
}
printf("\n");
}
int main() {
init();
int n, m;
scanf("%d%d", &n, &m);
vector<pair<int, int> > a;
vector<pair<int, int> > b;
a.clear();
b.clear();
for (int i = 0; i < n; i++) {
int x;
scanf("%d", &x);
while (x > 1) {
if (flag[x] == 0) flag[x] = x;
a.push_back(make_pair(flag[x], i));
x /= flag[x];
}
}
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
while (x > 1) {
if (flag[x] == 0) flag[x] = x;
b.push_back(make_pair(flag[x], i));
x /= flag[x];
}
}
sort(a.begin(), a.end());
sort(b.begin(), b.end());
int i, j;
i = j = 0;
vector<pair<int, int> > ansx;
vector<pair<int, int> > ansy;
for (; i < a.size() && j < b.size();) {
if (a[i].first < b[j].first) {
ansx.push_back(make_pair(a[i].second, a[i].first));
i++;
} else if (a[i].first > b[j].first) {
ansy.push_back(make_pair(b[j].second, b[j].first));
j++;
} else {
i++;
j++;
}
}
for (; i < a.size(); i++) ansx.push_back(make_pair(a[i].second, a[i].first));
for (; j < b.size(); j++) ansy.push_back(make_pair(b[j].second, b[j].first));
sort(ansx.begin(), ansx.end());
sort(ansy.begin(), ansy.end());
vector<int> x;
vector<int> y;
func(x, ansx);
func(y, ansy);
printf("%d %d\n", x.size(), y.size());
print(x);
print(y);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int binary_search(int a[], int n, int x) {
int low = 0, high = n - 1, result = -1, mid = 0;
while (low <= high) {
mid = low + (high - low) / 2;
if (a[mid] == x) {
return mid;
} else if (a[mid] > x) {
result = mid;
high = mid - 1;
} else {
low = mid + 1;
}
}
return result;
}
int main() {
ios_base::sync_with_stdio(0);
int i, j, k, l, m;
long long int sum = 0;
int v1[150010];
cin >> l;
for (i = 0; i < l; i++) {
cin >> k;
sum = sum + k;
v1[i] = sum;
}
cin >> j;
for (i = 0; i < j; i++) {
cin >> k;
cout << binary_search(v1, l, k) + 1 << endl;
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e5 + 5;
vector<int> v[N];
bool viz[N];
int cnt;
pair<long long, long long> a[N];
void dfs(int x) {
viz[x] = 1;
cnt++;
for (auto it : v[x])
if (!viz[it]) dfs(it);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
vector<pair<long long, long long> > ev;
int n, nredge = 0;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].first >> a[i].second;
ev.push_back({a[i].first, i});
ev.push_back({a[i].second, i});
}
sort(ev.begin(), ev.end());
set<pair<long long, long long> > s;
for (auto it : ev) {
if (nredge >= n) break;
if (s.count(it))
s.erase(it);
else {
int i = it.second;
long long r = a[i].second;
for (auto it : s) {
if (it.first > r) break;
int j = it.second;
v[i].push_back(j);
v[j].push_back(i);
nredge++;
if (nredge >= n) break;
}
s.insert({r, i});
}
}
dfs(1);
if (cnt == n && nredge == n - 1)
cout << "YES\n";
else
cout << "NO\n";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int q;
cin >> q;
while (q--) {
int n;
long long int m;
cin >> n >> m;
long long int t[n + 1], l[n + 1], r[n + 1];
t[0] = 0;
for (int i = 1; i <= n; i++) cin >> t[i] >> l[i] >> r[i];
long long int al[n + 1], ar[n + 1];
long long int left = m, right = m;
al[0] = m;
ar[0] = m;
int i;
for (i = 1; i <= n; i++) {
right = ar[i - 1] + t[i] - t[i - 1];
left = al[i - 1] - t[i] + t[i - 1];
if (right > r[i]) {
if (left > r[i])
break;
else {
al[i] = max(left, l[i]);
ar[i] = r[i];
}
} else {
if (right < l[i])
break;
else {
al[i] = max(left, l[i]);
ar[i] = right;
}
}
}
if (i == n + 1)
cout << "YES\n";
else
cout << "NO\n";
}
return 0;
}
| 3 |
#include<bits/stdc++.h>
using namespace std;
#define ll long long
int main(){
ll a,b;
cin>>a>>b;
if(a<=9&&b<=9) cout<<a*b;
else cout<<-1;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int w, b;
cin >> w >> b;
for (int i = 0; i < w; i++) {
for (int j = 0; j < b; j++) {
if (i == 0 && j == 0) {
cout << "W";
} else {
cout << "B";
}
}
cout << endl;
}
}
}
| 1 |
#include <iostream>
using namespace std;
int main(){
int n; cin >> n;
int s = 0, m = 0;
for(int i=0; i<n; i++){
int L; cin >> L;
s += L;
m = max(m, L);
}
if(m < s - m){
cout << "Yes" << endl;
}
else{
cout << "No" << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
constexpr ll inf = 1e9+7;
ll solve(vector<ll> As, bool flag) {
ll ans = 0;
ll sum = 0;
for (auto A : As) {
sum += A;
if (flag && sum <= 0) { ans += 1 - sum; sum = 1; }
else if (!flag && sum >= 0) { ans += 1 + sum; sum = -1; }
flag = !flag;
}
return ans;
}
int main () {
cin.tie(0);
ios::sync_with_stdio(false);
ll N;
cin>>N;
vector<ll> A(N);
for (ll n = 0; n < N; n++) cin>>A[n];
cout<<min(solve(A, false), solve(A, true))<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
long long a, b;
cin >> a >> b;
if (a == b) {
cout << 0 << endl;
continue;
}
if (a < b) {
if ((b - a) % 2 == 1) {
cout << 1 << endl;
} else {
cout << 2 << endl;
}
}
if (a > b) {
if ((a - b) % 2 == 1) {
cout << 2 << endl;
} else {
cout << 1 << endl;
}
}
}
return 0;
}
| 1 |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
string pls(string a,string b)
{
string ret;
reverse(a.begin(),a.end());
reverse(b.begin(),b.end());
if(a.size()<b.size())swap(a,b);
while(b.size() !=a.size() )b+='0';
while(ret.size()!=a.size()+1)ret+='0';
for(int i=0;i < a.size(); i++){
ret[i] = a[i] + b[i] + ret[i] - '0'*3;
if(ret[i]>9){
ret[i] = '0' + ret[i]%10;
ret[i+1] = '1';
}else{
ret[i]= '0' + ret[i];
}
}
reverse(ret.begin(),ret.end());
if(~ret.find_first_not_of('0'))return ret.substr(ret.find_first_not_of('0'),ret.size()-ret.find_first_not_of('0'));
else return "0";
}
bool func(vector<string> f , int n)
{
for(int i=0;i<3;i++){
for(int j=0;j<f[i].length();j++){
if(f[i][j]=='X'){
f[i][j]='0'+n;
}
}
}
return ( pls(f[0],f[1]) == f[2] );
}
int main()
{
bool flag;
int ret;
vector<string> m;
string s,t;
while(cin >> s){
s+=" ";
m.clear();
flag = false;
ret = -1;
for(int i=0;i<s.length();i++){
if(s[i]>='0' && s[i]<='9' || s[i]=='X'){
t+=s[i];
}else{
if(t.size()>=2 && t[0] == 'X')flag = true;
m.push_back(t);
t.clear();
}
}
for(int i=(flag?1:0);i<10;i++){
if(func(m,i))ret=i;
}
if(~ret)cout << ret << endl;
else cout << "NA" << endl;
}
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
struct Trie {
const static int ALPHA_SIZE = 2;
char base = 'a';
vector<vector<int> > g;
vector<int> pref, words;
int nxt = 1;
int move_to(int u, int c) {
if (g[u][c] == -1) {
g[u][c] = nxt++;
g.push_back(vector<int>(ALPHA_SIZE, -1));
pref.push_back(0);
words.push_back(0);
}
pref[g[u][c]]++;
return g[u][c];
}
public:
Trie() {
g.push_back(vector<int>(ALPHA_SIZE, -1));
pref.push_back(0);
words.push_back(0);
}
void addBit(int a) {
int u = 0;
for (int i = 31; i >= 0; i--) u = move_to(u, bool(a & (1ll << i)));
words[u]++;
}
int minXor(int u) {
int ans = 0, v = 0;
for (int i = 31; i >= 0; i--) {
ans *= 2;
if (u & (1ll << i) && g[v][1] != -1)
v = g[v][1];
else if (!(u & (1ll << i)) && g[v][0] != -1)
v = g[v][0];
else if (~g[v][0])
v = g[v][0], ans++;
else
v = g[v][1], ans++;
}
return ans;
}
int calc(int u = 0) {
if (u == -1) return 0;
int ans1 = calc(g[u][0]), ans2 = calc(g[u][1]);
return max(max(ans1, ans2) + min(1, min(ans1, ans2)), 1);
}
};
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T = 1, n;
while (T--) {
cin >> n;
Trie trie = Trie();
for (int i = 0; i < n; ++i) {
int aux;
cin >> aux;
trie.addBit(aux);
}
cout << n - trie.calc() << "\n";
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t, a, b;
cin >> t;
vector<int> primeDivisor(5000001), prime_factors(5000001), prefixSum(5000001);
for (int i = 2; i < 5000001; i++) {
if (primeDivisor[i] != 0) continue;
for (int j = i; j < 5000001; j += i) primeDivisor[j] = i;
}
for (int i = 2; i < 5000001; i++) {
int x = i;
while (x != 1) {
x /= primeDivisor[x];
prime_factors[i]++;
}
}
for (int i = 2; i < 5000001; i++)
prefixSum[i] = prefixSum[i - 1] + prime_factors[i];
while (t--) {
cin >> a >> b;
cout << prefixSum[a] - prefixSum[b] << "\n";
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
const double pi = acos(-1);
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const int MAXN = 1e6 + 5;
const double eps = 1e-9;
using namespace std;
char str[MAXN], ans[MAXN];
int a[MAXN], b[MAXN], ca[MAXN];
int main() {
int n, m;
scanf("%s", str);
n = strlen(str);
scanf("%d", &(m));
for (int i = 0; i < m; i++) {
int k, d, cnt = 0;
scanf("%d", &(k)), scanf("%d", &(d));
for (int j = 0; j < n; j++) a[j] = (j + 1) % n, b[j] = j;
for (int j = 0; j < d; j++)
for (int l = j; l < k; l += d) a[(n - 1 + cnt++) % n] = l;
for (int j = n - k + 1; j > 0; j /= 2) {
for (int l = 0; l < n; l++) {
ca[l] = a[l];
if (j & 1) b[l] = a[b[l]];
}
for (int l = 0; l < n; l++) a[l] = ca[a[l]];
}
for (int j = 0; j < n; j++) ans[(j + n - k + 1) % n] = str[b[j]];
for (int j = 0; j < n; j++) str[j] = ans[j];
printf("%s\n", str);
}
return 0;
}
| 5 |
#include <iostream>
using namespace std;
int main()
{
int n;
while (cin >> n){
if (n % 39 == 0){
cout << "3C" << "39" << endl;
}
else if (n % 39 < 10){
cout << "3C0" << n % 39 << endl;
}
else {
cout << "3C" << n % 39 << endl;
}
}
return (0);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char s[25];
int main() {
scanf("%s", s);
int len = strlen(s);
set<string> Set;
string p;
for (int i = 0; i <= len; ++i) {
if (i) p = p + s[i - 1];
for (int j = 0; j < 26; ++j) {
string tag = p;
tag = tag + (char)(j + 'a');
for (int k = i; k < len; ++k) {
tag = tag + s[k];
}
Set.insert(tag);
}
}
printf("%d\n", (int)Set.size());
return 0;
}
| 1 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
const long long MOD = 998244353;
const long long Mod = 998244352;
const int maxn = 2e5 + 5;
const double Inf = 10000.0;
const double PI = acos(-1.0);
using namespace std;
int bitcount(int x) { return x == 0 ? 0 : bitcount(x / 2) + (x & 1); }
int _popcount(int x) {
int cnt = 0;
for (int i = 0; i < 32; i++)
if (x & (1 << i)) cnt++;
return cnt;
}
long long mul(long long a, long long b, long long m) {
long long res = 0;
while (b) {
if (b & 1) res = (res + a) % m;
a = (a + a) % m;
b >>= 1;
}
return res % m;
}
long long quickPower(long long a, long long b, long long m) {
long long base = a;
long long ans = 1ll;
while (b) {
if (b & 1) ans = mul(ans, base, m);
base = mul(base, base, m);
b >>= 1;
}
return ans;
}
long long ksm(long long a, long long b, long long m) {
long long base = a % m;
long long ans = 1ll;
while (b) {
if (b & 1) ans *= base, ans %= m;
base *= base, base %= m;
b >>= 1;
}
return ans;
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
long long Lcm(long long a, long long b) { return a / gcd(a, b) * b; }
int readint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
long long readll() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
unsigned long long readull() {
unsigned long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void Put(long long x) {
if (x < 0) putchar('-'), x *= -1;
if (x > 9) Put(x / 10);
putchar(x % 10 + '0');
}
int a[maxn];
int sum[maxn];
int p[2][maxn];
int main() {
int h = readint();
for (int i = 0; i <= h; i++) {
a[i] = readint();
if (i)
sum[i] = sum[i - 1] + a[i];
else
sum[0] = a[0];
}
int cur = 1;
int f = 0;
p[0][1] = p[1][1] = 0;
for (int i = 1; i <= h; i++) {
for (int j = 0; j < a[i]; j++) {
cur++;
p[0][cur] = p[1][cur] = sum[i - 1];
}
if (a[i] > 1 && a[i - 1] > 1) {
f = 1;
p[1][cur]--;
}
}
if (!f)
puts("perfect");
else {
puts("ambiguous");
for (int i = 0; i < 2; i++) {
for (int j = 1; j <= sum[h]; j++) printf("%d ", p[i][j]);
puts("");
}
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int n;
string s[N];
unordered_map<string, int> mp;
unordered_map<string, bool> u;
int main() {
ios_base ::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> s[i];
for (int j = 0; j < (int)s[i].size(); ++j) {
string x = "";
for (int k = j; k < (int)s[i].size(); ++k) {
x += s[i][k];
if (!u[x]) {
++mp[x];
u[x] = 1;
}
}
}
for (int j = 0; j < (int)s[i].size(); ++j) {
string x = "";
for (int k = j; k < (int)s[i].size(); ++k) {
x += s[i][k];
u[x] = 0;
}
}
}
for (int i = 1; i <= n; ++i) {
int mn = 10;
string mn_ans = "";
for (int l = 0; l < (int)s[i].size(); ++l) {
string x = "";
for (int r = l; r < (int)s[i].size(); ++r) {
x += s[i][r];
if ((int)x.size() >= mn) break;
if (!(mp[x] - 1)) {
mn = (int)x.size();
mn_ans = x;
break;
}
}
}
cout << mn_ans << '\n';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 9;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int aa = 0, da = 0, ab = 0, db = 0;
for (int _ = (int)(0); _ < (int)(n); ++_) {
int type, a, b;
cin >> type >> a >> b;
if (type == 1)
aa += a + b, da += b;
else
ab += a + b, db += b;
}
if (2 * da > aa)
puts("DEAD");
else
puts("LIVE");
if (2 * db > ab)
puts("DEAD");
else
puts("LIVE");
return 0;
}
| 1 |
#include <bits/stdc++.h>
int main() {
char s1[10], s2[10], s3[10];
gets(s1);
int m, t1, t2, tm, hr, minn, xh, xm;
scanf("%d", &m);
s2[0] = s1[0];
s2[1] = s1[1];
s2[2] = '\0';
s3[0] = s1[3];
s3[1] = s1[4];
s3[2] = '\0';
int n1, n2;
n1 = atoi(s2);
n2 = atoi(s3);
if (m > 60) {
t1 = m - (60 * (m / 60));
t2 = m / 60;
minn = t1 + n2;
if (minn >= 60) {
minn = minn - 60;
t2 = t2 + 1;
} else {
minn = minn;
}
hr = t2 + n1;
if (hr >= 24) {
hr = hr - (24 * (hr / 24));
} else {
hr = hr;
}
} else if (m <= 60) {
t1 = m;
t2 = 0;
minn = t1 + n2;
if (minn >= 60) {
minn = minn - 60;
t2 = t2 + 1;
} else {
minn = minn;
}
hr = t2 + n1;
if (hr >= 24) {
hr = hr - (24 * (hr / 24));
} else {
hr = hr;
}
}
if (minn < 10 && hr < 10) {
printf("0%d:0%d\n", hr, minn);
}
if (minn >= 10 && hr < 10) {
printf("0%d:%d\n", hr, minn);
}
if (minn < 10 && hr >= 10) {
printf("%d:0%d\n", hr, minn);
}
if (minn >= 10 && hr >= 10) {
printf("%d:%d\n", hr, minn);
}
}
| 2 |
#include <iostream>
#include <vector>
#include <cstdio>
#include <cmath>
using namespace std;
const double INF = 1e10;
int main(){
int n;
while(cin>>n,n){
vector<double> x(n),y(n),z(n),r(n);
for(int i=0;i<n;++i){
cin>>x[i]>>y[i]>>z[i]>>r[i];
}
double edge[100][100];
for(int i=0;i<n;++i){
for(int j=0;j<n;++j){
double distance = sqrt((x[i]-x[j])*(x[i]-x[j])+(y[i]-y[j])*(y[i]-y[j])+(z[i]-z[j])*(z[i]-z[j]));
double cost = max(distance - r[i] - r[j] , 0.0);
edge[i][j] = cost;
}
}
double mincost[100];
bool used[100];
for(int i=0;i<n;++i){
mincost[i]=INF;
used[i]=false;
}
mincost[0]=0.0; double ans=0.0;
while(1){
int v = -1;
for(int i=0;i<n;++i){
if(!used[i] && (v == -1 || mincost[i] < mincost[v])) v=i;
}
if(v == -1) break;
used[v] = true;
ans += mincost[v];
for(int i=0;i<n;++i){
mincost[i] = min(mincost[i], edge[v][i]);
}
}
printf("%.03f\n",ans);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, l, k;
long long a[1000006];
long long f[1000005];
int nn;
long long c[1000005];
long long ans;
long long dq;
long long s[1000005];
const long long mod = 1e9 + 7;
int lowbit(int x) { return x & (-x); }
long long sum(int x) {
long long ans = 0;
for (int i = x; i > 0; i -= lowbit(i)) ans += c[i], ans %= mod;
return ans;
}
void add(int x, long long w) {
for (int i = x; i <= 1000000; i += lowbit(i)) c[i] += w, c[i] %= mod;
}
int main() {
scanf("%I64d%I64d%I64d", &n, &l, &k);
for (int i = 1; i <= n; ++i) scanf("%I64d", &a[i]);
for (int i = 1; i <= n; ++i) f[i] = a[i];
sort(f + 1, f + n + 1);
nn = unique(f + 1, f + n + 1) - (f + 1);
for (int i = 1; i <= n; ++i) a[i] = lower_bound(f + 1, f + nn + 1, a[i]) - f;
memset(f, 0, sizeof(f));
memset(c, 0, sizeof(c));
long long maxx = n * k;
for (int i = 1; i <= maxx; ++i) {
if (i <= n) {
f[i] = 1;
s[1]++;
add(a[i], 1);
continue;
}
dq = a[(i - 1) % n + 1];
f[i] = sum(dq), f[i] %= mod;
s[(i - 1) / n + 1] = (s[(i - 1) / n + 1] + f[i]) % mod;
if (i % n == 0) {
for (int j = 0; j <= n; ++j) c[j] = 0;
for (int j = i - n + 1; j <= i; ++j) add(a[j - (i - n)], f[j]);
}
}
long long m = l / n;
ans = 0;
for (int i = 1; i <= k; ++i) {
if (m < i) break;
dq = (m - i + 1) % mod;
dq = dq * s[i] % mod;
ans = (ans + dq) % mod;
}
memset(f, 0, sizeof(f));
memset(c, 0, sizeof(c));
for (int i = 1; i <= l % n; ++i) {
ans++;
ans %= mod;
add(a[i], 1);
}
maxx = min(n * k - n, l - l % n);
for (int i = 1; i <= maxx; ++i) {
dq = a[(i - 1) % n + 1];
f[i] = sum(nn) - sum(dq - 1), f[i] += mod, f[i] %= mod;
ans = (ans + f[i]) % mod;
if (i % n == 0) {
for (int j = 0; j <= n; ++j) c[j] = 0;
for (int j = i - n + 1; j <= i; ++j) add(a[j - (i - n)], f[j]);
}
}
printf("%I64d\n", ans);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T a, T b) {
if (a == 0) return b;
return gcd(b % a, a);
}
template <typename T>
T pow(T a, T b, long long m) {
T ans = 1;
while (b > 0) {
if (b % 2 == 1) ans = (ans * a) % m;
b /= 2;
a = (a * a) % m;
}
return ans % m;
}
const int N = 1e5 + 5;
long long n, k, m;
long long cache[1001][101][2];
int vis[1001][101][2];
long long dp(long long i, long long rem, int nonzerocheck) {
if (i == 0) {
if (rem == 0 && nonzerocheck) {
return 1;
} else {
return 0;
}
}
if (vis[i][rem][nonzerocheck]) {
return cache[i][rem][nonzerocheck];
}
vis[i][rem][nonzerocheck] = 1;
if (rem == 0 && nonzerocheck) {
long long store = pow(10LL, i - 1, m);
store *= 9;
store %= m;
cache[i][rem][nonzerocheck] = store;
return store;
}
long long store = pow(10LL, n - i, k);
for (long long j = 0; j <= 9; j++) {
long long cur = store * j;
cur %= k;
if (j == 0)
cache[i][rem][nonzerocheck] += dp(i - 1, (rem + cur) % k, nonzerocheck);
else
cache[i][rem][nonzerocheck] += dp(i - 1, (rem + cur) % k, 1);
cache[i][rem][nonzerocheck] %= m;
}
return cache[i][rem][nonzerocheck];
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k >> m;
long long ans = 0;
for (long long i = 0; i <= 9; i++) {
if (i == 0)
ans += dp(n - 1, i % k, 0);
else
ans += dp(n - 1, i % k, 1);
ans %= m;
}
cout << ans;
return 0;
}
| 4 |
#include<iostream>
#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>
#include<cstring>
#define MAX_N 10000
using namespace std;
typedef pair<int, int> P;
const int INF = 1 << 30;
int dp[2][MAX_N / 2 + 1][2];
int main() {
int n, ans = INF, t[MAX_N + 1] = {};
cin >> n;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < n / 2 + 1; j++) {
fill(dp[i][j], dp[i][j] + 2, INF);
}
}
for (int i = 0; i < n - 1; i++) {
cin >> t[i];
}
dp[1][1][1] = t[0];
for (int i = 1; i < n ; i++) {
for (int j = 0; j < n / 2 + 1; j++) {
for (int k = 0; k < 2; k++) {
dp[0][j][k] = dp[1][j][k];
dp[1][j][k] = INF;
}
}
for (int j = 0; j < n / 2; j++) {
if (j > i) break;
dp[1][j + 1][0] = min(dp[0][j + 1][1], dp[0][j + 1][0]);
dp[1][j + 1][1] = min(dp[1][j + 1][1], dp[0][j][1] + t[i] - t[i - 1]);
dp[1][j + 1][1] = min(dp[1][j + 1][1], dp[0][j][0] + t[i] + t[i - 1]);
}
ans = min(ans, min(dp[1][n / 2][0], dp[1][n/2][1]));
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1100;
int n, m, w;
int dp[maxn][maxn][3];
struct node {
int w, b, p;
} a[maxn];
int Find(int x) { return a[x].p == x ? x : a[x].p = Find(a[x].p); }
bool cmp(node x, node y) { return x.p < y.p; }
void upd(int x, int z, int &y) {
if (x == -1) return;
y = max(y, x + z);
}
int main() {
scanf("%d%d%d", &n, &m, &w);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].w);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].b), a[i].p = i;
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
int xx = Find(x), yy = Find(y);
if (xx != yy) a[xx].p = yy;
}
for (int i = 1; i <= n; i++) a[i].p = Find(i);
sort(a + 1, a + n, cmp);
memset(dp, -1, sizeof(dp));
dp[0][0][0] = 0;
for (int l = 0; l <= w; l++) {
for (int i = 1, j = 1; i <= n; i = j) {
int sumb = 0, sumw = 0;
for (j = i; j <= n && a[j].p == a[i].p; j++)
sumb += a[j].b, sumw += a[j].w;
for (int k = i; k < j; k++) {
if (k == i) {
upd(max(dp[k - 1][l][1], max(dp[k - 1][l][2], dp[k - 1][l][0])), 0,
dp[k][l][0]);
int x = a[k].w;
if (l >= x)
upd(max(dp[k - 1][l - x][0],
max(dp[k - 1][l - x][1], dp[k - 1][l - x][2])),
a[k].b, dp[k][l][1]);
} else {
upd(dp[k - 1][l][0], 0, dp[k][l][0]);
upd(dp[k - 1][l][1], 0, dp[k][l][1]);
int x = a[k].w;
if (l >= x) upd(dp[k - 1][l - x][0], a[k].b, dp[k][l][1]);
}
if (k == j - 1) {
if (l >= sumw) {
if (k == i)
upd(max(dp[k - 1][l - sumw][1],
max(dp[k - 1][l - sumw][2], dp[k - 1][l - sumw][0])),
sumb, dp[k][l][2]);
else
upd(dp[k - 1][l - sumw][0], sumb, dp[k][l][2]);
}
}
}
}
}
int ans = 0;
for (int l = 0; l <= w; l++) {
for (int j = 0; j < 3; j++) ans = max(ans, dp[n][l][j]);
}
printf("%d\n", max(0, ans));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t;
cin >> t;
while (t--) {
long long int n, m;
cin >> n >> m;
long long int prev = 0;
long long int mn = m;
long long int mx = m;
bool flag = false;
while (n--) {
long long int t, l, h;
cin >> t >> l >> h;
mx += (t - prev);
mn -= (t - prev);
prev = t;
if (mx < l || mn > h) {
flag = true;
}
mx = min(mx, h);
mn = max(mn, l);
}
if (!flag)
cout << "Yes\n";
else
cout << "No\n";
}
}
| 3 |
#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,res=1;
signed main(){
scanf("%lld",&n);
while(n--){
int a; scanf("%lld",&a);
if(a==0) return puts("0"),0;
else if(1000000000000000000/a<res) res=-1;
if(res!=-1) res*=a;
if(res>1000000000000000000) res=-1;
}
printf("%lld",res);
return 0;
} | 0 |
#include<iostream>
#include<algorithm>
using namespace std;
int main(){
long n,i,a[5000],t,x;
while(cin>>n,n){
for(i=0;i<n;i++)cin>>a[i];
x=-100000;
for(t=i=0;i<n;i++){
if(t<0)t=a[i];else t+=a[i];
if(x<t)x=t;
}
cout<<x<<endl;
}
return 0;
} | 0 |
#include <iostream>
#include <limits.h>
#include <queue>
#include <algorithm>
#include <map>
#include <cstring>
#define dprintf(s,...) printf("%s:%d" s,__func__,__LINE__,__VA_ARGS__)
using namespace std;
typedef pair<int,int> P;
typedef long long int ll;
int N,K;
int S[101],B[101][101];
bool solve(){
for(int i=0;i<K;i++){
int t=0;
for(int j=0;j<N;j++)
t+=B[j][i];
if(t>S[i]) return false;
}
return true;
}
int main(){
while(1){
cin>>N>>K;
if(N==0 && K==0) break;
for(int i=0;i<K;i++)
cin>>S[i];
for(int i=0;i<N;i++)
for(int j=0;j<K;j++)
cin>>B[i][j];
if(solve())cout<<"Yes"<<endl;
else cout<<"No"<<endl;
}
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b,c;
cin>>a>>b>>c;
cout<<a+b+c-max(a,max(b,c))<<endl;
return(0);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const long long MOD = 1e9 + 7;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int INF = 1e9 + 7;
const double PI = acos(-1.0);
const double EPS = 1e-8;
int _;
using namespace std;
int arr[MAXN];
int cnt[1005];
int mat[105][105];
int N;
void fill_4(int idx, int num) {
int xx = idx / (N / 2);
int yy = idx % (N / 2);
if (yy) xx++;
if (yy == 0) yy = N / 2;
mat[xx][yy] = num;
mat[N - xx + 1][yy] = num;
mat[xx][N - yy + 1] = num;
mat[N - xx + 1][N - yy + 1] = num;
}
void fill_2(int idx, int num) {
if (idx <= (N / 2)) {
mat[idx][N / 2 + 1] = mat[N - idx + 1][N / 2 + 1] = num;
} else {
idx -= N / 2;
mat[N / 2 + 1][idx] = mat[N / 2 + 1][N - idx + 1] = num;
}
}
void fill_1(int idx, int num) { mat[N / 2 + 1][N / 2 + 1] = num; }
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
while (cin >> N) {
memset(cnt, 0, sizeof(cnt));
for (int i = 1; i <= N * N; ++i) {
cin >> arr[i];
cnt[arr[i]]++;
}
int nd4 = (N / 2) * (N / 2);
int nd2 = N % 2 ? N / 2 * 2 : 0;
int nd1 = (N % 2 == 1);
for (int i = 1000; i >= 1; --i) {
if (cnt[i] >= 4) {
int togo = min(cnt[i] / 4, nd4);
for (int t = 1; t <= togo; ++t) fill_4(nd4 - t + 1, i);
cnt[i] -= togo * 4;
nd4 -= togo;
}
if (!nd4) break;
}
for (int i = 1000; i >= 1; --i) {
if (cnt[i] >= 2) {
int togo = min(cnt[i] / 2, nd2);
for (int t = 1; t <= togo; ++t) fill_2(nd2 - t + 1, i);
cnt[i] -= togo * 2;
nd2 -= togo;
}
if (!nd2) break;
}
for (int i = 1000; i >= 1; --i) {
if (cnt[i]) {
int togo = min(cnt[i], nd1);
for (int t = 1; t <= togo; ++t) fill_1(nd1 - t + 1, i);
cnt[i] -= togo;
nd1 -= togo;
}
if (!nd1) break;
}
if (!nd4 && !nd2 && !nd1) {
cout << "YES" << endl;
for (int i = 1; i <= N; ++i) {
for (int j = 1; j <= N; ++j) cout << mat[i][j] << " ";
cout << endl;
}
} else
cout << "NO" << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void debug(vector<T> li) {
for (auto v : li) {
cout << v << " ";
}
cout << "\n";
}
template <typename T>
inline void debug(vector<vector<T>> li) {
for (auto v1 : li) {
for (auto v2 : v1) {
cout << v2 << " ";
}
cout << "\n";
}
}
const int mxN = 2e5;
const int di[4] = {1, 0, -1, 0}, dj[4] = {0, 1, 0, -1};
void solve() {
int n, m;
cin >> n >> m;
if (n % m == 0) {
cout << "YES\n";
} else {
cout << "NO\n";
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int T;
cin >> T;
for (int t = 1; t <= T; t++) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct apple {
int data, no, has;
} a[2001011 * 2];
int ff[2001011], father[2001011], dian_sum[2001011], bian_sum[2001011],
maxx[2001011], sub_maxx[2001011], n, m, ans;
bool cmp1(apple aa, apple bb) { return aa.data < bb.data; }
bool cmp2(apple aa, apple bb) { return aa.no < bb.no; }
int find(int u) {
if (u == father[u]) return u;
father[u] = find(father[u]);
return father[u];
}
void put_together(int x, int y) {
int fa, fb;
fa = find(x);
fb = find(y);
if (fa == fb) {
bian_sum[fa]++;
return;
} else {
father[fa] = fb;
dian_sum[fb] += dian_sum[fa];
bian_sum[fb] += bian_sum[fa] + 1;
if (maxx[fa] > maxx[fb]) {
sub_maxx[fb] = maxx[fb];
maxx[fb] = maxx[fa];
} else {
sub_maxx[fa] = maxx[fa];
}
if (sub_maxx[fa] > sub_maxx[fb]) {
sub_maxx[fb] = sub_maxx[fa];
}
}
}
int main() {
int x, y;
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
scanf("%d%d", &a[i * 2 - 1].data, &a[i * 2].data);
a[i * 2 - 1].no = i * 2 - 1;
a[i * 2].no = i * 2;
}
sort(a + 1, a + m * 2 + 1, cmp1);
a[0].data = -1;
for (int i = 1; i <= m * 2; i++) {
if (a[i].data == a[i - 1].data)
a[i].has = n;
else
a[i].has = ++n;
}
sort(a + 1, a + m * 2 + 1, cmp2);
for (int i = 1; i <= m * 2; i++) {
ff[a[i].has] = a[i].data;
}
for (int i = 1; i <= n; i++) {
father[i] = i;
dian_sum[i] = 1;
maxx[i] = ff[i];
}
for (int i = 1; i <= m; i++) {
x = a[i * 2 - 1].has;
y = a[i * 2].has;
put_together(x, y);
}
for (int i = 1; i <= n; i++) {
if (i == father[i]) {
if (bian_sum[i] > dian_sum[i]) {
printf("-1");
return 0;
}
if (bian_sum[i] == dian_sum[i]) {
ans = max(ans, maxx[i]);
} else {
ans = max(ans, sub_maxx[i]);
}
}
}
printf("%d", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
bool pal(string s, int start, int end) {
if (s[start] != s[end])
return 0;
else if (start >= end)
return 1;
else
return pal(s, ++start, --end);
return 0;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
string merged;
cin >> merged;
int parts;
cin >> parts;
int sz = merged.size();
if (sz % parts != 0) {
cout << "NO" << endl;
} else {
int i = 0, loc = 0;
int div = sz / parts;
while (i < parts) {
if (pal(merged.substr(loc, div), 0, div - 1)) {
loc += div;
} else {
cout << "NO" << endl;
return 0;
}
i++;
}
cout << "YES" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
map<string, int> m;
while(cin >> s) {
m[s]++;
}
string r1, r2;
for(auto& p : m) {
if(m[r1] < p.second) {
r1 = p.first;
}
if(r2.size() < p.first.size()) {
r2 = p.first;
}
}
cout << r1 << ' ' << r2 << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, k, y;
scanf("%d", &n);
int x[n];
for (i = 0; i < n; i++) {
scanf("%d", &x[i]);
scanf("%d", &y);
}
k = 0;
for (i = 0; i < n; i++) {
if (x[i] <= 0) k++;
}
if (k <= 1)
printf("Yes\n");
else if (n - k <= 1)
printf("Yes\n");
else
printf("No\n");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long int t;
cin >> t;
while (t--) {
long long int n;
cin >> n;
long long int a[n];
for (long long int i = 0; i < n; i++) cin >> a[i];
if (n == 1) {
cout << -1 << endl;
continue;
}
map<long long int, long long int> mp;
long long int ans = 1e18;
for (long long int i = 0; i < n; i++) {
if (!mp.count(a[i])) {
mp[a[i]] = i;
} else {
ans = min(ans, i - mp[a[i]] + 1);
mp[a[i]] = i;
}
}
if (ans == 1e18)
cout << -1 << endl;
else
cout << ans << endl;
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
long long n, x, y, d;
cin >> t;
while (t--) {
cin >> n >> x >> y >> d;
if (y != 1 && y != n && abs(y - x) % d != 0 && abs(y - 1) % d != 0 &&
abs(n - y) % d != 0) {
cout << -1 << endl;
} else if (abs(y - x) % d == 0) {
cout << abs(y - x) / d << endl;
} else {
long long ans1 = (long long)1e13;
long long ans2 = (long long)1e13;
if (abs(n - y) % d == 0) {
long long tmp;
if ((n - x) % d == 0) {
tmp = (n - x) / d;
} else {
tmp = (n - x) / d + 1;
}
ans1 = abs(n - y) / d + tmp;
}
if (abs(y - 1) % d == 0) {
long long tmp;
if ((x - 1) % d == 0) {
tmp = (x - 1) / d;
} else {
tmp = (x - 1) / d + 1;
}
ans2 = abs(y - 1) / d + tmp;
}
cout << min(ans1, ans2) << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
int n, b, k, x;
struct A {
long long m[105][105];
} a, E;
inline A mul(const A& p, const A& q) {
A res;
for (int i = 0; i < x; i++)
for (int j = 0; j < x; j++) {
res.m[i][j] = 0;
for (int l = 0; l < x; l++)
res.m[i][j] = (res.m[i][j] + p.m[i][l] * q.m[l][j] % M) % M;
}
return res;
}
inline void qpow(int bb) {
while (bb) {
if (bb & 1) {
E = mul(E, a);
}
a = mul(a, a);
bb >>= 1;
}
printf("%lld\n", E.m[0][k]);
}
int main() {
scanf("%d%d%d%d", &n, &b, &k, &x);
for (int i = 0; i < x; i++) E.m[i][i] = 1;
for (int i = 1; i <= n; i++) {
int lj;
scanf("%d", &lj);
for (int j = 0; j < x; j++) a.m[j][(j * 10 % x + lj % x) % x]++;
}
qpow(b);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int m, n;
int ans[150];
int dp[2050][2050]; // S?????????????????£??????
using Set = bitset<12>;
int rec(int asked, int answer){ // ??????????????????aked???answer??¨??????????????????
int &res = dp[asked][answer];
if(res != -1) return res;
res = m;
int rem = 0;
for(int i = 0; i < n; ++i){
if((ans[i] & asked) == answer){
++rem;
}
}
if(rem <= 1) return res = 0;
for(int i = 0; i < m; ++i){
if(asked >> i & 1) continue;
int cnt[2] = {};
for(int j = 0; j < n; ++j){
if((ans[j] & asked) == answer){
++cnt[ans[i] >> j & 1];
}
}
// if(cnt[0] == 0 || cnt[1] == 0) continue;
int tmp = 0;
for(int j = 0; j < 2; ++j){
tmp = max(tmp, 1 + rec(asked | 1<<i, answer | (j << i)));
}
res = min(res, tmp);
}
return res;
}
int main(){
cin.tie(0);
ios_base::sync_with_stdio(0);
while(cin >> m >> n && m){
for(int i = 0; i < n; ++i){
char buf[100];
cin >> buf;
ans[i] = 0;
for(int j = 0; j < m; ++j){
if(buf[j]-'0') ans[i] |= 1 << j;
}
}
memset(dp,-1,sizeof(dp));
cout << rec(0,0) << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; ++i) cin >> a[i];
int result = 0;
for (int i = *max_element(a.begin(), a.end()); i >= 0; --i) {
if (i < *max_element(a.begin(), a.end()))
for (int j = 0; j < n; ++j)
if (a[j] > 0) --a[j];
if (a[0] == 0 || a[n - 1] == 0) goto lbl;
for (int j = 0; j < n - 1; ++j) {
if ((a[j] == 0) && (a[j + 1] == 0)) goto lbl;
}
++result;
}
lbl:
cout << result;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 3e5 + 5;
const long long mod = 1e9 + 7;
const long long inf = 1e9;
const long long del = 728729;
long long poww(long long a, long long b, long long md) {
return (!b ? 1
: (b & 1 ? a * poww(a * a % md, b / 2, md) % md
: poww(a * a % md, b / 2, md) % md));
}
long long n;
long long m;
long long visited[maxn];
vector<long long> adj[maxn];
vector<long long> back[maxn], dare[maxn];
long long par[maxn];
long long dis[maxn];
long long check[maxn];
vector<pair<pair<int, int>, long long> > ans;
bool dfs(long long root) {
visited[root] = 1;
long long cnt = 0;
long long test;
for (int i = 0; i < adj[root].size(); i++) {
long long u = adj[root][i];
if (!visited[u]) {
par[u] = root;
if (dfs(u) == false) {
cnt++;
if (cnt % 2 == 0) {
ans.push_back({{test, root}, u});
} else {
test = u;
}
}
}
}
check[root] = 1;
for (int i = 0; i < adj[root].size(); i++) {
long long u = adj[root][i];
if (u != par[root] && check[u] == 0) {
cnt++;
if (cnt % 2 == 0) {
ans.push_back({{test, root}, u});
} else {
test = u;
}
}
}
if (cnt % 2 == 1 && par[root] != -1) {
ans.push_back({{test, root}, par[root]});
return 1;
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> m;
for (long long i = 0; i < m; i++) {
long long x;
long long y;
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
if (m % 2 == 1) {
cout << "No solution";
return 0;
}
for (long long i = 1; i <= n; i++) {
if (!visited[i]) {
par[i] = -1;
dis[i] = 0;
dfs(i);
}
}
if (ans.size() != m / 2) {
cout << "No solution";
return 0;
}
while (ans.size()) {
cout << ans.back().first.first << " " << ans.back().first.second << " "
<< ans.back().second << endl;
ans.pop_back();
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int N = 2002;
const ll MOD = 1e9 + 7;
int n, k;
char s[N];
ll f[N][N][3];
inline void Add(ll& x, ll y) { (x += y) %= MOD; }
void Solve() {
f[0][0][0] = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= k; ++j) {
Add(f[i][j][0], (f[i - 1][j][0] + f[i - 1][j][1] + f[i - 1][j][2]) *
(s[i - 1] - 'a'));
Add(f[i][j][1], f[i - 1][j][0] + f[i - 1][j][1] + f[i - 1][j][2]);
for (int t = 0; t < j / (n - i + 1); ++t) {
if (i >= t + 1) {
int u = i - t - 1;
ll tmp1 = f[u][j - (t + 1) * (n - i + 1)][0] +
f[u][j - (t + 1) * (n - i + 1)][2];
ll tmp = tmp1 * ('z' - s[i - 1]);
Add(f[i][j][2], tmp);
}
}
}
}
}
int main() {
scanf("%d%d", &n, &k);
scanf("%s", s);
Solve();
ll ans = f[n][k][0];
Add(ans, f[n][k][1]);
Add(ans, f[n][k][2]);
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long a, b, n, x;
const int mod = 1e9 + 7;
long long ans;
long long aced(long long i, long long k) {
if (k == 0) return 1;
long long tmp = aced(i, k / 2);
if (k % 2 == 1)
return 1LL * tmp * tmp % mod * i % mod;
else
return 1LL * tmp * tmp % mod;
}
int main() {
cin >> a >> b >> n >> x;
if (a == 1) {
cout << 1LL * (x + 1LL * b * (n % mod)) % mod;
return 0;
}
ans = 1LL * (ans + 1LL * aced(a, n) * x % mod) % mod;
long long tmp =
1LL * (aced(a, n) % mod - 1) % mod * aced(a - 1, mod - 2) % mod * b % mod;
ans = 1LL * (ans + tmp) % mod;
cout << ans << endl;
}
| 4 |
#include <cstdlib>
#include <cmath>
#include <climits>
#include <cfloat>
#include <map>
#include <utility>
#include <set>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <sstream>
#include <deque>
#include <complex>
#include <stack>
#include <queue>
#include <cstdio>
#include <cctype>
#include <cstring>
#include <ctime>
#include <iterator>
#include <bitset>
#include <numeric>
#include <list>
#include <iomanip>
#include <cassert>
#include <array>
#include <tuple>
#include <initializer_list>
#include <unordered_set>
#include <unordered_map>
#include <forward_list>
using namespace std;
using ll = long long;
#define rep(i,k) for (int i = 0; i < (int)(k); i++)
#define all(cnt) begin(cnt), end(cnt)
int main() {
int w, h, t;
int p;
while (cin >> w >> h >> t >> p) {
int c[50][50] = {};
for (int i = 0; i < p; i++) {
int x, y, t;
cin >> x >> y >> t;
++c[y][x];
}
ll ans = 0;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
int x;
cin >> x;
ans += x * c[i][j];
}
}
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, m;
cin >> n >> m;
long long heights[n];
long long blocks = 0;
for (int i = 0; i < (n); i++) {
cin >> heights[i];
blocks += heights[i];
}
sort(heights, heights + n);
long long necessary = 0;
long long spot = 1;
for (int i = 1; i < (n); i++) {
if (spot + 1 <= heights[i]) {
spot++;
}
}
necessary += n;
necessary += heights[n - 1] - spot;
long long ans = blocks - necessary;
cout << ans;
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,k; cin>>n>>k;
int h[n]; for(int i=0;i<n;i++)cin>>h[i];
sort(h, h+n);
int ans=1000000000;
for(int i=0;i<n-k+1;i++){
ans=min(ans, h[i+k-1]-h[i]);
}
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, x, k, m;
const int MAXN = 200010;
long long int a[MAXN];
vector<long long int> maxs;
string b[MAXN];
void to2(int a, string &s) {
while (a) {
s += char(a % 2) + '0';
a /= 2;
}
reverse(s.begin(), s.end());
}
int main() {
scanf("%d %d %d", &n, &k, &x);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
int maxTool = 0;
for (int i = 0; i < n; i++) {
maxTool = max(maxTool, int(log2(a[i])));
}
long long int p = 1;
for (int i = 0; i < k; i++) {
p *= x;
}
long long int dpl[n], dpr[n];
dpl[0] = a[0];
for (int i = 1; i < n; i++) {
dpl[i] = dpl[i - 1] | a[i];
}
dpr[n - 1] = a[n - 1];
for (int i = n - 2; i >= 0; i--) {
dpr[i] = dpr[i + 1] | a[i];
}
long long int who = 0, what = 0, what2;
for (int i = 0; i < n; i++) {
what2 = 0;
if (i) {
what2 |= dpl[i - 1];
}
if (i != n - 1) {
what2 |= dpr[i + 1];
}
what2 |= a[i] * p;
if (what2 >= what) {
who = i;
what = what2;
}
}
for (int i = 0; i < k; i++) {
a[who] *= x;
}
long long int ans = 0;
for (int i = 0; i < n; i++) {
ans |= a[i];
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, M, Q, B;
int init[100010];
vector<int> sets[100010];
long long initsum[100010];
int bigsetID[100010];
int common[350][100010];
bool iselement[100010];
void pre(void) {
int i, j, k;
for ((i) = 0; (i) < (int)(M); (i)++)
for ((j) = 0; (j) < (int)(sets[i].size()); (j)++)
initsum[i] += init[sets[i][j]];
for ((i) = 0; (i) < (int)(M); (i)++) bigsetID[i] = -1;
B = 0;
for ((i) = 0; (i) < (int)(M); (i)++)
if (sets[i].size() >= 300) {
bigsetID[i] = B;
B++;
}
for ((i) = 0; (i) < (int)(M); (i)++)
if (bigsetID[i] != -1) {
int id = bigsetID[i];
for ((j) = 0; (j) < (int)(N); (j)++) iselement[j] = false;
for ((j) = 0; (j) < (int)(sets[i].size()); (j)++)
iselement[sets[i][j]] = true;
for ((j) = 0; (j) < (int)(M); (j)++)
for ((k) = 0; (k) < (int)(sets[j].size()); (k)++)
if (iselement[sets[j][k]]) common[id][j]++;
}
}
long long add_big_set[350];
long long add_set[100010];
long long add_element[100010];
long long big_set_sum[350];
long long sum_query(int id) {
int i;
long long ans = initsum[id];
if (bigsetID[id] != -1) {
ans += big_set_sum[bigsetID[id]];
return ans;
}
for ((i) = 0; (i) < (int)(B); (i)++) ans += add_big_set[i] * common[i][id];
for ((i) = 0; (i) < (int)(sets[id].size()); (i)++)
ans += add_element[sets[id][i]];
return ans;
}
void add_query(int id, int val) {
int i;
for ((i) = 0; (i) < (int)(B); (i)++)
big_set_sum[i] += common[i][id] * (long long)val;
if (bigsetID[id] != -1) add_big_set[bigsetID[id]] += val;
if (bigsetID[id] == -1)
for ((i) = 0; (i) < (int)(sets[id].size()); (i)++)
add_element[sets[id][i]] += val;
}
char buf[10];
void read_query(void) {
int id, val;
scanf("%s", buf);
if (buf[0] == '?') {
scanf("%d", &id);
id--;
long long ans = sum_query(id);
printf("%I64d\n", ans);
} else {
scanf("%d%d", &id, &val);
id--;
add_query(id, val);
}
}
int main(void) {
int i, j;
cin >> N >> M >> Q;
for ((i) = 0; (i) < (int)(N); (i)++) scanf("%d", &init[i]);
for ((i) = 0; (i) < (int)(M); (i)++) {
int sz, x;
scanf("%d", &sz);
for ((j) = 0; (j) < (int)(sz); (j)++) {
scanf("%d", &x);
x--;
sets[i].push_back(x);
}
}
pre();
for ((i) = 0; (i) < (int)(Q); (i)++) read_query();
return 0;
}
| 3 |
#include<iostream>
using namespace std;
#define MAX 500
int main(){
int n;
int w,h;
int map[MAX+1][MAX+1];
int x,y;
int s,t;
int cnt,max;
while(1){
cin>>n;
if(n==0) break;
cin>>w>>h;
for(int i=1;i<=h;i++){
for(int j=1;j<=w;j++){
map[i][j]=0;
}
}
for(int i=0;i<n;i++){
cin>>x>>y;
map[y][x]=1;
}
cin>>s>>t;
max=0;
for(int i=1;i<=h-t+1;i++){
for(int j=1;j<=w-s+1;j++){
cnt=0;
for(int k=0;k<t;k++){
for(int l=0;l<s;l++){
if(map[i+k][j+l]==1) cnt++;
}
}
if(max<cnt) max=cnt;
}
}
cout<<max<<endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int dr[4] = {0, 0, -1, 1}, dc[4] = {-1, 1, 0, 0};
class Dijkstra {
int N;
vector<vector<pair<int, int> > > E;
public:
Dijkstra(int n) {
N = n;
E = vector<vector<pair<int, int> > >(N + 1);
}
void insert(int u, int v, int w) { E[u].push_back(make_pair(v, w)); }
vector<int> dijkstra(int start, int end) {
vector<int> dist(N + 1, 1000000007);
dist[start] = 0;
priority_queue<pair<int, int> > pq;
pq.push(make_pair(0, start));
while (!pq.empty()) {
int w = -pq.top().first;
int u = pq.top().second;
if (u == end) return dist;
pq.pop();
if (dist[u] < w) continue;
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i].first;
int w2 = w + E[u][i].second;
if (dist[v] > w2) {
dist[v] = w2;
pq.push(make_pair(-w2, v));
}
}
}
return dist;
}
void g() {
int i, n, e, s, u, v, w;
vector<int> ans;
scanf("%d%d", &n, &e);
Dijkstra dk(n);
scanf("%d", &s);
for (i = 0; i < e; i++) {
scanf("%d%d%d", &u, &v, &w);
dk.insert(u, v, w);
}
ans = dk.dijkstra(s, N);
for (i = 1; i <= n; i++) {
if (ans[i] >= 1000000007)
printf("INF\n");
else
printf("%d\n", ans[i]);
}
}
};
class Prim {
int N;
vector<vector<pair<int, int> > > E;
public:
Prim(int n) {
N = n;
E = vector<vector<pair<int, int> > >(N + 1);
}
void insert(int u, int v, int w) { E[u].push_back(make_pair(v, w)); }
vector<int> execute(long long &cost) {
int k;
vector<int> dist(N + 1, 1000000007);
vector<bool> selected(N + 1, false);
dist[1] = 0;
cost = 0;
priority_queue<pair<int, int> > pq;
pq.push(make_pair(0, 1));
for (k = 0; k < N; k++) {
int w = -pq.top().first;
int u = pq.top().second;
pq.pop();
if (selected[u] == true) {
k--;
continue;
}
cost += w;
selected[u] = true;
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i].first;
int w2 = E[u][i].second;
if (selected[v] == true) continue;
if (dist[v] > w2) {
dist[v] = w2;
pq.push(make_pair(-w2, v));
}
}
}
return dist;
}
void g() {
int i, n, e, s, u, v, w;
long long cost;
vector<int> ans;
scanf("%d%d", &n, &e);
Prim pm(n);
scanf("%d", &s);
for (i = 0; i < e; i++) {
scanf("%d%d%d", &u, &v, &w);
pm.insert(u, v, w);
}
ans = pm.execute(cost);
printf("%d", cost);
}
};
class Floyd {
int N;
vector<vector<int> > E;
public:
Floyd(int n) {
N = n;
E = vector<vector<int> >(N + 1, vector<int>(N + 1, 1000000007));
}
void setRC(int r, int c, int w) { E[r][c] = w; }
int getRC(int r, int c) { return E[r][c]; }
void execute() {
int i, j, k;
for (i = 1; i <= N; ++i) E[i][i] = 0;
for (k = 1; k <= N; ++k)
for (i = 1; i <= N; ++i)
for (j = 1; j <= N; ++j) E[i][j] = min(E[i][j], E[i][k] + E[k][j]);
}
};
class DFS_Graph {
vector<vector<pair<int, int> > > E;
vector<int> A;
int N;
public:
DFS_Graph(int n) {
N = n;
E = vector<vector<pair<int, int> > >(N + 1);
A = vector<int>(N + 1);
}
void insert(int u, int v, int w) { E[u].push_back(make_pair(v, w)); }
void insert_fb(int u, int v, int w) {
E[u].push_back(make_pair(v, w));
E[v].push_back(make_pair(u, w));
}
int dfsAll(int start, int end) {
vector<bool> visited = vector<bool>(N + 1, false);
return dfs(start, end, visited);
}
int dfs(int start, int end, vector<bool> &visited) {
if (start == end) return 1;
visited[start] = true;
for (int i = 0; i < E[start].size(); i++) {
int v = E[start][i].first, c = E[start][i].second;
if (!visited[v]) {
if (dfs(v, end, visited)) return 1;
}
}
return 0;
}
void setA(int a, int b) { A[a] = b; }
int dfsAll2() {
vector<int> visited(N + 1, 0);
int i, j, seq = 0, ret = 0, a;
for (i = 1; i <= N; i++) dfs2(i, visited, ++seq);
for (i = 1; i <= N; i++) {
for (j = a = 0; j < E[i].size(); j++) {
a += E[i][j].second;
}
if (ret < a) ret = a;
}
return ret;
}
int dfs2(int start, vector<int> &visited, long long seq) {
visited[start] = seq;
int ret = A[start];
for (int i = 0; i < E[start].size(); i++) {
int v = E[start][i].first;
long long c = E[start][i].second;
if (visited[v] < seq) {
if (E[start][i].second == -1)
E[start][i].second = dfs2(v, visited, seq);
if (ret < E[start][i].second) ret = E[start][i].second;
}
}
return ret;
}
void g() {
int i, j, N, m, a, b, c, a2, b2, c2, lo, hi, mid, tmp, start, end;
scanf("%d%d", &N, &m);
DFS_Graph dg(N);
for (i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
dg.insert(a, b, 0);
}
scanf("%d", &m);
for (i = 0; i < m; i++) {
scanf("%d%d", &a, &b);
if (dg.dfsAll(a, b))
c = -1;
else if (dg.dfsAll(b, a))
c = 1;
else
c = 0;
printf("%d\n", c);
}
}
};
class DFS_Map {
vector<vector<int> > E;
int R, C;
public:
DFS_Map(int r, int c) {
R = r;
C = c;
E = vector<vector<int> >(R + 2, vector<int>(C + 2, 0));
}
void setRC(int r, int c, int w) { E[r][c] = w; }
int getRC(int r, int c) { return E[r][c]; }
void dfs(int rr, int cc, vector<vector<bool> > &visited) {
int i, r, c, v;
visited[rr][cc] = true;
for (i = 0; i < 4; i++) {
r = rr + dr[i];
c = cc + dc[i];
if (E[r][c] && !visited[r][c]) {
dfs(r, c, visited);
}
}
}
void dfsAll() {
vector<vector<bool> > visited =
vector<vector<bool> >(R + 2, vector<bool>(C + 2, 0));
int r, c;
for (r = 1; r <= R; r++)
for (c = 1; c <= C; c++)
if (!visited[r][c]) dfs(r, c, visited);
}
};
class BFS_Graph {
vector<vector<pair<int, int> > > E;
vector<int> IN;
int N;
public:
int is_cycle() {
for (int i = 1; i <= N; i++)
if (IN[i] > 0) return 1;
return 0;
}
BFS_Graph(int n) {
N = n;
E.clear();
IN.clear();
E = vector<vector<pair<int, int> > >(N + 1);
IN = vector<int>(N + 1, 0);
}
void insert(int u, int v, int w) {
E[u].push_back(make_pair(v, w));
IN[v]++;
}
void insert_fb(int u, int v, int w) {
E[u].push_back(make_pair(v, w));
E[v].push_back(make_pair(u, w));
}
vector<long long> bfs(int start, int end, int min_weight) {
vector<bool> visited = vector<bool>(N + 1, false);
vector<long long> weight(N + 1, 1000000000000007);
queue<int> Q;
visited[start] = true;
weight[start] = 0;
Q.push(start);
while (!Q.empty()) {
int u = Q.front(), w = weight[u];
if (u == end) break;
Q.pop();
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i].first, c = E[u][i].second;
if (c >= min_weight && !visited[v]) {
Q.push(v);
weight[v] = w + c;
visited[v] = true;
}
}
}
return weight;
}
vector<int> topologicalSort() {
vector<int> order;
queue<int> Q;
for (int i = 1; i <= N; i++)
if (!IN[i]) Q.push(i);
while (!Q.empty()) {
int u = Q.front();
Q.pop();
order.push_back(u);
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i].first;
if (IN[v] > 0) {
IN[v]--;
if (!IN[v]) Q.push(v);
}
}
}
return order;
}
vector<int> topologicalSortPQ() {
vector<int> order;
priority_queue<int> pq;
for (int i = 1; i <= N; i++)
if (!IN[i]) pq.push(-i);
while (!pq.empty()) {
int u = -pq.top();
pq.pop();
order.push_back(-u);
for (int i = 0; i < E[u].size(); i++) {
int v = E[u][i].first;
if (IN[v] > 0) {
IN[v]--;
if (!IN[v]) pq.push(-v);
}
}
}
return order;
}
int f() {
int v, u, i;
vector<int> IN2;
for (u = 1; u <= N; u++) {
for (i = 0; i < E[u].size(); i++) {
v = E[u][i].first;
if (IN[v] == 1) {
IN2 = IN;
IN[v]--;
topologicalSort();
if (!is_cycle()) return 1;
IN = IN2;
}
}
}
return 0;
}
void g() {
int i, j, N, m, a, b, c, a2, b2, c2, lo, hi, mid, tmp, start, end;
vector<tuple<int, int, int> > X;
vector<long long> y;
scanf("%d%d", &N, &m);
BFS_Graph bg(N);
X.reserve(m);
for (i = 0; i < m; i++) {
scanf("%d%d%d", &a, &b, &c);
if (a > b) tmp = a, a = b, b = tmp;
X.push_back(make_tuple(a, b, -c));
}
scanf("%d%d", &start, &end);
sort(X.begin(), X.end());
bg.insert_fb(get<0>(X[0]), get<1>(X[0]), -get<2>(X[0]));
for (i = 1; i < m; i++) {
a = get<0>(X[i - 1]);
b = get<1>(X[i - 1]);
c = get<2>(X[i - 1]);
a2 = get<0>(X[i]);
b2 = get<1>(X[i]);
c2 = get<2>(X[i]);
if (a == a2 && b == b2) continue;
bg.insert_fb(a2, b2, -c2);
}
lo = 1;
hi = 1000000007;
while (lo < hi) {
mid = (lo + hi + 1) / 2;
y = bg.bfs(start, end, mid);
if (y[end] < 1000000000000007) {
lo = mid;
} else {
hi = mid - 1;
}
}
printf("%d", lo);
}
};
class BFSMap {
vector<vector<int> > E;
int R, C;
public:
BFSMap(int r, int c) {
R = r;
C = c;
E = vector<vector<int> >(R + 2, vector<int>(C + 2, 0));
}
void setRC(int r, int c, int w) { E[r][c] = w; }
int getRC(int r, int c) { return E[r][c]; }
int bfsAll() {
int r, c, ret = 0;
vector<vector<int> > visited =
vector<vector<int> >(R + 2, vector<int>(C + 2, 0));
for (r = 1; r <= R; r++) {
for (c = 1; c <= C; c++) {
if (E[r][c] && !visited[r][c]) {
ret++;
bfs(r, c, visited);
}
}
}
return ret;
}
int bfsAll(vector<pair<int, int> > &Q) {
int i, r, c, ret = 0;
vector<vector<int> > visited =
vector<vector<int> >(R + 2, vector<int>(C + 2, 0));
for (i = 0; i < Q.size(); i++) {
r = Q[i].first;
c = Q[i].second;
if (!visited[r][c]) {
ret++;
bfs(r, c, visited);
}
}
return ret;
}
void bfs(int rr, int cc, vector<vector<int> > &visited) {
int i, r, c, r2, c2;
queue<pair<int, int> > Q;
Q.push(make_pair(rr, cc));
visited[rr][cc] = 1;
while (!Q.empty()) {
r = Q.front().first;
c = Q.front().second;
Q.pop();
for (i = 0; i < 4; i++) {
r2 = r + dr[i];
c2 = c + dc[i];
if (E[r2][c2] && !visited[r2][c2]) {
Q.push(make_pair(r2, c2));
visited[r2][c2] = visited[r][c] + 1;
}
}
}
}
void g() {
int i, j, r, c, r2, c2, R, C, a, ans = 0, idx = 0;
vector<pair<int, int> > Q[2];
vector<int> X;
scanf("%d%d", &R, &C);
BFSMap bm(R, C);
X.reserve(10004);
Q[0].reserve(10004);
Q[1].reserve(10004);
for (r = 1; r <= R; r++)
for (c = 1; c <= C; c++) {
scanf("%d", &a);
bm.setRC(r, c, a);
if (a) Q[0].push_back(make_pair(r, c));
}
while (1) {
a = bm.bfsAll(Q[idx]);
if (a > 1)
break;
else if (a == 0) {
ans = 0;
break;
}
ans++;
X.resize(0);
Q[1 - idx].resize(0);
for (i = 0; i < Q[idx].size(); i++) {
r = Q[idx][i].first;
c = Q[idx][i].second;
a = 0;
for (j = 0; j < 4; j++) {
r2 = r + dr[j];
c2 = c + dc[j];
if (bm.getRC(r2, c2) == 0) a++;
}
X.push_back(a);
}
for (i = 0; i < Q[idx].size(); i++) {
r = Q[idx][i].first;
c = Q[idx][i].second;
a = bm.getRC(r, c) - X[i];
if (a <= 0) {
a = 0;
} else {
Q[1 - idx].push_back(make_pair(r, c));
}
bm.setRC(r, c, a);
}
idx = 1 - idx;
}
printf("%d", ans);
}
};
class Number {
public:
Number() {}
int getDigitNum(long long xx) {
long long x;
int ret = 0;
for (x = 1; x < xx; x *= 10, ret++)
;
return ret;
}
int getDigitSum(int xx) {
int x, a = 0;
for (x = xx; x; x /= 10) a += (x % 10);
return a;
}
int getMSB(long long xx) {
int i;
for (i = 0; (1ll << i) <= xx; i++)
;
return i - 1;
}
long long convertBinaryToBase(long long x, int base) {
if (x == 0) return 0;
return base * convertBinaryToBase(x / 2, base) + (x % 2);
}
long long findFactor(long long k) {
for (long long d = 2; d * d <= k; d++)
if (k % d == 0) return d;
return 0;
}
};
class Palindrome {
public:
Palindrome() {}
int isPalindrome(long long xx) {
long long x;
int i, n;
vector<int> v;
for (x = xx; x > 0; x /= 10) {
v.push_back(x % 10);
}
n = v.size();
for (i = 0; i < n / 2; i++) {
if (v[i] != v[n - i - 1]) return 0;
}
return 1;
}
};
class BigNumber {
public:
BigNumber() {}
string add(string &s1, string &s2) {
int i, j, k, n1, n2, a;
string s3;
vector<int> v;
n1 = s1.size();
n2 = s2.size();
v.reserve(max(n1, n2) + 1);
for (i = n1 - 1, j = n2 - 1; i >= 0 && j >= 0; i--, j--) {
a = s1[i] - '0' + s2[j] - '0';
v.push_back(a);
}
while (i >= 0) {
a = s1[i] - '0';
v.push_back(a);
i--;
}
while (j >= 0) {
a = s2[j] - '0';
v.push_back(a);
j--;
}
for (i = 0, a = 0; i < v.size(); i++) {
a += v[i];
if (a >= 10) {
v[i] = a - 10;
a = 1;
} else {
v[i] = a;
a = 0;
}
}
if (a) v.push_back(a);
s3.reserve(v.size());
for (i = v.size() - 1; i >= 0; i--) s3 += (char)(v[i] + '0');
s3 += '\n';
return s3;
}
};
class PrimeNumber {
int N;
vector<int> NP, P;
public:
PrimeNumber() {}
PrimeNumber(int n) {
N = n;
NP.reserve(N + 4);
P.reserve(N / 4);
for (int i = 2; i * i <= N; i++) {
if (NP[i]) continue;
for (int j = i * i; j <= N; j += i) NP[i] = 1;
}
for (int i = 2; i <= N; i++)
if (!NP[i]) P.push_back(i);
}
long long gcd(long long x, long long y) {
long long z;
while (x) {
z = y % x;
y = x;
x = z;
}
return y;
}
vector<int> factorization(int x) {
vector<int> ret;
int i;
if (x == 1) {
ret.push_back(1);
return ret;
}
ret.push_back(1);
ret.push_back(x);
for (i = 2; i * i < x; i++) {
if (x % i == 0) {
ret.push_back(i);
ret.push_back(x / i);
}
}
if (i * i == x) ret.push_back(i);
return ret;
}
int factorization2(int x) {
int ret = 0, i;
if (x == 1) {
return 1;
}
ret = 2;
for (i = 2; i * i < x; i++) {
if (x % i == 0) {
ret += 2;
}
}
if (i * i == x) ret++;
return ret;
}
};
class BitOperation {
public:
BitOperation() {}
int getOneBitNum(int xx) {
int a = 0, x;
for (x = xx; x; x = x & (x - 1)) a++;
return a;
}
};
class Comb {
vector<vector<long long> > C;
vector<long long> F;
int N;
public:
Comb(int n) {
N = n;
C.resize(N + 1);
for (int i = 0; i <= N; i++) C[i].resize(i + 1);
for (int i = 0; i <= N; i++) C[i][i] = C[i][0] = 1;
for (int i = 1; i <= N; i++)
for (int j = 1; j < i; j++)
C[i][j] = (C[i - 1][j - 1] + C[i - 1][j]) % 998244353;
F.resize(N + 1);
F[0] = F[1] = 1;
for (int i = 1; i <= n; i++) F[i] = (F[i - 1] * i) % 998244353;
}
long long getC(int n, int r) { return C[n][r]; }
long long getF(int n) { return F[n]; }
long long get_comb(int n, int r) {
if (n == r || r == 0) return 1;
if (n <= 1000) return getC(n, r);
long long ret = 1;
int i;
if (r > n / 2) r = n - r;
for (i = n; i > n - r; i--) ret *= i;
for (i = 2; i <= r; i++) ret /= i;
return ret;
}
};
class Sort {
vector<int> tmp;
int N;
public:
Sort(int n) {
N = n;
tmp.reserve(n + 4);
}
void merge_sort(vector<int> &x, int lo, int hi) {
if (lo >= hi) return;
int i, j, k, mid = (lo + hi) / 2;
merge_sort(x, lo, mid);
merge_sort(x, mid + 1, hi);
for (i = lo, j = mid + 1, k = lo; i <= mid && j <= hi; k++) {
if (x[i] < x[j])
tmp[k] = x[i++];
else
tmp[k] = x[j++];
}
if (i <= mid) {
for (; i <= mid; i++, k++) tmp[k] = x[i];
}
if (j <= hi) {
for (; j <= hi; j++, k++) tmp[k] = x[j];
}
for (i = lo; i <= hi; i++) x[i] = tmp[i];
}
};
class PSum {
PSum() {}
vector<int> makeSum(const vector<int> &a, int n) {
vector<int> ret(a.size());
ret[0] = a[0];
for (int i = 1; i < a.size(); ++i) ret[i] = ret[i - 1] + a[i];
return ret;
}
vector<vector<int> > makeSum(const vector<vector<int> > &a, int n, int m) {
vector<vector<int> > ret(n, vector<int>(m));
int i, j;
for (i = 0; i < n; i++) ret[i][0] = a[i][0];
for (i = 0; i < n; i++) {
for (j = 1; j < m; j++) {
ret[i][j] = ret[i][j - 1] + a[i][j];
}
}
}
int getSum(const vector<int> &psum, int a, int b) {
if (a == 0) return psum[b];
return psum[b] - psum[a - 1];
}
int getSum(const vector<vector<int> > &psum, int r1, int c1, int r2, int c2) {
int ret = psum[r2][c2];
if (r1 > 0) ret -= psum[r1 - 1][c2];
if (c1 > 0) ret -= psum[r2][c1 - 1];
if (r1 > 0 && c1 > 0) ret += psum[r1 - 1][c1 - 1];
return ret;
}
};
class DisjointSet {
int N;
vector<int> P, R, A;
public:
DisjointSet(int n) {
N = n;
P = vector<int>(n + 1);
R = vector<int>(n + 1);
A = vector<int>(n + 1);
for (int i = 1; i <= n; i++) P[i] = i, R[i] = 0, A[i] = 1;
}
int getA(int x) { return A[x]; }
int find_set(int x) {
if (P[x] == x) return x;
int pa = find_set(P[x]);
return P[x] = pa;
}
int union_set(int x, int y) {
int px, py;
px = find_set(x);
py = find_set(y);
if (px == py) return px;
if (R[px] > R[py]) {
P[py] = px;
A[px] += A[py];
return px;
} else {
P[px] = py;
A[py] += A[px];
if (R[px] == R[py]) R[py]++;
return py;
}
}
};
class LIS {
int N, BI;
vector<int> A;
public:
LIS(int n) {
N = n;
A = vector<int>(n);
}
void setA(int x, int y) { A[x] = y; }
int execute() {
int i, lo, hi, x, vi;
vector<int> v = vector<int>(N, 0);
vi = -1;
v[++vi] = A[0];
for (i = 1; i < N; i++) {
if (A[i] > v[vi]) {
v[++vi] = A[i];
continue;
}
for (lo = 0, hi = vi; lo < hi;) {
if (v[(lo + hi) / 2] >= A[i])
hi = (lo + hi) / 2;
else
lo = (lo + hi) / 2 + 1;
}
v[hi] = A[i];
}
return vi + 1;
}
vector<int> execute2(int &len) {
vector<int> v, v1, p, ret;
int i, j;
v.push_back(A[0]);
v1.push_back(0);
p = vector<int>(N, -1);
for (int i = 1; i < A.size(); i++) {
if (v.back() < A[i]) {
p[i] = v1.back();
v.push_back(A[i]);
v1.push_back(i);
} else {
vector<int>::iterator itr = lower_bound(v.begin(), v.end(), A[i]);
*itr = A[i];
int idx = itr - v.begin();
if (idx != 0) {
p[i] = v1[idx - 1];
}
v1[idx] = i;
}
}
len = v1.size();
ret = vector<int>(len);
for (i = v1.back(), j = len - 1; i != -1; i = p[i], j--) ret[j] = A[i];
return ret;
}
int execute3() {
int i, j, ret = 0;
vector<int> v = vector<int>(N, 0);
for (i = 0; i < A.size(); i++) {
for (j = 0; j < i; j++)
if (A[j] < A[i] && v[i] < v[j]) v[i] = v[j];
v[i]++;
}
for (i = 0; i < v.size(); i++)
if (v[i] > ret) ret = v[i];
return ret;
}
void g() {
int T, i, j, k, a, b, c, d, e, f, g, n, m, x, y, z;
long long il, jl, kl, al, bl, cl, dl, nl, ml, xl, yl;
vector<int> v, v1, v2, v3, v4;
vector<unsigned int> v5, v6;
string s1, s2;
vector<string> vs;
scanf("%d", &n);
v1 = vector<int>(n);
LIS li(n);
for (i = 0; i < n; i++) {
scanf("%d", &v1[i]);
li.setA(i, v1[i]);
}
v = li.execute2(x);
printf("%d\n", x);
for (i = 0; i < v.size(); i++) printf("%d ", v[i]);
}
};
class SegmentTreeSum {
vector<long long> ST;
vector<int> A;
int N;
long long _init(vector<int> &a, int left, int right, int node) {
if (left == right) return ST[node] = a[left];
int mid = (left + right) / 2;
long long lv = _init(a, left, mid, node * 2),
rv = _init(a, mid + 1, right, node * 2 + 1);
return ST[node] = lv + rv;
}
long long _query(int left, int right, int node, int nodeLeft, int nodeRight) {
if (right < nodeLeft || nodeRight < left) return 0;
if (left <= nodeLeft && nodeRight <= right) return ST[node];
int mid = (nodeLeft + nodeRight) / 2;
long long lv = _query(left, right, node * 2, nodeLeft, mid),
rv = _query(left, right, node * 2 + 1, mid + 1, nodeRight);
return lv + rv;
}
long long _update(int index, int newValue, int node, int nodeLeft,
int nodeRight) {
if (index < nodeLeft || nodeRight < index) return ST[node];
if (nodeLeft == nodeRight) return ST[node] = newValue;
int mid = (nodeLeft + nodeRight) / 2;
long long lv = _update(index, newValue, node * 2, nodeLeft, mid),
rv = _update(index, newValue, node * 2 + 1, mid + 1, nodeRight);
return ST[node] = lv + rv;
}
public:
SegmentTreeSum(int n) {
N = n;
ST = vector<long long>(n * 4 + 4);
A = vector<int>(n + 4);
}
void setA(int x, int y) { A[x] = y; }
void init() { _init(A, 1, N, 1); }
long long query(int left, int right) { return _query(left, right, 1, 1, N); }
long long update(int index, int newValue) {
return _update(index, newValue, 1, 1, N);
}
};
class SegmentTreeMin {
vector<long long> ST;
vector<int> A;
int N;
long long _init(vector<int> &a, int left, int right, int node) {
if (left == right) return ST[node] = a[left];
int mid = (left + right) / 2;
long long lv = _init(a, left, mid, node * 2),
rv = _init(a, mid + 1, right, node * 2 + 1);
return ST[node] = min(lv, rv);
}
long long _query(int left, int right, int node, int nodeLeft, int nodeRight) {
if (right < nodeLeft || nodeRight < left) return 1000000007;
if (left <= nodeLeft && nodeRight <= right) return ST[node];
int mid = (nodeLeft + nodeRight) / 2;
long long lv = _query(left, right, node * 2, nodeLeft, mid),
rv = _query(left, right, node * 2 + 1, mid + 1, nodeRight);
return min(lv, rv);
}
long long _update(int index, int newValue, int node, int nodeLeft,
int nodeRight) {
if (index < nodeLeft || nodeRight < index) return ST[node];
if (nodeLeft == nodeRight) return ST[node] = newValue;
int mid = (nodeLeft + nodeRight) / 2;
long long lv = _update(index, newValue, node * 2, nodeLeft, mid),
rv = _update(index, newValue, node * 2 + 1, mid + 1, nodeRight);
return ST[node] = min(lv, rv);
}
public:
SegmentTreeMin(int n) {
N = n;
ST = vector<long long>(n * 4 + 4);
A = vector<int>(n + 4);
}
void setA(int x, int y) { A[x] = y; }
void init() { _init(A, 1, N, 1); }
long long query(int left, int right) { return _query(left, right, 1, 1, N); }
long long update(int index, int newValue) {
return _update(index, newValue, 1, 1, N);
}
};
class SegmentTreeMax {
vector<long long> ST;
vector<int> A;
int N;
long long _init(vector<int> &a, int left, int right, int node) {
if (left == right) return ST[node] = a[left];
int mid = (left + right) / 2;
long long lv = _init(a, left, mid, node * 2),
rv = _init(a, mid + 1, right, node * 2 + 1);
return ST[node] = max(lv, rv);
}
long long _query(int left, int right, int node, int nodeLeft, int nodeRight) {
if (right < nodeLeft || nodeRight < left) return 0;
if (left <= nodeLeft && nodeRight <= right) return ST[node];
int mid = (nodeLeft + nodeRight) / 2;
long long lv = _query(left, right, node * 2, nodeLeft, mid),
rv = _query(left, right, node * 2 + 1, mid + 1, nodeRight);
return max(lv, rv);
}
long long _update(int index, int newValue, int node, int nodeLeft,
int nodeRight) {
if (index < nodeLeft || nodeRight < index) return ST[node];
if (nodeLeft == nodeRight) return ST[node] = newValue;
int mid = (nodeLeft + nodeRight) / 2;
long long lv = _update(index, newValue, node * 2, nodeLeft, mid),
rv = _update(index, newValue, node * 2 + 1, mid + 1, nodeRight);
return ST[node] = max(lv, rv);
}
public:
SegmentTreeMax(int n) {
N = n;
ST = vector<long long>(n * 4 + 4);
A = vector<int>(n + 4);
}
void setA(int x, int y) { A[x] = y; }
void init() { _init(A, 1, N, 1); }
long long query(int left, int right) { return _query(left, right, 1, 1, N); }
long long update(int index, int newValue) {
return _update(index, newValue, 1, 1, N);
}
};
int L[20], R[20], N, M;
int f(int ff, int pp) {
if (ff == N) {
if (!pp) return R[ff];
return M - L[ff] + 1;
}
if (!pp) {
return min(f(ff + 1, 1) + M + 2, f(ff + 1, 0) + R[ff] * 2 + 1);
} else {
return min(f(ff + 1, 0) + M + 2, f(ff + 1, 1) + (M - L[ff] + 1) * 2 + 1);
}
}
int main() {
int i, j, k, n, m, A[4][4];
char str[200];
scanf("%d%d", &n, &M);
N = 0;
for (i = n; i >= 1; i--) {
scanf("%s\n", str);
for (j = 1; j <= M && str[j] == '0'; j++)
;
if (j > M) {
L[i] = M + 1;
R[i] = 0;
continue;
}
if (!N) N = i;
L[i] = j;
for (j = M; j >= 1 && str[j] == '0'; j--)
;
R[i] = j;
}
if (!N)
printf("0");
else
printf("%d", f(1, 0));
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
int P1 = 1e9 + 7;
int P2 = 1e9 + 9;
int pw[(int)4e4 + 100], pw2[(int)4e4 + 100];
vector<int> pos[300];
int main() {
int n;
scanf("%d", &n);
int N = n * (n - 1) / 2;
if (n == 2) {
int k, x;
scanf("%d%d", &k, &x);
printf("1 %d\n%d", x, k - 1);
for (int i = 0; i < k - 1; i++) {
scanf("%d", &x);
printf(" %d", x);
}
printf("\n");
return 0;
}
pw[0] = pw2[0] = 1;
for (int i = 1; i <= N; i++)
pw[i] = (pw[i - 1] * 10007LL) % P1, pw2[i] = (pw2[i - 1] * 10007LL) % P2;
int k, x;
for (int i = 0; i < N; i++) {
scanf("%d", &k);
for (int j = 0; j < k; j++) {
scanf("%d", &x);
pos[x].push_back(i);
}
}
map<pair<int, int>, vector<int> > ans;
for (int i = 1; i <= 200; i++) {
if (pos[i].empty()) continue;
int cur = 0, cur2 = 0;
for (auto x : pos[i]) {
cur = (cur + pw[x]) % P1;
cur2 = (cur2 + pw2[x]) % P2;
}
ans[make_pair(cur, cur2)].push_back(i);
}
for (auto x : ans) {
printf("%d", x.second.size());
for (auto num : x.second) printf(" %d", num);
printf("\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
set<long long> used;
int main() {
long long a, b, c;
long long x, y, z;
long long hc;
long long sol, sag;
long long res = 0;
cin >> a >> b >> x >> y;
for (int i = 30; i >= 0; i--) {
hc = (1LL << i);
c = (a / hc + 1) * hc;
z = (x / hc + 1) * hc;
if (a % hc == 0) c -= hc;
if (x % hc == 0) z -= hc;
if (z % (2LL << i) == 0) z += hc;
if (c % (2LL << i) == 0) c += hc;
for (long long l = 1, r = c; l <= 3 && r <= b; l++, r += hc * 2)
for (long long j = 1, t = z; j <= 3 && t <= y; j++, t += hc * 2) {
sol = (1LL << i) - 1LL;
sol = min(sol, (r - a));
sol = min(sol, (t - x));
sag = (1LL << i) - 1LL;
sag = min(sag, (b - r));
sag = min(sag, (y - t));
if (sol + sag + 1LL > res) {
res = sol + sag + 1;
}
}
}
cout << res << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 10;
const long long inf = -1e18;
const long long INF = 1e18;
const long long mod = 1e9 + 7;
const double PI = acos(-1);
string a, b;
int l, r, f, ans = 80000, cnt, z[5010];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
cin >> a >> b;
for (int i = 0; i < b.size(); i++) a += "4";
for (int i = 0; i < b.size(); i++) a = "4" + a;
for (int i = 0; i < a.size(); i++) {
int k = 0;
for (int j = 0; j < b.size(); j++) {
if (i + j >= a.size()) {
goto go;
}
if (a[i + j] != b[j]) k++;
}
ans = min(ans, k);
}
go:;
cout << ans;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int iid[500060];
struct node {
int w, id;
} a[500060];
bool cmp(node x, node y) { return x.w < y.w; }
int find(int x, int &len, int &fl) {
if (fl == 1) {
int l = x, r = n, mid;
while (l < r) {
mid = (l + r + 1) >> 1;
if (a[mid].w - a[x].w <= len)
l = mid;
else
r = mid - 1;
}
len -= a[l].w - a[x].w;
fl ^= 1;
return l;
} else {
int l = 1, r = x, mid;
while (l < r) {
mid = (l + r) >> 1;
if (a[x].w - a[mid].w > len)
l = mid + 1;
else
r = mid;
}
len -= a[x].w - a[l].w;
fl ^= 1;
return l;
}
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].w);
a[i].id = i;
}
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; ++i) iid[a[i].id] = i;
while (m--) {
int x, len;
scanf("%d%d", &x, &len);
x = iid[x];
int nw = x, ls = 0, fl = 1;
int L = find(nw, len, fl);
ls = nw;
nw = L;
while ((L = find(nw, len, fl)) && L != nw) {
if (ls == L) {
int dl = abs(a[L].w - a[nw].w);
if (((len / dl) & 1) == 0)
ls = nw, nw = L;
else
fl ^= 1;
len %= dl;
} else {
ls = nw, nw = L;
}
}
printf("%d\n", a[nw].id);
}
}
| 4 |
#include <iostream>
using namespace std;
int main(void){
int n;
cin>>n;
cout<<((n/10 == 9 || n%10 == 9)?"Yes":"No")<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int c[1 << 22], pre[1 << 22], a[1 << 22], n, m, ans[25], d[25], r, t;
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
u--;
v--;
d[u] |= (1 << v);
d[v] |= (1 << u);
}
if (m == n * (n - 1) / 2) {
cout << 0 << endl;
return 0;
}
memset(a, -1, sizeof(a));
memset(pre, -1, sizeof(pre));
for (int i = 0; i < n; i++) a[1 << i] = 0;
for (int i = 0; i < (1 << n); i++) {
if (a[i] == -1) continue;
for (int j = 0; j < n; j++)
if (i & (1 << j)) {
r = i | d[j];
if (a[r] == -1 || a[r] > a[i] + 1)
a[r] = a[i] + 1, pre[r] = j, c[r] = i;
}
}
t = (1 << n) - 1;
r = 0;
while (pre[t] != -1) ans[++r] = pre[t], t = c[t];
cout << r << endl;
for (int i = r; i; i--) printf("%d ", ans[i] + 1);
printf("\n");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long arr[100000];
int main() {
long long maxi = 0;
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
maxi = max(maxi, arr[i]);
}
long long left = maxi;
long long right = 10000000000LL;
while (left < right) {
long long midd = (left + right) / 2;
long long all = 0;
for (int i = 0; i < n; i++) {
all += midd - arr[i];
}
if (all >= midd) {
right = midd;
} else {
left = midd + 1;
}
}
cout << left << "\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long z1, z2, l, m1, m2, l2;
long long B, W;
long long n, x, y;
cin >> n;
cin >> x >> y;
z1 = (x - 1) + (y - 1);
W = z1;
m1 = (n - x) + (n - y);
B = m1;
if (n >= 2 && x >= 1 && y >= 1 && x <= n && y <= n)
if (W < B)
cout << "White";
else if (B < W)
cout << "Black";
else if (B == W)
cout << "White";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int K = 700;
const double eps = 1e-20;
double dp[K], p[K];
int main() {
int n, k;
scanf("%d%d", &n, &k);
p[1] = 1;
for (int i = 1; i <= n; i++)
for (int j = min(i + 1, K - 1); j >= 1; j--) {
int t = j * k;
dp[j] = (t + k - 1) * dp[j] / (t + k) + p[j] * j / (2 * k) +
(dp[j - 1] / t) + p[j - 1] * (j - 1) / t;
p[j] = p[j] * (t + k - 1) / (t + k) + p[j - 1] / t;
if (dp[j] < eps) dp[j] = 0;
if (p[j] < eps) p[j] = 0;
}
double ans = 0;
for (int i = 0; i < K; i++) ans += dp[i];
printf("%.10f\n", ans * k);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:102400000,102400000")
const int mod = 1000000007;
const int N = 100000 + 10;
const int MAGIC = 350;
int n, m, q, cnt;
vector<int> y[N];
int sz[N], to[N];
int delta[N][MAGIC];
int idx[N];
long long sum[N], col[N], a[N];
bool has[MAGIC][N];
char s[10];
void solve() {
int limit = 0;
for (int i = 0; i < m; i++) limit += sz[i];
limit = sqrt(limit * 1.0);
cnt = 0;
memset(to, -1, sizeof(to));
for (int i = 0; i < m; i++) {
if (sz[i] >= limit) {
to[i] = cnt;
idx[cnt] = i;
for (int j = 0; j < sz[i]; j++) {
has[cnt][y[i][j]] = 1;
}
cnt++;
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < sz[i]; j++) {
int x = y[i][j];
for (int k = 0; k < cnt; k++) {
if (has[k][x]) delta[i][k]++;
}
}
}
while (q--) {
scanf("%s", s);
int k, plus;
scanf("%d", &k);
k--;
if (s[0] == '?') {
long long ans = 0;
if (to[k] == -1) {
for (int i = 0; i < sz[k]; i++) {
int x = y[k][i];
ans += a[x];
}
for (int i = 0; i < cnt; i++) {
ans += col[i] * delta[k][i];
}
} else {
ans = sum[k];
for (int i = 0; i < cnt; i++) {
ans += col[i] * delta[k][i];
}
}
printf("%I64d\n", ans);
} else {
scanf("%d", &plus);
if (to[k] == -1) {
for (int i = 0; i < sz[k]; i++) {
int x = y[k][i];
a[x] += plus;
}
for (int j = 0; j < cnt; j++) {
sum[idx[j]] += delta[k][j] * plus;
}
} else {
col[to[k]] += plus;
}
}
}
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= n; i++) {
scanf("%I64d", &a[i]);
}
for (int i = 0; i < m; i++) {
int x;
scanf("%d", &x);
sz[i] = x;
for (int j = 0; j < sz[i]; j++) {
scanf("%d", &x);
y[i].push_back(x);
sum[i] += a[x];
}
}
solve();
return 0;
}
| 3 |
#include<iostream>
#include<queue>
#include<map>
#include<cstring>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<string>
#include<cstdio>
#include<iostream>
using namespace std;
#define fr first
#define sc second
#define INF 100
typedef pair<int,int>Pt;
int main(){
unsigned long long r=0,l=0,q,a,b;
string op;
cin >> q;
while(q--){
cin >> a >> op >> b;
if(op=="(") r += b;
else l += b;
cout << ( r==l ? "Yes" : "No") << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int result[100005];
int dp[100005][3];
int main() {
int length;
cin >> length;
char c;
for (int i = 0; i < length; i++) {
cin >> c;
result[i] = c - '0';
}
dp[0][0] = 1;
dp[0][1] = 1;
dp[0][2] = 0;
for (int i = 1; i < length; i++) {
if (result[i - 1] != result[i]) {
dp[i][0] = dp[i - 1][0] + 1;
dp[i][1] = dp[i - 1][1] + 1;
dp[i][2] = dp[i - 1][2] + 1;
} else {
dp[i][0] = dp[i - 1][0];
dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] + 1);
dp[i][2] = max(dp[i - 1][2], dp[i - 1][1] + 1);
}
}
cout << max(dp[length - 1][1], dp[length - 1][2]) << endl;
}
| 3 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.