请用正确的格式再发一遍我上面向你请求的代码

当然，下面是使用 MATLAB 语言实现的代码：

for v = 1:N
    for w = 1:N
        if w == v
            continue;
        else
            if d(u,v) > max(d(u,w),d(v,w))
                E(u,v) = 0; % eliminate edge (u,v)
                break;
            end
        end
    end
end

其中，`N` 是节点数目，`d` 是节点之间的距离矩阵，`u` 是当前考虑的节点，`E` 是边矩阵，`E(u,v)` 表示节点 `u` 和节点 `v` 之间是否存在边。在代码中，通过双重循环枚举每一对节点 `v` 和 `w`，并判断是否满足条件，如果满足则将边 `(u,v)` 删去。注意，使用 `break` 可以提高程序效率，避免不必要的计算。

相关问题

你可以把刚才给我的代码用代码格式再发一遍吗

当然可以，下面是完整的代码，包括将经过的边的编号写入Excel的部分：

import pandas as pd 
import numpy as np 
import networkx as nx 
import matplotlib.pyplot as plt 

df = pd.read_excel(r"C:\Users\li'yi'jie\Desktop\运筹学网络规划数据.xlsx") 

edges = [] 
for i in range(len(df)): 
    edge = { "id": df.loc[i, "边的编号"], 
             "tail": df.loc[i, "边的尾节点"], 
             "head": df.loc[i, "边的头节点"], 
             "length": df.loc[i, "长度"], 
             "capacity": df.loc[i, "容量"] } 
    edges.append(edge) 

plt.figure(figsize=(15,15)) 

G = nx.DiGraph() 

for edge in edges: 
    G.add_edge(edge["tail"], edge["head"], weight=edge["length"], id=edge["id"]) 

all_pairs = dict(nx.all_pairs_dijkstra_path(G, weight='weight')) 

rows = [] 
for start_node, dist_dict in all_pairs.items(): 
    for end_node, path in dist_dict.items(): 
        path_edges = []
        for i in range(len(path)-1):
            edge_id = G[path[i]][path[i+1]]['id']
            path_edges.append(edge_id)
        rows.append({'起始节点': start_node, '终止节点': end_node, '最短路径长度': dist_dict[end_node], '经过的边': path_edges}) 

df_result = pd.DataFrame(rows) 
df_result.to_excel('all_pairs.xlsx', index=False)

请再发一遍

好的，以下是可能的 Java 代码实现：

import java.time.LocalTime;
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String workTimeStr = "13:00-14:00;16:00-18:00";
        String availableTimeStr = "13:58-14:00;16:00-16:02";

        List<TimePeriod> workTime = parseTimeStr(workTimeStr);
        List<TimePeriod> availableTime = parseTimeStr(availableTimeStr);

        boolean hasAdjacentTime = false;
        for (int i = 0; i < availableTime.size() - 1; i++) {
            TimePeriod curPeriod = availableTime.get(i);
            TimePeriod nextPeriod = availableTime.get(i + 1);
            if (curPeriod.getEndTime().equals(nextPeriod.getStartTime())) {
                for (int j = 1; j < workTime.size(); j++) {
                    TimePeriod preWorkPeriod = workTime.get(j - 1);
                    TimePeriod curWorkPeriod = workTime.get(j);
                    if (preWorkPeriod.getEndTime().equals(curPeriod.getEndTime())
                            && curWorkPeriod.getStartTime().equals(nextPeriod.getStartTime())) {
                        hasAdjacentTime = true;
                        break;
                    }
                }
            }
        }

        if (hasAdjacentTime) {
            System.out.println("找到相邻的时间段！");
        } else {
            System.out.println("没有相邻的时间段。");
        }
    }

    private static List<TimePeriod> parseTimeStr(String timeStr) {
        List<TimePeriod> timeList = new ArrayList<>();
        String[] periodStrs = timeStr.split(";");
        for (String periodStr : periodStrs) {
            String[] timeStrs = periodStr.split("-");
            LocalTime startTime = LocalTime.parse(timeStrs[0]);
            LocalTime endTime = LocalTime.parse(timeStrs[1]);
            timeList.add(new TimePeriod(startTime, endTime));
        }
        return timeList;
    }
}

class TimePeriod {
    private LocalTime startTime;
    private LocalTime endTime;

    public TimePeriod(LocalTime startTime, LocalTime endTime) {
        this.startTime = startTime;
        this.endTime = endTime;
    }

    public LocalTime getStartTime() {
        return startTime;
    }

    public LocalTime getEndTime() {
        return endTime;
    }
}

其中，`TimePeriod` 类表示一个时间段，包含开始时间和结束时间；`parseTimeStr` 方法用于将字符串形式的时间段转换为 `TimePeriod` 对象的集合；`main` 方法中的主要逻辑是遍历可用工作时间段，判断它们是否和工作时间段中的相邻两个时段重合。如果找到相邻的时间段，则输出提示信息。