1) Abridged problem statement
- You are given N player heights (in meters), each in [1.95, 2.05], and their average is exactly 2.00 m.
- Arrange the players in a line so that for every contiguous segment, if H is the sum of heights in that segment and K is the number of players in it, then |H − 2.00·K| ≤ 0.10 m.
- Print “yes” and any valid permutation (1-based indices). Under these guarantees, a solution always exists.

2) Detailed editorial
- Reformulation:
  - Let di = hi − 2.00 (measured in meters). The problem’s condition becomes: for every contiguous segment, the sum of its di’s must be within [−0.10, 0.10].
  - Because the overall average is exactly 2.00, we have ∑i di = 0.
  - Each di ∈ [−0.05, 0.05] since hi ∈ [1.95, 2.05].

- Sufficient condition via prefix sums:
  - Let Sk be the prefix sum of the arranged sequence’s deviations: Sk = ∑t=1..k dpt (where p is the permutation).
  - If all prefix sums lie inside [−0.05, 0.05], then any subarray sum is the difference of two prefix sums, hence in [−0.10, 0.10]. Therefore the check always passes.

- Greedy construction:
  - Sort players by di (ascending). Maintain two pointers:
    - l at the most negative remaining deviation,
    - r at the most positive remaining deviation.
  - Maintain the running prefix sum S (start S = 0).
  - Repeat N times:
    - If S > 0, take the most negative remaining element (index l) to pull S down; increment l.
    - If S ≤ 0, take the most positive remaining element (index r) to pull S up; decrement r.

- Why it always works:
  - Existence of needed signs:
    - If S > 0 and there were no negative (or zero) elements left, then the sum of all remaining deviations would be ≥ 0, making the total sum > 0, contradicting ∑ di = 0. Hence when S > 0, a negative exists. Similarly, when S ≤ 0, a positive exists.
  - Bounding S:
    - When S > 0, we add some x ≤ 0 with x ≥ −0.05. Then S' = S + x ≤ S ≤ 0.05 and S' ≥ S − 0.05 > −0.05, so S' ∈ (−0.05, 0.05].
    - When S ≤ 0, we add some x ≥ 0 with x ≤ 0.05. Then S' = S + x ≥ S ≥ −0.05 and S' ≤ S + 0.05 ≤ 0.05, so S' ∈ [−0.05, 0.05].
  - Therefore every prefix sum stays within [−0.05, 0.05], and every subarray sum stays within [−0.10, 0.10].

- Complexity:
  - Sorting dominates: O(N log N) time, O(N) memory.

- Implementation notes:
  - The provided C++ works with doubles; it shifts each height by 2.0 and applies the two-pointer greedy directly. Because input heights are integer micrometers, one could also work in integer micrometers to avoid floating-point pitfalls (di = micrometers(hi) − 2,000,000, with bounds ±50,000 for ±0.05 m and ±100,000 for ±0.10 m), as the Python solution below does.

3) C++ Solution
```cpp
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
};

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
};

int n;
vector<double> a;

void read() {
    cin >> n;
    a.resize(n);
    cin >> a;
}

void solve() {
    // The key observation is that the initial sequence has average of 2.0, and
    // all elements are within [1.95; 2.05]. We will show that the answer is
    // always "yes". A helpful reformulation is that we want all subarrays to
    // have average within [1.90;2.10], or equivalently, if we subtract 2.0 from
    // each element, all subarrays must have sum within [-0.10;0.10]. The
    // initial average of 2.0 also means that the sum of all elements is 0.0. To
    // have each sum within [-0.10;0.10], it sufficient for all prefix sums to
    // be within [-0.05;0.05], which we can guarantee by constructing the
    // permutation greedily:
    //
    // - If the current prefix sum is positive, we know that there is certainly
    //   at least one negative element remaining (since the total sum is 0.0),
    //   so we add the smallest element remaining.
    //
    // - If the current prefix sum is non-positive, we add the largest element
    //   remaining. We are guaranteed that there is at least one positive
    //   element remaining, since otherwise the total sum would be negative.
    //
    // This way, we guarantee that the prefix sum always stays within
    // [-min_element;max_element], which is a subset of [-0.05;0.05].

    for(auto& x: a) {
        x -= 2.0;
    }

    vector<int> perm(n), ans;
    iota(perm.begin(), perm.end(), 0);
    sort(perm.begin(), perm.end(), [&](int i, int j) { return a[i] < a[j]; });

    double sum = 0.0;
    int l = 0, r = n - 1;
    for(int i = 0; i < n; i++) {
        if(sum > 0) {
            sum += a[perm[l++]];
            ans.push_back(perm[l - 1] + 1);
        } else {
            sum += a[perm[r--]];
            ans.push_back(perm[r + 1] + 1);
        }
    }

    cout << "yes\n";
    cout << ans << '\n';
}

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

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}
```

4) Python solution (well-commented)
```python
import sys

def parse_micrometers(s):
    """
    Parse a decimal string s representing meters into integer micrometers.
    Assumes input heights are integer micrometers as per the statement.
    Examples:
      "2"    -> 2_000_000
      "1.95" -> 1_950_000
      "2.050000" -> 2_050_000
    """
    s = s.strip()
    neg = s.startswith('-')
    if neg:
        s = s[1:]
    if '.' in s:
        left, right = s.split('.', 1)
    else:
        left, right = s, ''
    # pad or truncate fractional part to 6 digits (micrometers)
    right = (right + '000000')[:6]
    microunits = int(left) * 1_000_000 + (int(right) if right else 0)
    return -microunits if neg else microunits

def main():
    data = sys.stdin.read().strip().split()
    if not data:
        return
    it = iter(data)
    n = int(next(it))
    heights = [next(it) for _ in range(n)]

    # Convert to integer micrometers and then to deviations from 2_000_000 μm (2.0 m)
    two_m_micros = 2_000_000
    deviations = []
    for idx, s in enumerate(heights):
        mic = parse_micrometers(s)
        deviations.append((mic - two_m_micros, idx + 1))  # store (deviation, 1-based index)

    # Sort by deviation ascending
    deviations.sort(key=lambda t: t[0])

    # Two-pointer greedy: keep prefix sum in [-50_000, 50_000]
    S = 0  # prefix sum of deviations, in micrometers
    l, r = 0, n - 1
    order = []
    for _ in range(n):
        if S > 0:
            d, idx = deviations[l]
            l += 1
        else:
            d, idx = deviations[r]
            r -= 1
        S += d
        order.append(idx)

    # Under problem guarantees, a solution always exists
    out = []
    out.append("yes")
    out.append(" ".join(map(str, order)))
    print("\n".join(out))

if __name__ == "__main__":
    main()
```

5) Compressed editorial
- Shift heights by 2.00: di = hi − 2.00. Goal: for all contiguous segments, |∑ di| ≤ 0.10.
- It suffices to keep all prefix sums within [−0.05, 0.05], since any segment sum is a difference of two prefixes.
- Sort di ascending and build the permutation greedily with two pointers:
  - If current prefix sum S > 0, append the most negative remaining element; else append the most positive.
- Because ∑ di = 0 and each di ∈ [−0.05, 0.05], this choice always exists and keeps S within [−0.05, 0.05].
- Complexity: O(N log N) due to sorting.
