output_description: If an N-sided polygon satisfying the condition can be drawn, print `Yes`;
  otherwise, print `No`.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      L_1 L_2 ... L_N
attempt: # -*- coding: utf-8 -*-
  
  #############
  # Libraries #
  #############
  
  import sys
  input = sys.stdin.readline
  
  import math
  import bisect
  from collections import deque
  from fractions import gcd
  from functools import lru_cache
  
  
  #############
  # Constants #
  #############
  
  MOD = 10**9+7
  INF = float('inf')
  
  #############
  # Functions #
  #############
  
  ######INPUT######
  def inputI(): return int(input().strip())
  def inputS(): return input().strip()
  def inputIL(): return list(map(int,input().split()))
  def inputSL(): return list(map(str,input().split()))
  def inputILs(n): return list(int(input()) for _ in range(n))
  def inputSLs(n): return list(input().strip() for _ in range(n))
  def inputILL(n): return [list(map(int, input().split())) for _ in range(n)]
  def inputSLL(n): return [list(map(str, input().split())) for _ in range(n)]
  
  ######OUTPUT######
  def Yes(): print("Yes") return
  def No(): print("No") return
  
  #####Inverse#####
  def inv(n): return pow(n, MOD-2, MOD)
  
  ######Combination######
  kaijo_memo = []
  def kaijo(n):
    if(len(kaijo_memo) > n):
      return kaijo_memo[n]
    if(len(kaijo_memo) == 0):
      kaijo_memo.append(1)
    while(len(kaijo_memo) <= n):
      kaijo_memo.append(kaijo_memo[-1] * len(kaijo_memo) % MOD)
    return kaijo_memo[n]
  
  gyaku_kaijo_memo = []
  def gyaku_kaijo(n):
    if(len(gyaku_kaijo_memo) > n):
      return gyaku_kaijo_memo[n]
    if(len(gyaku_kaijo_memo) == 0):
      gyaku_kaijo_memo.append(1)
    while(len(gyaku_kaijo_memo) <= n):
      gyaku_kaijo_memo.append(gyaku_kaijo_memo[-1] * pow(len(gyaku_kaijo_memo),MOD-2,MOD) % MOD)
    return gyaku_kaijo_memo[n]
  
  def nCr(n,r):
    if(n == r):
      return 1
    if(n < r or r < 0):
      return 0
    ret = 1
    ret = ret * kaijo(n) % MOD
    ret = ret * gyaku_kaijo(r) % MOD
    ret = ret * gyaku_kaijo(n-r) % MOD
    return ret
  
  ######Factorization######
  def factorization(n):
      arr = []
      temp = n
      for i in range(2, int(-(-n**0.5//1))+1):
          if temp%i==0:
              cnt=0
              while temp%i==0:
                  cnt+=1
                  temp //= i
              arr.append([i, cnt])
      if temp!=1:
          arr.append([temp, 1])
  
      if arr==[]:
          arr.append([n, 1])
      return arr
  
  #####LCM#####
  def lcm(a, b):
      return a * b // gcd (a, b)
  
  #####BitCount#####
  def count_bit(n):
    count = 0
    while n:
      n &= n -1
      count += 1
    return count
  
  #############
  # Main Code #
  #############
  
  N = inputI()
  l = inputIL()
  l.sort()
  if sum(l[:-1]) >= sum[l]:
    No()
  else:
    Yes()
  
problem_description: Statement
  
  Determine if an N-sided polygon (not necessarily convex) with sides of length
  L_1, L_2, ..., L_N can be drawn in a two-dimensional plane.
  
  You can use the following theorem:
  
  **Theorem** : an N-sided polygon satisfying the condition can be drawn if and
  only if the longest side is strictly shorter than the sum of the lengths of
  the other N-1 sides.
samples: [{"input": "4\n    3 8 5 1", "output": "Yes\n    \n\nSince 8 < 9 = 3 + 5 + 1, it follows from the theorem that such a polygon can\nbe drawn on a plane.\n\n* * *"}, {"input": "4\n    3 8 4 1", "output": "No\n    \n\nSince 8 \\geq 8 = 3 + 4 + 1, it follows from the theorem that such a polygon\ncannot be drawn on a plane.\n\n* * *"}, {"input": "10\n    1 8 10 5 8 12 34 100 11 3", "output": "No"}]