赛前

头部

你好，世界

欢迎参与 《2025年12月FMCRAFT月赛》

以下是本届比赛的相关信息

比赛组别

$$ 2025年12月FMCRAFT月赛\left\{ \begin{array}{l} \text{J组}\left\{ \begin{array}{l} \text{第一轮} \end{array} \right. \end{array} \right. $$

本次比赛，设有J组，J组共一轮。无X、S组。

比赛基本信息

难度

难度：$\text{CSP-J}$

工作人员

举办人：___zjy___
出题人：___zjy___、zhaohaocheng1234

题目编排

||A|B|
|-|-|-|
|当前状态|正式试题|正式试题|
|题目名称|小乐の作业|小乐的球队|
|难度|普及-|普及|
|时间限制|1秒|1秒|1秒|
|内存限制|256MB|256MB|
|题目类型|传统|传统|
|评测标准|TF-OJ|TF-OJ|
|出题人|___zjy___|zhaohaocheng1234|
|验题人|___zjy___|___zjy___|

赛场

线上-TropicalFIshOnlineJudge

时间编排

比赛开始于: Hour:   Minute:

比赛结束于: Hour:   Minute:

P1304 哥德巴赫猜想 - 洛谷

第一代代码

#include <bits/stdc++.h>
using namespace std;
int i,n,a,b,fl,t;
int prime[] = {
    0,  
    2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
    31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
    73, 79, 83, 89, 97, 101, 103, 107, 109, 113,
    127, 131, 137, 139, 149, 151, 157, 163, 167, 173,
    179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
    233, 239, 241, 251, 257, 263, 269, 271, 277, 281,
    283, 293, 307, 311, 313, 317, 331, 337, 347, 349,
    353, 359, 367, 373, 379, 383, 389, 397, 401, 409,
    419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
    467, 479, 487, 491, 499, 503, 509, 521, 523, 541,
    547, 557, 563, 569, 571, 577, 587, 593, 599, 601,
    607, 613, 617, 619, 631, 641, 643, 647, 653, 659,
    661, 673, 677, 683, 691, 701, 709, 719, 727, 733,
    739, 743, 751, 757, 761, 769, 773, 787, 797, 809,
    811, 821, 823, 827, 829, 839, 853, 857, 859, 863,
    877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
    947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013,
    1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069,
    1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151,
    1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223,
    1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291,
    1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373,
    1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451,
    1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511,
    1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583,
    1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657,
    1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733,
    1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811,
    1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889,
    1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987,
    1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053,
    2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129,
    2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213,
    2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287,
    2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357,
    2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423,
    2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531,
    2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617,
    2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687,
    2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741,
    2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819,
    2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903,
    2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999,
    3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079,
    3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181,
    3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257,
    3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331,
    3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413,
    3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511,
    3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571,
    3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643,
    3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727,
    3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821,
    3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907,
    3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989,
    4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057,
    4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139,
    4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231,
    4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297,
    4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409,
    4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493,
    4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583,
    4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657,
    4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751,
    4759, 4783, 4787, 4789, 4793, 4801, 4813, 4817, 4831, 4861,
    4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943,
    4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009,
    5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099,
    5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189,
    5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281,
    5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393,
    5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449,
    5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527,
    5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641,
    5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701,
    5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801,
    5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861,
    5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953,
    5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067,
    6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143,
    6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229,
    6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311,
    6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373,
    6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481,
    6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577,
    6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679,
    6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763,
    6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841,
    6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947,
    6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001,
    7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109,
    7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211,
    7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307,
    7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417,
    7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507,
    7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573,
    7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649,
    7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727,
    7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841,
    7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927,
    7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017, 8039,
    8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117,
    8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221,
    8231, 8233, 8237, 8243, 8263, 8269, 8273, 8287, 8291, 8293,
    8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389,
    8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513,
    8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, 8599,
    8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681,
    8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747,
    8753, 8761, 8779, 8783, 8803, 8807, 8819, 8821, 8831, 8837,
    8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933,
    8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013,
    9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, 9127,
    9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203,
    9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293,
    9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, 9391,
    9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461,
    9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539,
    9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, 9643,
    9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739,
    9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817,
    9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, 9901,
    9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973
};
int main(){
    cin>>n;
    for(i=1;i<=(n-2)/2;i++){
        t=2*i+2;fl=0;
        cout<<t<<"=";
        for(a=1;a<=1300;a++){
            if(fl==1) break;
            for(b=1;b<=1300;b++){
                if(fl==1) break;
                if(prime[a]+prime[b]==t) cout<<prime[a]<<"+"<<prime[b]<<"\n",fl=1;
            }
        }
    }
}

第二代代码

发现数组越界，只有 $1299$个数，却循环到 $1300$

#include <bits/stdc++.h>
using namespace std;
int i,n,a,b,fl,t;
int prime[] = {
    0,  
    2, 3, 5, 7, 11, 13, 17, 19, 23, 29,
    31, 37, 41, 43, 47, 53, 59, 61, 67, 71,
    73, 79, 83, 89, 97, 101, 103, 107, 109, 113,
    127, 131, 137, 139, 149, 151, 157, 163, 167, 173,
    179, 181, 191, 193, 197, 199, 211, 223, 227, 229,
    233, 239, 241, 251, 257, 263, 269, 271, 277, 281,
    283, 293, 307, 311, 313, 317, 331, 337, 347, 349,
    353, 359, 367, 373, 379, 383, 389, 397, 401, 409,
    419, 421, 431, 433, 439, 443, 449, 457, 461, 463,
    467, 479, 487, 491, 499, 503, 509, 521, 523, 541,
    547, 557, 563, 569, 571, 577, 587, 593, 599, 601,
    607, 613, 617, 619, 631, 641, 643, 647, 653, 659,
    661, 673, 677, 683, 691, 701, 709, 719, 727, 733,
    739, 743, 751, 757, 761, 769, 773, 787, 797, 809,
    811, 821, 823, 827, 829, 839, 853, 857, 859, 863,
    877, 881, 883, 887, 907, 911, 919, 929, 937, 941,
    947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013,
    1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069,
    1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151,
    1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223,
    1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291,
    1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373,
    1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451,
    1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511,
    1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583,
    1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657,
    1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733,
    1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811,
    1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889,
    1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987,
    1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053,
    2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129,
    2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213,
    2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287,
    2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357,
    2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423,
    2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531,
    2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617,
    2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687,
    2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741,
    2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819,
    2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903,
    2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999,
    3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079,
    3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181,
    3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257,
    3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331,
    3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413,
    3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511,
    3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571,
    3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643,
    3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727,
    3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821,
    3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907,
    3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989,
    4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057,
    4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139,
    4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231,
    4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297,
    4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409,
    4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493,
    4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583,
    4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657,
    4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751,
    4759, 4783, 4787, 4789, 4793, 4801, 4813, 4817, 4831, 4861,
    4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943,
    4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009,
    5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099,
    5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189,
    5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281,
    5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393,
    5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449,
    5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527,
    5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641,
    5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701,
    5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801,
    5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861,
    5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953,
    5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067,
    6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143,
    6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229,
    6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311,
    6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373,
    6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481,
    6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577,
    6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679,
    6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763,
    6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841,
    6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947,
    6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001,
    7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109,
    7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211,
    7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307,
    7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417,
    7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507,
    7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573,
    7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649,
    7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727,
    7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841,
    7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927,
    7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017, 8039,
    8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117,
    8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221,
    8231, 8233, 8237, 8243, 8263, 8269, 8273, 8287, 8291, 8293,
    8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389,
    8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513,
    8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, 8599,
    8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681,
    8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747,
    8753, 8761, 8779, 8783, 8803, 8807, 8819, 8821, 8831, 8837,
    8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933,
    8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013,
    9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, 9127,
    9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203,
    9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293,
    9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, 9391,
    9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461,
    9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539,
    9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, 9643,
    9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739,
    9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817,
    9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, 9901,
    9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973
};
int main(){
    cin>>n;
    for(i=1;i<=(n-2)/2;i++){
        t=2*i+2;fl=0;
        cout<<t<<"=";
        for(a=1;a<=1229;a++){
            if(fl==1) break;
            for(b=1;b<=1229;b++){
                if(fl==1) break;
                if(prime[a]+prime[b]==t) cout<<prime[a]<<"+"<<prime[b],fl=1;
            }
        }
        cout<<"\n";
    }
}

第三代代码

少了一个质数，所以炸了，现在 AC 了

赛前

头部

你好，世界！

本次公告严格仿照LG

这里是2025年10月FMCRAFT月赛

众所周知，一张比赛需要一张头图

比赛基本信息

难度

绝对性对标 $CSP-X$

绝对性简单

小学生都能做出来

我说的是$T1 \space T2 \space T3$

主要人员

本次比赛，工作人员如下：

• 负责人：LG_DHEnry
• 出题人：LG_DHEnry _zjy_
• 验题人：LG_DHEnry _zjy_

本次比赛，只有两个人员

题目一览

确信——$CSP-X$

空为待补充项目

比赛时间

开始时间 2025-10-18 12:00

结束时间 2025-10-19 12:00

奖励

共计10元

为什么公告要放在我的Blog？

因为此次比赛，将在比赛1007 - 2025年10月FMCRAFT月赛 - TropicalFish-OnlineJudge、2025年10月FMCRAFT月赛 - 洛谷 | 计算机科学教育新生态和2025年10月FMCRAFT月赛 - 洛谷 | 计算机科学教育新生态同时举行，为防止更新不及时，所以在本Blog进行公告

• TropicalFish-OnlineJudge 没有洛谷账号的人可以在此提交
• 1团比赛 在1团的人可以提交
• 2团比赛 在2团的人可以提交

也许是因为FMCRAFT组织人数膨胀（？）

报名比赛

FMCRAFT - 洛谷 | 计算机科学教育新生态

FMCRAFT 2团 - 洛谷 | 计算机科学教育新生态

主页 - TropicalFish-OnlineJudge

在这3个地方，我们都将会同时举行比赛，但是！奖励分发标准以主页 - TropicalFish-OnlineJudge为准

重要

因题目E的原因，当我们看到有题目E的提交的时候，我们会进行强制停判，跳过判题，在比赛后，我们会进行重测。关于如何校验自己的答案是否正确，你可以浪费洛谷的评测资源哦。

因测试数据原因，你在洛谷和OJ提交的代码得分可能不同，请以OJ为准。

实际得分与题目数据范围SUBTASK分数可能不符，以实际为准。

赛时

赛后

排名

奖金

第一名是Im_aur
奖励10元

遗憾

pika_没有在oj提交

std

1

#include<bits/stdc++.h>
#define int long long
using namespace std;
int n,i,s1,s2,fl,l,j,s;char a[11100000];
main(){
    freopen("A.in","r",stdin);
    freopen("A.out","w",stdout);
    cin>>n;
    for(i=1;i<=n;i++){
        cin>>a+1;s1=s2=fl=0;
        l=strlen(a+1);
        for(j=1;j<=l;j++)
            if(a[j]=='6'){
                s++;fl=1;break;
            }
            else{
                if(a[j]=='0')s1++;
                if(a[j]=='1')s2++;
            }
        if(s1>s2&&!fl)s++;
    }
    cout<<s<<"\\n"<<n-s;
}

2

#include<bits/stdc++.h>
#pragma GCC optimize("O2")
#define int long long
using namespace std;
int n,i,s1,s2,fl,l,j,s,m,t,k;
main(){
    freopen("B.in","r",stdin);
    freopen("B.out","w",stdout);
    cin>>m>>n;
    for(i=0;i<=n;i++){
        for(j=0;j<=n;j++){
            for(k=0;k<=n/3;k++){
                if(i\*5+j\*3+k==m&&i+j+k\*3==n){
                    cout<<++t<<" "<<i<<" "<<j<<" "<<k\*3<<"\\n";
                }
            }
        }
    }
    if(t==0) cout<<"No!";
}

3

#include <iostream>
#include <vector>
#include <queue>
using namespace std;

vector<int> dirs = {-1, 0, 1, 0, -1};

void dfs(vector<vector<int>>& grid, queue<pair<int, int>>& q, int i, int j, int n, int m) {
    if (i < 0 || j < 0 || i >= n || j >= m || grid[i][j] != 1) {
        return;
    }
    grid[i][j] = 2;
    q.push(make\_pair(i, j));
    for (int k = 0; k < 4; ++k) {
        dfs(grid, q, i + dirs[k], j + dirs[k + 1], n, m);
    }
}

int shortestBridge(vector<vector<int>>& grid, int n, int m) {
    queue<pair<int, int>> q;
    bool found = false;
    
    for (int i = 0; i < n && !found; ++i) {
        for (int j = 0; j < m && !found; ++j) {
            if (grid[i][j] == 1) {
                dfs(grid, q, i, j, n, m);
                found = true;
            }
        }
    }
    
    int steps = 0;
    while (!q.empty()) {
        int size = q.size();
        while (size--) {
            pair<int, int> current = q.front();
            q.pop();
            int i = current.first;
            int j = current.second;
            for (int k = 0; k < 4; ++k) {
                int x = i + dirs[k];
                int y = j + dirs[k + 1];
                if (x >= 0 && y >= 0 && x < n && y < m) {
                    if (grid[x][y] == 1) {
                        return steps;
                    }
                    if (grid[x][y] == 0) {
                        grid[x][y] = 2;
                        q.push(make\_pair(x, y));
                    }
                }
            }
        }
        steps++;
    }
    return -1;
}

int main() {
    freopen("C.in","r",stdin);
    freopen("C.out","w",stdout);
    int n, m;
    cin >> n >> m;
    
    vector<vector<int>> grid(n, vector<int>(m));
    for (int i = 0; i < n; ++i) {
        for (int j = 0; j < m; ++j) {
            cin >> grid[i][j];
        }
    }
    
    cout << shortestBridge(grid, n, m) << endl;
    return 0;
}

4

#include <iostream>
#include <vector>
#include <queue>
#include <algorithm>
#pragma GCC optimize("O2")

using namespace std;

struct Transaction {
    int b;
    int c;
};

int main() {
    freopen("D.in","r",stdin);
    freopen("D.out","w",stdout);

    ios::sync\_with\_stdio(false);
    cin.tie(nullptr);
    
    int n, m;
    cin >> n >> m;
    
    vector<int> a(n+1);
    vector<Transaction> trans(n+1);
    
    for(int i=1; i<=n; ++i) cin >> a[i];
    for(int i=1; i<=n; ++i) cin >> trans[i].b >> trans[i].c;
    
    vector<pair<int, int>> operations;
    int collect\_ops = 0;
    
    auto can\_trade = [&](int idx) {
        return a[idx] >= trans[idx].b;
    };
    
    priority\_queue<pair<int, int>> pq; // {c, index}
    for(int i=1; i<=n; ++i) {
        if(!can\_trade(i)) {
            pq.push({trans[i].c, i});
        }
    }
    
    while(m--) {
        int op;
        cin >> op;
        
        if(op == 1) {
            int l, r, x;
            cin >> l >> r >> x;
            
            bool useful = false;
            for(int i=l; i<=r; ++i) {
                if(!can\_trade(i)) {
                    useful = true;
                    a[i] += x;
                    if(can\_trade(i)) {
                        // Remove from priority queue if now tradable
                        // (Implementation simplified for clarity)
                    }
                }
            }
            
            if(useful) collect\_ops++;
        } 
        else if(op == 2) {
            int x;
            cin >> x;
            if(can\_trade(x)) {
                a[x] -= trans[x].b;
            }
        }
    }
    
    cout << collect\_ops << endl;
    return 0;
}

5

#include <iostream>
using namespace std;

// 内联函数减少调用开销，直接使用\_\_int128计算
inline long long mul\_mod(long long a, long long b, long long mod) {
    return ((\_\_int128)a \* b) % mod;
}

// 计算排列数 P(n, r) mod mod，极致优化版本
long long permutation(long long n, long long r, long long mod) {
    if (mod == 1) return 0;
    if (r >= mod) return 0;  // 核心优化：连续mod个数必有倍数
    
    // 快速检查是否存在因子能被mod整除（提前退出循环）
    long long min\_val = n - r + 1;
    if (min\_val <= 0) return 0;  // 理论上r<=n，这里是防御性判断
    
    // 计算mod的最小质因子上限，用于快速判断
    long long limit = min(r, mod - 1);
    long long result = 1;
    
    for (long long i = 0; i < limit; ++i) {
        long long term = n - i;
        result = mul\_mod(result, term, mod);
        if (result == 0) break;  // 一旦出现0，直接返回
    }
    
    return result;
}

int main() {
    freopen("E.in","r",stdin);
    freopen("E.out","w",stdout);
    ios::sync\_with\_stdio(false);
    cin.tie(nullptr);
    
    int T;
    long long mod;
    cin >> T >> mod;
    
    // 批量处理输入输出，减少IO开销
    while (T--) {
        long long n, r;
        cin >> n >> r;
        cout << permutation(n, r, mod) << '\\n';
    }
    
    return 0;
}

视频

https://www.bilibili.com/video/BV17HWnzAEWx/?share_source=copy_web&vd_source=c2640429ffb126a929d74212d5168b1f

注意

文稿与视频实际内容可能存在出入，以视频为准

关于评论区的一些评论

很少能看到这么正确的科普视频，居然用的是devcpp

本来是想用VSCode的，但是我当时忘记了就用Devc++

都是基本功，还算可以。不过工程上极度不推荐用这个万能头文件和using namespace std 虽然大概率你是打算法竞赛的，不太可能会重视这种东西。

是OI

文稿

1. 变量初始化之谜

cpp

#include <iostream>
using namespace std;

int main() {
    int x;
    cout << "未初始化的x = " << x << endl;
    return 0;
}

​功能​：演示未初始化局部变量的行为
你以为是确定性的0吗？
实际上是随机垃圾值的！
​原理​：局部变量在栈上分配，不会自动初始化，值是之前使用该内存的残留数据

2. 浮点数精度陷阱

cpp

#include <iostream>
using namespace std;

int main() {
    double a = 0.1;
    double b = 0.2;
    double c = 0.3;
    cout << "0.1 + 0.2 == 0.3 ? " << (a + b == c) << endl;
    cout << "实际值: " << a + b << endl;
    return 0;
}

​功能​：验证浮点数精度问题
你以为是精确相等的吗？
实际上是不相等的！
​原理​：浮点数在二进制中无法精确表示0.1、0.2这样的十进制小数，存在精度误差

3. 数组越界不报错

cpp

#include <iostream>
using namespace std;

int main() {
    int arr[3] = {1, 2, 3};
    cout << "arr[5] = " << arr[5] << endl;
    cout << "程序还在运行！" << endl;
    return 0;
}

​功能​：测试数组越界访问的行为
你以为是会崩溃的吗？
实际上是可能正常输出的！
​原理​：C++不检查数组边界，越界访问是未定义行为，可能读到随机内存值而不崩溃

4. 布尔值的算术运算

cpp

#include <iostream>
using namespace std;

int main() {
    bool b = true;
    cout << "b + 5 = " << (b + 5) << endl;
    cout << "b * 10 = " << (b * 10) << endl;
    return 0;
}

​功能​：展示bool类型在算术运算中的行为
你以为是true/false的吗？
实际上是1/0参与运算的！
​原理​：bool在算术运算中会隐式转换为int，true为1，false为0

5. 自增运算符的迷惑行为

cpp

#include <iostream>
using namespace std;

int main() {
    int i = 5;
    int j = i++ + ++i;
    cout << "j = " << j << endl;
    return 0;
}

​功能​：演示序列点问题
你以为是确定结果的吗？
实际上是编译器随缘的！
​原理​：同一表达式中对同一变量多次修改是未定义行为，结果取决于编译器实现

6. 空结构体的大小

cpp

#include <iostream>
using namespace std;

struct Empty {};

int main() {
    cout << "空结构体大小: " << sizeof(Empty) << endl;
    return 0;
}

​功能​：探究空结构体的内存占用
你以为是0字节的吗？
实际上是1字节的！
​原理​：为了确保每个对象都有唯一地址，空结构体被分配1字节大小

7. const变量的"不可修改"

cpp

#include <iostream>
using namespace std;

int main() {
    const int x = 10;
    int* p = const_cast<int*>(&x);
    *p = 20;
    cout << "x = " << x << endl;
    cout << "*p = " << *p << endl;
    return 0;
}

​功能​：测试const_cast的能力和限制
你以为是真正不可变的吗？
实际上是可以绕过的！
​原理​：const_cast可以移除const属性，但修改const对象是未定义行为

非官方 FMCRAFT自编 常用 适用

📖 目录

1. 基础概念
2. 领地创建与选择
3. 权限标志详解
4. 玩家与组权限
5. 经济系统
6. 租赁系统
7. 子领地系统
8. 领地管理
9. 管理员命令
10. 实用技巧
11. 常见问题

阐述

做木头锄子

一左键，一右键，对准你家的两个对点
然后输入

/res create <家名>

然后你就看这个下面，里面有一些常用的权限

🏗️ 基础概念

要钱的话跟op讲，1积分=50元钱

领地基础

• 领地：受保护的3D区域
• 子领地：主领地内的独立区域
• 权限标志：控制领地的各种行为规则
• 选择工具：木锄（WOODEN_HOE）

基础命令格式

/res <命令> [参数]          # 玩家命令
/resadmin <命令> [参数]     # 管理员命令
/res <领地名> <命令> [参数] # 指定领地操作

🎯 领地创建与选择

选择领地范围

# 手动选择（手持木锄）
/res select                 # 查看选择状态
/res select clear          # 清除选择

# 快捷选择命令
/res select vert           # 从脚下到天空（Y:0-319）
/res select chunk          # 选择整个区块
/res select expand [格数]  # 向面对方向扩展选择
/res select size [长] [宽] [高] # 指定尺寸选择
/res select shift [方向] [格数] # 移动选择区域

创建领地

/res create [领地名]        # 创建领地
/res create [领地名] [成本] # 付费创建领地
/res auto [领地名]          # 自动创建（付费）
/res remove [领地名]        # 删除领地
/res confirm               # 确认危险操作

领地信息

/res list                   # 列出你的领地
/res list [页码]           # 分页查看
/res list all              # 列出所有领地
/res list [世界名]         # 指定世界的领地
/res info                   # 查看当前领地信息
/res info [领地名]         # 查看指定领地信息
/res info [领地名] full    # 详细信息
/res limits                 # 查看领地限制

🛡️ 权限标志详解

权限设置语法

# 基本语法
/res [领地名] set <标志> <值>
/res [领地名] pset <玩家> <标志> <值>
/res [领地名] gset <组名> <标志> <值>

# 值类型：true/false/remove

建筑相关标志

# 基础建筑权限
/res set build false        # 总建筑开关（推荐关闭）
/res set destroy false      # 禁止破坏方块
/res set place false        # 禁止放置方块
/res set use false          # 禁止使用物品（门、按钮等）
/res set container false    # 禁止使用容器（箱子、熔炉等）

# 高级建筑控制
/res set piston false       # 禁止活塞推动
/res set bucket false       # 禁止使用桶
/res set flow false         # 禁止液体流动
/res set lavaflow false     # 禁止岩浆流动
/res set waterflow false    # 禁止水流流动

战斗与生物

# PVP设置
/res set pvp false          # 禁止PVP
/res set invincible false   # 禁止伤害玩家

# 生物控制
/res set monsters false     # 禁止生成怪物
/res set animals true       # 允许生成动物
/res set leash false        # 禁止拴绳使用
/res set ride false         # 禁止骑乘生物

爆炸与破坏

/res set creeper false      # 禁止苦力怕爆炸
/res set tnt false          # 禁止TNT爆炸
/res set firespread false   # 禁止火势蔓延
/res set ignite false       # 禁止点火
/res set burn false         # 禁止燃烧

移动与传送

/res set move true          # 允许进入领地
/res set tp true            # 允许传送至领地
/res set enderpearl false   # 禁止未影珍珠传送
/res set pressure false     # 禁止压力板

其他重要标志

/res set chat false         # 禁止非成员聊天
/res set message true       # 显示进出消息
/res set noteleport false   # 禁止领地内传送
/res set fly false          # 禁止飞行
/res set gamemode keep      # 保持游戏模式

领地保护增强

# 完整保护设置
/res set build false
/res set destroy false
/res set place false
/res set use false
/res set container false
/res set pvp false
/res set creeper false
/res set tnt false
/res set ignite false
/res set bucket false

👥 玩家与组权限

玩家权限管理

# 单个玩家权限
/res pset [玩家] build true     # 允许建造
/res pset [玩家] destroy true   # 允许破坏
/res pset [玩家] container true # 允许使用容器
/res pset [玩家] admin true     # 给予管理权限

# 查看玩家权限
/res pinfo [玩家]               # 查看玩家在所有领地的权限
/res pinfo [玩家] [领地名]      # 查看指定领地权限

# 移除玩家权限
/res pset [玩家] build remove
/res removeplayer [玩家]        # 移除玩家所有权限

组权限管理

# 设置组权限
/res gset [组名] build true     # 组建造权限
/res gset [组名] destroy true   # 组破坏权限
/res gset default move true     # 默认组进入权限

# 组权限列表
/res glist                      # 列出所有组
/res ginfo [组名]               # 查看组权限详情

# 常用组名
- default    # 默认组（所有玩家）
- trusted    # 信任组
- members    # 成员组
- admins     # 管理组

权限优先级说明

玩家权限 > 组权限 > 全局权限
管理员权限 > 普通玩家权限

💰 经济系统

领地买卖

# 出售领地
/res sell [领地名] [价格]       # 出售领地
/res sell [领地名] 0           # 免费转让
/res unsell [领地名]           # 取消出售

# 购买领地
/res buy [领地名]              # 购买出售中的领地
/res selllist                  # 查看出售列表
/res offers                    # 查看收到的报价

领地银行

# 银行操作
/res bank deposit [金额]       # 存款
/res bank withdraw [金额]      # 取款
/res bank show                 # 查看余额
/res bank set [金额]           # 设置余额（管理员）

# 自动支付
/res set bankcharge true       # 启用银行自动支付

经济相关权限

/res set sell true             # 允许出售领地
/res set buy true              # 允许购买领地
/res set bank true             # 允许银行操作

🏠 租赁系统

出租领地

# 设置出租
/res rentable                  # 设置当前领地可出租
/res rentable [领地名]         # 设置指定领地可出租
/res rent [领地名] [价格] [天数] # 发布租赁信息
/res rent stop [领地名]        # 停止出租

# 租赁信息
/res rent list                 # 可租赁列表
/res rent info [领地名]        # 租赁详情
/res rent current              # 当前租赁信息

租客操作

/res rent buy [领地名]         # 租赁领地
/res rent release [领地名]     # 退租
/res rent renew [领地名]       # 续租
/res rent auto [领地名] on/off # 自动续租

租赁管理

/res rent expire [领地名] [天数] # 设置到期时间
/res rent clear [领地名]       # 清除租赁数据
/res rent give [领地名] [玩家]  # 转让租赁

🏘️ 子领地系统

创建子领地

# 在父领地内选择区域后
/res subzone [子领地名]        # 创建子领地
/res subzone [父领地].[子领地] # 完整名称创建

# 子领地列表
/res sublist                   # 当前领地子领地
/res sublist [父领地]          # 指定父领地子领地

子领地权限

# 子领地独立权限
/res [父领地].[子领地] set move false
/res [父领地].[子领地] pset [玩家] build true

# 继承设置
/res set subzoneinherit true   # 子领地继承父权限

子领地管理

/res subremove [父领地].[子领地] # 删除子领地
/res subrename [旧名] [新名]    # 重命名子领地
/res sublistall               # 所有子领地列表

🔧 领地管理

领地调整

# 边界调整
/res expand [格数]            # 向面对方向扩展
/res expand [方向] [格数]     # 指定方向扩展
/res expand vert              # 垂直扩展到顶
/res contract [格数]          # 缩小领地
/res shift [方向] [格数]      # 移动领地

# 方向参数：up, down, north, south, east, west

领地显示

/res show                     # 显示当前领地边界
/res show [领地名]            # 显示指定领地边界
/res show on/off              # 开启/关闭显示模式
/res show visual              # 可视化显示

领地清理

/res cleanarea                # 清理领地内非自然方块
/res removeall [玩家]         # 删除玩家所有领地
/res removeall confirm        # 确认删除

权限复制

/res mirror [源领地] [目标领地] # 复制权限设置
/res mirror confirm           # 确认复制

⚡ 管理员命令

领地管理

/resadmin create [玩家] [领地名] # 为玩家创建领地
/resadmin remove [领地名]       # 强制删除领地
/resadmin removeall [玩家]      # 删除玩家所有领地
/resadmin setowner [领地名] [新主人] # 转移所有权
/resadmin rename [旧名] [新名]  # 重命名领地

权限管理

/resadmin flags [领地名]       # 管理领地标志
/resadmin sieze [玩家]         # 接管玩家领地
/resadmin kick [玩家] [领地]    # 踢出玩家
/resadmin ban [玩家] [领地]     # 封禁玩家

系统管理

/resadmin reload              # 重载配置
/resadmin save                # 手动保存数据
/resadmin cleanup             # 清理数据
/resadmin version             # 查看版本

🎮 实用技巧

批量操作

# 批量设置权限
/res set destroy false place false use false container false

# 批量玩家权限
/res pset [玩家] build true destroy true place true

快捷命令

/res i        # res info
/res l        # res list  
/res t        # res tp
/res s        # res show

领地规划技巧

# 使用子领地划分功能区
/res subzone farm            # 农场区
/res subzone shop            # 商店区
/res subzone house           # 住宅区
/res subzone public          # 公共区

权限组合模板

# 住宅权限模板
/res set move true
/res set build true
/res set destroy true
/res set container true
/res set pvp false

# 商店权限模板  
/res set move true
/res set build false
/res set use true
/res set container true
/res set pvp false

# 公共区域模板
/res set move true
/res set build false
/res set use true
/res set container false

❓ 常见问题

权限问题

Q: 设置了destroy false但玩家还能破坏？

# 检查权限覆盖
/res info                  # 查看当前权限
/res pinfo [玩家]          # 查看玩家权限
# 玩家权限可能覆盖了全局权限

Q: 如何完全禁止非成员进入？

/res set move false
/res set tp false
/res gset default move false

领地问题

Q: 领地创建失败？

/res select size           # 检查选择大小
/res limits                # 检查限制
# 可能原因：大小超限、数量超限、金钱不足

Q: 领地重叠怎么办？

/res info                  # 查看当前领地
/res list                  # 查看附近领地
/res select                # 检查选择区域

经济问题

Q: 领地无法出售？

/res set sell true         # 确保出售权限开启
/res bank show             # 检查银行权限

Q: 租赁系统不工作？

/res rent info             # 检查租赁状态
/res rentable              # 确认可出租状态

其他问题

Q: 领地内怪物还在生成？

/res set monsters false
/res set animals false     # 如果需要

Q: 如何备份领地？

/resadmin save
# 数据位置: plugins/Residence/

Q: 领地传送点设置

# 站在目标位置
/res tpset
/res tp [领地名]

📋 命令速查表

这份完整手册涵盖了 Residence 插件的所有主要功能，从基础操作到高级管理，适合各种水平的玩家参考使用！

半官方

完整命令列表及用法说明

若要以管理员身份运行命令，请使用 /resadmin 而不是 /res。

一、常规命令

• /res ？[页码] – 显示帮助。在末尾键入数字会移至其他页面，默认为第 1 页。
• /resadmin – 每当您想要以管理员身份运行某些内容时，请使用它而不是 /res。

二、选择命令

• /res select [x， y， z] – 使用选择工具（默认为木斧）或将 X、Y 和 Z 指定为这些轴上距您所站立的中心点的距离，选择要保护的长方体区域（“10 5 10”将选择一个 21 宽 x 11 高 x 21 长的区域）。
• /res select chunk – 选择整个块进行保护。
• /res select auto [playername] – 打开自动选择工具。
• /res select expand [amount] – 沿着您的方向展开选择。
• /res select size – 显示所选区域大小。
• /res select shift [amount] – 将选择向您的方向移动。
• /res select vert – 将选择范围从天空扩展到基岩。
• /res select worldedit – 使用 WorldEdit 定义的区域。

三、创建命令

• /res area [add/remove/replace] [areaID] – 向住宅添加或删除区域。这些可以与同一住宅的区域重叠。
• /res create [ResidenceName] – 创建住宅。
• /res remove [ResidenceName] – 删除住宅。
• /res removeall – 删除您的所有住所。
• /res subzone [SubZoneName] – 在您的住所中创建一个子区域。您必须是所有者才能执行此操作。
• /res auto（居住地名称）（半径） – 创建您周围允许的最大居住地。
• /res confirm – 确认删除住宅。

四、信息命令

• /res area list [residence] – 列出住宅内的区域。
• /res show – 显示您当前居住的边界。
• /res area listall [residence] – 列出住宅的区域及其坐标。
• /res current – 显示您当前所在的住所。
• /res info – 获取有关住宅的信息，请关闭以查看有关您所处的住宅的信息。
• /res list [player] – 列出您拥有的住宅或玩家。
• /res listall – 列出所有住宅。
• /res listallhidden – 列出所有隐藏的住宅。
• /res listhidden – 列出隐藏的住宅。
• /res 限制 – 列出所有重要限制。
• /res sublist [residence] [page] – 列出当前居住的所有子区域。访问其他页面所需的居住地姓名和页面。
• /res version – 列出插件版本信息。

五、标志命令

• /res gset [GroupName] [flag] [true/false/remove] – 在不同的组上设置标志。
• /res lset [blacklist/ignorelist] [material] – 从住宅的黑名单/忽略列表中添加/删除材料。
• /res lset info – 列出住宅的黑名单/忽略列表设置。
• /res pset [PlayerName] [flag] [true/false/remove] – 为不同的玩家设置标志。
• /res set [flag] [true/false/remove] – 在住宅上设置标志。
• /res setall [flag] [true/false/remove] – 在所有世界的所有住所上设置标志。
• /res setallfor [playerName] [flag] [true/false/remove] – 在特定玩家拥有的所有住宅上设置通用标志。
• /res clearflags – 从驻留中删除所有标志。
• /res check [residence] [flag] （playername） – 为您检查旗帜状态。
• /res 标志 – 所有标志的列表。
• /resadmin 标志 – 所有管理员标志的列表。
• /res padd [player] – 将玩家添加到住所。
• /res pdel [player] – 将玩家从住所中移除。

六、实用程序命令

• /res expand [amount] – 将您所站的住所扩大到您所面对的方向指定的数量。
• /res 合同 [amount] – 合同居住您所面对的方向指定金额。
• /res default [residence] – 将居住地恢复为默认标志。
• /res give [residence] [player] – 为其他玩家提供住所。玩家必须在线，并且您必须拥有住宅。
• /res lists – 预定义的居住权限列表，请执行“/res lists”了解详细信息。
• /res message [residence] [enter/leave] [message] – 设置进入或离开区域消息。您可以省略使用您所代表的那个。
• /res message [residence] remove [enter/leave] – 删除进入或离开消息。
• /res mirror [source] [target] – 将权限从一个住宅镜像到另一个住宅。您必须是两者的所有者才能执行此操作。
• /res rename [OldName] [NewName] – 重命名住宅。对于子区域，OldName 必须是全名（parent.subzone），而 NewName 只是新名称。
• /res renamearea [residence] [OldName] [NewName] – 重命名附加到住宅的物理区域。
• /res tp [residence] – 传送到某个位置。
• /res tpconfirm – 忽略不安全的传送警告。
• /res tpset – 设置您住所的传送位置。
• /res unstuck – 将您移出保护区域。
• /res 命令 <allow/block/list> – 管理驻地允许或阻止的命令。
• /res compass – 将指南针指针设置为居住位置。
• /res kick – 将玩家踢出住所。
• /res material [material] – 通过其 id 检查材料是否存在。
• /res reset <residence/all> – 将居住地重置为默认标志。
• /res rt （worldname） （playerName） – 传送到世界中的随机位置。
• /res setmain – 将定义的住所设置为主要住所，以作为前缀显示在聊天中。
• /res tool – 显示住宅选择和信息工具名称。

七、聊天命令

• /res rc（住宅） – 加入当前或定义的住宅聊天频道。
• /res rc leave – 离开当前居住聊天频道。
• /res rc setcolor [colorCode] – 设置住宅聊天频道文本颜色。
• /res rc setprefix [newName] – 设置居住聊天频道前缀。
• /res rc kick [player] – 从通道踢玩家。

八、商店命令

带有商店旗帜的住宅可以利用商店命令功能。

• /res shop list – 显示 res shop 的列表。
• /res shop vote [amount] – 投票给住宅商店。
• /res shop like – 为住宅商店提供赞。
• /res shop votes – 显示 res shop 投票。
• /res shop likes – 显示 res shop 点赞。
• /res shop setdesc [text] – 设置住宅商店描述。
• /res shop createboard [place] – 创建 res 商店板。
• /res shop deleteboard – 删除 res shop board。

九、市场/经济命令

• /res lease [renew/cost] [residence] – 续签/显示更新住宅的成本。仅当使用 iConomy 时，费用才适用。
• /res 市场列表 – 查看待售住宅列表。
• /res market info [residence] – 查看待售住宅的信息。
• /res market sell [residence] [amount] – 出售住宅。
• /res market unsell [residence] – 停止出售住宅。
• /res market buy [residence] – 购买住宅。
• /res market rentable [residence] [cost] [days] repeat：<a>t/f</a> – 使住宅一次可出租 [天] 天数，在该时间段内以 [成本] 计价。如果重复：t，则该住宅将在当前承租人到期时自动再次出租。
• /res market rent [residence] <a>repeat：t/f</a> – 租用住宅，如果重复为真，只要业主对可出租人有重复：t，住宅就会在到期时自动重新出租。
• /res 市场发布 [住宅] – 将住宅从出租或可出租状态中删除。
• /res bank [存款/取款] [金额] – 管理住宅中的资金。

十、管理员命令

• /res resadmin [on/off] – 启用或禁用住宅管理。
• /res signconvert – 从 ResidenceSign 插件转换标志。
• /res signupdate – 更新的居住标志。
• /resadmin lease set [residence] [#days/infinite] – 将住宅的租约设置为在 # 天后到期或永不过期。
• /resadmin removeall [player] – 删除玩家拥有的所有住宅。
• /resadmin removeworld [worldName] – 从特定世界中删除所有住宅。注意：小心这一点！这将删除保存在指定世界中的所有住宅。这是无法撤消的。
• /resadmin setowner [residence] [player] – 更改了住宅所有者。
• /resadmin server [residence] – 将 Residence 设置为服务器拥有。
• /resload – 加载住宅插件。注意 res.yml中的任何更改都不会被覆盖。如果您最近添加/更改了res.yml并希望将更改推送到服务器，请使用此设置。
• /resreload – 重新加载住宅插件。注意：将覆盖res.yml中对最初随插件/服务器加载的设置的任何更改。如果您在res.yml中添加了/更改了任何内容，请勿使用。请改用 /resload。

此列表中可能还有更多命令，因为它并不总是最新的。

2025年10月14日，别了，Windows10！

感谢你！Windows10！

Windows编年史

前奏：MS-DOS

1981年
这是一个基于命令行的磁盘操作系统，是早期IBM个人电脑的核心。用户必须通过输入文本指令来执行所有操作，为最初的Windows提供了运行基础。

Windows 1.0

1985年11月20日发布
这是微软对图形用户界面的第一次尝试。它不是一个独立的操作系统，而是在MS-DOS上运行的操作环境。它引入了窗口管理、鼠标控制和有限的协同多任务功能。

Windows 2.0

1987年12月9日发布
相比前代，它允许应用程序窗口相互重叠，并改进了键盘和鼠标性能。著名的桌面出版软件Aldus PageMaker于此版本登陆Windows，为其带来了商业价值。

Windows 3.0

1990年5月22日发布
这是第一个取得巨大商业成功的Windows版本。它拥有重新设计的用户界面，支持16色，并改进了对Intel 8086/8088处理器的利用。它引入了程序管理器和文件管理器。

Windows 3.1

1992年4月6日发布
这是一个重要的更新版本，引入了TrueType字体，使Windows成为一个可行的桌面出版平台。它还首次包含了Windows徽标键支持，并普及了扫雷游戏。

Windows 95

1995年8月24日发布
这是一个里程碑式的版本。它带来了许多定义现代操作系统的元素，包括开始菜单、任务栏和桌面图标。它是一个独立的操作系统，不再需要单独购买DOS。

Windows 98

1998年6月25日发布
这个版本深度集成了Internet Explorer浏览器和Windows桌面，推动了互联网的普及。它改进了对USB和外设的支持，并引入了快速启动栏。

Windows ME

2000年9月14日发布
这个面向家庭用户的版本旨在提供丰富的多媒体体验。它引入了系统还原功能，但因其不稳定和基于DOS内核的限制而饱受批评，被认为是寿命最短的Windows版本之一。

Windows 2000

2000年2月17日发布
这是一个面向商业环境的强大且稳定的操作系统，源于Windows NT架构。它显著改进了安全性和网络功能，主要部署于企业和工作站。

Windows XP

2001年10月25日发布
这是微软史上最成功和最受欢迎的操作系统之一。它统一了消费级和企业级产品线，拥有全新的Luna用户主题，极大的提高了系统的稳定性和易用性，生命周期极长。

Windows Vista

2007年1月30日发布
这个版本引入了华丽的Aero Glass视觉特效，包括毛玻璃效果和窗口动态翻转。它加强了安全机制，但也因资源需求过高、兼容性差和频繁的用户账户控制提示而受到广泛批评。

Windows 7

2009年10月22日发布
它被视为对Vista的修正和升华。Windows 7保留了Vista的优点，同时大幅提升了性能、稳定性和兼容性。它改进了任务栏，增加了钉钉功能和触摸屏支持，获得了用户的一致好评。

Windows 8

2012年10月26日发布
这是一个为触摸时代设计的激进改革版本。它移除了传统的开始菜单和开始按钮，引入了全新的Metro风格开始屏幕。这一改动虽然针对平板优化，但却让许多桌面用户感到困惑和不便。

Windows 8.1

2013年10月17日发布
这是一个重要的更新，回应了用户对Windows 8的批评。它重新引入了开始按钮，并允许系统直接启动到桌面，改善了传统桌面模式下的使用体验。

Windows 10

2015年7月29日发布
微软宣称这是“最后一个Windows版本”，采用“Windows即服务”的模式进行持续更新。它带回了熟悉的开始菜单，并将其与现代动态磁贴相结合。引入了新的浏览器Microsoft Edge，并内置了智能语音助手Cortana。

Windows 10 Version 1507 (Build 10240)

2015年7月发布。这是Windows 10的初始正式版本，代号"Threshold 1"。它确立了Windows 10的核心体验：

• 回归的开始菜单：结合了Windows 7的传统布局和Windows 8的动态磁贴。
• Microsoft Edge浏览器：全新打造，取代IE成为默认浏览器，初始项目代号为"Spartan"。
• 任务视图与虚拟桌面：方便用户在不同任务和空间之间切换。
• Cortana集成：深度集成到任务栏的智能语音助手。
• 设置与应用：引入了现代化的“设置”应用，并推广可在电脑、平板、手机等多设备上运行的通用Windows应用。

Windows 10 Version 1511 (Build 10586) - 十一月更新

2015年11月发布。这是Windows 10的第一个重大更新，带来了多项改进和新功能：

• 性能提升：显著改进了Edge浏览器性能、启动时间和电池续航。
• 默认应用设置：在设置中简化了按文件类型设置默认应用的流程。
• Skype集成：将Skype消息、通话和视频集成到系统中，取代了之前的“Messaging”应用。
• 用户界面微调：对开始菜单、任务栏和操作中心进行了视觉和功能上的细微调整。

Windows 10 Version 1607 (Build 14393) - 周年更新

2016年8月发布。这是一个非常重大的更新，代号"Redstone 1"，带来了大量新特性：

• Windows Ink 工作区：为触控笔用户提供快速访问草图板、屏幕草图和白板的功能。
• Cortana增强：支持在锁屏界面使用，并可以识别手写笔记中的提醒。
• Windows Defender 安全中心：统一的安全管理和查看界面。
• Bash on Ubuntu on Windows：通过WSL子系统，原生支持运行Ubuntu Linux二进制可执行文件，对开发者意义重大。
• Edge浏览器扩展：为Edge浏览器引入了扩展插件支持。

Windows 10 Version 1703 (Build 15063) - 创意者更新

2017年4月发布。此更新侧重于创意和娱乐体验，代号"Redstone 2"：

• Paint 3D：全新的3D画图工具，鼓励用户创建和编辑3D对象。
• Microsoft Edge：新增电子书阅读功能，并改进了标签页管理。
• 游戏模式：优化系统资源分配，为游戏提供更高的CPU和GPU优先级，以提升游戏性能。
• 夜灯模式：通过减少屏幕蓝光来缓解视觉疲劳。

Windows 10 Version 1709 (Build 16299) - 秋季创意者更新

2017年10月发布。继续深化创意体验，代号"Redstone 3"：

• Fluent Design System：引入了微软全新的流畅设计语言，带来更具深度、动画和透明效果的视觉体验。
• Story Remix：后来演变为"视频编辑器"，可自动将照片和视频生成带有3D效果、转场和背景音乐的视频。
• OneDrive文件随选：允许用户在不占用本地空间的情况下，在文件资源管理器中看到所有云端文件。
• 与手机的深度链接：改进了与iOS和Android设备的连接体验。

Windows 10 Version 1809 (Build 17763) - 2018年十月更新

2018年11月发布。此版本因发布初期严重的文件删除Bug而闻名，但最终稳定后包含了一些关键功能，代号"Redstone 5"：

• 云剪贴板：支持跨设备同步剪贴板历史记录（通过Win+V调用）。
• 截图与草图：全新的截图工具，取代了旧的“截图工具”，并与通知中心更好地集成。
• 暗色主题文件资源管理器：为文件资源管理器引入了完整的暗色主题。
• 你的手机应用：开始更紧密地连接Android手机，实现短信同步和照片查看。

Windows 10 Version 2004 (Build 19041) - 2020年五月更新

2020年5月发布。这是一个重要的功能更新，内部版本号从v1809的17xxx跃升至19xxx：

• 新版Cortana：作为一个独立应用发布，专注于生产力，支持拖拽和聊天式界面。
• Windows Subsystem for Linux 2 (WSL 2)：使用了完整的Linux内核，带来了显著的性能提升和完整的系统调用兼容性。
• 虚拟桌面重命名：允许用户为不同的虚拟桌面自定义名称。
• DirectX 12 Ultimate：为游戏带来了新的图形技术，如光线追踪、可变速率着色等。

Windows 10 Version 21H2 (Build 19044)

2021年11月发布。这是Windows 10最后一个功能更新，主要专注于安全性和底层改进，新功能非常有限：

• WPA3 H2E标准支持：增强了Wi-Fi安全性。
• Windows Hello改进：为无密码登录提供了更好的支持。
• 此后，Windows 10转入仅接收安全更新和次要修补的支持阶段，开发重心全面转向Windows 11。

Windows 10 22H2 终极版本

Windows 10 版本 22H2（操作系统内部版本 19045）是 Windows 10 的最后一个功能更新版本。微软已明确表示，此后不会再为 Windows 10 推出任何新功能更新，22H2 即为该系统的终极版本。

22H2 在 21H2 的基础上，引入了一系列新功能和改进，旨在提升用户体验、生产力和系统性能：

• 用户界面与个性化：

  • Windows Spotlight 桌面：你可以将桌面壁纸设置为由 Microsoft 提供的、每日更新的 Bing 精美图像。
  • 增强的锁屏界面：锁屏界面不仅显示天气，还新增了体育、财经和交通信息等更多动态内容。
  • 开始菜单改进：支持创建应用文件夹，方便更好地组织和管理应用。

• 生产力与多任务处理：

  • 任务栏拖放功能：改进了任务栏的拖放操作体验，使用更加流畅。
  • 新的任务管理器：提供了更先进的界面和功能，便于监控和管理系统资源。
  • 改进的分享功能：可以直接将网页链接（URL）分享到 WhatsApp、Gmail、Facebook 和 LinkedIn 等应用程序。

• 辅助功能与工具：

  • 实时字幕：为系统中的音频内容提供实时字幕，提升无障碍体验。
  • 语音访问：允许用户通过语音命令来控制和操作电脑。
  • 优化的截图工具：修复了在开启“讲述人”辅助功能时可能出现的卡顿问题。

• 性能、安全与兼容性：

  • 对最新硬件的支持：为新型号的 CPU、GPU 和其他硬件提供了更好的兼容性和支持。
  • 增强的安全防护：包括更新的易受攻击驱动程序阻止列表，以防范 BYOVD（自带易受攻击驱动程序）攻击。
  • Windows Subsystem for Linux (WSL) 改进：带来了更高效的性能。

Windows 11

2021年10月5日发布
这是目前最新的主要版本。它拥有全新的、以居中式任务栏和开始菜单为中心的现代化界面设计。加强了窗口管理和多任务功能，并直接集成了Android子系统，允许用户在电脑上运行移动应用。对硬件安全有更高要求，需要TPM 2.0支持。

“The Next Chapter” & “A more human way to do.” （下一篇章 & 一种更人性化的操作方式）

Windows 10 宣传标语

再见了，Windows10！

永别了，Windows 10！

致Windows 10：一个时代的温暖告别

在科技的长河里，每一个操作系统的更迭都像是一段岁月的书签。当微软宣布Windows 10将在2025年走向生命终点时，无数人的心中泛起了一丝难以名状的涟漪。这不只是一款软件的退役，更是一个数字时代的温情谢幕。

回想2015年的夏天，Windows 10带着“升得精彩”的承诺翩然而至。那时的我们，刚从Windows 8的颠覆性变革中回过神来，迫切需要一个既熟悉又创新的归宿。你来了，带着回归传统的开始菜单，却又巧妙地融入了现代的动态磁贴——这何尝不是一种对过去的尊重与对未来的拥抱？

你的出现，像极了人生中的某个重要驿站。记得那些深夜，Cortana温柔的声音陪伴着赶工的我；记得任务视图让繁杂的工作变得井然有序；更记得Edge浏览器虽然稚嫩，却代表着重新出发的勇气。你见证了多少人的青春——从校园到职场，从青涩到成熟。

你最大的温柔，在于懂得平衡。不像前辈Windows 8那般激进，也不像后继者Windows 11那样追求极致的现代感。你保留了足够的传统元素让老用户感到安心，又引入了恰到好处的新功能满足时代的需要。这种中庸之道，让你成为了最多人愿意停留的港湾。

在兼容性方面，你几乎做到了极致。从古老的办公软件到最新的游戏，你都能从容应对。那些在其他系统上可能无法运行的经典程序，在你这里总能找到生存的空间。这种包容，让多少人在数字转型的洪流中得以喘息。

你的设计语言或许不够惊艳，但足够温暖。那个被称为“亚克力”的半透明效果，那些圆润的窗口角落，还有那些恰到好处的动画——它们共同营造了一个既专业又不失亲和的工作环境。在这里，创造力与生产力得以和谐共处。

如今，当我们即将迎来你的告别之时，不禁要问：为什么我们如此怀念？也许是因为你代表了一个特定的时代——那个移动互联网刚刚成熟、人工智能初露锋芒、工作与生活开始深度交融的时代。你是这个时代的数字见证者。

更让人感慨的是，你的离去标志着一个理念的终结。微软曾说你是“最后一个Windows版本”，承诺通过持续更新让你永葆青春。这个美好的愿景最终还是在技术的洪流中改变了方向。你的存在，提醒着我们：在追求创新的路上，有时也需要停下来巩固与完善。

在无数人的记忆里，你不仅是工具，更是伙伴。那些通过你完成的毕业论文，那些在你平台上运行的游戏时光，那些依靠你完成的工作项目——所有这些生活的碎片，都与你紧密相连。

告别从来都不容易，特别是告别一个陪伴了近十年的老朋友。但正如生命的轮回，技术的进步从不停歇。当我们在更新的系统上继续前行时，会记得曾经有一个系统，它平衡了创新与传承，在变革的时代为我们提供了温暖的栖息之地。

再见，Windows 10。你不仅是操作系统演进中的重要一环，更是无数人数字生活中难以磨灭的记忆坐标。在科技的编年史里，你永远拥有一个独特而温暖的位置。

同时，感谢AI！

建议先阅读个人对于 身高歧视 的评价 - 壹鲦热带鱼的小窝

正文

标题的意义

直意

吾辈既居权威之下，所成之事必谬，意思即我们这代人活在权威之下，所有的事情必当是错误的，显而易见
这里是权威指尊敬的教师
说实话，这也是一篇讽刺文，因为时间缘故，有些东西，不会藏的很深，这可能是一场赤裸裸的讽刺
我接受义务教育也已经有6年多了，谬，必，从学习成绩到实际行动，无处不在的权威，我们永远是被批判者，毫无反驳之权

批注

在教室里，真理的标准往往不是事实，而是讲台上那个人的脸色。

具体事例

在本文中，我们将会列举几个事例，来说明我的看法

事例一：【2025年-初一】课堂上的“阴阳怪气”与“当众处刑”

让我先从最近发生的“笔记事件”说起

这是10月13日的英语课上，我们老师一如既往地让我们做笔记，老师走到我们的 方同学（化名） 面前，看到他的书上，一个字也没动过，老师的眉头逐渐难看，
接下来，又是这熟悉的流程...

老师走回到讲台，大声的说：哎呀，我们的方同学是没有手啊？连笔记都不会做呀？

我们老师当时就跟小南娘似的，虽然女老师也可以骂娘炮

【阅读链接】以下是我们英语老师在开学的自我介绍
Hello everyone, I am Alice. In this academic year, I will be your English teacher. I have been teaching for 12 years, including 2 years in the UK and 10 years in China, so I am very experienced and can communicate with people in the UK as well. I am really looking forward to learning together with you.
此处省略20单词

从上面的阅读链接中，虽说能体会到我们的英语老师英语很牛逼，但是，去英国，难道不是只有有钱人才能去的吗？没钱去个屌，在入境的时候都被拦了

继续，老师开始体现她的权威了：我不是在批评你，我是在批评你的态度！态度决定一切！你这个样子，能考出什么样子？？？

欣喜的是，老师没说他是她带过的最差的一个学生

总结：整个过程依旧新云流水，从“笔记像屎”到“态度问题”，顶级转场，方同学，也是成功成为了“学习态度不端正”的坏学生，这一切，三分钟不到

事例二：【2025年-初一】称呼

依旧是我们英语老师与方同学的事情

起因：我们的方同学忘记交英语听写本了
英语老师找到方同学，说：方同学，你的听写本呢？
方同学递给老师听写本，在这呢
猎奇，老师说：哎呀，我们的方同学连我的姓也忘记啦？算了，忘记就忘记了吧？但是方同学你怎么连我的英文名Alice都不知道了啊？

我是没什么想说的了
说实话，到了初一，我倒是没见过有人叫老师还加姓氏的，虽说这样也不礼貌，但是初一了，胆子肥了，不说还好吧
我们的英语老师感觉有点过于较真儿了，有点抽象

事例三：【2024年-小六】坏学生一定会被权威所压迫吗：老师是可以有借口的

这是小学六年级的事情，事情中的老师指我们的学生班主任徐老师，沈同学依旧是化名

沈同学在下课的时候问同学一道题
徐老师看见，问：沈同学，你在讲什么？期末考能考100分了？？就这么放纵？？？
沈同学说：我问题啊，咋了，下课都不能问题了？
老师说：你自己上课不好好听，有什么好问的，自己去做

【阅读材料】
子贡问曰：“孔文子何以谓之‘文’也？”子曰：“敏而好学，不耻下问，是以谓之‘文’也。”
选自《论语·公冶长》

语文老师：

• 上课：敏而好学
• 下课：不能好学，自己的问题

抽象，虽然说我们的语文老师也是大学生毕业，得过且过，算了算了，毕竟给我们的好处也足够多了吧？

事例四：【2024年-小学】奠定的对应关系

简说

$$ \text{没带作业=没写作业} $$

$$ \text{上课走神=不尊重老师} $$

$$ \text{忘记给家长签字=不敢给家长签字} $$

$$ \text{忘记把作业带回家=懒得写作业} $$

$$ \text{解释=顶嘴} $$

$$ \text{低头看书=看没用的书} $$

$$ \text{问老师问题=没预习到位} $$

$$ \text{错题多=没用心练} $$

$$ \text{忘记值日=没有责任心} $$

已经没什么好说的了

细说(Deepseek)

经过仔细观察，我发现了教师权威运作的“完美”逻辑链：

逻辑一：错误必然化
只要你在老师的权威范围内，你必然会有错误。没有明显的错误？那就找潜在的错误。作业全对？那可能是你抄袭的。积极发言？那可能是你爱出风头。

逻辑二：错误道德化
任何具体错误，最终都会上升到“态度问题”“人品问题”。忘记带作业=不负责任；上课走神=不尊重老师；回答问题错误=不认真听讲。

逻辑三：批评公开化
批评必须公开进行，因为私下的批评无法起到“杀鸡儆猴”的作用。当众羞辱是维护权威最有效的手段。

逻辑四：解释无效化
学生的任何解释都被视为“顶嘴”“狡辩”。在权威的法庭上，被告没有辩护权。

逻辑五：结论绝对化
“我教书二十年”成为最常用的终极武器。时间的长度自动转化为正确的程度，质疑老师就是质疑真理。

这套逻辑链的可怕之处在于它的自我闭环——你无法从内部打破它，因为你的任何反抗行为都会被这个系统自动识别为新的错误证据。

“为你好”——最无懈可击的暴力

如果长辈的权威有万能盾牌，那，一定是为你好

这三个字的神奇之处在于：

• 它将一切不合理变得合理
• 它将一切暴力转化为“关爱”
• 它让受害者产生“不识好歹”的负罪感

我曾经亲眼目睹一个家长把孩子叫到公园，当着所有人的面训斥了整整40分钟。回来后，那个同学眼睛红肿，整整一天没有说话。
当有人质疑这种方式是否太伤人时，家长的回答是：“我现在严格一点，是为他好！等他将来到社会上，就知道感谢我了！”
多么完美的逻辑呀：现在的伤害是为了未来的受益。至于这个伤害到底有多大，这个受益是否真的会来，都不重要。重要的是，“为你好”这个咒语，让施暴者心安理得

我们，永远是：抗争->接受

没什么好说的
来自实验中学某个人说的：

初一上学期：积极抗争
刚进入初中时，我们还保有着小学生的直率。被冤枉时会大声辩解，觉得不公平时会提出异议。结果呢？大多数人都碰得头破血流

初一下学期：学会沉默
经过一个学期的“教育”，我们明白了：解释=顶嘴，质疑=挑衅。最安全的方式是保持沉默，即使内心波涛汹涌，表面也要波澜不惊

初二：逐渐麻木
当沉默成为习惯，麻木就开始蔓延。不再思考对错，只记住标准答案；不再坚持自我，只学会察言观色

初三：完全适应
到了初三，我们已经能熟练地在权威体系中生存。知道什么该说，什么不该说；知道如何讨好老师，如何避免冲突。我们成了这个体系合格的“产品”

这个过程，被美其名曰“成长”。而我认为，这更像是一个独立思考能力被逐渐剥夺的过程。

说了半天，到底，什么才算“教育权威？”

我不认为所有的教育权威都是该讽刺的，分以下几种

• 专业权威
• 人格权威
• 理性权威
• 职业权威[贬]
• 暴力权威[贬]

说着好像没什么大不了的，那么，我问你，Look in my eyes, I ask you, how many situations have you seen?，嗯，如果是第一到第三种见的比较多，那么，我的评价是：羡慕死了，有一个好老师

权威，不是全部

某些温柔的人，值得我们记住

如果一个长辈，只是用权威来维护自己的权威性，那么，只能说：$\text{树立自己的权威形象}$，毫无任何意义

当一个人只会用暴力来维持权威的时候，恰恰证明，$\text{他是个表面的巨人，实际的懦夫}$

感觉这篇文章结构还是有点乱，总之，我的意思就是，我有点反对那种权威=一切的思想，当然，个人观点，个人观点，个人观点，没什么好说的，散会

用#标题还是有原因的
我从来不否认我写blog不会用AI

【知识要点】栈、队列、堆、优先队列

1. 栈(Stack)和队列(Queue)基础

1.1 基本概念对比

1.2 队列的详细定义

• 队列是C++标准库中的重要数据结构
• 允许删除的一端称为队头(Front)
• 允许插入的一端称为队尾(Rear)
• 空队列：队列中没有元素的状态
• 操作原则：先进先出(FIFO)

1.3 C++队列基本操作示例

#include<bits/stdc++.h>
using namespace std;

int main() {
    queue<int> q; // 定义一个空队列
  
    for(int i=0; i<5; i++) {
        q.push(i); // 将i插入到队尾
    }
  
    q.emplace(32); // 将32放置到队尾，作用和push一样
  
    cout << q.size() << endl; // 输出队列中元素的个数
  
    while(!q.empty()) { // 当队列不为空时，继续循环
        cout << q.front() << endl; // 输出队列中的首元素
        q.pop(); // 将元素从队头删除
    }
  
    return 0;
}

1.4 队列queue的完整函数列表

• q.pop() - 删除queue的队头元素
• q.front() - 返回队列的队头元素，但不删除
• q.back() - 返回队列的队尾元素，但不删除
• q.push(arg) - 将元素arg插入到队列的队尾
• q.emplace(arg) - 将元素arg放置到队列的尾部(效果同push)
• q.size() - 返回队列中元素的个数
• q.empty() - 队列为空时返回true，否则false
• q.swap(q1) - 交换q和q1中的元素(交换底层数据结构)
• swap(q,q1) - 非成员函数，效果同成员函数swap

1.5 队列的应用场景

• BFS(广度优先搜索)算法
• 单调队列
• 缓冲区管理
• 任务调度

2. 堆(Heap)与优先队列(Priority Queue)

2.1 堆的基本概念

• 堆是一类特殊的数据结构，常用的是二叉堆
• 形式上是一个数组，本质上是一棵完全二叉树

• 分为大根堆和小根堆：

  • 大根堆：除根节点外，每个节点的值都大于等于其子节点的值

    • 公式表示：A[parent(i)] >= A[i]

  • 小根堆：除根节点外，每个节点的值都小于等于其子节点的值

    • 公式表示：A[parent(i)] <= A[i]
• 堆中的任一子树也还是堆

2.2 堆的基本操作

• push操作(插入)：往堆尾加入元素，并通过从下往上调整保持堆性质
• get操作(删除)：取出堆顶元素，用堆尾元素覆盖堆顶，再从上往下调整

2.3 优先队列的实现

C++中用 priority_queue实现堆的功能：

#include <bits/stdc++.h>
using namespace std;

int main() {
    // 默认大根堆
    priority_queue<int> max_heap;
  
    // 小根堆定义方式
    priority_queue<int, vector<int>, greater<int>> min_heap;
  
    // 自定义结构体的优先队列
    struct Node {
        int u, len;
        bool operator < (const Node &x) const {
            return x.len < len; // 注意这里是反向定义，实现小根堆效果
        }
    };
  
    priority_queue<Node> custom_heap;
  
    return 0;
}

2.4 优先队列的操作函数

• push(Elem e) - 插入元素，时间复杂度O(log n)
• pop() - 删除顶部元素，O(log n)
• top() - 返回顶部元素，O(1)
• size() - 返回元素数量
• empty() - 判断是否为空

2.5 优先队列的特殊注意事项

1. 不支持除顶部外其他元素的访问和操作
2. 没有内置的clear()操作，需要手动实现：

void clear(priority_queue<int> &q) {
    while (!q.empty()) q.pop();
}

3. 访问top()前必须检查队列是否为空

3. 经典问题与解决方案

3.1 合并果子问题

问题描述：有n堆果子，每次合并两堆消耗体力值为两堆果子数之和，求最小总消耗。

解决方案：

#include <bits/stdc++.h>
using namespace std;

int main() {
    int n, ans = 0;
    cin >> n;
    priority_queue<int, vector<int>, greater<int>> q;
  
    for(int i = 0; i < n; i++) {
        int x; cin >> x;
        q.push(x);
    }
  
    while(q.size() > 1) {
        int x = q.top(); q.pop();
        int y = q.top(); q.pop();
        ans += x + y;
        q.push(x + y);
    }
  
    cout << ans;
    return 0;
}

时间复杂度分析：O(n log n)

3.2 互数问题

问题描述：给定素数集合S，生成由S中素数乘积构成的"互数集合"，求第n小的互数。

解决方案：

typedef long long ll;

int main() {
    ll k, n;
    cin >> k >> n;
    vector<ll> primes(k);
    priority_queue<ll, vector<ll>, greater<ll>> heap;
    set<ll> seen;
  
    for(int i = 0; i < k; i++) {
        cin >> primes[i];
        heap.push(primes[i]);
        seen.insert(primes[i]);
    }
  
    ll humble = 1;
    for(int i = 0; i < n; i++) {
        humble = heap.top(); heap.pop();
        for(auto p : primes) {
            ll num = humble * p;
            if(seen.find(num) == seen.end()) {
                seen.insert(num);
                heap.push(num);
            }
        }
    }
  
    cout << humble;
    return 0;
}

时间复杂度分析：O(nk log n)

3.3 两个序列的最小N个和

问题描述：有两个长度为N的有序序列A和B，求A和B中各取一个数相加得到的N²个和中最小的N个。

解决方案：

#include <bits/stdc++.h>
using namespace std;

const int maxn = 1e5 + 10;

struct HeapNode {
    int x, val;
    bool operator < (const HeapNode &other) const {
        return val > other.val; // 小根堆
    }
};

int main() {
    int n, a[maxn], b[maxn], pos[maxn] = {0};
    priority_queue<HeapNode> q;
  
    cin >> n;
    for(int i = 0; i < n; i++) cin >> a[i];
    for(int i = 0; i < n; i++) cin >> b[i];
  
    // 初始时每个a[i]配b[0]
    for(int i = 0; i < n; i++) {
        q.push({i, a[i] + b[0]});
    }
  
    for(int i = 0; i < n; i++) {
        HeapNode tmp = q.top(); q.pop();
        cout << tmp.val << " ";
        int x = tmp.x;
        if(++pos[x] < n) {
            q.push({x, a[x] + b[pos[x]]});
        }
    }
  
    return 0;
}

时间复杂度分析：O(n log n)

4. 高级应用提示

1. Dijkstra算法优化：堆/优先队列可用于优化Dijkstra最短路径算法，将时间复杂度从O(V²)降低到O(E + V log V)
2. 单调队列：一种特殊的队列，可以高效解决滑动窗口最值问题
3. 多路归并：优先队列可以高效解决多路归并问题，如上面的最小N个和问题
4. Huffman编码：优先队列可用于构建最优前缀编码树

5. 总结

掌握这些基础数据结构及其应用场景，对于算法学习和编程竞赛至关重要。优先队列作为堆的高级抽象，在实际应用中更为方便，但理解其底层堆的原理同样重要。

【熟能生巧】

P9588 「MXOI Round 2」队列

题目描述

小 C 有一个队列，他要对这个队列进行 $q$ 次操作。操作共四种，参数分别如下：

$1\ x$：这是第一种操作，表示从队尾依次插入 $1,2,3,\cdots,x$；

$2\ y$：这是第二种操作，表示弹出队头的前 $y$ 个元素；

$3\ z$：这是第三种操作，表示查询队列中的第 $z$ 个元素；

$4$：这是第四种操作，表示查询队列中所有元素的最大值。

你需要帮助他维护这个队列，并对于每个第三种操作和第四种操作，输出查询的答案。

输入格式

第一行两个整数 $c,q$，其中 $c$ 表示测试点编号。$c=0$ 表示该测试点为样例。

接下来 $q$ 行，每行 $1 \sim 2$ 个整数，表示一个操作，格式见【题目描述】。

输出格式

对于每个第三种操作和第四种操作，输出一行一个整数，表示查询的答案。

输入输出样例 #1

输入 #1

0 9
1 5
1 3
2 2
1 4
3 6
3 8
2 4
4
3 3

输出 #1

3
2
4
1

说明/提示

【样例解释 #1】

在进行第四次操作后，队列中的元素依次为 $3,4,5,1,2,3,1,2,3,4$。

在进行第七次操作后，队列中的元素依次为 $2,3,1,2,3,4$。

【数据范围】

设 $\sum x$ 表示单个测试点内 $x$ 之和。

对于 $100\%$ 的数据，$1 \le q \le 2\times 10^5$，$1 \le x,y,z \le 10^9$，$0 \le \sum x \le 2\times10^{14}$，保证在进行第二种操作前队列内元素个数不小于 $y$，在进行第三种操作前队列内元素个数不小于 $z$，在进行第四种操作前队列内元素个数大于 $0$。

特殊性质 A：没有第二种操作。

特殊性质 B：没有第三种操作。

特殊性质 C：没有第四种操作。

P2723 [USACO3.1] 丑数 Humble Numbers

题目描述

对于一给定的素数集合 $S = \{ p_1, p_2, ..., p_k \}$, 考虑一个正整数集合，该集合中任一元素的质因数全部属于 $S$。这个正整数集合包括，$p_1$、$p_1 \times p_2$、$p_1 \times p_1$、$p_1 \times p_2 \times p_3$ ...(还有其它)。该集合被称为 $S$ 集合的“丑数集合”。注意：我们认为 $1$不是一个丑数。

你的工作是对于输入的集合 $S$ 去寻找“丑数集合”中的第 $n$ 个“丑数”。保证答案可以用 32 位有符号整数表示。

补充：丑数集合中每个数从小到大排列，每个丑数都是素数集合中的数的乘积，第 $n$ 个“丑数”就是在能由素数集合中的数相乘得来的（包括它本身）第 $n$ 小的数。

输入格式

输入的第一行是两个的整数，分别代表集合 $S$ 的大小 $k$ 和给定的参数 $n$。

输入的第二行有 $k$ 互不相同的整数，第 $i$ 个整数代表 $p_i$。

输出格式

输出一行一个整数，代表答案。

输入输出样例 #1

输入 #1

4 19
2 3 5 7

输出 #1

27

说明/提示

数据规模与约定

对于 $100\%$ 的数据，保证：

• $1 \leq k \leq 100$。
• $1 \leq n \leq 10^5$。
• $2 \leq p_i < 2^{31}$，且 $p_i$ 一定为质数。

说明

题目翻译来自 NOCOW。

USACO Training Section 3.1

P1323 删数问题

题目描述

一个集合有如下元素：$1$ 是集合元素；若 $P$ 是集合的元素，则 $2\times P+1$，$4\times P+5$ 也是集合的元素。

取出此集合中最小的 $k$ 个元素，按从小到大的顺序组合成一个多位数，现要求从中删除 $m$ 个数位上的数字，使得剩下的数字最大，编程输出删除前和删除后的多位数字。

注：不存在所有数被删除的情况。

输入格式

只有一行两个整数，分别代表 $k$ 和 $m$。

输出格式

输出为两行两个整数，第一行为删除前的数字，第二行为删除后的数字。

输入输出样例 #1

输入 #1

5  4

输出 #1

137915
95

说明/提示

数据规模与约定

• 对于 $30\%$ 的数据，保证 $1\le k,m\le300$。
• 对于 $100\%$ 的数据，保证 $1\le k,m\le3\times10^4$。

P2085 最小函数值

题目描述

有 $n$ 个函数，分别为 $F_1,F_2,\dots,F_n$。定义 $F_i(x)=A_ix^2+B_ix+C_i(x\in\mathbb N*)$。给定这些 $A_i$、$B_i$ 和 $C_i$，请求出所有函数的所有函数值中最小的 $m$ 个（如有重复的要输出多个）。

输入格式

第一行输入两个正整数 $n$ 和 $m$。

以下 $n$ 行每行三个正整数，其中第 $i$ 行的三个数分别为 $A_i$、$B_i$ 和 $C_i$。

输出格式

输出将这 $n$ 个函数所有可以生成的函数值排序后的前 $m$ 个元素。这 $m$ 个数应该输出到一行，用空格隔开。

输入输出样例 #1

输入 #1

3 10
4 5 3
3 4 5
1 7 1

输出 #1

9 12 12 19 25 29 31 44 45 54

说明/提示

数据规模与约定

对于全部的测试点，保证 $1 \leq n,m\le10000$，$1 \leq A_i\le10$,
$0 \leq B_i\le100$,
$0 \leq C_i\le10^4$。

【答案校对】

队列

#include <bits/stdc++.h>
#define int long long
using namespace std;
const int N=800010;
int c,T,t,i,cnt,op,x,del,qwq,f[N],l[N],r[N],a[N*2],h=1,n=400005;
int read(){
    int f=1,x=0;char ch=getchar();
    while(ch<'0'||ch>'9'){ 
        if(ch=='-') f=-1;
        ch=getchar();
    }
    while(ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return f*x;
}
void update(int x,int l,int r,int ql,int qr,int k){
    int mid=(l+r)>>1;
    if(ql<=l&&r<=qr){
        a[x]=k;return;
    }
    if(ql<=mid) update(x*2,l,mid,ql,qr,k);
    if(qr>mid) update(x*2+1,mid+1,r,ql,qr,k);
    a[x]=max(a[x*2],a[x*2+1]);
}
int query(int x,int l,int r,int ql,int qr){
    int mid=(l+r)>>1,sum=0;
    if(ql<=l&&r<=qr){
        return a[x];
    }
    if(ql<=mid) sum=max(sum,query(x*2,l,mid,ql,qr));
    if(qr>mid) sum=max(sum,query(x*2+1,mid+1,r,ql,qr));
    return sum;
}
signed main(){
    cin>>c>>T;
    while(T--){
        op=read();
        if(op==1)
            x=read(),l[++t]=1,r[t]=x,update(1,1,n,t,t,x),f[t]=f[t-1]+x;
        else if(op==2){
            x=read();cnt=0;
            for(i=h;i<=t;++i){
                cnt+=r[i]-l[i]+1;
                if(cnt>=x){
                    cnt-=r[i]-l[i]+1;
                    l[i]+=x-cnt;del+=x-cnt;
                    if(l[i]>r[i])update(1,1,n,i,i,0),++h;
                    break;
                }
                del+=r[i]-l[i]+1;r[i]=l[i]=0;++h;
                update(1,1,n,i,i,0);
            }
        }
        else if(op==3){
            x=read();
            qwq=lower_bound(f+h,f+t+1,del+x)-f;
            printf("%lld\n",del+x-f[qwq-1]);
        }
        else printf("%lld\n",query(1,1,n,h,t));
    }
}

丑数

#include <bits/stdc++.h>
#define int long long
using namespace std;
int n,m,i,j,a[105],b[105],s[100005],zx;
signed main(){
    cin>>n>>m;
    for(i=1;i<=n;i++)
        cin>>a[i];
    s[0]=1;
    for(i=1;i<=m;i++){
        zx=pow(2,31)-1;
        for(j=1;j<=n;j++){
            while(a[j]*s[b[j]]<=s[i-1])
                b[j]++;
            if(a[j]*s[b[j]]<zx)
                zx=a[j]*s[b[j]];
        }
        s[i]=zx;
    }
    cout<<s[m];
}

删数问题

#include <bits/stdc++.h>
#define int long long
using namespace std;
priority_queue<int,vector<int>,greater<int> > q;
string p;
int k,m,s;
signed main(){
    ios::sync_with_stdio(false);
    cin.tie(NULL);cout.tie(NULL);
    cin>>k>>m;
    q.push(1);
    while(k){
        int s=q.top();
        p=p+to_string(s);
        q.pop();
        q.push(s*2+1);
        q.push(s*4+5);
        k--;
    }
    cout<<p<<"\n";
    while(true){
        for(int i=0;i<p.size();i++){
            if(p[i+1]>p[i]){
                s++;
                p.erase(i,1);
                if(s>=m){
                    cout<<p;
                    exit(0);
                }
                break;
            }
        }
    }
}

最小函数值

#include <bits/stdc++.h>
#define int long long
using namespace std;
int a[10001],b[10001],c[10001],n,m,s[10000001],i,j,t;
signed main(){
    cin>>n>>m;
    for(i=1;i<=n;i++) cin>>a[i]>>b[i]>>c[i];
    for(i=1;i<=n;i++) for(j=1;j<=100;j++) s[++t]=a[i]*j*j+b[i]*j+c[i];
    sort(s+1,s+1+t);
    for(i=1;i<=m;i++) cout<<s[i]<<" ";
}

T1

【题面】T678583 A美丽数 (beauty)

题目描述

小 B 对数字有着独到的见解，他认为一个数是美丽数当且仅当这个数的相邻两位都不相同。

例如12345、12121是美丽数，而123321、11不是美丽数。
现在小B想知道，对于所有满足以下条件的数中，最小的那个数是什么?如果不存在这样的美丽数，则输出-1。

· 对 于i(0≤i≤9), 这个数中是i 的位数一共有ai 个。

· 这个数不能有前导0,即012是不合法的。
有多组测试点，每组测试点现在给你a0～a9, 请你回答小B 的问题。

输入格式

第一行包含一个整数T。

接下来T 行，每行10个整数， a0～a9, 含义如题。

输出格式

输出T, 每行一个整数，表示答案。

输入输出样例 #1

输入 #1

12
6 0 0 0 0 0 0 0 0 5
0 1 0 2 0 0 0 0 0 0
3 0 0 0 2 0 0 1 0 0
0 1 2 3 4 5 6 7 8 9
1 2 0 1 5 0 1 0 0 0
2 1 1 0 1 5 0 0 0 0
6 0 1 0 2 0 0 0 1 0
8 1 0 0 1 0 0 0 0 0
5 2 0 0 2 0 1 0 0 0
3 0 0 0 0 3 0 2 1 1
3 1 0 5 0 0 1 0 0 0
0 1 2 0 0 1 0 1 0 5

输出 #1

-1
313
404070
123234345454565656767676787897979898989898989
1404143464
1505052545
-1
-1
1010404060
5050507879
1303030363
1929295979

说明/提示

对于100%的数据，保证：T≤10,1≤n,ai≤ 10⁵, 其中$n=∑ai（0≤i≤9）$

A: 保证最多只有2个ai>0。

B: 保证最多只有3个ai>0。

【代码】T678583 A美丽数 (beauty)

#include <bits/stdc++.h>
using namespace std;
int t,i,d,p,m,c,w,l,g,a[11],cnt[11],f;
string s;
bool j(int t,int b=-1){
    int mx=0;
    for(i=1;i<=10;i++){
        if(i-1==b) continue;
        if(cnt[i]>mx) mx=cnt[i];
    }
    return mx\*2<=t+1;
}
int main(){
    cin>>t;
    while(t--){
        for(i=1;i<=10;i++) cin>>a[i];
        m=c=0;l=-1;s="";
        for(i=1;i<=10;i++) m+=a[i];
        if(m==0){cout<<-1<<"\\n";continue;}
        for(i=1;i<=10;i++) if(a[i]>c) c=a[i];
        if(c>(m+1)/2){cout<<-1<<"\\n";continue;}
        for(i=1;i<=10;i++) cnt[i]=a[i];
        for(p=0;p<m;p++){
            f=0;
            for(d=1;d<=10;d++){
                g=d-1;
                if(cnt[d]==0) continue;
                if(g==l) continue;
                if(p==0&&g==0) continue;
                cnt[d]--;
                if(j(m-p-1,g)){
                    s+=char('0'+g);
                    l=g;
                    f=1;
                    break;
                }
                cnt[d]++;
            }
            if(!f){cout<<-1<<"\\n";break;}
        }
        if(f) cout<<s<<"\\n";
    }
}

URL

【MX-X23】梦熊 X 组 · 月亮赛（同步赛） - 洛谷 | 计算机科学教育新生态

【MX-J26】梦熊 J 组 · 月亮赛（同步赛） - 洛谷 | 计算机科学教育新生态

我的分数

X组：10分

J组：210分

MX-J26/X23 月亮赛 官方题解

A. 丢手绢

小朋友的编号为 $1 \sim n$，直接处理不够便捷，因此将所有编号减去 1，转换为 $0 \sim n-1$。这样调整后，便能通过取模运算轻松计算出每个被放手绢的小朋友编号。

具体规则如下：设编号为 $x$ 的小朋友被记录的数字为 $a_{x}$，则被放手绢的小朋友编号为 $(x + a_{x}) \mod n$。需特别注意，此处涉及负数取模的情况，计算时需遵循相应的取模规则。

后续操作流程为：统计每个小朋友被投放手绢的次数，找出其中的最大值，再依次输出所有出现最大值的小朋友的位置（此处位置需根据最初编号规则还原，若最终结果需对应 $1 \sim n$ 的编号，需将计算得到的 $0 \sim n-1$ 编号加 1）。

该算法的时间复杂度为 $O(n)$，其中 $n$ 为小朋友的总数，仅需遍历一次所有小朋友的记录即可完成统计与计算。

B. 括号序列

首先进行初步判断：若括号序列中左括号和右括号的数量不相等，则该括号序列一定无法构成合法序列，直接判定为无解。接下来仅针对左右括号数量相等的情况展开分析。

判断括号序列是否合法可通过前缀和的方法实现，具体定义前缀和数组 $a_i$ 如下：

$$ a_{i}= \begin{cases} 0, & i=0 \\ a_{i-1}+1, & s_{i}='(' \\ a_{i-1}-1, & s_{i}=')' \end{cases} $$

当遇到相邻的 “)(” 时，将其修改为 “()”，这一操作的本质是将初始时 “)” 对应位置的前缀和加 1，而其他位置的前缀和保持不变。括号序列合法的核心条件是：所有位置的前缀和 $a_i \geq 0$。

基于此条件，判断流程如下：找到第一个满足 $a_i < 0$ 的位置，若该位置附近存在可修改的 “)(” 结构（即能通过修改使该位置及后续位置的前缀和均非负），则进行修改操作，随后再次检查修改后的括号序列是否满足所有前缀和 $a_i \geq 0$，以此确定序列是否合法。

该算法的时间复杂度为 $O(n)$，$n$ 为括号序列的长度，仅需遍历一次序列即可完成前缀和计算与合法性判断。

C. 猜拳游戏

首先定义 $g = \gcd(n, m)$（即 $n$ 和 $m$ 的最大公约数），并令 $n' = \frac{n}{g}$，$m' = \frac{m}{g}$。

在猜拳游戏中，$10100$ 是一个足够大的数字（其值超过 $\text{lcm}(n, m)$，即 $n$ 和 $m$ 的最小公倍数），因此只需考虑游戏不断进行过程中可能出现的所有状态。

将字符串 $a$（长度为 $n$）和字符串 $b$（长度为 $m$）分别按照下标对 $g$ 取模的余数进行分组，共可分为 $g$ 组。以第 $k$ 组（$0 \leq k < g$）为例，字符串 $a$ 中属于该组的有 $n'$ 个招式，字符串 $b$ 中属于该组的有 $m'$ 个招式，这两组招式两两组合形成的 $n' \times m'$ 种情况，一定会在同一局游戏中全部出现。

若要避免平局，必须保证字符串 $a$ 中该组的 $n'$ 个招式组成的集合与字符串 $b$ 中该组的 $m'$ 个招式组成的集合没有交集（即两组招式完全不同）。

接下来需讨论 “石头（R）、剪刀（P）、布（S）” 这三种招式在字符串 $a$ 和 $b$ 中的可选情况，在所有合法的情况中选择操作次数最少的方案，最后将 $g$ 组的最少操作次数相加，得到最终的答案。

该算法的时间复杂度为 $O(n + m)$，其中 $n$ 和 $m$ 分别为字符串 $a$ 和 $b$ 的长度，需分别遍历两个字符串完成分组与招式集合的判断。

D. 卡常数

首先分析单个数列的情况：对于某一数列，选择其中一个位置 $j$，会使该数列的代价乘以系数 $\frac{a_{i,j} - b_{i,j}}{a_{i,j}}$（其中 $a_{i,j}$ 和 $b_{i,j}$ 为该数列第 $j$ 个元素的相关参数）。由于该系数为真分数，将数列中所有这样的真分数按照从小到大的顺序排列后，从左到右选择这些真分数（即优先选择较小的真分数），能使数列代价的减少量最大，是最优的选择策略。

进一步计算每个数列中，按照上述顺序选择每个元素时，该元素能让数列代价比选择上一个元素后再减少的量，将这个减少量定义为该元素的“价值”。通过分析可发现，在同一个数列中，元素的价值是单调递减的（即越靠后选择的元素，其减少代价的能力越弱）。

基于单个数列的价值特性，将所有数列中所有元素的价值整合到一个集合中，对该集合按照从大到小的顺序排序，然后依次选择价值最大的元素，即可实现整体代价的最小化。

贪心策略正确性证明：由于单个数列内部元素的价值单调递减，后续元素的价值必然小于前面元素的价值，因此在选择时，后续元素不可能先于前面元素被选中，这就保证了将所有元素价值排序后从大到小选择的贪心策略是正确的。

设 $m = \sum l_i$（其中 $l_i$ 为第 $i$ 个数列的长度），则该算法的时间复杂度为 $O(m \log m)$，主要耗时在于对所有元素价值的排序操作。

E. 向死存魏

首先采用离线处理的方式，将所有的“二操作”（具体操作含义需结合题目背景，此处默认是对序列的修改或查询操作）加入到操作序列中。在执行操作的过程中，实时记录当前序列的长度，若某一查询操作要求的答案超过当前序列的长度，则判定该查询无解。设所有操作全部结束后，序列的最终长度为 $k$。

对于删除操作，由于每个元素至多被删除一次，且序列的最终长度为 $k$，因此可使用 $set$ 数据结构对序列进行暴力修改（如标记删除或直接移除元素），操作效率可满足需求。

对于查询操作，首先利用双指针法预处理出初始状态下从序列每个位置开始查询的答案。在后续的删除操作中，针对被删除的元素 $x$，先确定其删除区间：设删除区间左边第一个未被删除的位置为 $p$（若不存在这样的位置，则令 $p = 0$），删除区间右边第一个未被删除的位置为 $q$（若不存在这样的位置，则令 $q = k + 1$）。删除该区间内所有的 $x$ 后，会对起始位置在 $[p + 1, q - 1]$ 范围内的查询产生影响——从这些起始位置开始查询时，需要到位置 $q$ 才能找到元素 $x$。

为高效处理上述区间影响，需对 $[p + 1, q - 1]$ 范围内的当前查询答案进行更新（将答案设为 $q$），此处可使用线段树维护“区间取最值、单点查询”的操作，确保查询与更新的效率。

该算法的时间复杂度为 $O((k + m) \log k)$，其中 $k$ 为序列最终长度，$m$ 为操作总数，线段树的查询与更新操作均为 $O(\log k)$ 复杂度，且需处理 $m$ 次操作。

F. 网格 III

在网格操作中，每一次操作至多会影响 $O(n)$ 个格子（$n$ 为网格的边长或相关维度参数），因此只需关注当前操作实际改变的格子数量即可。

由于行列混合操作较为复杂，可将其拆分为两个独立的部分讨论：一是计算有多少行对当前列的修改产生贡献，二是计算有多少列对当前行的修改产生贡献。下文以“计算行对当前列修改的贡献”为例展开分析。

首先为每行和每列分别记录两个关键信息：最后一次修改的时间、最后一次修改的颜色（如红色或白色）。对于网格中 $k \times k$ 的正方形区域，其对应的所有行列信息仅存在两种不同的有效情况：

1. 该正方形区域内所有列的修改颜色均为红色，且最晚的白色行修改时间在最早的红色列修改时间之前；
2. 该正方形区域内存在列的修改颜色为白色，且所有行的修改颜色均为红色，同时最早的红色行修改时间在最晚的白色列修改时间之后。

由于 $k$ 的取值较小，可直接枚举包含当前列且长度为 $k$ 的区间，暴力查询该区间内的行列信息，进而统计满足上述两种情况的行的数量。为提高效率，对于每行，预先记录所有长度为 $k$ 的区间的信息，每次修改操作仅会改变 $O(k)$ 个区间的信息，后续可通过一维偏序的方法查询满足条件的行数量。

为简化时间与颜色的判断逻辑，对修改时间进行如下处理：若修改颜色为红色，时间值保持不变；若修改颜色为白色，时间值取其相反数。初始状态下，所有行列的修改颜色默认为红色，时间值可设为初始常量（如 0）。经过这样的处理，上述两种情况的判断可转化为对区间内时间值取最小值的操作。

可使用树状数组或线段树维护区间最小值，若直接暴力求区间最小值，算法的时间复杂度为 $O(n k^2 + n k \log n)$；若采用单调队列对区间最小值查询进行优化，时间复杂度可降至 $O(n k \log n)$，其中 $n$ 为网格的相关维度参数，$k$ 为正方形区域的边长。

G. 我爱数数

设 $t_i$ 表示使 $b_i \geq a_i$ 所需的操作次数（$a_i$ 和 $b_i$ 为题目给定的数组元素），则本题的答案等价于求 $E[\max_{i=1}^{n} t_i]$（即 $t_i$ 最大值的期望）。

可通过容斥原理计算该期望，具体公式为：答案等于对所有非空子集 $S \subseteq [n]$，求和 $(-1)^{|S| - 1} \times E[\min_{i \in S} t_i]$（其中 $|S|$ 表示子集 $S$ 的元素个数，$E[\min_{i \in S} t_i]$ 表示子集 $S$ 中 $t_i$ 最小值的期望）。

期望计算分析

假设有 $x$ 个区间满足：对任意 $i \in [l_p, r_p] \cap S$，均有 $c_p < a_i$（$[l_p, r_p]$ 为区间的左右端点，$c_p$ 为区间的相关参数）。此时，剩余的 $m - x$ 个区间（$m$ 为总区间数）一旦被选中，就会覆盖子集 $S$ 中的某个元素，导致 $t_i$ 的值固定。

在上述假设下，$E[\min_{i \in S} t_i]$ 的计算过程如下：

$$ E[\min_{i \in S} t_i] = \sum_{i=0}^{+\infty} \frac{x^i (m - x) (i + 1)}{m^{i + 1}} = \frac{m}{m - x} $$

基于此，定义 $w_x$ 为：对所有满足“恰好有 $x$ 个区间符合上述条件”的子集 $S$，求和 $(-1)^{|S| - 1}$。则最终答案可表示为：

$$ \text{答案} = \sum_{x=0}^{m - 1} w_x \times \frac{m}{m - x} $$

动态规划与优化

为计算 $w_x$，引入辅助函数 $h_i$，定义如下：

$$ h_i = \begin{cases} a_i - 1 & i \in S \\ +\infty & \text{Otherwise} \end{cases} $$

此时，“对任意 $i \in [l_p, r_p] \cap S$，$c_p < a_i$”这一限制条件可转化为“对任意 $i \in [l_p, r_p]$，$c_p \leq h_i$”。

进一步构建小根笛卡尔树（基于 $h_i$ 的值），并在树上进行动态规划。定义状态 $f_{L, R, u, x, 0/1}'$，其含义为：

• 考虑区间 $[L, R]$，仅关注 $h_i \geq u$ 的位置，且 $[L, R]$ 是一个连续段（即 $h_{L - 1} < u$ 且 $h_{R + 1} < u$）；
• 满足 $L \leq l_p \leq r_p \leq R$ 且 $c_p \leq x \leq \min_{i \in [l_p, r_p]} h_i$ 的区间 $p$ 共有 $x$ 个；
• 子集 $T = S \cap [L, R]$ 的元素个数为偶数（对应“0”）或奇数（对应“1”）；
• 该状态的值表示满足上述条件的子集 $T$ 的数量。

令 $f_{L, R, u, x} = f_{L, R, u, x, 0}' - f_{L, R, u, x, 1}'$，并引入辅助数组 $g$，则动态规划的转移公式如下：

$$ g_{L, R, u, x} = f_{L, R, u + 1, x} - \sum_{i=L}^{R} [h_i = u] \sum_{y=0}^{x} f_{L, i - 1, u + 1, y} \times g_{i + 1, R, u, x - y} $$

$$ f_{L, R, u, x} = g_{L, R, u, x - s_{L, R, u}} $$

其中 $s_{L, R, u}$ 表示满足 $L \leq l_p \leq r_p \leq R$ 且 $c_p = u$ 的区间 $p$ 的数量。

时间复杂度优化

若直接按照上述转移公式计算，时间复杂度为 $O(n^4 m^2)$（$n$ 为数组长度，$m$ 为总区间数）。但通过观察可知，$h_i = u$ 的位置对于所有 $u$ 而言，总数仅为 $n$ 个，因此可将时间复杂度优化至 $O(n^3 m^2)$。

进一步利用经典的拉格朗日插值（拉插）技巧，可将转移过程中的卷积运算转化为点乘运算，此时时间复杂度可降至 $O(n^3 m + m^2)$。关于拉格朗日插值技巧的具体应用，可参考题目 CF1874E Jellyfish and Hack。

我的评价

首先，让我吐槽一下这次比赛XJ的题目分配

题目分配

开始吐槽

在我的印象里，CSP-X是小学组的难度，但是，这里为什么X组的难度有NOI，我就感觉很猎奇，而且，为什么J组的第一二题在X组没，Who can tell me?

关于各题

【MX-X23-T1】丢手绢

这道题我大概提交了有好几次，主要是老是TLE，原因是因为写了太多没用的循环，这是AC的代码

#include <bits/stdc++.h>
using namespace std;
const int N=100010;
int n,x,i,f[N],ma,s;
int main(){
    cin>>n;
    for(i=1;i<=n;i++){
        cin>>x;s=i+x;
        while(s<1) s+=n;
        while(s>n) s-=n;
        f[s]++;
        ma=max(ma,f[s]);
    }
    for(i=1;i<=n;i++) if(f[i]==ma) cout<<i<<" ";
}

注意超n和小1的数据处理

【MX-X23-T2】括号串

这道题，我当时是在洛谷搜一道题，叫做括号串匹配，然后，找到了，但是没用，然后我在CSXX上找答案，找到了，但是没用

所以只好独立思考

namespace pts70{
bool check(string s){
    int tmp,i;
    for(i=tmp=0;i<s.length();i++){
        if(s[i]=='(') tmp++;
        else if(s[i]==')'){
            tmp--;
            if(tmp<0) return 0;
        }
    }
    return tmp==0;
}
int main(){
    cin>>T;
    while(T--){
        cin>>n>>s;fl1=0;
        if(check(s)) fl1=1;
        if(n>1000){cout<<(fl?"Yes":"No")<<"\n";continue;}
        ss=s;
        for(i=0;i<ss.length()-1;i++){
            ss=s;
            if(ss[i]==')'&&ss[i+1]=='('){
                ss[i]='(';ss[i+1]=')';
                if(check(ss)) fl=1;
                else ss=s;
            }
        }
        cout<<(fl?"Yes":"No")<<"\n";
    }
    return 0;
}
}

思路其实也很明显了，就是死暴力，check函数就是判断这个字符串的括号是否合法，然后，20-29行就是两个字符串一个一个往后做，替换，然后判断，可以就输出，不可以就下一个

然后我看了一眼前面那个人的代码，发现是我想多了，代码

#include <bits/stdc++.h>
using namespace std;
const int N=100010;
int T,n,t,w,wz,i,fl1,fl2,sts;
char s[N];
void count(){
    if(s[i]=='(') t++;
    if(s[i]==')') w++;
}
int main(){
    cin>>T;
    while(T--){
        cin>>n;t=w=0;fl1=1;
        for(i=1;i<=n;i++){
            cin>>s[i];
            count();
            if(t<w){fl1=0;wz=i;}
        }
        if(t==w){
            sts=1;
            if(fl1==1){cout<<"Yes\n";sts=0;continue;}
            swap(s[wz],s[wz+1]);
            t=w=0;fl2=1;
            for(i=1;i<=n;i++){
                count();
                if(t<w) fl2=0;
            }
            if(wz==n) fl2=0;
            if(sts==1) cout<<(fl2?"Yes":"No")<<"\n";
        }else{cout<<"No\n";continue;}
    }
}

【MX-X23-T3】猜拳游戏

不会做，这个代码 10pts

#include <bits/stdc++.h>
using namespace std;

int main(){
    cout<<1;
}