山东理工大学 2017级寒假ACM集训阶段测试赛题解

A、找最高 

解析：用结构体存储数据，用max记录身高最高的结构体即可

#include <stdio.h>
#include <stdlib.h>
struct node
{
    char name[20];
    int h,w;
}pa[10],max;

int main()
{
    int n,i;
    scanf ("%d",&n);
    for(i=0;i<n;i++)
    scanf ("%s %d %d",&pa[i].name,&pa[i].h,&pa[i].w);
    for(i=0;i<n;i++)
    {
        if(i==0)
            max=pa[i];
        else
        {
            if(pa[i].h>max.h)
                max=pa[i];
        }
    }
    printf("%s %d %d\n",max.name,max.h,max.w);

    return 0;
}

B、玩链表 

解析：顺序建立链表，之后是基本的插入操作

#include <stdio.h>
#include <stdlib.h>

struct node
{
    int data;
    struct node *next;
};


int main()
{
    int n,m;
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        int i,v;
        struct node *head, *tail, *p, *q;
        head=(struct node *)malloc(sizeof(struct node));
        head->next=NULL;
        tail=head;
        for(i=0; i<n; i++){
            p=(struct node *)malloc(sizeof(struct node));
            scanf("%d",&p->data);
            p->next=NULL;
            tail->next=p;
            tail=p;
        }
        for(i=0; i<m; i++){
            scanf("%d",&v);
            if(v!=0){
                q=(struct node *)malloc(sizeof(struct node));
                q->next=NULL;
                q->data=v;
                q->next=head->next;
                head->next=q;
            }
            else{
                p=head->next;
                while(p->next){
                    printf("%d ",p->data);
                    p=p->next;
                }printf("%d\n",p->data);

            }
        }
    }
    return 0;
}

C、Old MacDonald Had A Farm 

解析：教科书式的递推问题，当前年份的动物数量等于前一年的动物加上能生育的动物之和，即f(n)=f(n-1)+f(n-k)，k表示隔k年才能生育，最后把该年份所有动物之和输出即可。

#include <stdio.h>
#include <stdlib.h>
int main()
{
    int i,n;
    int a[31],b[31],c[31];
    while(scanf("%d",&n)!=EOF)
    {
        a[0]=b[0]=c[0]=1;
        a[1]=b[1]=c[1]=1;
        a[2]=b[2]=c[2]=2;
        for(i=3;i<=n;i++)
        {
          a[i]=a[i-1]+a[i-1];
          b[i]=b[i-1]+b[i-2];
          c[i]=c[i-1]+c[i-3];
        }
        printf("%d\n",a[n]+b[n]+c[n]);
    }
    return 0;
}

D、万世不竭
解析：典型的递归题目，由于不知道绳子割断之后的状态，因此用递归求解，递归终点为绳子长度小于4

#include <stdio.h>
#include <stdlib.h>
int a;
int f(int l)
{
    while(l>=4)
    {
        if(l%2==0&&l>=4) {a=1;return f(l/2)+f(l/2);}
        else if(l%2!=0&&l>=4) {a=1;return f(l/2)+f(l/2+1);}
    }
    return a;
}
int main()
{
    int l;
    while(~scanf("%d",&l))
    {
        printf("%d\n",f(l)-1);
    }
    return 0;
}

E、最大子段和 

解析：动态规划当中教科书式的题目，归纳一下，从第1个元素开始询问到第n个元素，设当前元素下标为k，如果第k-1个元素的最大子段和是正数，那么第k个元素的最大字段和可以记为第k-1个元素的最大字段和加上第k个元素，如果第k-1个元素的最大子段和是负数，第k个元素的最大子段和即为它本身。第1个元素的最大子段和就是自己。不明白的话自己可以在纸上写一下。

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int n,i,max=0,pre=0,x;
    scanf("%d",&n);
    for(i=0;i<n;i++)
    {
        scanf("%d",&x);
        if(pre>0)
            pre+=x;
        else
            pre=x;
        if(max<pre)
            max=pre;
    }
    printf("%d\n",max);
    return 0;
}

F、山峰 
解析：此题需要结合栈这种数据结构进行求解，每次遇到新元素，只能让栈内元素看到，看到新的元素的个数就是栈内元素个数，之后将比新元素小的元素出栈，因为这些元素被新元素挡住了，出栈即可。

#include <iostream>
#include<stdio.h>
#include<algorithm>
typedef long long  ll;
using namespace std;
int main()
{
    int n,a[1000005],top,e;
    ll s;
    while(~scanf("%d",&n))
    {
        top=0;
        s=0;
        for(int j=0; j<n; j++)
        {
            scanf("%d",&e);
            s+=top;
            while(top>0&&a[top]<e)
            top--;
            a[++top]=e;
        }
        cout<<s<<endl;
    }
    return 0;
}

