molecules: дихотомия по ширине скользящего окна на сортированном массиве (с промежуточными ДП возиться не стал).
railroads: перебор > ДП > граф (существование Эйлерова цикла с допущениями) > граф (#3 + минимальное основное дерево по компонентам)
shortcut: дихотомия по ответу с возрастающе сложными оптимизациями проверки (даже не брался)
Прилагаю решения на Python как наименее сложные. 

molecules: дихотомия по ширине скользящего окна на сортированном массиве (с промежуточными ДП возиться не стал). 

__all__ = ['find_subset']

SMALLER, BIGGER = object(), object()

def test (k, smin, smax, w):
    s = sum( w[:k] )
    if smin <= s <= smax:
        return 0
    smaller, bigger = s < smin, s > smax
    for i in range(k, len(w)):
        s = s - w[i-k] + w[i]
        smaller = smaller or s < smin
        bigger = bigger or s > smax
        if smin <= s <= smax:
            return i-k+1
    assert smaller != bigger
    return (SMALLER if smaller else BIGGER)

def find (smin, smax, w, idx):
    w = sorted(w)
    l, r = 0, len(w)+1
    while l + 1 < r:
        m = (l+r+1) // 2
        if test(m, smin, smax, w) is BIGGER:
            r = m
        else:
            l = m
    m = test(l, smin, smax, w)
    return ([] if m in {SMALLER, BIGGER} else idx[m:m+l])

def find_subset (l, u, w):
    idx = sorted(range( len(w) ), key=lambda i: w[i])
    return find(l, u, w, idx)

molecules: дихотомия по ширине скользящего окна на сортированном массиве (с промежуточными ДП возиться не стал). 

Unit Molecules;
{$Mode ObjFPC}
Interface
  TYPE
    TInts = Array of LongInt;

  Function Find_Subset (L, U : LongInt;  W : TInts): TInts;

Implementation

  Function Test (K, SMin, SMax : LongWord;  Const W, Idx : TInts): LongWord;
  Var
    S                   : QWord = 0;
    i, N                : LongWord;
    Smaller, Bigger     : Boolean;
  Begin
    For i:=1 To K
      Do Inc(S, W[ Idx[i-1] ]);
    If (SMin <= S) and (S <= SMax)
      Then Exit(1);
    Smaller := S < SMin;
    Bigger := S > SMax;
    N := Length(W);
    For i:=K+1 To N Do Begin
      S := S - W[ Idx[i-K-1] ] + W[ Idx[i-1] ];
      Smaller := Smaller or (S < SMin);
      Bigger := Bigger or (S > SMax);
      If (SMin <= S) and (S <= SMax)
        Then Exit(i-K+1);
    End;
    If Smaller = Bigger
      Then Halt(1);
    If Smaller
      Then Exit(0)
      Else Exit(N + 1);
  End;

  Function Find (SMin, SMax : LongWord;  Const W, Idx : TInts): TInts;
  Var
    N, L, R, M  : LongWord;
  Begin
    N := Length(W);
    L := 0;   R := N + 1;
    While L + 1 < R Do Begin
      M := (L+R+1) div 2;
      If Test(M, SMin, SMax, W, Idx) > N
        Then R := M
        Else L := M;
    End;
    M := Test(L, SMin, SMax, W, Idx);
    If (0 < M) and (M <= N)
      Then Exit( Copy(Idx, M-1, L) );
    SetLength(Result, 0);
  End;

  Procedure Sort (Var Idx : TInts;  Const W : TInts);
  Var
    Buff        : TInts;
  
    Procedure _Add (Var i, k : LongWord);   Inline;
    Begin
      Idx[k] := Buff[i];
      Inc(i);   Inc(k);
    End;
  
    Procedure _Sort (L, R : LongWord);
    Var
      i, j, k, C        : LongWord;
    Begin
      If L = R
        Then Exit;
      C := (L+R) div 2;
      _Sort(L, C);
      _Sort(C+1, R);
      For k:=L To R
        Do Buff[k] := Idx[k];
      k := L;   i := L;   j := C+1;
      While (i <= C) and (j <= R)
        Do If W[ Buff[i] ] <= W[ Buff[j] ]
          Then _Add(i, k)
          Else _Add(j, k);
      While (i <= C) Do _Add(i, k);
      While (j <= R) Do _Add(j, k);
    End;
  
  Begin
    SetLength(Buff, Length(W));
    _Sort(0, Length(W)-1);
  End;

  Function Find_Subset (L, U : LongInt;  W : TInts): TInts;
  Var
    Idx : TInts;
    i   : LongWord;
  Begin
    SetLength(Idx, Length(W));
    For i:=1 To Length(W)
      Do Idx[i-1] := i-1;
    Sort(Idx, W);
    Exit( Find(L, U, W, Idx) );
  End;

END.

railroads: перебор > ДП > граф (существование Эйлерова цикла с допущениями) > граф (#3 + минимальное основное дерево по компонентам) 

__all__ = ['plan_roller_coaster']

def find_min (l, speed, s, t, not_used):
    result, found = None, False
    for i in list(not_used):
        not_used.remove(i)
        d = max(0, speed-s[i])
        x = find_min(l+d, t[i], s, t, not_used)
        result = (result if found and x > result else x)
        found = True
        not_used.add(i)
    return (result if found else l)

def plan_roller_coaster (s, t):
    return find_min(0, 0, s, t, set(range( len(s) )))

__all__ = ['plan_roller_coaster']

def bits (mask):
    i, j = 1, 0
    while mask > 0:
        if mask & i > 0:
            mask -= i
            yield j
        i, j = i+i, j+1

def plan_roller_coaster (s, t):
    n = len(s)
    d = [[None]*n for i in range(1 << n)]
    for i in range(n):
        d[1 << i][i] = 0
    for mask in range(1 << n):
        b = set( bits(mask) )
        for i in b:
            if d[mask][i] is not None:
                for j in set(range(n)) - b:
                    d1 = d[mask][i] + max(0, t[i]-s[j])
                    m = mask | (1 << j)
                    d[m][j] = (d1 if d[m][j] is None or d1 < d[m][j] else d[m][j])
    return min( d[(1 << n) - 1] )

from bisect import bisect_left as find

__all__ = ['plan_roller_coaster']

MINX, MAXX = 1, 10**9
YES, NO = 0, 1


class DSF (object):
    __len__ = lambda o: o.size
    
    def __init__ (self, n):
        self.size, self._r, self._d = n, [0]*n, list( range(n) )
    
    def __getitem__ (self, u):
        if self._d[u] != u:
            self._d[u] = self[ self._d[u] ]
        return self._d[u]
    
    def merge (self, u, v):
        u, v = self[u], self[v]
        if u == v:
            return False
        if self._r[u] == self._r[v]:
            self._r[u] += 1
        if self._r[u] < self._r[v]:
            self._d[u] = v
        else:
            self._d[v] = u
        self.size -= 1
        return True


def plan_roller_coaster (s, t):
    s, t = s+[MAXX], t+[MINX]
    points = sorted( set(s+t) )
    dsf, d = DSF( len(points) ), [0]*len(points)
    for u, v in zip(s, t):
        u, v = find(points, u), find(points, v)
        dsf.merge(u, v)
        d[u] += 1
        d[v] -= 1
    opened = 0
    for i, x in enumerate(d):
        opened += x
        if opened > 0:
            return NO
        elif opened < 0:
            dsf.merge(i, i+1)
    assert opened == 0
    return (YES if len(dsf) == 1 else NO)

from bisect import bisect_left as find

__all__ = ['plan_roller_coaster']

MINX, MAXX = 1, 10**9


class DSF (object):
    __len__ = lambda o: o.size
    
    def __init__ (self, n):
        self.size, self._r, self._d = n, [0]*n, list( range(n) )
    
    def __getitem__ (self, u):
        if self._d[u] != u:
            self._d[u] = self[ self._d[u] ]
        return self._d[u]
    
    def merge (self, u, v):
        u, v = self[u], self[v]
        if u == v:
            return False
        if self._r[u] == self._r[v]:
            self._r[u] += 1
        if self._r[u] < self._r[v]:
            self._d[u] = v
        else:
            self._d[v] = u
        self.size -= 1
        return True


def plan_roller_coaster (s, t):
    s, t = s+[MAXX], t+[MINX]
    points = sorted( set(s+t) )
    n = len(points)
    dx = [x1-x for x, x1 in zip(points, points[1:])]
    dsf, d = DSF(n), [0]*n
    for u, v in zip(s, t):
        u, v = find(points, u), find(points, v)
        dsf.merge(u, v)
        d[u] += 1
        d[v] -= 1
    q = d.pop()
    result, opened, edges = 0, 0, []
    for i, x in enumerate(d):
        opened += x
        if opened == 0:
            edges.append(i)
        else:
            dsf.merge(i, i+1)
            result += max(0, opened * dx[i])
    assert opened == -q
    edges.sort(key=dx.__getitem__)
    for u in edges:
        v, x = u+1, dx[u]
        if dsf[u] != dsf[v]:
            result += x
            dsf.merge(u, v)
    return result