物联网学生科协第三届H-star现场编程比赛

问题 A: 剪纸片

时间限制: 1 Sec 内存限制: 128 MB

题目描写叙述

这是一道简单的题目，假如你身边有一张纸。一把剪刀。在H-star的比赛现场，你会这么做：

1. 将这张纸剪成两片(平行于短边剪开)；

2. 将当中一片剪成一个圆。作为圆柱的底面。

3. 纸的还有一片的一边沿着圆的周长将圆围起来，直到围成一圈。形成一个无盖的圆柱体。

须要注意的是，纸片可能会有重叠部分。

聪明的你机智的你喜欢思考的你这时候就開始想，一张纸片按上述方式所组成的圆柱的最大体积是多少呢？请你用编程解决问题。

输入

输入第一行包括一个数字t代表接下来有t组数据。

接下来的t行，输入两个数字w, h(1 ≤ w ≤ h ≤ 100)，分别代表纸片的宽和高。

输出

对每一组数据输出纸片所能构成的最大圆柱体的体积v（保留小数点的后三位小数）。

例子输入

3

10 10

10 50

10 30

例子输出

54.247

785.398

412.095

比較坑的是，PI必须用acos(-1)表示

这一题还是蛮简单的，能够算是纯数学问题。在这里就不赘述了，直接上代码

#include <iostream>
#include <cmath>
#include <cstdio>
#include <cstring>
using namespace std;
double PI = acos(-1);
double Min(double a, double b)
{
    return a < b ? a : b;
}
double Max(double a, double b)
{
    return a > b ?

a : b;
}
int main()
{
    //freopen("6.in", "r", stdin);
    //freopen("6.out", "w", stdout);
    double w, h, r, ans1, ans2, ans;
    int t;
    cin >> t;

    while (t--)
    {
        scanf("%lf%lf", &w, &h);
        r = Min(w / 2.0, h /(2.0 * PI + 2.0));//以w为圆柱的高
        ans1 = PI * r * r * w;
        r = Min(w / (2.0 * PI), h / 3.0);
        ans2 = PI * r * r * (h - 2.0 * r);//以h-2r为圆柱的高
        ans = Max(ans1, ans2);
        printf("%.3lf\n", ans);
    }
    return 0;
}

问题 B: 废品收集记

时间限制: 1 Sec 内存限制: 128 MB

题目描写叙述

写程序不是唯一的出路。可是假如H-star题目太难了，让你放弃了以后当程序猿的念头，放弃身边的那个Ta，那么你就有可能去捡破烂，假如你去捡破烂，就会碰到下述问题：

在河海有n个垃圾桶，每一个垃圾桶里面都有价值为m，体积为b的废品。可是你的背包体积仅仅有V，为了赚很多其它钱，为了身边的Ta更幸福，你每一次捡破烂，都希望自己体积为V的背包里装的废品价值尽量多。

所以你又想起你以前敲过的代码。你决定写一个程序解决问题。

输入

输入一个数字t，表示有t组数据：

每一组数据有三行：

第一行：输入两个数字n。V（n <= 1000, V <= 1000）；

n表示垃圾桶的数量。V表示背包的容量

第二行：输入包括n个数字，代表每一个垃圾桶中废品的价值m

第三行：输入包括n个数字。代表每一个垃圾桶中废品须要占用的背包的容量b

输出

输出你每次出去捡破烂背包所能装下破烂的最大价值（保证每次输出数据都在整形范围内）。

例子输入

1

5 10

1 2 3 4 5

5 4 3 2 1

例子输出

14

这是一道01背包的题目。想要了解01背包的，这边有一个博客的地址：http://www.cnblogs.com/xy-kidult/archive/2013/03/25/2970313.html

将问题一般化；

#include<stdio.h>
#include<string.h>
#define M 1009
typedef struct pack
{
    int cost;
    int val;
}PACK;
int main()
{
    int cas,n,v,i,j;
    int f[M];
    PACK a[M];
    scanf("%d",&cas);
    while(cas--)
    {
        scanf("%d%d",&n,&v);
        memset(f,0,sizeof(f));
        for(i=1;i<=n;i++)
            scanf("%d",&a[i].val);
        for(i=1;i<=n;i++)
            scanf("%d",&a[i].cost);
        for(i=1;i<=n;i++)
            for(j=v;j>=a[i].cost;j--)
                if(f[j]<f[j-a[i].cost]+a[i].val)
                    f[j]=f[j-a[i].cost]+a[i].val; //01背包状态方程
        printf("%d\n",f[v]);
    }
    return 0;
}

