solution
stringlengths 53
181k
| difficulty
int64 0
27
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
vector<string> split(const string& s, char c) {
vector<string> v;
stringstream ss(s);
string x;
while (getline(ss, x, c)) v.emplace_back(x);
return move(v);
}
void err(vector<string>::iterator it) {}
template <typename T, typename... Args>
void err(vector<string>::iterator it, T a, Args... args) {
cerr << it->substr((*it)[0] == ' ', it->length()) << " = " << a << '\n';
err(++it, args...);
}
const int NMAX = 405;
bitset<NMAX> bt[NMAX][NMAX][26], ans;
int n, m, r, c;
string a[NMAX], b[NMAX];
void Prep() {
for (int i = 0; i < n; i++)
for (int s = 0; s < m; s++)
for (int j = 0; j < m; j++) bt[i][s][a[i][j] - 'a'].set((j - s + m) % m);
}
void Go(int poz) {
ans.set();
for (int i = 0; i < r; i++) {
int row = (poz + i) % n;
for (int j = 0; j < c; j++)
if (b[i][j] != '?') ans &= bt[row][j % m][b[i][j] - 'a'];
}
}
int main() {
cin.sync_with_stdio(false);
int i, j;
cin >> n >> m;
for (i = 0; i < n; i++) cin >> a[i];
cin >> r >> c;
for (i = 0; i < r; i++) cin >> b[i];
Prep();
for (i = 0; i < n; i++) {
Go(i);
for (j = 0; j < m; j++) cout << ans[j];
cout << "\n";
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e2 + 200;
const int inf = 0x3f3f3f3f;
const double eps = 1e-7;
const double pi = acos(-1.0);
const int mod = 1e9 + 7;
inline int lowbit(int x) { return x & (-x); }
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
void ex_gcd(long long a, long long b, long long &d, long long &x,
long long &y) {
if (!b) {
d = a, x = 1, y = 0;
} else {
ex_gcd(b, a % b, d, y, x);
y -= x * (a / b);
}
}
inline long long qpow(long long a, long long b, long long MOD = mod) {
long long res = 1;
a %= MOD;
while (b > 0) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return res;
}
inline long long inv(long long x, long long p) { return qpow(x, p - 2, p); }
inline long long Jos(long long n, long long k, long long s = 1) {
long long res = 0;
for (int i = 1; i <= n + 1; ++i) res = (res + k) % i;
return (res + s) % n;
}
inline int read() {
int f = 1;
int x = 0;
char ch = getchar();
while (ch > '9' | ch < '0') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9')
x = (x << 3) + (x << 1) + ch - '0', ch = getchar();
return x * f;
}
int dir[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
int a[maxn];
int d[maxn * maxn];
int Map[1000000 + 500];
int main() {
int kase;
kase = read();
while (kase--) {
long long n = read();
memset(Map, 0, sizeof(Map));
int flag = 1;
for (int i = 1; i <= n; ++i) {
a[i] = read(), Map[a[i]]++;
if (Map[a[i]] > 1) flag = 0;
}
sort(a + 1, a + 1 + n);
d[1] = 1;
int pos = 1;
for (int i = 1; i <= n; ++i)
for (int j = i + 1; j <= n; ++j) {
Map[a[j] - a[i]] = 1;
}
for (int i = 2; i <= 1e6; ++i) {
if (pos >= n) break;
int flag1 = 1;
for (int j = 1; j <= pos; ++j) {
if (Map[i - d[j]]) {
flag1 = 0;
break;
}
}
if (flag1) {
d[++pos] = i;
}
if (pos >= n) break;
}
if (pos == n) {
printf("YES\n");
for (int i = 1; i <= pos; ++i) printf("%d ", d[i]);
puts("\n");
} else
printf("NO\n");
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
long long int powmod(long long int a, long long int e) {
if (e == 0) return 1;
long long int x = powmod(a * a % 1000000007, e >> 1);
return e & 1 ? x * a % 1000000007 : x;
}
long long int b[(long long int)100001];
multiset<long long int> st[60];
vector<long long int> v;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int n;
cin >> n;
for (long long int i = 0; i < n; i++) {
cin >> b[i];
long long int bit;
for (bit = 59; bit >= 0; bit--)
if ((1ll << bit) & b[i]) break;
st[bit].insert(b[i]);
}
long long int ans = 0;
for (long long int i = 0; i < n; i++) {
long long int mini = (1ll << 60);
long long int flag = 0;
long long int ansbit;
for (long long int bit = 59; bit >= 0; bit--) {
if (st[bit].empty()) continue;
if (!(ans & (1ll << bit))) {
flag = 1;
if (*st[bit].begin() < mini) {
ansbit = bit;
mini = *st[bit].begin();
}
}
}
if (flag == 0) {
cout << "No";
return 0;
}
st[ansbit].erase(st[ansbit].begin());
ans = ans xor mini;
v.push_back(mini);
}
cout << "Yes\n";
for (long long int i = 0; i < n; i++) cout << v[i] << " ";
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
long long gao(long long n, long long p) {
long long ret;
if (p & 1)
ret = (p + 1) >> 1;
else {
long long cnt = n >> 1;
long long np = ((p >> 1) - cnt) % (n - cnt);
if (np <= 0) np += n - cnt;
ret = cnt + gao(n - cnt, np);
}
return ret;
}
long long n, m;
int main() {
scanf("%lld%lld", &n, &m);
for (int i = (0); i < (m); ++i) {
long long p;
scanf("%lld", &p);
printf("%lld\n", gao(n, p));
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
vector<int> v[200005];
int col = 1;
int ans = 0, visited[200005] = {0}, colour[200005];
void dfs(int node, int pcol) {
visited[node] = 1;
col = 1;
for (int i = 0; i < (int)v[node].size(); i++) {
if (visited[v[node][i]] == 0) {
if (pcol == col || colour[node] == col) col++;
if (pcol == col || colour[node] == col) col++;
colour[v[node][i]] = col;
dfs(v[node][i], colour[node]);
col = colour[v[node][i]] + 1;
ans = (ans) >= (col - 1) ? ans : col - 1;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
v[x].push_back(y);
v[y].push_back(x);
}
colour[1] = 1;
dfs(1, 1);
cout << ans << '\n';
for (int i = 1; i < n + 1; i++) cout << colour[i] << " ";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T abs(T a) {
return a < 0 ? -a : a;
}
const int INF = (int)1e9;
const double PI = 3.1415926535897932384626433832795;
const int N = 0;
vector<string> v;
string tp, s;
int n;
int main() {
scanf("%d", &n);
while (n--) {
cin >> tp;
if (tp == "pwd") {
for (int i = 0; i < v.size(); i++) cout << "/" << v[i];
puts("/");
} else {
cin >> s;
s += '/';
if (s[0] == '/') {
v.clear();
string t = "";
for (int i = 1; i < s.size(); i++) {
if (s[i] == '/') {
if (t == ".." && v.size() > 0)
v.pop_back();
else
v.push_back(t);
t = "";
} else
t += s[i];
}
} else {
string t = "";
for (int i = 0; i < s.size(); i++) {
if (s[i] == '/') {
if (t == ".." && v.size() > 0)
v.pop_back();
else
v.push_back(t);
t = "";
} else
t += s[i];
}
}
}
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
map<int, bool> mp;
vector<int> v;
int arr[100000], cnt = 0, sum = 0;
int ans;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
mp[arr[i]] = true;
}
int i = 1;
while (k >= i) {
if (!mp[i]) k -= i, v.push_back(i);
i++;
}
cout << v.size() << "\n";
for (int i = 0; i < v.size(); i++) cout << v[i] << " ";
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
int main()
{
ll t;
cin>>t;
while(t--)
{
ll n,sum=0;
cin>>n;
n=n+2;
map<ll,ll> mp;
ll arr[n],i,a,b,f=0,j;
for(i=0;i<n;i++)
{
cin>>arr[i];
mp[arr[i]]++;
sum=sum+arr[i];
}
sort(arr,arr+n);
for(i=0;i<n;i++)
{
sum=sum-arr[i];
if(sum%2==0)
{
a=sum/2;
if(a==arr[i])
{
if(mp[a]>=2)
{
b=arr[i];
f=1;
break;
}
}
else if(mp[a]>=1)
{
b=arr[i];
f=1;
break;
}
}
sum=sum+arr[i];
}
ll g=0,h=0;
if(f==0)
cout<<-1<<endl;
else
{
for(i=0;i<n;i++)
{
if(a==arr[i] && g==0)
{
g=1;
continue;
}
else if(b==arr[i] && h==0)
{
h=1;
continue;
}
else
cout<<arr[i]<<" ";
}
cout<<endl;
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void smax(T &x, T y) {
x = max((x), (y));
}
template <class T>
inline void smin(T &x, T y) {
x = min((x), (y));
}
const int MOD = 1e9 + 7;
const int SIZE = 1e5 + 10;
const long long INF = 1e15;
int n, m, t;
int calcsecs(string &str) {
for (int i = 0; i < (((int)(str).size())); ++i)
if (str[i] == ':') str[i] = ' ';
stringstream SS;
SS << str;
int hh, mm, ss;
SS >> hh >> mm >> ss;
return hh * 60 * 60 + mm * 60 + ss;
}
int main() {
if (0) {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
}
while (cin >> n >> m >> t) {
vector<pair<int, int> > ans;
int st = 0, ed = 0;
int z = 0;
bool ok = false;
while (n--) {
string s;
cin >> s;
int secs = calcsecs(s);
while (st < ed && ans[st].second <= secs) st++;
if (st == ed) {
z++;
ans.push_back(make_pair(z, secs + t));
ed++;
} else {
int i = ans[st].first, j = ans[ed - 1].first;
if (j - i + 1 < m) {
z++;
ans.push_back(make_pair(z, secs + t));
ed++;
} else {
ans.push_back(make_pair(j, secs + t));
ed++;
}
}
int i = ans[st].first, j = ans[ed - 1].first;
if (j - i + 1 == m) ok = true;
}
if (!ok)
printf("No solution\n");
else {
printf("%d\n", z);
for (int i = 0; i < (((int)(ans).size())); ++i)
printf("%d\n", ans[i].first);
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 400010;
int T, m;
long long n, K, a[maxn];
int main() {
scanf("%d", &T);
while (T--) {
scanf("%lld %d %lld", &n, &m, &K);
for (int i = 1; i <= m; i++) {
scanf("%lld", &a[i]);
}
a[++m] = n;
for (int i = m; i; i--) {
a[i] -= a[i - 1];
}
long long l = 1, r = *min_element(a + 1, a + m + 1), lmax, rmin;
while (l <= r) {
long long mid = (l + r) >> 1, sum = 0;
for (int i = 1; i <= m; i++) {
sum += a[i] / mid - 1;
}
sum >= K ? l = (lmax = mid) + 1 : r = mid - 1;
}
l = 1, r = *max_element(a + 1, a + m + 1);
while (l <= r) {
long long mid = (l + r) >> 1, sum = 0;
for (int i = 1; i <= m; i++) {
sum += (a[i] + mid - 1) / mid - 1;
}
sum <= K ? r = (rmin = mid) - 1 : l = mid + 1;
}
if (lmax >= rmin) {
printf("0\n");
continue;
}
vector<pair<long long, long long>> V = {{lmax, rmin}};
for (int i = 1; i <= m; i++) {
long long foo = a[i] / lmax, bar = (a[i] + rmin - 1) / rmin;
if (foo >= bar) continue;
V.emplace_back(a[i] / (foo + 1), (a[i] - 1) / (bar - 1) + 1);
}
sort(V.begin(), V.end());
long long ans = LLONG_MAX, cur = rmin;
for (int i = 0; i < V.size(); i++) {
ans = min(ans, cur - V[i].first);
cur = max(cur, V[i].second);
}
printf("%lld\n", ans);
}
return 0;
}
| 25 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int a[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
int ans = 0;
for (int i = 1, j = 1; i <= n; ++i) {
if (i > j && a[i] < a[i - 1]) j = i;
ans = max(ans, i - j + 1);
}
printf("%d\n", ans);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct rect {
long long l, r, u, d;
rect() { l = 0, r = 0, u = 0, d = 0; }
rect(long long a, long long b, long long c, long long d1) {
l = a, r = b, u = c, d = d1;
}
};
long long n;
vector<pair<rect, long long>> a;
void read() {
cin >> n;
for (long long i = 0; i < n; i++) {
rect help;
long long a1, b1, c1, d1;
cin >> a1 >> b1 >> c1 >> d1;
help.l = a1;
help.d = b1;
help.r = c1;
help.u = d1;
a.push_back({help, i});
}
}
bool cmp_l(pair<rect, long long> a, pair<rect, long long> b) {
return a.first.l > b.first.l;
}
bool cmp_r(pair<rect, long long> a, pair<rect, long long> b) {
return a.first.r < b.first.r;
}
bool cmp_d(pair<rect, long long> a, pair<rect, long long> b) {
return a.first.d > b.first.d;
}
bool cmp_u(pair<rect, long long> a, pair<rect, long long> b) {
return a.first.u < b.first.u;
}
vector<bool> used;
bool check_l(vector<pair<rect, long long>> &st1,
vector<pair<rect, long long>> &st2, long long &maxR) {
while (!st1.empty() && used[st1.back().second]) st1.pop_back();
if (st1.empty()) return false;
st2.push_back(st1.back());
st1.pop_back();
while (!st1.empty() && used[st1.back().second]) st1.pop_back();
if (st1.empty()) return false;
maxR = max(maxR, st2.back().first.r);
return maxR <= st1.back().first.l;
}
bool check_r(vector<pair<rect, long long>> &st1,
vector<pair<rect, long long>> &st2, long long &minL) {
while (!st1.empty() && used[st1.back().second]) st1.pop_back();
if (st1.empty()) return false;
st2.push_back(st1.back());
st1.pop_back();
while (!st1.empty() && used[st1.back().second]) st1.pop_back();
if (st1.empty()) return false;
minL = min(minL, st2.back().first.l);
return minL >= st1.back().first.r;
}
bool check_d(vector<pair<rect, long long>> &st1,
vector<pair<rect, long long>> &st2, long long &maxU) {
while (!st1.empty() && used[st1.back().second]) st1.pop_back();
if (st1.empty()) return false;
st2.push_back(st1.back());
st1.pop_back();
while (!st1.empty() && used[st1.back().second]) st1.pop_back();
if (st1.empty()) return false;
maxU = max(maxU, st2.back().first.u);
return maxU <= st1.back().first.d;
}
bool check_u(vector<pair<rect, long long>> &st1,
vector<pair<rect, long long>> &st2, long long &minD) {
while (!st1.empty() && used[st1.back().second]) st1.pop_back();
if (st1.empty()) return false;
st2.push_back(st1.back());
st1.pop_back();
while (!st1.empty() && used[st1.back().second]) st1.pop_back();
if (st1.empty()) return false;
minD = min(minD, st2.back().first.d);
return minD >= st1.back().first.u;
}
void make(vector<pair<rect, long long>> &st) {
for (auto i : st) used[i.second] = true;
}
void make(vector<pair<rect, long long>> &st2, long long &cnt) {
for (auto i : st2) {
if (!used[i.second]) cnt--;
}
}
void make(vector<pair<rect, long long>> &st1,
vector<pair<rect, long long>> &st2) {
while (!st2.empty()) {
st1.push_back(st2.back());
st2.pop_back();
}
}
bool solve(vector<pair<rect, long long>> a) {
long long cnt = 0;
vector<pair<rect, long long>> st1[4], st2[4];
for (auto i : a) {
if (!used[i.second]) {
cnt++;
st1[0].push_back(i);
st1[1].push_back(i);
st1[2].push_back(i);
st1[3].push_back(i);
}
}
sort(st1[0].begin(), st1[0].end(), cmp_l);
sort(st1[1].begin(), st1[1].end(), cmp_r);
sort(st1[2].begin(), st1[2].end(), cmp_d);
sort(st1[3].begin(), st1[3].end(), cmp_u);
long long maxR, minL, maxU, minD;
maxR = -1e18;
minL = 1e18;
maxU = -1e18;
minD = 1e18;
while (cnt > 3) {
if (st1[0].empty() && st1[1].empty() && st1[2].empty() && st1[3].empty())
return false;
if (check_l(st1[0], st2[0], maxR)) {
make(st2[0], cnt);
if (!solve(st2[0])) return false;
make(st2[0]);
for (long long i = 0; i < 4; i++) make(st1[i], st2[i]);
maxR = -1e18;
minL = 1e18;
maxU = -1e18;
minD = 1e18;
continue;
}
if (check_r(st1[1], st2[1], minL)) {
make(st2[1], cnt);
if (!solve(st2[1])) return false;
make(st2[1]);
for (long long i = 0; i < 4; i++) make(st1[i], st2[i]);
maxR = -1e18;
minL = 1e18;
maxU = -1e18;
minD = 1e18;
continue;
}
if (check_d(st1[2], st2[2], maxU)) {
make(st2[2], cnt);
if (!solve(st2[2])) return false;
make(st2[2]);
for (long long i = 0; i < 4; i++) make(st1[i], st2[i]);
maxR = -1e18;
minL = 1e18;
maxU = -1e18;
minD = 1e18;
continue;
}
if (check_u(st1[3], st2[3], minD)) {
make(st2[3], cnt);
if (!solve(st2[3])) return false;
make(st2[3]);
for (long long i = 0; i < 4; i++) make(st1[i], st2[i]);
maxR = -1e18;
minL = 1e18;
maxU = -1e18;
minD = 1e18;
continue;
}
}
return true;
}
string ans;
void run() {
used.assign(n, false);
if (solve(a)) {
ans = "YES";
} else {
ans = "NO";
}
}
void write() { cout << ans << endl; }
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
read();
run();
write();
return 0;
}
| 22 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
void fileio(const string &s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
const long long INF = 4e18;
inline long long read() {
long long x = 0;
bool flag = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') flag = 0;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + c - '0';
c = getchar();
}
return (flag ? x : ~(x - 1));
}
long long t, n, k, f[2001][2001];
void solve() {
n = read();
k = read();
for (long long i = 1; i <= n; i++)
for (long long l = 0; l <= i; l++) f[i][l] = 0;
for (long long i = 1; i <= n; i++) {
long long x = read();
for (long long l = 0; l < i; l++) {
f[i][l + 1] = max(f[i][l + 1], f[i - 1][l]);
f[i][l] = max(f[i][l], f[i - 1][l] + (i - l == x));
}
}
for (long long i = 0; i <= n; i++)
if (f[n][i] >= k) {
cout << i << endl;
return;
}
puts("-1");
}
signed main() {
t = read();
while (t--) solve();
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 107;
int n;
int a[MAXN];
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n;
set<int> ms;
const int INF = 1e9 + 7;
int mn = INF;
int mx = -INF;
map<int, int> d;
for (int i = 0; i < n; ++i) {
cin >> a[i];
ms.insert(a[i]);
mn = min(mn, a[i]);
mx = max(mx, a[i]);
d[a[i]]++;
}
if (ms.size() == 2 && d[mn] == d[mx]) {
cout << "YES\n";
cout << mn << ' ' << mx << '\n';
} else {
cout << "NO\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
int mx = 0, mn = 1e9;
vector<string> v(n);
for (int i = 0; i < n; i++) cin >> v[i];
int ans = 1e9;
int ma;
int arr[8];
for (int i = 0; i < m; i++) arr[i] = i;
do {
int mx = 0, mn = 1e9;
for (int k = 0; k < n; k++) {
string s;
for (int j = 0; j < m; j++) s += v[k][arr[j]];
int d = stoi(s);
mn = min(mn, d);
mx = max(mx, d);
}
ans = min(ans, mx - mn);
} while (next_permutation(arr, arr + m));
cout << ans << "\n";
}
| 6 |
#include <bits/stdc++.h>
#define F(x,y,z) for(int x = y ; x < z ; x++)
using namespace std;
const int inf = 2e9;
int solve(vector<int>& a){
vector<vector<int> > dp;
int n = a.size();
for(int i = 0 ; i < a.size() ; i++){
vector<int> temp;
dp.push_back(temp);
}
F(i,0,n) dp[0].push_back(0);
F(i,1,n){
F(j,i,n) dp[i].push_back(inf);
int cnt = 0;
for(int j = i - 1 ; j >= 0 ; j--){
if (j + a[j] >= i){
dp[i][j + a[j] - i] = min(dp[i][j + a[j] - i],dp[j][i - j - 1] + cnt++);
}
}
for(int j = 1 ; j < dp[i].size() ; j++) dp[i][j] = min(dp[i][j],dp[i][j - 1]);
}
/*for(int i = 0 ; i < n ; i++){
for(int j = 0 ; i + j < n ; j++){
cout<<dp[i][j]<<" ";
}
cout<<"\n";
}
cout<<"\n\n";
*/
return dp[a.size() - 1][0];
}
int main(){
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--){
int n;
cin >> n;
vector<int> a;
while (n--){
int xx;
cin >> xx;
a.push_back(xx);
}
cout << solve(a) << "\n";
}
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
int cmp(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int z[100005];
int main() {
int n, a, i;
i = 1;
cin >> n;
for (a = 0; n > a; a++) {
cin >> z[a];
}
qsort(z, n, sizeof(z[0]), cmp);
for (a = 0; n > a; a++) {
if (z[a] >= i) {
i++;
}
}
cout << i << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int f[5555][5555], mx[7], g[101000];
int n, a[5555], ans = 0;
void R(int &x, int y) { x = max(x, y); }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; scanf("%d", &a[i++]))
;
for (int i = 0; i < n; i++) {
memset(mx, 0, sizeof mx);
memset(g, 0, sizeof g);
for (int j = 1; j < i; j++) {
R(mx[a[j] % 7], f[i][j]);
R(g[a[j]], f[i][j]);
}
for (int j = i + 1; j <= n; j++) {
R(f[i][j], max(g[a[j] + 1], g[a[j] - 1]) + 1);
R(f[i][j], mx[a[j] % 7] + 1);
R(f[i][j], f[i][0] + 1);
R(mx[a[j] % 7], f[i][j]);
R(g[a[j]], f[i][j]);
R(f[j][i], f[i][j]);
}
}
for (int i = 0; i <= n; i++) R(ans, *max_element(f[i], f[i] + n + 1));
cout << ans;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = 1e5 + 10;
char ch[N];
int f[N], g[N];
int n;
void init() {
scanf("%s", ch + 1);
n = strlen(ch + 1);
for (int i = 1; i <= n; i++) f[i] = ch[i] - '0', g[i] = f[i];
}
bool check(int l) {
for (int i = l, j = n; i < j; i++, j--) {
if (f[i] == f[j]) continue;
if (i == j - 1) {
if (f[i] - 1 == f[j] + 10) {
f[i]--;
f[j] += 10;
continue;
}
return false;
}
if (f[i] - 1 == f[j]) {
f[i]--;
f[i + 1] += 10;
continue;
}
if (f[i] == f[j] + 10) {
f[j] += 10;
f[j - 1]--;
continue;
}
if (f[i] - 1 == f[j] + 10) {
f[i]--;
f[i + 1] += 10;
f[j] += 10;
f[j - 1]--;
continue;
}
return false;
}
for (int i = l, j = n; i <= j; i++, j--) {
if (f[i] < 0 || f[i] > 18 || f[i] != f[j]) return false;
if (i == j) {
if (f[i] % 2 != 0) return false;
f[i] >>= 1;
} else {
f[j] >>= 1;
f[i] -= f[j];
}
}
if (f[1] == 0) return false;
for (int i = l; i <= n; i++) printf("%d", f[i]);
printf("\n");
return true;
}
void work() {
if (!check(1)) {
for (int i = 1; i <= n; i++) f[i] = g[i];
if (f[1] == 1 && n > 1) {
f[2] += 10;
if (check(2)) {
return;
}
}
puts("0");
}
}
int main() {
init();
work();
return 0;
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, a = 0, b = 0;
scanf("%d", &n);
if (n == 1) {
cout << "NO";
return (0);
}
for (int i = 0; i < n; i++) {
scanf("%d", &x);
if (x == 100)
a++;
else
b++;
}
if (a % 2)
cout << "NO";
else {
if (!(b % 2))
cout << "YES";
else if (b % 2 && a >= 2)
cout << "YES";
else
cout << "NO";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int a[111111];
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
sort(a, a + n);
printf("%d\n", a[n - m]);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long DELTA = 1000000007, maxn = 100 + 7;
long long k, m, n, ans[maxn][maxn * maxn], chooseMem[maxn][maxn],
powerMem[maxn][2];
;
bool isCeil[maxn];
int power(long long base, long long p) {
long long ans = 1;
while (p > 0) {
if (p % 2) {
ans *= base;
ans %= DELTA;
}
base *= base;
base %= DELTA;
p >>= 1;
}
return ans;
}
long long choose(long long r, long long n) {
if (chooseMem[r][n] != -1) return chooseMem[r][n];
if (r < 0 or r > n) return 0;
if (r == 0 or r == n) return 1;
chooseMem[r][n] = choose(r, n - 1) + choose(r - 1, n - 1);
chooseMem[r][n] %= DELTA;
return chooseMem[r][n];
}
int main() {
cin >> n >> m >> k;
memset(chooseMem, -1, sizeof chooseMem);
long long flo = (m / n), cei = (m / n) + 1;
int r = m % n;
for (int i = 0; i < n; i++) {
if (i > 0 and i <= r) {
isCeil[i] = true;
}
}
for (int i = 0; i <= n; i++) {
powerMem[i][0] = power(choose(i, n), flo);
powerMem[i][1] = power(choose(i, n), cei);
}
for (int i = 0; i <= n; i++) {
if (isCeil[1]) {
ans[1][i] += powerMem[i][1];
ans[1][i] %= DELTA;
} else {
ans[1][i] += powerMem[i][0];
ans[1][i] %= DELTA;
}
}
for (int i = 2; i <= n; i++) {
for (int j = 0; j <= (n * n); j++) {
for (int k = 0; k <= n; k++) {
if (k <= j) {
if (isCeil[i]) {
ans[i][j] += ans[i - 1][j - k] * powerMem[k][1];
ans[i][j] %= DELTA;
} else {
ans[i][j] += ans[i - 1][j - k] * powerMem[k][0];
ans[i][j] %= DELTA;
}
}
}
}
}
cout << ans[n][k] << endl;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 200, D = 12;
int n, m, a, q, mod;
long long fac[N], inv[N], sum[N];
long long bp(long long a, long long p, long long mod) {
long long r = 1;
while (p > 0) {
if (p & 1) r = r * a % mod;
p >>= 1;
a = a * a % mod;
}
return r;
}
long long c(int n, int k) { return fac[n] * inv[n - k] % mod * inv[k] % mod; }
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m >> a >> q;
long long x = 1;
for (int i = 1; i < N; i++) {
x = x * a % q;
if (x == 1) {
mod = i;
break;
}
}
fac[0] = inv[0] = 1;
for (int i = 1; i < N; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = bp(fac[i], mod - 2, mod);
}
sum[0] = 1;
for (int i = 1; i <= m; i++) {
sum[i] = (sum[i - 1] + c(m, i)) % mod;
}
for (int i = 0; i < n; i++) {
cout << bp(a, sum[min(m + 1, n - i) - 1], q) << " ";
}
return 0;
}
| 14 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int mod = 998244353;
long long dp[N][3];
struct edge {
int to, next;
} g[N << 1];
int head[N], cnt;
void add(int u, int v) {
g[++cnt].to = v;
g[cnt].next = head[u];
head[u] = cnt;
}
long long pw(long long a, long long b) {
long long ans = 1;
while (b) {
if (b & 1) ans = ans * a % mod;
a = a * a % mod;
b >>= 1;
}
return ans;
}
void dfs(int x, int fa) {
dp[x][0] = dp[x][2] = 1;
for (int i = head[x]; i; i = g[i].next) {
int y = g[i].to;
if (y == fa) continue;
dfs(y, x);
dp[x][0] = (dp[x][0] * (dp[y][0] + dp[y][1]) % mod) % mod;
dp[x][1] = (dp[x][1] + pw((dp[y][0] + 2 * dp[y][1] % mod) % mod, mod - 2) *
dp[y][2] % mod) %
mod;
dp[x][2] = (dp[x][2] * (dp[y][0] + 2 * dp[y][1]) % mod) % mod;
}
dp[x][1] = dp[x][1] * dp[x][2] % mod;
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
add(y, x);
}
dfs(1, 0);
printf("%lld\n", (dp[1][0] + dp[1][1]) % mod);
}
| 16 |
#include <bits/stdc++.h>
using namespace std;
struct ofl {
long double value;
int precision;
inline ofl(long double value, int precision)
: value(value), precision(precision) {}
};
const int seed = hash<string>()("alex256");
const int inf = (int)1e9 + 7;
const int64_t llInf = (int64_t)2e18 + 256;
const int mod = (int)1e9 + 7;
const long double pi = 3.141592653589793238462643383279502884197169399375105821;
const string luck = "🍀";
const char* errText = "error :(";
template <typename T1, typename T2>
inline istream& operator>>(istream& is, pair<T1, T2>& p) {
return is >> p.first >> p.second;
}
template <typename T1, typename T2>
inline ostream& operator<<(ostream& os, const pair<T1, T2>& p) {
return os << p.first << " " << p.second;
}
template <typename T>
inline istream& operator>>(istream& is, vector<T>& v) {
for (int i = 0; i < (int)(v.size()); i++) {
is >> v[i];
}
return is;
}
template <typename T>
inline ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = 0; i < (int)(v.size()); i++) {
if (i) {
os << " ";
}
os << v[i];
}
return os;
}
inline ostream& operator<<(ostream& os, const ofl& o) {
return os << fixed << setprecision(o.precision) << o.value;
}
inline bool iosOptimize() {
ios_base::sync_with_stdio(false);
return true;
}
bool iosOptimized = iosOptimize();
template <typename T>
inline T get() {
T value;
cin >> value;
return value;
}
template <>
inline char get() {
char c = '\0';
while (c <= ' ') {
cin >> c;
}
return c;
}
inline string getLn() {
string s;
getline(cin, s);
return s;
}
template <typename T, size_t Count>
struct VectorPacker {};
template <typename T>
struct VectorPacker<T, 0> {};
template <typename T>
inline vector<T> getVector(int size) {
vector<T> res(size);
cin >> res;
return res;
}
template <typename T, typename U, typename... Args>
inline typename VectorPacker<T, sizeof...(Args) + 1>::T getVector(
U size, Args... sizes) {
typename VectorPacker<T, sizeof...(Args) + 1>::T res(size);
for (int i = 0; i < (int)size; i++) {
res[i] = getVector<T>(sizes...);
}
return res;
}
inline void put() {}
template <typename T, typename... Args>
inline void put(const T& value, const Args&... vals) {
cout << value;
put(vals...);
}
template <typename... Args>
inline void putLn(const Args&... vals) {
put(vals...);
cout << "\n";
}
namespace std {
template <typename T1, typename T2>
struct hash<pair<T1, T2> > {
inline size_t operator()(const pair<T1, T2>& p) const {
return hash<T1>()(p.first) ^ hash<T2>()(p.second);
}
};
}; // namespace std
mt19937_64 rnd(seed);
inline void error(const char* text = errText) {
;
exit(256);
}
template <typename T1, typename T2>
inline void umax(T1& a, const T2& b) {
if (a < b) {
a = b;
}
}
template <typename T1, typename T2>
inline void umin(T1& a, const T2& b) {
if (a > b) {
a = b;
}
}
int64_t gcd(int64_t a, int64_t b) { return b ? gcd(b, a % b) : a; }
int64_t extGcd(int64_t a, int64_t b, int64_t& x, int64_t& y) {
if (!a) {
x = 0;
y = 1;
return b;
}
int64_t x1, y1, d = extGcd(b % a, a, x1, y1);
x = y1 - (b / a) * x1;
y = x1;
return d;
}
inline int addMod(int a, int b, int m = mod) { return ((int64_t)a + b) % m; }
inline int subMod(int a, int b, int m = mod) {
return ((int64_t)a + m - b) % m;
}
inline int mulMod(int a, int b, int m = mod) { return ((int64_t)a * b) % m; }
inline int divMod(int a, int b, int m = mod) {
int64_t x, y;
int64_t g = extGcd(b, m, x, y);
if (g != 1) {
;
exit(42);
}
x = (x % m + m) % m;
return mulMod(a, x, m);
}
struct Variable {
string name;
string val;
string op;
string val2;
int id1;
int id2;
int value;
bool counted;
};
int n = get<int>(), m = get<int>();
vector<Variable> vars(n);
map<string, int> mp;
signed main() {
for (int i = 0; i < n; i++) {
vars[i].name = get<string>();
get<string>();
vars[i].val = get<string>();
if (vars[i].val[0] != '0' && vars[i].val[0] != '1') {
vars[i].op = get<string>();
vars[i].val2 = get<string>();
vars[i].id1 = mp[vars[i].val];
vars[i].id2 = mp[vars[i].val2];
} else {
vars[i].op = "=";
}
mp[vars[i].name] = i;
}
string minS(m, '0');
string maxS(m, '0');
for (int bit = 0; bit < m; bit++) {
int vals[2];
for (int val = 0; val < 2; val++) {
vals[val] = 0;
for (int i = 0; i < n; i++) {
if (vars[i].op == "=") {
vars[i].value = vars[i].val[bit] - '0';
} else {
int lVal = (vars[i].val == "?") ? val : (vars[vars[i].id1].value);
int rVal = (vars[i].val2 == "?") ? val : (vars[vars[i].id2].value);
if (vars[i].op == "OR") {
vars[i].value = lVal | rVal;
} else if (vars[i].op == "AND") {
vars[i].value = lVal & rVal;
} else if (vars[i].op == "XOR") {
vars[i].value = lVal ^ rVal;
}
}
vals[val] += vars[i].value;
}
}
if (vals[0] > vals[1]) {
minS[bit] = '1';
maxS[bit] = '0';
} else if (vals[0] == vals[1]) {
minS[bit] = '0';
maxS[bit] = '0';
} else {
minS[bit] = '0';
maxS[bit] = '1';
}
}
putLn(minS);
putLn(maxS);
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e3 + 5;
vector<int> vt[MAX];
int n, m;
int main() {
int x, y;
while (~scanf("%d%d", &n, &m)) {
for (int i = 1; i <= n; ++i) vt[i].push_back(i);
while (m--) {
scanf("%d%d", &x, &y);
vt[x].push_back(x * 1000 + y);
vt[y].push_back(x * 1000 + y);
}
for (int i = 1; i <= n; ++i) {
printf("%d\n", vt[i].size());
for (vector<int>::iterator p = vt[i].begin(); p != vt[i].end(); ++p)
printf("%d %d\n", i, *p);
}
}
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = 150005;
vector<int> vet[N];
pair<int, int> cmp[N];
int p[N];
int find(int u) { return p[u] = (u == p[u]) ? u : find(p[u]); }
void une(int u, int v) {
u = find(u), v = find(v);
vet[cmp[v].first].push_back(cmp[u].second);
vet[cmp[u].second].push_back(cmp[v].first);
cmp[u].second = cmp[v].second;
p[v] = u;
}
void dfs(int u, int p) {
printf("%d ", u);
for (int v : vet[u]) {
if (v != p) dfs(v, u);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) cmp[i] = {i, i}, p[i] = i;
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d %d", &x, &y);
une(x, y);
}
int x;
for (int i = 1; i <= n; i++) {
if (vet[i].size() == 1) {
x = i;
break;
}
}
dfs(x, x);
printf("\n");
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 100010;
long long int num[MAX];
int main() {
long long int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> num[i];
}
sort(num, num + n);
for (int i = 0; i < n; i++) {
if (i == 0) {
if (num[i] != 1) {
num[i] = 1;
}
} else {
if (num[i] > num[i - 1]) {
num[i] = num[i - 1] + 1;
}
}
}
cout << num[n - 1] + 1 << endl;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300007;
char s[maxn];
long long suma[maxn], sumb[maxn], mx[maxn];
int main() {
int n;
scanf("%d", &n);
scanf("%s", s + 1);
for (int i = n; i >= 1; i--) {
if (s[i] == 'A') {
suma[i] = suma[i + 1] + 1;
sumb[i] = 0;
if (suma[i] == 1)
mx[i] = sumb[i + 1];
else
mx[i] = mx[i + 1];
} else {
sumb[i] = sumb[i + 1] + 1;
suma[i] = 0;
if (sumb[i] == 1)
mx[i] = suma[i + 1];
else
mx[i] = mx[i + 1];
}
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (s[i] == 'A') {
if (suma[i] == 1)
ans += n - i - mx[i];
else
ans += n - i - (mx[i] != 0);
} else {
if (sumb[i] == 1)
ans += n - i - mx[i];
else
ans += n - i - (mx[i] != 0);
}
}
printf("%lld\n", ans);
return 0;
}
| 11 |
#include <bits/stdc++.h>
int main() {
int n, sum = 0, x, i;
double m;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &x);
sum = sum + x;
}
m = (sum * 1.0) / n;
printf("%.12lf", m);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, m, arr[1000005], z[1000005], lenp;
bool beginning[1000005];
string p;
void z_algo() {
long long i, j, k, l, r, beta;
p.push_back('*');
i = 1;
j = 0;
r = 0;
l = 0;
z[0] = lenp;
for (k = 1; k < lenp; ++k) {
beta = r - k + 1;
if ((r >= k) && (z[k - l] < beta)) {
z[k] = z[k - l];
} else {
for (i = max(r, k); p[i] == p[i - k]; ++i)
;
--i;
l = k;
r = i;
z[k] = r - k + 1;
}
}
}
int main() {
long long i, j, k, xi, pre, sum, ans;
bool possible = true;
cin >> n >> m;
cin >> p;
lenp = p.length();
pre = -1 * lenp;
for (i = 0; i <= n + 1; ++i) {
beginning[i] = false;
arr[i] = 0;
}
z_algo();
for (i = 0; i < lenp; ++i) {
if (z[i] >= (lenp - i)) beginning[i] = true;
}
while (m--) {
cin >> xi;
--xi;
if (xi <= pre + lenp - 1) {
if (!beginning[xi - pre]) {
possible = false;
break;
}
}
arr[xi] += 1;
arr[xi + lenp] += -1;
pre = xi;
}
if (!possible) {
cout << "0";
return 0;
} else {
sum = 0;
ans = 1;
for (i = 0; i < n; ++i) {
sum += arr[i];
if (sum == 0) ans = (ans * 26) % 1000000007;
}
cout << ans;
}
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, l, c, d, p, nl, np, t1, t2, t3, t4, t5;
cin >> n >> k >> l >> c >> d >> p >> nl >> np;
t1 = (l * k) / nl;
t2 = c * d;
t3 = p / np;
t4 = min(t1, t2);
t5 = min(t2, t3);
cout << min(t4, t5) / n;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mxn = 3e5;
long long res = 1, n;
vector<long long> adj[mxn], vis(mxn), fac(mxn);
void dfs(long long a) {
vis[a] = 1;
long long ch = 0;
for (long long& x : adj[a]) {
if (vis[x]) continue;
ch++;
dfs(x);
}
if (ch == 0) return;
res *= fac[ch], res %= 998244353;
if (a == 1)
res *= n;
else
res *= (ch + 1);
res %= 998244353;
}
signed main() {
fac[0] = 1;
for (long long i = 1; i < mxn; i++)
fac[i] = fac[i - 1] * i, fac[i] %= 998244353;
cin >> n;
for (long long i = 0; i < n - 1; i++) {
long long u, v;
cin >> u >> v;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfs(1);
cout << res;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int main() {
int x, y, n, i, j;
double p, q, m, a, b;
cin >> x >> y >> n;
i = gcd(x, y);
x /= i;
y /= i;
if (n >= y)
cout << x << "/" << y;
else {
a = x;
b = y;
p = a / b;
a = 0;
b = 1;
m = 100005.0;
while (b <= n) {
q = a / b;
if (fabs(q - p) < m) {
x = a;
y = b;
m = fabs(q - p);
}
if (q > p)
b++;
else if (q < p)
a++;
}
cout << x << "/" << y << "\n";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long l;
string s;
cin >> l;
cin >> s;
long long d = 1;
cout << s[0];
for (long long i = 0; i + d < l;) {
i = i + d;
d++;
cout << s[i];
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 4000;
const int mod = 1000000007;
void add(int &a, long long b) { a = (a + b) % mod; }
vector<int> solve(vector<int> v) {
vector<int> now(2 * N + 1, 0);
now[N] = 1;
for (int a : v) {
vector<int> nxt = now;
for (int i = -N; i + a <= N; i++) add(nxt[i + a + N], now[i + N]);
for (int i = N; i - a >= -N; i--) add(nxt[i - a + N], now[i + N]);
now = nxt;
}
return now;
}
vector<int> solve_force(vector<int> v) {
vector<int> now(2 * N + 1, 0);
now[N] = 1;
for (int a : v) {
vector<int> nxt(2 * N + 1, 0);
for (int i = -N; i + a <= N; i++) add(nxt[i + a + N], now[i + N]);
for (int i = N; i - a >= -N; i--) add(nxt[i - a + N], now[i + N]);
now = nxt;
}
return now;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, m;
cin >> n >> m;
vector<int> g[n + 1];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
vector<int> v;
vector<bool> vis(n + 1, 0);
vis[1] = 1;
for (int i : g[1]) {
if (vis[i] == 1) continue;
int now = i;
int c = 1;
while (vis[now] == 0) {
c++;
vis[now] = 1;
int nxt = g[now][0];
if (vis[nxt] == 1) nxt = g[now][1];
now = nxt;
}
v.push_back(c);
}
set<int> s;
for (int a : v) s.insert(a);
vector<vector<int>> rm(n + 1);
vector<vector<int>> rm_force(n + 1);
for (int a : s) {
vector<int> tmp;
bool z = 0;
for (int b : v) {
if (b == a && z == 0) {
z = 1;
continue;
}
tmp.push_back(b);
}
rm[a] = solve(tmp);
rm_force[a] = solve_force(tmp);
}
int res = 0;
for (int a : v) {
for (int i = 1; i < a; i++) add(res, 2 * rm[a][abs(a - 2 * i) + N]);
for (int i = 1; i < a - 1; i++) add(res, 2 * rm[a][abs(a - 2 * i - 1) + N]);
add(res, 4ll * rm_force[a][a - 1 + N]);
}
if ((m % 2) == 0) add(res, solve_force(v)[N]);
cout << res << "\n";
return 0;
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
map<string, int> mp;
string name[N], s;
long long w[N], h[N];
int o, n, type[N];
int border[N], space[N];
int pl, pr, pSpace, pDot, p;
vector<int> v[N];
struct answer {
string s;
long long w, h;
answer(string s = "", long long w = 0, long long h = 0) : s(s), w(w), h(h) {}
bool operator<(const answer& b) const { return s < b.s; }
} ans[N];
int getNum(int l, int r) {
int ret = 0;
for (int i = (l); i < (r + 1); i++) ret = ret * 10 + s[i] - '0';
return ret;
}
int getO(string s) {
if (mp.count(s)) return mp[s];
name[o] = s;
mp[s] = o++;
return mp[s];
}
void pack() {
string s1, s2;
int o1, o2;
s1 = s.substr(0, pDot);
s2 = s.substr(pl + 1, pr - pl - 1);
o1 = getO(s1);
o2 = getO(s2);
v[o1].push_back(o2);
}
void set_border() {
string name;
int cur, num;
name = s.substr(0, pDot);
num = getNum(pl + 1, pr - 1);
cur = getO(name);
border[cur] = num;
}
void set_spacing() {
string name;
int cur, num;
name = s.substr(0, pDot);
num = getNum(pl + 1, pr - 1);
cur = getO(name);
space[cur] = num;
}
void widget() {
string name;
int cur, wi, hi;
name = s.substr(pSpace + 1, pl - pSpace - 1);
wi = getNum(pl + 1, p - 1);
hi = getNum(p + 1, pr - 1);
cur = getO(name);
type[cur] = 2;
w[cur] = wi;
h[cur] = hi;
}
void hbox() {
string name;
int cur;
name = s.substr(pSpace + 1);
cur = getO(name);
type[cur] = 0;
}
void vbox() {
string name;
int cur;
name = s.substr(pSpace + 1);
cur = getO(name);
type[cur] = 1;
}
void calc(int i) {
if (~w[i]) return;
w[i] = 0;
if (!v[i].size()) return;
if (type[i] == 0) {
w[i] = 2LL * border[i];
for (int j = (0); j < (v[i].size()); j++) {
if (j) w[i] += space[i];
calc(v[i][j]);
w[i] += w[v[i][j]];
h[i] = max(h[i], h[v[i][j]]);
}
h[i] += 2LL * border[i];
}
if (type[i] == 1) {
h[i] = 2LL * border[i];
for (int j = (0); j < (v[i].size()); j++) {
if (j) h[i] += space[i];
calc(v[i][j]);
h[i] += h[v[i][j]];
w[i] = max(w[i], w[v[i][j]]);
}
w[i] += 2LL * border[i];
}
}
int main() {
int k;
o = 0;
scanf("%d", &n);
getchar();
memset(w, -1, sizeof(w));
for (int i = (0); i < (n); i++) {
getline(cin, s);
pSpace = s.find(' ');
pl = s.find('(');
p = s.find(',');
pr = s.find(')');
pDot = s.find('.');
if (pDot != string::npos) {
if (s.substr(pDot + 1, 4) == "pack")
pack();
else if (s.substr(pDot + 1, 10) == "set_border")
set_border();
else if (s.substr(pDot + 1, 11) == "set_spacing")
set_spacing();
} else {
if (s.substr(0, 6) == "Widget")
widget();
else if (s.substr(0, 4) == "HBox")
hbox();
else if (s.substr(0, 4) == "VBox")
vbox();
}
}
for (int i = (0); i < (o); i++) {
calc(i);
ans[i] = answer(name[i], w[i], h[i]);
}
sort(ans, ans + o);
for (int i = (0); i < (o); i++)
cout << ans[i].s << " " << ans[i].w << " " << ans[i].h << "\n";
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 500005;
vector<int> v[MAXN];
int st[MAXN], et[MAXN], lazy[4 * MAXN];
int c[MAXN], order[MAXN];
long long seg[4 * MAXN];
int n, m, cnt = 0;
void DFS(int i, int p) {
order[cnt] = i;
st[i] = cnt++;
for (int j = 0; j < v[i].size(); j++) {
if (v[i][j] != p) {
DFS(v[i][j], i);
}
}
et[i] = cnt - 1;
}
void build(int nd, int l, int r) {
if (l == r) {
seg[nd] = (1ll << c[order[l]]);
return;
}
int mid = (l + r) / 2;
build(2 * nd, l, mid);
build(2 * nd + 1, mid + 1, r);
seg[nd] = seg[2 * nd] | seg[2 * nd + 1];
}
void update(int nd, int s, int e, int l, int r, int nc) {
if (lazy[nd]) {
seg[nd] = (1ll << lazy[nd]);
if (s != e) {
lazy[2 * nd] = lazy[nd];
lazy[2 * nd + 1] = lazy[nd];
}
lazy[nd] = 0;
}
if (e < l || s > r) {
return;
}
if (s >= l && e <= r) {
seg[nd] = (1ll << nc);
if (s != e) {
lazy[2 * nd] = nc;
lazy[2 * nd + 1] = nc;
}
return;
}
int mid = (e + s) / 2;
update(2 * nd, s, mid, l, r, nc);
update(2 * nd + 1, mid + 1, e, l, r, nc);
seg[nd] = seg[2 * nd] | seg[2 * nd + 1];
}
long long query(int nd, int s, int e, int l, int r) {
if (lazy[nd]) {
seg[nd] = (1ll << lazy[nd]);
if (s != e) {
lazy[2 * nd] = lazy[nd];
lazy[2 * nd + 1] = lazy[nd];
}
lazy[nd] = 0;
}
if (e < l || s > r) {
return 0;
}
if (s >= l && e <= r) {
return seg[nd];
}
int mid = (e + s) / 2;
return query(2 * nd, s, mid, l, r) | query(2 * nd + 1, mid + 1, e, l, r);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> c[i];
}
for (int i = 0; i < n - 1; i++) {
int x, y;
cin >> x >> y;
x--;
y--;
v[x].push_back(y);
v[y].push_back(x);
}
DFS(0, -1);
build(1, 0, n - 1);
while (m--) {
int idx;
cin >> idx;
if (idx == 1) {
int vx, cl;
cin >> vx >> cl;
vx--;
update(1, 0, n - 1, st[vx], et[vx], cl);
} else {
int vx, tot = 0;
cin >> vx;
vx--;
long long ans = query(1, 0, n - 1, st[vx], et[vx]);
for (int i = 0; i < 64; i++) {
if ((ans >> i) & 1) {
tot++;
}
}
cout << tot << "\n";
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
struct Point {
int x, y;
Point(int _x = 0, int _y = 0) : x(_x), y(_y){};
Point operator-(Point A) { return Point(x - A.x, y - A.y); }
int operator^(Point A) { return x * A.y - A.x * y; }
};
int main() {
Point p[2][5];
for (int i = 0; i < 2; ++i)
for (int j = 0; j < 4; ++j) {
scanf("%d%d", &p[i][j].x, &p[i][j].y);
p[i][j].x *= 2;
p[i][j].y *= 2;
}
for (int k = 0; k < 2; ++k)
p[k][4] = Point((p[k][0].x + p[k][2].x) / 2, (p[k][0].y + p[k][2].y) / 2);
set<int> val;
int a;
for (int k = 0; k < 2; ++k) {
for (int j = 0; j < 5; ++j) {
val.clear();
for (int i = 0; i < 3; ++i) {
a = (p[k][j] - p[k ^ 1][i]) ^ (p[k ^ 1][i + 1] - p[k ^ 1][i]);
if (a == 0) continue;
if (a > 0)
a = 1;
else
a = -1;
val.insert(a);
}
a = (p[k][j] - p[k ^ 1][3]) ^ (p[k ^ 1][0] - p[k ^ 1][3]);
if (a != 0) {
if (a > 0)
a = 1;
else
a = -1;
val.insert(a);
}
if (int(val.size()) == 1) {
printf("YES");
return 0;
}
}
}
printf("NO");
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
string s;
int main() {
cin >> s;
int f1, f2, i;
f1 = f2 = 0;
for (i = 0; i < s.size(); i++) {
if (s[i] != 'a') f1 = 1;
if (f1 == 1 && s[i] == 'a') f2 = 1;
if (f1 == 1 && f2 == 0) s[i]--;
}
if (f1 == 0) s[s.size() - 1] = 'z';
cout << s;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void checkpoint1() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
bool comp(pair<long long, long long> &a, pair<long long, long long> &b) {
if (a.first != b.first)
return a.first < b.first;
else {
if (a.second > b.second)
return b.second < a.second;
else if (a.second < b.second)
return a.second < b.second;
}
return a.first > b.first;
}
long long powe(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) {
res *= a;
res %= 1000000007;
}
a *= a;
a %= 1000000007;
b >>= 1;
}
return res;
}
int main() {
checkpoint1();
long long n, m, k;
cin >> n >> m >> k;
long long sub = 0, temp = 0;
long long a[m];
for (long long i = 0; i < m; i++) cin >> a[i];
long long ans = 0;
sort(a, a + m);
long long j = -1;
for (long long i = 0; i < m; i++) {
if (j == -1) {
ans++;
sub += temp;
temp = 0;
long long lol = a[i] - sub;
j = ceil((long double)lol / k);
temp++;
} else {
long long lol = a[i] - sub;
if (ceil((long double)lol / k) != j) {
j = -1;
i--;
} else
temp++;
}
}
cout << ans;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 130;
const int MOD = 1e9 + 7;
inline void add(int &x, int y) {
x += y;
if (x >= MOD) x -= MOD;
}
struct matrix {
int n, m;
int a[N][N];
matrix operator*(const matrix &x) const {
matrix ret;
ret.n = n;
ret.m = x.m;
memset(ret.a, 0, sizeof(ret.a));
for (int i = 0; i < n; i++)
for (int j = 0; j < ret.m; j++)
for (int k = 0; k < m; k++)
add(ret.a[i][j], 1ll * a[i][k] * x.a[k][j] % MOD);
return ret;
}
void show() {
puts("-----show-----");
printf("n:%d m:%d\n", n, m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d ", a[i][j]);
puts("");
}
puts("");
}
};
int a[8];
int v[8][N][N];
int ans;
matrix one, dp, tran;
matrix Pow(matrix x, int y) {
matrix mult = x, ret = one;
ret.n = x.n;
ret.m = x.m;
while (y) {
if (y & 1) ret = ret * mult;
mult = mult * mult;
y >>= 1;
}
return ret;
}
int main() {
one.n = 128;
one.m = 128;
memset(one.a, 0, sizeof(one.a));
for (int i = 0; i < 128; i++) one.a[i][i] = 1;
for (int i = 1; i <= 7; i++) scanf("%d", a + i);
for (int i = 1; i <= 7; i++)
for (int j = 0; j < (1 << i); j++)
for (int k = 0; k < (1 << i); k++)
for (int l = 0; l < (1 << i - 1); l++) {
int m = (l << 1) ^ 1 ^ (1 << i);
int add = 1;
for (int x = 0; x < i; x++)
if ((j & (1 << x)) && (k & (1 << x)) && (m & (1 << x)) &&
(m & (1 << x + 1)))
add = 0;
v[i][j][k] += add;
}
dp.n = 1;
dp.m = 1;
memset(dp.a, 0, sizeof(dp.a));
dp.a[0][0] = 1;
for (int i = 1; i <= 7; i++) {
for (int j = 0; j < dp.m; j++) {
dp.a[0][j + dp.m] = dp.a[0][j];
dp.a[0][j] = 0;
}
dp.m *= 2;
tran.n = dp.m;
tran.m = dp.m;
memset(tran.a, 0, sizeof(tran.a));
for (int j = 0; j < (1 << i); j++)
for (int k = 0; k < (1 << i); k++) tran.a[k][j] = v[i][j][k];
tran = Pow(tran, a[i]);
dp = dp * tran;
}
printf("%d\n", dp.a[0][127]);
return 0;
}
| 19 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int n, m;
int dp[2][505][505];
char grid[505][505];
int half;
bool chk_state(int row1, int row2, int dist) {
if (row1 > row2) return 0;
int taken = (m - 1) - dist + (row1) + (n - 1 - row2);
int lft = (n + m - 2) - taken;
if (lft < 0) return 0;
if (taken & 1) return 0;
int c1 = taken / 2 - row1;
int c2 = taken / 2 - (n - 1 - row2);
c2 = (m - 1) - c2;
if (c1 > c2) return 0;
if (c1 < 0 || c2 < 0) return 0;
if ((row1 + c1) != ((n - 1 - row2) + (m - 1 - c2))) return 0;
return 1;
}
int solve() {
dp[0][n - 1][m - 1] = (grid[0][0] == grid[n - 1][m - 1]);
int ans = 0;
for (int i = 0; i < n; i++) {
if (i)
for (int j = 0; j <= 500; j++)
for (int k = 0; k <= 500; k++) dp[i & 1][j][k] = 0;
for (int j = n - 1; j >= 0; j--) {
for (int k = m - 1; k >= 0; k--) {
if (!chk_state(i, j, k)) continue;
int dist = k;
int row1 = i;
int row2 = j;
int taken = (m - 1) - dist + (row1) + (n - 1 - row2);
int lft = (n + m - 2) - taken;
int c1 = taken / 2 - row1;
int c2 = taken / 2 - (n - 1 - row2);
c2 = (m - 1) - c2;
if (grid[row1][c1] == grid[row2][c2]) {
dp[i & 1][j][k] += dp[i & 1][j][k + 2];
dp[i & 1][j][k] %= mod;
dp[i & 1][j][k] += dp[i & 1][j + 1][k + 1];
dp[i & 1][j][k] %= mod;
dp[i & 1][j][k] += dp[(i - 1) & 1][j][k + 1];
dp[i & 1][j][k] %= mod;
dp[i & 1][j][k] += dp[(i - 1) & 1][j + 1][k];
dp[i & 1][j][k] %= mod;
ans += (dp[i & 1][j][k] * ((lft == 1 || lft == 0) &&
lft == (abs(row1 - row2) + abs(c1 - c2))));
ans %= mod;
}
}
}
}
return ans;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf(" %c", &grid[i][j]);
cout << solve();
return 0;
}
| 15 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, vb, vs;
cin >> n >> vb >> vs;
long long int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
long long int x, y;
cin >> x >> y;
double tmin = pow(10, 9);
double dmin = pow(10, 9);
long long int imin;
for (int i = 1; i < n; i++) {
double t1, t2;
t1 = (double)a[i] / (double)vb;
double dis;
dis = sqrt((x - a[i]) * (x - a[i]) + y * y);
t2 = (double)dis / (double)vs;
if (t1 + t2 < tmin) {
imin = i;
tmin = t1 + t2;
dmin = dis;
} else if (t1 + t2 == tmin) {
if (dis < dmin) {
dmin = dis;
imin = i;
}
}
}
cout << imin + 1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Bet {
int id;
int amount;
int time;
Bet() {}
Bet(int a, int b, int c) {
id = a;
time = b;
amount = c;
}
bool operator<(const struct Bet &rhs) const { return time < rhs.time; }
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<Bet> v;
vector<vector<Bet> > bets(n);
for (int i = 0; i < n; ++i) {
int a;
int b;
cin >> a >> b;
a--;
v.push_back(Bet(a, i, b));
bets[a].push_back(Bet(a, i, b));
}
vector<bool> have(n, false);
vector<Bet> temp;
for (int i = n - 1; i >= 0; --i) {
if (!have[v[i].id]) {
temp.push_back(v[i]);
have[v[i].id] = true;
}
}
stack<Bet> lastbet;
for (int i = temp.size() - 1; i >= 0; --i) {
lastbet.push(temp[i]);
}
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int k;
cin >> k;
vector<bool> remove(n, false);
for (int j = 0; j < k; ++j) {
int a;
cin >> a;
a--;
remove[a] = true;
}
vector<Bet> save;
Bet winner = Bet(-1, -1, 0);
while (!lastbet.empty()) {
Bet top = lastbet.top();
if (!remove[top.id]) {
if (winner.id >= 0) {
break;
}
winner = top;
}
save.push_back(top);
lastbet.pop();
}
if (winner.id >= 0) {
if (!lastbet.empty()) {
Bet nextTop = lastbet.top();
int n = bets[winner.id].size();
for (int pow = 20, shift = 1 << pow; pow >= 0;
pow--, shift = 1 << pow) {
int idx = n - shift;
if (idx >= 0) {
if (bets[winner.id][idx].time > nextTop.time) {
n = idx;
}
}
}
winner = bets[winner.id][n];
} else {
winner = bets[winner.id][0];
}
}
cout << winner.id + 1 << ' ' << winner.amount << endl;
for (int j = save.size() - 1; j >= 0; --j) {
lastbet.push(save[j]);
}
}
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char now[1 << 16], *S, *T;
if (S == T) {
T = (S = now) + fread(now, 1, 1 << 16, stdin);
if (S == T) return EOF;
}
return *S++;
}
inline int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
(c == '-') ? (f = 0) : 0;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return f ? x : ((~x) + 1);
}
const int mod = 998244353;
inline int add(const int &x, const int &y) {
return (x + y >= mod) ? (x + y - mod) : (x + y);
}
inline void Add(int &x, const int &y) {
x += y;
(x >= mod) ? (x -= mod) : 0;
}
inline int sub(const int &x, const int &y) {
return (x < y) ? (x - y + mod) : (x - y);
}
inline void Sub(int &x, const int &y) {
x -= y;
(x < 0) ? (x += mod) : 0;
}
inline int qpow(int a, int b) {
if (!a) return 0;
int res = 1;
for (; b; b >>= 1, a = 1ll * a * a % mod)
if (b & 1) res = 1ll * res * a % mod;
return res;
}
const int N = 1010;
int n, m, a[N], f[N][N], g[N][N];
int main() {
n = read();
m = read();
for (int(i) = (1); (i) <= (n); ++(i)) a[i] = read();
sort(a + 1, a + n + 1);
int ans = 0;
for (int i = 1; i * (m - 1) <= 100000; ++i) {
int k = 0;
f[0][0] = g[0][0] = 1;
for (int(j) = (1); (j) <= (n); ++(j)) {
while (k + 1 < j && a[k + 1] + i <= a[j]) ++k;
for (int(v) = (1); (v) <= (m); ++(v)) f[j][v] = add(f[j][v], g[k][v - 1]);
for (int(v) = (0); (v) <= (m); ++(v)) g[j][v] = add(g[j - 1][v], f[j][v]);
}
ans = add(ans, g[n][m]);
for (int(j) = (0); (j) <= (n); ++(j))
for (int(k) = (0); (k) <= (m); ++(k)) f[j][k] = g[j][k] = 0;
}
printf("%d\n", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
int main() {
int n, a[102], i, j, coin = 0;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 1; i <= n; i++) {
if ((a[i] == 2 && a[i + 1] == 3) || (a[i] == 3 && a[i + 1] == 2)) {
printf("Infinite\n");
break;
}
}
if (i == (n + 1)) {
printf("Finite\n");
for (j = 1; j < n; j++) {
switch (a[j]) {
case 1:
if (a[j + 1] == 2) {
if ((j > 1 && a[j - 1] == 2)) {
coin = coin + 3;
} else if (j == 1)
coin = coin + 3;
else if (j > 1 && a[j - 1] == 3)
coin = coin + 2;
} else
coin = coin + 4;
break;
case 2:
coin = coin + 3;
break;
case 3:
coin = coin + 4;
break;
}
}
printf("%d\n", coin);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int n0 = 1003;
vector<string> ans;
int N, ind[n0];
vector<array<int, 3>> add;
void solve(vector<int> v) {
int n = (int)(v).size();
int suf = 0;
if (n) {
suf = n - 1;
v[n - 1]--;
while (suf - 1 >= 0 && v[suf - 1] == n) v[suf - 1]--, suf--;
}
string cur;
for (int i = 0; i < N; i++) cur.push_back('0');
for (int i = suf; i < n; i++) cur[ind[i]] = '1';
for (int i = 0; i < (int)(add).size(); i++) {
if (i == (int)(add).size() - 1 && add[i][2] < add[i][0]) continue;
if (add[i][1]) {
cur[ind[add[i][0]]] = '1';
add[i][1]--;
}
}
ans.push_back(cur);
if (n) {
add.push_back({n - 1, v[n - 1], suf});
v.pop_back();
solve(v);
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
cin >> N;
vector<array<int, 2>> inp;
for (int i = 0; i < N; i++) {
int x;
cin >> x;
inp.push_back({x, i});
}
sort(begin(inp), end(inp));
vector<int> v(N);
for (int i = 0; i < N; i++) v[i] = inp[i][0], ind[i] = inp[i][1];
solve(v);
cout << (int)(ans).size() << '\n';
for (auto& i : ans) cout << i << '\n';
}
| 18 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9 + 7;
const long long INF = 1e18 + 5;
const long long mxn = 1e6 + 5;
const int mod = 1e9 + 7, pa = 1e6 + 7;
long long n, a[555555], u[555555], mx = 0, l[mxn], pr[mxn];
long long c[555555], b[555555], p[555555];
vector<int> v[mxn];
int main() {
int n, k;
cin >> n >> k;
string second;
cin >> second;
for (int i = 0; i < second.size(); i++) c[second[i] - '0']++;
string h = second, ss = second;
h += '9';
int mn = 1e9, id = 0;
for (int i = 0; i <= 9; i++) {
long long x = k - c[i];
int y = 0;
if (x <= 0 && mn > x) mn = 0, id = i, l[i] = 0;
if (x < 0) x = 0;
vector<pair<int, int> > v;
for (int j = 0; j <= 9; j++) v.push_back(make_pair(abs(i - j), j));
sort(v.begin(), v.end());
for (int j = 1; j < v.size(); j++) {
y += min(x, c[v[j].second]) * v[j].first, x -= min(x, c[v[j].second]);
}
if (mn > y) mn = y, id = i;
l[i] = y;
}
cout << mn << endl;
if (mn == 0) return cout << second, 0;
for (int jj = 0; jj <= 9; jj++) {
id = jj;
second = ss;
if (l[id] != mn) continue;
vector<int> v[55];
if (mn == 0) return cout << second, 0;
int x = max(0ll, k - c[id]);
for (int i = 0; i < n; i++)
if (id != second[i] - '0') v[abs(second[i] - '0' - id)].push_back(i);
int ii = id;
id = 0;
int y = 0;
for (int i = 0; i < n; i++) b[i] = second[i] - '0';
y = mn;
for (int i = 1; i <= 10; i++) {
if (y - v[i].size() >= 0)
id = i, y -= v[i].size(), p[i] = v[i].size();
else
p[i] = y / i, y = 0;
}
for (int i = 1; i <= 10; i++) {
for (int j = 0; j < v[i].size(); j++)
if (x > 0 && b[v[i][j]] > ii && p[i] > 0)
x--, second[v[i][j]] = ii + '0', p[i]--;
for (int j = v[i].size() - 1; j >= 0; j--)
if (x > 0 && p[i] > 0 && b[v[i][j]] < ii)
x--, p[i]--, second[v[i][j]] = ii + '0';
}
if (h.size() > second.size()) h = second;
if (h > second) h = second;
second = ss;
}
cout << h;
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100100;
int n, m, k;
bool rev;
vector<int> a[N];
const int BOUND = 11;
void clear() {
for (int i = 0; i < n; i++) {
a[i].clear();
a[i].resize(m);
for (int j = 0; j < m; j++) a[i][j] = 0;
}
}
int calcSquare(int x, int y) {
if (x < 0 || y < 0 || x + 1 >= n || y + 1 >= m) return 0;
return a[x][y] + a[x + 1][y] + a[x][y + 1] + a[x + 1][y + 1];
}
int evalScore(int x) {
if (x == 4) return 3;
if (x == 3) return 1;
return 0;
}
void printAns() {
if (!rev) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++)
if (a[i][j] == 1)
printf("*");
else
printf(".");
printf("\n");
}
} else {
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++)
if (a[j][i] == 1)
printf("*");
else
printf(".");
printf("\n");
}
}
return;
}
void solveStupid() {
clear();
int x = 0;
for (int i = 0; x < k && i < n; i++)
for (int j = 0; x < k && j < m; j++) {
int oldX = x;
a[i][j] = 1;
x += evalScore(calcSquare(i - 1, j - 1));
x += evalScore(calcSquare(i - 1, j));
if (x > k) {
a[i][j] = 0;
x = oldX;
}
}
if (x != k) throw;
printAns();
return;
}
int off(int x, int y) {
if (a[x][y] == 0) throw;
int res = 0;
res += evalScore(calcSquare(x - 1, y - 1));
res += evalScore(calcSquare(x - 1, y));
res += evalScore(calcSquare(x, y - 1));
res += evalScore(calcSquare(x, y));
a[x][y] = 0;
return res;
}
void solveBrute() {
clear();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) a[i][j] = 1;
k = 4 * (n - 1) * (m - 1) - k;
vector<pair<int, int> > pos;
pos.push_back(make_pair(0, 0));
pos.push_back(make_pair(1, 0));
pos.push_back(make_pair(0, 1));
pos.push_back(make_pair(0, 2));
pos.push_back(make_pair(0, m - 1));
pos.push_back(make_pair(n - 1, 0));
pos.push_back(make_pair(n - 1, m - 1));
if (m > 3) pos.push_back(make_pair(0, 3));
sort(pos.begin(), pos.end());
pos.resize(unique(pos.begin(), pos.end()) - pos.begin());
int w = (int)pos.size();
for (int mask = 0; mask < (1 << w); mask++) {
if (mask > 0 && ((mask & 1) == 0)) continue;
for (int i = 0; i < w; i++) a[pos[i].first][pos[i].second] = 1;
int cur = k;
for (int i = 0; i < w; i++) {
if (((mask >> i) & 1) == 0) continue;
cur -= off(pos[i].first, pos[i].second);
}
if (cur == 0) {
printAns();
return;
}
}
printf("-1\n");
return;
}
void solve() {
scanf("%d%d%d", &n, &m, &k);
if (k == 0) {
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i == 0 && j == 0)
printf("*");
else
printf(".");
}
printf("\n");
}
return;
}
rev = 0;
if (n > m) {
swap(n, m);
rev = 1;
}
int delta = 4 * (n - 1) * (m - 1) - k;
if (delta < 0) {
printf("-1\n");
return;
}
if (delta >= BOUND) {
solveStupid();
return;
}
solveBrute();
return;
}
int main() {
int t;
scanf("%d", &t);
while (t--) {
solve();
if (t != 0) printf("\n");
}
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
const int N = 10;
vector<vector<int>> frec(2, vector<int>(N, 0));
for (char ch : s) frec[0][ch - '0']++, frec[1][ch - '0']++;
string ans1 = "";
string ans2 = "";
int mx = 0, pib = -1;
for (int d1 = 1; d1 <= 9; d1++) {
int d2 = 10 - d1;
if (frec[0][d1] == 0 or frec[1][d2] == 0) continue;
frec[0][d1]--, frec[1][d2]--;
int zeros = 1;
for (int d = 0; d <= 9; d++) {
zeros += min(frec[0][d], frec[1][9 - d]);
}
if (zeros > mx) mx = zeros, pib = d1;
frec[0][d1]++, frec[1][d2]++;
}
if (pib != -1) {
int d1 = pib, d2 = 10 - pib;
ans1 += char('0' + d1);
ans2 += char('0' + d2);
frec[0][d1]--, frec[1][d2]--;
for (int d = 0; d <= 9; d++) {
int cnt = min(frec[0][d], frec[1][9 - d]);
ans1 += string(cnt, char('0' + d));
ans2 += string(cnt, char('0' + 9 - d));
frec[0][d] -= cnt;
frec[1][9 - d] -= cnt;
}
reverse(begin(ans1), end(ans1));
reverse(begin(ans2), end(ans2));
}
int cnt = min(frec[0][0], frec[1][0]);
ans1 += string(cnt, '0');
ans2 += string(cnt, '0');
frec[0][0] -= cnt;
frec[1][0] -= cnt;
for (int d = 0; d <= 9; d++)
for (int j = 0; j < frec[0][d]; j++) cout << char('0' + d);
cout << ans1 << '\n';
for (int d = 0; d <= 9; d++)
for (int j = 0; j < frec[1][d]; j++) cout << char('0' + d);
cout << ans2 << '\n';
return (0);
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const long long N = 1002;
long long dr[4] = {0, 0, 1, -1};
long long dc[4] = {1, -1, 0, 0};
long long ddr[8] = {0, 0, 1, -1, 1, -1, 1, -1};
long long ddc[8] = {1, -1, 0, 0, 1, -1, -1, 1};
long long ddr1[8] = {1, 1, -1, -1, 2, 2, -2, -2};
long long ddc1[8] = {2, -2, 2, -2, 1, -1, 1, -1};
int32_t main() {
fast();
long long n, d, h, D;
cin >> n >> d >> h;
D = d;
if (d > 2 * h) {
cout << "-1";
return 0;
}
if (n > 2 && h == 1 && d == 1) {
cout << "-1";
return 0;
}
if (n == 2 && h == 1 && d == 1) {
cout << "1 2\n";
return 0;
}
for (long long i = 0; i < min(h, d); i++) {
cout << 2 - 1 + i << " " << 2 + i << "\n";
}
d -= h;
for (long long i = 0; i < d; i++) {
if (i == 0)
cout << 1 << " " << h + 2 << "\n";
else {
cout << h + 1 + i << " " << h + 2 + i << "\n";
}
}
n -= D + 1;
long long key = 1;
if (h == D) key = 2;
for (long long i = 0; i < n; i++) {
cout << key << " " << D + 2 + i << "\n";
}
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> q[100005];
int f, t;
int p[100005];
bool r;
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
scanf("%d%d", &f, &t);
q[f].push_back(i), q[t].push_back(i);
}
for (int i = 1; i <= n; i++) {
if (q[i].size() >= 3) {
r = 1;
for (int j = 0; j <= 2; j++) {
p[q[i][j]] = j + 1;
}
break;
}
}
if (r == 0) {
for (int i = 0; i < n - 1; i++) {
cout << i << endl;
}
return 0;
}
int cnt = 2;
for (int i = 1; i <= n - 1; i++) {
if (p[i] == 3) cout << 0 << endl;
if (p[i] == 1) cout << 1 << endl;
if (p[i] == 2) cout << 2 << endl;
if (p[i] == 0) cout << ++cnt << endl;
}
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int n;
int a;
double min = 180.0;
int count = 0;
cin >> n;
cin >> a;
double degree = 180.0 / n;
double tmp;
for (int i = 1; i <= n - 2; i++) {
tmp = i * degree;
if (abs(tmp - a) < min) {
count = i;
min = abs(tmp - a);
}
}
cout << "1 2 " << n + 1 - count << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 9223372036854775807LL, SQ_MAX = 40000000000000000LL;
void getmin(long long &a, const long long b) {
if (b < a) a = b;
}
void getmax(long long &a, const long long b) {
if (b > a) a = b;
}
long long Sq(const long long a) { return a * a; }
struct Point {
long long x, y;
Point() {}
Point(const long long _x, const long long _y) : x(_x), y(_y) {}
};
int N;
Point P[100000];
bool SolveTilt(const long long tsq) {
long long ymn = 0, ymx = 0;
int l, r = 0;
for (l = 0; l < N && P[l].x < 0 && Sq(P[l].x) < tsq; l++)
getmax(ymx, P[l].y), getmin(ymn, P[l].y);
for (;;) {
if (l == N || P[l].x >= 0) return false;
for (; r < N && Sq(P[r].x - P[l].x) <= tsq; r++)
;
const long long y2 = sqrt(tsq - Sq(P[l].x));
if (y2 > -P[l].x) return false;
const long long y1 = max(-y2, (long long)(y2 - sqrt(tsq)));
if (r == N && ymn <= y1 && y2 <= ymx) return true;
getmax(ymx, P[l].y), getmin(ymn, P[l].y);
l++;
}
}
bool SolveLine(const long long lsq) {
static long long lymx[100000], lymn[100000], rymx[100000], rymn[100000];
lymx[0] = lymn[0] = P[0].y;
for (int i = 1; i < N; i++)
lymx[i] = max(lymx[i - 1], P[i].y), lymn[i] = min(lymn[i - 1], P[i].y);
rymx[N - 1] = rymn[N - 1] = P[N - 1].y;
for (int i = N - 1; i >= 0; i--)
rymx[i] = max(rymx[i + 1], P[i].y), rymn[i] = min(rymn[i + 1], P[i].y);
for (int r = 0, l = 0; r < N; r++) {
for (; Sq(P[r].x - P[l].x) > lsq; l++)
;
if (l == 0 && r == N - 1) return true;
const long long x1 = P[l].x, x2 = P[r].x,
y1 = min(l > 0 ? lymn[l - 1] : INF,
r + 1 < N ? rymn[r + 1] : INF),
y2 = max(l > 0 ? lymx[l - 1] : -INF,
r + 1 < N ? rymx[r + 1] : -INF);
if (Sq(y2 - y1) <= lsq && max(Sq(y1), Sq(y2)) + max(Sq(x1), Sq(x2)) <= lsq)
return true;
}
return false;
}
bool CmpX(const Point &a, const Point &b) { return a.x < b.x; }
long long TiltMin() {
sort(P, P + N, CmpX);
long long l = 0, r = SQ_MAX;
while (l < r) {
const long long mid = (l + r) / 2;
if (SolveTilt(mid))
r = mid;
else
l = mid + 1LL;
}
return r;
}
long long LineMin() {
sort(P, P + N, CmpX);
long long l = 0, r = SQ_MAX;
while (l < r) {
const long long mid = (l + r) / 2;
if (SolveLine(mid))
r = mid;
else
l = mid + 1LL;
}
return r;
}
void Flip1(bool ish) {
for (int i = 0; i < N; i++) (ish ? P[i].x : P[i].y) *= -1;
}
void Flip2() {
for (int i = 0; i < N; i++) swap(P[i].x, P[i].y);
}
void Flip3() {
Flip2();
Flip1(true), Flip1(false);
}
int main() {
while (scanf("%d", &N) == 1) {
for (int i = 0; i < N; i++) scanf("%lld%lld", &P[i].x, &P[i].y);
long long ans = INF;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 2; j++) getmin(ans, TiltMin()), Flip3();
Flip1(i & 1);
}
for (int i = 0; i < 2; i++) getmin(ans, LineMin()), Flip2();
printf("%lld\n", ans);
}
return 0;
}
| 21 |
#include <bits/stdc++.h>
using namespace std;
int n, a, b;
int x[110], y[110];
int f(int A, int B) {
if (x[A] > a || y[A] > b || x[B] > a || y[B] > b) return 0;
int x1 = x[A] - 1, y1 = y[A] - 1;
int x2 = a - x[B], y2 = b - y[B];
if (x1 >= x2 && y1 >= y2) return 0;
return x[A] * y[A] + x[B] * y[B];
}
int main() {
scanf("%d %d %d", &n, &a, &b);
for (int i = 0; i < n; i++) scanf("%d %d", &x[i], &y[i]);
int ans = 0;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = 0; k < 2; k++) {
for (int r = 0; r < 2; r++) {
ans = max(ans, f(i, j));
swap(x[j], y[j]);
}
swap(x[i], y[i]);
}
}
}
printf("%d\n", ans);
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int main() {
iostream::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long q;
cin >> q;
long long maxx = pow(10, 18) + 5;
set<long long> st, st1;
for (long long i = (2); i < (1000001); ++i) {
long long tmp = i * i * i;
while (true) {
st.insert(tmp);
if (tmp > maxx / i) break;
tmp *= i;
}
}
for (auto i : st) {
long long sq = sqrt(i);
if (i == sq * sq) st1.insert(i);
}
for (auto i : st1) {
st.erase(i);
}
vector<long long> v(st.begin(), st.end());
while (q--) {
long long a, b;
cin >> a >> b;
long long ans = 0;
ans += floor(sqrtl(b)) - ceil(sqrtl(a)) + 1;
ans += lower_bound((v).begin(), (v).end(), b + 1) -
lower_bound((v).begin(), (v).end(), a);
cout << ans << endl;
}
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 50005;
struct Node {
long long sum;
int tag;
Node *lson, *rson;
} * rt[N], *null;
int n, m, Q, C, f[N], c[N], pa[N], dep[N], sz[N], son[N], top[N], dfn[N],
pos[N], dfc;
vector<int> G[N];
long long sumd[N], sum2[N];
void dfs1(int u, int depth) {
dep[u] = depth;
sz[u] = 1;
for (int v : G[u]) {
dfs1(v, depth + 1);
sz[u] += sz[v];
if (sz[son[u]] < sz[v]) son[u] = v;
}
}
void dfs2(int u, int tp) {
pos[dfn[u] = ++dfc] = u;
top[u] = tp;
if (son[u]) {
dfs2(son[u], tp);
}
for (int v : G[u])
if (v != son[u]) {
dfs2(v, v);
}
}
long long Qry(Node *&i, int l, int r, int lf, int rg, int tag) {
if (lf <= l && r <= rg) return i->sum + 1ll * tag * (r - l + 1);
int mid = (l + r) >> 1;
long long ret = 0;
if (lf <= mid) ret += Qry(i->lson, l, mid, lf, rg, tag + i->tag);
if (rg > mid) ret += Qry(i->rson, mid + 1, r, lf, rg, tag + i->tag);
return ret;
}
void Add(Node *&i, int l, int r, int lf, int rg, int ty) {
if (i == null) {
i = new Node();
*i = *null;
}
if (lf <= l && r <= rg) {
i->tag += ty;
i->sum += ty * (r - l + 1);
} else {
int mid = (l + r) >> 1;
if (lf <= mid) Add(i->lson, l, mid, lf, rg, ty);
if (rg > mid) Add(i->rson, mid + 1, r, lf, rg, ty);
i->sum = i->lson->sum + i->rson->sum + i->tag * (r - l + 1);
}
if (!(i->tag) && !(i->sum)) {
delete i;
i = null;
}
}
void Add(int idx, int u, int ty) {
while (u) {
Add(rt[idx], 1, n, dfn[top[u]], dfn[u], ty);
u = pa[top[u]];
}
}
long long Qry(int idx, int u) {
long long ret = 0;
while (u) {
ret += Qry(rt[idx], 1, n, dfn[top[u]], dfn[u], 0);
u = pa[top[u]];
}
return ret;
}
void Modify(int idx, int u, int ty) {
sumd[idx] += ty * dep[u];
if (ty == 1) {
sum2[idx] += ty * Qry(idx, u);
Add(idx, u, ty);
} else {
Add(idx, u, ty);
sum2[idx] += ty * Qry(idx, u);
}
}
int main() {
null = new Node();
null->tag = null->sum = 0;
null->lson = null->rson = null;
scanf("%d%d%d%d", &n, &m, &Q, &C);
for (int i = 1; i <= m; i++) rt[i] = null;
for (int i = 1; i <= n; i++) {
scanf("%d", &f[i]);
}
for (int i = 2; i <= n; i++) {
scanf("%d", &pa[i]);
G[pa[i]].push_back(i);
}
for (int i = 1; i <= m; i++) scanf("%d", &c[i]);
dfs1(1, 1);
dfs2(1, 1);
for (int i = 1; i <= n; i++) Modify(f[i], i, 1);
while (Q--) {
int op;
scanf("%d", &op);
if (op == 1) {
int u, k;
scanf("%d%d", &u, &k);
Modify(f[u], u, -1);
f[u] = k;
Modify(f[u], u, 1);
} else {
int k;
scanf("%d", &k);
double ans = (1.0 * (sum2[k] * 2 + sumd[k]) * c[k] * c[k] -
2.0 * sumd[k] * C * c[k]) /
n +
1.0 * C * C;
printf("%.10lf\n", ans);
}
}
return 0;
}
| 23 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
int powermod(int a, long long p, int mod) {
long long t = a;
int r = 1;
while (p) {
if (p & 1) r = ((long long)r * t) % mod;
t = (t * t) % mod;
p >>= 1;
}
return r;
}
int n, x;
int a[100000];
int cnt[2 * 100000 + 1];
int main() {
scanf("%d", &n);
scanf("%d", &x);
int mina = 1000000000;
int maxa = -1;
long long suma = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
mina = min(a[i], mina);
maxa = max(a[i], maxa);
suma += a[i];
}
long long num = suma - maxa;
if (n >= x) {
for (int i = 0; i < n; i++) {
if (2LL * (maxa - a[i]) <= 2 * n) {
cnt[maxa - a[i]]++;
}
}
int p = 0;
while (cnt[p] > 0 && cnt[p] % x == 0) {
cnt[p + 1] += cnt[p] / x;
p++;
}
num += p;
}
printf("%d\n", powermod(x, min(num, suma), 1000000007));
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 2e5 + 5;
int a[maxN], pf[2010], x[maxN], y[maxN], m;
int dp[2010], n, k;
int solve(int id) {
if (id < 0) return 0;
int &r = dp[id];
if (~r) return r;
r = solve(id - 1) + a[id];
for (int i = int(0); i < int(m); i++) {
if (id - x[i] < -1) continue;
int q = x[i] - y[i];
r = min(r, solve(id - x[i]) + pf[id] - pf[id - q]);
}
return r;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cin.tie(0), cout.tie(0),
cout.precision(15);
memset(dp, -1, sizeof dp);
cin >> n >> m >> k;
for (int i = int(0); i < int(n); i++) cin >> a[i];
for (int i = int(0); i < int(m); i++) cin >> x[i] >> y[i];
sort(a, a + n);
pf[0] = a[0];
for (int i = int(1); i < int(k); i++) pf[i] = pf[i - 1] + a[i];
cout << solve(k - 1);
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int A[200];
bool has[200];
int main() {
int N;
while (cin >> N) {
for (int i = 0; i < N; i++) cin >> A[i];
long long int maxi = 0;
long long int cnt = 0;
vector<int> ans, tmp;
bool fs = true;
for (int i = 0; i < N - 1; i++)
for (int j = i + 1; j < N; j++) {
if (A[i] == A[j]) {
cnt = 0;
tmp.clear();
for (int k = i; k <= j; k++) {
if (A[k] > 0 || k == i || k == j) {
tmp.push_back(k);
cnt += A[k];
}
}
if (cnt > maxi || fs) {
ans.assign(tmp.begin(), tmp.end());
maxi = cnt;
fs = false;
}
}
}
cout << maxi << " " << N - ans.size() << endl;
memset(has, false, sizeof has);
for (int i = 0; i < ans.size(); i++) has[ans[i]] = true;
for (int i = 0; i < N; i++)
if (has[i] == false) cout << i + 1 << " ";
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long x, y, z;
while (cin >> x >> y >> z) {
long long sum = (x + y) / z, ans = 0;
if (x % z == 0 && y % z == 0) {
cout << sum << ' ' << 0 << endl;
continue;
} else {
long long a, b;
a = x % z;
b = y % z;
if (a + b >= z) {
if (a >= b)
ans = z - a;
else
ans = z - b;
}
cout << sum << ' ' << ans << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
std::mt19937 rng(
(int)std::chrono::steady_clock::now().time_since_epoch().count());
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(NULL);
int a, b;
std::cin >> a >> b;
if (a < b) {
std::cout << "-1\n";
return 0;
}
if (a == b) {
std::cout << a << '\n';
return 0;
}
long double ans = 1e12;
{
long long x = a + b;
long long l = 1, r = (long long)4e9;
while (l != r) {
long long mid = (l + r + 1) / 2;
if (x / mid / 2 / b >= 1) {
l = mid;
} else {
r = mid - 1;
}
}
ans = std::min(ans, (long double)x / l / 2.0);
}
{
long long x = a - b;
long long l = 0, r = (long long)4e9;
while (l != r) {
long long mid = (l + r + 1) / 2;
if (x / mid / 2 / b >= 1) {
l = mid;
} else {
r = mid - 1;
}
}
if (l > 0) {
ans = std::min(ans, (long double)x / l / 2.0);
}
}
std::cout << std::fixed << std::setprecision(15) << (double)ans << '\n';
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
int N, P[1000010], T, Q[1000010], X[1000010];
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", P + i);
scanf("%d", &T);
for (int i = 0; i < T; i++) {
scanf("%d", Q + i);
Q[i]--;
}
sort(Q, Q + T);
memset(X, -1, sizeof X);
for (int i = 0; i < T; i++) {
int k = Q[i];
stack<int> st;
st.push(k);
for (; k--;) {
if (X[k] != -1)
k = X[k];
else {
int e = st.top();
if (P[e] == P[k]) {
X[e] = k;
X[k] = e;
st.pop();
if (st.empty()) break;
} else {
st.push(k);
}
}
}
if (!st.empty()) {
puts("NO");
return 0;
}
}
stack<int> st;
for (int k = 0; k < N; k++) {
if (X[k] == -1) {
if (st.empty() || P[st.top()] != P[k])
st.push(k);
else {
int e = st.top();
st.pop();
X[e] = k;
X[k] = e;
}
} else
k = X[k];
}
if (st.empty()) {
puts("YES");
for (int i = 0; i < N; i++)
printf("%d%c", i < X[i] ? P[i] : -P[i], i + 1 == N ? '\n' : ' ');
} else
puts("NO");
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
int a[(1 << 22) + 10], n, m, pad;
bool vis[(1 << 22) + 10], has[(1 << 22) + 10];
void dfs(int x) {
vis[x] = 1;
if (has[x]) {
int rx = (~x) ^ pad;
if (!vis[rx]) dfs(rx);
}
for (int i = n; i >= 0; --i) {
if ((x >> i) & 1) {
int nx = x ^ (1 << i);
if (!vis[nx]) dfs(nx);
}
}
}
int main() {
cin >> n >> m;
pad = ~((1 << n) - 1);
for (int i = 0; i < m; ++i) scanf("%d", a + i), has[a[i]] = 1;
int ans = 0;
for (int i = 0; i < m; ++i) {
if (!vis[a[i]]) {
ans++;
dfs((~a[i]) ^ pad);
}
}
printf("%d\n", ans);
return 0;
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, aux, i, j;
cin >> n;
k = n * n;
aux = n;
i = 1;
while (aux) {
j = i;
if (n % 2 == 0)
j += n / 2;
else
j = j + n / 2 + 1;
for (i; i < j; i++) cout << i << " " << k - i + 1 << " ";
cout << "\n";
aux--;
}
return 0;
}
| 2 |
// Author: Pawan Raj
// Problem: E. Assimilation IV
// Contest: Codeforces - Educational Codeforces Round 109 (Rated for Div. 2)
// URL: https://codeforces.com/contest/1525/problem/E
#include <bits/stdc++.h>
#define fi first
#define se second
#define pb push_back
#define int long long
#define F(i, n) for (int i = 0; i < n; i++)
#define all(x)(x).begin(), (x).end()
#define show(A) for (auto i: A) cout << i << " "; cout << '\n';
#define show_(A, n) F(i, n) { show(A[i]) }
using namespace std;
using ld = long double;
using vi = vector < int > ;
using mi = map < int, int > ;
using pi = pair < int, int > ;
const int N = 300005;
const int MOD = 998244353;
const int inf = 1e18 + 1;
/***************************code begins here*****************************/
int power(int x, unsigned int y) {
int res = 1;
x = x % MOD;
if (x == 0) return 0;
while (y > 0)
{
if (y & 1)
res = (res*x) % MOD;
y = y>>1;
x = (x*x) % MOD;
}
return res;
}
int fact(int n){
if(n==0) return 1;
return (n*fact(n-1))%MOD;
}
void solve() {
int n, m, ans = 0; cin >> n >> m;
int a[n][m];
F(i, n) F(j, m) cin >> a[i][j];
F(j, m){
int temp = 1;
vi c(n);
F(i, n){
c[i] = a[i][j]-1;
}
sort(all(c));
// show(c);
F(i, n){
if((min(n, c[i]) - i )<=0){
temp = 0;
break;
}
temp *= min(n, c[i]) - i;
temp %= MOD;
}
temp = (temp*power(fact(n),MOD-2))%MOD;
ans = (ans + MOD + 1 - temp)%MOD;
}
cout << ans << '\n';
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
// cin >> t;
while (t--) solve();
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int M = 1000010;
const int inf = 0x3f3f3f3f;
const long long oo = 0x3f3f3f3f3f3f3f3fll;
const int mod = 1e9 + 9;
int n, a[N];
bool vis[N];
void dfs(int u, queue<int> &que) {
vis[u] = 1;
que.push(u);
if (vis[a[u]]) return;
dfs(a[u], que);
}
vector<vector<pair<int, int> > > ans;
queue<vector<pair<int, int> > > three, two;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
if (vis[i]) continue;
queue<int> que;
dfs(i, que);
while (que.size() >= 5) {
vector<pair<int, int> > temp;
int first = que.front();
int next = -1;
for (int i = 0; i < 5; i++)
temp.push_back(
make_pair(que.front(), (i == 4) ? first : a[que.front()])),
next = a[que.front()], que.pop();
ans.push_back(temp);
que.push(first);
a[first] = next;
}
if (que.size() == 2) {
vector<pair<int, int> > temp;
while (que.size())
temp.push_back(make_pair(que.front(), a[que.front()])), que.pop();
two.push(temp);
}
if (que.size() == 3) {
vector<pair<int, int> > temp;
while (que.size())
temp.push_back(make_pair(que.front(), a[que.front()])), que.pop();
three.push(temp);
}
if (que.size() == 4) {
vector<pair<int, int> > temp;
while (que.size())
temp.push_back(make_pair(que.front(), a[que.front()])), que.pop();
ans.push_back(temp);
}
}
while (two.size() && three.size()) {
vector<pair<int, int> > a = two.front();
vector<pair<int, int> > b = three.front();
two.pop();
three.pop();
vector<pair<int, int> > temp;
for (int i = 0; i < a.size(); i++) temp.push_back(a[i]);
for (int i = 0; i < b.size(); i++) temp.push_back(b[i]);
ans.push_back(temp);
}
while (two.size() >= 2) {
vector<pair<int, int> > a = two.front();
two.pop();
vector<pair<int, int> > b = two.front();
two.pop();
vector<pair<int, int> > temp;
for (int i = 0; i < a.size(); i++) temp.push_back(a[i]);
for (int i = 0; i < b.size(); i++) temp.push_back(b[i]);
ans.push_back(temp);
}
while (three.size() >= 3) {
vector<pair<int, int> > a = three.front();
three.pop();
vector<pair<int, int> > b = three.front();
three.pop();
vector<pair<int, int> > c = three.front();
three.pop();
vector<pair<int, int> > temp;
for (int i = 0; i < b.size(); i++) temp.push_back(b[i]);
temp.push_back(make_pair(a[0].first, a[1].first));
temp.push_back(make_pair(a[1].first, a[0].first));
ans.push_back(temp);
temp.clear();
for (int i = 0; i < c.size(); i++) temp.push_back(c[i]);
temp.push_back(make_pair(a[0].first, a[2].first));
temp.push_back(make_pair(a[2].first, a[0].first));
ans.push_back(temp);
}
while (two.size()) ans.push_back(two.front()), two.pop();
while (three.size()) ans.push_back(three.front()), three.pop();
cout << ans.size() << endl;
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].size() << endl;
for (int j = 0; j < ans[i].size(); j++) cout << ans[i][j].first << " ";
cout << endl;
for (int j = 0; j < ans[i].size(); j++) cout << ans[i][j].second << " ";
cout << endl;
}
return 0;
}
| 18 |
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
using namespace std;
const int kMaxn = 55;
int n, a[kMaxn], b[kMaxn];
pair<int, int> c[kMaxn];
int main() {
static int i, j, x, y, ans;
scanf("%d", &n);
for (i = 1; i <= n; ++i) {
scanf("%d", a + i);
c[i].first = a[i];
c[i].second = i;
}
sort(c + 1, c + n + 1);
for (i = 2; i <= n; ++i) b[c[i - 1].second] = a[c[i].second];
b[c[n].second] = a[c[1].second];
for (i = 1; i <= n; ++i) printf("%d ", b[i]);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
std::vector<long long> v(100001, 0);
std::vector<long long> dp(100001, 0);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k;
cin >> n >> k;
std::vector<long long> v(n, 0);
for (int i = 0; i < n; ++i) {
cin >> v[i];
}
long long sum = v[0];
long long cur = 0, i = 0, j = 0;
while (j < n) {
if (sum <= k) {
cur = max(cur, j - i + 1);
j++;
if (j >= n) break;
sum += v[j];
} else {
sum -= v[i++];
}
}
cout << cur;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
const int inf = 0x3f3f3f3f;
const long long INF = 1e18;
const int M = 3e5 + 5;
int tr[M * 29][2];
long long dp[100][2];
int cnt;
vector<int> g[M * 29];
void pn() { cout << "NO" << '\n'; }
void py() { cout << "YES" << '\n'; }
void add(int x, int pos) {
int rt = 0;
for (int i = 29; i >= 0; i--) {
int v = ((x >> i) & 1);
if (!tr[rt][v]) tr[rt][v] = ++cnt;
rt = tr[rt][v];
g[rt].push_back(pos);
}
}
void dfs(int rt, int now) {
int l = tr[rt][0], r = tr[rt][1];
if (l) dfs(l, now - 1);
if (r) dfs(r, now - 1);
if (!l || !r) return;
int i = 0;
long long res = 0;
for (int j = 0; j < (int)g[l].size(); j++) {
while (i < (int)g[r].size() && g[l][j] > g[r][i]) i++;
res += i;
}
dp[now][0] += res;
dp[now][1] += (long long)g[l].size() * (long long)g[r].size() - res;
}
int main() {
int n;
scanf("%d", &n);
for (int x, i = 1; i <= n; i++) {
scanf("%d", &x);
add(x, i);
}
dfs(0, 29);
long long sum = 0, x = 0;
for (int i = 29; i >= 0; i--) {
if (dp[i][0] > dp[i][1]) x += (1 << i);
sum += min(dp[i][0], dp[i][1]);
}
printf("%lld %lld\n", sum, x);
return 0;
}
| 12 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, p;
cin >> n >> p;
int edge_cnt = (2 * n) + p, curr_dif = 1;
set<pair<int, int> > s;
while (1) {
for (int i = 1; i <= n; i++) {
int j = i + curr_dif;
if (j > n) {
j -= n;
}
if (i == j) {
continue;
}
s.insert(make_pair(min(i, j), max(i, j)));
if (s.size() == edge_cnt) {
break;
}
}
curr_dif++;
if (s.size() == edge_cnt) {
break;
}
}
set<pair<int, int> >::iterator itr;
for (itr = s.begin(); itr != s.end(); itr++) {
pair<int, int> p;
p = *itr;
cout << p.first << " " << p.second << endl;
}
}
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
int vec[1000005];
map<long long, int> M;
int main() {
int n;
cin >> n;
for (int i = 2; i <= 1000000; i++) {
if (vec[i]) continue;
for (int j = i; j <= 1000000; j += i) vec[j] = i;
}
for (int i = 1; i <= 1000000; i++) {
M[1LL * i * i * i] = i;
}
for (int i = 0; i < n; i++) {
long long a, b;
scanf("%lld%lld", &a, &b);
long long c = a * b;
bool bad = 0;
if (M.find(c) == M.end()) {
bad = 1;
} else {
int x = M[c];
while (x != 1) {
int y = vec[x];
{
int A = 0, B = 0;
while (a % y == 0) {
a /= y;
A++;
}
while (b % y == 0) {
b /= y;
B++;
}
while (x % y == 0) x /= y;
if (A + B > 0) {
if ((A + B) % 3 == 0 && min(A, B) * 2 >= max(A, B))
;
else
bad = 1;
}
}
}
}
puts(bad ? "No" : "Yes");
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
const int N = int(5e5) + 10, M = int(5e5) + 10, mod = int(1e9) + 7;
int n, a[M], lx[M], rx[M], q, lp[N + 2], last[N];
vector<pair<int, pair<int, int> > > t[4 * M];
vector<pair<int, int> > mx[4 * M];
void build(int v, int tl, int tr) {
if (tl == tr) {
t[v].push_back(make_pair(lx[tl], make_pair(rx[tl], tl)));
mx[v].push_back(make_pair(rx[tl], tl));
return;
}
int tm = (tl + tr) >> 1;
build(v + v, tl, tm);
build(v + v + 1, tm + 1, tr);
t[v].resize(tr - tl + 1);
merge(t[v + v].begin(), t[v + v].end(), t[v + v + 1].begin(),
t[v + v + 1].end(), t[v].begin());
mx[v].push_back(t[v][0].second);
for (int i = 1; i < t[v].size(); i++) {
mx[v].push_back(t[v][i].second);
mx[v][i] = max(mx[v][i], mx[v][i - 1]);
}
}
int get(int v, int tl, int tr, int l, int r) {
if (l > tr || tl > r) return -1;
if (l <= tl && tr <= r) {
int lx = -1, rx = int(t[v].size());
while (rx - lx > 1) {
int mid = (lx + rx) >> 1;
if (t[v][mid].first <= l)
lx = mid;
else
rx = mid;
}
if (lx == -1 || mx[v][lx].first < r) return -1;
return mx[v][lx].second;
}
int tm = (tl + tr) >> 1;
int res = get(v + v, tl, tm, l, r);
if (res != -1) return res;
return get(v + v + 1, tm + 1, tr, l, r);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (int i = 1; i <= n; i++) {
lx[i] = last[a[i]] + 1;
last[a[i]] = i;
}
for (int i = 1; i < N; i++) {
last[i] = n + 1;
}
for (int i = n; i > 0; i--) {
rx[i] = last[a[i]] - 1;
last[a[i]] = i;
}
build(1, 1, n);
scanf("%d", &q);
int lst = -1;
for (int i = 1, l, r; i <= q; i++) {
scanf("%d%d", &l, &r);
lst = get(1, 1, n, l, r);
if (lst == -1) lst = 0;
printf("%d\n", a[lst]);
}
return 0;
}
| 16 |
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define int long long
#define pb push_back
#define mp make_pair
#define ff first
#define ss second
#define min3(a, b, c) min(c, min(a, b))
#define min4(a, b, c, d) min(d, min(c, min(a, b)))
#define max3(a, b, c) max(c, max(a, b))
#define max4(a, b, c, d) max(d, max(c, max(a, b)))
#define fast ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
ll nCrevenoroddfinder(ll n,ll r)
{
ll a=r;
ll b=n-r;
for(ll i=0;i<30;i++)
{
ll x=1<<i;
if((x&a)&&(x&b))
{
return 0;//even
}
}
return 1;//odd
}
// for calculating inverse
int modx(int x,int n)
{
int result=1,M=1e9+7;
while(n>0)
{
if(n % 2 ==1)
result=(result * x)%M;
x=(x*x)%M;
n=n/2;
}
return result;
}
ll ncr(ll n, ll k)
{
ll res = 1;
if (k > n - k)
k = n - k;
for (ll i = 0; i < k; ++i) {
res*=(n-i);
res /= (i + 1);
}
return res;
}
ll add(ll a,ll b,ll m){
return ((a%m)+(b%m))%m;
}
ll sub(ll a,ll b,ll m){
return ((a%m)-(b%m)+m)%m;
}
ll mul(ll a,ll b,ll m){
return ((a%m)*(b%m))%m;
}
ll inverse(ll a,ll m){
return modx(a,m-2);
}
ll power(ll x,ll n){
ll res=1;
while(n>0){
if(n%2==1)
res=(res*x);
x=x*x;
n/=2;
}
return res;
}
ll gcd(ll a,ll b){
if(b==0)
return a;
else
return gcd(b,a%b);
}
ll lcm(ll a,ll b){
return (a*b)/(gcd(a,b));
}
bool isprime(ll n) {
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0)return false;
}
return true;
}
bool isperfect(ll n) {
ll y = sqrt(n);
if (n % y == 0 && y * y == n)return true;
return false;
}
bool prime[10000000];
void seive() {
for(ll i=1;i<10000000;i++)
prime[i]=true;
prime[1] = true;
for (ll i = 2; i * i < 10000000; i++) {
if (!prime[i])continue;
for (ll j = i * i; j < 10000000; j += i) {
prime[j] = false;
}
}
}
int32_t main(){
fast
ll t,n,i,j;
cin>>t;
while(t--){
ll m;
cin>>n>>m; ll a[n],b[n],c[m],x[m],pos=-1;
for(i=0;i<n;i++)cin>>a[i];
for(i=0;i<n;i++)cin>>b[i];
for(i=0;i<m;i++)cin>>c[i];
vector<vector<ll>>mp(n+1);
// vector<ll>mp[n+1];
for(i=0;i<n;i++){
if(a[i]!=b[i]){
mp[b[i]].pb(i);
}
}
ll temp=n-1;
for(i=0;i<n;i++){
if(b[i]==c[m-1]){
pos=i;break;
}
}
// cout<<pos;
if(pos==-1){
cout<<"NO\n";continue;
}
ll flag=0;
for(i=m-1;i>=0;i--){
ll f=c[i],s=i;
if(i==m-1){
if(!mp[f].empty())
pos=mp[f].back();
}
if(!mp[f].empty()){
x[s]=mp[f].back();
mp[f].pop_back();
}
else x[s]=pos;
}
for (i = 0; i <=n; i++)
if (!mp[i].empty()) {
flag=1;break;
}
if(flag==1)cout<<"NO\n";
else{
cout<<"YES\n";
for(i=0;i<m;i++)
cout<<x[i]+1<<" ";
cout<<"\n";
}
}
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, y;
cin >> n;
set<int> x;
for (int i = 0; i < n; ++i) {
cin >> y;
x.insert(-y);
}
for (;;) {
bool b = false;
for (int t = -(*x.begin()) / 2; t > 0; t /= 2)
if (x.find(-t) == x.end()) {
x.erase(x.begin());
x.insert(-t);
b = true;
break;
}
if (!b) break;
}
for (set<int>::iterator it = x.begin(); it != x.end(); ++it)
cout << -(*it) << ' ';
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
string f(int i) {
int s = 1;
if (i < 1000) s = 0;
int a[4];
a[0] = i % 10;
i /= 10;
a[1] = i % 10;
i /= 10;
a[2] = i % 10;
i /= 10;
a[3] = i % 10;
i /= 10;
if (!s) a[3] = 0;
string t;
if ((a[1] == a[0]) || (a[0] == a[2]) || (a[0] == a[3]) || (a[1] == a[2]) ||
(a[1] == a[3]) || (a[2] == a[3]))
t = '+';
else {
t = char(a[3] + '0');
t += char(a[2] + '0');
t += char(a[1] + '0');
t += char(a[0] + '0');
}
return t;
}
int main() {
int n;
cin >> n;
string s[n];
int x[n][2];
for (int i = 0; i < n; i++) {
cin >> s[i] >> x[i][0] >> x[i][1];
}
string r;
int e = 0;
for (int i = 100; i <= 9999; i++) {
string u = f(i);
if (u != "+") {
int q = 1;
for (int j = 0; j < n; j++) {
int y[2];
y[0] = 0;
y[1] = 0;
for (int z = 0; z < 4; z++) {
for (int m = 0; m < 4; m++) {
if (s[j][z] == u[m] && z == m)
y[0]++;
else {
if (s[j][z] == u[m]) y[1]++;
}
}
}
if (y[0] != x[j][0] || y[1] != x[j][1]) {
q = 0;
break;
}
}
if (q == 1) {
e++;
r = u;
}
if (e > 1) {
cout << "Need more data";
return 0;
}
}
}
if (e) {
cout << r;
} else {
cout << "Incorrect data";
}
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void solve(void) {
int n;
cin >> n;
vector<pair<int, string>> ps(n), ans;
for (auto &p : ps) {
cin >> p.second >> p.first;
}
sort(ps.begin(), ps.end());
int h = 3000;
for (const auto &p : ps) {
auto pos = ans.begin() + p.first;
if (pos > ans.end()) {
cout << -1 << endl;
return;
}
ans.insert(pos, {h--, p.second});
}
for (auto a : ans) {
cout << a.second << ' ' << a.first << '\n';
}
}
int main() {
solve();
return 0;
}
| 10 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline T parse(const string &s) {
T x;
stringstream ss(s);
ss >> x;
return x;
}
const double EPS = 1e-12;
const int INF = 1000 * 1000 * 1000;
const long long LINF = INF * 1ll * INF;
const double DINF = 1e200;
const double PI = 3.1415926535897932384626433832795l;
int gcd(int a, int b) { return a ? gcd(b % a, a) : b; }
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long gcdex(long long a, long long b, long long &x, long long &y) {
if (!a) {
x = 0, y = 1;
return b;
}
long long k = b / a;
long long g = gcdex(b - k * a, a, y, x);
x -= k * y;
return g;
}
long long inv(long long a, long long m) {
assert(m > 1);
long long x, y, g;
g = gcdex(a, m, x, y);
return (x % (m / g) + m / g) % m / g;
}
long long crt(long long a1, long long m1, long long a2, long long m2) {
long long a = (a2 - a1 % m2 + m2) % m2;
long long x, y, g;
g = gcdex(m1, m2, x, y);
if (a % g) return -1;
long long m = m1 / g * m2;
assert(x + m2 >= 0);
x = a / g * (x + m2) % m2;
long long r = (a1 + x * m1) % m;
assert(r % m1 == a1 && r % m2 == a2);
return r;
}
long long powmod(long long a, long long p, long long m) {
assert(p >= 0);
long long r = 1;
while (p) {
if (p & 1) r = r * a % m;
p >>= 1;
a = a * a % m;
}
return r;
}
bool isprime(long long a) {
if (a <= 1) return false;
for (long long i = 2; i * i <= a; ++i) {
if (a % i == 0) return false;
}
return true;
}
long long sqrtup(long long a) {
if (!a) return 0;
long long x = max(0ll, (long long)sqrt((double)a));
while (x * x >= a) --x;
while ((x + 1) * (x + 1) < a) ++x;
return x + 1;
}
long long isqrt(long long a) {
assert(a >= 0);
long long x = max(0ll, (long long)sqrt((double)a));
while (x * x > a) --x;
while ((x + 1) * (x + 1) <= a) ++x;
return x;
}
long long sgn(long long x) { return x < 0 ? -1 : x > 0 ? 1 : 0; }
template <class T>
ostream &operator<<(ostream &s, const vector<T> &v);
template <class A, class B>
ostream &operator<<(ostream &s, const pair<A, B> &p);
template <class K, class V>
ostream &operator<<(ostream &s, const map<K, V> &m);
template <class T>
ostream &operator<<(ostream &s, const set<T> &m);
template <class T, size_t N>
ostream &operator<<(ostream &s, const array<T, N> &a);
template <class... T>
ostream &operator<<(ostream &s, const tuple<T...> &t);
template <class T>
ostream &operator<<(ostream &s, const vector<T> &v) {
s << '[';
for (int i = 0; i < (((int)(v).size())); ++i) {
if (i) s << ',';
s << v[i];
}
s << ']';
return s;
}
template <class A, class B>
ostream &operator<<(ostream &s, const pair<A, B> &p) {
s << "(" << p.first << "," << p.second << ")";
return s;
}
template <class K, class V>
ostream &operator<<(ostream &s, const map<K, V> &m) {
s << "{";
bool f = false;
for (const auto &it : m) {
if (f) s << ",";
f = true;
s << it.first << ": " << it.second;
}
s << "}";
return s;
}
template <class T>
ostream &operator<<(ostream &s, const set<T> &m) {
s << "{";
bool f = false;
for (const auto &it : m) {
if (f) s << ",";
f = true;
s << it;
}
s << "}";
return s;
}
template <class T>
ostream &operator<<(ostream &s, const multiset<T> &m) {
s << "{";
bool f = false;
for (const auto &it : m) {
if (f) s << ",";
f = true;
s << it;
}
s << "}";
return s;
}
template <class T, class V, class C>
ostream &operator<<(ostream &s, const priority_queue<T, V, C> &q) {
auto a = q;
s << "{";
bool f = false;
while (!a.empty()) {
if (f) s << ",";
f = true;
s << a.top();
a.pop();
}
return s << "}";
}
template <class T, size_t N>
ostream &operator<<(ostream &s, const array<T, N> &a) {
s << '[';
for (int i = 0; i < (((int)(a).size())); ++i) {
if (i) s << ',';
s << a[i];
}
s << ']';
return s;
}
template <class T>
ostream &operator<<(ostream &s, const deque<T> &a) {
s << '[';
for (int i = 0; i < (((int)(a).size())); ++i) {
if (i) s << ',';
s << a[i];
}
s << ']';
return s;
}
template <size_t n, class... T>
struct put1 {
static ostream &put(ostream &s, const tuple<T...> &t) {
s << get<sizeof...(T) - n>(t);
if (n > 1) s << ',';
return put1<n - 1, T...>::put(s, t);
}
};
template <class... T>
struct put1<0, T...> {
static ostream &put(ostream &s, const tuple<T...> &t) { return s; }
};
template <class... T>
ostream &operator<<(ostream &s, const tuple<T...> &t) {
s << "(";
put1<sizeof...(T), T...>::put(s, t);
s << ")";
return s;
}
ostream &put3(ostream &s, const char *, bool) { return s; }
template <class U, class... T>
ostream &put3(ostream &s, const char *f, bool fs, U &&u, T &&...t) {
while (*f == ' ') ++f;
if (!fs) s << ", ";
auto nf = f;
int d = 0;
while (*nf && (*nf != ',' || d)) {
if (*nf == '(')
++d;
else if (*nf == ')')
--d;
++nf;
}
auto nf2 = nf;
while (nf2 > f && *(nf2 - 1) == ' ') --nf;
fs = *f == '"';
if (!fs) {
s.write(f, nf2 - f);
s << "=";
};
s << u;
if (fs) s << ' ';
if (*nf) ++nf;
return put3(s, nf, fs, forward<T>(t)...);
}
int main(int argc, char **argv) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(20);
srand(time(0));
int n, k;
cin >> n >> k;
array<vector<int>, 4> A;
for (int q = 0; q < (4); ++q) {
A[q].resize(n);
for (int i = 0; i < (n); ++i) cin >> A[q][i];
}
vector<tuple<int, int, int>> R;
while (true) {
bool f = false, oo = false;
auto go = [&](int q, int i) {
if (q == 1) return i == n - 1 ? make_pair(2, i) : make_pair(1, i + 1);
return i == 0 ? make_pair(1, 0) : make_pair(2, i - 1);
};
for (int q = 1; q <= 2; ++q) {
for (int i = 0; i < (n); ++i) {
if (!A[q][i]) continue;
oo = true;
int qq = q == 1 ? 0 : 3;
if (A[qq][i] == A[q][i]) {
f = true;
R.push_back(make_tuple(A[q][i], qq + 1, i + 1));
A[qq][i] = A[q][i] = 0;
continue;
}
int ii;
tie(qq, ii) = go(q, i);
if (A[qq][ii] != 0) continue;
f = true;
R.push_back(make_tuple(A[q][i], qq + 1, ii + 1));
A[qq][ii] = A[q][i];
A[q][i] = 0;
}
}
if (!f) {
if (oo) {
assert(!((int)(R).size()));
cout << -1;
} else {
cout << ((int)(R).size()) << '\n';
for (auto t : R) {
cout << get<0>(t) << ' ' << get<1>(t) << ' ' << get<2>(t) << '\n';
}
}
return 0;
}
}
return 0;
}
| 13 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 32;
int ans[N][2], cnt = 0;
int G[10][10], rem[10], hd[10], on[10];
int n, d;
void RD(int &res) {
res = 0;
char c;
while (c = getchar(), c != '?')
;
do {
++res;
} while (c = getchar(), c == '?');
}
bool HALL() {
for (int S = 0; S < (1 << d); ++S) {
int tot = 0;
for (int i = 0; i < d; ++i)
if (S & (1 << i)) tot += rem[i + 1];
for (int i = 0; i < d; ++i)
for (int j = i; j < d; ++j)
if ((S & (1 << i)) || (S & (1 << j))) tot -= G[i + 1][j + 1];
if (tot > 0) return 0;
}
return 1;
}
void work() {
for (int e = 1; e <= n - 1; ++e) {
for (int i = 1; i <= d; ++i)
for (int j = 1; j <= d; ++j) {
int &ed = G[min(i, j)][max(i, j)];
if (hd[i] && rem[j] && ed) {
--ed;
--rem[j];
if (HALL()) {
if (!hd[j]) hd[j] = on[j];
ans[++cnt][0] = hd[i];
ans[cnt][1] = on[j]++;
} else {
++ed;
++rem[j];
}
}
}
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n - 1; ++i) {
static int x, y;
RD(x);
RD(y);
if (x > y) swap(x, y);
++G[x][y];
}
for (int tmp = n; tmp; tmp /= 10) ++d;
on[1] = 1;
for (int i = 2; i <= d; ++i) on[i] = on[i - 1] * 10;
++on[1];
for (int i = 1; i < d; ++i) rem[i] = on[i + 1] - on[i];
rem[d] = n - on[d] + 1;
hd[1] = 1;
if (!HALL()) return printf("-1\n"), 0;
work();
if (cnt < n - 1)
return printf("-1\n"), 0;
else
for (int i = 1; i <= cnt; ++i) printf("%d %d\n", ans[i][0], ans[i][1]);
return 0;
}
| 24 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, k, minn = INT_MAX, maxx = INT_MIN;
cin >> n >> k;
int pile[n];
for (int i = 0; i < n; i++) {
cin >> pile[i];
minn = min(minn, pile[i]);
maxx = max(maxx, pile[i]);
}
if ((maxx - minn) > k)
cout << "NO" << endl;
else {
cout << "YES" << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < pile[i]; j++) {
cout << 1 + (j % k) << " ";
}
cout << endl;
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 500005;
int sz[N * 8];
int v1[N * 8];
int v2[N * 8];
int n;
void pushup(int k) {
sz[k] = sz[k * 2] + sz[k * 2 + 1];
v1[k] = max(v1[k * 2], sz[k * 2] + v1[k * 2 + 1]);
v2[k] = min(v2[k * 2] + sz[k * 2 + 1], v2[k * 2 + 1]);
}
void build(int k, int l, int r) {
if (l == r) {
sz[k] = 0;
v1[k] = -(1 << 30);
v2[k] = 1 << 30;
return;
}
int mid = (l + r + 2 * N) / 2 - N;
build(k * 2, l, mid);
build(k * 2 + 1, mid + 1, r);
pushup(k);
}
void change(int k, int l, int r, int p) {
if (l == r) {
sz[k]++;
v1[k] = l + sz[k];
v2[k] = l;
return;
}
int mid = (l + r + 2 * N) / 2 - N;
if (p <= mid)
change(k * 2, l, mid, p);
else
change(k * 2 + 1, mid + 1, r, p);
pushup(k);
}
pair<int, int> find1(int k, int l, int r, int v) {
if (l == r) return pair<int, int>(l, min(-v, l));
int mid = (l + r + 2 * N) / 2 - N;
if (v + v1[k * 2] >= 0) return find1(k * 2, l, mid, v);
return find1(k * 2 + 1, mid + 1, r, v + sz[k * 2]);
}
int find2(int k, int l, int r, int p) {
if (l == r) return v2[k];
int mid = (l + r + 2 * N) / 2 - N;
if (p > mid) return find2(k * 2 + 1, mid + 1, r, p);
return min(find2(k * 2, l, mid, p) + sz[k * 2 + 1], v2[k * 2 + 1]);
}
int ask(int k, int l, int r, int p) {
if (p > r) return 0;
if (l == r) return sz[k];
int mid = (l + r + 2 * N) / 2 - N;
if (p > mid) return ask(k * 2 + 1, mid + 1, r, p);
return ask(k * 2, l, mid, p) + sz[k * 2 + 1];
}
int main() {
scanf("%d", &n);
build(1, -N, N);
change(1, -N, N, N);
while (n--) {
int x;
scanf("%d", &x);
change(1, -N, N, x);
pair<int, int> tmp = find1(1, -N, N, 0);
int ans = find2(1, -N, N, tmp.first);
ans = min(ans, tmp.second + ask(1, -N, N, tmp.first));
printf("%d\n", ans - 1);
}
}
| 22 |
#include <bits/stdc++.h>
class Task {
uint64_t *dp;
public:
Task();
uint64_t solve(int32_t x);
uint64_t *count;
static const int32_t MAX;
};
Task::Task() {
dp = new uint64_t[Task::MAX];
count = new uint64_t[Task::MAX];
std::fill(dp, dp + Task::MAX, 0);
std::fill(count, count + Task::MAX, 0);
dp[0] = 0;
}
uint64_t Task::solve(int32_t x) {
dp[1] = count[1];
for (int32_t i = 2; i <= x; i++) {
dp[i] = std::max(dp[i - 1], dp[i - 2] + i * count[i]);
}
return dp[x];
}
const int Task::MAX = 1e5 + 1;
int main() {
int32_t n, temp;
std::cin >> n;
Task t;
for (int32_t i = 1; i <= n; i++) {
std::cin >> temp;
t.count[temp]++;
}
std::cout << t.solve(Task::MAX) << std::endl;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long ways[1001][1001];
long long len, ans = 0;
char a[1001];
long long getWays(int pos, int dig) {
if (pos == len - 1) return 1;
if (!ways[pos][dig]) {
int sum = dig + a[pos + 1] - '0';
if (sum % 2) ways[pos][dig] += getWays(pos + 1, sum / 2 + 1);
ways[pos][dig] += getWays(pos + 1, sum / 2);
}
return ways[pos][dig];
}
int main() {
cin >> a;
len = strlen(a);
for (int i = 0; i <= 9; i++) ans += getWays(0, i);
int i, dig = a[0] - '0';
for (i = 1; i < len; i++)
if (abs(a[i] - '0' - dig) <= 1)
dig = a[i] - '0';
else
break;
if (i == len) ans--;
cout << ans << endl;
return 0;
}
| 9 |
#include <bits/stdc++.h>
using namespace std;
void swap(long long &a, long long &b) {
long long t = a;
a = b;
b = t;
}
int main() {
long long a, b, ans = 0;
cin >> a >> b;
if (a > b) swap(a, b);
while (a) {
ans += b / a;
b %= a;
swap(a, b);
}
cout << ans << endl;
return 0;
}
| 8 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 2 * 10000000 + 1;
long long c[N];
int main() {
long long a, n, ans = 0;
cin >> a >> n;
for (int i = 0; i < N; i++) c[i] = 1;
for (int i = 2; i * i <= N; i++)
for (int j = i * i; j <= N; j += i * i) c[j] = i * i;
for (int i = a; i < a + n; i++) ans += i / c[i];
cout << ans;
return 0;
}
| 7 |
#include <bits/stdc++.h>
using namespace std;
long long n, m;
int a[100005], b[100005];
long long fastPow(long long b, long long e) {
long long ans = 1;
while (e > 0) {
if (e & 1) ans = (ans * b) % 1000000007;
b = (b * b) % 1000000007;
e >>= 1;
}
return ans;
}
int memo[100005][3];
int DP(int pos, int state) {
if (pos == n) return state == 1;
if (state == 2) return 0;
int &ret = memo[pos][state];
if (ret != -1) return ret;
long long ans = 0, aux, len;
if (state == 1) {
aux = 1;
if (a[pos] == 0) aux *= m;
if (b[pos] == 0) aux *= m;
aux = (aux) % 1000000007;
ans = (aux * DP(pos + 1, state)) % 1000000007;
} else {
if (a[pos] != 0 && b[pos] != 0) {
if (a[pos] > b[pos])
ans = DP(pos + 1, 1);
else if (a[pos] < b[pos])
ans = DP(pos + 1, 2);
else if (a[pos] == b[pos])
ans = DP(pos + 1, 0);
} else {
if (a[pos] == 0 && b[pos] == 0) {
aux = ((m * (m - 1)) / 2) % 1000000007;
ans = (aux * DP(pos + 1, 1)) % 1000000007;
ans = (ans + (m * DP(pos + 1, 0)) % 1000000007) % 1000000007;
} else {
if (a[pos] == 0) {
len = (m - b[pos] + 1);
ans = ((len - 1) * DP(pos + 1, 1)) % 1000000007;
ans = (ans + DP(pos + 1, 0)) % 1000000007;
} else {
len = a[pos];
ans = ((len - 1) * DP(pos + 1, 1)) % 1000000007;
ans = (ans + DP(pos + 1, 0)) % 1000000007;
}
}
}
}
return ret = ans;
}
int main() {
cin >> n >> m;
long long total = 0, total1 = 1, total2 = 1;
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
if (a[i] == 0) total1 = (total1 * m) % 1000000007;
}
for (int i = 0; i < n; i++) {
scanf("%d", &b[i]);
if (b[i] == 0) total2 = (total2 * m) % 1000000007;
}
total = (total1 * total2) % 1000000007;
total = fastPow(total, 1000000007 - 2);
int st = -1, pos = -1;
for (int i = 0; i < n; i++) {
if (a[i] == 0 || b[i] == 0) {
pos = i;
break;
}
if (a[i] > b[i]) {
st = 1;
break;
} else if (a[i] < b[i]) {
st = 0;
break;
}
}
if (st != -1) {
if (st == 0)
puts("0");
else
puts("1");
} else {
if (pos == -1)
puts("0");
else {
memset(memo, -1, sizeof memo);
long long ans = DP(pos, 0);
ans = (ans * total) % 1000000007;
cout << ans << endl;
}
}
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1500 * 1500 + 5;
map<int, vector<pair<int, int>>> maping;
int Next[N];
int dp[N];
int arr[1505];
int range[1505];
int size;
void solve() {
for (int i = size - 1; i >= 0; i--) {
dp[i] = 0;
if (i + 1 < size) dp[i] = max(dp[i], dp[i + 1]);
if (Next[i] < size)
dp[i] = max(dp[i], dp[Next[i]] + 1);
else
dp[i] = max(dp[i], 1);
}
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> arr[i];
for (int i = 1; i <= n; i++) {
int cur = 0;
for (int j = i; j <= n; j++) {
cur += arr[j];
maping[cur].push_back({i, j});
}
}
int Max = -1, idx = -1;
for (auto &cur : maping) {
vector<pair<int, int>> &vec = cur.second;
size = vec.size();
if (size <= Max) continue;
memset(range, -1, sizeof range);
for (int i = size - 1; i >= 0; i--) {
int st = vec[i].first;
if (range[st - 1] == -1)
range[st - 1] = i;
else
range[st - 1] = min(range[st - 1], i);
}
for (int i = 1500; i >= 1; i--) {
if (range[i] == -1) range[i] = size + 5;
if (i < 1500) range[i] = min(range[i], range[i + 1]);
}
for (int i = 0; i < size; i++) Next[i] = range[vec[i].second];
solve();
if (dp[0] > Max) {
Max = dp[0];
idx = cur.first;
}
}
cout << Max << '\n';
vector<pair<int, int>> &vec = maping[idx];
size = vec.size();
memset(range, -1, sizeof range);
for (int i = size - 1; i >= 0; i--) {
int st = vec[i].first;
if (range[st - 1] == -1)
range[st - 1] = i;
else
range[st - 1] = min(range[st - 1], i);
}
for (int i = 1500; i >= 1; i--) {
if (range[i] == -1) range[i] = size + 5;
if (i < 1500) range[i] = min(range[i], range[i + 1]);
}
for (int i = 0; i < size; i++) Next[i] = range[vec[i].second];
solve();
int cur = 0;
while (cur < size) {
int c1 = 0, c2 = 0;
if (cur + 1 < size) c1 = dp[cur + 1];
if (Next[cur] < size)
c2 = dp[Next[cur]] + 1;
else
c2 = 1;
if (c1 >= c2)
cur = cur + 1;
else {
cout << vec[cur].first << ' ' << vec[cur].second << '\n';
cur = Next[cur];
}
}
return 0;
}
| 11 |
#include<bits/stdc++.h>
using namespace std;
#define max(a, b) (a < b ? b : a)
#define min(a, b) ((a > b) ? b : a)
#define mod 1e9 + 7
#define FOR(a, c) for (int(a) = 0; (a) < (c); (a)++)
#define FORL(a, b, c) for (int(a) = (b); (a) < (c); (a)++)
#define FORR(a, b, c) for (int(a) = (b); (a) > (c); (a)--)
#define INF 1000000000000000003
typedef long long int ll;
typedef vector<int> vi;
typedef vector<long long int> vl;
typedef pair<int, int> pi;
typedef pair<long long int, long long int> pl;
#define F first
#define S second
#define pb push_back
#define POB pop_back
#define mp make_pair
ll m=mod;
void solve(){
ll n,m,x=0,f=0;
cin>>n>>m;
vl a(n);
FOR(i,n)
{cin>>a[i];
x+=a[i];
}
if(m==0||m==x)
cout<<"NO"<<endl;
else
{cout<<"YES"<<endl;
x=0;
FOR(i,n)
{
if(x+a[i]==m)
{cout<<a[i+1]<<" "<<a[i]<<" ";
f=1;
x+=(a[i]+a[i+1]);
}
else if(f)
{
f=0;
continue;
}
else
{cout<<a[i]<< " ";
x+=a[i];
}
}
cout<<endl;
}
}
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL); cout.tie(NULL);
long t;
cin>>t ;
//t=1;
while(t--)
{
solve();
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int a[5010];
int n;
int main() {
memset(a, 0, sizeof(a));
scanf("%d", &n);
int x, y, z;
printf("? 1 2\n");
fflush(stdout);
scanf("%d", &x);
printf("? 2 3\n");
fflush(stdout);
scanf("%d", &y);
printf("? 1 3\n");
fflush(stdout);
scanf("%d", &z);
a[2] = (x + y - z) / 2;
a[1] = x - a[2];
a[3] = z - a[1];
for (int i = 4; i <= n; i++) {
printf("? %d %d\n", i - 1, i);
fflush(stdout);
scanf("%d", &x);
a[i] = x - a[i - 1];
}
printf("!");
for (int i = 1; i <= n; i++) {
printf(" %d", a[i]);
}
printf("\n");
fflush(stdout);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, a[200005], ans = 1;
int main() {
scanf("%d", &n);
if (n % 2)
cout << "YES" << endl;
else {
cout << "NO";
return 0;
}
for (int i = 1; i <= n; i++) {
if (i % 2) {
a[i] = ans++;
a[i + n] = ans++;
} else {
a[i + n] = ans++;
a[i] = ans++;
}
}
for (int i = 1; i <= n * 2; i++) cout << a[i] << " ";
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
string second;
cin >> second;
int n = second.size();
vector<vector<int>> dp(n, vector<int>(n, -1));
vector<int> ans(n, 0);
for (int i = 0; i < n; i++) {
dp[i][i] = 1;
for (int j = 1; i - j >= 0 && i + j <= n - 1; j++) {
if (second[i - j] != second[i + j]) break;
dp[i - j][i + j] = 1;
if (dp[i - j][i - 1] != -1) dp[i - j][i + j] = dp[i - j][i - 1] + 1;
}
for (int j = 1; i - j >= 0 && i + j - 1 <= n - 1; j++) {
if (second[i - j] != second[i + j - 1]) break;
dp[i - j][i + j - 1] = 1;
if (dp[i - j][i - 1] != -1) dp[i - j][i + j - 1] = dp[i - j][i - 1] + 1;
}
}
for (int i = 0; i < n; i++)
for (int j = i; j < n; j++) {
for (int p = 0; p < dp[i][j]; p++) ans[p]++;
}
for (int i = 0; i < n; i++) cout << ans[i] << " ";
return 0;
}
| 11 |
#include <bits/stdc++.h>
using namespace std;
map<long long, long long> mp;
vector<long long> v, prs;
long long lg(long long a) {
long long res = 0;
while (a > 1) {
a = (a + 1) / 2;
res++;
}
return res;
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, x;
cin >> n >> x;
x *= 8;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
if (!mp[a]) v.push_back(a);
mp[a]++;
}
sort(v.begin(), v.end());
long long s = 0;
prs.push_back(0);
for (long long i = 0; i < (long long)v.size(); i++) {
s += mp[v[i]];
prs.push_back(s);
}
long long y = 0;
while ((lg((long long)v.size() - y) * n) > x) y++;
long long ans = INT_MAX;
for (long long i = 0; i <= y; i++)
(ans) = min((ans), (prs[i] + (s - prs[(long long)v.size() - (y - i)])));
cout << ans << endl;
return 0;
}
| 8 |
#include <iostream>
#include <cmath>
using namespace std;
int main(){
int t;
cin>>t;
while (t--){
int a, b;
cin>>a>>b;
b--;
cout<<(b+(a%2)*b/(a/2))%a+1<<endl;
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long L = 24;
long long A[500009];
vector<pair<long long, long long> > G[500009];
long long mat[25], te[25];
long long ans[500009];
void add(long long v, long long t) {
long long i;
for (i = L - 1; i >= 0; i--) {
if (1 & (v >> i)) {
if (mat[i]) {
if (t > te[i]) {
swap(t, te[i]);
swap(v, mat[i]);
}
v ^= mat[i];
} else {
mat[i] = v;
te[i] = t;
return;
}
}
}
}
long long getans(long long t) {
long long i;
long long ret = 0;
for (i = L - 1; i >= 0; i--) {
if (te[i] >= t && (ret ^ mat[i]) > ret) ret ^= mat[i];
}
return ret;
}
int main() {
long long N, M, i, j, k, Q, l, r;
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> N;
for (i = 1; i <= N; i++) {
cin >> A[i];
}
cin >> Q;
for (i = 0; i < Q; i++) {
cin >> l >> r;
G[r].push_back({l, i});
}
for (i = 1; i <= N; i++) {
add(A[i], i);
for (auto v : G[i]) {
ans[v.second] = getans(v.first);
}
}
for (i = 0; i < Q; i++) {
cout << ans[i] << '\n';
}
}
| 17 |
#include <bits/stdc++.h>
using namespace std;
long long int C[300001];
vector<long long int> A;
vector<pair<long long int, long long int> > B;
int main() {
int m;
cin >> m;
for (int i = 0; i < m; i++) {
long long int x;
cin >> x;
A.push_back(x);
}
for (int i = 0; i < m; i++) {
long long int x;
cin >> x;
B.push_back(make_pair(x, i));
}
sort(B.begin(), B.end());
sort(A.begin(), A.end());
reverse(A.begin(), A.end());
for (int i = 0; i < m; i++) {
C[B[i].second] = A[i];
}
for (int i = 0; i < m; i++) {
cout << C[i] << " ";
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n;
vector<pair<int, int>> a;
for (int i = 0; i < n; i++) {
int x, y;
cin >> x >> y;
a.push_back(make_pair(y, x));
}
int c = 1, ans = 0;
sort(a.begin(), a.end(), greater<pair<int, int>>());
for (auto p : a) {
if (c > 0) {
c += p.first;
ans += p.second;
}
c--;
}
cout << ans << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e6 + 7;
int main() {
int t, n;
string s;
cin >> s;
map<string, int> q;
int len = s.size();
int ans = 0;
for (int i = 0; i < len; i++) {
string str;
for (int j = i; j < len; j++) str += s[j];
for (int j = 0; j < i; j++) str += s[j];
q[str]++;
if (q[str] == 1) ans++;
}
printf("%d\n", ans);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int a, b, p;
cin >> a >> b >> p;
string str;
cin >> str;
long long int n = str.size();
if (a > p && b > p) {
cout << n << endl;
continue;
}
long long int i;
long long int sum = 0;
for (i = n - 2; i >= 0; i--) {
long long int s1;
if (i != n - 2 && str[i] == str[i + 1])
continue;
else {
s1 = sum;
switch (str[i]) {
case 'A':
sum = sum + a;
break;
case 'B':
sum = sum + b;
break;
}
if (sum > p) {
sum = s1;
break;
}
}
}
cout << i + 2 << endl;
}
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e3;
const int INF = 1e9 + 9;
const int B = 1e9 + 7;
int n, m;
long long z;
struct DSU {
int p[N * N], sz[N * N], n, cmp;
void init(int _n) {
n = _n;
for (int i = int(1); i <= int(n); ++i) p[i] = i, sz[i] = 1;
cmp = n;
}
int f(int x) { return p[x] == x ? x : p[x] = f(p[x]); }
void unite(int a, int b) {
a = f(a), b = f(b);
if (a == b) return;
if (sz[a] < sz[b]) swap(a, b);
p[b] = a;
sz[a] += sz[b];
--cmp;
}
} dsu;
int id(int i, int j) { return (i - 1) * m + j; }
bool inside(int i, int j) { return 1 <= i && i <= n && 1 <= j && j <= m; }
struct elem {
int i, j, x;
elem() {}
} q[N * N];
bool operator<(const elem &a, const elem &b) { return a.x < b.x; }
int a[N][N];
bool u[N][N], ans[N][N];
int need, res;
int di[] = {0, +1, 0, -1};
int dj[] = {+1, 0, -1, 0};
void dfs(int i, int j) {
if (ans[i][j] || !need) return;
ans[i][j] = 1;
--need;
for (int dir = int(0); dir <= int(3); ++dir) {
int ni = i + di[dir], nj = j + dj[dir];
if (inside(ni, nj) && u[ni][nj]) dfs(ni, nj);
}
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
int sz = 0;
cin >> n >> m >> z;
for (int i = int(1); i <= int(n); ++i) {
for (int j = int(1); j <= int(m); ++j) {
cin >> a[i][j];
++sz;
q[sz].i = i, q[sz].j = j, q[sz].x = a[i][j];
}
}
sort(q + 1, q + 1 + sz);
dsu.init(n * m);
for (int i = int(sz); i >= int(1); --i) {
if (q[i].x == 0) break;
int r = q[i].i, c = q[i].j;
for (int dir = int(0); dir <= int(3); ++dir) {
int nr = r + di[dir], nc = c + dj[dir];
if (inside(nr, nc) && u[nr][nc]) dsu.unite(id(r, c), id(nr, nc));
}
u[r][c] = 1;
if (z % q[i].x == 0 && dsu.sz[dsu.f(id(r, c))] >= z / q[i].x) {
res = q[i].x;
need = z / q[i].x;
dfs(r, c);
cout << "YES\n";
for (int j = int(1); j <= int(n); ++j) {
for (int k = int(1); k <= int(m); ++k)
cout << q[i].x * ans[j][k] << " ";
cout << "\n";
}
return 0;
}
}
cout << "NO\n";
return 0;
}
| 12 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.