Codeforces Round #538 (Div. 2)

 

A. Got Any Grapes?

签.

#include <bits/stdc++.h>
using namespace std;

int x, y, z, a, b, c;
bool solve()
{
    if (a < x) return false;
    a -= x;
    b += a;
    if (b < y) return false;
    b -= y;
    c += b;
    if (c < z) return false;
    return true;
}

int main()
{
    while (scanf("%d%d%d", &x, &y, &z) != EOF)
    {
        scanf("%d%d%d", &a, &b, &c);
        puts(solve() ? "YES" : "NO");
    }
    return 0;
}

 

 

B. Yet Another Array Partitioning Task

Solved.

题意：

有一个序列, 要求把这个序列分成$k段，每段最少m个$

要求每一段中的前$m$大的数加起来的总和最大

输出总和以及分配的方案

注意这里分的序列是连续的

思路：

我们考虑答案的总和就是所有数排序后的前$m * k大之和$

$我们考虑一个不属于前m * k大的数$

$首先我们考虑每一段中都有m个数$

$并且这m个数属于前m * k大的$

$那么剩下的数，无论分到哪个组，都不会被统计进答案$

$那么只要贪心选取，标记哪些数是前m * k大$

$每个组只要够了m个这样的数，就开启下一组$

#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define N 200010
int n, m, k;
int vis[N];
struct node
{
    int a, id;
    void scan(int id)
    {
        this->id = id;
        scanf("%d", &a);
    }
    bool operator < (const node &other) const
    {
        return a > other.a;
    }
}a[N];

int main()
{
    while (scanf("%d%d%d", &n, &m, &k) != EOF)
    {
        memset(vis, 0, sizeof vis);
        for (int i = 1; i <= n; ++i) a[i].scan(i);
        ll res = 0;
        sort(a + 1, a + 1 + n); 
        for (int i = 1; i <= m * k; ++i) res += a[i].a, vis[a[i].id] = 1;
        vector <int> vec;
        for (int i = 1, tmp = 0; i <= n; ++i)
        {
            tmp += vis[i];
            if (tmp == m)
            {
                vec.push_back(i);
                tmp = 0;
            }
        }
        printf("%lld\n", res);    
        for (int i = 0; i < k - 1; ++i)
            printf("%d%c", vec[i], " \n"[i == k - 2]);
    }
    return 0;
}

 

 

C. Trailing Loves (or L'oeufs?)

Solved.

题意：

求$n!在b进制下末尾的0的个数$

思路：

我们考虑什么时候会产生$0$

对于$b进制，我们知道满b进1，末尾添一个0$

$那么我们只需要知道n!中所有数因数分解之后可以凑成多少个b末尾就是多少个0$

我们令$b = p_1^{t_1} \cdot p_2^{t_2} \cdots p_n^{t_n}$

那么求出$n!中有多少个 p_1^{t_1}, p_2^{t_2} \cdots p_n^{t_n} 取Min即可$

#include <bits/stdc++.h>
using namespace std;

#define ll unsigned long long
#define pll pair <ll, ll>
ll n, b;

ll f()
{
    ll res = (ll)1e18;
    ll limit = sqrt(b);  
    vector <pll> vec;
    for (ll i = 2; i <= limit; ++i) if (b % i == 0)  
    {
        pll tmp = pll(i, 0);
        while (b % i == 0)
        {
            ++tmp.second;
            b /= i; 
        }
        vec.push_back(tmp);
    } 
    if (b != 1)   
        vec.push_back(pll(b, 1));
    for (auto it : vec)
    {
        ll tmp = 0;
        for (ll i = it.first; ; i *= it.first) 
        {
            tmp += n / i;
            if (i > n / it.first + 10) break;
        }
        res = min(res, tmp / it.second);
    }
    return res;   
}

int main()
{
    while (scanf("%llu%llu", &n, &b) != EOF)
    {
        printf("%llu\n", f());
    }
    return 0;
}

 

 

D. Flood Fill

Upsolved.

题意：

$有一行不同颜色的球$

$首先可以选择一个主球，相同的球会合并$

$在接下来的每一步，我们都可以规定主球为任一颜色$

$和它相邻的并且颜色和它相同的都会合并$

$求所有球合并完的最少步骤$

思路：

 

$DP解法$

$dp[l][r][0/1] 表示 l->r 这个区间合并完后状态为0/1的最小步数$

$0表示合并后的颜色和c[l]相同，1表示合并后的颜色和c[1]相同$

$那么dp[l][r][0/1] 可以转移到 dp[l - 1][r][0]$

$dp[l][r][0/1] 可以转移到 dp[l][r + 1][1]$

#include <bits/stdc++.h>
using namespace std;

#define N 5010
int n, c[N];
int f[N][N][2];

int dp(int l, int r, int sta)
{
    if (l >= r)
        return 0;
    if (f[l][r][sta] != -1) 
        return f[l][r][sta];
    int res = (int)1e8;
    if (sta == 0)
    {
        res = min(res, dp(l + 1, r, 0) + (c[l] != c[l + 1]));
        res = min(res, dp(l + 1, r, 1) + (c[l] != c[r]));
    }
    else
    {
        res = min(res, dp(l, r - 1, 0) + (c[r] != c[l]));
        res = min(res, dp(l, r - 1, 1) + (c[r] != c[r - 1]));
    }
    return f[l][r][sta] = res;
}

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", c + i);
        memset(f, -1, sizeof f);
        printf("%d\n", min(dp(1, n, 0), dp(1, n, 1)));
    }
    return 0;
}

 