问题 C: Northcott游戏

时间限制: 1 Sec 内存限制: 128 MB

题目描写叙述

alpha和GrayGraySmall正在玩一种Northcott游戏。可是alpha老是输，因此他怀疑这个游戏是不是有某种必胜策略，郁闷的alpha如今向你求救了。你能帮帮他么？

游戏规则是这种：

如图所看到的，游戏在一个n行m列（1 ≤ n ≤ 1000且2 ≤ m ≤ 100）的棋盘上进行，每行有一个黑子（黑方）和一个白子（白方）。执黑的一方先行，每次玩家能够移动己方的不论什么一枚棋子到同一行的不论什么一个空格上。当然 这过程中不许越过该行的敌方棋子。两方轮流移动。直到某一方无法行动为止，移动最后一步的玩家获胜。

alpha总是先下（黑方）。图1是某个初始局面。图二是 alpha移动一个棋子后的局面（第一行的黑子左移两步）。

输入

输入数据有多组。

每组数据第一行为两个整数n和m，由空格分开。接下来有n行。每行两个数Ti，Ji (1 ≤ Ti, Ji ≤ m)分别表示alpha和GrayGraySmall在该行棋子所处的列数。

注意：各组測试数据之间有不定数量的空行。你必须处理到文件末。

输出

对于每组測试数据输出一行你的结果。

假设当前局面下alpha有必胜策略则输出“I WIN!”，否则输出“BAD LUCK!”。

例子输入

3 6

4 5

1 2

1 2

例子输出

BAD LUCK!

夏黑出的博弈论。。。我就不说什么了。他是说反正没人能做出来

#include <cstdio>
#include <cstdlib>
#include <cmath>
using namespace std;

int main(){
    int n, m;
    while(scanf("%d%d", &n, &m)!=EOF){
        m = 0;                          //这里注意m并没有什么用处我就懒得多定义一个变量了直接拿来用了
        int a, b;

        while(n--){
            scanf("%d%d", &a, &b);
            m ^= abs(a-b) - 1;
        }

        if(m){
            printf("I WIN!\n");
        }
        else{
            printf("BAD LUCK!\n");
        }
    }
    return 0;
}

问题 D: 我在NE304写程序的时候吃女神送给我的糖果

时间限制: 1 Sec 内存限制: 128 MB

题目描写叙述

一个立志做程序猿的人，做什么都会想到写程序。小明的女神以前送给他一堆糖果，可是他一直舍不得吃。最后等到了H-Star比赛，小明就把女神送给他的苹果带到了比赛现场，当作女神对他的祝福。可是问题往往就在这时候浮如今他的脑海：

小明有一个癖好。吃糖果的时候，不喜欢连着吃同一种糖果。喜欢先吃一种，下一次吃还有一种（小明一次仅仅吃一颗糖果）；可是小明不知道是否存在一种吃糖果的顺序使得他能把全部糖果都吃完。

小明觉得这是女神对他的一个考验，也是祝福，所以立即在NE304敲起了代码…

输入

第一行有一个整数T，接下来T组数据，每组数据占2行，第一行是一个整数N（0

#include<stdio.h>
long long sum;
int main()
{
   int n,i,num,maxn,cas;
   scanf("%d",&cas);
   while(cas--)
   {
       scanf("%d",&n);
      sum=maxn=0;
      for(i=0;i<n;i++)
      {
       scanf("%d",&num);
       if(num>maxn) maxn=num;
         sum+=num;
      }
      if(sum-maxn+1>=maxn) puts("Yes");
      else puts("No");
   }
   return 0;
}

问题 E: Lecture

时间限制: 1 Sec 内存限制: 128 MB

题目描写叙述

coco有一个说话特别特别快的新图论老师，由于说话太快所以coco尽管勉强能跟得上老师的课可是却没办法记好笔记，好在coco非常聪明。她想到了一个方法让自己跟得上课并记笔记。

