#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <queue>
#include <deque>
#include <stack>
#include <algorithm>
#include <numeric>
#include <string>
#include <sstream>
#include <cmath>
#include <cstring>
#include <assert.h>
#include <utility>
#include <tuple>
#include <array>
#include <bitset>
#include <cstdlib>

using int64 = long long;

template <typename T = int>
struct Range {
    struct RangeIterator {
        T i, step;

        RangeIterator(T i, T step): i{i}, step{step} {}

        T& operator*() { return i; }
        RangeIterator& operator++() {
            i += step;
            return *this;
        }
        bool operator!=(const RangeIterator& rhs) const {
            return (step > 0 && i < rhs.i) || (step < 0 && i > rhs.i);
        }
    };

    T start, stop, step;

    Range(T start, T stop, T step): start{start}, stop{stop}, step{step} {}
    Range(T start, T stop): Range(start, stop, 1) {}
    Range(T stop): Range(0, stop, 1) {}
    
    RangeIterator begin() const { return RangeIterator{start, step}; }
    RangeIterator end() const { return RangeIterator{stop, step}; }
};

struct Set {
    int entity;
    Set(int entity = 0): entity{entity} {}

    bool contains(int i) const { return (entity >> i) & 1; }
    bool contains(const Set& s) const { return s.entity == (entity & s.entity); }

    Set& operator+=(const Set& rhs) {
        entity |= rhs.entity;
        return *this;
    }
    Set& operator+=(const int rhs) {
        entity |= 1 << rhs;
        return *this;
    }
    Set& operator-=(const int rhs) {
        entity &= ~(1 << rhs);
        return *this;
    }
    bool operator==(const Set& rhs) const { return entity == rhs.entity; }
    bool operator!=(const Set& rhs) const { return entity != rhs.entity; }
    Set operator-(const int rhs) const { return Set(*this) -= rhs; }

    bool isEmpty() const { return entity == 0; }

    struct SetIterator {
        int i, set_entity;

        SetIterator(int set_entity): i{0}, set_entity{set_entity} {
            if (!((set_entity >> i) & 1)) forward();
        }

        void forward() {
            set_entity &= ~(1 << i);
            while (set_entity != 0 && !((set_entity >> i) & 1)) i++;
        }

        int& operator*() { return i; }
        SetIterator& operator++() {
            forward();
            return *this;
        }
        bool operator!=(const SetIterator& rhs) const {
            return set_entity != rhs.set_entity;
        }
    };

    SetIterator begin() const { return SetIterator{entity}; }
    SetIterator end() const { return SetIterator{0}; }
};

struct PowerSet {
    struct PowerSetIterator {
        Set set;

        PowerSetIterator(int set_entity): set{set_entity} {}

        Set& operator*() { return set; }
        PowerSetIterator& operator++() {
            set.entity++;
            return *this;
        }
        bool operator!=(const PowerSetIterator& rhs) const {
            return set != rhs.set;
        }
    };

    int size;

    PowerSet(int size): size{size} {}

    PowerSetIterator begin() const { return PowerSetIterator{0}; }
    PowerSetIterator end() const { return PowerSetIterator{1 << size}; }
};

template <typename T>
inline void chooseMax(T& a, const T& b) {
    a = std::max(a, b);
}

template <typename T>
inline void chooseMin(T& a, const T& b) {
    a = std::min(a, b);
}

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

    std::cout.setf(std::ios::fixed);
    std::cout.precision(10);

    int N;
    std::cin >> N;

    std::string s;
    std::cin >> s;

    if (std::count(s.begin(), s.end(), 'R') > std::count(s.begin(), s.end(), 'B')) {
        std::cout << "Yes" << std::endl;
    } else {
        std::cout << "No" << std::endl;
    }

    return 0;
}


Measured memory_bytes: 256