JAVA题解：

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine().trim());
        
        List<Version> versions = new ArrayList<>();
        for (int i = 0; i < N; i++) {
            versions.add(parseVersion(br.readLine().trim()));
        }
        
        String req = br.readLine().trim();
        String result = findBestMatch(versions, req);
        System.out.println(result);
    }
    
    // 解析版本号字符串为Version对象
    private static Version parseVersion(String s) {
        String[] parts = s.split("\\.");
        int major = Integer.parseInt(parts[0]);
        int minor = parts.length > 1 ? Integer.parseInt(parts[1]) : 0;
        int patch = parts.length > 2 ? Integer.parseInt(parts[2]) : 0;
        return new Version(major, minor, patch);
    }
    
    // 格式化Version对象为字符串
    private static String formatVersion(Version v) {
        if (v.patch == 0) {
            if (v.minor == 0) {
                return String.valueOf(v.major);
            }
            return v.major + "." + v.minor;
        }
        return v.major + "." + v.minor + "." + v.patch;
    }
    
    // 查找最佳匹配版本
    private static String findBestMatch(List<Version> versions, String req) {
        Version best = new Version(-1, -1, -1);
        
        if ("*".equals(req)) {
            // 找最新版本
            for (Version v : versions) {
                if (v.compareTo(best) > 0) {
                    best = v;
                }
            }
        } else {
            char mode = req.charAt(0);
            Version target = parseVersion(req.substring(1));
            
            for (Version v : versions) {
                if (mode == '^') {
                    // 主版本号必须相同，且版本号不小于目标版本
                    if (v.major != target.major || v.compareTo(target) < 0) {
                        continue;
                    }
                } else if (mode == '-' || mode == '~') {
                    // 主版本号和次版本号必须相同，且版本号不小于目标版本
                    if (v.major != target.major || v.minor != target.minor || v.compareTo(target) < 0) {
                        continue;
                    }
                }
                
                if (v.compareTo(best) > 0) {
                    best = v;
                }
            }
        }
        
        if (best.major < 0) {
            return "None";
        } else {
            return formatVersion(best);
        }
    }
    
    // 版本号类
    static class Version implements Comparable<Version> {
        int major;
        int minor;
        int patch;
        
        public Version(int major, int minor, int patch) {
            this.major = major;
            this.minor = minor;
            this.patch = patch;
        }
        
        @Override
        public int compareTo(Version other) {
            if (this.major != other.major) {
                return Integer.compare(this.major, other.major);
            }
            if (this.minor != other.minor) {
                return Integer.compare(this.minor, other.minor);
            }
            return Integer.compare(this.patch, other.patch);
        }
    }
}