coco知道两种语言，而老师上课的时候总是用第一种语言。语言中的单词都是由英文小写字母组成。每一门语言又由几个单词组成。

对每一门语言来说,全部的单词都是相互独立的，仅仅是拼写不同。并且，对于这些语言来说每一个单词都是一一相应的，对于一门语言的一个单词来说，它都会在还有一门语言中有确切的单词和确切的意思.。

coco能够卸下老师讲的每一个单词，无论是第一种语言还是另外一种语言。当然，在上课期间coco写下的每一个单词都是这两种语言中最短的那个。假设单词长度一样。coco会倾向于写第一种语言。

如今给你一段老师讲课的文本，找出这节课coco会在笔记本上记录的内容。

输入

第一行包括两个整数,n和 m( 1<= n,m <= 3000), 老师堂内容的单词数和这些语言中的单词数。

接下来的 m 行包括了这些单词.第 i行包括两个串 ai, bi。ai是第一门语言的单词, bi是第二门语言的单词,这两个单词拥有同样的意思.输入保证没有同样的单词出如今两种语言中,并且每一个单词在一中语言中仅仅出现一次.

接下来的一行有 n 个空格隔开的串 c1,c2,…,cn —讲课的内容.保证每一个 Ci串都会在集合{a1,a2,…am}中.

全部的串在输入中都不空,每一个单词都由不超过10个英文小写字母组成.

输出

输出有 n个单词:：你将会记录在笔记本中的讲课内容。单词顺序不变。

例子输入

4 3

codeforces codesecrof

contest round

letter message

codeforces contest letter contest

例子输出

codeforces round letter round

这是今天第二简单的题目。就是简单的字符串的应用，大家大一上的时候会觉得字符串特别难，可是如今可能就不觉得了。

我的方法是简单的直接搜索一遍就好了

#include <stdio.h>
#include <string.h>
#define maxn 3005

char a[maxn][15], b[maxn][15];
int findStr( char *c, int m ){
    for( int i = 0; i < m; i++ )
        if( strcmp( c, a[i] ) == 0 )
            return i;
    return -1;
}

int main(){
    int n, m;
    char c[15];
    scanf( "%d %d", &n, &m );
    for( int i = 0; i < m; i++ )
        scanf( "%s %s", a[i], b[i] );
    for( int i = 0, ok = 0; i < n; i++ ){
        scanf( "%s", c );
        int t = findStr( c, m );
        ok ? printf( " " ) : ok = 1;
        if( strlen( a[t] ) > strlen( b[t] ) )
            printf( "%s", b[t] );
        else
            printf( "%s", a[t] );
    }
    return 0;

}

问题 F: 回文数

时间限制: 1 Sec 内存限制: 128 MB

题目描写叙述

回文数是顺着读和反着读都一样的数字，给你一个数字，请你推断它是不是回文数。

输入

输入一个整数t（t在int范围内）

输出

假设这个数是回文数，则输出Yes，假设不是回文数。则输出No

例子输入

121

例子输出

Yes

签到题。

。

#include <stdio.h>

int main()
{
    int num, t;
    int sum = 0;
    scanf("%d", &num);
    t = num;
    while(num)          //将一个数转置，和原来的数字同样，就是回文数
    {
        sum = sum*10 + num%10;
        num /= 10;
    }

    if(t == sum)
        printf("Yes\n");
    else
        printf("No\n");
    return 0;
}

问题 G: 小明和他的嵌套娃娃

时间限制: 1 Sec 内存限制: 128 MB

题目描写叙述

小明有一个收藏嵌套娃娃的爱好，嵌套娃娃是这种一种娃娃，一个娃娃a1的宽为w1，高为h1，还有一个嵌套娃娃a2的宽为w2，高为h2，假设h1 > h2 并且 w1 > w2，则a2 能够嵌进a1;

小明有m个娃娃，他想在他女神生日的时候将他的全部娃娃都送给他女神。为了制造出一种“惊喜”的效果，他想要将小的娃娃尽量多的嵌套在大的娃娃里面，他觉得这种话，他的女神会“exciting”，他给你这些娃娃的宽和高，你能帮帮他，将这些娃娃尽量“少”的分组吗？

输入

