[关闭]
@baobaobear 2020-03-22T14:50:44.000000Z 字数 12446 阅读 207

Contest 20

contest

A 15291200127

  1. #include <set>
  2. #include <map>
  3. #include <deque>
  4. #include <queue>
  5. #include <stack>
  6. #include <cmath>
  7. #include <ctime>
  8. #include <bitset>
  9. #include <cstdio>
  10. #include <string>
  11. #include <vector>
  12. #include <cstdlib>
  13. #include <cstring>
  14. #include <cassert>
  15. #include <iostream>
  16. #include <algorithm>
  17. #include <unordered_map>
  18. #define mem(a,b) memset(a,b,sizeof (a))
  19. #define endl '\n'
  20. #define pb push_back
  21. typedef long long ll;
  22. const int maxn=200010;
  23. const int inf=1e9;
  24. const ll mod=998244353;
  25. const double pi=acos(-1.0);
  26. using namespace std;
  27. int main()
  28. {
  29.     ll n,a,b;
  30.     cin>>n>>a>>b;
  31.     ll ans=n/(a+b)*a;
  32.     ans+=min(n%(a+b),a);
  33.     cout<<ans<<endl;
  34.     return 0;
  35. }

B RobsonChen

  1. #include <iostream>
  2. #include <string>
  3. #include<algorithm>
  4. #include <cmath>
  5. #include <vector>
  7. using namespace std;
  8. typedef pair<int, int> PII;
  10. int main() {
  11.     string s;
  12.     cin >> s;
  13.     int n;
  14.     int len = s.size();
  15.     cin >> n;
  16.     vector<pair<int, char> > f;
  17.     for (int i = 1; i <= n; ++i) {
  18.         int op;
  19.         cin >> op;
  20.         if (op == 1) {
  21.             f.emplace_back(1, '0');
  22.         } else {
  23.             int k;
  24.             cin >> k;
  25.             string cur;
  26.             cin >> cur;
  27.             f.emplace_back(k + 1, cur[0]);
  28.         }
  29.     }
  30.     int num = 0;
  31.     for (auto i : f) {
  32.         if (i.first == 1) {
  33.             num++;
  34.             continue;
  35.         }
  36.         if (num % 2 == 0) {
  37.             if (i.first == 2) s.insert(0, 1, i.second);
  38.             else s.push_back(i.second);
  39.         } else {
  40.             if (i.first == 3) s.insert(0, 1, i.second);
  41.             else s.push_back(i.second);
  42.         }
  43.     }
  44.     if (num % 2)
  45.         reverse(s.begin(), s.end());
  46.     cout << s << endl;
  47.     return 0;
  48. }

C OUHE_csc

  1. #include<iostream>
  2. #include<algorithm>
  3. #include<cstdio>
  4. #include<cstring>
  6. using namespace std;
  8. typedef long long LL;
  10. const int N = 10;
  12. int a[N], b[N], p[N], n;
  14. bool check(int a[])
  15. {
  16.     for(int i = 0; i < n; i ++)
  17.         if(a[i] != p[i])  return false;
  18.     return true;
  19. }
  21. int main()
  22. {
  23.     scanf("%d", &n);
  24.     for(int i = 0; i < n; i ++)  scanf("%d", &a[i]);
  25.     for(int i = 0; i < n; i ++)  scanf("%d", &b[i]);
  27.     for(int i = 0; i < n; i ++)  p[i] = i + 1;
  29.     int r1 = -1, r2 = -1, num = 0;
  31.     do{
  32.         if(r1 == -1 and check(a))  r1 = num;
  33.         if(r2 == -1 and check(b))  r2 = num;
  34.         num ++;
  35.     }while(next_permutation(p, p + n));
  37.     printf("%d\n", abs(r1 - r2));
  38.     return 0;
  39. }

