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

1001

 1 /*
 2 素数 打表
 3 */
 4 #include <algorithm>
 5 #include <iostream>
 6 #include <iomanip>
 7 #include <cstring>
 8 #include <climits>
 9 #include <complex>
10 #include <fstream>
11 #include <cassert>
12 #include <cstdio>
13 #include <bitset>
14 #include <vector>
15 #include <deque>
16 #include <queue>
17 #include <stack>
18 #include <ctime>
19 #include <set>
20 #include <map>
21 #include <cmath>
22 
23 using namespace std;
24 
25 const int maxn = 1000;
26 bool isprime[maxn];
27 int cnt;
28 
29 void printlist() {
30     memset(isprime, true, sizeof(isprime));
31     isprime[0] = isprime[1] = false;
32     int pedge = int(sqrt(maxn));
33     for(int i = 2; i <= pedge; i++) {
34         if(isprime[i]) {
35             int o = maxn / i;
36             for(int j = 2; j <= o; j++) {
37                 isprime[i*j] = false;
38             }
39         }
40     }
41 } 
42 
43 int main() {
44     printlist();
45     cnt = 0;
46     for(int i = 2; i <= 1000; i++) {
47         if(isprime[i] && isprime[i-2]) {
48             cnt++;
49         }
50     }
51     printf("%d\n", cnt);
52     return 0;
53 }
1001

 

1002

 1 /*
 2 注意n,m=0的情况,会不输出结果,而答案应该是YES
 3 */
 4 #include <algorithm>
 5 #include <iostream>
 6 #include <iomanip>
 7 #include <cstring>
 8 #include <climits>
 9 #include <complex>
10 #include <fstream>
11 #include <cassert>
12 #include <cstdio>
13 #include <bitset>
14 #include <vector>
15 #include <deque>
16 #include <queue>
17 #include <stack>
18 #include <ctime>
19 #include <set>
20 #include <map>
21 #include <cmath>
22 
23 using namespace std;
24 
25 const int maxn = 11111;
26 char a[maxn];
27 char b[maxn];
28 int n, m;
29 
30 int main() {
31     // freopen("in", "r", stdin);
32     while(~scanf("%d %d", &n, &m)) {
33         memset(a, 0, sizeof(a));
34         memset(b, 0, sizeof(b));
35         int ans = 0;
36         if(n != 0) {        
37             scanf("%s", a);
38             scanf("%s", b);
39         }
40         for(int i = 0; i < n; i++) {    //O(n)
41             int mi = abs((a[i]-'0')-(b[i]-'0'));
42             ans += min(mi, 10-mi);
43         }
44         if(ans > m) {
45             printf("NO\n");
46         }
47         else {
48             printf("YES\n");
49         }
50     }
51     return 0;
52 }
1002

 

1003

  1 /*
  2 数据范围很大,朴素的O(n^2)无法解决
  3 用O(nlgn)以下的排序算法可以解决
  4 */
  5 #include <algorithm>
  6 #include <iostream>
  7 #include <iomanip>
  8 #include <cstring>
  9 #include <climits>
 10 #include <complex>
 11 #include <fstream>
 12 #include <cassert>
 13 #include <cstdio>
 14 #include <bitset>
 15 #include <vector>
 16 #include <deque>
 17 #include <queue>
 18 #include <stack>
 19 #include <ctime>
 20 #include <set>
 21 #include <map>
 22 #include <cmath>
 23 
 24 using namespace std;
 25 
 26 const int maxn = 111111;
 27 int r[maxn], p[maxn];
 28 int n, m;
 29 int bucket[10010];
 30 
 31 inline void input(int* a, int b) {
 32     for(int i = 0; i < b; i++) {
 33         scanf("%d", &a[i]);
 34     }
 35 }
 36 
 37 void buck(int* a, int b) {
 38     memset(bucket, 0, sizeof(bucket));
 39     for(int i = 0; i < b; i++) {
 40         bucket[a[i]]++;
 41     }
 42     int cnt = 0;
 43     for(int i = 0; i < 10010; i++) {    //O(10010+∑bucket[i])=O(n)+k
 44         if(bucket[i] != 0)
 45         for(int j = 0; j < bucket[i]; j++) {
 46             a[cnt++] = i;
 47         }
 48     }
 49 }
 50 
 51 int main() {
 52     // freopen("in", "r", stdin);
 53     while(~scanf("%d %d", &n, &m)) {
 54         input(r, n);
 55         input(p, m);
 56         buck(r, n);
 57         buck(p, m);
 58         int cnt = 0;
 59         for(int i = 0; i < n; i++) {
 60             if(r[i] >= p[cnt]) {
 61                 cnt++;
 62             }
 63         }
 64         printf("%d\n", cnt >= m ? m : cnt);
 65     }
 66     return 0;
 67 }
 68 
 69 // #include <algorithm>
 70 // #include <iostream>
 71 // #include <iomanip>
 72 // #include <cstring>
 73 // #include <climits>
 74 // #include <complex>
 75 // #include <fstream>
 76 // #include <cassert>
 77 // #include <cstdio>
 78 // #include <bitset>
 79 // #include <vector>
 80 // #include <deque>
 81 // #include <queue>
 82 // #include <stack>
 83 // #include <ctime>
 84 // #include <set>
 85 // #include <map>
 86 // #include <cmath>
 87 
 88 // using namespace std;
 89 
 90 // const int maxn = 100000;
 91 // int n, m;
 92 // int r[maxn], p[maxn];
 93 
 94 // int main() {
 95 //     // freopen("in", "r", stdin);
 96 //     // freopen("out", "w", stdout);
 97 //     while(~scanf("%d %d", &n, &m)) {
 98 //         for(int i = 0; i < n; i++) {
 99 //             scanf("%d", &r[i]);
