Codeforces Round #291 (Div. 2)

2023-10-26

题目链接contest#514

A. Chewbaсca and Number

不允许有前导零，所以如果第一位是9的话，需要特别考虑，一开始理解错了题意，又WA了呜呜呜……

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
char x[20];
int main()
{
    scanf("%s", x);
    int len = (int)strlen(x);
    for(int i=0, id; i<len; i++)
    {
        id = x[i] - '0';
        if(id > 4)
        {
            if(i == 0 && id == 9) continue;
            id = 9 - id;
            x[i] = id + '0';
        }
    }
    printf("%s\n", x);
    return 0;
}

B. Han Solo and Lazer Gun

由于我考虑到了精度，所以我在这里维护了一个gcd，把每个点对应的直线，维护出了它的对应的斜率还有截距，所以set里面维护了三个东西。最后的答案是set的size了。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e3 + 7;
int N, x, y;
int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
struct node
{
    int x, y;
    node(int a=0, int b=0):x(a), y(b) {}
    inline void _get() { scanf("%d%d", &x, &y); }
}a[maxN];
set<pair<int, pair<int, int>>> st;
int main()
{
    scanf("%d%d%d", &N, &x, &y);
    for(int i=1, k, b, ss, gg; i<=N; i++)
    {
        a[i]._get();
        k = a[i].y - y; b = a[i].x * y - x * a[i].y; ss = a[i].x - x;
        gg = gcd(k, b); gg = gcd(gg, ss);
        k /= gg; b /= gg; ss /= gg;
        st.insert(MP(k, MP(b, ss)));
    }
    printf("%d\n", (int)st.size());
    return 0;
}

C. Watto and Mechanism

这题就比较的坑了，首先是强制改变且仅改变一个点，其次是卡了一部分哈希，所以一定要选一个好的哈希值才是啊！这里最好不要用unsigned long long的自然溢出，会被卡掉了。

当然，若是利用了unordered_map的，一样会被卡内存或者其他，毕竟总不能哈希完了之后再去unordered_map吧，会被卡，亲测。

除了哈希，其他就没什么了，深刻的告诉我了一个好的hash多么重要！

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const ll Hash_1 = 257, mod = 1e9 + 7;
map<ll, bool> mp;
ll B7[600005], B5[600005];
inline void pre_did()
{
    B5[0] = B7[0] = 1;
    for(int i=1; i<=600000; i++)
    {
        B7[i] = B7[i - 1] * Hash_1 % mod;
    }
}
char s[600005];
int N, M;
ll get_Hash(char *ch)
{
    ll fir = 0;
    int len = (int)strlen(ch);
    for(int i=0; i<len; i++)
    {
        fir = fir * Hash_1 % mod + ch[i];
        fir %= mod;
    }
    return fir;
}
int main()
{
    pre_did();
    scanf("%d%d", &N, &M);
    ll val_s;
    for(int i=1; i<=N; i++)
    {
        scanf("%s", s);
        val_s = get_Hash(s);
        mp[val_s] = true;
    }
    int len;
    ll fir, tmp1;
    bool flag;
    while(M--)
    {
        flag = false;
        scanf("%s", s);
        val_s = get_Hash(s);
        fir = val_s % mod;
        tmp1 = fir;
        len = (int)strlen(s);
        for(int i=0; i<len; i++)
        {
            tmp1 = fir;
            if(s[i] == 'a')
            {
                tmp1 += B7[len - i - 1];
                tmp1 %= mod;
                if(mp[tmp1])
                {
                    flag = true;
                    printf("YES\n");
                    break;
                }
                tmp1 += B7[len - i - 1];
                tmp1 %= mod;
                if(mp[tmp1])
                {
                    flag = true;
                    printf("YES\n");
                    break;
                }
            }
            else if(s[i] == 'b')
            {
                tmp1 += B7[len - i - 1];
                tmp1 %= mod;
                if(mp[tmp1])
                {
                    flag = true;
                    printf("YES\n");
                    break;
                }
                tmp1 -= 2 * B7[len - i - 1];
                tmp1 %= mod;
                tmp1 += mod;
                tmp1 %= mod;
                if(mp[tmp1])
                {
                    flag = true;
                    printf("YES\n");
                    break;
                }
            }
            else
            {
                tmp1 -= B7[len - i - 1];
                tmp1 %= mod;
                tmp1 += mod;
                tmp1 %= mod;
                if(mp[tmp1])
                {
                    flag = true;
                    printf("YES\n");
                    break;
                }
                tmp1 -= B7[len - i - 1];
                tmp1 %= mod;
                tmp1 += mod;
                tmp1 %= mod;
                if(mp[tmp1])
                {
                    flag = true;
                    printf("YES\n");
                    break;
                }
            }
        }
        if(!flag) printf("NO\n");
    }
    return 0;
}

D. R2D2 and Droid Army

有N个机器人，每个机器人有M种属性，并且每个属性都有一个“种族值”（姑且这么称呼吧！），然后我们手上有K次机会，可以给所有机器人的某个种族值全降低1，如果降到0了，就不会再降了，现在呢，我们想知道，在这K次操作之后，可以获得最长连续的种族值之和为0的机器人的最长连续长度。

当然，可以操作少于K次。

那么，我们可以首先用线段树（RMQ更好啦！）来维护一下区间最大值，因为这里的最长连续长度是有线性关系的，所以说，我们可以再来个二分答案来维护。

于是乎，这道题就可以解出来了，我们首先二分答案区间连续长度，然后呢，用线段树来判断是否是合法的。更新。

