codeforces #106 div2 && Weak Win弱鸡赢第三场

这一场难度还算。。适中？

窝太弱啦！小伙伴们都在div1混迹若干年了我还在纠结div2……

 

A. Business trip 大概就是知道这个人每个月浇花的话花生长的长度ai，一年的生长总量要达到k厘米，问最少的浇花月份数。

好多场cf开篇都是这么一道排序+贪心？

#include <stdio.h>
#include <string.h>
#include <vector>
#include <queue>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int mod = 1e9+7;
const int maxn=100005;
int a[15],k;
int main(){
    scanf("%d",&k);
    for (int i=0; i<12; i++) {
        scanf("%d", &a[i]);
    }
    sort(a, a + 12);
    int cnt = 0, sum = 0;
    for (int i=11; i>=0; i--) {
        if (sum >= k) {
            break;
        }
        sum += a[i], cnt++;
    }
    if (sum < k) {
        puts("-1");
    } else {
        printf("%d\n", cnt);
    }
    return 0;
}

 

B. Martian Clock 火星上的时间和地球相似，都是一天24小时一小时60分钟，但是不知道发过来的时间的进制数。求所有可能的进制数，无限输出-1，不可能输出0.

简单判断一下，肯定是当前最大的数字+1为最小的可能的进制数，然后往上算就好啦。超出了24小时60分钟就是判断不合法的条件。无限怎么判呢，这里有一个进制数上限是60，想一想就知道啦。如果分钟数给一个1的话，最大就是59进制。

#include <stdio.h>
#include <string.h>
#include <vector>
#include <queue>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int mod = 1e9+7;
const int maxn=100005;
char s[55], a[55], b[55];
int am = 0, bm = 0, sa = 0, sb = 0;
int conv(char c) {
    if (c>='0' && c<='9')
        return c-'0';
    else
        return c-'A'+10;
}
int calc(char s[], int t) {
    int ret = 0;
    for (int i=0; s[i]; i++) {
        ret = ret * t + conv(s[i]);
    }
    return ret;
}
int main(){
    scanf("%s", s);
    int flag = 0, l1 = 0, l2 = 0, ff = 1, t;
    for (int i=0; s[i]; i++) {
        if (!flag) {
            if (s[i] != ':') {
                if (ff && s[i] == '0') {
                    continue;
                }
                ff = 0;
                a[l1++] = s[i];
                t = conv(s[i]);
                am = max(am, t);
            } else {
                flag = 1;
                ff = 1;
            }
        } else {
            if (ff && s[i] == '0') {
                continue;
            }
            ff = 0;
            b[l2++] = s[i];
            t = conv(s[i]);
            bm = max(bm, t);
        }
    }
    for (int i=max(am, bm)+1; ; i++) {
        sa = calc(a, i), sb = calc(b, i);
        if (sa > 23 || sb > 59) {
            if (i == max(am, bm)+1) {
                puts("0");
                return 0;
            }
            t = i;
            break;
        }
        if (i > 60) {
            puts("-1");
            return 0;
        }
    }
    for (int i=max(am, bm)+1; i<t; i++) {
        printf("%d ",i);
    }
    return 0;
}

 

C. Division into Teams 有n个人，每个人的技能等级是ai，现在要把这些人划成2队，要求每个人都有队，两队人数最多相差1，两队技能等级和最多相差最大的ai。

奇怪的构造。排个序，两两一组维护一下两队的等级差，哪个等级和比较大就把小的那个人分配给它。这样下来差永远不可能大于max{ai}。

#include <stdio.h>
#include <string.h>
#include <vector>
#include <queue>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int mod = 1e9+7;
const int maxn=100005;
struct node {
    int val, i;
    bool operator<(const node &rhs)const {
        return val > rhs.val;
    }
} a[maxn];
int n,a1[maxn],a2[maxn],flag,c1=0,c2=0;
int main(){
    scanf("%d",&n);
    int dif = 0;
    for (int i=1; i<=n; i++) {
        scanf("%d",&a[i].val);
        a[i].i = i;
    }
    sort(a + 1, a + n + 1);
    //for(int i=1;i<=n;i++)printf("=%d,%d=",a[i].val,a[i].i);puts("");
    if (n & 1) {
        flag = 1;
        n--;
    }
    for (int i=1; i<=n; i+=2) {
        if (dif > 0) {
            a1[++c1] = a[i+1].i, a2[++c2] = a[i].i;
            dif -= a[i].val - a[i+1].val;
        } else {
            a2[++c2] = a[i+1].i, a1[++c1] = a[i].i;
            dif += a[i].val - a[i+1].val;
        }
    }
    if (flag) {
        if (dif > 0) {
            a2[++c2] = a[n+1].i;
        } else {
            a1[++c1] = a[n+1].i;
        }
    }
    printf("%d\n", c1);
    for (int i=1; i<=c1; i++) {
        printf("%d%c",a1[i],i==c1?'\n':' ');
    }
    printf("%d\n", c2);
    for (int i=1; i<=c2; i++) {
        printf("%d%c",a2[i],i==c2?'\n':' ');
    }
    return 0;
}

 