100 //         }
101 //         for(int i = 0; i < m; i++) {
102 //             scanf("%d", &p[i]);
103 //         }
104 //         sort(r, r+n);
105 //         sort(p, p+m);
106 //         int cnt = 0;
107 //         for(int i = 0; i < n; i++) {
108 //             if(r[i] >= p[cnt]) {
109 //                 cnt++;
110 //             }
111 //         }
112 //         printf("%d\n", cnt > m ? m : cnt);
113 //     }
114 // }
1003

 

 

1004

 1 /*
 2 简单分析后知道x是没有用的
 3 贪心地选取y的平均数即可
 4 */
 5 #include <algorithm>
 6 #include <iostream>
 7 #include <iomanip>
 8 #include <cstring>
 9 #include <climits>
10 #include <complex>
11 #include <fstream>
12 #include <cassert>
13 #include <cstdio>
14 #include <bitset>
15 #include <vector>
16 #include <deque>
17 #include <queue>
18 #include <stack>
19 #include <ctime>
20 #include <set>
21 #include <map>
22 #include <cmath>
23 
24 using namespace std;
25 
26 typedef long long ll;
27 const int maxn = 1000010;
28 ll n, x, y[maxn];
29 
30 int main() {
31     // freopen("in", "r", stdin);
32     int T;
33     scanf("%d", &T);
34     while(T--) {
35         ll ave = 0;
36         ll ans = 0;
37         scanf("%I64d", &n);
38         for(int i = 0; i < n; i++) {
39             scanf("%I64d %I64d", &x, &y[i]);
40         }
41         if(n == 0) {
42             printf("0\n");
43             continue;
44         }
45         sort(y, y + n);
46         ave = n & 1 ? y[n/2] : (y[n/2-1] + y[n/2]) / 2;
47         for(int i = 0; i < n; i++) {
48             ans += abs(y[i] - ave);
49         }
50         printf("%I64d\n", ans);
51     }
52     return 0;
53 }
1004

 

1005

 1 /*
 2 进制转换模拟即可
 3 贪心求出关键语句
 4 递归输出结果
 5 */
 6 #include <algorithm>
 7 #include <iostream>
 8 #include <iomanip>
 9 #include <cstring>
10 #include <climits>
11 #include <complex>
12 #include <fstream>
13 #include <cassert>
14 #include <cstdio>
15 #include <bitset>
16 #include <vector>
17 #include <deque>
18 #include <queue>
19 #include <stack>
20 #include <ctime>
21 #include <set>
22 #include <map>
23 #include <cmath>
24 
25 using namespace std;
26 
27 const int maxn = 11000000;
28 const char* L = "0123456789ABCDEF";
29 int r1, r2;
30 char str[maxn];
31 
32 void pr(int a,int b) {
33     if(a == 0) return;
34     pr(a/b, b);
35     printf("%c", L[a%b]);
36 }
37 
38 int main() {
39     // freopen("in", "r", stdin);
40     while(~scanf("%s%*c%d %d%*c", str, &r1, &r2)) {
41         int lcl = 0, cl = 0, ed = -1;
42         for(int i = 0; str[i]; i++) {
43             if(str[i] >= 'a' && str[i] <= 'z') {
44                 ++cl;
45             }
46             else {
47                 cl = 0;
48             }
49             if(lcl < cl) {
50                 lcl = cl;
51                 ed = i;
52             }
53             if(str[i] & 1) {
54                 pr(str[i], r1);
55             }
56             else {
57                 pr(str[i], r2);
58             }
59         }
60         printf("\n%d\n", lcl);
61         for(int i = ed-lcl+1; i <= ed; i++) {
62             printf("%c", str[i]+'A'-'a');
63         }
64         printf("\n");
65     }
66     return 0;
67 }
1005

 

