Java 实现：在两点之间生成随机折线并找出最短且无遮挡的线段

以下是用 Java 实现的程序：

import java.util.ArrayList;
import java.util.List;
import java.util.Random;

class Point {
    int x;
    int y;
    
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

class Segment {
    Point start;
    Point end;
    
    public Segment(Point start, Point end) {
        this.start = start;
        this.end = end;
    }
}

public class ShortestSegment {
    public static void main(String[] args) {
        List<Segment> segments = generateSegments();
        Segment shortestSegment = findShortestSegment(segments);
        
        if (shortestSegment != null) {
            System.out.println('最短的线段是从 (' + shortestSegment.start.x + ',' + shortestSegment.start.y + ') 到 (' + shortestSegment.end.x + ',' + shortestSegment.end.y + ')');
        } else {
            System.out.println('不存在最短的线段');
        }
    }
    
    public static List<Segment> generateSegments() {
        Random random = new Random();
        int n = random.nextInt(31) + 10; // 生成 10 到 40 之间的随机数 n
        
        List<Segment> segments = new ArrayList<>();
        
        // 随机生成 n 条线段
        for (int i = 0; i < n; i++) {
            Point start = new Point(random.nextInt(100), random.nextInt(100)); // 线段起点坐标随机生成
            Point end = new Point(random.nextInt(100), random.nextInt(100)); // 线段终点坐标随机生成
            
            segments.add(new Segment(start, end));
        }
        
        // 随机生成干扰线段
        int m = random.nextInt(6) + 5; // 生成 5 到 10 之间的随机数 m
        
        for (int i = 0; i < m; i++) {
            Point start = new Point(random.nextInt(100), random.nextInt(100)); // 干扰线段起点坐标随机生成
            Point end = new Point(random.nextInt(100), random.nextInt(100)); // 干扰线段终点坐标随机生成
            
            segments.add(new Segment(start, end));
        }
        
        return segments;
    }
    
    public static Segment findShortestSegment(List<Segment> segments) {
        Segment shortestSegment = null;
        double shortestDistance = Double.MAX_VALUE;
        
        for (Segment segment : segments) {
            double distance = calculateDistance(segment);
            
            if (distance < shortestDistance && !isBlocked(segment, segments)) {
                shortestDistance = distance;
                shortestSegment = segment;
            }
        }
        
        return shortestSegment;
    }
    
    public static double calculateDistance(Segment segment) {
        int deltaX = segment.end.x - segment.start.x;
        int deltaY = segment.end.y - segment.start.y;
        
        return Math.sqrt(deltaX * deltaX + deltaY * deltaY);
    }
    
    public static boolean isBlocked(Segment segment, List<Segment> segments) {
        for (Segment otherSegment : segments) {
            if (otherSegment != segment) {
                // 判断是否有其他线段遮挡
                if (isIntersect(segment.start, segment.end, otherSegment.start, otherSegment.end)) {
                    return true;
                }
            }
        }
        
        return false;
    }
    
    public static boolean isIntersect(Point p1, Point p2, Point p3, Point p4) {
        int d1 = direction(p3, p4, p1);
        int d2 = direction(p3, p4, p2);
        int d3 = direction(p1, p2, p3);
        int d4 = direction(p1, p2, p4);
        
        return ((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) && ((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0));
    }
    
    public static int direction(Point p1, Point p2, Point p3) {
        return (p2.x - p1.x) * (p3.y - p1.y) - (p3.x - p1.x) * (p2.y - p1.y);
    }
}

这个程序首先通过 generateSegments() 方法随机生成 n 条线段和 m 条干扰线段。然后，通过 findShortestSegment() 方法找到最短的线段，同时满足没有被其他线段遮挡的条件。最后，根据最短线段的存在与否输出相应的结果。

在 findShortestSegment() 方法中，使用了 calculateDistance() 方法计算线段的长度，使用了 isBlocked() 方法判断线段是否被其他线段遮挡。在 isBlocked() 方法中，使用了 isIntersect() 方法判断两条线段是否相交。

希望对你有帮助！