题解

哈哈，很久不没写博客了，这次经过大家的努力，学校首次举办程序设计大赛，出了几个水题坑大家，在这也写一篇题解，供感兴趣的童鞋学习，本人是学弱，如有不清楚的地方，可以百度自行解决，本文只是起参考作用，如有错误欢迎指正。

一：过桥，这题数据出了很久了，数据上传oj时没有修改，导致大家在做题时出了点小状况，表示sorry，本题很简单，就只是对字符串的处理，假设用 一个整形变量ans记录结果，读入一个字符串然后扫描该字符串遇到‘w’ ans+=2，遇到‘m’ans+=1，遇到‘m’继续往后扫描就好了，要注意的是，答案是 ans<=30 的，所以如果当前 ans==29 然后下一字符为‘w’便直接结算算法就好了，应为ans+2=31>30。下面是我的代码：

1. #include<iostream>
2. #include<string>
3. 
   
4. using namespace std;
5. 
   
6. int main(){
7.     int T,ans;
8.     cin>>T;
9.     string str;
10.     while(T--){
11.         cin>>str;
12.         ans=0;
13.         for(int i=0;i<str.length() &&ans<=30 ;i++ ){
14. 
    
15.             if(str[i]=='w' )
16.                 ans+=2;
17.             if(str[i]=='m' )
18.                 ans+=1;
19.         }
20.         if(ans>30)
21.             cout<<30<<endl;
22.         else
23.             cout<<ans<<endl;
24.     }
25.     return 0;
26. }

二：排序，原本是出的10w个数据，只有用scanf()和printf()输入输出，并且用快排或者堆排序方可通过，但后来考虑坑题已经过多了，这个就不坑大家了就把数据改小了，排序算法我就不多说了，下面是代码，我用了stl里的sort()函数，该函数的具体使用大家可以百度，

#include<iostream>

#include<algorithm>

#include<cstdio>

using namespace std;

const int maxn=10005;

int a[maxn];

int main(){

    int T,n;

    scanf("%d",&T);

    while(T--){

       scanf("%d",&n);

       for(int i=0;i<n;i++)

         scanf("%d",&a[i]);

       sort(a,a+n);

       printf("%d",a[0]);

       for(int i=1;i<n;i++)

          printf(" %d",a[i]);

       printf("\n");

    }

    return 0;

}

三：poor dog，这个题是一个经典的深搜问，深搜广搜都能过，网上也有详细的解答

深度优先搜索

广度优先搜索

图的dfs与bfs

深搜的做法是搜出所有的路径，然后取最短的路径作为衡量标准，

广搜是直接一次广度优先收索找到的路径便是最短路径。

该题输入的是一个邻接矩阵，然后在输入4个整数，这里给出深搜代码：

1. #include<iostream>
2. #include<stack>
3. #define min(a,b) a<=b?a:b
4. using namespace std;
5. const int maxn=15;
6. int n,m;
7. int a[maxn][maxn];
8. int ans,x2,y2;
9. void dfs(int X, int Y, int step) {
10.      if (X == x2 && Y == y2) {
11.         ans = min(ans, step);
12.         return;
13.      }
14. 
    
15.     if (a[X][Y]==1 || X < 0 || X == n+1 || Y < 0 || Y == m+1 ) {
16.         return;
17.     }
18. 
    
19.     a[X][Y] = 1;
20.     step++;
21.     dfs(X - 1, Y, step);
22.     dfs(X + 1, Y, step);
23.     dfs(X,Y + 1, step);
24.     dfs(X,Y - 1, step);
25.     a[X][Y] = 0;
26. }
27. 
    
28. int main(){
29.     int T;
30.     cin>>T;
31.     while(T--){
32.         ans=999;
33.         int x1,y1;
34.         cin>>n>>m;
35.         for(int i=1;i<=n;i++){
36.             for(int j=1;j<=m;j++){
37.                 cin>>a[i][j];
38.             }
39.         }
40.         for(int i=0;i<=n+1;i++){
41.             a[i][0]=1;a[i][m +1]=1;
42.         }
43.         for(int i=0;i<=m+1;i++){
44.             a[0][i]=1;a[n+1][i]=1;
45.         }
46.         cin>>x1>>y1>>x2>>y2;
47.         dfs(x1, y1, 0);
48.         if(ans>=20){
49.             cout<<"poor dog"<<endl;
50.         }
51.         else{
52.             cout<<"luck dog"<<endl;
53.         }
54. 
    
55. 
    
56.     }
57. 
    
58.     return 0;
59. }

四：单词统计，这个题我觉得是很简单的一个题了，以为很多人回过，数据量不大，即使暴力一个一个统计也能统计出来，当然我的初衷是考考大家map映射容器

map容器

定义一个map 就只需要包所有单词扔map容器里，然后在输出就好，代码也很简短：

