Problem:
Problem J: Avant-garde Art
ICPC World Finals 6日目
ロシア構成主義とは、1910年代半ばに始まったソ連における芸術運動である。
R国に長く滞在していたティー氏は、 そのようなものに感化され、 ICPC World Finalsのリハーサル中にも関わらず、
クールなデザインを作ることにした。 ティー氏は語る： 「記号は円と線分だけで充分だ。
線分をいかに美しく交差させるかが重要である。」
問題
円周に\(n\)個の座標\( 1, 2, …, n \)を等間隔に割り当てる。
各座標からはちょうど1本の線分が出ており、 座標\( i \)の線分は異なる座標\( a_{i} \)に結ばれている。
（逆に、座標\( a_{i} \)の線分は座標\( a_{a_{i}} = i \)に結ばれている。） この状態から高々\( k
\)本の線分を（座標・長さに関係なく自由に）円周上に結び直すことが出来る。 互いに交差している線分の集合の最大サイズを答えよ。
入力
n k
a
1
a
2
… a
n
1行目に座標の数\(n\)、結び直すことのできる線分の数\(k\)が空白区切りで与えられる。
2行目に座標\(i\)の線分が結ばれる座標を表す\( a_{i} \)が空白区切りで与えられる。
出力
高々\(k\)本の線分を結び直した後に
互いに交差している線分の集合の最大サイズを1行に出力せよ。
制約
\( 2 \leq n \leq 8000 \)
\(n\)は偶数
\( 0 \leq k \leq \min(n/2, 20) \)
\( 1 \leq a_{i} \leq n \)
\( a_{i} \not = i \)
線分を自分自身に結ぶことは無い
\( a_{i} \not = a_{j} (i \not = j) \)
同じ座標に2本以上の線分が結ばれることは無い
\( a_{a_{i}} = i \)
\(i\)から\(j\)に線分が結ばれているならば、\(j\)から\(i\)に線分が結ばれている
入出力例
入力1
8 0
7 4 6 2 8 3 1 5
出力1
2
互いに交差する線分は下図の赤い線分で表される。
入力2
8 1
7 4 6 2 8 3 1 5
出力2
3
1,7を結ぶ線分を下図のように結び直せば互いに交差する3つの線分が得られる。
入力3
8 0
5 6 7 8 1 2 3 4
出力3
4
全ての線分は互いに交差しているため、交差する最大の線分の数は4となる。

Submitted solutions:

code_snippet: #include <bits/stdc++.h>
using namespace std;

using ll  = long long;
using ull = unsigned long long;

#define chmin(x,y) x = min(x,y)
#define chmax(x,y) x = max(x,y)

constexpr int BIG_NUM  = 2000000000;
constexpr ll  HUGE_NUM = 4000000000000000000LL; // オーバーフロー注意
constexpr int MOD      = 998244353;
constexpr double EPS   = 1e-9;

constexpr int SIZE = 8005;

int A[SIZE], dp[SIZE];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, K;
    cin >> N >> K;

    for (int i = 1; i <= N; i++) {
        cin >> A[i];
    }

    int ans = 1;

    for (int i = 1; i <= N; i++) {
        if (i > A[i]) continue;

        fill(dp, dp + N + 1, BIG_NUM);

        int tmp = 0;

        for (int k = i + 1; k <= A[i] - 1; k++) {
            if (A[k] < A[i]) continue;

            int ind = static_cast<int>(lower_bound(dp, dp + N, A[k]) - dp);
            dp[ind] = A[k];
            chmax(tmp, ind + 2);
        }
        chmax(ans, tmp);
    }

    cout << min(ans + K, N / 2) << '\n';
    return 0;
}
accuracy: 1
time_ms: 220
memory_kb: 3712
final_rank: 8

code_snippet: #include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef unsigned long long int ull;
#define chmin(x,y) x = min(x,y)
#define chmax(x,y) x = max(x,y)
#define BIG_NUM 2000000000
#define HUGE_NUM 4000000000000000000 //オーバーフローに注意
#define MOD 998244353
//#define MOD 1000000007
#define EPS 0.000000001




#define SIZE 8005

int A[SIZE],dp[SIZE];

int main(){

	int N,K;
	scanf("%d %d",&N,&K);

	for(int i = 1; i <= N; i++){

		scanf("%d",&A[i]);
	}

	int ans = 1;

	for(int i = 1; i <= N; i++){
		if(i > A[i])continue;

		for(int k = 0; k <= N; k++){

			dp[k] = BIG_NUM;
		}

		int tmp = 0;

		for(int k = i+1; k <= A[i]-1; k++){
			if(A[k] < A[i])continue;

			int ind = lower_bound(dp,dp+N,A[k])-dp;
			dp[ind] = A[k];
			chmax(tmp,ind+2);
		}
		chmax(ans,tmp);
	}

	printf("%d\n",min(ans+K,N/2));

	return 0;
}
accuracy: 1
time_ms: 260
memory_kb: 3260
final_rank: 3