对了，有些特殊情况记得考虑到位哟！

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e5 + 7;
int N, M, K, tree[6][maxN << 2], a[6][maxN];
void buildTree(int *tree, int *a, int rt, int l, int r)
{
    if(l == r)
    {
        tree[rt] = a[l];
        return;
    }
    int mid = HalF;
    buildTree(tree, a, Lson); buildTree(tree, a, Rson);
    tree[rt] = max(tree[lsn], tree[rsn]);
}
int query(int *tree, int rt, int l, int r, int ql, int qr)
{
    if(ql <= l && qr >= r) return tree[rt];
    int mid = HalF;
    if(qr <= mid) return query(tree, QL);
    else if(ql > mid) return query(tree, QR);
    else return max(query(tree, QL), query(tree, QR));
}
int used[6];
bool solve(int len)
{
    memset(used, 0, sizeof(used));
    int sum = 0;
    for(int i=1; i + len - 1 <= N; i++)
    {
        sum = 0;
        for(int j=1; j<=M; j++)
        {
            sum += ( used[j] = query(tree[j], 1, 1, N, i, i + len - 1) );
            if(sum > K) break;
            if(j == M) return true;
        }
    }
    return false;
}
int main()
{
    scanf("%d%d%d", &N, &M, &K);
    for(int i=1; i<=N; i++)
    {
        for(int j=1; j<=M; j++)
        {
            scanf("%d", &a[j][i]);
        }
    }
    for(int i=1; i<=M; i++) buildTree(tree[i], a[i], 1, 1, N);
    int l = 1, r = N, mid = 0, ans = 0;
    while(l <= r)
    {
        mid = (l + r) >> 1;
        if(solve(mid))
        {
            l = mid + 1;
            ans = mid;
        }
        else r = mid - 1;
    }
    if(ans) solve(ans);
    else { memset(used, 0, sizeof(used)); }
    for(int i=1; i<=M; i++) printf("%d%c", used[i], i == M ? '\n' : ' ');
    return 0;
}

E. Darth Vader and Tree

DP+矩阵快速幂优化好题。

算得上是经典问题吧，为了过这道题，特地去学了下矩阵快速幂，以及矩阵构造法。

我们再不考虑x大小的时候，我们可以直接：

$dp(i) = \sum (dp(i - j) * len(j) )$

其中，len(j)是j这个长度的出现次数，也就是输入的。

但是，我们知道，上式的i可能会很大，这里就得要想办法优化，由于这里的d≤100，我们可以在这里考虑优化。

用矩阵维护吧，因为这里有矩阵的性质。

$dp(i) = \sum (dp(i - j) * len(j) )$

$sum(n) = sum(n - 1) + dp(n)$

那么，我们就可以去构造矩阵了，矩阵的大小是101 * 101。因为我们的长度是1～100，所以其中可能会用到dp(1)~dp(100)的值（其实只用到99就可以了，但是方便嘛）。然后就是构造矩阵了。

写在代码里了。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e5 + 7;
const ll mod = 1e9 + 7;
int N, X, d[maxN], len[maxN] = {0};
ll dp[maxN] = {0}, sum[maxN] = {0};
struct matrice
{
    ll a[105][105];
    matrice() { memset(a, 0, sizeof(a)); }
    friend matrice operator * (matrice x, matrice y)       //重载函数，矩阵的乘积得到的新矩阵
    {
        matrice ans;
        for(int i=0; i<=100; i++)
        {
            for(int j=0; j<=100; j++)
            {
                ll tmp = 0;
                for(int k=0; k<=100; k++)
                {
                    tmp=(tmp + x.a[i][k] * y.a[k][j]) % mod;       //最后得到的需要取mod
                }
                ans.a[i][j] = tmp;
            }
        }
        return ans;
    }
    void OUT() { for(int i=0; i<=100; i++) for(int j=0; j<=100; j++) printf("%lld ", a[i][j]); puts(""); }
}Bas, AI, Want;
matrice fast_mi(matrice x, ll ti)
{
    matrice ans;
    for(int i=0; i<=100; i++) ans.a[i][i] = 1;  //构造单位阵
    while(ti)
    {
        if(ti & 1) ans = ans * x;
        x = x * x;
        ti >>= 1;
    }
    return ans;
}
int main()
{
    scanf("%d%d", &N, &X);
    for(int i=1; i<=N; i++) { scanf("%d", &d[i]); len[d[i]]++; }
    dp[0] = 1; sum[0] = 1;
    for(int i=1; i<=100; i++)
    {
        for(int j=i; j>0; j--)
        {
            dp[i] = (dp[i] + dp[i - j] * len[j]) % mod;
        }
        sum[i] = (sum[i - 1] + dp[i]) % mod;
    }
    if(X <= 100) { printf("%lld\n", sum[X]); return 0; }    //不需要矩阵优化
    for(int i=0; i<99; i++)
    {
        Bas.a[i][i + 1] = 1;
    }
    Bas.a[100][100] = 1;  //s(n) = s(n - 1) + dp(n)---(s(n - 1))
    for(int i=0; i<100; i++)    //dp(n) = segma(dp(n - k) * len(k))
    {
        Bas.a[99][i] = len[100 - i];    //dp(n)---solve
        Bas.a[100][i] = len[100 - i];   //s(n) = s(n - 1) + dp(n)---(dp(n))
    }
//    Bas.OUT();
    Bas = fast_mi(Bas, X - 100);
    for(int i=0; i<100; i++) AI.a[i][0] = dp[i + 1];
    AI.a[100][0] = sum[100];
    Want = Bas * AI;
    printf("%lld\n", Want.a[100][0]);
    return 0;
}

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

Codeforces

线段树

二分答案

哈希

DP