solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int val;
map<int, int, greater<int> > mp;
for (int i = 1; i <= n; i++) {
cin >> val;
mp[val]++;
}
int lim = n / 2;
if (mp.size() <= 2) {
cout << 0 << " " << 0 << " " << 0 << "\n";
continue;
}
if (n < 5) {
cout << 0 << " " << 0 << " " << 0 << "\n";
continue;
}
int g = 0, s = 0, b = 0;
for (auto it = mp.begin(); it != mp.end(); it++) {
if ((g == 0) && ((lim - it->second) >= 0)) {
g += it->second;
lim -= g;
} else if ((g > 0) && (s == 0) && ((lim - it->second) >= 0)) {
s += it->second;
lim -= s;
} else if ((s > 0) && (s <= g) && ((lim - it->second) >= 0)) {
s += it->second;
lim -= it->second;
} else if ((g > 0) && (s > g) && ((lim - it->second) >= 0)) {
b += it->second;
lim -= it->second;
} else
break;
}
if ((g == 0) || (s == 0) || (b == 0))
cout << 0 << " " << 0 << " " << 0 << "\n";
else if ((g >= s) || (g >= b))
cout << 0 << " " << 0 << " " << 0 << "\n";
else
cout << g << " " << s << " " << b << "\n";
}
return 0;
}
| 1 |
#include <iostream>
int main()
{
std::ios_base::sync_with_stdio(false);
int N, ans = 0;
std::cin >> N;
while (N > 0) {
ans += N % 10;
N /= 10;
}
std::cout << (ans != 1 ? ans : 10) << std::endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
string s[105];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
string h = "12345RGBYW";
int ans = 12;
for (int i = 0; i < 1024; i++) {
bool f[256] = {};
int cnt = 0;
for (int j = 0; j < 10; j++) {
if (i & (1 << j)) f[h[j]] = true, cnt++;
}
bool ok = true;
for (int j = 0; j < 10; j++) {
char c = h[j];
set<int> t;
set<pair<char, char> > nohint;
for (int k = 0; k < n; k++) {
char x = s[k][0], y = s[k][1];
if (f[x] == false && f[y] == false) nohint.insert(make_pair(x, y));
if (f[x] && x == c && f[y] == false)
t.insert(y);
else if (f[y] && y == c && f[x] == false)
t.insert(x);
}
ok &= t.size() <= 1 && nohint.size() <= 1;
}
if (ok && cnt < ans) ans = cnt;
}
cout << ans << "\n";
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
void solve();
long long int power(long long int n, long long int k) {
if (k == 0) return 1;
if (k % 2) return (n * power(n, k - 1)) % 1000000007;
return power((n * n) % 1000000007, k / 2);
}
long long int gcd(long long int a, long long int b) {
return b ? gcd(b, a % b) : a;
}
long long int lcm(long long int a, long long int b) {
return (((a * b) % 1000000007) * power((gcd(a, b)), 1000000007 - 2)) %
1000000007;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
solve();
return 0;
}
struct node {
int jumpCount;
int jumpTo;
int secLastJump;
};
void buildBlock(node dp[], int beg, int nums[], int block_size, int n) {
int n1 = beg + block_size;
int n2 = n;
int end = min(n1, n2) - 1;
for (int i = end; i >= beg; i--) {
if (i + nums[i] > end) {
dp[i - beg].jumpCount = 1;
dp[i - beg].jumpTo = i + nums[i];
dp[i - beg].secLastJump = i + 1;
} else {
dp[i - beg] = dp[i + nums[i] - beg];
dp[i - beg].jumpCount++;
}
}
}
void solve() {
int n, m;
cin >> n >> m;
int nums[n];
int block_size = 300;
int block_count = (long long int)ceil(((long double)(n)) / block_size);
for (int i = 0; i < n; i++) {
cin >> nums[i];
}
node dp[block_count][block_size];
for (int i = 0; i < block_count; i++) {
buildBlock(dp[i], i * block_size, nums, block_size, n);
}
while (m--) {
int type;
cin >> type;
if (type == 0) {
int i, x;
cin >> i >> x;
i--;
nums[i] = x;
buildBlock(dp[i / block_size], (i / block_size) * block_size, nums,
block_size, n);
} else {
int i;
cin >> i;
i--;
int count = 0;
int ans;
while (i < n) {
count += dp[i / block_size][i - i / block_size * block_size].jumpCount;
ans =
dp[i / block_size][i - ((i / block_size) * block_size)].secLastJump;
i = dp[i / block_size][i - ((i / block_size) * block_size)].jumpTo;
}
cout << ans << " " << count << "\n";
}
}
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define mp(a,b) make_pair((a),(b))
#define pb(a) push_back((a))
#define all(x) (x).begin(),(x).end()
#define uniq(x) sort(all(x)),(x).erase(unique(all(x)),end(x))
#define fi first
#define se second
#define dbg(...) _dbg(#__VA_ARGS__, __VA_ARGS__)
void _dbg(string){cout<<endl;}
template<class H,class... T> void _dbg(string s,H h,T... t){int l=s.find(',');cout<<s.substr(0,l)<<" = "<<h<<", ";_dbg(s.substr(l+1),t...);}
template<class T,class U> ostream& operator<<(ostream& o, const pair<T,U> &p){o<<"("<<p.fi<<","<<p.se<<")";return o;}
template<class T> ostream& operator<<(ostream& o, const vector<T> &v){o<<"[";for(T t:v){o<<t<<",";}o<<"]";return o;}
#define INF 1120000000
vector<string> split(const string &str, char sep){
vector<string> v;
stringstream ss(str);
string buffer;
while( getline(ss, buffer, sep ) ) v.pb(buffer);
if(str[str.size()-1] == sep) v.pb("");
return v;
}
int solve(string &s, string &t){
auto v = split(s, '"');
auto u = split(t, '"');
if(v.size()!=u.size()) return 0;
int x = 0;
rep(i,v.size()) if(v[i]!=u[i]){
if(i%2==0) return 0;
else x++;
}
if(x>1) return 0;
if(x==1) return 1;
else return 2;
}
int main(){
string s,t;
while(cin>>s, s!="."){
cin>>t;
int r = solve(s,t);
if(r==0) cout << "DIFFERENT" << endl;
else if(r==1) cout << "CLOSE" << endl;
else cout << "IDENTICAL" << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c = 1;
;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a, a + n);
for (int i = 1; i < n; i++) {
while (a[i] == a[i - 1]) i++;
a[c++] = a[i];
}
for (int i = 2; i < c; i++) {
if ((a[i] == a[i - 1] + 1) && (a[i] == a[i - 2] + 2)) {
cout << "YES";
return 0;
}
}
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 2147483647;
const long long LINF = 1e18;
const long double PI = 4 * atan((long double)1);
template <class T, class S>
ostream& operator<<(ostream& os, const pair<T, S>& p) {
os << p.first << " " << p.second;
return os;
}
template <class T, class S>
istream& operator>>(istream& is, pair<T, S>& p) {
is >> p.first >> p.second;
return is;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
for (int i = (0); i < (v.size()); ++i) os << v[i] << " \n"[i == v.size() - 1];
return os;
}
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
for (int i = (0); i < (v.size()); ++i) is >> v[i];
return is;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int z, n, s;
cin >> z;
while (z--) {
s = 0;
cin >> n;
vector<int> v(n);
cin >> v;
for (int i = (0); i < (n); ++i) {
s += v[i];
}
cout << (s + n - 1) / n << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
long int x;
cin >> x;
cout << x/500 * 1000 + (x%500)/5 * 5;
}
| 0 |
#include <bits/stdc++.h>
int n, m, s, t, ppl, maxppl, idd;
int a[20000], id[20000];
bool inq[20000];
int toInt(int hh, int mm, int ss) { return hh * 3600 + mm * 60 + ss; }
int main() {
int hh, mm, ss, oldestId, newestId;
scanf("%d%d%d", &n, &m, &t);
for (int i = 0; i < n; i++) {
scanf("%d:%d:%d", &hh, &mm, &ss);
a[i] = toInt(hh, mm, ss);
}
memset(inq, false, sizeof inq);
ppl = maxppl = 0;
s = idd = 0;
for (int b = 0; b < n; b++) {
int now = a[b];
while (s < b)
if (a[s] + t <= now)
s++;
else
break;
if (s == b)
ppl = 0;
else if (b) {
oldestId = id[s];
newestId = id[b - 1];
ppl = newestId - oldestId + 1;
}
if (ppl == m)
id[b] = idd;
else {
ppl++;
id[b] = ++idd;
if (ppl > maxppl) maxppl = ppl;
}
}
if (maxppl == m) {
printf("%d\n", idd);
for (int i = 0; i < n; i++) printf("%d\n", id[i]);
} else
puts("No solution");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int n0 = 1003;
int n, sz[n0], root, d, mx, h[n0], ep, has[n0], sub;
bool flag;
vector<int> g[n0], q, can;
array<int, 2> cur;
void get() {
if (q.empty()) return;
cout << "? " << (int)(q).size() << ' ';
for (int i : q) cout << i << ' ';
cout << endl;
int x, y;
cin >> x >> y;
cur = {x, y};
if (cur[0] == -1) exit(0);
}
void ans(int x, int y) { cout << "! " << x << ' ' << y << endl; }
void dfs(int v, int p) {
sz[v] = 1;
for (int to : g[v]) {
if (to == p) continue;
h[to] = h[v] + 1;
dfs(to, v);
sz[v] += sz[to];
if (v == root && (mx == -1 || sz[mx] < sz[to])) mx = to;
}
}
void go(int v, int p, int bad) {
if (!flag && v == bad) return;
can.push_back(v);
for (int to : g[v]) {
if (to == p) continue;
go(to, v, bad);
}
}
void fill_h(int x) {
q.clear();
for (int i : can)
if (h[i] >= x) q.push_back(i);
}
void search(int v, int p) {
has[v] = (v == ep);
for (int to : g[v]) {
if (to == p) continue;
search(to, v);
if (v == root && has[to]) sub = to;
has[v] |= has[to];
}
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
int tc;
cin >> tc;
while (tc--) {
cin >> n;
q.clear(), can.clear();
memset(&has, 0, sizeof(has)), memset(&sz, 0, sizeof(sz)),
memset(&h, 0, sizeof(h)), sub = -1;
for (int i = 1; i <= n; i++) q.push_back(i);
for (int i = 1; i < n; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y), g[y].push_back(x);
}
get();
root = cur[0], d = cur[1], mx = -1;
dfs(root, -1);
flag = (sz[root] == sz[mx] + 1);
go(root, -1, mx);
ep = root;
int l = 0, r = n;
if (!flag) r = n / 2 + 1;
while (l < r - 1) {
int mid = l + (r - l) / 2;
fill_h(mid);
get();
if ((int)(q).size() && cur[1] == d)
l = mid, ep = cur[0];
else
r = mid;
}
if (flag) {
ans(root, ep);
} else {
int need = d - h[ep];
search(root, -1);
flag = 0, can.clear();
go(root, -1, sub);
q.clear();
for (int i : can)
if (h[i] == need) q.push_back(i);
get();
int ep2 = cur[0];
ans(ep, ep2);
}
for (int i = 1; i <= n; i++) g[i].clear();
string fuckyou;
cin >> fuckyou;
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
long long dp[N][1 << N];
bool vis[1 << N];
bool Adj[N][N];
int n, m;
long long sub;
long long solve(int idx, int mask, int p, int st) {
if (dp[idx][mask] != -1) return dp[idx][mask];
long long res = 0;
for (int u = int(st); u <= int(n); u++) {
if (!Adj[idx][u]) continue;
if (u == p) continue;
if (u == st)
res++;
else if (!(mask >> u & 1))
res += solve(u, mask | (1 << u), idx, st);
}
return dp[idx][mask] = res;
}
int main() {
int a, b;
memset(dp, -1, sizeof(dp));
scanf("%d %d", &n, &m);
for (int i = 0; i < int(m); i++) {
scanf("%d %d", &a, &b);
Adj[a][b] = Adj[b][a] = 1;
}
long long ans = 0;
for (int i = int(1); i <= int(n); i++) {
ans += solve(i, 1 << i, 0, i);
}
printf("%I64d\n", ans / 2);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<long long> sq, nsq, cc;
int main() {
int n, x;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &x);
long long num = (long long)sqrt(x);
if (num * num == x)
sq.push_back(x);
else
nsq.push_back(x);
}
int l1 = sq.size();
int l2 = nsq.size();
if (l1 >= n / 2) {
for (int i = 0; i < l1; i++) {
if (sq[i] != 0)
cc.push_back(1);
else
cc.push_back(2);
}
sort(cc.begin(), cc.end());
int ans = 0;
for (int i = 0; i < l1 - (n / 2); i++) ans += cc[i];
cout << ans << endl;
} else {
for (int i = 0; i < l2; i++) {
long long temp = (long long)sqrt(nsq[i]);
cc.push_back(
min(nsq[i] - (temp * temp), (temp + 1) * (temp + 1) - nsq[i]));
}
sort(cc.begin(), cc.end());
long long ans = 0;
for (int i = 0; i < l2 - (n / 2); i++) ans += cc[i];
cout << ans << endl;
}
}
| 5 |
#include "bits/stdc++.h"
using namespace std;
int main(){
int a,b;cin>>a>>b;
cout<<--a*--b;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool chkmin(T &a, const T &b) {
return b < a ? a = b, 1 : 0;
}
template <typename T>
inline bool chkmax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
const int oo = 0x3f3f3f3f;
const int MAXN = 65;
map<int, bitset<MAXN << 1> > mp;
int n, m, a[MAXN], b[MAXN];
inline int read() {
char c = getchar();
int first = 0, f = 1;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
first = first * 10 + (c - '0');
c = getchar();
}
return first * f;
}
int main() {
n = read();
m = read();
for (int i = (0), i_end_ = (n); i < i_end_; ++i) a[i] = read();
for (int i = (0), i_end_ = (m); i < i_end_; ++i) b[i] = read();
for (int i = (0), i_end_ = (n); i < i_end_; ++i)
for (int j = (0), j_end_ = (m); j < j_end_; ++j) {
mp[a[i] + b[j]][i] = 1;
mp[a[i] + b[j]][n + j] = 1;
}
int ans = 0;
for (auto u : mp)
for (auto v : mp) chkmax(ans, int((u.second | v.second).count()));
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using pi2 = pair<int, int>;
using pl2 = pair<ll, ll>;
using cpl = complex<ld>;
const ld pi = 3.14159265358979323846264338327950288;
const ld tau = 2 * pi;
const int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
const int ddx[8] = {0, 1, 1, 1, 0, -1, -1, -1},
ddy[8] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int nx[8] = {1, 2, 2, 1, -1, -2, -2, -1},
ny[8] = {-2, -1, 1, 2, 2, 1, -1, -2};
const int N = 262144;
int a[200020], b[200020];
pi2 tree[525290];
void upd(int pos, int val) {
pos += N;
tree[pos].second += val;
if (tree[pos].second != 0) {
tree[pos].first = pos - N;
} else {
tree[pos].first = 1e9;
}
pos >>= 1;
while (pos) {
tree[pos].second = tree[pos << 1].second + tree[pos << 1 | 1].second;
tree[pos].first = min(tree[pos << 1].first, tree[pos << 1 | 1].first);
pos >>= 1;
}
}
int qry(int st, int ed) {
st += N;
ed += N;
int res = 1e9;
while (st <= ed) {
if (st & 1) {
res = min(res, tree[st].first);
st += 1;
}
if (~ed & 1) {
res = min(res, tree[ed].first);
ed -= 1;
}
if (st > ed) {
break;
}
st >>= 1;
ed >>= 1;
}
return res;
}
void Main() {
int n;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
upd(i - 1, 0);
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
upd(b[i], 1);
}
for (int i = 1; i <= n; i++) {
int tar = (n - a[i]) % n;
int idx = qry(tar, n - 1);
if (idx == 1e9) {
idx = qry(0, n - 1);
}
cout << (a[i] + idx) % n << ' ';
upd(idx, -1);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.precision(2);
Main();
}
| 5 |
#include <bits/stdc++.h>
int main() {
int n, p = 0, q = 0, a = 0, b = 0;
int t, x, y;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &t, &x, &y);
if (t == 1) {
a = a + x;
p++;
} else if (t == 2) {
b = b + x;
q++;
}
}
if (a >= (p * 5)) {
printf("LIVE\n");
} else if (a < (p * 5)) {
printf("DEAD\n");
}
if (b >= (q * 5)) {
printf("LIVE\n");
} else if (b < (q * 5)) {
printf("DEAD\n");
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
long long S = 0, f[26][26];
char a[111510], b[111510], c[111510];
int main() {
scanf("%s%s%d", a, b, &m);
for (int i = 0; i < 26; ++i) {
for (int j = 0; j < 26; ++j) f[i][j] = 1ll << 30;
f[i][i] = 0;
}
for (char x[3], y[3]; m--;) {
scanf("%s%s%d", x, y, &n);
*x -= 97;
*y -= 97;
f[*x][*y] = min(f[*x][*y], 1ll * n);
}
for (int k = 0; k < 26; ++k)
for (int i = 0; i < 26; ++i)
for (int j = 0; j < 26; ++j) f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
n = strlen(a);
m = strlen(b);
if (n ^ m) return 0 & puts("-1");
for (int i = 0; i < n; ++i)
for (int j = 0; j < 26; ++j)
if (f[a[i] - 97][j] + f[b[i] - 97][j] <
f[a[i] - 97][c[i]] + f[b[i] - 97][c[i]])
c[i] = j;
for (int i = 0; i < n; ++i) {
S += f[a[i] - 97][c[i]] + f[b[i] - 97][c[i]];
c[i] += 97;
}
if (S >= 1ll << 30)
puts("-1");
else
printf("%lld\n%s", S, c);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, p;
long long d, w;
cin >> n >> p >> w >> d;
for (long long i = 0; i < w; i++) {
if ((p - i * d) % w == 0) {
if (p - i * d >= 0 && n - i - (p - i * d) / w >= 0) {
cout << (p - i * d) / w << " " << i << " " << n - i - (p - i * d) / w
<< endl;
return 0;
}
}
}
puts("-1");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int tt;
cin >> tt;
while (tt--) {
string k, s;
cin >> k >> s;
int pos[26];
for (int i = 0; i < 26; i++) {
pos[k[i] - 'a'] = i;
}
int ans = 0;
for (int i = 1; i < s.size(); i++) {
ans += abs(pos[s[i] - 'a'] - pos[s[i - 1] - 'a']);
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,h,maxh=0,r=0;
cin>>n;
for(int i=0;i<n;++i){
cin>>h;
if(maxh<=h){
r++;
maxh=h;
}
}
cout<<r<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void solveA() {
int ar[6], n;
cin >> n;
for (int i = 0; i < n; i++) cin >> ar[i];
sort(ar, ar + n);
cout << ar[n / 2];
}
void solveB() {
int n;
cin >> n;
vector<pair<int, int>> rez;
pair<int, int> ar[102];
for (int i = 1; i <= n; i++) {
cin >> ar[i].first;
ar[i].second = i;
}
sort(ar + 2, ar + n + 1,
[&](pair<int, int> a, pair<int, int> b) { return a.first > b.first; });
int lastknow = 2;
for (int i = 1; i < n; i++) {
if (ar[i].first == 0) {
cout << "-1";
return;
}
for (int j = 0; j < ar[i].first; j++) {
rez.push_back(make_pair(ar[i].second, ar[lastknow].second));
lastknow++;
if (lastknow > n) {
cout << n - 1 << endl;
for (auto &x : rez) {
cout << x.first << " " << x.second << endl;
}
return;
}
}
}
}
bool ar[1002][1002];
int dist[1002][1002];
void solveC() {
for (int i = 0; i < 1002; i++) {
for (int j = 0; j < 1002; j++) {
ar[i][j] = false;
dist[i][j] = 1e9;
}
}
int n, m, k;
char c;
pair<int, int> start;
pair<pair<int, int>, char> steps[4] = {
make_pair(make_pair(1, 0), 'D'), make_pair(make_pair(0, -1), 'L'),
make_pair(make_pair(0, 1), 'R'), make_pair(make_pair(-1, 0), 'U')};
scanf("%d%d%d%c", &n, &m, &k, &c);
if (k & 1) {
cout << "IMPOSSIBLE";
return;
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
scanf("%c", &c);
ar[i][j] = (c == '*' ? false : true);
if (c == 'X') start = make_pair(i, j);
}
scanf("%c", &c);
}
bool flag = false;
for (int i = 0; i < 4; i++) {
flag |= ar[start.first + steps[i].first.first]
[start.second + steps[i].first.second];
}
if (!flag) {
cout << "IMPOSSIBLE";
return;
}
queue<pair<int, int>> q;
dist[start.first][start.second] = 0;
q.push(start);
while (!q.empty()) {
pair<int, int> cur = q.front();
q.pop();
for (int i = 0; i < 4; i++) {
pair<int, int> to = make_pair(cur.first + steps[i].first.first,
cur.second + steps[i].first.second);
if (ar[to.first][to.second] &&
dist[to.first][to.second] > dist[cur.first][cur.second] + 1) {
q.push(to);
dist[to.first][to.second] = dist[cur.first][cur.second] + 1;
}
}
}
pair<int, int> cur = start;
while (k) {
for (int i = 0; i < 4; i++) {
pair<int, int> to = make_pair(cur.first + steps[i].first.first,
cur.second + steps[i].first.second);
if (dist[to.first][to.second] < k) {
printf("%c", steps[i].second);
k--;
cur = to;
break;
}
}
}
}
long long a[20002];
void solveD() {
int n, k, t;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> t;
a[t]++;
}
if (k == 0) {
long long rez = 0;
for (int i = 0; i < 10001; i++) rez += (a[i] - 1) * a[i] / 2;
cout << rez;
return;
}
vector<int> masks;
int kol;
for (int i = 0; i < 16384; i++) {
kol = 0;
for (int j = 1; j < 16384; j <<= 1) {
if (i & j) kol++;
}
if (kol == k) masks.push_back(i);
}
long long rez = 0;
int tmp;
for (int i = 0; i < 10001; i++) {
if (!a[i]) continue;
for (auto &x : masks) {
rez += (a[i] * a[i ^ x]);
}
}
rez /= 2;
cout << rez;
}
int main() {
solveD();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
struct point {
long long x, y;
point() {}
point(long long _x, long long _y) {
x = _x;
y = _y;
}
long long operator^(const point &b) const { return x * b.y - y * b.x; }
point operator-(const point &b) const { return point(x - b.x, y - b.y); }
} p[210];
long long dp[210][210];
long long dfs(int l, int r) {
if (dp[l][r] >= 0) return dp[l][r];
if (l == r - 1) return 1;
long long res = 0;
for (int i = l + 1; i < r; i++) {
if (((p[l] - p[r]) ^ (p[i] - p[l])) > 0) {
res = (res + dfs(l, i) * dfs(i, r) % mod) % mod;
}
}
return dp[l][r] = res;
}
int n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%I64d%I64d", &p[i].x, &p[i].y);
long long s = 0;
for (int i = 0; i < n; i++) s += p[i] ^ p[(i + 1) % n];
if (s < 0) reverse(p, p + n);
memset(dp, -1, sizeof(dp));
long long ans = dfs(0, n - 1);
printf("%I64d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 100000000000000001;
const long long mod = 1073741824;
long long pow(long long x, unsigned long long y, long long p) {
long long res = 1;
x = x % p;
if (x == 0) return 0;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
long long _pow(long long a, long long b) {
if (!b) return 1;
long long temp = _pow(a, b / 2);
temp = (temp * temp);
if (b % 2) return (a * temp);
return temp;
}
long long invmod(long long a, long long m) { return pow(a, m - 2, m); }
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
bool isprime(long long n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (long long i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
void sub(long long &a, long long b) {
b %= mod;
a = (a + mod - b);
a %= mod;
}
vector<long long> fen;
void ufen(long long i, long long val) {
i++;
for (; i <= 1e5; i += i & -i) fen[i] += val;
}
long long psfen(long long i) {
long long ans = 0;
for (; i > 0; i -= i & -i) ans += fen[i];
return ans;
}
vector<long long> fact;
void factorial() {
fact.resize(2e5 + 1);
fact[0] = 1;
for (int i = 1; i <= 2e5; i++) fact[i] = (fact[i - 1] * i) % mod;
}
unsigned long long ncrmod(unsigned long long n, long long r, long long p) {
if (n < r) return 0;
if (r == 0) return 1;
return (fact[n] * invmod(fact[r], p) % p * invmod(fact[n - r], p) % p) % p;
}
vector<long long> se;
void call() {
se.resize((long long)3e5 + 1, 1);
se[1] = 0;
for (long long i = 2; i <= 3e5; i++) {
if (se[i]) {
for (long long j = i * i; j <= 3e5; j += i) se[j] = 0;
}
}
}
void solve() {
int n;
cin >> n;
int k, m;
cin >> k >> m;
int arr[n];
for (long long i = 0; i < n; i++) cin >> arr[i];
vector<long long> res[m];
for (long long i = 0; i < n; i++) res[arr[i] % m].push_back(arr[i]);
for (long long i = 0; i < m; i++) {
if (res[i].size() >= k) {
cout << "Yes\n";
for (long long j = 0; j < k; j++) cout << res[i][j] << " ";
return;
}
}
cout << "No";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL);
long long t = 1;
while (t--) {
solve();
cout << endl;
}
}
| 2 |
#include <bits/stdc++.h>
#pragma optimizitaion_level 3
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("fast-math")
using namespace std;
int n, h;
vector<int> b;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n >> h;
b.resize(n);
for (auto &i : b) cin >> i;
for (int i = 0; i < n; i++) {
vector<int> now(i + 1);
for (int j = 0; j <= i; j++) {
now[j] = b[j];
}
sort(now.rbegin(), now.rend());
int free = h;
for (int j = 0; j <= i; j += 2) {
if (free >= now[j]) {
free -= now[j];
} else
return cout << i << '\n', 0;
}
}
cout << n << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 7;
const long double pi = 3.14159;
const long long INF = 1e9 + 7;
double ans, realans, a, b, c, d;
int main() {
ios_base::sync_with_stdio();
cin.tie(0);
cout.tie(0);
;
srand(time(0));
;
cin >> a >> b >> c >> d;
ans = a / b;
realans = (1 - c / d) * (1 - a / b);
;
cout << fixed << setprecision(12) << ans / (1 - realans);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int k, c[1005][1005], mod = 1000000007, a[1005], dp[1005];
int add(int a, int b) {
long long c = a + b;
if (c >= mod) c -= mod;
return (int)c;
}
int main() {
c[0][0] = 1;
for (int i = 1; i <= 1003; ++i) {
c[i][0] = 1;
for (int j = 1; j <= i; ++j) {
c[i][j] = add(c[i - 1][j], c[i - 1][j - 1]);
}
}
scanf("%d", &k);
for (int i = 1; i <= k; ++i) scanf("%d", &a[i]);
long long ans = 1;
int sum = 0;
for (int i = 1; i <= k; ++i) {
ans = (ans * c[sum + a[i] - 1][a[i] - 1]) % mod;
sum += a[i];
}
printf("%lld\n", ans);
return 0;
}
| 3 |
#include <iostream>
#include <vector>
int main() {
std::vector <int> v;
int N, q, val;
std::cin >> N;
for (int i = 0; i < N; i++) {
std::cin >> q;
if (q == 0) {
std::cin >> val;
v.push_back(val);
}
else if (q == 1) {
std::cin >> val;
std::cout << v[val] << std::endl;
}
else if (q == 2) {
v.pop_back();
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
list<char> L;
for (int i = 0; i < s.length(); i++) L.push_back(s[i]);
list<char>::iterator it1 = L.begin();
list<char>::iterator it2 = L.begin();
++it2;
for (; it2 != L.end();)
if (*it1 == *it2) {
list<char>::iterator tmp1;
list<char>::iterator tmp2;
if (it1 == L.begin()) {
tmp1 = it1;
++tmp1;
++tmp1;
tmp2 = it2;
++tmp2;
++tmp2;
} else {
tmp1 = it1;
--tmp1;
tmp2 = it2;
++tmp2;
}
L.erase(it1, ++it2);
it1 = tmp1;
it2 = tmp2;
} else {
++it1;
++it2;
}
for (list<char>::iterator it = L.begin(); it != L.end(); it++) cout << *it;
exit:
return (0);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 10010, mo[] = {1224469897, 1503325967, 1336143462, 937397015};
const long long MAX = 5000000;
const int prime[][7] = {{7, 17, 37, 47, 61, 97},
{11, 13, 41, 43, 67, 89},
{2, 3, 23, 31, 53, 71, 83},
{5, 19, 29, 59, 73, 79}};
int n, m, k;
long long a[maxn], f[MAX][4], e[20], ee[20];
struct query {
int d, ans, no;
string p;
long long c;
} tmp;
vector<query> Q[20], R;
inline bool cmp(const query &a, const query &b) { return a.no < b.no; }
void work(int d) {
if (Q[d].size() == 0) return;
int digit = 0, tmp = n;
while (tmp) digit++, tmp /= d;
for (int v = k = 1; v <= digit; k++, v++) e[k] = e[k - 1] * (d + 1);
k = digit;
for (int i = 0; i < e[k]; i++) {
bool flag = true;
for (int p = 0; p < 4; p++) f[i][p] = 1;
for (int j = 0; j < k; j++) {
if (i / e[j] % (d + 1) == d) {
flag = false;
int s = i - d * e[j];
for (int t = 0; t < d; t++)
for (int p = 0; p < 4; p++) {
int ss = s + t * e[j];
f[i][p] = (f[i][p] * f[ss][p]) % mo[p];
}
break;
}
}
if (flag) {
int s = 0;
for (int j = 0, v = 1; j < k; v *= d, j++) s += i / e[j] % (d + 1) * v;
if (s >= n) continue;
for (int p = 0; p < 4; p++) f[i][p] = a[s] % mo[p];
}
}
for (int i = 0; i < (int)Q[d].size(); i++) {
long long s = 0;
Q[d][i].ans = 101;
for (int j = 0; j < min((int)Q[d][i].p.length(), k); j++) {
long long tmp;
if (Q[d][i].p[j] == '?')
tmp = d;
else if (Q[d][i].p[j] >= '0' && Q[d][i].p[j] <= '9')
tmp = Q[d][i].p[j] - '0';
else
tmp = Q[d][i].p[j] - 'A' + 10;
s += tmp * e[j];
}
bool flag = false;
for (int j = k; j < (int)Q[d][i].p.length(); j++)
if (Q[d][i].p[j] != '?' && Q[d][i].p[j] != '0') flag = true;
for (int p = 0; p < 4; p++) {
int w = p == 2 ? 7 : 6;
long long T = flag ? 0 : f[s][p];
for (int j = 0; j < w; j++) {
long long tmp = (T + Q[d][i].c) % prime[p][j];
if (!tmp) Q[d][i].ans = min(Q[d][i].ans, prime[p][j]);
}
}
if (Q[d][i].ans == 101) Q[d][i].ans = -1;
}
}
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
cin >> m;
for (int i = 0; i < m; i++) {
cin >> tmp.d >> tmp.p >> tmp.c;
tmp.no = i;
reverse(tmp.p.begin(), tmp.p.end());
Q[tmp.d].push_back(tmp);
}
e[0] = ee[0] = 1;
for (int i = 2; i <= 16; i++) work(i);
for (int i = 2; i <= 16; i++)
for (int j = 0; j < (int)Q[i].size(); j++) R.push_back(Q[i][j]);
sort(R.begin(), R.end(), cmp);
for (int i = 0; i < (int)R.size(); i++) cout << R[i].ans << endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct Tree {
Tree *ls, *rs;
int l, r;
long long sum;
bool same;
int x;
long long add;
Tree() {}
~Tree() {
if (ls) delete ls;
if (rs) delete rs;
}
void up() {
if (ls->same && rs->same && ls->x == rs->x) {
same = 1;
x = ls->x;
add = 0;
} else
same = 0, add = 0;
sum = rs->sum + ls->sum;
}
void down() {
if (add) {
ls->add += add;
ls->sum += add * (ls->r - ls->l);
ls->x = x;
rs->add += add;
rs->sum += add * (rs->r - rs->l);
rs->x = x;
add = 0;
}
}
Tree(int l, int r) : l(l), r(r) {
ls = rs = NULL;
sum = 0;
same = 0;
x = l;
add = 0;
if (r - l <= 1) {
same = 1;
return;
}
int m = (l + r) >> 1;
ls = new Tree(l, m);
rs = new Tree(m, r);
up();
}
void gao(int L, int R, int X) {
if (L <= l && r <= R) {
if (same) {
long long v = 1LL * abs(X - x);
x = X;
add += v;
sum += v * (r - l);
return;
}
}
down();
int m = (l + r) >> 1;
if (L < m) ls->gao(L, R, X);
if (R > m) rs->gao(L, R, X);
up();
}
long long ask(int L, int R) {
if (L <= l && r <= R) return sum;
int m = (l + r) >> 1;
long long ans = 0;
down();
if (L < m) ans += ls->ask(L, R);
if (R > m) ans += rs->ask(L, R);
up();
return ans;
}
};
int n, m;
int main() {
ios_base::sync_with_stdio(false);
while (cin >> n >> m) {
Tree* t = new Tree(1, n + 1);
int ty, a, b, c;
for (int i = 0; i < m; i++) {
cin >> ty;
if (ty == 1) {
cin >> a >> b >> c;
t->gao(a, b + 1, c);
} else {
cin >> a >> b;
cout << t->ask(a, b + 1) << endl;
}
}
delete t;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct fastio {
char s[100000];
int it, len;
fastio() { it = len = 0; }
inline char get() {
if (it < len) return s[it++];
it = 0;
len = fread(s, 1, 100000, stdin);
if (len == 0)
return EOF;
else
return s[it++];
}
bool notend() {
char c = get();
while (c == ' ' || c == '\n') c = get();
if (it > 0) it--;
return c != EOF;
}
} _buff;
inline long long getnum() {
long long r = 0;
bool ng = 0;
char c;
c = _buff.get();
while (c != '-' && (c < '0' || c > '9')) c = _buff.get();
if (c == '-') ng = 1, c = _buff.get();
while (c >= '0' && c <= '9') r = r * 10 + c - '0', c = _buff.get();
return ng ? -r : r;
}
template <class T>
inline void putnum(T x) {
if (x < 0) putchar('-'), x = -x;
register short a[20] = {}, sz = 0;
while (x) a[sz++] = x % 10, x /= 10;
if (sz == 0) putchar('0');
for (int i = sz - 1; i >= 0; i--) putchar('0' + a[i]);
}
inline char getreal() {
char c = _buff.get();
while (c <= 32) c = _buff.get();
return c;
}
const int mod = 998244353;
long long qpow(long long x, long long k) {
return k == 0 ? 1
: 1ll * qpow(1ll * x * x % mod, k >> 1) * (k & 1 ? x : 1) % mod;
}
char S[3011], T[3011];
int n, m;
int dp[3011][3011];
void upd(int &x, int v) { x = (x + v) % mod; }
bool cmp(char x, char y) { return !x || !y || x == y; }
int main() {
scanf("%s", S + 1);
scanf("%s", T + 1);
n = strlen(S + 1);
m = strlen(T + 1);
for (int i = 1; i <= n + 1; i++) dp[i][i - 1] = 1;
for (int i = n; i >= 1; i--) {
for (int j = i; j <= n; j++) {
dp[i][j] = (cmp(S[j - i + 1], T[j]) * dp[i][j - 1] +
cmp(S[j - i + 1], T[i]) * dp[i + 1][j]) %
mod;
}
}
int ans = 0;
for (int i = m; i <= n; i++) ans = (ans + dp[1][i]) % mod;
cout << ans << endl;
return 0;
}
| 5 |
#include <iostream>
int main() {
int H, W; std::cin >> H >> W;
while (H--) {
std::string S; std::cin >> S;
std::cout << S << "\n" << S << "\n";
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, c[55][55];
int solve(int a, int b) {
int k, t, i, j, sum, min = 100000000;
for (k = 1; k <= n - a + 1; k++)
for (t = 1; t <= m - b + 1; t++) {
sum = 0;
for (i = k; i <= a + k - 1; i++)
for (j = t; j <= b + t - 1; j++) sum += c[i][j];
if (sum < min) min = sum;
}
return min;
}
int min(int a, int b) { return a < b ? a : b; }
int main() {
int ans, i, j, a, b;
while (scanf("%d%d", &n, &m) != EOF) {
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) scanf("%d", &c[i][j]);
scanf("%d%d", &a, &b);
ans = min(solve(a, b), solve(b, a));
printf("%d\n", ans);
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
const int N=3e5+5;
int sum[N];
int main(){
int n,m;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;++i){
int l,r;
scanf("%d%d",&l,&r);
sum[l]++; sum[r+1]--; l--;
for(int j=1,nxt;j<=l;j=nxt+1){
nxt=min(l/(l/j),r/(r/j));
if(l/j<r/j) sum[j]++,sum[nxt+1]--;
}
}
for(int i=1;i<=m;++i){
sum[i]+=sum[i-1];
printf("%d\n",sum[i]);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int N = 4e2 + 99;
const int A = 5;
const int B = 4;
int pref[N][N], t[N][N];
int n, m;
deque<pair<int, int>> q;
int ans = INF;
void dodaj(int i, int j, int z) {
int suma = (pref[j - 1][z - 1] - pref[i][z - 1]);
suma += (j - i - 1 -
(pref[j - 1][z] - pref[i][z] - pref[j - 1][z - 1] + pref[i][z - 1]));
suma += (z - 1 - (pref[j][z - 1] - pref[j - 1][z - 1]));
suma += (z - 1 - (pref[i][z - 1] - pref[i - 1][z - 1]));
while (!q.empty() && q.back().second >= suma) q.pop_back();
q.push_back({z, suma});
}
void usun(int z) {
while (!q.empty() && q.front().first < z + B) q.pop_front();
}
int licz(int i, int j, int z) {
int suma = q.front().second;
suma -= (pref[j - 1][z] - pref[i][z]);
suma -= (z - (pref[i][z] - pref[i - 1][z]));
suma -= (z - (pref[j][z] - pref[j - 1][z]));
suma += (j - i - 1 -
(pref[j - 1][z] - pref[i][z] - pref[j - 1][z - 1] + pref[i][z - 1]));
return suma;
}
void solve() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
char c;
cin >> c;
t[i][j] = (c == '1');
pref[i][j] =
pref[i - 1][j] + pref[i][j - 1] - pref[i - 1][j - 1] + t[i][j];
}
}
for (int i = 1; i <= n - A + 1; i++) {
for (int j = i + A - 1; j <= n; j++) {
q.clear();
for (int z = B; z <= m; z++) {
dodaj(i, j, z);
}
for (int z = 1; z <= m - B + 1; z++) {
ans = min(ans, licz(i, j, z));
usun(z);
}
}
}
cout << ans << "\n";
ans = INF;
}
int main() {
int Q;
cin >> Q;
while (Q--) solve();
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
vector<bool> prime(1e6 + 5, true);
void SieveOfEratosthenes(long long int n) {
prime[0] = false;
prime[1] = false;
for (long long unsigned int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long unsigned int i = p * p; i <= n; i += p) prime[i] = false;
}
}
}
vector<int> v;
long long unsigned int countDivisors(long long unsigned int n) {
long long unsigned int cnt = 0;
for (long long unsigned int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (n / i == i) {
++cnt;
v.push_back(i);
} else {
cnt += 2;
v.push_back(i);
v.push_back(n / i);
}
}
}
return cnt;
}
int Search(string pat, string txt) {
int n = txt.size();
int m = pat.size();
for (int i = 0; i <= n - m; i++) {
int j;
for (j = 0; j < m; j++) {
if (txt[i + j] != pat[j]) {
break;
}
}
if (j == m) {
return i;
}
}
return -1;
}
int findFirst(const std::vector<long long int> &array, int key, int low,
int high) {
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (key == array[mid]) {
ans = mid;
high = mid - 1;
} else if (key > array[mid])
low = mid + 1;
else
high = mid - 1;
}
return ans;
}
int findLast(const std::vector<long long int> &array, int key, int low,
int high) {
int ans = -1;
while (low <= high) {
int mid = low + (high - low) / 2;
if (key == array[mid]) {
ans = mid;
low = mid + 1;
} else if (key > array[mid])
low = mid + 1;
else
high = mid - 1;
}
return ans;
}
int d, x, y;
void extendedEuclid(int a, int b) {
if (b == 0) {
d = 1;
x = 1;
y = 0;
} else {
extendedEuclid(b, a % b);
int temp = x;
x = y;
y = temp - (a / b) * y;
}
}
bool isPowerOfTwo(long long int x) { return (x && !(x & (x - 1))); }
int count_one_in_Bin(long long int n) {
int ans = 0;
while (n) {
n = n & (n - 1);
ans++;
}
return ans;
}
int Len_dec(long long int n) {
int ans = 0;
while (n > 0) {
n /= 10;
ans++;
}
return ans;
}
int Len_Bin(long long int n) {
int ans = 0;
while (n > 0) {
n /= 2;
ans++;
}
return ans;
}
string foo(long long int n) {
string str;
while (n > 0) {
str += to_string(n % 2);
n /= 2;
}
int cnt = 60 - str.size();
while (cnt-- > 0) str += "0";
reverse(str.begin(), str.end());
;
return str;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
int t;
t = 1;
cin >> t;
for (int tc = 0; tc < t; tc++) {
long long unsigned int l, r;
cin >> l >> r;
if (l == r) {
cout << l << endl;
continue;
}
long long unsigned int ans = l, mx = l, num = l;
string str = foo(l);
while (mx <= r) {
int i;
bool g = 0;
for (i = str.size() - 1; i >= 0; i--) {
if (str[i] == '0') {
str[i] = '1';
g = 1;
break;
}
}
int idx = str.size() - 1 - i;
long long unsigned int add = 1LL << idx;
num += add;
mx = num;
if (num <= r) {
ans = num;
continue;
} else {
break;
}
}
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long lint;
const int MAX_N = 100005;
int N, Q;
lint A[MAX_N], X[MAX_N], S[MAX_N], odd[MAX_N], even[MAX_N];
bool check(int q, int i){
int j = distance(A, lower_bound(A, A+N, 2*X[q]-A[i]));
int cnt = i - j;
if(A[i]+A[j]>=2*X[q]) cnt++;
if(cnt>N-i-1) return false;
return true;
}
int main(){
ios::sync_with_stdio(false), cin.tie(nullptr);
cin >> N >> Q;
for(int i=0;i<N;i++) cin >> A[i];
for(int i=0;i<Q;i++) cin >> X[i];
for(int i=1;i<=N;i++){
S[i] += S[i-1] + A[i-1];
odd[i] = odd[i-1], even[i] = even[i-1];
if(i%2) even[i] += A[i-1];
else odd[i] += A[i-1];
}
for(int i=0;i<Q;i++){
int left = -1, right = N + 1;
while(1<right-left){
int mid = (left+right) / 2;
if(check(i, mid)) left = mid;
else right = mid;
}
int lb = max(2*left - N + 2, 0);
lint ans = S[N] - S[left+1];
if(lb%2) ans += even[lb];
else ans += odd[lb];
cout << ans << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
int t;
cin >> t;
while (t--) {
int n, x, sum = 0;
cin >> n;
for (int i = 0; i < n; i++) cin >> x, sum += x;
cout << (sum + n - 1) / n << endl;
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
ll arr[200005];
int main()
{
ll n, k, x;
cin>>n>>k>>x;
for(int i=0;i<n;i++){
cin>>arr[i];
}
sort(arr, arr+n);
std::vector<ll> v;
ll cnt=0,xtra=0;
for(int i=1;i<n;i++){
ll d=arr[i]-arr[i-1];
if(d>x){
xtra=((d+x-1)/x)-1;
v.push_back(xtra);
cnt++;
}
}
sort(v.begin(),v.end());
for(int i=0;i<v.size();i++){
if(v[i]<=k){
k-=v[i];
cnt--;
}
}
cout<<cnt+1<<endl;
} | 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
int ans, tot, n, q, col[N], f[N], size[N], head[N], to[N << 1], ne[N << 1];
map<int, int> e[N];
struct SGT {
int L[N << 2], R[N << 2];
vector<int> v[N << 2][2];
void build(int k, int l, int r) {
L[k] = l, R[k] = r;
if (l == r) return;
int mid = (l + r) >> 1;
build(k << 1, l, mid);
build(k << 1 | 1, mid + 1, r);
}
void add(int k, int l, int r, int x, int y) {
if (L[k] >= l && R[k] <= r) {
v[k][0].push_back(x);
v[k][1].push_back(y);
return;
}
int mid = (L[k] + R[k]) >> 1;
if (l <= mid) add(k << 1, l, r, x, y);
if (r > mid) add(k << 1 | 1, l, r, x, y);
}
void init(int x, int fa, int c) {
col[x] = c;
for (int i = head[x]; i; i = ne[i]) {
int y = to[i];
if (y == fa) continue;
init(y, x, c ^ 1);
}
}
int get(int x) { return x == f[x] ? x : get(f[x]); }
void dfs(int k) {
int val = ans;
vector<int> st[2];
for (int i = 0; i < v[k][0].size(); i++) {
int x = v[k][0][i], y = v[k][1][i], l = get(x), r = get(y);
if (l == r) {
ans |= col[x] == col[y];
continue;
}
if (size[l] < size[r]) swap(l, r), swap(x, y);
st[0].push_back(x);
st[1].push_back(r);
st[0].push_back(y);
to[++tot] = y;
ne[tot] = head[x];
head[x] = tot;
to[++tot] = x;
ne[tot] = head[y];
head[y] = tot;
init(y, x, col[x] ^ 1);
f[r] = l;
size[l] += size[r];
}
if (L[k] == R[k])
puts(ans ? "NO" : "YES");
else
dfs(k << 1), dfs(k << 1 | 1);
for (int i = st[0].size() - 1; i > -1; i--) {
tot--;
head[st[0][i]] = ne[head[st[0][i]]];
if (i >= st[1].size()) continue;
size[get(st[1][i])] -= size[st[1][i]];
f[st[1][i]] = st[1][i];
}
ans = val;
}
} T;
int main() {
scanf("%d%d", &n, &q);
for (int i = 1; i <= n; i++) f[i] = i, size[i] = 1;
T.build(1, 1, q);
for (int i = 1, x, y; i <= q; i++) {
scanf("%d%d", &x, &y);
if (e[x][y])
T.add(1, e[x][y], i - 1, x, y), e[x].erase(y);
else
e[x][y] = i;
}
for (int i = 1; i <= n; i++) {
for (map<int, int>::iterator j = e[i].begin(); j != e[i].end(); j++) {
T.add(1, (*j).second, q, i, (*j).first);
}
}
T.dfs(1);
return 0;
}
| 6 |
#include<bits/stdc++.h>
#define EPS 1e-10
#define equals(a,b) (fabs((a)-(b)) < EPS)
#define rep(i,n) for(int i=0;i<n;++i)
typedef long long ll;
using namespace std;
struct Point {
double x,y;
Point(){}
Point(double x, double y): x(x),y(y){}
Point operator+(Point p) {return Point(x+p.x, y+p.y);}
Point operator-(Point p) {return Point(x-p.x, y-p.y);}
Point operator*(double k) {return Point(x*k,y*k);}
double norm(){return x*x+y*y;}
double abs(){sqrt(norm());}
bool operator == (const Point &p) const {return equals(x,p.x)&&equals(y,p.y);}
};
typedef Point P;
struct Segment {
Point p1,p2;
Segment(){}
Segment(Point p1, Point p2):p1(p1),p2(p2){}
};
double dot(Point a, Point b) {return a.x*b.x+a.y*b.y;}
Point project(Segment s, Point p) {
Point base = s.p2-s.p1;
double r = dot(p-s.p1,base)/base.norm();
return s.p1+(base*r);
}
int main() {
double x1,y1,x2,y2;
cin >>x1>>y1>>x2>>y2;
Point p1(x1,y1); Point p2(x2,y2);
Segment s(p1,p2);
int q; cin >> q;
rep(i,q) {
double x0,y0;
cin >>x0>>y0;
Point ans = project(s,Point(x0,y0));
cout << fixed << setprecision(8);
cout << ans.x << " " << ans.y << endl;
}
return 0;
}
| 0 |
#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int n;
cin >> n;
vector<vector<long int> > a(n, vector<long int>(n));
vector<vector<long int> > p(n, vector<long int>(n, 1));
for(int i=0; i<n; ++i){
for(int j=0; j<n; ++j){
cin >> a[i][j];
}
}
int f=0;
for(int i=0; i<n; ++i){
for(int j=0; j<i; ++j){
for(int k=0; k<n; ++k){
if(a[i][k]+a[k][j]<a[i][j]){
f=1;
}else if(a[i][k]+a[k][j]==a[i][j] && k!=i && k!=j){
p[i][j]=0;
}
}
}
}
if(f==1){
cout << -1 << endl;
}else{
long int r=0;
for(int i=0; i<n; ++i){
for(int j=0; j<i; ++j){
if(p[i][j]==1) r+=a[i][j];
}
}
cout << r << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> v(n);
for (string& s : v) cin >> s;
for (char ch = 'a'; ch <= 'z'; ch++) {
char bs[100];
const int i = 49;
int mn = i, mx = i;
string* ps = 0;
for (string& s : v) {
if (s.empty()) continue;
int j = 0;
for (; j < (int)s.size(); j++) {
if (s[j] == ch) break;
}
if (j == s.size()) continue;
int k, m;
for (k = j, m = i; k >= 0; --k, --m) {
bs[m] = s[k];
}
mn = min(mn, m + 1);
for (k = j, m = i; k < (int)s.size(); ++k, ++m) {
bs[m] = s[k];
}
mx = max(mx, m - 1);
s.clear();
ps = &s;
}
*(bs + 1 + mx) = 0;
if (ps) *ps = bs + mn;
}
string res;
for (string& s : v) {
if (s.size()) res += s;
}
cout << res << '\n';
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long md = 998244353;
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
int test = 1;
while (test--) {
string s;
cin >> s;
string t;
cin >> t;
int i = 0;
long long ans[1 + t.length()];
int l = t.length();
while (i <= l) ans[i] = 1, i++;
int ln = 0;
long long tt = 0;
long long p = 1;
for (char ch : s) {
i = 0;
while (i < l) {
if (i + ln >= l) {
if (i > 0 && t[i - 1] == ch) {
ans[i - 1] += ans[i];
ans[i - 1] %= md;
}
} else {
if (i > 0 && t[i - 1] == ch) {
ans[i - 1] += ans[i];
ans[i - 1] %= md;
}
if (t[i + ln] != ch) {
ans[i] = 0;
}
}
i++;
}
if (ch == t[l - 1]) ans[l - 1] += p, ans[l - 1] %= md;
p *= 2;
p %= md;
ln++;
if (ln >= l) tt += ans[0], tt %= md;
}
cout << tt << endl;
}
return 0;
}
| 3 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
#define llong long long
int T;
int n;
llong a[220];
llong B[110];
int op[220];
void ins(llong x)
{
for(int i=61;i>=0;--i)
if((x>>i)&1)
{
if(!B[i])
{
B[i]=x;
break;
}
x^=B[i];
}
}
bool find(llong x)
{
for(int i=61;i>=0;--i)
if((x>>i)&1)x^=B[i];
return x==0;
}
int main()
{
scanf("%d",&T);
while(T--)
{
scanf("%d",&n);
for(int i=1;i<=n;++i)scanf("%lld",&a[i]);
for(int i=1;i<=n;++i)scanf("%1d",&op[i]);
memset(B,0,sizeof(B));
int ans=0;
for(int i=n;i;--i)
if(op[i]==0)ins(a[i]);
else if(!find(a[i]))
{
ans=1;break;
}
printf("%d\n",ans);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long Lef[512345], Rig[512345];
char s[512345];
int main() {
int n, a, b, T;
cin >> n >> a >> b >> T;
scanf("%s", s);
for (int i = 0; i < n; i++) {
if (i == 0) {
Rig[i] = s[i] == 'w' ? 1 + b : 1;
} else {
Rig[i] = Rig[i - 1] + a + 1;
if (s[i] == 'w') Rig[i] += b;
}
}
Rig[n] = Lef[n] = 0xfffffff;
for (int i = n - 1; i > 0; i--) {
if (i == n - 1) {
Lef[n - i] = s[i] == 'w' ? 1 + b : 1;
} else {
Lef[n - i] = Lef[n - 1 - i] + 1 + a;
if (s[i] == 'w') Lef[n - i] += b;
}
}
int mx = 0;
for (int i = 0; i < n; i++) {
if (Rig[i] > T) break;
mx = max(mx, i + 1);
int lest = T - Rig[i] - (i + 1) * a;
if (lest < 0) continue;
int id = upper_bound(Lef, Lef + n - i, lest) - Lef;
mx = max(mx, id + i);
}
for (int i = 1; i < n; i++) {
if (T - Lef[i] - a - Rig[0] >= 0) mx = max(mx, i + 1);
int lest = T - Lef[i] - a - i * a;
if (lest < Rig[0]) continue;
int id = upper_bound(Rig, Rig + n - i, lest) - Rig;
mx = max(mx, i + id);
}
mx = min(mx, n);
cout << mx << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, m, L[N][N], R[N][N], f[N][N];
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, k, l, r; i <= n; i++) {
for (scanf("%d", &k); k; k--) {
scanf("%d%d", &l, &r);
for (int j = l; j <= r; j++) {
L[i][j] = l, R[i][j] = r;
}
}
}
for (int len = 1; len <= m; len++) {
for (int l = 1, r = len; r <= m; l++, r++) {
for (int x = l; x <= r; x++) {
int cnt = 0;
for (int y = 1; y <= n; y++) {
cnt += (l <= L[y][x] && R[y][x] <= r);
}
f[l][r] = max(f[l][r], f[l][x - 1] + cnt * cnt + f[x + 1][r]);
}
}
}
printf("%d\n", f[1][m]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n, q;
char str[105];
int num[15];
char st[105];
int cp, dp;
int l, r;
int next(int ty, int x) {
int tmp = x;
if (ty == 1) {
x++;
while (x <= r && st[x] == char('0' - 1)) x++;
}
if (ty == -1) {
x--;
while (x >= l && st[x] == char('0' - 1)) x--;
}
if (st[tmp] == '>' || st[tmp] == '<') {
if (x >= l && x <= r) {
if (st[x] == '>' || st[x] == '<') {
st[tmp] = char('0' - 1);
}
}
}
return x;
}
int main() {
int nu;
while (scanf("%d%d", &n, &q) != EOF) {
scanf(" %s", str);
for (int i = 0; i < q; i++) {
scanf("%d%d", &l, &r);
memset(num, 0, sizeof(num));
nu = 0;
for (int i = l; i <= r; i++) {
st[i - l] = str[i - 1];
if (st[i - l] >= '0' && st[i - l] <= '9') nu++;
}
st[r - l + 1] = '\0';
r = r - l;
l = 0;
cp = l;
dp = 1;
while (nu > 0 && cp >= l && cp <= r) {
if (st[cp] >= '0' && st[cp] <= '9') {
num[st[cp] - '0']++;
st[cp]--;
if (st[cp] < '0') nu--;
cp = next(dp, cp);
} else if (st[cp] == '>') {
dp = 1;
cp = next(dp, cp);
} else {
dp = -1;
cp = next(dp, cp);
}
}
for (int i = 0; i < 9; i++) {
printf("%d ", num[i]);
}
printf("%d\n", num[9]);
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000003;
const int N = 1000006;
long long power(int a, int b, int md) {
int res = 1;
while (b > 0) {
if (b & 1) res = (res * 1LL * a) % md;
a = (a * 1LL * a) % md;
b /= 2;
}
return res;
}
int pr[N];
int main() {
long long n, k;
scanf("%lld %lld", &n, &k);
int pos = 0;
for (int i = 0; i < 64; ++i) {
if (k & (1LL << i)) {
pos = i;
}
}
if (pos >= n && (1LL << n) < k) {
printf("1 1\n");
return 0;
}
long long gc2 = n % (mod - 1);
long long kk = k - 1;
while (kk > 0) {
gc2 += kk / 2;
gc2 %= (mod - 1);
kk /= 2;
}
int gc = power(2, gc2 % (mod - 1), mod);
int p2n = power(2, n % (mod - 1), mod);
pr[0] = p2n;
for (int i = 1; i < mod; ++i) {
pr[i] = (pr[i - 1] * 1LL * (p2n - i + mod) % mod) % mod;
}
int aa = k >= mod ? ((k / mod) % mod * 1LL * pr[mod - 1]) % mod : 1;
if (k % mod > 0) {
aa = (aa * 1LL * pr[k % mod - 1]) % mod;
}
int bb = power(p2n, k % (mod - 1), mod);
aa = (bb - aa + mod) % mod;
bb = (bb * 1LL * power(gc, mod - 2, mod)) % mod;
aa = (aa * 1LL * power(gc, mod - 2, mod)) % mod;
printf("%d %d\n", aa, bb);
return (0);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int mat[100][100];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> mat[i][j];
}
}
int row[100] = {0}, col[100] = {0}, ans = 0;
if (m < n) {
for (int i = 0; i < m; i++) {
int cmin = INT_MAX;
for (int j = 0; j < n; j++) {
cmin = min(cmin, mat[j][i]);
}
col[i] = cmin;
ans += cmin;
for (int j = 0; j < n; j++) {
mat[j][i] -= cmin;
}
}
for (int i = 0; i < n; i++) {
int rmin = INT_MAX;
for (int j = 0; j < m; j++) {
rmin = min(rmin, mat[i][j]);
}
row[i] = rmin;
ans += rmin;
for (int j = 0; j < m; j++) {
mat[i][j] -= rmin;
}
}
} else {
for (int i = 0; i < n; i++) {
int rmin = INT_MAX;
for (int j = 0; j < m; j++) {
rmin = min(rmin, mat[i][j]);
}
row[i] = rmin;
ans += rmin;
for (int j = 0; j < m; j++) {
mat[i][j] -= rmin;
}
}
for (int i = 0; i < m; i++) {
int cmin = INT_MAX;
for (int j = 0; j < n; j++) {
cmin = min(cmin, mat[j][i]);
}
col[i] = cmin;
ans += cmin;
for (int j = 0; j < n; j++) {
mat[j][i] -= cmin;
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (mat[i][j] != 0) {
cout << "-1" << endl;
return 0;
}
}
}
cout << ans << endl;
for (int i = 0; i < n; i++) {
for (int j = 0; j < row[i]; j++) {
cout << "row " << i + 1 << endl;
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < col[i]; j++) {
cout << "col " << i + 1 << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
const int MAX = 2e5 + 11;
using namespace std;
int N, A[MAX], L[MAX], R[MAX], B[MAX];
int main() {
scanf("%d", &N);
for (int i = 0; i < N; ++i) {
scanf("%d", &A[i + 1]);
}
stack<int> S;
for (int i = 1; i <= N; ++i) {
while (!S.empty() && A[S.top()] >= A[i]) {
S.pop();
}
L[i] = S.empty() ? 0 : S.top();
S.push(i);
}
S = stack<int>();
for (int i = N; i >= 1; --i) {
while (!S.empty() && A[S.top()] >= A[i]) {
S.pop();
}
R[i] = S.empty() ? N + 1 : S.top();
S.push(i);
}
for (int i = 1; i <= N; ++i) {
int t = R[i] - L[i] - 1;
B[t] = max(B[t], A[i]);
}
for (int i = N; i >= 1; --i) {
B[i] = max(B[i], B[i + 1]);
}
for (int i = 1; i <= N; ++i) {
printf("%d ", B[i]);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2 * 1e5 + 5;
int a[N], n, d, dep[N], y, mx;
vector<int> vec[N];
void dfs(int x, int pa) {
if (pa == -1)
dep[x] = 0;
else {
if (a[x] == a[pa])
dep[x] = dep[pa];
else
dep[x] = dep[pa] + 1;
}
if (dep[x] > mx) {
mx = dep[x];
y = x;
}
for (int y : vec[x]) {
if (y == pa) continue;
dfs(y, x);
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i);
for (int i = 0; i < n - 1; i++) {
int x, y;
scanf("%d%d", &x, &y);
x--, y--;
vec[x].push_back(y);
vec[y].push_back(x);
}
mx = -1;
dfs(0, -1);
dfs(y, -1);
printf("%d\n", (mx + 1) / 2);
return 0;
}
| 5 |
#include<iostream>
#include<math.h>
#include<algorithm>
#include <stdlib.h>
using namespace std;
long long a[300002];
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int T;
int n;
long long m, ans;
cin >> T;
while (T--)
{
cin >> n;
ans = 0;
m = 0;
for (int i = 0; i < n; ++i)
{
cin >> a[i];
if(i >= 1)ans += abs(a[i] - a[i - 1]);
if (i >= 2)
{
m = max(m, abs(a[i] - a[i - 1]) + abs(a[i - 1] - a[i - 2]) - abs(a[i] - a[i - 2]));
}
}
m = max(m, abs(a[0] - a[1]));
m = max(m, abs(a[n-1] - a[n-2]));
cout << ans - m << '\n';
}
} | 2 |
#include <bits/stdc++.h>
using namespace std;
#include <bits/stdc++.h>
using
namespace std;
template <typename T, class F = function<T(const T&, const T&)>>
class SparseTable {
public:
int n;
vector<vector<T>> sp;
F func;
SparseTable(const vector<T> &a , const F& f) : func(f) {
n = static_cast<int>(a.size());
int max_log = 32 - __builtin_clz(n);
sp.resize(max_log);
sp[0] = a;
for (int j = 1; j < max_log; ++j) {
sp[j].resize(n - (1 << j) + 1);
for (int i = 0; i <= n - (1 << j); ++i) {
sp[j][i] = func(sp[j - 1][i], sp[j - 1][i + (1 << (j - 1))]);
}
}
}
T get(int l , int r) const {
int lg = 32 - __builtin_clz(r - l + 1) - 1;
return func(sp[lg][l] , sp[lg][r - (1 << lg) + 1]);
}
};
void run() {
int n;
cin >> n;
vector<int> A(n);
for (auto &a : A)
cin >> a;
SparseTable<int> mn(A, [&](int i, int j) {
return min(i, j);
});
SparseTable<int> mx(A, [&](int i, int j) {
return max(i, j);
});
for (int i = 1 ;i + 1 < n ;i++) {
int v = mx.get(0 , i - 1);
int l = i , r = n - 2 , first = -1 , last = -1;
while (l <= r) {
int mid = (l + r) / 2;
int vv = mn.get(i , mid);
if (vv == v)
first = mid;
if (vv <= v) {
r = mid - 1;
} else {
l = mid + 1;
}
}
if (first == -1)
continue;
l = first , r = n - 2;
while (l <= r) {
int mid = (l + r) / 2;
int vv = mn.get(i , mid);
if (vv < v)
r = mid - 1;
else {
last = mid;
l = mid + 1;
}
}
int first2 = -1 , last2 = -1;
l = 0 , r = n - 1;
while (l <= r) {
int mid = (l + r) / 2;
int vv = mx.get(mid , n - 1);
if (vv == v)
first2 = mid;
if (vv >= v) {
l = mid + 1;
} else {
r = mid - 1;
}
}
if (first2 == -1)
continue;
l = 0 , r = first2;
while (l <= r) {
int mid = (l + r) / 2;
int vv = mx.get(mid , n - 1);
if (vv > v)
l = mid + 1;
else {
last2 = mid;
r = mid - 1;
}
}
int a = first + 1 , b = last + 1, c = last2 , d = first2;
if (a > c) {
swap(a , c);
swap(b , d);
}
if (c <= b) {
cout << "YES\n";
cout << i << ' ' << c - i << ' ' << n - c << '\n';
return;
}
}
cout << "NO\n";
}
int main() {
ios::sync_with_stdio(0) , cin.tie(0) , cout.tie(0);
#ifdef LOCAL
freopen("input.in" , "r" , stdin);
#endif
int t;
cin >> t;
while (t--)
run();
} | 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, t, c = 0, ans;
bool b = 0;
cin >> n >> t;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
if (!b && c + 86400 - x >= t) {
b = 1;
ans = i + 1;
} else
c += (86400 - x);
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int f[409][409];
char s[409], t[409];
int main() {
int T, i, j, k, n, m;
scanf("%d", &T);
while (T--) {
scanf("%s%s", s + 1, t + 1), n = strlen(s + 1), m = strlen(t + 1);
for (i = 1; i <= m; ++i) {
for (j = 1, k = 1; j <= n; ++j) {
while (j <= n && s[j] != t[k]) ++j;
if (j > n) {
puts("NO");
goto ggg;
}
++k;
if (k > i) break;
}
for (j = 0; j <= n; ++j) {
for (k = 0; k <= i; ++k) {
f[j][k] = -1e9;
}
}
f[0][0] = 0;
for (j = 1; j <= n; ++j) {
for (k = 0; k <= i; ++k) {
f[j][k] = f[j - 1][k];
if (f[j - 1][k] >= 0 && s[j] == t[i + f[j - 1][k] + 1]) ++f[j][k];
if (s[j] == t[k] && k > 0 && f[j][k] < f[j - 1][k - 1])
f[j][k] = f[j - 1][k - 1];
}
}
if (f[n][i] == m - i) {
puts("YES");
goto ggg;
}
}
puts("NO");
ggg:;
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MM = 320000;
const int LE = 1100000;
long long da[110000];
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int q;
cin >> q;
while (q-- != 0) {
int n, m;
cin >> n >> m;
vector<string> vs(n);
for (int i = 0; i < n; i++) cin >> vs[i];
int dx[n], dy[m];
int ans = INT_MAX;
for (int i = 0; i < n; i++) {
dx[i] = 0;
for (int j = 0; j < m; j++)
if (vs[i][j] == '.') dx[i]++;
}
for (int j = 0; j < m; j++) {
dy[j] = 0;
for (int i = 0; i < n; i++)
if (vs[i][j] == '.') dy[j]++;
}
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int cost = dx[i] + dy[j];
if (vs[i][j] == '.') cost--;
ans = min(cost, ans);
}
cout << ans << endl;
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
struct matrix {
long long a[128][128];
};
void mul(const matrix &a, const matrix &b, matrix &c, int ogr) {
for (int i = 0; i <= (ogr); ++i)
for (int j = 0; j <= (ogr); ++j) {
c.a[i][j] = 0;
for (int l = 0; l <= (ogr); ++l) {
c.a[i][j] += a.a[i][l] * b.a[l][j];
c.a[i][j] %= mod;
}
}
}
void prze(const matrix &a, matrix &b) {
for (int i = 0; i <= (127); ++i)
for (int j = 0; j <= (127); ++j) b.a[i][j] = a.a[i][j];
}
int w[12];
matrix przejscia[8];
matrix ans, tmp;
bool zla(int od, int doo, int podz, int wys) {
if (!(od & 1) && !(doo & 1) && podz & 1) return true;
--wys;
if (!(od & (1 << wys)) && !(doo & (1 << wys)) && podz & (1 << (wys - 1)))
return true;
for (int i = 0; i <= (wys - 2); ++i)
if (!(od & (1 << (i + 1))) && !(doo & (1 << (i + 1))) && podz & (1 << i) &&
podz & (1 << (i + 1)))
return true;
return false;
}
void buduj_przejscia() {
przejscia[1].a[1][0] = 1;
przejscia[1].a[0][1] = 1;
przejscia[1].a[1][1] = 1;
for (int i = 2; i <= (7); ++i) {
for (int j = 0; j <= ((1 << i) - 1); ++j)
for (int l = 0; l <= ((1 << i) - 1); ++l)
for (int k = 0; k <= ((1 << (i - 1)) - 1); ++k) {
if (zla(j, l, k, i)) continue;
++przejscia[i].a[j][l];
}
}
return;
cout << "CHuj wam w dupe";
}
int main() {
buduj_przejscia();
for (int i = 1; i <= (7); ++i) cin >> w[i];
for (int i = 0; i <= (127); ++i) ans.a[i][i] = 1;
for (int i = 1; i <= (7); ++i) {
while (w[i]) {
if (w[i] & 1) {
mul(ans, przejscia[i], tmp, (1 << i) - 1);
prze(tmp, ans);
}
w[i] /= 2;
mul(przejscia[i], przejscia[i], tmp, (1 << i) - 1);
prze(tmp, przejscia[i]);
}
}
cout << ans.a[0][0] << endl;
}
| 5 |
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int main() {
int n; cin >> n;
vector<ll> la(n);
for (ll &a: la) cin >> a;
ll x = la[0];
for (int i = 1; i < n; ++i) {
if (i % 2) x -= la[i];
else x += la[i];
}
cout << x;
for (int i = 0; i < n-1; ++i) {
x = 2*la[i]-x;
cout << " " << x;
}
cout << endl;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
#define int long long
typedef vector<int> arr;
typedef vector<arr> mat;
inline mat mul(mat a,mat b,int mod){
if((int)a.size()==1&&(int)a[0].size()==1){
mat res(b);
for(int i=0;i<(int)b.size();i++)
for(int j=0;j<(int)b[i].size();j++)
(res[i][j]*=a[0][0])%=mod;
return res;
}
if((int)b.size()==1&&(int)b[0].size()==1){
mat res(a);
for(int i=0;i<(int)a.size();i++)
for(int j=0;j<(int)a[i].size();j++)
(res[i][j]*=b[0][0])%=mod;
return res;
}
mat res(a.size(),arr(b[0].size(),0));
for(int i=0;i<(int)a.size();i++)
for(int j=0;j<(int)b[0].size();j++)
for(int k=0;k<(int)b.size();k++)
(res[i][j]+=a[i][k]*b[k][j])%=mod;
return res;
}
inline mat add(mat a,mat b,int mod){
mat res(a);
for(int i=0;i<(int)b.size();i++)
for(int j=0;j<(int)b[i].size();j++)
(res[i][j]+=b[i][j])%=mod;
return res;
}
inline mat sub(mat a,mat b,int mod){
mat res(a);
for(int i=0;i<(int)b.size();i++)
for(int j=0;j<(int)b[i].size();j++)
(res[i][j]+=mod-b[i][j])%=mod;
return res;
}
mat var(int &p);
mat expr(int &p);
mat term(int &p);
mat factor(int &p);
mat primary(int &p);
mat indexed_primary(mat a,int &p);
mat transposed_primary(mat a,int &p);
mat matrix(int &p);
mat row_seq(int &p);
mat row(int &p);
mat inum(int &p);
const int M=1<<15;
map<char,mat> mm;
string s;
bool dbg=0;
void print(mat a){
for(int i=0;i<(int)a.size();i++){
for(int j=0;j<(int)a[i].size();j++){
if(j) cout<<" ";
cout<<a[i][j];
}
cout<<endl;
}
}
mat var(int &p){
if(dbg) cout<<"var:"<<endl,print(mm[s[p]]);
return mm[s[p++]];
}
mat expr(int &p){
if(dbg) cout<<"expr:"<<endl;
mat res=term(p);
while(p<(int)s.size()){
if(s[p]=='+'){
p++;
res=add(res,term(p),M);
continue;
}
if(s[p]=='-'){
p++;
res=sub(res,term(p),M);
continue;
}
break;
}
if(dbg) cout<<"expr:"<<endl,print(res);
return res;
}
mat term(int &p){
if(dbg) cout<<"term:"<<endl;
mat res=factor(p);
while(p<(int)s.size()){
if(s[p]=='*'){
p++;
res=mul(res,factor(p),M);
continue;
}
break;
}
if(dbg) cout<<"term:"<<endl,print(res);
return res;
}
mat factor(int &p){
if(dbg) cout<<"factor:"<<endl;
mat res;
if(s[p]=='-'){
p++;
mat tmp=factor(p);
res=sub(mat(tmp.size(),arr(tmp[0].size(),0)),tmp,M);
}else{
res=primary(p);
}
if(dbg) cout<<"factor:"<<endl,print(res);
return res;
}
mat primary(int &p){
if(dbg) cout<<"primary:"<<endl;
mat res;
if(isupper(s[p])){
res=var(p);
}else if(s[p]=='('){
p++;
res=expr(p);
p++;
}else if(s[p]=='['){
res=matrix(p);
}else{
res=inum(p);
}
while(p<(int)s.size()){
if(s[p]=='('){
p++;
res=indexed_primary(res,p);
p++;
continue;
}
if(s[p]=='\''){
p++;
res=transposed_primary(res,p);
continue;
}
break;
}
if(dbg) cout<<"primary:"<<endl,print(res);
return res;
}
mat indexed_primary(mat a,int &p){
if(dbg) cout<<"indexed_primary:"<<endl;
mat res,b,c;
b=expr(p);
p++;
c=expr(p);
res.resize(b[0].size());
for(int i=0;i<(int)b[0].size();i++){
res[i].resize(c[0].size());
for(int j=0;j<(int)c[0].size();j++)
res[i][j]=a[b[0][i]-1][c[0][j]-1];
}
if(dbg) cout<<"indexed_primary:"<<endl,print(res);
return res;
}
mat transposed_primary(mat a,int &p){
if(dbg) cout<<"transposed_primary:"<<endl;
mat res;
res.resize(a[0].size());
for(int i=0;i<(int)a[0].size();i++){
res[i].resize(a.size());
for(int j=0;j<(int)a.size();j++)
res[i][j]=a[j][i];
}
if(dbg) cout<<"transposed_primary:"<<endl,print(res);
return res;
}
mat matrix(int &p){
if(dbg) cout<<"matrix:"<<endl;
mat res;
p++;
res=row_seq(p);
p++;
if(dbg) cout<<"matrix:"<<endl,print(res);
return res;
}
mat row_seq(int &p){
if(dbg) cout<<"row_seq:"<<endl;
mat res=row(p);
while(p<(int)s.size()){
if(s[p]==';'){
p++;
mat tmp=row(p);
for(int i=0;i<(int)tmp.size();i++)
res.push_back(tmp[i]);
continue;
}
break;
}
if(dbg) cout<<"row_seq:"<<endl,print(res);
return res;
}
mat row(int &p){
if(dbg) cout<<"row:"<<endl;
mat res=expr(p);
while(p<(int)s.size()){
if(s[p]==' '){
p++;
mat tmp=expr(p);
for(int i=0;i<(int)tmp.size();i++)
for(int j=0;j<(int)tmp[i].size();j++)
res[i].push_back(tmp[i][j]);
continue;
}
break;
}
if(dbg) cout<<"row:"<<endl,print(res);
return res;
}
mat inum(int &p){
if(dbg) cout<<"inum:"<<endl;
mat res(1,arr(1,0));
while(p<(int)s.size()&&isdigit(s[p]))
res[0][0]=(res[0][0]*10+s[p++]-'0')%M;
if(dbg) cout<<"inum:"<<endl,print(res);
return res;
}
string str[20];
signed main(){
int n;
while(cin>>n,n){
cin.ignore();
for(int i=0;i<n;i++) getline(cin,str[i]);
//cout<<n<<endl;for(int i=0;i<n;i++) cout<<str[i]<<endl;
mm.clear();
for(int i=0;i<n;i++){
int p=2;
s=str[i];
s.pop_back();
mm[s[0]]=expr(p);
for(int j=0;j<(int)mm[s[0]].size();j++){
for(int k=0;k<(int)mm[s[0]][j].size();k++){
if(k) cout<<" ";
cout<<mm[s[0]][j][k];
}
cout<<endl;
}
}
cout<<"-----"<<endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
const int p = 131;
int n;
bool ok[N][20];
int sum[N][26];
long long del[N], add[N][26];
unsigned long long h[N], pw[N];
char s[N];
inline unsigned long long calc(int l, int r) {
return h[r] - h[l - 1] * pw[r - l + 1];
}
inline int find(int a, int b) {
int l = 0, r = min(n - a + 1, n - b + 1);
while (l < r) {
const int mid = l + r + 1 >> 1;
if (calc(a, a + mid - 1) == calc(b, b + mid - 1))
l = mid;
else
r = mid - 1;
}
return l;
}
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
long long ans = n;
for (int i = pw[0] = 1; i <= n; ++i) {
for (int j = 0; j < 26; ++j) sum[i][j] = sum[i - 1][j];
pw[i] = pw[i - 1] * p;
h[i] = h[i - 1] * p + s[i];
++sum[i][s[i] - 'a'];
}
for (int i = 1; i <= n; ++i) ok[i][1] = 1;
for (int i = 2; i <= 16; ++i)
for (int j = 1; j + (1 << i) - 2 <= n; ++j)
if (ok[j][i - 1] && ok[j + (1 << i - 1)][i - 1]) {
int l = j, mid = j + (1 << i - 1) - 1, r = j + (1 << i) - 2,
c = s[mid] - 'a';
if (calc(l, mid - 1) == calc(mid + 1, r) &&
sum[r][c] - sum[l - 1][c] == 1)
ok[j][i] = 1;
}
for (int i = 2; i <= 16; ++i)
for (int j = 1; j + (1 << i) - 2 <= n; ++j) {
int l = j, mid = j + (1 << i - 1) - 1, r = j + (1 << i) - 2,
c = s[mid] - 'a';
long long val = (r - l + 1ll) * (r - l + 1);
if (ok[j][i]) {
ans += val;
del[j] += val;
del[mid] -= val;
del[mid + 1] += val;
del[r + 1] -= val;
for (int k = 0; k < 26; ++k)
if (k != c && sum[r][k] - sum[l - 1][k]) add[mid][k] -= val;
} else {
if (ok[l][i - 1] && ok[mid + 1][i - 1] &&
calc(l, mid - 1) == calc(mid + 1, r)) {
for (int k = 0; k < 26; ++k)
if (!(sum[r][k] - sum[l - 1][k])) add[mid][k] += val;
} else {
if (!ok[l][i - 1] && !ok[mid + 1][i - 1]) continue;
int lcp = find(l, mid + 1), pl = l + lcp, pr = mid + 1 + lcp;
if (calc(pl + 1, mid - 1) != calc(pr + 1, r)) continue;
if (ok[l][i - 1] &&
sum[r][c] - sum[l - 1][c] - (c == s[pr] - 'a') == 1)
add[pr][s[pl] - 'a'] += val;
if (ok[mid + 1][i - 1] &&
sum[r][c] - sum[l - 1][c] - (c == s[pl] - 'a') == 1)
add[pl][s[pr] - 'a'] += val;
}
}
}
long long mx = 0;
for (int i = 1; i <= n; ++i) {
del[i] += del[i - 1];
for (int j = 0; j < 26; ++j)
if (j != s[i] - 'a') mx = max(mx, add[i][j] - del[i]);
}
ans += mx;
return printf("%lld\n", ans), 0;
}
| 5 |
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
long long mod=1e9+7;
long long power(long long a,long long b)
{
return b?power(a*a%mod,b/2)*(b%2?a:1)%mod:1;
}
long long M;
string C;
long long P[1<<17];
long long c[1<<17];
long long X[10];
int main()
{
cin>>M>>C;
if(C.size()==1)
{
if(M<10)cout<<M<<endl;
else cout<<-1<<endl;
return 0;
}
P[0]=1;
for(int i=1;i<C.size();i++)P[i]=P[i-1]*10%mod;
for(int i=0;i<C.size();i++)
{
c[i]=C[i]-'0';
(X[c[i]]+=P[C.size()-i-1])%=mod;
}
vector<int>A(10);
for(int i=0;i<10;i++)A[i]=i;
do{
if(A[c[0]]==0)continue;
long long now=0;
for(int i=0;i<10;i++)(now+=X[i]*A[i])%=mod;
if(now==M)
{
for(int i=0;i<C.size();i++)
{
cout<<A[c[i]];
}
cout<<endl;
return 0;
}
}while(next_permutation(A.begin(),A.end()));
cout<<-1<<endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cout << (i & 1);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long tree[400009];
int mv[400009];
void build(int s, int t, int start) {
if (s == t) {
cin >> tree[start];
mv[start] = tree[start];
return;
}
int mid = (s + t) / 2;
build(s, mid, start * 2);
build(mid + 1, t, start * 2 + 1);
tree[start] = tree[start * 2] + tree[start * 2 + 1];
mv[start] = max(mv[start * 2], mv[start * 2 + 1]);
}
void sets(int k, int x, int s, int t, int start) {
if (s == t) {
tree[start] = x;
mv[start] = x;
return;
}
int mid = (s + t) / 2;
if (k <= mid)
sets(k, x, s, mid, start * 2);
else
sets(k, x, mid + 1, t, start * 2 + 1);
tree[start] = tree[start * 2] + tree[start * 2 + 1];
mv[start] = max(mv[start * 2], mv[start * 2 + 1]);
}
void update(int ll, int rr, int x, int s, int t, int start) {
if (s == t) {
tree[start] = tree[start] % x;
mv[start] = tree[start];
return;
}
if (mv[start] < x) return;
int mid = (s + t) / 2;
if (ll <= mid) update(ll, rr, x, s, mid, start * 2);
if (rr > mid) update(ll, rr, x, mid + 1, t, start * 2 + 1);
tree[start] = tree[start * 2] + tree[start * 2 + 1];
mv[start] = max(mv[start * 2], mv[start * 2 + 1]);
}
long long query(int ll, int rr, int s, int t, int start) {
if (ll <= s && rr >= t) return tree[start];
long long sum = 0;
int mid = (s + t) / 2;
if (ll <= mid) sum += query(ll, rr, s, mid, start * 2);
if (rr > mid) sum += query(ll, rr, mid + 1, t, start * 2 + 1);
return sum;
}
int main() {
int n, m, type, ll, rr, k, x;
while (cin >> n >> m) {
build(1, n, 1);
for (int i = 1; i <= m; i++) {
cin >> type;
if (type == 1) {
cin >> ll >> rr;
cout << query(ll, rr, 1, n, 1) << endl;
}
if (type == 2) {
cin >> ll >> rr >> x;
update(ll, rr, x, 1, n, 1);
}
if (type == 3) {
cin >> k >> x;
sets(k, x, 1, n, 1);
}
}
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
const int K = 666;
static int cnt[N], ans, _ans[N];
int main() {
int n, q;
cin >> n >> q;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
int l[q], r[q], mo_l = 0, mo_r = 0;
for (int i = 0; i < q; ++i) cin >> l[i] >> r[i], --l[i];
int cnt_bl = n / K + bool(n % K);
vector<int> block[cnt_bl];
for (int i = 0; i < q; ++i) block[l[i] / K].push_back(i);
for (int i = 0; i < cnt_bl; ++i) {
sort(block[i].begin(), block[i].end(),
[&](int a, int b) { return r[a] < r[b]; });
for (int x : block[i]) {
while (mo_l < l[x]) {
if (a[mo_l] < N)
ans -= cnt[a[mo_l]] == a[mo_l], ans += --cnt[a[mo_l]] == a[mo_l];
mo_l++;
}
while (mo_l > l[x])
if (a[--mo_l] < N)
ans -= cnt[a[mo_l]] == a[mo_l], ans += ++cnt[a[mo_l]] == a[mo_l];
while (mo_r < r[x]) {
if (a[mo_r] < N)
ans -= cnt[a[mo_r]] == a[mo_r], ans += ++cnt[a[mo_r]] == a[mo_r];
mo_r++;
}
while (mo_r > r[x])
if (a[--mo_r] < N)
ans -= cnt[a[mo_r]] == a[mo_r], ans += --cnt[a[mo_r]] == a[mo_r];
_ans[x] = ans;
}
}
for (int i = 0; i < q; ++i) cout << _ans[i] << '\n';
return 0;
}
| 2 |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
int main()
{
vector<string> vs;
vs.push_back("1111110");
vs.push_back("0110000");
vs.push_back("1101101");
vs.push_back("1111001");
vs.push_back("0110011");
vs.push_back("1011011");
vs.push_back("1011111");
vs.push_back("1110010");
vs.push_back("1111111");
vs.push_back("1111011");
while(true){
int n;
scanf("%d", &n);
if(n==-1)break;
string state = "0000000";
for(int i = 0; i < n; ++i){
int d;
scanf("%d", &d);
string signal;
for(int j = 0; j < 7; ++j){
if(state[j]!=vs[d][j]){
signal += '1';
}else{
signal += '0';
}
}
reverse(signal.begin(),signal.end());
printf("%s\n", signal.c_str());
state = vs[d];
}
}
return 0;
} | 0 |
// B.
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long LL;
int main(int argc, char *argv[]) {
int n, k;
cin >> n >> k;
int sz = (n * (n + 1)) / 2;
vector<LL> a(n), v(sz);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int si = 0;
for (int i = 0; i < n; ++i) {
LL c = 0;
for (int j = i; j < n; ++j) {
c += a[j];
v[si++] = c;
}
}
LL ans = 0;
for (int b = 40; b >= 0; --b) {
LL x = 1LL << b;
sort(v.rbegin(), v.rend());
LL c = 0;
for (int i = 0; i < sz; ++i) {
if (!(v[i] & x)) {
break;
}
++c;
v[i] &= ~x;
}
if (c >= k) {
ans |= x;
v.resize(c);
}
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long k, n, res;
int main() {
scanf("%I64d %I64d", &n, &k);
while (n % 5 == 0 && res < k) {
n /= 5;
res++;
}
res = 0;
while (n % 2 == 0 && res < k) {
n /= 2;
res++;
}
cout << n;
while (k--) printf("0");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, k;
cin >> n >> k;
int a[n + 1], b[10] = {0}, ans = 0;
for (int i = 1; i < n + 1; i++) {
cin >> a[i];
ans = ans + a[i] / 10;
b[10 - (a[i] % 10)]++;
}
for (int i = 1; i < 10; i++) {
while (k >= i && b[i]) {
k -= i;
b[i]--;
ans++;
}
}
ans = ans + k / 10;
ans = min(ans, 10 * n);
cout << ans << endl;
return 0;
}
| 3 |
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <stack>
#include <queue>
#include <cstring>
#include <climits>
#include <cmath>
#include <cfloat>
#define FOR(i,b,n) for(int i=b;i<n;i++)
#define REP(i,b,n) for(i=b;i<n;i++)
#define CLR(mat) memset(mat, 0, sizeof(mat))
using namespace std;
int main()
{
string s;
while(getline(cin, s), s != "END OF INPUT")
{
int i, d = 0;
REP(i, 0, s.size())
{
if( s[i] == ' ')
{
cout << i-d;
d = i+1;
}
}
cout << i-d << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
const int N = 2e5 + 10;
int n, u, v, cnt, d[N], parent[N];
std::set<std::pair<int, int> > far;
std::vector<int> graph[N];
void dfs(int v) {
if (d[v] > 2) far.insert({d[v], v});
for (int u : graph[v]) {
if (d[u] < 0) {
d[u] = d[v] + 1;
parent[u] = v;
dfs(u);
}
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
scanf("%d%d", &u, &v);
graph[--u].push_back(--v);
graph[v].push_back(u);
}
memset(d, -1, sizeof(d));
d[0] = 0;
dfs(0);
while (!far.empty()) {
auto it = --far.end();
std::pair<int, int> top = {d[parent[it->second]], parent[it->second]};
far.erase(top);
for (int u : graph[top.second]) {
far.erase({top.first + 1, u});
far.erase({top.first - 1, u});
}
cnt++;
}
printf("%d\n", cnt);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MAXB = 1e7;
char buf[MAXB], *cp = buf;
inline void rd(int &x) {
x = 0;
int f = 1;
while (*cp < '0' || '9' < *cp) {
if (*cp == '-') f = -1;
cp++;
}
while ('0' <= *cp && *cp <= '9') x = (x << 3) + (x << 1) + *cp - 48, cp++;
x *= f;
}
const int MAXN = 200010;
int n, m, ans;
int f[MAXN], h[MAXN], full[MAXN];
struct info {
int a, b, w;
inline void get() {
rd(a);
rd(b);
rd(w);
}
} t[MAXN];
bool operator<(info x, info y) { return x.w > y.w; }
void init() {
for (int i = 1; i <= n; i++) f[i] = i, h[i] = 1, full[i] = 0;
}
int find(int x) { return f[x] == x ? x : f[x] = find(f[x]); }
void uni(int x, int y) {
x = find(x);
y = find(y);
if (x == y) {
full[x] = 1;
return;
}
if (h[x] < h[y])
f[y] = x;
else if (h[x] > h[y])
f[x] = y;
else
f[x] = y, h[y]++;
}
int main() {
fread(buf, 1, MAXB, stdin);
rd(n);
rd(m);
for (int i = 0; i < m; i++) t[i].get();
sort(t, t + m);
init();
ans = 0;
for (int i = 0; i < m; i++) {
t[i].a = find(t[i].a);
t[i].b = find(t[i].b);
if (full[t[i].a] && full[t[i].b]) continue;
if (full[t[i].a])
full[t[i].b] = 1;
else if (full[t[i].b])
full[t[i].a] = 1;
else
uni(t[i].a, t[i].b);
ans += t[i].w;
}
printf("%d\n", ans);
return 0;
}
| 6 |
#include <iostream>
#include <algorithm>
#include<cmath>
#include<cstring>
#include<cstdio>
#include<cstdlib>
#include<vector>
#include<iomanip>
#include<ctime>
#include<set>
#include<map>
#include<queue>
#include<stack>
#include<bitset>
#define sqr(x) ((x)*(x))
#define fz1(i,n) for ((i)=1;(i)<=(n);(i)++)
#define fd1(i,n) for ((i)=(n);(i)>=1;(i)--)
#define fz0g(i,n) for ((i)=0;(i)<=(n);(i)++)
#define fd0g(i,n) for ((i)=(n);(i)>=0;(i)--)
#define fz0k(i,n) for ((i)=0;(i)<(n);(i)++)
#define fd0k(i,n) for ((i)=(long long)((n)-1);(i)>=0;(i)--)
#define fz(i,x,y) for ((i)=(x);(i)<=(y);(i)++)
#define fd(i,y,x) for ((i)=(y);(i)>=(x);(i)--)
#define fzin fz1(i,n)
#define fzim fz1(i,m)
#define fzjn fz1(j,n)
#define fzjm fz1(j,m)
#define ff(c,itr) for (__typeof((c).begin()) itr=(c).begin();itr!=(c).end();++itr)
#define rdst(st,len){static char ss[len];scanf(" %s",ss);(st)=ss;}
#define inc(x,y) {x+=(y);if(x>=mod)x-=mod;}
#define dec(x,y) {x-=(y);if(x<0)x+=mod;}
#define spln(i,n) (i==n?'\n':' ')
#define fac_init(n){fac[0]=fac[1]=inv[1]=fi[0]=fi[1]=1;fz(i,2,n){fac[i]=1ll*fac[i-1]*i%mod;inv[i]=1ll*(mod-mod/i)*inv[mod%i]%mod;fi[i]=1ll*fi[i-1]*inv[i]%mod;}}
using namespace std;
inline void read(int &x)
{
char c;int f=1;
while(!isdigit(c=getchar()))if(c=='-')f=-1;
x=(c&15);while(isdigit(c=getchar()))x=(x<<1)+(x<<3)+(c&15);
x*=f;
}
const int mod=1e9+7;
int n,i,j,k,a[405],b[405],visa[405],visb[405],fac[405],inv[405],fi[405],ans,num[405][405],vis[405][405],dp[405][405],f[405][405][405],g[405];
int c(int x,int y)
{
if(x<y) return 0;
return 1ll*fac[x]*fi[y]%mod*fi[x-y]%mod;
}
int calc()
{
int i,j;
dp[1][2]=1;
fz1(i,n/3-1){
fz0g(j,i*2){
fz0g(k,j){
inc(dp[i+1][j+2-k],1ll*dp[i][j]*c(j,k)%mod*fac[k]%mod)
}
}
}
int ans=0;
fz0g(i,n/3*2){
inc(ans,1ll*dp[n/3][i]*fac[i]%mod)
}
return ans;
}
int main()
{
fac_init(400)
read(n);
fz1(i,n){
read(a[i]);
}
fz1(i,n){
read(b[i]);
}
fz1(i,n){
visa[a[i]]=1;
num[i][0]=i;
memset(visb,0,sizeof(visb));
fz1(j,n){
visb[b[j]]=1;
num[i][j]=num[i][j-1]+(!visa[b[j]]);
if(!visa[b[j]]&&!visb[a[i]]){
vis[i][j]=1;
}
}
}
fd1(k,n/3){
memset(g,0,sizeof(g));
fd1(i,n){
int s=(k==n/3);
fd1(j,n){
if(vis[i][j]){
f[k][i][j]=1ll*s*(k*3-num[i][j])%mod;
}
inc(s,g[j])
inc(g[j],f[k+1][i][j])
}
}
}
int s=0;
fz1(i,n)fz1(j,n){
inc(s,f[1][i][j])
}
cout<<1ll*s*calc()%mod<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e17;
long long MOD = 1e9 + 7;
long double eps = 1e-15;
long long m[100008];
pair<long long, long long> dp[41][100005];
bool vis[100005];
long long a, b;
long long n;
pair<long long, long long> DP(long long x, long long sum) {
if (sum >= a) return {0, sum};
if (x >= 40) return {INF, INF};
if (x == n) return {INF, INF};
pair<long long, long long> &ret = dp[x][sum];
if (ret.first != -1) return ret;
ret = DP(x + 1, sum);
pair<long long, long long> p = DP(x + 1, sum * m[x]);
p.first++;
if (p.first < ret.first) ret = p;
if (p.first == ret.first && p.second <= ret.second) ret = p;
return ret;
}
void fs(long long x, long long sum) {
if (sum >= a) return;
pair<long long, long long> ret = DP(x, sum);
if (ret == DP(x + 1, sum)) {
fs(x + 1, sum);
} else {
vis[x] = 1;
fs(x + 1, sum * m[x]);
}
}
long long solve(long long h, long long w) {
memset(dp, -1, sizeof(dp));
memset(vis, 0, sizeof(vis));
pair<long long, long long> p = DP(0, h);
if (p.first > n) return INF;
fs(0, h);
long long res = p.first;
for (int i = 0; w < b && i < 40; i++) {
if (vis[i]) continue;
res++;
w *= m[i];
}
if (w < b) return INF;
return res;
}
int main() {
long long h, w;
cin >> a >> b >> h >> w >> n;
for (int i = 0; i < n; i++) cin >> m[i];
sort(m, m + n);
reverse(m, m + n);
long long r1 = solve(h, w);
long long r2 = solve(w, h);
r1 = min(r1, r2);
swap(a, b);
r1 = min(r1, min(solve(h, w), solve(w, h)));
if (r1 > n)
cout << -1;
else
cout << r1;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1005;
const int U = 700;
const int S = 305;
const int L = 1e6 + 5;
const int dx[4] = {0, 1, 0, -1};
const int dy[4] = {1, 0, -1, 0};
const int ch[4] = {'U', 'R', 'D', 'L'};
int block[N][N], last[N][N];
pair<int, int> q[N * N];
void go(int x, int y, int S, int T, int *path) {
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) last[i][j] = -1;
last[x][y] = 4;
int head = 0, tail = 0;
q[0] = pair<int, int>(x, y);
for (; head <= tail && last[S][T] < 0; ++head) {
int nx = q[head].first, ny = q[head].second;
for (int i = 0; i < 4; i++) {
int xx = nx + dx[i], yy = ny + dy[i];
if (xx < 0 || yy < 0 || xx >= N || yy >= N) continue;
if (block[xx][yy] || last[xx][yy] >= 0) continue;
last[xx][yy] = i, q[++tail] = pair<int, int>(xx, yy);
}
}
if (last[S][T] < 0) {
path[0] = -1;
return;
}
path[0] = 0;
for (int tp; !(S == x && T == y);) {
path[++path[0]] = tp = last[S][T];
S -= dx[tp], T -= dy[tp];
}
for (int i = 1; i + i <= path[0]; i++) swap(path[i], path[path[0] - i + 1]);
}
void sgo(int &x, int &y, int *path, int *spath) {
spath[0] = 0;
for (int i = 1; i <= path[0]; i++) {
int xx = x + dx[path[i]], yy = y + dy[path[i]];
if (xx > 0 && yy > 0 && xx < N && yy < N && block[xx][yy])
;
else
x = xx, y = yy, spath[++spath[0]] = path[i];
}
}
int sx, sy, tx, ty, K;
int blx[N], bly[N];
int sp[L], spl[L], ans[L];
void ad(int x) { ans[++ans[0]] = x; }
void outgo() {
ans[0] = 0;
for (int i = 1; i <= sp[0]; i++) ans[++ans[0]] = sp[i];
sx = U - 1, sy = U - 1, sgo(tx, ty, sp, spl);
go(tx, ty, U - 1, U - 1, sp);
for (int i = 1; i <= sp[0]; i++) ans[++ans[0]] = sp[i];
tx = U - 1, ty = U - 1, sgo(sx, sy, sp, spl);
if (sx <= tx && sy <= ty) {
int bx(N), by(N);
for (int i = 1; i <= K; i++)
if (bly[i] < by || (bly[i] == by && blx[i] < bx))
bx = blx[i], by = bly[i];
for (int i = 0; i < ty - by + 1; i++) ad(2);
for (int i = 0; i < tx - bx; i++) ad(3);
for (int i = 0; i < ty - sy; i++) ad(0);
ad(3), ad(0);
for (int i = 0; i < tx - sx; i++) ad(1);
} else if (sx <= tx && sy > ty) {
int bx(N), by(0);
for (int i = 1; i <= K; i++)
if (bly[i] > by || (bly[i] == by && blx[i] < bx))
bx = blx[i], by = bly[i];
for (int i = 0; i < tx - bx; i++) ad(3);
for (int i = 0; i < sy - by - 1; i++) ad(2);
ad(3), ad(2);
for (int i = 0; i < tx - sx; i++) ad(1);
} else if (sx > tx && sy <= ty) {
int bx(0), by(N);
for (int i = 1; i <= K; i++)
if (bly[i] < by || (bly[i] == by && blx[i] > bx))
bx = blx[i], by = bly[i];
for (int i = 0; i < ty - by + 1; i++) ad(2);
for (int i = 0; i < tx - bx; i++) ad(3);
for (int i = 0; i < ty - sy; i++) ad(0);
ad(1), ad(0);
for (int i = 0; i < sx - tx; i++) ad(3);
} else {
int bx(0), by(0);
for (int i = 1; i <= K; i++)
if (bly[i] > by || (bly[i] == by && blx[i] > bx))
bx = blx[i], by = bly[i];
for (int i = 0; i < tx - bx; i++) ad(3);
for (int i = 0; i < sy - by - 1; i++) ad(2);
ad(1), ad(2);
for (int i = 0; i < sx - tx; i++) ad(3);
}
}
void chasing() {
ans[0] = 0, go(sx, sy, tx, ty, sp);
for (; !(sx == tx && sy == ty);) {
for (int i = 1; i <= sp[0]; i++) ans[++ans[0]] = sp[i];
sx = tx, sy = ty, sgo(tx, ty, sp, spl);
for (int i = 0; i <= spl[0]; i++) sp[i] = spl[i];
}
}
int main() {
while (scanf("%d%d%d%d%d", &sx, &sy, &tx, &ty, &K) > 0) {
sx += S, sy += S, tx += S, ty += S;
memset(block, 0, sizeof(int) * N * N);
for (int i = 1, x, y; i <= K; i++)
scanf("%d%d", &x, &y), block[x + S][y + S] = 1, blx[i] = x + S,
bly[i] = y + S;
if (!K || (go(sx, sy, tx, ty, sp), sp[0] < 0)) {
puts("-1");
continue;
}
if ((go(sx, sy, U - 1, U - 1, sp), sp[0] < 0))
chasing();
else
outgo();
for (int i = 1; i <= ans[0]; i++) printf("%c", ch[ans[i]]);
puts("");
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
long long b[n + 1], a[n + 1];
for (long long i = 1; i <= n; i++) {
cin >> b[i];
}
a[1] = b[1];
long long maxn = a[1];
for (long long i = 2; i <= n; i++) {
maxn = max(maxn, a[i - 1]);
a[i] = b[i] + maxn;
}
for (long long i = 1; i <= n; i++) {
cout << a[i] << " ";
}
}
| 2 |
#include<iostream>
using namespace std;
int main()
{
int n;
cin>>n;
if(n<1200)cout<<"ABC";
else if(n<2800)cout<<"ARC";
else cout<<"AGC";
return(0);
} | 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
const int maxN = 110000;
int n, m, a[maxN];
int killers[maxN], nonkillers[maxN];
int candidates[maxN];
int main() {
scanf("%d%d", &n, &m);
int s = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
if (a[i] > 0) {
++killers[a[i]];
} else {
++nonkillers[-a[i]];
++s;
}
}
int cnt = 0;
for (int i = 1; i <= n; ++i) {
int score = killers[i] + (s - nonkillers[i]);
if (score == m) {
candidates[i] = true;
++cnt;
}
}
for (int i = 1; i <= n; ++i) {
bool isT = false;
bool isF = false;
if (a[i] > 0) {
if (candidates[a[i]]) {
isT = true;
if (cnt > 1) {
isF = true;
}
} else {
isF = true;
}
} else {
if (!candidates[-a[i]]) {
isT = true;
} else {
isF = true;
if (cnt > 1) {
isT = true;
}
}
}
if (isT && isF) {
printf("Not defined\n");
} else if (isT) {
printf("Truth\n");
} else {
printf("Lie\n");
}
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin>>a>>a>>b;
cout<<((a*10+b)%4==0?"YES":"NO")<<endl;
return 0;
}
| 0 |
#include <stdio.h>
constexpr int N = 1e5;
char vS[N+3], vT[N+3];
constexpr short K = 'A' - 1;
int main(void){
int i, q;char c1, c2;
scanf("%s%s", vS+1, vT+1);
vS[0] = 0; i = 1; while(vS[i] != '\0') {(vS[i] += vS[i-1] - K) %= 3; i++;}
vT[0] = 0; i = 1; while(vT[i] != '\0') {(vT[i] += vT[i-1] - K) %= 3; i++;}
scanf("%d", &q);
while(q--){
int a, b, c, d; scanf("%d%d%d%d", &a, &b, &c, &d); a--; c--;
c1 = (vS[b] - vS[a] + 3) % 3;
c2 = (vT[d] - vT[c] + 3) % 3;
puts(c1 == c2 ? "YES" : "NO");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y, step;
} que[100005 * 2];
int n, k;
int vis[2][100005], dir[3][2] = {{1, 0}, {-1, 0}};
char wall[2][100005];
bool bfs() {
int f, r;
node p, q;
memset(vis, 0, sizeof(vis));
dir[2][0] = k;
dir[2][1] = 1;
f = 0, r = 1;
while (f < r) {
p = que[f++];
for (int i = 0; i < 3; i++) {
q.x = p.x + dir[i][0];
q.y = p.y + dir[i][1];
q.y %= 2;
if (q.x > p.step) {
if (q.x >= n) return 1;
q.step = p.step + 1;
if (wall[q.y][q.x] != 'X' && !vis[q.y][q.x]) {
vis[q.y][q.x] = 1;
que[r++] = q;
}
}
}
}
return 0;
}
int main() {
cin >> n >> k;
cin >> wall[0] >> wall[1];
if (bfs())
cout << "YES" << endl;
else
cout << "NO" << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3f;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
long long n;
cin >> n;
long long a = 0, b = 0;
long long ans = 0;
vector<pair<long long, long long> > v(n);
for (long long i = 0; i < n; i++) {
long long x, y;
cin >> x >> y;
v[i] = {x, y};
if (x == y) --ans;
if (y < a || b > x) {
a = x;
b = y;
} else {
long long l = max(a, b), r = min(x, y);
ans += (r - l + 1);
a = x;
b = y;
}
}
if (v[n - 1].first == v[n - 1].second) ++ans;
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e6 + 5;
int par[mx], rnk[mx];
void init(int n) {
for (int i = 0; i < n; i++) par[i] = i, rnk[i] = 0;
}
int find(int x) {
if (par[x] == x)
return x;
else
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y) return;
if (rnk[x] < rnk[y])
par[x] = y;
else {
par[y] = x;
if (rnk[x] == rnk[y]) rnk[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
int main() {
int n, m;
scanf("%d %d", &n, &m);
init(n + 1);
map<int, vector<pair<int, int>>> edge;
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d %d %d", &u, &v, &w);
u--;
v--;
edge[w].push_back({u, v});
}
int ret = 0;
vector<pair<int, int>> cur;
for (auto &it : edge) {
cur.clear();
for (auto &x : it.second)
if (!same(x.first, x.second)) cur.push_back(x);
for (auto &x : cur)
if (!same(x.first, x.second))
unite(x.first, x.second);
else
ret++;
}
printf("%d\n", ret);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int nm = 100010;
const long long inf = 1000000000;
int n;
map<int, int> vt;
vector<pair<int, int> > xxx;
vector<int> total;
set<int> val;
map<int, int> newval;
int tree[2 * nm];
int demBeHon(int x) {
int l = 0, r = (int)total.size() - 1, kq = total.size();
while (l <= r) {
int mid = (l + r) >> 1;
if (xxx[mid].second < x) {
kq = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (kq == 0) return total.size() > 0 ? total.back() : 0;
long long res = total.back() - total[kq - 1];
if (kq >= 1 && xxx[kq - 1].first < x) res += x - xxx[kq - 1].first;
return res;
}
int demLonHon(int x) {
int l = 0, r = (int)total.size() - 1, kq = total.size();
while (l <= r) {
int mid = (l + r) >> 1;
if (xxx[mid].second > x) {
kq = mid;
r = mid - 1;
} else
l = mid + 1;
}
if (kq == 0) return total.size() > 0 ? total.back() : 0;
long long res = total.back() - total[kq - 1];
if (kq >= 1 && xxx[kq - 1].second > x) res += xxx[kq - 1].second - x;
return res;
}
int get(int i) {
int res = 0;
while (i > 0) {
res += tree[i];
i -= i & (-i);
}
return res;
}
void update(int i) {
while (i < nm + nm) {
tree[i]++;
i += i & (-i);
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
int u, v;
scanf("%d%d", &u, &v);
int tmp = vt[u];
if (!tmp) {
tmp = u;
val.insert(u);
}
int tmp2 = vt[v];
if (!tmp2) {
tmp2 = v;
val.insert(v);
}
vt[u] = tmp2;
vt[v] = tmp;
}
int cnt = 0;
for (set<int>::iterator it = val.begin(); it != val.end(); ++it) {
cnt++;
newval[*it] = cnt;
}
long long res = 0;
int next = inf;
for (map<int, int>::reverse_iterator it = vt.rbegin(); it != vt.rend();
++it) {
int i = it->first, x = it->second;
if (i + 1 <= next) {
xxx.push_back(make_pair(i + 1, next));
if (total.size() == 0)
total.push_back(next - i);
else
total.push_back(total.back() + next - i);
}
long long tmp = demBeHon(x);
res += tmp;
next = it->first - 1;
res += (long long)get(newval[x] - 1);
update(newval[x]);
}
next = 1;
xxx.clear();
total.clear();
for (map<int, int>::iterator it = vt.begin(); it != vt.end(); ++it) {
int i = it->first, x = it->second;
if (i - 1 >= next) {
xxx.push_back(make_pair(next, i - 1));
if (total.size() == 0)
total.push_back(i - next);
else
total.push_back(total.back() + i - next);
}
long long tmp = demLonHon(x);
res += tmp;
next = it->first + 1;
}
cout << res << "\n";
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
void chmax(T& a, T b) {
a = max(a, b);
}
template <class T>
void chmin(T& a, T b) {
a = min(a, b);
}
int dpl[4320][4320];
int dpr[4320][4320];
int ls, rs;
int n, p, c, h, t, qq, a, b;
vector<pair<int, int> > add[21600], del[21600], query[21600];
int ans[21600];
queue<pair<int, int> > q;
int main() {
cin >> n >> p;
for (int i = 0; i < n; i++) {
cin >> c >> h >> t;
add[t].push_back(pair<int, int>(c, h));
del[t + p].push_back(pair<int, int>(c, h));
}
cin >> qq;
for (int i = 0; i < qq; i++) {
cin >> a >> b;
query[a].push_back(pair<int, int>(b, i));
}
for (int i = 1; i <= 20000; i++) {
for (int j = 0; j < add[i].size(); j++) {
c = add[i][j].first;
h = add[i][j].second;
for (int k = 0; k <= 4320; k++) {
if (k - c < 0)
dpr[rs + 1][k] = dpr[rs][k];
else
dpr[rs + 1][k] = max(dpr[rs][k], dpr[rs][k - c] + h);
}
rs++;
q.push(pair<int, int>(c, h));
}
for (int j = 0; j < del[i].size(); j++) {
if (ls == 0) {
vector<pair<int, int> > tmp;
while (!q.empty()) {
tmp.push_back(q.front());
q.pop();
}
for (int k = tmp.size() - 1; k >= 0; k--) {
c = tmp[k].first;
h = tmp[k].second;
for (int l = 0; l <= 4320; l++) {
if (l - c < 0)
dpl[ls + 1][l] = dpl[ls][l];
else
dpl[ls + 1][l] = max(dpl[ls][l], dpl[ls][l - c] + h);
}
ls++;
}
rs = 0;
}
ls--;
}
for (int j = 0; j < query[i].size(); j++) {
b = query[i][j].first;
int ind = query[i][j].second;
int& res = ans[ind];
for (int k = 0; k <= b; k++) {
res = max(res, dpl[ls][k] + dpr[rs][b - k]);
}
}
}
for (int i = 0; i < qq; i++) {
cout << ans[i] << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const long long int mod = (long long int)1e9 + 7;
const long long int inf = 1e18;
int solve() {
long long int n;
cin >> n;
vector<long long int> v(n + 11);
for (long long int i = 2; i <= n; i++) {
cin >> v[i];
}
vector<long long int> ans;
while (n > 0) {
ans.push_back(n);
n = v[n];
}
sort((ans).begin(), (ans).end());
for (auto it : ans) {
cout << it << " ";
}
cout << "\n";
return 0;
}
int main() {
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
typedef long long ll;
typedef pair<int,int>P;
const int INF=0x3f3f3f3f;
const ll INFL=0x3f3f3f3f3f3f3f3f;
const int MOD=1000000007;
ll dp[200][2][5];
int main(){
string s;int K;cin>>s>>K;
dp[0][0][0]=1;
rep(i,s.size())rep(j,2)rep(k,K+1){
int lim=(j?9:s[i]-'0');
for(int t=0;t<=lim;t++){
dp[i+1][j||t<lim][k+(t>0)]+=dp[i][j][k];
}
}
ll ans=0;
rep(i,2){
ans+=dp[s.size()][i][K];
}
cout<<ans<<endl;
} | 0 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int N = 1 << 6 | 1;
const int inf = 0x3f3f3f3f;
const long long oo = 0x3f3f3f3f3f3f3f3fll;
int n, m;
int dp[41][N][N], w[N];
int dfs(int a, int nw, int sp) {
if (a == n + 1) return (sp == 0) ? 0 : inf;
int &ret = dp[a][nw][sp];
if (ret + 1) return ret;
ret = inf;
for (int i = 0; i < (1 << m); i++) {
int nx = sp | i;
int ns = nx | (nx << 1) | (nx >> 1) | nw;
ns = (~ns) & ((1 << m) - 1);
ret = min(ret, dfs(a + 1, nx, ns) + w[nx]);
}
return ret;
}
int main() {
for (int i = 1; i < N; i++)
if ((i & (-i)) != i)
w[i] = w[i ^ (i & (-i))] + 1;
else
w[i] = 1;
scanf("%d%d", &n, &m);
if (n < m) swap(m, n);
memset(dp, -1, sizeof(dp));
cout << n * m - dfs(1, 0, 0) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, width[201010], height[201010],
max1 = 0, i, max2 = 0, prefeixsum[201010], flag = 0, wid, hit, ans;
cin >> n;
width[0] = 0;
for (i = 1; i <= n; i++) cin >> width[i] >> height[i];
max1 = height[1];
long long pos = 1;
for (i = 2; i <= n; i++) {
if (height[i] > max1) {
pos = i;
max1 = height[i];
}
}
for (i = 1; i <= n; i++) {
if ((i != pos) && (height[i] > max2)) max2 = height[i];
}
for (i = 1; i <= n; i++) width[i] += width[i - 1];
for (i = 1; i <= n; i++) {
wid = width[n] - width[i] + width[i - 1];
if (height[i] < max1)
hit = max1;
else if (height[i] == max1)
hit = max2;
ans = wid * hit;
cout << ans << " ";
}
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
int x, y;
string s;
class SegmentTree {
private:
vector<int> st, a, b, c;
int left(int p) { return (p << 1); }
int right(int p) { return (p << 1) + 1; }
void build(int p, int l, int r) {
if (l == r) {
if (s[l] == '(') {
st[p] = 0;
a[p] = 0;
b[p] = 1;
c[p] = 0;
} else {
st[p] = 0;
a[p] = 0;
b[p] = 0;
c[p] = 1;
}
} else {
build(left(p), l, (l + r) / 2);
build(right(p), (l + r) / 2 + 1, r);
int t = min(b[left(p)], c[right(p)]);
a[p] = a[left(p)] + a[right(p)] + t;
b[p] = b[left(p)] + b[right(p)] - t;
c[p] = c[left(p)] + c[right(p)] - t;
}
}
public:
SegmentTree() {
st.assign(n * 4, 0);
a.assign(n * 4, 0);
b.assign(n * 4, 0);
c.assign(n * 4, 0);
build(1, 0, n - 1);
}
pair<int, pair<int, int> > query(int p, int l, int r) {
if (l > r || l > y || r < x) {
return pair<int, pair<int, int> >(0, pair<int, int>(0, 0));
}
if (l >= x && r <= y) {
return pair<int, pair<int, int> >(a[p], pair<int, int>(b[p], c[p]));
}
int mid = (l + r) / 2;
pair<int, pair<int, int> > f1 = query(left(p), l, mid);
pair<int, pair<int, int> > f2 = query(right(p), mid + 1, r);
int tmp = min(f1.second.first, f2.second.second);
pair<int, pair<int, int> > ans;
ans.first = f1.first + f2.first + tmp;
ans.second.first = f1.second.first + f2.second.first - tmp;
ans.second.second = f1.second.second + f2.second.second - tmp;
return ans;
}
};
int main() {
cin >> s;
n = s.size();
SegmentTree st;
cin >> m;
while (m--) {
cin >> x >> y;
x--, y--;
cout << 2 * st.query(1, 0, n - 1).first << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
long long x, y, n, i, ans;
typedef struct {
long long a, b;
} pp;
pp p[N];
bool compa(pp ta, pp tb) {
return abs(ta.a) + abs(ta.b) < abs(tb.a) + abs(tb.b);
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (i = 0; i < n; i++) {
cin >> p[i].a >> p[i].b;
if (p[i].a) ans += 2;
if (p[i].b) ans += 2;
ans += 2;
}
cout << ans << '\n';
sort(p, p + n, compa);
for (i = 0; i < n; i++) {
x = p[i].a;
y = p[i].b;
if (x > 0) cout << "1 " << x << " R" << '\n';
if (x < 0) cout << "1 " << -x << " L" << '\n';
if (y > 0) cout << "1 " << y << " U" << '\n';
if (y < 0) cout << "1 " << -y << " D" << '\n';
cout << 2 << '\n';
if (x > 0) cout << "1 " << x << " L" << '\n';
if (x < 0) cout << "1 " << -x << " R" << '\n';
if (y > 0) cout << "1 " << y << " D" << '\n';
if (y < 0) cout << "1 " << -y << " U" << '\n';
cout << 3 << '\n';
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e7 + 5;
const int maxn = 1e4 + 5;
int main() {
int i, j, k, l, n, temp[maxn];
while (scanf("%d", &n) != EOF) {
for (i = 1; i <= n; i++) {
k = 0;
for (j = i; j <= (n * n / 2); j += n) {
if (j == i)
printf("%d", j);
else
printf(" %d", j);
temp[k++] = n * n + 1 - j;
}
for (l = n / 2 - 1; l >= 0; l--) {
printf(" %d", temp[l]);
}
printf("\n");
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<pair<int, int>> a;
for (int i = 0; i < n; i++) {
int t1, t2;
scanf("%d %d", &t1, &t2);
a.push_back(make_pair(t1, t2));
}
sort(a.begin(), a.end());
int ans = 0, mx = a[0].second;
for (int i = 1; i < n; i++) {
if (a[i].second > mx)
mx = a[i].second;
else
ans++;
}
cout << ans;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define FOR(i,a,b) for(int i=int(a);i<int(b);i++)
#define REP(i,b) FOR(i,0,b)
using vi=vector<int>;
#define PB push_back
#define ALL(x) x.begin(),x.end()
//#define LN cerr<<__LINE__<<endl
#define LN 0
using pi=pair<int,int>;
int read(){
int i;
scanf("%d",&i);
return i;
}
void chmin(int&a,int b){
a=a<b?a:b;
}
void chmax(int&a,int b){
a=a>b?a:b;
}
struct SegTree{
vi buf;
int s;
SegTree(int n){
s=1;
while(s<n)s*=2;
buf.resize(s*2,-1);
}
void Update(int i,int v){
i+=s;
buf[i]=v;
while((i/=2)>=1)buf[i]=max(buf[i*2],buf[i*2+1]);
}
int GetIdx(int b,int e,int t,vi&dst,int l,int r,int i){
if(buf[i]<=t||e<=l||r<=b)return t;
if(b<=l&&r<=e){
if(l+1==r){
if(t<buf[i])dst.PB(l);
return max(t,buf[i]);
}else{
if(t<buf[i*2])
t=GetIdx(b,e,t,dst,l,(l+r)/2,i*2);
if(t<buf[i*2+1])
t=GetIdx(b,e,t,dst,(l+r)/2,r,i*2+1);
return t;
}
}
t=GetIdx(b,e,t,dst,l,(l+r)/2,i*2);
t=GetIdx(b,e,t,dst,(l+r)/2,r,i*2+1);
return t;
}
void GetIdx(int b,int e,vi& dst){
GetIdx(b,e,-1,dst,0,s,1);
}
};
inline int xorshift(){
static int w=1145141919;
w=w^(w<<17);
w=w^(w>>13);
w=w^(w<<5);
return w;
}
struct Node{
Node *l,*r;
int v,s;
} buf[200010];
Node* Merge(Node*a,Node*b){
if(!a)return b;
if(!b)return a;
int s=a->s+b->s,x=xorshift()%s;
if(x<a->s){
a->r=Merge(a->r,b);
a->s=s;
return a;
}else{
b->l=Merge(a,b->l);
b->s=s;
return b;
}
}
using pn=pair<Node*,Node*>;
pn Split(Node*x,int t){
if(!x)return pn(0,0);
if(t<=x->v){
pn c=Split(x->l,t);
if(c.first)x->s-=c.first->s;
x->l=c.second;
return pn(c.first,x);
}else{
pn c=Split(x->r,t);
if(c.second)x->s-=c.second->s;
x->r=c.first;
return pn(x,c.second);
}
}
int MaxValue(Node* x){
while(x->r)x=x->r;
return x->v;
}
void Show(Node* x){
if(!x)return;
Show(x->l);
cerr<<x->v<<" ";
Show(x->r);
}
int main(){
int n=read();
SegTree seg(n*2);
vector<Node*> trs(n*2);
vi mx(n*2,-1);
REP(i,n){
int x=read()-1;
seg.Update(i,x);
trs[i]=buf+i;
trs[i]->v=x;
trs[i]->s=1;
mx[i]=x;
}
vi idx;
FOR(i,n,n*2){
idx.clear();
seg.GetIdx(0,i,idx);
int last=-1;
Node*x=0;
for(auto j:idx){
LN;
pn c=Split(trs[j],last);
LN;
last=mx[j];
LN;
if(c.first)
mx[j]=MaxValue(c.first);
else
mx[j]=-1;
LN;
seg.Update(j,mx[j]);
LN;
trs[j]=c.first;
LN;
x=Merge(x,c.second);
LN;
}
if(x->s==n){
cout<<i-n<<endl;
return 0;
}
mx[i]=last;
seg.Update(i,mx[i]);
trs[i]=x;
//Show(x);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t, n, x, a, b;
cin >> t;
while (t--) {
int d;
cin >> n >> x >> a >> b;
if (a > b) {
d = a;
a = b;
b = d;
}
if ((a - 1) > x) {
a -= x;
x = 0;
} else {
x -= (a - 1);
a = 1;
}
if (n - b > x) {
b += x;
x = 0;
} else {
x -= (n - b);
b = n;
}
cout << b - a << '\n';
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct node {
node *next;
int nodeIndex;
node(node *next, int index) {
this->next = next;
this->nodeIndex = index;
}
};
node *nodeArr[300001];
vector<int> path;
void pathDfs(int x, int y, bool *visited, bool &pathFound) {
node *src = nodeArr[x];
visited[src->nodeIndex] = true;
path.push_back(x);
if (x == y) {
pathFound = true;
return;
}
while (src != NULL) {
if (src->next && !visited[src->next->nodeIndex] && !pathFound) {
pathDfs(src->next->nodeIndex, y, visited, pathFound);
}
if (pathFound) {
return;
}
src = src->next;
}
path.pop_back();
}
void removeEdge(int a, int b) {
node *root = nodeArr[a];
while (true) {
if (root->next->nodeIndex == b) {
root->next = root->next->next;
return;
}
root = root->next;
}
}
void individualDFS(int a, long long &count, bool *visited) {
node *src = nodeArr[a];
visited[src->nodeIndex] = true;
count++;
while (src != NULL) {
if (src->next && !visited[src->next->nodeIndex]) {
individualDFS(src->next->nodeIndex, count, visited);
}
src = src->next;
}
}
void removeEdges() {
if (path.size() == 2) {
removeEdge(path[0], path[1]);
removeEdge(path[1], path[0]);
} else {
removeEdge(path[0], path[1]);
removeEdge(path[1], path[0]);
removeEdge(path[path.size() - 2], path[path.size() - 1]);
removeEdge(path[path.size() - 1], path[path.size() - 2]);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, x, y;
cin >> n >> x >> y;
for (int i = 1; i <= n; i++) {
nodeArr[i] = new node(NULL, i);
}
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
node *tempNode = new node(NULL, b);
node *root = nodeArr[a];
while (true) {
if (root->next == NULL) {
root->next = tempNode;
break;
}
root = root->next;
}
tempNode = new node(NULL, a);
root = nodeArr[b];
while (true) {
if (root->next == NULL) {
root->next = tempNode;
break;
}
root = root->next;
}
}
bool visited[300001];
bool pathFound = false;
vector<int> path;
for (int i = 1; i <= n; i++) {
visited[i] = false;
}
pathDfs(x, y, visited, pathFound);
removeEdges();
long long firstCount = 0;
for (int i = 1; i <= n; i++) {
visited[i] = false;
}
individualDFS(x, firstCount, visited);
long long secondCount = 0;
for (int i = 1; i <= n; i++) {
visited[i] = false;
}
individualDFS(y, secondCount, visited);
long long N = (long long)n;
cout << N * (N - 1) - firstCount * secondCount << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int main() {
int t;
scanf("%d", &t);
while (t--) {
int n;
scanf("%d", &n);
int k;
int a[n];
for (k = 0; k < n; k++) scanf("%d", &a[k]);
int p = n - 2;
int i, j;
for (i = 0; i < p; i++) {
for (j = i + 2; j < n; j++) {
if (a[i] == a[j]) {
printf("YES\n");
break;
}
}
if (a[i] == a[j]) {
break;
}
}
if (a[i] == a[j]) continue;
printf("NO\n");
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int gi() {
int x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 3) + (x << 1) + ch - 48;
ch = getchar();
}
return x * f;
}
template <typename T>
inline bool Max(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
template <typename T>
inline bool Min(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
const int N = 2e5 + 7, inf = 0x3f3f3f3f;
const double INF = 1.0 * 1e17;
int n, m, edc = 1, ndc;
int rt, mxs, sn;
int vis[N << 2], head[N], h2[N], son[N];
struct edge {
int lst, to, k, b;
edge() {}
edge(int lst, int to, int k, int b) : lst(lst), to(to), k(k), b(b) {}
} e[N << 2];
void Add(int u, int v, int k, int b) {
e[++edc] = edge(head[u], v, k, b), head[u] = edc;
e[++edc] = edge(head[v], u, k, b), head[v] = edc;
}
void Add2(int u, int v, int k, int b) {
e[++edc] = edge(h2[u], v, k, b), h2[u] = edc;
e[++edc] = edge(h2[v], u, k, b), h2[v] = edc;
}
void build(int l, int r, int fa, vector<edge> &vt) {
if (l == r) {
Add(fa, vt[l].to, vt[l].k, vt[l].b);
return;
}
int mid = l + r >> 1, o = vt.size() - 1 == r ? fa : ++ndc;
build(l, mid, o, vt);
build(mid + 1, r, o, vt);
if (o > n) Add(fa, o, 0, 0);
}
void dfs0(int u, int fa) {
vector<edge> vt;
for (int i = h2[u], v = e[i].to; i; i = e[i].lst, v = e[i].to)
if (v ^ fa) {
dfs0(v, u);
vt.push_back(e[i]);
}
if (vt.size() <= 2) {
for (int i = 0; i < vt.size(); ++i) Add(u, vt[i].to, vt[i].k, vt[i].b);
} else
build(0, vt.size() - 1, u, vt);
}
void getrt(int u, int fa) {
son[u] = 1;
for (int i = head[u], v = e[i].to; i; i = e[i].lst, v = e[i].to)
if (!vis[i] && v ^ fa) {
getrt(v, u);
son[u] += son[v];
if (Min(mxs, max(son[v], sn - son[v]))) rt = i;
}
}
struct Point {
long long x, y;
Point() {}
Point(long long x, long long y) : x(x), y(y) {}
bool operator<(const Point &rhs) const {
if (x != rhs.x) return x < rhs.x;
return y < rhs.y;
}
};
vector<Point> p;
Point operator+(Point a, Point b) { return Point(a.x + b.x, a.y + b.y); }
Point operator-(Point a, Point b) { return Point(a.x - b.x, a.y - b.y); }
int ff(long long x) {
if (x > 0) return 1;
if (x == 0) return 0;
if (x < 0) return -1;
}
const double eps = 1e-10;
int dcmp(double x) {
if (fabs(x) < eps) return 0;
return x < 0 ? -1 : 1;
}
int Cross(Point a, Point b) {
if (!(a.x * b.y) && !(a.y * b.x)) return 0;
if (!(a.x * b.y)) return -1 * ff(a.y) * ff(b.x);
if (!(a.y * b.x)) return ff(a.x) * ff(b.y);
if (dcmp(1.0 * a.x / b.x - 1.0 * a.y / b.y) == 0) return 0;
if (ff(b.x) * ff(b.y) > 0) {
return dcmp(1.0 * a.x / b.x - 1.0 * a.y / b.y) > 0 ? 1 : -1;
} else {
return dcmp(1.0 * a.x / b.x - 1.0 * a.y / b.y) < 0 ? 1 : -1;
}
}
vector<Point> ConvexHull(vector<Point> &p) {
if (p.empty()) return p;
sort(p.begin(), p.end());
vector<Point> stk;
stk.push_back(p[0]);
for (int i = 1; i < p.size(); ++i) {
while (stk.size() > 1 &&
Cross(stk[stk.size() - 1] - stk[stk.size() - 1 - 1],
p[i] - stk[stk.size() - 1]) <= 0)
stk.pop_back();
stk.push_back(p[i]);
}
int k = stk.size();
for (int i = (int)p.size() - 2; i >= 0; --i) {
while (stk.size() > k &&
Cross(stk[stk.size() - 1] - stk[stk.size() - 1 - 1],
p[i] - stk[stk.size() - 1]) <= 0)
stk.pop_back();
stk.push_back(p[i]);
}
if (stk.size() > 1) stk.pop_back();
return stk;
}
vector<Point> MinkowskiSum(vector<Point> A, vector<Point> B) {
if (A.empty()) return B;
if (B.empty()) return A;
vector<Point> C;
int n = A.size(), m = B.size();
A.push_back(A[0]), B.push_back(B[0]);
C.push_back(A[0] + B[0]);
if (n == 2 && m == 2 && Cross(A[1] - A[0], B[1] - B[0]) == 0) {
C.push_back(C[0] + (A[1] - A[0]) + (B[1] - B[0]));
sort(C.begin(), C.end());
return C;
}
for (int p1 = 0, p2 = 0; p1 < n || p2 < m;) {
if (p2 >= m ||
(p1 < n && Cross(A[p1 + 1] - A[p1], B[p2 + 1] - B[p2]) >= 0)) {
C.push_back(C.back() + (A[p1 + 1] - A[p1]));
++p1;
} else {
C.push_back(C.back() + (B[p2 + 1] - B[p2]));
++p2;
}
}
if (C.size() > 1) C.pop_back();
return C;
}
void getdep(int u, int fa, long long k, long long b, vector<Point> &p) {
if (u <= n) p.push_back(Point(k, b));
for (int i = head[u], v = e[i].to; i; i = e[i].lst, v = e[i].to)
if (!vis[i] && v ^ fa) {
getdep(v, u, k + e[i].k, b + e[i].b, p);
}
}
void solve(int sel) {
if (!sel) return;
vis[sel] = vis[sel ^ 1] = 1;
int a = e[sel].to, b = e[sel ^ 1].to;
vector<Point> A, B;
getdep(a, 0, e[sel].k, e[sel].b, A);
getdep(b, 0, 0, 0, B);
if (!A.empty() && !B.empty()) {
A = ConvexHull(A);
B = ConvexHull(B);
vector<Point> C = MinkowskiSum(A, B);
for (int i = 0; i < C.size(); ++i) p.push_back(C[i]);
}
int old = sn;
if (son[a] < son[b]) swap(a, b);
rt = 0, mxs = inf, sn = sn - son[b], getrt(a, 0), solve(rt);
rt = 0, mxs = inf, sn = son[b], getrt(b, 0), solve(rt);
}
long long f(Point a, int x) { return a.x * x + a.y; }
int main() {
n = gi(), m = gi();
if (n == 1) {
for (int i = 0; i <= m - 1; ++i) printf("%d%c", 0, i == m - 1 ? '\n' : ' ');
return 0;
}
ndc = n;
for (int i = 1; i <= n - 1; ++i) {
int u = gi(), v = gi(), k = gi(), b = gi();
Add2(u, v, k, b);
}
dfs0(1, 0);
rt = 0, mxs = inf, sn = ndc, getrt(1, 0), solve(rt);
p = ConvexHull(p);
for (int i = 0, j = p.size() - 1; i < m; ++i) {
while (j >= 1 && f(p[j - 1], i) >= f(p[j], i)) --j;
printf("%lld%c", p[j].x * i + p[j].y, i == m - 1 ? '\n' : ' ');
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
typedef vector<int> vi;
const int INF = 1e9;
//Segment Tree
class SegmentTree{
public:
int n;
vi node;
vi ofset;
SegmentTree(vi a){
int n_ = a.size();
n=1;
while(n<n_)n*=2;
node = vi(2*n-1, INF);
for(int i=0;i<n_;i++)node[i+n-1] = a[i];
for(int i=n-2;i>=0;i--)node[i] = min(node[2*i+1], node[2*i+2]);
ofset = vi(2*n-1,0);
}
//return minimum value in [a,b). ( [l,r) is interval in which k is.)
int rmq(int a,int b,int k=0,int l=0,int r=0){
if(l>=r)r = n;
if(r<=a || b<=l)return INF;
if(a<=l && r<=b)return node[k]+ofset[k];
int pl = rmq(a,b,2*k+1,l,(l+r)/2);
int pr = rmq(a,b,2*k+2,(l+r)/2,r);
return min(pl,pr) + ofset[k];
}
int search(int a,int b,int v,int k=0,int l=0,int r=0){
if(l>=r)r = n;
if(r<=a || b<=l)return INF;
if(a<=l && r<=b && node[k]+ofset[k] >= v)return l;
if(r-l<=1)return INF;
int vr = rmq(a,b,2*k+2,(l+r)/2,r);
if(vr + ofset[k] >= v){
int res = search(a,b,v-ofset[k],2*k+1,l,(l+r)/2);
return min(res, (l+r)/2);
}else{
int res = search(a,b,v-ofset[k],2*k+2,(l+r)/2,r);
return res;
}
}
int update_range(int a,int b,int v,int k=0,int l=0,int r=0){
if(l>=r)r = n;
if(r<=a || b<=l)return node[k];
if(a<=l && r<=b){
ofset[k] += v;
return node[k]+ofset[k];
}
int vl = update_range(a,b,v,2*k+1,l,(l+r)/2);
int vr = update_range(a,b,v,2*k+2,(l+r)/2,r);
node[k] = min(vl,vr);
return node[k]+ofset[k];
}
};
int main(){
cin.tie(0); ios::sync_with_stdio(0);
int n,q;
cin >> n >> q;
string s;
cin >> s;
set<int> minus;
vi h(n,1);
rep(i,n-1){
if(s[i+1] == '(')h[i+1] = h[i] + 1;
else{
h[i+1] = h[i] - 1;
minus.insert(i+1);
}
}
SegmentTree st(h);
while(q--){
int p;
cin >> p; p--;
if(s[p] == '('){
s[p] = ')';
minus.insert(p);
st.update_range(p,n,-2);
p = *minus.begin();
s[p] = '(';
minus.erase(p);
st.update_range(p,n,2);
}else{
s[p] = '(';
minus.erase(p);
st.update_range(p,n,2);
p = st.search(0,p+1,2);
s[p] = ')';
minus.insert(p);
st.update_range(p,n,-2);
}
cout << p+1 << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
vector<int> sosedi[maxn];
int parent[maxn], shagi[maxn], start[maxn], finish[maxn], n;
bool visit_vertex[maxn];
void dfs(int v, int predok) {
parent[v] = predok;
shagi[v] = shagi[predok] + 1;
for (auto p : sosedi[v])
if (p != predok) dfs(p, v);
}
vector<int> circles;
int rt, lp, lq;
bool find_circle() {
circles.clear();
int p = 0;
for (int i = 1; i <= n; i++)
if (start[i] != finish[i] && shagi[i] > shagi[p]) p = i;
if (!p) return 1;
for (int u = p; visit_vertex[u] = 1, circles.push_back(u),
start[parent[u]] != finish[parent[u]];
u = parent[u])
;
int q = 0;
for (int i = 1; i <= n; i++)
if (start[i] != finish[i] && !visit_vertex[i] && shagi[i] > shagi[q]) q = i;
if (q) {
reverse(circles.begin(), circles.end());
for (int u = q; visit_vertex[u] = 1, circles.push_back(u),
start[parent[u]] != finish[parent[u]];
u = parent[u])
;
} else
q = parent[circles.back()];
for (int i = 1; i <= n; i++)
if (start[i] != finish[i] && !visit_vertex[i]) return 0;
int u, v;
for (u = p, v = q; u != v; u = parent[u])
if (shagi[u] < shagi[v]) swap(u, v);
rt = u;
if (circles.size() != shagi[p] + shagi[q] - 2 * shagi[rt]) return 0;
lp = p, lq = q;
return 1;
}
int main() {
cin >> n;
int pa, pb;
for (int i = 1; i <= n; i++) {
cin >> start[i];
if (start[i] == 0) pa = i;
}
for (int i = 1; i <= n; i++) {
cin >> finish[i];
if (finish[i] == 0) pb = i;
}
for (int i = 1, u, v; i < n; i++) {
cin >> u >> v;
sosedi[u].push_back(v), sosedi[v].push_back(u);
}
shagi[0] = -1;
dfs(pb, 0);
for (int u = pa; u != pb; u = parent[u]) swap(start[u], start[parent[u]]);
long long ans = shagi[pa];
if (!find_circle()) {
printf("-1\n");
return 0;
}
if (!circles.size()) {
printf("0 %d\n", ans);
return 0;
}
int gap = 0, len = circles.size();
for (int i = 0; i < len; i++)
if (finish[circles[i]] == start[circles[0]]) gap = i;
for (int i = 1; i < len; i++)
if (finish[circles[(i + gap) % len]] != start[circles[i]]) {
printf("-1\n");
return 0;
}
memset(visit_vertex, false, maxn);
for (int i = pa; i; i = parent[i]) visit_vertex[i] = 1;
if (visit_vertex[circles[0]] || visit_vertex[circles.back()]) {
int po = circles.size();
for (int i = 0; i < circles.size(); i++)
if (!visit_vertex[circles[i]]) {
po = i;
break;
}
ans = ans - po +
min(po + gap * 1ll * (len + 1),
abs((len - gap) * 1ll * (len + 1) - po));
} else
ans = (ans + min(gap, len - gap) * 1ll * (len + 1));
for (; !visit_vertex[rt]; rt = parent[rt]) ans += 2;
if (lp > lq) swap(lq, lp);
printf("%d %d %lld\n", lp, lq, ans);
return 0;
}
| 6 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.