new file: P7075.cpp

P13085.cpp

@@ -0,0 +1,89 @@
+#include <bits/stdc++.h>
+#define int long long
+using namespace std;
+int a, b;
+int dp[35][35];
+int getlen(int num)
+{
+    if (num < 10)
+        return 1;
+    int cnt = 0;
+    while (num)
+    {
+        num /= 10;
+        cnt++;
+    }
+    return cnt;
+}
+int calc(int x)
+{
+    if (x <= 0)
+        return 0;
+    vector<int> digit;
+    while (x)
+    {
+        digit.push_back(x % 10);
+        x /= 10;
+    }
+    int len = digit.size();
+    int res = 0;
+    for (int i = 1; i < len; ++i)
+    {
+        for (int j = 1; j <= 9; ++j)
+        {
+            res += dp[i][j];
+        }
+    }
+    for (int i = len - 1; i >= 0; --i)
+    {
+        int cur = digit[i];
+        int start = (i == len - 1) ? 1 : 0;
+        for (int j = start; j < cur; ++j)
+        {
+            if (i == len - 1 || abs(j - digit[i + 1]) >= 2)
+            {
+                if (i == 0)
+                {
+                    ++res;
+                }
+                else
+                {
+                    res += dp[i + 1][j];
+                }
+            }
+        }
+        if (i != len - 1 && abs(cur - digit[i + 1]) < 2)
+        {
+            break;
+        }
+        if (i == 0)
+        {
+            ++res;
+        }
+    }
+    return res;
+}
+
+signed main()
+{
+    scanf("%lld%lld", &a, &b);
+    int _b = getlen(b);
+    for (int i = 0; i <= 9; ++i)
+    {
+        dp[1][i] = 1;
+    }
+    for (int i = 2; i <= _b; ++i)
+    {
+        for (int j = 0; j <= 9; ++j)
+        {
+            for (int k = 0; k <= 9; ++k)
+            {
+                if (abs(j - k) < 2)
+                    continue;
+                dp[i][j] += dp[i - 1][k];
+            }
+        }
+    }
+    printf("%lld\n", calc(b) - calc(a - 1));
+    return 0;
+}

P2014.cpp

@@ -0,0 +1,47 @@
+#include <bits/stdc++.h>
+#define int long long
+using namespace std;
+const int MAXN = 305;
+int n, m, s[MAXN];
+vector<int> g[MAXN];
+int dp[MAXN][MAXN];
+int sz[MAXN];
+void dfs(int u)
+{
+    sz[u] = 1;
+    for (int j = 0; j <= m + 1; ++j)
+        dp[u][j] = INT_MIN;
+    dp[u][1] = s[u];
+    for (int v : g[u])
+    {
+        dfs(v);
+        for (int i = sz[u]; i >= 1; --i)
+        {
+            if (dp[u][i] < 0)
+                continue;
+            for (int k = 1; k <= sz[v] && i + k <= m + 1; ++k)
+            {
+                if (dp[v][k] < 0)
+                    continue;
+                dp[u][i + k] = max(dp[u][i + k], dp[u][i] + dp[v][k]);
+            }
+        }
+        sz[u] += sz[v];
+    }
+}
+signed main()
+{
+    ios::sync_with_stdio(false);
+    cin.tie(nullptr);
+    cin >> n >> m;
+    for (int i = 1; i <= n; ++i)
+    {
+        int fa;
+        cin >> fa >> s[i];
+        g[fa].push_back(i);
+    }
+    s[0] = 0;
+    dfs(0);
+    cout << dp[0][m + 1] << '\n';
+    return 0;
+}

P2602.cpp

