хочу чтобы в этом коде спользовалась нечеткая логика принципа минимакс или максимин:
using System;
using System.Collections.Generic;
using System.Linq;

namespace FuzzyLogicMarriage
{
    class Program
    {
        static void Main(string[] args)
        {
            // Участники
            string[] men = { "Эд", "Фрэнк", "Джордж", "Гарри" };
            string[] women = { "Бетти", "Алиса", "Дороти", "Кэрол" };

            // Генерация всех возможных перестановок жен
            var marriagePermutations = GetPermutations(women, women.Length).ToList();

            // Для хранения вероятностей браков и танцев
            Dictionary<(string man, string woman), double> marriageProbabilities = new Dictionary<(string, string), double>();
            Dictionary<(string man, string woman), double> danceProbabilities = new Dictionary<(string, string), double>();

            // Инициализация вероятностей браков
            InitializeMarriageProbabilities(marriageProbabilities);

            // Инициализация вероятностей танцев
            InitializeDanceProbabilities(danceProbabilities);

            List<(Dictionary<string, string> marriageMap, Dictionary<string, string> danceMap, double finalProbability)> solutions = new();

            foreach (var marriage in marriagePermutations)
            {
                // Заполняем карту браков для текущей перестановки
                Dictionary<string, string> marriageMap = new Dictionary<string, string>();
                for (int i = 0; i < men.Length; i++)
                {
                    marriageMap[men[i]] = marriage[i];
                }

                // Проверяем браки
                double totalMarriageProbability = 0;

                for (int i = 0; i < men.Length; i++)
                {
                    var key = (men[i], marriage[i]);
                    totalMarriageProbability += marriageProbabilities.ContainsKey(key) ? marriageProbabilities[key] : 0;
                }

                double averageMarriageProbability = totalMarriageProbability / men.Length;

                // Пропускаем, если вероятность браков низкая
                if (averageMarriageProbability < 0.5)
                    continue;

                // Проверяем танцевальные пары
                double totalDanceProbability = 0;
                Dictionary<string, string> danceMap = new Dictionary<string, string>();
                HashSet<string> usedWomen = new HashSet<string>();

                foreach (var man in men)
                {
                    foreach (var woman in women)
                    {
                        // Убедимся, что мужчина не танцует с женой и женщина ещё не танцевала
                        if (marriageMap.ContainsKey(man) && marriageMap[man] == woman || usedWomen.Contains(woman))
                            continue;

                        // Проверяем вероятность танцев
                        if (danceProbabilities.ContainsKey((man, woman)))
                        {
                            totalDanceProbability += danceProbabilities[(man, woman)];
                            danceMap[man] = woman;
                            usedWomen.Add(woman); // Женщина больше не может танцевать
                            break;
                        }
                    }
                }

                double finalProbability = (averageMarriageProbability + totalDanceProbability / men.Length) / 2;

                if (finalProbability >= 0.6)
                {
                    solutions.Add((new Dictionary<string, string>(marriageMap), new Dictionary<string, string>(danceMap), finalProbability));
                }
            }

            // Вывод найденных решений
            if (solutions.Count > 0)
            {
                foreach (var solution in solutions)
                {
                    Console.WriteLine("\n=== Найденное решение ===");
                    Console.WriteLine("Браки:");
                    foreach (var pair in solution.marriageMap)
                    {
                        Console.WriteLine($"{pair.Key} женат на {pair.Value}");
                    }
                    Console.WriteLine("\nТанцевальные пары:");
                    foreach (var pair in solution.danceMap)
                    {
                        Console.WriteLine($"{pair.Key} танцевал с {pair.Value}");
                    }
                    Console.WriteLine($"Итоговая вероятность: {solution.finalProbability:F2}");
                }
            }
            else
            {
                Console.WriteLine("Решение не найдено.");
            }

            Console.WriteLine("\nНажмите любую клавишу, чтобы выйти...");
            Console.ReadKey();
        }

