csp1111

#include <iostream>
#include <vector>
#include <cmath>
#include <limits>
#include <algorithm>

using namespace std;

struct Location {
    int x, y, z;
};

double distance(const Location& loc1, const Location& loc2) {
    return sqrt(pow(loc1.x - loc2.x, 2) + pow(loc1.y - loc2.y, 2) + pow(loc1.z - loc2.z, 2));
}

void find_best_locations(int m, int n, const vector<Location>& locations, vector<int>& best_combination) {
    double min_distance_sum = numeric_limits<double>::max();

    vector<int> indices(m);
    iota(indices.begin(), indices.end(), 0);
    
    vector<int> combination(n);
    for (int i = 0; i < n; ++i) {
        combination[i] = i;
    }
    
    do {
        double distance_sum = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                distance_sum += pow(distance(locations[combination[i]], locations[combination[j]]), 2);
            }
        }
        
        if (distance_sum < min_distance_sum) {
            min_distance_sum = distance_sum;
            best_combination = combination;
        }
        
        if (combination[0] == m - n) {
            break;
        }

        combination[n - 1]++;
        for (int i = n - 1; i > 0; --i) {
            if (combination[i] == m - (n - i - 1)) {
                combination[i - 1]++;
                for (int j = i; j < n; ++j) {
                    combination[j] = combination[j - 1] + 1;
                }
            }
        }

    } while (combination[0] < m - n + 1);
}

int main() {
    int m, n;
    cin >> m >> n;

    vector<Location> locations(m);
    for (int i = 0; i < m; ++i) {
        cin >> locations[i].x >> locations[i].y >> locations[i].z;
    }

    vector<int> best_combination;
    find_best_locations(m, n, locations, best_combination);
    
    sort(best_combination.begin(), best_combination.end());

    for (size_t i = 0; i < best_combination.size(); ++i) {
        cout << best_combination[i] + 1; // 输出1-based索引
        if (i < best_combination.size() - 1) {
            cout << " ";
        }
    }
    cout << endl;

    return 0;
}