2019牛客暑期多校第六场题解ABDJ

A.Garbage Classification

传送门

题意：给你两个串，第一个串s由小写字母组成，第二个串t由dwh组成，长度为26，分别表示字母a到z代表的字符。现在要你判断：

• 如果字符串中‘h’的数量至少占s串长度的25%，输出  “Harmful”
• 如果字符串中‘h’的数量最多占s串长度的10%，输出  “Recyclable”
• 否则，如果字符串中‘d’的数量至少是‘w’的两倍，输出 “Dry”
• 否则输出 “Wet”

题解：判断即可。

代码：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 2e3 + ;
char s[N],t[];
int main() {
    int T, cnt = ;
    for (scanf("%d",&T);T--;) {
        scanf("%s%s",s,t);
        int len = strlen(s);
        printf("Case #%d: ", cnt++);
        int num[] = {},w = , h = , d = ;
        for (int i = ; i < len; i++) num[s[i]-'a']++;
        for (int i = ; i < ; i++) {
            if (t[i] == 'w') w+=num[i];
            if (t[i] == 'h') h+=num[i];
            if (t[i] == 'd') d+=num[i];
        }
        if (h* >= len) printf("Harmful\n");
        else if (h* <= len) printf("Recyclable\n");
        else if (d >=  * w) printf("Dry\n");
        else printf("Wet\n");
    }
    return ;
}

B.Shorten IPv6 Address

传送门

题意：给你一个128长度的二进制串，要转化成IPv6地址的形式，例如 “0:0:123:4567:89ab:0:0:0”（忽略前导0），若有连续两个及以上的0，那么可以把那一段写成“::”，但是注意一个地址中最多有1个“::”。要求输出最短的形式，如果长度相同输出字典序最小的结果。

题解：显然我们将最长连续0的那一段转化为“::”比转化把它短的要优，当有长度相同的连续0时，显然转化中间的比转化两边的优（转化中间的比转化两边的长度要少1），相同且都在首尾或者且都在中间时，显然选转化后面那个更优（‘0’字典序比‘:’小）。

　　     可以将二进制转化为十六进制比较也可以转化为十进制比较，因为C++可以直接%x输出十六进制数所以用十进制比较方便。

　　     想法是对的但是写丑了WA了一下午嘤嘤嘤(╥╯^╰╥)

代码：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
#define maxn 2
const int N = 1e5 + ;
char s[];
int cel(int id) {
    int x = ;
    for (int i = id; i < id + ; i++) x = x *  + s[i]-'';
    return x;
}
int main() {
    int T,t=;
    for (scanf("%d",&T);T--;) {
        scanf("%s",s);
        int pos = -,num = ;
        int a[] = {};
        for (int i = ; i < ; i+=)
            a[i/] = cel(i);
        for (int i = ; i >= ; i--) {
            int cnt = ;
            if (!a[i]) {
                while(i>= && !a[i]) i--,cnt++;
                i++;
                if (cnt == num && pos+num ==  && i) pos = i,num = cnt;
                if (cnt > num) pos = i,num = cnt;
            }
        }
        printf("Case #%d: ",t++);
        for (int i = ; i < ; i++) {
            if ( i == pos) {
                if (pos == ) printf(":");
                printf(":");
                i+=num-;
            }else {
                printf("%x",a[i]);
                if (i!=) printf(":");
            }
        }
        printf("\n");
    }
    return ;
}

十进制

#include <bits/stdc++.h>
#define ll long long
using namespace std;
#define maxn 2
const int N = 1e5 + ;
char s[],ans[][];
bool _is0[];
char cel(int id) {
    int x = ;
    for (int i = id; i < id + ; i++) x = x *  + s[i]-'';
    if (x < ) return x+'';
    return x-+'a';
}
bool judge0(int x){
    int i;
    for (i = ; ans[x][i+]; i++) {
        if (ans[x][i] != '') return false;
        for(int j = i; ans[x][j]; j++) ans[x][j] = ans[x][j+];
            i--;
    }
    return ans[x][i]=='';
}
int main() {
    int T,t=;
    for (scanf("%d",&T);T--;) {
        scanf("%s",s);
        int pos = -;
        int num = ;
        for (int i = , j = ,k = ; i < ; i+=) {
            ans[k][j++] = cel(i);
            if(j == ) ans[k][j] = '\0',j = ,_is0[k]=judge0(k),k++;
        }
        for (int i = ; i >= ; i--) {
            int cnt = ;
            if (_is0[i]) {
                while(i>= && _is0[i]) i--,cnt++;
                i++;
                if (cnt == num && pos+num ==  && i) pos = i,num = cnt;
                if (cnt > num) pos = i,num = cnt;
            }
        }
        printf("Case #%d: ",t++);
        for (int i = ; i < ; i++) {
            if ( i == pos) {
                i+=num-;
                if (pos == ) printf(":");
                printf(":");
            }else {
                printf("%s",ans[i]);
                if (i!=) printf(":");
            }
        }
        printf("\n");
    }
    return ;
}