        // Метод для генерации всех перестановок
        static IEnumerable<string[]> GetPermutations(string[] list, int length)
        {
            if (length == 1)
                return list.Select(t => new string[] { t });

            return GetPermutations(list, length - 1)
                .SelectMany(t => list.Where(e => !t.Contains(e)),
                            (t1, t2) => t1.Concat(new string[] { t2 }).ToArray());
        }

        // Инициализация вероятностей браков
        static void InitializeMarriageProbabilities(Dictionary<(string, string), double> marriageProbabilities)
        {
            marriageProbabilities[("Эд", "Бетти")] = 0.0;
            marriageProbabilities[("Эд", "Алиса")] = 0.0;
            marriageProbabilities[("Эд", "Дороти")] = 0.7;
            marriageProbabilities[("Эд", "Кэрол")] = 0.6;

            marriageProbabilities[("Фрэнк", "Бетти")] = 0.1;
            marriageProbabilities[("Фрэнк", "Алиса")] = 0.5;
            marriageProbabilities[("Фрэнк", "Дороти")] = 0.2;
            marriageProbabilities[("Фрэнк", "Кэрол")] = 0.7;

            marriageProbabilities[("Джордж", "Бетти")] = 0.3;
            marriageProbabilities[("Джордж", "Алиса")] = 0.7;
            marriageProbabilities[("Джордж", "Дороти")] = 0.2;
            marriageProbabilities[("Джордж", "Кэрол")] = 0.4;

            marriageProbabilities[("Гарри", "Бетти")] = 0.5;
            marriageProbabilities[("Гарри", "Алиса")] = 0.5;
            marriageProbabilities[("Гарри", "Дороти")] = 0.5;
            marriageProbabilities[("Гарри", "Кэрол")] = 0.5;
        }

