2019北信科题解

北京信息科技大学第十一届程序设计竞赛（重现赛）

这场比赛是我有史以来打过最简单的一场

十分简单

最复杂的名词也就只是简单线段树（区间修改）和记忆化搜索。

题目概况

A，记忆化搜索。n=1e18，得开longlong，用map记忆化。
B，简单快速幂
C，打表找规律
D，简单广搜
E，埃氏筛+暴力深搜
F，map
G，简单数学，边乘边除，不爆精度就可
H，超简单数学题
I，简单线段树，抄板子就好
J，前缀和，二分搜索

A

如果不记忆化就TLE咯

#include<bits/stdc++.h>
#define ll long long
using namespace std;
map <ll, ll> dp;
ll cal(ll n){if(!dp[n]){if(n == 1 || n == 0) dp[n] = 0;    else if(n & 1) dp[n] = cal(n / 2) + cal(n / 2 + 1) + 1;else dp[n] = cal(n / 2) * 2;}return dp[n];
}
int main(){int T;ll n;scanf("%d", &T);while(T--){scanf("%lld", &n);printf("%lld\n", cal(n));}
}

B

快速幂模太简单

#include<bits/stdc++.h>
using namespace std;
static const int Mod = 109;
int poww(int base, int n){int ans = 1;while(n){if(n & 1) ans = (ans * base) % Mod;base = (base * base) % Mod;n >>= 1;}return ans;
}
int main(){int n, m;scanf("%d%d", &n, &m);printf("%d", (n * poww(n-1, m-1)) % Mod);return 0;
}

C

C一看就可以找规律，懒得想了先暴力打表一波

#include<bits/stdc++.h>
using namespace std;
int vis[1000010];
int main(){for(int n = 1; n < 1000000; n++){int cnt = n, now = 1;memset(vis, 0, sizeof(vis));while(cnt > 1){while(vis[now % n + 1]) now = now % n + 1;now =now % n + 1; vis[now] = 1;while(vis[now % n + 1]) now = now % n + 1;now =now % n + 1; cnt--; }printf("n == %-3d, ans = %-3d    ", n, now);}
}

运行出来长这样

可以发现 n = 1， 3， 7， 15， 31，... ，2^k - 1 时，ans == n ；其余情况 ans[n] = ans[n-1] + 2

则可以想到先找到小于n的最大的2^k - 1，然后再xjb+2即可

#include<bits/stdc++.h>
#define ll long long
using namespace std;
long long poww(ll base, ll n){ll ans = 1;while(n){if(n & 1) ans *= base;base *= base;n >>= 1;}return ans;
}
int main(){int T;long long n;cin >> T;while(T--){cin >> n;long long x = n, j = 0;while(x){ x >>= 1; j++;}x = poww(2, j - 1);printf("%lld\n", 2 * (n - x + 1) - 1);}
}

D

简单广搜