#include<iostream>

#include<map>

#include<string>

 

using namespace std;

int main(){

    map Mymap;

    string str;

    while(cin>>str){

        Mymap[str]++;

    }

    map::iterator it;

    it=Mymap.begin();

    for(;it!=Mymap.end();it++)

            cout<< it->first<<":"<< it->second<<endl;

    return 0;

}

五：积分，这个题我想直接贴代码算了，就是输入一个函数的系数和指数，如f(x) = 1 + 3x^2 + 2x^4求∫f(x)dx = x + x^3 + (2/5)x^5,估计大家觉得麻烦的就只有化简，求积分就是指数加1，系数除以新指数，这里化简有一个函数 叫 gcd（int a,int b）返回值是a，b的最大公约数，所以 a/gcd(a,b)/ b/gcd(a，b) 及为最简分数了，这里给出代码，代码中有gcd函数的实现，想了解gcd的原理可以百度“辗转相除”

gcd，辗转相除

1. #include<iostream>
2. #include<fstream>
3. #include<ctime>
4. #include<cstdlib>
5. #include<algorithm>

1. using namespace std;
2. const int maxn=2010;
3. 
   
4. int gcd(int a,int b){
5.     return b==0?a:gcd(b,a%b);
6. }
7. 
   
8. int main(){
9.     int a[maxn];
10.     int T;
11.     cin>>T;
12.     while(T--){
13.          int n;
14.          cin>>n;
15.         n*=2;
16.         for(int i=1;i<=n;i++){
17.             cin>>a[i];
18.         }
19. 
    
20.         for(int i=2;i<=n;i=i+2){
21.            if(a[i-1]%(a[i]+1) == 0){
22.                 cout<<a[i-1]/(a[i]+1)<<" "<<a[i]+1;
23.                 if(i!=n)
24.                     cout<<" ";
25.            }
26.            else{
27.                 if(a[i-1]<0){
28.                   a[i-1]*=-1;
29.                   int tmp=gcd(a[i-1],a[i]+1);
30.                   cout<<"-"<<a[i-1]/tmp<<"/"<<(a[i]+1)/tmp<<" "<<a[i]+1;
31.                   if(i!=n)
32.                       cout<<" ";
33.                 }
34.                 else{
35.                     int tmp=gcd(a[i-1],a[i]+1);
36.                     cout<<a[i-1]/tmp<<"/"<<(a[i]+1)/tmp<<" "<<a[i]+1;
37.                     if(i!=n)
38.                        cout<<" ";
39.                 }
40.            }
41. 
    
42.         }
43.         cout<<endl;
44. 
    
45.     }
46.     return 0;
47. }

六：tdap的数学，这是一个经典的题目

大树斐波那契

大树斐波那契，快速矩阵幂做法

这两个博客已经讲得非常的清楚了，而且都给出了证明过程，我就不写了，因为数据不一样，下面是我的代码大家可以参考：

1. #include<iostream>
2. #include<cstring>
3. #include<cstdio>
4. #include<cstdlib>
5. 
   
6. 
   
7. using namespace std;
8. 
   
9. 
   
10. typedef long long LL;
11. const LL mod=1000000007;
12. LL ans;
13. struct matrix{
14.      LL a[3][3];
15. }A,B;
16. 
    
17. 
    
18. matrix mult2(matrix A,matrix B){  
19.     matrix C;
20.     for(int i=1;i<=2;i++){  
21.         for(int j=1;j<=2;j++){    
22.             C.a[i][j]=0;
23.             for(int k=1;k<=2;k++){  
24.                 C.a[i][j] = (C.a[i][j] + A.a[i][k]*B.a[k][j])%mod;
25.             }        }
26.     }
27.     return C;
28. }
29. 
    
30. 
    
31. matrix mult(matrix A,LL n){  
32.     if(n==1) return A;
33.     A = mult(A,n/2);
34.     if(n%2==0)  return  A = mult2(A,A);
35.     return  A = mult2(mult2(A,A),B);
36. }
37. 
    
38. 
    
39. int main(){
40.     int T;
41.     int n,a,b,x0,x1;
42.     LL ans;
43.     scanf("%d",&T);
44.     while(T--){
45.        scanf("%d%d%d%d%d",&n,&a,&b,&x0,&x1);
46.        if(n==1){
47.           printf("%d\n",x1);
48.           continue;
49.        }
50.        A.a[1][1]=a;
51.        A.a[1][2]=b;
52.        A.a[2][1]=1;
53.        A.a[2][2]=0;
54.        B=A;
55.        A = mult(A,n-1);
56. 
    
57. 
    
58.        ans = ((A.a[1][1]*x1)%mod + (A.a[1][2]*x0)%mod)%mod;
59.        printf("%lld\n",ans);
60.     }
61. 
    
62. 
    
63.     return 0;
64. }

