weixin_30527551
weixin_30527551

Educational Codeforces Round 60 Problem B. Emotes

由於每個數字可以使用任意多次，每個數字不能連續出現 k 次，因此可以選出最大的兩個數字，交錯使用。最開始想的是兩個數字每次重複 k 次，發現樣例不對。。後來才發現其實次大的數字只需要出現一次，更多的位置留給最大的數字才能使得結果最大。也就是每個循環是 k 個最大數字加上 1 個次大數字。循環節長度是 k+1 。可以寫出一個公式來： m/(k+1)*(k*a1+b1) + (m%(k+1)) * a1 其中 a1 是最大數，b1 是次大數。

 

  1 // ==================================================
  2 
  3 // C library
  4 #include 
  5 #include 
  6 #include 
  7 #include 
  8 #include 
  9 #include 
 10 #include 
 11 #include 
 12 
 13 // Containers
 14 #include 
 15 #include 
 16 #include 
 17 #include 
 18 #include 
 19 #include <set>
 20 #include 
 21 #include 
 22 #include 
 23 
 24 // Input/Output
 25 #include 
 26 #include 
 27 #include 
 28 #include 
 29 #include 
 30 #include 
 31 #include 
 32 
 33 // Other
 34 #include 
 35 #include <string>
 36 #include 
 37 #include 
 38 #include 
 39 #include 
 40 #include 
 41 #include 
 42 #include 
 43 #include 
 44 #include 
 45 #include 
 46 
 47 // ==================================================
 48 
 49 using namespace std;
 50 
 51 // constants
 52 const double EPS = 1e-9;
 53 
 54 // type alias
 55 using PII = pair<int, int>;
 56 using LL = long long int;
 57 using VI = vector<int>;
 58 using VC = vector<char>;
 59 using VS = vector<string>;
 60 using VVI = vector;
 61 using MII = map<int, int>;
 62 using MCI = map<char, int>;
 63 using SI = set<int>;
 64 
 65 // ==================================================
 66 
 67 // fast IO
 68 static auto __2333__ = []() {
 69                          ios::sync_with_stdio(false); cin.tie(nullptr); return 0; }();
 70 
 71 // ==================================================
 72 
 73 // some macro for less typing
 74 #define max_(x, y) ((x) > (y) ? (x) : (y))
 75 #define min_(x, y) ((x) > (y) ? (y) : (x))
 76 
 77 #define REP(i, n) for (int i = 0; i < int(n); ++i) // [0, n)
 78 #define REPV(i, n) for (int i = int(n - 1); i >= 0; --i)   // reverse [0, n)
 79 #define FOR(i, a, b) for (int i = int(a); i < int(b); ++i) // [a, b)
 80 #define DWN(i, b, a) for (int i = int(b - 1); i >= int(a); --i) // reverse [a, b)
 81 
 82 #define REP_1(i, n) for (int i = 1; i <= int(n); ++i)           // [1, n]
 83 #define REPV_1(i, n) for (int i = int(n); i >= 1; --i)          // reverse [1, n]
 84 #define FOR_1(i, a, b) for (int i = int(a); i <= int(b); ++i)   // [a, b]
 85 #define DWN_1(i, b, a) for (int i = int(b); i >= a; --i)        // reverse [a, b]
 86 
 87 // DEBUG PRINT macro
 88 #define PR(x) cout << #x " = " << (x) << "\t"
 89 #define NL cout << "\n"
 90 
 91 #define PR1(x) PR(x), NL
 92 #define PR2(x1, x2) PR(x1), PR1(x2)
 93 #define PR3(x1, x2, x3) PR(x1), PR2(x2, x3)
 94 #define PR4(x1, x2, x3, x4) PR(x1), PR3(x2, x3, x4)
 95 
 96 int direction[8][2] = { {-1, 0}, {1, 0}, {0, -1}, {0, 1},
 97                                                     {-1, -1}, {-1, 1}, {1, -1}, {1, 1} };
 98 
 99 // ==================================================
