**【问题描述】** 请编写一个程序，输入整数 m 和 n，计算 m 到 n 之间（包含 m 和 n）偶整数的和。 **【输入形式】** 两个整数 m 和 n。 **【输出形式】** 在提示信息后输出求得的和。

以下是 Python3 的代码实现：

m, n = map(int, input().split())
if m % 2 != 0:
    m += 1  # 如果 m 是奇数，就将 m 加 1，变为偶数
if n % 2 != 0:
    n -= 1  # 如果 n 是奇数，就将 n 减 1，变为偶数
sum = (m + n) * ((n - m) // 2 + 1) // 2  # 使用等差数列求和公式计算偶数的和
print(sum)

代码说明：

1. 首先通过 `input()` 函数获取两个整数 m 和 n，使用 `map()` 函数将输入的字符串转换为整数并分别赋值给变量 m 和 n。
2. 判断 m 和 n 是否为偶数，如果不是偶数，则将它们分别加 1 和减 1，使它们变为偶数。
3. 使用等差数列求和公式计算 m 到 n 之间偶数的和，并将结果赋值给变量 `sum`。
4. 最后使用 `print()` 函数输出求得的和。

相关问题

用Java语言编写程序计算带权无向树中两结点的最大长度，输入：第一行是两个以空格符分隔的整数n和m；接下来的第二行到第m+1行，每行包含4个以空格分开的元素x，y，w和d来描述一条道路，其中x和y是一条长度为w的道路相连的两个农场的编号，d是字符N.E.S.或W，表示从x到y的道路的方向。 输出：给出最远的一对农场之间距离的整数。

好的，我可以为您解答这个问题。下面是一个可能的实现方法：

首先，我们需要定义一个节点类来表示带权无向树中的每个节点：

class Node {
    int id;         // 节点的编号
    int weight;     // 节点的权重
    List<Edge> edges;   // 节点所连接的边

    public Node(int id, int weight) {
        this.id = id;
        this.weight = weight;
        this.edges = new ArrayList<Edge>();
    }
}

同时，我们需要定义一个边类来表示每条边：

class Edge {
    Node from;      // 边的起始节点
    Node to;        // 边的终止节点
    int length;     // 边的长度

    public Edge(Node from, Node to, int length) {
        this.from = from;
        this.to = to;
        this.length = length;
    }
}

接下来，我们可以定义一个带权无向树类来存储整个树的信息：

class WeightedUndirectedTree {
    List<Node> nodes;   // 树的所有节点
    List<Edge> edges;   // 树的所有边

    public WeightedUndirectedTree() {
        this.nodes = new ArrayList<Node>();
        this.edges = new ArrayList<Edge>();
    }

    // 添加节点
    public void addNode(Node node) {
        this.nodes.add(node);
    }

    // 添加边
    public void addEdge(Edge edge) {
        this.edges.add(edge);
        edge.from.edges.add(edge);
        edge.to.edges.add(edge);
    }
}

有了上述的类定义，我们就可以开始编写计算最大长度的算法了。具体实现方法如下：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        // 读入n和m
        int n = sc.nextInt();
        int m = sc.nextInt();

        // 创建带权无向树
        WeightedUndirectedTree tree = new WeightedUndirectedTree();
        for (int i = 1; i <= n; i++) {
            tree.addNode(new Node(i, 0));
        }

        // 读入边列表并添加到树中
        for (int i = 0; i < m; i++) {
            int x = sc.nextInt();
            int y = sc.nextInt();
            int w = sc.nextInt();
            String d = sc.next();

            Node from = tree.nodes.get(x - 1);
            Node to = tree.nodes.get(y - 1);
            int length = w;
            if (d.equals("N") || d.equals("S")) {
                length *= 2;
            }
            tree.addEdge(new Edge(from, to, length));
        }

        // 计算最大距离
        int maxDistance = getMaxDistance(tree);
        System.out.println(maxDistance);
    }

    public static int getMaxDistance(WeightedUndirectedTree tree) {
        int[] maxDistance = new int[1];
        dfs(tree.nodes.get(0), null, 0, maxDistance);
        return maxDistance[0];
    }

    private static void dfs(Node node, Node parent, int distance, int[] maxDistance) {
        maxDistance[0] = Math.max(maxDistance[0], distance);
        for (Edge edge : node.edges) {
            Node child = edge.from == node ? edge.to : edge.from;
            if (child != parent) {
                dfs(child, node, distance + edge.length, maxDistance);
            }
        }
    }
}

在上述算法中，我们首先读入输入数据，然后将边列表添加到带权无向树中。之后，我们对树进行一次深度优先搜索，计算出从根节点到每个叶子节点的最大距离。具体实现方法是通过递归的方式，依次遍历每个子节点，如果子节点不是当前节点的父节点，则递归计算子节点的最大距离，并将其加上当前节点到子节点的距离，更新最大距离值。搜索结束后，最大距离值就是带权无向树中任意两个节点的最大长度。

当然，上述算法中还有一些细节需要注意，比如遍历子节点时需要排除父节点，计算距离时需要考虑边的长度和方向等等。但是总体来说，这个算法还是比较简单的，可以用来解决大部分带权无向树相关的问题。

题目描述 春节到了，小从要给亲戚送年货，一直小从在编号为1的位置，他一共给n-1家亲戚送年货，由于每家要给的东西较多，所以每送一家，小从都需要回家再拿一份年货。现在我们给每家亲戚编号为2—n, 这些亲戚直接有m条道路相连，每条道路的距离为s。请你帮小从计算一些，送完所有年货，他一共要走多少路。 输入格式 第一行包含两个这个数n和m，（1<n<30） 接下来有m行，每行包含3个整数，x,y,s分别表示从编号x到编号y的距离是s. 输出格式 一个整数，表示小童走的路程。

这道题的意思是，给出一张无向图，其中有 n 个点和 m 条边，点的编号从 1 到 n。需要计算从点 1 出发，经过其他所有点后再回到点 1 时走过的路径长度。你需要编写一个程序来计算这个路径长度。

输入的第一行包含两个整数 n 和 m，表示点的数量和边的数量。接下来的 m 行，每行包含三个整数 x、y 和 s，表示存在一条从点 x 到点 y 的路径，长度为 s。

输出一个整数，表示从点 1 出发，经过其他所有点后再回到点 1 时走过的路径长度。

示例

输入：
4 4
1 2 1
2 3 1
3 1 1
1 4 1
输出：
4