2022-03-31每日刷题打卡

2022-03-31每日刷题打卡

代码源——每日一题

完美数 - 题目 - Daimayuan Online Judge

对于给定的数字 a , b ,当整数 n 在十进制下的所有数位都为 a 或 b 时，我们称 n 是“好数”

对于好数 n ，当 n在十进制下每一位的数字之和也为“好数”时，我们称 n 是一个“完美数”

请你求出有多少 m 位数是“完美数”

输入格式

输入一行三个整数 a , b , m , 含义如题面所示 (1≤m≤10^6,1≤a,b≤9)。

输出格式

输出一行一个整数表示完美数的数量 ， 由于答案可能很大 ， 请你将答案对 10^9+7 取模

样例输入

5 1 5

样例输出

1

样例解释

只有 11111 满足要求

这题要求是，找出m位数的完美数。注意是m位数，比如5位数那就是10w，这里m最多可以取到10^6，这是相当吓人的，所以说也不用想着通过枚举来判断每一位是不是a或b了。但是我们完全可以反过来，既然好数是只有a和b的是数，那我们就用a和b排列出m位数，那他就是好数了。但完美数怎么办呢，一样的想法，完美数是好数各位数加起来仍然是好数，这里好数只有a和b组成，那么各位数之和就是x个a+y个b。我们只要枚举a或b的个数（x或y），然后计算出x*a+y *b，再看这个和是否是好数即可。如果是好数，那么说明x个a和y个b组成的m位数就将是个完美数。然后只要计算出他们的排列组合即可。

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<math.h>
#include<set>
#include<numeric>
#include<string>
#include<string.h>
#include<iterator>
#include<map>
#include<unordered_map>
#include<stack>
#include<list>
#include<queue>
#include<iomanip>

#define endl '\n';
typedef long long ll;
typedef pair<ll, ll>PII;
const int MOD = 1e9 + 7, N = 1e6 + 10;

ll fact[N], infact[N];

ll qmi(int a, int b)
{
    ll res = 1;
    while (b)
    {
        if (b & 1) res = res * a % MOD;
        a = a * (ll)a % MOD;
        b >>= 1;
    }
    return res;
}

void init()
{
    fact[0] = infact[0] = 1;
    for (int i = 1; i < N; i++)
        fact[i] = fact[i - 1] * i % MOD;

    infact[N - 1] = qmi(fact[N - 1], MOD - 2);
    for (int i = N - 2; i; i--)
        infact[i] = infact[i + 1] * (i + 1) % MOD;
}

int C(int a, int b)
{
    return (fact[a] * infact[b] % MOD * infact[a - b] % MOD) % MOD;
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int a, b, m;
    cin >> a >> b >> m;
    init();
    char c = a + '0', d = b + '0';
    int x;
    ll res = 0;
    for (int i = 0; i <= m; i++)
    {
        x = m - i;
        ll num = x * a + i * b;
        bool flag = true;
        while (num)
        {
            if (num % 10 != a && num % 10 != b)
            {
                flag = false;
                break;
            }
            num /= 10;
        }
        if (!flag)continue;
        res = (res + C(m,i)) % MOD;
    }
    cout << (res%MOD) << endl;
    return 0;
}

洛谷——线段树

P3372 【模板】线段树 1 - 洛谷 | 计算机科学教育新生态 (luogu.com.cn)

题目描述

如题，已知一个数列，你需要进行下面两种操作：

1. 将某区间每一个数加上 k。
2. 求出某区间每一个数的和。

输入格式

第一行包含两个整数 n, m，分别表示该数列数字的个数和操作的总个数。

第二行包含 n个用空格分隔的整数，其中第 i 个数字表示数列第 i 项的初始值。

接下来 m 行每行包含 3 或 44 个整数，表示一个操作，具体如下：

1. 1 x y k：将区间 [x, y] 内每个数加上 k。
2. 2 x y：输出区间 [x, y] 内每个数的和。

输出格式

输出包含若干行整数，即为所有操作 2 的结果。

输入输出样例

输入 #1复制

