[BISTU校赛]12月12日校赛题解

1001

/*
素数 打表
*/
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;

const int maxn = 1000;
bool isprime[maxn];
int cnt;

void printlist() {
    memset(isprime, true, sizeof(isprime));
    isprime[0] = isprime[1] = false;
    int pedge = int(sqrt(maxn));
    for(int i = 2; i <= pedge; i++) {
        if(isprime[i]) {
            int o = maxn / i;
            for(int j = 2; j <= o; j++) {
                isprime[i*j] = false;
            }
        }
    }
} 

int main() {
    printlist();
    cnt = 0;
    for(int i = 2; i <= 1000; i++) {
        if(isprime[i] && isprime[i-2]) {
            cnt++;
        }
    }
    printf("%d
", cnt);
    return 0;
}

1002

/*
注意n,m=0的情况，会不输出结果，而答案应该是YES
*/
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;

const int maxn = 11111;
char a[maxn];
char b[maxn];
int n, m;

int main() {
    // freopen("in", "r", stdin);
    while(~scanf("%d %d", &n, &m)) {
        memset(a, 0, sizeof(a));
        memset(b, 0, sizeof(b));
        int ans = 0;
        if(n != 0) {        
            scanf("%s", a);
            scanf("%s", b);
        }
        for(int i = 0; i < n; i++) {    //O(n)
            int mi = abs((a[i]-'0')-(b[i]-'0'));
            ans += min(mi, 10-mi);
        }
        if(ans > m) {
            printf("NO
");
        }
        else {
            printf("YES
");
        }
    }
    return 0;
}

1003

/*
数据范围很大，朴素的O(n^2)无法解决
用O(nlgn)以下的排序算法可以解决
*/
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;

const int maxn = 111111;
int r[maxn], p[maxn];
int n, m;
int bucket[10010];

inline void input(int* a, int b) {
    for(int i = 0; i < b; i++) {
        scanf("%d", &a[i]);
    }
}

void buck(int* a, int b) {
    memset(bucket, 0, sizeof(bucket));
    for(int i = 0; i < b; i++) {
        bucket[a[i]]++;
    }
    int cnt = 0;
    for(int i = 0; i < 10010; i++) {    //O(10010+∑bucket[i])=O(n)+k
        if(bucket[i] != 0)
        for(int j = 0; j < bucket[i]; j++) {
            a[cnt++] = i;
        }
    }
}

int main() {
    // freopen("in", "r", stdin);
    while(~scanf("%d %d", &n, &m)) {
        input(r, n);
        input(p, m);
        buck(r, n);
        buck(p, m);
        int cnt = 0;
        for(int i = 0; i < n; i++) {
            if(r[i] >= p[cnt]) {
                cnt++;
            }
        }
        printf("%d
", cnt >= m ? m : cnt);
    }
    return 0;
}

// #include <algorithm>
// #include <iostream>
// #include <iomanip>
// #include <cstring>
// #include <climits>
// #include <complex>
// #include <fstream>
// #include <cassert>
// #include <cstdio>
// #include <bitset>
// #include <vector>
// #include <deque>
// #include <queue>
// #include <stack>
// #include <ctime>
// #include <set>
// #include <map>
// #include <cmath>

// using namespace std;

// const int maxn = 100000;
// int n, m;
// int r[maxn], p[maxn];

// int main() {
//     // freopen("in", "r", stdin);
//     // freopen("out", "w", stdout);
//     while(~scanf("%d %d", &n, &m)) {
//         for(int i = 0; i < n; i++) {
//             scanf("%d", &r[i]);
//         }
//         for(int i = 0; i < m; i++) {
//             scanf("%d", &p[i]);
//         }
//         sort(r, r+n);
//         sort(p, p+m);
//         int cnt = 0;
//         for(int i = 0; i < n; i++) {
//             if(r[i] >= p[cnt]) {
//                 cnt++;
//             }
//         }
//         printf("%d
", cnt > m ? m : cnt);
//     }
// }

1004

/*
简单分析后知道x是没有用的
贪心地选取y的平均数即可
*/
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;

typedef long long ll;
const int maxn = 1000010;
ll n, x, y[maxn];

int main() {
    // freopen("in", "r", stdin);
    int T;
    scanf("%d", &T);
    while(T--) {
        ll ave = 0;
        ll ans = 0;
        scanf("%I64d", &n);
        for(int i = 0; i < n; i++) {
            scanf("%I64d %I64d", &x, &y[i]);
        }
        if(n == 0) {
            printf("0
");
            continue;
        }
        sort(y, y + n);
        ave = n & 1 ? y[n/2] : (y[n/2-1] + y[n/2]) / 2;
        for(int i = 0; i < n; i++) {
            ans += abs(y[i] - ave);
        }
        printf("%I64d
", ans);
    }
    return 0;
}

1005

/*
进制转换模拟即可
贪心求出关键语句
递归输出结果
*/
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;

const int maxn = 11000000;
const char* L = "0123456789ABCDEF";
int r1, r2;
char str[maxn];

void pr(int a,int b) {
    if(a == 0) return;
    pr(a/b, b);
    printf("%c", L[a%b]);
}

int main() {
    // freopen("in", "r", stdin);
    while(~scanf("%s%*c%d %d%*c", str, &r1, &r2)) {
        int lcl = 0, cl = 0, ed = -1;
        for(int i = 0; str[i]; i++) {
            if(str[i] >= 'a' && str[i] <= 'z') {
                ++cl;
            }
            else {
                cl = 0;
            }
            if(lcl < cl) {
                lcl = cl;
                ed = i;
            }
            if(str[i] & 1) {
                pr(str[i], r1);
            }
            else {
                pr(str[i], r2);
            }
        }
        printf("
%d
", lcl);
        for(int i = ed-lcl+1; i <= ed; i++) {
            printf("%c", str[i]+'A'-'a');
        }
        printf("
");
    }
    return 0;
}

1006

/*
首先考虑一个成绩不删除的情况
再每次拿出一个成绩，判断是否合理
*/
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;

const int maxn = 111;
int n, flag, cur;
int s[maxn];
bool vis[maxn];

int main() {
    // freopen("in", "r", stdin);
    while(~scanf("%d", &n)) {
        for(int i = 0; i < n; i++) {
            scanf("%d", &s[i]);
        }
        flag = 0;
        for(int i = 1; i < n; i++) {
            if(s[i-1] <= s[i]) continue;
            flag = 1;
        }
        if(!flag) {
            printf("Yes
");
            continue;
        }
        int tmp[maxn];
        int k = 0;
        for(int i = 0; i < n; i++) {
            memset(vis, 0, sizeof(vis));
            memset(tmp, 0, sizeof(tmp));
            flag = 0;
            vis[i] = 1;
            cur = s[i];
            k = 0;
            for(int j = 0; j < n; j++) {
                if(!vis[j]) tmp[k++] = s[j];
            }
            for(int j = 1; j < k; j++) {
                if(tmp[j-1] <= tmp[j]) continue;
                flag = 1;
                break;
            }
            if(!flag) {
                break;
            }
        }
        if(flag) {
            printf("No
");
        }
        else {
            printf("Yes
");
        }
    }
    return 0;
}

1007

/*
时间要求很严格
贪心+bfs，先找二进制最小的数
再统计里面的1的数量
*/
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;

typedef pair<int, int> PII;
const int maxn = 1010;
const int inf = 0x7f7f7f;
const int dx[4] = {0, 0, 1, -1};
const int dy[4] = {1, -1, 0, 0};

char G[maxn][maxn];
bool vis[maxn][maxn];
int n, m, ans;

inline int max(int x, int y) {
    return x > y ? x : y;
}

inline int min(int x, int y) {
    return x < y ? x : y;
}

bool judge(int x, int y) {
    if(x >= 1 && x <= n && y >= 1 && y <= m) {
        return 1;
    }
    return 0;
}

void bfs() {
    int mx = 2;
    queue<PII> q;
    memset(vis, 0, sizeof(vis));
    q.push(PII(1, 1)); vis[1][1] = 1;
    while(!q.empty()) {
        PII t = q.front(); q.pop();
        if(G[t.first][t.second] == '0') {
            for(int i = 0; i < 4; i++) {
                int xx = t.first + dx[i];
                int yy = t.second + dy[i];
                if(judge(xx, yy) && !vis[xx][yy]) {
                    vis[xx][yy] = 1;
                    mx = max(mx, xx+yy);
                    q.push(PII(xx, yy));
                }
            }
        }
    }
    if(vis[n][m] && G[n][m] == '0') {
        printf("0
");
    }
    else {
        ans += 1;
        for(int i = mx; i < n + m; i++) {
            char mn = '1';
            for(int j = 1; j <= n; j++) {
                if(1 <= i - j && i - j <= m && vis[j][i-j]) {
                    mn = min(mn, min(G[j][i-j+1], G[j+1][i-j]));
                }
            }
            ans += mn - '0';
            for(int j = 1; j <= n; j++) {
                if(1 <= i - j && i - j <= m && vis[j][i-j]) {
                    if (G[j+1][i-j] == mn) {
                        vis[j+1][i-j] = 1;
                    }
                    if (G[j][i-j+1] == mn) {
                        vis[j][i-j+1] = 1;
                    }
                }
            }
        }
        printf("%d
", ans);
    }
}

int main() {
    // freopen("in", "r", stdin);
    int T;
    scanf("%d", &T);
    while(T--) {
        ans = 0;
        scanf("%d %d", &n, &m);
        for(int i = 1; i <= n; i++) {
            scanf("%s", G[i]+1);
        }
        for(int i = 1; i <= n; i++) {
            G[i][0] = G[i][m+1] = '@';
        }
        for(int i = 0; i <= m + 1; i++) {
            G[0][i] = G[n+1][i] = '@';
        }
        bfs();
     }
    return 0;
}

1008

/*
数学推导即可
*/
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;

typedef long long int LL;

LL solve(LL x) {
    if(x == 1) return 1;
    if(x & 1) return solve(x / 2) * 3 + 1;
    return solve(x / 2) * 3;
}

int main() {
    int T;
    scanf("%d", &T);
    while(T--) {
        LL n;
        scanf("%I64d", &n);
        printf("%I64d
", solve(n));
    }
}

1009

/*
组合数学或者dp均可求出
*/
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;

typedef unsigned long long ull;

int n, m;
const ull mod = 10000000000007;
ull memo[1111][1111];

ull solve(int nn, int mm) {
    if(memo[nn][mm] != -1) return memo[nn][mm];
    if(mm > nn / 2) mm = nn - mm;
    return memo[nn][mm] = (solve(nn-1, mm-1) % mod + solve(nn-1, mm) % mod) % mod;
}

int main() {
    memset(memo, -1, sizeof(memo));
    for(int i = 0; i < 1111; i++) {
        memo[i][0] = 1;
        memo[i][1] = i;
        memo[i][i] = 1;
    }
    while(~scanf("%d %d", &n, &m)) {
        ull ans = 0;
        if(n == 1) {
            printf("1
");
            continue;
        }
        int k = m / n;
        for(int i = 0; i <= k; i++) {
            ull p = m - i * n;
            ull q = i;
            if(p < q) swap(p, q);
            ans = (ans % mod + solve(p+q, q) % mod) % mod;
        }
        printf("%llu
", ans % mod);
    }
    return 0;
}

1010

/*
本场码农题
注意题目要求，暴力写即可
*/
#include <algorithm>
#include <iostream>
#include <iomanip>
#include <cstring>
#include <climits>
#include <complex>
#include <fstream>
#include <cassert>
#include <cstdio>
#include <bitset>
#include <vector>
#include <deque>
#include <queue>
#include <stack>
#include <ctime>
#include <set>
#include <map>
#include <cmath>

using namespace std;

const int maxn = 33;
const int maxm = 22;

typedef struct Node {
    char mov[maxn];
    char dir[maxn];
    char art[maxn];
}Node;

bool cmp(Node a, Node b) {
    int mm = strcmp(a.mov, b.mov);
    int dd = strcmp(a.dir, b.dir);
    int aa = strcmp(a.art, b.art);
    if(mm == 0) {
        if(dd == 0) return aa < 0;
        else return dd < 0;            
    }
    else return mm < 0;
}

int n;
Node x[maxm];
const char dir[maxm][maxm] = {"ChristopherNolan", "JohnWoo", "StevenSpielberg", "JamesCameron", "AnLee"};
const char art[maxm][maxm] = {"JenniferLawrence", "EmmaWatson", "ChristianBale", "AnneHathaway", "MattDamon", "TomCruise"};
int flag[maxn];
int num[maxn];
int cntd, cnta;

void init() {
    cntd = 0, cnta = 0;
    memset(flag, 0, sizeof(flag));
    memset(num, 0, sizeof(num));
    for(int i = 0; i <= maxn; i++) {
        memset(x[i].mov, 0, sizeof(x[i].mov));
        memset(x[i].dir, 0, sizeof(x[i].dir));
        memset(x[i].art, 0, sizeof(x[i].art));
    }
}

void input() {
    for(int i = 0; i < n; i++) {
        scanf("%s %s %s", x[i].mov, x[i].dir, x[i].art);
    }
}

void solve() {
    int cnt = 1;
    int cur = 0;
    bool numflag = 0;
    sort(x, x + n, cmp);
    for(int i = 0; i < n; i++) {    //O(n)
        int pp = x[i].mov[strlen(x[i].mov)-1] - '0';
        if(pp == cnt) {
            if(!numflag) {
                cur++;
                numflag = 1;
            }
            num[i] = cur;
            cnt++;
        }
        else {
            if(pp == 1) {
                num[i] = ++cur;
                cnt = 2;
            }
            else {            
                cnt = 1;
                numflag = 0;
            }
        }
    }
    for(int k = 0; k < n; k++) {    //O(n)
        for(int i = 0; i < 5; i++) {
            if(strcmp(x[k].dir, dir[i]) == 0) flag[k]++;
        }
        for(int j = 0; j < 6; j++) {
            if(strcmp(x[k].art, art[j]) == 0) flag[k]++;
        }
    }
    for(int k = cur; k > 0; k--) {    //O(2n)
        int maxo = 0;
        for(int i = 0; i < n; i++) {
            if(num[i] == k) {
                maxo = maxo > flag[i] ? maxo : flag[i];
            }
        }
        for(int i = 0; i < n; i++) {
            if(num[i] == k) {
                flag[i] = maxo;
            }
        }
    }
}

void output() {
    for(int k = 2; k >= 0; k--) {
        for(int i = 0; i < n; i++) {
            if(flag[i] == k) {
                printf("%s
", x[i].mov);
            }
        }
    }
}

int main() {
    // freopen("in", "r", stdin);
    // freopen("out", "w", stdout);
    while(~scanf("%d", &n)) {
        init();
        input();
        solve();
        output();
    }
    return 0;
}