CodeForces-505C Mr. Kitayuta, the Treasure Hunter

Mr. Kitayuta, the Treasure Hunter

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

The Shuseki Islands are an archipelago of 30001 small islands in the Yutampo Sea. The islands are evenly spaced along a line, numbered from 0 to 30000 from the west to the east. These islands are known to contain many treasures. There are n gems in the Shuseki Islands in total, and the i-th gem is located on island pi.

Mr. Kitayuta has just arrived at island 0. With his great jumping ability, he will repeatedly perform jumps between islands to the east according to the following process:

• First, he will jump from island 0 to island d.
• After that, he will continue jumping according to the following rule. Let l be the length of the previous jump, that is, if his previous jump was from island prev to island cur, let l = cur - prev. He will perform a jump of length l - 1, l or l + 1 to the east. That is, he will jump to island (cur + l - 1), (cur + l) or (cur + l + 1) (if they exist). The length of a jump must be positive, that is, he cannot perform a jump of length 0 when l = 1. If there is no valid destination, he will stop jumping.

Mr. Kitayuta will collect the gems on the islands visited during the process. Find the maximum number of gems that he can collect.

Input

The first line of the input contains two space-separated integers n and d (1 ≤ n, d ≤ 30000), denoting the number of the gems in the Shuseki Islands and the length of the Mr. Kitayuta's first jump, respectively.

The next n lines describe the location of the gems. The i-th of them (1 ≤ i ≤ n) contains a integer pi (d ≤ p1 ≤ p2 ≤ ... ≤ pn ≤ 30000), denoting the number of the island that contains the i-th gem.

Output

Print the maximum number of gems that Mr. Kitayuta can collect.

Examples

input

4 10
10
21
27
27

output

3

input

8 8
9
19
28
36
45
55
66
78

output

6

input

13 7
8
8
9
16
17
17
18
21
23
24
24
26
30

output

4

Note

In the first sample, the optimal route is 0  →  10 (+1 gem)  →  19  →  27 (+2 gems)  → ...

In the second sample, the optimal route is 0  →  8  →  15  →  21 →  28 (+1 gem)  →  36 (+1 gem)  →  45 (+1 gem)  →  55 (+1 gem) →  66 (+1 gem)  →  78 (+1 gem)  → ...

In the third sample, the optimal route is 0  →  7  →  13  →  18 (+1 gem)  →  24 (+2 gems)  →  30 (+1 gem)  → ...

题意:Shuseki列岛由30001个岛组成,它们排成一列,编号0~30000,有n种宝石在这些岛中,输入n个数表示第i种宝石在标号为a[i]的岛,现在
一个人从编号为0的岛出发,先跳跃到d岛,假设当前岛为cur,上一个岛为pre,然后以后每次跳跃的长度只能为(cur-pre-1),(cur-pre),
(cur-pre+1),问这个人最多能捡到多少宝石
题解:普通的记忆化搜索题,不过要注意的是,dp第二维记录当前岛是由多远的跳跃到达的时候,不能直接开30000的长度,这样数组必然会爆掉.
我们可以发现如果每次跳跃的长度都是递增的那么d+(d+1)+(d+2)+...+(d+245)>245*246/2>30000,同理递减的也是如此,因此他的跳跃的长度
必然不超过500种,因此只要将第二维开500的长度即可.

#include<cstdio>
#include<algorithm>
#include<string.h>
using namespace std;
const int MX = 30000;
int p[MX + 1000], last, dp[MX + 1000][505], st;
int dfs(int cur, int cost) {
    // printf("%d\n",cur);
    if(cur > last) return 0;
    if(dp[cur][cost] != -1) return dp[cur][cost];
    int ret = 0;
    ret = max(ret, dfs(cur + st + cost + 1 - 250, cost + 1));
    ret = max(ret, dfs(cur + st + cost - 250, cost));
    if(st + cost - 1 - 250 > 0) ret = max(ret, dfs(cur + st + cost - 1 - 250, cost - 1));
    return dp[cur][cost] = max(dp[cur][cost], ret + p[cur]);
}
int main() {
    int n;
    //freopen("in.txt","r",stdin);
    while(~scanf("%d%d", &n, &st)) {
        int x;
        last = 0;
        memset(p, 0, sizeof(p));
        memset(dp, -1, sizeof(dp));
        for(int i = 0; i < n; i++) {
            scanf("%d", &x);
            p[x]++;
            last = max(x, last);
        }
        printf("%d\n", dfs(st, 250));
    }

    return 0;
}