@@ -0,0 +1,48 @@
+#include <bits/stdc++.h>
+using namespace std;
+#define int long long
+
+int dig[20], len;
+int dp[20][20][2][2]; // pos, cnt, limm, fl
+int dfs(int pos, int cnt, bool limm, bool fl, int too)
+{
+    if (pos == len)
+        return cnt;
+    if (dp[pos][cnt][limm][fl] != -1)
+        return dp[pos][cnt][limm][fl];
+    int up = limm ? dig[pos] : 9;
+    int res = 0;
+    for (int d = 0; d <= up; ++d)
+    {
+        bool nl = fl && (d == 0);
+        int add = 0;
+        if (!(fl && d == 0) && d == too)
+            add = 1;
+        res += dfs(pos + 1, cnt + add, limm && (d == up), nl, too);
+    }
+    return dp[pos][cnt][limm][fl] = res;
+}
+int doo(int n, int too)
+{
+    if (n <= 0)
+        return 0;
+    len = 0;
+    while (n)
+    {
+        dig[len++] = n % 10;
+        n /= 10;
+    }
+    reverse(dig, dig + len);
+    memset(dp, -1, sizeof(dp));
+    return dfs(0, 0, true, true, too);
+}
+signed main()
+{
+    int a, b;
+    cin >> a >> b;
+    for (int i = 0; i <= 9; ++i)
+    {
+        cout << doo(b, i) - doo(a - 1, i) << ' ';
+    }
+    return 0;
+}

P2657.cpp

@@ -0,0 +1,89 @@
+#include <bits/stdc++.h>
+using namespace std;
+int a, b;
+int dp[15][15];
+int getlen(int num)
+{
+    if (num < 10)
+        return 1;
+    int cnt = 0;
+    while (num)
+    {
+        num /= 10;
+        cnt++;
+    }
+    return cnt;
+}
+int calc(int x)
+{
+    if (x <= 0)
+        return 0;
+    vector<int> digit;
+    while (x)
+    {
+        digit.push_back(x % 10);
+        x /= 10;
+    }
+    int len = digit.size();
+    int res = 0;
+    for (int i = 1; i < len; ++i)
+    {
+        for (int j = 1; j <= 9; ++j)
+        {
+            res += dp[i][j];
+        }
+    }
+    for (int i = len - 1; i >= 0; --i)
+    {
+        int cur = digit[i];
+        int start = (i == len - 1) ? 1 : 0;
+        for (int j = start; j < cur; ++j)
+        {
+            if (i == len - 1 || abs(j - digit[i + 1]) >= 2)
+            {
+                if (i == 0)
+                {
+                    ++res;
+                }
+                else
+                {
+                    res += dp[i + 1][j];
+                }
+            }
+        }
+        if (i != len - 1 && abs(cur - digit[i + 1]) < 2)
+        {
+            break;
+        }
+        if (i == 0)
+        {
+            ++res;
+        }
+    }
+    return res;
+}
+
+int main()
+{
+    scanf("%d%d", &a, &b);
+    int _b = getlen(b);
+    for (int i = 0; i <= 9; ++i)
+    {
+        dp[1][i] = 1;
+    }
+    for (int i = 2; i <= _b; ++i)
+    {
+        for (int j = 0; j <= 9; ++j)
+        {
+            for (int k = 0; k <= 9; ++k)
+            {
+                if (abs(j - k) < 2)
+                    continue;
+                dp[i][j] += dp[i - 1][k];
+            }
+        }
+    }
+
+    printf("%d\n", calc(b) - calc(a - 1));
+    return 0;
+}

P3372.cpp

