56：《死亡笔记》Ryuk兴趣期的时间压缩问题：有限窗口下的指数级清洗公式

import numpy as np
import matplotlib.pyplot as plt

class ExponentialCleaning:
    def __init__(self, initial_crime_rate, time_window, initial_rate, growth_rate):
        self.C0 = initial_crime_rate
        self.T = time_window
        self.r0 = initial_rate
        self.k = growth_rate
    
    def crime_rate(self, t):
        """计算时间t时的犯罪率"""
        integral = self.r0 / self.k * (np.exp(self.k * t) - 1)
        return self.C0 * np.exp(-integral)
    
    def optimal_strategy(self):
        """计算最优清洗策略"""
        t = np.linspace(0, self.T, 1000)
        r = self.r0 * np.exp(self.k * t)
        C = self.crime_rate(t)
        
        # 计算总清洗量
        total_cleaning = self.C0 - self.crime_rate(self.T)
        
        return t, r, C, total_cleaning
    
    def visualize(self):
        """可视化清洗过程"""
        t, r, C, total_cleaning = self.optimal_strategy()
        
        fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))
        
        ax1.plot(t, r, 'r-', label='清洗速率')
        ax1.set_ylabel('清洗速率')
        ax1.set_title('指数级清洗策略')
        ax1.legend()
        
        ax2.plot(t, C, 'b-', label='犯罪率')
        ax2.set_xlabel('时间')
        ax2.set_ylabel('犯罪率')
        ax2.legend()
        
        plt.tight_layout()
        plt.show()
        
        print(f"初始犯罪率: {self.C0}")
        print(f"最终犯罪率: {self.crime_rate(self.T):.4f}")
        print(f"总清洗量: {total_cleaning:.4f}")

class TimeWindowOptimizer:
    def __init__(self, min_interest_period, max_interest_period, interest_decay_rate):
        self.t_min = min_interest_period
        self.t_max = max_interest_period
        self.decay_rate = interest_decay_rate
    
    def interest_probability(self, t):
        """计算时间t时Ryuk仍有兴趣的概率"""
        if t < self.t_min:
            return 1.0
        elif t > self.t_max:
            return 0.0
        else:
            return np.exp(-self.decay_rate * (t - self.t_min))
    
    def expected_cleaning(self, cleaning_strategy):
        """计算期望清洗量"""
        def integrand(t):
            prob = self.interest_probability(t)
            # 假设cleaning_strategy返回时间t时的清洗量
            cleaning = cleaning_strategy(t)
            return prob * cleaning
        
        from scipy.integrate import quad
        result, _ = quad(integrand, 0, self.t_max)
        return result
    
    def optimize_window(self, cleaning_strategy_generator):
        """优化时间窗口策略"""
        best_strategy = None
        best_expected_cleaning = 0
        
        # 遍历可能的策略参数
        for k in np.linspace(0.1, 1.0, 10):
            for r0 in np.linspace(0.1, 0.5, 5):
                def strategy(t):
                    ec = ExponentialCleaning(1.0, t, r0, k)
                    return 1.0 - ec.crime_rate(t)
                
                expected = self.expected_cleaning(strategy)
                if expected > best_expected_cleaning:
                    best_expected_cleaning = expected
                    best_strategy = (r0, k)
        
        return best_strategy, best_expected_cleaning

import networkx as nx

class CrimeNetworkAnalyzer:
    def __init__(self, network):
        self.network = network
    
    def centrality_analysis(self):
        """分析网络中心性"""
        # 计算各种中心性指标
        betweenness = nx.betweenness_centrality(self.network)
        degree = nx.degree_centrality(self.network)
        eigenvector = nx.eigenvector_centrality(self.network)
        
        # 综合中心性得分
        centrality = {}
        for node in self.network.nodes():
            centrality[node] = (betweenness[node] + degree[node] + eigenvector[node]) / 3
        
        # 按中心性排序
        sorted_nodes = sorted(centrality.items(), key=lambda x: x[1], reverse=True)
        return sorted_nodes
    
    def cascade_effect(self, removed_nodes):
        """分析移除节点后的级联效应"""
        # 创建网络副本
        network_copy = self.network.copy()
        
        # 移除节点
        network_copy.remove_nodes_from(removed_nodes)
        
        # 计算最大连通分量
        largest_cc = max(nx.connected_components(network_copy), key=len)
        
        # 计算网络效率
        efficiency = nx.global_efficiency(network_copy)
        
        return len(largest_cc), efficiency
    
    def optimal_removal_strategy(self, budget):
        """计算最优节点移除策略"""
        # 获取中心性排序
        sorted_nodes = self.centrality_analysis()
        
        # 测试不同的移除策略
        best_performance = 0
        best_strategy = []
        
        for k in range(1, budget + 1):
            # 移除前k个中心节点
            removed = [node for node, _ in sorted_nodes[:k]]
            cc_size, efficiency = self.cascade_effect(removed)
            
            # 计算性能指标（越小越好）
            performance = cc_size * efficiency
            
            if performance < best_performance or best_performance == 0:
                best_performance = performance
                best_strategy = removed
        
        return best_strategy, best_performance