Codeforces Round #298 (Div. 2)

　　　　　　　　　　A. Exam

 

An exam for n students will take place in a long and narrow room, so the students will sit in a line in some order. The teacher suspects that students with adjacent numbers (i and i + 1) always studied side by side and became friends and if they take an exam sitting next to each other, they will help each other for sure.

Your task is to choose the maximum number of students and make such an arrangement of students in the room that no two students with adjacent numbers sit side by side.

Input

A single line contains integer n (1 ≤ n ≤ 5000) — the number of students at an exam.

Output

In the first line print integer k — the maximum number of students who can be seated so that no two students with adjacent numbers sit next to each other.

In the second line print k distinct integers a1, a2, ..., ak (1 ≤ ai ≤ n), where ai is the number of the student on the i-th position. The students on adjacent positions mustn't have adjacent numbers. Formally, the following should be true: |ai - ai + 1| ≠ 1 for all i from 1 tok - 1.

If there are several possible answers, output any of them.

Sample test(s)

input

6

output

6
1 5 3 6 2 4

input

3

output

2
1 3


题意：一排学生，依次编号为1到n，
现在要考试了，老师知道每个学生i都会和相邻的学生(i-1)和(i+1)作弊，
所以老师要重新排列，拆散他们，使得任何一个i都不能和(i-1),(i+1)相邻。
当然啦，这样会有一些学生可能无法同时考试。
输出k：最多能同时有多少个学生去考试
k个数：分别为这k个学生原来的编号。

思路：1到4特判，n>=5时一定可以所有人同时考试(两两搭配)。
wa了2次，因为4时特判错了。
4时4个人可以同时考试，我逗比了，以为只能有3个。

#include<iostream>
using namespace std;
const int maxn=5004;
int a[maxn];
int main()
{
    int n;
    while(cin>>n)
    {
        if(n==1)
        {
            cout<<1<<endl;
            cout<<1<<endl;
        }
        else if(n==2)
        {
            cout<<1<<endl;
            cout<<1<<endl;
        }
        else if(n==3)
        {
            cout<<2<<endl;
            cout<<"1 3"<<endl;
        }
        else if(n==4)
        {
            cout<<4<<endl;
            cout<<"3 1 4 2"<<endl;
        }
        else{
            cout<<n<<endl;
            for(int i=1;i<=n;i++)
                a[i]=i;
            int k=(n+1)/2;
            int first=0;
            for(int i=1;i<=k;i++)
            {
                if(first)
                    cout<<" ";
                first++;
                cout<<a[i];
                if(i+k<=n){
                    cout<<" "<<a[i+k];
                }
            }
            cout<<endl;
        }
    }
    return 0;
}

　　　　　　　　　　B. Covered Path

 

The on-board computer on Polycarp's car measured that the car speed at the beginning of some section of the path equals v1 meters per second, and in the end it is v2 meters per second. We know that this section of the route took exactly t seconds to pass.

Assuming that at each of the seconds the speed is constant, and between seconds the speed can change at most by d meters per second in absolute value (i.e., the difference in the speed of any two adjacent seconds does not exceed d in absolute value), find the maximum possible length of the path section in meters.

Input

The first line contains two integers v1 and v2 (1 ≤ v1, v2 ≤ 100) — the speeds in meters per second at the beginning of the segment and at the end of the segment, respectively.

The second line contains two integers t (2 ≤ t ≤ 100) — the time when the car moves along the segment in seconds, d (0 ≤ d ≤ 10) — the maximum value of the speed change between adjacent seconds.

It is guaranteed that there is a way to complete the segment so that:

• the speed in the first second equals v1,
• the speed in the last second equals v2,
• the absolute value of difference of speeds between any two adjacent seconds doesn't exceed d.

Output

Print the maximum possible length of the path segment in meters.

Sample test(s)

input

5 6
4 2

output

26

input

10 10
10 0

output

100

Note

In the first sample the sequence of speeds of Polycarpus' car can look as follows: 5, 7, 8, 6. Thus, the total path is 5 + 7 + 8 + 6 = 26meters.

In the second sample, as d = 0, the car covers the whole segment at constant speed v = 10. In t = 10 seconds it covers the distance of 100 meters.

题意：一辆车，第1秒的速度为v1，第t秒的速度为v2，从第一秒到第t秒，每秒变化的速度要求
　　　为v-d和v+d之间。
问，这t秒内最大的位移。

