针对二维坐标系上的点，定义一个点类，实现简单的数据输入输出

好的，下面是一个简单的点类的实现示例：

class Point:
    def __init__(self, x=0, y=0):
        self.x = x
        self.y = y

    def input(self):
        self.x = float(input("请输入点的 x 坐标："))
        self.y = float(input("请输入点的 y 坐标："))

    def output(self):
        print("该点的坐标为：({:.2f}, {:.2f})".format(self.x, self.y))

这个点类有两个属性：x 和 y，分别表示点在二维坐标系上的横纵坐标。类中的 input 方法用于输入点的坐标，output 方法用于输出点的坐标。在 input 方法中，我们使用 float 函数将输入的字符串转换成浮点数类型。

使用示例：

# 创建一个点对象
p = Point()

# 输入点的坐标
p.input()

# 输出点的坐标
p.output()

示例输出：

请输入点的 x 坐标：3.14
请输入点的 y 坐标：2.71
该点的坐标为：(3.14, 2.71)

相关问题

定义Point类实现三维坐标点。定义dist_from方法实现两点之间距离的计算。 【输入形式】输入两行，第一行是第一个点的坐标值，第二行是第二个点的坐标值。坐标值x, y, z之间用空格隔开。 【输出形式】距离 【样例输入】 0 0 0 1 1 1 【样例输出】 1.73205

好的，我来帮你解答这个问题。

可以按照以下的代码实现：

import math

class Point:
    def __init__(self, x=0, y=0, z=0):
        self.x = x
        self.y = y
        self.z = z

    def dist_from(self, other):
        dx = self.x - other.x
        dy = self.y - other.y
        dz = self.z - other.z
        return math.sqrt(dx ** 2 + dy ** 2 + dz ** 2)

if __name__ == '__main__':
    p1 = Point(*map(float, input().split()))
    p2 = Point(*map(float, input().split()))
    print('{:.5f}'.format(p1.dist_from(p2)))

在这个代码中，我们定义了一个`Point`类，用于表示三维坐标系中的点。类中包含了`x`、`y`、`z`三个属性，分别表示点在x轴、y轴、z轴上的坐标。

`dist_from`方法用于计算当前点与另一个点之间的距离。它接受一个`other`参数，用于表示另一个点，计算公式为：$\sqrt{(x_1-x_2)^2+(y_1-y_2)^2+(z_1-z_2)^2}$。

在程序的主函数中，我们先读取两个点的坐标，然后实例化两个`Point`对象，最后调用`dist_from`方法计算距离并输出结果。

用禁忌搜索算法解决TSP问题，c++实现，每个节点用二维坐标系表示

好的，禁忌搜索算法可以用来解决TSP问题，以下是C++实现的示例代码：

#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <ctime>
#include <cstdlib>

using namespace std;

const int MAXN = 100;

// 城市的数量
int n;
// 城市的坐标
int x[MAXN], y[MAXN];
// 最优路径和距离
vector<int> bestPath;
double bestDistance;

// 计算两个城市之间的距离
double dist(int i, int j) {
    return sqrt((x[i]-x[j])*(x[i]-x[j]) + (y[i]-y[j])*(y[i]-y[j]));
}

// 计算一条路径的总距离
double getPathDistance(const vector<int>& path) {
    double distance = 0.0;
    for (int i = 0; i < n; ++i) {
        distance += dist(path[i], path[(i+1)%n]);
    }
    return distance;
}

// 生成一个初始解
vector<int> generateInitialPath() {
    vector<int> path(n);
    for (int i = 0; i < n; ++i) {
        path[i] = i;
    }
    random_shuffle(path.begin(), path.end());
    return path;
}

// 交换路径中的两个城市
void swapCities(vector<int>& path, int i, int j) {
    swap(path[i], path[j]);
}

// 禁忌搜索算法
void tabuSearch(int maxIter, int tabuSize) {
    // 初始化当前路径和最优路径
    vector<int> currentPath = generateInitialPath();
    bestPath = currentPath;
    bestDistance = getPathDistance(currentPath);

    // 初始化禁忌表
    vector<vector<int>> tabuList(n, vector<int>(n, 0));

    for (int iter = 1; iter <= maxIter; ++iter) {
        // 选择最好的相邻解
        int bestI = -1, bestJ = -1;
        double bestDelta = 1e9;
        for (int i = 0; i < n; ++i) {
            for (int j = i+1; j < n; ++j) {
                // 计算交换位置i和j的路径长度变化
                double delta = dist(currentPath[i], currentPath[j])
                             + dist(currentPath[(i+1)%n], currentPath[(j+1)%n])
                             - dist(currentPath[i], currentPath[(i+1)%n])
                             - dist(currentPath[j], currentPath[(j+1)%n]);
                // 如果这个交换比当前最好的还要好，且不在禁忌表中，就更新最好的交换位置
                if (delta < bestDelta && tabuList[i][j] == 0) {
                    bestDelta = delta;
                    bestI = i;
                    bestJ = j;
                }
            }
        }

        // 更新当前路径和最优路径
        swapCities(currentPath, bestI, bestJ);
        double currentDistance = getPathDistance(currentPath);
        if (currentDistance < bestDistance) {
            bestPath = currentPath;
            bestDistance = currentDistance;
        }

        // 将这个交换加入禁忌表
        tabuList[bestI][bestJ] = tabuList[bestJ][bestI] = tabuSize;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                if (tabuList[i][j] > 0) {
                    tabuList[i][j]--;
                }
            }
        }
    }
}

int main() {
    srand(time(NULL));

    // 输入城市的数量和坐标
    cin >> n;
    for (int i = 0; i < n; ++i) {
        cin >> x[i] >> y[i];
    }

    // 运行禁忌搜索算法，输出最优路径和距离
    tabuSearch(1000, n/2);
    cout << "Best path:\n";
    for (int i = 0; i < n; ++i) {
        cout << bestPath[i] << " ";
    }
    cout << "\nBest distance: " << bestDistance << endl;

    return 0;
}

这段代码中，我们定义了一个`tabuSearch()`函数来实现禁忌搜索算法，其中`maxIter`表示最大迭代次数，`tabuSize`表示禁忌表的大小。函数中首先生成一个初始路径，然后不断迭代，每次选择最好的相邻解并更新路径和禁忌表，直到达到最大迭代次数为止。最后输出最优路径和距离。

在`tabuSearch()`函数中，我们使用了一个二维数组`tabuList`来表示禁忌表，其中`tabuList[i][j]`表示位置i和j是否在禁忌表中。在每次更新路径和禁忌表时，我们将这个交换加入禁忌表，并将禁忌表中的所有交换次数减1，以保证交换不会一直在禁忌表中。