哈尔滨理工大学软件与微电子学院第八届程序设计竞赛同步赛（高年级）题解（全）

链接：https://ac.nowcoder.com/acm/contest/301#question
来源：牛客网

比较难的有

目录（很难的，比较难的）

A小乐乐的组合数+ B小乐乐搭积木 C小乐乐玩木桶 D小乐乐玩木桶+

E小乐乐匹配字符串 F小乐乐下象棋 G小乐乐打游戏 H小乐乐学数学

I小乐乐学博弈 J小乐乐和25

A小乐乐的组合数+

小乐乐得知一周有7天之后就对7产生了兴趣。

小乐乐得到了两堆数字数字时连续的。

第一堆包含[1,n]n个数字，第二堆包含[1,m]m个数字。
小乐乐想要从两堆中各挑选出一个整数x,y，使得x,y的和为7的倍数。

请问小乐乐有多少种组合的方式
。

输入整数n,m。(1<=n,m<=1e6)

输出满足的对数。

注意超出了int范围

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
int main(){ll ans = 0,n,m;cin>>n>>m;for(int i=1;i<=n;i++)ans += (m+i)/7 - i/7;cout<<ans<<endl;return 0;
}

B小乐乐搭积木

小乐乐想要给自己搭建一个积木城堡。

积木城堡我们假设为n*m的平面矩形。

小乐乐现在手里有1*2，2*1两种地砖。

小乐乐想知道自己有多少种组合方案。

第一行输入整数n,m。(1<=n,m<=10)

输出组合方案数。

dfs+状态压缩