code_snippet: #include<iostream>
#include<string>
#include<iomanip>
#include<cmath>
#include<vector>
#include<algorithm>

using namespace std;

#define int long long
#define rep(i,n) for(int i = 0; i < (n); i++)
#define endl "\n"

const long long INF = (long long)1e18;
const long long MOD = (long long)1e9 + 7; 

string yn(bool f){return f?"Yes":"No";}
string YN(bool f){return f?"YES":"NO";}

#define MAX

signed main(){
	cin.tie(0);
	ios::sync_with_stdio(false);
	cout<<fixed<<setprecision(10);
	
	int n, k;
	int num = 0;
	int maximum = 1;
	vector<int> a, b, c;
	
	cin>>n>>k;
	
	a.resize(n+1);
	
	for(int i = 1; i <= n; i++){
		cin>>a[i];
	}
	
	for(int i = 1; i <= n; i++){
		vector<int> lis;
		for(int j = i; j < a[i]; j++){
			if(a[j] < a[i]) continue;
			
			if(lis.size() == 0 || lis.back() < a[j]) lis.push_back(a[j]);
			else {
				int it = lower_bound(lis.begin(), lis.end(), a[j]) - lis.begin();
				lis[it] = a[j];
			}
		}
		maximum = max((int)lis.size(), maximum);
	}
	
	cout<<min(maximum + k, n/2)<<endl;
	return 0;
}
accuracy: 1
time_ms: 90
memory_kb: 3304
final_rank: 2

code_snippet: #include<bits/stdc++.h>
using namespace std;
using Int = long long;
using ll = long long;

template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b)a=b;};
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b)a=b;};


template<typename T>
struct SegmentTree{
  using F = function<T(T, T)>;
  Int n;
  F f;
  T ti;
  vector<T> dat;
  SegmentTree(){}
  SegmentTree(F f, T ti):f(f), ti(ti){}

  void init(Int n_){
    n = 1;
    while(n < n_) n<<= 1;
    dat.assign(n<<1, ti);
  }

  void build(const vector<T> &v){
    Int n_ = v.size();
    init(n_);
    for(Int i=0;i<n_;i++) dat[n+i] = v[i];
    for(Int i=n-1;i;i--)
      dat[i] = f(dat[(i<<1)|0], dat[(i<<1)|1]);
  }

  void set_val(Int k, T x){
    dat[k+=n] = x;
    while(k>>=1)
      dat[k] = f(dat[(k<<1) | 0], dat[(k<<1) | 1]);
  }

  T query(Int a,Int b){
    T vl = ti, vr = ti;
    for(Int l=a + n, r = b + n; l<r ; l>>=1, r>>=1){
      if(l&1) vl = f(vl, dat[l++]);
      if(r&1) vr = f(dat[--r], vr);
    }
    return f(vl, vr);
  }
    

};
signed main(){
  cin.tie(0);
  ios::sync_with_stdio(0);


  Int n,k;
  cin>>n>>k;
  vector<Int> as(n);
  for(Int i=0;i<n;i++) cin>>as[i],as[i]--;

  Int ans=1;
  for(Int i=0;i<n;i++){
    if(i>as[i]) continue;
    auto f=[](Int a,Int b){return max(a,b);};   
    SegmentTree<Int> seg(f,-n);
    seg.build(vector<Int>(n,-n));
    seg.set_val(as[i],1);
    for(Int j=i+1;j<as[i];j++){
      if(j>as[j]) continue;
      if(as[j]<as[i]) continue;      
      Int res=seg.query(0,as[j]);
      seg.set_val(as[j],res+1);
      //cout<<i<<" "<<j<<":"<<res+1<<endl;
      chmax(ans,res+1);
    }
  }
  
  ans+=k;
  chmin(ans,n/2);
  cout<<ans<<endl;
  return 0;
}
accuracy: 1
time_ms: 880
memory_kb: 3368
final_rank: 9

