#include <bits/stdc++.h>
#define rep(i, n) for(int(i) = 0; (i) < (n); (i)++)
#define FOR(i, m, n) for(int(i) = (m); (i) < (n); (i)++)
#define ALL(v) (v).begin(), (v).end()
#define LLA(v) (v).rbegin(), (v).rend()
#define SZ(v) (v).size()
#define INT(...)                                                               \
    int __VA_ARGS__;                                                           \
    read(__VA_ARGS__)
#define LL(...)                                                                \
    ll __VA_ARGS__;                                                            \
    read(__VA_ARGS__)
#define DOUBLE(...)                                                            \
    double __VA_ARGS__;                                                        \
    read(__VA_ARGS__)
#define CHAR(...)                                                              \
    char __VA_ARGS__;                                                          \
    read(__VA_ARGS__)
#define STRING(...)                                                            \
    string __VA_ARGS__;                                                        \
    read(__VA_ARGS__)
#define VEC(type, name, size)                                                  \
    vector<type> name(size);                                                   \
    read(name)
using namespace std;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using Graph = vector<vector<int>>;
template <typename T> struct edge {
    int to;
    T cost;
    edge(int t, T c) : to(t), cost(c) {}
};
template <typename T> using WGraph = vector<vector<edge<T>>>;
const int INF = 1 << 30;
const ll LINF = 1LL << 60;
const int MOD = 1e9 + 7;
template <class T> inline vector<T> make_vec(size_t a, T val) {
    return vector<T>(a, val);
}
template <class... Ts> inline auto make_vec(size_t a, Ts... ts) {
    return vector<decltype(make_vec(ts...))>(a, make_vec(ts...));
}

void read() {}
template <class T> inline void read(T &a) { cin >> a; }
template <class T, class S> inline void read(pair<T, S> &p) {
    read(p.first), read(p.second);
}
template <class T> inline void read(vector<T> &v) {
    for(auto &a : v)
        read(a);
}
template <class Head, class... Tail>
inline void read(Head &head, Tail &...tail) {
    read(head), read(tail...);
}
template <class T> inline void chmax(T &a, T b) { (a < b ? a = b : a); }
template <class T> inline void chmin(T &a, T b) { (a > b ? a = b : a); }

/**
 * @brief Manage interval by set. Note that interval is harf-open [l,r).
 *
 * @tparam T Universal set.
 */
template <typename T> class IntervalSet : std::set<std::pair<T, T>> {
  private:
    const T INF = std::numeric_limits<T>::max() - 65;
    bool isMergeAdjacent;

  public:
    /**
     * @brief Construct a new Interval Set object
     *
     * @param f If merge adjacent interval
     */
    IntervalSet(bool f) : isMergeAdjacent(f) {
        this->emplace(-INF, -INF + 1);
        this->emplace(INF, INF + 1);
    }
    /**
     * @brief Get a interval to which p belongs.
     *
     * @param p Element in T
     * @return Iterator of interval to which p belongs. If not exists, return
     * iterator end().
     */
    auto get(T p) const {
        auto it = this->upper_bound({p, INF});
        if(it == this->begin() || (--it)->second < p)
            return this->end();
        return it;
    }
    /**
     * @brief Insert interval [l,r).
     *
     * @param l Left end of interval.
     * @param r Right end of interval.
     */
    void insert(T l, T r) {
        assert(l < r);
        auto it = std::prev(this->lower_bound({l, r}));
        if(it->first <= l && l + !isMergeAdjacent <= it->second) {
            l = std::min(l, it->first);
            r = std::max(r, it->second);
            this->erase(it);
        }
        it = this->lower_bound({l, r});
        while(1) {
            if(l <= it->first && it->first <= r) {
                r = std::max(r, it->second);
                it = this->erase(it);
            } else
                break;
        }
        this->emplace(l, r);
    }

    // /**
    //  * @brief Remove interval [l,r).
    //  *
    //  * @param l Left end of interval.
    //  * @param r Right end of interval.
    //  */
    // void remove(T l, T r) { assert(l < r); }

    /**
     * @brief Judge if p and q are in same interval.
     *
     * @param p Element in T.
     * @param q Element in T.
     * @return If p and q are in same interval.
     */
    bool same(T p, T q) const {
        auto it = get(p);
        return it != this->end() && it->first <= q && q <= it->second;
    }

    /**
     * @brief Show contents of set.
     *
     */
    void dump() {
        for(auto it = this->begin(), e = this->end(); it != e; ++it) {
            if(std::abs(it->first) == INF)
                continue;
            std::cout << "[" << it->first << "," << it->second
                      << (it == std::prev(std::prev(e)) ? ")" : "), ");
        }
        std::cout << std::endl;
    }
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    INT(n, k);
    k--;
    VEC(ll, x, n);
    VEC(ll, a, n);
    int lcur = k - 1, rcur = k + 1;
    ll left = x[k] - a[k], right = x[k] + a[k];
    int res = 1;
    int find = 0;
    while(1) {
        find = 0;
        if(lcur >= 0 && left <= x[lcur]) {
            chmin(left, x[lcur] - a[lcur]);
            chmax(right, x[lcur] + a[lcur]);
            lcur--;
            find++;
        }
        if(rcur < n && x[rcur] <= right) {
            chmin(left, x[rcur] - a[rcur]);
            chmax(right, x[rcur] + a[rcur]);
            rcur++;
            find++;
        }
        res += find;
        if(find == 0)
            break;
    }
    cout << res << endl;
}