line message -a 努力 += required final sidebar treat

A. Odds and Ends

Where do odds begin, and where do they end? Where does hope emerge, and will they ever break?

Given an integer sequence a1, a2, ..., an of length n. Decide whether it is possible to divide it into an odd number of non-empty subsegments, the each of which has an odd length and begins and ends with odd numbers.

A subsegment is a contiguous slice of the whole sequence. For example, {3, 4, 5} and {1} are subsegments of sequence {1, 2, 3, 4, 5, 6}, while {1, 2, 4} and {7} are not.

Input

The first line of input contains a non-negative integer n

(1 ≤ n ≤ 100) — the length of the sequence.

The second line contains n space-separated non-negative integers a1, a2, ..., an (0 ≤ ai ≤ 100) — the elements of the sequence.

Output

Output "Yes" if it‘s possible to fulfill the requirements, and "No" otherwise.

You can output each letter in any case (upper or lower).

Examples input

3
1 3 5

output

Yes

input

5
1 0 1 5 1

output

Yes

input

3
4 3 1

output

No

input

4
3 9 9 3

output

No

Note

In the first example, divide the sequence into 1 subsegment: {1, 3, 5} and the requirements will be met.

In the second example, divide the sequence into 3 subsegments: {1, 0, 1}, {5}, {1}.

In the third example, one of the subsegments must start with 4 which is an even number, thus the requirements cannot be met.

In the fourth example, the sequence can be divided into 2 subsegments: {3, 9, 9}, {3}, but this is not a valid solution because 2 is an even number.

題意：給定一數組，判斷是否可以分成奇數個組，每組個數是奇數，每組的首尾都為奇數。

分析：偶數長度不可能，奇數長度無論怎麽分，首尾必須都為奇數，否則不可能，思維題！

#include <bits/stdc++.h>

using namespace std;

const int maxn = 105;

int a[maxn];

int main()
{
    int n;
    scanf("%d",&n);

    for(int i = 0; i < n; i++)
        scanf("%d",&a[i]);

    if(n%2==1) {
        if(a[0]%2==0||a[n-1]%2==0)
            puts("No");
        else puts("Yes");
    }
    else {
        puts("No");
    }


    return 0;
}

B. Tell Your World

Connect the countless points with lines, till we reach the faraway yonder.

There are n points on a coordinate plane, the i-th of which being (i, yi).

Determine whether it‘s possible to draw two parallel and non-overlapping lines, such that every point in the set lies on exactly one of them, and each of them passes through at least one point in the set.

Input

The first line of input contains a positive integer n (3 ≤ n ≤ 1 000) — the number of points.

The second line contains n space-separated integers y1, y2, ..., yn ( - 109 ≤ yi ≤ 109) — the vertical coordinates of each point.

Output

Output "Yes" (without quotes) if it‘s possible to fulfill the requirements, and "No" otherwise.

You can print each letter in any case (upper or lower).

Examples input

5
7 5 8 6 9

output

Yes

input

5
-1 -2 0 0 -5

output

No

input

5
5 4 3 2 1

output

No

input

5
1000000000 0 0 0 0

output

Yes

Note

In the first example, there are five points: (1, 7), (2, 5), (3, 8), (4, 6) and (5, 9). It‘s possible to draw a line that passes through points 1, 3, 5, and another one that passes through points 2, 4 and is parallel to the first one.

In the second example, while it‘s possible to draw two lines that cover all points, they cannot be made parallel.

In the third example, it‘s impossible to satisfy both requirements at the same time.

題意：

給定 n 個點的坐標，判斷是否所有的點，都在兩條不重合的平行線上。

分析：

計算幾何很少接觸，但是一般CF的計算幾何都是考思維，感覺很復雜，情況很多！

看了大牛的思路，確實厲害。

因為只存在兩條平行直線，枚舉這平行直線，平行直線可以通過ab，bc，ac，另一個點就在另一條平行的直線上。

這樣將所有點分為了兩個部分，其中另一個部分，要麽只有一個點，要麽在一條直線上，並且平行。

#include <bits/stdc++.h>

using namespace std;

const int maxn = 1005;

typedef long long ll;
int n;

struct Node {
    ll x,y;
} nodes[maxn],pp[maxn];

