#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>

using namespace std;

int main() {
    int N;
    cin >> N;
    vector<int> p(N);
    for (int i = 0; i < N; ++i) {
        cin >> p[i];
    }

    // dp[v]: Chi phí tối thiểu sau khi đã xử lý các ngày trước đó và còn lại v voucher.
    // Khởi tạo INF cho tất cả.
    // Số voucher tối đa có thể nhận là N (nếu tất cả đều > 100).
    const int INF = INT_MAX / 2;
    vector<int> dp(N + 1, INF);
    dp[0] = 0;

    for (int i = 0; i < N; ++i) {
        vector<int> next_dp(N + 1, INF);
        for (int v = 0; v <= N; ++v) {
            if (dp[v] == INF) continue;

            // Trạng thái 1: Dùng tiền mặt mua ngày i
            int cost_pay = dp[v] + p[i];
            int voucher_received = (p[i] > 100) ? 1 : 0;
            if (v + voucher_received <= N) {
                next_dp[v + voucher_received] = min(next_dp[v + voucher_received], cost_pay);
            }

            // Trạng thái 2: Dùng voucher mua ngày i (chỉ nếu có voucher)
            if (v > 0) {
                int cost_free = dp[v];
                // Khi dùng voucher, không nhận voucher mới dù giá > 100
                next_dp[v - 1] = min(next_dp[v - 1], cost_free);
            }
        }
        dp = next_dp;
    }

    int ans = INF;
    for (int v = 0; v <= N; ++v) {
        ans = min(ans, dp[v]);
    }
    cout << ans << endl;
    return 0;
}

#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;

int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    int n;cin>>n;
    vector<long long> p(n+1);
    for (int i=1;i<=n;i++){
        cin>>p[i];
    }    
    // dp[i][k]: Chi phí tối thiểu sau ngày i với k voucher
    vector<vector<long long> > dp(n+1,vector<long long>(n+1,INF));
    dp[0][0]=0;
    for (int i=1;i<=n;i++){
        for (int k=0;k<=n;k++){
            long long cur=dp[i-1][k];
            if (cur==INF) continue;

            // Di chuyển từ state (i-1, k) sang (i, ...)

            // 1. Dùng voucher: Phải có k > 0. 
            // Cost không đổi, voucher giảm 1 (k -> k-1)
            if (k>0){
                dp[i][k-1]=min(dp[i][k-1],cur);
            }

            // 2. Dùng tiền: Cost tăng p[i].
            // Voucher tăng 1 nếu p[i] > 100.
            long long gain=p[i]>100 ? 1 : 0;
            if (k+gain<=n){
                dp[i][k+gain]=min(dp[i][k+gain],cur+p[i]);
            }
        }
    }
    long long ans=INF;
    for (int k=0;k<=n;k++){
        ans=min(ans,dp[n][k]);
    }
    cout<<ans;
    return 0;
}

// Pseudocode cho logic tham lam
// Cần sắp xếp lại thứ tự các ngày? Không, phải giữ nguyên thứ tự.
// Do đó cách này chỉ hiệu quả nếu ta tối ưu hóa việc chọn ngày dùng voucher.
// Tuy nhiên, bài toán này phụ thuộc thứ tự.
// Một cách tiếp cận tham lam khác: Luôn dùng voucher ngay khi có thể cho các ngày sau có giá trị cao.

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

int main() {
    int N;
    cin >> N;
    vector<int> p(N);
    for(int i=0; i<N; i++) cin >> p[i];

    long long total_cost = 0;
    priority_queue<int> available_vouchers; // Chứa giá trị của các ngày đã mua > 100

    // Giả sử ta mua tất cả bằng tiền.
    // Sau đó, ta có thể dùng voucher để 'bù' lại một số ngày.
    // Nhưng voucher chỉ nhận được khi mua > 100.
    // Logic tham lam:
    // 1. Luôn mua ngày hiện tại bằng tiền.
    // 2. Nếu có voucher từ các ngày trước, và ngày này > 100, ta có thể cân nhắc.
    // Thực tế, DP là bắt buộc.

    // Thay vào đó, ta dùng Logic 'Tích lũy voucher và dùng cho ngày đắt nhất sau đó'.
    // Ta duyệt từ đầu đến cuối.
    // Khi gặp ngày > 100, ta 'mua' nó và nhận voucher.
    // Ta có thể 'hoàn tiền' nếu dùng voucher cho một ngày khác.
    // Thuật toán:
    // Duyệt qua các ngày, giả sử mua tất bằng tiền.
    // Duyệt lại các ngày từ cuối lên đầu?
    // Hoặc: Giữ một list các ngày đã mua > 100 và voucher.
    // Nếu gặp ngày mới > 100: Mua, nhận voucher.
    // Nếu gặp ngày <= 100: Cân nhắc dùng voucher.
    // Nếu gặp ngày > 100: Cân nhắc dùng voucher (vì voucher nhận từ ngày trước).

    // Do bài toán QHĐ là chính xác nhất, code tham lam khá phức tạp để chứng minh đúng.
    // Dưới đây là code minh họa logic tham lam (Greedy) nếu vấn đề có thể được tối ưu hóa.
    // Tuy nhiên, với ràng buộc bài này, DP là chuẩn.

    // Code minh họa DP 1 chiều (Space optimized) là tốt nhất.
    // Hãy tham khảo Solution 3.
    return 0;
}