code_snippet: #include<bits/stdc++.h>
#define LL long long
#define REP(i, n) for(int i=0;i<(n);++i)
#define REPA(i, n) for(int i=1;i<(n);++i)
#define lp(i, n) for(int i=-;i<(n);++i)
#define PII pair<int, int>
#define PLL pair<long long, long long>
#define MOD ((int)1e9 + 7)
#define INF ((int)1e9)
#define DEKAI ((int)1e9+7)
#define ALL(x) (x).begin(), (x).end()
#define BIT(x) (1<<(x))
#define foreach(i, n) for(auto &i:(n))
using namespace std;

int main(){
    int N, K;
    cin >> N >> K;
    vector<int> line(N);
    vector<int> dl;
    foreach(i, line)cin>>i;
    int ans = 0;
    for(int i=1;i<N;++i){
        dl.assign(N, INF);
        REP(j, i){
            if(line[j] < i)continue;
            *upper_bound(ALL(dl), line[j])=line[j];
        }
        ans = max(ans, (int)(lower_bound(ALL(dl), INF) - dl.begin()));
    }
    cout << min(ans+K, N/2) << endl;
    return 0;
}
accuracy: 1
time_ms: 510
memory_kb: 3156
final_rank: 5

code_snippet: #include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;


struct LIS{
  int n;
  vector<int>dp,a;
  LIS(int sz):n(sz),dp(sz),a(sz){}
  void input(vector<int>&v){
    r(i,v.size())a[i]=v[i];
  }
  int lis(){
    dp[0]=a[0];
    int len=1;
    for(int i=1;i<n;i++){
      if(dp[len-1]<a[i]) dp[len++] = a[i];
      else *lower_bound(dp.begin(),dp.begin()+len,a[i]) = a[i];
    }
    return len;
  }
};

signed main(){
  int n,k;
  cin>>n>>k;
  int a[n];
  for(int i=0;i<n;i++){
    cin>>a[i];
    a[i]--;
  }

  int ans=0;

  for(int i=0;i<n;i++){

    //cout<<i<<endl;
    
    vector<int>v;
    int x=a[i];
    if( x<i ) continue;
    
    for(int j=i+1;j<x;j++){
      //cout<<i<<' '<<j<<endl;
      if( i<a[j] && a[j]<x )continue;
      int t=a[j];
      if(t<i)t+=8800;
      v.push_back(t);
      
    }

    if(!v.size())continue;

    //cout<<v.size()<<endl;

    LIS L(v.size());
    L.input(v);

    ans=max(ans,L.lis());
  }

  ans++;

  cout<<ans+min(k,n/2-ans)<<endl;
}
accuracy: 1
time_ms: 180
memory_kb: 3236
final_rank: 1

code_snippet: #include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;


struct LIS{
  int n;
  vector<int>dp,a;
  LIS(int sz):n(sz),dp(sz),a(sz){}
  void input(vector<int>&v){
    r(i,v.size())a[i]=v[i];
  }
  int lis(){
    dp[0]=a[0];
    int len=1;
    for(int i=1;i<n;i++){
      if(dp[len-1]<a[i]) dp[len++] = a[i];
      else *lower_bound(dp.begin(),dp.begin()+len,a[i]) = a[i];
    }
    return len;
  }
};

signed main(){
  int n,k;
  cin>>n>>k;
  int a[n];
  for(int i=0;i<n;i++){
    cin>>a[i];
    a[i]--;
  }

  int ans=0;

  for(int i=0;i<n;i++){

    //cout<<i<<endl;
    
    vector<int>v;
    int x=a[i];
    if( x<i ) continue;
    
    for(int j=i+1;j<x;j++){
      //cout<<i<<' '<<j<<endl;
      if( i<a[j] && a[j]<x )continue;
      int t=a[j];
      if(t<i)t+=8800;
      v.push_back(t);
      
    }

    if(!v.size())continue;

    //cout<<v.size()<<endl;

    LIS L(v.size());
    L.input(v);

    ans=max(ans,L.lis());
  }

  ans++;

  cout<<ans+min(k,n-ans)<<endl;
}
accuracy: 0.8833333333333333
time_ms: 180
memory_kb: 3232
final_rank: 12

code_snippet: #include<bits/stdc++.h>
using namespace std;
using Int = long long;
using ll = long long;

template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b)a=b;};
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b)a=b;};


template<typename T>
struct SegmentTree{
  using F = function<T(T, T)>;
  Int n;
  F f;
  T ti;
  vector<T> dat;
  SegmentTree(){}
  SegmentTree(F f, T ti):f(f), ti(ti){}

  void init(Int n_){
    n = 1;
    while(n < n_) n<<= 1;
    dat.assign(n<<1, ti);
  }

  void build(const vector<T> &v){
    Int n_ = v.size();
    init(n_);
    for(Int i=0;i<n_;i++) dat[n+i] = v[i];
    for(Int i=n-1;i;i--)
      dat[i] = f(dat[(i<<1)|0], dat[(i<<1)|1]);
  }

