BOOL CWallet :: SelectCoins (int64 nTargetValue, установите<пара >& setCoinsRet, int64& nValueRet) сопзЬ



BOOL CWallet :: SelectCoinsMinConf (int64 nTargetValue, внутр nConfMine, внутр nConfTheirs, вектор vCoins,
                                 задавать<пара >& setCoinsRet, int64& nValueRet) сопзЬ
{
    setCoinsRet.clear ();
    nValueRet = 0;

    // Список значений меньше, чем цели
    пара > coinLowestLarger;
    coinLowestLarger.first = станд :: numeric_limits::Максимум();
    coinLowestLarger.second.first = NULL;
    вектор<пара > > VVALUE;
    Int64 nTotalLower = 0;

    random_shuffle (vCoins.begin (), vCoins.end (), GetRandInt);

    BOOST_FOREACH (выход COutput, vCoins)
    {
        Const CWalletTx * pcoin = output.tx;

        если (output.nDepth < (pcoin->IsFromMe ()? nConfMine: nConfTheirs))
            Продолжать;

        INT I = output.i;
        Int64 п = pcoin->Vout [I] .nValue;

        пара > монета = make_pair (п, make_pair (pcoin, я));

        если (п == nTargetValue)
        {
            setCoinsRet.insert (coin.second);
            nValueRet + = coin.first;
            возвращает истину;
        }
        иначе если (п < nTargetValue + CENT)
        {
            vValue.push_back (монеты);
            nTotalLower + = п;
        }
        иначе если (п < coinLowestLarger.first)
        {
            coinLowestLarger = монета;
        }
    }

    если (nTotalLower == nTargetValue)
    {
        для (беззнаковое INT I = 0; я < vValue.size (); ++ я)
        {
            setCoinsRet.insert (VVALUE [я] .second);
            nValueRet + = VVALUE [I] .first;
        }
        возвращает истину;
    }

    если (nTotalLower < nTargetValue)
    {
        если (coinLowestLarger.second.first == NULL)
            вернуться ложным;
        setCoinsRet.insert (coinLowestLarger.second);
        nValueRet + = coinLowestLarger.first;
        возвращает истину;
    }

    // Решите сумму подмножества по стохастической аппроксимации
    сортировать (vValue.rbegin (), vValue.rend (), CompareValueOnly ());
    вектор<голец> vfBest;
    int64 nBest;

    ApproximateBestSubset (VVALUE, nTotalLower, nTargetValue, vfBest, nBest, 1000);
    если (nBest! = nTargetValue && nTotalLower >= NTargetValue + CENT)
        ApproximateBestSubset (VVALUE, nTotalLower, nTargetValue + Cent, vfBest, nBest, 1000);

    // Если мы имеем большую монету и (или стохастической аппроксимации не найти хорошее решение,
    // или следующая большая монета ближе), вернуть большую монету
    если (coinLowestLarger.second.first &&
        ((NBest! = NTargetValue && nBest < nTargetValue + CENT) || coinLowestLarger.first <= NBest))
    {
        setCoinsRet.insert (coinLowestLarger.second);
        nValueRet + = coinLowestLarger.first;
    }
    еще {
        для (беззнаковое INT I = 0; я < vValue.size (); я ++)
            если (vfBest [I])
            {
                setCoinsRet.insert (VVALUE [я] .second);
                nValueRet + = VVALUE [I] .first;
            }

        //// отладки печати
        Е ("SelectCoins () лучшее подмножество: ");
        для (беззнаковое INT I = 0; я < vValue.size (); я ++)
            если (vfBest [I])
                Е ("% s ", FormatMoney (VVALUE [я] .first) .c_str ());
        Е ("общий% s \ п", FormatMoney (nBest) .c_str ());
    }

    возвращает истину;
}