ZOJ Consecutive Blocks（左右指標移動）

題意很簡單就是讓你看看隔著k個不同的，最多還能構成多少個連續的啊。

10^5託託的不能o(n^2)，顯然是左右指標瞎搞啊，但是這道題可以排序使得更簡單。

按照數字的大小，和地址的先後二級排序，然後分相同數字和不相同數字進行討論，找到滿足條件的最優的解。

Consecutive Blocks

---

Time Limit: 2 Seconds      Memory Limit: 65536 KB

---

There are N (1 ≤ N ≤ 10⁵) colored blocks (numbered 1 to N from left to right) which are lined up in a row. And the i-th block's color is C_i (1 ≤ C_i ≤ 10⁹). Now you can remove at most K (0 ≤ K ≤N) blocks, then rearrange the blocks by their index from left to right. Please figure out the length of the largest consecutive blocks with the same color in the new blocks created by doing this.

For example, one sequence is {1 1 1 2 2 3 2 2} and K=1. We can remove the 6-th block, then we will get sequence {1 1 1 2 2 2 2}. The length of the largest consecutive blocks with the same color is 4.

Input

Input will consist of multiple test cases and each case will consist of two lines. For each test case the program has to read the integers N and K, separated by a blank, from the first line. The color of the blocks will be given in the second line of the test case, separated by a blank. The i-th integer means C_i.

Output

Please output the corresponding length of the largest consecutive blocks, one line for one case.

Sample Input

8 1
1 1 1 2 2 3 2 2

Sample Output

4

#include <algorithm>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <iomanip>
#include <stdio.h>
#include <string>
#include <queue>
#include <cmath>
#include <stack>
#include <map>
#include <set>
#define eps 1e-8
#define M 1000100
//#define LL __int64
#define LL long long
#define INF 0x7ffffff
#define PI 3.1415926535898


const int maxn = 101000;

using namespace std;

struct node
{
    int x;
    int point;
}f[maxn];

bool cmp(node a, node b)
{
    if(a.x == b.x)
        return a.point < b.point;
    return a.x < b.x;
}

int main()
{
    int n, k;
    while(cin >>n>>k)
    {
        int x;
        for(int i = 0; i < n; i++)
        {
            cin >>x;
            f[i].x = x;
            f[i].point = i;
        }
        sort(f, f+n, cmp);
        int Max = -1;
        int i, j;
        int r = 1;
        int dis = 1;
        for(i = 0; i < n;)
        {
            dis = r-i;
            for(j = r; j < n; j++)
            {
                if(f[i].x != f[j].x)
                {
                    Max = max(Max, dis);
                    i = j;
                    r = j+1;
                    break;
                }
                if(f[j].point-f[i].point > j-i+k)
                {
                    Max = max(Max, dis);
                    i++;
                    dis--;
                    r = j;
                    break;
                }
                dis++;
            }
            if(j == n)
            {
                Max = max(dis, Max);
                break;
            }
        }
        cout<<Max<<endl;
    }
    return 0;
}