D 15291200127

  1. #include <set>
  2. #include <map>
  3. #include <deque>
  4. #include <queue>
  5. #include <stack>
  6. #include <cmath>
  7. #include <ctime>
  8. #include <bitset>
  9. #include <cstdio>
  10. #include <string>
  11. #include <vector>
  12. #include <cstdlib>
  13. #include <cstring>
  14. #include <cassert>
  15. #include <iostream>
  16. #include <algorithm>
  17. #define mem(a,b) memset(a,b,sizeof (a))
  18. #define endl '\n'
  19. #define pb push_back
  20. typedef long long ll;
  21. const int maxn=200010;
  22. const int inf=1e9;
  23. const int mod=10000;
  24. const double pi=acos(-1.0);
  25. using namespace std;
  26. int n;
  27. struct A
  28. {
  29.     int x;int y;
  30. }d[1100];
  31. int hash[11110],b[11110];
  32. int fd(A x)
  33. {
  34.     int u=(x.x*x.x+x.y*x.y)%mod+1;
  35.     u=hash[u];
  36.     while(u)
  37.     {
  38.         if(d[u].x==x.x&&d[u].y==x.y)
  39.             return 1;
  40.         u=b[u];
  41.     }
  42.     return 0;
  43. }
  44. int main()
  45. {
  46.     while(cin>>n)
  47.     {
  48.         if(n==0)
  49.             break;
  50.         mem(hash,0);
  51.         mem(b,0);
  52.         for(int i=1;i<=n;i++)
  53.         {
  54.             cin>>d[i].x>>d[i].y;
  55.             int x=(d[i].x*d[i].x+d[i].y*d[i].y)%mod+1;
  56.             b[i]=hash[x];
  57.             hash[x]=i;
  58.         }
  59.         int ans=0;
  60.         for(int i=1;i<=n;i++)
  61.             for(int j=1;j<=n;j++)
  62.             {
  63.                 if(i==j)
  64.                     continue;
  65.                 int x=d[i].x-d[j].x,y=d[i].y-d[j].y;
  66.                 A p,q;
  67.                 p.x=d[i].x-y;
  68.                 p.y=d[i].y+x;
  69.                 q.x=d[j].x-y;
  70.                 q.y=d[j].y+x;
  71.                 if(fd(p)&&fd(q))
  72.                     ans++;
  73.                 p.x=d[i].x+y;
  74.                 p.y=d[i].y-x;
  75.                 q.x=d[j].x+y;
  76.                 q.y=d[j].y-x;
  77.                 if(fd(p)&&fd(q))
  78.                     ans++;
  79.             }
  80.         cout<<ans/8<<endl;
  81.     }
  83. }

E AsilenceBTF

  1. #include<bits/stdc++.h>
  2. using namespace std;
  4. typedef long long ll;
  5. #define For(i,x,y) for(int i=x; i<y; ++i)
  6. #define mem(x,y) memset(x,y,sizeof(x))
  7. #define ALL(a) a.begin(),a.end()
  8. #define PII pair<int,int>
  9. #define INF 0x3f3f3f3f
  10. #define DOF 0x7f7f7f7f
  11. #define se second
  12. #define fi first
  13. #define endl '\n'
  15. template <typename T>
  16. inline void read(T &r){
  17.     static char c; r=0; int f=1;
  18.     for(c=getchar(); c<'0'||c>'9'; c=getchar()) if(c=='-')f=-1;
  19.     for(; c>='0'&&c<='9'; r=(r<<1)+(r<<3)+(c^48),c=getchar());
  20.     r*=f;
  21. } // -_- 
  23. const int N = 2e5+105;
  24. void solve(){
  25.     int n; cin>>n;
  26.     string s; cin>>s;
  27.     int start = s.size();
  28.     for(char c = 'z'; c >= 'a'; --c){
  29.         string str=""; int f = 0;
  30.         for(int i = 0; i < s.size(); ++i){
  31.             if(s[i] == c){
  32.                 if(i - 1 >= 0 && s[i-1] == c - 1) continue;
  33.                 if(i + 1 < s.size() && s[i+1] == c - 1) continue;
  34.                 str.push_back(s[i]);
  35.             }else str.push_back(s[i]);
  36.             f++;
  37.         }
  38.         if(f!=s.size()) ++c;
  39.         s=str;
  40.     }
  41.     cout<<start-s.size()<<endl;
  42. }
  43. int main(){
  44.     int t = 1;
  45.     // cin>>t;
  46.     while(t --) solve();
  47.     // system("pause");
  48. }