第一行输入包括一个正整数t，表示接下来有t组数据（1 ≤ t ≤ 20）。接下来的t组数据，每一组数据都包括一个正整数m，表示有m个娃娃（1 ≤ m ≤ 20000）。 下一行包括 2m 个整数w1, h1,w2, h2, … ,wm, hm,

wi 和 hi 分别表示第i个娃娃的宽和高，对于全部的w。h都有（ 1 ≤ wi, hi ≤ 10000）.

输出

输出一个数字。表示最少能够分为几组。

例子输入

4

3

20 30 40 50 30 40

4

20 30 10 10 30 20 40 50

3

10 30 20 20 30 10

4

10 10 20 30 40 50 39 51

例子输出

1

2

3

2

这道题有一个超时的坑。可是没有人做出来

能够直接剪枝。。。考的是离散数学的偏序问题

原题地址：POJ 3636。想看具体解释的话。直接百度也能够

或者使用二分法。。。第一步是直接排序。

。。

。

好了。

。。

上代码

#include<stdio.h>
#include<algorithm>
using namespace std;
#define Max 20001
struct D{
    int w,h;
}d[Max];
D dd[Max];

bool cmp(D x,D y)//w升序。h降序能够保证w相等时，一定不会出现覆盖的情形。
{
    if(x.w==y.w) return x.h>y.h;
    return x.w<y.w;
}
int main()
{
    int n,i,j,m;
    scanf("%d",&n);
    while(n--)
    {
        int result=0;
        scanf("%d",&m);
        for(i=0;i<m;i++)
            scanf("%d%d",&d[i].w,&d[i].h);
        sort(d,d+m,cmp);
        for(i=0;i<m;i++)
        {
            int flag=0;
            for(j=0;j<result;j++)
                if(d[i].w>dd[j].w&&d[i].h>dd[j].h)
                {
                    dd[j]=d[i];
                    flag=1;
                    break;
                }
                if(!flag) dd[result++]=d[i];
        }
        printf("%d\n",result);
       }
    return 0;
}

问题 H: 优秀的三名研究生

时间限制: 1 Sec 内存限制: 128 MB

题目描写叙述

ACM实验室的alpha教授手下有三个研究生，每学期初alpha教授会给他们安排若干任务，每一个任务都有相应的难度值，教授要求每学期必须把全部任务全部完毕，并且难度值小的任务要先完毕。

教授的三个研究生都是非常优秀的学生，完毕这些任务对他们来说并没有什么困难，可是由于彼此都非常优秀。所以都不愿意和其它人一样，于是他们都想自己完毕任务的顺序和其它人不一样。

输入

输入数据第一行是一个正整数 n (1 ≤ n ≤ 2000) — 任务的数量。

第二行包括n个整数h1。 h2。…。hn(1 ≤ hi ≤ 2000), hi代表第i个任务的难度值。

输出

假设任务能够存在三种不同的完毕顺序，则第一行输出“YES”， 接下来三行输出三种完毕任务的顺序。假设有超过三种完毕任务的顺序，则先对较低难度值任务字典序排列，再对较高难度值任务字典序排列，依次输出前三种。

假设任务不存在三种不同的完毕顺序。则仅仅要输出“NO“。

例子输入

4

1 3 3 1

例子输出

YES

1 4 2 3

4 1 2 3

4 1 3 2

夏黑的题目，我就不说什么了，直接上代码：

#include<algorithm>
#include<iostream>
using namespace std;
int main()
{
    int n;
    cin>>n;
    pair<int,int> a[n];
    int now=0;
    for(int i=0;i<n;i++)cin>>a[i].first,a[i].second=i;
    sort(a,a+n);
    for(int i=0;i<n-1;i++)if(a[i].first==a[i+1].first)now++;
    if(now<2)
    {
        cout<<"NO\n";
        return 0;
    }
    int w=0;
    cout<<"YES\n";
    for(int i=0;i<n;i++)cout<<a[i].second+1<<" ";
    cout<<endl;
    for(int i=0;i<n,w!=2;i++)
    {
        if(a[i].first==a[i+1].first)
        {
            swap(a[i],a[i+1]);
            for(int j=0;j<n;j++)cout<<a[j].second+1<<" ";
            cout<<endl;
            w++;
        }
    }

    return 0;
}