思路：从第1秒开始，尽量增加速度，再中间再减少速度，使得第t秒时刚好为v2。
　　(位移就是v-t坐标曲线围成的面积)

1.由于对称性，若v1>v2，则swap
2.我刚开始两边同时增加d和减少d，在中间对接，但是这样是错的，若v1和v2差距太大的话
3.先让v1增加，使得v1尽量接近于v2，但同时保证v1<=v2
　然后同时改变速度，在中间对接，注意中间的处理情况。

#include<iostream>
using namespace std;
const int maxn=105;
int a[maxn];
int main()
{
    int v1,v2;
    while(cin>>v1>>v2)
    {
        int t,d;
        cin>>t>>d;
        if(v1>v2)
        {
            int mmm=v1;
            v1=v2;
            v2=mmm;
        }
        a[1]=v1;
        a[t]=v2;
        int i=1;
        while(a[i]+d<v2)
        {
            a[i+1]=a[i]+d;
            i++;
        }
        int j=t;
        while(j-i>1)
        {
            a[i+1]=a[i]+d;
            a[j-1]=a[j]+d;
            i++;
            j--;
        }
        if(i==j){
            i--;
        }
        if(a[i]+d<a[j])
            a[j]=a[i]+d;
        int sum=0;
        for(int i=1;i<=t;i++)
            sum+=a[i];
        cout<<sum<<endl;
    }
    return 0;
}

　　　　　　　　　　C. Polycarpus' Dice

 

Polycarp has n dice d1, d2, ..., dn. The i-th dice shows numbers from 1 to di. Polycarp rolled all the dice and the sum of numbers they showed is A. Agrippina didn't see which dice showed what number, she knows only the sum A and the values d1, d2, ..., dn. However, she finds it enough to make a series of statements of the following type: dice i couldn't show number r. For example, if Polycarp had two six-faced dice and the total sum is A = 11, then Agrippina can state that each of the two dice couldn't show a value less than five (otherwise, the remaining dice must have a value of at least seven, which is impossible).

For each dice find the number of values for which it can be guaranteed that the dice couldn't show these values if the sum of the shown values is A.

Input

The first line contains two integers n, A (1 ≤ n ≤ 2·105, n ≤ A ≤ s) — the number of dice and the sum of shown values where s = d1 + d2 + ... + dn.

The second line contains n integers d1, d2, ..., dn (1 ≤ di ≤ 106), where di is the maximum value that the i-th dice can show.

Output

Print n integers b1, b2, ..., bn, where bi is the number of values for which it is guaranteed that the i-th dice couldn't show them.

Sample test(s)

input

2 8
4 4

output

3 3 

input

1 3
5

output

4 

input

2 3
2 3

output

0 1 

Note

In the first sample from the statement A equal to 8 could be obtained in the only case when both the first and the second dice show 4. Correspondingly, both dice couldn't show values 1, 2 or 3.

In the second sample from the statement A equal to 3 could be obtained when the single dice shows 3. Correspondingly, it couldn't show 1, 2, 4 or 5.

In the third sample from the statement A equal to 3 could be obtained when one dice shows 1 and the other dice shows 2. That's why the first dice doesn't have any values it couldn't show and the second dice couldn't show 3.

题意：现在有n个骰子，用这n个骰子摇出的和为A
一次给出n个骰子的范围,d[i]，,表示i-th个骰子的范围为1~d[i]
依次输出这n个骰子的各自的范围 ( 1~d[i] ) 中有多少个数是不可能出现的。

思路：当其他骰子同时为最小和最大时这个骰子向上的数就为最大数和最小数，小于最小的，和大于最大的，肯定就不可能出现的。

#include<cstdio>
#include<iostream>
using namespace std;
const int maxn=200000+10;
long long A;
int d[maxn];
int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        cin>>A;
        for(int i=1;i<=n;i++)
            scanf("%d",&d[i]);
        if(n==1)
        {
            long long sum=d[1]-1;
            cout<<sum;
        }else
        {
            long long max=0;
            for(int i=1;i<=n;i++)
                max+=d[i];
            int first=0;
            for(int i=1;i<=n;i++)
            {
                long long sum=0;
                long long x=A+1-n;
                if(d[i]>x)
                    sum+=(d[i]-x);
                long long y=A-(max-d[i]);
                if(y>0)
                    sum+=(y-1);
                if(first)
                    cout<<" ";
                first++;
                cout<<sum;
            }
        }
        cout<<endl;
    }
    return 0;
}