  void set_val(Int k, T x){
    dat[k+=n] = x;
    while(k>>=1)
      dat[k] = f(dat[(k<<1) | 0], dat[(k<<1) | 1]);
  }

  T query(Int a,Int b){
    T vl = ti, vr = ti;
    for(Int l=a + n, r = b + n; l<r ; l>>=1, r>>=1){
      if(l&1) vl = f(vl, dat[l++]);
      if(r&1) vr = f(dat[--r], vr);
    }
    return f(vl, vr);
  }
    

};
signed main(){
  cin.tie(0);
  ios::sync_with_stdio(0);


  Int n,k;
  cin>>n>>k;
  vector<Int> as(n);
  for(Int i=0;i<n;i++) cin>>as[i],as[i]--;

  Int ans=1;
  for(Int i=0;i<n;i++){
    if(i>as[i]) continue;
    auto f=[](Int a,Int b){return max(a,b);};   
    SegmentTree<Int> seg(f,-n);
    seg.build(vector<Int>(n,-n));
    seg.set_val(as[i],1);
    for(Int j=i+1;j<as[i];j++){
      if(j>as[j]) continue;
      if(as[j]<as[i]) continue;      
      Int res=seg.query(0,as[j]);
      seg.set_val(as[j],res+1);
      //cout<<i<<" "<<j<<":"<<res+1<<endl;
      chmax(ans,res+1);
    }
  }
  
  ans+=k;
  chmin(ans,n/2);
  cout<<ans<<endl;
  return 0;
}
accuracy: 1
time_ms: 890
memory_kb: 3412
final_rank: 10

code_snippet: #include<bits/stdc++.h>
using namespace std;
using Int = long long;
using ll = long long;

template<typename T1,typename T2> inline void chmin(T1 &a,T2 b){if(a>b)a=b;};
template<typename T1,typename T2> inline void chmax(T1 &a,T2 b){if(a<b)a=b;};


template<typename T>
struct SegmentTree{
  using F = function<T(T, T)>;
  Int n;
  F f;
  T ti;
  vector<T> dat;
  SegmentTree(){}
  SegmentTree(F f, T ti):f(f), ti(ti){}

  void init(Int n_){
    n = 1;
    while(n < n_) n<<= 1;
    dat.assign(n<<1, ti);
  }

  void build(const vector<T> &v){
    Int n_ = v.size();
    init(n_);
    for(Int i=0;i<n_;i++) dat[n+i] = v[i];
    for(Int i=n-1;i;i--)
      dat[i] = f(dat[(i<<1)|0], dat[(i<<1)|1]);
  }

  void set_val(Int k, T x){
    dat[k+=n] = x;
    while(k>>=1)
      dat[k] = f(dat[(k<<1) | 0], dat[(k<<1) | 1]);
  }

  T query(Int a,Int b){
    T vl = ti, vr = ti;
    for(Int l=a + n, r = b + n; l<r ; l>>=1, r>>=1){
      if(l&1) vl = f(vl, dat[l++]);
      if(r&1) vr = f(dat[--r], vr);
    }
    return f(vl, vr);
  }
    

};
signed main(){
  cin.tie(0);
  ios::sync_with_stdio(0);


  Int n,k;
  cin>>n>>k;
  vector<Int> as(n);
  for(Int i=0;i<n;i++) cin>>as[i],as[i]--;

  Int ans=1;
  for(Int i=0;i<n;i++){
    if(i>as[i]) continue;
    auto f=[](Int a,Int b){return max(a,b);};   
    SegmentTree<Int> seg(f,-n);
    seg.build(vector<Int>(n,-n));
    seg.set_val(as[i],1);
    for(Int j=i+1;j<as[i];j++){
      if(j>as[j]) continue;
      if(as[j]<as[i]) continue;      
      Int res=seg.query(0,as[j]);
      seg.set_val(as[j],res+1);
      //cout<<i<<" "<<j<<":"<<res+1<<endl;
      chmax(ans,res+1);
    }
  }
  
  ans+=k;
  chmin(ans,n);
  cout<<ans<<endl;
  return 0;
}
accuracy: 0.8833333333333333
time_ms: 930
memory_kb: 3372
final_rank: 14

code_snippet: #include<bits/stdc++.h>
 using namespace std;
#define INF 1000000
#define REP(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
int n,k;
int a[8001];
bool used[8001];
int R[4001];
int L[4001];