@@ -0,0 +1,84 @@
+#include <bits/stdc++.h>
+#define int long long
+using namespace std;
+struct node
+{
+    int l, r, num;
+    int lt;
+} seg[400005];
+int a[100005];
+void init(int now, int l, int r)
+{
+    seg[now].l = l, seg[now].r = r;
+    if (l == r)
+    {
+        seg[now].num = a[l];
+        return;
+    }
+    int mid = l + r >> 1;
+    init(now * 2, l, mid);
+    init(now * 2 + 1, mid + 1, r);
+    seg[now].num = seg[now * 2].num + seg[now * 2 + 1].num;
+}
+void pd(int now)
+{
+    int lt = seg[now].lt;
+    seg[now * 2].num += lt * (seg[now * 2].r - seg[now * 2].l + 1), seg[now * 2].lt += lt;
+    seg[now * 2 + 1].num += lt * (seg[now * 2 + 1].r - seg[now * 2 + 1].l + 1), seg[now * 2 + 1].lt += lt;
+    seg[now].lt = 0;
+}
+void add(int now, int l, int r, int num)
+{
+    if (seg[now].r <= r && seg[now].l >= l)
+    {
+        seg[now].num += num * (seg[now].r - seg[now].l + 1), seg[now].lt += num;
+        return;
+    }
+    if (seg[now].r < l || seg[now].l > r)
+    {
+        return;
+    }
+    pd(now);
+    add(now * 2, l, r, num);
+    add(now * 2 + 1, l, r, num);
+    seg[now].num = seg[now * 2].num + seg[now * 2 + 1].num;
+}
+int query(int now, int l, int r)
+{
+    if (seg[now].l >= l && seg[now].r <= r)
+    {
+        return seg[now].num;
+    }
+    if (seg[now].r < l || seg[now].l > r)
+    {
+        return 0;
+    }
+    pd(now);
+    return query(now * 2, l, r) + query(now * 2 + 1, l, r);
+}
+int n, q;
+signed main()
+{
+    scanf("%lld%lld", &n, &q);
+    for (int i = 1; i <= n; ++i)
+        scanf("%lld", &a[i]);
+    init(1, 1, n);
+    while (q--)
+    {
+        int op;
+        scanf("%lld", &op);
+        if (op == 1)
+        {
+            int l, r, k;
+            scanf("%lld%lld%lld", &l, &r, &k);
+            add(1, l, r, k);
+        }
+        else
+        {
+            int l, r;
+            scanf("%lld%lld", &l, &r);
+            printf("%lld\n", query(1, l, r));
+        }
+    }
+    return 0;
+}

P3390.cpp

@@ -0,0 +1,75 @@
+#include <bits/stdc++.h>
+const int mod = 1e9 + 7;
+#define int long long
+using namespace std;
+int n;
+struct node
+{
+    int a[105][105];
+    void operator*=(const node &b)
+    {
+        int res[105][105] = {};
+        for (int i = 1; i <= n; ++i)
+        {
+            for (int j = 1; j <= n; ++j)
+            {
+                for (int k = 1; k <= n; ++k)
+                {
+                    res[i][j] += (a[i][k] * b.a[k][j]) % mod;
+                    res[i][j] %= mod;
+                }
+            }
+        }
+        for (int i = 1; i <= n; ++i)
+        {
+            for (int j = 1; j <= n; ++j)
+            {
+                a[i][j] = res[i][j] % mod;
+            }
+        }
+    }
+} a;
+long long k;
+node pow(node a, int k)
+{
+    node res;
+    for (int i = 1; i <= n; ++i)
+        for (int j = 1; j <= n; ++j)
+            res.a[i][j] = (i == j);
+    while (k)
+    {
+        if (k & 1)
+            res *= a;
+        a *= a;
+        k >>= 1;
+    }
+    while (k)
+    {
+        if (k & 1)
+            res *= a;
+        a *= a;
+        k >>= 1;
+    }
+    return res;
+}
+signed main()
+{
+    scanf("%lld%lld", &n, &k);
+    for (int i = 1; i <= n; ++i)
+    {
+        for (int j = 1; j <= n; ++j)
+        {
+            scanf("%lld", &a.a[i][j]);
+        }
+    }
+    node res = pow(a, k);
+    for (int i = 1; i <= n; ++i)
+    {
+        for (int j = 1; j <= n; ++j)
+        {
+            printf("%lld ", res.a[i][j]);
+        }
+        puts("");
+    }
+    return 0;
+}

P5657.cpp

@@ -0,0 +1,32 @@
+#include <bits/stdc++.h>
+using namespace std;
+int n;
+unsigned long long k;
+unsigned long long p2[100];
+string gr(int now, unsigned long long k)
+{
+    if (now == 1)
+    {
+        if (k == 0)
+            return "0";
+        else
+            return "1";
+    }
+    if (k < p2[now - 1])
+    {
+        return "0" + gr(now - 1, k);
+    }
+    else
+    {
+        return "1" + gr(now - 1, p2[now] - k - 1);
+    }
+}
+int main()
+{
+    p2[0] = 1;
+    for (int i = 1; i <= 99; ++i)
+        p2[i] = p2[i - 1] * 2;
+    scanf("%d%llu", &n, &k);
+    cout << gr(n, k);
+    return 0;
+}