#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn = (1<<12);
int w,h,t;
ll a[2][maxn];
void DFS(int cur,int Now,int pre){if(cur == w){a[t][Now] += a[!t][pre];return;}if(cur + 1 <= w){DFS(cur+1,Now << 1, pre << 1|1);///不放，上层是1，这层可以不放，即这层是0DFS(cur+1,Now << 1|1,pre << 1);///竖着，上层是0，可以竖着放（并且一定是要竖着放的，否则填不满），所以这层是1}if(cur + 2 <= w)DFS(cur+2,Now << 2|3,pre << 2|3);///横着，上层连着两个都是1，这层也一样
}
int main(){scanf("%d%d",&h,&w);if((h*w)&1)///都是奇数肯定不可能return 0*printf("0\n");if(w > h)///优化，降低dfs中树的深度w ^= h ^= w ^= h;a[t][(1 << w) - 1] = 1;for(int i = 1 ; i <= h ; i++)///枚举行t = !t,DFS(0,0,0),memset(a[!t],0,sizeof(a[0]));printf("%lld\n",a[t][(1 << w) -1]);return 0;
}

C小乐乐玩木桶

小乐乐用散落在森林里的木板做了一个木桶。

已知底面积为S(㎡)。

小乐乐经过各种仪器的精密测量知道了，所有木板的近似长度h[i]。

小乐乐想知道自己拼凑出的木桶的最大装水体积为？

（容量测量，底面积乘高，木桶不倾斜）

第一行输入整数n，S。(1<=n,s<=1000，n表示拼凑木桶所需木板)
第二行输入n个整数h[i](1<=h[i]<=1000,h[i]表示i号木板的长度)

输出木桶最大装水体积。

常识、短板效应，最小的板乘底面积即可

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
double t,s,ans = 1e9;
int main()
{int n;cin>>n>>s;while(n--)cin>>t,ans = min(t,ans);cout<<ans*s<<endl;return 0;
}

D小乐乐玩木桶+

小乐乐用散落在森林里的木板做了一个木桶。

已知底面积为S(㎡)。

小乐乐经过各种仪器的精密测量知道了，所有木板的近似长度h[i]。

小乐乐只能选用三块木板去拼木桶，小乐乐拼凑成的木桶的最大装水体积是(㎡)？

（容量测量，底面积乘高，木桶不倾斜）

第一行输入整数n，S。(3<=n<=1000，1<=s<=1000，n表示拼凑木桶所需木板)
第二行输入n个整数h[i](1<=h[i]<=1000,h[i]表示i号木板的长度)

输出木桶最大装水体积。

稍微贪下心，要最长的那三根，然后短板，sort一遍即可

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
double t[1007],s,ans = 1e9;
int main()
{int n;cin>>n>>s;for(int i=0;i<n;i++)cin>>t[i];sort(t,t+n);cout<<s*t[n-3]<<endl;return 0;
}

E小乐乐匹配字符串

小乐乐有字符串str1,str2。

小乐乐想要给他们找朋友。

小乐乐想知道在这两个字符串中最多能匹配出多长的相同子串（可非连续）。

第一行输入字符串str1;
第二行输入字符串str2;
数据保证字符串长度小于1000，且非空，字符串仅由小写字母组成。

输出最长相同子串的长度。

dp，最长公共子序列，考虑每个位置

$dp[i][j]=max(dp[i-1][j],dp[i][j-1])$ ，a[i] != b[j]

$dp[i][j]=dp[i-1][j-1]+1$ ，a[i] == b[j]

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e3+7;
char s1[maxn],s2[maxn];
int dp[maxn][maxn];
int LCS(int n,int m){memset(dp,0,sizeof(dp));for (int i=1;i<=n;i++){for (int j = 1;j<=m;j++){if(s1[i] == s2[j])dp[i][j] = dp[i-1][j-1]+1;elsedp[i][j] = max(dp[i][j-1],dp[i-1][j]);}}return dp[n][m];
}
int main(){cin>>s1+1>>s2+1;cout<<LCS(strlen(s1+1),strlen(s2+1))<<endl;return 0;
}

F小乐乐下象棋

小乐乐一天天就知道玩，这一天又想玩象棋。
我们都知道马走日。
现在给定一个棋盘，大小是n*m,把棋盘放在第一象限，棋盘的左下角是(0,0),右上角是(n - 1, m - 1);
小乐乐想知道，一个马从左下角(0, 0)开始，走了k步之后，刚好走到右上角(n - 1, m - 1)的方案数。

输入：多组样例输入，每组一行，三个整数n, m, k(1 <= n, m, k <= 200),如题目所示。

输出：输出答案 mod 1000000007

dfs记忆化搜索

#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn = 2e2+7,mod = 1e9+7;
ll dp[maxn][maxn][maxn];
int dir[8][2]={1,2,2,1,2,-1,1,-2,-1,-2,-2,-1,-2,1,-1,2};
int n,m,k;
ll dfs(int x,int y,int step){if(dp[x][y][step]!=-1)return dp[x][y][step];ll ans = 0;for(int i=0;i<8;i++){int tx = x+dir[i][0];int ty = y+dir[i][1];if(tx<n && tx>=0 && ty<m && ty>=0 && step<k)ans = (ans + dfs(tx,ty,step+1))%mod;}return dp[x][y][step] = ans;
}
int main(){while(~scanf("%d%d%d",&n,&m,&k)){memset(dp,-1,sizeof(dp));dp[n-1][m-1][k] = 1;printf("%lld\n",dfs(0,0,0));}return 0;
}

G小乐乐打游戏

小乐乐觉得学习太简单了，剩下那么多的时间好无聊，于是便想打游戏。
最近新出了一个特别火的游戏，叫吃猪，小乐乐准备玩一玩。
吃猪游戏很简单，给定一个地图，大小为n*m，在地图中会随机出现一个火山口，只要小乐乐能逃离这个地图，他便能吃猪！
但吃鸡远没有那么简单：
        1.小乐乐每走一次只能上下左右四个方向中走一步。
        2.小乐乐每走一步，火山喷发的岩浆就会向四周蔓延一个格子，所有岩浆走过的地方都视为被岩浆覆盖。
        3.小乐乐碰到岩浆就会死。
        4.地图中还有很多障碍，使得小乐乐不能到达，但是岩浆却可以把障碍融化。
        5.小乐乐只有走到题目给定的终点才算游戏胜利，才能吃猪。
小乐乐哪见过这场面，当场就蒙了，就想请帮帮他，告诉他是否能吃猪。

多组样例输入
第一行给定n,m,(1 <= n, m <= 1000)代表地图的大小。
接下来n行，每一行m个字符，代表地图，对于每一个字符，如果是'.'，代表是平地，'S'代表小乐乐起始的位置，
'E'代表终点，'#'代表障碍物，'F'代表火山口。

输出只有一行。如果小乐乐能吃猪，输出"PIG PIG PIG!"。否则输出"A! WO SI LA!"。

bfs，那种直接找的bfs，用更新一张表（地图）的方式会爆内存，

注：并不需要预处理火山蔓延，可以直接求当前点到火山口的曼哈顿距离

#include <bits/stdc++.h>
typedef long long ll;
using namespace std;
const int maxn = 1e3+3;
int dir[4][2]={1,0,0,1,0,-1,-1,0,};
char s[maxn][maxn];
int vis[maxn][maxn],n,m;
struct node{int x,y,indx;
}Start,Fire,End;
int dist(node x){return abs(Fire.x-x.x)+abs(Fire.y-x.y);}
int bfs(){queue<node> Q;vis[Start.x][Start.y] = 1;Q.push(Start);while(!Q.empty()){node x = Q.front();Q.pop();if(x.x == End.x && x.y == End.y)return 1;for(int i=0;i<4;i++){node tx = {x.x+dir[i][0],x.y+dir[i][1],x.indx+1};if(tx.x>0&&tx.x<=n && tx.y>0&&tx.y<=m && !vis[tx.x][tx.y])if(tx.indx<dist(tx) && s[tx.x][tx.y]!='#')vis[tx.x][tx.y] = 1,Q.push(tx);}}return 0;
}
void solve(){memset(vis,0,sizeof(vis));for(int i=1;i<=n;i++){for(int j=1;j<=m;j++){cin>>s[i][j];if(s[i][j] == 'S')Start = node{i,j,0};if(s[i][j] == 'E')End = node{i,j,0};if(s[i][j] == 'F')Fire = node{i,j,0};}}printf("%s\n",bfs()?"PIG PIG PIG!":"A! WO SI LA!");
}
int main(){while(~scanf("%d%d",&n,&m))solve();return 0;
}

H小乐乐学数学

小乐乐上了一节数学课，数学老师讲的很好，小乐乐听的也如痴如醉。
小乐乐听了老师的讲解，知道了什么是素数，现在他想做几个习题。
现在题目来了：
首先我们先定义孤独的数：在一个区间中的一个数字x,如果他与这个区间中的任何数都互质，那么他就是孤独的数。
我们给定一个序列，然后接下来会有多次询问，对于每次询问，给定两个整数l, r,我想知道对于(a[l], a[l + 1], ...., a[r])区间来说中有多少孤独的数。

多组样例输入。

对于每一组来说，给定两个整数n和m(1 <= n, m <= 100000),代表序列的长度和询问的次数,

接下来一行有一个长度为n的整数数组a，对于第i个整数a[i], (1 <= a[i] <= 100000)。

接下开m行，每行两个整数l, r(1 <= l <= r <= n),代表区间的左端点位置和有端点位置。

对于每个询问，输出一行，只有一个整数，代表询问的区间中，孤独的数的数量为多少。

将每一个数唯一分解，然后求出其在左边和右边第一个非互质的位置

然后你想查询 $[l,r]$ ，那么是不是所有 $[l,r]$ 中的左边非互质的位置的个数减去右边非互质位置的个数

（左边的好想，因为 $[l,r]$ 区间内的数，有几个非互质就有几个非互质的位置在l之前，

但是同时要考虑右边的非互质位置，因为如果区间内出现了右边的非互质位置，

说明区间内的某个数出现了不互质，是要减掉的）

用树状数组维护一个前缀和查询 query(q[i].r)

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e5+7;
int vis[maxn],l[maxn],r[maxn],ans[maxn],tree[maxn],n;
vector<int> G[maxn];
struct node{int l,r,x,id;bool operator<(const node&t)const{return l<t.l;}
}q[maxn],a[maxn];
struct Node{///堆int l,r,x;bool operator<(const Node&t)const{return x>t.x;}
};
void add(int pos,int val){while(pos<=n){tree[pos] += val;pos += pos&-pos;}
}
int query(int pos){int ans=0;while(pos){ans += tree[pos];pos -= pos&-pos;}return ans;
}
void init(){for(int i=2;i<maxn;i++)if(!vis[i]){for(int j=i;j<maxn;j+=i)G[j].push_back(i),vis[j]=1;}
}
int main(){init();int m,x;while(~scanf("%d%d",&n,&m)){memset(vis,0,sizeof(int)*(n+1));for(int i=1;i<=n;i++){scanf("%d",&x);l[i]=0,r[i]=n+1,tree[i]=0;for(int j=0;j<G[x].size();j++){int t=G[x][j];if(vis[t]){l[i]=max(l[i],vis[t]);if(r[vis[t]]==n+1)r[vis[t]]=i;}vis[t]=i;}}for(int i=1;i<=n;i++)a[i].x=i,a[i].l=l[i],a[i].r=r[i];for(int i=1;i<=m;i++)scanf("%d%d",&q[i].l,&q[i].r),q[i].id=i;sort(a+1,a+1+n);sort(q+1,q+1+m);priority_queue<Node> Q;int pos=1;for(int i=1;i<=m;i++){while(!Q.empty() && Q.top().x<q[i].l)add(Q.top().x,-1),add(Q.top().r,1),Q.pop();while(a[pos].l<q[i].l && pos<=n)add(a[pos].x,1),add(a[pos].r,-1),Q.push(Node{a[pos].l,a[pos].r,a[pos].x}),pos++;ans[q[i].id] = query(q[i].r);}for(int i=1;i<=m;i++)printf("%d\n",ans[i]);}return 0;
}

I小乐乐学博弈

小乐乐和小皮蛋开始学习关于博弈的知识。
给定两堆石子，第一堆有n个石子，第二堆有m个石子。
每次操作可以从一堆石子中拿走一些石子，拿走石子的数量可以是1 - k个，小乐乐先手拿石子，然后依次轮流。
假如到小乐乐的轮次，小乐乐拿不了了(也就是所有的石子都被拿光了)，那么小皮蛋就获胜，反之亦然。
假设小乐乐和小皮蛋都绝顶聪明，都会采用最佳的策略，请问最后谁会赢。

多组数据输入，对于每一组数据，只有一行由空格分开的三个整数n, m, k(0 <= n, m <= 1000000000, k >= |n - m|).

如果小乐乐会赢，输出"HAI YOU SEI!",否则输出"LAOZI CHUI SI NI!"。

先手一定可以拿到两堆数量相同的情况，所以除了一开始就是两堆一样，都是先手必胜，注意多组

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
ll n,m,k;
int main(){while(cin>>n>>m>>k)if(n==m)cout<<"LAOZI CHUI SI NI!"<<endl;elsecout<<"HAI YOU SEI!"<<endl;return 0;
}

J小乐乐和25

小乐乐特别喜欢25这个数字，他想把所有的数字都变成25的倍数。
现在小乐乐得到一个数字，想问问你最少用几次操作才可以把这个数字改造成25的倍数。
对于一次操作我们可以把相邻的两位做交换，比如123经过一次操作之后就可以变成213或者132。

多组数据输入

对于每组数据，只有一行输入一个整数n(1 <= n <= 1000000000)。

如果经过最少x次操作后，这个数就变成了25的倍数，那么输出x；

如果这个数无论怎么变化都变不成25的倍数，输出-1.

容易得出，25的倍数后两位一定是00,25,50,75

所以只要在原来的数里找到两位组成这四个就行了，

将数按位分解，放到数组里，然后，枚举两个位置，计算交换次数即可

注：这两个数是有顺序的，所以有时需要多交换一次

#include<bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
int n,p[15];
int Step(int i,int j){return i>j?i+j-3:i+j-2;
}
int solve(){if(n%25 == 0)return 0*printf("0\n");int pos = 0,ans = inf;while(n){///注意是倒序的p[++pos]=n%10;n/=10;}for(int i = 1;i<=pos;i++)for(int j = i+1;j<=pos;j++){if((p[i]*10+p[j])%25 == 0)ans=min(ans,Step(i,j));if((p[i]+p[j]*10)%25 == 0)ans=min(ans,Step(j,i));}return 0*printf("%d\n",ans != inf?ans:-1);
}
int main(){while(~scanf("%d",&n))solve();return 0;
}