solution
stringlengths 10
983k
| difficulty
int64 0
25
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 811287553;
long long powmod(long long a, long long b) {
long long res = 1;
a %= mod;
for (; b; b >>= 1) {
if (b & 1) res = res * a % mod;
a = a * a % mod;
}
return res;
}
int n, m, s, t, a, b, d;
vector<long long> dist, dist1;
vector<pair<int, int> > grh[2][100000];
vector<pair<pair<int, int>, int> > queries;
set<pair<int, int> > absEdges;
map<pair<int, int>, int> minEdges;
long long reachableCnt[2][100000];
const long long INF = 1000000000000;
void dijkstra(int src, vector<long long>& d, int mode) {
d.resize(n, INF);
d[src] = 0;
priority_queue<pair<long long, int> > pq;
pq.push(make_pair(0, src));
while (!pq.empty()) {
long long topD = -pq.top().first;
int topIdx = pq.top().second;
pq.pop();
if (d[topIdx] < topD) continue;
int sz = grh[mode][topIdx].size();
for (int i = 0; i < (int)sz; i++) {
int nIdx = grh[mode][topIdx][i].first;
int nD = grh[mode][topIdx][i].second;
long long nD1 = topD + nD;
if (d[nIdx] > nD1) {
d[nIdx] = nD1;
pq.push(make_pair(-nD1, nIdx));
}
}
}
}
int calReachable(int idx, vector<long long>& d, bool rev) {
if (rev && idx == s) {
reachableCnt[!rev][idx] = 1;
return 1;
}
if (!rev && idx == t) {
reachableCnt[!rev][idx] = 1;
return 1;
}
long long& ret = reachableCnt[!rev][idx];
if (ret != -1) return ret;
int ret1 = 0;
int sz = grh[rev][idx].size();
for (int i = 0; i < (int)sz; i++) {
int nIdx = grh[rev][idx][i].first;
int nD = grh[rev][idx][i].second;
if (d[nIdx] == d[idx] + nD) {
ret1 += calReachable(nIdx, d, rev);
ret1 %= mod;
}
}
return ret = (ret1 % mod);
}
int main() {
cin >> n >> m >> s >> t;
s--, t--;
for (int i = 0; i < (int)m; i++) {
cin >> a >> b >> d;
a--, b--;
grh[0][a].push_back(make_pair(b, d));
grh[1][b].push_back(make_pair(a, d));
queries.push_back(make_pair(make_pair(a, b), d));
if (minEdges.count(make_pair(a, b)))
minEdges[make_pair(a, b)] = min(minEdges[make_pair(a, b)], d);
else
minEdges[make_pair(a, b)] = d;
}
memset(reachableCnt, -1, sizeof(reachableCnt));
dijkstra(s, dist, 0);
dijkstra(t, dist1, 1);
calReachable(t, dist1, 1);
calReachable(s, dist, 0);
for (int i = 0; i < (int)m; i++) {
int x = queries[i].first.first, y = queries[i].first.second,
d = queries[i].second;
if ((((reachableCnt[0][x] * reachableCnt[1][y]) % mod) ==
reachableCnt[0][t]) &&
minEdges[make_pair(x, y)] < d) {
if (minEdges[make_pair(x, y)] == 1)
cout << "NO" << endl;
else
cout << "CAN " << d - minEdges[make_pair(x, y)] + 1 << endl;
} else {
long long d1 = dist[x] + dist1[y];
if ((((reachableCnt[0][x] * reachableCnt[1][y]) % mod) ==
reachableCnt[0][t])) {
if (d1 + d == dist[t])
cout << "YES" << endl;
else {
if (d > 1 && d1 + 1 < dist[t])
cout << "CAN " << d + d1 - (dist[t] - 1) << endl;
else
cout << "NO" << endl;
}
} else {
if (d > 1 && d1 + 1 < dist[t])
cout << "CAN " << d + d1 - (dist[t] - 1) << endl;
else
cout << "NO" << endl;
}
}
}
return 0;
}
| 11 | CPP |
#include<bits/stdc++.h>
using namespace std;
int main()
{
int n,x=0;
cin>>n;
long long a[n],min=LLONG_MAX,sum=0;
for(int i=0;i<n;i++){
cin>>a[i];
if(a[i]<0){
a[i]*=-1;x++;
}
if(a[i]<min){
min=a[i];
}
sum+=a[i];
}
if(x%2==0){cout<<sum;}
else{cout<<sum-2*min;}
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') f = -1;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return x * f;
}
const int N = 5000005;
struct Graph {
int head[N], nxt[N], to[N], En;
inline void add_edge(int u, int v) {
++En;
to[En] = v, nxt[En] = head[u];
head[u] = En;
}
} G1, G2;
int dfn[N], low[N], sk[N], bel[N], vis[N], siz[N], dp[N], TimeIndex, SCC, top;
char s[100001][51];
void tarjan(int u) {
dfn[u] = low[u] = ++TimeIndex;
sk[++top] = u;
vis[u] = 1;
for (int i = G1.head[u]; i; i = G1.nxt[i]) {
int v = G1.to[i];
if (!dfn[v])
tarjan(v), low[u] = min(low[u], low[v]);
else if (vis[v])
low[u] = min(low[u], dfn[v]);
}
if (low[u] == dfn[u]) {
++SCC;
do {
vis[sk[top]] = 0;
bel[sk[top]] = SCC;
top--;
} while (sk[top + 1] != u);
}
}
int dfs(int u) {
if (dp[u]) return dp[u];
int ans = 0;
for (int i = G2.head[u]; i; i = G2.nxt[i]) ans = max(ans, dfs(G2.to[i]));
dp[u] = siz[u] + ans;
return dp[u];
}
int main() {
int n = read(), m = read(), d = read(), tot = n * d;
for (int i = 1; i <= m; ++i) {
int u = read(), v = read();
for (int j = 0; j < d; ++j)
G1.add_edge(((u - 1) * d + j + 1), ((v - 1) * d + (j + 1) % d + 1));
}
for (int i = 1; i <= n; ++i) scanf("%s", s[i]);
tarjan(1);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < d; ++j) {
int x = ((i - 1) * d + j + 1);
if (s[i][j] == '1' && vis[bel[x]] != i) vis[bel[x]] = i, siz[bel[x]]++;
for (int k = G1.head[x]; k; k = G1.nxt[k])
if (bel[x] != bel[G1.to[k]]) G2.add_edge(bel[x], bel[G1.to[k]]);
}
}
cout << dfs(bel[1]);
return 0;
}
| 11 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long N = 3e5 + 52;
const long long base = 257;
const long long inf = 1e9 + 7;
long long P[N], n, type, numquery, dem[N];
string str;
unordered_map<long long, int> mymap;
struct hashing {
vector<long long> H;
void create(string str) {
H.resize(str.size() + 2, 0);
for (int i = (1); i <= (str.size()); i++)
H[i] = (H[i - 1] * base + str[i - 1]) % inf;
}
long long gethash(int u, int v) {
return (H[v] - H[u - 1] * P[v - u + 1] + inf * inf) % inf;
}
};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
memset(dem, 0, sizeof(dem));
P[0] = 1;
for (int i = (1); i <= (N - 1); i++) P[i] = (P[i - 1] * base) % inf;
cin >> numquery;
for (int num = (1); num <= (numquery); num++) {
cin >> type >> str;
n = str.size();
hashing H;
H.create(str);
long long get = H.gethash(1, str.size());
if (type == 1) {
dem[str.size()]++;
mymap[get]++;
} else if (type == 2) {
dem[str.size()]--;
mymap[get]--;
} else {
int d = 0;
for (int leng = (1); leng <= (str.size()); leng++) {
if (dem[leng] == 0) continue;
for (int i = (1); i <= (n - leng + 1); i++) {
long long tmp = H.gethash(i, i + leng - 1);
if (mymap[tmp] > 0) d++;
}
}
cout << d << "\n";
cout << flush;
}
}
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> Pii;
int main() {
int n;
while(cin >> n && n) {
vector<Pii> vec(n);
for(int ii=0; ii<n; ii++) {
int S, m, s;
cin >> S;
int t = 0;
for(int i=0; i<4; i++) {
cin >> m >> s;
t += s+m*60;
}
vec[ii] = Pii(t, S);
}
sort(vec.begin(),vec.end());
cout << vec[0].second << endl << vec[1].second << endl << vec[vec.size()-2].second << endl;
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const long long linf = 4000000000000000000LL;
const long long inf = 1000000007;
const long double pi = 3.1415926535;
void pv(vector<int> a) {
for (auto& x : a) cout << x << " ";
cout << '\n';
}
void pv(vector<long long> a) {
for (auto& x : a) cout << x << " ";
cout << '\n';
}
void pv(vector<vector<int>> a) {
for (int i = (0); i < (int(a.size())); ++i) {
cout << i << '\n';
pv(a[i]);
cout << '\n';
}
}
void pv(vector<vector<long long>> a) {
for (int i = (0); i < (int(a.size())); ++i) {
cout << i << '\n';
pv(a[i]);
}
cout << '\n';
}
void pv(vector<string> a) {
for (auto& x : a) cout << x << '\n';
cout << '\n';
}
void build_primes(vector<int>& primes, int size) {
vector<int> visited;
visited.resize(size, 0);
for (int i = (2); i < (size); ++i) {
if (visited[i] == 0) {
primes.push_back(i);
int a = i;
while (a < size) {
visited[a] = 1;
a += i;
}
}
}
}
vector<vector<long long>> matrix_mult(vector<vector<long long>>& a,
vector<vector<long long>>& b) {
int n = a.size();
vector<vector<long long>> answer;
answer.resize(n);
for (int i = 0; i < n; i++) answer[i].resize(n, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++)
answer[i][j] = (answer[i][j] + a[i][k] * b[k][j]) % inf;
}
}
return answer;
}
int modInverse(int a, int m) {
int m0 = m;
int y = 0, x = 1;
if (m == 1) return 0;
while (a > 1) {
int q = a / m;
int t = m;
m = a % m, a = t;
t = y;
y = x - q * y;
x = t;
}
if (x < 0) x += m0;
return x;
}
long long power(long long x, long long y) {
long long k = 1LL << 60;
long long z = 1;
while (k != 0) {
z *= z;
z %= inf;
if (y >= k) {
z *= x;
z %= inf;
y -= k;
}
k >>= 1;
}
return z;
}
struct point {
long double x, y;
bool operator<(const point& rhs) const {
if (x == rhs.x) return y < rhs.y;
return x < rhs.x;
}
};
struct pt {
long long x, y;
bool operator<(const pt& rhs) const {
if (x == rhs.x) return y < rhs.y;
return x < rhs.x;
}
};
long double area(point x, point y, point z) {
return (x.y * y.x + y.y * z.x + z.y * x.x - x.x * y.y - y.x * z.y -
z.x * x.y) /
2.0;
}
bool clockwise(point x, point y, point z) { return area(x, y, z) > 0; }
long double area(pt x, pt y, pt z) {
return (x.y * y.x + y.y * z.x + z.y * x.x - x.x * y.y - y.x * z.y -
z.x * x.y) /
2.0;
}
bool clockwise(pt x, pt y, pt z) { return area(x, y, z) > 0; }
long long gcd(long long a, long long b) {
if (a > b) swap(a, b);
if (a == 0) return b;
return gcd(a, b % a);
}
int popcount(long long a) {
int count = 0;
while (a) {
count += (a & 1);
a >>= 1;
}
return count;
}
long long choose(long long n, long long r) {
long long p = 1, k = 1;
if (n - r < r) r = n - r;
if (r != 0) {
while (r) {
p *= n;
k *= r;
long long m = gcd(p, k);
p /= m;
k /= m;
n--;
r--;
}
} else
p = 1;
return p;
}
vector<long long> prefix_hash(string& a, vector<long long>& powers,
long long mod) {
int n = int(a.size());
vector<long long> prefix(n + 1);
for (int i = (0); i < (n); ++i)
prefix[i + 1] = (prefix[i] + powers[i] * (a[i] - '1' + 1)) % mod;
return prefix;
}
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
uint64_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
struct custom_hash_fast {
uint64_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
x ^= FIXED_RANDOM;
return x ^ (x >> 16);
}
};
void setIO(string second) {
ios_base::sync_with_stdio(0);
cin.tie(0);
if (int(second.size())) {
freopen((second + ".in").c_str(), "r", stdin);
if (second != "test3") freopen((second + ".out").c_str(), "w", stdout);
}
}
int n, k;
long long p;
vector<long long> a, b;
long long ans = linf;
void solve() {
long long sum = 0;
for (int i = (0); i < (n); ++i) {
sum = max(sum, abs(a[i] - b[i]) + abs(p - b[i]));
}
ans = min(ans, sum);
}
int main() {
setIO("");
cin >> n >> k >> p;
a.resize(n);
for (auto& x : a) cin >> x;
vector<long long> c(k);
for (auto& x : c) cin >> x;
sort(a.begin(), a.end());
sort(c.begin(), c.end());
for (int i = (0); i < (n); ++i) b.push_back(c[i]);
for (int i = (0); i < (k - n); ++i) {
solve();
b.erase(b.begin());
b.push_back(c[i + n]);
}
solve();
cout << ans << '\n';
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k;
cin >> n >> k;
float x = float(n) / k;
int ans[n];
if (x < 3) {
cout << -1;
} else {
int a[k];
for (int i = 0; i < k; i++) {
a[i] = i + 1;
}
copy(a, a + k, ans);
for (int i = 0; i < k; i++) {
a[i] = k - i;
}
copy(a, a + k, ans + k);
for (int i = 0; i < k; i++) {
a[i] = i + 1;
}
copy(a, a + k, ans + 2 * k);
if (x == 3 && k % 2 == 1) {
for (int i = 0; i < 3 * k; i++) {
if (ans[i] == 1) {
ans[i] = (k / 2) + 1;
} else if (ans[i] == (k / 2) + 1) {
ans[i] = 1;
}
}
ans[0] = 1;
ans[k / 2] = k / 2 + 1;
}
copy(ans, ans + 3 * k, ostream_iterator<int>(cout, " "));
for (int i = 3 * k; i < n; i++) {
cout << (k + 1) / 2 << " ";
}
}
return 0;
}
| 9 | CPP |
n, k = list(map(int, input().split()))
arr = list(map(int, input().split()))
max_el = 0
for i in range(n):
if k % arr[i] == 0:
if max_el < arr[i]:
max_el = arr[i]
print(k // max_el)
| 7 | PYTHON3 |
#include<iostream>
#include<string>
int main(){
int n;
std::cin >> n;
std::cin.ignore();
for(int i = 0; i < n; i++){
std::string str;
std::getline(std::cin, str);
for(int a = 1; a < 26; a++){
for(int b = 0; b < 26; b++){
std::string str2 = str;
for(int j = 0; j < str2.size(); j++){
if(str2[j] != ' ')str2[j] = ((a * (str2[j] - 'a') + b) % 26) + 'a';
}
if(str2.find("that") != -1 || str2.find("this") != -1){
std::cout << str2 << std::endl;
goto end;
}
}
}
end:;
}
return 0;
} | 0 | CPP |
for t in range(int(input())):
a,b,c,n = map(int,input().split(" "))
diff = 3*max(a,b,c) - (a+b+c)
if diff > n or (n - diff)%3 != 0:
print("NO")
else:
print("YES") | 7 | PYTHON3 |
n,m=map(int,input().split())
if (min(n,m)%2==0):
print('Malvika')
else:
print('Akshat')
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<ll, ll> P;
#define EACH(i,a) for (auto& i : a)
#define FOR(i,a,b) for (ll i=(a);i<(b);i++)
#define RFOR(i,a,b) for (ll i=(b)-1;i>=(a);i--)
#define REP(i,n) for (ll i=0;i<(n);i++)
#define RREP(i,n) for (ll i=(n)-1;i>=0;i--)
#define debug(x) cout<<#x<<": "<<x<<endl
#define pb push_back
#define ALL(a) (a).begin(),(a).end()
const ll linf = 1e18;
const int inf = 1e9;
const double eps = 1e-12;
const double pi = acos(-1);
template<typename T>
istream& operator>>(istream& is, vector<T>& vec) {
EACH(x,vec) is >> x;
return is;
}
/*
template<class... T>
ostream& operator<<(ostream& os, tuple<T...>& t) {
for (size_t i = 0; i < tuple_size< tuple<T...> >::value; ++i) {
if (i) os << " ";
os << get<0>(t);
}
return os;
}
*/
template<typename T>
ostream& operator<<(ostream& os, vector<T>& vec) {
REP(i,vec.size()) {
if (i) os << " ";
os << vec[i];
}
return os;
}
template<typename T>
ostream& operator<<(ostream& os, vector< vector<T> >& vec) {
REP(i,vec.size()) {
if (i) os << endl;
os << vec[i];
}
return os;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
ll L;
while (cin >> L) {
vector<int> r;
{
string str; getline(cin, str);
stringstream ss; ss << str;
int val;
while ( ss >> val ) {
r.pb(val);
}
}
int N = r.size();
vector< vector< vector<ld> > > dp;
vector< vector<ld> > dp0(N+1, vector<ld>((1 << N), linf)); dp0[0][0] = 0;
REP(t, N) {
dp = vector< vector< vector<ld> > >(N+1, vector< vector<ld> >(N+1, vector<ld>((1 << N), linf)));
dp[0] = dp0;
REP(i, N) {
REP(j, N+1) {
REP(k, (1 << N)) {
if (dp[i][j][k] >= linf-eps) continue;
dp[i+1][j][k] = min(dp[i+1][j][k], dp[i][j][k]);
if ((k & (1 << i)) == 0) {
int nk = k | (1 << i);
int nj = i+1;
ld nv = linf;
if (j == 0) {
// if (dp[i][j][k] > eps) cout << i << " " << j << " " << k << " " << dp[i][j][k] << endl;
assert(dp[i][j][k] < eps);
nv = min(nv, (ld)2*r[i]);
}
else {
int prev = j-1;
int r1 = r[prev], r2 = r[i];
ld dx = sqrt((r1+r2)*(r1+r2) - abs(r1-r2)*abs(r1-r2));
nv = min(nv, dp[i][j][k]-r[prev]+dx+r[i]);
}
dp[i+1][nj][nk] = min(dp[i+1][nj][nk], nv);
}
}
}
}
dp0 = dp[N];
}
ld ans = linf;
REP(i, N+1) ans = min(ans, dp0[i][(1<<N)-1]);
// cout << fixed << setprecision(10) << ans << endl;
if (ans <= L+eps) {
cout << "OK" << endl;
}
else {
cout << "NA" << endl;
}
}
} | 0 | CPP |
# define _CRT_SECURE_NO_WARNINGS 1
# include <iostream>
# include <string>
# include <bitset>
# include <vector>
# include <algorithm>
# include <cstdlib>
# include <cstdio>
# include <cstring>
# include <cstdlib>
# include <iomanip>
# include <queue>
# include <sstream>
# include <climits>
# include <cmath>
# include <list>
# include <functional>
# include <string>
# include <ctime>
# include <set>
# include <map>
# include <stack>
# include <unordered_map>
using namespace std;
//# define M_PI 3.141592
# define INF ((int)(1<<30))
# define FOR(i,n) for(int i=0;i<(int)n;i++)
# define FORI(i,k,n) for(int i=k;i<(int)n;i++)
# define toRad 2.0*M_PI/360.0
# define inin(x) int x;cin>>x;
# define all(x) x.begin(),x.end()
# define debug(x) cout<<#x<<" :"<<x<<endl;
# define rep(i,n) for(int i=0;i<(int)n;i++)
# define EPS 1e-12
# define CHECK(i,a) FOR(i,a.size())cout<<#a<<"["<<i<<"] : "<<a[i]<<endl;
int main()
{
string s;
bool f = false;
while (cin >> s)
{
if (f)cout << endl;
reverse(all(s));
while (s.size() < 5)s += '0';
reverse(all(s));
f = true;
for (int i = 0; i < s.size(); i++)
{
char c = '*';
if (s[i] >= '5')
c = ' ';
cout << c;
}cout << endl;
for (int i = 0; i < s.size(); i++)
{
char c = ' ';
if (s[i] >= '5')
c = '*';
cout << c;
}cout << endl;
for (int i = 0; i < s.size(); i++)
{
cout << '=';
}cout << endl;
for (int j = 0; j < 5; j++)
{
for (int i = 0; i < s.size(); i++)
{
char c = '*';
if (s[i] == '0' + j || s[i] == '5' + j)
c = ' ';
cout << c;
}cout << endl;
}
}
} | 0 | CPP |
S = input()
T = input()
n = len(S)
m = len(T)
flag = 0
ans = 'UNRESTORABLE'
for i in range(n - m + 1):
for j in range(m):
if S[i + j] != '?' and S[i + j] != T[j]:
break
else:
S2 = S[: i] + T + S[i + m :]
ans = S2.replace('?', 'a')
print(ans) | 0 | PYTHON3 |
k = int(input())
l = int(input())
x = (k**i for i in range((l//k) + 2))
y = next(x)
i = 0
while y <= l:
if y == l:
print("YES")
print(i - 1)
exit()
i += 1
y = next(x)
print("NO")
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int v[120];
for (int i = 0; i < n; i++) cin >> v[i];
sort(v, v + n);
vector<int> Q;
int k = 0;
if (v[n - 1] == 100) {
Q.push_back(100);
n--;
}
if (v[0] == 0) {
Q.push_back(0);
k = 1;
}
bool w = 1, e = 1;
int second = 0;
for (int i = k; i < n; i++) {
if (v[i] == 100) continue;
if (v[i] == 0) {
Q.push_back(0);
continue;
}
if (v[i] / 10 == 0 and v[i] % 10 != 0 and e) {
Q.push_back(v[i]);
e = 0;
continue;
}
if (v[i] / 10 != 0 and v[i] % 10 == 0 and w) {
Q.push_back(v[i]);
w = 0;
continue;
}
second = v[i];
}
if (e and w and second) Q.push_back(second);
cout << Q.size() << endl;
for (int i = 0; i < Q.size(); i++) cout << Q[i] << " ";
cout << endl;
}
| 7 | CPP |
n=int(input())
s=[]
for i in range(n):
s.append(list(map(int, input().split())))
s=sorted(s)
i=0
while i<n:
if s[i][0]>0:
break
i+=1
sr=s[i:]
sl=list(reversed(s[:i]))
answ=0
if len(sr)>len(sl):
for i in range(len(sl)):
answ+= sl[i][1]+sr[i][1]
answ+= sr[len(sl)][1]
print(answ)
elif len(sr)==len(sl):
for i in range(len(sl)):
answ+= sl[i][1]+sr[i][1]
print(answ)
else:
for i in range(len(sr)):
answ+= sr[i][1]+sl[i][1]
answ+= sl[len(sr)][1]
print(answ) | 7 | PYTHON3 |
from itertools import accumulate
n,k = map(int,input().split())
a = list(map(int,input().split()))
acc = list(accumulate(a))[:-1]
acc.sort()
ans = k*sum(a)-sum(acc[:k-1])
print(ans) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
cout << "25";
return 0;
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
vector<pair<int, int> > adj[100100];
int n, L, R;
struct RMQ_Tree {
int n;
pair<int, int> mx[8 * 100100];
void init(int _n) {
for (n = 1; n < _n; n <<= 1)
;
for (int i = 1; i < 4 * n; i++) mx[i] = pair<int, int>(-0x3f3f3f3f, 0);
}
void insert(int p, pair<int, int> val) {
p += n + 1;
for (; p >= 1 && val > mx[p]; p >>= 1) mx[p] = val;
}
pair<int, int> calc(int st, int ed) {
if (st > ed) return pair<int, int>(-0x3f3f3f3f, 0);
st += n;
ed += n + 2;
pair<int, int> ans = pair<int, int>(-0x3f3f3f3f, 0);
while (st ^ ed ^ 1) {
if (~st & 1) smax(ans, mx[st ^ 1]);
if (ed & 1) smax(ans, mx[ed ^ 1]);
st >>= 1;
ed >>= 1;
}
return ans;
}
} Tree;
int qf, qb, q[100100], sz[100100], fa[100100];
int nn, vst[100100], id[100100], dis[100100], val[100100], mid;
int ans, S, T;
int find_root(int u) {
qf = qb = 0;
q[qb++] = u;
fa[u] = 0;
while (qf < qb) {
u = q[qf++];
for (int i = adj[u].size(); i--;) {
int v = adj[u][i].first;
if (v == fa[u] || vst[v]) continue;
fa[v] = u;
q[qb++] = v;
}
}
nn = qb;
for (int i = nn; i--;) {
sz[u = q[i]] = 1;
int mx = 0;
for (int j = adj[u].size(); j--;) {
int v = adj[u][j].first;
if (v == fa[u] || vst[v]) continue;
smax(mx, sz[v]);
sz[u] += sz[v];
}
if (mx * 2 <= nn && sz[u] * 2 >= nn) return u;
}
}
void dfs(int u, int p, int d, int pv) {
id[nn] = u;
dis[nn] = d;
val[nn] = pv;
nn++;
for (int i = adj[u].size(); i--;) {
int v = adj[u][i].first;
if (v == p || vst[v]) continue;
int w = adj[u][i].second;
dfs(v, u, d + 1, pv + (w >= mid ? 1 : -1));
}
}
bool check(int u, int mx_dp) {
Tree.init(mx_dp);
Tree.insert(0, pair<int, int>(0, u));
for (int i = adj[u].size(); i--;) {
int v = adj[u][i].first;
if (vst[v]) continue;
int w = adj[u][i].second;
nn = 0;
dfs(v, u, 1, (w >= mid ? 1 : -1));
for (int i = 0; i < nn; i++) {
pair<int, int> mx = Tree.calc(max(L - dis[i], 0), min(R - dis[i], mx_dp));
if (val[i] + mx.first >= 0) {
ans = mid;
S = id[i];
T = mx.second;
return true;
}
}
for (int i = 0; i < nn; i++) {
Tree.insert(dis[i], pair<int, int>(val[i], id[i]));
}
}
return false;
}
void solve(int u) {
u = find_root(u);
vst[u] = 1;
nn = 0;
dfs(u, 0, 0, 0);
int st = ans, ed = 0x3f3f3f3f;
int mx_dp = *max_element(dis, dis + nn);
while (ed - st > 1) {
mid = st + ed >> 1;
if (check(u, mx_dp))
st = mid;
else
ed = mid;
}
for (int i = adj[u].size(); i--;) {
int v = adj[u][i].first;
if (!vst[v]) solve(v);
}
}
int main() {
cin >> n >> L >> R;
int u, v, w;
for (int i = 1; i < n; i++) {
scanf("%d %d %d", &u, &v, &w);
adj[u].push_back(pair<int, int>(v, w));
adj[v].push_back(pair<int, int>(u, w));
}
ans = -1;
solve(1);
printf("%d %d\n", S, T);
return 0;
}
| 11 | CPP |
n,a,b=map(int,input().split())
if (b-a)%2==0:
ans=(b-a)//2
else:
ans=min((a+b)//2,(2*(n+1)-(a+b))//2)
print(ans) | 0 | PYTHON3 |
n=int(input())
s=[];ans=0
for i in range(n):
a=int(input())
if a%10!=0:
s.append(a)
ans+=a
s.sort()
if ans%10==0:
if s:
ans-=s[0]
else:
ans=0
print(ans) | 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m;
string we, ns, sol = "";
void fast() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int main() {
fast();
cin >> n >> m;
cin >> we;
cin >> ns;
sol += we[0];
sol += we.back();
sol += ns[0];
sol += ns.back();
if (sol == "<>v^" || sol == "><^v") {
cout << "YES";
} else {
cout << "NO";
}
return 0;
}
| 8 | CPP |
#include <iostream>
#include <unordered_map>
using namespace std;
int v,e;
unordered_map<int,unordered_map<int,int> > g;
int dfs(int pos, int flow, unordered_map<int,bool> &arrived) {
if(pos==v-1) return flow;
arrived[pos] = true;
for(pair<int,int> p : g[pos]) {
int next = p.first;
int capacity = p.second;
if(!arrived[next]&&capacity>0) {
int res = dfs(next,min(flow,capacity),arrived);
if(res>0) {
g[pos][next] -= res;
g[next][pos] += res;
if(g[pos][next]<=0) g[pos].erase(next);
return res;
}
}
}
return 0;
}
int main() {
cin >> v >> e;
for(int i = 0; i < e; i++) {
int u,v2,c;
cin >> u >> v2 >> c;
g[u][v2] = c;
}
int ans = 0;
while(true) {
unordered_map<int,bool> arrived(v);
int flow = dfs(0,1<<30,arrived);
if(flow<=0) break;
else ans += flow;
}
cout << ans << endl;
}
| 0 | CPP |
n=int(input())
a=[int(x) for x in input().split()]
c=0
for i in range(1,n-1):
if a[i]==0 and a[i-1]==1 and a[i+1]==1:
a[i+1]=0
c+=1
print(c) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
bool home = 1;
signed realMain();
signed main() {
home = 0;
if (home) {
freopen("input", "r", stdin);
} else {
ios::sync_with_stdio(0);
cin.tie(0);
}
realMain();
}
const int M = (int)1e9 + 7;
int add(int a, int b) {
a += b;
if (a >= M) return a - M;
if (a < 0) return a + M;
return a;
}
int mul(int a, int b) { return a * (long long)b % M; }
int mul(int a, int b, int c) { return mul(a, mul(b, c)); }
int pw(int a, int b) {
int r = 1;
while (b) {
if (b & 1) {
r = mul(r, a);
}
a = mul(a, a);
b /= 2;
}
return r;
}
int dv(int a, int b) { return mul(a, pw(b, M - 2)); }
const int N = (int)2e5 + 7;
int n, l[N], r[N], p[N];
int ret;
int pdif(int l1, int r1, int l2, int r2) {
int lmax = max({l1, l2}), rmin = min({r1, r2}), com = max(0, rmin - lmax + 1);
int prod_len = mul(r1 - l1 + 1, r2 - l2 + 1);
return add(1, -dv(com, prod_len));
}
int pdif(int l1, int r1, int l2, int r2, int l3, int r3) {
int ret = 0;
int com13 = min({r1, r2, r3}) - max({l1, l2, l3}) + 1;
int com1 = min({r1, r2}) - max({l1, l2}) + 1;
int com3 = min({r2, r3}) - max({l2, l3}) + 1;
com13 = max(0, com13);
com1 = max(0, com1);
com3 = max(0, com3);
ret = add(
ret, mul(com13, mul(dv(r3 - l3, r3 - l3 + 1), dv(r1 - l1, r1 - l1 + 1))));
ret = add(ret, mul(com1 - com13, dv(r1 - l1, r1 - l1 + 1)));
ret = add(ret, mul(com3 - com13, dv(r3 - l3, r3 - l3 + 1)));
ret = add(ret, r2 - l2 + 1 - (com13 + com1 + com3 - com13 - com13));
ret = dv(ret, r2 - l2 + 1);
return ret;
}
signed realMain() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> l[i];
}
for (int i = 1; i <= n; i++) {
cin >> r[i];
}
for (int i = 1; i <= n; i++) {
p[i] = pdif(l[i - 1], r[i - 1], l[i], r[i]);
}
int ciu = 0;
for (int i = 1; i <= n; i++) {
ret = add(ret, mul(p[i], ciu));
if (i - 1 >= 1) {
ciu = add(ciu, p[i - 1]);
ret = add(ret, pdif(l[i - 2], r[i - 2], l[i - 1], r[i - 1], l[i], r[i]));
}
}
ret = mul(ret, 2);
for (int i = 1; i <= n; i++) {
ret = add(ret, p[i]);
}
if (home) {
assert(ret == 116666753);
}
cout << ret << "\n";
return 0;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * f;
}
const long long maxn = 4e5 + 1e2;
struct Node {
long long pos, val;
};
long long l[maxn], r[maxn];
long long n, m;
long long a[maxn];
Node s[maxn];
long long top;
long long ans;
long long pos[maxn];
bool in(long long x, long long l, long long r) { return (x >= l) && (x <= r); }
signed main() {
n = read();
for (long long i = 1; i <= n; i++) a[i] = read(), pos[a[i]] = i;
l[1] = 1;
top = 1;
s[1].val = a[1];
s[1].pos = 1;
for (long long i = 2; i <= n; i++) {
while (top >= 1 && s[top].val <= a[i]) top--;
if (!top)
l[i] = 1;
else
l[i] = s[top].pos + 1;
s[++top].val = a[i];
s[top].pos = i;
}
r[n] = n;
top = 1;
s[1].val = a[n];
s[1].pos = n;
for (long long i = n - 1; i >= 1; i--) {
while (top >= 1 && s[top].val < a[i]) top--;
if (!top)
r[i] = n;
else
r[i] = s[top].pos - 1;
s[++top].val = a[i];
s[top].pos = i;
}
for (long long i = 1; i <= n; i++) {
long long mx = a[i];
if (i - l[i] < r[i] - i) {
for (long long j = l[i]; j < i; j++) {
if (in(pos[mx - a[j]], i, r[i])) ans++;
}
} else {
for (long long j = i + 1; j <= r[i]; j++) {
if (in(pos[mx - a[j]], l[i], i)) ans++;
}
}
}
cout << ans;
return 0;
}
| 11 | CPP |
import math
def powerseq(c, n):
add = 0
for i in range(n):
add += c**i
return add
n = int(input())
a = list(map(int, input().split()))
a.sort()
c1 = int(math.floor(pow(a[-1], 1/(n-1))))
c2 = int(math.ceil(pow(a[-1], 1/(n-1))))
s1 = 0
for i in range(n):
s1 += abs(a[i] - c1**i)
s2 = 0
for i in range(n):
s2 += abs(a[i] - c2**i)
if s1 < s2:
print(s1)
else:
print(s2)
| 8 | PYTHON3 |
t = int(input())
for i in range(t) :
n = int(input())
array = list(map(int, input().split(" ")))
array = sorted(array)
print(array[n] - array[n-1])
| 8 | PYTHON3 |
t=int(input())
p=0
for i in range(t):
n=input()
c=list(n)
if c[0]=="+":
p=p+1
elif c[0]=="-":
p=p-1
elif c[-1]=="+":
p=p+1
else:
if c[-1]=="-":
p=p-1
print(p)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = (1LL << 60) - 1;
const long long maxN = 1000001;
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) {
string s;
cin >> s;
if (((long long)(s).size()) < 2) {
cout << "YES"
<< "\n";
return 0;
}
map<char, long long> fre;
long long num = 1;
for (char c = 'A'; c <= 'Z'; ++c) {
fre[c] = num++;
}
long long chk = 0;
for (long long i = 2; i < ((long long)(s).size()); ++i) {
long long nn = fre[s[i]];
long long a = fre[s[i - 1]];
long long b = fre[s[i - 2]];
long long sum = a + b;
sum--;
if (sum > 26) {
sum = sum % 26;
}
if (nn == sum)
continue;
else
chk = 1;
}
if (chk) {
cout << "NO"
<< "\n";
} else
cout << "YES"
<< "\n";
}
}
| 12 | CPP |
# stdin = open('testdata.txt')
# def input():
# return stdin.readline().strip()
def sort(lst):
flag = 0
i = 1
while i < len(lst):
if(lst[i] > lst[i - 1]):
flag = 1
i += 1
if (not flag) :
return 1
else :
return 0
def solution(n, k, lst):
if len(lst) == 1 or len(lst) == 0:
print(-1)
return
while k > 0:
req_idx = -2
j = 0
for i in range(n-1):
if lst[i] < lst[i+1]:
lst[i] = lst[i] + 1
k = k - 1
break
if sort(lst) and k > 0:
print(-1)
return
elif k == 0:
print(i+1)
return
t = int(input())
for _ in range(t):
n, k= map(int,input().split())
lst = list(map(int, input().split()))
solution(n, k, lst)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, a[1000006], s[1000006], p[1000006], f[1000006], aib[1000006];
long long int rez = 0;
vector<int> v;
void normalizare() {
int i;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> a[i];
v.push_back(a[i]);
}
sort(v.begin(), v.end());
unique(v.begin(), v.end());
for (i = 1; i <= n; i++)
a[i] =
abs(std::distance(lower_bound(v.begin(), v.end(), a[i]), v.begin())) +
1;
}
long long query(int x) {
long long sum = 0;
while (x) {
sum += aib[x];
x = (x & (x - 1));
}
return sum;
}
void update(int x) {
while (x <= n) {
aib[x]++;
x = 2 * x - (x & (x - 1));
}
}
void solutie() {
int i;
for (i = 1; i <= n; i++) {
f[a[i]]++;
s[i] = f[a[i]];
}
memset(f, 0, sizeof(f));
for (i = n; i >= 1; i--) {
f[a[i]]++;
p[i] = f[a[i]];
}
for (i = n; i >= 1; i--) {
rez += query(s[i] - 1);
update(p[i]);
}
cout << rez;
}
int main() {
normalizare();
solutie();
return 0;
}
| 10 | CPP |
n = input()
n=int(n)
a = input().split(" ")
cubos=[]
caja=[]
res=[]
for i in range(len(a)):
cubos.append(int(a[i]))
m = max(cubos)
for i in range(m):
caja.append([])
for j in range(n):
caja[i].append(0)
j=0
for cubo in cubos:
tope=m-cubo
while(tope>=0 and tope<m):
caja[tope][j]=1
tope +=1
j+=1
def flip (a):
while(a>=0):
for i in range(m):
j=a
while (j<n-1): #i constante y j variable
if caja[i][j]==1 and caja[i][j+1] == 0:
caja[i][j] = 0
caja[i][j+1] = 1
j+=1 #siguiente columna
a-=1
flip(n-2)
for j in range(n):
cont=0
for i in range(m):
if caja[i][j]==1:
cont+=1
res.append(cont)
for i in res:
print(i, end=" ")
| 7 | PYTHON3 |
n = int(input())
nums = [int(x) for x in input().split()]
s = sum(nums)
if s % 3 != 0:
print(0)
else:
s = int(s / 3)
res = 0
pos = []
tmp = 0
for i in range (0, n):
pos.append(0)
for i in range (n - 1, -1, -1):
tmp += nums[i]
if tmp == s:
pos[i] = 1
for i in range (n - 2, -1, -1):
pos[i] += pos[i + 1]
tmp = 0
for i in range (0, n - 2):
tmp += nums[i]
if tmp == s:
res += pos[i + 2]
print(res) | 9 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K; cin >> N >> K;
cout << (int)(K * pow(K - 1, N - 1)) << endl;
} | 0 | CPP |
a=int(input())
for i in range(a):
c=int(input())
print(1,c-1)
| 7 | PYTHON3 |
#include<cstdio>
#include<algorithm>
#include<queue>
using namespace std;
typedef long long ll;
const int INF = 1000000000;
int prime[100000];
int primeNumber;
int d[1011][1011];
int xData[1030001];
int yData[1030001];
int p[1011][1011];
int dp[1000001];
bool used[1000001];
int m, n;
int main(){
prime[0] = 2;
primeNumber = 1;
for (int i = 3; i <= 1000000; i++) {
bool flag = true;
for (int j = 0; j < primeNumber; j++) {
if (i < prime[j] * prime[j]) break;
if (i % prime[j] == 0) {
flag = false;
break;
}
}
if (flag) prime[primeNumber++] = i;
}
int x = 505, y = 505; // 1(505, 505)
int counter = 2; // max move : counter / 2
int tempCounter = 1;
int moveDirection = 0; // right 0 up 1 left 2 down 3
for (int num = 1; num <= 1010000; num++) {
d[x][y] = num; xData[num] = x; yData[num] = y;
tempCounter--;
if (moveDirection == 0) x++;
if (moveDirection == 1) y--;
if (moveDirection == 2) x--;
if (moveDirection == 3) y++;
if (tempCounter == 0) {
counter++;
tempCounter = counter / 2;
moveDirection = (moveDirection + 1) % 4;
}
}
for (int i = 0; i < 1011; i++)
for (int j = 0; j < 1011; j++)
p[i][j] = 0;
for (int i = 0; i < primeNumber; i++)
p[xData[prime[i]]][yData[prime[i]]] = 1;
while (1) {
scanf("%d%d", &m, &n);
if (m == 0) break;
for (int i = 0; i < 1000001; i++)
dp[i] = -1;
for (int i = 0; i < 1000001; i++) used[i] = false;
queue<int> que;
que.push(n);
dp[n] = p[xData[n]][yData[n]];
int ans[2] = {0, 0};
if (dp[n] == 1) {
ans[0] = 1;
ans[1] = n;
}
while (!que.empty()) {
int z = que.front(); que.pop();
if (used[z]) continue;
used[z] = true;
for (int i = -1; i <= 1; i++) {
int x = xData[z] + i, y = yData[z] + 1;
int s = d[x][y];
if (s > m) continue;
if (dp[s] >= dp[z] + p[x][y]) continue;
dp[s] = dp[z] + p[x][y];
que.push(s);
if (ans[0] < dp[s]) {
ans[0] = dp[s];
if (p[x][y] == 1) ans[1] = s;
}
else if (ans[0] == dp[s] && ans[1] < s && p[x][y] == 1) ans[1] = s;
}
}
if (ans[0] == 0) ans[1] = 0;
printf("%d %d\n", ans[0], ans[1]);
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
signed main() {
int t = 1;
cin>>t;
while(t--) {
int n; cin>>n;
vector<int>v(n);
for(auto &z : v) cin>>z;
int x = v[0];
cout << "0 ";
for(int i = 1 ; i < n ; i++) {
int y=0;
for(int j = 0 ; j < 32 ; j++) {
if((x&(1<<j))) {
if(!(v[i]&(1<<j))) {
y|=(1<<j);
}
}
}
cout << y << " ";
x=v[i]^y;
}
cout << "\n";
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int inf = 9e18;
const long double pi = 2 * acos(0.0);
long long int t, n;
vector<long long int> arr, prr;
vector<vector<long long int>> brr, crr;
vector<bool> rec;
long long int power(long long int x, long long int y) {
long long int res = 1ll;
while (y > 0) {
if (y & 1) res = res * x;
y >>= 1;
x = x * x;
}
return res;
}
void solve() {
cin >> n;
crr.resize(n + 1), brr.resize(n - 2), rec.resize(n + 1, false);
;
for (int i = 0; i < n - 2; i++) brr[i].resize(3);
;
for (int i = 0; i < n - 2; i++) cin >> brr[i][0] >> brr[i][1] >> brr[i][2];
;
for (int i = 0; i < n - 2; i++) {
crr[brr[i][0]].push_back(brr[i][1]), crr[brr[i][0]].push_back(brr[i][2]);
crr[brr[i][1]].push_back(brr[i][0]), crr[brr[i][1]].push_back(brr[i][2]);
crr[brr[i][2]].push_back(brr[i][1]), crr[brr[i][2]].push_back(brr[i][0]);
}
long long int st;
;
for (int i = 1; i < n + 1; i++) {
if ((int)((crr[i]).size()) == 2) {
st = i;
break;
}
}
prr.push_back(st), rec[st] = true;
vector<long long int> drr(n + 1, 0);
drr[st] = 1;
vector<pair<long long int, long long int>> temp;
;
for (int i = 0; i < (int)((crr[st]).size()); i++) {
if (!rec[crr[st][i]]) {
temp.push_back(make_pair((int)((crr[crr[st][i]]).size()), crr[st][i]));
drr[crr[st][i]]++;
}
}
sort(temp.begin(), temp.end());
st = temp[0].second;
rec[st] = true, prr.push_back(st);
while ((int)((prr).size()) != n) {
vector<pair<long long int, long long int>> temp;
;
for (int i = 0; i < (int)((crr[st]).size()); i++) {
if (!rec[crr[st][i]]) {
temp.push_back(make_pair(drr[crr[st][i]], crr[st][i]));
drr[crr[st][i]]++;
}
}
sort(temp.rbegin(), temp.rend());
st = temp[0].second;
rec[st] = true, prr.push_back(st);
};
for (int i = 0; i < (int)((prr).size()); i++) cout << prr[i] << " ";
}
int32_t main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
t = 1;
while (t--) {
solve();
}
}
| 9 | CPP |
#include<iostream>
#include<vector>
using namespace std;
vector<int> par(100005,-1);
void initialize(int n){
for (int i=0;i<n;i++){
par[i]=i;
}
return;
}
int root(int x){
if (x==par[x]){
return x;
}else{
return par[x]=root(par[x]);
}
}
bool find(int x,int y){
return root(x)==root(y);
}
void uni(int x,int y){
x=root(x);
y=root(y);
if(x==y){
return;
}else{
par[x]=y;
}
}
int main(){
int n,m,q,i,j;
int s,t;
cin >> n >> m;
initialize(n);
for(i=0;i<m;i++){
cin >> s >> t;
uni(s,t);
}
cin >> q;
for (i=0;i<q;i++){
cin >> s >> t;
if (find(s,t)){
cout << "yes" <<endl;
}else{
cout << "no" <<endl;
}
}
return 0;
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long Inf = 4e18;
const long long K = 62;
void add_self(long long& x, long long y) { x = min(x + y, Inf); }
long long mul(long long x, long long y) {
if (!x || !y) return 0;
if (Inf / x < y) return Inf;
return x * y;
}
vector<vector<long long> > Zero(long long n, long long m) {
return vector<vector<long long> >(n, vector<long long>(m, 0));
}
vector<vector<long long> > Ident(long long n) {
vector<vector<long long> > Res = Zero(n, n);
for (long long i = 0; i < n; i++) Res[i][i] = 1;
return Res;
}
vector<vector<long long> > Multy(const vector<vector<long long> >& A,
const vector<vector<long long> >& B) {
assert(A[0].size() == B.size());
vector<vector<long long> > Res = Zero(A.size(), B[0].size());
for (long long i = 0; i < Res.size(); i++)
for (long long j = 0; j < Res[0].size(); j++)
for (long long k = 0; k < A[0].size(); k++)
add_self(Res[i][j], mul(A[i][k], B[k][j]));
return Res;
}
vector<vector<long long> > Power(const vector<vector<long long> >& A,
long long k) {
if (!k) return Ident(A.size());
if (k & 1) return Multy(A, Power(A, k - 1));
return Power(Multy(A, A), k >> 1);
}
const long long N = 200200;
long long a[N];
int main() {
long long n, k;
cin >> n >> k;
for (long long i = 0; i < n; i++) scanf("%I64d", a + i);
reverse(a, a + n);
while (!a[n - 1]) n--;
reverse(a, a + n);
for (long long i = 0; i < n; i++)
if (a[i] >= k) return cout << "0", 0;
if (n > 10) {
for (long long rep = 0;; rep++) {
for (long long i = 0; i < n; i++)
if (a[i] >= k) return cout << rep, 0;
for (long long i = 1; i < n; i++) add_self(a[i], a[i - 1]);
}
}
vector<vector<long long> > Base = Zero(1, n);
vector<vector<long long> > Trans[K];
for (long long i = 0; i < n; i++) Base[0][i] = a[i];
Trans[0] = Zero(n, n);
for (long long i = 0; i < n; i++)
for (long long j = i; j < n; j++) Trans[0][i][j] = 1;
for (long long r = 1; r < K; ++r)
Trans[r] = Multy(Trans[r - 1], Trans[r - 1]);
long long Ans = 0;
for (long long jump = K - 1; ~jump; jump--) {
vector<vector<long long> > Cur = Multy(Base, Trans[jump]);
bool ok = false;
for (long long i = 0; i < n; i++)
if (Cur[0][i] >= k) {
ok = true;
break;
}
if (ok) continue;
Ans += 1LL << jump;
Base = Cur;
}
cout << Ans + 1;
}
| 12 | CPP |
#include <bits/stdc++.h>
using namespace std;
void solutionB();
int main() {
ios_base::sync_with_stdio(false);
solutionB();
return EXIT_SUCCESS;
}
long long n;
struct point {
double x, y;
point(double x = 0, double y = 0) : x(x), y(y) {}
} p[1024];
inline double dist(const point& a, const point& b) {
double dx = a.x - b.x, dy = a.y - b.y;
return sqrt(dx * dx + dy * dy);
}
inline double length(const point& p) { return sqrt(p.x * p.x + p.y * p.y); }
inline point normalize(const point& p) {
double len = length(p);
assert(len > 1e-9);
return point(p.x / len, p.y / len);
}
point operator-(const point& a, const point& b) {
return point(a.x - b.x, a.y - b.y);
}
point operator+(const point& a, const point& b) {
return point(a.x + b.x, a.y + b.y);
}
point operator*(const point& p, float k) { return point(p.x * k, p.y * k); }
inline double cross(const point& a, const point& b) {
return a.x * b.y - a.y * b.x;
}
void solve() {
double r = dist(p[0], p[1]);
double l = 0.0;
for (long long i = 0; i < n; ++i) r = min(r, dist(p[i], p[(i + 1) % n]));
r -= 2 * 1e-9;
for (long long it = 0; it < 80; ++it) {
double mid = (l + r) / 2.0;
bool good = true;
for (long long i = 0; i < n; ++i) {
long long i1 = i, i2 = (i + 1) % n, i3 = (i + 2) % n;
point normal = normalize(p[i3] - p[i1]);
normal = point(-normal.y, normal.x);
point p1 = p[i1] + normal * mid;
point p2 = p[i2] - normal * mid;
point p3 = p[i3] + normal * mid;
if (cross(p2 - p1, p3 - p1) > 1e-9) good = false;
}
for (long long i = 0; i < n; ++i)
for (long long j = i + 1; j < n; ++j) {
double d = dist(p[i], p[j]);
if (d - 2.0 * mid < 1e-9) good = false;
}
if (good)
l = mid;
else
r = mid;
}
cout << fixed << setprecision(9) << r << '\n';
}
void solutionB() {
for (; cin >> n;) {
for (long long i = 0; i < n; ++i) cin >> p[i].x >> p[i].y;
solve();
cerr << endl;
}
}
| 8 | CPP |
t= int(input())
for _ in range(t):
n= int(input())
d={}
str="YES"
for i in range(n):
a= input()
for j in a:
if j in d:
d[j]+=1
else:
d[j]=1
for k in d:
if d[k]%n!=0:
str="NO"
else:
continue
print(str)
| 7 | PYTHON3 |
def solve():
x,y,n = map(int, input().split())
a = n%x
if(a==y):
return n
if(a>y):
return(n - (a-y))
else:
c = x-y
return (n - (a+c))
for _ in range(int(input())):
print(solve())
| 7 | PYTHON3 |
if __name__ == "__main__":
n, m = map(int, input().split())
ans = n
rem = 0
while n > 0:
rem += n % m
n = n // m
ans += n
if rem >= m:
ans += rem // m
n += rem // m
rem = rem % m
print(ans) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > bfs_graph_adj[1300000 + 9];
long long bfs_dis[1300000 + 9];
int bfs_color[1300000 + 9];
vector<int> bfs_queue[1300000 + 9];
vector<int> BFS_LEVEL_NODES;
void bfs_with_source_by_level(int source) {
int curr, i, child, siz, level, j, k, ind, first;
level = 0;
bfs_queue[0].push_back(source);
bfs_dis[source] = 0;
bfs_color[source] = 1;
while (!bfs_queue[level].empty()) {
ind = 0;
while (ind < bfs_queue[level].size()) {
BFS_LEVEL_NODES.clear();
first = bfs_queue[level][ind];
while (ind < bfs_queue[level].size() &&
bfs_dis[bfs_queue[level][ind]] == bfs_dis[first]) {
BFS_LEVEL_NODES.push_back(bfs_queue[level][ind]);
ind++;
}
for (j = 0; j < 10; j++) {
for (k = 0; k < BFS_LEVEL_NODES.size(); k++) {
curr = BFS_LEVEL_NODES[k];
siz = bfs_graph_adj[curr].size();
for (i = 0; i < siz; i++) {
child = bfs_graph_adj[curr][i].second;
if (bfs_graph_adj[curr][i].first == j) {
if (bfs_color[child] == 0) {
bfs_color[child] = 1;
bfs_dis[child] =
bfs_dis[curr] * 10 + bfs_graph_adj[curr][i].first;
bfs_dis[child] %= 1000000007;
bfs_queue[level + 1].push_back(child);
}
}
}
}
}
}
level++;
}
}
int main() {
int i, j, k, l, n, m = 0, tot, temp, curr, val, prev, a, b, c, t, ans, now,
flag, x, y, siz, w, h, d, ii, jj, xx, yy, ind, len, max_n,
q, s, f, g;
cin >> n >> m;
ind = n;
for (i = 1; i <= m; i++) {
cin >> j >> k;
curr = i;
vector<int> vec;
while (curr) {
vec.push_back(curr % 10);
curr /= 10;
}
reverse(vec.begin(), vec.end());
;
prev = j;
for (l = 0; l < vec.size(); l++) {
if (l < vec.size() - 1) {
ind++;
now = ind;
} else
now = k;
bfs_graph_adj[prev].push_back(make_pair(vec[l], now));
prev = now;
}
swap(j, k);
prev = j;
for (l = 0; l < vec.size(); l++) {
if (l < vec.size() - 1) {
ind++;
now = ind;
} else
now = k;
bfs_graph_adj[prev].push_back(make_pair(vec[l], now));
prev = now;
}
}
bfs_with_source_by_level(1);
for (i = 2; i <= n; i++) printf("%d\n", bfs_dis[i]);
}
| 12 | CPP |
N = int(input()) + 2
X = [0, 0] + list(map(int, input().split()))
dp = [[0, 0] for _ in range(N)]
for i in range(2, N):
if i%2:
dp[i][1] = max(dp[i-2][1] + X[i], dp[i-1][1])
dp[i][0] = max(dp[i-2][0] + X[i], dp[i-1][0])
else:
dp[i][1] = dp[i-2][1] + X[i]
if i!=2:
dp[i][0] = max(dp[i-2][0] + X[i], dp[i-1][1])
#print(dp)
if N%2:
print(dp[-1][0])
else:
print(dp[-1][1])
| 0 | PYTHON3 |
from sys import stdin, stdout
from math import floor, gcd, fabs, factorial, fmod, sqrt, inf, log
from collections import defaultdict as dd, deque
from heapq import merge, heapify, heappop, heappush, nsmallest
from bisect import bisect_left as bl, bisect_right as br, bisect
mod = pow(10, 9) + 7
mod2 = 998244353
def inp(): return stdin.readline().strip()
def iinp(): return int(inp())
def out(var, end="\n"): stdout.write(str(var)+"\n")
def outa(*var, end="\n"): stdout.write(' '.join(map(str, var)) + end)
def lmp(): return list(mp())
def mp(): return map(int, inp().split())
def smp(): return map(str, inp().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(m, val) for j in range(n)]
def remadd(x, y): return 1 if x%y else 0
def ceil(a,b): return (a+b-1)//b
def isprime(x):
if x<=1: return False
if x in (2, 3): return True
if x%2 == 0: return False
for i in range(3, int(sqrt(x))+1, 2):
if x%i == 0: return False
return True
# def find_arr(arr):
# print(arr)
# n = len(arr)
# if n<=1:
# return arr
# mn = min(arr)
# ind = arr.index(mn)
# l1 = [mn]*ind
# r1 = find_arr(arr[ind+1:])
# l2 = find_arr(arr[:ind])
# r2 = [mn]*(n-ind)
# if sum(l1)+mn+sum(r1)>sum(l2)+sum(r2):
# return l1+[mn]+r1
# else:
# return l2+r2
def solve(arr):
n = len(arr)
dp = l1d(n)
dp[0] = arr[0]
st = [0]
mn = arr[0]
for i in range(1, n):
while len(st)!=0 and arr[st[-1]]>=arr[i]:
st.pop()
if len(st)==0:
dp[i] = (i+1)*arr[i]
else:
dp[i] = dp[st[-1]]+(i-st[-1])*arr[i]
st.append(i)
return dp
n = iinp()
arr = lmp()
# print(*find_arr(arr))
dp1 = solve(arr)
dp2 = solve(list(reversed(arr)))
dp2.reverse()
mxind = 0
mx = dp1[0]+dp2[0]-arr[0]
for i in range(1, n):
x = dp1[i]+dp2[i]-arr[i]
if x>mx:
mxind = i
mx = x
ansl = l1d(n)
ansl[mxind] = arr[mxind]
mn = arr[mxind]
for i in range(mxind-1, -1, -1):
mn = min(arr[i], mn)
ansl[i] = mn
mn = arr[mxind]
for i in range(mxind+1, n):
mn = min(arr[i], mn)
ansl[i] = mn
print(*ansl)
| 9 | PYTHON3 |
n=int(input())
p=list(map(int,input().split()))
c=0
for i in range(1,n-1):
if sorted(p[i-1:i+2]).index(p[i])==1:
c+=1
print(c) | 0 | PYTHON3 |
n, h, m = map(int, input().split())
A = [h] * n
for i in range(m):
l, r, mh = map(int, input().split())
for i in range(l-1, r):
A[i] = min(A[i], mh)
ans = 0
for i in A:
ans += i**2
print(ans) | 7 | PYTHON3 |
S=int(input())
print(S//3600,S%3600//60,S%60,sep=":")
| 0 | PYTHON3 |
from functools import reduce
from math import sqrt, floor
def findFactors(n):
return list(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
n,x = map(int,input().split())
fac = sorted(findFactors(x))
final_fac = []
i = 0
j =len(fac)-1
while(i<j):
if fac[j] <= n:
final_fac.append(fac[i])
final_fac.append(fac[j])
j-=1
i+=1
c = len(final_fac)
if((sqrt(x)-floor(sqrt(x))) == 0 and int(sqrt(x))<=n):
c+=1
print(c) | 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[3], c, b;
cin >> a[0] >> a[1] >> a[2];
sort(a, a + 3);
c = a[2] - a[1];
b = a[1] - a[0];
cout << c + b;
}
| 7 | CPP |
#include <bits/stdc++.h>
const int mod = 998244353, g = 3, _g = 332748118, maxn = 1e6 + 9;
inline long long Pow(long long base, long long b) {
long long ret(1);
while (b) {
if (b & 1) ret = 1ll * ret * base % mod;
base = 1ll * base * base % mod;
b >>= 1;
}
return ret;
}
long long r[maxn];
inline long long Fir(long long n) {
long long limit(1), len(0), up(n << 1);
while (limit < up) {
limit <<= 1;
++len;
}
for (long long i = 0; i < limit; ++i)
r[i] = (r[i >> 1] >> 1) | ((i & 1) << len - 1);
return limit;
}
inline void NTT(long long *a, long long n, long long type) {
for (long long i = 0; i < n; ++i)
if (i < r[i]) std::swap(a[i], a[r[i]]);
for (long long mid = 1; mid < n; mid <<= 1) {
long long wn(Pow(type ? g : _g, (mod - 1) / (mid << 1)));
for (long long R = mid << 1, j = 0; j < n; j += R)
for (long long k = 0, w = 1; k < mid; ++k, w = w * wn % mod) {
long long x(a[j + k]), y(1ll * w * a[j + mid + k] % mod);
a[j + k] = 1ll * (x + y) % mod;
a[j + mid + k] = 1ll * (x - y + mod) % mod;
}
}
}
long long T[maxn], F[maxn], H[maxn], G[maxn], fac[maxn], fav[maxn], tmp[maxn],
sum[maxn], B[maxn];
inline long long Mul(long long n, long long *a, long long *b, long long *ans) {
long long limit(Fir(n));
NTT(a, limit, 1);
NTT(b, limit, 1);
for (long long i = 0; i < limit; ++i) ans[i] = 1ll * a[i] * b[i] % mod;
NTT(ans, limit, 0);
for (long long i = ((n - 1) << 1) + 1; i < limit; ++i) a[i] = b[i] = 0;
return Pow(limit, mod - 2);
}
inline void Solve(long long n, long long *a) {
if (!n) {
a[0] = 1;
return;
}
if (n == 1) {
a[1] = 1;
return;
}
long long len(n / 2);
Solve(len, a);
for (long long i = 0; i <= len; ++i) {
F[i] = 1ll * Pow(len, i) * fav[i] % mod;
H[i] = 1ll * fac[i] * a[i] % mod;
}
for (long long i = 0; i <= (len >> 1); ++i) std::swap(H[i], H[len - i]);
long long limit(Fir(len + 1));
for (long long i = len + 1; i < limit; ++i) F[i] = H[i] = 0;
NTT(F, limit, 1);
NTT(H, limit, 1);
for (long long i = 0; i < limit; ++i) G[i] = 1ll * F[i] * H[i] % mod;
NTT(G, limit, 0);
long long ty(Pow(limit, mod - 2));
for (long long i = 0; i <= len; ++i)
tmp[i] = 1ll * G[len - i] * ty % mod * Pow(fac[i], mod - 2) % mod;
long long val(Mul(len + 1, a, tmp, B));
for (long long i = 0; i <= (len << 1); ++i) a[i] = 1ll * B[i] * val % mod;
if (n & 1) {
for (long long i = 0; i < n; ++i) T[i] = a[i];
for (long long i = 1; i <= n; ++i)
a[i] = 1ll * (T[i - 1] + 1ll * (n - 1) * T[i] % mod) % mod;
}
}
inline long long Get_c(long long n, long long m) {
return 1ll * fac[n] * fav[m] % mod * fav[n - m] % mod;
}
long long n, a, b;
long long ans[maxn];
int main() {
scanf("%d%d%d", &n, &a, &b);
fac[0] = fac[1] = 1;
for (long long i = 2; i <= n; ++i) fac[i] = 1ll * fac[i - 1] * i % mod;
fav[n] = Pow(fac[n], mod - 2);
for (long long i = n; i >= 1; --i) fav[i - 1] = 1ll * fav[i] * i % mod;
Solve(n - 1, ans);
printf("%d\n", 1ll * ans[a + b - 2] * Get_c(a + b - 2, a - 1) % mod);
}
| 13 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double inf = 1e12;
const double inf2 = 9e11;
const int M = 1e5 + 5;
const double eps = 1e-4;
double a[M];
double b[M];
int main() {
int n, p;
cin >> n >> p;
double suma = 0, sumb = 0;
for (int i = 0; i < n; i++) {
scanf("%lf", &a[i]);
suma += a[i];
scanf("%lf", &b[i]);
sumb += b[i];
}
double t1, t2;
t1 = 0, t2 = inf;
while (t2 - t1 >= eps) {
double mid = (t2 + t1) / 2;
double csm = 0;
for (int i = 0; i < n; i++) {
csm += max(0.0, mid * a[i] - b[i]);
}
if (csm / mid < p) {
t1 = mid;
} else
t2 = mid;
}
if (t2 < inf2)
cout << t2;
else
cout << -1;
}
| 7 | CPP |
#include <bits/stdc++.h>
int n, m, k;
int col[1111];
int To[1111][1111], Tr[1111][1111], rev[1111], deg[1111], dep;
void adjust(int y, int A, int B) {
col[Tr[y][A]] = B;
int TP = To[y][A];
To[y][A] = To[y][B], To[y][B] = TP, TP = Tr[y][A], Tr[y][A] = Tr[y][B],
Tr[y][B] = TP;
if (To[y][B]) adjust(To[y][B], B, A);
}
void ins(int x, int y, int t) {
if (deg[x] % k == 0) rev[x] = ++dep;
if (deg[y] % k == 0) rev[y] = ++dep;
deg[x]++, deg[y]++, x = rev[x], y = rev[y];
register int i;
int A = 0, B = 0;
for (i = 1; i <= k; i++)
if (!(To[x][i] | To[y][i])) {
col[t] = i, To[x][i] = y, Tr[x][i] = t, To[y][i] = x, Tr[y][i] = t;
return;
}
for (i = 1; i <= k; i++)
if (!To[x][i]) A = i;
for (i = 1; i <= k; i++)
if (!To[y][i]) B = i;
adjust(y, A, B), col[t] = A, To[x][A] = y, Tr[x][A] = t, To[y][A] = x,
Tr[y][A] = t;
}
int main() {
scanf("%d%d%d", &n, &m, &k);
register int i;
for (i = 1; i <= n; i++) scanf("%*d");
for (i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y), ins(x, y + n, i);
}
for (i = 1; i <= m; i++) printf("%d\n", col[i]);
}
| 12 | CPP |
A,B=map(int,input().split())
print(sum(sorted([A,B,A-1,B-1])[-2:])) | 0 | PYTHON3 |
y=int(input())
st=str(y)
stl=list(st)
if y<0:
if len(st)>=3:
we=stl.pop()
tu=stl.pop()
if we>tu:
stl.append(tu)
else:
stl.append(we)
if stl[1]=="0":
print(0)
exit()
for i in range(len(stl)):
print(stl[i],end="")
exit()
if len(st)==2:
print(0)
exit()
else:
print(y)
| 7 | PYTHON3 |
a,b=input().split()
n=int(a)
k=int(b)-1
s=input().split()
s1=list(s)
L=[]
for i in s1:
sd=int(i)
L.append(sd)
sum=0
for i in range(n):
if (L[i]>=L[k])&(L[i]>0):
sum=sum+1
print(sum)
| 7 | PYTHON3 |
for Case in ' ' * int(input()):
x, y, k = map(int, input().split())
# a = [int(s) for s in map(int, input().split())]
print((y * k + k - 2) // (x - 1) + 1 + k)
| 7 | PYTHON3 |
def main():
c = int(input())
vals = [input().split() for v in range(c)]
res = False
for v in vals:
a,b,c = v
if int(b)>=2400 and int(c)>int(b):
res = True
print("YES" if res else "NO")
if __name__ == "__main__":
main()
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int a[100];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int m;
cin >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--;
int up = y - 1;
int down = a[x] - y;
a[x] = 0;
if (x > 0) {
a[x - 1] += up;
}
if (x < n - 1) {
a[x + 1] += down;
}
}
for (int i = 0; i < n; i++) {
cout << a[i] << endl;
}
}
| 7 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
int ans[200005];
int main() {
ios::sync_with_stdio(0);
long long l, r, x, y, k;
cin >> l >> r >> x >> y >> k;
while (x <= y) {
long long p = x * k;
if (p >= l && p <= r) {
cout << "YES\n";
return 0;
}
x++;
}
cout << "NO\n";
}
| 7 | CPP |
import sys
from collections import deque
n, q = map(int, input().split())
queues = {str(i): deque() for i in range(n)}
lines = sys.stdin.readlines()
for i in range(q):
query, *arg = lines[i].split()
if query == '0': # enqueue t x
queues[arg[0]].append(arg[1])
elif query == '1': # front
if len(queues[arg[0]]):
print(queues[arg[0]][0])
elif query == '2': # dequeue
if len(queues[arg[0]]):
queues[arg[0]].popleft()
else:
raise AssertionError
| 0 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int N = 1000005;
int m, n, cnt, head[N], pre[N], to[N];
vector<int> gg[N];
inline void addedge(int u, int v) {
pre[++cnt] = head[u];
head[u] = cnt;
to[cnt] = v;
}
bool vis[N], hav[N];
void dfs(int now) {
if (now == n + 1) return;
int i;
for (i = now; i <= n; i++)
if (!vis[i]) break;
if (i == n + 1) return;
vis[i] = 1;
int sz = gg[i].size();
for (int j = head[i]; j; j = pre[j]) vis[to[j]] = 1;
dfs(i + 1);
for (int j = 0; j < sz; j++)
if (hav[gg[i][j]]) return;
hav[i] = 1;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1, x, y; i <= m; i++) {
scanf("%d%d", &x, &y);
addedge(x, y);
gg[y].push_back(x);
}
dfs(1);
cnt = 0;
for (int i = 1; i <= n; i++) cnt += hav[i];
printf("%d\n", cnt);
for (int i = 1; i <= n; i++)
if (hav[i]) printf("%d ", i);
printf("\n");
return 0;
}
| 9 | CPP |
#include <iostream>
#include <string>
using namespace std;
int main()
{
for (;;)
{
string s;
cin >> s;
if (s == "-")
{
break;
}
int m;
cin >> m;
for (int i = 0; i < m; i++)
{
int h;
cin >> h;
string t = s.substr(h, s.length() - h) + s.substr(0, h);
s = t;
}
cout << s << endl;
}
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 5e3 + 10;
int n, dp[N][N], mod = 1e9 + 7;
char a[N];
int calc(int i, int f) {
if (f < 0) return 0;
if (i == n) return 1;
int &ret = dp[i][f];
if (ret != -1) return ret % mod;
if (a[i - 1] == 'f')
ret = 1LL * calc(i + 1, f + 1);
else
ret = (1LL * calc(i + 1, f) % mod + 1LL * calc(i, f - 1) % mod) % mod;
return ret % mod;
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf(" %c", &a[i]);
}
cout << calc(1, 0);
return 0;
}
| 9 | CPP |
n = int(input())
from collections import Counter
factors = []
i = 2
while n > 1:
if n < i * i:
factors.append(n)
break
while n % i == 0:
factors.append(i)
n //= i
i += 1
ans = 0
for cnt in Counter(factors).values():
i = 1
while cnt >= i:
cnt -= i
i += 1
ans += 1
print(ans)
| 0 | PYTHON3 |
for _ in range(int(input())):
n,x,m = map(int,input().split())
i,j = x,x
f = 0
for _ in range(m):
a,b = map(int,input().split())
if x>=a and x<=b and f==0:
f = 1
i = a
j = b
if f==1 and b<=j and b>=i:
i = min(i,a)
j = max(j,b)
elif f==1 and a<=j and a>=i:
i = min(i,a)
j = max(j,b)
elif f==1 and a<=i and b>=j:
i = min(a,i)
j = max(j,b)
print(j-i+1)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int nc, mc, c;
int n[100002];
int m[100002];
int cn[100002];
int Lowbit(int t) { return t & (t ^ (t - 1)); }
int Sum(int end) {
int sum = 0;
while (end > 0) {
sum += cn[end];
end -= Lowbit(end);
}
return sum;
}
int result(int j, int i) {
int m1;
int sum = 0;
for (m1 = i; m1 <= j; m1++) {
sum = sum + m[m1];
}
return sum;
}
void cinit(int pos) { cn[pos] = result(pos, pos - Lowbit(pos) + 1); }
int main() {
memset(m, 0, m[0]);
memset(n, 0, n[0]);
memset(cn, 0, cn[0]);
int i, j;
scanf("%d%d%d", &nc, &mc, &c);
for (i = 1; i <= nc; i++) {
scanf("%d", &n[i]);
n[i] = n[i] % c;
}
for (i = 1; i <= mc; i++) {
scanf("%d", &m[i]);
m[i] = m[i] % c;
cinit(i);
}
if ((nc - mc + 1) >= (mc)) {
for (i = 1; i <= mc; i++) {
n[i] = n[i] + Sum(i);
}
for (i = mc + 1; i <= nc - mc + 1; i++) {
n[i] = n[i] + Sum(mc);
}
for (i = nc - mc + 2, j = 1; i <= nc; i++, j++) {
n[i] = n[i] + Sum(mc) - Sum(j);
}
} else {
for (i = 1; i <= nc - mc + 1; i++) {
n[i] = n[i] + Sum(i);
}
for (i = nc - mc + 2, j = 1; i <= mc; i++, j++) {
n[i] = n[i] + Sum(i) - Sum(j);
}
for (i = mc + 1; i <= nc; i++, j++) {
n[i] = n[i] + Sum(mc) - Sum(j);
}
}
for (i = 1; i <= nc - 1; i++) {
n[i] = n[i] % c;
printf("%d ", n[i]);
}
printf("%d\n", n[nc] % c);
return 0;
}
| 10 | CPP |
R = lambda:map(int,input().split())
n,= R()
for i1 in range(n):
t = n // 2
for i2 in range(n-t):
print((n*i2)+i1+1,' ',end='')
for i2 in range(n-t,n):
print((n*i2)+n-i1,' ',end='')
print() | 9 | PYTHON3 |
for _ in range(int(input())):
n = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
min_a = min(a)
min_b = min(b)
cnt = 0
for i in range(n):
if (a[i] > min_a and b[i] > min_b):
cnt += max(a[i]-min_a, b[i]-min_b)
elif (a[i] > min_a):
cnt += a[i] - min_a
else:
cnt += b[i] - min_b
print(cnt) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e3 + 7;
const int INF = 1e9;
int s, k, n, m, x, y, p, q, c, d, a, b;
char ar[MAX][MAX];
int ans[MAX][MAX];
int ret[MAX][MAX];
int dx[] = {-1, 1, 0, 0};
int dy[] = {0, 0, -1, 1};
bool vis[MAX][MAX];
int dfs(int x, int y, int cnt) {
vis[x][y] = true;
for (int k = 0; k < 4; ++k) {
int p = x + dx[k];
int q = y + dy[k];
if (ar[p][q] == '.' && vis[p][q] == false &&
(p > 0 && q > 0 && p <= n && q <= m))
cnt += dfs(p, q, 0);
}
return cnt + ans[x][y];
}
void DFS(int x, int y, int cnt) {
ret[x][y] = cnt;
vis[x][y] = false;
for (int k = 0; k < 4; ++k) {
int p = x + dx[k];
int q = y + dy[k];
if (ar[p][q] == '.' && vis[p][q] == true &&
(p > 0 && q > 0 && p <= n && q <= m))
DFS(p, q, cnt);
}
return;
}
int MAIN() {
cin >> n >> m >> k;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) cin >> ar[i][j];
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j)
if (ar[i][j] == '*')
for (int k = 0; k < 4; ++k) {
int p = i + dx[k];
int q = j + dy[k];
if (ar[p][q] == '.' && (p > 0 && q > 0 && p <= n && q <= m))
ans[p][q]++;
}
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
if (ar[i][j] == '.' && ret[i][j] == 0) {
int an = dfs(i, j, 0);
DFS(i, j, an);
}
}
while (k--) {
cin >> a >> b;
cout << ret[a][b] << endl;
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
return MAIN();
}
| 10 | CPP |
'''
Auther: ghoshashis545 Ashis Ghosh
College: jalpaiguri Govt Enggineering College
'''
from os import path
import sys
from heapq import heappush,heappop
from functools import cmp_to_key as ctk
from collections import deque,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(input())
def si():return input().rstrip()
def mi():return map(int,input().split())
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
mod=1000000007
# mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('a')
file = 1
def solve():
# for _ in range(ii()):
n = ii()
a = li()
x = 0
for i in a:
x ^= i
if x and n%2==0:
print('NO')
return
print('YES')
if n%2==0:
n-=1
print(n-1)
for i in range(1,n-1,2):
print(1,i+1,i+2)
for i in range(1,n-1,2):
print(1,i+1,i+2)
if __name__ =="__main__":
if(file):
if path.exists('input.txt'):
sys.stdin=open('input.txt', 'r')
sys.stdout=open('output.txt','w')
else:
input=sys.stdin.readline
solve()
| 10 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int n, m, f[1100], a[3333], b[3333], l[3333], r[3333];
void init() {
scanf("%d%d", &n, &m);
for (int i = (1); i <= (m); ++i)
scanf("%d%d%d%d", &a[i], &b[i], &l[i], &r[i]);
}
int find(int t) {
if (f[t] == t) return t;
return f[t] = find(f[t]);
}
bool ok(int ll, int rr) {
for (int i = (1); i <= (n); ++i) f[i] = i;
for (int i = (1); i <= (m); ++i)
if (l[i] <= ll && r[i] >= rr) f[find(a[i])] = find(b[i]);
return find(1) == find(n);
}
void work() {
int ll, rr, k, gg = -1, ans = 0;
for (int i = (1); i <= (m); ++i) {
ll = 0;
rr = 1000000;
while (ll <= rr) {
k = (ll + rr) >> 1;
if (ok(l[i], l[i] + k))
gg = k + 1, ll = k + 1;
else
rr = k - 1;
}
if (gg != -1) ans = max(ans, gg);
}
if (ans)
printf("%d", ans);
else
puts("Nice work, Dima!");
}
int main() {
init();
work();
return 0;
}
| 10 | CPP |
#include <vector>
#include <cstdio>
int main(){
int N,L;
for(;scanf("%d%d",&N,&L),L;){
std::vector<std::pair<int,int> >v(N);
for(int i=0;i<N;i++){
char c;
scanf(" %c%d",&c,&v[i].second);
v[i].first=c=='L'?-1:1;
}
int rl,rr,f=1,t=0;
for(;f;t++){
rl=rr=f=0;
for(int i=0;i<N;i++)if(v[i].second!=0&&v[i].second!=L){
v[i].second+=v[i].first;
if(v[i].second==0)rl=i+1;
if(v[i].second==L)rr=i+1;
}
for(int i=0;i<N;i++)if(v[i].second!=0&&v[i].second!=L){
f=1;
for(int j=i+1;j<N;j++)if(v[i].second==v[j].second){
v[i].first*=-1;
v[j].first*=-1;
}
}
}
printf("%d %d\n",t,rl?rl:rr);
}
} | 0 | CPP |
arr=[0,1,1,2]
n=4*(10**5)+100
for i in range(4,n):
b=bin(i)[2:]
k=b.count('1')
arr.append(arr[i%k]+1)
#print(b,arr[i])
n=int(input())
z=input()
l=z.count('1')
l1=l+1
l2=l-1
ans1=0
ans2=0
for i in range(n):
if(z[i]=='1'):
u=pow(2,n-1-i,l1)
ans1=(ans1+u)%l1
if l2>0:
ans2=(ans2+pow(2,n-1-i,l2))%l2
for i in range(n):
if z[i]=='0':
p=ans1+pow(2,n-1-i,l1)
p%=l1
print(1+arr[p])
else:
if l2==0:
print(0)
else:
p=ans2-pow(2,n-1-i,l2)
p%=l2
print(1+arr[p])
| 0 | PYTHON3 |
n = int(input())
m = int(input())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
l = 0.0
r = 2e9
cnt = 0
while cnt < 100:
c = (l + r) / 2
w = c + m
f = True
for i in range(n):
w -= w / a[i]
if w < m:
f = False
break
w -= w / b[(i + 1) % n]
if w < m:
f = False
break
if f:
r = c
else:
l = c
cnt += 1
if r < 1.5e9:
print("%.10f" % r)
else:
print(-1)
| 9 | PYTHON3 |
from collections import deque
from itertools import product
def bfs(x, y):
dist = [[10 ** 9] * w for _ in range(h)]
dist[y][x] = 0
que = deque([(x, y)])
near = list(product(range(-2, 3), repeat=2))
while len(que) > 0:
x, y = que.popleft()
if (x, y) == (Dw - 1, Dh - 1):
return dist[y][x]
for dx, dy in near:
cnt = (abs(dx) + abs(dy) >= 2)
i, j = x + dx, y + dy
if (0 <= i < w and 0 <= j < h and
dist[j][i] > dist[y][x] + cnt and s[j][i] == '.'):
dist[j][i] = dist[y][x] + cnt
if cnt == 0:
que.appendleft((i, j))
elif cnt == 1:
que.append((i, j))
return -1
h, w = map(int, input().split())
Ch, Cw = map(int, input().split())
Dh, Dw = map(int, input().split())
s = [input() for _ in range(h)]
print(bfs(Cw - 1, Ch - 1))
| 0 | PYTHON3 |
import sys
def minp():
return sys.stdin.readline().strip()
def mint():
return int(minp())
def mints():
return map(int, minp().split())
def solve():
x0, y0, ax, ay, bx, by = mints()
xs, ys, t = mints()
c = 0
p = [(x0,y0)]
while True:
x0, y0 = x0 * ax + bx, y0 * ay + by
if abs(x0)+abs(y0) > 1e16*4:
c += 1
if c == 3:
break
else:
p.append((x0,y0))
n = len(p)
r = 0
for i in range(n):
x1, y1 = p[i]
d = abs(x1-xs)+abs(y1-ys)
if d <= t:
r = max(r, 1)
for j in range(i+1,n):
x2, y2 = p[j]
if abs(x2-x1)+abs(y2-y1) + d <= t:
r = max(r, j-i+1)
for j in range(i):
x2, y2 = p[j]
if abs(x2-x1)+abs(y2-y1) + d <= t:
r = max(r, i-j+1)
print(r)
solve()
#01
# 123 | 10 | PYTHON3 |
import sys
n = int(input())
a = list(map(int, input().split()))
ans = 0
for x in a:
ans = max(ans, min(x-1, 10**6-x))
print(ans) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1000000000000;
int main() {
long long n, m, k;
cin >> n >> m >> k;
vector<vector<long long>> v;
vector<long long> strc(n, 0), colc(m, 0), strt(n, 0), colt(m, 0);
v.resize(n);
for (long long i = 0; i < k; i++) {
long long a, q, w;
cin >> a >> q >> w;
q--;
if (a == 1) {
strt[q] = i;
strc[q] = w;
} else {
colt[q] = i;
colc[q] = w;
}
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
if (strc[i] == 0 && colc[j] == 0) cout << "0";
if (strc[i] == 0 && colc[j] != 0) cout << colc[j];
if (strc[i] != 0 && colc[j] == 0) cout << strc[i];
if (strc[i] != 0 && colc[j] != 0) {
if (strt[i] > colt[j])
cout << strc[i];
else
cout << colc[j];
}
cout << ' ';
}
cout << endl;
}
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005, INF = 9999999;
const long long P = 1e9 + 7;
template <typename T>
inline void read(T& first, char s = getchar()) {
first = 0;
while (s > '9' || s < '0') s = getchar();
while (s <= '9' && s >= '0') first = first * 10 + s - '0', s = getchar();
}
int main() {
int n;
puts("YES");
cin >> n;
for (int i = 1; i <= n; i++) {
int first, second;
scanf("%d%d%*d%*d", &first, &second);
first = abs(first), second = abs(second);
printf("%d\n", (((first & 1) << 1) | second & 1) + 1);
}
return 0;
}
| 8 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long mod = 1000000000 + 7;
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<long long> mario;
for (int i = 0; i < n; i++) {
long long x;
cin >> x;
mario.push_back(x);
}
sort(mario.rbegin(), mario.rend());
long long update = 10e17;
long long ans = 0;
for (int i = 0; i < mario.size(); i++) {
update = min(update - 1, mario[i]);
ans += max(update, (long long)0);
}
cout << ans;
return 0;
}
| 8 | CPP |
from math import log2
n=int(input())
p=0
l=[]
while not log2(n+1).is_integer():
p+=2
k=int(log2(n))
l.append(k+1)
tam=2**k
kalan=n-2**k
n-=(2*kalan)
if log2(n).is_integer():
p-=1
break
print(p)
if l:
print(*l) | 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline T bigmod(T p, T e, T M) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % M;
p = (p * p) % M;
}
return (T)ret;
}
template <class T>
inline T gcd(T a, T b) {
if (b == 0) return a;
return gcd(b, a % b);
}
template <class T>
inline T modinverse(T a, T M) {
return bigmod(a, M - 2, M);
}
template <class T>
inline T bpow(T p, T e) {
long long int ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p);
p = (p * p);
}
return (T)ret;
}
int toInt(string s) {
int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
int toLlint(string s) {
long long int sm;
stringstream ss(s);
ss >> sm;
return sm;
}
struct D {
int h, w;
};
int n;
D a[1005];
int main() {
int t, i, j, k, sm, mx;
long long int rs = (LLONG_MAX / 10LL);
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d%d", &a[i].w, &a[i].h);
}
for (i = 1; i < 1001; i++) {
mx = i;
priority_queue<int> q;
int w = 0, x = 0;
for (j = 0; j < n; j++) {
if (a[j].w > mx && a[j].h > mx) {
break;
}
if (a[j].h > mx) {
x++;
w += a[j].h;
} else {
w += a[j].w;
if (a[j].w <= a[j].h || a[j].w > mx) continue;
q.push(a[j].w - a[j].h);
}
}
if (j < n) continue;
x = n / 2 - x;
if (x < 0) continue;
while (!q.empty()) {
x--;
if (x < 0) break;
w -= q.top();
q.pop();
}
rs = min(rs, (long long int)mx * (long long int)w);
}
printf("%lld\n", rs);
return 0;
}
| 8 | CPP |
m,n,a =map(int,input().split())
if m%a ==0 and n%a ==0:
i = m//a * n//a
print(i)
elif m%a !=0 and n%a !=0:
j =(m//a+1)*(n//a+1)
print(j)
else:
k=(m//a)*(n//a+1)
print(k)
| 7 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n, k; cin >> n >> k;
set<string> r;
for(int i = 0; i < n; i++){
string s; cin >> s;
r.insert(s);
}
map<char, int> cnt;
for(auto e : r) cnt[e[0]]++;
int op = r.size() / k;
while(op > 0){
int sum = 0;
for(auto e : cnt) sum += min(op, e.second);
sum = sum / k;
if(sum < op) op--;
else break;
}
cout << op << endl;
return 0;
}
| 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 100002, LG = 19;
int n, m, q;
bool vis[N];
vector<int> g[N], g2[N];
int T[N], P[N][LG], L[N];
set<pair<int, int> > edges;
void dfs(int x, int level) {
vis[x] = true;
for (int i = 0; i <= ((int)(g2[x]).size()) - 1; ++i) {
int child = g2[x][i];
if (!vis[child]) {
T[child] = x;
L[child] = level + 1;
dfs(child, level + 1);
}
}
}
void chRoot(int root) {
T[root] = root;
L[root] = 1;
memset(vis, 0, sizeof vis);
dfs(root, 1);
for (int i = 1; i <= n; ++i)
for (int j = 0; (1ll << j) < n; j++) P[i][j] = -1;
for (int i = 1; i <= n; ++i) P[i][0] = T[i];
for (int j = 1; (1ll << j) < n; j++)
for (int i = 1; i <= n; ++i)
if (P[i][j - 1] != -1) P[i][j] = P[P[i][j - 1]][j - 1];
}
int query(int p, int q) {
if (L[p] < L[q]) swap(p, q);
int log;
for (log = 1; (1ll << log) <= L[p]; log++)
;
log--;
int ret = 0;
for (int i = log; i >= 0; --i)
if (L[p] - (1ll << i) >= L[q]) p = P[p][i], ret += 1 << i;
if (p == q) return ret;
for (int i = log; i >= 0; i--)
if (P[p][i] != -1 && P[p][i] != P[q][i])
p = P[p][i], q = P[q][i], ret += 2 << i;
return ret + 2 - edges.count({p, q});
}
int main() {
scanf("%d%d%d", &n, &m, &q);
for (int i = 1; i <= m; ++i) {
int x, y;
scanf("%d%d", &x, &y);
g[x].push_back(y);
g[y].push_back(x);
edges.insert({x, y});
edges.insert({y, x});
}
queue<int> Q;
Q.push(1);
vis[1] = true;
while (((int)(Q).size())) {
int i = Q.front();
Q.pop();
for (int j : g[i])
if (!vis[j]) {
vis[j] = true;
Q.push(j);
g2[i].push_back(j);
g2[j].push_back(i);
}
}
chRoot(1);
while (q--) {
int x, y;
scanf("%d%d", &x, &y);
printf("%d\n", query(x, y));
}
}
| 8 | CPP |
for i in range(int(input())):
a, b, c, d=map(int, input().split())
print(max(a*(b-d-1),a*d, b*(a-c-1),b*c)) | 7 | PYTHON3 |
n = int(input())
nums = list(map(int, input().split()))
nums.sort()
if n > 50:
print(sum(nums)-n)
exit(0)
def cal(x):
cur = 1
ans = 0
for i in range(n):
ans += abs(cur-nums[i])
cur *= x
return ans
out = 10000000000000000
for j in range(1, int(nums[-1]**(1/(n-1)))+1000):
c = cal(j)
if c < out:
out = c
print(out)
| 8 | PYTHON3 |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100011;
int pre[maxn << 2];
int sub[maxn << 2];
int n;
int a[maxn];
void PushUp(int* seg, int rt) { seg[rt] = seg[rt << 1] + seg[rt << 1 | 1]; }
void build(int* seg, int l, int r, int rt) {
if (l == r) {
seg[l] = 0;
return;
}
int m = (l + r) >> 1;
build(seg, l, m, rt << 1);
build(seg, m + 1, r, rt << 1 | 1);
}
void update(int* seg, int p, int c, int l, int r, int rt) {
if (l == r) {
seg[rt] += c;
return;
}
int m = (l + r) >> 1;
if (p <= m)
update(seg, p, c, l, m, rt << 1);
else
update(seg, p, c, m + 1, r, rt << 1 | 1);
PushUp(seg, rt);
}
int query(int* seg, int L, int R, int l, int r, int rt) {
if (L <= l && r <= R) {
return seg[rt];
}
int m = (l + r) >> 1;
int ans = 0;
if (L <= m) ans += query(seg, L, R, l, m, rt << 1);
if (R > m) ans += query(seg, L, R, m + 1, r, rt << 1 | 1);
return ans;
}
int main() {
std::ios_base::sync_with_stdio(false);
long long k;
cin >> n >> k;
vector<int> v;
for (int i = 1; i <= n; i++) {
cin >> a[i];
v.push_back(a[i]);
}
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
for (int i = 1; i <= n; i++)
a[i] = lower_bound(v.begin(), v.end(), a[i]) - v.begin() + 1;
int m = v.size() + 1;
build(pre, 1, m, 1);
build(sub, 1, m, 1);
long long cur = 0;
for (int i = 1; i <= n; i++) {
cur += (long long)query(pre, a[i] + 1, m, 1, m, 1);
update(pre, a[i], 1, 1, m, 1);
}
long long ans = 0;
update(pre, a[n], -1, 1, m, 1);
update(sub, a[n], 1, 1, m, 1);
for (int l = n - 1, r = n; l >= 1; l--) {
while (r <= n && cur > k) {
update(sub, a[r], -1, 1, m, 1);
cur -= (long long)query(pre, a[r] + 1, m, 1, m, 1);
if (a[r] > 1) cur -= (long long)query(sub, 1, a[r] - 1, 1, m, 1);
r++;
}
ans += n + 1 - r;
update(pre, a[l], -1, 1, m, 1);
cur -= (long long)query(pre, a[l] + 1, m, 1, m, 1);
if (a[l] > 1) cur -= (long long)query(sub, 1, a[l] - 1, 1, m, 1);
while (r > l - 1 + 1 && cur <= k) {
r--;
update(sub, a[r], 1, 1, m, 1);
cur += (long long)query(pre, a[r] + 1, m, 1, m, 1);
if (a[r] > 1) cur += (long long)query(sub, 1, a[r] - 1, 1, m, 1);
}
}
cout << ans << endl;
return 0;
}
| 11 | CPP |
def main():
N = int(input())
A = tuple(int(input()) for _ in [0] * N)
players = [1, 2]
spectating = 3
for i in A:
if i in players:
loser = players[0] ^ players[1] ^ i
players = [i, spectating]
spectating = loser
else:
print('NO')
break
else:
print('YES')
main()
| 7 | PYTHON3 |
n,m=map(lambda x:int(x),input().split())
num=input()
list=[int(x) for x in num.split()]
list.sort()
lastword=[]
for i in range(m):
if list[i]>0:
break
else:
lastword.append(list[i])
print(-sum(lastword))
| 8 | PYTHON3 |
#include<iostream>
#include<cstdio>
#include<cstdlib>
using namespace std;
const int mod=998244353;
int n,m,a[310][310];
int od[310],ev[310],bit[310],xxj[310];
int main()
{
cin>>n>>m;
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++)
cin>>a[i][j],a[i][j]&=1;
/* if(n<m)
{
for(int i=1;i<=n;i++)
for(int j=i+1;j<=m;j++)
swap(a[i][j],a[j][i]);
swap(n,m);
}
*/
/* for(int i=1;i<=n;i++,puts(""))
for(int j=1;j<=m;j++)
printf("%d ",a[i][j]);
*/
int u=max(n,m);
od[1]=1;ev[1]=3;
for(int i=2;i<=u;i++)
{
od[i]=(ev[i-1]+3ll*od[i-1]%mod)%mod;
ev[i]=(od[i-1]+3ll*ev[i-1]%mod)%mod;
}
int cnt=0;
/* for(int i=1;i<=u;i++)
{
int p=i;
for(int j=i+1;j<=u;j++)
if(a[i][i]<a[j][i]) p=j;
if(p!=i) swap(a[p],a[i]);
if(!a[i][i]) continue;
cnt++;
for(int j=i+1;j<=u;j++)
if(a[j][i])
for(int k=i;k<=u;k++)
a[j][k]^=a[i][k];
}
*/
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
if(a[i][j])
{
if(xxj[j])
for(int k=j;k<=m;k++)
a[i][k]^=a[xxj[j]][k];
else {xxj[j]=i;cnt++;break;}
}
}
bit[0]=1;
for(int i=1;i<=u;i++) bit[i]=2ll*bit[i-1]%mod;
int bs=1ll*bit[n-cnt]*bit[m-cnt]%mod;
printf("%lld\n",1ll*od[cnt]*bs%mod);
}
| 0 | CPP |
r=int(input())
if(r%2==1 and r>3):
print(f'1 {int((r-3)/2)}')
else:
print("NO") | 7 | PYTHON3 |
s = input()
t = input()
flag = 0
res = list()
"""def test(res,s,t):
if res>s and res<t:
return 1
else:
return 0
for i in range(len(s)):
if s[i]==t[i]:
res+=s[i]
elif ord(t[i])-ord(s[i])>=1:
res+=chr(ord(s[i])+1)
elif ord(t[i])-ord(s[i])==1:
res+=s[i]
flag = 1
if i==len(s)-1 and flag==1:
res+=t[i]
if test(res,s,t):
print(res)
quit()
else:
print('No such string')
quit()
if len(res)!=len(s):
print('No such string')
quit()
if res==s or res==t:
print('No such string')
quit()
print(res)"""
def test(res,s,t):
if res>s and res<t:
return 1
else:
return 0
for k in range(len(s)):
res.append(s[k])
i = len(s)-1
while i>=0:
if s[i]=='z':
res[i]='a'
if ord(s[i])+1<=122:
res[i] = (chr(ord(s[i])+1))
if i<=len(s)-1:
for k in range(i+1,len(s)):
res[k]='a'
break
i-=1
if test(''.join(map(str,res)),s,t):
print(''.join(map(str,res)))
else:
print('No such string') | 7 | PYTHON3 |
#include <cstdio>
#include <iostream>
#include <map>
#include <string>
using namespace std;
typedef struct{
string product;
int num;
string stuff[100];
}recipe;
int n, m;
map<string, long> mp; //普通に買うときの値段
recipe r[100];
long rec(string a){
long ret=0;
int p=-1;
//合成可能か
bool find=false;
for(int i=0; i<m; ++i){
if(r[i].product==a){
find=true;
p=i;
break;
}
}
if( !find ) ret=mp[a]; //無理だった
else{
for(int i=0; i<r[p].num; ++i){
ret+=rec(r[p].stuff[i]);
}
ret=min(ret, mp[a]);
}
return ret;
}
int main(){
while(1){
//入力
scanf(" %d", &n);
if(n==0) break;
for(int i=0; i<n; ++i){
string s;
long p;
cin >> s >> p;
mp[s]=p;
}
scanf(" %d", &m);
for(int i=0; i<m; ++i){
cin >> r[i].product;
cin >> r[i].num;
for(int j=0; j<r[i].num; ++j) cin >> r[i].stuff[j];
}
string want;
cin >> want;
//処理
printf("%ld\n", rec(want));
}
} | 0 | CPP |
#include <bits/stdc++.h>
using namespace std;
char s1[100100], s2[5][100100], num[5];
void solve() {
int i, j, k, n, t, p, p2, len, f12, f13, f14, f23, f24, f34, T;
scanf("%d%d", &n, &k);
memset(num, 0, sizeof(num));
bool flag = true;
for (T = 1; T <= n; T++) {
for (t = 1; t <= 4; t++) {
scanf("%s", s1);
len = strlen(s1);
p = k;
for (i = len; i >= 1 && p > 0; i--) {
s2[t][len - i] = s1[i - 1];
if (s1[i - 1] == 'a' || s1[i - 1] == 'e' || s1[i - 1] == 'i' ||
s1[i - 1] == 'o' || s1[i - 1] == 'u')
p--;
}
s2[t][len - i] = '\0';
if (p > 0) flag = false;
}
f12 = strcmp(s2[1], s2[2]);
f13 = strcmp(s2[1], s2[3]);
f14 = strcmp(s2[1], s2[4]);
f23 = strcmp(s2[2], s2[3]);
f24 = strcmp(s2[2], s2[4]);
f34 = strcmp(s2[3], s2[4]);
if (f12 == 0 && f34 == 0 && f13 == 0)
num[1] = num[1] + 1;
else if (f12 == 0 && f34 == 0)
num[2] = num[2] + 1;
else if (f13 == 0 && f24 == 0)
num[3] = num[3] + 1;
else if (f14 == 0 && f23 == 0)
num[4] = num[4] + 1;
else
flag = false;
}
int ans = 0;
for (i = 2; i <= 4; i++)
if (num[i] != 0) ans++;
if (ans > 1) flag = false;
if (!flag)
printf("NO\n");
else {
if (num[2] != 0)
printf("aabb\n");
else if (num[3] != 0)
printf("abab\n");
else if (num[4] != 0)
printf("abba\n");
else
printf("aaaa\n");
}
}
int main() { solve(); }
| 7 | CPP |
Subsets and Splits