kickstart 谷歌 D 2020 年 7 月 12 日 13: 00

https://codingcompetitions.withgoogle.com/kickstart/round/000000000019ff08/0000000000386d5c （kick start上网方式需百度）

 （第一题ac，第二题ac，第三题，小数据集能ac，第四题，小数据集能ac）

第一题：

大致意思就是要找峰值点（第一，必须严格大于前面所有值，第二，要么是结尾值，要么必须满足比后一位严格大），基础题，略

Problem

Isyana is given the number of visitors at her local theme park on N consecutive days. The number of visitors on the i-th day is V_i. A day is record breaking if it satisfies both of the following conditions:

• The number of visitors on the day is strictly larger than the number of visitors on each of the previous days.
• Either it is the last day, or the number of visitors on the day is strictly larger than the number of visitors on the following day.

Note that the very first day could be a record breaking day!

Please help Isyana find out the number of record breaking days.

Input

The first line of the input gives the number of test cases, T. T test cases follow. Each test case begins with a line containing the integer N. The second line contains N integers. The i-th integer is V_i.

Output

For each test case, output one line containing Case #x: y, where x is the test case number (starting from 1) and y is the number of record breaking days.

Limits

Time limit: 20 seconds per test set.
Memory limit: 1GB.
1 ≤ T ≤ 100.
0 ≤ V_i ≤ 2 × 10⁵.

Test set 1

1 ≤ N ≤ 1000.

Test set 2

1 ≤ N ≤ 2 × 10⁵ for at most 10 test cases.
For the remaining cases, 1 ≤ N ≤ 1000.

Sample

Input	Output
4 8 1 2 0 7 2 0 2 0 6 4 8 15 16 23 42 9 3 1 4 1 5 9 2 6 5 6 9 9 9 9 9 9	Case #1: 2 Case #2: 1 Case #3: 3 Case #4: 0

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