#define MAX_N 8010
int dp[MAX_N];
int solve(int x){
    fill(dp,dp+n+1,INF);
    for(int i=L[x]+1;i<R[x];i++){
        int b=a[i];
        if(L[x]>b)b+=n;
        if(R[x]<b){
           *lower_bound(dp,dp+n,b)=b;
        }
    }
    return (lower_bound(dp,dp+n,INF)-dp);
}
/*
int solve(int x){
    fill(dp,dp+n,INF);
    for(int i=R[x]+1;i<L[x]+n;i++){
        int b=a[i%n];
        if(b<R[x]&&b>L[x]){
           *lower_bound(dp,dp+n,b)=b;
        }
    }
    return (lower_bound(dp,dp+n,INF)-dp);
}*/

int main(){
    cin>>n>>k;
    REP(i,8001){
        used[i]=false;
    }
    REP(i,n){
        cin>>a[i];
        a[i]--;
    }
    
    int c=0;
    REP(i,n){
        if(used[i]==true)continue;
        used[i]=true;
        used[a[i]]=true;
        L[c]=i;
        R[c]=a[i];
        c++;
    }
    
    int ans=0;
    REP(i,n/2){
        //????????§???????¢????????????????
        ans=max(ans,solve(i));
    }
    ans=min(n/2,ans+k+1);
    cout<<ans<<endl;
    return 0;
}
accuracy: 1
time_ms: 530
memory_kb: 3212
final_rank: 6

code_snippet: #include<bits/stdc++.h>
 using namespace std;
#define INF 1000000
#define REP(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
int n,k;
int a[8001];
bool used[8001];
int R[4001];
int L[4001];

#define MAX_N 8010
int dp[MAX_N];
int solve(int x){
    fill(dp,dp+n,INF);
    for(int i=L[x]+1;i<R[x];i++){
        int b=a[i];
        if(L[x]>b)b+=n;
        if(R[x]<b){
           *lower_bound(dp,dp+n,b)=b;
        }
    }
    return (lower_bound(dp,dp+n,INF)-dp);
}

int main(){
    cin>>n>>k;
    REP(i,8001){
        used[i]=false;
    }
    REP(i,n){
        cin>>a[i];
        a[i]--;
    }
    
    REP(i,n){
        if(used[i]==true)continue;
        used[i]=true;
        used[a[i]]=true;
        L[i]=i;
        R[i]=a[i];
    }
    
    int ans=0;
    REP(i,n/2){
        //????????§???????¢????????????????
        ans=max(ans,solve(i));
    }
    ans=min(n/2,ans+k+1);
    cout<<ans<<endl;
    return 0;
}
accuracy: 0.6833333333333333
time_ms: 270
memory_kb: 3192
final_rank: 19

code_snippet: #include<bits/stdc++.h>
 using namespace std;
#define INF 1000000
#define REP(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
int n,k;
int a[8001];
bool used[8001];
int R[4001];
int L[4001];

#define MAX_N 8010
int dp[MAX_N];
int solve(int x){
    fill(dp,dp+n,INF);
    for(int i=L[x]+1;i<=R[x];i++){
        int b=a[i];
        if(L[x]>b)b+=n;
        if(R[x]<b){
           *lower_bound(dp,dp+n,b)=b;
        }
    }
    return (lower_bound(dp,dp+n,INF)-dp);
}

int main(){
    cin>>n>>k;
    REP(i,8001){
        used[i]=false;
    }
    REP(i,n){
        cin>>a[i];
        a[i]--;
    }
    
    REP(i,n){
        if(used[i]==true)continue;
        used[i]=true;
        used[a[i]]=true;
        L[i]=i;
        R[i]=a[i];
    }
    
    int ans=0;
    REP(i,n/2){
        //????????§???????¢????????????????
        ans=max(ans,solve(i));
    }
    ans=min(n/2,ans+k+1);
    cout<<ans<<endl;
    return 0;
}
accuracy: 0.6833333333333333
time_ms: 240
memory_kb: 3152
final_rank: 16

code_snippet: #include<bits/stdc++.h>
 using namespace std;
#define INF 1000000000
#define REP(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
int n,k;
int a[8001];
bool used[8001];
int R[4001];
int L[4001];

#define MAX_N 8001
int dp[MAX_N];
int solve(int x){
    fill(dp,dp+n,INF);
    for(int i=L[x]+1;i<=R[x];i++){
        if(i==x)continue;
        int b=a[i];
        if(L[x]>b)b+=n;
        if(R[x]<b){
           *lower_bound(dp,dp+n,b)=b;
        }
    }
   /* REP(i,5){
        cout<<dp[i]<<endl;
    }*/
    return (lower_bound(dp,dp+n,INF)-dp);
}