ll cc(Node a,Node b,Node c) {
    return (b.y-a.y)*(c.x-b.x) - (c.y-b.y)*(b.x-a.x);
}

bool check() {
    int cnt=0;
    for(int i=3; i<=n; i++)
        if(cc(nodes[1],nodes[2],nodes[i])!=0)
            pp[++cnt]=nodes[i];

    for(int i=3; i<=cnt; i++)
        if(cc(pp[1],pp[2],pp[i])!=0)
            return 0;
    Node ta,tb,tc;
    ta.x=nodes[2].x-nodes[1].x,ta.y=nodes[2].y-nodes[1].y;
    tb.x=pp[2].x-pp[1].x,tb.y=pp[2].y-pp[1].y;
    tc.x=tc.y=0;
    return cnt<2||cc(tc,ta,tb)==0;
}

int main() {
    scanf("%d",&n);

    for(int i = 1; i <= n; i++) {
        scanf("%I64d",&nodes[i].y);
        nodes[i].x = i;
    }

    int ff = 0;
    for(int i=3; i<=n&&!ff; i++)
        if(cc(nodes[i-2],nodes[i-1],nodes[i])!=0)
            ff=1;
    if(!ff) {
        printf("NO\n");
        return 0;
    }
    if(check()) {
        printf("YES\n");
        return 0;
    }
    swap(nodes[1],nodes[3]);
    if(check()) {
        printf("YES\n");
        return 0;
    }
    swap(nodes[2],nodes[3]);
    if(check()) {
        printf("YES\n");
        return 0;
    }
    printf("NO\n");
    return 0;

    return 0;
}

C. From Y to Y

From beginning till end, this message has been waiting to be conveyed.

For a given unordered multiset of n lowercase English letters ("multi" means that a letter may appear more than once), we treat all letters as strings of length 1, and repeat the following operation n - 1 times:

• Remove any two elements s and t from the set, and add their concatenation s + t to the set.

The cost of such operation is defined to be , where f(s, c) denotes the number of times character cappears in string s.

Given a non-negative integer k, construct any valid non-empty set of no more than 100 000 letters, such that the minimum accumulative cost of the whole process is exactly k. It can be shown that a solution always exists.

Input

The first and only line of input contains a non-negative integer k (0 ≤ k ≤ 100 000) — the required minimum cost.

Output

Output a non-empty string of no more than 100 000 lowercase English letters — any multiset satisfying the requirements, concatenated to be a string.

Note that the printed string doesn‘t need to be the final concatenated string. It only needs to represent an unordered multiset of letters.

Examples input

12

output

abababab

input

3

output

codeforces

Note

For the multiset {‘a‘, ‘b‘, ‘a‘, ‘b‘, ‘a‘, ‘b‘, ‘a‘, ‘b‘}, one of the ways to complete the process is as follows:

• {"ab", "a", "b", "a", "b", "a", "b"}, with a cost of 0;
• {"aba", "b", "a", "b", "a", "b"}, with a cost of 1;
• {"abab", "a", "b", "a", "b"}, with a cost of 1;
• {"abab", "ab", "a", "b"}, with a cost of 0;
• {"abab", "aba", "b"}, with a cost of 1;
• {"abab", "abab"}, with a cost of 1;
• {"abababab"}, with a cost of 8.

The total cost is 12, and it can be proved to be the minimum cost of the process.

題意：給定一個整數 k ，求構造一個字符串，字符串由單個多重集合的字母拼起來，每次連接兩個字符串，都有代價，總代價題目中有。

分析：

策略是：全部都與單字符拼起來。接近答案時，換一個字符重頭來。

#include <bits/stdc++.h>

using namespace std;

int main()
{

    int n;
    scanf("%d",&n);

    string s = "";
    if(n==0) {
        cout<<"a"<<endl;
    }
    else {
        char c = ‘a‘;
        while(n) {
            int sum = 0;
            int i = 0;
            for(i = 0; sum <=n; i++) {
                sum +=i;
            }

            n -=(sum-i+1);
            for(int j = 0; j<i-1;j++) {
                s +=c;
            }
            c++;

        }
        cout<<s<<endl;
    }
    
    return 0;
}

總的來說，感覺思維上和大佬們還是有很大的差距，要繼續努力才行~~~

Codeforces Round #431 (Div. 2)