P7075.cpp

@@ -0,0 +1,154 @@
+#include <bits/stdc++.h>
+using namespace std;
+typedef long long ll;
+const ll T_BC = 1721424LL;
+const ll jend = 577737LL;
+const int ds[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+bool runac(int y) { return y % 4 == 0; }
+bool runbc(int y) { return y % 4 == 1; }
+bool runac_new(int y)
+{
+    return (y % 400 == 0) || (y % 4 == 0 && y % 100 != 0);
+}
+ll count_run(ll N)
+{
+    if (N <= 0)
+        return 0;
+    return N / 4 - N / 100 + N / 400;
+}
+ll days_bc(int y)
+{
+    ll years = 4713 - y;
+    ll leaps = 1179 - (y + 3) / 4;
+    return years * 365 + leaps;
+}
+ll days_ac(int y)
+{
+    ll years = y - 1;
+    ll leaps = years / 4;
+    return years * 365 + leaps;
+}
+ll days_new(ll y)
+{
+    if (y <= 1583)
+        return 0;
+    ll years = y - 1583;
+    ll leaps = count_run(y - 1) - count_run(1582);
+    return years * 365 + leaps;
+}
+pair<int, int> gett(ll q, bool run)
+{
+    int days[13];
+    for (int i = 1; i <= 12; ++i)
+        days[i] = ds[i];
+    if (run)
+        days[2] = 29;
+    int month = 1;
+    while (q >= days[month])
+    {
+        q -= days[month];
+        ++month;
+    }
+    return {month, (int)q + 1};
+}
+void solve(ll r)
+{
+    if (r < T_BC)
+    {
+        int el = 1, er = 4713;
+        while (el < er)
+        {
+            int mid = (el + er) / 2;
+            if (days_bc(mid) <= r)
+                er = mid;
+            else
+                el = mid + 1;
+        }
+        int y = el;
+        ll q = r - days_bc(y);
+        bool run = runbc(y);
+        auto [m, d] = gett(q, run);
+        printf("%d %d %d BC\n", d, m, y);
+    }
+    else
+    {
+        r -= T_BC;
+        if (r < jend)
+        {
+
+            int el = 1, er = 1582;
+            while (el < er)
+            {
+                int mid = (el + er + 1) / 2;
+                if (days_ac(mid) <= r)
+                    el = mid;
+                else
+                    er = mid - 1;
+            }
+            int y = el;
+            ll q = r - days_ac(y);
+            bool run = runac(y);
+            auto [m, d] = gett(q, run);
+            printf("%d %d %d\n", d, m, y);
+        }
+        else
+        {
+            r -= jend;
+            if (r < 78)
+            {
+                int y = 1582, m, d;
+                if (r < 17)
+                {
+                    m = 10;
+                    d = 15 + r;
+                }
+                else
+                {
+                    r -= 17;
+                    if (r < 30)
+                    {
+                        m = 11;
+                        d = 1 + r;
+                    }
+                    else
+                    {
+                        r -= 30;
+                        m = 12;
+                        d = 1 + r;
+                    }
+                }
+                printf("%d %d %d\n", d, m, y);
+            }
+            else
+            {
+                r -= 78;
+                ll el = 1583, er = 1000000000LL + 1000000;
+                while (el < er)
+                {
+                    ll mid = (el + er + 1) / 2;
+                    if (days_new(mid) <= r)
+                        el = mid;
+                    else
+                        er = mid - 1;
+                }
+                ll y = el;
+                ll q = r - days_new(y);
+                bool run = runac_new((int)y);
+                auto [m, d] = gett(q, run);
+                printf("%d %d %lld\n", d, m, y);
+            }
+        }
+    }
+}
+int main()
+{
+    int t;
+    scanf("%d", &t);
+    while (t--)
+    {
+        ll q;
+        scanf("%lld", &q);
+        solve(q);
+    }
+    return 0;
+}

P7913.cpp

@@ -0,0 +1,68 @@
+#include <bits/stdc++.h>
+using namespace std;
+int n, m1, m2;
+pair<int, int> plane1[100005], plane2[100005];
+int f1[100005], f2[100005];
+int main()
+{
+    scanf("%d%d%d", &n, &m1, &m2);
+    for (int i = 1; i <= m1; i++)
+    {
+        scanf("%d%d", &plane1[i].first, &plane1[i].second);
+    }
+    sort(plane1 + 1, plane1 + m1 + 1, [](pair<int, int> x, pair<int, int> y)
+         { return x.first < y.first; });
+    for (int i = 1; i <= m2; i++)
+    {
+        scanf("%d%d", &plane2[i].first, &plane2[i].second);
+    }
+    sort(plane2 + 1, plane2 + m2 + 1, [](pair<int, int> x, pair<int, int> y)
+         { return x.first < y.first; });
+    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> q;
+    priority_queue<int, vector<int>, greater<int>> freeQ;
+    for (int i = 1; i <= n; i++)
+        freeQ.push(i);
+    for (int i = 1; i <= m1; ++i)
+    {
+        while (!q.empty() && q.top().first <= plane1[i].first)
+            freeQ.push(q.top().second), q.pop();
+        if (!freeQ.empty())
+        {
+            q.push({plane1[i].second, freeQ.top()});
+            f1[freeQ.top()]++;
+            freeQ.pop();
+        }
+    }
+    for (int i = 1; i <= n; i++)
+    {
+        f1[i] += f1[i - 1];
+    }
+    while (!freeQ.empty())
+        freeQ.pop();
+    while (!q.empty())
+        q.pop();
+    for (int i = 1; i <= n; i++)
+        freeQ.push(i);
+    for (int i = 1; i <= m2; ++i)
+    {
+        while (!q.empty() && q.top().first <= plane2[i].first)
+            freeQ.push(q.top().second), q.pop();
+        if (!freeQ.empty())
+        {
+            q.push({plane2[i].second, freeQ.top()});
+            f2[freeQ.top()]++;
+            freeQ.pop();
+        }
+    }
+    for (int i = 1; i <= n; i++)
+    {
+        f2[i] += f2[i - 1];
+    }
+    int maxres = 0;
+    for (int i = 0; i <= n; ++i)
+    {
+        maxres = max(maxres, f1[i] + f2[n - i]);
+    }
+    printf("%d\n", maxres);
+    return 0;
+}

P9752.cpp

@@ -0,0 +1,49 @@
+#include <bits/stdc++.h>
+using namespace std;
+int n;
+int aa[10];
+bool pd(int now)
+{
+    for (int i = 1; i <= n; ++i)
+    {
+        int acpy = aa[i];
+        int pp = 0;
+        int cha = 0;
+        int ncpy = now;
+        int xl = 0;
+        for (int j = 1; j <= 5; ++j)
+        {
+            if (acpy % 10 != ncpy % 10)
+            {
+                pp++;
+
+                if (pp == 1)
+                    cha = ((acpy % 10 - ncpy % 10) + 10) % 10, xl = j;
+                
+                else if (((acpy % 10 - ncpy % 10) + 10) % 10 != cha || abs(j - xl) != 1) return 0;
+            }
+            acpy /= 10, ncpy /= 10;
+        }
+        if (pp > 2 || pp == 0)
+            return 0;
+    }
+    return 1;
+}
+int main()
+{
+    scanf("%d", &n);
+    for (int i = 1; i <= n; ++i)
+    {
+        int a, b, c, d, e;
+        scanf("%d%d%d%d%d", &a, &b, &c, &d, &e);
+        aa[i] = 10000 * a + 1000 * b + 100 * c + 10 * d + e;
+    }
+    int ans = 0;
+    for (int i = 0; i <= 99999; i++)
+    {
+        if (pd(i))
+            ans++;
+    }
+    printf("%d\n", ans);
+    return 0;
+}