int main(){
    cin>>n>>k;
    REP(i,8001){
        used[i]=false;
    }
    REP(i,n){
        cin>>a[i];
        a[i]--;
    }
    
    REP(i,n){
        if(used[i]==true)continue;
        used[i]=true;
        used[a[i]]=true;
        L[i]=i;
        R[i]=a[i];
    }
    
    int ans=0;
    REP(i,n/2){
        //????????§???R[i],L[i]?????????
        //int LL=L[i];
        //int RR=R[i];
        //????????§???????¢????????????????
        ans=max(ans,solve(i));
        //cout<<ans;
    }
    ans=min(n/2,ans+k+1);
    cout<<ans<<endl;
}
accuracy: 0.6833333333333333
time_ms: 240
memory_kb: 3156
final_rank: 17

code_snippet: #include<bits/stdc++.h>
 using namespace std;
#define INF 1000000000
#define REP(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
int n,k;
int a[8001];
bool used[8001];
int R[4001];
int L[4001];

#define MAX_N 8001
int dp[MAX_N];
int solve(int x){
    fill(dp,dp+n,INF);
    for(int i=L[x]+1;i<=R[x];i++){
        if(i==x)continue;
        int b=a[i];
        if(L[x]>b)b+=n;
        if(R[x]<b){
           *lower_bound(dp,dp+n,b)=b;
        }
    }
   /* REP(i,5){
        cout<<dp[i]<<endl;
    }*/
    return (lower_bound(dp,dp+n,INF)-dp);
}

int main(){
    cin>>n>>k;
    REP(i,8001){
        used[i]=false;
    }
    REP(i,n){
        cin>>a[i];
        a[i]--;
    }
    
    REP(i,n){
        if(used[i]==true)continue;
        used[i]=true;
        used[a[i]]=true;
        L[i]=i;
        R[i]=a[i];
    }
    
    int ans=0;
    REP(i,n){
        //????????§???R[i],L[i]?????????
        //int LL=L[i];
        //int RR=R[i];
        //????????§???????¢????????????????
        ans=max(ans,solve(i));
        //cout<<ans;
    }
    ans=min(n/2,ans+k+1);
    cout<<ans<<endl;
}
accuracy: 0.6833333333333333
time_ms: 240
memory_kb: 3140
final_rank: 15

code_snippet: #include<bits/stdc++.h>
 using namespace std;
#define INF 1000000000
#define REP(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
int n,k;
int a[8001];
bool used[8001];
int R[4001];
int L[4001];

#define MAX_N 8001
int dp[MAX_N];
int solve(int x){
    fill(dp,dp+n,INF);
    for(int i=L[x]+1;i<=R[x];i++){
        if(i==x)continue;
        int b=a[i];
        if(L[x]>b)b+=n;
        if(R[x]<b){
           *lower_bound(dp,dp+n,b)=b;
        }
    }
   /* REP(i,5){
        cout<<dp[i]<<endl;
    }*/
    return (lower_bound(dp,dp+n,INF)-dp);
}

int main(){
    cin>>n>>k;
    REP(i,8001){
        used[i]=false;
    }
    REP(i,n){
        cin>>a[i];
        a[i]--;
    }
    
    REP(i,n){
        if(used[i]==true)continue;
        used[i]=true;
        L[i]=i;
        R[i]=a[i];
    }
    
    int ans=0;
    REP(i,n){
        //????????§???R[i],L[i]?????????
        //int LL=L[i];
        //int RR=R[i];
        //????????§???????¢????????????????
        ans=max(ans,solve(i));
        //cout<<ans;
    }
    ans=min(n/2,ans+k+1);
    cout<<ans<<endl;
}
accuracy: 0.6833333333333333
time_ms: 320
memory_kb: 3144
final_rank: 18

code_snippet: #include<bits/stdc++.h>
 using namespace std;
#define INF 1000000000
#define REP(i,n) for(int (i)=0;(i)<(int)(n);(i)++)
int n,k;
int a[8001];
bool used[8001];
int R[4001];
int L[4001];

#define MAX_N 8001
int dp[MAX_N];
int solve(int x){
    fill(dp,dp+n,INF);
    for(int i=L[x]+1;i<=R[x];i++){
        if(i==x)continue;
        int b=a[i];
        if(L[x]>b)b+=n;
        if(R[x]<b){
           *lower_bound(dp,dp+n,b)=b;
        }
    }
   /* REP(i,5){
        cout<<dp[i]<<endl;
    }*/
    return (lower_bound(dp,dp+n,INF)-dp);
}

