2025HuaweiCodeCraft/read_refuse.cpp at main · NJUWallSpider/2025HuaweiCodeCraft · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
#include <cmath>
#include <algorithm>
#include "read_re.h"
#include <random>
#include <chrono>
#include <string>
#include <climits>
#include <utility>

// Refusal strategy: Directly refuse requests that cannot be completed within the specified time calculated from current head
void Reader::refuse_request(){
    std::vector<int> refuse_id;
    int refuse_count = 0;
    const int LIMIT = 105;
    // Estimate how many time slices are needed to finish reading the current interval
    // for (int i = 1; i <= data_.N; i++) {
    //     if (read_time[i] > 0) {
    //         read_time[i]--;
    //         continue;
    //     }
    //     std::vector<int> time(2, 0);
    //     for (int point_index = 0; point_index <= 1; point_index++) {
    //         int disk_point = data_.disk_point[i][point_index];
    //         int end_pos = end[i][point_index];
    //         time[point_index] = (end_pos - disk_point) * 16 / data_.G;
    //     }
    //     read_time[i] = std::min(time[0], time[1]);

    //     // Iterate all objects on this disk, refuse requests not in current interval read_time[i] slices in advance
    //     std::vector<int>& disk = data_.disk[i];
    //     int total_advance = 1;
    //     do {
    //         // Check if there is an object at current head position
    //         if (disk[total_advance] != 0) {
    //             int object_id = disk[total_advance]; // Get current object ID
    //             Object& object = data_.object.at(object_id); // Get current object
    //             // Refuse in advance if current object is not in the interval
    //             if (!object.is_requested || (total_advance <= end[i][0] && total_advance >= start[i][0])
    //                 || (total_advance <= end[i][1] && total_advance >= start[i][1])) {
    //                 total_advance += object.size; // Accumulate moved distance
    //                 continue;
    //             }
    //             for (auto it = --object.request_ids.end(); it != object.request_ids.begin(); --it) {
    //                 Request& request = data_.request.at(*it);
    //                 if (request.is_done) break;
    //                 if(data_.timestamp - request.timestamp > LIMIT) break;
    //                 if (data_.timestamp - request.timestamp + read_time[i] > LIMIT) {
    //                     refuse_count++;
    //                     refuse_id.push_back(request.request_id);
    //                     request.is_done = true;
    //                 }
    //             }
    //             total_advance += object.size; // Accumulate moved distance
    //         } else {
    //             total_advance += 1; // Accumulate moved distance
    //         }
    //     } while (total_advance <= data_.V); // Continue searching if moved distance is less than disk size
    // }

    ////// Ensure all uncompletable requests are reported as refused /////

    // Initialize refuse_index
    if(data_.timestamp == LIMIT) {
        for(int i = data_.request_num; i >= 1; i--) {
            Request& request = data_.request.at(i);
            if(data_.timestamp - request.timestamp == LIMIT) {
                data_.refuse_index = i;
                break;
            }
        }
    }
    if(data_.timestamp >= LIMIT) {
        for(int i = data_.refuse_index; i >= 1; i--) {
            Request& request = data_.request.at(i);
            if(data_.timestamp - request.timestamp > LIMIT) {
                break;
            }
            if(!request.is_done && data_.timestamp - request.timestamp == LIMIT) {
                refuse_count++;
                refuse_id.push_back(request.request_id);
                request.is_done = true;
            }
        }
        for(int i = data_.refuse_index + 1; i <= data_.request_num; i++) {
            Request& request = data_.request.at(i);
            if(data_.timestamp - request.timestamp + 1 == LIMIT) {
                data_.refuse_index = i;
            } else {
                break;
            }
        }
    }
    std::cout << refuse_count << std::endl;
    for (int r : refuse_id) {
        std::cout << r << std::endl;
    }
}