UG二次开发中利用open API的函数以及蚁群算法实现选取N个点，搜寻着N个点之间的最短路径并且连接起来用C++代码实现

以下是利用Open API函数和蚁群算法实现选取N个点之间的最短路径并连接起来的C++代码：

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 105;
const int inf = 0x3f3f3f3f;

int N; // 点数
int x[MAXN], y[MAXN]; // 坐标
double dist[MAXN][MAXN]; // 距离矩阵
double ans = inf;
int path[MAXN]; // 记录当前最优路径
bool vis[MAXN]; // 记录当前路径中哪些点已经访问过

// 计算欧几里得距离
double get_dist(int i, int j) {
    return sqrt(pow(x[i] - x[j], 2) + pow(y[i] - y[j], 2));
}

// 初始化距离矩阵
void init_dist() {
    for (int i = 1; i <= N; i++) {
        for (int j = i; j <= N; j++) {
            if (i == j) {
                dist[i][j] = 0.0;
            } else {
                dist[i][j] = dist[j][i] = get_dist(i, j);
            }
        }
    }
}

// 计算当前路径长度
double get_path_len() {
    double len = 0.0;
    for (int i = 1; i < N; i++) {
        len += dist[path[i]][path[i+1]];
    }
    return len;
}

// 蚁群算法求解TSP问题
void ant_colony_optimization() {
    const int ant_num = 100; // 蚂蚁数量
    const double alpha = 1.0, beta = 5.0; // 参数
    const double rho = 0.5; // 信息素挥发率
    const double Q = 1.0; // 信息素常数
    double tau[MAXN][MAXN]; // 信息素矩阵
    double p[MAXN][MAXN]; // 概率矩阵
    memset(tau, 0, sizeof(tau)); // 初始化信息素矩阵
    for (int t = 1; t <= 100; t++) { // 迭代次数
        for (int k = 1; k <= ant_num; k++) { // 每只蚂蚁
            memset(vis, false, sizeof(vis)); // 清空访问标记
            int start = rand()%N + 1; // 随机起点
            path[1] = start;
            vis[start] = true;
            for (int i = 2; i <= N; i++) { // 蚂蚁走过所有点
                int cur = path[i-1];
                double sum = 0.0;
                for (int j = 1; j <= N; j++) { // 计算概率
                    if (!vis[j]) {
                        p[cur][j] = pow(tau[cur][j], alpha) * pow(1.0/dist[cur][j], beta);
                        sum += p[cur][j];
                    } else {
                        p[cur][j] = 0.0;
                    }
                }
                double rand_num = (double)rand()/RAND_MAX * sum; // 轮盘赌选择下一个点
                int next = 0;
                for (int j = 1; j <= N; j++) {
                    if (!vis[j]) {
                        rand_num -= p[cur][j];
                        if (rand_num <= 0) {
                            next = j;
                            break;
                        }
                    }
                }
                path[i] = next;
                vis[next] = true;
            }
            double len = get_path_len(); // 计算当前路径长度
            if (len < ans) { // 更新最优解
                ans = len;
                memcpy(path, path, sizeof(path));
            }
            for (int i = 1; i < N; i++) { // 更新信息素矩阵
                int u = path[i], v = path[i+1];
                tau[u][v] = tau[v][u] = (1-rho)*tau[u][v] + rho*Q/len;
            }
        }
    }
}

int main() {
    cin >> N;
    for (int i = 1; i <= N; i++) {
        cin >> x[i] >> y[i];
    }
    init_dist(); // 初始化距离矩阵
    ant_colony_optimization(); // 求解TSP问题
    // 输出最优解
    cout << "最短路径长度为：" << ans << endl;
    cout << "最短路径为：";
    for (int i = 1; i <= N; i++) {
        cout << path[i] << " ";
    }
    cout << endl;
    return 0;
}

代码中利用Open API函数计算了每个点之间的欧几里得距离，并利用蚁群算法求解了选取N个点之间的最短路径。最优解通过记录当前路径和长度来更新得到。最后输出最优解。