$LCS解法$

我们假设$主球的位置在x$

$那么x把区间分成左右两部分$

$每次可以选择左边一个合并或者右边一个合并$

$但是更优的是 左边和右边的相同，那么一步就可以将他们都合并$

$我们就是要找这样相同的$

假如这样的东西

$abcxcba$

$x代表主球，相同字母代表相同数字$

$那么我们只需要三次就可以合并完$

$我们要找的就是这种相同的越多越好，并且是有顺序可以接在一起的$

$那么把字符串翻转求LCS就可以$

$要注意除2 ，因为多算了一次$

#include <bits/stdc++.h>
using namespace std;

#define N 5010
int n, m, a[N], b[N];
int f[N][N];

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        a[0] = -1; m = 0;
        for (int i = 1, x; i <= n; ++i)
        {
            scanf("%d", &x);
            if (x != a[m]) a[++m] = x;
        }
        for (int i = 1; i <= m; ++i) 
            b[m - i + 1] = a[i];
        memset(f, 0, sizeof f);
        for (int i = 1; i <= m; ++i)
            for (int j = 1; j <= m; ++j)
            {
                f[i][j] = max(f[i][j - 1], f[i - 1][j]);  
                if (a[i] == b[j]) 
                    f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);
            }
        printf("%d\n", m - 1 - f[m][m] / 2);
    }
    return 0;
}

 

下面这个线段树版本本质上和$LCS思想差不多$

#include <bits/stdc++.h>
using namespace std;

#define N 10010  
int n, m, c[N];
vector <int> vec[N];

namespace SEG
{
    int Max[N << 2];
    void init(){ memset(Max, 0, sizeof Max); }
    void update(int id, int l, int r, int pos, int val)
    {
        if (l == r)
        {
            Max[id] = max(Max[id], val);
            return;
        }
        int mid = (l + r) >> 1;
        if (pos <= mid) update(id << 1, l, mid, pos, val);
        else update(id << 1 | 1, mid + 1, r, pos, val);
        Max[id] = max(Max[id << 1], Max[id << 1 | 1]);
    }
    int query(int id, int l, int r, int ql, int qr)
    {
        if (qr < ql) return 0;
        if (l >= ql && r <= qr) return Max[id];
        int res = 0;
        int mid = (l + r) >> 1;
        if (ql <= mid) res = max(res, query(id << 1, l, mid, ql, qr));
        if (qr > mid) res = max(res, query(id << 1 | 1, mid + 1, r, ql, qr));
        return res;
    }
}
    