十六进制

D.Move

传送门

题意：有n件物品，每件物品体积为v_i，用k个相同大小的盒子来装他们，问盒子最小体积可以为多少。

题解：我们知道盒子最小体积为max(a[n],sum/k)，我们可以从最小可能的体积开始枚举，一个个来判断。数据都很小不超过1000所以不会T。

那我们怎么判断呢？我们可以把物品按体积由大到小依次放进盒子里，能放得下就放，否则就放下一个，放不进就表示盒子小了，否则就是答案。

代码：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e3 + ;
const ll INF = 1ll<<;
int a[N],n,m,b[N];
bool check(int x){
    for (int i = ; i <= m; i++) b[i] = x;
    for (int i = n; i >= ; i--) {
        bool fg = ;
        for (int j = ; j <= m; j++)
            if (a[i] <= b[j]) {
                b[j] -= a[i];
                fg = ;
                break;
            }
        if (!fg) return false;
    }
    return true;
}
int main() {
    int T, cnt = ;
    for (scanf("%d",&T);T--;) {
        int sum = ;
        scanf("%d%d",&n,&m);
        for (int i = ; i <= n; i++) {
            scanf("%d",&a[i]);
            sum+=a[i];
        }
        sort(a+,a++n);
        for (int i = max(a[n],sum/m);;i++)
            if (check(i)) {
                printf("Case #%d: %d\n", cnt++,i);
                break;
            }
    }
    return ;
}

J.Upgrading Technology

传送门

题意：有n个技能，每个技能都有m个等级（一开始等级都为0），每升一级需要花费C(i,j)（只能一级一级升），如果每个技能都达到i级，可以得到d_i的利润。可以不升级利润为0,。问能得到的最大利润为多少。

题解：我们可以用前缀和维护每个技能升级的最小花费，倒着更新一遍最小值。然后把每个技能升级到i（可能是以上）所需的最小花费加起来，然后我们维护下每个等级利润d的前缀和，技能最小等级为i时的利润为d的前缀和 - 每个技能升级到i所需的最小花费。这里要注意两个点，一是我们前面维护的每个技能升级到i（可能是以上）所需的最小花费可能把技能等级更新到了i以上，若每个技能等级都在i以上，那么获得的利润就不是d_1~i，而是当前最小技能j的利润和d1~j，所以我们需要保留一个升级到i所需花费与我们维护的最小值差最小的来确保最低等级为i且获得的利润最大。二是注意可能存在有技能等级为0，其他技能升级花费为负的情况。

代码：

#include <bits/stdc++.h>
#define ll long long
using namespace std;
const int N = 1e3 + ;
const ll INF = 1ll<<;
ll a[N][N],c[N][N],b[N];
int main() {
    int T, cnt = ,n,m;
    for (scanf("%d",&T);T--;) {
        scanf("%d%d",&n,&m);
        memset(a,,sizeof(a));
        for (int i = ; i <= n; i++) {
            for (int j = ; j <= m; j++) {
                scanf("%lld",&a[i][j]);
                a[i][j] += a[i][j-];
                c[i][j] = a[i][j];
            }
            a[n+][m] += a[i][m];
            for (int j = m-; j >= ; j--){
                a[i][j] = min(a[i][j],a[i][j+]);
                a[n+][j] += a[i][j];
            }
        }
        b[] = ;
        for (int i = ; i <= m; i++) {
            scanf("%lld",&b[i]);
            b[i] += b[i-];
        }
        ll ans = ;
        for (int i = ; i <= m; i++) {
            int pos = -;
            ll mind = INF,d;
            for (int j = ; j <= n; j++) {
                d = c[j][i] - a[j][i];
                if (d < mind) {
                    mind = d;
                    pos = j;
                }
            }
            ans = max(ans,b[i]-a[n+][i]+a[pos][i]-c[pos][i]);
        }
        printf("Case #%d: %lld\n", cnt++,ans);
    }
    return ;
}