Codeforces Round #260 (Div. 2) A~C

题目链接

A. Laptops

time limit per test:1 second
memory limit per test:256 megabytes
input:standard input
output:standard output

One day Dima and Alex had an argument about the price and quality of laptops. Dima thinks that the more expensive a laptop is, the better it is. Alex disagrees. Alex thinks that there are two laptops, such that the price of the first laptop is less (strictly smaller) than the price of the second laptop but the quality of the first laptop is higher (strictly greater) than the quality of the second laptop.

Please, check the guess of Alex. You are given descriptions of n laptops. Determine whether two described above laptops exist.

Input

The first line contains an integer n (1 ≤ n ≤ 10⁵) — the number of laptops.

Next n lines contain two integers each, a_i and b_i (1 ≤ a_i, b_i ≤ n), where a_i is the price of the i-th laptop, and b_i is the number that represents the quality of the i-th laptop (the larger the number is, the higher is the quality).

All a_i are distinct. All b_i are distinct.

Output

If Alex is correct, print "Happy Alex", otherwise print "Poor Alex" (without the quotes).

Sample test(s)

input

2
1 2
2 1

output

Happy Alex

题意 ： 给你n台笔记本的价格和质量，如果能找出一台电脑的价格比另一台的高可是质量却比他低就输出Happy Alex，否则输出Poor Alex。

思路 ：将价格排序，然后找相邻的是否质量后边的大于前边那台的。这样做的道理是，价格排完序之后，如果存在不相邻的后者质量小于前者质量，那么中间必定有相邻的质量不符合前小于后。例如，价格3 4 5的电脑，如果5的质量比3的差，那么4的质量高于3时，说明4的质量高于5，4 5相邻。如果4的质量低于5的话，那么4的质量低于3，3 4 相邻。

#include <cstdio>
#include <cstring>
#include <cmath>
#include <iostream>
#include <algorithm>

using namespace std ;

struct node
{
    int price ;
    int qua ;
}a[100010];

int cmp(node x,node y)
{
    return x.price < y.price ;
}
int main()
{
    int n ;
    scanf("%d",&n) ;
    for(int i = 0 ; i < n ; i++)
    {
        scanf("%d %d",&a[i].price,&a[i].qua) ;    }
        sort(a,a+n,cmp) ;
        int flag = 0 ;
        for(int i = 0 ; i < n-1 ; i++)
        {
            if(a[i].qua > a[i+1].qua)
            {
                flag = 1 ;
                break ;
            }
        }
        if(flag)
            puts("Happy Alex") ;
        else puts("Poor Alex") ;
    return 0 ;
}

B. Fedya and Maths

time limit per test:1 second
memory limit per test:256 megabytes
input:standard input
output:standard output

Fedya studies in a gymnasium. Fedya's maths hometask is to calculate the following expression:

(1ⁿ + 2ⁿ + 3ⁿ + 4ⁿ) mod 5

for given value of n. Fedya managed to complete the task. Can you? Note that given number n can be extremely large (e.g. it can exceed any integer type of your programming language).

Input

The single line contains a single integer n (0 ≤ n ≤ 10¹⁰⁵). The number doesn't contain any leading zeroes.

Output

Print the value of the expression without leading zeros.

Sample test(s)

input

4

output

4

input

124356983594583453458888889

output

0

Note

Operation x mod y means taking remainder after division x by y.

Note to the first sample:

题意 ： 给你一个N，让你求（1ⁿ+2ⁿ+3ⁿ+4ⁿ）%5的值。

思路 ： 1到9这9的数字的n次方都是有规律的，1无论几次方个位数一定是1，而2的几次方个位数则是6，2，4，8分别代表是n模4为0，则2ⁿ个位数是6，n模4为1，则个位数是2……，

3的与2一样的规律，分别是1 3 9 7，而4的规律则是6 4，只有两个，我们写成以下形式：

n%4 = 0    1 + 6 + 1 + 6  = 14 

n%4 = 1    1 + 2 + 3 + 4  =  10

n%4 = 2    1 + 4 + 9 + 6  =  20

n%4 = 3    1 + 8 + 7 + 4  =  20

由此可见，只有在n%4为0时，取余为4，其余都为0.。。。

import java.math.*;
import java.util.*;

public class Main
{

    public static void main(String[] args)
    {
        Scanner cin = new Scanner(System.in) ;
        BigInteger n;
        n = cin.nextBigInteger();
        BigInteger t = n.mod(BigInteger.valueOf(4));
        if(t.compareTo(BigInteger.ZERO) == 0)
            System.out.println(4) ;
        else System.out.println(0) ;
        cin.close();
    }
}

C. Boredom

time limit per test:1 second
memory limit per test:256 megabytes
input:standard input
output:standard output

Alex doesn't like boredom. That's why whenever he gets bored, he comes up with games. One long winter evening he came up with a game and decided to play it.

Given a sequence a consisting of n integers. The player can make several steps. In a single step he can choose an element of the sequence (let's denote it a_k) and delete it, at that all elements equal to a_k + 1 and a_k - 1 also must be deleted from the sequence. That step brings a_k points to the player.

Alex is a perfectionist, so he decided to get as many points as possible. Help him.

Input

The first line contains integer n (1 ≤ n ≤ 10⁵) that shows how many numbers are in Alex's sequence.

The second line contains n integers a₁, a₂, ..., a_n (1 ≤ a_i ≤ 10⁵).

Output

Print a single integer — the maximum number of points that Alex can earn.

Sample test(s)

input

2
1 2

output

2

input

3
1 2 3

output

4

input

9
1 2 1 3 2 2 2 2 3

output

10

Note

Consider the third test example. At first step we need to choose any element equal to 2. After that step our sequence looks like this [2, 2, 2, 2]. Then we do 4 steps, on each step we choose any element equals to 2. In total we earn 10 points.

题意 ： 删掉某个数x，之后你可以得到x分，但同时数列中所有x-1与x+1都要删除，问怎么样删除能得到最大的分数，输出这个分数。

思路 ：先哈希一下再dp，dp[i]=max(dp[i-1],dp[i-2]+i*hashh[i])，这个方程代表的是当删除 i 的时候能得到分数，要么是你不删除i，而删除i-1，则得到的是删除i-1时得到的最大的分数，此时i与i-2都会被删掉。

如果你要删除 i ，因此i-1需要被删除，此时得到的分数就是你删除i-2时得到的最大值再加上删除 i 得到的分数。

例如6 7 8

你要是删除7，那你到8这个位置的时候能得到的最大值就是删除7得到的最大值。可是如果你删除6的话，那你到8这个位置时就是删除6得到的最大值再加上删除自己能够得到的分数。

#include <cstdio>
#include <cstring>
#include <iostream>
#define LL long long

using namespace std ;

int a[100010] ;
LL hashh[100010],dp[100010] ;

int main()
{
    int n ;
    while(scanf("%d",&n)!=EOF)
    {
        memset(hashh,0,sizeof(hashh)) ;
        memset(dp,0,sizeof(dp)) ;
        int maxx = 0 ;
        for(int i = 0 ; i < n ; i++)
        {
            scanf("%d",&a[i]) ;
            hashh[a[i]] ++ ;
            maxx = max(a[i],maxx) ;
        }
        dp[1] = hashh[1] ;
        for(int i = 2 ; i <= maxx ; i++)
            dp[i] = max(dp[i-1],dp[i-2]+i*hashh[i]) ;
        printf("%I64d
",dp[maxx]) ;
    }
    return 0 ;
}