Live Archive 训练题

7091 Height Ordering

Mrs. Chambers always has her class line up in height order (shortest at the front of the line). EverySeptember a new class of exactly 20 3rd graders arrive, all of different height. For the first few days it takes a long time to get the kids in height order, since no one knows where they should be in the line.Needless to say, there is quite a bit of jockeying around. This year Mrs. Chambers decided to try a new method to minimize this ordering chaos. One student would be selected to be the first person in line.Then, another student is selected and would find the first person in the line that is taller than him, andstand in front of that person, thereby causing all the students behind him to step back to make room.If there is no student that is taller, then he would stand at the end of the line. This process continues,one student at-a-time, until all the students are in line, at which point the students will be lined up in height order.For this problem, you will write a program that calculates the total number of steps taken back during the ordering process for a given class of students.
Input
The first line of input contains a single integer P, (1 ≤ P ≤ 1000), which is the number of data sets that follow. Each data set should be processed identically and independently.
Each data set consists of a single line of input. It contains the data set number, K, followed by 20 non-negative unique integers separated by a single space. The 20 integers represent the height (in millimeters) of each student in the class.
Output
For each data set there is one line of output. The single output line consists of the data set number, K, followed by a single space followed by total number of steps taken back.
Sample Input
4
1 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919
2 919 918 917 916 915 914 913 912 911 910 909 908 907 906 905 904 903 902 901 900
3 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 900
4 918 917 916 915 914 913 912 911 910 909 908 907 906 905 904 903 902 901 900 919
Sample Output
1 0
2 190
3 19
4 171

题目意思：给20个学生按照身高由高到低排序，按照顺序依次将学生排到第一个比他高的学生前面，他腾出的空间将由后面的学生补上，问所需要移动的次数。

解题思路：这道题其实抽象过来就是依次求所有学生其后比其矮的学生的人数，因为比他矮的学生经过最后一定会排在他的前面。

#include<cstdio>
#include<cstring>
using namespace std;
int main()
{
    int i,j,n,counts,ranks;
    int a[];
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d",&ranks);
        counts=;
        for(i=; i<; i++)
        {
            scanf("%d",&a[i]);
        }
        for(i=; i<; i++)
        {
            for(j=i+; j<; j++)
            {
                if(a[j]<a[i])
                {
                    counts++;
                }
            }
        }
        printf("%d %d\n",ranks,counts);
    }
    return ;
}

7092 Islands in the Data Stream

Given a sequence of integers a1, a2, a3, …, an, an island in the sequence is a contiguous subsequence for which each element is greater than the elements immediately before and after the subsequence. In the examples below, each island in the sequence has a bracket below it. The bracket for an island contained within another island is below the bracket of the containing island. Write a program that takes as input a sequence of 12 non-negative integers and outputs the number of islands in the sequence.

Input

The first line of input contains a single integer P, (1 ≤ P ≤ 1000), which is the number of data sets that follow. Each data set should be processed identically and independently. Each data set consists of a single line of input. It contains the data set number, K, followed by 12 non-negative integers separated by a single space. The first and last integers in the sequence will be ‘0’.

Output

For each data set there is one line of output. The single output line consists of the data set number, K, followed by a single space followed by the number of islands in the sequence.

题目意思：给出12个数字，如果一个子序列的两个端点及以内的每一个元素都大于子序列端点两边前一个和后一个数字，那么这个子序列称之为岛，求出这个序列一共有多少个岛。
解题思路： 直接可以暴力，利用三个for循环，把每个子序列都遍历一遍，令i,j为两个端点，用k进行遍历。

#include<cstdio>
#include<cstring>
using namespace std;
int main()
{
    int i,j,n,counts,ranks;
    int a[];
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d",&ranks);
        counts=;
        for(i=; i<; i++)
        {
            scanf("%d",&a[i]);
        }
        for(i=; i<; i++)
        {
            for(j=i+; j<; j++)
            {
                if(a[j]<a[i])
                {
                    counts++;
                }
            }
        }
        printf("%d %d\n",ranks,counts);
    }
    return ;
}

7094 Happy Happy Prime Prime

RILEY VASHTEE: [reading from display] Find the next number in the sequence:
313 331 367 ...? What?
THE DOCTOR: 379.
MARTHA JONES: What?
THE DOCTOR: It’s a sequence of happy primes — 379.
MARTHA JONES: Happy what?
THE DOCTOR: Any number that reduces to one when you take the sum of the square of its digits and continue iterating it until it yields 1 is a happy number. Any number that doesn’t, isn’t. A happy prime is both happy and prime.
THE DOCTOR: I dunno, talk about dumbing down. Don’t they teach recreational mathematics anymore?
Excerpted from “Dr. Who”, Episode 42 (2007).
The number 7 is certainly prime. But is it happy?
7 → 7
2 = 49
49 → 4
2 + 92 = 97
97 → 9
2 + 72 = 130
130 → 1
2 + 32 = 10
10 → 1
2 + 02 = 1
It is happy :-). As it happens, 7 is the smallest happy prime. Please note that for the purposes of this problem, 1 is not prime.
For this problem you will write a program to determine if a number is a happy prime.
Input
The first line of input contains a single integer P, (1 ≤ P ≤ 1000), which is the number of data sets that follow. Each data set should be processed identically and independently.
Each data set consists of a single line of input. It contains the data set number, K, followed by the happy prime candidate, m, (1 ≤ m ≤ 10000).
Output
For each data set there is a single line of output. The single output line consists of the data set number, K, followed by a single space followed by the candidate, m, followed by a single space, followed by ‘YES’ or ‘NO’, indicating whether m is a happy prime.
Sample Input
4
1 1
2 7
3 383
4 1000
Sample Output
1 1 NO
2 7 YES
3 383 YES
4 1000 NO