int main(){
    cin>>n>>k;
    REP(i,8001){
        used[i]=false;
    }
    REP(i,n){
        cin>>a[i];
        a[i]--;
    }
    
    REP(i,n){
        if(used[i]==true)continue;
        L[i]=i;
        R[i]=a[i];
    }
    
    int ans=0;
    REP(i,n){
        //????????§???R[i],L[i]?????????
        //int LL=L[i];
        //int RR=R[i];
        //????????§???????¢????????????????
        ans=max(ans,solve(i));
        //cout<<ans;
    }
    ans=min(n/2,ans+k+1);
    cout<<ans<<endl;
}
accuracy: 0.6833333333333333
time_ms: 360
memory_kb: 3148
final_rank: 20

code_snippet: #include<bits/stdc++.h>

using namespace std;

typedef long long LL;

#define fin "\n"


#define FOR(i,bg,ed) for(int i=(bg);i<(ed);i++)
#define REP(i,n) FOR(i,0,n)

template <typename T>
inline void chmin(T &l,T r){l=min(l,r);}

template <typename T>
inline void chmax(T &l,T r){l=max(l,r);}

template <typename T>
istream& operator>>(istream &is,vector<T> &v){
    for(auto &it:v)is>>it;
    return is;
}

#define BITTYPE int
#define BITCNT  1
#define BITSIZE 512345
namespace BIT_{
    int i=0;
    BITTYPE t[BITCNT][BITSIZE];
    inline BITTYPE* get(){
        BITTYPE* res=t[i++];
        i%=BITCNT;
        return res;
    }
}
//[1,n],0?????±?????????!
struct BIT{
    using T=BITTYPE;
    T* bit;
    int n;
    BIT(T* _table,int n):bit(_table),n(n){
        std::fill(bit,bit+n+1,0);
    }
    BIT(int n):BIT(BIT_::get(),n){}
    T sum(int i){
        T s=0;
        while(i>0){
            chmax(s,bit[i]);
            i-=i&-i;
        }
        return s;
    }
    void add(int i,T x){
        while(i<=n){
            chmax(bit[i],x);i+=i&-i;
        }
    }
    void clear(int sz){
        std::fill(bit,bit+n+1,0);
    }

}; 
int main(){
    int n,k;
    cin>>n>>k;
    vector<int> v(2*n,-1);
    REP(i,n){
        int p=i,q;
        cin>>q;q--;
        if(p<q)v[p+n]=q+n;
        else q+=n;
        v[p]=q;
    }
    int res=1+k;
    REP(i,n)if(v[i]!=-1){
        int p=i;
        int q=v[i];
        BIT bit(p+n-v[i]);

        FOR(j,p+1,q)if(v[i]<v[j]&&v[j]<p+n){
            int latte=bit.sum(v[j]-v[i]-1)+1;
            bit.add(v[j]-v[i],latte);
            chmax(res,latte+1+k);
        }
    }
    cout<<min(res,n/2)<<endl;
    return 0;
}
accuracy: 1
time_ms: 390
memory_kb: 3208
final_rank: 4

code_snippet: #include<bits/stdc++.h>

using namespace std;

typedef long long LL;

#define fin "\n"


#define FOR(i,bg,ed) for(int i=(bg);i<(ed);i++)
#define REP(i,n) FOR(i,0,n)

template <typename T>
inline void chmin(T &l,T r){l=min(l,r);}

template <typename T>
inline void chmax(T &l,T r){l=max(l,r);}

template <typename T>
istream& operator>>(istream &is,vector<T> &v){
    for(auto &it:v)is>>it;
    return is;
}

#define BITTYPE int
#define BITCNT  1
#define BITSIZE 512345
namespace BIT_{
    int i=0;
    BITTYPE t[BITCNT][BITSIZE];
    inline BITTYPE* get(){
        BITTYPE* res=t[i++];
        i%=BITCNT;
        return res;
    }
}
//[1,n],0?????±?????????!
struct BIT{
    using T=BITTYPE;
    T* bit;
    int n;
    BIT(T* _table,int n):bit(_table),n(n){
        std::fill(bit,bit+n+1,0);
    }
    BIT(int n):BIT(BIT_::get(),n){}
    T sum(int i){
        T s=0;
        while(i>0){
            chmax(s,bit[i]);
            i-=i&-i;
        }
        return s;
    }
    void add(int i,T x){
        while(i<=n){
            chmax(bit[i],x);i+=i&-i;
        }
    }
    void clear(int sz){
        std::fill(bit,bit+n+1,0);
    }

}; 
int main(){
    int n,k;
    cin>>n>>k;
    vector<int> v(2*n,-1);
    REP(i,n){
        int p=i,q;
        cin>>q;q--;
        if(p<q)v[p+n]=q+n;
        else q+=n;
        v[p]=q;
    }
    int res=1;
    REP(i,n)if(v[i]!=-1){
        int p=i;
        int q=v[i];
        BIT bit(p+n-v[i]);

        FOR(j,p+1,q)if(v[i]<v[j]&&v[j]<p+n){
            int latte=bit.sum(v[j]-v[i]-1)+1;
            bit.add(v[j]-v[i],latte);
            chmax(res,latte+1+k);
        }
    }
    cout<<min(res,n/2)<<endl;
    return 0;
}
accuracy: 0.9
time_ms: 380
memory_kb: 3188
final_rank: 11