        // Инициализация вероятностей танцев
        static void InitializeDanceProbabilities(Dictionary<(string, string), double> danceProbabilities)
        {
            danceProbabilities[("Эд", "Бетти")] = 1.0;
            danceProbabilities[("Эд", "Алиса")] = 0.0;
            danceProbabilities[("Эд", "Дороти")] = 0.0;
            danceProbabilities[("Эд", "Кэрол")] = 0.0;

            danceProbabilities[("Фрэнк", "Бетти")] = 0.0;
            danceProbabilities[("Фрэнк", "Алиса")] = 0.9;
            danceProbabilities[("Фрэнк", "Дороти")] = 0.4;
            danceProbabilities[("Фрэнк", "Кэрол")] = 0.8;

            danceProbabilities[("Джордж", "Бетти")] = 0.0;
            danceProbabilities[("Джордж", "Алиса")] = 0.5;
            danceProbabilities[("Джордж", "Дороти")] = 1.0;
            danceProbabilities[("Джордж", "Кэрол")] = 0.4;

            danceProbabilities[("Гарри", "Бетти")] = 0.0;
            danceProbabilities[("Гарри", "Алиса")] = 0.3;
            danceProbabilities[("Гарри", "Дороти")] = 0.5;
            danceProbabilities[("Гарри", "Кэрол")] = 1.0;
        }
    }
}
ВОт пример где работают так с вероятностями и степенями прнадлежности:
#include <iostream>
#include <string>
#include <map>
#include <vector>
#include <windows.h>
#include <algorithm>
using namespace std;
// Хранение степеней принадлежности для фактов
map<string, double> fuzzyFacts;
// Структура правила
struct Rule {
string part1; // условие
string part2; // вывод
double weight; // вес правила (степень уверенности)
};
// База правил
vector<Rule> fuzzyRules;
// Функция для обработки строк
string Trim(string s) {
while (s.length() > 0 && s[0] == ' ') s = s.erase(0, 1);
while (s.length() > 0 && s[s.length() - 1] == ' ') s = s.erase(s.length() - 1, 1);
return s;
}
// Разделение строки по запятой
vector<string> Split(const string& s, char delimiter) {
vector<string> tokens;

size_t start = 0, end = 0;
while ((end = s.find(delimiter, start)) != string::npos) {
tokens.push_back(Trim(s.substr(start, end - start)));
start = end + 1;
}
tokens.push_back(Trim(s.substr(start)));
return tokens;
}
// Проверка факта с учетом степени принадлежности
double GetFactValue(string fact) {
fact = Trim(fact);
if (fuzzyFacts.find(fact) != fuzzyFacts.end()) {
return fuzzyFacts[fact];
}
return 0.0; // Факт отсутствует — принадлежность равна 0
}
// Добавление нового факта
void AddFact(string fact, double value) {
fact = Trim(fact);
fuzzyFacts[fact] = max(fuzzyFacts[fact], value); // Учитываем максимальную принадлежность
}
// Применение правил
void ApplyRules() {
bool updated;
do {
updated = false;
for (const auto& rule : fuzzyRules) {
// Разделяем условия
vector<string> conditions = Split(rule.part1, ',');
double minDegree = 1.0;
// Вычисляем минимальную степень принадлежности среди условий
for (const string& condition : conditions) {
minDegree = min(minDegree, GetFactValue(condition));
}
// Умножаем на вес правила
double conclusionValue = minDegree * rule.weight;
// Добавляем вывод с учетом текущей максимальной степени
if (conclusionValue > GetFactValue(rule.part2)) {
AddFact(rule.part2, conclusionValue);
updated = true;
}
}
} while (updated);
}
// Вывод текущего состояния фактов
void ShowFactsLegacy() {
cout << "\nСостояние рабочей памяти (степени принадлежности):\n";
for (const auto& fact : fuzzyFacts) {
string displayFact = fact.first;
// Заменяем "Лучший" на "Лучшая уверенность"
if (displayFact.find("Лучший") != string::npos) {
displayFact.replace(displayFact.find("Лучший"), 7, "Лучшая уверенность");
}
cout << displayFact << ": " << fact.second << endl;
}
}
// Вывод итогового решения
void ShowBestResults() {

cout << "\nИтоговое решение:\n";
// Храним пары "тип" -> "лучший факт"
map<string, pair<string, double>> bestResults;
for (const auto& fact : fuzzyFacts) {
if (fact.first.find("Лучшая уверенность") == string::npos) {
// Определяем тип человека (имя)
string name = fact.first.substr(0, fact.first.find(" из "));
if (bestResults.find(name) == bestResults.end() || fact.second > bestResults[name].second) {
bestResults[name] = { fact.first, fact.second };
}
}
}
// Выводим лучшие результаты
for (const auto& result : bestResults) {
cout << result.second.first << endl;
}
}
// Главная функция
int main() {
SetConsoleCP(1251);
SetConsoleOutputCP(1251);
// Инициализация фактов
AddFact("Андреев из Вязьмы", 0.5);
AddFact("Андреев из Рославля", 0.9);
AddFact("Борисов из Вязьмы", 0.7);
AddFact("Борисов из Ельни", 1.0);
AddFact("Васильев из Гагарина", 0.85);
AddFact("Григорьев из Вязьмы", 0.75);
AddFact("Данилов из Ярцева", 1.0);
// Добавление правил
fuzzyRules.push_back({ "Андреев из Рославля", "Лучшая уверенность Андреев", 1.0 });
fuzzyRules.push_back({ "Борисов из Ельни", "Лучшая уверенность Борисов", 1.0 });
fuzzyRules.push_back({ "Васильев из Гагарина", "Лучшая уверенность Васильев", 1.0 });
fuzzyRules.push_back({ "Григорьев из Вязьмы", "Лучшая уверенность Григорьев", 1.0 });
fuzzyRules.push_back({ "Данилов из Ярцева", "Лучшая уверенность Данилов", 1.0 });
// Применение правил
ApplyRules();
// Вывод результатов
ShowFactsLegacy();
// Итоговое решение
ShowBestResults();
return 0;
}