[통산 240편 금자탑 달성 🏆] 초·중·고 정보 과학·자료구조(그래프) 교육과 국방 전술 C4I 다대다 무기-표적 동적 할당(WTA): ZeliDesk의 온디바이스 순수 C# 이분 매칭 헝가리안(Hungarian) 알고리즘, 경매(Auction) 분산 최적화, 0-Alloc SIMD 요격 비용 행렬, 0.1ms KAMD 대공 방어 실시간 타겟 할당 엔진 아키텍처

using System;
using System.Runtime.CompilerServices;

namespace ZeliDesk.Defense.C4I
{
    /// 

    /// ZeliDesk 온디바이스 순수 C# O(N^3) 헝가리안 최적 무기-표적 할당 솔버
    /// 
    public static class HungarianWtaSolver
    {
        public const float Infinity = 1e9f;

        /// 

        /// N개의 대공 무기 플랫폼과 M개의 적 표적 간 최소 비용 완전 매칭 계산 (0-Alloc)
        /// 
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void Solve(
            ReadOnlySpan<float> costMatrix, // N x N 정사각 비용 행렬 (1차원 평탄화)
            int n,
            Span<int> weaponToTargetMatch,  // 결과: 무기 i -> 표적 j
            Span<int> targetToWeaponMatch)  // 결과: 표적 j -> 무기 i
        {
            // 1. 스택 메모리 할당 (최대 64x64 교전 규모 지원, 0-GC)
            Span<float> u = stackalloc float[n + 1];
            Span<float> v = stackalloc float[n + 1];
            Span<int> p = stackalloc int[n + 1];
            Span<int> way = stackalloc int[n + 1];
            Span<float> minv = stackalloc float[n + 1];
            Span<bool> used = stackalloc bool[n + 1];

            p.Clear();
            way.Clear();
            u.Clear();
            v.Clear();

            // 2. 헝가리안 최단 증강 경로 탐색 (1-Indexed)
            for (int i = 1; i <= n; i++)
            {
                p[0] = i;
                int j0 = 0;
                minv.Fill(Infinity);
                used.Clear();

                do
                {
                    used[j0] = true;
                    int i0 = p[j0];
                    float delta = Infinity;
                    int j1 = 0;

                    for (int j = 1; j <= n; j++)
                    {
                        if (!used[j])
                        {
                            float cur = costMatrix[(i0 - 1) * n + (j - 1)] - u[i0] - v[j];
                            if (cur < minv[j])
                            {
                                minv[j] = cur;
                                way[j] = j0;
                            }
                            if (minv[j] < delta)
                            {
                                delta = minv[j];
                                j1 = j;
                            }
                        }
                    }

                    for (int j = 0; j <= n; j++)
                    {
                        if (used[j])
                        {
                            u[p[j]] += delta;
                            v[j] -= delta;
                        }
                        else
                        {
                            minv[j] -= delta;
                        }
                    }

                    j0 = j1;
                } while (p[j0] != 0);

                // 증강 경로 역추적 매칭 갱신
                do
                {
                    int j1 = way[j0];
                    p[j0] = p[j1];
                    j0 = j1;
                } while (j0 != 0);
            }

            // 3. 0-Indexed 변환 및 결과 매핑
            weaponToTargetMatch.Fill(-1);
            for (int j = 1; j <= n; j++)
            {
                int weapon = p[j] - 1;
                int target = j - 1;
                targetToWeaponMatch[target] = weapon;
                weaponToTargetMatch[weapon] = target;
            }
        }
    }
}