F AsilenceBTF

  1. #include <bits/stdc++.h>
  2. #define For(i,x,y) for(int i=x; i<y; ++i)
  3. #define mem(x,y) memset(x,y,sizeof(x))
  4. #define PII pair<long long,long long>
  5. #define INF 0x3f3f3f3f
  6. #define ll long long
  7. #define maxn 1005
  8. #define se second
  9. #define fi first
  10. #define endl '\n'
  11. using namespace std;
  12. const int N=100000;
  13. int pose[N],a[N];
  14. int main(){
  15.     int t,n,tot=2;
  16.     for(int i=2 ; ; ++i){
  17.         a[i]=(i-1)*i/2; ++tot;
  18.         if(a[i]>1000000000) break;
  19.     }
  20.     cin>>t;
  21.     while(t--){
  22.         cin>>n;
  23.         mem(pose,0);
  24.         printf("13");
  25.         int p=0;
  26.         for(;;){
  27.             int x=lower_bound(a+2,a+tot,n)-a;
  28.             if(a[x]>n)--x;
  29.             p=max(p,x);
  30.             while(n>=a[x]){
  31.                 n-=a[x]; ++pose[x];
  32.             }
  33.             if(n<=0) break;
  34.         }
  35.         For(i,2,N){
  36.             if(i>p) break;
  37.             printf("3");
  38.             while(pose[i]--) printf("7");
  39.         }
  40.         printf("\n");
  41.     }
  42.     // system("pause");
  43.     return 0;
  44. }

G puluo

  1. #include<stdio.h>
  2. #include<string.h>
  3. int dp[1000005][2],num[1000005]={0};
  4. char tmp[1000005];
  5. int min(int a,int b){
  6.     return a<b?a:b;
  7. }
  8. int main()
  9. {
  10.     int len,ans;
  11.     for(int i=0;i<1000005;i++)for(int j=0;j<2;j++)dp[i][j]=99;
  12.     scanf("%s",tmp);
  13.     len=strlen(tmp);
  14.     for(int i=1;i<=len;i++)num[i]=tmp[i-1]-'0';
  15.     dp[len][0]=num[len];dp[len][1]=10-num[len];
  16.     for(int i=len-1;i>=0;i--)
  17.     {
  18.         /*数位*/
  19.         dp[i][0]=min(dp[i+1][0]+num[i],dp[i+1][1]+num[i]+1),
  20.         dp[i][1]=min(10+dp[i+1][0]-num[i],10+dp[i+1][1]-(num[i]+1));
  21.     }
  22.     ans=min(dp[0][0],dp[0][1]);
  23.     printf("%d\n",ans);
  24. }

H AsilenceBTF

  1. // #include<bits/stdc++.h>
  2. #include<iostream>
  3. #include<cstdio>
  4. #include<cstring>
  5. #include<algorithm>
  6. #include<queue>
  7. using namespace std;
  9. typedef long long ll;
  10. #define For(i,x,y) for(int i=x; i<y; ++i)
  11. #define mem(x,y) memset(x,y,sizeof(x))
  12. #define ALL(a) a.begin(),a.end()
  13. #define PII pair<int,int>
  14. #define INF 0x3f3f3f3f
  15. #define DOF 0x7f7f7f7f
  16. #define se second
  17. #define fi first
  18. #define endl '\n'
  20. template <typename T>
  21. inline void read(T &r){
  22.     static char c; r=0; int f=1;
  23.     for(c=getchar(); c<'0'||c>'9'; c=getchar()) if(c=='-')f=-1;
  24.     for(; c>='0'&&c<='9'; r=(r<<1)+(r<<3)+(c^48),c=getchar());
  25.     r*=f;
  26. } // -_- 
  28. const int N = 1e4 + 105;
  29. struct node{
  30.     int pi, di;
  31.     bool operator<(const node&tl) const{
  32.         return di < tl.di;
  33.     }
  34. }a[N];
  35. priority_queue<int>que;
  36. int main(){
  37.     int n;
  38.     while(cin>>n){
  39.         for(int i = 1; i <= n; ++i){
  40.             scanf("%d%d", &a[i].pi, &a[i].di);
  41.         }
  42.         while(!que.empty()) que.pop();
  43.         sort(a + 1, a + 1 + n);
  44.         int tot = n, ans = 0;
  45.         for(int i = 10000; i >= 1; --i){
  46.             while(a[tot].di >= i && tot >= 1){
  47.                 que.push(a[tot].pi); 
  48.                 --tot;
  49.             }
  50.             if(que.empty()) continue;
  51.             ans += que.top(); que.pop();
  52.         }
  53.         cout<<ans<<endl;
  54.     }
  55. }

