?? algorithm
字號:
advance(_F2, _D);
_X = merge(_F, _F1, _F1, _F2, _X, _P);
_F = _F2; }
if (_N <= _D)
copy(_F, _L, _X);
else
{_BI _F1 = _F;
advance(_F1, _D);
merge(_F, _F1, _F1, _L, _X, _P); }}
// TEMPLATE FUNCTION partial_sort
template<class _RI> inline
void partial_sort(_RI _F, _RI _M, _RI _L)
{_Partial_sort(_F, _M, _L, _Val_type(_F)); }
template<class _RI, class _Ty> inline
void _Partial_sort(_RI _F, _RI _M, _RI _L, _Ty *)
{make_heap(_F, _M);
for (_RI _I = _M; _I < _L; ++_I)
if (*_I < *_F)
_Pop_heap(_F, _M, _I, _Ty(*_I), _Dist_type(_F));
sort_heap(_F, _M); }
// TEMPLATE FUNCTION partial_sort WITH PRED
template<class _RI, class _Pr> inline
void partial_sort(_RI _F, _RI _M, _RI _L, _Pr _P)
{_Partial_sort(_F, _M, _L, _P, _Val_type(_F)); }
template<class _RI, class _Ty, class _Pr> inline
void _Partial_sort(_RI _F, _RI _M, _RI _L, _Pr _P, _Ty *)
{make_heap(_F, _M, _P);
for (_RI _I = _M; _I < _L; ++_I)
if (_P(*_I, *_F))
_Pop_heap(_F, _M, _I, _Ty(*_I), _P, _Dist_type(_F));
sort_heap(_F, _M, _P); }
// TEMPLATE FUNCTION partial_sort_copy
template<class _II, class _RI> inline
_RI partial_sort_copy(_II _F1, _II _L1, _RI _F2, _RI _L2)
{return (_Partial_sort_copy(_F1, _L1, _F2, _L2,
_Dist_type(_F2), _Val_type(_F1))); }
template<class _II, class _RI, class _Pd, class _Ty> inline
_RI _Partial_sort_copy(_II _F1, _II _L1, _RI _F2, _RI _L2,
_Pd *, _Ty *)
{_RI _X = _F2;
if (_X != _L2)
{for (; _F1 != _L1 && _X != _L2; ++_F1, ++_X)
*_X = *_F1;
make_heap(_F2, _X);
for (; _F1 != _L1; ++_F1)
if (*_F1 < *_F2)
_Adjust_heap(_F2, _Pd(0), _Pd(_X - _F2),
_Ty(*_F1));
sort_heap(_F2, _X); }
return (_X); }
// TEMPLATE FUNCTION partial_sort_copy WITH PRED
template<class _II, class _RI, class _Pr> inline
_RI partial_sort_copy(_II _F1, _II _L1, _RI _F2, _RI _L2,
_Pr _P)
{return (_Partial_sort_copy(_F1, _L1, _F2, _L2, _P,
_Dist_type(_F2), _Val_type(_F1))); }
template<class _II, class _RI, class _Pd,
class _Ty, class _Pr> inline
_RI _Partial_sort_copy(_II _F1, _II _L1, _RI _F2, _RI _L2,
_Pr _P, _Pd *, _Ty *)
{_RI _X = _F2;
if (_X != _L2)
{for (; _F1 != _L1 && _X != _L2; ++_F1, ++_X)
*_X = *_F1;
make_heap(_F2, _X, _P);
for (; _F1 != _L1; ++_F1)
if (_P(*_F1, *_F2))
_Adjust_heap(_F2, _Pd(0), _Pd(_X - _F2),
_Ty(*_F1), _P);
sort_heap(_F2, _X, _P); }
return (_X); }
// TEMPLATE FUNCTION nth_element
template<class _RI> inline
void nth_element(_RI _F, _RI _Nth, _RI _L)
{_Nth_element(_F, _Nth, _L, _Val_type(_F)); }
template<class _RI, class _Ty> inline
void _Nth_element(_RI _F, _RI _Nth, _RI _L, _Ty *)
{for (; _SORT_MAX < _L - _F; )
{_RI _M = _Unguarded_partition(_F, _L, _Median(_Ty(*_F),
_Ty(*(_F + (_L - _F) / 2)), _Ty(*(_L - 1))));
if (_M <= _Nth)
_F = _M;
else
_L = _M; }
_Insertion_sort(_F, _L); }
// TEMPLATE FUNCTION nth_element WITH PRED
template<class _RI, class _Pr> inline
void nth_element(_RI _F, _RI _Nth, _RI _L, _Pr _P)
{_Nth_element(_F, _Nth, _L, _P, _Val_type(_F)); }
template<class _RI, class _Ty, class _Pr> inline
void _Nth_element(_RI _F, _RI _Nth, _RI _L, _Pr _P, _Ty *)
{for (; _SORT_MAX < _L - _F; )
{_RI _M = _Unguarded_partition(_F, _L, _Median(_Ty(*_F),
_Ty(*(_F + (_L - _F) / 2)), _Ty(*(_L - 1)), _P), _P);
if (_M <= _Nth)
_F = _M;
else
_L = _M; }
_Insertion_sort(_F, _L, _P); }
// TEMPLATE FUNCTION lower_bound
template<class _FI, class _Ty> inline
_FI lower_bound(_FI _F, _FI _L, const _Ty& _V)
{return (_Lower_bound(_F, _L, _V, _Dist_type(_F))); }
template<class _FI, class _Ty, class _Pd> inline
_FI _Lower_bound(_FI _F, _FI _L, const _Ty& _V, _Pd *)
{_Pd _N = 0;
_Distance(_F, _L, _N);
for (; 0 < _N; )
{_Pd _N2 = _N / 2;
_FI _M = _F;
advance(_M, _N2);
if (*_M < _V)
_F = ++_M, _N -= _N2 + 1;
else
_N = _N2; }
return (_F); }
// TEMPLATE FUNCTION lower_bound WITH PRED
template<class _FI, class _Ty, class _Pr> inline
_FI lower_bound(_FI _F, _FI _L, const _Ty& _V, _Pr _P)
{return (_Lower_bound(_F, _L, _V, _P, _Dist_type(_F))); }
template<class _FI, class _Ty, class _Pd, class _Pr> inline
_FI _Lower_bound(_FI _F, _FI _L, const _Ty& _V, _Pr _P, _Pd *)
{_Pd _N = 0;
_Distance(_F, _L, _N);
for (; 0 < _N; )
{_Pd _N2 = _N / 2;
_FI _M = _F;
advance(_M, _N2);
if (_P(*_M, _V))
_F = ++_M, _N -= _N2 + 1;
else
_N = _N2; }
return (_F); }
// TEMPLATE FUNCTION upper_bound
template<class _FI, class _Ty> inline
_FI upper_bound(_FI _F, _FI _L, const _Ty& _V)
{return (_Upper_bound(_F, _L, _V, _Dist_type(_F))); }
template<class _FI, class _Ty, class _Pd> inline
_FI _Upper_bound(_FI _F, _FI _L, const _Ty& _V, _Pd *)
{_Pd _N = 0;
_Distance(_F, _L, _N);
for (; 0 < _N; )
{_Pd _N2 = _N / 2;
_FI _M = _F;
advance(_M, _N2);
if (!(_V < *_M))
_F = ++_M, _N -= _N2 + 1;
else
_N = _N2; }
return (_F); }
// TEMPLATE FUNCTION upper_bound WITH PRED
template<class _FI, class _Ty, class _Pr> inline
_FI upper_bound(_FI _F, _FI _L, const _Ty& _V, _Pr _P)
{return (_Upper_bound(_F, _L, _V, _P, _Dist_type(_F))); }
template<class _FI, class _Ty, class _Pd, class _Pr> inline
_FI _Upper_bound(_FI _F, _FI _L, const _Ty& _V, _Pr _P, _Pd *)
{_Pd _N = 0;
_Distance(_F, _L, _N);
for (; 0 < _N; )
{_Pd _N2 = _N / 2;
_FI _M = _F;
advance(_M, _N2);
if (!_P(_V, *_M))
_F = ++_M, _N -= _N2 + 1;
else
_N = _N2; }
return (_F); }
// TEMPLATE FUNCTION equal_range
template<class _FI, class _Ty> inline
pair<_FI, _FI> equal_range(_FI _F, _FI _L, const _Ty& _V)
{return (_Equal_range(_F, _L, _V, _Dist_type(_F))); }
template<class _FI, class _Ty, class _Pd> inline
pair<_FI, _FI> _Equal_range(_FI _F, _FI _L,
const _Ty& _V, _Pd *)
{_Pd _N = 0;
_Distance(_F, _L, _N);
for (; 0 < _N; )
{_Pd _N2 = _N / 2;
_FI _M = _F;
advance(_M, _N2);
if (*_M < _V)
_F = ++_M, _N -= _N2 + 1;
else if (_V < *_M)
_N = _N2;
else
{_FI _F2 = lower_bound(_F, _M, _V);
advance(_F, _N);
_FI _L2 = upper_bound(++_M, _F, _V);
return (pair<_FI, _FI>(_F2, _L2)); }}
return (pair<_FI, _FI>(_F, _F)); }
// TEMPLATE FUNCTION equal_range WITH PRED
template<class _FI, class _Ty, class _Pr> inline
pair<_FI, _FI> equal_range(_FI _F, _FI _L, const _Ty& _V,
_Pr _P)
{return (_Equal_range(_F, _L, _V, _P, _Dist_type(_F))); }
template<class _FI, class _Ty, class _Pd, class _Pr> inline
pair<_FI, _FI> _Equal_range(_FI _F, _FI _L, const _Ty& _V,
_Pr _P, _Pd *)
{_Pd _N = 0;
_Distance(_F, _L, _N);
for (; 0 < _N; )
{_Pd _N2 = _N / 2;
_FI _M = _F;
advance(_M, _N2);
if (_P(*_M, _V))
_F = ++_M, _N -= _N2 + 1;
else if (_P(_V, *_M))
_N = _N2;
else
{_FI _F2 = lower_bound(_F, _M, _V, _P);
advance(_F, _N);
_FI _L2 = upper_bound(++_M, _F, _V, _P);
return (pair<_FI, _FI>(_F2, _L2)); }}
return (pair<_FI, _FI>(_F, _F)); }
// TEMPLATE FUNCTION binary_search
template<class _FI, class _Ty> inline
bool binary_search(_FI _F, _FI _L, const _Ty& _V)
{_FI _I = lower_bound(_F, _L, _V);
return (_I != _L && !(_V < *_I)); }
// TEMPLATE FUNCTION binary_search WITH PRED
template<class _FI, class _Ty, class _Pr> inline
bool binary_search(_FI _F, _FI _L, const _Ty& _V, _Pr _P)
{_FI _I = lower_bound(_F, _L, _V, _P);
return (_I != _L && !_P(_V, *_I)); }
// TEMPLATE FUNCTION merge
template<class _II1, class _II2, class _OI> inline
_OI merge(_II1 _F1, _II1 _L1, _II2 _F2, _II2 _L2, _OI _X)
{for (; _F1 != _L1 && _F2 != _L2; ++_X)
if (*_F2 < *_F1)
*_X = *_F2++;
else
*_X = *_F1++;
return (copy(_F2, _L2, copy(_F1, _L1, _X))); }
// TEMPLATE FUNCTION merge WITH PRED
template<class _II1, class _II2, class _OI, class _Pr> inline
_OI merge(_II1 _F1, _II1 _L1, _II2 _F2, _II2 _L2, _OI _X,
_Pr _P)
{for (; _F1 != _L1 && _F2 != _L2; ++_X)
if (_P(*_F2, *_F1))
*_X = *_F2++;
else
*_X = *_F1++;
return (copy(_F2, _L2, copy(_F1, _L1, _X))); }
// TEMPLATE FUNCTION inplace_merge
template<class _BI> inline
void inplace_merge(_BI _F, _BI _M, _BI _L)
{if (_F != _L)
_Inplace_merge(_F, _M, _L,
_Dist_type(_F), _Val_type(_F)); }
template<class _BI, class _Pd, class _Ty> inline
void _Inplace_merge(_BI _F, _BI _M, _BI _L, _Pd *, _Ty *)
{_Pd _D1 = 0;
_Distance(_F, _M, _D1);
_Pd _D2 = 0;
_Distance(_M, _L, _D2);
_Temp_iterator<_Ty> _Xb(_D1 < _D2 ? _D1 : _D2);
_Buffered_merge(_F, _M, _L, _D1, _D2, _Xb); }
template<class _BI, class _Pd, class _Ty> inline
void _Buffered_merge(_BI _F, _BI _M, _BI _L,
_Pd _D1, _Pd _D2, _Temp_iterator<_Ty>& _Xb)
{if (_D1 == 0 || _D2 == 0)
;
else if (_D1 + _D2 == 2)
{if (*_M < *_F)
iter_swap(_F, _M); }
else if (_D1 <= _D2 && _D1 <= _Xb._Maxlen())
{copy(_F, _M, _Xb._Init());
merge(_Xb._First(), _Xb._Last(), _M, _L, _F); }
else if (_D2 <= _Xb._Maxlen())
{copy(_M, _L, _Xb._Init());
_Merge_backward(_F, _M, _Xb._First(), _Xb._Last(), _L); }
else
{_BI _Fn, _Ln;
_Pd _D1n = 0;
_Pd _D2n = 0;
if (_D2 < _D1)
{_D1n = _D1 / 2;
_Fn = _F;
advance(_Fn, _D1n);
_Ln = lower_bound(_M, _L, _Ty(*_Fn));
_Distance(_M, _Ln, _D2n); }
else
{_D2n = _D2 / 2;
_Ln = _M;
advance(_Ln, _D2n);
_Fn = upper_bound(_F, _M, _Ty(*_Ln));
_Distance(_F, _Fn, _D1n); }
_BI _Mn = _Buffered_rotate(_Fn, _M, _Ln,
_D1 - _D1n, _D2n, _Xb);
_Buffered_merge(_F, _Fn, _Mn, _D1n, _D2n, _Xb);
_Buffered_merge(_Mn, _Ln, _L,
_D1 - _D1n, _D2 - _D2n, _Xb); }}
template<class _BI1, class _BI2, class _BI3> inline
_BI3 _Merge_backward(_BI1 _F1, _BI1 _L1, _BI2 _F2, _BI2 _L2,
_BI3 _X)
{for (; ; )
if (_F1 == _L1)
return (copy_backward(_F2, _L2, _X));
else if (_F2 == _L2)
return (copy_backward(_F1, _L1, _X));
else if (*--_L2 < *--_L1)
*--_X = *_L1, ++_L2;
else
*--_X = *_L2, ++_L1; }
template<class _BI, class _Pd, class _Ty> inline
_BI _Buffered_rotate(_BI _F, _BI _M, _BI _L,
_Pd _D1, _Pd _D2, _Temp_iterator<_Ty>& _Xb)
{if (_D1 <= _D2 && _D1 <= _Xb._Maxlen())
{copy(_F, _M, _Xb._Init());
copy(_M, _L, _F);
return (copy_backward(_Xb._First(), _Xb._Last(), _L)); }
else if (_D2 <= _Xb._Maxlen())
{copy(_M, _L, _Xb._Init());
copy_backward(_F, _M, _L);
return (copy(_Xb._First(), _Xb._Last(), _F)); }
else
{rotate(_F, _M, _L);
advance(_F, _D2);
return (_F); }}
// TEMPLATE FUNCTION inplace_merge WITH PRED
template<class _BI, class _Pr> inline
void inplace_merge(_BI _F, _BI _M, _BI _L, _Pr _P)
{if (_F != _L)
_Inplace_merge(_F, _M, _L, _P,
_Dist_type(_F), _Val_type(_F)); }
template<class _BI, class _Pd, class _Ty, class _Pr> inline
void _Inplace_merge(_BI _F, _BI _M, _BI _L, _Pr _P,
_Pd *, _Ty *)
{_Pd _D1 = 0;
_Distance(_F, _M, _D1);
_Pd _D2 = 0;
_Distance(_M, _L, _D2);
_Temp_iterator<_Ty> _Xb(_D1 < _D2 ? _D1 : _D2);
_Buffered_merge(_F, _M, _L, _D1, _D2, _Xb, _P); }
template<class _BI, class _Pd, class _Ty, class _Pr> inline
void _Buffered_merge(_BI _F, _BI _M, _BI _L,
_Pd _D1, _Pd _D2, _Temp_iterator<_Ty>& _Xb, _Pr _P)
{if (_D1 == 0 || _D2 == 0)
;
else if (_D1 + _D2 == 2)
{if (_P(*_M, *_F))
iter_swap(_F, _M); }
else if (_D1 <= _D2 && _D1 <= _Xb._Maxlen())
{copy(_F, _M, _Xb._Init());
merge(_Xb._First(), _Xb._Last(), _M, _L, _F, _P); }
else if (_D2 <= _Xb._Maxlen())
{copy(_M, _L, _Xb._Init());
_Merge_backward(_F, _M, _Xb._First(), _Xb._Last(),
_L, _P); }
else
{_BI _Fn, _Ln;
_Pd _D1n = 0;
_Pd _D2n = 0;
if (_D2 < _D1)
{_D1n = _D1 / 2;
_Fn = _F;
advance(_Fn, _D1n);
_Ln = lower_bound(_M, _L, _Ty(*_Fn), _P);
_Distance(_M, _Ln, _D2n); }
else
{_D2n = _D2 / 2;
_Ln = _M;
advance(_Ln, _D2n);
_Fn = upper_bound(_F, _M, _Ty(*_Ln), _P);
_Distance(_F, _Fn, _D1n); }
_BI _Mn = _Buffered_rotate(_Fn, _M, _Ln,
_D1 - _D1n, _D2n, _Xb);
_Buffered_merge(_F, _Fn, _Mn, _D1n, _D2n, _Xb, _P);
_Buffered_merge(_Mn, _Ln, _L,
_D1 - _D1n, _D2 - _D2n, _Xb, _P); }}
template<class _BI1, class _BI2, class _BI3, class _Pr> inline
_BI3 _Merge_backward(_BI1 _F1, _BI1 _L1, _BI2 _F2, _BI2 _L2,
?? 快捷鍵說明
復制代碼
Ctrl + C
搜索代碼
Ctrl + F
全屏模式
F11
切換主題
Ctrl + Shift + D
顯示快捷鍵
?
增大字號
Ctrl + =
減小字號
Ctrl + -