G、二叉树的建树及遍历

此题没有解析，是oj练习中的原题

#include<bits/stdc++.h>
using namespace std;

struct Tree
{
    char c;
    Tree *lt,*rt;
};
Tree *creat(char *pre,char *in,int len)
{
    Tree *head;
    if(len<=0)
        return NULL;
    head = new Tree;
    char *p;

    head->c = *pre;
    for(p = in;p!=NULL;p++)
        if(*p == *pre) break;
    int lon = p-in;
    head->lt = creat(pre+1,in,lon);
    head->rt = creat(pre+lon+1,p+1,len-lon-1);
    return head;
}
void fout(Tree *r)
{
    if(r)
    {

        fout(r->lt);
        fout(r->rt);
        cout<<r->c;
    }
}

void levelout(Tree *r)
{

    Tree *que[100];
    int i=0,j=0;
    que[j++]=r;
    while(i<j)
    {
        if(que[i])
        {
            que[j++]=que[i]->lt;
            que[j++]=que[i]->rt;
            printf("%c",que[i]->c);
        }
        i++;
    }
}

int main()
{
    char xx[55],zx[55],*p;
    Tree *root;
    int n;
    scanf("%d",&n);
    while(n--)
    {
        scanf("%s%s",xx,zx);
        p=xx;
        root=creat(p,zx,strlen(xx));
        fout(root);
        cout<<endl;
        levelout(root);
        cout<<endl;
    }
    return 0;
}

H、Huffman

解析：堆的基本题

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <stdlib.h>
#define MAXLONGINT 214783647
int heap[233333],len;

void put(int x);
int get();
int main()
{
    int n,i,x,num=0,ans=0;
    scanf("%d",&n);
    for (i=1;i<=n;i++)
    {
        scanf("%d",&x);
        put(x);
    }
    while (len>1)
    {
        num=get();
        num+=get();
        ans+=num;
        put(num);
    }
    printf("%d\n",ans);
    return 0;
}

void put(int x)
{
    int son,tmp;
    len++;
    heap[len]=x;
    son=len;
    while (son!=1&&heap[son/2]>heap[son])
    {
        tmp=heap[son/2];
        heap[son/2]=heap[son];
        heap[son]=tmp;
        son/=2;
    }
    return;
}

int get()
{
    int fa,son,tmp,num;
    num=heap[1];
    heap[1]=heap[len];
    len--;
    fa=1;
    while (fa*2<=len||(fa*2+1<=len))
    {
        if (fa*2+1>len||heap[fa*2]<heap[fa*2+1]) son=fa*2;
        else son=fa*2+1;
        if (heap[fa]>heap[son])
        {
            tmp=heap[fa];
            heap[fa]=heap[son];
            heap[son]=tmp;
            fa=son;
        }
        else break;
    }
    return num;
}

I、换零钱

解析：动态规划中的完全背包问题

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int dp[32768 + 5];
int main()
{
    dp[0] = 0;
    int i, j, n;
    for(i = 1; i <= 3; i++)
    {
        for(j = i; j <= 32768; j++)
        {
            if(i == 1)dp[j] = 1;
            else
            {
                dp[j] += dp[j - i];
            }
        }
    }
    while(scanf("%d", &n) != EOF)
    {
        if(n == 0)printf("0\n");
        else printf("%d\n", dp[n + 1]);
    }
    return 0;
}

J、 上色的纱雾
解析：将答案进行二分查找，之后对查找的答案进行贪心验证

#include <bits/stdc++.h>

using namespace std;

int N, M;
int n[100005];
int ans;

void binsearch(int low, int high)
{
    if(low > high)
        return;
    int mid = low + ((high-low)/2);
    int sum = 0, count = 1;
    for(int i = 1; i < N; i++)
    {
        if(sum + n[i] - n[i-1] <=  mid)
        {
            sum += n[i] - n[i-1];
        }
        else
        {
            count++;
            sum = 0;
        }
    }
    if(count > M)
        binsearch(mid+1, high);
    else
    {
        ans = mid;
        binsearch(low, mid-1);
    }
}

int main()
{
    while(~scanf("%d%d", &N, &M))
    {
        for(int i = 0; i < N; i++)
            scanf("%d", &n[i]);
        sort(n, n+N);
        int low, high;
        high = n[N-1] - n[0];
        low = 0;
        binsearch(low, high);
        printf("%d\n", ans);
    }
    return 0;
}