1. 程式人生 > >給定一個數組,求其某個子區間,該區間和最大

給定一個數組,求其某個子區間,該區間和最大

#include<iostream>
#include<vector>
#include<iterator>
#include<type_traits>
#include<ctime>
#include<random>
#include<functional>

template<class _Countable_Ty, class _Iterator_Ty>
class Record final {
public:
	_Iterator_Ty _Estimated_Begin;
	_Iterator_Ty _Estimated_End;
	_Countable_Ty _Estimated_Count;
private:
	_Iterator_Ty _Truth_Begin;
	_Iterator_Ty _Truth_End;
	_Countable_Ty _Truth_Count;
public:
	Record() {}
	~Record() {}
public:
	void push() {
		_Truth_Begin = _Estimated_Begin;
		_Truth_End = _Estimated_End;
		_Truth_Count = _Estimated_Count;
	}
	const _Iterator_Ty& cTruthBegin() const {
		return _Truth_Begin;
	}
	const _Iterator_Ty& cTruthEnd() const {
		return _Truth_End;
	}
	const _Countable_Ty& cTruthCount() const {
		return _Truth_Count;
	}
};

class MaximumSubRange {
public:
	template<class iterator_type>
	Record<typename std::iterator_traits<iterator_type>::value_type, iterator_type>
		operator()(iterator_type BeginIter, iterator_type EndIter) {
		using value_type = typename std::iterator_traits<iterator_type>::value_type;
		using record_type = Record<value_type, iterator_type>;

		std::function<iterator_type(iterator_type, iterator_type)> _FindValueableFirst = std::bind(
			[](iterator_type BeginIter, iterator_type EndIter) -> iterator_type {
			while (BeginIter != EndIter && *BeginIter < 0)
				++BeginIter;
			return BeginIter;
		}, std::placeholders::_1, std::placeholders::_2);
		record_type _Record;

		_Record._Estimated_Count = 0;
		if ((_Record._Estimated_Begin = _FindValueableFirst(BeginIter, EndIter)) == EndIter)
			_Record._Estimated_End = EndIter;
		else {
			_Record._Estimated_Count += *_Record._Estimated_Begin;
			_Record._Estimated_End = std::next(_Record._Estimated_Begin);
		}
		_Record.push();
		while (_Record._Estimated_End != EndIter) {
			_Record._Estimated_Count += *(_Record._Estimated_End++);
			if (_Record._Estimated_Count < 0) {
				if ((_Record._Estimated_Begin = _FindValueableFirst(_Record._Estimated_End, EndIter)) == EndIter)
					break;
				_Record._Estimated_Count = *_Record._Estimated_Begin;
				_Record._Estimated_End = std::next(_Record._Estimated_Begin);
			}
			if (_Record.cTruthCount() <= _Record._Estimated_Count)
				_Record.push();
		}
		return _Record;
	}
};

void showAlgo(size_t Size) {
	//Macro
	using value_type = double;
	using Container = std::vector<value_type>;
	//Init Variate
	Container Vector;
	Vector.reserve(Size);
	std::default_random_engine Seed((unsigned int)time(NULL));
	std::normal_distribution<value_type> Distribution(1.0, 5.0);
	auto Random = std::bind(Distribution, std::ref(Seed));
	//Assign
	for (size_t i = 0; i < Size; ++i)
		Vector.push_back(Random());
	/*//Output
	std::ostream_iterator<double> OutIter(std::cout, " ");
	std::copy(Vector.begin(), Vector.end(), OutIter);
	std::cout << std::endl;*/
	//Algorithm
	clock_t BnTime, EdTime;
	BnTime = clock();
	auto Get = MaximumSubRange()(Vector.begin(), Vector.end());
	EdTime = clock();
	std::cout << R"(       All Size: )" << Size << std::endl
		      << R"(          Count: )" << Get.cTruthCount() << std::endl
		      << R"(      Begin Pos: )" << std::distance(Vector.begin(), Get.cTruthBegin()) << std::endl
		      << R"(        End Pos: )" << std::distance(Vector.begin(), std::prev(Get.cTruthEnd(), 1)) << std::endl
		      << R"(  Cost Time(ms): )" << EdTime - BnTime << std::endl;
	//End
	return;
}

int main() {
	showAlgo(100000); //10W
	system("pause");
	return 0;
}

修改時間:180522;