From 1eb2c4e3039a9e2f2c474ea8ab7703468d698442 Mon Sep 17 00:00:00 2001
From: unlockable <g@unlockableworld.com>
Date: Mon, 22 Jan 2024 22:04:29 +0100
Subject: [PATCH] 80.

---
 2023210/input.txt |  1 +
 2023210/main.cpp  | 93 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 94 insertions(+)
 create mode 100644 2023210/input.txt
 create mode 100644 2023210/main.cpp

diff --git a/2023210/input.txt b/2023210/input.txt
new file mode 100644
index 0000000..5a2d1bd
--- /dev/null
+++ b/2023210/input.txt
@@ -0,0 +1 @@
+3 3 1 1 2 1 2 3 10 3 4
\ No newline at end of file
diff --git a/2023210/main.cpp b/2023210/main.cpp
new file mode 100644
index 0000000..3684771
--- /dev/null
+++ b/2023210/main.cpp
@@ -0,0 +1,93 @@
+#include <stdio.h>
+
+struct CalcResult {
+    int dim_sizes[32];
+    int min_multiply_times;
+};
+
+unsigned short *tensors;
+// unsigned short tensors[66000];
+int n = 0, k = 0;
+CalcResult *m;
+// CalcResult m[10000];
+// int * m;
+
+int tensor_pos(int num, int dim) {
+    return k * num + dim;
+}
+
+int setm(int i, int j, int num, int *dims) {
+    if (j < i) {
+        return 0;
+    }
+
+    m[(2 * n - i + 1) * i / 2 + j - i].min_multiply_times = num;
+    for (int i = 0; i < k - 2; i++) {
+        m[(2 * n - i + 1) * i / 2 + j - i].dim_sizes[i] = dims[i];
+    }
+
+    return m[(2 * n - i + 1) * i / 2 + j - i].min_multiply_times;
+}
+
+CalcResult getm(int i, int j) {
+    if (j <= i) {
+        return CalcResult{{0}, 0};
+    }
+
+    return m[(2 * n - i + 1) * i / 2 + j - i];
+}
+
+CalcResult find_min(int start, int end) {
+    if (start == end || getm(start, end).min_multiply_times != 0) {
+        return getm(start, end);
+    }
+
+    int min = 2147483647;
+    int needed_multiply_by_d = 1;
+
+    // prepare the dims
+    int segment_dim_size[32] = {0};
+    for (int dim = 0; dim < k - 2; dim++) {
+        for (int tens = start; tens <= end; tens++) {
+            int d_k = tensors[tensor_pos(tens, dim)];
+            if (d_k != 1) {
+                needed_multiply_by_d *= d_k;
+                segment_dim_size[dim] = d_k;
+                break;
+            }
+            segment_dim_size[dim] = 1;
+        }
+    }
+
+    for (int split_pos = start; split_pos < end; split_pos++) {
+        // int a = tensors[tensor_pos(start, k - 2)];
+        // a = tensors[tensor_pos(split_pos, k - 1)];
+        // a = tensor_pos(end, k - 1);
+        int total_needed = tensors[tensor_pos(start, k - 2)] *
+                           tensors[tensor_pos(split_pos, k - 1)] * tensors[tensor_pos(end, k - 1)] *
+                           needed_multiply_by_d;
+        CalcResult left = find_min(start, split_pos), right = find_min(split_pos + 1, end);
+        total_needed += left.min_multiply_times + right.min_multiply_times;
+        if (total_needed < min) {
+            min = total_needed;
+        }
+    }
+
+    setm(start, end, min, segment_dim_size);
+    return getm(start, end);
+}
+
+int main() {
+    scanf("%d %d", &n, &k);
+    tensors = new unsigned short[n * k];
+    m = new CalcResult[(n + 1) * n / 2];
+    for (int tensor_count = 0; tensor_count < n; tensor_count++) {
+        for (int dim = 0; dim < k; dim++) {
+            scanf("%hu", &tensors[tensor_pos(tensor_count, dim)]);
+        }
+    }
+
+    printf("%d\n", find_min(0, n - 1).min_multiply_times);
+
+    return 0;
+}
\ No newline at end of file