1006

 1 /*
 2 首先考虑一个成绩不删除的情况
 3 再每次拿出一个成绩,判断是否合理
 4 */
 5 #include <algorithm>
 6 #include <iostream>
 7 #include <iomanip>
 8 #include <cstring>
 9 #include <climits>
10 #include <complex>
11 #include <fstream>
12 #include <cassert>
13 #include <cstdio>
14 #include <bitset>
15 #include <vector>
16 #include <deque>
17 #include <queue>
18 #include <stack>
19 #include <ctime>
20 #include <set>
21 #include <map>
22 #include <cmath>
23 
24 using namespace std;
25 
26 const int maxn = 111;
27 int n, flag, cur;
28 int s[maxn];
29 bool vis[maxn];
30 
31 int main() {
32     // freopen("in", "r", stdin);
33     while(~scanf("%d", &n)) {
34         for(int i = 0; i < n; i++) {
35             scanf("%d", &s[i]);
36         }
37         flag = 0;
38         for(int i = 1; i < n; i++) {
39             if(s[i-1] <= s[i]) continue;
40             flag = 1;
41         }
42         if(!flag) {
43             printf("Yes\n");
44             continue;
45         }
46         int tmp[maxn];
47         int k = 0;
48         for(int i = 0; i < n; i++) {
49             memset(vis, 0, sizeof(vis));
50             memset(tmp, 0, sizeof(tmp));
51             flag = 0;
52             vis[i] = 1;
53             cur = s[i];
54             k = 0;
55             for(int j = 0; j < n; j++) {
56                 if(!vis[j]) tmp[k++] = s[j];
57             }
58             for(int j = 1; j < k; j++) {
59                 if(tmp[j-1] <= tmp[j]) continue;
60                 flag = 1;
61                 break;
62             }
63             if(!flag) {
64                 break;
65             }
66         }
67         if(flag) {
68             printf("No\n");
69         }
70         else {
71             printf("Yes\n");
72         }
73     }
74     return 0;
75 }
1006

 

1007

  1 /*
  2 时间要求很严格
  3 贪心+bfs,先找二进制最小的数
  4 再统计里面的1的数量
  5 */
  6 #include <algorithm>
  7 #include <iostream>
  8 #include <iomanip>
  9 #include <cstring>
 10 #include <climits>
 11 #include <complex>
 12 #include <fstream>
 13 #include <cassert>
 14 #include <cstdio>
 15 #include <bitset>
 16 #include <vector>
 17 #include <deque>
 18 #include <queue>
 19 #include <stack>
 20 #include <ctime>
 21 #include <set>
 22 #include <map>
 23 #include <cmath>
 24 
 25 using namespace std;
 26 
 27 typedef pair<int, int> PII;
 28 const int maxn = 1010;
 29 const int inf = 0x7f7f7f;
 30 const int dx[4] = {0, 0, 1, -1};
 31 const int dy[4] = {1, -1, 0, 0};
 32 
 33 char G[maxn][maxn];
 34 bool vis[maxn][maxn];
 35 int n, m, ans;
 36 
 37 inline int max(int x, int y) {
 38     return x > y ? x : y;
 39 }
 40 
 41 inline int min(int x, int y) {
 42     return x < y ? x : y;
 43 }
 44 
 45 bool judge(int x, int y) {
 46     if(x >= 1 && x <= n && y >= 1 && y <= m) {
 47         return 1;
 48     }
 49     return 0;
 50 }
 51 
 52 void bfs() {
 53     int mx = 2;
 54     queue<PII> q;
 55     memset(vis, 0, sizeof(vis));
 56     q.push(PII(1, 1)); vis[1][1] = 1;
 57     while(!q.empty()) {
 58         PII t = q.front(); q.pop();
 59         if(G[t.first][t.second] == '0') {
 60             for(int i = 0; i < 4; i++) {
 61                 int xx = t.first + dx[i];
 62                 int yy = t.second + dy[i];
 63                 if(judge(xx, yy) && !vis[xx][yy]) {
 64                     vis[xx][yy] = 1;
 65                     mx = max(mx, xx+yy);
 66                     q.push(PII(xx, yy));
 67                 }
 68             }
 69         }
 70     }
 71     if(vis[n][m] && G[n][m] == '0') {
 72         printf("0\n");
 73     }
 74     else {
 75         ans += 1;
 76         for(int i = mx; i < n + m; i++) {
 77             char mn = '1';
 78             for(int j = 1; j <= n; j++) {
 79                 if(1 <= i - j && i - j <= m && vis[j][i-j]) {
 80                     mn = min(mn, min(G[j][i-j+1], G[j+1][i-j]));
 81                 }
 82             }
 83             ans += mn - '0';
 84             for(int j = 1; j <= n; j++) {
 85                 if(1 <= i - j && i - j <= m && vis[j][i-j]) {
 86                     if (G[j+1][i-j] == mn) {
 87                         vis[j+1][i-j] = 1;
 88                     }
 89                     if (G[j][i-j+1] == mn) {
 90                         vis[j][i-j+1] = 1;
 91                     }
 92                 }
 93             }
 94         }
 95         printf("%d\n", ans);
 96     }
 97 }
 98 
 99 int main() {
100     // freopen("in", "r", stdin);
101     int T;
102     scanf("%d", &T);
103     while(T--) {
104         ans = 0;
105         scanf("%d %d", &n, &m);
106         for(int i = 1; i <= n; i++) {
107             scanf("%s", G[i]+1);
108         }
109         for(int i = 1; i <= n; i++) {
110             G[i][0] = G[i][m+1] = '@';
111         }
112         for(int i = 0; i <= m + 1; i++) {
113             G[0][i] = G[n+1][i] = '@';
114         }
115         bfs();
116      }
117     return 0;
118 }
1007

 

