//セグ木基本
#include "bits/stdc++.h"
using namespace std;
#define REP(i, n) for(ll i = 0;i < n;i++)
#define ll long long
#define MOD 1000000007
using vi = vector<int>; // intの1次元の型に vi という別名をつける
using vvi = vector<vi>; // intの2次元の型に vvi という別名をつける

int n,k;


class SegTree
{
  public:
  ll n2;//2のべき乗になる数でn以上の数
  ll ln2;//n2のlog2値
  vector<ll> data;//●●●●●●●●●●●●●●●●●●●●●●●●●●●●●

  SegTree(ll ninput,ll is)
  {
    ll il=0LL;
    for(ll i=1LL;i<(1LL<<62LL);i*=2)
    {
      if (i>=ninput)
      {
        n2=i;
        ln2=il;
        break;
      }
      il++;
    }

    data.resize(n2*2);
    for(int i=0;i<n2*2;i++){
      data[i]=is;//●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●
    }
  }

  //配列内初期化●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●
  ll Initval(){
    return (1<<30)+((1<<30)-1);
  }


  //min関数的な
  //●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●●
  ll SGTfunc_min(ll d0,ll d1){
    return min(d0,d1);
  }

  ll SGTfunc_max(ll d0,ll d1){
    return max(d0,d1);
  }

  //データをセットして内部更新 O(logn)
  void Updata_min(int posi,ll d)
  {
    int myi=posi+n2;
    data[myi]=d;//葉
    for(int i=0;i<ln2;i++){//中間要素
      myi/=2;
      data[myi]=SGTfunc_min(data[myi*2],data[myi*2+1]);
    }
  }

  //データをセットして内部更新 O(logn)
  void Updata_max(int posi,ll d)
  {
    int myi=posi+n2;
    data[myi]=d;//葉
    for(int i=0;i<ln2;i++){//中間要素
      myi/=2;
      data[myi]=SGTfunc_max(data[myi*2],data[myi*2+1]);
    }
  }


  //lを含むrを含まないところまでの区間
  ll GetMin(int l,int r)
  {
    ll ret=data[l];
    int l_=l;
    int r_=r;
    for(int i=0;(l_+r_)>0;i++){
      int offset=1<<(ln2-i);
      if (r_%2==1){
          if (r_-1>=l_){
            ret=SGTfunc_min(ret,data[offset+r_-1]);
            r_--;
          }
      }
      if (l_%2==1){
          if (l_<r_){
            ret=SGTfunc_min(ret,data[offset+l_]);
            l_++;
          }
      }
      r_>>=1;
      l_>>=1;
    }
    return ret;
  }


  //lを含むrを含まないところまでの区間
  ll GetMax(int l,int r)
  {
    ll ret=data[l];
    int l_=l;
    int r_=r;
    for(int i=0;(l_+r_)>0;i++){
      int offset=1<<(ln2-i);
      if (r_%2==1){
          if (r_-1>=l_){
            ret=SGTfunc_max(ret,data[offset+r_-1]);
            r_--;
          }
      }
      if (l_%2==1){
          if (l_<r_){
            ret=SGTfunc_max(ret,data[offset+l_]);
            l_++;
          }
      }
      r_>>=1;
      l_>>=1;
    }
    return ret;
  }


};






int main(){
  int ans=1;
  
  cin >> n >> k;
  vi p(n);
  vi sor(n);
  int flag=0;
  REP(i,n){
    cin>>p[i];
    if (i!=0){
      if (p[i]>p[i-1]){
        flag++;
        if (flag>=k-1){
          sor[i-k+1]=1;
        }
      }else{
        flag=0;
      }
    }
  }



  SegTree segtree_min(k,1LL<<32);
  SegTree segtree_max(k,0);

  REP(i,k){
    segtree_min.Updata_min(i,p[i]);
    segtree_max.Updata_max(i,p[i]);
  }

  int w=k;
  int syokaiflag=sor[0];
  for(int i=k;i<n;i++){
    segtree_min.Updata_min(w,p[i]);
    segtree_max.Updata_max(w,p[i]);
    if ((segtree_min.GetMin(0,k+1)==p[i-k])&(segtree_max.GetMax(0,k+1)==p[i])){
      //ans--;
    }else{
      if (sor[i-k+1]==1){
        //ans--;
        if (syokaiflag==0){
          ans++;
          syokaiflag=1;
        }
      }else{
        ans++;
      }
    }
    //ans++;
    w++;
    w%=k+1;
  }




/*
  segtree.Updata(1,28);
  segtree.Updata(2,48);
  segtree.Updata(3,-9);
  segtree.Updata(4,438);

  cout<<segtree.GetMin(0,6)<<endl;
  cout<<segtree.GetMin(2,4)<<endl;
  cout<<segtree.GetMin(3,7)<<endl;
  cout<<segtree.GetMin(0,3)<<endl;
  cout<<segtree.GetMin(1,5)<<endl;
*/


  cout<<ans<<endl;
  return 0;
}

Measured memory_bytes: 9984