def maximin_distance_subset1d(items, K=None, min_thresh=None, verbose=False):
    r"""
    Greedy algorithm, may be exact for 1d case.
    First, choose the first item, then choose the next item that is farthest
    away from all previously chosen items. Iterate.

    CommandLine:
        python -m utool.util_alg --exec-maximin_distance_subset1d

    Notes:
        Given a set of items V.
        Let $E = V \times V$ be the the set of all item pairs.

        The goal is to return the largest subset of item such that the distance
        between any pair of items in the subset is greater than some threshold.

        Let t[u, v] be the distance between u and v.

        Let x[u, v] = 1 if the annotation pair (u, v) is included.

        Let y[u] = 1 if the annotation u is included.

        Objective:
            maximize sum(y[u] for u in V)

        subject to:
            # Annotations pairs are only included if their timedelta is less than
            # the threshold.
            x[u, v] = 0 if t[u, v] > thresh

            # If an edge is exclued at least one of its endpoints must be
            # excluded
            y[u] + y[v] - x[u, v] < 2


    Example:
        >>> # DISABLE_DOCTEST
        >>> import utool as ut
        >>> from utool.util_alg import *  # NOQA
        >>> #items = [1, 2, 3, 4, 5, 6, 7]
        >>> items = [20, 1, 1, 9, 21, 6, 22]
        >>> min_thresh = 5
        >>> K = None
        >>> result = maximin_distance_subset1d(items, K, min_thresh, verbose=True)
        >>> print(result)
        (array([1, 3, 6]), [1, 9, 22])

    Example:
        >>> # DISABLE_DOCTEST
        >>> import utool as ut
        >>> from utool.util_alg import *  # NOQA
        >>> #items = [1, 2, 3, 4, 5, 6, 7]
        >>> items = [0, 1]
        >>> min_thresh = 5
        >>> K = None
        >>> result = maximin_distance_subset1d(items, K, min_thresh, verbose=True)
        >>> print(result)
    """
    if False:
        import pulp
        # Formulate integer program
        prob = pulp.LpProblem("MaxSizeLargeDistSubset", pulp.LpMaximize)
        # Solution variable indicates if set it chosen or not
        item_indices = list(range(len(items)))
        pair_indices = list(ut.combinations(item_indices, 2))
        x = pulp.LpVariable.dicts(name='x', indexs=pair_indices,
                                  lowBound=0, upBound=1, cat=pulp.LpInteger)
        y = pulp.LpVariable.dicts(name='y', indexs=item_indices,
                                  lowBound=0, upBound=1, cat=pulp.LpInteger)
        # minimize the number of sets
        prob.objective = sum(y[i] for i in item_indices)

        # subject to
        count = 0
        for u, v in pair_indices:
            # Minimum thresh constraint
            if abs(items[u] - items[v]) < min_thresh:
                prob.add(x[(u, v)] == 0, name='thresh_%r' % (count,))
                count += 1

        count = 0
        for u, v in pair_indices:
            prob.add(y[u] + y[v] - x[(u, v)] <= 1, 'exclusion_%r' % (count,))
            count += 1

        pulp.PULP_CBC_CMD().solve(prob)
        # Read solution
        flags = [y[i].varValue >= 1.0 for i in item_indices]
        chosen_items_idxs = ut.where(flags)
        chosen_items = ut.take(items, chosen_items_idxs)

        # total_value = sum([val for val, flag in zip(values, flags) if flag])
        # items_subset = [item for item, flag in zip(items, flags) if flag]
        # each element is covered
        # containing_sets = [i for i in set_indices if e in candidate_sets_dict[i]]
        # prob.add(sum(x[i] for i in containing_sets) >= 1)

    import utool as ut
    import vtool as vt
    points = np.array(items)[:, None]
    # Initial sorting of 1d points
    initial_sortx = points.argsort(axis=0).flatten()
    points = points.take(initial_sortx, axis=0)

    if K is None:
        K = len(items)

    def distfunc(x, y):
        return np.abs(x - y)

    assert points.shape[1] == 1
    assert len(points) >= K, 'cannot return subset'
    if K == 1:
        current_idx = [0]
    else:
        current_idx = [0, -1]
        if min_thresh is not None and distfunc(points[0], points[-1])[0] < min_thresh:
            current_idx = [0]
    chosen_mask = vt.index_to_boolmask(current_idx, len(points))

    for k in range(2, K):
        unchosen_idx = np.nonzero(~chosen_mask)[0]
        unchosen_items = points.compress(~chosen_mask, axis=0)
        chosen_items = points.compress(chosen_mask, axis=0)
        distances = distfunc(unchosen_items, chosen_items.T)
        min_distances = distances.min(axis=1)
        argx = min_distances.argmax()
        if min_thresh is not None:
            if min_distances[argx] < min_thresh:
                break
        new_idx = unchosen_idx[argx]
        chosen_mask[new_idx] = True

    # Put chosen mask back in the input order of items
    chosen_items_mask = chosen_mask.take(initial_sortx.argsort())
    chosen_items_idxs = np.nonzero(chosen_items_mask)[0]
    chosen_items = ut.take(items, chosen_items_idxs)
    #current_idx = np.nonzero(chosen_mask)[0]
    if verbose:
        print('Chose subset')
        chosen_points = points.compress(chosen_mask, axis=0)
        distances = (spdist.pdist(chosen_points, distfunc))
        print('chosen_items_idxs = %r' % (chosen_items_idxs,))
        print('chosen_items = %r' % (chosen_items,))
        print('distances = %r' % (distances,))
    return chosen_items_idxs, chosen_items