2026-02-01：K 因数分解。用go语言，给定两个正整数 n 和 k，要把 n 表示为恰好 k 个正整数相乘的结果（因子允许重复）。在所有满足乘积

package main

import (
    "fmt"
    "math"
    "slices"
)

const mx = 100_001

var divisors [mx][]int

func init() {
    // 预处理每个数的因子
    for i := 1; i < mx; i++ {
        for j := i; j < mx; j += i { // 枚举 i 的倍数 j
            divisors[j] = append(divisors[j], i) // i 是 j 的因子
        }
    }
}

func minDifference(n, k int) (ans []int) {
    minDiff := math.MaxInt
    path := make([]int, k)
    var dfs func(int, int)
    dfs = func(i, n int) {
        if i == k-1 {
            // path[0] 最小，n 最大
            if n-path[0] < minDiff {
                minDiff = n - path[0]
                path[i] = n
                ans = slices.Clone(path)
            }
            return
        }
        for _, d := range divisors[n] { // 枚举 n 的因子 d
            if d*d > n || i > 0 && d-path[0] >= minDiff {
                break
            }
            if i == 0 || d >= path[i-1] {
                path[i] = d // 直接覆盖，无需恢复现场
                dfs(i+1, n/d)
            }
        }
    }
    dfs(0, n)
    return
}

func main() {
    n := 44
    k := 3
    result := minDifference(n, k)
    fmt.Println(result)
}

# -*-coding:utf-8-*-

import math
import sys
from typing import List

MX = 100_001

# 预处理每个数的因子
divisors = [[] for _ in range(MX)]
for i in range(1, MX):
    for j in range(i, MX, i):  # 枚举 i 的倍数 j
        divisors[j].append(i)  # i 是 j 的因子

def min_difference(n: int, k: int) -> List[int]:
    min_diff = float('inf')
    path = [0] * k
    ans = []
    
    def dfs(i: int, current_n: int):
        nonlocal min_diff, ans
        
        if i == k - 1:
            # path[0] 最小，current_n 最大
            if current_n - path[0] < min_diff:
                min_diff = current_n - path[0]
                path[i] = current_n
                ans = path.copy()
            return
        
        # 枚举 current_n 的因子 d
        for d in divisors[current_n]:
            if d * d > current_n or (i > 0 and d - path[0] >= min_diff):
                break
            
            if i == 0 or d >= path[i - 1]:
                path[i] = d  # 直接覆盖，无需恢复现场
                dfs(i + 1, current_n // d)
    
    dfs(0, n)
    return ans

if __name__ == "__main__":
    n = 44
    k = 3
    result = min_difference(n, k)
    print(result)

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
#include <cmath>
using namespace std;

constint MX = 100001;
vector<int> divisors[MX];

// 预处理每个数的因子
void init() {
    for (int i = 1; i < MX; i++) {
        for (int j = i; j < MX; j += i) { // 枚举 i 的倍数 j
            divisors[j].push_back(i);     // i 是 j 的因子
        }
    }
}

void dfs(int i, int n, int k, int& minDiff, vector<int>& path, vector<int>& ans) {
    if (i == k - 1) {
        // path[0] 最小，n 最大
        if (n - path[0] < minDiff) {
            minDiff = n - path[0];
            path[i] = n;
            ans = path;
        }
        return;
    }

    for (int d : divisors[n]) { // 枚举 n 的因子 d
        if (d * d > n || (i > 0 && d - path[0] >= minDiff)) {
            break;
        }
        if (i == 0 || d >= path[i - 1]) {
            path[i] = d; // 直接覆盖，无需恢复现场
            dfs(i + 1, n / d, k, minDiff, path, ans);
        }
    }
}

vector<int> minDifference(int n, int k) {
    vector<int> ans;
    int minDiff = INT_MAX;
    vector<int> path(k);

    dfs(0, n, k, minDiff, path, ans);
    return ans;
}

int main() {
    init();

    int n = 44;
    int k = 3;
    vector<int> result = minDifference(n, k);

    for (int num : result) {
        cout << num << " ";
    }
    cout << endl;

    return0;
}