int main()
{
    int t, n;
    cin>>t;
    for(int i=1;i<=t;i++)
    {
        cin>>n;
        vector<int> v;
        for(int j=0;j<n;j++)
        {
            int tt;
            cin>>tt;
            v.push_back(tt);
        }
        int result = 0;
        int max_v = INT_MIN;

        if(v.size()==1)
        result = 1;
        else
        {
            for(int j=0;j<v.size();j++)
            {
                if(j>=1)
                max_v = max(max_v, v[j-1]);

                if(j<=v.size()-2)
                {
                    if(v[j]>max_v && v[j]>v[j+1])
                    result++;
                }
                else
                {
                    if(v[j]>max_v)
                    result++;
                }
            }
        }

        printf("Case #%d: %d
", i, result);


    }//end of for



    return 0;
}

第二题：

本题题意复杂些，就是要一堆数字转换成A B C D，数字若是升/降序，则转换成的字母也要是对应的升/降序。问，不满足这种次序关系的有几处。

方法：每出现连续5个降序或者5个升序，则不满足情况+1

Problem

An alien has just landed on Earth, and really likes our music. Lucky for us.

The alien would like to bring home its favorite human songs, but it only has a very strange instrument to do it with: a piano with just 4 keys of different pitches.

The alien converts a song by writing it down as a series of keys on the alien piano. Obviously, this piano will not be able to convert our songs completely, as our songs tend to have many more than 4 pitches.

The alien will settle for converting our songs with the following rules instead:

• The first note in our song can be converted to any key on the alien piano.
• For every note after,
  • if its pitch is higher than the previous note, it should be converted into a higher-pitched key than the previous note's conversion;
  • if lower, it should be converted into a lower-pitched key than the previous note's conversion;
  • if exactly identical, it should be converted into the same key as the previous note's conversion.

Note: two notes with the same pitch do not need to be converted into the same key if they are not adjacent.

What the alien wants to know is: how often will it have to break its rules when converting a particular song?

To elaborate, let us describe one of our songs as having K notes. The first note we describe as "note 1", the second note "note 2", and the last note "note K."
So note 2 comes immediately after note 1.
Now if note 2 is lower than note 1 in our version of the song, yet converted to an equally-pitched or lower-pitched key (relative to note 2's conversion) in the alien's version of the song, then we consider that a single rule break.
For each test case, return the minimum amount of times the alien must necessarily break one of its rules in converting that song.

Input

The first line of the input gives the number of test cases, T. T test cases follow.
Each test case consists of two lines.
The first line consists of a single integer, K.
The second line consists of K space-separated integers, A₁, A₂ ... A_K, where A_i refers to the pitch of the i-th note for this test case.

Output

For each test case, output one line containing Case #x: y, where x is the test case number (starting from 1) and y is the minimum number of times that particular test case will require the alien to break its own rules during the conversion process.

Limits

Memory limit: 1GB.
1 ≤ T ≤ 100.
1 ≤ A_i ≤ 10⁶.

Test set 1

Time limit: 20 seconds.
1 ≤ K ≤ 10.

Test set 2

Time limit: 40 seconds.
1 ≤ K ≤ 10⁴.

Sample

Input	Output
2 5 1 5 100 500 1 8 2 3 4 5 6 7 8 9	Case #1: 0 Case #2: 1

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

int main()
{
    int t, a;
    cin>>t;
    for(int i=1;i<=t;i++)
    {
        cin>>a;
        vector<int> v;
        for(int j=0;j<a;j++)
        {
            int tt;
            cin>>tt;
            v.push_back(tt);
        }
        int result = 0;
        int inc = 0, dec = 0;
        for(int j=1;j<v.size();j++)
        {
            if(v[j]>v[j-1])
            {
                inc++;
                dec = 0;
            }
            if(v[j]<v[j-1])
            {
                dec++;
                inc = 0;
            }
            if(inc==4 || dec==4)
            {
                result++;
                inc = 0;
                dec = 0;
            }
        }
        printf("Case #%d: %d
", i, result);
        
    }
    
    
    return 0;
}

第三题：

该题是考察树，注意每个人是随机访问一个点，然后向上访问(travel up) 直到树根。然后求图画的节点的期望值。

（对于每个TreeNode需要提前建立parent的索引，暴力法，对于A，B两个人，分别遍历了每个节点，时间复杂度较高，小数据能ac）

Problem

Amadea and Bilva are decorating a rooted tree containing N nodes, labelled from 1 to N. Node 1 is the root of the tree, and all other nodes have a node with a numerically smaller label as their parent.

Amadea and Bilva's decorate the tree as follows:

• Amadea picks a node of the tree uniformly at random and paints it. Then, she travels up the tree painting every A-th node until she reaches the root.
• Bilva picks a node of the tree uniformly at random and paints it. Then, she travels up the tree painting every B-th node until she reaches the root.

The beauty of the tree is equal to the number of nodes painted at least once by either Amadea or Bilva. Note that even if they both paint a node, it only counts once.

What is the expected beauty of the tree?

Input

The first line of the input gives the number of test cases, T. T test cases follow. Each test case begins with a line containing the three integers N, A and B. The second line contains N-1 integers. The i-th integer is the parent of node i+1.

Output

For each test case, output one line containing Case #x: y, where x is the test case number (starting from 1) and y is the expected beauty of the tree.

y will be considered correct if it is within an absolute or relative error of 10^-6 of the correct answer. See the FAQ for an explanation of what that means, and what formats of real numbers we accept.

Limits

Memory limit: 1GB.
1 ≤ T ≤ 100.
1 ≤ A ≤ N.
1 ≤ B ≤ N.

Test set 1

Time limit: 20 seconds.
1 ≤ N ≤ 100.

Test set 2

Time limit: 40 seconds.
For up to 5 cases, 1 ≤ N ≤ 5 × 10⁵.
For all other cases, 1 ≤ N ≤ 100.

Sample

Input	Output
3 8 2 3 1 1 3 4 4 3 4 10 3 4 1 1 1 1 1 1 1 1 1 4 3 1 1 2 3	Case #1: 2.65625 Case #2: 1.9 Case #3: 2.875

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

struct TreeNode {
      int val;
      //vector<TreeNode*> child;
      TreeNode *parent;
      TreeNode(int x) : val(x), parent(NULL){}

  };

int main()
{
    int t;
    cin>>t;
    for(int i=1;i<=t;i++)
    {
        int n,a,b;
        cin>>n>>a>>b;
        vector<TreeNode*> v(n+1,NULL);

        v[1] = new TreeNode(1);

        for(int j=0;j<n-1;j++)
        {
            int tt;
            cin>>tt;

            v[j+2] = new TreeNode(j+2);
            v[j+2] -> parent = v[tt];
        }

        //vector<TreeNode*> vv(v);
        set<TreeNode*> s;
        int num = 0;
        for(int x=1;x<=n;x++)
        for(int y=1;y<=n;y++)
        {
            s.clear();
            TreeNode* p = v[x];
            TreeNode* q = v[y];
            while(p)
            {
                s.insert(p);
                for(int k=1;k<=a;k++)
                {
                    if(!p)
                    break;
                    p = p->parent;
                }
            }//

            while(q)
            {
                s.insert(q);
                for(int k=1;k<=b;k++)
                {
                    if(!q)
                    break;
                    q = q->parent;
                }
            }


            num += s.size();

        }//end of for x,y
        //cout<<"num:"<<num<<endl;
        //cout<<"n:"<<n<<endl;

        double result = num/1.0/(n*n);
        //cout<<"result:"<<result<<endl;
        printf("Case #%d: %f
", i, result);

    }


    return 0;
}

第四题：

题意：一横排有n个房间，每个房间往左往右走，都可能需要开锁，每次开难度较小的锁，到达尽头则不能继续走。给出si(start)起始房间的号码，求问第ki次进入到了哪个房间。

暴力求解，每次记下了每个房间左右的房间号，记录了左右锁的难度。（问题在于每次初始化，很耗时，所以只有小数据能ac）

Problem

Bangles is preparing to go on a tour of her local museum. The museum is made up of N rooms in a row, numbered from 1 to N from left to right. The rooms are connected by N-1 locked doors, each connecting a pair of adjacent rooms. Each door has a difficulty level indicating how difficult it is for Bangles to open the door. No two doors will have the same difficulty level. The door between the i-th room and (i+1)-th room has difficulty level D_i.

Bangles will pick one of the rooms to start in, and visit each of the rooms in the museum one at a time, taking pictures as she goes. She takes a picture in her starting room, then she repeats the following procedure until she has taken a picture in all the rooms: Of the two locked doors available to her, she will open the door with the lower difficulty level and take a picture in the newly unlocked room. If there is only one locked door available to her, then she will unlock that door. Once a door is unlocked, it remains unlocked.

Bangles is not yet sure which room she would like to start in, so she needs you to answer Q queries. For the i-th query, she would like to know: What is the K_i-th room that she will take a picture in if she starts in the S_i-th room?

Input

The first line of the input gives the number of test cases, T. T test cases follow. The first line of each test case contains the two integers N and Q. The second line contains N-1 integers, describing the locked doors. The i-th integer (starting from 1) is D_i. Then, Q lines follow, describing the queries. The i-th of these lines contains the two integers S_i and K_i.

Output

For each test case, output one line containing Case #x: y, where x is the test case number (starting from 1) and y is a list of the answers for the Q queries in order, separated by spaces.

Limits

Time limit: 40 seconds per test set.
Memory limit: 1GB.
1 ≤ T ≤ 100.
1 ≤ D_i ≤ 10⁵, for all i.
All D_i are distinct.
1 ≤ S_i ≤ N, for all i.
1 ≤ K_i ≤ N, for all i.

Test set 1

2 ≤ N ≤ 1000.
1 ≤ Q ≤ 1000.

Test set 2

2 ≤ N ≤ 10⁵ and 1 ≤ Q ≤ 10⁵ for at most 20 test cases.
For the remaining cases, 2 ≤ N ≤ 1000 and 1 ≤ Q ≤ 1000.

Sample

Input	Output
2 5 4 90 30 40 60 3 4 3 1 1 5 4 3 10 2 6 2 4 5 9 30 7 1 8 6 8 6 8

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

int main()
{
    int t;
    cin>>t;
    for(int i=1;i<=t;i++)
    {
        int n, q;
        cin>>n>>q;
        vector<int> v;
        for(int j=0;j<n-1;j++)
        {
            int tt;
            cin>>tt;
            v.push_back(tt);
        }
        vector<int> result;

        for(int tt=1;tt<=q;tt++)
        {
            //cout<<"tt:"<<tt<<endl;
            vector<int> l_room(n+1,0),r_room(n+1,0),l_value(n+1,0),r_value(n+1,0);
            for(int j=1;j<=n;j++)
            {
                //cout<<"j:"<<j<<endl;
                l_room[j] = j-1;
                r_room[j] = j+1;
                if(j-2>=0)
                l_value[j] = v[j-2];
                else
                l_value[j] = INT_MAX;

                if(j!=n)
                r_value[j] = v[j-1];
                else
                r_value[j] = INT_MAX;
            }
            //cout<<"22222"<<endl;
            int s,k;
            cin>>s>>k;

            k--;

            for(int u=1;u<=k;u++)
            {


                if(l_value[s]<r_value[s])
                {
                    int temp = s;
                    s = l_room[s];
                    r_room[s] = r_room[temp];
                    r_value[s] = r_value[temp];
                }
                else
                {
                    int temp = s;
                    s = r_room[s];
                    l_room[s] = l_room[temp];
                    l_value[s] = l_value[temp];
                }
            }
            result.push_back(s);
            //cout<<"end this"<<endl;

        } //end of q
        printf("Case #%d: ",i);
        for(auto u:result)
        cout<<u<<" ";

        cout<<endl;


    }



    return 0;
}