#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;

#define MAX_V 100000
#define INF (1<<24)

struct edge { int to, cap, cost, rev;};


int V;
vector<edge> G[MAX_V];
int dist[MAX_V];
int prevv[MAX_V],preve[MAX_V];


void init_edge(){
  for(int i=0;i<V;i++)G[i].clear();
}

void add_edge(int from,int to,int cap,int cost){
  //cout<<from<<' '<<to<<' '<<cap<<' '<<cost<<endl;
  G[from].push_back((edge){to,cap,cost,G[to].size()});
  G[to].push_back((edge){from,0,-cost,G[from].size()-1});
}

int min_cost_flow(int s,int t,int f){
  int res=0;
  while(f>0){

    fill(dist,dist+V,INF);
    dist[s]=0;
    bool update=true;
    while(update){
      update=false;
      for(int v=0;v<V;v++){
	if(dist[v]==INF)continue;
	for(int i=0;i< (int) G[v].size();i++){
	  edge &e = G[v][i];
	  if(e.cap > 0 && dist[e.to] > dist[v] + e.cost){
	    dist[e.to] = dist[v] + e.cost;
	    prevv[e.to] = v;
	    preve [e.to] = i;
	    update = true;
	  }
	}
      }
    }
    if(dist[t]==INF)return -1;
    int d=f;
    for(int v=t;v!=s;v=prevv[v]){
      d=min(d,G[prevv[v]][preve[v]].cap);
    }
    f-=d;
    res+=d*dist[t];
    for(int v=t;v!=s;v=prevv[v]){
      edge &e = G[prevv[v]][preve[v]];
      e.cap-=d;
      G[v][e.rev].cap+=d;
    }

  }
  return res;
}

int n,sum;
int t[100];
int main(){
  
  while(cin>>n){

    init_edge();
    sum=0;
    for(int i=0;i<n;i++){cin>>t[i];sum-=t[i];}

    sort(t,t+n);
    reverse(t,t+n);
    
    for(int i=0;i<n;i++){
      add_edge(i,n+i,t[i],-1);
    }

    for(int i=0;i<n-1;i++){
      for(int j=i+1;j<n;j++){
	add_edge(n+i,j,t[j],0);
      }
    }
    
    for(int i=0;i<n;i++){
      add_edge(n+i,n+n,INF,0);
    }

    add_edge(n+n+1,0,INF,0);
    V=n+n+2;
    //cout<<min_cost_flow(0,n+n,t[0])<<' '<<sum<<endl;
    int z=min_cost_flow(n+n+1,n+n,t[0]);
    if(z==-1||z!=sum)cout<<"NO"<<endl;
    else cout<<"YES"<<endl;
    
  }

  return 0;
}