1008

 1 /*
 2 数学推导即可
 3 */
 4 #include <algorithm>
 5 #include <iostream>
 6 #include <iomanip>
 7 #include <cstring>
 8 #include <climits>
 9 #include <complex>
10 #include <fstream>
11 #include <cassert>
12 #include <cstdio>
13 #include <bitset>
14 #include <vector>
15 #include <deque>
16 #include <queue>
17 #include <stack>
18 #include <ctime>
19 #include <set>
20 #include <map>
21 #include <cmath>
22 
23 using namespace std;
24 
25 typedef long long int LL;
26 
27 LL solve(LL x) {
28     if(x == 1) return 1;
29     if(x & 1) return solve(x / 2) * 3 + 1;
30     return solve(x / 2) * 3;
31 }
32 
33 int main() {
34     int T;
35     scanf("%d", &T);
36     while(T--) {
37         LL n;
38         scanf("%I64d", &n);
39         printf("%I64d\n", solve(n));
40     }
41 }
1008

 

1009

 1 /*
 2 组合数学或者dp均可求出
 3 */
 4 #include <algorithm>
 5 #include <iostream>
 6 #include <iomanip>
 7 #include <cstring>
 8 #include <climits>
 9 #include <complex>
10 #include <fstream>
11 #include <cassert>
12 #include <cstdio>
13 #include <bitset>
14 #include <vector>
15 #include <deque>
16 #include <queue>
17 #include <stack>
18 #include <ctime>
19 #include <set>
20 #include <map>
21 #include <cmath>
22 
23 using namespace std;
24 
25 typedef unsigned long long ull;
26 
27 int n, m;
28 const ull mod = 10000000000007;
29 ull memo[1111][1111];
30 
31 ull solve(int nn, int mm) {
32     if(memo[nn][mm] != -1) return memo[nn][mm];
33     if(mm > nn / 2) mm = nn - mm;
34     return memo[nn][mm] = (solve(nn-1, mm-1) % mod + solve(nn-1, mm) % mod) % mod;
35 }
36 
37 int main() {
38     memset(memo, -1, sizeof(memo));
39     for(int i = 0; i < 1111; i++) {
40         memo[i][0] = 1;
41         memo[i][1] = i;
42         memo[i][i] = 1;
43     }
44     while(~scanf("%d %d", &n, &m)) {
45         ull ans = 0;
46         if(n == 1) {
47             printf("1\n");
48             continue;
49         }
50         int k = m / n;
51         for(int i = 0; i <= k; i++) {
52             ull p = m - i * n;
53             ull q = i;
54             if(p < q) swap(p, q);
55             ans = (ans % mod + solve(p+q, q) % mod) % mod;
56         }
57         printf("%llu\n", ans % mod);
58     }
59     return 0;
60 }
1009

 