I rubbish_is_me

  1. #include<iostream>
  2. #include<cstdio>
  3. #include<algorithm>
  4. #include<sstream>
  5. #include<string>
  6. #include<string.h>
  7. #include<cmath>
  8. #include<stack>
  9. #include<queue>
  10. #include<vector>
  11. #include<map>
  12. #define E (2.71828182)
  13. #define PI (3.1415926535898)
  14. #define mem(a,b)    memset(a,b,sizeof(a))
  15. #define _max(a,b,c) (max(a,b)>c?max(a,b):c)
  16. #define mod 1000000007
  17. #include<set>
  18. #define gc getchar
  19. #define debug(a) cout << "*" << a << "*" << endl
  20. using namespace std;
  21. typedef long long ll;
  22. typedef unsigned long long ull;
  23. typedef pair<float, int> P;
  24. const int N = 200000;
  25. const long long  MAX_V = 5005, INF = 2147483647, MOD = 998244353;
  26. #include <iostream>
  27. using namespace std;
  28. int n, a[400005], b[200005], ga[400005], gb[200005];
  29. int nex[200005];
  30. void getNext() {
  31.      int *p = gb;
  32.      nex[0] = -1;
  33.      int j = 0;
  34.      int k = -1;
  35.      while (j < n - 1) {
  36.         if (k == -1 || p[j] == p[k]) {
  37.         //  if (p[++j] == p[++k])
  38.         //    next[j] = next[k];
  39.         //    else
  40.             nex[++j] = ++k;
  41.         } else {
  42.             k = nex[k];
  43.         }
  44.      }
  45.  }
  46. bool KMP() {
  47.     bool f = false;
  48.     int *t = ga, *p = gb;
  49.     int i = 0; // 主串的位置
  50.     int j = 0; // 模式串的位置
  51.     while (i < 2 * n - 1) {
  52.         if (j == -1 || t[i] == p[j]) { // 当j为-1时，要移动的是i，当然j也要归0
  53.             i++;
  54.             j++;
  55.             if (j == n)
  56.             {
  57.                 f = true;
  58.                 printf("%d %d\n", i - j, b[0] ^ a[i - j]);
  59.                 j = nex[j - 1] + 1;
  60.             }
  61.         } else {
  62.             // i不需要回溯了
  63.             // i = i - j + 1;
  64.             j = nex[j]; // j回到指定位置
  66.         }
  68.      }
  69.      return f;
  70. }
  71. int main()
  72. {
  73.     while (~scanf("%d", &n))
  74.     {
  75.         for (int i = 0; i < n; i++) 
  76.         {
  77.             scanf("%d", &a[i]);
  78.             if (i)
  79.                 ga[i - 1] = a[i - 1] ^ a[i]; 
  80.         }
  81.         ga[n - 1] = a[n - 1] ^ a[0];
  82.         for (int i = 0; i < n; i++) 
  83.         {
  84.             scanf("%d", &b[i]);
  85.             if (i)
  86.                 gb[i - 1] = b[i - 1] ^ b[i]; 
  87.         }
  88.         gb[n - 1] = b[n - 1] ^ b[0];
  89.         for (int i = n; i < 2 * n; i++) ga[i] = ga[i - n];
  90.         getNext();
  91.         if(!KMP())  printf("\n");
  92.     }
  93. }