100 
101 // simplest print
102 template
103 void PRC(const T& a) { cout << a << " "; }
104 
105 // print container
106 template
107 void PRCO(const T& c) { for (auto x : c) PRC(x); NL; }
108 
109 // print vector
110 template
111 void PRV(const vector& c) { PRCO>(c); }
112 
113 // print C-style array
114 template
115 void PRA(const T (&ar)[N]) {
116   for (auto x : ar) PRC(x); NL;
117 }
118 
119 // print pair
120 template
121 void PRP(const pair& p) { PRC(p.first); PRLN(p.second); }
122 
123 // print a value and a new line
124 template
125 void PRLN(const T& a) { cout << a << "\n"; }
126 
127 // ==================================================
128 // math
129 bool is_prime(LL x)
130 {
131   if (x == 1) return false;
132   assert(x > 1);
133   LL m = ceil(sqrt(x));
134   FOR_1(i, 2, m) { if (!(x % i)) return false; }
135   return true;
136 }
137 
138 // prime table
139 const int PRIME_MAX = 10;
140 VI prime_table;
141 vector<bool> prime_table_bool(PRIME_MAX, true);
142 
143 void get_prime() {
144   FOR_1(i, 2, PRIME_MAX) {
145     if (prime_table_bool[i]) {
146       prime_table.push_back(i);
147       for (int j = i << 1; j <= PRIME_MAX; j += i) prime_table_bool[j] = false;
148     }
149   }
150 }
151 
152 // double equals
153 bool eq(double a, double b) { return fabs(a - b) < EPS; }
154 
155 double random_() {
156   // generate random number in [0, 1]
157   return double(rand()) / RAND_MAX;
158 }
159 
160 int random_(int m) {
161   // generate random int between [0, m - 1]
162   return int(random_() * (m - 1) + 0.5);
163 }
164 
165 // high precision integer
166 
167 class BNI {
168   friend ostream &operator<<(ostream &, const BNI &);
169   friend istream &operator>>(istream &, BNI &);
170 public:
171   BNI() = default;
172   BNI(const string &s) { *this = s; }
173   BNI(const char s[]) :BNI(string(s)) {}
174   BNI(const BNI &rhs) = default;
175   BNI(const LL n) { *this = n; };
176   BNI(istream &in) { string s; in >> s; *this = s; }
177 
178   BNI &operator=(const BNI &rhs) = default;
179   BNI &operator=(const string &s) {
180     string s_ = clean_zero_str(s);
181     num.resize(s_.size());
182     int i = 0;
183     for (auto it = s_.crbegin(); it != s_.crend(); ++it)
184       num[i++] = *it - '0';
185     return *this;
186   }
187   BNI &operator=(const char s[]) {
188     operator=(string(s));
189     return *this;
190   }
191   BNI &operator=(LL n) {
192     stringstream ss; ss << n;
193     string s; ss >> s;
194     *this = s;
195     return *this;
196   }
197   BNI operator+(const BNI &rhs) const {
198     BNI res;
199     size_t max_len = max_(num.size(), rhs.num.size());
200     int x;
201     for (int i = 0, rem = 0; rem || i < max_len; ++i) {
202       x = rem;
203       if (i < num.size()) x += num[i];
204       if (i < rhs.num.size()) x += rhs.num[i];
205       res.num.push_back(x % 10);
206       rem = x / 10;
207     }
208     res.clean_zero();
209     return res;
210   }
211   BNI& operator+=(const BNI &rhs) {
212     *this = *this + rhs;
213     return *this;
214   }
215   BNI operator*(const BNI &rhs) const {
216     BNI res;
217     size_t sum_len = num.size() + rhs.num.size();
218     res.num.resize(sum_len);
219     for (size_t i = 0; i < num.size(); ++i) {
220       for (size_t j = 0; j < rhs.num.size(); ++j) {
221         res.num[i + j] += num[i] * rhs.num[j];
222       }
223     }
224     for (size_t i = 0; i < res.num.size() - 1; ++i) {
225       res.num[i + 1] += res.num[i] / 10;
226       res.num[i] %= 10;
227     }
228     res.clean_zero();
229     return res;
230   }
231   BNI& operator*=(const BNI &rhs) {
232     *this = *this * rhs;
233     return *this;
234   }
235   /*
236    * assume *this >= rhs
237    */
238   BNI operator-(const BNI &rhs) const {
239     assert(*this >= rhs);
240     if (rhs == 0LL) return *this;
241     BNI res;
242     int x;
243     for (int i = 0, rem = 0; i < num.size(); ++i) {
244       x = num[i] - rem;
245       if (i < rhs.num.size()) x -= rhs.num[i];
246       if (x >= 0) rem = 0;
247       else { rem = 1; x += 10; }
248       res.num.push_back(x);
249     }
250     res.clean_zero();
251     return res;
252   }
253   BNI& operator-=(const BNI &rhs) {
254     *this = *this - rhs;
255     return *this;
256   }
257   /*
258    * assume rhs is not zero
259    */
260   pair operator/(const BNI &rhs) const {
261     assert(BNI(0LL) != rhs);
262     if (*this < rhs) return make_pair(0LL, *this);
263 
264     BNI quotient, rem;
265     string nume = c_str();
266     string numerator = nume.substr(0, rhs.num.size());
267     size_t pos = rhs.num.size();
268     vector times(10);
269     for (int i = 0; i < 10; ++i) times[i] = rhs * i;
270     string quot;
271 
272     while (pos <= nume.size()) {
273       BNI nume_b = numerator;
274       int cnt = 0;
275 
276       while (cnt < 10 && times[cnt] <= nume_b) ++cnt;
277       --cnt;
278 
279       quot += char(cnt + '0');
280       rem = nume_b - times[cnt];
281 
282       if (pos < nume.size())
283         numerator = rem.c_str() + nume[pos];
284 
285       ++pos;
286     }
287 
288     quotient = quot;
289 
290     return make_pair(quotient, rem);
291   }
292   bool operator<(const BNI &rhs) const {
293     if (num.size() == 0) return !(rhs.num.size() == 0);
294     if (num.size() != rhs.num.size()) {
295       return num.size() < rhs.num.size();
296     }
297     for (int i = num.size() - 1; i >= 0; --i) {
298       if (num[i] != rhs.num[i]) return num[i] < rhs.num[i];
299     }
300     return false;
301   }
302   bool operator>(const BNI &rhs) const { return rhs < *this; }
303   bool operator<=(const BNI &rhs) const { return !(*this > rhs); }
304   bool operator>=(const BNI &rhs) const { return !(*this < rhs); }
305   bool operator!=(const BNI &rhs) const { return (*this < rhs) || (*this > rhs); }
306   bool operator==(const BNI &rhs) const { return !(*this != rhs); }
307   size_t size() const { return num.size(); }
308   string c_str() const {
309     string s;
310     for (auto x : num) s = char(x + '0') + s;
311     return s.empty() ? "0" : s;
312   }
313   void left_shift() {
314     if (!num.empty()) num.pop_back();
315   }
316 protected:
317   vector<int> num;
318   string clean_zero_str(const string &s) {
319     if (s.empty() || s[0] != '0') return s;
320     size_t i = 0;
321     while (i < s.size() && '0' == s[i]) ++i;
322     return s.substr(i);
323   }
324   void clean_zero() {
325     for (auto it = num.rbegin(); it != num.rend() && *it == 0;) {
326       ++it;
327       num.pop_back();
328     }
329   }
330 };
331 
332 ostream &operator<<(ostream &out, const BNI &x) {
333   out << x.c_str();
334   return out;
335 }
336 
337 istream &operator>>(istream &in, BNI &x) {
338   x = BNI(in);
339   return in;
340 }
341 
342 // high precision float
343 class BNF : protected BNI {
344   friend ostream &operator<<(ostream &out, const BNF &x);
345   friend istream &operator>>(istream &in, BNF &x);
346 public:
347   BNF() = default;
348   BNF(const string &s) { *this = s; }
349   BNF(const char s[]): BNF(string(s)) {}
350   BNF(const BNF &rhs) = default;
351   BNF(const LL n) { *this = n; }
352   BNF(istream &in) { string s; in >> s; *this = s; }
353 
354   BNF &operator=(const string &s) {
355     string s_ = clean_zero_str(s);
356     num.resize(s_.size());
357     int i = 0;
358     for (auto it = s_.crbegin(); it != s_.crend(); ++it)
359       num[i++] = *it - '0';
360     return *this;
361   }
362   BNF &operator=(const char s[]) {
363     operator=(string(s)); return *this;
364   }
365   BNF &operator=(LL n) {
366     stringstream ss; ss << n;
367     string s; ss >> s;
368     *this = s;
369     return *this;
370   }
371   BNF operator+(const BNF &rhs) const {
372     pair<string, string> in_fr1 = split(), in_fr2 = rhs.split();
373     string inte1 = in_fr1.first, frac1 = in_fr1.second,
374       inte2 = in_fr2.first, frac2 = in_fr2.second;
375     LL inc = 0LL;
376     BNI frac_sum;
377     inc += sum_has_carry(frac1, frac2, frac_sum);
378     BNI inte_sum = BNI(inte1) + inte2 + inc;
379 
380     return join_inte_frac(inte_sum, frac_sum);
381   }
382   BNF& operator+=(const BNF &rhs) {
383     *this = *this + rhs;
384     return *this;
385   }
386   /*
387    * assume *this >= rhs
388    */
389   BNF operator-(const BNF &rhs) const {
390     assert(*this >= rhs);
391     pair<string, string> in_fr1 = split(), in_fr2 = rhs.split();
392     string inte1 = in_fr1.first, frac1 = in_fr1.second,
393       inte2 = in_fr2.first, frac2 = in_fr2.second;
394     LL dec = 0LL;
395     if (BNI(frac1) < frac2) {
396       frac1 = '1' + frac1; ++dec;
397     }
398     while (frac1.size() < frac2.size()) frac1 += '0';
399     while (frac2.size() < frac1.size()) frac2 += '0';
400     BNI frac = BNI(frac1) - frac2;
401     BNI inte = BNI(inte1) - dec - inte2;
402     return join_inte_frac(inte, frac);
403   }
404   BNF& operator-=(const BNF &rhs) {
405     return *this = *this - rhs;
406   }
407   BNF operator*(const BNF &rhs) const {
408     pair<string, string> in_fr1 = split(), in_fr2 = rhs.split();
409     string inte1 = in_fr1.first, frac1 = in_fr1.second,
410       inte2 = in_fr2.first, frac2 = in_fr2.second;
411     BNI res = BNI(inte1 + frac1) * (inte2 + frac2);
412     int deci = decimals + rhs.decimals;
413     string res_s = res.c_str();
414     while (res_s.size() < deci) res_s = '0' + res_s;
415     return BNF(res_s.substr(0, res_s.size() - deci) + '.'
416                + res_s.substr(res_s.size() - deci));
417   }
418   BNF& operator*=(const BNF &rhs) {
419     return *this = *this * rhs;
420   }
421   bool operator<(const BNF &rhs) const {
422     pair<string, string> in_fr1 = split(), in_fr2 = rhs.split();
423     string inte1 = in_fr1.first, frac1 = in_fr1.second,
424       inte2 = in_fr2.first, frac2 = in_fr2.second;
425     if (inte1 < inte2) return true;
426     else if (inte1 == inte2) return frac1 < frac2;
427     else return false;
428   }
429   bool operator>(const BNF &rhs) const { return rhs < *this; }
430   bool operator<=(const BNF &rhs) const { return !(*this > rhs); }
431   bool operator>=(const BNF &rhs) const { return !(*this < rhs); }
432   bool operator!=(const BNF &rhs) const { return (*this < rhs) || (*this > rhs); }
433   bool operator==(const BNF &rhs) const { return !(*this != rhs); }
434 
435 protected:
436   int decimals = 0;
437   LL sum_has_carry(const BNI &a, const BNI &b, BNI &sum) const {
438     int max_len = max_(a.size(), b.size());
439     sum = a + b;
440     if (sum.size() > max_len) { sum.left_shift(); return 1LL; }
441     return 0LL;
442   }
443   BNF join_inte_frac(const BNI &inte, const BNI &frac) const {
444     return BNF(inte.c_str() + "." + frac.c_str());
445   }
446   string clean_tail_zero_str(const string &s) {
447     int i = 0;
448     string r;
449     while (i < s.size() && '.' != s[i]) r += s[i++];
450 
451     int j = s.size() - 1;
452     while (j >= 0 && '0' == s[j]) --j;
453     for (int k = i + 1; k <= j; ++k) r += s[k];
454     decimals = j >= i ? j - i : 0;
455     return r;
456   }
457   string clean_zero_str(const string &s) {
458     string r = BNI::clean_zero_str(s);
459     return clean_tail_zero_str(r);
460   }
461   string c_str() const {
462     string s;
463     for (int i = 0; i < num.size(); ++i) {
464       if (i == decimals) s = '.' + s;
465       s = char(num[i] + '0') + s;
466     }
467     if (s.empty()) s = "0";
468     if (num.size() == decimals) s = '.' + s;
469     return s;
470   }
471   pair<string, string> split() const {
472     string s = c_str();
473     size_t p = s.find('.');
474     return make_pair(s.substr(0, p), s.substr(p + 1));
475   }
476 };
477 
478 ostream &operator<<(ostream &out, const BNF &x) {
479   cout << x.c_str(); return out;
480 }
481 
482 istream &operator>>(istream &in, BNF &x) {
483   x = BNF(in); return in;
484 }
485 
486 // Trie Tree
487 const int ALPHASIZE = 26;
488 
489 class TrieNode {
490 public:
491   TrieNode()
492     :wordEnd{false}, cnt{1}
493   {
494     REP(i, ALPHASIZE) { child[i] = nullptr; }
495   }
496   ~TrieNode() {}
497   void insert(string word) {
498     int i;
499     TrieNode *cur = this;
500     for (auto x:word) {
501       i = x - 'a';
502       if (nullptr == cur->child[i]) {
503         cur->child[i] = new TrieNode();
504         cur = cur->child[i];
505       } else {
506         cur = cur->child[i];
507         ++cur->cnt;
508       }
509     }
510     cur->wordEnd = true;
511   }
512   bool search(string word) {
513     int i;
514     TrieNode *cur = this;
515     for (auto x:word) {
516       i = x - 'a';
517       if (nullptr == cur->child[i]) {
518         return false;
519       }
520       cur = cur->child[i];
521     }
522     return cur->wordEnd;
523   }
524   int cnt_words(string word) {
525     int i; TrieNode *cur = this;
526     for(auto x:word) {
527       i = x - 'a';
528       if (nullptr == cur->child[i]) return 0;
529       cur = cur->child[i];
530     }
531     return cur->cnt;
532   }
533   TrieNode *child[ALPHASIZE];
534   bool wordEnd;
535   int cnt; // number of words with the prefix
536 };
537 
538 
539 
540 // ==================================================
541 
542 
543 const int MAXN=200009;
544 LL a[MAXN];
545 LL n,m,k;
546 
547 int main( void ) {
548 
549 #ifdef DEBUG
550   freopen("b.in", "r", stdin);
551 #endif
552 
553   while (cin>>n>>m>>k) {
554     REP(i,n) cin>>a[i];
555     sort(a,a+n,greater());
556     LL a1=a[0], b1=a[1];
557     LL res = m/(k+1) * (a1*k+b1) + (m%(k+1)) * a1;
558     PRLN(res);
559   }
560 
561   return 0;
562 }
View Code

 