int main()
{
    while (scanf("%d", &n) != EOF)
    {
        m = 0, c[0] = -1;
        for (int i = 1, x; i <= n; ++i)
        {
            scanf("%d", &x);
            if (x != c[m]) c[++m] = x;
        }
        for (int i = m + 1; i <= 2 * m; ++i) c[i] = c[i - m]; 
        for (int i = 1; i <= m; ++i) vec[i].clear();  
        for (int i = 2 * m; i >= m + 1; --i) vec[c[i]].push_back(i);
        int res = (int)1e8;
          SEG::init();
        for (int i = m; i >= 1; --i)
        {
            for (auto it : vec[c[i]])
            {
                int tmp = SEG::query(1, 1, 2 * m, m + 1, it - 1);
                SEG::update(1, 1, 2 * m, it, tmp + 1);
            }
        }    
        for (int i = m; i <= 2 * m; ++i) res = min(res, m - 1 - SEG::query(1, 1, 2 * m, i, i) / 2);
        printf("%d\n", res);
    }
    return 0;
}

 

 

E. Arithmetic Progression

Upsolved.

题意：

给出一个等差序列，但是不有序

$有两种询问方式$

$?\; i 表示询问第i个位置上的数是多少$

$> x 表示询问序列中存不存在严格大于x的数字$

最后给出首项和公差

询问次数最多60

思路：

首先可以用$30次询问求出上界$

$接着如果搞定公差下界就有了$

$我们随机询问30个数，就得到900个差值$

$再求这个差值的gcd就是答案$

$为什么不会出现求的值的答案的倍数的情况?$