#include<bits/stdc++.h>
#include<stdlib.h>
#define MAXN 35
using namespace std;
const int dir[4][2] = {1, 0, -1, 0, 0, 1, 0, -1};
int n, m, cnt = 0, Minlen = 1000;
char Map[MAXN][MAXN];
int vis[MAXN][MAXN];
typedef struct Node{int x, y, len;
}Node;
inline bool in(int x, int y){return x >= 0 && x < n && y >= 0 && y < m;
}
Node New(int x, int y, int len){Node *u = (Node*)malloc(sizeof(Node));//malloc 用于指针u->x = x, u->y = y, u->len = len;return *u;
}
void bfs(int x, int y, int len){queue <Node> q;q.push(New(x, y, len));while(!q.empty()){Node v = q.front(); q.pop();if(vis[v.x][v.y]) continue;//这句话不能省！否则只能过60%数据vis[v.x][v.y] = 1;if(Map[v.x][v.y] == 'e'){cnt++;Minlen = min(Minlen, v.len);continue;}for(int i = 0; i < 4; i++){int nx = v.x + dir[i][0], ny = v.y + dir[i][1];if(in(nx, ny) && !vis[nx][ny] && Map[nx][ny] != '*') q.push(New(nx, ny, v.len + 1));}}
}
int main(){int sx, sy;scanf("%d%d", &n, &m);for(int i = 0; i < n; i++) scanf("%s", Map[i]);for(int i = 0; i < n; i++)for(int j = 0; j < m; j++) if(Map[i][j] == 'k'){sx = i; sy = j;}bfs(sx, sy, 0);if(cnt)printf("%d %d", cnt, Minlen);else printf("-1");return 0;
}

E

这道题我最开始没想到深搜，想成匹配了，一直想不明白怎样才能一个素数只选一次……明明一个vis就能解决的事，差点搞成网络流……

#include<bits/stdc++.h>
#define MAXN 1000
using namespace std;
static const int INF = 1e9;
int n, Min = INF, a[MAXN + 5], judge[MAXN + 5], vis[MAXN + 5];
vector <int> ans[MAXN + 5];
void Init(){//埃式筛素数for(int i = 2; i <= MAXN; i++){if(judge[i])continue;for(int j = i; j <= MAXN; j += i){ans[j].push_back(i);judge[j] = 1;}}
}
void dfs(int now, int sum){if(now == n + 1){Min = min(Min, sum);return;}int tem = a[now];for(int i = 0; i < ans[tem].size(); i++){int t = ans[tem][i];if(vis[t]) continue;vis[t] = 1;dfs(now + 1, sum + t);vis[t] = 0;}
}
int main(){scanf("%d", &n);for(int i = 1; i <= n; i++){scanf("%d", &a[i]);if(n == 1){printf("-1"); return 0;}}Init();dfs(1, 0);if(Min == INF)printf("-1");else printf("%d", Min);return 0;
}

F

直接map就过

#include<bits/stdc++.h>
using namespace std;
static const int INF = 2e9 + 1;
map <int, int> vis1, vis2, vis3, vis4;
int main(){int k, x, y, d = INF, t;scanf("%d", &k);for(int i = 0; i < k; i++){scanf("%d%d", &x, &y);if(d == INF && vis1[x] + vis2[y] + vis3[x + y] + vis4[x - y] > 0) d = i;vis1[x] = vis2[y] = vis3[x + y] = vis4[x - y] = 1;}scanf("%d", &t);while(t--){scanf("%d", &x);printf(x <= d ? "No\n" : "Yes\n");}
}

G

看似概率问题，实际组合问题 $ans = 0.8^m * 0.2^{n-m} *C \binom{m}{n}$

需要注意的是，C(25,50)很大很大，会爆longlong，所以需要边乘边除

//=(4/5)^m * (1/5)^(n-m) * C(m, n);
#include<bits/stdc++.h>
using namespace std;
int main(){int n, m;double ans = 1.0;cin >> n >> m;for(int i = 0; i < n-m; i++) ans = 0.2 * ans * (n - i) / (1 + i);//边乘边除（*0.2 <=> /5）for(int i = n - m; i < n; i++) ans = ans * 0.8;printf("%.4lf", ans);return 0;
}

H

价格越大的折扣越凶就ok，即顺序a[i]与倒序b[i]对应乘积累加

#include<bits/stdc++.h>
#define MAXN 1000
using namespace std;
int a[MAXN + 5];
double b[MAXN + 5];
bool cmp(double x, double y){return x > y;
}
int main(){int T, n;scanf("%d", &T);while(T--){scanf("%d", &n);for(int i = 0; i < n; i++) scanf("%d", &a[i]);for(int i = 0; i < n; i++) scanf("%lf", &b[i]);sort(a, a + n);sort(b, b + n, cmp);double sum = 0.0;for(int i = 0; i < n; i++) sum = sum + b[i] * a[i];printf("%.3lf\n", sum);}return 0;
}

I

超简单线段树，比板子还简单……

#include<bits/stdc++.h>
#define MAXN 100000
using namespace std;
int sum[MAXN << 2], tag[MAXN  << 2];
inline int lson(int node){return node << 1;
}
inline int rson(int node){return node << 1 | 1;
}
inline void push_up(int rt){sum[rt] = sum[lson(rt)] + sum[rson(rt)];
}
inline void push_down(int rt, int l, int r){int mid = (l + r) >> 1;tag[lson(rt)] += tag[rt]; tag[rson(rt)] += tag[rt];sum[lson(rt)] += tag[rt] * (mid - l + 1);sum[rson(rt)] += tag[rt] * (r - mid);tag[rt] = 0;
}
void build(int rt, int l, int r){if(l == r){sum[rt] = 0; return;}int mid = (l + r) >> 1;build(lson(rt), l, mid);build(rson(rt), mid + 1, r);push_up(rt);
}
void add(int rt, int l, int r, int L, int R){if(L <= l && r <= R){sum[rt] += (r - l + 1);tag[rt] += 1;return;}push_down(rt, l, r);int mid = (l + r) >> 1;if(L <= mid) add(lson(rt), l, mid, L, R);if(R > mid) add(rson(rt), mid + 1, r, L, R);push_up(rt);
}
int query(int rt, int l, int r, int node){if(l == r) return sum[rt];push_down(rt, l, r);int mid = (l + r) >> 1;if(node <= mid) return query(lson(rt), l, mid, node);if(node > mid) return query(rson(rt), mid + 1, r, node);return 0;
}
int main(){int n, q, l, r;scanf("%d%d", &n, &q);build(1, 1, n);while(q--){scanf("%d%d", &l, &r);add(1, 1, n, l, r);}for(int i = 1; i <= n; i++) printf("%d ", query(1, 1, n, i));return 0;
}

J

这道题一看就应该想到前缀和

设 b[i] 的前缀和为 sum[i] ，对于第 j 天种下的树 a[j] ,第 i 天（i > j）被砍的高度为 sum[i] - sum[j - 1]

当 sum[i] - sum[j - 1] >= a[j] 即sum[i] >= a[j] + sum[j - 1]时，树就死了。要找到是砍死树的最小的 i

很显然，前缀和sum递增。那找最小的 i 不就是lower_bound么……

#include<bits/stdc++.h>
#define MAXN 100005
using namespace std;
int a[MAXN], b[MAXN];
long long sum[MAXN];
int main(){int n;scanf("%d", &n);for(int i = 1; i <= n; ++i) scanf("%d", &a[i]);for(int i = 1; i <= n; ++i){scanf("%d", &b[i]);sum[i] = sum[i-1] + b[i];}for(int i = 1; i <= n; i++){int d = lower_bound(sum + 1, sum + 1 + n, a[i] + sum[i - 1]) - sum;printf("%d ", d);}return 0;
}