这是关于D,G的个人想法

D|智乃的果子

这是一个典型的 ** 哈夫曼树（Huffman Tree）** 问题，目标是通过合并果子堆，使总代价最小。

1. 批量处理相同重量：将相同重量 w 的 c 个果子视为一组。
2. 哈夫曼树批量合并：
3. 每次从优先队列中取出当前重量最小的一组 (w,c)。
4. 如果 c≥2，则可以两两合并，产生 c//2 个重量为 2 的新堆，总代价增加 c//2×2w。将这 c//2 个新堆放回队列。
5. 如果 c 是奇数，会剩下 1 个重量为 w 的堆，也放回队列。如果 c=1,需要从队列中再取出下一个最小的堆 (w 1​ ,c 1​ )，将这两个堆合并为一个重量为 w+w 1​ 的新堆，总代价增加 w+w 1​ 。将新堆放回队列，同时如果 c 1​ >1，将剩下的 c 1​ −1 个堆 (w 1​ ,c 1​ −1) 也放回队列。

代码展示

#include<bits/stdc++.h>
using namespace std;
const int mod=1e9+7;
typedef pair<long long,int> PII;
int main(){
    int n;
    cin>>n;
    priority_queue<PII,vector<PII>,greater<PII>> pq;
    for(int i=0;i<n;i++){
        int c,w;
        cin>>c>>w;
        pq.emplace(w,c);
    }
    long long ans=0;
    while(true){
        auto [w,c]=pq.top();
        pq.pop();
        if(c>1){
            ans=(ans%mod+c/2*w*2%mod)%mod;
            pq.emplace(w*2,c/2);
            if(c%2){
            pq.emplace(w,1);
            }
        }else if(!pq.empty()){
            auto [w1,c1]=pq.top();
            pq.pop();
            
            ans=(ans%mod+w%mod+w1%mod)%mod;
            pq.emplace(w+w1,1);
            if(c1>1)
                pq.emplace(w1,c1-1);
        
        }else{
            break;
        }
        
    
    }
    cout<<ans<<'\n';
    return 0;
}

G|智乃的箭头魔术

-核心 操作：

• 操作 0：互换 → 异或 3
• 操作 1：奇数异或 2
• 操作 2：互换 → 异或 1
• 操作 3：偶数异或 2
• 操作 4：+1 取模 4
• 操作 5：+3 取模 4（等价于 - 1 取模 4）

代码展示

#include<bits/stdc++.h>
using namespace std;
int main() {
    // 1. 定义100个操作序列（拆分拼接，保持原内容不变）
    string operation_seq = "01122334451420153201254102145302145102141023";
    operation_seq += "02142025101203201451451522302514203214510021454101002532";
    // 2. 初始化状态：tar代表当前状态值（初始为0）
    int current_state = 0;
    // 3. 遍历每个操作，按规律更新状态
    for (char op_char : operation_seq) {
        // 将字符型操作转为整数（如 '0' → 0）
        int operation = op_char - '0';
        // 按操作类型分支处理，每一步添加注释说明逻辑
        switch (operation) {
            case 0:  // 操作0：互换 → 状态异或3
                current_state ^= 3;
                break; 
            case 1:  // 操作1：对奇数状态异或2（tar&1 为1表示奇数）
                if (current_state & 1) {
                    current_state ^= 2;
                }
                break;
                
            case 2:  // 操作2：互换 → 状态异或1
                current_state ^= 1;
                break;
                
            case 3:  // 操作3：对偶数状态异或2（!(tar&1) 为1表示偶数）
                if (!(current_state & 1)) {
                    current_state ^= 2;
                }
                break;
                
            case 4:  // 操作4：加1后对4取模
                current_state = (current_state + 1) % 4;
                break;
                
            case 5:  // 操作5：减1（等价于加3）后对4取模（避免负数）
                current_state = (current_state + 3) % 4;
                break;
                
            default: // 防御性处理：非法操作（
                cout << "警告：无效操作 " << operation << endl;
                break;
        }

        cout << current_state;
    }
    cout << endl;
    
    return 0;
}