$概率很小，官方题解有证 (逃$

注意随机的时候要用大数随机

#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define N 1000010
int n, cnt;

bool check(int x)
{
    printf("> %d\n", x);
    ++cnt;
    fflush(stdout);
    int tmp;
    scanf("%d", &tmp);
    return tmp == 0; 
}

int vis[N];
int gcd(int a, int b)
{
    return b ? gcd(b, a % b) : a;
}

int main()
{
    while (scanf("%d", &n) != EOF)
    {
        if (n <= 60)
        {
            vector <int> vec;
            for (int i = 1, x; i <= n; ++i)
            {
                printf("? %d\n", i);
                fflush(stdout);
                scanf("%d", &x);
                vec.push_back(x);
            }
            sort(vec.begin(), vec.end());
            printf("! %d %d\n", vec[0], vec[1] - vec[0]);
            fflush(stdout);
            continue;
        }
        cnt = 0;
        int l = 0, r = (int)1e9, res = -1;
        while (r - l >= 0)
        {
            int mid = (l + r) >> 1;
            if (check(mid))
            {
                res = mid;
                r = mid - 1;
            }
            else
                l = mid + 1;
        }
        vector <int> vec, gap; 
        vec.push_back(res);
        memset(vis, 0, sizeof vis); 
        for (int i = cnt + 1, x; i <= 60; ++i)
        {
            do
            {
                x = ((rand() << 14) + rand()) % n + 1;
            } while (vis[x]);
            vis[x] = 1;
            printf("? %d\n", x);
            fflush(stdout); 
            scanf("%d", &x);
            vec.push_back(x); 
        }
        sort(vec.begin(), vec.end());
        vec.erase(unique(vec.begin(), vec.end()), vec.end());
        for (int i = 0, len = vec.size(); i < len; ++i)
            for (int j = i + 1; j < len; ++j)
                gap.push_back(vec[j] - vec[i]);
        int d = 0;
        for (auto it : gap) d = gcd(d, it);
        printf("! %d %d\n", res - (n - 1) * d, d);
        fflush(stdout);
    }
    return 0;
}

 

F. Please, another Queries on Array?

Upsolved.

题意：

给出一个序列

有两种操作

$M\; l, r, x 将[l, r]里面的数乘上x$

$q\; l, r  询问\phi(\prod_{i = l}^{r} a_i) mod 10^9 + 7$

思路：

考虑$\phi(p^k) = p^{k - 1} \cdot (p - 1)$

并且$\phi()是积性函数$

$有\phi(x \cdot y) = \phi(x) \cdot \phi(y)$

$那么令k = p_1^{t_1} \cdot p_2^{t_2} \cdots p_n^{t_n}$

那么

$\phi(k) = \phi(p_1^{t_1}) \cdots$

$\phi(k) = p_1^{t_1 - 1} \cdot (p_1 - 1) \cdots$

$\phi(k) = p_1^{t_1} \cdot \frac{p_1 - 1}{p_1} \cdots$

 

那么询问的答案就是

$\phi(k) = k \cdot \prod_{p \in P} \frac{p - 1}{p}$

 

前面那一段用乘积线段树维护

考虑题目的数的值中涉及到的素数只有62个

$后面那一段用或线段树维护是否存在即可$

#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define N 400010
const ll MOD = (ll)1e9 + 7;  
int n, m, q, a[N];
int prime[110], pos[310];    
ll inv[110], b[310];

void init()
{
    m = 0; 
    memset(pos, 0, sizeof pos);
    for (int i = 2; i <= 300; ++i)
    {
        if (!pos[i])
            prime[++m] = i;
        for (int j = i * i; j <= 300; j += i)  
            pos[j] = 1;
    }
    for (int i = 1; i <= 300; ++i)
    {
        b[i] = 0;
        for (int j = 1; j <= 62; ++j)
            if (i % prime[j] == 0)
                b[i] |= (1ll << (j - 1));  
    }
}

ll qmod(ll base, ll n)
{
    ll res = 1;
    while (n)
    {
        if (n & 1) res = res * base % MOD;
        base = base * base % MOD;
        n >>= 1;
    }
    return res;
}

namespace SEG
{
    struct node
    { 
        int cnt;  
        ll sum, lazy; 
        ll S, W;
        void init() 
        {
            sum = 1;  
            lazy = 1;
            S = 0, W = 0;
        }
        void add(ll val, ll SE)
        {
            sum = (sum * qmod(val, cnt)) % MOD; 
            lazy = (lazy * val) % MOD;   
            S |= SE;
            W |= SE;
        } 
        node operator + (const node &other) const
        {
            node res; res.init(); 
            res.sum = (sum * other.sum) % MOD;
            res.S = S | other.S;
            res.cnt = cnt + other.cnt;
            return res;  
        }
    }a[N << 2], res;  
    void pushdown(int id)
    {
        if (a[id].lazy == 1 && a[id].W == 0) return;
        a[id << 1].add(a[id].lazy, a[id].W);
        a[id << 1 | 1].add(a[id].lazy, a[id].W);
        a[id].lazy = 1;    
        a[id].W = 0;
    } 
    void build(int id, int l, int r)
    {
        a[id].init();
        a[id].cnt = (r - l + 1);
        if (l == r) return;
        int mid = (l + r) >> 1;
        build(id << 1, l, mid);
        build(id << 1 | 1, mid + 1, r);
    }
    void update(int id, int l, int r, int ql, int qr, ll val, ll SE)
    {
        if (l >= ql && r <= qr)
        {
            a[id].add(val, SE);
            return;
        }
        int mid = (l + r) >> 1;
        pushdown(id);
        if (ql <= mid) update(id << 1, l, mid, ql, qr, val, SE);
        if (qr > mid) update(id << 1 | 1, mid + 1, r, ql, qr, val, SE);
        a[id] = a[id << 1] + a[id << 1 | 1];
    }
    void query(int id, int l, int r, int ql, int qr)
    {
        if (l >= ql && r <= qr)
        {
            res = res + a[id];
            return;
        }
        int mid = (l + r) >> 1;
        pushdown(id);
        if (ql <= mid) query(id << 1, l, mid, ql, qr);
        if (qr > mid) query(id << 1 | 1, mid + 1, r, ql, qr);
    }
}

int main()
{
    init();
    for (int i = 1; i <= 62; ++i)
        inv[i] = qmod(prime[i], MOD - 2); 
    while (scanf("%d%d", &n, &q) != EOF)
    {
        for (int i = 1; i <= n; ++i) scanf("%d", a + i);
        SEG::build(1, 1, n);
        for (int i = 1; i <= n; ++i)
            SEG::update(1, 1, n, i, i, a[i], b[a[i]]);
        char op[20]; int l, r, x;
        for (int i = 1; i <= q; ++i)
        {
            scanf("%s%d%d", op, &l, &r);
            if (op[0] == 'M')
            {
                scanf("%d", &x); 
                SEG::update(1, 1, n, l, r, x, b[x]);
            }
            else
            {
                SEG::res.init();
                SEG::query(1, 1, n, l, r);
                ll res = SEG::res.sum;
                ll S = SEG::res.S;
                for (int j = 1; j <= 62; ++j)
                    if ((S >> (j - 1)) & 1ll)
                        res = (res * (prime[j] - 1) % MOD * inv[j]) % MOD;
                printf("%lld\n", res);
            }
        }
    }
    return 0;
}