Untitled

// 在路徑上優化連結
void optimizeLinksOnPath(QuantumNetwork* network, int pairID, int source, int destination, int* path, int pathLength) {
    // 儲存每個節點對間已建立的糾纏鏈路數量
    int entangledLinksCount[MAX_NODES];
    // 儲存各節點對的Fidelity與糾纏probability，索引 [1] 表示未經優化，索引 [2] 表示已優化
    double probability[4][pathLength];
    double fide[4][pathLength];

    int minPathCount = 0; // 記錄成功建立糾纏鏈路的節點對數
    int node1_quantumMemories = network->nodes[path[0]].quantumMemories; // 起始節點的量子記憶體數量
    int node2_quantumMemories = network->nodes[path[pathLength - 1]].quantumMemories; // 終止節點的量子記憶體數量
    double finalFidelity = 1.0; // 路徑的總Fidelity
    double total_dis = 0.0;     // 路徑的總距離
    double finalprobability = 0.0; // 路徑的總probability

    // 建立初始的糾纏鏈路，逐一處理路徑上的節點對
    for (int i = 0; i < pathLength - 1; i++) {
        int node1 = path[i];
        int node2 = path[i + 1];
        total_dis += graph[node1][node2].distance; // 計算整體路徑距離

        // 檢查兩節點是否有可用的量子記憶體
        if (network->nodes[node1].quantumMemories > 0 && network->nodes[node2].quantumMemories > 0) {
            entangledLinksCount[i] = 1; // 初始化糾纏鏈路數量

            // 計算未經優化的Fidelity與probability
            fide[1][i] = calculateFidelity(graph[node1][node2].distance, network->beta);
            fide[2][i] = fide[1][i];
            probability[1][i] = calculateprobability(graph[node1][node2].distance, network->alpha) * network->swapProb;
            probability[2][i] = probability[1][i];

            // 更新路徑的總Fidelity與probability
            finalFidelity *= fide[2][i];
            finalprobability += probability[2][i];

            // 消耗兩節點的量子記憶體
            network->nodes[node1].quantumMemories--;
            network->nodes[node2].quantumMemories--;
            minPathCount++; // 計算成功建立的節點對數量
        } else {
            // 若任何一段無法建立，恢復節點的初始狀態並結束
            for (int i = 0; i < pathLength; i++) {
                network->nodes[path[i]].quantumMemories = network->nodes[path[i]].iniQMemories;
            }
            return;
        }
    }

    // 若只有一段鏈路，嘗試通過純化提升Fidelity
    if (minPathCount == 1) {
        int node1 = path[0];
        int node2 = path[1];

        // 持續純化直到Fidelity達到閾值或無法繼續純化
        while (network->nodes[node1].quantumMemories > 0 && network->nodes[node2].quantumMemories > 0) {
            network->nodes[node1].quantumMemories--;
            network->nodes[node2].quantumMemories--;
            probability[2][0] = compute_purification_probability(probability[2][0], probability[1][0]) * network->swapProb;
            fide[2][0] = purify(fide[2][0], fide[1][0]);
            entangledLinksCount[0]++;
            if (fide[2][0] >= network->fidelityThreshold) {
                break;
            }
        }
    } else {
        // 若路徑包含多段，嘗試優化整體Fidelity
        while (finalFidelity < network->fidelityThreshold) {
            int count = -1;
            double max_puri = 0.0;

            // 遍歷所有節點對，選擇Fidelity提升最大的一對進行純化
            for (int i = 0; i < minPathCount; i++) {
                int node1 = path[i];
                int node2 = path[i + 1];

                if (network->nodes[node1].quantumMemories > 0 && network->nodes[node2].quantumMemories > 0) {
                    fide[3][i] = purify(fide[2][i], fide[1][i]) - fide[2][i];
                    if (max_puri < fide[3][i]) {
                        max_puri = fide[3][i];
                        count = i;
                    }
                }
            }

            if (count == -1) break; // 無法進行進一步優化，結束

            // 執行選定節點對的純化操作
            network->nodes[path[count]].quantumMemories--;
            network->nodes[path[count + 1]].quantumMemories--;
            entangledLinksCount[count]++;
            finalFidelity /= fide[2][count];
            finalprobability -= probability[2][count];
            fide[2][count] = purify(fide[2][count], fide[1][count]);
            probability[2][count] = compute_purification_probability(probability[2][count], probability[1][count]) * network->swapProb;
            finalFidelity *= fide[2][count];
            finalprobability += probability[2][count];
        }
    }

    // 嘗試直接建立起點到終點的糾纏鏈路（bypass 機制）
    int cnt_link = 0;
    double probability1[2] = {0.0, 0.0};
    double fide1[2] = {0.0, 0.0};
    int node1 = path[0];
    int node2 = path[pathLength - 1];

    while (node1_quantumMemories > 0 && node2_quantumMemories > 0) {
        node1_quantumMemories--;
        node2_quantumMemories--;

        if (cnt_link == 0) {
            fide1[0] = calculateFidelity(total_dis, network->beta);
            fide1[1] = fide1[0];
            probability1[0] = calculateprobability(total_dis, network->alpha) * network->swapProb;
            probability1[1] = probability1[0];
            cnt_link++;
        } else {
            probability1[1] = compute_purification_probability(probability1[1], probability1[0]) * network->swapProb;
            fide1[1] = purify(fide1[1], fide1[0]);
            cnt_link++;
        }

        if (fide1[1] >= network->fidelityThreshold) {
            break;
        }
    }

    // 檢查路徑是否達到目標Fidelity
    if (finalFidelity >= network->fidelityThreshold) {
        printf("%d %d %d\n", pairID, source, destination);
        printf("%d\n", pathLength - 1);

        if (cnt_link != 0 && fide1[1] >= network->fidelityThreshold && finalprobability < probability1[1]) {
            printf("%d %d %d\n", node1, node2, cnt_link);
        } else {
            for (int i = 0; i < pathLength - 1; i++) {
                printf("%d %d %d\n", path[i], path[i + 1], entangledLinksCount[i]);
            }
        }

        // 恢復節點的初始量子記憶體數量
        for (int i = 0; i < pathLength; i++) {
            network->nodes[path[i]].iniQMemories = network->nodes[path[i]].quantumMemories;
        }
    } else if(fide1[1] >= network->fidelityThreshold){
        printf("%d %d %d\n", pairID, source, destination);
        printf("%d\n", pathLength - 1);
        printf("%d %d %d\n", node1, node2, cnt_link);
        for (int i = 0; i < pathLength; i++) {
            network->nodes[path[i]].iniQMemories = network->nodes[path[i]].quantumMemories;
        }
    }
    else {
        // 若未達到目標Fidelity，恢復節點的初始量子記憶體數量
        for (int i = 0; i < pathLength; i++) {
            network->nodes[path[i]].quantumMemories = network->nodes[path[i]].iniQMemories;
        }
    }
}