text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, x, y, max = 0;
cin >> n >> c;
cin >> y;
for (int i = 1; i < n; i++) {
cin >> x;
if (y - x > 0 && y - x > max) max = y - x;
y = x;
}
if (max > c)
cout << max - c << endl;
else
cout << 0 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool primes[10000001];
int main() {
ios_base::sync_with_stdio(0), cin.tie(0);
int n, c, x;
cin >> n >> c;
cin >> x;
int maxdiff = 0, y;
for (int i = 1; i < n; i++) {
cin >> y;
maxdiff = max(maxdiff, x - y);
x = y;
}
if (maxdiff <= c)
cout << 0 << endl;
else
cout << maxdiff - c << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[100];
int n, c;
cin >> n >> c;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int maxx = 0;
for (int i = 0; i < n - 1; i++) {
if (a[i] >= c) maxx = max(maxx, a[i] - a[i + 1] - c);
}
cout << maxx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
int s[n], a, i, j, b;
a = 0, b = 0;
for (i = 0; i < n; i++) {
cin >> s[i];
if (i > 0) {
a = s[i - 1] - s[i] - c;
if (a > b) {
b = a;
}
}
}
cout << b << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[121];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int N, c, ans = 0;
cin >> N >> c;
for (int i = 1; i <= N; i++) {
cin >> arr[i];
}
for (int i = 1; i < N; i++) {
ans = max(arr[i] - c - arr[i + 1], ans);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 100224;
int n, c, a[maxN];
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
cin >> n >> c;
int ans = 0;
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i > 0) {
ans = max(ans, -a[i] + a[i - 1] - c);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, c;
cin >> n >> c;
long long arr[n];
for (long long i = 0ll; i < n; i++) {
cin >> arr[i];
}
long long diff = 0;
for (long long i = 0; i < n - 1; i++) {
long long rec = arr[i] - arr[i + 1];
if (rec > diff) {
diff = rec;
}
}
if (diff - c < 0)
cout << "0";
else
cout << diff - c;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a, b, c[101], d[101], mx = -1e9, cnt;
int main() {
cin >> a >> b;
for (int i = 1; i <= a; ++i) {
cin >> c[i];
}
for (int i = 1; i < a; ++i) {
d[i] = c[i] - c[i + 1] - b;
}
for (int i = 1; i <= a; ++i) {
mx = max(d[i], mx);
}
cout << mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, d;
cin >> n >> d;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int maxi = INT_MIN;
for (int i = 1; i < n; i++) {
maxi = max(maxi, a[i - 1] - a[i] - d);
}
if (maxi < 0)
cout << "0";
else
cout << maxi;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int *arr;
int d, c, t = 0;
cin >> d >> c;
arr = new int[d];
for (int z = 0; z < d; z++) cin >> arr[z];
for (int z = 0; z < d - 1; z++) {
if (arr[z] > arr[z + 1]) {
t = max(t, arr[z] - (arr[z + 1] + c));
}
}
cout << t;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
int r_max = 0;
int temp, pre;
cin >> pre;
for (int i = 0; i < n - 1; ++i) {
cin >> temp;
r_max = max(r_max, pre - temp - c);
pre = temp;
}
cout << r_max << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace ::std;
int a[110], n, c, i, j, o, m;
int main() {
cin >> n >> c;
cin >> a[0];
for (i = 1; i < n; i++) {
cin >> a[i];
m = max(a[i - 1] - a[i] - c, m);
}
cout << m;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, c, a[110], maxn, maxx;
inline void Init() {
scanf("%d%d", &n, &c);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
}
inline void solve() {
Init();
for (int i = 1; i <= n - 1; i++) {
int tmp = a[i] - c - a[i + 1];
maxn = max(maxn, tmp);
}
printf("%d\n", maxn);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 0xff;
long long n, c, x[N], answer;
void smx(long long &a, const long long &b) {
if (a < b) {
a = b;
}
}
int32_t main() {
cin >> n >> c;
for (long long i = 0; i < n; ++i) {
cin >> x[i];
if (i) {
smx(answer, x[i - 1] - x[i] - c);
}
}
cout << answer << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
int last, current;
cin >> last;
int max_profit = 0;
for (int i = 1; i < n; i++) {
cin >> current;
max_profit = max(max_profit, last - current - c);
last = current;
}
cout << max_profit << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
vector<int> k(n);
int max = 0;
for (int i = 0; i < n; i++) {
cin >> k[i];
if (i > 0) {
max = std::max(k[i - 1] - k[i] - c, max);
}
}
cout << max << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = (long long)1e9 + 7;
int main() {
ios_base ::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, c;
cin >> n >> c;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int mx = 0;
for (int i = 1; i < n; i++) {
mx = max(mx, (v[i - 1] - v[i] - c));
}
cout << mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
int d[n];
for (int i = 0; i < n; i++) cin >> d[i];
int a[n - 1];
for (int i = 0; i < n - 1; i++) {
if ((d[i] - d[i + 1] - c) > 0) {
a[i] = (d[i] - d[i + 1] - c);
} else
a[i] = 0;
}
int max = a[0];
for (int i = 0; i < n - 1; i++) {
max = ((a[i]) > (max) ? (a[i]) : (max));
}
cout << max;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, min = 101, p = 0;
cin >> n >> c;
int a[n];
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++) {
p = max(p, a[i] - a[i + 1] - c);
}
cout << p;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return (a * b) / gcd(a, b); }
int divisors(int n) {
int cnt = 0;
for (int x = 1; x * x <= n; x++) {
if (n % x == 0) {
cnt++;
if (n / x != x) cnt++;
}
}
return cnt;
}
void solve() {
int n, c;
cin >> n >> c;
int arr[n];
int m = 0;
int x;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 1; i < n; i++) {
m = max(arr[i - 1] - arr[i] - c, m);
}
cout << m << endl;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[101], an = 0, n, x;
scanf("%d%d", &n, &x);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n - 1; i++) an = max(a[i] - a[i + 1] - x, an);
printf("%d\n", an);
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = (int)1e6 + 123;
const double eps = 1e-6;
const long long INF = 1000000000000000000ll;
using namespace std;
int n, c, a[200];
int main() {
cin >> n >> c;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
int ans = 0;
for (int i = 1; i < n; i++) {
int cur = a[i];
if (cur >= a[i + 1]) {
cur -= a[i + 1];
if (cur >= c) {
cur -= c;
ans = max(ans, cur);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, ans(0);
cin >> n >> c;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
int i = 0;
while (i < n - 1) {
int q = (a[i] - a[i + 1]) - c;
ans = max(ans, q);
i++;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n;
int k;
cin >> n >> k;
int arr[n];
cin >> arr[0];
int tp[n - 1];
int max = 0;
for (int i = 1; i < n; i++) {
cin >> arr[i];
int temp = arr[i - 1] - arr[i];
if (temp > max) {
max = temp;
}
}
if (max - k >= 0) {
cout << max - k;
} else
cout << "0";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int MAXSHORT = 0x7fff;
int main() {
int n, c;
cin >> n >> c;
int best = 0, k, last = -1;
for (int i = 0; i < (int)(n); ++i) {
cin >> k;
best = max(last - k - c, best);
last = k;
}
cout << best << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, i;
cin >> n >> c;
int a, b;
cin >> a;
int maxdiff = 0, diff;
for (i = 0; i < n - 1; ++i) {
cin >> b;
diff = a - b;
if (diff > maxdiff) {
maxdiff = diff;
}
a = b;
}
if (maxdiff - c > 0)
cout << maxdiff - c << endl;
else
cout << 0 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100 + 10;
int x[MaxN];
int main() {
int n, c;
cin >> n >> c;
for (int i = 0; i < n; ++i) cin >> x[i];
int mx = 0;
for (int i = 0; i < n - 1; ++i) mx = max(mx, x[i] - x[i + 1] - c);
cout << mx;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, c, ans = 0;
int a[105];
int main() {
cin >> n >> c;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 1; i < n; i++)
if (a[i] - a[i + 1] > ans) ans = a[i] - a[i + 1];
ans = ans - c;
if (ans > 0)
cout << ans << endl;
else
cout << "0\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[105];
int main(int argc, char **argv) {
ios::sync_with_stdio(0);
int n, c, d, maxi = 0;
cin >> n >> c;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
if ((a[i] - a[i + 1]) > maxi) maxi = a[i] - a[i + 1];
}
if ((maxi - c) < 0) return cout << 0, 0;
cout << maxi - c;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, d = 0;
cin >> n >> c;
int a[n];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) d = max(d, a[i] - a[i + 1] - c);
cout << d;
}
|
#include <bits/stdc++.h>
int binarySearch(int arr[], int l, int r, int x) {
if (r >= l) {
int mid = l + (r - l) / 2;
if (arr[mid] == x) return mid;
if (arr[mid] > x) return binarySearch(arr, l, mid - 1, x);
return binarySearch(arr, mid + 1, r, x);
}
return -1;
}
int cmpi(const void *a, const void *b) {
return ((const int *)a)[0] - ((const int *)b)[0];
}
int cmp(const void *a, const void *b) { return *(int *)a - *(int *)b; }
int max(int a, int b) {
if (a >= b)
return a;
else
return b;
}
int main() {
int n, c, b[1000001], tmp = 0;
scanf("%d %d", &n, &c);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
for (int i = 0; i < n - 1; i++) {
tmp = max(b[i] - b[i + 1] - c, tmp);
}
printf("%d\n", tmp);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, min1 = -9999, b;
cin >> n >> c;
int a[n + 1];
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n - 1; i++) {
b = a[i] - c - a[i + 1];
if (b < 0)
continue;
else {
min1 = max(min1, b);
}
}
if (min1 == -9999)
cout << 0 << endl;
else
cout << min1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int d, m;
int maxP = 0;
scanf("%d%d", &d, &m);
vector<int> days(d, 0);
for (int i = 0; i < d; i++) {
scanf("%d", &days[i]);
}
for (int i = 0; i < (d - 1); i++) {
if (days[i] - days[i + 1] - m > maxP) {
maxP = days[i] - days[i + 1] - m;
}
}
printf("%d", maxP);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, c;
cin >> n >> c;
vector<int> v(n);
for (int i = 0; i < n; i++) {
cin >> v[i];
}
int max_diff = INT_MIN;
for (int i = 0; i < n - 1; i++) {
if (v[i] - v[i + 1] > max_diff) max_diff = v[i] - v[i + 1];
}
int profit = max_diff - c;
if (profit > 0)
cout << profit << "\n";
else
cout << 0 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, c, arr[102], mx;
int main() {
scanf("%d %d", &n, &c);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
for (int i = 0; i < n - 1; i++) {
mx = max(arr[i] - arr[i + 1] - c, mx);
}
printf("%d\n", mx);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int n, c, max = 0, t;
scanf("%d%d", &n, &c);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n - 1; i++) {
t = a[i] - c;
if (t < 0)
continue;
else {
t -= a[i + 1];
if (t > max) max = t;
}
}
printf("%d\n", max);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, i, k[100] = {0};
int x[100], c;
int d, ans = 0;
int main() {
scanf("%d", &n);
scanf("%d", &c);
for (i = 0; i < n; i++) {
scanf("%d", &x[i]);
}
for (i = 0; i < n; i++) {
k[i] = x[i] - x[i + 1];
}
for (i = 0; i < n - 1; i++) {
ans = max(ans, k[i]);
}
if (ans - c < 0) {
printf("0");
} else {
printf("%d", ans - c);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int days, rentPrice, currDayPrice = 0, afterCurrDayPrice = 0, minus,
prices[100];
minus = 0;
cin >> days >> rentPrice;
for (int i = 1; i < days + 1; i++) {
cin >> prices[i];
}
for (int i = 1; i < days + 1; i++) {
if (i == days) break;
int diff = prices[i] - prices[i + 1];
if (diff > minus) {
minus = diff;
currDayPrice = prices[i];
afterCurrDayPrice = prices[i + 1];
}
}
int earn = (currDayPrice - afterCurrDayPrice) - rentPrice;
if (((currDayPrice + afterCurrDayPrice) == 0) &&
((currDayPrice - afterCurrDayPrice) < rentPrice))
earn = 0;
cout << ((earn > 0) ? earn : 0);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, pp, pro = 0;
cin >> n >> pp;
vector<int> dp(n);
for (int i = 0; i < n; i++) cin >> dp[i];
for (int i = 0; i < n - 1; i++) {
if (dp[i] - dp[i + 1] - pp > pro) pro = dp[i] - dp[i + 1] - pp;
}
cout << pro;
return 0;
}
|
#include <bits/stdc++.h>
const int MAXN = 110;
using namespace std;
int arr[MAXN];
int main() {
int n, c;
cin >> n >> c;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
int ans = 0;
for (int i = 0; i < n - 1; i++) {
ans = max(ans, arr[i] - arr[i + 1] - c);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, diff, max;
cin >> n >> c;
int arr[n];
for (int i = 0; i < n; i++) cin >> arr[i];
for (int i = 0; i < n - 1; i++) {
if (i == 0) {
diff = max = arr[i] - arr[i + 1];
} else {
diff = arr[i] - arr[i + 1];
if (diff > max) max = diff;
}
}
if (max - c >= 0)
cout << max - c;
else
cout << 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[100005], b[100005], c[100005], n, kq, m, d[100005], k;
string s;
int main() {
cin >> n >> k;
for (int i = 1; i <= n; i++) cin >> a[i];
for (int i = 2; i <= n; i++) kq = max(kq, a[i - 1] - a[i] - k);
cout << kq;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[101] = {0};
int main() {
int n, c, k, ans = 0;
cin >> n >> c;
for (int i = 0; i < n; i++) {
cin >> k;
arr[i] = k;
if (i >= 1) ans = max(arr[i - 1] - arr[i], ans);
}
ans -= c;
if (ans < 0) ans = 0;
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long double PI = acosl(-1);
bool compare_int(int a, int b) { return (a > b); }
bool compare_string(string a, string b) { return a.size() < b.size(); }
bool compare_pair(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second < b.second);
}
long long int fact(long long int n) {
if (n == 0 || n == 1)
return 1;
else
return n * fact(n - 1);
}
bool check(int n) {
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
int32_t main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, c, x;
cin >> n >> c;
vector<int> a;
for (int i = 0; i < n; i++) cin >> x, a.push_back(x);
int ans = INT_MIN;
for (int i = 0; i < n - 1; i++) {
x = a[i] - a[i + 1];
ans = max(ans, x);
}
if (ans - c < 0)
cout << 0 << endl;
else
cout << ans - c << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[105];
int main() {
int n, c, ans = 0;
scanf("%d%d", &n, &c);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n - 1; i++) {
ans = max(a[i] - a[i + 1] - c, ans);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int prices[105];
int n, m, ans = 0, last = 0, temp;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> prices[i];
}
for (int i = 0; i < n - 1; i++) {
ans = max(ans, (prices[i] - prices[i + 1]) - m);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
int x[n];
for (int i = 0; i < n; i++) cin >> x[i];
int ans = 0;
for (int i = 0; i < n - 1; i++) {
int diff = x[i] - x[i + 1] - c;
ans = max(ans, diff);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
int arr[n];
int max = 0;
int min = INT_MAX;
for (int i = 0; i < n; i++) {
cin >> arr[i];
}
for (int i = 1; i < n; i++) {
if (arr[i - 1] - arr[i] - c > max) {
max = arr[i - 1] - arr[i] - c;
}
}
cout << max << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
bool debug = 1;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
long long ln, lk, lm;
int a[105];
int main() {
scanf("%d%d", &n, &m);
for (int(i) = 1; (i) <= (int)(n); (i)++) scanf("%d", a + i);
for (int(i) = 1; (i) <= (int)(n - 1); (i)++) {
k = max(k, a[i] - a[i + 1]);
}
k -= m;
printf("%d\n", max(k, 0));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a[1001], b, c, d[501], maxn = 0;
cin >> b >> c;
for (int i = 1; i <= b; i++) {
cin >> a[i];
}
for (int i = 1; i <= b - 1; i++) {
d[i] = a[i] - a[i + 1];
if (d[i] > maxn) {
maxn = d[i];
}
}
if (maxn > 0 && maxn - c > 0) {
cout << maxn - c << endl;
} else
cout << 0 << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:500000000")
using namespace std;
int main() {
int n, c, i;
cin >> n >> c;
vector<int> a(n);
for (i = 0; i < n; i++) cin >> a[i];
int res = 0;
for (i = 0; i + 1 < n; i++) res = max(res, a[i] - a[i + 1] - c);
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int in() {
int x = 0, c;
for (; (unsigned long long)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -in();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned long long)((c = getchar()) - '0') < 10);
return x;
}
long long in64() {
long long x = 0, c;
for (; (unsigned long long)((c = getchar()) - '0') >= 10;) {
if (c == '-') return -in();
if (!~c) throw ~0;
}
do {
x = (x << 3) + (x << 1) + (c - '0');
} while ((unsigned long long)((c = getchar()) - '0') < 10);
return x;
}
void out(int n) {
char buf[33];
int i = 30;
if (n < 0) putchar('-'), n = -n;
do {
buf[i--] = '0' + n % 10;
n /= 10;
} while (n);
while (i < 30) putchar(buf[++i]);
}
void out64(long long n) {
char buf[55];
int i = 50;
if (n < 0) putchar('-'), n = -n;
do {
buf[i--] = '0' + n % 10;
n /= 10;
} while (n);
while (i < 50) putchar(buf[++i]);
}
void readArray(int array1[], int len) {
for (int i = 0; i < len; i++) {
array1[i] = in();
}
}
void read2Array(int array1[], int array2[], int len) {
for (int i = 0; i < len; i++) {
array1[i] = in();
array2[i] = in();
}
}
int main() {
int dayNow, dayPre = 0, maxi = 0;
int n = in();
int c = in();
for (int i = (0), _b = (n); i < _b; i++) {
dayNow = in();
maxi = max(maxi, dayPre - dayNow);
dayPre = dayNow;
}
cout << max(0, maxi - c);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, c, max = 0;
cin >> n >> c;
int x[n];
for (int i = 0; i < n; i++) {
cin >> x[i];
}
for (int i = 0; i < n - 1; i++) {
int temp = x[i] - x[i + 1] - c;
if (temp > max) max = temp;
}
cout << max;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, diff = 0, max = 0, a[100];
cin >> n >> c;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < n - 1; i++) {
diff = a[i] - a[i + 1];
if (diff > max) {
max = diff;
}
}
if (max - c >= 0) {
cout << max - c;
} else {
cout << 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sum, d, z, mn = 1000000000, mx = -1000000000, ans, k, pos, l = 1, x,
y, r = 1, n, m, xc, yc;
map<int, int> mp;
bool ok;
int main() {
cin >> n >> x;
int a[n];
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 1; i < n; ++i) {
if (a[i] - x < a[i - 1]) {
if (a[i - 1] - a[i] - x > r - l) r = a[i - 1], l = a[i] + x;
}
}
cout << r - l;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, price;
scanf("%d %d", &n, &price);
vector<int> honey;
for (int i = 0; i < n; i++) {
int c;
scanf("%d", &c);
honey.push_back(c);
}
int answ = 0;
for (int i = 0; i < n - 1; ++i) {
answ = max(answ, honey[i] - honey[i + 1] - price);
}
printf("%d", answ);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, sum = 0, max = 0;
scanf("%d %d", &a, &b);
for (int i = 0; i < a; ++i) {
scanf("%d", &c);
if (i < a) sum = sum - c;
if (sum > max) {
max = sum;
}
sum = c;
}
max = max - b;
if (max > 0)
printf("%d\n", max);
else
printf("%s\n", "0");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, arr[100], max, i, c;
cin >> n;
cin >> c;
for (i = 0; i < n; i++) {
cin >> arr[i];
}
max = arr[0] - arr[1];
for (i = 0; i < (n - 1); i++) {
if ((arr[i] - arr[i + 1]) > max) {
max = arr[i] - arr[i + 1];
}
}
if (max >= c) {
cout << (max - c);
} else
cout << "0";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int ans = 0;
int n, c;
cin >> n >> c;
int x[101];
for (int i = 0; i < n; i++) {
cin >> x[i];
}
for (int i = 0; i < n - 1; i++) {
if (x[i] - x[i + 1] > ans) ans = x[i] - x[i + 1];
}
if (ans - c > 0)
cout << ans - c;
else
cout << 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, l = 0;
cin >> n >> c;
int a[n];
{
for (int i = 0; i < n; i++) {
cin >> a[i];
if (i == 1) {
l = a[0] - a[1];
}
if (i >= 2 && (a[i - 1] - a[i] > l)) {
l = a[i - 1] - a[i];
}
}
l = l - c;
if (l <= 0)
cout << "0" << endl;
else
cout << l;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char* argv[]) {
int n, c;
cin >> n >> c;
int val;
vector<int> x;
for (int i = 0; i < n; ++i) {
cin >> val;
x.push_back(val);
}
int res = 0;
for (int i = 0; i < x.size() - 1; ++i) {
int cost = x[i];
if (cost < x[i + 1]) continue;
cost -= x[i + 1];
if (cost < c) continue;
cost -= c;
res = max(res, cost);
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int days, c;
int max, pos;
int diff;
cin >> days >> c;
int arr[days];
for (int i = 0; i < days; i++) cin >> arr[i];
max = 0;
for (int i = 0; i < days - 1; i++) {
diff = arr[i] - arr[i + 1];
if (max < diff) {
max = diff;
}
}
if (max - c <= 0)
cout << 0;
else {
cout << max - c;
}
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, c, honey[1005], profit, max, i;
while (scanf("%d%d", &n, &c) != EOF) {
max = 0;
for (i = 0; i < n; i++) scanf("%d", &honey[i]);
for (i = 0; i < n - 1; i++) {
profit = honey[i] - honey[i + 1] - c;
if (max < profit) max = profit;
}
printf("%d\n", max);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, x[105], m = 0;
x[0] = 0;
scanf("%d%d", &n, &c);
for (int i = 1; i <= n; ++i) {
scanf("%d", &x[i]);
m = max(m, x[i - 1] - x[i]);
}
printf("%d", max(0, m - c));
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
int diff = 0;
int ar[n];
for (int i = 0; i < n; i++) {
cin >> ar[i];
}
for (int i = 1; i < n; i++) {
if (ar[i - 1] - ar[i] > diff) diff = ar[i - 1] - ar[i];
}
if (diff >= c)
cout << diff - c;
else
cout << 0;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, c, max = 0;
scanf("%d%d", &n, &c);
int ar[n];
for (int i = 0; i < n; i++) scanf("%d", &ar[i]);
for (int i = 0; i < n - 1; i++) {
if (ar[i] >= ar[i + 1]) {
if (ar[i] - ar[i + 1] - c > max) max = ar[i] - ar[i + 1] - c;
}
}
printf("%d", max);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
cin >> n >> k;
int a[n];
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int maxdiff = k;
for (int i = 1; i < n; i++) {
int diff = a[i - 1] - a[i];
if (diff > maxdiff) {
maxdiff = diff;
}
}
cout << maxdiff - k;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, x[100], ans = 0;
cin >> n >> c;
for (int i = 0; i < n; i++) {
cin >> x[i];
if (i != 0 && x[i - 1] - x[i] - c > ans) ans = x[i - 1] - x[i] - c;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, max = 0;
int arr[100];
cin >> n >> c;
for (int i = 0; i < n; i++) {
cin >> arr[i];
if (i == 1) {
max = arr[0] - arr[1] - c;
}
if (arr[i - 1] - arr[i] - c > max) {
max = arr[i - 1] - arr[i] - c;
}
}
if (max <= 0)
cout << 0;
else
cout << max;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
int x[101];
scanf("%d%d", &n, &c);
for (int i = 0; i < n; i++) {
scanf("%d", &x[i]);
}
int maxm = x[0] - x[1];
for (int i = 1; i < n - 1; i++) {
maxm = max(x[i] - x[i + 1], maxm);
}
maxm -= c;
if (maxm > 0)
printf("%d\n", maxm);
else
printf("0\n");
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c;
cin >> n >> c;
vector<int> v1, v2;
;
for (int i = 0; i < n; i++) {
int j;
cin >> j;
v1.push_back(j);
}
for (int i = 0; i < n - 1; i++) {
v2.push_back(v1[i] - v1[i + 1] - c);
}
sort(v2.begin(), v2.end());
int j = (v2.back() > 0) ? (v2.back()) : 0;
cout << j;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6;
int a[N];
int main() {
int n, c;
cin >> n >> c;
for (int i = 0; i < n; i++) cin >> a[i];
int ma = -1;
for (int i = 0; i < n - 1; i++)
if (a[i] - a[i + 1] - c > ma) ma = a[i] - a[i + 1] - c;
cout << max(ma, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int d, n;
cin >> d >> n;
int arr[101] = {0}, arr2[101] = {0};
for (int i = 0; i < d; i++) cin >> arr[i];
for (int i = 1; i < d; i++) {
arr2[i] = arr[i - 1] - arr[i];
}
sort(arr2, arr2 + d);
int var = (arr2[d - 1] - n);
if (var <= 0) {
cout << "0" << endl;
return 0;
} else
cout << var << endl;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int arr[10000], n, c;
scanf("%d %d", &n, &c);
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
int max = -1;
for (int i = 0; i < n - 1; i++) {
if (arr[i] - arr[i + 1] - c > max) {
max = arr[i] - arr[i + 1] - c;
}
}
if (max == -1) max = 0;
printf("%d\n", max);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, c, ans = 0;
cin >> n >> c;
vector<int> v;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
v.push_back(a);
}
for (int i = 0; i < n - 1; i++) {
if (v[i] - v[i + 1] - c > ans) ans = v[i] - v[i + 1] - c;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e9;
const long long mod = 1e9 + 7;
const double eps = 1e-8;
const long long MAX = 1e7 + 20;
template <class T>
T gcd(T a, T b) {
return (b != 0 ? gcd<T>(b, a % b) : a);
}
template <class T>
T lcm(T a, T b) {
return (a / gcd<T>(a, b) * b);
}
const int N = 200200;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long a, b, c, d;
cin >> a >> b;
vector<long long> v;
for (int i = 0; i < a; i++) {
cin >> c;
v.push_back(c);
}
vector<long long> v1;
for (int i = 0; i < a - 1; i++) {
if (v[i] >= v[i + 1]) {
v1.push_back(v[i] - v[i + 1] - b);
}
}
sort(v1.begin(), v1.end());
if (v1.size() == 0 || v1[v1.size() - 1] < 0) {
cout << 0 << endl;
return 0;
}
cout << v1[v1.size() - 1] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
stack<int> v;
int n, k, i, ma, a;
cin >> n >> k;
ma = 0;
for (i = 1; i <= n; i++) {
if (i != 1) {
cin >> a;
if (v.top() - a > ma) ma = v.top() - a;
v.push(a);
} else {
cin >> a;
v.push(a);
}
}
if (ma - k >= 0) {
ma = ma - k;
cout << ma << endl;
} else
cout << 0 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
int visit[111111];
vector<int> v[111111], mark[111111];
int dfs(int t) {
vector<int> v1;
int i;
for (i = 0; i < v[t].size(); i++) {
int u = v[t][i];
if (visit[mark[t][i]] == 0) {
visit[mark[t][i]] = 1;
int w = dfs(u);
if (w == 0)
v1.push_back(u);
else
printf("%d %d %d\n", t, u, w);
}
}
while (v1.size() > 1) {
printf("%d %d %d\n", v1[v1.size() - 1], t, v1[v1.size() - 2]);
v1.pop_back();
v1.pop_back();
}
if (v1.size() == 1)
return v1[0];
else
return 0;
}
int main() {
memset(visit, 0, sizeof(visit));
scanf("%d%d", &n, &m);
int i;
for (i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
v[a].push_back(b);
v[b].push_back(a);
mark[a].push_back(i);
mark[b].push_back(i);
}
if (m % 2)
printf("No solution\n");
else {
for (i = 1; i <= n; i++) dfs(i);
}
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC optimization("unroll-loops")
const int mod = 1000000007;
const int inf = 1000000009;
const long long INF = 1000000000000000009;
const long long big = 1000000000000000;
const long double eps = 0.000000000000000000001;
using namespace std;
struct triple {
int a, b, c;
};
vector<triple> W;
bool O[100005], B[100005];
vector<int> P[100005];
int L[100005];
void dfs(int n, int p) {
O[n] = 1;
vector<int> A;
for (auto v : P[n]) {
if (!O[v]) {
L[v] = L[n] + 1;
dfs(v, n);
if (!B[v]) A.push_back(v);
} else if (v != p && L[v] > L[n])
A.push_back(v);
}
int s = A.size();
for (int i = 1; i < s; i += 2) W.push_back({A[i - 1], n, A[i]});
if ((int)s % 2 == 1) {
W.push_back({A[s - 1], n, p});
B[n] = 1;
}
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, m;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int a, b;
cin >> a >> b;
P[a].push_back(b);
P[b].push_back(a);
}
if (m % 2 != 0) {
cout << "No solution";
return 0;
}
dfs(1, 0);
for (auto v : W) cout << v.a << " " << v.b << " " << v.c << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
int first[maxn], nxt[maxn << 1], vv[maxn << 1];
bool vis[maxn];
int mark[maxn];
int edge[maxn];
void dfs(int n, int fa) {
vis[n] = true;
for (int e = first[n]; e; e = nxt[e])
if (vv[e] != fa && !vis[vv[e]]) dfs(vv[e], n);
int top = 0;
for (int e = first[n]; e; e = nxt[e])
if (vv[e] != fa && mark[vv[e]] != 1) edge[top++] = vv[e];
if (top & 1)
edge[top++] = fa, mark[n] = 1;
else
mark[n] = 2;
for (int i = 0; i < top; i += 2) {
printf("%d %d %d\n", edge[i], n, edge[i + 1]);
if (mark[edge[i]] == 2) mark[edge[i]] = 1;
if (mark[edge[i + 1]] == 2) mark[edge[i + 1]] = 1;
}
}
int main() {
int e = 1;
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
nxt[e] = first[u], vv[e] = v, first[u] = e++;
nxt[e] = first[v], vv[e] = u, first[v] = e++;
}
if (m & 1)
puts("No solution");
else
dfs(1, 0);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int n, m;
unordered_set<int> g[N];
void print(int u, int v, int w) { printf("%d %d %d\n", u, v, w); }
int dfs(int v) {
vector<int> adj;
vector<int> unpaired;
for (auto u : g[v]) {
adj.push_back(u);
g[u].erase(v);
}
g[v].clear();
for (auto u : adj) {
int w = dfs(u);
if (w == 0) {
unpaired.push_back(u);
} else {
print(v, u, w);
}
}
while (unpaired.size() >= 2) {
int u = unpaired.back();
unpaired.pop_back();
int w = unpaired.back();
unpaired.pop_back();
print(u, v, w);
}
if (unpaired.empty()) return 0;
return unpaired.back();
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0, a, b; i < m; ++i) {
scanf("%d%d", &a, &b);
g[a].insert(b);
g[b].insert(a);
}
if (m & 1) {
puts("No solution");
return 0;
}
dfs(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
const int N = 100 * 1000 + 20;
map<pair<int, int>, int> e;
vector<int> gr[N];
int mark[N], par[N];
vector<pair<int, pair<int, int> > > ans;
void getInput() {
cin >> n >> m;
if (m % 2 == 1) {
cout << "No solution";
exit(0);
}
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
x--, y--;
gr[x].push_back(y), gr[y].push_back(x);
}
return;
}
void dfs(int v, int par) {
mark[v] = 1;
for (auto u : gr[v]) {
if (!mark[u]) {
dfs(u, v);
}
}
vector<int> rtr;
for (auto u : gr[v]) {
if (!e[{u, v}] and u != par) {
rtr.push_back(u);
e[{u, v}] = e[{v, u}] = 1;
}
}
if (rtr.size() % 2 == 1) {
rtr.push_back(par);
e[{par, v}] = e[{v, par}] = 1;
}
for (int i = 0; i < rtr.size(); i += 2) {
ans.push_back({rtr[i], {v, rtr[i + 1]}});
}
return;
}
int main() {
getInput();
dfs(0, 0);
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first + 1 << " " << ans[i].second.first + 1 << " "
<< ans[i].second.second + 1 << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
vector<int> g[N + 100];
vector<pair<pair<int, int>, int> > ans;
int vis[N + 100];
int dfs(int v, int par) {
vis[v] = 1;
vector<int> tmp;
for (auto it : g[v]) {
if (!vis[it]) {
int f = dfs(it, v);
if (f) {
ans.push_back(make_pair(make_pair(v, it), f));
} else {
tmp.push_back(it);
}
} else {
if (it != par && vis[it] == 1) tmp.push_back(it);
}
}
int ret = 0;
if ((int)tmp.size() % 2) {
ret = tmp.back();
tmp.pop_back();
}
for (int sz = tmp.size(), i = 0; i < sz; i += 2) {
ans.push_back(make_pair(make_pair(tmp[i], v), tmp[i + 1]));
}
vis[v] = 2;
return ret;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++) {
int a, b;
scanf("%d%d", &a, &b);
g[a].push_back(b);
g[b].push_back(a);
}
if (m % 2) {
printf("No solution\n");
} else {
dfs(1, 0);
for (auto it : ans) {
printf("%d %d %d\n", it.first.first, it.first.second, it.second);
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
vector<tuple<int, int, int> > ans;
vector<int> e[100005];
int dep[100005];
int gao(int x, int src) {
dep[x] = dep[src] + 1;
vector<int> u;
for (int y : e[x])
if (y != src) {
if (!dep[y]) {
int z = gao(y, x);
if (!z)
u.push_back(y);
else
ans.push_back(tuple<int, int, int>(x, y, z));
} else if (dep[y] < dep[x]) {
u.push_back(y);
}
}
for (size_t i = 0; i + 1 < u.size(); i += 2)
ans.push_back(tuple<int, int, int>(u[i], x, u[i + 1]));
if (u.size() % 2) return u.back();
return 0;
}
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
e[x].push_back(y);
e[y].push_back(x);
}
if (gao(1, 0)) {
puts("No solution");
} else
for (tuple<int, int, int> c : ans) {
int x, y, z;
tie(x, y, z) = c;
printf("%d %d %d\n", x, y, z);
}
}
|
#include <bits/stdc++.h>
using namespace std;
set<int> a[1000001];
long n, m;
bool used[1000001] = {0};
void dfs(int v = 0, int pre = 0) {
used[v] = 1;
set<int>::iterator it;
set<int> RT;
RT = a[v];
for (it = RT.begin(); it != RT.end(); it++)
if (!used[*it]) dfs(*it, v);
if ((a[v].size()) % 2 == 1) {
a[v].erase(pre);
}
bool f = 0;
for (it = a[v].begin(); it != a[v].end(); it++) {
a[*it].erase(v);
if (!f)
cout << (*it) << ' ' << v << ' ', f = 1;
else
f = 0, cout << (*it) << endl;
}
}
int main() {
cin >> n >> m;
long s = 0;
if (m % 2 == 1) {
cout << "No solution";
return 0;
}
for (int k = 1; k <= m; ++k) {
long x, y;
cin >> x >> y;
a[x].insert(y);
a[y].insert(x);
}
dfs(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int to, nx;
} e[200050];
int head[200050];
int num = 0;
bool bo[200050];
void addedge(int x, int y) {
e[num].to = y;
e[num].nx = head[x];
head[x] = num++;
}
bool ok[200050];
int gao(int now) {
ok[now] = true;
queue<int> q;
for (int p = head[now]; p != -1; p = e[p].nx) {
if (!bo[p]) {
q.push(e[p].to);
bo[p] = bo[p ^ 1] = true;
}
}
queue<int> p;
while (!q.empty()) {
int u = q.front();
q.pop();
int w = gao(u);
if (w != 0)
printf("%d %d %d\n", w, u, now);
else
p.push(u);
}
while (p.size() >= 2) {
int u, v;
u = p.front();
p.pop();
v = p.front();
p.pop();
printf("%d %d %d\n", u, now, v);
}
if (!p.empty())
return p.front();
else
return 0;
}
int main() {
int i, j, k, n, m;
num = 0;
memset(head, -1, sizeof(head));
memset(ok, 0, sizeof(ok));
memset(bo, 0, sizeof(bo));
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
addedge(x, y);
addedge(y, x);
}
if (m % 2)
printf("No solution\n");
else {
gao(1);
}
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
template <class T>
T gcd(T a, T b) {
return a ? gcd(b % a, a) : b;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T sign(T a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const int dxK[] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int dyK[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int dxKn[] = {-2, -1, 1, 2, 2, 1, -1, -2};
const int dyKn[] = {1, 2, 2, 1, -1, -2, -2, -1};
const int N = int(2e6) + 9;
const int M = int(2e2) + 9;
const int LOGN = 22;
const int SQN = 350;
const int MOD = int(1e9) + 7;
const int INF = 1e9 + 100;
const long long INF64 = 2e18;
const long double PI = 3.1415926535897932384626433832795;
const long double EPS = 1e-9;
int n, m;
vector<pair<int, int> > g[N];
bool u[N], ue[N];
pair<int, int> e[N];
int a[N], b[N], c[N], szres;
void add(int v, int u) {
for (int i = 0; i < (int)(2); ++i) {
swap(e[v].first, e[v].second);
for (int j = 0; j < (int)(2); ++j) {
swap(e[u].first, e[u].second);
if (e[u].first == e[v].first) {
a[szres] = e[u].second;
b[szres] = e[u].first;
c[szres] = e[v].second;
++szres;
return;
}
}
}
assert(false);
}
int dfs(int v) {
u[v] = true;
int cur = -1;
for (int i = 0; i < (int)((int)(g[v].size())); ++i) {
int to = g[v][i].first, id = g[v][i].second;
if (ue[id]) continue;
ue[id] = true;
if (u[to]) {
if (cur == -1)
cur = id;
else
add(cur, id), cur = -1;
} else {
int cur2 = dfs(to);
if (cur2 != -1)
add(cur2, id);
else {
if (cur == -1)
cur = id;
else
add(cur, id), cur = -1;
}
}
}
return cur;
}
void solve() {
cin >> n >> m;
for (int i = 0; i < (int)(m); ++i) {
cin >> e[i].first >> e[i].second;
--e[i].first, --e[i].second;
g[e[i].first].push_back(make_pair(e[i].second, i));
g[e[i].second].push_back(make_pair(e[i].first, i));
}
if (m & 1) {
cout << "No solution";
return;
}
assert(dfs(0) == -1);
for (int i = 0; i < (int)(m / 2); ++i)
cout << a[i] + 1 << ' ' << b[i] + 1 << ' ' << c[i] + 1 << endl;
}
int main() {
srand(time(NULL));
srand(time(NULL));
cout << setprecision(10) << fixed;
cerr << setprecision(10) << fixed;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void SetIO(string Name) {
string Input = Name + ".in", Output = Name + ".out";
freopen(Input.c_str(), "r", stdin), freopen(Output.c_str(), "w", stdout);
}
const int N = 100010, M = 200010;
int First[N], To[M], Use[M], Next[M], Tot;
int n, m;
inline void Insert(int u, int v) {
To[Tot] = v, Next[Tot] = First[u];
First[u] = Tot++;
}
inline void Input() {
scanf("%d%d", &n, &m);
if (m & 1) {
puts("No solution");
exit(0);
}
for (int i = (1); i <= (n); i++) First[i] = -1;
for (int i = (1); i <= (m); i++) {
int u, v;
scanf("%d%d", &u, &v);
Insert(u, v), Insert(v, u);
}
}
inline int Search(int u) {
int Tab, v, w;
vector<int> Que, Unpair;
for (Tab = First[u]; Tab != -1; Tab = Next[Tab])
if (!Use[Tab]) {
Use[Tab] = Use[Tab ^ 1] = 1;
Que.push_back(To[Tab]);
}
for (int i = (0); i < (((int)(Que).size())); i++) {
w = Search(v = Que[i]);
if (w)
printf("%d %d %d\n", u, v, w);
else
Unpair.push_back(v);
}
for (Tab = 1; Tab < ((int)(Unpair).size()); Tab += 2)
printf("%d %d %d\n", Unpair[Tab - 1], u, Unpair[Tab]);
if (((int)(Unpair).size()) & 1) return Unpair.back();
return 0;
}
inline void Solve() { Search(1); }
int main() {
Input();
Solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct why {
int en, e_id;
} next, u;
int vis[100000 + 10], mask[100000 + 10];
;
vector<why> ve[100000 + 10];
vector<int> q[100000 + 10];
int dfs(int x) {
vector<int> qq, qqq;
int find = 0, flag = 0, i;
vis[x] = 1;
for (i = 0; i < ve[x].size(); i++) {
int edge_id = ve[x][i].e_id;
find = 0;
if (!mask[edge_id]) {
flag++;
mask[edge_id] = 1;
if (!vis[ve[x][i].en]) {
find = dfs(ve[x][i].en);
if (find) qq.push_back(ve[x][i].en);
}
if (!find) qqq.push_back(ve[x][i].en);
}
}
if (!flag) return 0;
if (qq.size()) {
for (i = 0; i < qq.size(); i++) {
int temp = qq[i];
printf("%d %d %d\n", x, temp, q[temp][0]);
}
for (i = 0; i < qqq.size(); i += 2) {
if (i + 1 == qqq.size()) {
q[x].push_back(qqq[i]);
return 1;
}
printf("%d %d %d\n", qqq[i], x, qqq[i + 1]);
}
return 0;
} else {
for (i = 0; i < qqq.size(); i += 2) {
if (i + 1 == qqq.size()) {
q[x].push_back(qqq[i]);
return 1;
}
printf("%d %d %d\n", qqq[i], x, qqq[i + 1]);
}
return 0;
}
}
int main() {
int n, m, i, j, x, y, ans = 0;
scanf("%d %d", &n, &m);
memset(mask, 0, sizeof(mask));
memset(vis, 0, sizeof(vis));
for (i = 1; i <= m; i++) {
scanf("%d %d", &x, &y);
u.en = y, u.e_id = ans;
ve[x].push_back(u);
u.en = x, u.e_id = ans;
ve[y].push_back(u);
ans++;
}
if (m % 2 == 1) {
printf("No solution\n");
return 0;
}
dfs(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, first[110000], len;
struct node {
int x, y, next;
} e[210000];
bool v[210000];
void ins(int x, int y) {
len++;
e[len].x = x;
e[len].y = y;
e[len].next = first[x];
first[x] = len;
}
int Dfs(int x) {
vector<int> Set;
Set.clear();
vector<int> UNP;
UNP.clear();
for (int k = first[x]; k != -1; k = e[k].next)
if (v[k]) {
v[k] = v[k ^ 1] = false;
Set.push_back(e[k].y);
}
for (int i = 0; i < Set.size(); i++) {
int w = Dfs(Set[i]);
if (w)
printf("%d %d %d\n", x, Set[i], w);
else
UNP.push_back(Set[i]);
}
while (UNP.size() >= 2) {
int u = UNP[UNP.size() - 1], w = UNP[UNP.size() - 2];
printf("%d %d %d\n", u, x, w);
UNP.pop_back();
UNP.pop_back();
}
if (UNP.size())
return UNP[0];
else
return 0;
}
int main() {
scanf("%d%d", &n, &m);
len = 1;
memset(first, -1, sizeof(first));
for (int i = 1; i <= m; i++) {
int x, y;
scanf("%d%d", &x, &y);
ins(x, y);
ins(y, x);
}
memset(v, 1, sizeof(v));
if (m % 2 == 1)
printf("No solution\n");
else
Dfs(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
vector<int> adj[MAX], tree[MAX], point_to[MAX];
bool visited[MAX];
int out_degree[MAX], father[MAX];
int n, m;
set<pair<int, int> > edges;
void dfs(int source) {
visited[source] = true;
for (auto &each : adj[source]) {
if (!visited[each]) {
tree[source].push_back(each);
edges.erase(pair<int, int>(min(each, source), max(each, source)));
father[each] = source;
dfs(each);
}
}
}
void fix(int source) {
for (auto &each : tree[source]) {
fix(each);
}
if (out_degree[source] & 1) {
point_to[source].push_back(father[source]);
out_degree[source]++;
} else if (father[source] != -1) {
out_degree[father[source]]++;
point_to[father[source]].push_back(source);
}
}
int main() {
scanf("%d %d", &n, &m);
if (m & 1) {
puts("No solution");
return 0;
}
for (int i = int(0); i < int(m); i++) {
int u, v;
scanf("%d %d", &u, &v);
edges.emplace(min(u, v), max(u, v));
adj[u].push_back(v);
adj[v].push_back(u);
}
father[1] = -1;
dfs(1);
for (auto &each : edges) {
point_to[each.first].push_back(each.second);
out_degree[each.first]++;
}
fix(1);
for (int i = int(1); i < int(n + 1); i++) {
for (int j = 0; j < (int)point_to[i].size(); j += 2) {
printf("%d %d %d\n", point_to[i][j], i, point_to[i][j + 1]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000;
struct Ans {
int u, v, w;
Ans(int u = 0, int v = 0, int w = 0) : u(u), v(v), w(w) {}
};
int n, m;
vector<int> G[maxn + 5];
int vis[maxn + 5];
vector<Ans> ans;
int dfs(int u, int fa) {
vis[u] = vis[fa] + 1;
vector<int> P;
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
if (vis[v]) {
if (vis[u] < vis[v]) P.push_back(v);
continue;
}
int temp = dfs(v, u);
if (temp)
ans.push_back(Ans(u, v, temp));
else
P.push_back(v);
}
int i;
for (i = 0; i < (int)P.size() - 1; i += 2)
ans.push_back(Ans(P[i], u, P[i + 1]));
if (i == (int)P.size() - 1) return P[(int)P.size() - 1];
return 0;
}
int main() {
while (cin >> n >> m) {
for (int i = 1; i <= n; i++) G[i].clear();
for (int i = 0; i < m; i++) {
int u, v;
scanf("%d%d", &u, &v);
G[u].push_back(v);
G[v].push_back(u);
}
ans.clear();
int rest = dfs(1, 0);
if (rest)
printf("No solution\n");
else {
for (int i = 0; i < ans.size(); i++)
printf("%d %d %d\n", ans[i].u, ans[i].v, ans[i].w);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
vector<pair<int, int>> graph[100005];
bool vis[100005];
int a[100005], b[100005];
set<int> st;
vector<pair<int, pair<int, int>>> ans;
void dfs(int n, int p) {
vis[n] = 1;
vector<int> v;
for (auto e : graph[n]) {
if (e.second != p && !vis[e.first]) {
dfs(e.first, e.second);
if (!st.count(e.second)) {
v.push_back(e.second);
}
} else if (e.second != p && vis[e.first] && !st.count(e.second)) {
v.push_back(e.second);
}
}
while (v.size() >= 2) {
int p = v.back();
v.pop_back();
int q = v.back();
v.pop_back();
st.insert(p);
st.insert(q);
ans.push_back({(a[q] == n ? b[q] : a[q]), {n, (a[p] == n ? b[p] : a[p])}});
}
if (v.size()) {
int q = v.back();
ans.push_back({(a[q] == n ? b[q] : a[q]), {n, (a[p] == n ? b[p] : a[p])}});
st.insert(p);
st.insert(q);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> M;
for (int i = 1; i <= M; i++) {
cin >> a[i] >> b[i];
graph[a[i]].emplace_back(b[i], i);
graph[b[i]].emplace_back(a[i], i);
}
if (M & 1) {
cout << "No solution\n";
return 0;
}
dfs(1, 0);
for (auto k : ans) {
cout << k.first << " " << k.second.first << " " << k.second.second << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 10, mod = 1e9 + 7, base = 41, INF = 99999999999, sq = 502;
int q, n, m, h[MAX];
vector<pair<int, pair<int, int> > > ans;
bool used[MAX], mark[MAX];
vector<int> adj[MAX];
inline void hdfs(int v) {
mark[v] = 1;
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (!mark[u]) {
h[u] = h[v] + 1;
hdfs(u);
}
}
}
inline void dfs(int v, int p) {
mark[v] = 1;
queue<int> second;
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (!mark[u]) {
dfs(u, v);
}
if (u != p && !used[u]) second.push(u);
}
while (second.size() > 1) {
int x = second.front();
second.pop();
int y = second.front();
used[x] = (h[x] > h[v]), used[y] = (h[y] > h[v]);
second.pop();
ans.push_back({x, {v, y}});
}
if (second.size()) {
int x = second.front();
used[x] = (h[x] > h[v]);
ans.push_back({x, {v, p}});
used[v] = 1;
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
if (m & 1) return cout << "No solution", -0;
for (int u, v, i = 0; i < m; i++) {
cin >> u >> v;
adj[v].push_back(u), adj[u].push_back(v);
}
hdfs(1);
memset(mark, 0, sizeof(mark));
dfs(1, -1);
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].first << ' ' << ans[i].second.first << ' '
<< ans[i].second.second << '\n';
}
return -0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX1 = 2e5 + 7, MOD = 998244353;
long long n, m, x, y, mark[MAX1], parent[MAX1], ft[MAX1];
set<long long> bach[MAX1], pack[MAX1];
vector<long long> adj[MAX1];
vector<pair<long long, pair<long long, long long> > > ans;
void DFS(long long v, long long par) {
mark[v] = 1;
for (int i = 0; i < adj[v].size(); i++) {
int u = adj[v][i];
if (mark[u] && u != par && !ft[u]) pack[v].insert(u);
if (mark[u]) continue;
parent[u] = v;
bach[v].insert(u);
DFS(u, v);
}
long long flag = -1;
for (int i : bach[v]) {
if (flag == -1)
flag = i;
else {
ans.push_back({flag, {v, i}});
flag = -1;
}
}
if (!par) return;
if (flag != -1 && pack[v].size()) {
int u = *pack[v].begin();
ans.push_back({flag, {v, u}});
pack[v].erase(u);
pack[u].erase(v);
flag = -1;
}
while (pack[v].size() >= 2) {
int u1 = *pack[v].begin();
pack[v].erase(u1);
pack[u1].erase(v);
int u2 = *pack[v].begin();
pack[v].erase(u2);
pack[u2].erase(v);
ans.push_back({u1, {v, u2}});
}
if (pack[v].size() && par) {
int u = *pack[v].begin();
pack[v].erase(u);
pack[u].erase(v);
ans.push_back({u, {v, par}});
bach[par].erase(v);
}
if (flag >= 0) {
int u = flag;
ans.push_back({u, {v, parent[v]}});
bach[parent[v]].erase(v);
}
ft[v] = 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
cin >> n >> m;
int mm = m;
while (mm--) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (int i = 1; i <= n; ++i) {
if (!mark[i]) DFS(i, 0);
}
if (m % 2) {
cout << "No solution" << '\n';
return 0;
}
for (int i = 0; i < ans.size(); ++i) {
cout << ans[i].first << ' ' << ans[i].second.first << ' '
<< ans[i].second.second << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5 + 7;
int n;
int m;
vector<int> g[N];
vector<int> gCorrect[N];
vector<int> backEdges[N];
bool vis[N];
int d[N];
void buildBackEdges(int a) {
vis[a] = 1;
for (auto &b : g[a]) {
if (vis[b] == 0) {
d[b] = 1 + d[a];
gCorrect[a].push_back(b);
buildBackEdges(b);
} else {
if (d[b] < d[a] - 1) {
backEdges[b].push_back(a);
}
}
}
}
struct T {
int a;
int b;
int c;
};
vector<T> sol;
int dfs(int a) {
vector<int> nodes;
for (auto &b : gCorrect[a]) {
int c = dfs(b);
if (c) {
sol.push_back({a, b, c});
} else {
nodes.push_back(b);
}
}
for (auto &it : backEdges[a]) {
nodes.push_back(it);
}
while ((int)nodes.size() >= 2) {
int x = nodes.back();
nodes.pop_back();
int y = nodes.back();
nodes.pop_back();
sol.push_back({x, a, y});
}
if (nodes.empty()) {
return 0;
} else {
return nodes[0];
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> m;
for (int i = 1; i <= m; i++) {
int x, y;
cin >> x >> y;
g[x].push_back(y);
g[y].push_back(x);
}
if (m % 2 == 1) {
cout << "No solution\n";
return 0;
}
buildBackEdges(1);
for (int i = 1; i <= n; i++) {
g[i] = gCorrect[i];
}
dfs(1);
for (auto &it : sol) {
cout << it.a << " " << it.b << " " << it.c << "\n";
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N_ = 100005;
int N, M;
vector<int> Gph[N_], Child[N_];
int depth[N_];
bool visited[N_];
int W[N_];
vector<int> res;
void ins(int a, int b, int c) {
res.push_back(a);
res.push_back(b);
res.push_back(c);
}
void DFS(int u, int p, int d) {
visited[u] = true;
depth[u] = d;
vector<int> rev;
for (int i = 0; i < Gph[u].size(); i++) {
int v = Gph[u][i];
if (!visited[v])
Child[u].push_back(v), DFS(v, u, d + 1);
else if (v != p && depth[v] > depth[u])
rev.push_back(v);
}
for (int i = 0; i < rev.size(); i += 2) {
if (i + 1 >= rev.size())
W[u] = rev[i];
else
ins(rev[i], u, rev[i + 1]);
}
}
bool processW(int u, int p) {
if (Child[u].empty()) return true;
vector<int> remained;
for (int i = 0; i < Child[u].size(); i++) {
int v = Child[u][i];
if (processW(v, u)) {
if (W[v] == 0)
remained.push_back(v);
else
ins(u, v, W[v]);
}
}
int nd = 0;
for (int i = 0; i < remained.size(); i += 2) {
if (i + 1 >= remained.size())
nd = remained[i];
else
ins(remained[i], u, remained[i + 1]);
}
if (nd > 0) {
if (W[u] == 0) {
if (p != -1) ins(nd, u, p);
return false;
} else {
ins(nd, u, W[u]);
W[u] = 0;
}
}
return true;
}
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= M; i++) {
int u, v;
scanf("%d%d", &u, &v);
Gph[u].push_back(v);
Gph[v].push_back(u);
}
DFS(1, -1, 0);
processW(1, -1);
if (res.size() / 3 * 2 != M)
puts("No solution");
else {
for (int i = 0; i < res.size(); i += 3) {
for (int j = 0; j < 3; j++) printf("%d ", res[i + j]);
puts("");
}
}
return 0;
}
|
#include <bits/stdc++.h>
bool a[100000 * 2 + 1], aa[100000 + 1];
int b[100000 * 2 + 1], c[100000 * 2 + 1], h[100000 + 1], n, m, i, x, y;
int go(int k) {
aa[k] = 1;
int i, t, x = 0;
for (i = h[k]; i; i = b[i])
if (!a[i]) {
a[i > m ? i - m : i + m] = 1;
if (t = aa[c[i]] ? 0 : go(c[i]))
printf("%d %d %d\n", k, c[i], t);
else if (x)
printf("%d %d %d\n", x, k, c[i]), x = 0;
else
x = c[i];
}
return x;
}
int main() {
scanf("%d%d", &n, &m);
if (m & 1) {
puts("No solution");
return 0;
}
for (i = 1; i <= m; ++i) {
scanf("%d%d", &x, &y);
b[i] = h[x];
c[i] = y;
h[x] = i;
b[i + m] = h[y];
c[i + m] = x;
h[y] = i + m;
}
go(1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int vis[100100];
vector<int> adj[100100];
vector<pair<int, pair<int, int>>> ans;
int dfs(int v) {
vis[v] = 2;
vector<int> res;
for (auto i : adj[v]) {
if (vis[i] == 0) {
int node = dfs(i);
if (node == 0)
res.push_back(i);
else
ans.push_back(make_pair(v, make_pair(i, node)));
} else if (vis[i] == 1)
res.push_back(i);
}
vis[v] = 1;
while (res.size() != 0) {
int node1 = res[res.size() - 1];
res.pop_back();
if (!res.size()) return node1;
int node2 = res[res.size() - 1];
res.pop_back();
ans.push_back(make_pair(node1, make_pair(v, node2)));
}
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m, x, y, i;
cin >> n >> m;
if (m % 2 == 1) {
cout << "No solution" << endl;
return 0;
}
for (i = 0; i < m; i++) {
cin >> x >> y;
adj[x].push_back(y);
adj[y].push_back(x);
}
for (i = 1; i <= n; i++)
if (vis[i] != 1) dfs(i);
for (i = 0; i < ans.size(); i++)
cout << ans[i].first << " " << ans[i].second.first << " "
<< ans[i].second.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int G = 1000 * 100 + 10;
vector<pair<int, int> > e[G];
bool visited[G];
int solve(int v) {
vector<int> remain;
for (int i = 0; i < e[v].size(); i++) {
int u = e[v][i].first, z;
if (!visited[e[v][i].second]) {
visited[e[v][i].second] = true;
z = solve(u);
if (z)
cout << z << ' ' << u << ' ' << v << '\n';
else
remain.push_back(u);
}
}
while (remain.size() > 1) {
cout << remain.back() << ' ' << v << ' ';
remain.pop_back();
cout << remain.back() << '\n';
remain.pop_back();
}
if (remain.size())
return remain[0];
else
return 0;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, a, b, root;
cin >> n >> m;
for (int i = 1; i <= m; i++) {
cin >> a >> b;
e[a].push_back({b, i});
e[b].push_back({a, i});
if (e[a].size() > 1) root = a;
if (e[b].size() > 1) root = b;
}
if (m % 2) {
cout << "No solution" << endl;
return 0;
}
solve(root);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.