题目意思：判断一个数是不是快乐素数，要求该数既是素数，并且该数经过有限次变化后的各位数平方之后和为1。

解题思路：直接模拟即可，注意去重判断。

#include<cstdio>
#include<cmath>
#include<cstring>
using namespace std;
int vis[];
int isprime(int n)
{
    int i;
    if(n==)
    {
        return ;
    }
    for(i=;i<=sqrt(n);i++)
    {
        if(n%i==)
        {
            return ;
        }
    }
    return ;
}
int judge(int n)
{
    int ans,i;
    memset(vis,,sizeof(vis));
    while(!vis[n]&&n!=)
    {
        ans=;
        vis[n]=;
        while(n>=)
        {
            ans=ans+(n%)*(n%);
            n=n/;
        }
        if(ans!=)
        {
            n=ans;
        }
        else
        {
            return ;
        }
    }
    return ;
}
int main()
{
    int i,j,n,flag,no,m;
    scanf("%d",&n);
    while(n--)
    {
        scanf("%d%d",&no,&m);
        printf("%d %d ",no,m);
        if(isprime(m)&&judge(m))
        {
            printf("YES\n");
        }
        else
        {
            printf("NO\n");
        }
    }
    return ;
}

7096 A Rational Sequence

An infinite full binary tree labeled by positive rational numbers is defined by:
• The label of the root is 1/1.
• The left child of label p/q is p/(p+q).
• The right child oflabel p/q is (p+q)/q.
The top of the tree is shown in the following figure:
A rational sequence is defined by doing a level order (breadth first) traversal of the tree (indicated by the light dashed line). So that:
F(1) = 1/1, F(2) = 1/2, F(3) = 2/1, F(4) = 1/3, F(5) = 3/2, F(6) = 2/3, . . .
Write a program which takes as input a rational number, p/q, in lowest terms and finds the next rational number in the sequence. That is, if F(n) = p/q, then the result is F(n + 1).

Input
The first line of input contains a single integer P, (1 ≤ P ≤ 1000), which is the number of data sets that follow. Each data set should be processed identically and independently.
Each data set consists of a single line of input. It contains the data set number, K, which is then followed by a space, then the numerator of the fraction, p, followed immediately by a fonward slash (/), followed immediately by the denominator of the fraction, q. Both p and q will be relatively prime and 0 ≤ p, q ≤ 2147483647.
Output
For each data set there is a single line of output. It contains the data set number, K, followed by a single space which is then followed by the numerator of the fraction, followed immediately by a forward slash (‘/’) followed immediately by the denominator of the fraction. Inputs will be chosen such that neither the numerator nor the denominator will overflow a 32-bit integer.

Sample Input
5
1 1/1
2 1/3
3 5/2
4 2178309/1346269
5 1/1OOOOOOO
Sample Output
1 1/2
2 3/2
3 2/5
4 1346269/1860498
5 1OOOOOOO/9999999

题目意思：每个结点有左右两个值（p/q），其左孩子是（p/(p+q)），右孩子是（(p+q)/q），给出下一个结点的值。

解题思路：实际上这道题就是按照二叉树层次遍历求下一个结点，我们分成三种情况：

1如果是根结点，那么下一个结点必然是1/2。

2如果该结点是某个结点的左孩子，那么可以推得下一个结点。

3如果该结点是某个结点的右孩子，那么首先要向上找到一个父亲结点，再从这个父亲结点向下找。

#include<cstdio>
#include<cmath>
#include<cstring>
#define ll long long int
using namespace std;
int main()
{
    ll a,b,t,n,p,q,counts;
    scanf("%lld",&t);
    while(t--)
    {
        scanf("%lld%lld/%lld",&n,&p,&q);
        if(p==q)
        {
            a=;
            b=;
        }
        else if(p<q)///如果是左孩子，能够直接得到右孩子
        {
            a=q;
            b=q-p;
        }
        else if(p>q)
        {
            a=q;
            counts=;///记录返回所需要的层数
            /*while(1)
            {
                if(p<=q)
                {
                    break;
                }
                p=p-q;
                counts++;
            }*/
            ///化减法为除法
            counts=(p-p%q)/q;
            b=q-p+counts*q;///向上回溯获得新的分母
            b=b+counts*q;///向下获得新的分子
            //b=q-p+2*counts*q;//化简后的式子
        }
        printf("%lld %lld/%lld\n",n,a,b);
    }
    return ;
}