J 15291200127

  1. #include <set>
  2. #include <map>
  3. #include <deque>
  4. #include <queue>
  5. #include <stack>
  6. #include <cmath>
  7. #include <ctime>
  8. #include <bitset>
  9. #include <cstdio>
  10. #include <string>
  11. #include <vector>
  12. #include <cstdlib>
  13. #include <cstring>
  14. #include <cassert>
  15. #include <iostream>
  16. #include <algorithm>
  17. #include <unordered_map>
  18. #define mem(a,b) memset(a,b,sizeof (a))
  19. #define endl '\n'
  20. #define pb push_back
  21. typedef long long ll;
  22. const int maxn=200010;
  23. const int inf=1e9;
  24. const ll mod=998244353;
  25. const double pi=acos(-1.0);
  26. using namespace std;
  27. int main()
  28. {
  29.     std::ios::sync_with_stdio(false);
  30.     int n,p;
  31.     string s;
  32.     cin>>n>>p>>s;
  33.     ll ans=0,x=1,a[11100],b=0;
  34.     if (p==2||p==5)
  35.     {
  36.         for (int i=0;i<n;i++)
  37.             if ((s[i]-'0')%p==0)
  38.                 ans+=i+1;
  39.     }
  40.     else
  41.     {
  42.         a[0]=1;
  43.         for (int i=n-1;i>=0;i--)
  44.         {
  45.             b+=(s[i]-'0')*x;
  46.             b%=p;
  47.             ans+=a[b]++;
  48.             x=x*10%p;
  49.         }
  50.     }
  51.     cout<<ans<<endl;
  52.     return 0;
  53. }

