A.牛牛和牛可乐的赌约 #逆元 #快速幂
题目链接
题意
(n)面骰子（点数分别从(1)到(n)，掷出每面的概率为(frac{1} {n})），先让你投(m)次骰子，如果全部投出点数为(n)点面。你在计算输的概率，请输出分数(p/q mod 1e9+7)。
分析
显然，P(输)(=1- (frac{1}{n})^m=frac{(n-1)^m}{n^m})，但注意题目要求你求出P(输)在(mod 1e9+7)意义下的值，故先对分子进行快速幂，再对分母(n^m)求出其逆元(inv(n^m))。考虑到模数为质数，直接使用费马小定理+快速幂即可得到逆元。
费马小定理：若(p)为素数，(a)为正整数，且(a、p)互质，则有(a^{p-1}equiv 1（mod p）)。
由于逆元(x)满足$a imes x equiv 1(mod p) Rightarrow a imes x equiv a^{p-1}(mod p) Rightarrow xequiv a^{p-2}(mod p) $
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <cstring>
#include <vector>
#include <cmath>
#include <unordered_map>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
const int MAXN = 55;
ll qpow(ll base, ll power, ll mymod){
ll ans = 1;
while(power > 0){
if(power & 1)
ans = ans * base % mymod;
power >>= 1;
base = (base * base) % mymod;
}
return ans;
}
ll Inv(ll a, ll mymod){
return qpow(a, mymod - (ll)2, mymod);
}
int main() {
int q;
scanf("%d", &q);
while(q--){
ll n, m;
scanf("%lld%lld", &n, &m);
ll a = qpow(n, m, (ll)MOD);
ll b = Inv(a, (ll)MOD);
printf("%lld
", ((ll)(a - 1) * b) % ((ll)MOD));
}
}
B.牛牛和牛可乐的赌约2 #博弈论 #打表
题目链接
题意
一个棋盘游戏，棋盘左上角为((0,0))，该棋盘在((x, y))的位置有一棋子，你和(Bob)轮流移动该棋子，可左移也可上移，可移动一格或者两格，直到不能在移动(即到达((0,0)))的那个人为输。
你第一个出手，若游戏过程中两个人都用最优策略，最后你是否能够获胜。
分析
感谢@秃头小白的文章讲解。
显然((0,0))为必败态。而若((x,y))周围((x−1,y)(x−2,y)(x,y−1)(x,y−2))存在一点为必败态，则该点是必胜态。
for (int i = 1; i <= 45; i++) {
for (int j = 1; j <= 45; j++) {
bool ans = 1;
//寻找必败点
if (i > 2) ans &= vis[i - 2][j];
if (j > 2) ans &= vis[i][j - 2];
if (i > 1) ans &= vis[i - 1][j];
if (j > 1) ans &= vis[i][j - 1];
vis[i][j] = !ans;
}
}
for (int i = 1; i <= 45; i++) {
for (int j = 1; j <= 45; j++) {
printf("%d ", vis[i][j]);
}
printf("
");
}
通过打出P-N表格，我们就能观察本题隐藏的性质，注意到
该表格对(3 imes 3)矩阵分形，预先处理(3 imes 3)矩阵后，判断询问点在该矩阵位置即可。
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <cstring>
#include <vector>
#include <cmath>
#include <unordered_map>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
const int MAXN = 55;
string str;
bool vis[MAXN][MAXN];
bool ans[4][4] = {{0, 1, 1}, {1, 0, 1}, {1, 1, 0}};
int main() {
int q;
scanf("%d", &q);
while(q--){
int i, j; scanf("%d%d", &i, &j);
if(ans[i % 3][j % 3]) printf("yyds
");
else printf("awsl
");
}
}
C.单词记忆方法 #递归 #分治
题目链接
题意
每个字母都有一个权值，(A)权值为(1)，(B)权值为(2)，… 依次类推。现要你求出一个字符串所有字母的权值总和，注意该字符串存在括号及数字，如(ABCABC、(ABC)2、HHHH、(H2)2、H4)，形如化学式。
分析
其实这题就是CCF CSP201912-3的化学方程式的弱化版，只不过你不用判断等式两边是否相等，只需考虑一个化学式中有多少个原子即可。
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <cstring>
#include <vector>
#include <cmath>
#include <unordered_map>
using namespace std;
string str;
ll vis[4], ans;
ll getDigit(int& lo, int hi){
ll res = 0;
while(lo <= hi && isdigit(str[lo]))
res = res * (ll)10 + (ll)(str[lo++] - '0');
return res == 0 ? 1 : res;
}
void Compute(int lo, int hi, ll val){
if(lo == hi){
ans += (val * (ll)(str[lo] - 'A' + 1));
return;
}
val *= (ll)getDigit(lo, hi);
for (int i = lo, j = i + 1; i <= hi; i = j, j++){
if('A' <= str[i] && str[i] <= 'Z'){
int tmp = j;
Compute(i, j - 1, val * (ll)getDigit(tmp, hi));
}
else if(str[i] == '('){
for (int cnt = 1; cnt != 0; j++){
if(str[j] == '(') cnt++;
else if(str[j] == ')') cnt--;
}
int tmp = j;
Compute(i + 1, j - 1, val * (ll)getDigit(tmp, hi));
}
}
}
int main(){
cin >> str;
Compute(0, str.length(), 1);
printf("%lld
", ans);
}
D.位运算之谜
题目链接
题意
(a+b)的值为(x)，(a&b)的值为(y)，首先需要判断能否有一组(a, b)满足当前的情况，如果有，那么求出(a xor b)，否则输出(-1)
分析
实际上该题并不需要我们将(a,b)的具体值求出来，我们知道异或和即是不进位的加法，我们现在知道(a+b)的结果，又因为((a&b)<<1)模拟(a+b)的进位。正常的加法运算 (a+b = a xor b+((a&b)<<1))。
当(a+b - ((a & b ) << 1))如果是负数，显然无法存在(a,b)满足题意，因为(a xor b)一定不为负。另外，还有一个排除条件，由于(a&b)与(a xor b)一定取反，也就说两者按位与一定为(0)。
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <cstring>
#include <vector>
#include <cmath>
#include <unordered_map>
using namespace std;
typedef long long ll;
ll x, y;
int main(){
int q; scanf("%d", &q);
while(q--){
scanf("%lld%lld", &x, &y);
ll ans = x - (ll)(y << 1);
if(ans < 0 || ans & y) printf("-1
");
else if(ans >= 0) printf("%lld
", ans);
}
}
F.牛牛的健身运动 #三分思想
题目链接
题意
(m)天中，牛牛选其中一天来锻炼。每天有(n)件器材。第(k)天的第(i)种器材能够增加(k*a_i+b_i)力量。由于某种原因，牛牛只能在当天选择所有器材中增加力量值最小的两件（且两件不能相同）。牛牛希望能够选择某一天，使得他增加力量值最大，现要你求出他最多增加的力量。
分析
每一天牛牛只能选择力量值最小的两件，也就说假定现在为第(k)天，则他只能增加(y_k=min(k*(a_i+a_j)+(b_i+b_j), 1leq i,j leq n))力量值，显然需要枚举两两器材搭配取得这一最小值。
但牛牛又希望从所有天中的最小值(y_k(1leq k leq m))取得最大值，求给定区间的最大值，用三分查找的算法较为适合。
#include <string>
#include <cstring>
#include <cstdio>
#include <iostream>
#include <stack>
#include <queue>
#include <map>
#include <vector>
#include <deque>
#include <cmath>
#include <algorithm>
#include <unordered_map>
using namespace std;
typedef long long ll;
const int MAXN = 2e3 + 5;
int n, m;
ll a[MAXN], b[MAXN];
ll Check(int x) { //获得当天增加力量最小值
ll mymin = 0x3f3f3f3f3f3f3f3f;
for (int i = 1; i <= n; i++)
for (int j = i + 1; j <= n; j++)
mymin = min(mymin, (a[i] + a[j]) * (ll)x + (b[i] + b[j]));
return mymin;
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) scanf("%lld%lld", &a[i], &b[i]);
int lo = 1, hi = m;
ll ans = -0x3f3f3f3f3f3f3f3f;
while (lo + 10 < hi) { //缩小区间
int mid1 = lo + (hi - lo) / 3;
int mid2 = hi - (hi - lo) / 3;
if (Check(mid1) <= Check(mid2)) lo = mid1;
else hi = mid2;
}
for (int i = lo; i <= hi; i++) ans = max(ans, Check(i)); //在小区间枚举比较最值
printf("%lld
", ans);
return 0;
}
G.牛牛和字符串的日常 #KMP
题目链接
题意
给定喜欢句子，如果今日读的书中某连续(k)个字符恰好为喜欢句子的某个前缀，那么能够加(k)分。然而每天只能注意到一次自己喜欢的句子（即只能加分一次），你需要尽可能找到加分高的句子。现要求(n)天后总共最多能有多少分
分析
由数据规模可知只能满足(O(n))或更低的算法。直接用KMP模板即可，求出模式串（即喜欢句子）最长匹配长度。
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <cstring>
#include <vector>
#include <cmath>
#include <unordered_map>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
const int MAXN = 1e5 + 5;
int nextTable[MAXN];
void buildNext(string str){
int comlen = nextTable[0] = -1;
int len = str.length(), i = 0;
while(i < (len - 1)){
if(comlen == -1 || str[i] == str[comlen]){
i++;
comlen++;
nextTable[i] = comlen;
}
else comlen = nextTable[comlen];
}
}
int KMP(string str, string T){
int i = 0, j = 0;
int res = -1;
while(i < (int)T.length() && j < (int)str.length()){
if(j < 0 || T[i] == str[j]){
i++; j++;
}
else j = nextTable[j];
res = max(res, j); //需添加的语句，更新模式串最长匹配长度
}
return res;
}
int main(){
string str; cin >> str; buildNext(str);
int n, ans = 0; scanf("%d", &n);
for (int i = 1; i <= n; i++){
string tmp; cin >> tmp;
ans += KMP(str, tmp);
}
printf("%d
", ans);
}
H.上学要迟到了 #单源最短路径
题目链接
题意
你去学校的路是一条总共有(n)个公交车站的直线，且车站之间距离相等，每个车站只有一种对应的公交车(a_i)，且每个公交车只在对应站停下。而第(i)种公交车到达其下一个对应车站所需时间为(t_i)，且单向行驶（从左到右）。而走路可以任意方向走，但步行走一站需(T)时间。你的家在(s)，学校在(t)，求到达学校最短时间。
分析
这题其实不难，但是要注意两个隐藏细节(wa了好多发)：
- 虽然公交车是单向，但人步行可以双向！
- 公交车从一个对应站到另一个对应站，无论距离多长，耗费时间固定！
接下来，给人步行路径建双向边，给每种车的途径站建单向边，用(Dijkstra)算法求出路径即可。
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <cstring>
#include <vector>
#include <cmath>
#include <unordered_map>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
const int MAXN = 1e5 + 5;
typedef struct Edge{
int to, w;
} Edge;
typedef struct qnode{
int v, data;
bool operator <(const qnode& r) const {
return data > r.data;
}
}qnode;
vector<Edge> H[MAXN];
int n, m, st, ed, t;
int cost[MAXN], lastPos[MAXN];
int dis[MAXN];
void dijkstra(){
priority_queue<qnode> myque;
for (int i = 1; i <= n; i++) dis[i] = 0x3f3f3f3f;
dis[st] = 0;
myque.push({st, 0});
while(!myque.empty()){
qnode tmp = myque.top(); myque.pop();
int u = tmp.v, len = tmp.data;
if(len != dis[u]) continue;
for (int i = 0; i < H[u].size(); i++){
int v = H[u][i].to, w = H[u][i].w;
if(dis[u] + w < dis[v]){
dis[v] = dis[u] + w;
myque.push({v, dis[v]});
}
}
}
}
int main(){
cin >> n >> m >> st >> ed >> t;
for (int i = 1; i <= m; i++) scanf("%d", &cost[i]);
for(int i = 1, v; i <= n; i++){
scanf("%d", &v);
if(lastPos[v] != 0) H[lastPos[v]].push_back({i, cost[v]});
lastPos[v] = i;//记录v车的上一站点
}
for (int i = 1; i <= n - 1; i++) H[i].push_back({i + 1, t});
for (int i = n; i >= 2; i--) H[i].push_back({i - 1, t}); //双向边
dijkstra();
printf("%d
", dis[ed]);
return 0;
}
I.迷宫 #动态规划
题目链接
题意
(n imes m（n,mleq 100）)地图，每个点有权值(a_{ij})，现要你从((1,1))走到((n, m))，可以往右走或往下走，每经过一个点便可得到相应权值，对权值和(mod 1e4+7)。问你从不同方式走到((n,m))能获得多少种权值和？
分析
如果暴力搜索的话，总共有(C^n_{m+n})路径，估计时间复杂度为(O(n!))，显然要用DP。
注意到取模(1e4+7)，我们知道权值和最大可能为(1e4+7)，最小可能为(1)，说明我们可以把权值枚举出来的。但是我们不知道能取到这一区间的哪些值，所以需要DP下看看哪些模数对应的权值和是可达的。
于是定义(dp[i][j][k])表示，地图((i,j))点，能否达到权值(k)。接下来枚举地图上的每一点及其所有模数，转移可从上一行的点、上一列的点进行。
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <cstring>
#include <vector>
#include <cmath>
#include <unordered_map>
using namespace std;
typedef long long ll;
const int MOD = 1e4 + 7;
const int MAXN = 105;
int n, m, val[MAXN][MAXN];
bool dp[MAXN][MAXN][MOD + 5];
int main(){
scanf("%d%d", &n, &m);
for(int i = 1; i <= n; i++){
for (int j = 1; j <= m; j++){
int tmp; scanf("%d", &tmp);
val[i][j] = tmp % MOD; //避免
}
}
dp[1][1][val[1][1]] = 1;
for (int i = 1; i <= n; i++){
for (int j = 1; j <= m; j++){
for (int k = 0; k < MOD; k++){ //枚举模数
dp[i][j][k] |= dp[i - 1][j][((k - val[i][j]) % MOD + MOD) % MOD];
dp[i][j][k] |= dp[i][j - 1][((k - val[i][j]) % MOD + MOD) % MOD];
}
}
}
int ans = 0;
for (int k = 0; k < MOD; k++) ans += dp[n][m][k];
printf("%d
", ans);
}
J.树上行走 #并查集
题目链接
题意
给定(n)个节点、(n-1)条边的树，它有两种类型的点，一旦进入一个点，你只能走到与之有边相连的且与之同类型节点，现要你尽量在更多的节点可以移动，可以进入哪些点？
分析
先对同类型节点进行合并成树，然后对每种类型节点的树的规模进行比较，找到其最值，最后再对规模等于该最值的类型节点加入答案。
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <string>
#include <cstring>
#include <vector>
#include <cmath>
#include <unordered_map>
using namespace std;
typedef long long ll;
const int MOD = 1e9 + 7;
const int MAXN = 2e5 + 5;
int flag[MAXN], tot = 0, fa[MAXN];
int n, sz[MAXN], ans[MAXN];
int findSet(int x){
if(x != fa[x]) fa[x] = findSet(fa[x]);
return fa[x];
}
int main(){
scanf("%d", &n);
for (int i = 1, tmp; i <= n; i++){
scanf("%d", &flag[i]);
fa[i] = i;
}
for (int i = 1, u, v; i <= n - 1; i++){
scanf("%d%d", &u, &v);
if(flag[u] != flag[v]) continue;
int pu = findSet(u), pv = findSet(v);
fa[pu] = pv; //同类型节点进行合并
}
int mymax = -1, cnt = 0;
for (int i = 1; i <= n; i++) findSet(i); //一定要保证所有顶点的路径都压缩完！！！
for (int i = 1; i <= n; i++){
sz[fa[i]]++; //统计该类型节点组成的树规模
mymax = max(mymax, sz[fa[i]]);
}
for (int i = 1; i <= n; i++){
if(sz[fa[i]] == mymax) ans[++cnt] = i; //满足条件，加入答案
}
printf("%d
", cnt);
for (int i = 1; i <= cnt; i++) printf("%d ", ans[i]);
return 0;
}