code_snippet: #include<bits/stdc++.h>

using namespace std;

typedef long long LL;

#define fin "\n"


#define FOR(i,bg,ed) for(int i=(bg);i<(ed);i++)
#define REP(i,n) FOR(i,0,n)

template <typename T>
inline void chmin(T &l,T r){l=min(l,r);}

template <typename T>
inline void chmax(T &l,T r){l=max(l,r);}

template <typename T>
istream& operator>>(istream &is,vector<T> &v){
    for(auto &it:v)is>>it;
    return is;
}

#define BITTYPE int
#define BITCNT  1
#define BITSIZE 512345
namespace BIT_{
    int i=0;
    BITTYPE t[BITCNT][BITSIZE];
    inline BITTYPE* get(){
        BITTYPE* res=t[i++];
        i%=BITCNT;
        return res;
    }
}
//[1,n],0?????±?????????!
struct BIT{
    using T=BITTYPE;
    T* bit;
    int n;
    BIT(T* _table,int n):bit(_table),n(n){
        std::fill(bit,bit+n+1,0);
    }
    BIT(int n):BIT(BIT_::get(),n){}
    T sum(int i){
        T s=0;
        while(i>0){
            chmax(s,bit[i]);
            i-=i&-i;
        }
        return s;
    }
    void add(int i,T x){
        while(i<=n){
            chmax(bit[i],x);i+=i&-i;
        }
    }
    void clear(int sz){
        std::fill(bit,bit+n+1,0);
    }

}; 
int main(){
    int n,k;
    cin>>n>>k;
    vector<int> v(2*n,-1);
    REP(i,n){
        int p=i,q;
        cin>>q;q--;
        if(p<q)v[p+n]=q+n;
        else q+=n;
        v[p]=q;
    }
    int res=1;
    REP(i,n)if(v[i]!=-1){
        int p=i;
        int q=v[i];
        BIT bit(p+n-v[i]);

        FOR(j,p+1,q)if(v[i]<v[j]&&v[j]<p+n){
            int latte=bit.sum(v[j]-v[i]-1)+1;
            bit.add(v[j]-v[i],latte);
            chmax(res,latte+1+k);
        }
    }
    cout<<min(res,n)<<endl;
    return 0;
}
accuracy: 0.8833333333333333
time_ms: 420
memory_kb: 3188
final_rank: 13

code_snippet: #include <iostream>
#include <algorithm>
using namespace std;
const int inf = 999999999;
int seg[16399];
void update(int i, int x) {
	i += 8192; seg[i] = x;
	while (i > 1) {
		i >>= 1;
		seg[i] = max(seg[i << 1], seg[i << 1 | 1]);
	}
}
int query(int a, int b, int k, int l, int r) {
	if (a <= l && r <= b) return seg[k];
	if (r <= a || b <= l) return -inf;
	int lc = query(a, b, k << 1, l, (l + r) >> 1);
	int rc = query(a, b, k << 1 | 1, (l + r) >> 1, r);
	return max(lc, rc);
}
int n, m, a[8009], inv[8009]; bool ok[8009];
int main() {
	cin >> n >> m;
	for (int i = 0; i < n; i++) cin >> a[i], a[i]--, inv[a[i]] = i;
	int ret = 0;
	for (int i = 0; i < n; i++) {
		if (i > a[i]) continue;
		fill(seg + 1, seg + 16384, -inf);
		update(i, 1);
		for (int j = inv[i] + 1; j < n; j++) {
			if (inv[j] <= i || inv[j] > a[i]) continue;
			update(inv[j], query(i, inv[j], 1, 0, 8192) + 1);
		}
		ret = max(ret, seg[1]);
	}
	cout << min(ret + m, n / 2) << endl;
	return 0;
}
accuracy: 1
time_ms: 880
memory_kb: 3224
final_rank: 7