转载于:https://www.cnblogs.com/algouage/p/10583688.html

你可能感兴趣的:(Educational Codeforces Round 60 Problem B. Emotes)

  • 99分的A和60分的B以及…… MG12357
    前几天聊天，麦苗说起A和B，A在世人眼中过的不错，他自己却整天焦虑各种烦恼；B过的不算好，看着倒是没什么烦恼很开心。其实这个现象也不奇怪，还记得我上学那会儿就有这种体会。A同学明明考了99分，还是伤心难过不能自已，还找人抱怨，同学安慰她的时候心里还会默默说一句“学婊，花样炫耀啊”。而B同学可能才考60分，就欢天喜地甚至喜极而泣，很多同学可能还会不屑的在心里想“这点出息”。也许我曾经也是这样想的，现
  • 2022-05-22光印随思60学习要与现实打通 无名之米8
    20220522光印随思60学习要与现实打通今天在匆忙中完成了新网师课程的第七次预习作业。每次完成预习作业的过程都是一次艰难的学习，先要学习相关的文本和文件，了解作业需要的理论知识，之后需要把理论知识运用于实际工作和生活中。这也是学习的真正价值所在。在很多时候，会有这样的感觉，读了很多书为什么没有啥长进？现在回想应该就是，当只有阅读和感受，没有把阅读心得转化为文字，没有把阅读的知识运用到实际的场景
  • 代码随想录Day 41|动态规划之买卖股票问题，leetcode题目121. 买卖股票的最佳时机、122. 买卖股票的最佳时机Ⅱ、123. 买卖股票的最佳时机Ⅲ LluckyYH 动态规划leetcode算法数据结构
    提示：DDU，供自己复习使用。欢迎大家前来讨论~文章目录买卖股票的最佳时机相关题目题目一：121.买卖股票的最佳时机解题思路：题目二：122.买卖股票的最佳时机II解题思路：题目三：123.买卖股票的最佳时机III解题思路总结买卖股票的最佳时机相关题目题目一：121.买卖股票的最佳时机[[121.买卖股票的最佳时机](https://leetcode.cn/problems/combination
  • 杨丽萍被diss上热搜：是谁在胡乱定义中国女性？ 果沐妈咪
    最近，舞蹈大师杨丽萍因为60岁还没结婚没孩子，被某音网友diss上热搜，评论还被点赞1万多次，一度占据了热评第一名（目前已删）。很难想象在2020年，还有人揪着女性的衣领质问：你怎么不结婚呢？你怎么不生孩子呢？很快，这种言论引发了微博上的大讨论。几位女明星也站出来为杨丽萍发声，声援她。戚薇“一个人最大的失败是：时至今日还在给我们“女人”下定义，还把儿孙满堂当作女人唯一的成就。。。生育工具？！呵呵，
  • uniapp使用内置地图选择插件，实现地址选择并在地图上标点 神夜大侠 Uniappvue.jsuniapp
    uniapp使用内置地图选择插件，实现地址选择并在地图上标点代码如下：page{background:#F4F5F6;}::-webkit-scrollbar{width:0;height:0;color:transparent;}page{height:100%;width:100%;font-size:24rpx;}image,view,input,textarea,label,text,na
  • 朱元璋惩治贪官：贪污60两银子以上斩首，60两相当于现在多少钱？ 三晋风云客
    但凡对明朝历史了解一些，都清楚在明朝做官不容易，而且还得担心自己的身家性命，指不定就因为某些事情就挂了，甚至祸及全家，不过在明代，出现过向皇帝讨薪的官员，还没有出现过朝廷无官的情况，党派之争、贪官污吏依然是存在的。看看朱元璋在位时，为惩治贪官做了哪些努力？对自己所培养的官员都不姑息迁就；制定整肃贪污的纲领《大诰》和《醒贪简要录》；允许民间的百姓上访；并且做出规定：贪污60两银子以上斩首。朱元璋曾先
  • leetcode-124 Binary Tree Maximum Path Sum 乐观的大鹏 LeetCode
    Givenanon-emptybinarytree,findthemaximumpathsum.Forthisproblem,apathisdefinedasanysequenceofnodesfromsomestartingnodetoanynodeinthetreealongtheparent-childconnections.Thepathmustcontainatleastonenodea
  • 8 冰鈊夢
    transition动画transform.box{width:200px;height:200px;background-color:gold;margin:50pxauto0;transition:all1sease;}.box:hover{transform:translate(50px,50px);}.box2{width:200px;height:200px;background-col
  • 【LeetCode】53. Maximum Subarray 墨染百城 LeetCodeleetcode
    问题描述问题链接：https://leetcode.com/problems/maximum-subarray/#/descriptionFindthecontiguoussubarraywithinanarray(containingatleastonenumber)whichhasthelargestsum.Forexample,giventhearray[-2,1,-3,4,-1,2,1,-
  • css2中的透明 琪33
    .out{width:400px;height:400px;background-color:blue;margin:100pxauto;border:1pxsolid#000;opacity:0.6;}.in{width:200px;height:200px;background-color:red;margin:100pxauto;}
  • Codeforces Round 972 (Div. 2) A-C 题解 AKDreamer_HeXY Codeforces比赛题解c++算法动态规划数据结构贪心算法
    本来以为B2难度会1900什么的，结果感觉1200还没有，先做的B1，后悔了QwQ关于我现场没切出C这件事……现场排名：A.SimplePalindrome题意构造一个长度为nnn的字符串，只包含aeiou五种字母，需要使得构造出来的字符串所包含的回文子序列数量最小思路当n≤5n\le5n≤5时，只要555个字母不重复出现都是最优情况当n>5n>5n>5时，可以证明：把相同字母放在一起是最优情况：
  • 2023-03-24 卯金刀_fafd
    美丽的伊犁河谷流失大半的伤痛伊犁河谷是祖国新疆一块美丽湿润的土地，有赛江南之美誉，这里风景秀丽，美如诗画，是中国最西部的湿地，在干旱的中亚是非常难得的一片肥美良田；原本整个伊犁河谷都是中国的领土，由于晚清腐败，导致失去了大片伊犁河谷，最终只留下小部分的土地，这是祖国的痛，这么美丽的土地失去了是整个中华民族永不可忘的痛，这一切的原因都是由于中俄《伊犁条约》签订。19世纪60~70年代，中国西北地区发
  • 每日一题《leetcode--LCR 022.环形链表||》 Peace & Love487 题目分享leetcode链表算法笔记数据结构
    https://leetcode.cn/problems/c32eOV/我们使用两个指针，fast与slow。它们起始都位于链表的头部。随后slow指针每次向后移动一个位置，而fast指针向后移动两个位置。如果链表中存在环，则fast指针最终将再次与slow指针在环中相遇。structListNode*detectCycle(structListNode*head){structListNode*
  • LCR 078. 合并 K 个升序链表 装B且挨揍の LeetCode链表算法数据结构经验分享笔记java
    https://leetcode.cn/problems/vvXgSW/description/https://leetcode.cn/problems/vvXgSW/description/解题思路方法一：每个链表维护一个索引，每次找到值最小的节点，索引加一。可以采用优先队列实现。/***Definitionforsingly-linkedlist.*publicclassListNode{*i
  • 变频器：原理、应用及其在现代工业与生活中的节能与智能控制作用 智能科技前沿 人工智能科技生活单片机嵌入式硬件
    创作不易，您的打赏、关注、点赞、收藏和转发是我坚持下去的动力！1.变频器的原理变频器（Inverter），是一种将固定频率的交流电（通常是50Hz或60Hz）转换为可变频率和电压的交流电的电气设备。其工作原理是基于电力电子技术和控制理论的应用，能够通过改变供给电机的电源频率来控制电动机的速度和扭矩。变频器的基本工作原理可以分为以下几个阶段：整流：首先，将输入的交流电（AC）通过整流器（通常是二极管
  • 【机器人建模和控制】读书笔记 Piccab0o 机器人
    机器人建模和控制——马克·斯庞A.x10=x1∙x0x^0_1=x_1\bulletx_0x10=x1∙x0，其实就是：1）x1x_1x1轴向量在O0O_0O0系下的坐标2）在x0x_0x0轴上的投影3）坐标变换矩阵的R10R_1^0R10的第一个元素B.点p在o1x1y1z1o_1x_1y_1z_1o1x1y1z1系下的坐标p1p^1p1可以表示为：p=ux1+vy1+wz1p=ux_1+vy_
  • matlab游标标注移动,matlab实现图形窗口的数据游标 莫白想 matlab游标标注移动
    DatacursorsforfigurewindowSeveralrelatedfunctions:CreateCursorsetsupaverticalcursoronallaxesinafigure.Thecursorscanbemovedaroundusingthemouse.MultiplecursorsaresupportedineachfigureGetCursorLocationre
  • python-pcl函数_Python简介，第4章-函数 cumei1658 javawebglpythonluaios
    python-pcl函数Runningthroughthedoor,Baldricfoundhimselfinanenormouscavern,itsceilinglostinshadow.Greatcolumnsofblackstonesoaredfromtheground,andpoolsoflavabubbledthroughout,lightingthecaverninadarkred.T
  • 今天到底是谁的生日 马蹄踏碎落叶
    在我的记忆中，最使我百思不得其解的就是奶奶的六十大寿，那天发生的事。早晨九点多，我们全家已经把家里打扫的一尘不染，为祝贺奶奶60大寿的东西也准备齐全了，一会儿小姑，大姑全来了！他们各自带了礼物。该准备午餐了，奶奶让我去拿围裙，一走进房间看见一地的瓜子壳，像下了雪似的积了厚厚一层。走进客厅姑父和大爷正在打牌，笑声此起彼伏，而老寿星奶奶呢却正在厨房烧菜，忙得像一只陀螺。大爷说:“我快渴死了，奶奶匆匆忙
  • 多表查询_关联查询 活跃家族 sql
    innerjoin:通常关联项on后面的是主外键，两个表都有的才显示leftjoin:左连，select*fromSleftjoinBons.字段=B.字段，一定会将左边表的数据全部查询出来rightjoin:select*fromSrightjoinBons.字段=B.字段一定会将右边表的数据全部查询出来索引：增加查询效率，数据量很大的时候，提高查询速度，当给表加索引之后，重新插入数据，就会让索
  • HTML中"bgcolor"与"background-color"的区别 Sardar_ html
    bgcolor只是标签属性，而backgroud更多作为css的样式属性。它们俩大多数情况下效果完全相同。但在标签下效果不同。不支持bgcolor属性，只能用style标签添加CSS样式。作为table的属性而言：HelloWorld!和HelloWorld!效果完全相同。作为body属性而言：效果完全相同。不过个人推荐统一用CSS样式进行控制，把style统一放到.css文件中。backgrou
  • 60 竹音尘
    一切好像又回到了开头。刚开始去的时候。就是如此。人孰无过，人孰无过。该怎么办呢？又回去了。有时候，想象的也只有自己而已。那么心疼心累就是自己而已。不，算了，算了。下次坚持努力，继续加油。一定要争跑吧。
  • Python: round函数 湫兮之风 pythonpython开发语言numpy人工智能
    语法在Python中，round()是一个内置函数，用于对浮点数进行四舍五入。基本语法如下：round(number,ndigits)其中：number是你要四舍五入的浮点数。ndigits（可选）决定了四舍五入到哪个位置，0是到整数位，负数是到十位、百位等。如果不提供这个参数，那么默认四舍五入到最接近的整数。例子：print(round(3.14159,2))#输出：3.14print(roun
  • Python round函数详解 寒秋丶 Python自动化测试性能测试python开发语言测试开发软件开发软件测试自动化测试性能测试
    大家好，在Python编程中，经常需要对数字进行舍入操作。无论是在金融领域的货币计算，还是科学计算中的数据处理，都可能需要使用到四舍五入功能。为了满足这一需求，Python提供了一个内置函数round()，它能够方便地对数字进行舍入操作。在本文中，将深入探讨Python中round()函数的用法和特性。将从基本语法开始，逐步深入，讨论该函数在不同情况下的行为，以及如何在实际编程中灵活运用。无论您是
  • 65岁老人亲身经历，老年的无助，从活到60岁的那一刻，就注定了 舒山有鹿
    01人到中年，前怕虎，后怕狼，中间怕没钱。人到晚年，前不见归途，后不见来路，让人唏嘘感叹。如果说中年是一道坎，那晚年就是一座山。我们跨过了坎，可还是逃不过这座大山。因为谁也无法逃避老去的命运，谁也无法改变年迈体衰的事实。尤其在这个老龄化突出，且老人不受待见的年代里面，人到晚年，或许就是一场劫难。对此，很多人都会疑惑，老龄化突出还可以理解，可为什么老人会面临“不受待见”的命运呢？人老了，被人嫌弃，被
  • 人生规划10期:与家庭划分边界，钱生钱 记与忆
    你好，冷大，关注你有一年多了，很多个深夜下班的路上都是听着你的问答栏目度过的，感谢有你。我女生，今年26岁，初中学历，家里老二，我有一个姐姐一个弟弟，姐姐前年出嫁，今年宝宝一岁。弟弟在外地打工今年第5年了，去年网络赌博欠下10万，我爸妈借了亲戚的钱还上了，姐姐出了5万，这事我后来才知道。父母年龄都近60，农民，从小觉得在这样的家庭自己还挺幸福的，因为爸妈都是一样的疼我们(农村重男轻女很常见)，可从
  • python语言爬虫爬取歌曲代码X EYYLTV python爬虫java
    importrequestssong_urls=[“https://m804.music.126.net/20240915142147/4e01caa69abda60b165e185607805ee1/jdyyaac/obj/w5rDlsOJwrLDjj7CmsOj/30379084686/b56a/dbd5/39fc/792d87f5d7014bb78547ec3804eeaac5.m4a?au
  • HALTT4LLM：大型语言模型的幻觉检测指标 谢忻含Norma
    HALTT4LLM：大型语言模型的幻觉检测指标haltt4llmThisprojectisanattempttocreateacommonmetrictotestLLM'sforprogressineliminatinghallucinationswhichisthemostseriouscurrentprobleminwidespreadadoptionofLLM'sformanyrealpur
  • 中考数学想考满分？必须刷完这60道经典压轴题！（高清打印版） 孔文教育QD
    孔文教育启东校区距离中考还有30多天的时间，如果平常数学可以考100分左右的同学，就可以重视一下压轴题的提升，老师整理了60道压轴题，包括了考点解析等内容，可以做起来哦！孩子升入初中之后，学习压力逐渐增加，孩子的学习能力以及适应环境的能力决定孩子能够分到哪个层次。中考决定孩子进入普通高中还是职业高中，这是个很现实的问题，经数据研究，中考的普职分流比为1:1，换言之，假设有100个考生，其中就有50
  • Codeforces Round 969 (Div. 2) C. Dora and C++ （裴蜀定理） 致碑前繁花 刷题记录c语言c++开发语言
    什么？竟然是裴蜀定理。。。由于这里给出了a和b两个数，我们或许可以想到使用同样是需要给出两个定值的裴蜀定理，即：如果给定xxx和yyy，那么一定有ax+by=gcd(x,y)ax+by=gcd(x,y)ax+by=gcd(x,y)。所以在这时候我们就可以让输入的所有数都去对gcd(a,b)gcd(a,b)gcd(a,b)取模，这样就能够得到所有数的最简形式（可以当成是让所有数尽可能消去aaa和bb
  • java短路运算符和逻辑运算符的区别 3213213333332132 java基础
    /* * 逻辑运算符——不论是什么条件都要执行左右两边代码 * 短路运算符——我认为在底层就是利用物理电路的“并联”和“串联”实现的 * 原理很简单，并联电路代表短路或（||），串联电路代表短路与（&&）。 * * 并联电路两个开关只要有一个开关闭合，电路就会通。 * 类似于短路或（||），只要有其中一个为true（开关闭合）是
  • Java异常那些不得不说的事 白糖_ javaexception
    一、在finally块中做数据回收操作 比如数据库连接都是很宝贵的，所以最好在finally中关闭连接。 JDBCAgent jdbc = new JDBCAgent(); try{ jdbc.excute("select * from ctp_log"); }catch(SQLException e){ ... }finally{ jdbc.close();
  • utf-8与utf-8(无BOM)的区别 dcj3sjt126com PHP
    BOM——Byte Order Mark，就是字节序标记   在UCS 编码中有一个叫做"ZERO WIDTH NO-BREAK SPACE"的字符，它的编码是FEFF。而FFFE在UCS中是不存在的字符，所以不应该出现在实际传输中。UCS规范建议我们在传输字节流前，先传输 字符"ZERO WIDTH NO-BREAK SPACE"。这样如
  • JAVA Annotation之定义篇 周凡杨 java注解annotation入门注释
        Annotation: 译为注释或注解 An annotation, in the Java computer programming language, is a form of syntactic metadata that can be added to Java source code. Classes, methods, variables, pa
  • tomcat的多域名、虚拟主机配置 g21121 tomcat
    众所周知apache可以配置多域名和虚拟主机，而且配置起来比较简单，但是项目用到的是tomcat，配来配去总是不成功。查了些资料才总算可以，下面就跟大家分享下经验。 很多朋友搜索的内容基本是告诉我们这么配置： 在Engine标签下增面积Host标签，如下： <Host name="www.site1.com" appBase="webapps"
  • Linux SSH 错误解析（Capistrano 的cap 访问错误 Permission ） 510888780 linuxcapistrano
    1.ssh -v [email protected] 出现 Permission denied (publickey,gssapi-keyex,gssapi-with-mic,password). 错误 运行状况如下： OpenSSH_5.3p1, OpenSSL 1.0.1e-fips 11 Feb 2013 debug1: Reading configuratio
  • log4j的用法 Harry642 javalog4j
    一、前言：     log4j 是一个开放源码项目，是广泛使用的以Java编写的日志记录包。由于log4j出色的表现，     当时在log4j完成时，log4j开发组织曾建议sun在jdk1.4中用log4j取代jdk1.4 的日志工具类，但当时jdk1.4已接近完成，所以sun拒绝使用log4j，当在java开发中
  • mysql、sqlserver、oracle分页，java分页统一接口实现 aijuans oraclejave
    定义：pageStart 起始页，pageEnd 终止页,pageSize页面容量 oracle分页： 　　　　select * from ( select mytable.*,rownum num from (实际传的SQL) where rownum<=pageEnd) where num>=pageStart sqlServer分页：  
  • Hessian 简单例子 antlove javaWebservicehessian
    hello.hessian.MyCar.java package hessian.pojo; import java.io.Serializable; public class MyCar implements Serializable { private static final long serialVersionUID = 473690540190845543
  • 数据库对象的同义词和序列 百合不是茶 sql序列同义词ORACLE权限
    回顾简单的数据库权限等命令; 解锁用户和锁定用户 alter user scott account lock/unlock; //system下查看系统中的用户 select * dba_users; //创建用户名和密码 create user wj identified by wj; identified by //授予连接权和建表权 grant connect to
  • 使用Powermock和mockito测试静态方法 bijian1013 持续集成单元测试mockitoPowermock
            实例： package com.bijian.study; import static org.junit.Assert.assertEquals; import java.io.IOException; import org.junit.Before; import org.junit.Test; import or
  • 精通Oracle10编程SQL(6)访问ORACLE bijian1013 oracle数据库plsql
    /* *访问ORACLE */ --检索单行数据 --使用标量变量接收数据 DECLARE v_ename emp.ename%TYPE; v_sal emp.sal%TYPE; BEGIN select ename,sal into v_ename,v_sal from emp where empno=&no; dbms_output.pu
  • 【Nginx四】Nginx作为HTTP负载均衡服务器 bit1129 nginx
     Nginx的另一个常用的功能是作为负载均衡服务器。一个典型的web应用系统，通过负载均衡服务器，可以使得应用有多台后端服务器来响应客户端的请求。一个应用配置多台后端服务器，可以带来很多好处：   负载均衡的好处 增加可用资源 增加吞吐量 加快响应速度，降低延时 出错的重试验机制 Nginx主要支持三种均衡算法： round-robin l
  • jquery-validation备忘 白糖_ jquerycssF#Firebug
    留点学习jquery validation总结的代码：   function checkForm(){ validator = $("#commentForm").validate({// #formId为需要进行验证的表单ID errorElement :"span",// 使用"div"标签标记错误， 默认:&
  • solr限制admin界面访问（端口限制和http授权限制） ronin47 限定Ip访问
    solr的管理界面可以帮助我们做很多事情，但是把solr程序放到公网之后就要限制对admin的访问了。 可以通过tomcat的http基本授权来做限制，也可以通过iptables防火墙来限制。 我们先看如何通过tomcat配置http授权限制。 第一步： 在tomcat的conf/tomcat-users.xml文件中添加管理用户，比如： <userusername="ad
  • 多线程-用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 bylijinnan java多线程
    public class IncDecThread { private int j=10; /* * 题目:用JAVA写一个多线程程序，写四个线程，其中二个对一个变量加1，另外二个对一个变量减1 * 两个问题： * 1、线程同步--synchronized * 2、线程之间如何共享同一个j变量--内部类 */ public static
  • 买房历程 cfyme
        2015-06-21: 万科未来城，看房子   2015-06-26: 办理贷款手续，贷款73万，贷款利率5.65=5.3675   2015-06-27: 房子首付,签完合同   2015-06-28，央行宣布降息 0.25，就2天的时间差啊，没赶上。   首付，老婆找他的小姐妹接了5万，另外几个朋友借了1-
  • [军事与科技]制造大型太空战舰的前奏 comsci 制造
           天气热了........空调和电扇要准备好..........        最近,世界形势日趋复杂化,战争的阴影开始覆盖全世界..........        所以,我们不得不关
  • dateformat dai_lm DateFormat
    "Symbol Meaning Presentation Ex." "------ ------- ------------ ----" "G era designator (Text) AD" "y year
  • Hadoop如何实现关联计算 datamachine mapreducehadoop关联计算
        选择Hadoop，低成本和高扩展性是主要原因，但但它的开发效率实在无法让人满意。     以关联计算为例。     假设：HDFS上有2个文件，分别是客户信息和订单信息，customerID是它们之间的关联字段。如何进行关联计算，以便将客户名称添加到订单列表中？   &nbs
  • 用户模型中修改用户信息时，密码是如何处理的 dcj3sjt126com yii
    当我添加或修改用户记录的时候对于处理确认密码我遇到了一些麻烦，所有我想分享一下我是怎么处理的。 场景是使用的基本的那些(系统自带)，你需要有一个数据表(user)并且表中有一个密码字段(password),它使用 sha1、md5或其他加密方式加密用户密码。 面是它的工作流程: 当创建用户的时候密码需要加密并且保存，但当修改用户记录时如果使用同样的场景我们最终就会把用户加密过的密码再次加密，这
  • 中文 iOS/Mac 开发博客列表 dcj3sjt126com Blog
      本博客列表会不断更新维护，如果有推荐的博客，请到此处提交博客信息。 本博客列表涉及的文章内容支持 定制化Google搜索，特别感谢 JeOam 提供并帮助更新。 本博客列表也提供同步更新的OPML文件（下载OPML文件），可供导入到例如feedly等第三方定阅工具中，特别感谢 lcepy 提供自动转换脚本。这里有导入教程。
  • js去除空格，去除左右两端的空格 蕃薯耀 去除左右两端的空格js去掉所有空格js去除空格
    js去除空格，去除左右两端的空格 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>&g
  • SpringMVC4零配置--web.xml hanqunfeng springmvc4
    servlet3.0+规范后，允许servlet，filter，listener不必声明在web.xml中，而是以硬编码的方式存在，实现容器的零配置。 ServletContainerInitializer：启动容器时负责加载相关配置 package javax.servlet; import java.util.Set; public interface ServletContainer
  • 《开源框架那些事儿21》：巧借力与借巧力 j2eetop 框架UI
    同样做前端UI，为什么有人花了一点力气，就可以做好？而有的人费尽全力，仍然错误百出？我们可以先看看几个故事。 故事1：巧借力，乌鸦也可以吃核桃 有一个盛产核桃的村子，每年秋末冬初，成群的乌鸦总会来到这里，到果园里捡拾那些被果农们遗落的核桃。 核桃仁虽然美味，但是外壳那么坚硬，乌鸦怎么才能吃到呢？原来乌鸦先把核桃叼起，然后飞到高高的树枝上，再将核桃摔下去，核桃落到坚硬的地面上，被撞破了，于是，
  • JQuery EasyUI 验证扩展 可怜的猫 jqueryeasyui验证
      最近项目中用到了前端框架-- EasyUI，在做校验的时候会涉及到很多需要自定义的内容，现把常用的验证方式总结出来，留待后用。   以下内容只需要在公用js中添加即可。   使用类似于如下： <input class="easyui-textbox" name="mobile" id="mobile&
  • 架构师之httpurlconnection----------读取和发送(流读取效率通用类) nannan408
    1.前言.    如题. 2.代码. /* * Copyright (c) 2015, S.F. Express Inc. All rights reserved. */ package com.test.test.test.send; import java.io.IOException; import java.io.InputStream
  • Jquery性能优化 r361251 JavaScriptjquery
    一、注意定义jQuery变量的时候添加var关键字 这个不仅仅是jQuery，所有javascript开发过程中，都需要注意，请一定不要定义成如下： $loading = $('#loading'); //这个是全局定义，不知道哪里位置倒霉引用了相同的变量名，就会郁闷至死的 二、请使用一个var来定义变量 如果你使用多个变量的话，请如下方式定义： . 代码如下: var page
  • 在eclipse项目中使用maven管理依赖 tjj006 eclipsemaven
    概览: 如何导入maven项目至eclipse中 建立自有Maven  Java类库服务器 建立符合maven代码库标准的自定义类库 Maven在管理Java类库方面有巨大的优势，像白衣所说就是非常“环保”。 我们平时用IDE开发都是把所需要的类库一股脑的全丢到项目目录下，然后全部添加到ide的构建路径中，如果用了SVN/CVS，这样会很容易就 把
  • 中国天气网省市级联页面 x125858805 级联
    1、页面及级联js <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%> <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"> &l
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他