5 5
1 5 4 2 3
2 2 4
1 2 3 2
2 3 4
1 1 5 1
2 1 4

输出 #1复制

11
8
20

说明/提示

对于 30% 的数据：m≤10。
对于 70% 的数据：m≤10^4。
对于 100% 的数据：1≤n,m≤10^5。

保证任意时刻数列中任意元素的和在 [-2^{63}, 2^{63}) 内。

这里是基础树状数组的进阶版。如果还不会基础树状数组的可以去2022-03-29每日刷题打卡_你好_Ä的博客-CSDN博客看一看。

之前学到的地方是单点修改+区间和计算。用线段树我们可以在logn的复杂度下做到单点修改和区间和计算。但此时是区间修改，如果还是用一般的线段树，那效率是很低的，不如直接用数组。所以这里我们加入了一个新的概念：懒惰标记。

懒惰标记，简单来说，就是通过延迟对节点信息的更改，从而减少可能不必要的操作次数。每次执行修改时，我们通过打标记的方法表明该节点对应的区间在某一次操作中被更改，但不更新该节点的子节点的信息。实质性的修改则在下一次访问带有标记的节点时才进行。

也就是，当我们要在l到r区间的点都加上x时，我们找到管理这些区间的父节点而不是叶子节点，给这个父节点记录上大小为x的懒惰标记，这样当下次我们计算区间和时，就可以根据 懒惰标记*该区间的点数 知道这个区间通过1操作增加了多少总和。加上原本父节点存储的总和，就是我们要的区间总和了。
有了懒惰标记，我们就不用真的给区间的点都加上x，通过计算，我们还是可以通过logn的复杂度完成区间的修改和查询。

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm>
#include<math.h>
#include<set>
#include<numeric>
#include<string>
#include<string.h>
#include<iterator>
#include<map>
#include<unordered_map>
#include<stack>
#include<list>
#include<queue>
#include<iomanip>

#define endl '\n';
typedef long long ll;
typedef pair<ll, ll>PII;
ll n, m, a[100005], f[500050],lz[500050];

void buildtree(int k, int l, int r)
{
    if (l == r)
    {
        //到达叶节点后把值赋给树状数组
        f[k] = a[l];
        return;
    }
    int m = (l + r) / 2;
    //以m为中点分成左右
    buildtree(k + k, l, m);//左
    buildtree(k + k + 1, m + 1, r);//右
    f[k] = f[k + k] + f[k + k + 1];//父节点值是两个子节点的和
}

void add(int k, int l, int r, int x, int y, ll c)
{
    if (l == x && y == r)
    {
        lz[k] += c;
        return;
    }
    f[k] += (y - x + 1) * c;
    int m = (l + r) / 2;
    if (y <= m)
        add(k + k, l, m, x, y, c);
    else
        if (x > m)add(k + k + 1, m+1, r, x, y, c);
        else
        {
            add(k + k, l, m, x, m, c);
            add(k + k + 1, m + 1, r, m + 1, y, c);
        }
}

ll calc(int k, int l, int r, int x, int y, ll p)
{
    p += lz[k];
    if (l == x && y == r)
    {
        return p * (r - l + 1) + f[k];
    }
    int m = (l + r) / 2;
    //看目标区间在左边还是右边
    if (y <= m)
        return calc(k + k, l, m, x, y, p);
    else
        if (x > m)
            return calc(k + k + 1, m + 1, r, x, y, p);
        else return calc(k + k, l, m, x, m, p) + calc(k + k + 1, m + 1, r, m + 1, y, p);
}

int main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin >> n >> m;
    for (int i = 1; i <= n; i++)cin >> a[i];
    buildtree(1, 1, n);
    while (m--)
    {
        int t;
        cin >> t;
        if (t == 1)
        {
            int x, y, c;
            cin >> x >> y >> c;
            add(1, 1, n, x, y, c);
        }
        else
        {
            int x, y;
            cin >> x >> y;
            cout << calc(1, 1, n, x, y, 0) << endl;
        }
    }
    

    return 0;
}