D. Coloring Brackets 有一堆括号形如(()())，保证都能配对，现在要给它们染色，染色规则如下：每个括号要么不染色，要么染成红色或蓝色；每一对括号要么左边染色，要么右边染色；两个相邻的括号不能同色。求合法方案数。

dp+dfs。分两种状态讨论：如果当前搜索的l,r正好匹配，那么直接往中间搜处理结果；否则找出和左边括号匹配的点，左段右段分别搜出来然后再处理结果。返回条件是当前只剩下()，单组括号有4种合法方案。

#include <stdio.h>
#include <string.h>
#include <vector>
#include <queue>
#include <stack>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int mod = 1e9+7;
const int maxn=100005;
char s[777];
int f[777][777][3][3], match[777];
stack<int> stk;
void dp(int l, int r) {
    if (l == r - 1) {
        f[l][r][0][1] = f[l][r][0][2] = f[l][r][1][0] = f[l][r][2][0] = 1;
        return;
    }
    if (match[l] == r) {
        dp(l+1, r-1);
        for (int i=0; i<3; i++)
            for (int j=0; j<3; j++) {
                if (j != 1)
                    f[l][r][0][1] = (f[l][r][0][1] + f[l+1][r-1][i][j]) % mod;
                if (i != 1)
                    f[l][r][1][0] = (f[l][r][1][0] + f[l+1][r-1][i][j]) % mod;
                if (j != 2)
                    f[l][r][0][2] = (f[l][r][0][2] + f[l+1][r-1][i][j]) % mod;
                if (i != 2)
                    f[l][r][2][0] = (f[l][r][2][0] + f[l+1][r-1][i][j]) % mod;
                }
    } else {
        dp(l, match[l]); dp(match[l]+1, r);
        for (int i=0; i<3; i++)
            for (int j=0; j<3; j++)
                for (int x=0; x<3; x++)
                    for (int y=0; y<3; y++)
                        if (!((x==1&&y==1) || (x==2&&y==2))) {
                            (f[l][r][i][j] += (1LL * f[l][match[l]][i][x] * f[match[l]+1][r][y][j]) % mod) %= mod;
                        }
    }
}
int main(){
    scanf("%s", s + 1);
    int len = strlen(s + 1);
    for (int i=len; i>0; i--) {
        if (s[i] == ')') {
            stk.push(i);
        } else {
            match[i] = stk.top(); stk.pop();
        }
    }
    dp(1, len);
    int ans = 0;
    for (int i=0; i<3; i++) {
        for (int j=0; j<3; j++) {
            (ans += f[1][len][i][j]) %= mod;
        }
    }
    printf("%d\n", ans);
    return 0;
}

 

E. Martian Strings  有一个字符串s，从里面选择性的挑s[a,b],s[c,d]阅读（1 ≤ a ≤ b < c ≤ d ≤ n），先读前面的再读后面的，现在给你一个美丽词汇的列表，问在这两段之间（一个词可以分在左边一部分和右边一部分）最多能看见多少种这样的词。

众所周知kmp是专门处理字符串匹配的。这个题要求一个词拆成两部分，那么正着匹一遍当前缀，倒着匹一遍当后缀，两边捏巴捏巴能捏起来的就满足题意。注意对长度为1的词的特判。

#include <stdio.h>
#include <string.h>
#include <vector>
#include <queue>
#include <string>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;
const int mod = 1e9+7;
const int maxn=100005;
char t[maxn], p[maxn], tr[maxn], pr[maxn];
int f[maxn], d[2][maxn], flag;
void getFail(char* P, int* f) {
    int m = strlen(P);
    f[0] = 0;
    f[1] = 0;
    for (int i=1; i<m; i++) {
        int j = f[i];
        while (j && P[i] != P[j]) {
            j = f[j];
        }
        f[i+1] = P[i]==P[j] ? j+1 : 0;
    }
}
void find(char* T, char*P, int*f) {
    int n = strlen(T), m = strlen(P);
    getFail(P, f);
    int j = 0;
    for (int i=0; i<n; i++) {
        while (j && P[j] != T[i]) {
            j = f[j];
        }
        if (P[j] == T[i]) {
            j++;
        }
        if (i) {
            d[flag][i] = max(j, d[flag][i-1]);
        } else {
            d[flag][i] = j;
        }
    }
}
int main(){
    scanf("%s", t);
    int n = strlen(t), q, ans = 0;
    strcpy(tr, t); reverse(tr, tr + n);
    scanf("%d", &q);
    while (q--) {
        scanf("%s", p);
        int m = strlen(p);
        if (m == 1) {
            continue;
        }
        strcpy(pr, p); reverse(pr, pr + m);
        flag = 0; getFail(p, f); find(t, p, f);
        flag = 1; getFail(pr, f); find(tr, pr, f);
        for (int i=0; i<n; i++) {
            if (n-i-2 < 0) {
                break;
            }
            if (d[0][i] + d[1][n-i-2] >= m) {
                ans++;
                break;
            }
        }
    }
    printf("%d\n", ans);
    return 0;
}

 

记一个脑残加手残选手数不清1e5有几个零不看样例就交题没想清楚就敲代码的日常。。