solution
stringlengths 52
181k
| difficulty
int64 0
6
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
unsigned long long n;
string s;
unsigned long long cal(unsigned long long l) {
if (l == -1) return 0;
unsigned long long k = 1, z = 0;
for (unsigned long long i = l; i >= 0; i--) {
if ((z + (s[i] - '0') * k) < n) {
z = z + (s[i] - '0') * k;
k *= 10;
if (s[i] != '0') l = i;
} else
break;
}
return z + cal(l - 1) * n;
}
int main() {
cin >> n;
cin >> s;
cout << cal(s.length() - 1);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
inline long long getInt() {
long long ret;
char ch;
bool flg = false;
while ((ch = getchar()) < '0' || ch > '9') flg |= (ch == '-');
ret = ch - '0';
while ((ch = getchar()) >= '0' && ch <= '9') ret = ret * 10 + (ch - '0');
return flg ? -ret : ret;
}
const int MOD = 1000000007;
inline int advPow(int a, int b) {
int ret = 1;
while (b) {
if (b & 1) ret = (long long)ret * a % MOD;
a = (long long)a * a % MOD;
b >>= 1;
}
return ret;
}
const int MAXK = 5050;
int dp[2][MAXK];
int main() {
int N = getInt(), K = getInt();
for (int i = 1; i <= K; i++) {
dp[i & 1][i] = 1;
for (int j = 1; j < i; j++)
dp[i & 1][j] =
(dp[!(i & 1)][j - 1] + (long long)dp[!(i & 1)][j] * j) % MOD;
}
int ans = 0, fc = 1;
for (int i = 1; i <= min(N, K); i++) {
fc = (long long)fc * (N - i + 1) % MOD;
ans = (ans + (long long)dp[K & 1][i] * fc % MOD * advPow(2, N - i)) % MOD;
}
printf("%d\n", ans);
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
long long sum = 0;
cin >> n;
for (int i = 0; i < n; i++) {
char x;
cin >> x;
if (x == 'B') {
sum += pow(2, i);
}
}
cout << sum;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int n, i, l, r, a[300300];
pair<int, long long> p;
map<int, pair<int, long long> > m;
long long sum, cur, res;
vector<int> v;
int main() {
res = -1000000000;
res *= 1000000000;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
if (m.count(a[i])) {
p = m[a[i]];
cur = sum - p.second + a[i];
if (a[i] < 0) cur += a[i];
if (cur > res) {
res = cur;
l = p.first;
r = i;
}
if (sum < p.second) m[a[i]] = make_pair(i, sum);
} else
m[a[i]] = make_pair(i, sum);
if (a[i] >= 0) sum += a[i];
}
for (i = 1; i <= n; i++)
if (i < l || i > r || (i > l && i < r && a[i] < 0)) v.push_back(i);
printf("%I64d %d\n", res, int(v.size()));
for (i = 0; i < v.size(); i++)
printf("%d%c", v[i], (i + 1 == v.size()) ? '\n' : ' ');
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <int MOD_>
struct modnum {
static constexpr int MOD = MOD_;
static_assert(MOD_ > 0, "MOD must be positive");
private:
using ll = long long;
int v;
static int minv(int a, int m) {
a %= m;
assert(a);
return a == 1 ? 1 : int(m - ll(minv(m, a)) * ll(m) / a);
}
public:
modnum() : v(0) {}
modnum(ll v_) : v(int(v_ % MOD)) {
if (v < 0) v += MOD;
}
explicit operator int() const { return v; }
friend std::ostream& operator<<(std::ostream& out, const modnum& n) {
return out << int(n);
}
friend std::istream& operator>>(std::istream& in, modnum& n) {
ll v_;
in >> v_;
n = modnum(v_);
return in;
}
friend bool operator==(const modnum& a, const modnum& b) {
return a.v == b.v;
}
friend bool operator!=(const modnum& a, const modnum& b) {
return a.v != b.v;
}
modnum inv() const {
modnum res;
res.v = minv(v, MOD);
return res;
}
modnum neg() const {
modnum res;
res.v = v ? MOD - v : 0;
return res;
}
modnum operator-() const { return neg(); }
modnum operator+() const { return modnum(*this); }
modnum& operator++() {
v++;
if (v == MOD) v = 0;
return *this;
}
modnum& operator--() {
if (v == 0) v = MOD;
v--;
return *this;
}
modnum& operator+=(const modnum& o) {
v += o.v;
if (v >= MOD) v -= MOD;
return *this;
}
modnum& operator-=(const modnum& o) {
v -= o.v;
if (v < 0) v += MOD;
return *this;
}
modnum& operator*=(const modnum& o) {
v = int(ll(v) * ll(o.v) % MOD);
return *this;
}
modnum& operator/=(const modnum& o) { return *this *= o.inv(); }
friend modnum operator++(modnum& a, int) {
modnum r = a;
++a;
return r;
}
friend modnum operator--(modnum& a, int) {
modnum r = a;
--a;
return r;
}
friend modnum operator+(const modnum& a, const modnum& b) {
return modnum(a) += b;
}
friend modnum operator-(const modnum& a, const modnum& b) {
return modnum(a) -= b;
}
friend modnum operator*(const modnum& a, const modnum& b) {
return modnum(a) *= b;
}
friend modnum operator/(const modnum& a, const modnum& b) {
return modnum(a) /= b;
}
};
template <typename T>
T pow(T a, long long b) {
assert(b >= 0);
T r = 1;
while (b) {
if (b & 1) r *= a;
b >>= 1;
a *= a;
}
return r;
}
using num = modnum<int(1e9) + 7>;
const int MAXN = 1.1e5;
int N;
num K;
num phi[MAXN];
num phiSum[MAXN];
num kCoeff[MAXN * 2];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
cin >> N >> K;
for (int i = 0; i <= N; i++) {
phi[i] = i;
}
for (int p = 2; p <= N; p++) {
if (phi[p] != p) continue;
for (int j = p; j <= N; j += p) {
phi[j] -= phi[j] / p;
}
}
phiSum[0] = 0;
for (int i = 1; i <= N; i++) {
phiSum[i] = phiSum[i - 1] + phi[i];
}
for (int i = 0; i <= N - 2; i++) {
kCoeff[i] += N - 1 - i;
}
for (int g = 1; g <= N - 1; g++) {
int v = (N + g - 1) / g;
if (v > 1) {
kCoeff[v * g - N] -= phi[v];
kCoeff[g] += phi[v];
}
kCoeff[g] += phiSum[(N - 1) / g] - 1;
}
num ans = 0;
num pK = 1;
for (int i = 0; i <= N - 1; i++, pK *= K) {
ans += kCoeff[i] * pK;
}
ans /= pow(K, N);
cout << ans << '\n';
return 0;
}
| 5 |
#include<stdio.h>
#include<bits/stdc++.h>
using namespace std ;
int main()
{
int a , b , c , d ;
cin>>a>>b>>c>>d;
int x = c-a , y = d-b ;
cout<<c-y<<" "<<d+x<<" "<<a-y<<" "<<b+x;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXN = 40;
int n;
char s[MAXN + 1];
int slen;
long long dp[MAXN][MAXN][MAXN + 1];
long long sum[MAXN + 1];
bool can[MAXN][MAXN];
long long solve() {
for (int i = (0); i < (n); ++i) can[i][i] = true;
for (int i = (0); i < (n); ++i)
for (int j = (i + 1); j < (n); ++j) {
can[i][j] = true;
for (int k = (0); k < (slen); ++k)
if (i + k >= j && s[k] != s[i + k - j] ||
j + k >= i + n && s[k] != s[j + k - i - n])
can[i][j] = false;
can[j][i] = can[i][j];
}
memset(dp, 0, sizeof(dp));
for (int i = (0); i < (n); ++i) dp[i][i][1] = 1;
for (int fst = (0); fst < (n); ++fst)
for (int lst = (fst); lst < (n); ++lst)
for (int i = (1); i <= (lst - fst + 1); ++i)
if (dp[fst][lst][i] != 0) {
for (int nxt = (lst + 1); nxt < (n); ++nxt)
if (can[fst][nxt] && can[lst][nxt]) {
int nfree = max(0, nxt - lst - slen);
dp[fst][nxt][i + 1] += dp[fst][lst][i] << nfree;
}
}
memset(sum, 0, sizeof(sum));
for (int fst = (0); fst < (n); ++fst)
for (int lst = (fst); lst < (n); ++lst)
for (int i = (1); i <= (lst - fst + 1); ++i)
if (dp[fst][lst][i] != 0) {
int nfree = max(0, fst + n - lst - slen);
sum[i] += dp[fst][lst][i] << nfree;
}
sum[0] = 1LL << n;
long long none = 0;
for (int i = (0); i <= (n); ++i) {
long long cur = sum[i];
if (i % 2 == 0)
none += cur;
else
none -= cur;
}
return (1LL << n) - none;
}
void run() {
scanf("%d", &n);
scanf("%s", s);
slen = strlen(s);
printf("%lld\n", solve());
}
int main() {
run();
return 0;
}
| 6 |
#include <iostream>
using namespace std;
int main(){
int A,B,K;
cin>>A>>B>>K;
for(int i=0;i<K;i++){
if(i%2==0){
B+=A/2;
A/=2;
}else{
A+=B/2;
B/=2;
}
}
cout<<A<<" "<<B;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
namespace flow {
const int M = 10000, N = 200;
int second[M], nxt[M], gap[N], fst[N], c[N], pre[N], q[N], dis[N];
int f[M];
int S, T, tot, Tn;
void init(int s, int t, int tn) {
tot = 1;
assert(tn < N);
for (int(i) = (0); (i) < (tn); (i)++) fst[i] = 0;
S = s;
T = t;
Tn = tn;
}
void add(int u, int v, int c1, int c2 = 0) {
tot++;
second[tot] = v;
f[tot] = c1;
nxt[tot] = fst[u];
fst[u] = tot;
tot++;
second[tot] = u;
f[tot] = c2;
nxt[tot] = fst[v];
fst[v] = tot;
}
int sap() {
int u = S, t = 1;
int flow = 0;
for (int(i) = (0); (i) < (Tn); (i)++) c[i] = fst[i], dis[i] = Tn, gap[i] = 0;
q[0] = T;
dis[T] = 0;
pre[S] = 0;
for (int(i) = (0); (i) < (t); (i)++) {
int u = q[i];
for (int j = fst[u]; j; j = nxt[j])
if (dis[second[j]] > dis[u] + 1 && f[j ^ 1])
q[t++] = second[j], dis[second[j]] = dis[u] + 1;
}
for (int(i) = (0); (i) < (Tn); (i)++) gap[dis[i]]++;
while (dis[S] <= Tn) {
while (c[u] && (!f[c[u]] || dis[second[c[u]]] + 1 != dis[u]))
c[u] = nxt[c[u]];
if (c[u]) {
pre[second[c[u]]] = c[u] ^ 1;
u = second[c[u]];
if (u == T) {
int minf = 1e9;
for (int p = pre[T]; p; p = pre[second[p]]) minf = min(minf, f[p ^ 1]);
for (int p = pre[T]; p; p = pre[second[p]])
f[p ^ 1] -= minf, f[p] += minf;
flow += minf;
u = S;
}
} else {
if (!(--gap[dis[u]])) break;
int mind = Tn;
c[u] = fst[u];
for (int j = fst[u]; j; j = nxt[j])
if (f[j] && dis[second[j]] < mind) mind = dis[second[j]], c[u] = j;
dis[u] = mind + 1;
gap[dis[u]]++;
if (u != S) u = second[pre[u]];
}
}
return flow;
}
}; // namespace flow
int n, k, ma, pi[303030], ci[303030], li[303030];
char nprimo[303030];
vector<int> p, c;
int main() {
for (int i = 2; i < 303030; i++)
if (!nprimo[i])
for (long long j = (long long)i * i; j < 303030; j += i) nprimo[j] = 1;
scanf("%d%d", &n, &k);
for (int(i) = (0); (i) < (n); (i)++) scanf("%d%d%d", pi + i, ci + i, li + i);
int l = 1, r = n, m, ans = -1;
while (l <= r) {
p.clear();
c.clear();
ma = 0;
m = (l + r) >> 1;
for (int(i) = (0); (i) < (n); (i)++)
if (li[i] <= m) {
if (ci[i] > 1)
p.push_back(pi[i]), c.push_back(ci[i]);
else
ma = max(ma, pi[i]);
}
if (ma) p.push_back(ma), c.push_back(1);
int s = ((int)(p).size()) + 1, t = ((int)(p).size()) + 2, sum = 0;
flow::init(s, t, t + 1);
for (int(i) = (0); (i) < (((int)(p).size())); (i)++)
if (c[i] & 1)
flow::add(s, i + 1, p[i]), sum += p[i];
else
flow::add(i + 1, t, p[i]), sum += p[i];
for (int(i) = (0); (i) < (((int)(p).size())); (i)++)
for (int(j) = (0); (j) < (i); (j)++)
if (!nprimo[c[i] + c[j]]) {
if (c[i] & 1)
flow::add(i + 1, j + 1, 1e7 + 10);
else
flow::add(j + 1, i + 1, 1e7 + 10);
}
if (sum - flow::sap() >= k)
ans = m, r = m - 1;
else
l = m + 1;
}
printf("%d\n", ans);
}
| 6 |
#include<iostream>
#include<cstdio>
#define M 100000
using namespace std;
int main(){
int n;
int m;
int l;
int pos = 0;
int ans = 0;
int x[100000];
scanf("%d %d",&n,&m);
x[0] = 0;
for (int i = 1; i < n; i++){
scanf("%d", &x[i]);
x[i] += x[i - 1];
}
while (m--){
scanf("%d", &l);
if(l > 0){
ans += x[pos + l] - x[pos];
}
else{
ans -= x[pos + l] - x[pos];
}
pos += l;
ans %= M;
}
printf("%d\n", ans);
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main(){
string s;
while(cin>>s,s[0]!='#'){
int sl=s.length();
int ans=0;
vector<int>memo(30,-1);
queue<string>s1,s2;
for(int i=0;i<(1<<sl);++i){
string a=s;
for(int j=0;j<sl;++j){
if(i & (1<<(sl-j-1))){
a[j]++;
if(memo[s[j]-'a'+1]!=i && s[j]!='z'){
memo[s[j]-'a'+1]=i;
}else{
goto BREAK1;
}
}else{
if(memo[s[j]-'a']!=i && s[j]!='a'){
goto BREAK2;
}else{
memo[s[j]-'a']=i;
}
}
}
++ans;
if(ans<=10)s1.push(a);
s2.push(a);
if(s2.size()>5)s2.pop();
BREAK1:
BREAK2:
1;
}
cout<<ans<<endl;
if(ans<=10){
for(int i=0;i<ans;++i){
cout<<s1.front()<<endl;
s1.pop();
}
}
else{
for(int i=0;i<5;++i){
cout<<s1.front()<<endl;
s1.pop();
}
for(int i=0;i<5;++i){
cout<<s2.front()<<endl;
s2.pop();
}
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
int n, k;
cin >> n >> k;
set<int> st;
for (int i = 0; i < n; ++i) {
int x;
cin >> x;
st.insert(x);
}
int Min = *st.begin();
if (Min - 1 <= k) return cout << Min << "\n", 0;
int m3lsh = 5;
while (m3lsh--)
for (auto i : st)
while (i % Min > k) --Min;
cout << Min << endl;
return 0;
}
| 5 |
#include <iostream>
#include <algorithm>
#include <vector>
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(){
int e;
while(cin>>e and e>0){
int ans=10000000;
for(int i=0;i*i*i<=e;i++){
for(int j=0;j*j<=e-i*i*i;j++){
int m=i+j+e-(i*i*i+j*j);
if(ans>m) ans=m;
}
}
cout<<ans<<endl;
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
T power(T a, T b) {
T x;
if (b == 0)
x = 1;
else
x = a;
for (size_t i = 1; i < b; i++) x *= a;
return x;
}
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
long long int n, m, a, b, c, ab, ba, x, y, z, avg, sum;
int arr3[1000001], arr4[200001], arr5[100001];
bool f, f1, f2;
string str, s1, s2, s3, s4;
set<int> seto;
double d, d1;
long long int x1, x2, y11, y2;
int mini = 1 << 30, maxi = 0;
vector<int> v;
stack<int> s;
int main() {
cin >> str;
arr3[0] = -1;
for (int i = 0; i < str.size(); i++) {
if (str[i] == '(') {
s.push(i);
arr3[s.size()] = i;
} else if (!s.empty()) {
s.pop();
x = i - arr3[(int)s.size()];
if (x > maxi) {
maxi = x;
sum = 1;
} else if (x == maxi)
sum++;
} else {
arr3[0] = i;
}
}
cout << maxi << ' ' << max((long long int)1, sum);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n;
cin >> n;
long long int a[n + 1];
set<long long int> s;
for (long long int i = (long long int)1; i <= (long long int)n; i++) {
cin >> a[i];
s.insert(a[i]);
}
vector<long long int> temp;
temp.push_back(-1);
map<long long int, long long int> mp;
long long int j = 0;
for (auto i : s) {
mp[i] = ++j;
temp.push_back(i);
}
vector<long long int> v[j + 1];
for (long long int i = (long long int)1; i <= (long long int)j; i++)
v[i].push_back(-1), v[i].push_back(-1);
s.clear();
s.insert(mp[a[1]]);
for (long long int i = (long long int)2; i <= (long long int)n; i++) {
auto it = s.lower_bound(mp[a[i]]);
if (it == s.end()) {
it--;
v[*it][1] = mp[a[i]];
cout << temp[*it] << " ";
} else if (it == s.begin()) {
v[*it][0] = mp[a[i]];
cout << temp[*it] << " ";
} else {
if (v[*it][0] == -1) {
v[*it][0] = mp[a[i]];
cout << temp[*it] << " ";
} else {
*it--;
v[*it][1] = mp[a[i]];
cout << temp[*it] << " ";
}
}
s.insert(mp[a[i]]);
}
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
long long n;
cin >> n;
unordered_map<long long, long long> mp;
unordered_map<long long, vector<long long>> graph;
unordered_map<long long, long long> indegree;
vector<long long> v(n);
for (long long i = 0; i < n; i++) {
long long x;
cin >> x;
mp[x]++;
v[i] = x;
indegree[x] = 0;
}
for (long long i = 0; i < n; i++) {
if (v[i] & 1) {
long long from = 3 * v[i];
if (mp.count(from)) {
indegree[v[i]]++;
graph[from].push_back(v[i]);
}
} else {
if (mp.count(3 * v[i])) {
indegree[v[i]]++;
graph[3 * v[i]].push_back(v[i]);
} else {
if (mp.count(v[i] / 2)) {
indegree[v[i]]++;
graph[v[i] / 2].push_back(v[i]);
}
}
}
}
long long first = -1;
for (auto ele : indegree) {
if (ele.second == 0) {
first = ele.first;
break;
}
}
cout << first << " ";
while (!graph[first].empty()) {
cout << graph[first][0] << " ";
first = graph[first][0];
}
}
| 4 |
#include<bits/stdc++.h>
using namespace std;
int n,k;
int main()
{
scanf("%d%d",&k,&n);
for(int i=n-k+1;i<=n+k-1;i++) printf("%d ",i);
} | 0 |
#include <iostream>
using namespace std;
int main() {
int n,t[100],s=0,p,x;
cin >> n;
for(int i =0;i<n;i++){
cin >> t[i];
s += t[i];
}
cin >> n;
for(int i=0;i<n;i++){
cin >> p >> x;
cout << s - t[p-1] + x << endl;
}
} | 0 |
#include <bits/stdc++.h>
const long long INF = (1LL << 60) - 1;
using namespace std;
long long power(long long x, long long y) {
long long res = 1;
x = x % 1000000007;
while (y > 0) {
if (y & 1) res = (res * x) % 1000000007;
y = y >> 1;
x = (x * x) % 1000000007;
}
return res;
}
long long BINARY_SEARCH(long long dp[], long long n, long long key) {
long long s = 1;
long long e = n;
while (s <= e) {
long long mid = (s + e) / 2;
if (dp[mid] == key)
return mid;
else if (dp[mid] > key)
e = mid - 1;
else
s = mid + 1;
}
return -1;
}
string CONVERT_TO_BINARY(long long s) {
string res = "";
while (s != 0) {
res += (char)('0' + s % 2);
s /= 2;
}
reverse(res.begin(), res.end());
return res;
}
bool PALIN(string s) {
long long i = 0;
long long j = s.length() - 1;
while (i <= j) {
if (s[i] != s[j]) return false;
j--, i++;
}
return true;
}
long long STOI(string s) {
long long num = 0;
long long po = 1;
for (long long i = s.length() - 1; i >= 0; i--) {
num += po * (s[i] - '0');
po *= 10;
}
return num;
}
long long modInverse(long long a, long long m) { return power(a, m - 2); }
int findLongestSub(string bin) {
int n = bin.length(), i;
int sum = 0;
unordered_map<int, int> prevSum;
int maxlen = 0;
int currlen;
for (i = 0; i < n; i++) {
if (bin[i] == '1')
sum++;
else
sum--;
if (sum > 0) {
maxlen = i + 1;
} else if (sum <= 0) {
if (prevSum.find(sum - 1) != prevSum.end()) {
currlen = i - prevSum[sum - 1];
maxlen = max(maxlen, currlen);
}
}
if (prevSum.find(sum) == prevSum.end()) prevSum[sum] = i;
}
return maxlen;
}
vector<long long> prefix_KMP(string &s) {
vector<long long> pi;
pi[0] = 0;
for (long long i = 1; i <= s.length() - 1; i++) {
long long j = pi[i - 1];
while (j > 0 && s[i] != s[j]) {
j = pi[j - 1];
}
if (s[i] == s[j]) {
j++;
}
pi[i] = j;
}
return pi;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
long long cnt = 0;
while (n > 0) {
if (n % k != 0) {
cnt += n % k;
long long x = n % k;
n -= x;
} else {
n /= k;
cnt++;
}
}
cout << cnt << endl;
}
}
| 1 |
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
using namespace std;
template <typename T>
T gcd(T a, T b) {
T m;
while (b != T(0)) {
m = a % b;
a = b;
b = m;
}
return a;
}
template <typename T>
T lcm(T a, T b) {
return a == 0 && b == 0 ? 0 : (a / gcd(a, b)) * b;
}
int solve() {
int n;
cin >> n;
if (n == 2) {
printf("3\n");
printf("2 1 2\n");
return 0;
}
if (n == 3) {
printf("4\n");
printf("2 1 3 2\n");
return 0;
}
std::vector<int> ans;
if (n & 1) {
for (int i = 2; i < n; i += 2) ans.push_back(i);
ans.push_back(n);
for (int i = 1; i < n; i += 2) ans.push_back(i);
for (int i = 2; i < n; i += 2) ans.push_back(i);
} else {
for (int i = 2; i < n; i += 2) ans.push_back(i);
ans.push_back(n - 1);
ans.push_back(n);
for (int i = 1; i < n; i += 2) ans.push_back(i);
for (int i = 2; i < n; i += 2) ans.push_back(i);
}
printf("%d\n", (int)ans.size());
for (int i : ans) printf("%d ", i);
return 0;
}
int main(int argc, char* argv[]) {
::std::ios::sync_with_stdio(false);
::std::cin.tie(0);
::std::cout.tie(0);
solve();
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int M = 100;
int color[50][50];
int n, r1, c1, r2, c2;
int otv = 0;
void bfs(int p, int q, int c) {
color[p][q] = c;
for (int dp = -1; dp < 2; dp++)
for (int dq = -1; dq < 2; ++dq)
if (dp * dp + dq * dq == 1 && p + dp >= 0 && p + dp < n && q + dq >= 0 &&
q + dq < n)
if (color[p + dp][q + dq] != c && color[p + dp][q + dq] != 1) {
if (color[p + dp][q + dq] == 0)
bfs(p + dp, q + dq, c);
else
otv = -1;
}
}
int main() {
cin >> n >> r1 >> c1 >> r2 >> c2;
if (n == 1) {
cout << 0;
return 0;
}
char h;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j) {
cin >> h;
color[i][j] = h - '0';
}
color[r2 - 1][c2 - 1] = 3;
bfs(r1 - 1, c1 - 1, 2);
if (!otv)
bfs(r2 - 1, c2 - 1, 3);
else {
cout << 0;
return 0;
}
otv = 1e9;
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
for (int x = 0; x < n; ++x)
for (int y = 0; y < n; ++y)
if (color[i][j] == 2 && color[x][y] == 3 &&
otv > (x - i) * (x - i) + (y - j) * (y - j))
otv = (x - i) * (x - i) + (y - j) * (y - j);
cout << otv;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int oddness = 0;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
for (int j = 0; j < m; j++) {
cout << "#";
}
} else {
++oddness;
for (int j = 0; j < m; j++) {
if (oddness % 2 == 1 && j == m - 1) {
cout << "#";
} else if (oddness % 2 == 0 && j == 0) {
cout << "#";
} else {
cout << '.';
}
}
}
cout << "\n";
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 62;
const int mods = 1e9 + 7;
const int MAXN = 1000005;
const int INF = 0x3f3f3f3f;
inline int read() {
int f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
pair<int, int> b[MAXN];
map<int, int> Map;
int n, m, a[MAXN], f[MAXN], Ans[MAXN], mxx[MAXN], mxy[MAXN];
int get(int x, int y) { return x * m + y; }
int find(int x) { return f[x] == x ? f[x] : f[x] = find(f[x]); }
void unions(int x, int y) { f[find(x)] = find(y); }
void update(int r) {
for (int l = r; l >= 0 && b[l].first == b[r].first; l--)
Ans[b[l].second] = mxx[b[l].second / m] = mxy[b[l].second % m] =
Ans[find(b[l].second)];
}
signed main() {
n = read(), m = read();
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) a[get(i, j)] = read(), f[get(i, j)] = get(i, j);
for (int i = 0; i < n; i++) {
Map.clear();
for (int j = 0; j < m; j++) {
if (Map.find(a[get(i, j)]) != Map.end())
unions(Map[a[get(i, j)]], get(i, j));
Map[a[get(i, j)]] = get(i, j);
}
}
for (int i = 0; i < m; i++) {
Map.clear();
for (int j = 0; j < n; j++) {
if (Map.find(a[get(j, i)]) != Map.end())
unions(Map[a[get(j, i)]], get(j, i));
Map[a[get(j, i)]] = get(j, i);
}
}
for (int i = 0; i < n * m; i++) b[i] = make_pair(a[i], i);
sort(b, b + n * m);
for (int i = 0; i < n * m; i++) {
if (i && b[i].first != b[i - 1].first) update(i - 1);
int t = max(mxx[b[i].second / m], mxy[b[i].second % m]) + 1;
upmax(Ans[find(b[i].second)], t);
}
update(n * m - 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) printf("%d ", Ans[get(i, j)]);
puts("");
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n = 0, ct = 0, x = 0, ct2 = 0;
cin >> n;
long long int arr[n + 1];
for (int a = 0; a < n; a++) cin >> arr[a];
bool ok = false;
arr[n] = -1000000000000000000;
for (int a = 0; a < n; a++)
if (arr[a] == arr[a + 1])
ct++;
else {
ct++;
ct2 += (ct * (ct + 1)) / 2;
ct = 0;
}
cout << ct2;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000 + 5;
vector<vector<int> > Maze;
int n;
int Getp(int v, int p) {
int ans = 0;
while (v && v % p == 0) {
v /= p;
ans++;
}
return ans;
}
int dp[N][N];
void update(int i, int j, int c) {
if (dp[i][j] == -1)
dp[i][j] = c;
else
dp[i][j] = min(dp[i][j], c);
}
string res;
int ans;
int p[N][N];
void go(int x, int y) {
if (x && dp[x][y] == dp[x - 1][y] + p[x][y]) {
go(x - 1, y);
res += 'D';
} else if (y) {
go(x, y - 1);
res += 'R';
}
}
void solve(int x) {
memset(dp, -1, sizeof(dp));
int i, j;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
p[i][j] = Getp(Maze[i][j], x);
if (i == 0 && j == 0)
dp[i][j] = p[i][j];
else {
if (i) update(i, j, p[i][j] + dp[i - 1][j]);
if (j) update(i, j, p[i][j] + dp[i][j - 1]);
}
}
}
if (ans > dp[n - 1][n - 1]) {
ans = dp[n - 1][n - 1];
res = "";
go(n - 1, n - 1);
}
}
int main() {
int i, j, x;
Maze.clear();
scanf("%d", &n);
bool Zero = false;
int Zerox, Zeroy;
for (i = 0; i < n; i++) {
vector<int> t;
for (j = 0; j < n; j++) {
scanf("%d", &x);
t.push_back(x);
if (x == 0) {
Zero = true;
Zerox = i;
Zeroy = j;
}
}
Maze.push_back(t);
}
ans = 100000000;
solve(2);
solve(5);
if (ans > 1 && Zero) {
ans = 1;
res = "";
for (i = 0; i < Zerox; i++) {
res += 'D';
}
for (i = 0; i < Zeroy; i++) {
res += 'R';
}
for (i = Zeroy; i < n - 1; i++) {
res += 'R';
}
for (i = Zerox; i < n - 1; i++) {
res += 'D';
}
}
cout << ans << endl << res << endl;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10 + 10, MAXM = 1 << 6;
int n;
int r[MAXN][MAXN], bits[MAXM];
bool checka(int v) {
int a[3], tn = 0;
for (int i = 0; i < (5); i++) {
if ((v >> i) & 1) {
a[tn++] = i;
}
}
int ans = 0;
for (int i = 0; i < (3); i++) {
for (int j = (i + 1); j <= (2); j++) {
if (r[a[i]][a[j]] == 1) ++ans;
}
}
return ans >= 3 ? true : false;
}
bool checkna(int v) {
int a[3], tn = 0;
for (int i = 0; i < (5); i++) {
if ((v >> i) & 1) {
a[tn++] = i;
}
}
for (int i = 0; i < (3); i++) {
for (int j = 0; j < (3); j++) {
if (i != j && r[a[i]][a[j]] == 1) return false;
}
}
return true;
}
bool solve() {
for (int i = 0; i < (1 << 5); i++) {
if (bits[i] != 3) continue;
if (checka(i) || checkna(i)) {
return true;
}
}
return false;
}
int main() {
memset(bits, 0, sizeof(bits));
for (int i = (1); i <= (MAXM - 1); i++) {
if (i & 1)
bits[i] = bits[i >> 1] + 1;
else
bits[i] = bits[i >> 1];
}
memset(r, 0, sizeof(r));
cin >> n;
for (int i = 0; i < (n); i++) {
int a, b;
cin >> a >> b;
a--, b--;
r[a][b] = r[b][a] = 1;
}
if (solve()) {
puts("WIN");
} else
puts("FAIL");
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void amin(T &x, const T &y) {
if (y < x) x = y;
}
template <class T>
inline void amax(T &x, const T &y) {
if (x < y) x = y;
}
using LL = long long;
using PII = pair<int, int>;
using VI = vector<int>;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
const int MAXN = 1e5 + 10;
int n, t, m;
VI g[MAXN];
int sum[MAXN];
int dfs(int rt, int f) {
sum[rt] = 0;
for (auto &v : g[rt]) {
if (v == f) continue;
sum[rt] += dfs(v, rt);
}
if (sum[rt] == 0) sum[rt] = 1;
return sum[rt];
}
void MAIN() {
cin >> n;
for (int i = (2); i < (n + 1); i++) {
int j;
cin >> j;
g[i].push_back(j);
g[j].push_back(i);
}
dfs(1, -1);
sort(sum + 1, sum + n + 1);
for (int k = (1); k < (n + 1); k++) {
cout << sum[k] << " ";
}
cout << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int TC = 1;
for (int tc = (0); tc < (TC); tc++) {
MAIN();
}
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
int n;
string s, p;
int main() {
cin >> n;
if (n <= 9) return cout << n << endl, 0;
for (int i = 10; i <= n; ++i) {
int x = i;
char ch;
s = "";
while (x > 0) {
ch = (x % 10) + '0';
s = ch + s;
x /= 10;
}
p += s;
}
cout << p[n - 10] << endl;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1LL << 60;
void imin(long long& l, long long r) { l = min(l, r); }
const long long N = 1024;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<long long> a(n + 1);
for (long long i = 0; i < n; i++) cin >> a[i];
a[n] = 0;
vector<vector<long long>> dp(n + 1, vector<long long>(N, inf));
dp[0][a.front()] = 1;
for (long long i = 0; i < n; i++) {
for (long long j = 1; j < N; j++) {
if (dp[i][j] != inf) {
stack<long long> s;
s.push(j);
long long k = i;
for (; k + 1 < n && j >= s.top() && s.top() >= a[k + 1]; k++) {
long long current = a[k + 1];
while (!s.empty() && s.top() == current) s.pop(), current++;
s.push(current);
}
if (s.top() == j + 1) {
imin(dp[k][j + 1], dp[i][j]);
}
imin(dp[i + 1][a[i + 1]], dp[i][j] + (i + 1 < n));
}
}
}
cout << *min_element(dp[n].begin(), dp[n].end()) << '\n';
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = std::tuple<int, int>;
const int dx[8] = {-1, 1, 0, 0, -1, -1, 1, 1},
dy[8] = {0, 0, -1, 1, -1, 1, -1, 1};
int N, C;
int A[500100];
int cnt[500100], cnt2[500100], nxt[500100];
int dp[500100];
int main() {
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
std::cin >> N >> C;
for (int i = 1; i <= N; ++i) {
std::cin >> A[i];
}
for (int i = 1; i <= N; ++i) {
cnt[i] = cnt[i - 1] + (A[i] == C);
}
for (int i = N; i >= 1; --i) {
cnt2[i] = cnt2[i + 1] + (A[i] == C);
}
memset(nxt, -1, sizeof(nxt));
for (int i = N; i >= 1; --i) {
int a = A[i];
if (nxt[a] == -1) {
dp[i] = 1 + cnt2[i + 1];
nxt[a] = i;
continue;
}
dp[i] = std::max(1 + cnt2[i + 1], 1 + dp[nxt[a]]);
nxt[a] = i;
}
int res = cnt[N];
for (int i = 1; i <= N; ++i) {
res = std::max(res, cnt[i - 1] + dp[i]);
}
std::cout << res << std::endl;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct str {
int a, b;
bool operator<(const str& A) const { return a - b > A.a - A.b; }
};
int main() {
int n, m;
long long sum = 0;
str arr[100002];
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%d %d", &arr[i].a, &arr[i].b);
sum += arr[i].a;
}
if (sum <= m) {
printf("0");
return 0;
}
sort(arr, arr + n);
int cnt = 0;
bool trig = false;
for (int i = 0; i < n; i++) {
sum -= (arr[i].a - arr[i].b);
cnt++;
if (sum <= m) {
trig = true;
break;
}
}
if (trig)
printf("%d", cnt);
else
printf("-1");
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int N;
vector<string> A[26];
bool cmp(const string& lhs, const string& rhs) { return lhs + rhs < rhs + lhs; }
bool wrap(const string& lhs, const string& rhs) {
bool r = cmp(lhs, rhs);
return r;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N;
for (int i = 0; i < (N); i++) {
string s;
cin >> s;
A[s[0] - 'a'].push_back(s);
}
for (int i = 0; i < (26); i++) {
sort((A[i]).begin(), (A[i]).end(), wrap);
for (auto&& s : A[i]) {
cout << s;
}
}
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
int a[6];
int main() {
for (int i = 0; i < 6; i++) {
scanf("%d", &a[i]);
}
int h = a[1] + a[2];
int ans = 0, w = a[0], nw;
for (int i = 0; i < h; i++) {
if ((i < a[1]) && (i < a[5]))
nw = w + 1;
else if ((i < a[1]) ^ (i < a[5]))
nw = w;
else
nw = w - 1;
ans += w + nw;
w = nw;
}
printf("%d\n", ans);
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x;
cin >> n;
int sum(0);
int miin2(-100000), miin(100000);
for (int i(0); i < n; i++) {
cin >> x;
if (x > 0) {
sum += x;
if (x % 2 != 0) {
miin = min(miin, x);
}
}
if (x < 0 && x % 2 != 0) {
miin2 = max(x, miin2);
}
}
if (sum % 2 == 0) {
cout << max(sum + miin2, sum - miin);
} else
cout << sum;
}
| 2 |
#include <iostream>
#include <vector>
#include <algorithm>
#include <functional>
#include <cstdio>
using namespace std;
int main()
{
int N, M;
scanf("%d%d", &N, &M);
vector<int> A(N+1), B(M+1);
const int MAX_N = N*M;
constexpr long long int MOD = 1000000007;
for(int i = 0; i < N; ++i) scanf("%d", &A[i]);
for(int j = 0; j < M; ++j) scanf("%d", &B[j]);
sort(begin(A), end(A), greater<int>());
sort(begin(B), end(B), greater<int>());
long long int ba = 0, bb = 0;
long long int ans = 1;
for(long long int i = MAX_N; i > 0; --i){
if(A[ba] > i){
ans = 0;
break;
}
if(B[bb] > i){
ans = 0;
break;
}
if(A[ba] == i && B[bb] == i){
++ba, ++bb;
}else if(A[ba] == i && B[bb] != i){
++ba;
ans = (ans*bb) % MOD;
}else if(A[ba] != i && B[bb] == i){
++bb;
ans = (ans*ba) % MOD;
}else{
ans = (ans*(ba*bb-MAX_N+i)) % MOD;
}
if(ans <= 0){
ans = 0;
break;
}
}
cout << ans << endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 200005;
int c[MAXN], id[MAXN];
bool flag[MAXN][2];
int a[4][MAXN], an[4];
long long ans, cur, s0cnt;
multiset<int> s0, s1;
bool comp(int a, int b) { return c[a] < c[b]; }
int main() {
int n, m, k, minx;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; ++i) scanf("%d", &c[i]), id[i] = i;
for (int i = 0, nn, x; i < 2; ++i) {
scanf("%d", &nn);
while (nn--) scanf("%d", &x), flag[x][i] = true;
}
sort(id + 1, id + n + 1, comp);
for (int i = 1; i <= n; ++i)
if (!flag[id[i]][0] && !flag[id[i]][1])
a[0][++an[0]] = c[id[i]];
else if (flag[id[i]][0] && !flag[id[i]][1])
a[1][++an[1]] = c[id[i]];
else if (!flag[id[i]][0] && flag[id[i]][1])
a[2][++an[2]] = c[id[i]];
else
a[3][++an[3]] = c[id[i]];
ans = LLONG_MAX;
minx = max(max(2 * k - m, 0), max(k - an[1], k - an[2]));
if (minx <= m && minx <= an[3]) {
for (int i = 1; i <= minx; ++i) cur += a[3][i];
for (int i = minx + 1; i <= an[3]; ++i) s1.insert(a[3][i]);
for (int j = 1; j <= 2; ++j) {
for (int i = 1; i <= k - minx; ++i) cur += a[j][i];
for (int i = k - minx + 1; i <= an[j]; ++i) s1.insert(a[j][i]);
}
for (int i = 1; i <= an[0]; ++i) s1.insert(a[0][i]);
for (int i = 0; i < m - 2 * k + minx; ++i)
s0cnt += *s1.begin(), s0.insert(*s1.begin()), s1.erase(s1.begin());
ans = min(ans, cur + s0cnt);
for (int i = minx + 1; i <= min(m, an[3]); ++i) {
multiset<int>::iterator iter;
if ((iter = s1.find(a[3][i])) != s1.end())
s1.erase(iter);
else
s0.erase(s0.find(a[3][i])), s0cnt -= a[3][i];
for (int j = 1; j <= 2; ++j)
if (s0.size() == 0 || a[j][k - i + 1] >= *s0.rbegin())
s1.insert(a[j][k - i + 1]);
else
s0.insert(a[j][k - i + 1]), s0cnt += a[j][k - i + 1];
while (s0.size() < m + i - 2 * k && s1.size() > 0)
s0cnt += *s1.begin(), s0.insert(*s1.begin()), s1.erase(s1.begin());
while (s0.size() > m + i - 2 * k)
s0cnt -= *s0.rbegin(), s1.insert(*s0.rbegin()),
s0.erase(s0.find(*s0.rbegin()));
cur += a[3][i];
cur -= a[1][k - i + 1];
cur -= a[2][k - i + 1];
ans = min(ans, cur + s0cnt);
}
}
if (ans == LLONG_MAX) ans = -1;
printf("%I64d\n", ans);
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
long long t;
cin >> t;
while (t--) {
long long n, k;
cin >> n >> k;
vector<long long> a(n);
for (long long i = 0; i < n; i++) cin >> a[i];
long long m = 1e9;
for (auto e : a) {
m = min(m, e);
}
long long ans = 0;
for (auto e : a) {
long long rem = max(0LL, k - e);
ans += rem / m;
}
ans -= max(0LL, k - m) / m;
cout << ans << endl;
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
ll solve(const vector<int> &a, int l, int r, int waterline) {
int next_waterline = *min_element(begin(a) + l, begin(a) + r);
ll res2 = (ll)next_waterline - waterline;
if (res2 > (ll)r - l) {
return r - l;
}
int start = -1;
int island_min_height = 0;
for (int i = l; i < r; ++i) {
if (a[i] == next_waterline && start != -1) {
res2 += solve(a, start, i, next_waterline);
start = -1;
} else if (a[i] > next_waterline) {
if (start == -1) {
start = i;
island_min_height = a[i];
} else {
island_min_height = min(island_min_height, a[i]);
}
}
}
if (start != -1) {
res2 += solve(a, start, r, next_waterline);
}
return min((ll)r - l, res2);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
vector<int> a(n);
for (auto &e : a) {
cin >> e;
}
a.emplace_back(0);
auto heights = a;
sort(begin(heights), end(heights));
heights.erase(unique(begin(heights), end(heights)), end(heights));
cout << solve(a, 0, n + 1, 0) << endl;
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
long long int bef[55][55][4][2];
string mp[55];
long long int n, k;
long long int dx[] = {0, 1, 0, -1};
long long int dy[] = {1, 0, -1, 0};
int run(long long int turn, long long int x, long long int y, long long int dp,
long long int cp) {
if (turn == k) {
cout << mp[x][y] << endl;
return 0;
}
if (0 < bef[x][y][dp][cp]) {
long long int cycle = turn - bef[x][y][dp][cp];
long long int t = (k - turn) / cycle * cycle;
if (t != 0) return run(turn + t, x, y, dp, cp);
}
bef[x][y][dp][cp] = turn;
while (true) {
long long int xx = x + dx[dp];
long long int yy = y + dy[dp];
if (xx < 0 || n <= xx || yy < 0 || ((long long int)(mp[0]).size()) <= yy)
break;
if (mp[x][y] != mp[xx][yy]) break;
x = xx;
y = yy;
}
while (true) {
long long int xx = x + dx[(dp + ((cp) ? 1 : -1) + 4) % 4];
long long int yy = y + dy[(dp + ((cp) ? 1 : -1) + 4) % 4];
if (xx < 0 || n <= xx || yy < 0 || ((long long int)(mp[0]).size()) <= yy)
break;
if (mp[x][y] != mp[xx][yy]) break;
x = xx;
y = yy;
}
long long int xx = x + dx[dp];
long long int yy = y + dy[dp];
if (xx < 0 || n <= xx || yy < 0 || ((long long int)(mp[0]).size()) <= yy ||
mp[xx][yy] == '0') {
if (cp == 1)
return run(turn + 1, x, y, (dp + 1) % 4, 0);
else
return run(turn + 1, x, y, dp, 1);
} else {
return run(turn + 1, xx, yy, dp, cp);
}
}
int main() {
memset(bef, -1, sizeof(bef));
cin >> n >> k;
for (long long int i = 0; i < ((long long int)(n)); ++i) cin >> mp[i];
run(0, 0, 0, 0, 0);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using tpl = tuple<int, int, int>;
using pcc = pair<char, char>;
const int inf = 9999999;
const ll mod = 1e9 + 7;
int dr[] = {-1, 0, 1, 0};
int dc[] = {0, 1, 0, -1};
int kr[] = {-1, 1, -2, -2, -1, 1, 2, 2};
int kc[] = {-2, -2, -1, 1, 2, 2, -1, 1};
int dgr[] = {-1, -1, 1, 1};
int dgc[] = {1, -1, -1, 1};
const int lim = 3e5 + 5;
int ans[lim];
int nxt[lim];
int getNext(int x) {
if (nxt[x] == x) return x;
return nxt[x] = getNext(nxt[x]);
}
int main() {
int n, m, l, r, x;
cin >> n >> m;
for (int i = 1; i <= n; i++) nxt[i] = i;
for (int i = 0; i < m; i++) {
cin >> l >> r >> x;
int cur = getNext(l);
while (cur <= r) {
if (cur == x)
cur = cur + 1;
else {
ans[cur] = x;
nxt[cur] = cur + 1;
}
cur = getNext(cur);
if (!cur) break;
}
}
for (int i = 1; i <= n; i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
string s;
long long n, k, m, p, TC;
long long h;
long long base = 1;
long long solve(int level, long long curr_val, long long b, long long e,
bool from_left) {
if (level == h) {
return curr_val - 1;
}
if (n <= (b + e) / 2) {
long long new_curr;
if (from_left) {
new_curr = curr_val + (base << (h - level));
} else {
new_curr = curr_val + 1;
}
return solve(level + 1, new_curr, b, (b + e) / 2, true);
} else {
long long new_curr;
if (from_left) {
new_curr = curr_val + 1;
} else {
new_curr = curr_val + (base << (h - level));
}
return solve(level + 1, new_curr, (b + e) / 2 + 1, e, false);
}
}
int main() {
cin >> h >> n;
cout << solve(0, 1, 1, base << h, false) << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return (a == 0) ? b : gcd(b % a, a); }
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m, l, r, mn = 1e10;
cin >> n >> m;
for (long long i = 0; i < m; ++i) {
cin >> l >> r;
mn = min(mn, r - l + 1);
}
cout << mn << '\n';
for (long long i = 0; i < n; ++i) cout << i % mn << " ";
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
const int MAXM = 1000005;
const int MOD = 1000000007;
const int MAMOD = 998244353;
const int INF = 0x3f3f3f3f;
const long long LLINF = 0x3f3f3f3f3f3f3f3f;
const double PI = acos(-1.0);
const double EPS = 1e-8;
int n;
string s;
int d[MAXN];
bool vis[MAXN];
int main() {
ios::sync_with_stdio(0);
cin >> n >> s;
for (int i = 0; i < n; ++i) cin >> d[i];
int st = 0, ok = 1;
while (st >= 0 && st < n) {
if (vis[st]) {
ok = 0;
break;
}
vis[st] = 1;
if (s[st] == '<')
st -= d[st];
else
st += d[st];
}
if (ok)
cout << "FINITE"
<< "\n";
else
cout << "INFINITE"
<< "\n";
return 0;
}
| 2 |
#include "stdio.h"
int day;
int num;
int temp[201];
int wear[200];
int dp[201][200] = {};
int min[201] = {};
int max[201] = {};
int ans=0;
int abs(int a) {
if (a > 0)return a;
return -a;
}
int Max(int a, int b) {
if (a > b)return a;
return b;
}
int main() {
scanf("%d %d", &day, &num);
for (int i = 0; i < day; i++) {
scanf("%d", &temp[i + 1]);
}
for (int i = 0; i < num; i++) {
scanf("%d %d %d", &min[i], &max[i], &wear[i]);
}
for (int i = 2; i <= day; i++) {
for (int j = 0; j < num; j++) {
if (temp[i] >= min[j] && temp[i] <= max[j]) {
for (int k = 0; k < num; k++) {
if (temp[i-1] >= min[k] && temp[i-1] <= max[k]) {
dp[i][j] = Max(dp[i][j], dp[i - 1][k] + abs(wear[k] - wear[j]));
}
}
}
}
}
for (int i = 0; i < num; i++)ans = Max(ans, dp[day][i]);
printf("%d\n", ans);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 10;
int f[N], n, pos[N], num[N], in[N];
vector<pair<int, int>> edge[N];
int visited[N];
queue<pair<int, int>> q;
bool dfs(int u, int k, int fa) {
num[u] = 1;
for (auto e : edge[u]) {
int v = e.first, Edge = e.second;
if (!visited[Edge] && v != fa) {
in[v] = Edge;
if (dfs(v, k, u)) return true;
num[u] += num[v];
}
}
//cout << u << ' ' << fa << ' ' << k << ' ' << num[u] << '\n';
if (num[u] == f[k - 1]) {
visited[in[u]] = 1;
q.push({u, k - 1}); q.push({fa, k - 2});
return true;
} else if (num[u] == f[k - 2]) {
visited[in[u]] = 1;
q.push({fa, k - 1}); q.push({u, k - 2});
return true;
}
return false;
}
bool judge(int k) {
q.push({1, k});
while (!q.empty()) {
int u = q.front().first, k = q.front().second; q.pop();
if (k >= 2 && !dfs(u, k, 0)) return false;
}
return true;
}
void init() {
f[0] = f[1] = 1;
pos[1] = 1;
for (int i = 2; i <= 30; i++) {
f[i] = f[i - 1] + f[i - 2];
//cout << f[i] << '\n';
if (f[i] <= 2e5) pos[f[i]] = i;
}
}
int main() {
//freopen("in.txt", "r", stdin);
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
init();
for (int i = 1; i <= n - 1; i++) {
int u, v;
cin >> u >> v;
edge[u].push_back({v, i});
edge[v].push_back({u, i});
}
if (pos[n] && judge(pos[n])) cout << "YES\n";
else cout << "NO\n";
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-10;
const long long mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const int maxn = 2e5 + 5;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, m, cnt, cnt2, an, ap;
unordered_map<int, int> ma;
int pos[maxn * 4], ans[maxn], tt[maxn * 2];
struct bus {
int s, f, t, id;
bool operator<(const bus& b) const { return f > b.f; }
} sp[maxn];
struct people {
int l, r, b, id;
bool operator<(const people& p) const { return r > p.r; }
} pp[maxn];
struct node {
int l, r, v;
};
struct SegTree {
node t[maxn << 2];
void build(int o, int l, int r) {
t[o].l = l;
t[o].r = r;
t[o].v = INF;
if (l == r) return;
int m = (l + r) >> 1;
build(o << 1, l, m);
build(o << 1 | 1, m + 1, r);
}
void pushup(int o) { t[o].v = min(t[o << 1].v, t[o << 1 | 1].v); }
void upd(int o, int p, int v) {
if (t[o].l == t[o].r) {
t[o].v = min(t[o].v, v);
return;
}
int m = (t[o].l + t[o].r) >> 1;
if (p <= m)
upd(o << 1, p, v);
else
upd(o << 1 | 1, p, v);
pushup(o);
}
void qry(int o, int ql, int qr, int v) {
if (ql <= t[o].l && t[o].r <= qr) {
if (t[o].v <= v) {
if (t[o].l < an) {
ap = o;
an = min(an, t[o].l);
}
}
return;
}
int m = (t[o].l + t[o].r) >> 1;
if (ql <= m) qry(o << 1, ql, qr, v);
if (qr > m) qry(o << 1 | 1, ql, qr, v);
}
int qry2(int o, int v) {
if (t[o].l == t[o].r) {
return t[o].l;
}
int m = (t[o].l + t[o].r) >> 1;
int lson = t[o << 1].v, rson = t[o << 1 | 1].v;
if (lson <= v) {
return qry2(o << 1, v);
} else {
return qry2(o << 1 | 1, v);
}
}
} ST;
int main(void) {
scanf("%d%d", &n, &m);
cnt = cnt2 = 0;
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &sp[i].s, &sp[i].f, &sp[i].t);
sp[i].id = i;
pos[++cnt] = sp[i].s;
pos[++cnt] = sp[i].f;
tt[++cnt2] = sp[i].t;
ma[sp[i].t] = i;
}
for (int i = 1; i <= m; i++) {
scanf("%d%d%d", &pp[i].l, &pp[i].r, &pp[i].b);
pp[i].id = i;
pos[++cnt] = pp[i].l;
pos[++cnt] = pp[i].r;
tt[++cnt2] = pp[i].b;
}
sort(pos + 1, pos + cnt + 1);
int sz = unique(pos + 1, pos + cnt + 1) - pos - 1;
sort(tt + 1, tt + cnt2 + 1);
int sz2 = unique(tt + 1, tt + cnt2 + 1) - tt - 1;
for (int i = 1; i <= n; i++) {
sp[i].s = lower_bound(pos + 1, pos + sz + 1, sp[i].s) - pos;
sp[i].f = lower_bound(pos + 1, pos + sz + 1, sp[i].f) - pos;
sp[i].t = lower_bound(tt + 1, tt + sz2 + 1, sp[i].t) - tt;
}
for (int i = 1; i <= m; i++) {
pp[i].l = lower_bound(pos + 1, pos + sz + 1, pp[i].l) - pos;
pp[i].r = lower_bound(pos + 1, pos + sz + 1, pp[i].r) - pos;
pp[i].b = lower_bound(tt + 1, tt + sz2 + 1, pp[i].b) - tt;
}
sort(sp + 1, sp + n + 1);
sort(pp + 1, pp + m + 1);
ST.build(1, 1, sz2);
int tp = 1;
for (int i = 1; i <= m; i++) {
while (tp <= n && sp[tp].f >= pp[i].r) {
ST.upd(1, sp[tp].t, sp[tp].s);
++tp;
}
an = INF;
ST.qry(1, pp[i].b, sz2, pp[i].l);
if (an == INF)
ans[pp[i].id] = -1;
else {
int res = ST.qry2(ap, pp[i].l);
ans[pp[i].id] = ma[tt[res]];
}
}
for (int i = 1; i <= m; i++) printf("%d%c", ans[i], (i == m) ? '\n' : ' ');
return 0;
}
| 5 |
/*
* @Author: your name
* @Date: 2021-03-05 15:16:23
* @LastEditTime: 2021-03-06 22:33:30
* @LastEditors: Please set LastEditors
* @Description: In User Settings Edit
* @FilePath: \code_formal\cf\CF_700_3.cpp
*/
#include <iostream>
#include <algorithm>
#include <string.h>
#include <string>
#include <cmath>
#include <map>
#include <vector>
#include <cstdio>
#define pr printf
#define sc scanf
#define sf(n) scanf("%d", &n)
#define sff(n1, n2) scanf("%d %d", &n1, &n2)
#define sfff(n1, n2, n3) scanf("%d %d %d", &n1, &n2, &n3)
#define sl(n) scanf("%lld", &n)
#define sll(n1, n2) scanf("%lld %lld", &n1, &n2)
#define slll(n1, n2, n3) scanf("%lld %lld %lld", &n1, &n2, &n3)
#define for0(i, n) for (i = 0; i < n; i++)
#define for1n(i, n) for (i = 1; i <= n; i++)
#define foran(i, a, n) for (i = a; i <= n; i++)
#define forna(i, a, n) for (i = n; i >= a; i--)
#define pb push_back
#define fi first
#define se second
#define mem(ara, n) memset(ara, n, sizeof(ara))
#define memb(ara) memset(ara, false, sizeof(ara))
#define all(x) (x).begin(), (x).end()
#define sq(x) ((x) * (x))
#define sz(x) x.size()
const int N = 1e5 + 10;
const int mod = 998244353;
typedef long long int ll;
namespace fastIO
{
inline void input(ll &res)
{
char c = getchar();
res = 0;
int f = 1;
while (!isdigit(c))
{
f ^= c == '-';
c = getchar();
}
while (isdigit(c))
{
res = (res << 3) + (res << 1) + (c ^ 48);
c = getchar();
}
res = f ? res : -res;
}
inline ll qpow(ll a, ll b)
{
ll ans = 1, base = a;
while (b)
{
if (b & 1)
ans = (ans * base % mod + mod) % mod;
base = (base * base % mod + mod) % mod;
b >>= 1;
}
return ans;
}
} // namespace fastIO
using namespace fastIO;
using namespace std;
int n, k;
int main()
{
int _ = 1;
sf(_);
while (_--)
{
cin >> n >> k;
int ans = n - k;
int cnt = (k + 1) / 2, i, j;
ans += k - cnt;
cout << ans << endl;
for (j = cnt; j <= k - 1; ++j)
cout << j << " ";
for (j = k + 1; j < n + 1; ++j)
cout << j << " ";
cout << endl;
}
return 0;
}
/*
3
7
1 4 2 2 2 2 2
2
2 3
5
1 1 1 1 1
4
3
0
*/ | 1 |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vs = vector<string>;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0), cout.tie(0);
int N;
cin >> N;
vll val(N), mask(N);
ll tot = 0;
for (int i = 0; i < N; i++) {
cin >> val[i] >> mask[i];
tot += val[i];
}
ll res = 0;
for (int b = 0; b < 62; b++) {
ll cur = 0;
for (int i = 0; i < N; i++) {
if ((mask[i] & (1ll << b)) && (mask[i] < (1ll << (b + 1)))) cur += val[i];
}
if ((cur > 0 && tot > 0) || (cur < 0 && tot < 0)) {
res ^= 1ll << b;
for (int i = 0; i < N; i++) {
if (mask[i] & (1ll << b)) val[i] *= -1;
}
}
}
cout << res << endl;
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
sort(a.begin(), a.end());
int c = 0;
for (int i = 1; i < n; i++) {
c += ((k - a[i]) / a[0]);
}
cout << c << "\n";
}
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
const int N = 5005;
struct P {
long long x, y;
P(long long x = 0, long long y = 0) : x(x), y(y) {}
} p[N], S[N];
long long Dis(P a, P b) {
return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}
P operator+(P a, P b) { return P(a.x + b.x, a.y + b.y); }
P operator-(P a, P b) { return P(a.x - b.x, a.y - b.y); }
long long operator*(P a, P b) { return a.x * b.y - a.y * b.x; }
bool operator<(P a, P b) {
long long val = (a - p[1]) * (b - p[1]);
return val == 0 ? Dis(a, p[1]) < Dis(b, p[1]) : val > 0;
}
int n, tot, sss;
double area(P a, P b, P c) { return abs((b - a) * (c - a)) / 2.0; }
void graham() {
int t = 1;
for (int i = 2; i <= n; i++)
if (p[i].y < p[t].y || (p[i].y == p[t].y && p[i].x < p[t].x)) t = i;
swap(p[1], p[t]);
sort(p + 2, p + n + 1);
S[1] = p[1];
S[2] = p[2];
tot = 2;
for (int i = 3; i <= n; i++) {
while (tot > 1 && (p[i] - S[tot]) * (S[tot] - S[tot - 1]) >= 0) tot--;
S[++tot] = p[i];
}
}
void solve() {
double mx = 0;
int a = 0, b = 0, c = 0;
for (int i = 1; i < tot - 1; i++) {
for (int j = i + 1, k = j + 1; j < tot; j++) {
while (k < tot && area(S[i], S[j], S[k + 1]) > area(S[i], S[j], S[k]))
k++;
double now = area(S[i], S[j], S[k]);
if (now > mx) mx = now, a = i, b = j, c = k;
}
}
P x = S[b] + (S[c] - S[a]), y = S[c] + (S[a] - S[b]),
z = S[a] + (S[b] - S[c]);
cout << x.x << ' ' << x.y << endl;
cout << y.x << ' ' << y.y << endl;
cout << z.x << ' ' << z.y << endl;
}
int main() {
scanf("%d%d", &n, &sss);
for (int i = 1; i <= n; i++) scanf("%I64d%I64d", &p[i].x, &p[i].y);
graham();
solve();
return 0;
}
| 5 |
#include <bits/stdc++.h>
const int kN = 500000 + 5;
int n, k;
std::vector<std::pair<int, int>> edges[kN];
using LL = long long;
LL f[kN][2];
void dfs(int u, int fa, int wa) {
std::vector<LL> vec;
LL s = 0;
for (auto t : edges[u]) {
int v = t.first;
int w = t.second;
if (v != fa) {
dfs(v, u, w);
if (f[v][1] > f[v][0]) {
vec.emplace_back(f[v][1] - f[v][0]);
s += f[v][1];
} else {
s += f[v][0];
}
}
}
std::sort(vec.begin(), vec.end());
int c = vec.size();
f[u][0] = s;
for (int i = 0; i < std::max(c - k, 0); ++i) f[u][0] -= vec[i];
f[u][1] = s + wa;
for (int i = 0; i < std::max(c - k + 1, 0); ++i) f[u][1] -= vec[i];
}
int main() {
int q;
scanf("%d", &q);
while (q--) {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; ++i) edges[i].clear();
for (int i = 0; i < n - 1; ++i) {
int a, b, w;
scanf("%d%d%d", &a, &b, &w);
--a;
--b;
edges[a].emplace_back(b, w);
edges[b].emplace_back(a, w);
}
dfs(0, -1, 0);
printf("%lld\n", f[0][0]);
}
}
| 3 |
#include <iostream>
using namespace std;
int main()
{
int s, w;
cin >> s >> w;
cout << (w>=s?"unsafe":"safe") << endl;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
int n,a,sum;
int main()
{
cin>>n;
for (int i=1;i<=n;i++)
{
cin>>a;sum+=a-1;
}
cout<<sum<<endl;
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 510000;
const int M = 5100000;
const int mod = 1e9 + 7;
const int inf = (int)1e9;
const double eps = 1e-9;
const long long INF = 1e11;
int n, k, m;
int id1[N], intree[N];
int dep[N], f[N];
int sz[N], son[N], dfn[N], fat[N], arr[N], cnt;
vector<int> g[N];
pair<int, int> a[N], b[N];
long long aw[N], bw[N], ed[N], st[M];
int find1(int i) { return id1[i] == i ? i : id1[i] = find1(id1[i]); }
void dfs(int x, int fa) {
sz[x] = 1;
dep[x] = dep[fa] + 1;
f[x] = fa;
for (auto y : g[x]) {
if (y != fa) {
dfs(y, x);
sz[x] += sz[y];
if (sz[y] > sz[son[x]]) son[x] = y;
}
}
}
void dfs2(int x, int fa, int anc) {
dfn[x] = ++cnt;
arr[cnt] = x;
fat[x] = anc;
if (son[x]) dfs2(son[x], x, anc);
for (auto y : g[x]) {
if (y != fa && y != son[x]) {
dfs2(y, x, y);
}
}
}
void change(int k, int l, int r, int a, int b, long long w) {
if (a > b) return;
if (l == a && r == b) {
st[k] = min(st[k], w);
return;
}
int mid = (l + r) / 2;
if (b <= mid)
change(k << 1, l, mid, a, b, w);
else if (a > mid)
change(k << 1 | 1, mid + 1, r, a, b, w);
else
change(k << 1, l, mid, a, mid, w),
change(k << 1 | 1, mid + 1, r, mid + 1, b, w);
}
void pushdown(int k, int l, int r, int a, int b, long long now) {
st[k] = min(st[k], now);
if (l == r) {
if (ed[arr[l]] != -1) aw[ed[arr[l]]] = min(aw[ed[arr[l]]], st[k]);
return;
}
int mid = (l + r) / 2;
if (b <= mid)
pushdown(k << 1, l, mid, a, b, st[k]);
else if (a > mid)
pushdown(k << 1 | 1, mid + 1, r, a, b, st[k]);
else
pushdown(k << 1, l, mid, a, mid, st[k]),
pushdown(k << 1 | 1, mid + 1, r, mid + 1, b, st[k]);
}
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k >> m;
for (int i = 1; i <= n; i++) {
id1[i] = i;
ed[i] = -1;
}
for (int i = 1; i < M; i++) st[i] = INF;
int fu, fv;
for (int i = 1; i <= k; i++) {
cin >> a[i].first >> a[i].second;
if (a[i].first > a[i].second) swap(a[i].first, a[i].second);
fu = find1(a[i].first);
fv = find1(a[i].second);
id1[fu] = fv;
g[a[i].first].push_back(a[i].second);
g[a[i].second].push_back(a[i].first);
}
for (int i = 1; i <= m; i++) {
cin >> b[i].first >> b[i].second >> bw[i];
fu = find1(b[i].first);
fv = find1(b[i].second);
if (fu == fv) continue;
intree[i] = 1;
id1[fu] = fv;
g[b[i].first].push_back(b[i].second);
g[b[i].second].push_back(b[i].first);
}
dep[0] = 0;
dfs(1, 0);
dfs2(1, 0, 1);
for (int i = 1; i <= k; i++) {
aw[i] = INF;
if (dep[a[i].first] > dep[a[i].second])
ed[a[i].first] = i;
else
ed[a[i].second] = i;
}
int u, v;
for (int i = 1; i <= m; i++) {
if (intree[i]) continue;
u = b[i].first;
v = b[i].second;
while (fat[u] != fat[v]) {
if (dep[fat[u]] > dep[fat[v]])
change(1, 1, n, dfn[fat[u]], dfn[u], bw[i]), u = f[fat[u]];
else
change(1, 1, n, dfn[fat[v]], dfn[v], bw[i]), v = f[fat[v]];
}
change(1, 1, n, min(dfn[u], dfn[v]) + 1, max(dfn[u], dfn[v]), bw[i]);
}
pushdown(1, 1, n, 1, n, INF);
long long ans = 0;
bool can = false;
for (int i = 1; i <= k; i++) {
if (aw[i] == INF) can = true;
ans += aw[i];
}
if (can)
printf("-1\n");
else
printf("%lld\n", ans);
return 0;
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 5;
string s[MAXN];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
string ans = "";
for (int j = 0; j < (int)s[0].length(); j++) {
bool b = false, b2 = false;
char ch = '?';
for (int i = 0; i < n; i++) {
if (s[i][j] != '?') {
if (ch == '?') {
b2 = true;
ch = s[i][j];
} else if (s[i][j] != ch) {
b = true;
}
}
}
if (b)
ans += '?';
else if (b2)
ans += ch;
else
ans += 'x';
}
cout << ans << endl;
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0;i<n;i++)
typedef long long ll;
int n;
int q,x;
vector<int>v;
int main(){
cin>>n;
while(n--){
cin>>q;
if(q==2)v.pop_back();
if(q==0){
cin>>x;
v.push_back(x);
}
if(q==1){
cin>>x;
cout<<v[x]<<endl;
}
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005, md = 998244353;
int n, ans, sa, sb, sc;
struct node {
int a, b;
} nm[N];
int fac[N];
bool cmp1(node a, node b) {
if (a.a == b.a) return a.b < b.b;
return a.a < b.a;
}
bool cmp2(node a, node b) { return a.b < b.b; }
template <class I>
inline void get(I &a) {
char c = getchar();
a = 0;
for (; c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar()) a = a * 10 + c - '0';
}
int main() {
get(n);
for (int i = 1; i <= n; i++) {
get(nm[i].a);
get(nm[i].b);
}
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = (long long)fac[i - 1] * i % md;
sort(nm + 1, nm + 1 + n, cmp1);
sa = sb = sc = 1;
ans = fac[n];
int la = 1;
for (int i = 1; i <= n; i++)
if (i != 1 && nm[i].a != nm[i - 1].a) {
sa = (long long)sa * fac[i - la] % md;
la = i;
}
sa = (long long)sa * fac[n - la + 1] % md;
la = 1;
for (int i = 1; i <= n; i++)
if (!(nm[i].a >= nm[i - 1].a && nm[i].b >= nm[i - 1].b)) {
sb = 0;
break;
}
for (int i = 1; i <= n; i++)
if (i != 1 && (nm[i].a != nm[i - 1].a || nm[i].b != nm[i - 1].b)) {
sb = (long long)sb * fac[i - la] % md;
la = i;
}
sb = (long long)sb * fac[n - la + 1] % md;
sort(nm + 1, nm + 1 + n, cmp2);
la = 1;
for (int i = 1; i <= n; i++)
if (i != 1 && nm[i].b != nm[i - 1].b) {
sc = (long long)sc * fac[i - la] % md;
la = i;
}
sc = (long long)sc * fac[n - la + 1] % md;
ans = ((long long)ans - sa - sc + sb + 2 * md) % md;
printf("%d\n", ans);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
long long n,i,nr,x,aux;
int main()
{
cin>>n;
i=5;
if(n%2==0)
while(i<=n)
nr=nr+n/(i*2) , i=i*5;
cout<<nr;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int par[200005], n;
long long ans;
map<long long, long long> comp, use;
map<int, vector<pair<int, int> > > mm;
vector<pair<long long, pair<int, int> > > Q;
void intialize() {
for (int i = 1; i <= n; i++) par[i] = i;
}
int parent(int x) {
if (par[x] != x) {
par[x] = parent(par[x]);
}
return par[x];
}
void unions(int x, int y) {
int p = parent(x);
int q = parent(y);
par[p] = q;
}
void findans() {
for (auto it : mm) {
stack<pair<long long, pair<int, int> > > st;
for (int i = 0; i < (it).second.size(); i++) {
if (parent((it).second[i].first) != parent(it.second[i].second)) {
st.push(make_pair(it.first,
make_pair(it.second[i].first, it.second[i].second)));
}
}
comp[it.first] = st.size();
while (st.size()) {
pair<long long, pair<int, int> > p = st.top();
st.pop();
int x = p.second.first;
int y = p.second.second;
if (parent(x) != parent(y)) {
unions(x, y);
use[p.first]++;
}
}
}
}
int main() {
int m, x, y;
long long w;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> x >> y >> w;
mm[w].push_back(make_pair(x, y));
}
intialize();
findans();
for (auto it : comp) {
ans += (it.second - use[it.first]);
}
cout << ans;
return 0;
}
| 6 |
#include<algorithm>
#include<iostream>
#include<cmath>
using namespace std;
int main()
{
long m,h,w,s[3];
cin>>h>>w;
m=h*w;
for(int i=1;i<h;i++)
{
s[0]=i*w;
if(w%2&&(h-i)%2)
{
s[1]=min(w,h-i)*(max(w,h-i)-1)/2;
s[2]=min(w,h-i)*(max(w,h-i)+1)/2;
}
else
{
s[1]=s[2]=w*(h-i)/2;
}
sort(s,s+3);
m=min(m,s[2]-s[0]);
}
swap(h,w);
for(int i=1;i<h;i++)
{
s[0]=i*w;
if(w%2&&(h-i)%2)
{
s[1]=min(w,h-i)*(max(w,h-i)-1)/2;
s[2]=min(w,h-i)*(max(w,h-i)+1)/2;
}
else
{
s[1]=s[2]=w*(h-i)/2;
}
sort(s,s+3);
m=min(m,s[2]-s[0]);
}
cout<<m<<endl;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
struct team {
int h;
int a;
};
int main() {
int n;
int c = 0;
cin >> n;
team t[100];
for (int i = 0; i < n; i++) {
cin >> t[i].h;
cin >> t[i].a;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (t[i].a == t[j].h) {
c++;
}
}
}
cout << c;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
inline int rd() {
int r;
scanf("%d", &r);
return r;
}
pair<int, int> A[200050];
int cnt, n, m, rt, a, b, c, d, k;
void GP(int &a, int &b, pair<int, int> P) { a = P.first, b = P.second; }
struct Node {
int l, r, siz, key, F, G;
} tr[200050];
int up(int t) {
tr[t].siz = tr[tr[t].l].siz + tr[tr[t].r].siz + 1;
if (!tr[t].l && !tr[t].r) {
tr[t].F = tr[t].G = 0;
return t;
}
if (!tr[t].l) {
tr[t].F = tr[tr[t].r].G;
tr[t].G = tr[tr[t].r].F + 1;
return t;
}
if (!tr[t].r) {
tr[t].F = tr[tr[t].l].G;
tr[t].G = tr[tr[t].l].F + 1;
return t;
}
tr[t].F = tr[tr[t].l].G + tr[tr[t].r].G;
tr[t].G =
max(tr[tr[t].l].F + tr[tr[t].r].G, tr[tr[t].l].G + tr[tr[t].r].F) + 1;
return t;
}
void build(int l, int r, int &t) {
if (l > r) return;
int now = -1, lo = 0;
for (int _ = l; _ <= r; _++)
A[_].second > now ? now = A[_].second, lo = _ : 0;
tr[t = ++cnt].key = A[lo].second;
build(l, lo - 1, tr[t].l);
build(lo + 1, r, tr[t].r);
up(t);
}
pair<int, int> spl(int t, int k) {
int tmp;
if (!k) return make_pair(0, t);
if (k == tr[t].siz) return make_pair(t, 0);
return tr[tr[t].l].siz + 1 <= k
? (GP(tr[t].r, tmp, spl(tr[t].r, k - tr[tr[t].l].siz - 1)), up(t),
make_pair(t, tmp))
: (GP(tmp, tr[t].l, spl(tr[t].l, k)), up(t), make_pair(tmp, t));
}
int mer(int first, int second) {
if (!first || !second) return first + second;
return tr[first].key > tr[second].key
? (tr[first].r = mer(tr[first].r, second), up(first))
: (tr[second].l = mer(first, tr[second].l), up(second));
}
void solve() {
for (int _ = k + 1; _ <= n; _++)
A[_].first = (1LL * a * A[_ - 1].first + b) % 1000000009,
A[_].second = (1LL * c * A[_ - 1].second + d) % 1000000009;
sort(A + 1, A + n + 1);
build(1, n, rt);
m = rd();
while (m--) {
int ll = rd(), rr = rd(), r1, r2;
pair<int, int> tmp;
tmp.first = ll, tmp.second = 0;
ll = (int)(lower_bound(A + 1, A + n + 1, tmp) - A) - 1;
GP(r1, rt, spl(rt, ll));
tmp.first = rr + 1, tmp.second = 0;
rr = (int)(lower_bound(A + 1, A + n + 1, tmp) - A - 1) - ll;
GP(rt, r2, spl(rt, rr));
printf("%d\n", max(tr[rt].F, tr[rt].G));
rt = mer(r1, rt);
rt = mer(rt, r2);
}
}
void init() {
n = rd(), k = rd();
for (int _ = 1; _ <= k; _++) A[_].first = rd(), A[_].second = rd();
a = rd(), b = rd(), c = rd(), d = rd();
}
int main() {
init();
solve();
return 0;
}
| 4 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<string>
#include<set>
#include<queue>
#include<stack>
#include<bitset>
#include<functional>
#include<map>
#include<iomanip>
#include<limits>
#include<unordered_set>
#include<cmath>
using namespace std;
//long long p = 998244353;
long long p = 1000000007;
#define int long long
#define vel vector<long long>
#define vvel vector<vel>
#define rep(i,n) for(int i=0;i<n;i++)
#define sor(v) sort(v.begin(),v.end())
#define mmax(a,b) a=max(a,b)
#define mmin(a,b) a=min(a,b)
#define mkp make_pair
#define pin pair<int,int>
#define qin pair<pin,int>
#define V vector
#define Endl endl
#define veb vector<bool>
#define fcout cout << fixed << setprecision(15)
#define rev(s) reverse(s.begin(),s.end())
#define lower(h,val) lower_bound(h.begin(),h.end(),val)-h.begin()
#define upper(h,val) upper_bound(h.begin(),h.end(),val)-h.begin()
int max_kai = 150000;
vel kai(max_kai, 1);
vel inv_kai;
int rui(int a, int n, int mod) {
if (n == 0) { return 1 % mod; }
int x = rui(a, n / 2, mod);
x *= x; x %= mod;
if (n % 2 == 1) { x *= a; x %= mod; }
return x;
}
vel pa;
int root(int x) {
if (pa[x] == -1) { return x; }
int ans = root(pa[x]); pa[x] = ans;
return ans;
}
void marge(int x, int y) {
x = root(x);
y = root(y);
if (x != y) { pa[x] = y; }
}
int gcd(int x, int y) {
if (x < y) { return gcd(y, x); }
if (y == 0) { return x; }
return gcd(y, x % y);
}
long long modinv(long long a, long long m) {
long long b = m, u = 1, v = 0;
while (b) {
long long t = a / b;
a -= t * b; swap(a, b);
u -= t * v; swap(u, v);
}
u %= m;
if (u < 0) u += m;
return u;
}
vel uni(vel x) {
if (x.size() == 0) { return x; }
sor(x);
int n = x.size();
vel ans(1, x[0]);
for (int j = 1; j < n; j++) {
if (x[j - 1] != x[j]) { ans.push_back(x[j]); }
}
x = ans;
return x;
}
void pr(vel& v) {
int n = v.size();
if (n != 0) {
cout << v[0];
rep(i, n - 1) {
cout << " " << v[i + 1];
}
cout << endl;
}
}
int sol(int x, int k) {
if (x == 0 || k == 0) { return 0; }
return x + sol(x / 2, k - 1);
}
signed main(){
int n, k; cin >> n >> k;
int ok = 0;
int ng = k + 1;
while (ng - ok > 1) {
int mid = (ok + ng) / 2;
int x = sol(mid, n);
if (x > k) {
ng = mid;
}
else { ok = mid; }
}
cout << ok << endl;
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
long long a[101][101];
long long b[101];
int main() {
int m, n;
cin >> m >> n;
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++) cin >> a[i][j];
for (int i = 0; i < m; i++) {
long long minn = 100000000000000;
for (int j = 0; j < n; j++) {
if (a[i][j] < minn) minn = a[i][j];
}
b[i] = minn;
}
long long maxx = 0;
for (int i = 0; i < m; i++) {
if (b[i] > maxx) maxx = b[i];
}
cout << maxx;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
long long powm(long long base, long long exp, long long mod = 1000000007) {
long long ans = 1;
while (exp) {
if (exp & 1) ans = (ans * base) % mod;
exp >>= 1, base = (base * base) % mod;
}
return ans;
}
struct Point {
long long x, y;
} pts[2005];
map<pair<long double, pair<long double, long double>>, long long> m;
inline long double y_intercept(Point p, Point q) {
if (p.x == q.x) return (long double)1e18;
return ((long double)(p.y * q.x - p.x * q.y) / (q.x - p.x));
}
inline long double slope(Point p, Point q) {
if (p.x == q.x) return (long double)1e18;
return ((long double)(p.y - q.y) / (p.x - q.x));
}
inline long double x_intercept(Point p, Point q) {
if (p.y == q.y) return (long double)1e18;
return ((long double)(q.y * p.x - p.y * q.x) / (q.y - p.y));
}
inline long long check(long long x) { return ((1 + sqrt(1 + 8 * x)) / 2); }
inline long long nC3(long long x) { return ((x * (x - 1) * (x - 2)) / 6); }
int main() {
long long x0, y0, n, x, y, flag = 0, ans = 0;
scanf("%lld", &n), ans = nC3(n);
for (long long i = 0; i < n; i++)
scanf("%lld", &pts[i].x), scanf("%lld", &pts[i].y);
for (long long i = 0; i < n; i++)
for (long long j = i + 1; j < n; j++)
m[{slope(pts[i], pts[j]),
{x_intercept(pts[i], pts[j]), y_intercept(pts[i], pts[j])}}]++;
for (auto i : m) ans -= nC3(check(i.second));
return 0 * printf("%lld ", ans);
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline bool upmin(T &x, T y) {
return y < x ? x = y, 1 : 0;
}
template <typename T>
inline bool upmax(T &x, T y) {
return x < y ? x = y, 1 : 0;
}
const long double eps = 1e-11;
const long double pi = acos(-1);
const int oo = 1 << 30;
const long long loo = 1ll << 62;
const int mods = 1e9 + 7;
const int MAXN = 200005;
const int INF = 0x3f3f3f3f;
inline int read() {
int f = 1, x = 0;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return x * f;
}
set<pair<int, int> > Set;
int n, m, t, cp, cu, cd, a[305][305], D[305][305], U[305][305], X1, Y1, X2, Y2;
int get(int x, int y) {
if (x == y) return cp;
if (x > y) return cu;
if (x < y) return cd;
}
signed main() {
n = read(), m = read(), t = read(), cp = read(), cu = read(), cd = read();
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) a[i][j] = read();
for (int i = 2; i <= n; i++)
for (int j = 1; j <= m; j++)
D[i][j] = D[i - 1][j] + get(a[i][j], a[i - 1][j]);
for (int i = n - 1; i >= 1; i--)
for (int j = 1; j <= m; j++)
U[i][j] = U[i + 1][j] + get(a[i][j], a[i + 1][j]);
int ans = INF;
for (int i = 1; i <= n; i++)
for (int j = i + 2; j <= n; j++) {
int sum = 0;
Set.clear();
for (int k = 2; k <= m; k++) {
int p = sum + get(a[i][k], a[i][k - 1]) + get(a[j][k - 1], a[j][k]);
if (k > 2) {
int y = D[j][k] - D[i][k];
set<pair<int, int> >::iterator it =
Set.lower_bound(make_pair(t - y - p, 0));
if (it != Set.end() && upmin(ans, abs(t - (*it).first - y - p)))
X1 = i, Y1 = (*it).second, X2 = j, Y2 = k;
if (it != Set.begin()) {
it--;
if (upmin(ans, abs(t - (*it).first - y - p)))
X1 = i, Y1 = (*it).second, X2 = j, Y2 = k;
}
}
Set.insert(make_pair(U[i][k - 1] - U[j][k - 1] - sum, k - 1));
sum = p;
}
}
printf("%d %d %d %d\n", X1, Y1, X2, Y2);
return 0;
}
| 4 |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100 * 1000 + 10;
const double eps = 1e-9;
int n, k, h;
pair<pair<int, int>, int> a[maxN];
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> k >> h;
for (int i = 1; i <= n; i++) cin >> a[i].first.first;
for (int i = 1; i <= n; i++) cin >> a[i].first.second;
for (int i = 1; i <= n; i++) a[i].second = i;
sort(a + 1, a + n + 1);
vector<int> ans;
double lo = 0.0, hi = 2e9;
for (int rep = 1; rep <= 100; rep++) {
double mid = (lo + hi) / 2.0;
vector<int> Q;
int now = 1;
for (int i = 1; i <= n && now <= k; i++) {
double Time = (now * h) / (double)a[i].first.second;
if (Time <= mid + eps) {
Q.push_back(a[i].second);
now++;
}
}
if (now > k) {
hi = mid;
ans = Q;
} else
lo = mid;
}
for (int i = 0; i < (int)ans.size(); i++) cout << ans[i] << ' ';
cout << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, i, j;
double k, l, t, r, w, e;
double x, y;
cin >> x >> y;
cin >> n;
double mi = 10000000000000;
while (n--) {
cin >> k >> l >> e;
t = abs(k - x) * abs(k - x);
r = abs(y - l) * abs(y - l);
w = sqrt(t + r);
mi = min(mi, w / e);
}
cout << setprecision(12) << mi << endl;
return 0;
}
| 1 |
#include<bits/stdc++.h>
const int N=100005;
using namespace std;
int n,to[N*2],hd[N*2],lk[N],cnt,
re[N],f[N],sz[N],de[N];
bool vis[N];
inline void add(int u,int v){
to[++cnt]=v,hd[cnt]=lk[u],lk[u]=cnt;
}int u,v;
void dfs(int x){
sz[x]=1;
for(int s,i=lk[x];i;i=hd[i])
if(f[x]^(s=to[i]))
f[s]=x,de[s]=de[x]+1,dfs(s),
sz[x]+=sz[s];
}
inline void get(int x){
f[x]=0,dfs(x);
for(int i=1;i<=n;i++)
if(de[i]>de[u])u=i;
}
inline void cal(int s){
for(int k=1;k<s;k++)
printf("%d ",u+k);
printf("%d ",u),u+=s;
}
int main(){
scanf("%d",&n);
for(int i=1;i<n;i++)
scanf("%d%d",&u,&v),
add(u,v),add(v,u);
get(1),get(u),v=cnt=0;
for(;vis[u]=1,u;u=f[u])
re[cnt++]=sz[u]-v,v=sz[u];
for(int i=1;i<=n;i++)
if(!vis[f[i]])return puts("-1"),0;
u=1,v=2;
for(int i=0,j=cnt-1;i<cnt;i++,j--){
if(v>1&&re[i]!=re[j])
v=re[i]<re[j];
cal(re[v?i:j]);
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long int s[20000] = {0}, h[10] = {0}, n, m, k, i, j, x, y;
short int a[20000][10];
cin >> n >> m >> k;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) cin >> a[i][j];
for (i = 0; i < k; i++) {
scanf("%ld%ld", &x, &y);
h[y - 1]++;
s[x - 1]--;
}
for (i = 0; i < n; i++)
for (j = 0; j < m; j++)
if (a[i][j]) s[i] += h[j];
for (i = 0; i < n; i++) printf("%ld ", s[i]);
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2e5 + 5;
long long n, b[2 * MAXN], a[2 * MAXN], m;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> n;
long long s = 0;
for (int i = 0; i < n; ++i) {
cin >> b[i];
s += b[i];
}
for (int i = 0; i < n; ++i) b[i + n] = b[i];
bool x = 0;
for (int i = 0; i < n; ++i) {
if (b[i] != 0) x = 1;
}
if (x == 0) {
cout << "YES\n";
for (int i = 0; i < n; ++i) cout << 1 << ' ';
cout << endl;
return 0;
}
int ind = -1;
for (int i = 1; i <= n; ++i) {
if (b[i - 1] < b[i]) ind = i;
}
if (ind == -1) {
cout << "NO\n";
return 0;
}
a[ind % n] = b[ind];
m = s + b[ind] * (1LL << 40);
for (int i = ind + 1; i < ind + n; ++i) {
a[i % n] = m;
m -= b[i];
}
cout << "YES\n";
for (int i = 0; i < n; ++i) cout << a[i] << ' ';
cout << endl;
}
| 5 |
#include<iostream>
#include<algorithm>
#include<vector>
#include<stack>
#include<queue>
#include<list>
#include<string>
#include<cstring>
#include<cstdlib>
#include<cstdio>
#include<cmath>
#include<ctime>
using namespace std;
typedef long long ll;
bool debug = false;
const double eps = 1e-10;
clock_t START, END;
struct Point {
double x, y;
Point(double x = 0, double y = 0) :x(x), y(y) {}
};
typedef Point Vector;
Vector operator - (const Point& A, const Point& B) { return Vector(A.x - B.x, A.y - B.y); }
int dcmp(double x) { if (fabs(x) < eps)return 0; else return x < 0 ? -1 : 1; }
double Cross(Vector A, Vector B) { return A.x * B.y - A.y * B.x; }
double Dot(const Vector& A, const Vector& B) { return A.x * B.x + A.y * B.y; }
double Distance(Point u, Point v) {
return sqrt(fabs((u.x - v.x) * (u.x - v.x)) + fabs((u.y - v.y) * (u.y - v.y)));
}
int main(void)
{
if (debug) {
START = clock();
freopen("in29.txt", "r", stdin);
freopen("out.txt", "w", stdout);
};
int n;
double x, y, ans;
vector<Point> p;
cin >> n;
for (int i = 0; i < n; i++) {
scanf("%lf%lf", &x, &y);
p.push_back(Point(x, y));
}
p.push_back(p[0]);
for (int u = 0, v = 1; u < n; u++) {
bool rev = false;
for (;;) {
int diff = dcmp(Cross(p[u + 1] - p[u], p[v + 1] - p[v]));
if (diff)
rev = true;
if (diff <= 0 && rev) {
ans = max(ans, Distance(p[u], p[v]));
if (diff == 0)
ans = max(ans, Distance(p[u], p[v + 1]));
break;
}
v = (v + 1) % n;
}
}
printf("%.6lf\n", ans);
if (debug) {
END = clock();
double endtime = (double)(END - START) / 1000;
printf("total time = %lf s", endtime);
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
int A[105];
int N, M;
vector<int> v;
int main() {
scanf("%d%d", &N, &M);
int o = 0;
for(int i = 1; i <= M; i++) {
scanf("%d", &A[i]);
if(A[i] & 1) o++;
}
if(o > 2) { puts("Impossible"); return 0; }
if(M == 1) {
if(N == 1) printf("1\n1\n1\n");
else printf("%d\n2\n%d %d\n", A[1], A[1] - 1, 1);
return 0;
}
for(int i = 1; i <= M; i++) if(A[i] & 1) swap(A[i], A[1]);
for(int i = 2; i <= M; i++) if(A[i] & 1) swap(A[i], A[M]);
for(int i = 1; i <= M; i++) printf("%d ", A[i]); puts("");
v.push_back(A[1] + 1);
for(int i = 2; i < M; i++) v.push_back(A[i]);
if(A[M] > 1) v.push_back(A[M] - 1);
printf("%d\n", v.size());
for(int i : v) printf("%d ", i); puts("");
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long int n;
cin >> n;
vector<long long int> v(n);
for (long long int i = 0; i < n; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
if (n == 1) {
cout << 0 << "\n";
cout << v[0] << "\n";
} else if (n == 2) {
cout << 0 << "\n";
cout << v[0] << " " << v[1] << "\n";
} else {
long long int x = (n - 1) / 2;
vector<long long int> ans(n);
long long int ptr = 0;
for (long long int i = 1; i < n; i = i + 2) {
ans[i] = v[ptr];
ptr++;
}
for (long long int i = 0; i < n; i = i + 2) {
ans[i] = v[ptr];
ptr++;
}
cout << x << "\n";
for (long long int i = 0; i < n; i++) {
if (i == 0) {
cout << ans[0];
} else
cout << " " << ans[i];
}
cout << "\n";
}
}
| 4 |
#include<cstdio>
int main() {
int n,a,b;
scanf("%d\n%d\n%d",&n,&a,&b);
printf("%d\n",(n-a+1)*(n-b+1));
} | 0 |
#include <bits/stdc++.h>
#define endl '\n'
#define all(a) (a).begin(), (a).end()
#define len(a) (int) (a).size()
#define forn(i, n) for (int (i) = 0; (i) < (n); ++(i))
#define int long long
using namespace std;
void solve();
mt19937 rnd(2009);
signed main(){
#ifdef LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#else
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
swap(rng, rnd);
#endif
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
solve();
}
int get_small(int mask, int sub){
int cur = 0, res = 0;
forn (i, 61){
if ((mask >> i)&1){
res *= 2;
res += (sub >> i)&1;
cur++;
}
}
return res;
}
int n, m, p;
string get_big(int mask, int sub){
int cur = 0;
string res;
forn (i, m){
if ((mask >> (m - i - 1))&1){
res += (char) ('0' + ((sub >> cur)&1));
cur++;
}
else {
res += '0';
}
}
return res;
}
void solve() {
cin >> n >> m >> p;
vector<int> a(n);
forn (i, n){
string s; cin >> s;
for (auto j : s){
a[i] *= 2;
a[i] += (j == '1');
}
}
shuffle(all(a), rnd);
string bst; forn (i, m) bst += '0';
/*
for (auto i : a){
cout << i << endl;
}*/
forn (qwe, min(40ll, n)){
int mask = a[qwe];
int lng = __builtin_popcountll(mask);
vector<int> vals(1ll << lng);
for (auto i : a){
vals[((1ll << lng) - 1) ^ get_small(mask, mask&i)]++;
}
for (int k = 0; k < lng; k++) {
for (int msk = 0; msk < (1 << lng); msk++)
if ((msk >> k) & 1)
vals[msk] += vals[msk ^ (1 << k)];
}
vector<int> vals2(1ll << lng);
forn (msk, 1ll << lng){
vals2[msk] = vals[((1ll << lng) - 1) ^ msk];
}
vals = vals2;
forn (msk, 1ll << lng){
if (vals[msk] * 2 >= n){
auto cur = get_big(mask, msk);
/*
if (cur == "1000"){
cout << mask << endl;
cout << msk << endl;
for (auto i : vals){
cout << i << ' ';
}
cout << endl;
}*/
if (count(all(cur), '1') > count(all(bst), '1'))
bst = cur;
}
}
}
cout << bst << endl;
} | 4 |
#include <bits/stdc++.h>
using namespace std;
int n, ans;
int x[1100000], pw[1100000];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &x[i]);
sort(x + 1, x + n + 1);
pw[0] = 1;
for (int i = 1; i <= n; i++) pw[i] = pw[i - 1] * 2 % 1000000007;
for (int i = 1; i < n; i++)
ans = (ans + 1LL * (x[i + 1] - x[i]) * (pw[i] - 1) % 1000000007 *
(pw[n - i] - 1)) %
1000000007;
printf("%d\n", (ans + 1000000007) % 1000000007);
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
long long int arr[200][200], deg[200];
stack<pair<long long int, long long int> > stk;
int main() {
long long int n, m;
cin >> n >> m;
for (long long int i = 0; i < m; i++) {
long long int u, v;
cin >> u >> v;
deg[u]++;
deg[v]++;
arr[u][v] = 1;
arr[v][u] = 1;
}
long long int ans = 0;
while (1) {
int f = 0;
for (long long int i = 1; i <= n; i++) {
if (deg[i] == 1) {
f = 1;
for (long long int j = 1; j <= n; j++) {
if (arr[i][j] == 1) {
stk.push(make_pair(i, j));
break;
}
}
}
}
if (f == 0) break;
ans++;
while (!stk.empty()) {
pair<long long int, long long int> temp = stk.top();
deg[temp.first]--;
deg[temp.second]--;
arr[temp.first][temp.second] = 0;
arr[temp.second][temp.first] = 0;
stk.pop();
}
}
cout << ans << endl;
return 0;
}
| 2 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005;
struct info {
bool legal, l_2;
int lis[3], cnt;
void merge(const info &b) {
static int cur[6];
int tot = cnt;
for (int i = 0; i < cnt; i++) cur[i] = lis[i];
for (int i = 0; i < b.cnt; i++) cur[tot++] = b.lis[i];
sort(cur, cur + tot);
tot = unique(cur, cur + tot) - cur;
if (tot < 4) {
cnt = tot;
for (int i = 0; i < tot; i++) lis[i] = cur[i];
} else {
cnt = 3;
for (int i = tot - 3; i < tot; i++) lis[i - (tot - 3)] = cur[i];
}
if (cnt > 1) legal = 0;
l_2 &= b.legal;
if (!l_2) legal = 0;
}
void init() {
cnt = 0;
legal = l_2 = 1;
}
void init(int d) {
lis[cnt++] = d;
legal = l_2 = 1;
}
void add() {
for (int i = 0; i < cnt; i++) lis[i]++;
}
};
vector<int> lk[maxn];
info sub[maxn];
int n, ans;
void link(int u, int v) { lk[u].push_back(v); }
void dfs(int now, int pre) {
bool lf = 1;
sub[now].init();
for (int i = 0; i < lk[now].size(); i++)
if (lk[now][i] != pre) {
lf = 0;
dfs(lk[now][i], now);
info tmp = sub[lk[now][i]];
tmp.add();
sub[now].merge(tmp);
}
if (lf) sub[now].init(0);
}
info other[maxn];
void trans(int now, int pre, info out) {
info tmp;
tmp.init();
if (lk[now].size() == 1) tmp.init(0);
for (int i = 0; i < lk[now].size(); i++)
if (lk[now][i] != pre) {
other[lk[now][i]] = tmp;
info bak = sub[lk[now][i]];
bak.add();
tmp.merge(bak);
}
tmp.init();
for (int i = lk[now].size() - 1; i >= 0; i--)
if (lk[now][i] != pre) {
int v = lk[now][i];
other[v].merge(tmp);
other[v].merge(out);
other[v].add();
trans(v, now, other[v]);
info bak = sub[lk[now][i]];
bak.add();
tmp.merge(bak);
}
info cur = sub[now];
cur.merge(out);
if (cur.l_2 && cur.cnt < 3) {
if (cur.cnt == 1)
ans = min(ans, cur.lis[0]);
else
ans = min(ans, cur.lis[cur.cnt - 1] + cur.lis[cur.cnt - 2]);
}
}
int main() {
scanf("%d", &n);
for (int i = 1, u, v; i < n; i++) {
scanf("%d%d", &u, &v);
link(u, v), link(v, u);
}
info fi;
fi.init();
dfs(1, 0);
ans = (1 << 30);
trans(1, 0, fi);
if (ans == (1 << 30))
printf("-1\n");
else {
for (; ans % 2 == 0; ans /= 2)
;
printf("%d\n", ans);
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
#pragma comment(linker, "/STACK:1024000000,1024000000")
int gcd(int x, int y) {
while (y) {
int t = x % y;
x = y;
y = t;
}
return x;
}
int n;
long long a[1000100], b[1000100];
long long sa[1000100], sb[1000100];
int id[1000100];
map<long long, int> mp;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++) scanf("%lld", &b[i]);
for (int i = 1; i <= n; i++)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
int flag = 0;
if (sa[n] < sb[n]) {
swap(sa, sb);
flag = 1;
}
int l = 1, r = 0;
for (; l <= n; l++) {
while (r < n && sb[r + 1] <= sa[l]) r++;
id[l] = r;
}
for (int i = 0; i <= n; i++) sa[i] = sa[i] - sb[id[i]];
for (int i = 0; i <= n; i++) {
if (!mp[sa[i]])
mp[sa[i]] = i + 1;
else {
int x = mp[sa[i]] - 1;
if (!flag) {
printf("%d\n", i - x);
for (int j = x + 1; j <= i; j++) printf("%d ", j);
printf("\n%d\n", id[i] - id[x]);
for (int j = id[x] + 1; j <= id[i]; j++) printf("%d ", j);
} else {
printf("%d\n", id[i] - id[x]);
for (int j = id[x] + 1; j <= id[i]; j++) printf("%d ", j);
printf("\n%d\n", i - x);
for (int j = x + 1; j <= i; j++) printf("%d ", j);
}
break;
}
}
}
| 6 |
#include <bits/stdc++.h>
using namespace std;
int v1, v2, v3, vm;
int vm1, vm2, vm3;
int main() {
cin >> v1 >> v2 >> v3 >> vm;
vm1 = 2 * v1;
vm2 = 2 * v2;
vm3 = max(v3, vm);
if (vm3 > 2 * min(v3, vm)) {
cout << "-1";
return 0;
}
if (vm1 <= 2 * vm || vm2 <= 2 * vm) {
cout << "-1";
return 0;
}
cout << vm1 << '\n' << vm2 << '\n' << vm3;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool possible[27], flag, visit[27];
char str[121212];
int n, ans, res = 26;
int main() {
cin >> n;
getchar();
for (int i = 0; i < 26; i++) possible[i] = 1;
for (int j = 1; j <= n; j++) {
char ch = getchar();
getchar();
scanf("%s", str);
getchar();
int len = strlen(str);
if (flag && ch != '.' && j != n) {
ans++;
continue;
}
if (ch == '!') {
for (int i = 0; i < len; i++) visit[str[i] - 'a'] = 1;
for (int i = 0; i < 26; i++)
if (!visit[i] && possible[i]) {
possible[i] = 0;
res--;
}
memset(visit, 0, sizeof(visit));
}
if (ch == '.') {
for (int i = 0; i < len; i++) visit[str[i] - 'a'] = 1;
for (int i = 0; i < 26; i++)
if (visit[i] && possible[i]) {
possible[i] = 0;
res--;
}
memset(visit, 0, sizeof(visit));
}
if (ch == '?') {
if (possible[str[0] - 'a']) {
possible[str[0] - 'a'] = 0;
res--;
}
}
if (res == 1) flag = true;
}
cout << ans;
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, z;
cin >> n >> k;
int ct = 1;
z = n;
for (int i = 1; i <= n; i++) {
if (k == n - 1) {
cout << z << ' ';
z--;
} else {
k++;
cout << i << ' ';
}
}
return 0;
}
| 1 |
#include <bits/stdc++.h>
using namespace std;
bool arr[1000009] = {0};
void sieve() {
arr[0] = 1;
arr[1] = 1;
for (int i = 2; i < 1000009; i++) {
if (arr[i] == 0) {
for (int j = i * 2; j < 1000009; j += i) {
arr[j] = 1;
}
}
}
}
int main() {
int n, m, index = 1;
cin >> n >> m;
for (int i = 0; i < n; i++) {
if (i % 2 == 0) {
for (int j = 0; j < m; j++) {
cout << '#';
}
} else {
if (index == i || i == index + 4) {
for (int j = 0; j < m; j++) {
if (j == m - 1) {
cout << '#';
} else {
cout << '.';
}
}
index = i;
} else {
for (int j = 0; j < m; j++) {
if (j == 0) {
cout << '#';
} else {
cout << '.';
}
}
}
}
cout << endl;
}
}
| 1 |
#include<bits/stdc++.h>
using namespace std;
int N, M, ap[100009];
long long h[100009];
vector < pair < int, int > > v[100009];
void dfs (int nod)
{
ap[nod] = 1;
for (auto it : v[nod])
if (ap[it.first] == 0)
h[it.first] = h[nod] + it.second, dfs (it.first);
}
int main ()
{
//freopen ("input", "r", stdin);
//freopen ("output", "w", stdout);
scanf ("%d %d", &N, &M);
while (M --)
{
int x, y, d;
scanf ("%d %d %d", &x, &y, &d);
v[x].push_back ({y, d});
v[y].push_back ({x, -d});
}
for (int i=1; i<=N; i++)
if (ap[i] == 0)
h[i] = 0, dfs (i);
for (int i=1; i<=N; i++)
for (auto it : v[i])
if (h[it.first] != h[i] + it.second)
{
printf ("No\n");
return 0;
}
printf ("Yes\n");
return 0;
}
| 0 |
#include<cstdio>
using namespace std;
int main(void)
{
int a,b,c,d,h1,h2,k1,k2;
scanf("%d %d %d %d %d %d %d %d",&h1,&h2,&k1,&k2,&a,&b,&c,&d);
if((a*h1)+(b*h2)+(h1/10*c)+(h2/20*d)<(a*k1)+(b*k2)+(k1/10*c)+(k2/20*d)){
printf("kenjiro\n");
}
if((a*h1)+(b*h2)+(h1/10*c)+(h2/20*d)>(a*k1)+(b*k2)+(k1/10*c)+(k2/20*d)){
printf("hiroshi\n");
}
if((a*h1)+(b*h2)+(h1/10*c)+(h2/20*d)==(a*k1)+(b*k2)+(k1/10*c)+(k2/20*d)){
printf("even\n");
}
return 0;
}
| 0 |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
inline int read() {
int s = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
s = (s << 3) + (s << 1) + (ch ^ 48);
ch = getchar();
}
return s * w;
}
const int N = 200100;
int head[N], ver[N << 1], Next[N << 1], tot;
int n, m, s, ans;
int f[N], d[N];
vector<int> G[N];
void add(int x, int y) {
ver[++tot] = y;
Next[tot] = head[x];
head[x] = tot;
}
void solve(int x, int y) {
if (1 == 0)
printf("%d ", 2);
else
printf("%d\n", 2);
;
if (1 == 0)
printf("%d ", d[x] - d[y] + 1);
else
printf("%d\n", d[x] - d[y] + 1);
;
while (x != y) {
if (0 == 0)
printf("%d ", x);
else
printf("%d\n", x);
;
x = f[x];
}
if (1 == 0)
printf("%d ", y);
else
printf("%d\n", y);
;
ans = 2;
}
void dfs(int x, int far) {
if (ans == 2) return;
d[x] = d[far] + 1;
f[x] = far;
for (int i = head[x]; i; i = Next[i]) {
int y = ver[i];
if (d[y]) {
if (d[x] - d[y] + 1 >= s) {
solve(x, y);
return;
}
} else {
if (ans == 2) return;
dfs(y, x);
if (ans == 2) return;
}
if (ans == 2) return;
}
}
int main() {
n = read();
m = read();
for (int i = 1; i <= m; i++) {
int x = read(), y = read();
add(x, y);
add(y, x);
}
s = ceil(sqrt((double)n));
dfs(1, 0);
if (ans != 2) {
for (int i = 1; i <= n; i++) {
G[d[i] % (s - 1)].push_back(i);
}
for (int i = 0; i < s - 1; i++) {
if (G[i].size() >= s) {
if (1 == 0)
printf("%d ", 1);
else
printf("%d\n", 1);
;
for (int j = 0; j < s; j++)
if (0 == 0)
printf("%d ", G[i][j]);
else
printf("%d\n", G[i][j]);
;
printf("\n");
return 0;
}
}
}
}
| 6 |
#include <iostream>
using namespace std;
int main(){
int n,p,i,stc;
int hstc[50];
while(1){
cin >> n >> p;
if (n==0&&p==0) break;
stc = p;
for (i=0;i<n;i++) hstc[i]=0;
i=0;
while(1){
if (stc >0){
stc--;
hstc[i]++;
if (hstc[i]==p) break;
}else{
stc=hstc[i];
hstc[i]=0;
}
i++;
if (i==n) i=0;
}
cout << i << endl;
}
return 0;
} | 0 |
#include<iostream>
using namespace std;
int main(){
int n;
cin >> n;
cout << (n*180-360) << "\n";
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int main() {
long long t;
cin >> t;
while (t--) {
long long c, m, f;
cin >> c >> m >> f;
long long ans = min(c, m);
c -= ans;
m -= ans;
long long ct = c + m + f;
if (ct >= ans)
cout << ans << endl;
else {
long long v = 0;
if ((ans - ct) % 3 != 0) v++;
cout << ans - v - (ans - ct) / 3 << endl;
}
}
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
template <class A, class B>
ostream& operator<<(ostream& out, const pair<A, B>& a) {
return out << "(" << a.first << "," << a.second << ")";
}
template <class A>
ostream& operator<<(ostream& out, const vector<A>& a) {
out << "";
for (auto it = a.begin(); it != a.end(); it++) {
if (it != a.begin()) out << " ";
out << *it;
}
out << "";
return out;
}
template <class A, class B>
istream& operator>>(istream& in, pair<A, B>& a) {
in >> a.first >> a.second;
return in;
}
template <class A>
istream& operator>>(istream& in, vector<A>& a) {
for (A& i : a) in >> i;
return in;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long u = 1000, d = -1000, l = 1000, r = -1000, black = 0;
long long R, C;
cin >> R >> C;
vector<vector<char>> v(R, vector<char>(C));
for (long long i = 0; i < R; i++)
for (long long j = 0; j < C; j++) {
cin >> v[i][j];
if (v[i][j] == 'B') black++;
}
for (long long i = 0; i < C; i++) {
for (long long j = 0; j < R; j++) {
if (v[j][i] == 'B') {
u = min(j, u);
break;
}
}
}
for (long long i = 0; i < C; i++) {
for (long long j = R - 1; j >= 0; j--) {
if (v[j][i] == 'B') {
d = max(j, d);
break;
}
}
}
for (long long i = 0; i < R; i++) {
for (long long j = 0; j < C; j++) {
if (v[i][j] == 'B') {
l = min(j, l);
break;
}
}
}
for (long long i = 0; i < R; i++) {
for (long long j = C - 1; j >= 0; j--) {
if (v[i][j] == 'B') {
r = max(j, r);
break;
}
}
}
long long side = max(d - u + 1, r - l + 1);
long long sqrr = side * side;
long long def = min(R, C);
if (sqrr <= def * def)
cout << sqrr - black;
else if (black != 0)
cout << -1;
else
cout << 1;
}
| 2 |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
struct P {
int H, W;
P(int w, int h) : H(h), W(w) {}
P(){}
bool operator < (const P &a) const
{
return H*W < a.W*a.H;
}
};
int main()
{
int N, W, H;
while (cin>>N>>W>>H, N||W||H) {
vector<P> piece;
piece.emplace_back(W, H);
for (int i=0; i<N; i++) {
int p, s; cin>>p>>s;
p--;
int PW = piece[p].W, PH = piece[p].H;
s %= 2*(PW+PH);
if (0 < s && s < PW) {
piece.emplace_back(PW-s, PH);
piece.emplace_back(s, PH);
} else if (PW < s && s < PW+PH) {
s -= PW;
piece.emplace_back(PW, PH-s);
piece.emplace_back(PW, s);
} else if (PW+PH < s && s < 2*PW+PH) {
s-= PW+PH;
piece.emplace_back(PW-s, PH);
piece.emplace_back(s, PH);
} else {
s -= 2*PW+PH;
piece.emplace_back(PW, PH-s);
piece.emplace_back(PW, s);
}
sort(piece.end()-2, piece.end());
piece.erase(piece.begin()+p);
}
sort(piece.begin(), piece.end());
for (int i=0; i<piece.size(); i++) {
if (i>0) cout << " ";
cout << piece[i].W*piece[i].H;
}
cout << endl;
}
} | 0 |
#include <bits/stdc++.h>
using namespace std;
int qpow(long long a, long long b, long long m) {
long long c = 1;
while (b) {
if (b & 1) c = c * a % m;
b >>= 1;
a = a * a % m;
}
return c;
}
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int a;
for (int i = (0); i < (n); ++i) {
cin >> a;
if (a <= 2)
cout << 0;
else {
cout << (a % 2 ? a / 2 : a / 2 - 1);
}
cout << "\n";
}
return 0;
}
| 1 |
#include<cstdio>
#include<cstdlib>
#include<iostream>
#include<cassert>
using namespace std;
const int N = 2e5;
char a[N*3+3];
int n,m;
int main()
{
scanf("%d%d",&n,&m);
scanf("%s",a+1); for(int i=1; i<=n; i++) a[i] -= 65;
int tag = 0,hd = 1,tl = n;
for(int i=1; i<=n+n; i++)
{
if((a[hd]^tag)==0) {a[hd]^=1;}
else {tag^=1; hd++; tl++; a[tl] = tag;}
if(i==m) {for(int j=hd; j<=tl; j++) printf("%c",(a[j]^tag)+65); return 0;}
}
if((n&1)&&(m&1)) {a[hd]^=1;}
for(int i=hd; i<=tl; i++) printf("%c",(a[i]^tag)+65);
return 0;
} | 0 |
#include <bits/stdc++.h>
using namespace std;
char gameGrid[10], mark;
int b, c;
bool isOver(char gameGrid[]) {
for (int k = 1; k <= 9; k++) {
if (gameGrid[k] == '.') {
return false;
}
}
return true;
}
bool checkValid(char gameGrid[]) {
b = 0;
c = 0;
for (int a = 1; a <= 9; a++) {
if (gameGrid[a] == 'X')
b++;
else if (gameGrid[a] == '0')
c++;
}
if (b > (c + 1) || b < c)
return false;
else
return true;
}
bool checkWin(char gameGrid[]) {
if (gameGrid[1] == gameGrid[2] && gameGrid[2] == gameGrid[3])
mark = gameGrid[1];
else if (gameGrid[4] == gameGrid[5] && gameGrid[5] == gameGrid[6])
mark = gameGrid[4];
else if (gameGrid[7] == gameGrid[8] && gameGrid[8] == gameGrid[9])
mark = gameGrid[7];
else if (gameGrid[1] == gameGrid[4] && gameGrid[4] == gameGrid[7])
mark = gameGrid[1];
else if (gameGrid[2] == gameGrid[5] && gameGrid[5] == gameGrid[8])
mark = gameGrid[2];
else if (gameGrid[3] == gameGrid[6] && gameGrid[6] == gameGrid[9])
mark = gameGrid[3];
else if (gameGrid[1] == gameGrid[5] && gameGrid[5] == gameGrid[9])
mark = gameGrid[1];
else if (gameGrid[3] == gameGrid[5] && gameGrid[5] == gameGrid[7])
mark = gameGrid[3];
if (mark == 'X' || mark == '0')
return true;
else
return false;
}
bool checkTurn(char gameGrid[]) {
int b, c;
b = 0;
c = 0;
for (int a = 1; a <= 9; a++) {
if (gameGrid[a] == 'X')
b++;
else if (gameGrid[a] == '0')
c++;
}
if (c == b)
return true;
else if (c < b)
return false;
}
int main() {
for (int i = 1; i <= 9; i++) {
cin >> gameGrid[i];
}
if (checkValid(gameGrid) == false)
cout << "illegal" << endl;
else if (checkValid(gameGrid) == true &&
(((checkWin(gameGrid)) && mark == 'X' && b == c) ||
((checkWin(gameGrid)) && mark == '0' && b > c)))
cout << "illegal" << endl;
else {
if (isOver(gameGrid) == true) {
if (checkWin(gameGrid) == true && mark == 'X')
cout << "the first player won" << endl;
else if (checkWin(gameGrid) == true && mark == '0')
cout << "the second player won" << endl;
else
cout << "draw" << endl;
} else {
if (checkWin(gameGrid) == true && mark == 'X')
cout << "the first player won" << endl;
else if (checkWin(gameGrid) == true && mark == '0')
cout << "the second player won" << endl;
else if (checkTurn(gameGrid))
cout << "first" << endl;
else
cout << "second" << endl;
}
}
return 0;
}
| 3 |
#include <bits/stdc++.h>
using namespace std;
int read() {
int w = 0, flg = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') {
flg = -1;
}
ch = getchar();
}
while (ch <= '9' && ch >= '0') {
w = w * 10 + ch - '0', ch = getchar();
}
return w * flg;
}
int head[110], ednum = 1;
struct edge {
int nxt, to, w;
} ed[1010 * 5];
void add_Edge(int u, int v, int w) {
ednum++;
ed[ednum].nxt = head[u], ed[ednum].to = v, ed[ednum].w = w;
head[u] = ednum;
}
int n, m, s1, t1, s2, t2, x[1010], y[1010], g[1010], id[1010];
int lev[110], cur[110], in[110], out[110];
bool is[110];
bool bfs(int s, int t) {
memset(lev, 0x3f, sizeof(lev));
queue<int> que;
que.push(s);
lev[s] = 0;
while (!que.empty()) {
int u = que.front();
que.pop();
cur[u] = head[u];
for (int i = head[u]; i; i = ed[i].nxt) {
if (!ed[i].w) continue;
int v = ed[i].to;
if (lev[v] > lev[u] + 1) {
lev[v] = lev[u] + 1;
que.push(v);
}
}
}
return lev[t] != 0x3f3f3f3f;
}
int dfs(int u, int fl, int t) {
if (u == t) return fl;
int ret = 0;
for (int &i = cur[u]; i; i = ed[i].nxt) {
int v = ed[i].to;
if (!ed[i].w || lev[v] != lev[u] + 1) continue;
int k = dfs(v, min(fl, ed[i].w), t);
ed[i].w -= k, ed[i ^ 1].w += k;
ret += k, fl -= k;
if (!fl) break;
}
return ret;
}
int dinic(int s, int t) {
int re = 0;
while (bfs(s, t)) re += dfs(s, 0x3f3f3f3f, t);
return re;
}
int main() {
n = read(), m = read(), s1 = read(), t1 = read(), s2 = n + 1, t2 = s2 + 1;
for (int i = (1); i <= (m); i++) {
x[i] = read(), y[i] = read(), g[i] = read();
if (!g[i])
add_Edge(x[i], y[i], 0x3f3f3f3f), add_Edge(y[i], x[i], 0);
else {
add_Edge(x[i], y[i], 1), add_Edge(y[i], x[i], 0);
add_Edge(y[i], x[i], 0x3f3f3f3f), add_Edge(x[i], y[i], 0);
}
}
printf("%d\n", dinic(s1, t1));
for (int i = (1); i <= (n); i++)
if (lev[i] != 0x3f3f3f3f) is[i] = true;
ednum = 1;
memset(head, 0, sizeof(head));
memset(ed, 0, sizeof(ed));
for (int i = (1); i <= (m); i++) {
in[y[i]]++, out[x[i]]++;
id[i] = ednum + 1;
add_Edge(x[i], y[i], 0x3f3f3f3f - 1), add_Edge(y[i], x[i], 0);
}
for (int i = (1); i <= (n); i++) {
if (in[i] > out[i])
add_Edge(s2, i, in[i] - out[i]), add_Edge(i, s2, 0);
else
add_Edge(i, t2, out[i] - in[i]), add_Edge(t2, i, 0);
}
add_Edge(t1, s1, 0x3f3f3f3f), add_Edge(s1, t1, 0);
dinic(s2, t2);
for (int i = (1); i <= (m); i++) {
if (!g[i])
puts("0 1");
else {
if (is[x[i]] && !is[y[i]])
printf("%d %d\n", ed[id[i]].w + 1, ed[id[i]].w + 1);
else
printf("%d %d\n", ed[id[i]].w + 1, ed[id[i]].w + 2);
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 5e5 + 10;
int n, m, x, y, w, cnt, col[maxn], dis[maxn], vis[maxn], d[maxn], head[maxn];
struct node {
int nxt, to, val;
} e[maxn << 1];
void add(int x, int y, int w) {
e[++cnt].to = y;
e[cnt].nxt = head[x];
head[x] = cnt;
e[cnt].val = w;
}
queue<int> q;
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; ++i) {
scanf("%d%d%d", &x, &y, &w);
add(y, x, w);
}
if (n == 1) {
cout << "0" << endl << "0";
return 0;
}
memset(col, -1, sizeof(col));
q.push(n);
vis[n] = 0;
while (q.size()) {
int x = q.front();
q.pop();
if (x == 1) {
break;
}
for (int i = head[x]; i; i = e[i].nxt) {
int v = e[i].to;
if (vis[v]) continue;
if (col[v] == -1 || col[v] == 1 - e[i].val) {
col[v] = 1 - e[i].val;
} else {
q.push(v);
d[v] = d[x] + 1;
vis[v] = 1;
}
}
}
if (d[1]) {
cout << d[1] << endl;
} else {
cout << "-1" << endl;
}
for (int i = 1; i <= n; ++i) {
if (col[i] == -1) {
cout << "0";
} else {
cout << col[i];
}
}
return 0;
}
| 5 |
#include <bits/stdc++.h>
using namespace std;
struct data {
int y, d, m;
} a, b;
int _m[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
int _ml[] = {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool isleap(int y) {
if (y % 400 == 0 || (y % 4 == 0 && y % 100 != 0)) return true;
return false;
}
int main() {
int aa = 0, bb = 0, i;
scanf("%d:%d:%d", &a.y, &a.m, &a.d);
scanf("%d:%d:%d", &b.y, &b.m, &b.d);
aa += (a.y - 1) / 4;
aa -= (a.y - 1) / 100;
aa += (a.y - 1) / 400;
aa += (a.y - 1) * 365;
aa += a.d;
bb += (b.y - 1) / 4;
bb -= (b.y - 1) / 100;
bb += (b.y - 1) / 400;
bb += (b.y - 1) * 365;
bb += b.d;
if (isleap(a.y)) {
for (i = 0; i < (int)a.m - 1; i++) aa += _ml[i];
} else {
for (i = 0; i < (int)a.m - 1; i++) aa += _m[i];
}
if (isleap(b.y)) {
for (i = 0; i < (int)b.m - 1; i++) bb += _ml[i];
} else {
for (i = 0; i < (int)b.m - 1; i++) bb += _m[i];
}
cout << fabs(aa - bb) << endl;
return 0;
}
| 2 |
#include <iostream>
using namespace std;
int main(){
int N;
int n=1;
cin >> N;
while(n<=N){
n *= 2;
}
cout << n/2;
return 0;
} | 0 |
#include<bits/stdc++.h>
using namespace std;
inline int read()
{
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;
}
typedef long long ll;
ll mod=1000000007;
int main()
{
int n=read(),p=0;
ll ans=1;
for(int i=1;i<=n;i++)
{
int x=read();
if (x>=2*p+1) ans=ans*(++p)%mod;
else ans=ans*(p+1)%mod;
}
cout<<ans<<endl;
return 0;
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.