solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
#define int long long
const int fx=55,nax=2005;
int f[fx][nax]={1},s[fx][nax]={1},n,mod,res[fx];
int32_t main()
{
cin>>n>>mod;
for(int i=1;i<=n*(n-1)/2;i++)
s[0][i]=1;
for(int i=1;i<=n;i++)
for(int j=0;j<=n*(n-1)/2;j++)
{
if(j-i>=0)
f[i][j]=(s[i-1][j]-s[i-1][j-i]+mod)%mod;
else
f[i][j]=s[i-1][j];
s[i][j]=((j?s[i][j-1]:0)+f[i][j])%mod;
}
for(int i=1;i<=n;i++)
for(int j=1;j<=i;j++)
for(int k=j+1;k<=i;k++)
for(int w=0;w<=(i-1)*(i-2)/2;w++)
{
int cur=w-(k-j)-1;
if(cur<0)
continue;
res[i]=(res[i]+f[i-1][w]*s[i-1][cur]%mod)%mod;
}
for(int i=2;i<=n;i++)
res[i]=(res[i]+i*res[i-1])%mod;
cout<<res[n];
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int maxn = 200005, maxk = 105;
int n, maxx, cnt, ans;
int a[maxn], tot[maxk], sum[maxn], t[maxn * 2];
inline int min(int a, int b) { return a < b ? a : b; }
inline int max(int a, int b) { return a > b ? a : b; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
tot[a[i]]++;
}
for (int i = 1; i <= 100; i++) {
if (tot[i] == maxx) cnt++;
if (tot[i] > maxx) cnt = 1, maxx = tot[i];
}
if (cnt > 1) {
printf("%d\n", n);
return 0;
}
for (int i = 1; i <= 100; i++)
if (tot[i] == maxx) {
maxx = i;
break;
}
for (int i = 1; i <= 100; i++) {
for (int j = 1; j <= n; j++)
sum[j] = sum[j - 1] + (a[j] == i ? -1 : (a[j] == maxx ? 1 : 0));
for (int j = -n; j <= n; j++) t[n + j] = 1000000000;
for (int j = 1; j <= n; j++) {
ans = max(ans, j - t[n + sum[j]] + 1);
t[n + sum[j - 1]] = min(t[n + sum[j - 1]], j);
}
}
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void printImpl(const vector<T>& coll) {
copy(coll.begin(), coll.end(), ostream_iterator<T>(cout, " "));
cout << endl;
}
template <class T, int N>
void printImpl(T (&coll)[N]) {
copy(coll, coll + N, ostream_iterator<T>(cout, " "));
cout << endl;
}
template <class Key, class Value>
void printImpl(const map<Key, Value>& data) {
typename map<Key, Value>::const_iterator it;
for (it = data.begin(); it != data.end(); ++it) {
cout << it->first << ":" << it->second << endl;
}
}
template <class T>
void printImpl(const T& data) {
cout << data << endl;
}
int main() {
int N, M, T;
cin >> N >> M >> T;
if (N < M) {
cout << "No solution" << endl;
return 0;
}
const int MT = 86400;
vector<vector<int> > added(MT), left(MT);
vector<int> res(N);
for (int i = 0; i < (N); ++i) {
int hh, mm, ss;
char c;
cin >> hh >> c >> mm >> c >> ss;
int start = hh * 3600 + mm * 60 + ss;
added[start].push_back(i);
left[start + T].push_back(i);
}
multiset<int> active;
set<int> uniqueActive;
int lastAdded = -1;
int ix = 0;
int maxReached = -1;
for (int t = 0; t < MT; ++t) {
for (int ii = 0; ii < left[t].size(); ++ii) {
int leftId = left[t][ii];
active.erase(active.find(res[leftId]));
if (active.find(res[leftId]) == active.end()) {
uniqueActive.erase(res[leftId]);
}
}
for (int ii = 0; ii < added[t].size(); ++ii) {
int reqId = added[t][ii];
if (uniqueActive.size() < M) {
active.insert(ix);
uniqueActive.insert(ix);
res[reqId] = ix;
lastAdded = ix;
++ix;
} else {
active.insert(lastAdded);
res[reqId] = lastAdded;
}
maxReached = max<int>(maxReached, uniqueActive.size());
}
}
if (maxReached < M) {
cout << "No solution" << endl;
return 0;
}
cout << ix << endl;
for (int i = 0; i < (N); ++i) {
cout << res[i] + 1 << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
double xx1, yy1, xx2, yy2, vm, t, vx, vy, wx, wy;
inline double Distance(double x, double y) { return sqrt(x * x + y * y); }
inline double Zero(double x) {
if (fabs(x) < 1e-10) return 0;
if (x < 0) return -1;
return 1;
}
inline bool Check(double tt) {
double x = xx1 + min(tt, t) * vx + max(tt - t, 0.0) * wx;
double y = yy1 + min(tt, t) * vy + max(tt - t, 0.0) * wy;
double tmp = Distance(xx2 - x, yy2 - y), tmp2 = tt * vm;
if (Zero(tmp - tmp2) <= 0) return 1;
return 0;
}
inline void Mybin(double low, double high) {
for (double mid = (low + high) * 0.5; high - low > 1e-10;
(Check(mid) ? high = mid : low = mid), mid = (low + high) * 0.5)
;
printf("%.18lf\n", low);
}
inline void solve() {
scanf("%lf%lf%lf%lf%lf%lf%lf%lf%lf%lf", &xx1, &yy1, &xx2, &yy2, &vm, &t, &vx,
&vy, &wx, &wy);
Mybin(0.0, 100000000.0);
}
int main() {
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<long long int, pair<int, int>>> gg;
int tab[200001] = {0};
long long int weight = 0;
vector<pair<int, int>> adjacencyList[100000];
int V;
vector<int> visit;
int E;
int dfs_low[100000] = {0};
int dfsRoot = 0;
int rootChildren = 0;
int dfs_num[100000] = {0};
int dfs_parent[100000] = {0};
bool visited[100000] = {false};
int articulation_vertex[100000] = {0};
void dfs(int u) {
visited[u] = 1;
for (int i = 0; i < adjacencyList[u].size(); i++) {
if (visited[adjacencyList[u][i].first] == 0) {
dfs(adjacencyList[u][i].first);
}
}
}
long long int yo[200001];
int findx(int x) { return (tab[x] == x) ? x : (tab[x] = findx(tab[x])); }
void uniform(int x, int y) { tab[findx(x)] = findx(y); }
int main() {
cin.tie(0);
cin >> V >> E;
long long int maxi = 1000000000001;
long long int mini = 0;
for (int i = 0; i < V; ++i) {
cin >> yo[i];
if (yo[i] < maxi) {
maxi = yo[i];
mini = i;
}
}
for (int i = 0; i < E; ++i) {
int x, y;
long long int z;
cin >> x >> y >> z;
gg.push_back(make_pair(z, make_pair(x, y)));
}
for (int i = 1; i <= V; ++i) {
if (mini + 1 != i)
gg.push_back(make_pair(yo[i - 1] + yo[mini], make_pair(mini + 1, i)));
}
sort(gg.begin(), gg.end());
for (int i = 1; i <= V; ++i) {
tab[i] = i;
}
for (int i = 0; i < E + V - 1; ++i) {
if (findx(gg[i].second.first) != findx(gg[i].second.second)) {
weight += gg[i].first;
uniform(gg[i].second.first, gg[i].second.second);
}
}
cout << weight;
return 0;
}
| 6 |
#include <iostream>
#include <algorithm>
using namespace std;
int main(){
int a[101]={},b;
while(cin>>b){
a[b]++;
}
b=0;
for(int i=1;i<=100;i++){
if(b<a[i])b=a[i];
}
for(int j=1;j<=100;j++){
if(b==a[j])cout<<j<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1000000 + 100;
int n;
int a[maxn], b[maxn], tt[maxn], pre[maxn] = {0}, ans[maxn], sum[maxn],
c[maxn] = {0};
void add(int x, int v) {
while (x <= n) c[x] ^= v, x += (-x) & x;
}
int get(int x) {
int res = 0;
while (x) res ^= c[x], x -= (-x) & x;
return res;
}
struct query {
int l, r, id;
bool operator<(const query &rhs) const {
return r == rhs.r ? l < rhs.l : r < rhs.r;
}
} q[maxn];
int main() {
scanf("%d", &n);
sum[0] = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
b[i] = a[i];
sum[i] = sum[i - 1] ^ a[i];
}
sort(b + 1, b + n + 1, less<int>());
int num = unique(b + 1, b + n + 1) - b - 1;
for (int i = 1; i <= n; ++i) {
int tmp = lower_bound(b + 1, b + 1 + num, a[i]) - b;
tt[tmp] = a[i];
a[i] = tmp;
}
int m;
scanf("%d", &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d", &q[i].l, &q[i].r);
q[i].id = i;
}
sort(q + 1, q + 1 + m);
for (int i = 1, t = 1; i <= n; ++i) {
if (pre[a[i]]) add(pre[a[i]], tt[a[i]]);
add(i, tt[a[i]]), pre[a[i]] = i;
while (q[t].r == i) {
ans[q[t].id] =
get(q[t].r) ^ get(q[t].l - 1) ^ sum[q[t].r] ^ sum[q[t].l - 1];
++t;
}
}
for (int i = 1; i <= m; ++i) printf("%d\n", ans[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
char a[1000100], b[1000100], t[1000100];
int main() {
int i, j, n, La, Lb, num = 0;
cin >> n;
getchar();
a[num++] = '<';
a[num++] = '3';
for (i = 0; i < n; i++) {
gets(t);
for (j = 0; t[j] != '\0'; j++) a[num++] = t[j];
a[num++] = '<';
a[num++] = '3';
}
a[num] = '\0';
La = strlen(a);
gets(b);
Lb = strlen(b);
i = j = 0;
while (i < La && j < Lb) {
if (a[i] == b[j])
i++, j++;
else
j++;
}
if (i >= La)
printf("yes\n");
else
printf("no\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int need[200005];
int a[200005];
vector<int> day[400005];
bool solve(int d) {
int s = 0;
for (int i = 0; i < 200005; i++) {
s += (need[i] = a[i]);
}
s *= 2;
int now = d;
for (int i = d; i >= 1; i--) {
now = min(now, i);
for (auto t : day[i]) {
int k = min(need[t], now);
now -= k;
need[t] -= k;
s -= k;
}
}
if (s > d)
return false;
else
return true;
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 1; i <= n; i++) scanf("%d", a + i);
while (m--) {
int a, b;
scanf("%d%d", &a, &b);
day[a].push_back(b);
}
int x, x1 = 0, x2 = 400005;
while (x1 + 1 != x2) {
x = x1 + x2 >> 1;
if (solve(x))
x2 = x;
else
x1 = x;
}
cout << x2 << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, m, s, d;
vector<pair<int, int>> v[100005];
set<int> traveller[100005];
int times[100005];
void dijkstra(int s) {
set<pair<int, int>> pq;
times[s] = 0;
pq.insert({0, s});
while (!pq.empty()) {
int x = pq.begin()->second;
int t = pq.begin()->first;
pq.erase(pq.begin());
while (traveller[x].count(t)) t++;
for (int i = 0; i < v[x].size(); i++) {
pair<int, int> p = v[x][i];
int y = p.first;
int t1 = p.second;
if (times[y] > t + t1) {
times[y] = t + t1;
pq.insert({times[y], y});
}
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
v[a].push_back({b, c});
v[b].push_back({a, c});
}
for (int i = 0; i < n; i++) {
int x;
cin >> x;
for (int j = 0; j < x; j++) {
int y;
cin >> y;
traveller[i].insert(y);
}
}
s = 0;
d = n - 1;
for (int i = 0; i <= 100000; i++) times[i] = 2000000000;
dijkstra(0);
if (times[n - 1] != 2000000000)
cout << times[n - 1];
else
cout << -1;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300050;
vector<int> e[N];
int f[N], s, t, n;
int que[N], l, r, dis[N], source[N];
inline int find(int x) { return f[x] == x ? x : (f[x] = find(f[x])); }
bool expand() {
int cr = r;
while (l != cr) {
int x = que[++l];
for (__typeof(e[x].begin()) it = e[x].begin(); it != e[x].end(); ++it)
if (dis[*it] > dis[x] + 1)
dis[que[++r] = *it] = dis[x] + 1, source[*it] = source[x];
else if (dis[*it] == dis[x] + 1)
f[find(source[*it])] = find(source[x]);
}
if (l >= r) {
printf("-1\n");
exit(0);
}
return find(s) == find(t);
}
int main() {
int m, ts, a;
scanf("%d%d%d", &n, &m, &ts);
while (ts--) scanf("%d", &a), que[++r] = a, source[a] = a;
for (int i = 1, a, b; i <= m; ++i) {
scanf("%d%d", &a, &b);
e[a].push_back(n + i);
e[n + i].push_back(a);
e[n + i].push_back(b);
e[b].push_back(n + i);
}
scanf("%d%d", &s, &t);
if (source[t] != t) source[t] = t, que[++r] = t;
memset(dis, 0x3f, sizeof dis);
for (int i = 1; i <= r; ++i) dis[que[i]] = 0;
for (int i = 1; i <= n + m; ++i) f[i] = i;
if (s == t)
puts("0");
else {
int res(1), t(0);
while (!expand()) ++res;
printf("%d\n", res);
}
}
| 3 |
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <cstring>
#include <queue>
#include <functional>
#include <cmath>
#include <string>
#include <set>
#include <map>
#define SIZE 55
using namespace std;
typedef long long int ll;
typedef pair <int,int> P;
vector <int> A[SIZE];
vector <int> B[SIZE];
int pa[SIZE],pb[SIZE];
int deg[SIZE];
bool use[SIZE];
void dfs_a(int v,int p)
{
pa[v]=p;
for(int i=0;i<A[v].size();i++)
{
int to=A[v][i];
if(to!=p) dfs_a(to,v);
}
}
void dfs_b(int v,int p)
{
pb[v]=p;
for(int i=0;i<B[v].size();i++)
{
int to=B[v][i];
if(to!=p) dfs_b(to,v);
}
}
void solve()
{
int n;
scanf("%d",&n);
for(int i=0;i<n;i++) A[i].clear();
for(int i=0;i<n;i++) B[i].clear();
for(int i=0;i<n-1;i++)
{
int a,b;
scanf("%d %d",&a,&b);a--,b--;
A[a].push_back(b);
A[b].push_back(a);
}
for(int i=0;i<n-1;i++)
{
int a,b;
scanf("%d %d",&a,&b);a--,b--;
B[a].push_back(b);
B[b].push_back(a);
}
dfs_a(0,-1);
dfs_b(0,-1);
bool up=true;
for(int i=0;i<n;i++) if(pa[i]!=pb[i]) up=false;
if(up)
{
puts("0");
return;
}
int ans=-1;
for(int s=0;s<n;s++)
{
if(A[s].size()==1)
{
int t=A[s][0];
for(int i=0;i<A[t].size();i++)
{
if(A[t][i]==s)
{
swap(A[t][i],A[t][A[t].size()-1]);
break;
}
}
A[t].pop_back();
for(int i=0;i<n;i++)
{
// s->i に辺を張る
A[s][0]=i;
A[i].push_back(s);
dfs_a(s,-1);
dfs_b(s,-1);
memset(use,false,sizeof(use));
queue <int> que;
int cnt=0;
que.push(s);
while(!que.empty())
{
int v=que.front();que.pop();
use[v]=true;
cnt++;
for(int j=0;j<A[v].size();j++)
{
int to=A[v][j];
if(to!=pa[v]&&pb[to]==v) que.push(to);
}
}
for(int j=0;j<n;j++)
{
deg[j]=A[j].size()-1;
}
while(1)
{
int v=-1;
for(int j=0;j<n;j++)
{
if(!use[j]&°[j]==0&&use[pb[j]])
{
v=j;
break;
}
}
if(v==-1) break;
use[v]=true;
deg[pa[v]]--;
}
bool up=true;
for(int j=0;j<n;j++)
{
if(!use[j])
{
up=false;
}
}
if(up)
{
int vl=n-cnt+1;
if(ans==-1) ans=vl;
else ans=min(ans,vl);
}
A[i].pop_back();
}
A[t].push_back(s);
A[s][0]=t;
}
}
printf("%d\n",ans);
}
int main()
{
int T;
scanf("%d",&T);
while(T--) solve();
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
char card[53][5];
short f[53][53][53][53];
int n;
bool check(int a, int b) {
return card[a][0] == card[b][0] || card[a][1] == card[b][1];
}
bool dfs(int N, int a, int b, int c) {
short &res = f[N][a][b][c];
if (N == 1) return true;
if (res != -1) return res;
if (check(b, c) && dfs(N - 1, N - 3, a, c)) return res = 1;
if (N - 3 && check(N - 3, c) && dfs(N - 1, c, a, b)) return res = 1;
res = 0;
return false;
}
int main(int argc, char *argv[]) {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%s", card[i]);
}
memset(f, -1, sizeof(f));
dfs(n, n - 2, n - 1, n);
puts(f[n][n - 2][n - 1][n] ? "YES" : "NO");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int first1, second1;
first1 = second1 = 0;
string a, b;
getline(cin, a);
getline(cin, b);
for (int i = 0, j = 0; i < a.size(), j < b.size(); i++, j++) {
char low = tolower(a[i]);
char low1 = tolower(b[j]);
if (low != low1) {
int x = int(low);
int y = int(low1);
if (x < y) {
second1++;
break;
} else {
first1++;
break;
}
}
}
if (first1 == 0 && second1 == 0) {
cout << "0";
} else {
if (first1 != 0)
cout << "1";
else
cout << "-1";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T>>;
template <typename Args>
void kill(Args args) {
cout << args << "\n";
exit(0);
}
const double PI = acos(-1);
const long long MOD = 1000000007;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const int N = 1010100;
string types[N];
int input_nums = 0;
set<int> input_idx;
int vals[N];
int other[N];
vector<int> adj[N];
int will_change[N];
int n;
int process(vector<int> temp, string type) {
if (type == "AND") {
return temp[0] & temp[1];
} else if (type == "OR") {
return temp[0] | temp[1];
} else if (type == "XOR") {
return temp[0] ^ temp[1];
} else if (type == "NOT") {
return !temp[0];
} else
return temp[0];
}
bool check(int tocheck, int p) {
if (types[p] == "NOT") {
return 1;
}
if (types[p] == "AND") {
return ((1 ^ vals[tocheck]) & (vals[other[tocheck]])) != vals[p];
}
if (types[p] == "XOR") {
return ((1 ^ vals[tocheck]) ^ (vals[other[tocheck]])) != vals[p];
}
if (types[p] == "OR") {
return ((1 ^ vals[tocheck]) | (vals[other[tocheck]])) != vals[p];
} else
return 1;
}
int dfs1(int v, int p = 0) {
if (types[v] == "IN") return vals[v];
vector<int> temp;
for (int next : adj[v]) {
if (next != p) temp.emplace_back(dfs1(next, v));
}
return vals[v] = process(temp, types[v]);
}
void dfs2(int v, int p = 0, bool cur = 1) {
if (types[v] == "IN") {
will_change[v] = cur;
return;
}
for (int next : adj[v]) {
if (next != p) {
dfs2(next, v, cur & (check(next, v)));
}
}
}
void solve(int testnum) {
cin >> n;
string s;
for (int i = 1; i <= n; i++) {
cin >> s;
types[i] = s;
if (s == "AND" || s == "OR" || s == "XOR") {
int x, y;
cin >> x >> y;
adj[i].emplace_back(x);
adj[x].emplace_back(i);
adj[i].emplace_back(y);
adj[y].emplace_back(i);
other[x] = y;
other[y] = x;
} else if (s == "NOT") {
int x;
cin >> x;
adj[i].emplace_back(x);
adj[x].emplace_back(i);
other[x] = x;
} else {
input_nums++;
int x;
cin >> x;
input_idx.insert(i);
vals[i] = x;
other[x] = x;
}
}
dfs1(1);
dfs2(1);
for (int i : input_idx) {
if (will_change[i]) {
cout << (1 ^ vals[1]);
} else
cout << vals[1];
}
}
void precompute() {}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(12);
int testcase = 1;
clock_t zzzx = clock();
precompute();
for (int i = 1; i <= testcase; i++) {
solve(i);
}
double elapsed_time = (double)(clock() - zzzx) / CLOCKS_PER_SEC;
cerr << "elapsed_time"
<< " = " << (elapsed_time) << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
long long int dig(long long int n) {
long long int ans = 0, x;
while (n > 0) {
x = n % 10;
ans++;
n /= 10;
}
return ans;
}
int main() {
long long int n, ans = 0, d, x, p;
cin >> n;
d = dig(n);
x = n - (pow(10, d - 1) - 1);
p = d - 1;
while (p > 0) {
ans = ans + ((9 * pow(10, p - 1)) * p);
p--;
}
ans = ans + x * d;
cout << ans << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int a[7], b[7];
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
int n, x;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> x;
a[x]++;
}
for (int i = 1; i <= n; i++) {
cin >> x;
b[x]++;
}
int ans = 0, cur = 0, cur1 = 0;
for (int i = 1; i <= 5; i++) {
if ((a[i] + b[i]) % 2 != 0) {
cout << "-1\n";
return 0;
}
int temp = (a[i] + b[i]) / 2;
if (a[i] > b[i]) {
int req = a[i] - temp;
if (cur >= req) {
ans += req;
cur -= req;
} else {
ans += cur;
cur1 += (req - cur);
cur = 0;
}
} else if (a[i] < b[i]) {
int req = b[i] - temp;
if (cur1 >= req) {
ans += req;
cur1 -= req;
} else {
ans += cur1;
cur += (req - cur1);
cur1 = 0;
}
}
}
cout << ans << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define N 200010
inline int read(){
char ch=getchar(); int x=0;
for (;ch>'9'||ch<'0';ch=getchar());
for (;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
return x;
}
int n,X,x[N],S[N],P[N];
signed main(){
n=read(); X=read();
for (int i=1;i<=n;i++) x[i]=read(),S[i]=S[i-1]+x[i];
P[1]=5; for (int i=2;i<=n;i++) P[i]=2*i+1;
int ans=9e18;
for (int k=1;k<=n;k++){
int tmp=0,p=n;
for (int i=1;p>0;p-=k,i++){
tmp+=(S[p]-S[max(p-k,0LL)])*P[i];
if (tmp>ans) break;
}
tmp+=X*k;
if (tmp<ans) ans=tmp;
}
printf("%lld\n",ans+n*X);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int K = 10005, N = 55, mod = 1e9 + 7;
int k, dp[K][N], inv[N], ans = 1;
long long n;
inline void addmod(int &a, int b) { a = (a + b) % mod; }
inline void mulmod(int &a, int b) { a = 1ll * a * b % mod; }
inline int add(int a, int b) { return (a + b) % mod; }
inline int mul(int a, int b) { return 1ll * a * b % mod; }
inline void solve(int p, int c) {
memset(dp, 0, sizeof dp);
dp[0][c] = 1;
for (int i = 1, I = (k) + 1; i < I; ++i)
for (int j = c, I = (0) - 1; j > I; --j)
dp[i][j] = add(dp[i][j + 1], mul(dp[i - 1][j], inv[j + 1]));
int cur = 0, expo = 1;
for (int i = 0, I = (c) + 1; i < I; ++i)
addmod(cur, mul(dp[k][i], expo)), mulmod(expo, p);
mulmod(ans, cur);
}
int main() {
cin >> n >> k;
inv[1] = 1;
for (int i = 2, I = (N - 1) + 1; i < I; ++i)
inv[i] = mul(inv[mod % i], mod - mod / i);
for (int p = 2, I = (sqrt(n)) + 1; p < I; ++p) {
int c = 0;
while (n % p == 0) n /= p, ++c;
if (c) solve(p, c);
}
if (n > 1) solve(n % mod, 1);
cout << ans;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e3 + 5, maxm = 1e5 + 5, inf = LLONG_MAX >> 1;
long long n, m, s, t, x, y, z, tot, head[maxn + 1], suc[maxm << 1 | 1],
len[maxm << 1 | 1], to[maxm << 1 | 1], dis[2][maxn + 1], p[maxn + 1],
cnt[maxn + 1][maxn + 1], sum[maxn + 1][maxn + 1], f[2][maxn + 1][maxn + 1];
bool vis[maxn + 1];
pair<long long, long long> minx[2][maxn + 1][2];
struct city {
long long dis, no;
city(long long a = 0, long long b = 0) : dis(a), no(b) {}
} cities[2][maxn + 1];
inline bool cmp(const city &t1, const city &t2) { return t1.dis < t2.dis; }
inline void add_edge(long long x, long long y, long long z) {
suc[++tot] = head[x];
head[x] = tot;
to[tot] = y;
len[tot] = z;
return;
}
void Dijkstra(long long opt, long long start) {
memset(vis, 0, sizeof vis);
dis[opt][start] = 0;
for (long long i = 1; i <= n; ++i) {
long long pos = 0;
for (long long j = 1; j <= n; ++j)
if (!vis[j] && dis[opt][j] < dis[opt][pos]) pos = j;
vis[pos] = true;
for (long long j = head[pos]; j; j = suc[j])
if (dis[opt][to[j]] > dis[opt][pos] + len[j])
dis[opt][to[j]] = dis[opt][pos] + len[j];
}
for (long long i = 1; i <= n; ++i) {
cities[opt][i].dis = dis[opt][i];
cities[opt][i].no = i;
}
sort(cities[opt] + 1, cities[opt] + n + 1, cmp);
return;
}
signed main() {
memset(dis, 0x3f, sizeof dis);
scanf("%lld%lld%lld%lld", &n, &m, &s, &t);
for (long long i = 1; i <= n; ++i) scanf("%lld", &p[i]);
for (long long i = 1; i <= m; ++i) {
scanf("%lld%lld%lld", &x, &y, &z);
add_edge(x, y, z);
add_edge(y, x, z);
}
Dijkstra(0, s);
Dijkstra(1, t);
for (long long i = 1; i <= n; ++i) {
long long pos1 = lower_bound(cities[0] + 1, cities[0] + n + 1,
city(cities[0][i].dis, 0), cmp) -
cities[0] - 1,
pos2 = lower_bound(cities[1] + 1, cities[1] + n + 1,
city(dis[1][cities[0][i].no], 0), cmp) -
cities[1] - 1;
++cnt[pos1][pos2];
sum[pos1][pos2] += p[cities[0][i].no];
}
for (long long i = n; ~i; --i)
for (long long j = n; ~j; --j) {
cnt[i][j] += cnt[i][j + 1] + cnt[i + 1][j] - cnt[i + 1][j + 1];
sum[i][j] += sum[i][j + 1] + sum[i + 1][j] - sum[i + 1][j + 1];
}
for (long long i = n; ~i; --i)
for (long long j = n; ~j; --j) {
if (!cnt[i][j]) continue;
f[0][i][j] =
sum[i][j] - (minx[0][j][0].second == cnt[i][j] ? minx[0][j][1].first
: minx[0][j][0].first);
f[1][i][j] =
sum[i][j] - (minx[1][i][0].second == cnt[i][j] ? minx[1][i][1].first
: minx[1][i][0].first);
if (minx[0][j][0].second == cnt[i][j])
minx[0][j][0].first = min(minx[0][j][0].first, f[1][i][j]);
else {
minx[0][j][1] =
min(minx[0][j][1],
max(minx[0][j][0], make_pair(f[1][i][j], cnt[i][j])));
minx[0][j][0] = min(minx[0][j][0], make_pair(f[1][i][j], cnt[i][j]));
}
if (minx[1][i][0].second == cnt[i][j])
minx[1][i][0].first = min(minx[1][i][0].first, f[0][i][j]);
else {
minx[1][i][1] =
min(minx[1][i][1],
max(minx[1][i][0], make_pair(f[0][i][j], cnt[i][j])));
minx[1][i][0] = min(minx[1][i][0], make_pair(f[0][i][j], cnt[i][j]));
}
}
if (f[0][0][0] > sum[0][0] - f[0][0][0])
puts("Break a heart");
else if (f[0][0][0] < sum[0][0] - f[0][0][0])
puts("Cry");
else
puts("Flowers");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T gcd(T first, T second) {
while (second > 0) {
first %= second;
swap(first, second);
}
return first;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class _T>
inline _T sqr(const _T &first) {
return first * first;
}
template <class _T>
inline string tostr(const _T &a) {
ostringstream os("");
os << a;
return os.str();
}
const long double PI = 3.1415926535897932384626433832795L;
template <typename T>
inline void input(T &a) {
static int ed;
a = 0;
while (!isdigit(ed = getchar()) && ed != '-') {
}
char neg = 0;
if (ed == '-') {
neg = 1;
ed = getchar();
}
while (isdigit(ed)) {
a = 10 * a + ed - '0';
ed = getchar();
}
if (neg) a = -a;
}
template <typename T = int>
inline T nxt() {
T res;
input(res);
return res;
}
void myassert(bool v) { assert(v); }
mt19937 generator;
bool check(int v) {
if (v < 2) return false;
for (int i = 2; i * i <= v; ++i) {
if (v % i == 0) {
return false;
}
}
return true;
}
long long pw(long long a, long long n, long long m) {
long long res = 1;
while (n) {
if (n & 1ll) {
res = res * a % m;
}
a = a * a % m;
n >>= 1;
}
return res;
}
long long mod = 1000000007;
const int N = 1000001;
vector<int> divisors[N + 1];
int cnt[N + 1];
long long f[N];
long long r[N];
long long fi[N];
void pre() {
for (int i = 1; i < N; ++i) {
for (int j = i; j < N; j += i) {
cnt[j] += 1;
}
}
int cc = 0;
for (int i = 1; i < N; ++i) {
cc += cnt[i];
divisors[i].reserve(cnt[i]);
}
memset((cnt), 0, sizeof(cnt));
for (int i = N - 1; i >= 1; --i) {
for (int j = i; j < N; j += i) {
divisors[j].push_back(i);
}
}
f[0] = fi[0] = 1;
r[1] = 1;
for (int i = 2; i < N; ++i) {
r[i] = (-mod / i * r[mod % i] % mod + mod) % mod;
}
for (int i = 1; i < N; ++i) {
f[i] = f[i - 1] * i % mod;
fi[i] = fi[i - 1] * r[i] % mod;
}
cerr << (double)clock() / CLOCKS_PER_SEC << endl;
}
long long bin(int n, int k) {
if (k > n) return 0;
return f[n] * fi[n - k] % mod * fi[k] % mod;
}
long long dp[N];
long long delta[N];
long long ans = 0;
int k;
void addNumber(int first) {
for (int d : divisors[first]) {
delta[d] %= mod;
ans -= dp[d] * d;
cnt[d] += 1;
long long v = bin(cnt[d], k) - delta[d];
if (v < 0) {
v += mod;
}
long long dd = v - dp[d];
if (dd < 0) {
dd += mod;
}
dp[d] = v;
ans += dp[d] * d;
ans %= mod;
for (int q : divisors[d]) {
if (q != d) {
delta[q] += dd;
}
}
}
}
void solve(int test) {
int n = nxt();
k = nxt();
int q = nxt();
ans = 0;
for (int i = 0; i < n; ++i) {
int first = nxt();
addNumber(first);
}
for (int i = 0; i < q; ++i) {
int first = nxt();
addNumber(first);
cout << (ans + mod) % mod << "\n";
}
}
int main(int argc, char **argv) {
pre();
int t = 1;
int c = 0;
while (t--) {
solve(++c);
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
void checkmin(T &t, T x) {
if (x < t) t = x;
}
template <class T>
void checkmax(T &t, T x) {
if (x > t) t = x;
}
template <class T>
void _checkmin(T &t, T x) {
if (t == -1) t = x;
if (x < t) t = x;
}
template <class T>
void _checkmax(T &t, T x) {
if (t == -1) t = x;
if (x > t) t = x;
}
set<int> fo[2500];
int M[50][50];
char V[51][51], color[2500];
int n, m;
bool is_valid(int x, int y) { return (x >= 0 && x < n && y >= 0 && y < m); }
int CN;
void dfs(int x, int y, char col) {
if (V[x][y] != col) return;
M[x][y] = CN;
if (is_valid(x - 1, y) && M[x - 1][y] == 0) dfs(x - 1, y, col);
if (is_valid(x + 1, y) && M[x + 1][y] == 0) dfs(x + 1, y, col);
if (is_valid(x, y - 1) && M[x][y - 1] == 0) dfs(x, y - 1, col);
if (is_valid(x, y + 1) && M[x][y + 1] == 0) dfs(x, y + 1, col);
}
void add_edge(int f, int t) {
fo[f].insert(t);
fo[t].insert(f);
}
int lev[2500], cl, ANS = 1E9;
queue<int> Q;
void bfs(int vr) {
memset(lev, 0, sizeof lev);
cl = 1;
while (!Q.empty()) Q.pop();
Q.push(vr);
lev[vr] = 1;
while (!Q.empty()) {
int V = Q.front();
Q.pop();
for (set<int>::iterator it = fo[V].begin(); it != fo[V].end(); ++it) {
int T = *it;
if (lev[T] == 0) {
lev[T] = lev[V] + 1;
cl = max(cl, lev[T]);
Q.push(T);
}
}
}
cl--;
if (color[vr] == 'B' && cl % 2 == 0) cl++;
if (color[vr] == 'W' && cl % 2 == 1) cl++;
ANS = min(ANS, cl);
}
int main() {
int i, j, k, l;
scanf("%d%d", &n, &m);
for (i = 0; i < n; ++i) scanf("%s", &V[i]);
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j)
if (M[i][j] == 0) {
++CN;
dfs(i, j, V[i][j]);
}
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) {
color[M[i][j]] = V[i][j];
if (is_valid(i - 1, j) && M[i - 1][j] != M[i][j])
add_edge(M[i - 1][j], M[i][j]);
if (is_valid(i + 1, j) && M[i + 1][j] != M[i][j])
add_edge(M[i + 1][j], M[i][j]);
if (is_valid(i, j - 1) && M[i][j - 1] != M[i][j])
add_edge(M[i][j - 1], M[i][j]);
if (is_valid(i, j + 1) && M[i][j + 1] != M[i][j])
add_edge(M[i][j + 1], M[i][j]);
}
for (i = 1; i <= CN; ++i) bfs(i);
cout << ANS << '\n';
return 0;
}
| 5 |
#include <bits/stdc++.h>
int determinante(int a1, int b1, int a2, int b2, int a3, int b3);
int main() {
int n, x[2002], y[2002], j, k, res, i;
scanf("%d", &n);
res = 0;
for (i = 0; i < n; i++) {
scanf("%d%d", &x[i], &y[i]);
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
for (int k = j + 1; k < n; k++) {
if (determinante(x[i], y[i], x[j], y[j], x[k], y[k]) != 0) {
res++;
}
}
}
}
printf("%d", res);
return 0;
}
int determinante(int x1, int y1, int x2, int y2, int x3, int y3) {
int a, b;
a = (x1 * y2 + y1 * x3 + x2 * y3);
b = (x3 * y2 + y3 * x1 + x2 * y1);
return a - b;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
using namespace std;
void fast() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
signed main() {
long long t;
cin >> t;
while (t--) {
long long x, y, n;
cin >> x >> y >> n;
long long xx = n % x;
if (xx == y) {
cout << n << "\n";
continue;
}
if (xx > y)
cout << n - (xx - y) << "\n";
else {
n = n - xx;
n = n - (x - y);
cout << n << "\n";
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
void print_hor(int x, int y) {
bool d = true;
int cur_x = x, cur_y = y;
while (cur_x != n + 1) {
if (d)
for (int i = y; i <= m; i++) printf("%i %i\n", cur_x, i);
else
for (int i = m; i >= y; i--) printf("%i %i\n", cur_x, i);
cur_x++;
d = !d;
}
}
void print_vert(int x, int y) {
bool d = true;
int cur_y = y;
while (cur_y != m + 1) {
if (d)
for (int i = x; i <= n; i++) printf("%i %i\n", i, cur_y);
else
for (int i = n; i >= x; i--) printf("%i %i\n", i, cur_y);
cur_y++;
d = !d;
}
}
int main() {
scanf("%i%i", &n, &m);
if (n == 1) {
if (m != 2)
printf("1\n1 %i 1 1\n", m);
else
printf("0\n");
for (int i = 1; i <= m; i++) printf("1 %i\n", i);
printf("1 1\n");
return 0;
}
if (m == 1) {
if (n != 2)
printf("1\n%i 1 1 1\n", n);
else
printf("0\n");
for (int i = 1; i <= n; i++) printf("%i 1\n", i);
printf("1 1\n");
return 0;
}
if (n % 2 == 0) {
printf("0\n1 1\n");
print_hor(1, 2);
for (int i = n; i >= 1; i--) printf("%i 1\n", i);
return 0;
}
if (m % 2 == 0) {
printf("0\n1 1\n");
print_vert(2, 1);
for (int i = m; i >= 1; i--) printf("1 %i\n", i);
return 0;
}
printf("1\n%i %i 1 1\n", n, m);
print_vert(1, 1);
printf("1 1\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int n;
int a[maxn];
long long dp[maxn][3][3];
int main(void) {
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) scanf("%d", &a[i]);
for (int i = 1; i < n; i++) {
if (a[i - 1] == 0) continue;
int b = a[i - 1];
if (b % 2 == 0) b--;
dp[i][0][0] = dp[i - 1][0][0] + b;
b = a[i - 1];
if (b <= 1) continue;
if (b % 2 == 1) b--;
dp[i][0][1] = dp[i - 1][0][1] + b;
dp[i][0][0] = max(dp[i][0][0], dp[i][0][1]);
}
for (int i = n - 2; i >= 0; i--) {
if (a[i] == 0) continue;
int b = a[i];
if (b % 2 == 0) b--;
dp[i][1][0] = dp[i + 1][1][0] + b;
b = a[i];
if (b <= 1) continue;
if (b % 2 == 1) b--;
dp[i][1][1] = dp[i + 1][1][1] + b;
dp[i][1][0] = max(dp[i][1][0], dp[i][1][1]);
}
long long sol = 0;
sol = dp[0][1][0];
sol = max(sol, dp[n - 1][0][0]);
for (int i = 1; i < n - 1; i++) {
long long c1 = dp[i][1][0];
if (a[i - 1] > 1) {
int add = a[i - 1];
if (add % 2 == 1) add--;
c1 += dp[i - 1][0][1] + add;
}
sol = max(sol, c1);
long long c2 = dp[i][0][0];
if (a[i] > 1) {
int add = a[i];
if (add % 2 == 1) add--;
c2 += dp[i + 1][1][1] + add;
}
sol = max(sol, c2);
}
printf("%lld\n", sol);
return 0;
}
| 3 |
#include <cstdio>
#include <iostream>
#include <algorithm>
#include <cstring>
#include <vector>
#include <stack>
#include <queue>
#include <string>
#define REP(i,n)for (int i=0;i<(n);i++)
#define PB push_back
#define MP make_pair
#define ALL(a) (a).begin(),(a).end()
#define ll long long
using namespace std;
typedef pair<int,int> P;
ll dp[31][50];
bool is_ok[31][50];
int main(){
int n;
while(1){
cin>>n;
if(n==0)break;
REP(i,31)REP(j,50)dp[i][j]=0LL;
memset(is_ok,false,sizeof(is_ok));
REP(i,n){
int f;
cin>>f;
REP(j,f){
int a;cin>>a;is_ok[a][i]=true;
}
}
REP(i,n)dp[0][i]=1LL<<i;
int ans=-1;
for(int i=1;i<=30;i++){
REP(j,n){
dp[i][j]=dp[i-1][j];
if(is_ok[i][j]){
REP(k,n){
if(is_ok[i][k])dp[i][j]|=dp[i-1][k];
}
}
}
REP(j,n){
if(dp[i][j]==(1LL<<n)-1)ans=i;
}
if(ans!=-1)break;
}
cout<<ans<<endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 10;
char s[maxn][maxn];
int main() {
int a, b;
for (int i = 0; i < 11; i++) gets(s[i]);
scanf("%d%d", &a, &b);
int r = (a - 1) % 3, c = (b - 1) % 3;
int flag = 0;
for (int i = r * 3 + r; i < (r + 1) * 3 + r; i++) {
for (int j = c * 3 + c; j < (c + 1) * 3 + c; j++) {
if (s[i][j] == '.') {
flag = 1;
break;
}
}
}
if (flag) {
for (int i = r * 3 + r; i < (r + 1) * 3 + r; i++) {
for (int j = c * 4; j < c * 4 + 3; j++) {
if (s[i][j] == '.') s[i][j] = '!';
}
}
for (int i = 0; i < 11; i++) printf("%s\n", s[i]);
} else {
for (int i = 0; i < 11; i++) {
for (int j = 0; j < 11; j++)
if (s[i][j] == '.') s[i][j] = '!';
}
for (int i = 0; i < 11; i++) printf("%s\n", s[i]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
#define forn(i, n) for (int (i) = 0; (i) != (n); (i)++)
ll n, c, g, a, we, le, ac, L[7], p[7], k;
signed main()
{
cin >> n >> c, c *= n, k = (1 << (n - 1));
forn(i, n) cin >> L[i], L[i] *= n;
sort(L, L + n);
iota(p, p + n - 1, 0);
do {
vector<vector<ll> > dp(c + 1, vector<ll>(k));
dp[L[n - 1]][0] = 1;
forn(i, c) if (i % n)
{
we = p[i % n - 1];
forn(mask, k) if (!((1 << we) & mask))
for (ac = i; ac <= c; ac++)
dp[max(ac, min(c, L[we] + i))][mask + (1 << we)] += dp[ac][mask];
}
g += dp[c][k - 1], a++;
} while (next_permutation(p, p + n - 1));
printf("%.15f", g / pow(c / n, n - 1) / a);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<int> b, sol;
map<int, vector<int> > f;
int a;
for (int i = 0; i < n; i++) {
cin >> a;
f[a].push_back(i);
}
for (int i = 0; i < m; i++) {
cin >> a;
b.push_back(a);
}
int flag = 1;
for (int i = 0; i < b.size(); i++) {
if (f[b[i]].size() == 0) {
cout << "Impossible" << '\n';
return 0;
} else {
if (f[b[i]].size() > 1)
flag = 0;
else
sol.push_back(f[b[i]][0] + 1);
}
}
if (flag) {
cout << "Possible" << '\n';
for (int i = 0; i < sol.size(); i++) cout << sol[i] << " ";
cout << '\n';
} else
cout << "Ambiguity" << '\n';
return 0;
}
| 2 |
#include <bits/stdc++.h>
char map[1005][1005];
int d[1005][1005];
int color[1005][1005];
int fila[100000][2];
int front, end;
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, 1, -1};
void put(int a, int b) {
if (end >= 100000) {
end = 0;
}
fila[end][0] = a;
fila[end++][1] = b;
}
int main(void) {
int r, c;
int i, j;
int sx, sy;
int fx, fy;
int x, y;
int nx, ny;
int counter = 0;
int max;
scanf(" %d %d", &r, &c);
for (i = 0; i < r; i++) {
scanf(" %s", map[i]);
}
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++) {
d[i][j] = INT_MAX;
color[i][j] = 0;
if (map[i][j] == 'E') {
sx = i;
sy = j;
} else if (map[i][j] == 'S') {
fx = i;
fy = j;
}
}
}
counter = 0;
max = INT_MAX;
front = end = 0;
color[sx][sy] = 1;
d[sx][sy] = 0;
put(sx, sy);
while (front != end) {
if (front >= 100000) {
front = 0;
}
x = fila[front][0];
y = fila[front][1];
if (d[x][y] > max) {
break;
}
if (map[x][y] == 'S') {
max = d[x][y];
}
if (isdigit(map[x][y])) {
counter += map[x][y] - '0';
}
front++;
for (i = 0; i < 4; i++) {
nx = x + dx[i];
ny = y + dy[i];
if (nx >= 0 && nx < r && ny >= 0 && ny < c) {
if (map[nx][ny] != 'T' && color[nx][ny] == 0) {
color[nx][ny] = 1;
d[nx][ny] = d[x][y] + 1;
put(nx, ny);
}
}
}
}
printf("%d\n", counter);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int main() {
string s;
int n, k, cnt = 0;
scanf("%d%d", &n, &k);
cin >> s;
if (k == 2) {
char x[] = {'A', 'B'};
int q = 0, cnt1 = 0, cnt2 = 0;
string temp1, temp2;
for (int i = 0; i < n; i++, temp1 += x[q], q = (q + 1) & 1)
if (s[i] != x[q]) {
cnt1++;
}
char X[] = {'B', 'A'};
q = 0;
for (int i = 0; i < n; i++, temp2 += X[q], q = (q + 1) & 1)
if (s[i] != X[q]) {
cnt2++;
}
cout << min(cnt1, cnt2) << endl << ((cnt1 < cnt2) ? temp1 : temp2);
return 0;
}
for (int i = 0; i < n; i++)
if (s[i] == s[i - 1]) {
for (int j = 0; j < k; j++)
if (s[i - 1] != char(j + 'A') &&
(i + 1 >= n || s[i + 1] != char(j + 'A'))) {
s[i] = char(j + 'A');
cnt++;
break;
}
}
cout << cnt << endl << s;
return 0;
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse4")
using namespace std;
const long long MAX = -1000000000000000000;
const long long MIN = 1000000000000000000;
const long long inf = 1000000000;
const long long KOK = 100000;
const long long LOG = 30;
const long long li = 500005;
const long long mod = 1000000007;
int n, m, b[li], a[li], k, flag, t, vis[li], mpp[li];
int cev;
string s;
vector<int> v;
int main(void) {
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (int i = 0; i <= n + 2; i++) vis[i] = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
mpp[a[i]] = i;
}
for (int i = 1; i <= n; i++) {
int ind = i;
for (int j = mpp[i]; j > i; j--) {
if (vis[j - 1] == 1) {
ind = j;
break;
}
if (a[j] > a[j - 1]) {
ind = j;
break;
}
vis[j - 1] = 1;
mpp[a[j - 1]] = j;
swap(a[j], a[j - 1]);
}
mpp[i] = ind;
}
for (int i = 1; i <= n; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
return 0;
}
| 2 |
#include<bits/stdc++.h>
using namespace std;
using Int = long long;
template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b) a=b;}
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b) a=b;}
struct Dice{
int s[6];
void roll(char c){
//the view from above
// N
//W E
// S
//s[0]:top
//s[1]:south
//s[2]:east
//s[3]:west
//s[4]:north
//s[5]:bottom
int b;
if(c=='E'){
b=s[0];
s[0]=s[3];
s[3]=s[5];
s[5]=s[2];
s[2]=b;
}
if(c=='W'){
b=s[0];
s[0]=s[2];
s[2]=s[5];
s[5]=s[3];
s[3]=b;
}
if(c=='N'){
b=s[0];
s[0]=s[1];
s[1]=s[5];
s[5]=s[4];
s[4]=b;
}
if(c=='S'){
b=s[0];
s[0]=s[4];
s[4]=s[5];
s[5]=s[1];
s[1]=b;
}
// migi neji
if(c=='R'){
b=s[1];
s[1]=s[2];
s[2]=s[4];
s[4]=s[3];
s[3]=b;
}
if(c=='L'){
b=s[1];
s[1]=s[3];
s[3]=s[4];
s[4]=s[2];
s[2]=b;
}
}
int top() {
return s[0];
}
int hash(){
int res=0;
for(int i=0;i<6;i++) res=res*256+s[i];
return res;
}
};
vector<Dice> makeDices(Dice d){
vector<Dice> res;
for(int i=0;i<6;i++){
Dice t(d);
if(i==1) t.roll('N');
if(i==2) t.roll('S');
if(i==3) t.roll('S'),t.roll('S');
if(i==4) t.roll('L');
if(i==5) t.roll('R');
for(int k=0;k<4;k++){
res.push_back(t);
t.roll('E');
}
}
return res;
}
template<typename T>
vector<T> compress(vector<T> v){
sort(v.begin(),v.end());
v.erase(unique(v.begin(),v.end()),v.end());
return v;
}
template<typename T>
map<T, int> dict(const vector<T> &v){
map<T, int> res;
for(int i=0;i<(int)v.size();i++)
res[v[i]]=i;
return res;
}
//INSERT ABOVE HERE
signed main(){
int h,w;
cin>>h>>w;
vector<string> s(h);
for(int i=0;i<h;i++) cin>>s[i];
int dy[]={-1,0,1,0,0};
int dx[]={0,1,0,-1,0};
int dd[6][4]={{4,2,1,3},
{0,2,5,3},
{4,5,1,0},
{4,0,1,5},
{5,2,0,3},
{1,2,4,3}};
struct T{
int y,x,v,p;
T(){}
T(int y,int x,int v,int p):y(y),x(x),v(v),p(p){}
};
auto in=[&](int y,int x){return 0<=y&&y<h&&0<=x&&x<w;};
vector<vector<int> > used(h,vector<int>(w,-1));
vector<vector<int> > dc;
auto bfs=
[&](int sy,int sx)->void{
queue<T> q;
used[sy][sx]=0;
q.emplace(sy,sx,0,4);
vector<int> vs(6,'#');
while(!q.empty()){
T t=q.front();q.pop();
vs[t.v]=int(s[t.y][t.x]);
int pd=0,pv=used[t.y-dy[t.p]][t.x-dx[t.p]];
for(int k=0;k<4;k++)
if(dd[t.v][k]==pv) pd=(6-t.p)+(k);
pd%=4;
//cout<<t.v<<":"<<t.p<<":"<<char(vs[t.v])<<":"<<pv<<" "<<pd<<endl;
for(int k=0;k<4;k++){
int ny=t.y+dy[k],nx=t.x+dx[k];
if(!in(ny,nx)||s[ny][nx]=='.'||~used[ny][nx]) continue;
used[ny][nx]=dd[t.v][(pd+k)%4];
q.emplace(ny,nx,used[ny][nx],k);
}
}
Dice di;
for(int i=0;i<6;i++) di.s[i]=vs[i];
auto ds=makeDices(di);
for(Dice d:ds){
if(d.s[0]=='#'||d.s[1]=='#'||d.s[2]=='#') continue;
dc.push_back(vector<int>({d.s[0],d.s[1],d.s[2]}));
// cout<<char(d.s[0])<<" "<<char(d.s[1])<<" "<<char(d.s[2])<<endl;
}
};
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if(~used[i][j]||s[i][j]=='.') continue;
bfs(i,j);
}
}
dc=compress(dc);
int m=dc.size();
using D = tuple<int, int, int>;
set<D> ss;
for(int i=0;i<m;i++)
ss.emplace(dc[i][0],dc[i][1],dc[i][2]);
auto YES=[&](){cout<<"Yes"<<endl;exit(0);};
for(int i=0;i<m;i++){
for(int j=0;j<i;j++){
int a=dc[i][0],b=dc[i][1],c=dc[i][2];
int d=dc[j][0],e=dc[j][1],f=dc[j][2];
set<int> sc({a,b,c,d,e,f});
if(sc.size()!=6u) continue;
//cout<<char(a)<<" "<<char(b)<<" "<<char(c);
//cout<<" "<<char(d)<<" "<<char(e)<<" "<<char(f)<<endl;
if(!ss.count(D(d,b,e))) continue;
if(!ss.count(D(e,b,a))) continue;
if(!ss.count(D(a,b,c))) continue;
if(!ss.count(D(c,b,d))) continue;
if(!ss.count(D(d,e,f))) continue;
if(!ss.count(D(e,a,f))) continue;
if(!ss.count(D(a,c,f))) continue;
if(!ss.count(D(c,d,f))) continue;
YES();
}
}
cout<<"No"<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int a,b;
cin >> a >> b;
cout << a + (b/2) ;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T a) {
return a >= 0 ? a : -a;
}
template <class T>
T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
template <class T>
T mod(T a, T b) {
T ret = a % b;
if (ret < 0) ret += b;
return ret;
}
long long mulmod(long long a, long long b, long long c) {
if (b == 0LL) return 0LL;
long long ret = mulmod(a, b >> 1, c);
ret = (ret + ret) % c;
if (b & 1LL) ret = (ret + a) % c;
return ret;
}
long long powmod(long long a, long long b, long long c) {
if (b == 0LL) return 1LL;
long long ret = powmod(a, b >> 1, c);
ret = ret * ret % c;
if (b & 1LL) ret = ret * a % c;
return ret;
}
template <class T>
inline T& rd(T& x) {
char c;
while (!isdigit((c = getchar())))
;
x = c - '0';
while (isdigit((c = getchar()))) x = x * 10 + c - '0';
return x;
}
template <class T>
inline T& rdd(T& x) {
char c;
while ((c = getchar()), c != '-' && !isdigit(c))
;
if (c == '-') {
x = '0' - (c = getchar());
while (isdigit((c = getchar()))) x = x * 10 + '0' - c;
} else {
x = c - '0';
while (isdigit((c = getchar()))) x = x * 10 + c - '0';
}
return x;
}
inline double& rf(double& x) {
char c;
while ((c = getchar()), c != '-' && c != '.' && !isdigit(c))
;
if (c == '-')
if ((c = getchar()) == '.') {
x = 0;
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + '0' - c;
x *= l;
} else {
x = '0' - c;
while (isdigit((c = getchar()))) x = x * 10 + '0' - c;
if (c == '.') {
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + '0' - c;
x *= l;
}
}
else if (c == '.') {
x = 0;
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + c - '0';
x *= l;
} else {
x = c - '0';
while (isdigit((c = getchar()))) x = x * 10 + c - '0';
if (c == '.') {
double l = 1;
while (isdigit((c = getchar()))) l /= 10, x = x * 10 + c - '0';
x *= l;
}
}
return x;
}
const int N = 200005;
vector<int> G[N];
bool v[N], used[N];
int A[N], n, k, tt, ttt;
long long ans;
void dfs(int u) {
A[u] = used[u];
v[u] = 1;
for (register int i = 0; i < int(G[u].size()); ++i) {
int& t = G[u][i];
if (v[t]) continue;
dfs(t);
A[u] += A[t];
ans += min(2 * k - A[t], A[t]);
}
}
int main() {
rd(n), rd(k);
for (register int i = 1; i <= k << 1; ++i) used[rd(tt)] = 1;
for (register int i = 2; i <= n; ++i)
rd(tt), rd(ttt), G[tt].push_back(ttt), G[ttt].push_back(tt);
dfs(1);
cout << ans;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long int maxn = 1e5 + 5;
const long long int inf = 1e9;
const long double PI = acos(-1);
void yes() { cout << "YES\n"; }
void no() { cout << "NO\n"; }
long long int pmod(long long int a, long long int mod = 1000000007) {
return ((a) % mod + mod) % mod;
}
long long int cel(long long int x1, long long int y1) {
if ((x1) <= 0) {
return (x1) / (y1);
}
return (((x1) / (y1)) + (((x1) % (y1)) != 0));
}
long long int gcd(long long int a, long long int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a / gcd(a, b)) * b;
}
long long bp(long long a, long long b) {
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long bpm(long long a, long long b, long long m = 1000000007) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % m;
a = (a * a) % m;
b >>= 1;
}
return res % m;
}
string vow = "aeiou";
const int dx4[] = {-1, 0, 1, 0};
const int dy4[] = {0, 1, 0, -1};
const int dx8[] = {-1, 0, 1, 0, -1, -1, 1, 1};
const int dy8[] = {0, 1, 0, -1, -1, 1, -1, 1};
const int dxhorse[] = {-2, -2, -1, -1, 1, 1, 2, 2};
const int dyhorse[] = {1, -1, 2, -2, 2, -2, 1, -1};
void solve() {
int n;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) cin >> a[i];
;
for (int i = 0; i < n; i++) cin >> b[i];
;
vector<long long int> mx1(n + 1, 0), mx2(n + 1, 0);
mx1[1] = a[0];
mx2[1] = b[0];
for (int i = 1; i < n; i++) {
mx1[i + 1] = max(mx2[i] + a[i], mx2[i - 1] + a[i]);
mx2[i + 1] = max(mx1[i] + b[i], mx1[i - 1] + b[i]);
}
cout << max(mx1[n], mx2[n]);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cout.tie();
;
int t = 1;
while (t--) {
solve();
cout << "\n";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 510, mod = 1000000007;
int niz[MAXN];
int n;
int dp[MAXN][MAXN];
int rek(int a, int b) {
if (a >= b) return 1;
int &ret = dp[a][b];
if (ret != -1) return ret;
ret = 0;
for (int i = a + 1; i <= b; i++)
if (niz[a] < niz[i])
ret =
((long long int)ret + (long long int)rek(a + 1, i - 1) * rek(i, b)) %
mod;
ret = ((long long int)ret + (long long int)rek(a + 1, b)) % mod;
return ret;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &niz[i]);
memset(dp, -1, sizeof(dp));
printf("%d\n", rek(2, n));
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100007;
struct BIT {
int n;
vector<int> cover;
void clear() {
n = 0;
cover.clear();
cover.push_back(0);
}
void push_back() {
cover.push_back(0);
n++;
}
void build() {
for (int i = 1; i <= n; i++) insert(i, 1);
}
void insert(int x, int val) {
for (int i = x; i <= n; i += i & (-i)) cover[i] += val;
}
int count(int x) {
int res = 0;
for (int i = x; i > 0; i -= i & (-i)) res += cover[i];
return res;
}
};
struct EDG {
int xx, ee;
EDG(int _xx, int _ee) { xx = _xx, ee = _ee; }
};
vector<EDG> edg[maxn];
int n, m;
int root, du[maxn], Dep[maxn], Deps[maxn], Mark[maxn], Marks[maxn];
vector<BIT> bit;
void dfs(int x, int father, int e, int sign, BIT &it) {
Mark[x] = Marks[e] = sign;
it.push_back();
Dep[x] = Deps[e] = it.n;
for (int i = 0; i < edg[x].size(); i++) {
int xx = edg[x][i].xx, ee = edg[x][i].ee;
if (xx != father) dfs(xx, x, ee, sign, it);
}
}
void work() {
for (int i = 1; i <= n; i++) edg[i].clear();
memset(du, 0, sizeof(du));
for (int i = 1; i < n; i++) {
int fir, lst;
scanf("%d%d", &fir, &lst);
edg[fir].push_back(EDG(lst, i));
edg[lst].push_back(EDG(fir, i));
du[fir]++, du[lst]++;
}
root = 1;
for (int i = 1; i <= n; i++)
if (du[i] > 2) root = i;
int total = 0;
bit.clear();
for (int i = 0; i < edg[root].size(); i++) {
int x = edg[root][i].xx, e = edg[root][i].ee;
BIT it;
it.clear();
dfs(x, root, e, total++, it);
it.build();
bit.push_back(it);
}
scanf("%d", &m);
for (int i = 1; i <= m; i++) {
int order;
scanf("%d", &order);
if (order == 1) {
int e;
scanf("%d", &e);
int sign = Marks[e], x = Deps[e];
bit[sign].insert(x, 1);
}
if (order == 2) {
int e;
scanf("%d", &e);
int sign = Marks[e], x = Deps[e];
bit[sign].insert(x, -1);
}
if (order == 3) {
int fir, lst;
scanf("%d%d", &fir, &lst);
if (lst == root) swap(fir, lst);
if (fir == root) {
int sign = Mark[lst], x = Dep[lst];
if (x > bit[sign].count(x))
puts("-1");
else
printf("%d\n", x);
continue;
}
if (Mark[fir] == Mark[lst]) {
if (Dep[fir] > Dep[lst]) swap(fir, lst);
int sign = Mark[lst], L = Dep[fir], R = Dep[lst];
if (R - L > bit[sign].count(R) - bit[sign].count(L))
puts("-1");
else
printf("%d\n", R - L);
continue;
}
int res = 0;
int sign = Mark[fir], x = Dep[fir];
if (x > bit[sign].count(x)) {
puts("-1");
continue;
}
res += x;
sign = Mark[lst], x = Dep[lst];
if (x > bit[sign].count(x)) {
puts("-1");
continue;
}
res += x;
printf("%d\n", res);
}
}
}
int main() {
while (scanf("%d", &n) != EOF) work();
}
| 4 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:66777216")
using namespace std;
int a, b, c, d, n, m, k;
vector<int> sm[100002];
bool cool[1000002];
int mx[1000002];
int res;
void dfs1(int v, int pr = -1) {
mx[v] = -1000000000;
if (cool[v]) mx[v] = 0;
for (int _n(((int)((sm[v]).size())) - 1), i(0); i <= _n; i++) {
int w = sm[v][i];
if (w == pr) continue;
dfs1(w, v);
mx[v] = max(mx[v], mx[w] + 1);
}
}
void dfs(int v, int pr, int sof) {
if (sof > d) return;
bool ok = 1;
int tm = -1000000000, tm2 = -1000000000;
for (int _n(((int)((sm[v]).size())) - 1), i(0); i <= _n; i++) {
int w = sm[v][i];
if (w == pr) continue;
if (mx[w] + 1 > d) {
ok = 0;
}
if (mx[w] + 1 > tm) {
tm2 = tm;
tm = mx[w] + 1;
} else if (mx[w] + 1 > tm2) {
tm2 = mx[w] + 1;
}
}
if (ok) ++res;
for (int _n(((int)((sm[v]).size())) - 1), i(0); i <= _n; i++) {
int w = sm[v][i];
if (w == pr) continue;
int nx = sof + 1;
if (cool[v]) nx = max(nx, 1);
if (mx[w] + 1 != tm)
nx = max(nx, tm + 1);
else
nx = max(nx, tm2 + 1);
dfs(w, v, nx);
}
}
int main() {
scanf("%d%d%d", &n, &m, &d);
for (int _n((m)-1), i(0); i <= _n; i++) {
scanf("%d", &a);
--a;
cool[a] = 1;
}
for (int _n((n - 1) - 1), i(0); i <= _n; i++) {
scanf("%d%d", &a, &b);
--a;
--b;
sm[a].push_back(b);
sm[b].push_back(a);
}
dfs1(0);
dfs(0, -1, -1000000000);
printf("%d\n", res);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
bool comp1(pair<double, double> p1, pair<double, double> p2) {
return p1.first > p2.first || p1.first == p2.first && p1.second > p2.second;
}
bool comp2(pair<double, double> p1, pair<double, double> p2) {
return p1.first - p1.second > p2.first - p2.second ||
p1.first - p1.second == p2.first - p2.second && p1.first > p2.first;
}
pair<double, double> pp[2048];
pair<double, double> p[2048];
set<pair<double, int> > wa, wb, ca, cb;
double sa, sb;
int n, na, nb;
double kk[2048];
int main() {
scanf("%d%d%d", &n, &na, &nb);
for (int i = 0, to = n; i < to; ++i) scanf("%lf", &pp[i].first);
for (int i = 0, to = n; i < to; ++i) scanf("%lf", &pp[i].second);
sort(pp, pp + n, comp1);
double r = 0.;
for (int i = n; i >= 0; --i) {
for (int j = 0, to = n; j < to; ++j) p[j] = pp[j];
sort(p, p + i, comp2);
wa.clear();
wb.clear();
ca.clear();
cb.clear();
for (int j = i, to = n; j < to; ++j) cb.insert(make_pair(p[j].second, j));
for (int j = 0, to = i; j < to; ++j) {
kk[j] = (1 - p[j].second) * p[j].first;
ca.insert(make_pair(kk[j], j));
}
sa = sb = 0;
for (int j = 0, to = i; j < to; ++j) sb += p[j].second;
for (int j = 0, to = i + 1; j < to; ++j) {
while (!wa.empty() && j + wa.size() > na) {
sa -= wa.begin()->first;
ca.insert(*wa.begin());
wa.erase(wa.begin());
}
while (!cb.empty() && i - j + wb.size() < nb) {
sb += cb.rbegin()->first;
wb.insert(*cb.rbegin());
cb.erase(*cb.rbegin());
}
while (!ca.empty() && j + wa.size() < na) {
sa += ca.rbegin()->first;
wa.insert(*ca.rbegin());
ca.erase(*ca.rbegin());
}
if (i - j + wb.size() <= nb && j + wa.size() <= na) {
r = max(r, sa + sb);
}
if (j != i) {
sa += p[j].first;
if (wa.count(make_pair(kk[j], j))) {
sa -= (1 - p[j].second) * p[j].first;
wa.erase(make_pair(kk[j], j));
} else {
ca.erase(make_pair(kk[j], j));
}
sb -= p[j].second;
cb.insert(make_pair((1 - p[j].first) * p[j].second, j));
}
}
}
printf("%lf\n", r);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long a[1000], b[1000];
long long n;
int main() {
cin >> n;
long long ans = n;
for (int i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (a[i] == b[j] && i != j) {
ans--;
break;
}
}
}
cout << ans << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int main() {
int c, n, m;
cin >> c >> n >> m;
vector<int> dp(c + 1);
for (int i = 0; i < n; ++i) {
int s, p;
cin >> s >> p;
for (int j = c; j >= s; --j)
dp[j] = max(dp[j], dp[j - s] + p);
}
for (int i = 1; i <= m; ++i)
cout << dp[c / i] * i << "\n";
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int x = 0, nOp;
string op;
cin >> nOp;
for (int i = 0; i < nOp; i++) {
cin >> op;
if (op[0] == '+' || op[1] == '+')
x++;
else
x--;
}
cout << x;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int check(string s) {
vector<long long int> v;
v.push_back(0);
for (char c : s) {
if (c == '(') {
v.push_back(v.back() + 1);
} else {
v.push_back(v.back() - 1);
}
}
long long int f = 0;
long long int minm = 1000000000000000000;
for (long long int i = 1; i < v.size(); i++) {
if (v[i] < minm) {
minm = v[i];
f = 1;
} else if (v[i] == minm) {
f++;
}
}
return f;
}
void solve() {
long long int n;
cin >> n;
string s;
cin >> s;
long long int open = 0, close = 0;
for (char c : s) {
if (c == '(') {
open++;
} else {
close++;
}
}
if (open != close) {
cout << 0 << "\n";
cout << "1 1"
<< "\n";
return;
}
long long int maxm = 0;
long long int idx1 = 1, idx2 = 1;
for (long long int i = 0; i < n; i++) {
for (long long int j = i; j < n; j++) {
string temp = s;
swap(temp[i], temp[j]);
long long int curr = check(temp);
if (curr > maxm) {
idx1 = i + 1, idx2 = j + 1;
maxm = curr;
}
}
}
cout << maxm << "\n";
cout << idx1 << ' ' << idx2 << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<long long> A, B, C;
vector<long long> b, c, bb, cc;
long long solve(int mm) {
b.push_back(0);
bb.resize(b.size());
bb[0] = b[0];
for (int i = 1; i < (int)b.size(); i++) bb[i] = b[i] + bb[i - 1];
cc.resize(c.size());
cc[0] = c[0];
for (int i = 1; i < (int)c.size(); i++) cc[i] = c[i] + cc[i - 1];
long long ans = 0;
for (int i = 0; i * 3 <= mm && i < (int)c.size(); i++) {
int r = mm - i * 3;
r = min(r / 2, -1 + (int)b.size());
ans = max(ans, cc[i] - c[i] + bb[r] - b[r]);
}
return ans;
}
int main() {
scanf("%d", &n), scanf("%d", &m);
for (int i = 0; i < (int)n; i++) {
int w, c;
scanf("%d", &w), scanf("%d", &c);
if (w == 1) A.push_back(c);
if (w == 2) B.push_back(c);
if (w == 3) C.push_back(c);
}
sort(A.begin(), A.end(), greater<long long>());
sort(B.begin(), B.end(), greater<long long>());
sort(C.begin(), C.end(), greater<long long>());
for (int i = 0; i + 1 < (int)A.size(); i += 2) {
b.push_back(A[i] + A[i + 1]);
}
for (int i = 0; i < (int)B.size(); i++) b.push_back(B[i]);
sort(b.begin(), b.end(), greater<long long>());
for (int i = 0; i < (int)C.size(); i++) c.push_back(C[i]);
c.push_back(0);
long long ans = solve(m);
if (A.size() > 0) {
b.clear();
for (int i = 1; i + 1 < (int)A.size(); i += 2) {
b.push_back(A[i] + A[i + 1]);
}
for (int i = 0; i < (int)B.size(); i++) b.push_back(B[i]);
sort(b.begin(), b.end(), greater<long long>());
ans = max(ans, solve(m - 1) + A[0]);
}
printf("%lld\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MAX = 1e6;
vector<pair<int, int> > adj[MAX];
bool prime[MAX];
int prime_numbers[9999999], pos;
void sieve() {
prime[0] = 1;
prime[1] = 1;
for (int i = 4; i <= MAX; i += 2) prime[i] = 1;
int root = sqrt(MAX);
for (int i = 3; i <= root; i += 2) {
if (prime[i] == 0) {
for (int j = i * i; j <= MAX; j += i) {
prime[j] = 1;
}
}
}
prime_numbers[pos++] = 2;
for (int i = 3; i < MAX; i += 2)
if (prime[i] == 0) prime_numbers[pos++] = i;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
sieve();
long long int n, m, sp = 0, mst = 0;
cin >> n >> m;
for (int i = 0; i < pos; i++) {
if (prime_numbers[i] > n) {
sp = prime_numbers[i];
mst = prime_numbers[i];
break;
}
}
int val = sp / (n - 1);
int rem = sp % (n - 1);
for (int i = 1; i < n; i++) {
adj[i].push_back({i + 1, val + rem});
rem = 0;
}
m -= (n - 1);
if (m) {
for (int i = 1; i < n; i++) {
for (int j = i + 2; j <= n; j++) {
adj[i].push_back({j, MAX});
m--;
if (m == 0) goto ans;
}
}
}
ans:
cout << sp << " " << mst << endl;
for (int i = 1; i <= n; i++) {
for (auto x : adj[i])
cout << i << " " << x.first << " " << x.second << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1050010;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
int n, a[N], b[N], m, st[N], tp, fa[N];
vector<pair<int, int> > E[N];
bool vis[N];
int getf(int x) { return x == fa[x] ? x : fa[x] = getf(fa[x]); }
void dfs(int u) {
while (!E[u].empty()) {
auto e = E[u].back();
E[u].pop_back();
int v = e.first, id = e.second;
if (vis[abs(id)]) continue;
vis[abs(id)] = 1;
dfs(v);
st[++tp] = -id;
}
}
int main() {
cin >> m;
for (int i = 1; i <= m; i++) a[i] = gi(), b[i] = gi();
for (int ans = 20; ~ans; ans--) {
cerr << ans << '\n';
n = 1 << ans;
for (int i = 0; i < n; i++) E[i].clear(), fa[i] = i;
for (int i = 1; i <= m; i++) {
int x = a[i] & (n - 1), y = b[i] & (n - 1);
E[x].push_back(make_pair(y, i));
E[y].push_back(make_pair(x, -i));
fa[getf(x)] = getf(y);
}
bool fl = 1;
int p = -1;
for (int i = 0; i < n && fl; i++) {
if (int(E[i].size()) & 1) fl = 0;
if (!E[i].empty()) {
if (p == -1)
p = i;
else if (getf(p) != getf(i))
fl = 0;
}
}
if (!fl) continue;
cout << ans << '\n';
dfs(p);
for (int i = 1; i <= tp; i++) {
if (st[i] > 0)
cout << 2 * st[i] - 1 << ' ' << 2 * st[i] << ' ';
else
st[i] = -st[i], cout << 2 * st[i] << ' ' << 2 * st[i] - 1 << ' ';
}
break;
}
return 0;
}
| 6 |
#include <iostream>
#include <algorithm>
#include <cctype>
#include <cstdio>
#include <math.h>
using namespace std;
int main(){
int m,w[10];
while(cin>>m){
int k=0;
for(int i=0;i<10;i++)w[i]=0;
for(int i=9;i>=0;i--)if(m>=pow(2,i)){w[i]=1;m-=pow(2,i);}
for(int i=0;i<10;i++){
if(w[i]==1&&k==0){cout<<pow(2,i);k=1;}
else if(w[i]==1)cout<<" "<<pow(2,i);
}
cout<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long linf = 2e18 + 5e2;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long n, m, a, d;
cin >> n >> m >> a >> d;
vector<long long> t(m);
for (int i = 0; i < m; i++) {
cin >> t[i];
}
m++;
t.push_back(n * a);
long long out = 0, curn = 0, last_open = -d;
for (int i = 0; i < m; i++) {
curn = min(n, max((last_open + d) / a, curn));
long long v = t[i];
long long target_n = min(v / a, n);
if (target_n > curn) {
long long chunk = d / a + 1;
long long am = (target_n - curn) / chunk;
if (am) {
out += am;
curn += am * chunk;
last_open = (target_n - chunk + 1) * a;
}
assert(target_n >= curn);
if (target_n - curn) {
out++;
last_open = (curn + 1) * a;
}
}
if (v > last_open + d) {
out++;
last_open = v;
}
}
cout << out;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep2(i,m,n) for(int i=(int)(m);i<(int)(n);i++)
#define rep(i,n) rep2(i,0,n)
int h,w,n;
int a[210][210]={0};
int m[210][210]={0};
int me(int h1,int h2,int w1,int w2){
int r=m[h2][w2]-m[h2][w1-1]-m[h1-1][w2]+m[h1-1][w1-1];
if(r<0) r=0;
return r;
}
int ch(int h1,int h2,int w1,int w2){
int r=0;
for(int i=h1;i<h2;i++){
r=max(r,min(me(h1,i,w1,w2),me(i+1,h2,w1,w2)));
}
for(int i=w1;i<w2;i++){
r=max(r,min(me(h1,h2,w1,i),me(h1,h2,i+1,w2)));
}
return r;
}
int main() {
//int h,w,n;
cin>>h>>w>>n;
for(int i=1;i<=h;i++){
for(int j=1;j<=w;j++){
cin>>a[i][j];
m[i][j]=m[i-1][j]+m[i][j-1]-m[i-1][j-1]+a[i][j];
}
}
if(n==2){
int r=0;
for(int i=1;i<h;i++){
r=max(r,min(me(1,i,1,w),me(i+1,h,1,w)));
}
for(int i=1;i<w;i++){
r=max(r,min(me(1,h,1,i),me(1,h,i+1,w)));
}
cout<<r<<endl;
return 0;
}
if(n==3){
int r=0;
for(int i=1;i<h;i++){
r=max(r,min(ch(1,i,1,w),me(i+1,h,1,w)));
//cout<<r<<endl;
r=max(r,min(ch(i+1,h,1,w),me(1,i,1,w)));
//cout<<r<<endl;
}
for(int i=1;i<w;i++){
r=max(r,min(ch(1,h,1,i),me(1,h,i+1,w)));
r=max(r,min(ch(1,h,i+1,w),me(1,h,1,i)));
//cout<<r<<endl;
}
cout<<r<<endl;
}
if(n==4){
int r=0;
int e;
for(int i=1;i<h;i++){
for(int j=i;j<h;j++){
for(int k=1;k<w;k++){
for(int l=k;l<w;l++){
e=min(min(me(1,i,1,l),me(1,j,l+1,w)),min(me(i+1,h,1,k),me(j+1,h,k+1,w)));
r=max(r,e);
e=min(min(me(1,j,1,k),me(1,i,k+1,w)),min(me(j+1,h,1,l),me(i+1,h,l+1,w)));
r=max(r,e);
}
}
}
}
for(int i=1;i<h;i++){
for(int j=i;j<h;j++){
e=min(me(1,i,1,w),min(me(i+1,j,1,w),ch(j+1,h,1,w)));
r=max(r,e);
e=min(me(1,i,1,w),min(ch(i+1,j,1,w),me(j+1,h,1,w)));
r=max(r,e);
e=min(ch(1,i,1,w),min(me(i+1,j,1,w),me(j+1,h,1,w)));
r=max(r,e);
}
}
for(int i=1;i<h;i++){
for(int j=1;j<w;j++){
e=min(ch(1,h,1,i),min(me(1,j,i+1,w),me(j+1,h,i+1,w)));
r=max(r,e);
e=min(me(1,h,1,i),min(ch(1,j,i+1,w),me(j+1,h,i+1,w)));
r=max(r,e);
e=min(me(1,h,1,i),min(me(1,j,i+1,w),ch(j+1,h,i+1,w)));
r=max(r,e);
e=min(ch(1,j,1,i),min(me(j+1,h,1,i),me(1,h,i+1,w)));
r=max(r,e);
e=min(me(1,j,1,i),min(ch(j+1,h,1,i),me(1,h,i+1,w)));
r=max(r,e);
e=min(me(1,j,1,i),min(me(j+1,h,1,i),ch(1,h,i+1,w)));
r=max(r,e);
}
}
for(int i=1;i<w;i++){
for(int j=i;j<w;j++){
e=min(me(1,h,1,i),min(me(1,h,i+1,j),ch(1,h,j+1,w)));
r=max(r,e);
e=min(ch(1,h,1,i),min(me(1,h,i+1,j),me(1,h,j+1,w)));
r=max(r,e);
e=min(me(1,h,1,i),min(ch(1,h,i+1,j),me(1,h,j+1,w)));
r=max(r,e);
}
}
for(int i=1;i<h;i++){
for(int j=1;j<w;j++){
e=min(ch(1,i,1,w),min(me(i+1,h,1,j),me(i+1,h,j+1,w)));
r=max(r,e);
e=min(me(1,i,1,w),min(me(i+1,h,1,j),ch(i+1,h,j+1,w)));
r=max(r,e);
e=min(me(1,i,1,w),min(ch(i+1,h,1,j),me(i+1,h,j+1,w)));
r=max(r,e);
e=min(ch(1,i,1,j),min(me(1,i,j+1,w),me(i+1,h,1,w)));
r=max(r,e);
e=min(me(1,i,1,j),min(ch(1,i,j+1,w),me(i+1,h,1,w)));
r=max(r,e);
e=min(me(1,i,1,j),min(me(1,i,j+1,w),ch(i+1,h,1,w)));
r=max(r,e);
}
}
cout<<r<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
const double pi = acos(-1.0);
const int mod = 1e9 + 7;
const int N = 1e5 + 10;
const int inf = 0x3f3f3f3f;
using namespace std;
char a[N];
int v[128][N];
int vv[N];
int h[128];
int main() {
scanf("%s", a);
int k = strlen(a);
for (int i = 0; i < k; i++)
for (int j = 0; j < 26; j++)
v[j][i] = v[j][i == 0 ? i : i - 1] + ((a[i] - 'a') == j);
for (int i = 0; i < k; i++) vv[a[i]]++;
for (int i = 0; i < k; i++) {
vv[a[i]]--;
if (vv[a[i]] <= 0) h[a[i]] = i;
}
int p = 0;
int f = 0;
for (int j = 25; j >= 0; j--) {
int l = v[j][k - 1] - v[j][p];
if (f == 0) l = v[j][k - 1];
if (l == 0) continue;
f = 1;
while (l--) printf("%c", j + 'a');
p = h[j + 'a'];
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long n, i, x, ans, ns, a[2000000];
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> x;
a[x] = i;
}
ans = n;
ns = x;
for (i = 0; i <= 1000000; i++)
if (a[i])
if (a[i] < ans) {
ans = a[i];
ns = i;
}
cout << ns;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, a[100100], b[100100], c[100100];
long long ans;
char ch[100100];
void init(int *a) {
scanf("%s", ch + 1);
for (int i = 1; i <= n; ++i) a[i] = ch[i] - 48;
}
void dfs(int x, int w) {
if (!ans) return;
if (0 <= a[x + 1] + w && a[x + 1] + w <= 9) {
printf("%d %d\n", x, w);
a[x] += w, a[x + 1] += w;
--ans;
return;
}
dfs(x + 1, -w);
if (!ans) return;
printf("%d %d\n", x, w);
a[x] += w;
a[x + 1] += w;
--ans;
}
int main() {
scanf("%d", &n);
init(a);
init(b);
for (int i = 1; i <= n; ++i) c[i] = a[i];
for (int i = 1; i < n; ++i) {
int d = b[i] - c[i];
c[i] += d;
c[i + 1] += d;
ans += abs(d);
}
if (c[n] != b[n]) {
puts("-1");
return 0;
}
cout << ans << endl;
ans = min(ans, 100000ll);
for (int i = 1; i < n && ans > 0; ++i)
while (a[i] != b[i] && ans > 0) dfs(i, (b[i] - a[i]) / abs(b[i] - a[i]));
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 10;
const int inf = 1e9;
const int mo = 998244353;
int a[N];
int main() {
int n;
scanf("%d", &n);
for (auto i = (1); i <= (n); ++i) a[i] = n;
for (auto i = (1); i <= (n); ++i) {
int x;
scanf("%d", &x);
x = min(x, n);
for (auto i = (n); i >= (1); --i) a[i - 1] = min(a[i - 1], a[i]);
for (auto i = (x + 1); i <= (n); ++i) a[i] = n;
for (auto i = (0); i <= (x - 1); ++i) {
a[i + 1] = min(a[i + 1], a[i] + 1);
++a[i];
}
}
int ans = n;
for (auto i = (0); i <= (n); ++i) ans = min(ans, a[i]);
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000;
const int N = 100 * 1000 + 10;
int n, m, d;
bool u[N];
bool good[N];
vector<int> g[N];
int hh[N];
int lo[N];
void dfs1(int v) {
u[v] = true;
if (good[v])
hh[v] = 0;
else
hh[v] = -INF;
for (int to : g[v]) {
if (u[to]) continue;
dfs1(to);
hh[v] = max(hh[v], hh[to] + 1);
}
}
void dfs2(int v, int best) {
u[v] = true;
if (good[v])
lo[v] = max(best, 0);
else
lo[v] = best;
multiset<int> s;
for (auto to : g[v]) {
if (u[to]) continue;
s.insert(hh[to]);
}
for (auto to : g[v]) {
if (u[to]) continue;
int mx = lo[v];
s.erase(s.find(hh[to]));
auto it = s.end();
if (it != s.begin()) {
--it;
mx = max(mx, *it + 1);
}
dfs2(to, mx + 1);
s.insert(hh[to]);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> d;
fill(good, good + n, false);
for (int i = 0; i < m; i++) {
int x;
cin >> x;
--x;
good[x] = true;
}
for (int i = 0; i < n - 1; i++) {
int a, b;
cin >> a >> b;
--a;
--b;
g[a].push_back(b);
g[b].push_back(a);
}
fill(u, u + n, 0);
dfs1(0);
fill(u, u + n, 0);
dfs2(0, -INF);
vector<int> res;
for (int i = 0; i < n; i++)
if (hh[i] <= d && lo[i] <= d) res.push_back(d);
cout << res.size();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
struct pt {
long long x;
double y;
};
bool cmp(pt a, pt b) {
if (a.x < b.x) {
return 1;
}
if (a.x > b.x) {
return 0;
}
return a.y > b.y;
}
long long area(pt a, pt b, pt c) {
double ans = a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y);
return ans < 0;
}
long long obr(pt a, pt b, pt c) {
double ans = a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y);
return ans > 0;
}
vector<pt> solve(long long n, vector<pt> p) {
sort(p.begin(), p.end(), cmp);
vector<pt> up;
vector<pt> dn;
up.push_back(p[0]);
dn.push_back(p[0]);
pt p1 = p[0];
pt p2 = p[p.size() - 1];
for (long long i = 1; i < p.size(); i++) {
if (p[i].x == p[i - 1].x) {
continue;
}
if (i == p.size() - 1 || area(p1, p[i], p2)) {
while (up.size() > 1 &&
!area(up[up.size() - 2], up[up.size() - 1], p[i])) {
up.pop_back();
}
up.push_back(p[i]);
}
}
vector<pt> g;
for (long long i = 0; i < up.size(); i++) {
g.push_back(up[i]);
}
return g;
}
signed main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
long long w, q, n;
cin >> n;
vector<pt> v;
for (long long i = 1; i <= n; i++) {
long long x, y;
cin >> x >> y;
v.push_back({x, y - 1. * x * x});
}
vector<pt> g = solve(n, v);
long long cnt = 0;
for (long long i = 1; i < g.size(); i++) {
if (g[i].x == g[i - 1].x) {
continue;
}
cnt++;
}
cout << cnt << "\n";
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long k;
scanf("%d %I64d", &n, &k);
int f[n];
long long w[n];
for (int i = 0; i < n; i++) scanf("%d", &f[i]);
for (int i = 0; i < n; i++) scanf("%I64d", &w[i]);
int anc[n][34];
long long sum[n][34], mn[n][34];
for (int i = 0; i < n; i++) {
anc[i][0] = f[i];
sum[i][0] = w[i];
mn[i][0] = w[i];
}
for (int i = 1; i < 34; i++) {
for (int j = 0; j < n; j++) {
anc[j][i] = anc[anc[j][i - 1]][i - 1];
sum[j][i] = sum[anc[j][i - 1]][i - 1] + sum[j][i - 1];
mn[j][i] = min(mn[anc[j][i - 1]][i - 1], mn[j][i - 1]);
}
}
for (int i = 0; i < n; i++) {
int ank = i;
long long csum = 0, cmn = 1001001001;
for (long long j = 34; j >= 0; j--) {
if (k & (1ll << j)) {
csum += sum[ank][j];
cmn = min(cmn, mn[ank][j]);
ank = anc[ank][j];
}
}
printf("%I64d %I64d\n", csum, cmn);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
template <class T>
std::ostream& operator<<(std::ostream& out, std::vector<T>& dat) {
for (int i = 0; i < dat.size(); ++i) {
out << dat[i];
if (i < dat.size() - 1) out << ' ';
}
return out;
}
long long MOD = 998244353;
long long gcd(long long a, long long b) {
if (b == 0) return a;
return gcd(b, a % b);
}
long long gcdExtended(long long a, long long b) {
long long s = 0;
long long t = 1;
long long r = b;
long long sOld = 1;
long long tOld = 0;
long long rOld = a;
while (r != 0) {
long long q = rOld / r;
long long rNew = rOld - q * r;
rOld = r;
r = rNew;
long long sNew = sOld - q * s;
sOld = s;
s = sNew;
long long tNew = tOld - q * t;
tOld = t;
t = tNew;
}
return sOld;
}
std::vector<long long> merge(std::vector<long long>& left,
std::vector<long long>& right,
long long* inv_count) {
std::vector<long long> output;
long long i = 0, j = 0;
while (i < left.size() && j < right.size()) {
if (left[i] <= right[j])
output.push_back(left[i++]);
else {
output.push_back(right[j++]);
*inv_count += (left.size() - i);
}
}
for (; i < left.size(); i++) output.push_back(left[i]);
for (; j < right.size(); j++) output.push_back(right[j]);
return output;
}
std::vector<long long> merge_sort(std::vector<long long>& input,
long long* inv_count) {
if (input.size() < 2) return input;
std::vector<long long> left, right;
long long middle = input.size() / 2;
for (long long i = 0; i < middle; i++) left.push_back(input[i]);
for (long long i = middle; i < input.size(); i++) right.push_back(input[i]);
auto L = merge_sort(left, inv_count);
auto R = merge_sort(right, inv_count);
return merge(L, R, inv_count);
}
long long countInversions(std::vector<long long>& dat) {
long long out = 0;
merge_sort(dat, &out);
return out;
}
void solve(int testID) {
int N;
std::cin >> N;
std::vector<int> dat(N);
std::set<int> found;
std::vector<long long> x;
for (int k = 0; k < N; ++k) {
std::cin >> dat[k];
if (dat[k] != -1) {
found.insert(dat[k]);
x.push_back(dat[k]);
}
}
long long existingInversions = countInversions(x);
existingInversions %= MOD;
std::vector<int> missing;
missing.push_back(-50);
for (int k = 1; k <= N; ++k) {
if (found.count(k) == 0) missing.push_back(k);
}
if (missing.size() == 1) {
std::cout << existingInversions << '\n';
return;
}
long long M = missing.size() - 1;
long long out = 0;
long long outStep = 0;
for (int k = 0; k < N; ++k) {
if (dat[k] > 0) {
int lo = 0;
int hi = missing.size();
while (hi - lo > 1) {
int curr = (lo + hi) / 2;
if (missing[curr] < dat[k])
lo = curr;
else
hi = curr;
}
int numMissingBelow = lo;
outStep += numMissingBelow;
} else {
out += outStep;
}
}
outStep = 0;
for (int k = N - 1; k >= 0; --k) {
if (dat[k] > 0) {
int lo = 0;
int hi = missing.size();
while (hi - lo > 1) {
int curr = (lo + hi) / 2;
if (missing[curr] < dat[k])
lo = curr;
else
hi = curr;
}
int numMissingBelow = lo;
outStep += M - numMissingBelow;
} else {
out += outStep;
}
}
long long numA = out;
long long denomA = M;
long long numB = (M * (M - 1)) / 2;
long long denomB = 2;
long long num = numA * denomB + numB * denomA;
long long denom = denomA * denomB;
long long g = gcd(num, denom);
num /= g;
denom /= g;
num += existingInversions * denom;
num %= MOD;
denom %= MOD;
long long denomInverse = gcdExtended(denom, MOD);
while (denomInverse < 0) denomInverse += MOD;
long long outFinal = (num * denomInverse) % MOD;
std::cout << outFinal << std::endl;
}
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout.precision(14);
gcdExtended(6, 11);
solve(0);
return 0;
}
| 6 |
#include <bits/stdc++.h>
const long long LINF = 1e18;
const int INF = 1e9;
const int M = 1e9 + 7;
const double EPS = 1e-9;
using namespace std;
string str;
set<int> s[2];
vector<vector<int> > ans;
int n = 0;
bool fl = 0;
int main() {
ios_base::sync_with_stdio(0);
cin >> str;
int len = str.length();
for (int i = 0; i < len; i++) s[str[i] - '0'].insert(i);
fl = str[0] - '0';
ans.resize(s[0].size() + 10);
while (!s[0].empty()) {
if (s[1].size() && *s[0].begin() > *s[1].begin()) {
fl = 1;
break;
}
int t = 0;
int pos = *s[0].begin();
ans[n].push_back(pos + 1);
s[0].erase(s[0].begin());
while (1) {
t = (t + 1) % 2;
auto it = s[t].upper_bound(pos);
if (it != s[t].end()) {
pos = *it;
s[t].erase(it);
ans[n].push_back(pos + 1);
} else {
if (!t) fl = 1;
break;
}
}
n++;
if (fl) break;
}
fl += s[1].size();
if (fl) {
cout << "-1";
return 0;
}
cout << n << "\n";
for (int i = 0; i < n; i++) {
int len = ans[i].size();
cout << len << " ";
for (int j = 0; j < len; j++) cout << ans[i][j] << " ";
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
int a[n], b[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
sort(a, a + n);
sort(b, b + n);
for (int i = 0; i < n; i++) cout << a[i] << " ";
cout << endl;
for (int i = 0; i < n; i++) cout << b[i] << " ";
cout << endl;
}
}
| 1 |
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <cctype>
#include <algorithm>
#include <random>
#include <bitset>
#include <queue>
#include <functional>
#include <set>
#include <map>
#include <vector>
#include <chrono>
#include <iostream>
#include <limits>
#include <numeric>
#define LOG(FMT...) fprintf(stderr, FMT)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
// mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <class T>
istream& operator>>(istream& is, vector<T>& v) {
for (T& x : v) is >> x;
return is;
}
template <class T>
ostream& operator<<(ostream& os, const vector<T>& v) {
if (!v.empty()) {
os << v.front();
for (int i = 1; i < v.size(); ++i) os << ' ' << v[i];
}
return os;
}
int main() {
#ifdef LBT
freopen("test.in", "r", stdin);
int nol_cl = clock();
#endif
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, m, k, a, b, c;
ll t;
cin >> n >> m >> k >> a >> b >> c >> t;
vector<int> s(m), cur(m);
cin >> s;
priority_queue<pair<int, int>> pq;
int ans = -1;
function<void(int)> update = [&](int i) {
if ((s[i] - 1) * (ll)b + (cur[i] - s[i]) * (ll)c <= t && cur[i] < s[i + 1]) {
int np = min(s[i + 1] - 1LL, cur[i] + (t - (s[i] - 1) * (ll)b - (cur[i] - s[i]) * (ll)c) / a);
pq.emplace(np - cur[i] + 1, i);
}
};
for (int i = 0; i < m - 1; ++i)
if ((s[i] - 1) * (ll)b <= t) {
int np = min(s[i + 1] - 1LL, s[i] + (t - (s[i] - 1) * (ll)b) / a);
cur[i] = np + 1;
ans += np - s[i] + 1;
update(i);
}
if ((s[m - 1] - 1) * (ll)b <= t)
++ans;
k -= m;
while (k-- && !pq.empty()) {
int upd, i;
tie(upd, i) = pq.top();
pq.pop();
ans += upd;
cur[i] += upd;
update(i);
}
cout << ans << '\n';
#ifdef LBT
LOG("Time: %dms\n", int((clock() - nol_cl) / (double)CLOCKS_PER_SEC * 1000));
#endif
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
pair<int, int> operator+(const pair<int, int> &a, const pair<int, int> &b) {
pair<int, int> n;
n.first = a.first + b.first;
n.second = a.second + b.second;
return n;
}
pair<int, int> segment[200020 * 5], lazy[200020 * 5], bs[200020];
int a, ar[200020];
long long top;
pair<int, int> crate(int k, int b, int s) {
if (b == s) return segment[k] = pair<int, int>(!ar[b], ar[b]);
return segment[k] = crate(2 * k, b, (b + s) / 2) +
crate(2 * k + 1, (b + s) / 2 + 1, s);
}
pair<int, int> update(int k, int b, int s, int x) {
if (s < x || b > x) return segment[k];
if (x <= b && s <= x) {
return segment[k] = pair<int, int>(0, 0);
}
segment[k] = update(2 * k, b, (b + s) / 2, x) +
update(2 * k + 1, (b + s) / 2 + 1, s, x);
return segment[k] + lazy[k];
}
pair<int, int> find(int k, int b, int s, int x, int y) {
if (s < x || b > y) return pair<int, int>(0, 0);
if (x <= b && s <= y) return segment[k] + lazy[k];
return find(2 * k, b, (b + s) / 2, x, y) +
find(2 * k + 1, (b + s) / 2 + 1, s, x, y) + lazy[k];
}
void al(int n) {
pair<int, int> t1 = find(1, 1, a, n + 1, a);
pair<int, int> t2 = find(1, 1, a, 1, n - 1);
top += (long long)t1.first + t2.second;
update(1, 1, a, n);
}
int main() {
scanf("%d", &a);
for (int i = 1; i <= a; i++) bs[i].second = i;
for (int i = 1; i <= a; i++) {
scanf("%d", &ar[i]);
if (ar[i])
bs[i].first = a - i + 1;
else
bs[i].first = i - 1;
}
sort(bs + 1, bs + 1 + a);
reverse(bs + 1, bs + 1 + a);
crate(1, 1, a);
for (int i = 1; i <= a; i++) al(bs[i].second);
printf("%I64d\n", top);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int ncnt;
struct Node {
Node *next[2];
} node[100100 * 60], *root;
void insert(long long x) {
Node *tmp = root;
for (int i = 59; i >= 0; i--) {
int k = (x & (1ll << i)) ? 1 : 0;
if (!tmp->next[k]) tmp->next[k] = &node[ncnt++];
tmp = tmp->next[k];
}
}
long long ask(long long x) {
Node *tmp = root;
long long ret = 0;
for (int i = 59; i >= 0; i--) {
int k = (x & (1ll << i)) ? 0 : 1;
if (!tmp->next[k])
k = k ^ 1;
else
ret |= 1ll << i;
tmp = tmp->next[k];
}
return ret;
}
int n;
long long a[100100];
int main() {
scanf("%d", &n);
root = &node[ncnt++];
for (int i = 0; i < n; i++) cin >> a[i];
insert(a[0]);
for (int i = 1; i < n; i++) {
a[i] ^= a[i - 1];
insert(a[i]);
}
long long tol = a[n - 1], ans = ask(tol);
for (int i = 0; i < n; i++) ans = max(ans, ask(tol ^ a[i]));
cout << ans << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5;
int To[N], Ne[N], St[N], Tor[N], Ner[N], Str[N], en;
inline __attribute__((always_inline)) void getedge() {
int u, v;
scanf("%d%d", &u, &v);
To[++en] = v, Ne[en] = St[u], St[u] = en;
Tor[en] = u, Ner[en] = Str[v], Str[v] = en;
}
bool f[N], s[N];
int p;
vector<int> ans;
void solve(int n) {
if (n == 0) return;
while (f[p]) ++p;
int u = p, cnt = 1;
f[u] = 1;
for (int i = St[u]; i; i = Ne[i])
if (!f[To[i]]) f[To[i]] = 1, ++cnt;
solve(n - cnt);
bool can = 1;
for (int i = Str[u]; i; i = Ner[i])
if (s[Tor[i]]) can = 0;
if (can) s[u] = 1, ans.push_back(u);
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
while (m--) getedge();
p = 1, solve(n);
printf("%u\n", ans.size());
for (int x : ans) printf("%d ", x);
return 0;
}
| 5 |
#include <bits/stdc++.h>
int main() {
int s;
int a, b, c;
double x, y, z, p;
while (scanf("%d", &s) != EOF) {
scanf("%d %d %d", &a, &b, &c);
p = 1.0 * (a + b + c) / s;
if (a + b + c == 0) {
x = 0, y = 0, z = 0;
printf("%.10lf %.10lf %.10lf\n", x, y, z);
continue;
}
x = a / p;
y = b / p;
z = c / p;
printf("%.10lf %.10lf %.10lf\n", x, y, z);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
map<long long, long long> mp;
for (long long i = 2; i <= 62; i++) {
long long x = (1LL << i) - 1LL;
for (long j = 0; j < i - 1; j++) {
long long y = 1LL << j;
mp[x - y]++;
}
}
map<long long, long long>::iterator it;
vector<long long> v;
for (it = mp.begin(); it != mp.end(); it++) {
long long x = it->first;
v.push_back(x);
}
long long n, m;
cin >> n >> m;
int cnt = 0;
for (auto x : v) {
if (n <= x && x <= m) cnt++;
}
cout << cnt << endl;
}
| 2 |
#include<cstdio>
#include<deque>
#include<algorithm>
using namespace std;
typedef pair<long long, int> P;
const long long inf = 1e18;
int M, N;
int K;
int A[100100];
long long dp[100100][330];
long long solve(){
for(int i = 0; i < N; ++i){
dp[i][1] = A[i];
}
for(int j = 2; j <= K; ++j){
deque<P> deq;
if(dp[0][j - 1] != -inf) deq.push_front(P(dp[0][j - 1], 0));
dp[0][j] = -inf;
for(int i = 1; i < N; ++i){
if(!deq.empty()){
if(deq.front().first == -inf){
dp[i][j] = -inf;
}else{
dp[i][j] = deq.front().first + (long long)A[i] * j;
}
while(!deq.empty()){
if(deq.back().first < dp[i][j - 1]){
deq.pop_back();
}else break;
}
deq.push_back(P(dp[i][j - 1], i));
if(deq.front().second == i - M){
deq.pop_front();
}
}else{
dp[i][j] = -inf;
if(dp[i][j - 1] != -inf){
deq.push_front(P(dp[i][j - 1], i));
}
}
}
}
long long ans = -1;
for(int i = 0; i < N; ++i){
/* for(int j = 0; j <= K; ++j){
printf("%lld ", dp[i][j]);
}
printf("\n");*/
ans = max(ans, dp[i][K]);
}
return ans;
}
void input(){
scanf("%d%d%d", &N, &M, &K);
for(int i = 0; i < N; ++i){
scanf("%d", A + i);
}
}
int main(){
input();
long long ans = solve();
printf("%lld\n", ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> s;
int cnt = 0;
for (int i = 0; i < n - 1; i++) {
if (s[i] == s[i + 1] && s[i] != '?') {
cout << "No\n";
return 0;
}
cnt += (s[i] == '?');
}
cnt += (s[n - 1] == '?');
if (cnt == 0) {
cout << "No\n";
return 0;
}
if (s[0] == '?' || s[n - 1] == '?') {
cout << "Yes\n";
return 0;
}
for (int i = 1; i < n - 1; i++) {
if (s[i] == '?') {
if (s[i - 1] != '?' && s[i + 1] != '?') {
if (s[i - 1] == s[i + 1]) {
cout << "Yes\n";
return 0;
}
} else {
cout << "Yes\n";
return 0;
}
}
}
cout << "No\n";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
struct DSU {
int n;
vector<int> e;
DSU(int _) : n(_) { e = vector<int>(n + 1, -1); }
inline int root(int x) { return (e[x] < 0 ? x : (e[x] = root(e[x]))); }
inline bool same(int x, int y) { return root(x) == root(y); }
inline bool join(int x, int y) {
x = root(x), y = root(y);
if (x == y) return false;
if (e[y] < e[x]) swap(x, y);
e[x] += e[y];
e[y] = x;
return true;
}
};
const int mxn = 200 * 1000 + 3, lgn = 18;
int up[mxn][lgn], mx[mxn][lgn], dt[mxn], ans[mxn];
vector<array<int, 3>> g[mxn];
set<array<int, 2>> wt[mxn];
int n, m;
void init(int v = 1, int p = 1) {
up[v][0] = p;
for (int i = 1; i < lgn; i++) {
up[v][i] = up[up[v][i - 1]][i - 1];
mx[v][i] = max(mx[up[v][i - 1]][i - 1], mx[v][i - 1]);
}
for (auto &[u, w, id] : g[v])
if (u != p) {
dt[u] = dt[v] + 1;
mx[u][0] = w;
init(u, v);
}
}
array<int, 2> kth(int v, int di) {
int x = 0;
for (int i = 0; i < lgn; i++)
if (di >> i & 1) {
x = max(x, mx[v][i]);
v = up[v][i];
}
return {v, x};
}
array<int, 2> lca(int a, int b) {
if (dt[a] > dt[b]) swap(a, b);
auto [c, res] = kth(b, dt[b] - dt[a]);
if (a == c) return {a, res};
for (int i = lgn - 1; i >= 0; i--)
if (up[a][i] != up[c][i]) {
res = max({res, mx[a][i], mx[c][i]});
a = up[a][i];
c = up[c][i];
}
res = max({res, mx[a][0], mx[c][0]});
return {up[a][0], res};
}
void dfs(int v = 1, int p = -1) {
for (auto &[u, w, i] : g[v])
if (u != p) {
dfs(u, v);
if (wt[u].empty())
ans[i] = -1;
else
ans[i] = (*wt[u].begin())[0] - 1;
if (wt[u].size() > wt[v].size()) swap(wt[u], wt[v]);
for (auto ed : wt[u]) {
if (wt[v].count(ed))
wt[v].erase(ed);
else
wt[v].insert(ed);
}
}
}
signed main() {
std::ios::sync_with_stdio(0);
std::cout.tie(0);
std::cin.tie(0);
cin >> n >> m;
DSU uf(n);
vector<array<int, 4>> ed(m);
for (int i = 0; i < m; i++) {
cin >> ed[i][1] >> ed[i][2] >> ed[i][0];
ed[i][3] = i;
ans[i] = -2;
}
sort(ed.begin(), ed.end());
for (auto &[w, u, v, i] : ed) {
if (uf.join(u, v)) {
g[u].push_back({v, w, i});
g[v].push_back({u, w, i});
} else {
wt[u].insert({w, i});
wt[v].insert({w, i});
}
}
init();
dfs();
for (auto &[w, u, v, i] : ed)
if (ans[i] < -1) ans[i] = lca(u, v)[1] - 1;
for (int i = 0; i < m; i++) cout << ans[i] << ' ';
cout << '\n';
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int n, k;
const int N = 1e5 + 10;
pair<int, int> a[N], b[N];
void solve() {
cin >> n >> k;
for (__typeof(n) i = 1; i <= n; i++) {
cin >> a[i].first;
a[i].second = i;
}
sort(a + 1, a + 1 + n);
int ans = 1;
for (__typeof(n) i = 2; i <= n; i++) {
if (a[i - 1].second + 1 != a[i].second) ans++;
}
if (ans <= k)
cout << "Yes\n";
else
cout << "No\n";
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
;
int t;
cin >> t;
for (__typeof(t) i = 1; i <= t; i++) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll DIM = 107, maxN = 10007, INF = 10000000000007, mod = 1000000007;
ll t, n, k, a[DIM], dp[maxN], p, b;
bool flag = false;
void solve() {
flag = false;
cin >> n >> k;
for (int i = 1; i <= n; ++i)
cin >> a[i];
sort(a + 1, a + n + 1);
p = 0;
for (int i = 1; i <= n; ++i) {
p += a[i];
if (p == k) {
if (i == n) flag = true;
b = a[i];
a[i] = a[n];
a[n] = b;
break;
}
}
if (flag) {
cout << "NO";
}
else {
cout << "YES\n";
for (int i = 1; i <= n; ++i)cout << a[i] << ' ';
}
cout << '\n';
}
//void solve() {
// flag = false;
// cin >> n;
// p = 1;
// for (int i = 1; i <= 30; ++i) {
// p *= 2;
// if (n == p)
// flag = true;
// }
// if (!flag)
// cout << "NO\n";
// else
// cout << "YES\n";
//}
int main() {
cin.tie(0);
cout.tie(0);
ios::sync_with_stdio(false);
cin >> t;
while (t--)
solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
class Truck {
public:
int v, c, l, r, idx;
Truck() {}
Truck(int v, int c, int l, int r) : v(v), c(c), l(l), r(r) {}
inline void init(int idx) {
this->idx = idx;
scanf("%d%d%d%d", &v, &c, &l, &r);
}
};
const int MAXN = 300030 + 1;
int n, dp[MAXN], pos[MAXN];
vector<int> updateList, ans;
map<int, vector<Truck> > disMap;
inline int calc(const vector<Truck>& truck, vector<int>& out) {
vector<int> path((int)truck.size());
dp[0] = 0;
pos[0] = -1;
for (int i = 0; i < (int)truck.size(); i++) {
if (dp[truck[i].l] == -1) continue;
if (dp[truck[i].l + truck[i].c] == -1)
updateList.push_back(truck[i].l + truck[i].c);
if (dp[truck[i].l + truck[i].c] < dp[truck[i].l] + truck[i].v) {
pos[truck[i].l + truck[i].c] = i;
path[i] = pos[truck[i].l];
dp[truck[i].l + truck[i].c] = dp[truck[i].l] + truck[i].v;
}
}
int res = dp[truck[0].l + truck[0].c + truck[0].r];
for (int i = 0; i < (int)updateList.size(); i++) dp[updateList[i]] = -1;
updateList.clear();
if (res == -1) return -1;
int o = pos[truck[0].l + truck[0].c + truck[0].r];
while (o != -1) {
out.push_back(truck[o].idx);
o = path[o];
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
Truck truck;
truck.init(i);
disMap[truck.l + truck.c + truck.r].push_back(truck);
}
memset(dp, 0xFF, sizeof(dp));
int res = 0;
for (map<int, vector<Truck> >::iterator iter = disMap.begin();
iter != disMap.end(); iter++) {
vector<int> out;
int tmpres = calc(iter->second, out);
if (tmpres > res) {
res = tmpres;
ans = out;
}
}
printf("%d\n", (int)ans.size());
for (int i = (int)ans.size() - 1; i >= 0; i--)
printf("%d%c", ans[i], i ? ' ' : '\n');
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
void fre() {
freopen("c://test//input.in", "r", stdin);
freopen("c://test//output.out", "w", stdout);
}
template <class T1, class T2>
inline void gmax(T1 &a, T2 b) {
if (b > a) a = b;
}
template <class T1, class T2>
inline void gmin(T1 &a, T2 b) {
if (b < a) a = b;
}
const int N = 305, M = 0, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
int n, m, T;
int t[3];
int a[N][N];
int gr[N][N];
int gl[N][N];
int gu[N][N];
int gd[N][N];
int tp(int x) {
if (x == 0) return t[0];
if (x > 0) return t[2];
if (x < 0) return t[1];
}
int check(int y1, int x1, int y2, int x2) {
int ret = 0;
ret += gr[y1][x2] - gr[y1][x1];
ret += gd[y2][x2] - gd[y1][x2];
ret += gl[y2][x1] - gl[y2][x2];
ret += gu[y1][x1] - gu[y2][x1];
return ret;
}
int main() {
while (~scanf("%d%d%d", &n, &m, &T)) {
scanf("%d%d%d", &t[0], &t[1], &t[2]);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) scanf("%d", &a[i][j]);
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= m; ++j) {
gr[i][j] = (j > 1) * (gr[i][j - 1] + tp(a[i][j - 1] - a[i][j]));
gd[i][j] = (i > 1) * (gd[i - 1][j] + tp(a[i - 1][j] - a[i][j]));
}
}
for (int i = n; i >= 1; --i) {
for (int j = m; j >= 1; --j) {
gl[i][j] = (j < m) * (gl[i][j + 1] + tp(a[i][j + 1] - a[i][j]));
gu[i][j] = (i < n) * (gu[i + 1][j] + tp(a[i + 1][j] - a[i][j]));
}
}
int ans = 1e9;
int sty, stx, edy, edx;
for (int i = 1; i <= n - 2; ++i) {
for (int j = 1; j <= m - 2; ++j) {
for (int y = i + 2; y <= n; ++y) {
for (int x = j + 2; x <= m; ++x) {
int tmp = abs(check(i, j, y, x) - T);
if (tmp < ans) {
ans = tmp;
sty = i;
stx = j;
edy = y;
edx = x;
}
}
}
}
}
printf("%d %d %d %d\n", sty, stx, edy, edx);
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, n, m;
scanf("%d", &n);
scanf("%d", &m);
if (n == 1 || m == 1) {
if (n > 2 || m > 2)
printf("1\n%d %d 1 1\n", n, m);
else
printf("0\n");
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) printf("%d %d\n", i, j);
printf("1 1\n");
return 0;
}
if (n % 2 == 0) {
printf("0\n1 1\n");
for (i = 1; i <= n; i++) {
if (i % 2)
for (j = 2; j <= m; j++) printf("%d %d\n", i, j);
else
for (j = m; j > 1; j--) printf("%d %d\n", i, j);
}
for (i = n; i >= 1; i--) printf("%d 1\n", i);
return 0;
}
if (m % 2 == 0) {
printf("0\n1 1\n");
for (i = 1; i <= m; i++) {
if (i % 2)
for (j = 2; j <= n; j++) printf("%d %d\n", j, i);
else
for (j = n; j > 1; j--) printf("%d %d\n", j, i);
}
for (i = m; i >= 1; i--) printf("1 %d\n", i);
return 0;
}
printf("1\n%d %d 1 1\n", n, m);
for (i = 1; i <= n; i++) {
if (i % 2)
for (j = 1; j <= m; j++) printf("%d %d\n", i, j);
else
for (j = m; j >= 1; j--) printf("%d %d\n", i, j);
}
printf("1 1\n");
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 5, MOD = 1e9 + 7;
vector<int> a[N];
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int g, x, i = 0; i < n; i++) {
scanf("%d", &g);
while (g--) {
scanf("%d", &x);
a[x].push_back(i);
}
}
sort(a + 1, a + 1 + m);
long long ans = 1, cnt = 1;
for (int i = 2; i <= m; i++) {
if (a[i] == a[i - 1])
ans = ans * (++cnt) % MOD;
else
cnt = 1;
}
printf("%I64d\n", ans);
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5, INF = 1e9;
bool check(int n, string s) {
for (int i = 1; i <= n; i++)
if (s[i] == '0') return false;
cout << 1 << ' ' << n - 1 << ' ' << 2 << ' ' << n << endl;
return true;
}
void sol(int n, string s) {
for (int i = 1; i <= n; i++)
if (s[i] == '0') {
if (i - 1 >= n / 2)
cout << 1 << " " << i << " " << 1 << " " << i - 1 << endl;
else
cout << i << " " << n << " " << i + 1 << " " << n << endl;
return;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n;
string s;
cin >> n >> s;
s = "#" + s;
if (!check(n, s)) sol(n, s);
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int md = 1e9 + 7;
const int maxn = 1e5 + 5;
struct Marix {
long long maze[2][2];
Marix() { memset(maze, 0, sizeof maze); }
void One() {
maze[0][0] = maze[1][1] = 1;
maze[0][1] = maze[1][0] = 0;
}
Marix operator+(const Marix& tmp) const {
Marix ret;
ret.maze[0][0] = (maze[0][0] + tmp.maze[0][0]) % md;
ret.maze[0][1] = (maze[0][1] + tmp.maze[0][1]) % md;
ret.maze[1][0] = (maze[1][0] + tmp.maze[1][0]) % md;
ret.maze[1][1] = (maze[1][1] + tmp.maze[1][1]) % md;
return ret;
}
Marix operator*(const Marix& tmp) const {
Marix ret;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 2; j++) {
for (int k = 0; k < 2; k++) {
ret.maze[i][j] += maze[i][k] * tmp.maze[k][j] % md;
ret.maze[i][j] %= md;
}
}
}
return ret;
}
} B;
Marix quick_pow(Marix a, long long k) {
Marix ans;
ans.One();
while (k) {
if (k & 1) ans = ans * a;
a = a * a;
k >>= 1;
}
return ans;
}
struct SegTree {
int l, r;
Marix sum, add;
void Add(const Marix& A) {
sum = A * sum;
add = A * add;
}
} tree[maxn << 2];
void push_up(int rt) {
tree[rt].sum = tree[rt << 1].sum + tree[rt << 1 | 1].sum;
}
void push_down(int rt) {
tree[rt << 1].Add(tree[rt].add);
tree[rt << 1 | 1].Add(tree[rt].add);
tree[rt].add.One();
}
void build(int l, int r, int rt) {
tree[rt].l = l;
tree[rt].r = r;
tree[rt].add.maze[0][0] = 1;
tree[rt].add.maze[0][1] = 0;
tree[rt].add.maze[1][0] = 0;
tree[rt].add.maze[1][1] = 1;
if (l == r) {
int x;
scanf("%d", &x);
tree[rt].sum = quick_pow(B, x);
return;
}
int mid = (l + r) >> 1;
build(l, mid, rt << 1);
build(mid + 1, r, rt << 1 | 1);
push_up(rt);
}
void update(int l, int r, int rt, const Marix& A) {
if (l <= tree[rt].l && tree[rt].r <= r) {
tree[rt].Add(A);
return;
}
push_down(rt);
int mid = (tree[rt].l + tree[rt].r) >> 1;
if (l <= mid) update(l, r, rt << 1, A);
if (mid < r) update(l, r, rt << 1 | 1, A);
push_up(rt);
}
Marix ans;
void query(int l, int r, int rt) {
if (l <= tree[rt].l && tree[rt].r <= r) {
ans = ans + tree[rt].sum;
return;
}
push_down(rt);
int mid = (tree[rt].l + tree[rt].r) >> 1;
if (l <= mid) query(l, r, rt << 1);
if (mid < r) query(l, r, rt << 1 | 1);
push_up(rt);
}
int main() {
B.maze[0][0] = B.maze[0][1] = B.maze[1][0] = 1;
int n, m, opt, l, r, x;
scanf("%d%d", &n, &m);
build(1, n, 1);
while (m--) {
scanf("%d", &opt);
if (opt == 1) {
scanf("%d%d%d", &l, &r, &x);
Marix A = quick_pow(B, x);
update(l, r, 1, A);
} else {
scanf("%d%d", &l, &r);
ans.maze[0][0] = ans.maze[0][1] = ans.maze[1][0] = ans.maze[1][1] = 0;
query(l, r, 1);
cout << ans.maze[0][1] << '\n';
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int e, k;
cin >> e;
int ar[e];
for (int i = 0; i < e; i++) cin >> ar[i];
for (int i = 0; i < e; i++) {
for (int j = i + 1; j < e; j++) {
if (ar[i] > ar[j]) {
k = ar[i];
ar[i] = ar[j];
ar[j] = k;
}
}
}
for (int w = 0; w < e; w++) {
if (w + 1 == e)
cout << ar[w] << endl;
else
cout << ar[w] << " ";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 50;
int n, q, type, x, y, p[2] = {1, 2};
double d, Sx, Sy, Sm;
struct point {
double x, y;
point operator+(point p) { return {x + p.x, y + p.y}; }
point operator-(point p) { return {x - p.x, y - p.y}; }
point operator*(double a) { return {x * a, y * a}; }
point operator/(double a) { return {x / a, y / a}; }
double operator*(point p) { return x * p.x + y * p.y; }
double operator^(point p) { return x * p.y - y * p.x; }
} g, a[maxn];
int read() {
int x = 0, sgn = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + (c ^ 48), c = getchar();
return x * sgn;
}
inline point rot(point p, double d) {
return {p.x * cos(d) - p.y * sin(d), p.y * cos(d) + p.x * sin(d)};
}
inline double deg(point p, point q) { return atan2(p ^ q, p * q); }
inline double dis(point p, point q = {0, 0}) {
return sqrt((p.x - q.x) * (p.x - q.x) + (p.y - q.y) * (p.y - q.y));
}
int main() {
n = read(), q = read();
for (int i = 1; i <= n; i++) a[i].x = read(), a[i].y = read();
for (int i = 2; i < n; i++) {
double m = ((a[i] - a[1]) ^ (a[i + 1] - a[1])) / 2;
point tg = (a[i] + a[i + 1] + a[1]) / 3;
Sx += tg.x * m, Sy += tg.y * m, Sm += m;
}
g = {Sx / Sm, Sy / Sm};
for (int i = 1; i <= n; i++) a[i] = a[i] - g;
for (int i = 1; i <= q; i++) {
type = read();
if (type == 1) {
x = read(), y = read();
if (x == p[0])
x = p[1];
else
x = p[0];
point t = g + rot(a[x], d);
d += deg(rot(a[x], d) * -1, {0, -1});
g = {t.x, t.y - dis(g, t)};
if (x == p[0])
p[1] = y;
else
p[0] = y;
} else {
x = read();
point p = g + rot(a[x], d);
printf("%f %f\n", p.x, p.y);
}
}
return 0;
}
| 5 |
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
int a[100][100], b[100];
int main() {
int n, m; cin >> n >> m;
rep(i, n)rep(j, m)cin >> a[i][j];
rep(i, m)cin >> b[i];
rep(i, n) {
int sum = 0;
rep(j, m)sum += a[i][j] * b[j];
cout << sum << endl;
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int w[5000], a[5000], fi[5000];
const int Inf = 1000000000;
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> w[i];
fi[i] = Inf;
}
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (w[j] > w[i]) {
if (fi[i] > a[j]) fi[i] = a[j];
}
}
}
int ans = Inf;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
if (w[j] > w[i]) {
if (fi[j] != Inf) {
if (a[i] + a[j] + fi[j] < ans) ans = a[i] + a[j] + fi[j];
}
}
}
}
if (ans == Inf)
cout << "-1" << endl;
else
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
typedef long double ld;
ld dp[302][302][302];
int n;
ld ds(int a, int b, int c) {
if(a+b+c == 0) {return 0;}
if(a < 0 || b < 0 || c < 0) {return 0;}
if(dp[a][b][c] != 0) {return dp[a][b][c];}
ld pa=a,pb=b,pc=c;
ld pz = n-(a+b+c);
pa /=n;
pb /=n;
pc /=n;
pz /=n;
ld ret = 1+(pa*ds(a-1,b,c))+(pb*ds(a+1,b-1,c))+(pc*ds(a,b+1,c-1));
return dp[a][b][c] = ret/(1-pz);
}
int main() {
scanf("%d ",&n);
int q[3];
memset(q,0,sizeof(q));
memset(dp,0,sizeof(dp));
for(int i=0;i<n;i++) {
int t;
scanf("%d ",&t);
t--;if(t>=0) {q[t]++;}
}
cout << setprecision(15) << ds(q[0],q[1],q[2]) << '\n';
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
long long s, k;
cin >> s >> k;
long long sum = 1;
vector<long long> v;
for (long long i = 0; i < k && sum <= s; i++) {
v.push_back(sum);
sum += v[i];
}
if (sum <= s) {
v.push_back(v.back() * 2 - 1);
sum = v.back() * 2 - 1;
}
for (long long i = 0; sum <= s; i++) {
v.push_back(v.back() * 2 - v[i]);
sum = v.back() * 2 - v[i];
}
vector<long long> b;
for (long long i = v.size() - 1; i >= 0; i--) {
if (s == 0) break;
if (v[i] <= s) {
s -= v[i];
b.push_back(v[i]);
}
}
if (b.size() < 2) b.push_back(0);
cout << b.size() << '\n';
for (auto it : b) cout << it << " ";
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long test = 1;
while (test--) solve();
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N, M;
signed long long L[202020], R[202020], MA[202020], MI[202020];
vector<signed long long> A;
int id[202020];
map<signed long long, vector<int> > EV;
void solve() {
int i, j, k, l, r, x, y;
string s;
cin >> N >> M;
for (i = 0; i < N; i++) cin >> L[i] >> R[i];
for (i = 0; i < M; i++) {
signed long long LL;
cin >> LL;
A.push_back(LL);
EV[A[i]].push_back(i + 1000000);
}
for (i = 0; i < N - 1; i++) {
MI[i] = L[i + 1] - R[i];
MA[i] = R[i + 1] - L[i];
EV[MI[i]].push_back(i);
}
set<pair<signed long long, int> > S;
for (auto& r : EV) {
vector<int> VV = r.second;
sort((VV.begin()), (VV.end()));
for (auto& ev : VV) {
if (ev < 1000000) {
S.insert({MA[ev], ev});
} else if (ev < 2000000) {
ev -= 1000000;
auto s = S.begin();
if (s == S.end()) continue;
x = s->second;
if (A[ev] > MA[x]) return (void)printf("No\n");
id[x] = ev + 1;
S.erase(s);
}
}
}
if (S.size()) return (void)printf("No\n");
(void)printf("Yes\n");
for (i = 0; i < N - 1; i++) (void)printf("%d ", id[i]);
(void)printf("\n");
}
int main(int argc, char** argv) {
string s;
int i;
if (argc == 1) ios::sync_with_stdio(false);
for (i = 0; i < argc - 1; i++) s += argv[i + 1], s += '\n';
for (i = 0; i < s.size(); i++) ungetc(s[s.size() - 1 - i], stdin);
solve();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 5;
int n;
map<int, int> od;
map<int, int> te;
vector<int> pr, af;
int a[3][maxn];
int main() {
cin >> n;
for (int i = 0; i < 3 * n; ++i) {
int x;
cin >> x;
od[x] = i + 1;
}
for (int i = 0; i < n; ++i) {
cin >> a[0][i] >> a[1][i] >> a[2][i];
te[a[0][i]] = te[a[1][i]] = te[a[2][i]] = i + 1;
}
int ro;
cin >> ro;
int tt = te[ro] - 1;
if (od[ro] <= od[a[0][tt]] && od[ro] <= od[a[1][tt]] &&
od[ro] <= od[a[2][tt]]) {
int mx = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 3; ++j)
if (a[j][i] != ro) {
if (i <= tt) {
if (i == tt) mx = max(mx, a[j][i]);
pr.push_back(a[j][i]);
} else {
af.push_back(a[j][i]);
}
}
}
sort(pr.begin(), pr.end());
for (int i = 0; i < pr.size(); ++i) {
if (pr[i] <= mx)
cout << pr[i] << ' ';
else
af.push_back(pr[i]);
}
sort(af.begin(), af.end());
for (int i = 0; i < af.size(); ++i) cout << af[i] << ' ';
cout << endl;
} else {
for (int i = 1; i <= 3 * n; ++i) {
if (i != ro) cout << i << ' ';
}
cout << endl;
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int dc[] = {1, 0, -1, 0};
int dr[] = {0, 1, 0, -1};
string b[55];
int *nxt[4][55];
int main() {
int m, n;
cin >> m >> n;
for (int i = 0; i < m; i++) {
cin >> b[i];
nxt[0][i] = new int[b[i].size()];
nxt[1][i] = new int[b[i].size()];
nxt[2][i] = new int[b[i].size()];
nxt[3][i] = new int[b[i].size()];
}
for (int i = 0; i < m; i++)
for (int j = b[i].size() - 1; j >= 0; j--)
nxt[0][i][j] = (j == b[i].size() - 1)
? j
: ((b[i][j] != b[i][j + 1]) ? j : nxt[0][i][j + 1]);
for (int i = 0; i < m; i++)
for (int j = b[i].size() - 1; j >= 0; j--)
nxt[3][i][j] =
(i == 0) ? i : ((b[i][j] != b[i - 1][j]) ? i : nxt[3][i - 1][j]);
for (int i = 0; i < m; i++)
for (int j = 0; j < b[i].size(); j++)
nxt[2][i][j] =
(j == 0) ? j : ((b[i][j] != b[i][j - 1]) ? j : nxt[2][i][j - 1]);
for (int i = m - 1; i >= 0; i--)
for (int j = b[i].size() - 1; j >= 0; j--)
nxt[1][i][j] =
(i == m - 1) ? i : ((b[i][j] != b[i + 1][j]) ? i : nxt[1][i + 1][j]);
int r = 0, c = 0;
int dp = 0;
int cp = -1;
for (int step = 0; step < n; step++) {
if (dp == 0 || dp == 2) {
c = nxt[dp][r][c];
r = nxt[(dp + cp + 4) % 4][r][c];
} else {
r = nxt[dp][r][c];
c = nxt[(dp + cp + 4) % 4][r][c];
}
int nextr = r + dr[dp];
int nextc = c + dc[dp];
if (nextr >= 0 && nextr < m && nextc >= 0 && nextc < b[0].size() &&
b[nextr][nextc] != '0')
r = nextr, c = nextc;
else {
if (cp == -1)
cp = 1;
else
cp = -1, dp = (dp + 1) % 4;
}
}
cout << b[r][c] << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(void){
int N,K;
vector<int> v(26);
cin>>N>>K;
for(int i=0; i<N; ++i){
string tmp;
cin>>tmp;
v[tmp[0]-'A']++;
}
//multiset<int> s(v.begin(),v.end());
int result=0;
sort(v.begin(),v.end());
while(true){
if(v.size()<K){
break;
}
//multiset<int>::iterator it=s.end();
for(int i=0; i<K; ++i){
v[v.size()-i-1]--;
}
result++;
sort(v.begin(),v.end());
if(v[0]<0){
result--;
break;
}
}
cout<<result<<endl;
return 0;
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
bool isLuckyNumber(ll num, ll d){
// checking if the number itself a lucky number,
// by checking if any of the digit is equal to d (his fav. number)
ll digit;
while(num>0){
digit = num%10;
if(digit == d) {
return true;
}
num /= 10;
}
return false;
}
void solve(){
ll n, d, num;
cin>>n>>d;
vector<ll> table(10, -1);
for(ll i=1; i<=10; i++){
if(table[(d*i)%10] < 0){
table[(d*i)%10] = i;
}
}
// for(ll i =0; i<=10; i++){
// cout<<"at i = "<<i<<" we have table[i] = "<<table[i]<<endl;
// }
while(n--){
cin>>num;
if(num>d*10){
cout<<"YES"<<endl;
continue;
}
if(isLuckyNumber(num, d)){
cout<<"YES"<<endl;
continue;
}
// checking if the number ends with a digit which is available in table[],
// available in table & less than equal to number:- it can written as sum of lucky numbers.
if( table[num%10] != -1){
if( table[num%10]*d <= num){
cout<<"YES"<<endl;
continue;
}
}
cout<<"NO"<<endl;
}
}
int main(){
int t;
cin>>t;
while(t--){
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, k;
long long x, y, ax, ay, bx, by;
long long sx, sy, t;
scanf("%lld %lld %lld %lld %lld %lld", &x, &y, &ax, &ay, &bx, &by);
scanf("%lld %lld %lld", &sx, &sy, &t);
vector<pair<long long, long long> > data;
while (x <= ((long long)8) * ((long long)1e16) &&
y <= ((long long)8) * ((long long)1e16)) {
data.push_back({x, y});
x = ax * x + bx;
y = ay * y + by;
}
long long res = 0;
for (i = 0; i < data.size(); i++) {
long long step, tres = 0;
step = (long long)abs(data[i].first - sx) +
(long long)abs(data[i].second - sy);
if (step <= t) {
tres = 1;
for (j = i + 1; j < data.size(); j++) {
step += (long long)abs(data[j].first - data[j - 1].first) +
(long long)abs(data[j].second - data[j - 1].second);
if (step > t) break;
tres++;
}
}
res = max(res, tres);
}
for (i = 0; i < data.size(); i++) {
long long step, tres = 0;
step = (long long)abs(data[i].first - sx) +
(long long)abs(data[i].second - sy);
if (step <= t) {
tres = 1;
for (j = i - 1; j >= 0; j--) {
step += (long long)abs(data[j].first - data[j + 1].first) +
(long long)abs(data[j].second - data[j + 1].second);
if (step > t) break;
tres++;
}
}
res = max(res, tres);
}
printf("%lld", res);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 2e5 + 6;
long long a[MAX_N];
int main() {
int n, k;
while (scanf("%d %d", &n, &k) != EOF) {
for (int i = 1; n >= i; i++) {
scanf("%lld", &a[i]);
}
long long pre = 0;
long long _n = n;
long long _i = 2;
for (int i = 2; n >= i; i++) {
long long d = pre - (_i - 1) * (_n - _i) * a[i];
if (d < k) {
printf("%d\n", i);
_n--;
} else {
pre += a[i] * (_i - 1);
_i++;
}
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
int n;
int Max1, Max2;
int main(int argc, char const *argv[]) {
scanf("%d", &n);
int Pos;
for (int i = 1; i <= n; i++) {
scanf("%d", &Pos);
if (Pos <= 500000) {
Max1 = max(Max1, Pos - 1);
} else {
Max2 = max(Max2, 1000000 - Pos);
}
}
printf("%d\n", max(Max1, Max2));
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int i, j, k, t, c, n;
cin >> n;
int a[n];
int b[n];
for (i = 0; i < n; i++) cin >> a[i];
;
for (i = 0; i < n - 1; i++) {
b[i] = abs(a[i] - a[i + 1]);
}
long long ans = 0;
long long sum = 0;
for (i = 0; i < n - 1; i++) {
if (i % 2) {
sum -= b[i];
} else
sum += b[i];
if (sum < 0) sum = 0;
if (sum > ans) ans = sum;
}
sum = 0;
for (i = 1; i < n - 1; i++) {
if (i % 2 == 0) {
sum -= b[i];
} else
sum += b[i];
if (sum < 0) sum = 0;
if (sum > ans) ans = sum;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define vi vector<int>
#define vvi vector<vector<int> >
#define vb vector<bool>
#define vpii vector<pair<int,int> >
#define pii pair<int,int>
#define mii map<int,int>
#define mod 1000000007
#define pb push_back
#define ff first
#define ss second
#define mkp make_pair
#define input(a,b,n) for(i=b;i<n;i++){cin>>a[i];}
#define print(a,b,n) for(i=b;i<n;i++){cout<<a[i]<<" ";}cout<<endl;
#define shadj(n) for(i=1;i<=n;i++){cout<<i<<"->";for(j=0;j<a[i].size();j++){cout<<a[i][j]<<" ";}cout<<endl;}
const int inf=0x3f3f3f3f3f3f3f3f;
ll power(ll a, ll b){
ll res = 1;
while(b!=0){
if(b&1){
res *= a;
}
a = (a * a);
b = (b / 2);
}
return res;
}
ll fac[100001];
void factorial(ll n)
{
fac[0] = 1;
for (ll i = 1; i <= n; i++)
{
//cout<<"ERRE";
fac[i] = (fac[i - 1] * i)%mod;
fac[i] %= mod;
}
}
ll ncr(ll n, ll r)
{
if(n<0)
return (ll)0;
ll nn=fac[n];
nn/=fac[r];
nn/=fac[n-r];
return nn;
}
int32_t main()
{
//ios_base::sync_with_stdio(false);
//cin.tie(NULL);
//cout.tie(NULL);
//freopen("input.txt", "r", stdin);freopen("output.txt", "w", stdout);
ll i,j,k,l,n,m,t;
t=1;
cin>>t;
while(t--)
{
cin>>n;
set<ll> a;
ll f=0;
for(i=0;i<n;i++)
{
cin>>k;
a.insert(k);
if(k<0)
f=1;
}
if(f==1)
{
cout<<"NO\n";
continue;
}
ll x,y;
x=a.size();
y=0;
set<ll> ::iterator p,q;
k=0;
while(x!=y)
{
x=a.size();
if(k<=300)
k++;
else
break;
for(p=a.begin();p!=a.end();p++)
{
q=p;
q++;
for(;q!=a.end();q++)
{
a.insert(abs(*p-*q));
}
}
y=a.size();
}
if(a.size()<=300)
{
cout<<"YES\n"<<a.size()<<"\n";
for(p=a.begin();p!=a.end();p++)
{
cout<<*p<<" ";
}
}
else
{
cout<<"NO";
}
cout<<endl;
}
return 0;
}
| 1 |
// luogu-judger-enable-o2
#include <bits/stdc++.h>
using namespace std;
long long st;
long long n,x,y,z;
int state;
const long long si=1e9+7;
long long dp[45][1<<17];
int main()
{
scanf("%d%d%d%d",&n,&x,&y,&z);
long long ans=1;
for (int i=1;i<=n;i++)
ans=(ans*10)%si;
st=(1<<z-1)|(1<<z+y-1)|(1<<(x+y+z-1));
state=(1<<x+y+z)-1;
dp[0][0]=1;
for (int i=1;i<=n;i++)
for (int j=0;j<=state;j++)
{
if (dp[i-1][j]==0)
continue;
for (int k=1;k<=10;k++)
{
int noww=(j<<k)|(1<<k-1);
noww=noww&state;
if ((noww&st)!=st)
dp[i][noww]=(dp[i][noww]+dp[i-1][j])%si;
}
}
for (int i=0;i<=state;i++)
ans=(ans-dp[n][i]+si)%si;
cout<<ans<<endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int hash2[1003], hash1[1003];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long int n, m;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
long long int a, b;
cin >> a >> b;
hash2[a] = 1;
hash1[b] = 1;
}
long long int mid;
for (int i = 1; i <= n; i++) {
if (hash2[i] == 0 && hash1[i] == 0) {
mid = i;
}
}
cout << n - 1 << "\n";
for (int i = 1; i <= n; i++) {
if (i != mid) cout << i << " " << mid << "\n";
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const long long _n = 1e5 + 1, inf = 1e9;
long long ans, chk, n, k;
int main() {
cin >> n >> k;
for (long long i = k - 1; i >= 0; i--) {
if (n % i == 0) {
ans = (n / i) * k + i;
break;
}
}
cout << ans;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long int n, m;
long long int mn(long long int x, long long int y) {
long long int z = x / y;
long long int a = x % y;
long long int ans = 0;
for (long long int i = 0; i < a; i++) {
ans = ans + (1ll * (((z + 1) * (z)) / 2));
}
for (long long int i = 0; i < y - a; i++)
ans = ans + (1ll * (((z) * (z - 1)) / 2));
return ans;
}
long long int mx(long long int x, long long int y) {
long long int z = x - y + 1;
return (1ll * (((z) * (z - 1)) / 2));
}
int main() {
cin >> n >> m;
cout << 1ll * mn(n, m) << " ";
cout << 1ll * mx(n, m) << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
inline long long toLongLong(string s) {
long long v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T>
inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
inline vector<char> toVC(string s) {
vector<char> data(s.begin(), s.end());
return data;
}
template <typename T1, typename T2>
istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <typename T>
istream &operator>>(istream &in, vector<T> &v) {
for (auto &x : v) in >> x;
return in;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const std::pair<T1, T2> &p) {
out << "[" << p.first << ", " << p.second << "]"
<< "\n";
return out;
}
template <class T>
void chmin(T &a, const T b) {
a = min(a, b);
}
template <class T>
void chmax(T &a, const T b) {
a = max(a, b);
}
int main() {
int T;
cin >> T;
while (T--) {
vector<long long> a(3);
cin >> a;
sort((a).rbegin(), (a).rend());
if (a[0] > a[1] + a[2]) {
cout << a[1] + a[2] << endl;
} else {
cout << accumulate((a).begin(), (a).end(), 0LL) / 2 << endl;
}
}
}
| 1 |
#include <bits/stdc++.h>
const long long INF = (long long)1e18L;
struct Edge {
int from, to;
long long time;
};
bool operator<(const Edge& a, const Edge& b) {
if (a.time < b.time) return true;
if (a.time > b.time) return false;
return a.from < b.from || (a.from == b.from && a.to < b.to);
}
bool operator>(const Edge& a, const Edge& b) { return b < a; }
struct PlanetManager {
std::vector<long long> time, delay;
PlanetManager(const std::vector<long long>& list = {}) : time(list) {
const int n = (int)list.size();
delay.assign(n, 1);
for (int i = n - 2; i >= 0; --i) {
if (time[i] + 1 == time[i + 1]) {
delay[i] = delay[i + 1] + 1;
} else {
delay[i] = 1;
}
}
}
long long getDelay(long long tArrival) const {
auto it = std::lower_bound(time.begin(), time.end(), tArrival);
if (it == time.end() || *it != tArrival) {
return 0;
}
return delay[int(it - time.begin())];
}
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(0);
std::cout.tie(0);
std::cerr.tie(0);
int n, m;
while (std::cin >> n >> m) {
std::vector<std::vector<Edge>> edges(1 + n);
for (int i = 0; i < m; ++i) {
int u, v;
long long t;
std::cin >> u >> v >> t;
edges[u].push_back(Edge{u, v, t});
edges[v].push_back(Edge{v, u, t});
}
std::vector<PlanetManager> planets(1 + n);
for (int idPlanet = 1; idPlanet <= n; ++idPlanet) {
int cnt;
std::cin >> cnt;
std::vector<long long> time(cnt);
for (auto& it : time) {
std::cin >> it;
}
planets[idPlanet] = PlanetManager(time);
}
std::vector<long long> minTime(1 + n, INF);
std::priority_queue<Edge, std::vector<Edge>, std::greater<Edge>> queue;
queue.push(Edge{0, 1, 0});
while (!queue.empty()) {
auto temp = queue.top();
queue.pop();
int prev = temp.from, curr = temp.to;
long long time = temp.time;
if (minTime[curr] <= time) {
continue;
}
minTime[curr] = time;
time += planets[curr].getDelay(time);
for (const auto& e : edges[curr]) {
int next = e.to;
long long nextTime = time + e.time;
if (minTime[next] > nextTime) {
queue.push(Edge{curr, next, nextTime});
}
}
}
long long answ = (minTime[n] == INF) ? -1 : minTime[n];
std::cout << answ << std::endl;
}
return 0;
}
| 2 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.