问题 I: alpha特工学院

时间限制: 1 Sec 内存限制: 128 MB

题目描写叙述

alpha特工学院如今有n名学员，校长alpha用严格的规章制度给他们以史上最残酷的特工训练。

特工学院新学期即将到来，新学期将会持续d天，每天有k辆车接送学员上学。

由于是特工训练，所以校长alpha是不同意学员们彼此之间成为朋友的。所以alpha规定，在这k天时间里面，随意两个学员最多仅仅能有一天的时间是乘坐同一辆车的。

那么问题来了，教务老师在排学员的每天乘车方案时遇到了问题。聪明的小伙伴你能够帮助教务老师解决问题，让她不至于被校长责怪么？

输入

输入数据第一行是三个正整数 n, k, d (1 ≤ n, d ≤ 1000; 1 ≤ k ≤ 1000000000).

输出

假设找不到完美的解决方式则输出-1.

假设有完美解决方式则输出d行，每一行n个数字。第i行第j个数字表示第j学生

必须在第i天乘坐这辆车。

假设有多组输出。请參考例子的输出顺序。

校车的命名採用正整数从1-k。

例子输入

3 2 2

例子输出

1 2 1

1 1 2

还是夏黑的题，自己看看吧= =

还是没人做

#include <iostream>
#include <cstdio>
using namespace std;
int main()
{
    int n, k, d, i, j, v[1000];
    long long x=1;
    cin>>n>>k>>d;
    for (i=0; i<d && x<n; i++) x*=k;
    if (x<n) cout<<-1<<endl;
    else {
        for (i=0; i<n; i++) v[i]=i;
        for (i=0; i<d; i++) {
            for (j=0; j<n; j++) {
                cout<<v[j]%k+1<<" ";
                v[j]/=k;
            }
            cout<<endl;
        }
    }
    return 0;
}

问题 J: 遍历 遍历 遍历

时间限制: 1 Sec 内存限制: 128 MB

题目描写叙述

给你一个树，请你从上到下。从左到右，遍历树的每一个节点。

输入

第一行输入一个数N (N<=10)。代表总结点数。结点被从0~N-1编号。

接下来的n行，每行输入两个数。分别代表结点的左右孩子结点；

假设一个结点没有左右孩子，则用“-”表示。左右孩子之间用空格分开。

输出

依据你遍历树的顺序（从上到下，从左到右）。依次输出叶子结点；结点之间用空格隔开，结尾没有空格。

例子输入

8

1 -

- -

0 -

2 7

- -

- -

5 -

4 6

例子输出

4 1 5

数据结构。。

。

二叉树的广度优先搜索。。。。

#include <iostream>
#include <queue>
#include <cstdio>
#include <cstring>
using namespace std;
struct Node {
    int lchild;
    int rchild;
    Node() {
        lchild = -1;
        rchild = -1;
    }
};
Node node[20];
int n, flag = 0;
bool findroot[20];
char l, r;
queue<int> q;
void bfs(int i) {
    q.push(i);
    while(!q.empty()) {
        int cur = q.front();
        q.pop();
        if(node[cur].lchild == -1 && node[cur].rchild == -1) {
            if(flag == 0) {
                printf("%d", cur);
                flag = 1;
            } else {
                printf(" %d", cur);
            }
        }
        if(node[cur].lchild != -1) {
            q.push(node[cur].lchild);
        }
        if(node[cur].rchild != -1) {
            q.push(node[cur].rchild);
        }
    }
    printf("\n");
}
int main() {
    memset(findroot, false, sizeof(findroot));
    scanf("%d", &n);
    getchar();
    for (int i = 0; i < n; i ++) {
        scanf("%c %c", &l, &r);
        getchar();
        if(isdigit(l)) {
            node[i].lchild = l - '0';
            findroot[node[i].lchild] = 1;
        }
        if(isdigit(r)) {
            node[i].rchild = r - '0';
            findroot[node[i].rchild] = 1;
        }
    }
    for (int i = 0; i < n; i ++) {
        if(findroot[i] == 0) {
            bfs(i);
            break;
        }
    }
    return 0;
}

祝大家决赛取得好成绩。没了。