七：魔法，这是线段树，用主席树也可以，这里不详说，有兴趣可以去学习线段树，树状数组，主席树等高级数据结构，这都是很有用的数据结构，这题就直接贴线段树写法的代码吧：

线段树

树状数组

主席树

1. #include <iostream>
2. #include <cstdio>
3. #include <cstring>
4. #include <algorithm>
5. #include <cmath>
6. #include <vector>
7. using namespace std;
8. #define lson 2*u
9. #define rson 2*u+1
10. const int maxn=100010;
11. int n,m;
12. struct tnode{
13.     int l,r,cnt;
14.     int a[10];
15.     int getmid(){
16.         return (l+r)/2;
17.     }
18. }tree[4*maxn];
19. void build(int l,int r,int u){
20.     tree[u].l=l,tree[u].r=r,tree[u].cnt=0;
21.     memset(tree[u].a,0,sizeof(tree[u].a));
22.     if (l==r){
23.         return ;
24.     }
25.     int mid=tree[u].getmid();
26.     build(l,mid,lson);
27.     build(mid+1,r,rson);
28. }
29. void update(int l,int r,int u,int c){
30.     if (tree[u].l==l&&tree[u].r==r){
31.         tree[u].cnt+=c;
32.         int Max=min(10,r-l+1);
33.         for (int i=0;i<Max;i++) tree[u].a[i]+=c;
34.         return ;
35.     }
36.     int mid=tree[u].getmid();
37.     if (r<=mid) update(l,r,lson,c);
38.     else if (l>mid) update(l,r,rson,c);
39.     else{
40.         update(l,mid,lson,c);
41.         update(mid+1,r,rson,c);
42.     }
43.     int Max=min(tree[u].r-tree[u].l+1,10);
44.     for (int i=0,j=0,k=0;k<Max;){
45.         if (tree[lson].a[i]>tree[rson].a[j]) tree[u].a[k++]=tree[lson].a[i++]+tree[u].cnt;
46.         else tree[u].a[k++]=tree[rson].a[j++]+tree[u].cnt;
47.     }
48. }
49. int ans[10];
50. void query(int l,int r,int u,int K){
51.     if (tree[u].l==l&&tree[u].r==r){
52.         int Max=min(r-l+1,10);
53.         vector<int> v;
54.         for (int i=0;i<Max;i++) v.push_back(tree[u].a[i]+K);
55.         for (int i=0;i<10;i++) v.push_back(ans[i]);
56.         sort(v.begin(),v.end(),greater<int>());
57.         for (int i=0;i<10;i++) ans[i]=v[i];
58.         return ;
59.     }
60.     int mid=tree[u].getmid();
61.     if (r<=mid) query(l,r,lson,K+tree[u].cnt);
62.     else if (l>mid) query(l,r,rson,K+tree[u].cnt);
63.     else{
64.         query(l,mid,lson,K+tree[u].cnt);
65.         query(mid+1,r,rson,K+tree[u].cnt);
66.     }
67. }
68. int main()
69. {
70.     char cmd[10];
71.     int l,r,K;
72.     while(~scanf("%d%d",&n,&m)){
73.         build(1,n,1);
74.         while(m--){
75.             scanf("%s%d%d%d",cmd,&l,&r,&K);
76.             if (cmd[0]=='A') update(l,r,1,K);
77.             else{
78.                 memset(ans,0,sizeof(ans));
79.                 query(l,r,1,0);
80.                 int tt=0;
81.                 for (int i=0;i<K;i++) tt+=ans[i];
82.                 printf("%d\n",tt);
83.             }
84.         }
85.     }
86.    
87.     return 0;
88. }

八：谁是赢家，关大神已经证明过了，这直接贴博文链接

取石头

1. #include<iostream>
2. using namespace std;
3.   
4. int main(){
5.     int T;
6.     cin>>T;
7.     while(T--){
8.         int m,n;
9.         cin>>n>>m;
10.         if(n%(m+1)==0)
11.             cout<<"tdap"<<endl;
12.         else
13.             cout<<"xsong"<<endl;
14.     }
15.     return 0;
16. }

九：max sum，这是一道很简单的动态规划，看了代码你一定会的，代码如下：

1. #include<iostream>
2. using namespace std;
3. 
   
4. 
   
5. int main(){
6.     int n;
7.     cin>>n;
8.     while(n--){
9.         int sum=0;
10.         int f,k=0,tmp;
11.         cin>>tmp;
12.         for(int i=0;i<tmp;i++){
13.             cin>>f;
14.             k+=f;
15.             if(k>sum)
16.                 sum=k;
17.             if(k<=0)
18.                k=0;
19.         }
20.         cout<<sum<<endl;
21.     }
22.     return 0;
23. }

其他的题感觉没什么好说的了，有问题可以QQ小刀关大神，或者找本学弱给你粗略讲解