K baobaobear

  1. #define _CRT_SECURE_NO_WARNINGS
  2. #include <iostream>
  3. #include <algorithm>
  4. #include <string>
  5. #include <vector>
  6. #include <stack>
  7. #include <deque>
  8. #include <queue>
  9. #include <list>
  10. #include <limits>
  11. #include <set>
  12. #include <map>
  13. #include <functional>
  15. #include <inttypes.h>
  16. #include <stdint.h>
  17. #include <limits.h>
  18. #include <stdio.h>
  19. #include <stdlib.h>
  20. #include <string.h>
  21. #include <math.h>
  22. #include <time.h>
  24. using namespace std;
  25. typedef long long ll;
  27. #ifndef PRId64
  28. #define PRId64 "lld"
  29. #endif
  30. #ifndef SCNd64
  31. #define SCNd64 "lld"
  32. #endif
  33. #define SC sc()
  34. #define PT pr()
  35. #define NL pt_nl()
  36. #define FORi(i,b,e) for (int i = (b), _ = (e); i < _; ++i)
  37. #define FORe(i,b,e) for (int i = (b), _ = (e); i <= _; ++i)
  38. #define FORre(i,b,e) for (int i = (b), _ = (e); i >= _; --i)
  40. static int sc_ret = 0;
  41. struct pt_nl {};
  42. struct sc
  43. {
  44.     sc& operator>>(char& v) { v = sc_ret = getchar(); return *this; }
  45.     sc& operator>>(int& v) { /*sc_ret = read(v);*/ sc_ret = scanf("%d", &v); return *this; }
  46.     sc& operator>>(unsigned& v) { sc_ret = scanf("%u", &v); return *this; }
  47.     sc& operator>>(double& v) { sc_ret = scanf("%lf", &v); return *this; }
  48.     sc& operator>>(char* v) { sc_ret = scanf("%s", v); return *this; }
  49.     sc& operator>>(string& v) { sc_ret = (bool)(cin >> v); return *this; }
  50.     sc& operator>>(ll& v) { sc_ret = read(v); return *this; }
  51.     sc& ch(char& v) { sc_ret = scanf(" %c", &v); return *this; }
  52.     sc& gets(char* v) { sc_ret = fgets(v, INT_MAX, stdin) != 0; v[strlen(v) - 1] = 0; return *this; }
  53.     operator bool() const { return sc_ret > 0; }
  54.     template <typename T>
  55.     int read(T& v)
  56.     {
  57.         T x = 0, k = 1;
  58.         int c = getchar();
  59.         while (c < '0' || c > '9')
  60.         {
  61.             if (c == '-') k = -1;
  62.             c = getchar();
  63.         }
  64.         while (c >= '0' && c <= '9') x = (x << 3) + (x << 1) + (c - 48), c = getchar();
  65.         v = x * k;
  66.         return c;
  67.     }
  68. };
  69. struct pr
  70. {
  71.     pr& ln() { putchar('\n'); return *this; }
  72.     pr& operator<<(const pt_nl& nl) { putchar('\n'); return *this; }
  73.     pr& operator<<(char v) { putchar(v); return *this; }
  74.     pr& operator<<(int v) { write(v); return *this; }
  75.     pr& operator<<(double v) { printf("%.2f", v); return *this; }
  76.     pr& operator()(const char* fmt, double v) { printf(fmt, v); return *this; }
  77.     pr& operator<<(const char* v) { printf("%s", v);return *this; }
  78.     pr& operator<<(string v) { printf("%s", v.c_str());return *this; }
  79.     pr& operator<<(ll v) { write(v);return *this; }
  80.     template <typename T>
  81.     void write(T v)
  82.     {
  83.         int cnt = 0; char c[23];
  84.         if (v == 0)
  85.         {
  86.             putchar('0');
  87.             return;
  88.         }
  89.         if (v < 0) putchar('-'), v = -v;
  90.         while (v) c[++cnt] = (v % 10) + 48, v /= 10;
  91.         while (cnt > 0) putchar(c[cnt--]);
  92.     }
  93.     template <typename T>
  94.     void ln(T* arr, int size)
  95.     {
  96.         if (size > 0)
  97.         {
  98.             (*this)(arr[0]);
  99.             for (int i = 1; i < size; ++i)
  100.             {
  101.                 putchar(' ');
  102.                 (*this)(arr[i]);
  103.             }
  104.             putchar('\n');
  105.         }
  106.     }
  108.     template <typename T>
  109.     void muln(T* arr, int size)
  110.     {
  111.         for (int i = 0; i < size; ++i)
  112.         {
  113.             (*this)(arr[i]);
  114.             putchar('\n');
  115.         }
  116.     }
  117. };
  119. const int inf = 0x3f3f3f3f;
  120. const int mod = 1000000007;
  121. const int maxn = 2000000 + 10;
  123. struct seg_tree
  124. {
  125.     struct node
  126.     {
  127.         ll max;
  128.         ll min;
  129.         ll lz_add;
  130.         node() { max = min = lz_add = 0; }
  131.     };
  132.     int sz;
  133.     vector<node> d;
  134.     inline int lson(int tp) { return tp * 2 + 1; }
  135.     inline int rson(int tp) { return tp * 2 + 2; }
  136.     ll get_max(int l, int r, int tl, int tr, int tp)
  137.     {
  138.         if (l <= tl && tr <= r)
  139.         {
  140.             return d[tp].max;
  141.         }
  142.         int tmid = (tl + tr) / 2;
  143.         if (d[tp].lz_add != 0)
  144.         {
  145.             update_add(tl, tmid, d[tp].lz_add, tl, tmid, lson(tp));
  146.             update_add(tmid, tr, d[tp].lz_add, tmid, tr, rson(tp));
  147.             d[tp].lz_add = 0;
  148.         }
  149.         ll ret = INT64_MIN;
  150.         if (l < tmid) ret = max(ret, get_max(l, r, tl, tmid, lson(tp)));
  151.         if (r > tmid) ret = max(ret, get_max(l, r, tmid, tr, rson(tp)));
  152.         return ret;
  153.     }
  154.     ll get_min(int l, int r, int tl, int tr, int tp)
  155.     {
  156.         if (l <= tl && tr <= r)
  157.         {
  158.             return d[tp].min;
  159.         }
  160.         int tmid = (tl + tr) / 2;
  161.         if (d[tp].lz_add != 0)
  162.         {
  163.             update_add(tl, tmid, d[tp].lz_add, tl, tmid, lson(tp));
  164.             update_add(tmid, tr, d[tp].lz_add, tmid, tr, rson(tp));
  165.             d[tp].lz_add = 0;
  166.         }
  167.         ll ret = INT64_MAX;
  168.         if (l < tmid) ret = min(ret, get_min(l, r, tl, tmid, lson(tp)));
  169.         if (r > tmid) ret = min(ret, get_min(l, r, tmid, tr, rson(tp)));
  170.         return ret;
  171.     }
  172.     void build(int a[], int alen, int tl, int tr, int tp)
  173.     {
  174.         if (tl + 1 == tr)
  175.         {
  176.             if (tl < alen)
  177.             {
  178.                 d[tp].max = a[tl];
  179.                 d[tp].min = a[tl];
  180.             }
  181.             else
  182.             {
  183.                 d[tp].max = 0;
  184.                 d[tp].min = 0;
  185.             }
  186.             return;
  187.         }
  188.         int tmid = (tl + tr) / 2;
  189.         build(a, alen, tl, tmid, lson(tp));
  190.         build(a, alen, tmid, tr, rson(tp));
  191.         d[tp].max = max(d[lson(tp)].max, d[rson(tp)].max);
  192.         d[tp].min = min(d[lson(tp)].min, d[rson(tp)].min);
  193.     }
  194.     void build(int a[], int alen)
  195.     {
  196.         build(a, alen, 0, sz, 0);
  197.     }
  198.     void update_add(int l, int r, ll v, int tl, int tr, int tp)
  199.     {
  200.         if (l <= tl && tr <= r)
  201.         {
  202.             d[tp].max += v;
  203.             d[tp].min += v;
  204.             d[tp].lz_add += v;
  205.             return;
  206.         }
  207.         int tmid = (tl + tr) / 2;
  208.         if (d[tp].lz_add != 0)
  209.         {
  210.             update_add(tl, tmid, d[tp].lz_add, tl, tmid, lson(tp));
  211.             update_add(tmid, tr, d[tp].lz_add, tmid, tr, rson(tp));
  212.             d[tp].lz_add = 0;
  213.         }
  214.         if (l < tmid) update_add(l, r, v, tl, tmid, lson(tp));
  215.         if (r > tmid) update_add(l, r, v, tmid, tr, rson(tp));
  216.         d[tp].max = max(d[lson(tp)].max, d[rson(tp)].max);
  217.         d[tp].min = min(d[lson(tp)].min, d[rson(tp)].min);
  218.     }
  219.     void update_add(int l, int r, ll v)
  220.     {
  221.         update_add(l, r + 1, v, 0, sz, 0);
  222.     }
  223.     void init(int size)
  224.     {
  225.         sz = size;
  226.         while (sz & (sz - 1)) sz += sz&-sz;
  227.         d.resize(sz * 2);
  228.     }
  229.     ll get_min(int l, int r)
  230.     {
  231.         return get_min(l, r + 1, 0, sz, 0);
  232.     }
  233.     ll get_max(int l, int r)
  234.     {
  235.         return get_max(l, r + 1, 0, sz, 0);
  236.     }
  237. };
  239. int main()
  240. {
  241.     int n, m;
  242.     SC >> n >> m;
  243.     seg_tree st;
  244.     st.init(n + 4);
  245.     FORi(i, 0, m)
  246.     {
  247.         int o, l, r, a, b;
  248.         SC >> o >> l >> r;
  249.         if (o == 1)
  250.         {
  251.             int mn = 0, mx = 0;
  252.             if (l < r)
  253.             {
  254.                 mn = st.get_min(l + 1, r);
  255.                 mx = st.get_max(l + 1, r);
  256.             }
  257.             if (mn == 0 && mx == 0)
  258.             {
  259.                 PT << 1 << NL;
  260.             }
  261.             else
  262.             {
  263.                 PT << 0 << NL;
  264.             }
  265.         }
  266.         else
  267.         {
  268.             SC >> a >> b;
  269.             st.update_add(l, l, a);
  270.             if (l < r)
  271.                 st.update_add(l + 1, r, b);
  272.             st.update_add(r + 1, r + 1, -a - b * (r - l));
  273.         }
  274.     }
  275.     return 0;
  276. }

L

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注