mirror of
https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git
synced 2023-10-11 13:05:55 +08:00
4e3abd4601
* [feat/fix/docs]: Improvements in the...
...`backtracking` folder, and minor fixes in the `others/iterative_tree_traversals.cpp` and the `math/check_prime.cpp` files.
* clang-format and clang-tidy fixes for 9cc3951d
Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Co-authored-by: Abhinn Mishra <49574460+mishraabhinn@users.noreply.github.com>
64 lines
2.2 KiB
C++
64 lines
2.2 KiB
C++
/**
|
|
* @file
|
|
* @brief returns which is the longest/shortest number
|
|
* using [minimax](https://en.wikipedia.org/wiki/Minimax) algorithm
|
|
*
|
|
* @details
|
|
* Minimax (sometimes MinMax, MM or saddle point) is a decision rule used in
|
|
* artificial intelligence, decision theory, game theory, statistics,
|
|
* and philosophy for minimizing the possible loss for a worst case (maximum
|
|
* loss) scenario. When dealing with gains, it is referred to as "maximin"—to
|
|
* maximize the minimum gain. Originally formulated for two-player zero-sum game
|
|
* theory, covering both the cases where players take alternate moves and those
|
|
* where they make simultaneous moves, it has also been extended to more complex
|
|
* games and to general decision-making in the presence of uncertainty.
|
|
*
|
|
* @author [Gleison Batista](https://github.com/gleisonbs)
|
|
* @author [David Leal](https://github.com/Panquesito7)
|
|
*/
|
|
#include <algorithm> /// for std::max, std::min
|
|
#include <array> /// for std::array
|
|
#include <cmath> /// for log2
|
|
#include <iostream> /// for IO operations
|
|
|
|
/**
|
|
* @namespace backtracking
|
|
* @brief Backtracking algorithms
|
|
*/
|
|
namespace backtracking {
|
|
/**
|
|
* @brief Check which is the maximum/minimum number in the array
|
|
* @param depth current depth in game tree
|
|
* @param node_index current index in array
|
|
* @param is_max if current index is the longest number
|
|
* @param scores saved numbers in array
|
|
* @param height maximum height for game tree
|
|
* @returns the maximum or minimum number
|
|
*/
|
|
template <size_t T>
|
|
int minimax(int depth, int node_index, bool is_max,
|
|
const std::array<int, T> &scores, double height) {
|
|
if (depth == height) {
|
|
return scores[node_index];
|
|
}
|
|
|
|
int v1 = minimax(depth + 1, node_index * 2, !is_max, scores, height);
|
|
int v2 = minimax(depth + 1, node_index * 2 + 1, !is_max, scores, height);
|
|
|
|
return is_max ? std::max(v1, v2) : std::min(v1, v2);
|
|
}
|
|
} // namespace backtracking
|
|
|
|
/**
|
|
* @brief Main function
|
|
* @returns 0 on exit
|
|
*/
|
|
int main() {
|
|
std::array<int, 8> scores = {90, 23, 6, 33, 21, 65, 123, 34423};
|
|
double height = log2(scores.size());
|
|
|
|
std::cout << "Optimal value: "
|
|
<< backtracking::minimax(0, 0, true, scores, height) << std::endl;
|
|
return 0;
|
|
}
|