1010

  1 /*
  2 本场码农题
  3 注意题目要求,暴力写即可
  4 */
  5 #include <algorithm>
  6 #include <iostream>
  7 #include <iomanip>
  8 #include <cstring>
  9 #include <climits>
 10 #include <complex>
 11 #include <fstream>
 12 #include <cassert>
 13 #include <cstdio>
 14 #include <bitset>
 15 #include <vector>
 16 #include <deque>
 17 #include <queue>
 18 #include <stack>
 19 #include <ctime>
 20 #include <set>
 21 #include <map>
 22 #include <cmath>
 23 
 24 using namespace std;
 25 
 26 const int maxn = 33;
 27 const int maxm = 22;
 28 
 29 typedef struct Node {
 30     char mov[maxn];
 31     char dir[maxn];
 32     char art[maxn];
 33 }Node;
 34 
 35 bool cmp(Node a, Node b) {
 36     int mm = strcmp(a.mov, b.mov);
 37     int dd = strcmp(a.dir, b.dir);
 38     int aa = strcmp(a.art, b.art);
 39     if(mm == 0) {
 40         if(dd == 0) return aa < 0;
 41         else return dd < 0;            
 42     }
 43     else return mm < 0;
 44 }
 45 
 46 int n;
 47 Node x[maxm];
 48 const char dir[maxm][maxm] = {"ChristopherNolan", "JohnWoo", "StevenSpielberg", "JamesCameron", "AnLee"};
 49 const char art[maxm][maxm] = {"JenniferLawrence", "EmmaWatson", "ChristianBale", "AnneHathaway", "MattDamon", "TomCruise"};
 50 int flag[maxn];
 51 int num[maxn];
 52 int cntd, cnta;
 53 
 54 void init() {
 55     cntd = 0, cnta = 0;
 56     memset(flag, 0, sizeof(flag));
 57     memset(num, 0, sizeof(num));
 58     for(int i = 0; i <= maxn; i++) {
 59         memset(x[i].mov, 0, sizeof(x[i].mov));
 60         memset(x[i].dir, 0, sizeof(x[i].dir));
 61         memset(x[i].art, 0, sizeof(x[i].art));
 62     }
 63 }
 64 
 65 void input() {
 66     for(int i = 0; i < n; i++) {
 67         scanf("%s %s %s", x[i].mov, x[i].dir, x[i].art);
 68     }
 69 }
 70 
 71 void solve() {
 72     int cnt = 1;
 73     int cur = 0;
 74     bool numflag = 0;
 75     sort(x, x + n, cmp);
 76     for(int i = 0; i < n; i++) {    //O(n)
 77         int pp = x[i].mov[strlen(x[i].mov)-1] - '0';
 78         if(pp == cnt) {
 79             if(!numflag) {
 80                 cur++;
 81                 numflag = 1;
 82             }
 83             num[i] = cur;
 84             cnt++;
 85         }
 86         else {
 87             if(pp == 1) {
 88                 num[i] = ++cur;
 89                 cnt = 2;
 90             }
 91             else {            
 92                 cnt = 1;
 93                 numflag = 0;
 94             }
 95         }
 96     }
 97     for(int k = 0; k < n; k++) {    //O(n)
 98         for(int i = 0; i < 5; i++) {
 99             if(strcmp(x[k].dir, dir[i]) == 0) flag[k]++;
100         }
101         for(int j = 0; j < 6; j++) {
102             if(strcmp(x[k].art, art[j]) == 0) flag[k]++;
103         }
104     }
105     for(int k = cur; k > 0; k--) {    //O(2n)
106         int maxo = 0;
107         for(int i = 0; i < n; i++) {
108             if(num[i] == k) {
109                 maxo = maxo > flag[i] ? maxo : flag[i];
110             }
111         }
112         for(int i = 0; i < n; i++) {
113             if(num[i] == k) {
114                 flag[i] = maxo;
115             }
116         }
117     }
118 }
119 
120 void output() {
121     for(int k = 2; k >= 0; k--) {
122         for(int i = 0; i < n; i++) {
123             if(flag[i] == k) {
124                 printf("%s\n", x[i].mov);
125             }
126         }
127     }
128 }
129 
130 int main() {
131     // freopen("in", "r", stdin);
132     // freopen("out", "w", stdout);
133     while(~scanf("%d", &n)) {
134         init();
135         input();
136         solve();
137         output();
138     }
139     return 0;
140 }
1010

 

你可能感兴趣的:([BISTU校赛]12月12日校赛题解)