solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
long long n, aib[200002], x;
long long poz[200002];
long long lol[200002];
void update(long long aib[], long long poz, long long val) {
for (long long i = poz; i <= n; i += (i & -i)) aib[i] += val;
}
long long query(long long aib[], long long poz) {
long long sum = 0;
for (long long i = poz; i; i -= (i & -i)) sum += aib[i];
return sum;
}
long long cb(long long aib[], long long val) {
long long ans = 0;
long long sum = 0;
for (long long pas = (1 << 17); pas; (pas >>= 1))
if (ans + pas <= n && sum + aib[ans + pas] < val) {
sum += aib[ans + pas];
ans += pas;
}
return ans + 1;
}
long long gauss(long long a, long long b) {
if (a > b) return 0;
return 1ll * (b - a + 1) * (a + b) / 2;
}
int main() {
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> x;
poz[x] = i;
}
long long lmao = 0;
for (long long i = 1; i <= n; i++) {
update(aib, poz[i], 1);
update(lol, poz[i], poz[i]);
lmao += query(aib, n) - query(aib, poz[i]);
long long poz = cb(aib, (i + 1) / 2);
long long a = query(lol, poz), b = query(lol, n) - query(lol, poz);
cout << gauss(poz - (i + 1) / 2 + 1, poz) - a -
gauss(poz + 1, poz + (i - (i + 1) / 2)) + b + lmao
<< " ";
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int p[] = {2, 3, 5, 7, 11};
int a[1000000], cnt[5], n, lmt;
void dfs(int x, int pre) {
if (x > lmt) return;
if (x > 1) a[n++] = x;
for (int i = pre; i < 5; ++i) dfs(x * p[i], i);
}
bool check(int k) {
memset(cnt, 0, sizeof(cnt));
for (int i = 0; i < k; ++i)
for (int j = 0; j < 5; ++j)
if (a[i] % p[j] == 0) ++cnt[j];
for (int i = 0; i < 5; ++i)
if (cnt[i] && cnt[i] * 2 < k) return false;
return true;
}
int main() {
srand(time(0));
int k;
cin >> k;
lmt = 2 * k * k;
dfs(1, 0);
while (true) {
random_shuffle(a, a + n);
if (check(k)) break;
}
for (int i = 0; i < k; ++i) printf("%d%c", a[i], i == k - 1 ? '\n' : ' ');
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll mod = 1e9+7;
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
int n,k,a;
cin >> n >> k;
vector<ll> cnt(k+1);
cnt[0] = 1;
for(int i = 0; i < n; ++i){
cin >> a;
ll tmp = 0;
for(int j = k; j >= k-a; --j) tmp = (tmp+cnt[j])%mod;
for(int j = k; j > 0; --j){
tmp = (tmp-cnt[j])%mod;
cnt[j] = (cnt[j]+tmp)%mod;
if(j-a > 0) tmp = (tmp+cnt[j-a-1])%mod;
}
}
cout << (cnt[k]+mod)%mod;
return 0;
} | 0 |
#include <iostream>
using namespace std;
int main(){
int n,t,c[200],a[200],i,ans=10000;
cin >> n >> t;
for(i=0;i<n;i++){
cin >> c[i] >> a[i];
if(a[i]>t) continue;
ans = min(ans,c[i]);
}
if(ans!=10000){
cout << ans << endl;
}else{
cout <<"TLE" << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
cout << (n - 4) / 2;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i;
cin >> n;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
if (n > 1) {
if (n == 2 && a[0] == a[1])
cout << -1 << endl;
else {
for (i = 0; i < n - 1; i++) {
if (a[i] < a[i + 1]) break;
}
cout << 1 << endl << i + 1 << endl;
}
} else {
cout << -1 << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
cin >> s;
long long int n = s.size();
long long int a[n];
for (int i = 0; i < n; i++) {
a[i] = s[i] - '0';
}
long long int sum = 0, ans = 0, p = 1;
for (long long int i = n - 1; i >= 0; i--) {
long long int k =
(((i * (i + 1)) / 2) % 1000000007 * p % 1000000007 + sum) % 1000000007;
sum = (sum + ((n - i) * p) % 1000000007) % 1000000007;
p = (p * 10) % 1000000007;
ans = (ans + (a[i] * k) % 1000000007) % 1000000007;
}
cout << ans << '\n';
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
enum { North, East, South, West };
int mi[] = {-1, 0, 1, 0, -1, 1, 1, -1};
int mj[] = {0, 1, 0, -1, 1, 1, -1, -1};
class node {
public:
int o, x, y, v;
node(){};
node(int _o, int _x, int _y, int _v) { o = _o, x = _x, y = _y, v = _v; }
};
const int MN = 101;
stack<node> data;
int n, m, q;
int mat[MN][MN];
void row(int p) {
int x = mat[p][m - 1];
for (int i = m - 1; i > 0; i--) {
mat[p][i] = mat[p][i - 1];
}
mat[p][0] = x;
}
void col(int p) {
int x = mat[n - 1][p];
for (int i = n - 1; i > 0; i--) {
mat[i][p] = mat[i - 1][p];
}
mat[0][p] = x;
}
void init() {
freopen("in.txt", "r", stdin);
freopen("out.txt", "w", stdout);
cout << "[FREOPEN]" << endl;
return;
}
int main() {
memset(mat, 0, sizeof(mat));
scanf("%d %d %d", &n, &m, &q);
while (q--) {
int o;
scanf("%d", &o);
if (o == 1) {
int x;
scanf("%d", &x);
x--;
data.push(node(o, x, -1, -1));
} else if (o == 2) {
int x;
scanf("%d", &x);
x--;
data.push(node(o, x, -1, -1));
} else {
int x, y, v;
scanf("%d %d %d", &x, &y, &v);
x--, y--;
data.push(node(o, x, y, v));
}
}
while (!data.empty()) {
int o = data.top().o;
if (o == 1) {
int x = data.top().x;
row(x);
} else if (o == 2) {
int x = data.top().x;
col(x);
} else {
int x = data.top().x;
int y = data.top().y;
int v = data.top().v;
mat[x][y] = v;
}
data.pop();
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
j > 0 ? printf(" ") : NULL;
printf("%d", mat[i][j]);
}
printf("\n");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int n, d[1001], a = 1;
string s;
int main() {
cin >> s;
n = s.size();
for (int i = n - 1; i >= 0; i--) {
d[i] = 1;
for (int j = i + 1; j < n; j += 2)
if (s[j] == s[i] && d[j] >= d[i]) a = max(a, d[i] = d[j] + 1);
}
cout << a;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int arr[305];
string get(int x) {
string temp = "";
while (x > 0) {
temp += min(9, x) + '0';
x -= 9;
}
reverse(temp.begin(), temp.end());
return temp;
}
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> arr[i];
string last = get(arr[0]);
cout << last << '\n';
for (int i = 1; i < n; i++) {
string temp = "";
int diff = arr[i] - arr[i - 1];
if (diff <= 0) {
int cnt = 0, ch = -1;
for (int j = 0; j < last.size(); j++) {
cnt += last[j] - '0';
if (cnt >= arr[i]) {
ch = j - 1;
break;
}
}
while (ch >= 0 && last[ch] == '9') ch--;
if (ch == -1) {
temp = "1";
for (int j = 0; j < last.size(); j++) temp += "0";
diff = arr[i] - 1;
for (int j = temp.size() - 1; j >= 0 && diff > 0; j--) {
temp[j] = min(9, diff) + '0';
diff -= 9;
}
cout << temp << '\n';
last = temp;
continue;
}
temp = last;
temp[ch]++;
diff = arr[i];
for (int j = 0; j <= ch; j++) diff -= temp[j] - '0';
for (int j = ch + 1; j < temp.size(); j++) temp[j] = '0';
for (int j = temp.size() - 1; j >= 0 && diff > 0; j--) {
temp[j] = min(9, diff) + '0';
diff -= 9;
}
} else {
int cnt = 0, ch = -1;
for (int j = last.size() - 1; j >= 0; j--) {
cnt += '9' - last[j];
if (cnt >= diff) {
ch = j;
break;
}
}
if (ch == -1) {
string x = get(arr[i]);
if (x.size() > last.size() || (x.size() == last.size() && x > last)) {
temp = x;
cout << temp << '\n';
last = temp;
continue;
}
temp = "1";
for (int j = 0; j < last.size(); j++) temp += "0";
diff = arr[i] - 1;
for (int j = temp.size() - 1; j >= 0 && diff > 0; j--) {
temp[j] = min(9, diff) + '0';
diff -= 9;
}
cout << temp << '\n';
last = temp;
continue;
}
temp = last;
for (int j = temp.size() - 1; j >= 0 && diff > 0; j--) {
int x = min('9' - temp[j], diff);
temp[j] += x;
diff -= x;
}
}
cout << temp << '\n';
last = temp;
}
return 0;
}
| 3 |
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<algorithm>
#include<queue>
#include<set>
#include<map>
#include<iostream>
using namespace std;
#define ll long long
#define REP(a,b,c) for(int a=b;a<=c;a++)
#define re register
#define file(a) freopen(a".in","r",stdin);freopen(a".out","w",stdout)
typedef pair<int,int> pii;
#define mp make_pair
inline int gi()
{
int f=1,sum=0;char ch=getchar();
while(ch>'9' || ch<'0'){if(ch=='-')f=-1;ch=getchar();}
while(ch>='0' && ch<='9'){sum=(sum<<3)+(sum<<1)+ch-'0';ch=getchar();}
return f*sum;
}
const int N=1000010;
int h,w,n,ans,mx[N<<1],tag[N<<1];
struct node
{
int x,y;
bool operator<(const node &b)const{return x<b.x||(x==b.x&&y<b.y);}
}p[N];
void puttag(int o,int x){tag[o]+=x;mx[o]+=x;}
void pushdown(int o){puttag(o<<1,tag[o]);puttag(o<<1|1,tag[o]);tag[o]=0;}
void pushup(int o){mx[o]=max(mx[o<<1],mx[o<<1|1]);}
void modify(int o,int l,int r,int posl,int posr,int v)
{
if(posl<=l&&r<=posr){puttag(o,v);return;}
int mid=(l+r)>>1;pushdown(o);
if(posl<=mid)modify(o<<1,l,mid,posl,posr,v);
if(mid<posr)modify(o<<1|1,mid+1,r,posl,posr,v);
pushup(o);
}
pii a[N],b[N];
//a是单调减，b是单调增。
void solve()
{
memset(tag,0,sizeof(tag));memset(mx,0,sizeof(mx));
sort(p+1,p+n+1);int l=0,r=0;
for(int i=1;i<n;i++)
{
if(p[i].y<=h/2)
{
int lst=i-1;
while(l&&p[i].y>a[l].second)
{
modify(1,1,n,a[l].first,lst,a[l].second-p[i].y);
lst=a[l].first-1;l--;
}
if(lst!=i-1)a[++l]=mp(lst+1,p[i].y);
}
else
{
int lst=i-1;
while(r&&p[i].y<b[r].second)
{
modify(1,1,n,b[r].first,lst,p[i].y-b[r].second);
lst=b[r].first-1;r--;
}
if(lst!=i-1)b[++r]=mp(lst+1,p[i].y);
}
modify(1,1,n,i,i,h-p[i].x);
a[++l]=mp(i,0);b[++r]=mp(i,h);
ans=max(ans,p[i+1].x+mx[1]);
}
}
int main()
{
w=gi();h=gi();n=gi();
for(int i=1;i<=n;i++)p[i].x=gi(),p[i].y=gi();
p[++n]=(node){0,0};p[++n]=(node){w,h};
solve();
for(int i=1;i<=n;i++)swap(p[i].x,p[i].y);swap(h,w);
solve();
printf("%d\n",ans*2);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int n, k, lg[1 << N];
long double p[N], ps[1 << N], dp[1 << N];
vector<int> opt_mask;
int32_t main() {
cin >> n >> k;
for (int i = 0; i < n; i++) cin >> p[i];
int cnt = 0;
for (int i = 0; i < n; i++)
if (p[i] == 0) cnt++;
k = min(k, n - cnt);
int tmp = 1;
for (int i = 0; i < N; i++) {
lg[tmp] = i;
tmp <<= 1;
}
ps[0] = 0;
for (int i = 1; i < (1 << n); i++) {
int bit = i & (-i);
ps[i] = ps[i ^ bit] + p[lg[bit]];
}
int rev = (1 << n) - 1;
dp[0] = 1;
for (int i = 0; i < n; i++) dp[1 << i] = p[i];
for (int mask = 1; mask < (1 << n); mask++) {
if (__builtin_popcount(mask) == 1) continue;
bool flag = false;
for (int i = 0; i < n; i++)
if (((mask >> i) & 1) && p[i] == 0) flag = true;
if (flag) {
dp[mask] = 0;
;
continue;
}
for (int i = 0; i < n; i++)
if ((mask >> i) & 1) {
dp[mask] += dp[mask ^ (1 << i)] * (p[i] / (ps[mask ^ (1 << i) ^ rev]));
}
}
for (int mask = 0; mask < (1 << n); mask++)
if (__builtin_popcount(mask) == k) opt_mask.push_back(mask);
for (int i = 0; i < n; i++) {
long double res = 0;
for (int mask : opt_mask)
if (((mask >> i) & 1)) res += dp[mask];
cout << fixed << setprecision(10) << res << ' ';
}
cout << endl;
}
| 3 |
#include <iostream>
#include <map>
#include <cstring>
using namespace std;
#define mk make_pair
int main(){
map<char, string> former;
former['A'] = "00000";
former['B'] = "00001";
former['C'] = "00010";
former['D'] = "00011";
former['E'] = "00100";
former['F'] = "00101";
former['G'] = "00110";
former['H'] = "00111";
former['I'] = "01000";
former['J'] = "01001";
former['K'] = "01010";
former['L'] = "01011";
former['M'] = "01100";
former['N'] = "01101";
former['O'] = "01110";
former['P'] = "01111";
former['Q'] = "10000";
former['R'] = "10001";
former['S'] = "10010";
former['T'] = "10011";
former['U'] = "10100";
former['V'] = "10101";
former['W'] = "10110";
former['X'] = "10111";
former['Y'] = "11000";
former['Z'] = "11001";
former[' '] = "11010";
former['.'] = "11011";
former[','] = "11100";
former['-'] = "11101";
former['\''] = "11110";
former['?'] = "11111";
map<string, char> later;
later["101"] = ' ';
later["000000"] = '\'';
later["000011"] = ',';
later["10010001"] = '-';
later["010001"] = '.';
later["000001"] = '?';
later["100101"] = 'A';
later["10011010"] = 'B';
later["0101"] = 'C';
later["0001"] = 'D';
later["110"] = 'E';
later["01001"] = 'F';
later["10011011"] = 'G';
later["010000"] = 'H';
later["0111"] = 'I';
later["10011000"] = 'J';
later["0110"] = 'K';
later["00100"] = 'L';
later["10011001"] = 'M';
later["10011110"] = 'N';
later["00101"] = 'O';
later["111"] = 'P';
later["10011111"] = 'Q';
later["1000"] = 'R';
later["00110"] = 'S';
later["00111"] = 'T';
later["10011100"]= 'U';
later["10011101"] = 'V';
later["000010"] = 'W';
later["10010010"] = 'X';
later["10010011"] = 'Y';
later["10010000"] = 'Z';
string s;
while( getline(cin, s) ){
string ans = "";
for( int i = 0; i < s.size(); i++ ){
ans += former[s[i]];
}
s = ans;
ans = "";
for( int i = 0; i < s.size(); i++ ){
for( int j = 1; i+j <= s.size(); j++ ){
if( later.find(s.substr(i,j)) == later.end() ) continue;
ans += later[s.substr(i,j)];
i = i+j-1;
break;
}
}
cout << ans << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
long long n, sol = 0, modul = 1000000007;
vector<long long> parent, depth;
long long where(long long pos) {
if (parent[pos] == -1) return pos;
long long a = depth[pos];
long long b = parent[pos];
long long c = where(parent[pos]);
parent[pos] = c;
depth[pos] = (a + depth[b]) % modul;
return c;
}
void uniona(long long a, long long x, long long b) {
long long wa = where(a);
if (wa == b) return;
sol = (sol + x + depth[a]) % modul;
depth[wa] = (x + depth[a]) % modul;
parent[wa] = b;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cin >> n;
parent.assign(n, -1);
depth.assign(n, 0);
for (long long i = 0; i < n; i++) {
long long k;
cin >> k;
for (long long j = 0; j < k; j++) {
long long a, b;
cin >> a >> b;
a--;
uniona(a, b, i);
}
}
cout << (sol + modul) % modul << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int c = 0;
void bfs(map<long long int, vector<long long int> > &map, vector<bool> &visited,
long long int x) {
queue<long long int> q;
q.push(x);
visited[x] = true;
while (!q.empty()) {
long long int y = q.front();
q.pop();
for (long long int i : map[y]) {
if (!visited[i]) {
q.push(i);
visited[i] = true;
}
}
}
}
int main() {
long long int x, y, n, m;
cin >> n >> m;
map<long long int, vector<long long int> > map;
std::vector<bool> visited(n + 1, false), visitedf(n + 1, false);
for (long long int i = 0; i < m; i++) {
cin >> x >> y;
map[x].push_back(y);
map[y].push_back(x);
}
if (m != n - 1) {
cout << "no";
return 0;
}
bfs(map, visited, map.begin()->first);
for (long long int i = 1; i <= n; i++) {
if (!visited[i]) {
cout << "no";
return 0;
}
}
cout << "yes";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c;
cin >> a >> b >> c;
a = a - b;
int k = abs(a);
if (k > c && a > 0)
cout << '+';
else if (k > c && a < 0)
cout << '-';
else if (c == 0 && a == 0)
cout << 0;
else
cout << '?';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
cout << max(n, m) - 1 << ' ' << min(n, m);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T>
inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
const long long INF = 1e18;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
vector<int> a(2), b(1);
a[1] = 1;
b[0] = 1;
int N;
cin >> N;
for (int i = 1; i < N; i++) {
vector<int> c(i + 2);
for (int j = 0; j < a.size(); j++) {
c[j + 1] = a[j];
}
for (int k = -1; k <= 1; k += 2) {
for (int j = 0; j < b.size(); j++) {
c[j] += k * b[j];
}
bool ok = true;
for (int j = 0; j < c.size(); j++) {
if (abs(c[j]) > 1) ok = false;
}
if (ok) break;
for (int j = 0; j < b.size(); j++) {
c[j] -= k * b[j];
}
assert(k != 1);
}
swap(a, b);
swap(a, c);
}
cout << a.size() - 1 << "\n";
for (int i = 0; i < a.size(); i++) {
if (i != 0) cout << " ";
cout << a[i];
}
cout << "\n";
cout << b.size() - 1 << "\n";
for (int i = 0; i < b.size(); i++) {
if (i != 0) cout << " ";
cout << b[i];
}
cout << "\n";
return 0;
}
| 2 |
#include<iostream>
#include<algorithm>
#include<functional>
#include<climits>
using namespace std;
template<class S=int, class T=std::less<S>, S nil=INT_MAX>
class RMQ2D{
int h,w;
S *datrmq;
mutable int xs,xe;
static int calcsize(int n){
int res=1;
while(res<n)res<<=1;
return res;
}
void xbuild(int y,int n,const S a[]){
S *dat=datrmq+y*(2*w-1);
for(int i=0;i<n;i++)dat[w-1+i]=a[i];
for(int i=n;i<w;i++)dat[w-1+i]=nil;
for(int i=w-2;i>=0;i--){
dat[i]=std::min(dat[i*2+1],dat[i*2+2],T());
}
}
void xupdate(S *dat,int x,int a){
x+=w-1;
dat[x]=a;
while(x>0){
x=(x-1)/2;
dat[x]=std::min(dat[x*2+1],dat[x*2+2],T());
}
}
void yupdate(int y,int x,int a){
y+=h-1;
while(y>0){
y=(y-1)/2;
xupdate(datrmq+y*(2*w-1),x,a);
}
}
S xquery(const S *dat,int k,int l,int r)const{
if(r<=xs||xe<=l)return nil;
if(xs<=l&&r<=xe)return dat[k];
else{
S vl=xquery(dat,k*2+1,l,(l+r)/2);
S vr=xquery(dat,k*2+2,(l+r)/2,r);
return std::min(vl,vr,T());
}
}
S yquery(int ys,int ye,int k,int l,int r)const{
if(r<=ys||ye<=l)return nil;
if(ys<=l&&r<=ye)return xquery(datrmq+k*(2*w-1), 0,0,w);
else{
S vl=yquery(ys,ye,k*2+1,l,(l+r)/2);
S vr=yquery(ys,ye,k*2+2,(l+r)/2,r);
return std::min(vl,vr,T());
}
}
public:
RMQ2D(int h,int w,const S a[]){
S *dat;
int n=h,m=w;
h=this->h=calcsize(h);
w=this->w=calcsize(w);
datrmq=new S[(2*h-1)*(2*w-1)];
dat=new S[2*w-1];
for(int i=0;i<w;i++)dat[i]=nil;
for(int i=0;i<n;i++)xbuild(h-1+i,m,a+i*m);
for(int i=n;i<h;i++)xbuild(h-1+i,m,dat);
for(int i=h-2;i>=0;i--){
const S *a=datrmq+(i*2+1)*(2*w-1);
const S *b=datrmq+(i*2+2)*(2*w-1);
S *c=datrmq+i*(2*w-1);
for(int j=0;j<2*w-1;j++){
c[j]=std::min(a[j],b[j],T());
}
}
delete[] dat;
}
~RMQ2D(){
delete[] datrmq;
}
void update(int y,int x,int a){//(y,x)をaに変更
yupdate(y,x,a);
}
S query(int ys,int ye,int xs,int xe)const{//[ys,ye)+[xs,xe)の最小(大)値
this->xs=xs;
this->xe=xe;
return yquery(ys,ye,0,0,h);
}
};
unsigned int g[1000000];
int main(){
int r,c,q;
while(cin>>r>>c>>q,r|c|q){
for(int i=0;i<r*c;i++)cin>>g[i];
RMQ2D<unsigned int,std::less<unsigned int>,~0u> rmq(r,c,g);
for(int i=0;i<q;i++){
int y1,x1,y2,x2;
cin>>y1>>x1>>y2>>x2;
cout<<rmq.query(y1,y2+1,x1,x2+1)<<endl;
}
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
namespace mcf {
const int N = 600;
const long long INF = 0x3f3f3f3f3f3f3f3f;
struct Edge {
int v, r;
long long f, c, p;
};
vector<Edge> adj[N];
int sz[N];
long long mc;
vector<Edge> mcf_edges;
void init(int n = N) {
mc = 0;
fill(sz, sz + n, 0);
fill(adj, adj + n, vector<Edge>());
}
void add_edge(int a, int b, long long c = 1, long long p = 0) {
mc = max(mc, c);
adj[a].push_back({b, sz[b]++, 0, c, p});
adj[b].push_back({a, sz[a]++, 0, 0, -p});
}
bool vis[N];
int par[N];
long long pot[N], dist[N];
void pot_init(int n) {
fill(pot, pot + n, 0);
for (int i = 1; i < n; i++)
for (const Edge& e : mcf_edges)
if (e.c) pot[e.v] = min(pot[e.v], pot[e.r] + e.p);
}
long long mcf(int s, int t, long long& price, int n, bool sparse) {
fill(vis, vis + n, 0);
fill(dist, dist + n, INF);
dist[s] = 0;
if (sparse) {
priority_queue<pair<long long, int>> dk;
dk.push({0, s});
while (!dk.empty()) {
int u = dk.top().second;
dk.pop();
if (vis[u]) continue;
for (const Edge& e : adj[u]) {
if (e.f < e.c && dist[e.v] > dist[u] + pot[u] - pot[e.v] + e.p) {
dist[e.v] = dist[u] + pot[u] - pot[e.v] + e.p;
par[e.v] = e.r;
dk.push({-dist[e.v], e.v});
}
}
}
} else {
for (int u = s; u != -1;) {
vis[u] = true;
for (const Edge& e : adj[u]) {
if (e.f < e.c && dist[e.v] > dist[u] + pot[u] - pot[e.v] + e.p) {
dist[e.v] = dist[u] + pot[u] - pot[e.v] + e.p;
par[e.v] = e.r;
}
}
u = -1;
long long best = INF;
for (int i = 0; i < n; i++)
if (!vis[i] && dist[i] < best) best = dist[u = i];
}
}
if (dist[t] >= INF) {
return 0;
}
long long df = INF;
for (int u = t; u != s;) {
const Edge& r = adj[u][par[u]];
df = min(df, adj[r.v][r.r].c - adj[r.v][r.r].f);
u = r.v;
}
for (int u = t; u != s;) {
Edge &r = adj[u][par[u]], &e = adj[r.v][r.r];
e.f += df;
r.f -= df;
price += df * e.p;
u = r.v;
}
for (int i = 0; i < n; i++) {
pot[i] = min(INF, dist[i] + pot[i]);
}
return df;
}
long long min_cost_flow(int s, int t, long long& price, int n = N,
bool sparse = false) {
pot_init(n);
long long flow = price = 0;
while (long long df = mcf(s, t, price, n, sparse)) {
flow += df;
}
return flow;
}
} // namespace mcf
int SEP = 205;
int s = 550;
int sp = 551;
int t = 552;
int tp = 553;
char col1[205], col2[205];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n1, n2, m, r, b;
cin >> n1 >> n2 >> m >> r >> b;
cin >> col1 >> col2;
mcf::init(tp + 10);
mcf::pot_init(tp + 10);
int spcap = 0;
for (int i = 0; i < n1; ++i) {
int u = i;
if (col1[i] == 'R') {
mcf::add_edge(s, u, 1e8, 0);
mcf::add_edge(sp, u, 1, 0);
mcf::add_edge(s, tp, 1, 0);
++spcap;
} else if (col1[i] == 'B') {
mcf::add_edge(u, t, 1e8, 0);
mcf::add_edge(u, tp, 1, 0);
mcf::add_edge(sp, t, 1, 0);
++spcap;
} else {
mcf::add_edge(u, t, 1e8, 0);
mcf::add_edge(s, u, 1e8, 0);
}
}
for (int i = 0; i < n2; ++i) {
int u = SEP + i;
if (col2[i] == 'R') {
++spcap;
mcf::add_edge(u, t, 1e8, 0);
mcf::add_edge(u, tp, 1, 0);
mcf::add_edge(sp, t, 1, 0);
} else if (col2[i] == 'B') {
++spcap;
mcf::add_edge(s, u, 1e8, 0);
mcf::add_edge(sp, u, 1, 0);
mcf::add_edge(s, tp, 1, 0);
} else {
mcf::add_edge(u, t, 1e8, 0);
mcf::add_edge(s, u, 1e8, 0);
}
}
map<pair<long long, long long>, vector<int>> mp;
for (int q = 0; q < m; ++q) {
int u, v;
cin >> u >> v;
u += -1;
v += SEP - 1;
mp[pair<long long, long long>(u, v)].push_back(q);
mcf::add_edge(u, v, 1, r);
mcf::add_edge(v, u, 1, b);
}
mcf::add_edge(t, s, 1e8, 0);
long long price = 0;
long long flow_amount = mcf::min_cost_flow(sp, tp, price);
if (flow_amount != spcap) {
cout << -1 << endl;
} else {
cout << price << endl;
vector<char> ans(m, 'U');
for (int i = 0; i < tp; ++i) {
for (auto& e : mcf::adj[i]) {
int j = e.v;
if (e.f && e.p == r && mp.count(pair<long long, long long>(i, j))) {
int ind = mp[pair<long long, long long>(i, j)].back();
mp[pair<long long, long long>(i, j)].pop_back();
ans[ind] = 'R';
} else if (e.f && e.p == b &&
mp.count(pair<long long, long long>(j, i))) {
int ind = mp[pair<long long, long long>(j, i)].back();
mp[pair<long long, long long>(j, i)].pop_back();
ans[ind] = 'B';
}
}
}
for (auto& c : ans) {
cout << c;
}
cout << endl;
}
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MN = 105, MM = 2017;
int n, m, es[MM], ee[MM];
bool seen[MM], mk[MN];
vector<pair<int, int> > adj[MN];
vector<int> vec;
int dfs(int s) {
mk[s] = true;
int ret = 1;
for (auto x : adj[s])
if (!mk[x.first] && !seen[x.second]) ret += dfs(x.first);
return ret;
}
bool check(int s) {
bool F = true;
dfs(s);
for (int i = 0; i < n; ++i)
if (!mk[i] && dfs(i) > 1) F = false;
memset(mk, 0, sizeof mk);
return F;
}
void solve2(int ind, int st) {
for (int i = 0; i < ind; ++i) cout << vec[i] + 1 << ' ';
for (int rp = ind; rp < m - 1; ++rp) {
for (auto x : adj[st]) {
int v = x.first, e = x.second;
if (seen[e]) continue;
seen[e] = true;
if (check(v)) {
cout << st + 1 << ' ';
st = v;
break;
}
seen[e] = false;
}
}
cout << st + 1 << ' ' << vec[0] + 1 << '\n';
}
void solve() {
for (int i = 0; i < m; ++i) seen[i] = true;
for (int i = ((int)(vec).size()) - 2; ~i; --i) {
seen[i] = false;
for (auto x : adj[vec[i]])
if (x.first > vec[i + 1] && !seen[x.second]) {
int v = x.first, e = x.second;
seen[e] = true;
if (check(v)) {
solve2(i + 1, v);
return;
}
seen[e] = false;
}
}
cout << "No solution\n";
}
int main() {
ios_base ::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> m;
int lst;
cin >> lst;
--lst;
vec.push_back(lst);
for (int i = 0; i < m; ++i) {
int t;
cin >> t;
--t;
es[i] = lst, ee[i] = t;
vec.push_back(t);
lst = t;
}
for (int i = 0; i < m; ++i) {
adj[es[i]].push_back({ee[i], i});
adj[ee[i]].push_back({es[i], i});
}
for (int i = 0; i < n; ++i) sort(adj[i].begin(), adj[i].end());
solve();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<string> vs;
string s;
for (int i = (int)0; i < (int)N; i++) {
cin >> s;
vs.push_back(s);
}
long long int ans = 1;
for (int i = (int)0; i < (int)M; i++) {
set<char> st;
for (int j = (int)0; j < (int)N; j++) {
st.insert(vs[j][i]);
}
ans = (ans * st.size()) % 1000000007;
}
cout << ans << '\n';
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
struct lichao {
int l, r;
long long A, B;
lichao() : l(0), r(0), A(0), B(-0x7fffffffffffffffLL) {}
} tree[3 << 20];
const int MAX = 1e9, SZ = 1 << 19, MAX_SIZE = 1 << 20;
int op, node_cnt = 2 * SZ, T[300000];
vector<pair<int, int>> query;
char buf[MAX_SIZE], obuf[MAX_SIZE];
inline char get_char() {
static int p = 0, s = 0;
if (p == s) {
p = 0;
s = fread(buf, 1, MAX_SIZE, stdin);
if (p == s) return 0;
}
return buf[p++];
}
inline int get_int() {
int ret = 0;
bool is_negative = false;
char c = -1;
while (!('0' <= c && c <= '9') && c != '-') c = get_char();
if (c == '-') {
is_negative = true;
c = get_char();
}
while ('0' <= c && c <= '9') ret *= 10, ret += c - '0', c = get_char();
return (is_negative ? -ret : ret);
}
inline void flush_output() {
if (op) {
fwrite(obuf, 1, op, stdout);
op = 0;
}
}
inline void put_char(char c) {
if (op == MAX_SIZE) {
flush_output();
}
obuf[op++] = c;
}
inline void print_int(long long n) {
static char temp[30];
bool is_negative = (n < 0);
int c = 29;
if (n == 0) {
put_char('0');
} else {
for (n = abs(n); n; n /= 10) {
temp[c--] = n % 10 + '0';
}
if (is_negative) {
put_char('-');
}
for (c++; c < 30; c++) {
put_char(temp[c]);
}
}
put_char('\n');
}
int get_sign(long long a) { return a < 0 ? -1 : a > 0; }
void add_line2(long long A, long long B, int p) {
int s = -MAX, e = MAX;
for (;;) {
int m = (s + e) / 2;
long long ys = A * s + B, ym = A * m + B, ye = A * e + B, &pA = tree[p].A,
&pB = tree[p].B;
long long pys = pA * s + pB, pym = pA * m + pB, pye = pA * e + pB;
if (ym > pym) {
swap(A, pA);
swap(B, pB);
swap(ys, pys);
swap(ym, pym);
swap(ye, pye);
}
if (pys >= ys && pye >= ye) return;
if (get_sign(ys - pys) * get_sign(ym - pym) < 0 || ym == pym && ys > pys) {
if (tree[p].l == 0) tree[p].l = node_cnt++;
p = tree[p].l;
e = m;
} else {
if (tree[p].r == 0) tree[p].r = node_cnt++;
p = tree[p].r;
s = m + 1;
}
}
}
void add_line(int s, int e, long long A, long long B) {
for (s += SZ, e += SZ; s <= e; s >>= 1, e >>= 1) {
if (s & 1) add_line2(A, B, s++);
if (~e & 1) add_line2(A, B, e--);
}
}
long long get_maxy2(int x, int p) {
long long ret = -0x7fffffffffffffffLL;
int s = -MAX, e = MAX;
while (p && s < e) {
int m = (s + e) / 2;
ret = max(ret, tree[p].A * x + tree[p].B);
if (x <= m) {
p = tree[p].l;
e = m;
} else {
p = tree[p].r;
s = m + 1;
}
}
return max(ret, tree[p].A * x + tree[p].B);
}
long long get_maxy(int t, int x) {
long long ret;
for (ret = get_maxy2(x, t += SZ); t >>= 1;) ret = max(ret, get_maxy2(x, t));
return ret;
}
int main() {
int Q = get_int();
long long a, b;
memset(T, -1, sizeof(T));
query.resize(Q);
for (int i = 0; i < Q; i++) {
int t = get_int();
a = get_int();
if (t == 1) {
query[i] = {a, get_int()};
T[i] = Q - 1;
} else if (t == 2) {
T[--a] = i;
T[i] = -2;
} else
query[i].first = a;
}
for (int i = 0; i < Q; i++) {
tie(a, b) = query[i];
if (T[i] == -1) {
if ((b = get_maxy(i, a)) == -0x7fffffffffffffffLL) {
put_char('E');
put_char('M');
put_char('P');
put_char('T');
put_char('Y');
put_char(' ');
put_char('S');
put_char('E');
put_char('T');
put_char('\n');
} else
print_int(b);
} else if (T[i] >= i)
add_line(i, T[i], a, b);
}
flush_output();
return 0;
}
| 6 |
#include<iostream>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
cout<<(a+b-1)/b<<endl;
} | 0 |
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
const long long MAXN = 1123456;
const long long N = 1e5;
const long long inf = 3e18;
mt19937_64 rnd(chrono::system_clock::now().time_since_epoch().count());
template <typename T>
void vout(T s) {
cout << s << endl;
exit(0);
}
string a, b;
long long res = 0;
vector<pair<long long, long long> > ans;
long long n;
void try_dec(long long pos);
void try_inc(long long pos);
void try_dec(long long pos) {
if (pos == n) vout(-1);
if ((int)ans.size() == N) {
for (auto i : ans) cout << i.first + 1 << " " << i.second << "\n";
exit(0);
}
if (a[pos] == '0') {
try_inc(pos + 1);
}
if ((int)ans.size() < N) ans.push_back({pos - 1, -1});
a[pos]--;
a[pos - 1]--;
}
void try_inc(long long pos) {
if (pos == n) vout(-1);
if ((int)ans.size() == N) {
for (auto i : ans) cout << i.first + 1 << " " << i.second << "\n";
exit(0);
}
if (a[pos] == '9') {
try_dec(pos + 1);
}
if ((int)ans.size() < N) ans.push_back({pos - 1, 1});
a[pos]++;
a[pos - 1]++;
}
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cin >> n >> a >> b;
long long Sa, Sb;
Sa = Sb = 0;
for (int i = 0; i < n; i++) {
if (i % 2)
Sa += a[i] - '0';
else
Sa -= a[i] - '0';
if (i % 2)
Sb += b[i] - '0';
else
Sb -= b[i] - '0';
}
if (Sa != Sb || b[0] == '0') vout("-1");
long long delta = 0;
for (int i = 0; i < n; i++) {
long long nw = a[i] + delta;
res += abs(nw - b[i]);
delta = b[i] - nw;
}
cout << res << "\n";
for (int i = 0; i < n; i++) {
while (a[i] < b[i]) {
try_inc(i + 1);
}
while (a[i] > b[i]) {
try_dec(i + 1);
}
}
for (auto i : ans) cout << i.first + 1 << " " << i.second << "\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int a[100020], p[100020], o[100020];
inline bool cmp(const int x, const int y) { return a[x] < a[y]; }
int main(void) {
int n, m;
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) p[i] = i;
sort(p + 1, p + n + 1, cmp);
for (i = 1, m = 0; i <= n; i = j) {
for (j = i; a[p[i]] == a[p[j]]; j++) o[p[j]] = max(m - p[j], 0) - 1;
for (j = i; a[p[i]] == a[p[j]]; j++) m = max(m, p[j]);
}
for (i = 1; i <= n; i++) printf("%d ", o[i]);
return 0;
}
| 2 |
#include <cstdio>
int main() {
int N;
scanf("%d", &N);
printf("%lf\n", (((N+1)/2)*1.0) / N);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int solve = 0;
int main() {
int n;
scanf("%d", &n);
int cap[n];
for (int i = 0; i < n; i++) {
scanf("%d", &cap[i]);
}
int idx = n - 1;
for (int i = n - 1; i >= 0; i--) {
idx = min(idx, i);
if (idx > i - cap[i]) {
solve += min(idx, idx - i + cap[i]);
solve = min(solve, n - 1);
idx = max(0, i - cap[i]);
}
if (solve == n - 1 || idx == 0) break;
}
printf("%d\n", n - solve);
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
char s[2000010], str[2000010], vis[50];
int main() {
int n, m, len, loc, maxc = -0x3f3f3f3f, maxi = -0x3f3f3f3f, last = 0, pos = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> str >> m;
last = 0;
pos = 0;
len = strlen(str);
for (int i = 0; i < len; i++) {
int tmp = str[i] - 'a';
}
for (int j = 0; j < m; j++) {
cin >> loc;
maxi = max(maxi, loc + len - 1);
pos = max(last + 1, loc);
int t = pos;
for (int k = pos - loc; k < len; k++) {
s[t++] = str[k];
}
last = loc + len - 1;
}
}
for (int i = 1; i <= maxi; i++) {
if (s[i] >= 'a' && s[i] <= 'z')
cout << s[i];
else {
cout << "a";
}
}
return 0;
}
| 3 |
#include <iostream>
using namespace std;
int main()
{
double v ;
while(cin >> v)
{
int N=1;
while(1)
{
int y=N*5-5;
if(v*v<=19.6*y) break;
else N++;
}
cout << N << '\n' ;
}
} | 0 |
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=5005,mod=1e9+7;
int n,a,b;
ll f[N],c[N][N],dp[N][2];
ll C(int n,int m)
{
if(m==0||n==m) return 1;
if(m==1) return n;
if(c[n][m]) return c[n][m];
return c[n][m]=(C(n-1,m-1)+C(n-1,m))%mod;
}
ll qpow(ll a,ll n)
{
ll ans=1;
for(;n;n>>=1,a=a*a%mod)if(n&1) ans=ans*a%mod;
return ans;
}
int main()
{
scanf("%d%d%d",&n,&a,&b);
if(a>b) swap(a,b);
f[1]=1;
for(int i=1;i<b;i++)
{
f[i+1]=(f[i+1]+f[i])%mod;
for(int j=a;i+j+1<=b;j++)
f[i+j+1]=(f[i+j+1]+f[i])%mod;
}
dp[0][0]=dp[0][1]=1;
for(int i=0;i<n;i++)
{
for(int j=i+1;j<i+a&&j<=n;j++)
(dp[j][0]+=dp[i][1])%=mod;
for(int j=i+1;j<i+b&&j<=n;j++)
(dp[j][1]+=dp[i][0]*f[j-i+(i==0||j==n)])%=mod;
}
ll ans=qpow(2,n);
ans=(ans-dp[n][0]-dp[n][1])%mod;
ans=(ans+mod)%mod;
printf("%lld\n",ans);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 110000;
const int inf = 1 << 20;
int a[N], b[N];
int main() {
int n, m;
int i, j;
cin >> n >> m;
int cnt = 1;
if (m % 2 == 1) {
a[(m + 1) / 2] = cnt++;
i = (m + 1) / 2 - 1;
j = (m + 1) / 2 + 1;
} else {
i = m / 2;
j = m / 2 + 1;
}
while (true) {
if (i == 0) break;
a[i--] = cnt++;
a[j++] = cnt++;
}
for (i = 1; i <= m; i++) {
b[a[i]] = i;
}
for (i = 0; i < n; i++) {
printf("%d\n", b[i % m + 1]);
}
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
long long int exp(int a, int b) {
if (b == 1) return a;
return ((long long int)exp(a, b - 1) * a) % MOD;
}
int main() {
int n, m, k;
scanf("%d %d %d", &n, &m, &k);
if (k > 2 && k < n && k % 2 == 1)
printf("%d\n", m * m);
else if (k > 2 && k < n && k % 2 == 0)
printf("%d\n", m);
else if (k == 1)
printf("%lld\n", exp(m, n));
else if (k == 2)
printf("%d\n", m);
else if (k == n && n % 2 == 1)
printf("%lld\n", exp(m, n / 2 + 1));
else if (k == n && n % 2 == 0)
printf("%lld\n", exp(m, n / 2));
else if (k > n)
printf("%lld\n", exp(m, n));
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t, i;
cin >> t;
for (i = 0; i < t; ++i) {
long long int n;
cin >> n;
long long int cnt2 = 0, cnt3 = 0, cnt5 = 0;
while (n % 2 == 0) {
n /= 2;
cnt2++;
}
while (n % 3 == 0) {
n /= 3;
cnt3++;
}
while (n % 5 == 0) {
n /= 5;
cnt5++;
}
if (n != 1) {
cout << -1 << endl;
} else {
cout << cnt2 + cnt3 * 2 + cnt5 * 3 << endl;
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 10;
int N, M;
vector<int> adj[MAXN];
int ans[MAXN];
priority_queue<pair<int, int> > pq;
int deg[MAXN];
void fix(int x) {
deg[x] = 0;
for (int y : adj[x]) {
deg[x] += (ans[y] == ans[x]);
}
pq.push(pair<int, int>(deg[x], x));
}
int main() {
scanf("%d %d", &N, &M);
for (int i = 1; i <= M; i++) {
int x, y;
scanf("%d %d", &x, &y);
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= N; i++) {
ans[i] = 0;
}
for (int i = 1; i <= N; i++) {
fix(i);
}
while (pq.top().first > 1) {
int dg = pq.top().first, vert = pq.top().second;
pq.pop();
if (deg[vert] != dg) {
continue;
}
ans[vert] ^= 1;
for (int y : adj[vert]) {
fix(y);
}
fix(vert);
}
for (int i = 1; i <= N; i++) {
printf("%d", ans[i]);
}
puts("");
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
getline(cin, s);
int c = 0;
for (int i = 0; i < s.size(); i++) {
int code = int(s[i]), k = 128, ans = 0;
while (code > 0) {
ans += (code % 2) * k;
k /= 2;
code /= 2;
}
cout << (256 + c - ans) % 256 << endl;
c = ans;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, n1, n2;
vector<int> v1, v2;
int resh[100009];
int resa[100009];
map<int, int> home, away;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> n1 >> n2;
v1.push_back(n1);
v2.push_back(n2);
home[n1]++;
away[n2]++;
}
for (int i = 0; i < n; i++) {
resh[i] = n - 1;
resa[i] = n - 1;
}
for (int i = 0; i < n; i++) {
resh[i] += home[v2[i]];
resa[i] -= home[v2[i]];
}
for (int i = 0; i < n; i++) cout << resh[i] << " " << resa[i] << endl;
return 0;
}
| 2 |
#include "bits/stdc++.h"
#include<unordered_map>
#include<unordered_set>
#pragma warning(disable:4996)
using namespace std;
using ld = long double;
template<class T>
using Table = vector<vector<T>>;
const ld eps = 1e-9;
int N;
bool check(const vector<pair<ld, ld>>&cs, const ld amid) {
map<ld, int>mp;
for (auto c : cs) {
const ld r = c.second;
const ld x = c.first;
if (r > amid) {
ld dis = sqrt(r*r - amid*amid);
mp[x - dis]++;
mp[x + dis]--;
}
}
ld pre = -1;
int num = 0;
ld len = 0;
bool preok = false;
for (auto m : mp) {
num += m.second;
if (num) {
if (!preok) {
pre = m.first;
}
}
else {
if (num < 0)assert(false);
if (preok) {
len = max(len, m.first - pre);
}
}
preok = num;
}
return amid*2 < len;
}
int main() {
while (1) {
cin >> N;
if (!N)break;
vector<pair<ld, ld>>cs;
for (int i = 0; i < N; ++i) {
int x, r; cin >> x >> r;
cs.push_back(make_pair(x, r));
}
ld amin = 0;
ld amax = 2e6;
int atime = 40;
while (atime--) {
ld amid = (amin + amax) / 2;
if (check(cs, amid)) {
amin = amid;
}
else {
amax = amid;
}
}
cout << setprecision(22) << fixed << amin*2 << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1000000007;
const double PI = acos(-1.);
const int N = 200000 + 5;
int n, a[N], w[N];
int din[N], dot[N], fot[N];
vector<int> G[N];
void dfsd(int u, int f) {
int i, v;
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
dfsd(v, u);
}
if (w[u]) {
din[u] = 1;
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
if (din[v])
din[u] += din[v];
else {
din[u] = 0;
break;
}
}
dot[u] = 1;
int mx = 0;
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
if (din[v])
dot[u] += din[v];
else
mx = max(mx, dot[v]);
}
dot[u] += mx;
} else
din[u] = dot[u] = 0;
}
void Max2(int &a, int &b, int c) {
if (c >= a) {
b = a;
a = c;
} else
b = max(b, c);
}
void dfsf(int u, int f) {
int i, v;
if (w[u]) {
int b[2];
b[0] = fot[u];
b[1] = 0;
int sum = 0;
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
if (din[v])
sum += din[v];
else
Max2(b[0], b[1], dot[v]);
}
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
if (din[v]) {
fot[v] = sum - din[v] + 1 + b[0];
} else {
if (dot[v] == b[0])
fot[v] = sum + 1 + b[1];
else
fot[v] = sum + 1 + b[0];
}
if (!w[v]) fot[v] = 0;
}
} else {
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
fot[v] = 0;
}
}
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
dfsf(v, u);
}
}
int dfsdp(int u, int f) {
int ret = 0;
int i, v;
if (w[u]) {
ret = 1;
int mx = 0;
if (~f) mx = fot[u];
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
if (din[v])
ret += din[v];
else
mx = max(mx, dot[v]);
}
ret += mx;
}
for (i = 0; i < G[u].size(); i++) {
v = G[u][i];
if (v == f) continue;
int tmp = dfsdp(v, u);
ret = max(ret, tmp);
}
return ret;
}
int cnt(int A) {
int i;
for (i = 1; i <= n; i++) w[i] = a[i] >= A;
int rt = -1;
for (i = 1; i <= n; i++)
if (!w[i]) rt = i;
if (rt == -1) return n;
dfsd(rt, -1);
fot[rt] = 0;
dfsf(rt, -1);
int ans = dfsdp(rt, -1);
return ans;
}
int main() {
if (0)
freopen(
"535F"
".out",
"r", stdin);
if (0)
freopen(
"535F"
"wa.txt",
"w", stdout);
int i, j, _T;
int k;
while (~scanf("%d%d", &n, &k)) {
for (i = 1; i <= n; i++) scanf("%d", &a[i]), G[i].clear();
for (i = 1; i < n; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v), G[v].push_back(u);
}
vector<int> L;
for (i = 1; i <= n; i++) L.push_back(a[i]);
sort(L.begin(), L.end());
L.erase(unique(L.begin(), L.end()), L.end());
int le = 0, re = L.size() - 1, ge = -1;
while (re >= le) {
if (re - le <= 1) {
if (cnt(L[re]) >= k)
ge = re;
else
ge = le;
break;
}
int mid = (le + re) / 2;
if (cnt(L[mid]) >= k)
le = mid;
else
re = mid;
}
printf("%d\n", L[ge]);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
const int N = 3005;
char s[N];
int main() {
int i, n, last = 1;
static int b[260];
b[(int)'a'] = b[(int)'e'] = b[(int)'i'] = b[(int)'o'] = b[(int)'u'] = 1;
scanf("%s", s + 1);
n = strlen(s + 1);
for (i = 1; i <= n; i++) {
if (i <= 2) {
putchar(s[i]);
continue;
}
if (last <= i - 2 && !b[(int)s[i]] && !b[(int)s[i - 1]] &&
!b[(int)s[i - 2]]) {
if (s[i] != s[i - 1] || s[i] != s[i - 2]) {
putchar(' ');
last = i;
}
}
putchar(s[i]);
}
puts("");
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 5;
long long N, Q, current_answer = 0, BLOCK_SIZE = 450;
long long cnt[1000005], answers[maxn], arr[maxn];
struct Query {
int left;
int right;
int pos;
bool operator<(const Query &q) const {
if (left / BLOCK_SIZE != q.left / BLOCK_SIZE) return left < q.left;
return (right < q.right) ^ ((left / BLOCK_SIZE) & 1);
}
} queries[maxn];
int main() {
scanf("%I64d %I64d", &N, &Q);
for (int i = 0; i < N; i++) scanf("%I64d", &arr[i]);
for (int i = 0; i < Q; i++) {
scanf("%d %d", &queries[i].left, &queries[i].right);
queries[i].left--;
queries[i].right--;
queries[i].pos = i;
}
sort(queries, queries + Q);
int mo_left = 0, mo_right = -1;
int x;
for (int i = 0; i < Q; i++) {
int left = queries[i].left;
int right = queries[i].right;
while (mo_right < right) {
mo_right++;
x = arr[mo_right];
current_answer -= cnt[x] * cnt[x] * x;
cnt[x] += 1;
current_answer += cnt[x] * cnt[x] * x;
}
while (mo_right > right) {
x = arr[mo_right];
current_answer -= cnt[x] * cnt[x] * x;
cnt[x] -= 1;
current_answer += cnt[x] * cnt[x] * x;
mo_right--;
}
while (mo_left < left) {
x = arr[mo_left];
current_answer -= cnt[x] * cnt[x] * x;
cnt[x] -= 1;
current_answer += cnt[x] * cnt[x] * x;
mo_left++;
}
while (mo_left > left) {
mo_left--;
x = arr[mo_left];
current_answer -= cnt[x] * cnt[x] * x;
cnt[x] += 1;
current_answer += cnt[x] * cnt[x] * x;
}
answers[queries[i].pos] = current_answer;
}
for (int i = 0; i < Q; i++) printf("%I64d\n", answers[i]);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n;
bool pre[1000005][26];
string T[200002];
ll ans;
struct trie {
trie *son[26];
int sum[26];
trie() {
for (int i = 0; i < 26; i++) son[i] = NULL, sum[i] = 0;
}
} * root;
bool cmp(const string &a, const string &b) { return a.size() > b.size(); }
void insert(string &s) {
for (int j = 0; j < 26; j++) pre[0][j] = s[0] - 'a' == j;
for (int i = 1; i < s.size(); i++)
for (int j = 0; j < 26; j++)
pre[i][j] = pre[i - 1][j] | (s[i] - 'a' == j);
trie *cur = root;
for (int i = s.size() - 1; i >= 0; i--) {
if (cur->son[s[i] - 'a'] == NULL) cur->son[s[i] - 'a'] = new trie;
if (i == 0) ans += cur->sum[s[0] - 'a'];
for (int j = 0; j < 26; j++) cur->sum[j] += pre[i][j];
cur = cur->son[s[i] - 'a'];
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
cin >> n;
root = new trie;
for (int i = 1; i <= n; i++) cin >> T[i];
sort(T + 1, T + n + 1, cmp);
for (int i = 1; i <= n; i++) insert(T[i]);
cout << ans;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template<class T> ostream& operator << (ostream& os, const vector<T>& v) { os << "["; for (int i=0; i<v.size(); i++) { os << v[i]; if (i < v.size() - 1) os << ", "; } return os << "]"; }
constexpr size_t MAX_N = 100001;
int N;
int K;
int T[MAX_N];
int main() {
cin >> N >> K;
for (int i=0; i<N; i++) {
cin >> T[i];
}
sort(&T[0], &T[N]);
vector<int> gaps;
for (int i=0; i<N-1; i++) {
gaps.push_back(T[i+1] - T[i] - 1);
}
sort(gaps.begin(), gaps.end());
reverse(gaps.begin(), gaps.end());
// cout << "gaps=" << gaps << endl;
long long ans = T[N-1] - T[0] + 1;
// cout << "ans=" << ans << endl;
for (int i=0; i<N && i<K-1; i++) {
// cout << "sub " << gaps[i] << endl;
ans -= gaps[i];
}
cout << ans << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
void Get_Val(int &Ret) {
Ret = 0;
char ch;
while (ch = getchar(), ch > '9' || ch < '0')
;
do {
(Ret *= 10) += ch - '0';
} while (ch = getchar(), ch >= '0' && ch <= '9');
}
const int Max_N(55);
const int Max_R(5050);
int N, R, F[Max_N], S[Max_N], P[Max_N], PreS[Max_N];
void init() {
Get_Val(N), Get_Val(R);
for (int i = 1; i <= N; ++i)
scanf("%d%d%d", F + i, S + i, P + i), PreS[i] = PreS[i - 1] + S[i];
}
long double G[Max_N][Max_R];
void work() {
long double l(0.0), r(1000000000.0), mid, F00;
for (int cnt = 0; cnt <= 100; ++cnt) {
mid = (l + r) / 2.0;
for (int t = 0; t <= PreS[N]; ++t)
if (t <= R)
G[N][t] = 0.0;
else
G[N][t] = mid;
for (int i = N - 1; i >= 1; --i) {
double p = P[i + 1] / 100.0;
for (int t = 0; t <= PreS[i + 1]; ++t) {
G[i][t] = mid;
if (t <= R)
G[i][t] =
min(G[i][t], p * (G[i + 1][t + F[i + 1]] + F[i + 1]) +
(1.0 - p) * (G[i + 1][t + S[i + 1]] + S[i + 1]));
}
}
F00 = P[1] / 100.0 * (G[1][F[1]] + F[1]) +
(1.0 - P[1] / 100.0) * (G[1][S[1]] + S[1]);
if (mid < F00)
l = mid;
else
r = mid;
}
printf("%.10lf", static_cast<double>(l));
}
int main() {
init();
work();
return 0;
}
| 3 |
#include<iostream>
#include<vector>
using namespace std;
int a[20],n;
bool solve(int i,int m){
int res;
if(m==0){
return true;
}
if(i>=n){
return false;
}
return solve(i+1,m) || solve(i+1,m-a[i]);
}
int main(){
int q;
int m;
cin>>n;
for(int i=0;i<n;i++){
cin>>a[i];
}
cin>>q;
for(int i=0;i<q;i++){
cin>>m;
if(solve(0,m)==1){
cout<<"yes\n";
}else{
cout<<"no\n";
}
}
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long n;
multiset<long long> st;
vector<long long> vect;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
vect.push_back(a);
}
long long delta = 0;
for (long long i = 0; i < n; i++) {
st.insert(vect[i] + delta);
long long t_new;
cin >> t_new;
long long res = 0;
while (!st.empty() && (*st.begin() - delta) <= t_new) {
res += *st.begin() - delta;
st.erase(st.begin());
}
res += t_new * (long long)st.size();
delta += t_new;
cout << res << ' ';
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t, flag, sum, cnt, d, i;
cin >> t;
while (t--) {
string s;
cin >> s;
flag = 0;
sum = 0;
cnt = 0;
for (i = 0; i < s.size(); i++) {
d = s[i] - '0';
sum = sum + d;
if (d == 0) flag = 1;
if (d % 2 == 0) cnt++;
}
if (sum % 3 == 0 && flag == 1 && cnt > 1)
cout << "red" << endl;
else
cout << "cyan" << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bitset<2000002> b;
int sum,k;
int main() {
int n,V;
scanf("%d",&n);
b[0]=1;
while(n--) {
int v;
scanf("%d",&v);
b|=b<<v;
sum+=v;
}
int i=(sum)/2+1;
while(i--) if(b[i]) {k=sum-i;break;}
printf("%lld",k);
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int main()
{
int A, B;
cin >> A >> B;
cout << 6 - A - B << '\n';
}
| 0 |
#include<bits/stdc++.h>
using namespace std;
const int N=605;
int n,dis[N],vis[N],Dis[N];
vector<pair<int,int>> e[N];
void dijkstra(int s){
memset(dis,0x3f,sizeof(dis));
dis[s]=0;
for(int i=1;i<=n;++i) vis[i]=0;
for(int T=1;T<=n;++T){
int u=0;
for(int i=1;i<=n;++i)
if(!vis[i] && dis[u]>dis[i]) u=i;
vis[u]=1;
for(int i=1;i<=n;++i) Dis[i]=0x3f3f3f3f;
for(auto [v,val]:e[u])
Dis[(v+dis[u]-1)%n+1]=min(Dis[(v+dis[u]-1)%n+1],dis[u]+val);
for(int i=2;i<=n;++i)
Dis[i]=min(Dis[i-1]+1,Dis[i]);
Dis[1]=min(Dis[n]+1,Dis[1]);
for(int i=2;i<=n;++i)
Dis[i]=min(Dis[i-1]+1,Dis[i]);
for(int i=1;i<=n;++i)
dis[i]=min(dis[i],Dis[i]);
}
}
signed main(){
int m;
cin>>n>>m;
for(int i=1;i<=m;++i){
int u,v,w;
cin>>u>>v>>w;
++u,++v;
e[u].push_back({v,w});//e[v].push_back({u,w});
}
for(int i=1;i<=n;++i){
dijkstra(i);
for(int j=1;j<=n;++j)
cout<<dis[j]<<" ";
cout<<"\n";
}
return 0;
}
| 4 |
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<bits/stdc++.h>
using namespace std;
#define N 105
#define ll long long
#define in(l,n) for(int i=l;i<=n;i++)
int n,q,a[N],b[N],c[N],x[N];
ll sumb[N];
ll dp[N][N*N];
const int mod=1e9+7;
int main(){
scanf("%d",&n);
in(1,n) scanf("%d",c+i);
in(2,n) {
scanf("%d",b+i);
b[i]=b[i]+b[i-1];
sumb[i]=sumb[i-1]+b[i];
}
scanf("%d",&q);
in(1,q) scanf("%d",x+i);
int M=*max_element(c+1,c+n+1);
in(0,n*M) dp[0][i]=1;
in(1,n){
for(int j=0;j<=n*M;j++){
if(j<i*x[1]+sumb[i])
continue;
dp[i][j]=dp[i-1][j];
if(j>c[i])
dp[i][j]-=dp[i-1][j-c[i]-1];
dp[i][j]+=mod;
dp[i][j]%=mod;
}
for(int j=1;j<=n*M;j++){
dp[i][j]+=dp[i][j-1];
dp[i][j]%=mod;
}
}
dp[n][n*M]+=mod;
dp[n][n*M]%=mod;
printf("%lld\n",dp[n][n*M]);
} | 5 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
bool isPrime[1000005] = {false};
vector<long long> prm;
vector<long long> SPF(1000005);
void sieve() {
isPrime[1] = isPrime[0] = 0;
long long i;
for (i = 2; i < 1000005; ++i) isPrime[i] = 1;
for (i = 2; i * i < 1000005; ++i) {
if (isPrime[i]) {
for (long long j = i * i; j < 1000005; j += i) isPrime[j] = 0;
}
}
if (!prm.empty()) prm.clear();
for (i = 2; i < 1000005; ++i) {
if (isPrime[i]) prm.push_back(i);
}
}
bool flip(bool f) {
if (f) return 0;
return 1;
}
long long fastPower(long long a, long long b) {
if (b == 0) return 1;
long long prod = 1;
while (b > 0) {
if (b & 1) prod = prod * a;
b = b >> 1;
a = a * a;
}
return prod;
}
long long fact(long long n) {
long long res = 1;
for (long long i = 2; i <= n; i++) {
res = (res * (i % mod)) % mod;
}
return res;
}
long long nCr(long long n, long long r) {
return (long double)fact(n) / (long double)(fact(r) * fact(n - r));
}
void printa(bool f) {
if (f)
cout << "YES"
<< "\n";
else
cout << "NO"
<< "\n";
}
void solve() {
long long n, m, k;
cin >> n >> m >> k;
long long i;
map<long long, long long> mp;
for (i = 0; i < n; ++i) {
long long a, b;
cin >> a >> b;
if (mp.find(a) == mp.end()) {
mp[a] = b;
} else
mp[a] = min(b, mp[a]);
}
long long sum = 0;
for (auto x : mp) {
sum += x.second;
}
sum = min(k, sum);
cout << sum << "\n";
}
int main() {
int tc = 1;
while (tc--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 107;
int n, sum, in;
void solve() {
cin >> n;
sum = 0;
for (int i = 0; i < n; ++i) {
cin >> in;
if (in <= 2048) {
sum += in;
}
}
cout << ((sum >= 2048) ? "YES" : "NO") << endl;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
while (t--) solve();
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void rd(T &x) {
char ch;
x = 0;
bool fl = false;
while (!isdigit(ch = getchar())) (ch == '-') && (fl = true);
for (x = (ch ^ '0'); isdigit(ch = getchar()); x = x * 10 + (ch ^ '0'))
;
(fl == true) && (x = -x);
}
template <class T>
inline void output(T x) {
if (x / 10) output(x / 10);
putchar(x % 10 + '0');
}
template <class T>
inline void ot(T x) {
if (x < 0) putchar('-'), x = -x;
output(x);
putchar(' ');
}
template <class T>
inline void prt(T a[], int st, int nd) {
for (register int i = st; i <= nd; ++i) ot(a[i]);
putchar('\n');
}
namespace Miracle {
const int N = 1005;
int n, m;
int x, y;
double t[N][N];
double f[N][N];
void guass(int l) {
for (register int i = 1; i < m; ++i) {
double lp = t[i + 1][i] / t[i][i];
for (register int j = i; j <= min(m, i + 2); ++j) {
t[i + 1][j] = t[i + 1][j] - t[i][j] * lp;
}
t[i + 1][m + 1] = t[i + 1][m + 1] - t[i][m + 1] * lp;
}
for (register int i = m; i >= 1; --i) {
t[i][m + 1] = t[i][m + 1] - t[i][i + 1] * f[l][i + 1];
f[l][i] = t[i][m + 1] / t[i][i];
}
}
int main() {
rd(n);
rd(m);
rd(x);
rd(y);
if (m == 1) {
for (register int i = n - 1; i >= x; --i) {
f[i][1] = f[i + 1][1] + 2;
}
} else {
for (register int i = n - 1; i >= x; --i) {
for (register int j = 1; j <= m; ++j) {
if (j == 1) {
t[j][1] = 2;
t[j][2] = -1;
t[j][m + 1] = f[i + 1][1] + 3;
} else if (j == m) {
t[j][m] = 2;
t[j][m - 1] = -1;
t[j][m + 1] = f[i + 1][m] + 3;
} else {
t[j][j] = 3;
t[j][j + 1] = -1;
t[j][j - 1] = -1;
t[j][m + 1] = f[i + 1][j] + 4;
}
}
guass(i);
}
}
printf("%.10lf", f[x][y]);
return 0;
}
} // namespace Miracle
signed main() {
Miracle::main();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
vector<int> adj[1010];
vector<int> vis(1010, 0);
vector<int> dist1(1010, 1000000007);
vector<int> dist2(1010, 1000000007);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, s, t;
cin >> n >> m >> s >> t;
int a, b;
vector<pair<int, int>> v;
for (long long i = 0; i < m; i++) {
cin >> a >> b;
adj[a].push_back(b);
adj[b].push_back(a);
v.push_back(make_pair(a, b));
v.push_back(make_pair(b, a));
}
sort(v.begin(), v.end());
dist1[s] = 0;
queue<int> q;
q.push(s);
vis[s] = 1;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i : adj[v]) {
if (vis[i] == 0) {
q.push(i);
dist1[i] = dist1[v] + 1;
vis[i] = 1;
}
}
}
for (long long i = 0; i < n + 1; i++) {
vis[i] = 0;
}
q.push(t);
vis[t] = 1;
dist2[t] = 0;
while (!q.empty()) {
int v = q.front();
q.pop();
for (int i : adj[v]) {
if (vis[i] == 0) {
q.push(i);
dist2[i] = dist2[v] + 1;
vis[i] = 1;
}
}
}
int count = 0;
int dist = dist1[t];
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
pair<int, int> p = {i, j};
if (binary_search(v.begin(), v.end(), p) == 0) {
if ((dist1[i] + dist2[j] + 1) < dist ||
(dist1[j] + dist2[i] + 1) < dist) {
continue;
} else {
count++;
}
}
}
}
cout << count << '\n';
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int N; cin >> N;
string A, B, C; cin >> A >> B >> C;
int ans = 0;
for(int i=0; i<N; i++){
if(A[i]==B[i] && B[i] == C[i]) continue;
else if(A[i]==B[i] || B[i]==C[i] || C[i]==A[i]) ans+=1;
else ans+=2;
}
cout << ans << endl;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long int div_floor(const long long int &a, const long long int &b) {
return a / b - (((a ^ b) < 0) and a % b);
}
long long int div_ceil(const long long int &a, const long long int &b) {
return a / b + (((a ^ b) >= 0) and a % b);
}
vector<int> parent;
vector<int> cnt;
void make_set(int v) {
parent[v] = v;
cnt[v] = 1;
}
int find_set(int v) {
if (v == parent[v]) return v;
return parent[v] = find_set(parent[v]);
}
void union_sets(int a, int b) {
a = find_set(a);
b = find_set(b);
if (a != b) {
if (cnt[a] < cnt[b]) swap(a, b);
parent[b] = a;
cnt[a] += cnt[b];
}
}
void solve() {
int n, m;
cin >> n >> m;
vector<vector<int> > adj(n);
for (int i = 0; i < m; i++) {
int u, v;
cin >> u >> v;
u--;
v--;
adj[u].push_back(v);
adj[v].push_back(u);
}
for (auto &e : adj) sort(e.begin(), e.end());
int vertex = 0;
for (int i = 0; i < n; i++)
if ((long long int)adj[i].size() < (long long int)adj[vertex].size())
vertex = i;
vector<int> nodes = adj[vertex];
nodes.push_back(vertex);
sort(nodes.begin(), nodes.end());
int n1 = (long long int)nodes.size();
map<int, int> translate;
for (int i = 0; i < n1; i++) translate[nodes[i]] = i;
parent.resize(n1);
cnt.resize(n1);
for (int i = 0; i < n1; i++) make_set(i);
for (int i = 0; i < n1; i++) {
int cntr = 0;
for (auto &v : adj[nodes[i]])
if (!binary_search(nodes.begin(), nodes.end(), v)) cntr++;
for (auto &v : nodes)
if (!binary_search(adj[nodes[i]].begin(), adj[nodes[i]].end(), v))
union_sets(i, translate[v]);
if (cntr + n1 < n) union_sets(i, translate[vertex]);
}
int ans = 0;
for (int i = 0; i < n1; i++) ans += parent[i] == i;
cout << ans << '\n';
vector<vector<int> > comps(n);
for (int i = 0; i < n1; i++) comps[nodes[find_set(i)]].push_back(nodes[i]);
for (int i = 0; i < n; i++)
if (!binary_search(nodes.begin(), nodes.end(), i)) {
comps[nodes[find_set(translate[vertex])]].push_back(i);
}
for (auto &v : comps) {
if ((long long int)v.size() > 0) {
cout << (long long int)v.size() << " ";
for (auto &e : v) cout << e + 1 << " ";
cout << '\n';
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t = 1;
while (t--) solve();
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T gcd(T a, T b) {
return b ? gcd(b, a % b) : a;
}
int n;
long long k;
int a[11111], b[11111];
void basic() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n; i++) {
cin >> b[i];
}
long long l = 0, r = 11111, ans = 0;
while (l < r) {
long long m = (l + r + 1) >> 1;
long long q = 0;
for (int i = 0; i < n; i++) {
if (a[i] * m > b[i]) q += m * a[i] - b[i];
}
if (q == k) {
ans = m;
break;
}
if (q > k)
r = m - 1;
else {
ans = l = m;
}
}
cout << ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
basic();
getchar();
getchar();
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int WZP = 6666666;
char LZH[WZP], *SSS = LZH, *TTT = LZH;
inline char gc() {
if (SSS == TTT) {
TTT = (SSS = LZH) + fread(LZH, 1, WZP, stdin);
if (SSS == TTT) return EOF;
}
return *SSS++;
}
inline int read01() {
char s = gc();
for (; s < '0' || s > '1'; s = gc())
;
return s - '0';
}
inline int read() {
char s = gc();
int x = 0;
for (; s < '0' || s > '9'; s = gc())
;
for (; s >= '0' && s <= '9'; s = gc()) x = x * 10 - 48 + s;
return x;
}
const int N = 200005;
struct edge {
int to, next;
} e[N * 2];
int head[N], tot;
int dep[N], dfn[N], ed[N];
int fa[N][19], a[N], b[N];
int n, spe1, spe2, A[N], B[N];
void add(int x, int y) {
e[++tot] = (edge){y, head[x]};
head[x] = tot;
}
void dfs(int x) {
dep[x] = dep[fa[x][0]] + 1;
dfn[x] = ++*dfn;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa[x][0]) {
fa[e[i].to][0] = x;
dfs(e[i].to);
}
ed[x] = *dfn;
}
bool insub(int x, int y) { return dfn[x] <= dfn[y] && ed[y] <= ed[x]; }
int LCA(int x, int y) {
if (dep[x] < dep[y]) swap(x, y);
int tmp = dep[x] - dep[y];
for (int i = (int)(0); i <= (int)(18); i++)
if (tmp & (1 << i)) x = fa[x][i];
for (int i = (int)(18); i >= (int)(0); i--)
if (fa[x][i] != fa[y][i]) x = fa[x][i], y = fa[y][i];
return x == y ? x : fa[x][0];
}
pair<int, int> merge(const pair<int, int> &a, int x) {
if (a.first == -1) return pair<int, int>(-1, -1);
if (a.first == 0) return pair<int, int>(x, x);
static int c[5], L;
c[0] = a.first;
c[1] = a.second;
c[2] = x;
L = LCA(c[0], c[1]);
if (insub(L, c[2]) && (insub(c[2], c[0]) || insub(c[2], c[1])))
return pair<int, int>(c[0], c[1]);
L = LCA(c[0], c[2]);
if (insub(L, c[1]) && (insub(c[1], c[0]) || insub(c[1], c[2])))
return pair<int, int>(c[0], c[2]);
L = LCA(c[1], c[2]);
if (insub(L, c[0]) && (insub(c[0], c[1]) || insub(c[0], c[2])))
return pair<int, int>(c[1], c[2]);
return pair<int, int>(-1, -1);
}
long long solve(int x, int y, int L, int *a) {
int l = 1, r = dep[x] + dep[y] - 2 * dep[L], len = r, at = 1;
for (; x != L; x = fa[x][0], l++) A[l] = a[x], B[l] = b[x];
for (; y != L; y = fa[y][0], r--) A[r] = a[y], B[r] = b[y];
for (int i = (int)(1); i <= (int)(len); i++)
if (A[i])
for (; A[1] != B[at]; at++)
;
for (int i = 1; i <= len; i++)
if (A[i] != B[(i + at - 2) % len + 1]) return 1ll << 60;
return 1ll * min(at - 1, len + 1 - at) * (len + 1);
}
int cnt, aa[N];
bool dfs(int x, int fa, int spe) {
if (x == spe) return 1;
for (int i = head[x]; i; i = e[i].next)
if (e[i].to != fa)
if (dfs(e[i].to, x, spe)) {
cnt++;
swap(aa[x], aa[e[i].to]);
return 1;
}
return 0;
}
void flip(int p1, int p2) { dfs(p2, 0, p1); }
bool checkSAME(int *a, int *b) {
for (int i = (int)(1); i <= (int)(n); i++)
if (a[i] != b[i]) return 0;
return 1;
}
int tp;
int main() {
n = read();
for (int i = (int)(1); i <= (int)(n); i++)
a[i] = read(), spe1 = (a[i] == 0 ? i : spe1);
for (int i = (int)(1); i <= (int)(n); i++)
b[i] = read(), spe2 = (b[i] == 0 ? i : spe2);
for (int i = (int)(1); i <= (int)(n - 1); i++) {
int x = read(), y = read();
add(x, y);
add(y, x);
}
memcpy(aa, a, sizeof(aa));
dfs(spe2);
flip(spe1, spe2);
if (checkSAME(aa, b)) return printf("0 %d\n", cnt), 0;
for (int i = (int)(1); i <= (int)(18); i++)
for (int j = (int)(1); j <= (int)(n); j++)
fa[j][i] = fa[fa[j][i - 1]][i - 1];
pair<int, int> tmp(0, 0);
for (int i = (int)(1); i <= (int)(n); i++)
if (aa[i] != b[i]) tmp = merge(tmp, i);
if (tmp.first == -1) return puts("-1"), 0;
if (dep[tmp.first] > dep[tmp.second]) swap(tmp.first, tmp.second);
if (insub(tmp.first, tmp.second)) tmp.first = fa[tmp.first][0];
long long ans = 1ll << 60;
int L1 = LCA(tmp.first, tmp.second);
cnt = 0;
memcpy(aa, a, sizeof(aa));
flip(spe1, tmp.first);
swap(aa[tmp.first], aa[tmp.second]);
cnt++;
flip(tmp.second, spe2);
ans = min(ans, cnt + solve(tmp.first, tmp.second, L1, aa));
cnt = 0;
memcpy(aa, a, sizeof(aa));
flip(spe1, tmp.second);
swap(aa[tmp.second], aa[tmp.first]);
cnt++;
flip(tmp.first, spe2);
ans = min(ans, cnt + solve(tmp.first, tmp.second, L1, aa));
if (ans >= 1ll << 50) return puts("-1"), 0;
if (tmp.first > tmp.second) swap(tmp.first, tmp.second);
printf("%d %d ", tmp.first, tmp.second);
printf("%lld\n", ans);
}
| 6 |
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<algorithm>
#define MAXN 15
#define INF 0x3F3F3F3F
int v[MAXN][MAXN], n, m, x, y, z;
int c[1 << MAXN][MAXN], f[1 << MAXN][MAXN];
int main(){
scanf("%d%d", &n, &m);
for(int i = 0;i < m;i++){
scanf("%d%d%d", &x, &y, &z);
x--;y--;
v[x][y] = v[y][x] = z;
}
for(int d = 0;d < (1 << n);d++){
for(int i = 0;i < n;i++){
f[d][i] = INF;
for(int j = 0;j < n;j++)if((d >> j) & 1)c[d][i] += v[i][j];
}
}
f[1][0] = 0;
for(int d = 0;d < (1 << n);d++){
for(int i = 0;i < n;i++){
if(((d >> i) & 1) && f[d][i] != INF){
for(int j = 0;j < n;j++){
if(!((d >> j) & 1) && v[i][j]){
f[d | (1 << j)][j] = std::min(
f[d | (1 << j)][j],
f[d][i] + c[d][j] - v[i][j]
);
}
}
register int next = d ^ (1 << i), st = ((1 << n) - 1) ^ d, sum;
for(int j = st;j > 0;j = (j - 1) & st){
sum = 0;
for(int l = 0;l < n;l++)if((j >> l) & 1)sum += c[next][l];
f[d | j][i] = std::min(f[d | j][i], f[d][i] + sum);
}
}
}
}
printf("%d\n", f[(1 << n) - 1][n - 1]);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool chkmax(T &x, T y) {
return x < y ? x = y, true : false;
}
template <typename T>
bool chkmin(T &x, T y) {
return x > y ? x = y, true : false;
}
int readint() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n;
vector<pair<int, int> > v[2][25];
int ans[1005];
bool vis[1005];
void ask(vector<int> x) {
printf("%d\n", x.size());
for (auto r : x) printf("%d ", r);
printf("\n");
fflush(stdout);
}
void build(int l, int r, int dep) {
if (l == r) return;
int mid = (l + r) / 2;
build(l, mid, dep + 1);
build(mid + 1, r, dep + 1);
v[0][dep].push_back(make_pair(l, mid)),
v[1][dep].push_back(make_pair(mid + 1, r));
}
int main() {
n = readint();
build(1, n, 1);
memset(ans, 0x3f, sizeof(ans));
for (int i = 1; i <= 10; i++) {
for (int t = 0; t <= 1; t++) {
if (!v[t][i].size()) continue;
vector<int> qry(0);
memset(vis, 0, sizeof(vis));
for (auto x : v[t][i])
for (int j = x.first; j <= x.second; j++) qry.push_back(j), vis[j] = 1;
ask(qry);
int x;
for (int j = 1; j <= n; j++) {
x = readint();
if (!vis[j]) chkmin(ans[j], x);
}
}
}
printf("-1\n");
for (int i = 1; i <= n; i++) printf("%d ", ans[i]);
printf("\n");
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
FILE *in;
FILE *out;
int n, m;
int a[1024];
priority_queue<pair<int, int> > q;
int main(void) {
in = stdin;
out = stdout;
fscanf(in, "%d %d", &n, &m);
for (int i = 0; i < m; i++) fscanf(in, "%d", &a[i]);
vector<int> answer;
for (int first = 0; first < m; first++) {
int last = -1;
vector<int> ans;
while (!q.empty()) q.pop();
for (int i = 0; i < m; i++) {
if (first == i) {
if (a[i] > 1) q.push(make_pair(a[i] - 1, i + 1));
} else
q.push(make_pair(a[i], i + 1));
}
ans.push_back(first + 1);
last = first + 1;
for (int i = 1; i < n; i++) {
if (q.empty()) break;
pair<int, int> cur = q.top();
q.pop();
if (last == cur.second) {
if (q.empty()) break;
pair<int, int> nxt = q.top();
q.pop();
ans.push_back(nxt.second);
nxt.first--;
last = nxt.second;
if (nxt.first > 0) q.push(nxt);
q.push(cur);
continue;
} else {
ans.push_back(cur.second);
cur.first--;
last = cur.second;
if (cur.first > 0) q.push(cur);
}
}
if ((int)ans.size() < n) continue;
if (ans.back() == first + 1) {
ans.pop_back();
while (!q.empty()) {
pair<int, int> cur = q.top();
q.pop();
if (ans.back() == cur.second || cur.second == first + 1) continue;
ans.push_back(cur.second);
break;
}
}
if ((int)ans.size() == n &&
ans[(int)ans.size() - 1] != ans[(int)ans.size() - 2] &&
ans[(int)ans.size() - 1] != ans[0]) {
answer = ans;
break;
}
}
if (n > (int)answer.size())
fprintf(out, "-1\n");
else {
for (int i = 0; i < (int)answer.size(); i++)
fprintf(out, "%d%c", answer[i], i + 1 == (int)answer.size() ? '\n' : ' ');
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct Tree {
long long x, height;
bool operator<(const Tree& b) const { return x < b.x; }
} q[105005];
const long long INF = 0x3f3f3f3f3f3f3f3f;
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld%lld", &q[i].x, &q[i].height);
}
sort(q + 1, q + 1 + n);
q[0].x = -INF;
q[n + 1].x = INF;
int res = 0;
for (int i = 1; i <= n; i++) {
if (q[i].x - q[i].height > q[i - 1].x) {
res++;
continue;
}
if (q[i].x + q[i].height < q[i + 1].x) {
q[i].x += q[i].height;
res++;
}
}
cout << res << endl;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const int MXN = 5e5 + 5, MXC = 1 << 20;
int n, p[MXN][2];
vector<pair<int, int> > adj[MXC];
bool vis[MXC];
vector<int> ans;
void dfs(int u) {
vis[u] = 1;
for (auto& p : adj[u])
if (!vis[p.first]) dfs(p.first);
}
int build(int m) {
for (int i = (0); i <= (m); ++i) adj[i].clear();
int u, v;
for (int i = (0); i < (n); ++i) {
u = p[i][0] & m;
v = p[i][1] & m;
adj[u].emplace_back(v, i << 1);
adj[v].emplace_back(u, i << 1 | 1);
}
return u;
}
bool valid(int b) {
int m = (1 << b) - 1;
memset((vis), 0, (1 << b) * sizeof(vis[0]));
build(m);
bool c = 0;
for (int u = (0); u <= (m); ++u) {
if (adj[u].size() & 1) return 0;
if (!vis[u] && adj[u].size()) {
if (!c)
dfs(u), c = 1;
else
return 0;
}
}
return 1;
}
void path(int b) {
int m = (1 << b) - 1;
memset((vis), 0, (n) * sizeof(vis[0]));
int s = build(m);
stack<pair<int, int> > stk;
stk.emplace(s, -1);
while (stk.size()) {
int u = stk.top().first;
if (adj[u].size()) {
pair<int, int> e = adj[u].back();
adj[u].pop_back();
if (vis[e.second >> 1]) continue;
vis[e.second >> 1] = 1;
stk.push(e);
} else {
int p = stk.top().second;
if (p != -1) {
ans.push_back((p ^ 1) + 1);
ans.push_back(p + 1);
}
stk.pop();
}
}
}
void solve() {
cin >> n;
for (int i = (0); i < (n); ++i) cin >> p[i][0] >> p[i][1];
int b = 0;
ans.reserve(2 * n);
while (b < 20)
if (valid(b + 1))
++b;
else
break;
path(b);
cout << b << '\n';
for (auto& a : ans) cout << a << ' ';
cout << '\n';
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
solve();
}
| 6 |
#include<iostream>
#include<cstdio>
#include<algorithm>
#define N (100009)
#define MOD (1000000007);
using namespace std;
long long n,a,b,r,sum,s[N],f[N];
int main()
{
scanf("%lld%lld%lld",&n,&a,&b);
if (a>b) swap(a,b);
for (int i=1; i<=n; ++i)
scanf("%lld",&s[i]);
for (int i=3; i<=n; ++i)
if (s[i]-s[i-2]<a){puts("0"); return 0;}
f[0]=1; s[0]=-b; sum=0; r=0;
for (int i=1; i<=n; ++i)
{
while (r<i && s[i]-s[r]>=b) sum=(sum+f[r++])%MOD;
f[i]=sum;
if (s[i]-s[i-1]<a) sum=0, r=i-1;
}
for (int i=r; i<=n; ++i)
sum=(sum+f[i])%MOD;
printf("%lld\n",sum);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
string solve(string s) {
vector<char> v;
for (int i = s.length() - 1; i >= 0; --i)
if (v.empty() || v.back() <= s[i]) v.push_back(s[i]);
return string(v.rbegin(), v.rend());
}
int main() {
string s;
cin >> s;
cout << solve(s);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k;
long long dip;
cin >> n >> k;
if (n <= k)
dip = 0;
else
dip = n / (2 * (k + 1));
cout << dip << " " << k * dip << " " << n - dip * (k + 1);
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long a[505], dp[505][505];
signed main() {
long long n;
cin >> n;
for (long long i = 1; i <= n; i++) cin >> a[i], dp[i][i] = 1;
for (long long le = 1; le < n; le++) {
for (long long l = 1; l + le <= n; l++) {
long long r = l + le;
dp[l][r] = INT_MAX;
if (a[l] == a[r]) {
if (le == 1) dp[l + 1][r - 1] = 1;
dp[l][r] = dp[l + 1][r - 1];
}
for (long long k = l; k < r; k++)
dp[l][r] = min(dp[l][r], dp[l][k] + dp[k + 1][r]);
}
}
cout << dp[1][n];
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9;
const long long MAX_N = 6e5 + 5;
void solve() {
long long n;
cin >> n;
if (n == 1)
cout << -1;
else {
long long k = n;
k++;
while (k % 4 != 0) k++;
cout << k / 2 << " " << 2;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
cerr << "time taken : " << (float)clock() / CLOCKS_PER_SEC << " secs" << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
template<typename T> inline void chkmin(T &a, const T &b) { a = a < b ? a : b; }
template<typename T> inline void chkmax(T &a, const T &b) { a = a > b ? a : b; }
const int MAXN = 1 << 19, MOD = 924844033;
LL modpow(LL a, int b) {
LL res = 1;
for (; b; b >>= 1) {
if (b & 1) res = res * a % MOD;
a = a * a % MOD;
}
return res;
}
void ntt(LL *a, int n, int inv) {
for (int i = 1, j = n >> 1; i < n; i++) {
if (i < j) swap(a[i], a[j]);
for (int k = n >> 1; (j ^= k) < k; k >>= 1);
}
for (int h = 2; h <= n; h <<= 1) {
int hh = h >> 1, wn = modpow(5, inv ? MOD - 1 - (MOD - 1) / h : (MOD - 1) / h);
for (int i = 0; i < n; i += h) {
LL w = 1;
for (int j = i; j < i + hh; j++) {
LL x = a[j], y = a[j + hh] * w % MOD;
a[j] = (x + y) % MOD;
a[j + hh] = (x - y + MOD) % MOD;
w = w * wn % MOD;
}
}
}
if (inv) {
LL mul = modpow(n, MOD - 2);
for (int i = 0; i < n; i++) a[i] = a[i] * mul % MOD;
}
}
LL A[MAXN], B[MAXN], fac[MAXN], inv[MAXN];
int cnt[MAXN], sz[MAXN], n;
vector<int> gra[MAXN];
void dfs(int u, int fa) {
sz[u] = 1;
for (int v : gra[u]) if (v != fa) {
dfs(v, u);
sz[u] += sz[v];
++cnt[sz[v]];
}
++cnt[n - sz[u]];
}
int main() {
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int u, v; scanf("%d%d", &u, &v);
gra[u].push_back(v), gra[v].push_back(u);
}
for (int i = fac[0] = 1; i <= n; i++) fac[i] = fac[i - 1] * i % MOD;
inv[n] = modpow(fac[n], MOD - 2);
for (int i = n; i > 0; i--) inv[i - 1] = inv[i] * i % MOD;
dfs(1, 0);
for (int i = 0; i < n; i++) {
A[i] = (LL)cnt[n - i] * fac[n - i] % MOD;
B[i] = inv[i];
}
int m = 1;
for (; m < n + n - 1; m <<= 1);
ntt(A, m, 0), ntt(B, m, 0);
for (int i = 0; i < m; i++) A[i] = A[i] * B[i] % MOD;
ntt(A, m, 1);
for (int i = 1; i <= n; i++)
printf("%lld\n", (n * fac[n] % MOD * inv[n - i] - A[n - i] + MOD) % MOD * inv[i] % MOD);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const long long MM = int(1e4) + 5;
long long m, n, i, j, x, y, t, ans, a[MM], m1, m2, u, v, s;
void xuli() { ans = s * 2 + max(0 * 1ll, m - n) * (m1 + m2); }
void xuat() {
if (n <= 2 || m < n)
cout << -1 << endl;
else {
cout << ans << endl;
for (i = 2; i <= n + 1; i++)
cout << i - 1 << " " << (i - 1) % n + 1 << endl;
for (i = n + 1; i <= m; i++) cout << u << " " << v << endl;
}
}
void nhap() {
cin >> t;
while (t--) {
cin >> n >> m;
s = 0;
m1 = MM;
m2 = MM;
for (i = 1; i <= n; i++) {
cin >> a[i];
s += a[i];
if (a[i] < m1) {
swap(m1, m2);
swap(u, v);
m1 = a[i];
u = i;
} else if (a[i] < m2) {
m2 = a[i];
v = i;
}
}
xuli();
xuat();
}
}
int main() {
nhap();
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long power(long long x, long long y) {
if (y == 0) return 1ll;
if (y % 2)
return (x % 1000000007 * power(x, y - 1) % 1000000007) % 1000000007;
else
return power((x * x) % 1000000007, y / 2) % 1000000007;
}
set<string> ans;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int n = s.length();
bool dp[n][2];
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2; j++) {
dp[i][j] = false;
}
}
if (n - 3 > 4) {
dp[n - 3][1] = true;
ans.insert(s.substr(n - 3, 3));
}
if (n - 2 > 4) {
dp[n - 2][0] = true;
ans.insert(s.substr(n - 2, 2));
}
for (int i = n - 4; i > 4; i--) {
if (dp[i + 2][1]) {
dp[i][0] = true;
ans.insert(s.substr(i, 2));
} else if (dp[i + 2][0]) {
if (s.substr(i, 2) != s.substr(i + 2, 2)) {
dp[i][0] = true;
ans.insert(s.substr(i, 2));
}
}
if (dp[i + 3][0]) {
dp[i][1] = true;
ans.insert(s.substr(i, 3));
} else if (dp[i + 3][1]) {
if (s.substr(i, 3) != s.substr(i + 3, 3)) {
dp[i][1] = true;
ans.insert(s.substr(i, 3));
}
}
}
cout << ans.size() << "\n";
for (auto j : ans) cout << j << "\n";
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int n, t;
bool visited[30000 + 10];
int adj[30000 + 10];
void DFS(int s) {
visited[s] = true;
if (!visited[adj[s]]) DFS(adj[s]);
}
int main() {
int temp;
cin >> n >> t;
for (int i = 1; i < n; i++) {
cin >> temp;
adj[i] = i + temp;
}
DFS(1);
if (visited[t])
cout << "YES";
else
cout << "NO";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<int(n);++i)
typedef long long ll;
vector<ll> width = {1LL};
ll solve(ll s1, ll s2, ll l1, ll l2, int level){
if (level == 0) return abs(l1-l2);
ll w = width[level-1];
if (s1/w != s2/w) {
return abs(s1-s2) + abs(l1-l2);
} else if (s1/w == 1 && abs(l1/w - l2/w) >= 2) {
return min(s1%w + s2%w + 2, w*2 - s1%w - s2%w) + abs(l1-l2);
} else {
return solve(s1%w, s2%w, l1, l2, level-1);
}
}
int main(void){
rep(i,30){
width.push_back(width.back() * 3LL);
}
int Q;
cin >> Q;
rep(q,Q){
ll x1,y1,x2,y2;
cin >> x1 >> y1 >> x2 >> y2;
x1--,y1--,x2--,y2--;
if (abs(x1-x2) > abs(y1-y2)) {
swap(x1,y1), swap(x2,y2);
}
cout << solve(x1,x2,y1,y2,30) << endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
inline int inc(int x, int v, int mod) {
x += v;
return x >= mod ? x - mod : x;
}
inline int dec(int x, int v, int mod) {
x -= v;
return x < 0 ? x + mod : x;
}
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
int _, __, ___;
using namespace std;
template <typename T>
inline void read(T& ret) {
ret = 0;
T f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
ret = (ret << 3) + (ret << 1) + (c ^ 48);
c = getchar();
}
ret = ret * f;
}
template <typename T, typename... Args>
inline void read(T& t, Args&... args) {
read(t);
read(args...);
}
long long read() {
long long ret = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
ret = (ret << 3) + (ret << 1) + (c ^ 48);
c = getchar();
}
return ret * f;
}
const int MAXN = 4e6 + 10;
int lowbit(int x) { return x & -x; }
struct bit {
struct tree {
int N;
long long a[MAXN];
void add(int x, long long v) {
while (x <= N) a[x] += v, x += lowbit(x);
}
long long sum(int x) {
long long sum = 0;
while (x) sum += a[x], x -= lowbit(x);
return sum;
}
} T1, T2;
void add(int x, long long v) {
T1.add(x, v);
T2.add(x, x * v);
}
void update(int L, int R, long long v) {
add(L, v);
add(R + 1, -v);
}
long long sum(int x) { return (x + 1) * T1.sum(x) - T2.sum(x); }
long long query(int L, int R) { return sum(R) - sum(L - 1); }
} tx, ty;
int main() {
int n, m, w;
read(n, m, w);
int op;
int x1, x2, y1, y2;
long long v;
tx.T1.N = tx.T2.N = n;
ty.T1.N = ty.T2.N = m;
long long tot = 0;
while (w--) {
read(op, x1, y1, x2, y2);
if (op) {
long long ans = tx.query(x1, x2) + ty.query(y1, y2);
printf("%lld\n", ans - tot);
} else {
scanf("%lld", &v);
tot += (x2 - x1 + 1) * (y2 - y1 + 1) * v;
tx.update(x1, x2, v * (y2 - y1 + 1));
ty.update(y1, y2, v * (x2 - x1 + 1));
}
}
return 0;
}
| 5 |
#include <cstdio>
#include <vector>
#include <algorithm>
#define STR_MAX 100000
using namespace std;
vector<int> pos[26];
long long int cycl=0,p=0,N;
int main(){
char str[STR_MAX+1];
scanf("%s",str);
for(int i=0;str[i] != '\0';i++){
pos[str[i]-'a'].push_back(i+1);
N++;
}
scanf("%s",str);
for(int i=0;str[i] != '\0';i++){
int ch=str[i]-'a';
if(pos[ch].size()==0){
printf("-1\n");return 0;
}
auto chp=upper_bound(pos[ch].begin(),pos[ch].end(),p);
if(chp==pos[ch].end()){
cycl++;chp=pos[ch].begin();
}
p=*chp;
}
printf("%ld",cycl*N+p);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200010;
int n, k, q;
int a[MAXN], b[MAXN];
int main() {
scanf("%d%d%d", &n, &k, &q);
for (int i = 1; i <= n; i++) {
int l, r;
scanf("%d%d", &l, &r);
a[l]++;
a[r + 1]--;
}
for (int i = 1; i <= 200000; i++) {
a[i] += a[i - 1];
b[i] = b[i - 1];
if (a[i] >= k) b[i]++;
}
while (q--) {
int l, r;
scanf("%d%d", &l, &r);
printf("%d\n", b[r] - b[l - 1]);
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
string s;
int act = 'a', next, sum = 0;
cin >> s;
for (int i = 0; i < s.size(); i++) {
next = s[i];
sum += min(abs(act - next), 26 - abs(act - next));
act = next;
}
cout << sum << '\n';
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string s;
cin >> n >> s;
string t = s.substr(0, n / 2);
if (s == t + t) {
cout << "Yes" << endl;
} else {
cout << "No" << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n;
if (n % 2 == 0) {
m = n / 2 + 1;
cout << m << endl;
for (int i = 1; i <= n / 2; i++) {
cout << "1 " << i << endl;
}
for (int i = 1; i <= n / 2; i++) {
cout << m << ' ' << i << endl;
}
} else {
m = (n - 1) / 2 + 1;
cout << m << endl;
for (int i = 1; i <= (n + 1) / 2; i++) {
cout << "1 " << i << endl;
}
for (int i = 2; i <= (n + 1) / 2; i++) {
cout << m << ' ' << i << endl;
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1E6 + 10;
long long read() {
long long a = 0;
char b = 1, c;
do
if ((c = getchar()) == 45) b = -1;
while (c < 48 || c > 57);
do a = (a << 3) + (a << 1) + (c & 15);
while ((c = getchar()) > 47 && c < 58);
return a * b;
}
void write(long long x, char c) {
if (x < 0) putchar('-'), x = -x;
char a[20], s = 0;
do a[++s] = x % 10 | 48;
while (x /= 10);
do putchar(a[s]);
while (--s);
putchar(c);
}
int a[N], b[N];
long long c[N], r[N];
bool check() {
int n = read();
long long s = 0;
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i <= n; ++i) {
b[i] = read();
a[i] -= b[i];
s += a[i];
}
if (s > 0) return 0;
c[n] = r[n] = 0;
for (int i = n; i >= 2; --i) {
c[i - 1] = max(c[i] + a[i], 0ll);
r[i - 1] = r[i] + a[i];
}
for (long long i = 1, t = 0, mx = 0; i <= n; ++i) {
if (b[i] < c[i] || b[i] < r[i]) return 0;
t += a[i];
mx = max(mx, t);
r[i + 1] += mx;
}
return 1;
}
int main() {
for (int x = read(); x--;) {
puts(check() ? "YES" : "NO");
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int dcmp(long double x, long double y) {
return fabs(x - y) <= 1e-9 ? 0 : x < y ? -1 : 1;
}
const int MAX = 5e5 + 10;
const long long MOD = 1e9 + 7;
class UnionFind {
private:
vector<int> p, rank, setSize;
int numSets;
public:
UnionFind(int N) {
setSize.assign(N, 1);
numSets = N;
rank.assign(N, 0);
p.assign(N, 0);
for (int i = 0; i < N; i++) p[i] = i;
}
int findSet(int i) { return (p[i] == i) ? i : (p[i] = findSet(p[i])); }
bool isSameSet(int i, int j) { return findSet(i) == findSet(j); }
void unionSet(int i, int j) {
if (!isSameSet(i, j)) {
numSets--;
int x = findSet(i), y = findSet(j);
if (rank[x] > rank[y]) {
p[y] = x;
setSize[x] += setSize[y];
} else {
p[x] = y;
setSize[y] += setSize[x];
if (rank[x] == rank[y]) rank[y]++;
}
}
}
int numDisjointSets() { return numSets; }
int sizeOfSet(int i) { return setSize[findSet(i)]; }
};
void solve();
void read();
void clear();
int n, m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
solve();
}
void read() {}
void solve() {
cin >> n >> m;
UnionFind dsu = UnionFind(n + 1);
for (int i = 0; i < (int)(m); ++i) {
int siz;
cin >> siz;
int last = -1;
for (int j = 0; j < (int)(siz); ++j) {
int u;
cin >> u;
if (last != -1) {
dsu.unionSet(u, last);
}
last = u;
}
}
for (int i = 0; i < (int)(n); ++i) {
cout << dsu.sizeOfSet(i + 1) << ' ';
}
cout << '\n';
}
| 3 |
#include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
template <typename T>
void setmax(T& x, T y) {
x = max(x, y);
}
template <typename T>
void setmin(T& x, T y) {
x = min(x, y);
}
void solve() {
int n;
cin >> n;
vector<int> a(n);
vector<int> r(n);
vector<int> c(n);
for (int i = 0; i < int(n); i++) cin >> a[i];
bool ok = 1;
vector<pair<int, int>> ans;
vector<int> ones;
vector<int> last;
for (int i = n - 1; ~i; i--) {
if (a[i] == 0) continue;
if (a[i] == 1) {
ans.push_back({i, i});
ones.push_back(i);
continue;
}
if (a[i] == 3) {
ans.push_back({i, i});
int last_col;
if (last.empty() and ones.empty()) {
ok = 0;
break;
} else if (!last.empty()) {
last_col = last.back();
last.pop_back();
} else {
last_col = ones.back();
ones.pop_back();
}
ans.push_back({i, last_col});
} else {
if (ones.empty()) {
ok = 0;
break;
}
int last_row = ones.back();
ones.pop_back();
ans.push_back({last_row, i});
}
last.push_back(i);
}
if (!ok) {
cout << -1;
return;
}
cout << (int)ans.size() << '\n';
for (auto [x, y] : ans) {
cout << x + 1 << ' ' << y + 1 << '\n';
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int t = 1;
for (int i = 0; i < int(t); i++) {
solve();
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
int num[100050];
int s[100050];
int t[100500];
int main() {
while (scanf("%d", &n) == 1) {
for (int i = 0; i < n; i++) scanf("%d", &num[i]);
s[0] = num[0];
for (int i = 1; i < n; i++) s[i] = s[i - 1] + num[i];
s[n] = 0;
for (int i = n - 1; i >= 0; i--) t[i] = t[i + 1] + num[i];
int mx = max(s[n - 1], t[0]);
int mt = 1000000000;
int ind = -1;
mx = max(mx, -t[0]);
for (int i = 1; i < n; i++) {
if (s[i - 1] < mt) {
mt = s[i - 1];
ind = i - 1;
}
mx = max(-t[i] + s[i - 1], mx);
if (mt < 0 && ind != -1) {
mx = max(-t[i] - s[ind] + (s[i - 1] - s[ind]), mx);
}
}
mt = 1000000000;
ind = n;
mx = max(mx, -s[n - 1]);
for (int i = n - 2; i >= 0; i--) {
if (t[i + 1] < mt) {
mt = t[i + 1];
ind = i + 1;
}
mx = max(-s[i] + t[i + 1], mx);
if (mt < 0 && ind != n) {
mx = max(-s[i] - t[ind] + (t[i + 1] - t[ind]), mx);
}
}
printf("%d\n", mx);
}
return 0;
}
| 3 |
#include <cstdio>
#define max(a,b) ((a) > (b) ? (a) : (b))
int N,a,b,t,r[21][21]={0},dp[21]={0};
int l=0;
int rec(int loc, int bef){
int tmp = -1;
dp[loc] = -1;
for(int i = 1; i <= N; i++){
if(r[loc][i] > 0 && dp[i] == 0){
int t2 = rec(i,loc);
tmp = max(tmp,t2);
}
}
if(tmp == -1)
return 0;
dp[loc] = tmp;
l += r[loc][bef]*2;
return tmp + r[loc][bef];
}
int main(){
while(scanf("%d",&N), N != 0){
l = 0;
for(int i = 1; i <= N; i++){
for(int j = 1; j <= N; j++){
r[i][j] = 0;
}
dp[i] = 0;
}
for(int i = 1; i < N; i++){
scanf("%d%d%d",&a,&b,&t);
r[a][b] = r[b][a] = t;
}
rec(1,1);
printf("%d\n", l - dp[1]);
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, r = 0, g = 0, b = 0;
string s;
cin >> n >> s;
for (int i = 0; i < n; i++) {
if (s[i] == 'R')
r++;
else if (s[i] == 'G')
g++;
else
b++;
}
if (r == n) {
cout << "R";
return;
}
if (b == n) {
cout << "B";
return;
}
if (g == n) {
cout << "G";
return;
}
if (b != n - 1) cout << "B";
if (g != n - 1) cout << "G";
if (r != n - 1) cout << "R";
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int t = 1;
while (t--) {
solve();
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
void file(string s) {
freopen((s + ".in").c_str(), "r", stdin);
freopen((s + ".out").c_str(), "w", stdout);
}
template <typename Tp>
void read(Tp &x) {
int fh = 1;
char c = getchar();
x = 0;
while (c > '9' || c < '0') {
if (c == '-') {
fh = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 1) + (x << 3) + (c & 15);
c = getchar();
}
x *= fh;
}
int n, m;
vector<int> G[1000005];
namespace Tarjan {
int dfn[1000005], ndfn[1000005], low[1000005], ins[1000005], tot;
stack<int> stk;
int FLG;
int l2[1000005];
void dfs0(int x) {
dfn[x] = low[x] = ++tot;
ins[x] = 1;
stk.push(x);
for (auto y : G[x]) {
if (dfn[y]) {
if (ins[y])
low[x] = min(low[x], dfn[y]);
else
FLG = -1;
} else {
dfs0(y);
low[x] = min(low[x], low[y]);
}
}
ins[x] = 0;
stk.pop();
}
void dfs(int x) {
dfn[x] = low[x] = l2[x] = ++tot;
ndfn[tot] = x;
ins[x] = 1;
stk.push(x);
for (auto y : G[x]) {
if (dfn[y]) {
if (ins[y]) {
if (dfn[y] < low[x]) {
swap(low[x], l2[x]);
low[x] = dfn[y];
} else {
if (dfn[y] < l2[x]) l2[x] = dfn[y];
}
}
} else {
dfs(y);
if (low[y] < low[x]) {
swap(low[x], l2[x]);
low[x] = low[y];
} else {
if (low[y] < l2[x]) l2[x] = low[y];
}
if (l2[y] < low[x]) {
swap(low[x], l2[x]);
low[x] = l2[y];
} else {
if (l2[y] < l2[x]) l2[x] = l2[y];
}
}
}
if (dfn[x] == low[x]) {
int y = stk.top();
stk.pop();
ins[y] = 0;
while (y != x) {
y = stk.top();
stk.pop();
ins[y] = 0;
}
}
}
bool chk_good(int RT, int tp = 0) {
for (int i = 1; i <= n; ++i) dfn[i] = low[i] = l2[i] = ins[i] = 0;
tot = 0;
FLG = 0;
dfs0(RT);
if (tot != n || FLG == -1) return 0;
if (tp) {
for (int i = 1; i <= n; ++i) dfn[i] = low[i] = l2[i] = ins[i] = 0;
tot = 0;
FLG = 0;
dfs(RT);
}
return 1;
}
} // namespace Tarjan
int ans[1000005];
int ta[1000005];
signed main() {
srand(time(0));
int CasT;
read(CasT);
while (CasT--) {
read(n);
read(m);
for (int i = 1; i <= n; ++i) ans[i] = 0, G[i].clear();
for (int i = 1, u, v; i <= m; ++i) {
read(u);
read(v);
G[u].push_back(v);
}
for (int i = 1; i <= n; ++i) ta[i] = i;
random_shuffle(ta + 1, ta + n + 1);
int RT = -1;
for (int i = 1; i <= n && i <= 100; ++i) {
if (Tarjan::chk_good(i)) RT = i;
}
random_shuffle(ta + 1, ta + n + 1);
for (int i = n; i >= 1 && i >= n - 100; --i) {
if (Tarjan::chk_good(i)) RT = i;
}
if (n >= 104 && Tarjan::chk_good(104)) RT = 104;
if (n >= 80000 && Tarjan::chk_good(80000)) RT = 80000;
if (RT == -1) {
puts("-1");
continue;
}
Tarjan::chk_good(RT, 1);
ans[RT] = 1;
for (int i = 2; i <= Tarjan::tot; ++i) {
int x = Tarjan::ndfn[i];
if (Tarjan::dfn[x] == Tarjan::low[x])
ans[x] = -1;
else {
if (Tarjan::dfn[x] != Tarjan::l2[x])
ans[x] = -1;
else
ans[x] = ans[Tarjan::ndfn[Tarjan::low[x]]];
}
}
int cnt = 0;
for (int i = 1; i <= n; ++i)
if (ans[i] == 1) ++cnt;
if (cnt * 5 >= n) {
for (int i = 1; i <= n; ++i) {
if (ans[i] == 1) printf("%d ", i);
}
puts("");
} else {
puts("-1");
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
double prob[2002][2002];
int main() {
int n, t;
double p;
cin >> n;
cin >> p;
cin >> t;
prob[0][0] = 1;
for (int i = 1; i <= t; i++) {
prob[i][0] = 0;
prob[0][i] = prob[0][i - 1] * (1 - p);
}
for (int i = 1; i < n; i++) {
for (int j = 1; j <= t; j++) {
prob[i][j] = prob[i - 1][j - 1] * p + prob[i][j - 1] * (1 - p);
}
}
for (int i = 1; i <= t; i++) {
prob[n][i] = prob[n - 1][i - 1] * p + prob[n][i - 1];
}
double ans = 0;
for (int i = 0; i <= n; i++) {
ans += prob[i][t] * i;
}
printf("%.9f", ans);
cout << endl;
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
struct point {
int x, y;
point(int _x = 0, int _y = 0) : x(_x), y(_y) {}
bool operator<(const point &o) const {
return x < o.x || x == o.x && y < o.y;
}
} p[200000];
int main() {
int n, k;
scanf("%d%d", &n, &k);
if (k >= n) {
printf("-1\n");
return 0;
}
for (int i = 0; i < n; i++) scanf("%d%d", &p[i].x, &p[i].y);
sort(p, p + n);
vector<pair<int, int> > ans;
for (int i = 0; i <= k; i++)
for (int j = 0; i + j <= k; j++) {
int t = k - i - j;
int _x = p[i].x + p[n - j - 1].x;
int _y = p[i].y + p[n - j - 1].y;
bool flag = true;
for (int l = i; l < n - j; l++) {
int loc = lower_bound(p, p + n, point(_x - p[l].x, _y - p[l].y)) - p;
if (p[loc].x + p[l].x != _x || p[loc].y + p[l].y != _y) {
if (t == 0) {
flag = false;
break;
}
t--;
}
}
if (flag) ans.push_back(make_pair(_x, _y));
}
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
printf("%d\n", ans.size());
for (int i = 0; i < ans.size(); i++)
printf("%.1lf %.1lf\n", (double)ans[i].first / 2,
(double)ans[i].second / 2);
return 0;
}
| 6 |
#include <iostream>
#include <cstdio>
#include <map>
#define reep(i,n,m) for(int i=(n);i<(m);i++)
#define rep(i,n) reep(i,0,n)
using namespace std;
typedef pair<int,int> pii;
typedef long long ll;
int main(){
ll H,W,N;
cin >> H >> W >> N;
map<pii,ll> num;
rep(i,N){
int x,y;
cin >> y >> x;
y--;
x--;
int dx[] = {1,-1,0};
int dy[] = {1,-1,0};
rep(k,3){
rep(j,3){
int nx = x + dx[k];
int ny = y + dy[j];
if(nx<1||nx>=W-1||ny<1||ny>=H-1){
continue;
}
num[pii(ny,nx)]++;
}
}
}
ll cou[10] = {0};
cou[0] = (W-2)*(H-2);
map<pii,ll>::iterator it = num.begin();
while(it!=num.end()){
cou[it->second]++;
cou[0]--;
it++;
}
rep(i,10){
cout << cou[i] << endl;
}
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct node {
int id;
int x, y;
} a[3];
bool cmp(node xx, node yy) { return xx.y > yy.y; }
char s[505][505];
int main() {
int sum = 0;
for (int i = 0; i < 3; i++) {
scanf("%d%d", &a[i].x, &a[i].y);
if (a[i].x > a[i].y) swap(a[i].x, a[i].y);
a[i].id = i;
sum += a[i].x * a[i].y;
}
sort(a, a + 3, cmp);
int tmp = a[0].y;
if (tmp * tmp != sum) {
puts("-1");
return 0;
}
printf("%d\n", tmp);
for (int i = 0; i < a[0].x; i++, puts(""))
for (int j = 0; j < a[0].y; j++) putchar('A' + a[0].id);
if (a[1].y == tmp && a[2].y == tmp) {
for (int i = 0; i < a[1].x; i++, puts(""))
for (int j = 0; j < a[1].y; j++) putchar('A' + a[1].id);
for (int i = 0; i < a[2].x; i++, puts(""))
for (int j = 0; j < a[2].y; j++) putchar('A' + a[2].id);
return 0;
}
if (a[1].x + a[0].x - tmp) swap(a[1].x, a[1].y);
if (a[2].x + a[0].x - tmp) swap(a[2].x, a[2].y);
for (int i = a[0].x; i < tmp; i++)
for (int j = 0; j < a[1].y; j++) s[i][j] = 'A' + a[1].id;
for (int i = a[0].x; i < tmp; i++)
for (int j = a[1].y; j < tmp; j++) s[i][j] = 'A' + a[2].id;
for (int i = a[0].x; i < tmp; i++) puts(s[i]);
}
| 4 |
#include <stdio.h>
#include <stdlib.h>
typedef long long ll;
int main(void) {
ll i, j, k, h, w, l;
int dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0};
char dir[6] = "NESW";
while( 1 ) {
ll x, y, d, cycle;
scanf("%lld%lld%lld", &h, &w, &l);
if(!h && !w && !l) break;
ll a[h][w][4];
char c[h][w + 10];
for(i = 0; i < h; ++i) {
scanf("%s", c[i]);
for(j = 0; j < w; ++j) {
if(c[i][j] == 'N') x = j, y = i, d = 0;
else if(c[i][j] == 'E') x = j, y = i, d = 1;
else if(c[i][j] == 'S') x = j, y = i, d = 2;
else if(c[i][j] == 'W') x = j, y = i, d = 3;
}
}
for(i = 0; i < h; ++i) for(j = 0; j < w; ++j) for(k = 0; k < 4; ++k) a[i][j][k] = -1;
a[y][x][d] = 0;
for(i = 0; i < l; ) {
if(x + dx[d] >= w || y + dy[d] >= h || x + dx[d] < 0 || y + dy[d] < 0 || c[y + dy[d]][x + dx[d]] == '#') {
d = (d + 1) % 4;
if(a[y][x][d] == -1) a[y][x][d] = i;
else {
cycle = i - a[y][x][d];
break;
}
} else {
y += dy[d], x += dx[d], ++i;
if(a[y][x][d] == -1) a[y][x][d] = i;
else {
cycle = i - a[y][x][d];
break;
}
}
}
if(i == l) {
printf("%lld %lld %c\n", y + 1, x + 1, dir[d]);
continue;
}
l -= i;
l %= cycle;
for(i = 0; i < (!l ? cycle : l); ) {
if(x + dx[d] >= w || y + dy[d] >= h || x + dx[d] < 0 || y + dy[d] < 0 || c[y + dy[d]][x + dx[d]] == '#') {
d = (d + 1) % 4;
} else {
y += dy[d], x += dx[d], ++i;
}
}
/*for(i = 0; i < h; ++i) {
for(j = 0; j < w; ++j) printf("%lld/%lld/%lld/%lld ", a[i][j][0], a[i][j][1], a[i][j][2], a[i][j][3]);
printf("\n");
}*/
printf("%lld %lld %c\n", y + 1, x + 1, dir[d]);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
#define mod 998244353
#define MOD 1000000007
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3fll
typedef long long ll;
typedef pair<int,int> pii;
typedef unsigned long long ull;
const int maxn=(1<<18)+10;
int n,k,s,t,m;
vector<int> a;
ll C[55][55],ways[55];
ll cnt[maxn];
void solve()
{
for(int i=0;i<m;i++)
{
for(int msk=0;msk<(1<<m);msk++)
{
if(!(msk>>i&1))
{
cnt[msk^(1<<i)]+=cnt[msk];
}
}
}
}
int main()
{
scanf("%d%d%d%d",&n,&k,&s,&t);
for(int i=0;i<n;i++)
{
int x;
scanf("%d",&x);
if(((x&s)==s)&&((x|t)==t))a.push_back(x);
}
if(a.empty())
{
printf("0\n");
return 0;
}
n=a.size();
C[0][0]=1;
for(int i=1;i<55;i++)
{
C[i][0]=C[i][i]=1;
for(int j=1;j<i;j++)C[i][j]=C[i-1][j]+C[i-1][j-1];
}
for(int i=0;i<55;i++)
{
for(int j=0;j<=i&&j<k;j++)ways[i]+=C[i][j];
// if(i<=n)cout<<i<<" "<<ways[i]<<endl;
}
int free=(s^t);
vector<int> bts;
bts.clear();
for(int i=0;i<18;i++)if(free>>i&1)bts.push_back(i);
m=bts.size();
for(int i=0;i<n;i++)
{
int tmp=a[i];
a[i]=0;
for(int j=0;j<m;j++)if(tmp>>bts[j]&1)a[i]|=(1<<j);
// cout<<a[i]<<endl;
}
ll ans=0;
for(int i=0;i<n;i++)
{
memset(cnt,0,sizeof(cnt));
for(int j=i+1;j<n;j++)
{
cnt[a[i]^a[j]]++;
}
// for(int j=0;j<(1<<m);j++)cout<<cnt[j]<<endl;system("pause");
solve();
for(int j=0;j<(1<<m);j++)
{
int sz=__builtin_popcount(j);
if(sz&1)ans-=ways[cnt[j]];
else ans+=ways[cnt[j]];
}
}
if(ans<0)ans=-ans;
printf("%lld\n",ans);
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int n, m, d, a[1007], c[1007], ans[1007];
int sum = 0;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n >> m >> d;
for (int i = 1; i <= m; i++) {
cin >> a[i];
sum += a[i];
c[i] = a[i];
}
for (int i = m; i >= 1; i--) c[i] += c[i + 1];
sum += (d - 1) * (m + 1) + 1;
if (sum < n + 1) return cout << "NO\n", 0;
cout << "YES\n";
int idx = 1, i = 1, dd = 0;
while (idx <= m && i <= n) {
while (n - i + 1 > c[idx] && dd < d - 1) {
dd++;
i++;
}
for (int j = i; j < i + a[idx]; j++) ans[j] = idx;
i += a[idx];
dd = 0;
idx++;
}
for (int i = 1; i <= n; i++) cout << ans[i] << " ";
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int t;
cin >> t;
while (t--) {
long long int n, m, k;
cin >> n >> m >> k;
k = min(k, m - 1);
vector<long long int> v(n);
for (long long int(i) = (0); (i) < (n); (i)++) cin >> v[i];
long long int gg = 0;
for (long long int(i) = (0); (i) < (k + 1); (i)++) {
long long int ans = INT_MAX;
for (long long int(j) = (0); (j) < (m - k); (j)++) {
long long int s = max(v[i + j], v[i + j + (n - m)]);
ans = min(s, ans);
}
gg = max(ans, gg);
}
cout << gg << endl;
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
const long long MAX_N = 4e3 + 10;
const long long mod = 1e9 + 7;
const int INF = 1e9;
inline long long bpow(long long t, long long n) {
long long ans = 1;
while (n > 0) {
if (n & 1) ans = (ans * t) % mod;
t = (t * t) % mod, n >>= 1;
}
return ans;
}
unordered_map<int, int> dp;
int a[MAX_N];
int ind(int l, int r, int k, int x) {
return l * 8000 * 65 + r * 130 + k * 2 + x;
}
int cdp(int l, int r, int k, int x) {
if ((r - l + 1) < k) return 0;
int pos = ind(l, r, k, x);
if (dp.count(pos)) return dp[pos];
int& ans = dp[pos];
if (x == 0)
ans = max(cdp(l + k, r, k, 1) + a[l + k - 1] - a[l - 1],
(r - l >= k) ? (a[l + k] - a[l - 1] + cdp(l + k + 1, r, k + 1, 1))
: (-INF));
else
ans = min(a[r - k] - a[r] + cdp(l, r - k, k, 0),
(r - l >= k) ? (a[r - k - 1] - a[r] + cdp(l, r - k - 1, k + 1, 0))
: INF);
return ans;
}
int main() {
dp.rehash(4000 * 4000);
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cout << fixed << setprecision(0);
int n;
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i <= n; i++) a[i] += a[i - 1];
cout << cdp(1, n, 1, 0);
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
long long _t, x, y, k;
cin >> _t;
while (_t--) {
int flag = 0;
cin >> x >> y >> k;
if (k - max(x, y) & 1) flag = 1;
if (x > k || y > k)
cout << -1 << endl;
else {
if (flag) {
if ((x + y) & 1)
cout << k - 1 << endl;
else
cout << k - 2 << endl;
} else {
if ((x + y) & 1)
cout << k - 1 << endl;
else
cout << k << endl;
}
}
}
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int N = 1000000007;
void solve() {
int a, b, c, d;
cin >> b >> a >> c >> d;
cout << (c - 1) / a + b / a - d / a << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
cin >> t;
while (t--) {
solve();
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 55, Ti = 20005;
struct edge {
int v;
double w;
int nxt;
} e[N * 2];
int hd[N], cnt, dis[N][N], n, m, T, X, L, C, R[6 * Ti];
void adde(int u, int v, int w) {
e[++cnt] = (edge){v, (double)w, hd[u]}, hd[u] = cnt;
}
double F[N][2 * Ti], P[N * 2][2 * Ti], G[N * 2][2 * Ti];
struct E {
double x, y;
E() {}
E(double a) : x(a), y(0) {}
E(double a, double b) : x(a), y(b) {}
E operator+(const E& a) { return E(x + a.x, y + a.y); }
E operator-(const E& a) { return E(x - a.x, y - a.y); }
E operator*(const E& a) { return E(x * a.x - y * a.y, x * a.y + y * a.x); }
void operator*=(const E& a) { *this = *this * a; }
};
E A[6 * Ti], B[6 * Ti];
double pi = acos((double)-1);
void fft(E* x, int t) {
E wn, w, l, r;
for (int i = 0; i < L; i++)
if (i < R[i]) swap(x[i], x[R[i]]);
for (int i = 1; i < L; i <<= 1) {
wn = E(cos(pi / i), sin(pi / i * t));
for (int I = i << 1, j = 0; j < L; j += I) {
w = 1;
for (int k = 0; k < i; k++, w *= wn) {
l = x[j + k], r = w * x[j + k + i];
x[j + k] = l + r, x[j + k + i] = l - r;
}
}
}
}
void cal(int u, int l, int mid, int r) {
if (u == n) return;
for (int i = hd[u]; i; i = e[i].nxt) {
for (int j = 0; j < L; j++) B[j] = A[j] = 0;
for (int j = 1; j <= r - l; j++) B[r - l - j] = P[i][j];
for (int j = mid + 1; j <= r; j++) A[j - mid] = F[e[i].v][j];
fft(A, 1), fft(B, 1);
for (int j = 0; j < L; j++) A[j] *= B[j];
fft(A, -1);
for (int j = l; j <= mid; j++) G[i][j] += A[r - l - mid + j].x / L;
}
}
void update(int u, int l, int r) {
for (int i = l; i <= r; i++) {
F[u][i] = 1e200;
for (int j = hd[u]; j; j = e[j].nxt)
F[u][i] = min(F[u][i], G[j][i] + e[j].w);
}
}
void print() {
for (int i = 1; i <= n; i++) {
cout << i << endl;
for (int j = 0; j <= 2 * T; j++)
cout << fixed << setprecision(2) << F[i][j] << ' ';
cout << endl;
}
cout << endl;
}
void solve(int l, int r) {
if (l < r) {
int mid = (l + r) >> 1;
solve(mid + 1, r);
for (L = 1, C = 0; L <= 2 * r - l - mid; L <<= 1, C++)
;
for (int i = 0; i < L; i++) R[i] = R[i >> 1] >> 1 | (i & 1) << (C - 1);
for (int i = 1; i < n; i++) cal(i, l, mid, r);
solve(l, mid);
} else
for (int i = 1; i < n; i++) update(i, l, r);
}
double check(double x) { return max(x, (double)0); }
int main() {
cin >> n >> m >> T >> X;
memset(dis, 0x3f, sizeof(dis));
for (int i = 1, u, v, w; i <= m; i++) {
scanf("%d%d%d", &u, &v, &w);
adde(u, v, w), dis[u][v] = w;
for (int j = 1, p; j <= T; j++)
scanf("%d", &p), P[i][j] = (double)p / 100000.0;
}
for (int i = 1; i <= n; i++) dis[i][i] = 0;
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1; j <= n; j++)
dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
for (L = 1, C = 0; L <= 3 * T; L <<= 1, C++)
;
for (int i = 0; i < L; i++) R[i] = R[i >> 1] >> 1 | (i & 1) << (C - 1);
for (int i = 1; i <= n; i++)
fill(F[i] + T + 1, F[i] + 2 * T + 1, X + dis[i][n]);
for (int i = 1; i < n; i++) cal(i, 0, T, 2 * T);
solve(0, T);
cout << fixed << setprecision(10) << check(F[1][0]);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int n,x;
int main(){
cin>>n;
for(int i=0;i<n;i++){
cin>>x;
if(x%2) continue;
else if(x%3==0 || x%5==0) continue;
else{
cout<<"DENIED";
return 0;
}
}
cout<<"APPROVED";
return 0;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.