25 条题解

  • 2
    @ 2021-7-18 14:55:00

    #include<bits/stdc++.h> using namespace std; typedef long long ll; static char buf[100000],*p1=buf,*p2=buf; #define gc p1p2&&(p2=(p1=buf)+fread(buf,1,100000,stdin),p1p2)?EOF:*p1++; inline ll read() { ll res=0,w=0; char c=gc; while (!isdigit(c)) w|=c=='-',c=gc; while (isdigit(c)) res=(res<<1)+(res<<3)+(c^48),c=gc; if (w) res=-res; return res; } inline void write(ll x) { static int sta[50],top=0; if (x<0) putchar('-'),x=-x; do { sta[top++]=x%10,x/=10; }while (x); while (top) putchar(sta[--top]+48); putchar(' '); }

    signed main() { ll a=read(),b=read(); write(a+b); }

    • 0
      @ 2025-7-24 16:03:57 
      #include<bits/stdc++.h>
using namespace std;
int n,fac[50000],ans[50000]={1,1};
int main()
{
    cin>>n;
    for(int i=1;i<=n;i++)
    {
        for (int j=1;j<=ans[0];j++)
        {
            ans[j]=ans[j]*i+fac[j];
            fac[j]=0;
            if (ans[j]>=10)
            {
                fac[j+1]+=ans[j]/10;
                ans[j]%=10;
                if (j==ans[0]) ++ans[0];
            }
        }
    }
    for (int i=ans[0];i>0;i--) cout<<ans[i];
}
      • 0
        @ 2025-7-24 15:50:23

        快来看我的高精度函数！

        兼带高精加、高精减、高精乘！！！

        不过大佬被喷，高精除我没写哟。

        string cheng(string n,string m)
{
    string k="";
    int a[10010],b[10010],f[10010];
    int la=n.size(),lb=m.size(),lf=la+lb;
    memset(a,0,sizeof(a));
    memset(b,0,sizeof(b));
    memset(f,0,sizeof(f));
    for(int i=la-1;i>=0;i--) a[la-i]=n[i]-'0';
    for(int i=lb-1;i>=0;i--) b[lb-i]=m[i]-'0';
    for(int i=1;i<=la;i++)
        for(int j=1;j<=lb;j++)
            f[i+j-1]+=a[i]*b[j];
    for(int i=1;i<=lf;i++)
    {
        f[i+1]+=f[i]/10;
        f[i]%=10;
    }
    while(f[lf]==0&&lf>1) lf--;
    for(int i=lf;i>=1;i--) k=k+char(f[i]+'0');
    return k;
}
string jia(string n,string m)
{
    int f[10010],a[10010],b[10010];
    string t="";
    memset(a,0,sizeof(a));
    memset(b,0,sizeof(b));
    memset(f,0,sizeof(f));
    int a1=n.size(),a2=m.size(),a3=max(a1,a2)+1;
	for(int i=1;i<=a1;i++) a[i]=n[a1-i]-'0';
	for(int i=1;i<=a2;i++) b[i]=m[a2-i]-'0';
	for(int i=1;i<=a3;i++)
	{
		f[i]+=a[i]+b[i];
		if(f[i]>=10)
		{
			f[i]-=10;
			f[i+1]++;
		}
	}
	if(f[a3]==0) a3--;
    for(int i=a3;i>=1;i--) t=t+char(f[i]+'0');
    return t;
}
string jian(string n,string m)
{
    int a[10010],b[10010],f[10010],la=n.size(),lb=m.size(),lf;
    string k="";
    memset(a,0,sizeof(a));
    memset(b,0,sizeof(b));
    memset(f,0,sizeof(f));
    if(lb>la||la==lb&&n<m)
    {
        swap(n,m);
        swap(la,lb);
        cout<<'-';
    }
    lf=la;
    for(int i=1;i<=la;i++) a[i]=n[la-i]-'0';
	for(int i=1;i<=lb;i++) b[i]=m[lb-i]-'0';
    for(int i=1;i<=lf;i++)
    {
        if(a[i]<b[i])
        {
            a[i+1]--;
            a[i]+=10;
        }
        f[i]=a[i]-b[i];
    }
    while(f[lf]==0&&lf>1) lf--;
    for(int i=lf;i>=1;i--) k=k+char(f[i]+'0');
    return k;
}
string dfs(string n,char w,string m)
{
    if(w=='+') return jia(n,m);
    if(w=='*') return cheng(n,m);
    if(w=='-') return jian(n,m);
}
        • 0
          @ 2025-7-17 11:19:18

          #include <bits/stdc++.h> using namespace std; int a,b,s; int f(int x,int y){ return x+y; } int main() { cin>>a>>b; s=0; s=1; s=9; s=2; s=9; s=4; s=4; s=4; s=4; s=4; s=4; s=4; s=4; s=4; s=4; s=4; s=4; s=4; s=4; s=4; s=4; cout<<a+b; }

          • 0
            @ 2025-7-14 15:28:15

            print(char(7))

            • 0
              @ 2025-7-13 14:29:17

              高精加​

              #include<bits/stdc++.h>
using namespace std;
int a[2000],b[2000],f[2000];
int main()
{
	string n,m;
	cin>>n>>m;
	int a1=n.size(),a2=m.size(),a3=max(a1,a2)+1;
	for (int i=1;i<=a1;i++) a[i]=n[a1-i]-'0';
	for (int i=1;i<=a2;i++) b[i]=m[a2-i]-'0';
	for (int i=1;i<=a3;i++)
	{
		f[i]+=a[i]+b[i];
		if (f[i]>=10)
		{
			f[i]-=10;
			f[i+1]++;
		}
	}
	if (f[a3]==0) a3--;
	for (int i=a3;i>=1;i--) cout<<f[i];
}
              • 0
                @ 2025-7-12 16:18:54

                #include <bits/stdc++.h> using namespace std; int n,m,x,t; char a[200][200]; int main() { cin>>n>>m>>x; for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) cin>>a[i][j]; for(int i=1;i<=n;i++){ for(int j=1;j<=m;j++){ if(a[i][j]>='a'){ t=a[i][j]-32+x; if(t>'Z') t=t-26; } else{ t=a[i][j]+32+x; if(t>'z') t=t-26; } cout<<char(t); } cout<<endl; } return 0; }

                • 0
                  @ 2025-7-12 16:18:48

                  姓马的，不要叫！

                  • 0
                    @ 2025-7-12 16:18:41

                    #include <bits/stdc++.h> using namespace std; int n,m,x,t; char a[200][200]; int main() { cin>>n>>m>>x; for(int i=1;i<=n;i++) for(int j=1;j<=m;j++) cin>>a[i][j]; for(int i=1;i<=n;i++){ for(int j=1;j<=m;j++){ if(a[i][j]>='a'){ t=a[i][j]-32+x; if(t>'Z') t=t-26; } else{ t=a[i][j]+32+x; if(t>'z') t=t-26; } cout<<char(t); } cout<<endl; } return 0; }

                    • 0
                      @ 2025-7-12 15:50:20 
                      #include<bits/stdc++.h>
using namespace std;
long long a,b;
int main()
{ 
 
	cin>>a>>b;
	cout<<a+b;
	return 0;
}
                      • 0
                        @ 2025-7-12 13:52:13

                        姓陈的，不要叫！

                        这是我闲着没事干手写头文件的：

                        #ifndef _INC_MINGW_SECAPI
#define _INC_MINGW_SECAPI
#if defined(__cplusplus) && (MINGW_HAS_SECURE_API == 1)
#ifndef _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES
#define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES 1         /* default to 1 */
#endif 
#ifndef _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY
#define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY 0  /* default to 0 */
#endif 
#ifndef _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 0       /* default to 0 */
#endif
#ifndef _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT 0 /* default to 0 */
#endif 
#ifndef _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY 0 /* default to 0 */
#endif 
#else
#undef _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES
#undef _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY
#undef _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES
#undef _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT
#undef _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY
#define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES 0
#define _CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY 0
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES 0
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT 0
#define _CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY 0
#endif 
#define __MINGW_CRT_NAME_CONCAT1(sym) ::sym
#define __MINGW_CRT_NAME_CONCAT2(sym) ::sym##_s
#define __MINGW_CRT_NAME_INSECURE(sym) ::__insecure__##sym
#define __MINGW_CRT_NAME_INSECURE_DEF(sym) __insecure__##sym
#ifdef __cplusplus
extern "C++" {
template <bool __test, typename __dsttype>
  struct __if_array;
template <typename __dsttype>
  struct __if_array <true, __dsttype> {
    typedef __dsttype __type;
};
}
#endif 
#if (_CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES == 1)
#define __CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_0_2_(__ret,__func,__type1,__attrib1,__arg1,__type2,__attrib2,__arg2,__type3,__attrib3,__arg3)\
  extern "C" { _CRTIMP __ret __cdecl __func(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2, __type3 __attrib3 __arg3); }\
  extern "C++" {\
    template <size_t __size> inline\
    __ret __cdecl __func(\
    __type1 (&__arg1)[__size],\
    __type3 __attrib3 (__arg3)) {\
      return __MINGW_CRT_NAME_CONCAT1(__func)(__arg1,__size,__arg3);\
    }\
  }
#else
#define __CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_0_2_(__ret,__func,__type1,__attrib1,__arg1,__type2,__attrib2,__arg2,__type3,__attrib3,__arg3)\
  _CRTIMP __ret __cdecl __func(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2, __type3 __attrib3 __arg3);
#endif
#if (_CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY == 1)
#define __CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY_0_3_(__ret,__func,__type1,__attrib1,__arg1,__type2,__attrib2,__arg2,__type3,__attrib3,__arg3,__type4,__attrib4,__arg4)\
  extern "C" { _CRTIMP __ret __cdecl __func(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2, __type3 __attrib3 __arg3, __type4 __attrib4 __arg4); }\
  extern "C++" {\
    template <size_t __size> inline\
    __ret __cdecl __func(\
    __type1 (&__arg1)[__size],\
    __type3 __attrib3 (__arg3),\
    __type4 __attrib4 (__arg4)) {\
      return __MINGW_CRT_NAME_CONCAT1(__func)(__arg1,__size,__arg3,__arg4);\
    }\
  }
#else
#define __CRT_SECURE_CPP_OVERLOAD_SECURE_NAMES_MEMORY_0_3_(__ret,__func,__type1,__attrib1,__arg1,__type2,__attrib2,__arg2,__type3,__attrib3,__arg3,__type4,__attrib4,__arg4)\
  _CRTIMP __ret __cdecl __func(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2, __type3 __attrib3 __arg3, __type4 __attrib4 __arg4);
#endif 
#if (_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES == 1)
#define __CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_0_2_(__ret,__func,__type1,__attrib1,__arg1,__type2,__attrib2,__arg2)\
  extern "C" {\
    inline __ret __cdecl __MINGW_CRT_NAME_INSECURE_DEF(__func)(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2){\
      _CRTIMP __ret __cdecl __func(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2);\
      return __func(__arg1,__arg2);\
    }\
  }\
  extern "C++" {\
    template <size_t __size> inline\
    __ret __cdecl __func(\
    __type1 (&__arg1)[__size],\
    __type2 (__arg2)) {\
      return __MINGW_CRT_NAME_CONCAT2(__func) (__arg1,__size,__arg2) == 0 ? __arg1 : NULL;\
    }\
    template <typename __t1> inline \
    __t1 __cdecl __func(\
    __t1 __attrib1 (__arg1),\
    __type2 __attrib2 (__arg2)) {\
      return __MINGW_CRT_NAME_INSECURE(__func)(__arg1,__arg2);\
    }\
  }
#else
#define __CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_0_2_(__ret,__func,__type1,__attrib1,__arg1,__type2,__attrib2,__arg2)\
  _CRTIMP __ret __cdecl __func(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2) __MINGW_ATTRIB_DEPRECATED_SEC_WARN;
#endif 
#if (_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT == 1) && (_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES == 1)
#define __CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT_0_3_(__ret,__func,__type1,__attrib1,__arg1,__type2,__attrib2,__arg2,__type3,__attrib3,__arg3)\
  extern "C" {\
    inline __ret __cdecl __MINGW_CRT_NAME_INSECURE_DEF(__func)(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2, __type3 __attrib3 __arg3){\
      _CRTIMP __ret __cdecl __func(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2, __type3 __attrib3 __arg3);\
      return __func(__arg1,__arg2,__arg3);\
    }\
  }\
  extern "C++" {\
    template <size_t __size> inline\
    __ret __cdecl __func(\
    __type1 (&__arg1)[__size],\
    __type2 __attrib2 (__arg2),\
    __type3 __attrib3 (__arg3)) {\
      return __MINGW_CRT_NAME_CONCAT2(__func) (__arg1,__size,__arg2,__arg3) == 0 ? __arg1 : NULL;\
    }\
    template <typename __t1> inline \
    __ret __cdecl __func(\
    __t1 (__arg1),\
    __type2 __attrib2 (__arg2),\
    __type3 __attrib3 (__arg3)) {\
      return __MINGW_CRT_NAME_INSECURE(__func) (__arg1,__arg2,__arg3);\
    }\
  }
#define __CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT_1_4_(__ret,__imp_attrib,__func,__real_func,__type1,__attrib1,__arg1,__type2,__attrib2,__arg2,__type3,__attrib3,__arg3,__type4,__attrib4,__arg4)\
  extern "C" {\
    inline __ret __cdecl __MINGW_CRT_NAME_INSECURE_DEF(__func)(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2, __type3 __attrib3 __arg3, __type4 __attrib4 __arg4){\
      __imp_attrib __ret __cdecl __func(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2, __type3 __attrib3 __arg3, __type4 __attrib4 __arg4);\
      return __func(__arg1,__arg2,__arg3,__arg4);\
    }\
  }\
  extern "C++" {\
    template <size_t __size> inline\
    __ret __cdecl __func(\
    __type1 (&__arg1)[__size],\
    __type2 __attrib2 (__arg2),\
    __type3 __attrib3 (__arg3),\
    __type4 __attrib4 (__arg4)) {\
      return __MINGW_CRT_NAME_CONCAT1(__real_func) (__arg1,__size,__arg2,__arg3,__arg4) == 0 ? __arg1 : NULL;\
    }\
    template <typename __t1> inline \
    __ret __cdecl __func(\
    __t1 (__arg1),\
    __type2 __attrib2 (__arg2),\
    __type3 __attrib3 (__arg3),\
    __type4 __attrib4 (__arg4)) {\
      return __MINGW_CRT_NAME_INSECURE(__func) (__arg1,__arg2,__arg3,__arg4);\
    }\
  }
#else
#define __CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT_0_3_(__ret,__func,__type1,__attrib1,__arg1,__type2,__attrib2,__arg2,__type3,__attrib3,__arg3)\
  _CRTIMP __ret __cdecl __func(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2, __type3 __attrib3 __arg3) __MINGW_ATTRIB_DEPRECATED_SEC_WARN;
#define __CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_COUNT_1_4_(__ret,__imp_attrib,__func,__real_func,__type1,__attrib1,__arg1,__type2,__attrib2,__arg2,__type3,__attrib3,__arg3,__type4,__attrib4,__arg4)\
  __imp_attrib __ret __cdecl __func(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2, __type3 __attrib3 __arg3, __type4 __attrib4 __arg4) __MINGW_ATTRIB_DEPRECATED_SEC_WARN;
#endif
#if (_CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY == 1)
#define __CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY_0_3_(__ret,__func,__type1,__attrib1,__arg1,__type2,__attrib2,__arg2,__type3,__attrib3,__arg3)\
  extern "C" {_CRTIMP __ret __cdecl __func(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2, __type3 __attrib3 __arg3) __MINGW_ATTRIB_DEPRECATED_SEC_WARN;}\
  extern "C++" {\
    template <size_t __size, typename __dsttype> inline\
    typename __if_array < (__size > 1), void * >::__type __cdecl __func(\
    __dsttype (&__arg1)[__size],\
    __type2 __attrib2 (__arg2),\
    __type3 __attrib3 (__arg3)) {\
      return __MINGW_CRT_NAME_CONCAT2(__func) (__arg1,__size * sizeof(__dsttype),__arg2,__arg3) == 0 ? __arg1 : NULL;\
    }\
  }
#else
#define __CRT_SECURE_CPP_OVERLOAD_STANDARD_NAMES_MEMORY_0_3_(__ret,__func,__type1,__attrib1,__arg1,__type2,__attrib2,__arg2,__type3,__attrib3,__arg3)\
  _CRTIMP __ret __cdecl __func(__type1 * __attrib1 __arg1, __type2 __attrib2 __arg2, __type3 __attrib3 __arg3) __MINGW_ATTRIB_DEPRECATED_SEC_WARN;
#endif
#endif 
#include<bits/stdc++.h>
#define int long long 
using namespace std;
int a,b;
int main(){
	cin>>a>>b;
	cout<<a+b;
	return 0;
}
                        • 0
                          @ 2025-6-2 19:04:16

                          记得一键三连哦！

                          超级详细的！

                          注意（打个广告：我们班的xhchenyr超级有实力的！！！）

                          c++

                          #include<bits/stdc++.h>
using namespace std;
int a[2000],b[2000],f[2000],l,p,o,g;
int main()
{
	string n,m;
	cin>>n>>m;
	int a1=n.size(),a2=m.size(),a3=max(a1,a2)+1;
	for (int i=1;i<=a1;i++) a[i]=n[a1-i]-'0';
	for (int i=1;i<=a2;i++) b[i]=m[a2-i]-'0';
	for (int i=1;i<=a3;i++)
	{
		f[i]+=a[i]+b[i];
		if (f[i]>=10)
		{
			f[i]-=10;
			f[i+1]++;
		}
	}
	if (f[a3]==0) a3--;
	for (int i=a3;i>=1;i--) cout<<f[i];
}

                          c

                          #include <stdio.h>
int main() 
{
    int a,b;
    scanf ("%d %d",&a,&b);
    printf ("%d",a+b);
 }

                          Python 2

                          a=input()
b=input()
print(a+b)

                          Python 3

                          try:
    while True:
	    a,b=map(int,input().split(' '))
	    print(a+b)
except:
	pass

                          还有c++方法！！！

                          最短路之Dijkstra c++

                          #include<bits/stdc++.h>
using namespace std;
const int N = 200020;
int n, m, h[N], e[N], w[N], ne[N], idx;
int dist[N];
bool st[N];
void add(int a, int b, int c)
{
    e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++;
}
int dijkstra()
{
    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> heap;
    heap.push({0, 1});
    memset(dist, 0x3f, sizeof dist);
    dist[1] = 0;
    while(!heap.empty())
    {
        auto t = heap.top();
        heap.pop();
        int vel = t.second;
        if(st[vel]) continue;
        st[vel] = true;
        for(int i = h[vel]; i != -1; i = ne[i])
        {
            int j = e[i];
            if(dist[j] > dist[vel] + w[i])
            {
                dist[j] = dist[vel] + w[i];
                heap.push({dist[j], j});
            }
        }
    }
    if(dist[3] == 0x3f3f3f3f) return -1;
    return dist[3];
}
int main()
{
    int a, b;
    memset(h, -1, sizeof h);
    cin >> a >> b;
    add(1, 2, a);
    add(2, 3, b);
    int t = dijkstra();
    cout << t;
    return 0;
}

                          矩阵乘法 c++

                          #include<bits/stdc++.h>
using namespace std;
int q, b;
int a[2][2] = 
{
    {0, 1},
    {1, 1}
};
int n;
void mo(int f[])
{
    int ans[2] = {0};
    for(int i = 0; i < 2; i ++)
    {
        for(int j = 0; j < 2; j ++)
        {
            ans[i] += f[j] * a[i][j];
        }
    }
    for(int i = 0; i < 2; i ++) f[i] = ans[i];
}
int main()
{
    cin >> q >> b;
    int f[3] = {q, b};
    for(int i = 1; i <= 1; i ++) mo(f);
    cout << f[1];
    return 0;
}

                          递推解法 c++

                          #include<bits/stdc++.h>
using namespace std;
int f[3];
int main()
{
    int a, b;
    cin >> a >> b;
    f[1] = a;
    f[2] = b;
    for(int i = 3; i <= 3; i ++ ) f[i] = f[i - 1] + f[i - 2];
    cout << f[3] << endl;
    return 0;
}

                          二分 c++

                          #include <bits/stdc++.h>
using namespace std;
int a, b;
int main() {
    scanf("%d%d", &a, &b);
    int l = 0, r = 200000000;
    while (l < r) {
        int mid = l + r >> 1;
        if (mid == a + b) {printf("%d\n", mid); return 0;}
        if (mid <  a + b) l = mid + 1;
        if (mid >  a + b) r = mid - 1;
    }
    cout << l << endl;
    return 0;
}

                          前缀和

                          #include <bits/stdc++.h>
using namespace std;
int a[5], s[5];
int main() {
    for (int i = 1;i <= 2; i++) scanf("%d", &a[i]), s[i] += a[i] + s[i - 1];
    printf("%d\n", s[2]);
    return 0;
}

                          后缀和

                          #include <bits/stdc++.h>
using namespace std;
int a[5], s[5];
int main() {
    for (int i = 2;i >= 1; i--) scanf("%d", &a[i]), s[i] += a[i] + s[i + 1];
    printf("%d\n", s[1]);
    return 0;
}

                          网络流 c++

                          #include<bits/stdc++.h>
using namespace std;
#define set(x) Set(x)
#define REP(i,j,k) for (int i=(j),_end_=(k);i<=_end_;++i)
#define DREP(i,j,k) for (int i=(j),_start_=(k);i>=_start_;--i)
#define mp make_pair
#define x first
#define y second
#define pb push_back
template<typename T> inline bool chkmin(T &a,const T &b){ return a > b ? a = b, 1 : 0; }
template<typename T> inline bool chkmax(T &a,const T &b){ return a < b ? a = b, 1 : 0; }
typedef long long LL;
typedef pair<int,int> node;
const int dmax = 1010, oo = 0x3f3f3f3f;
int n, m;
int a[dmax][dmax] , ans;
int d[dmax], e[dmax];
priority_queue <node> q;
inline bool operator >(node a,node b){ return a.y>b.y; }
bool p[dmax];
void Set(int x){ p[x] = 1; }
void unset(int x){ p[x] = 0; }
bool check(int x){ return x != 1 && x != n && !p[x] && e[x] > 0; }
void preflow(){
    e[1] = oo;
    d[1] = n - 1;
    q.push(mp(1, n - 1));
    set(1);
    while (!q.empty()) {
        bool flag = 1;
        int k = q.top().x;
        q.pop(), unset(k);
        DREP(i, n, 1)
        if ((d[k] == d[i] + 1 || k == 1) && a[k][i] > 0){
            flag = 0;
            int t = min(a[k][i], e[k]);
            e[k] -= t;
            a[k][i] -= t;
            e[i] += t;
            a[i][k] += t;
            if (check(i)) {
                q.push(mp(i, d[i]));
                set(i);
            }
            if (e[k] == 0) break;
        }
        if (flag) {
            d[k] = oo;
            REP(i, 1, n)
            if (a[k][i] > 0) chkmin(d[k], d[i] + 1);
        }
        if (check(k)) {
            q.push(mp(k, d[k]));
            set(k);
        }
    }
    ans = e[n];
}
int main() {
    n = 2, m = 2;
    int x, y;
    scanf("%d%d", &x, &y);
    a[1][2] += x + y;
    preflow();
    printf("%d\n", ans);
    return 0;
}

                          分块 c++

                          #include<bits/stdc++.h>
using namespace std;
long long a[50000010], sum[50000010], add[50000010];
int L[50000010], R[50000010];
int pos[50000010];
int n = 1, m = 2, t;

void change(int l, int r, long long d) {
    int p = pos[l], q = pos[r];
    if (p == q) {
        for (int i = l; i <= r; i++) a[i] += d;
        sum[p] += d*(r - l + 1);
    }
    else {
        for (int i = p + 1; i <= q - 1; i++) add[i] += d;
        for (int i = l; i <= R[p]; i++) a[i] += d;
        sum[p] += d*(R[p] - l + 1);
        for (int i = L[q]; i <= r; i++) a[i] += d;
        sum[q] += d*(r - L[q] + 1);
    }
}

long long ask(int l, int r) {
    int p = pos[l], q = pos[r];
    long long ans = 0;
    if (p == q) {
        for (int i = l; i <= r; i++) ans += a[i];
        ans += add[p] * (r - l + 1);
    }
    else {
        for (int i = p + 1; i <= q - 1; i++)
            ans += sum[i] + add[i] * (R[i] - L[i] + 1);
        for (int i = l; i <= R[p]; i++) ans += a[i];
        ans += add[p] * (R[p] - l + 1);
        for (int i = L[q]; i <= r; i++) ans += a[i];
        ans += add[q] * (r - L[q] + 1);
    }
    return ans;
}

int main() {
    a[1] = 0;
    t = sqrt(n*1.0);
    for (int i = 1; i <= t; i++) {
        L[i] = (i - 1)*sqrt(n*1.0) + 1;
        R[i] = i*sqrt(n*1.0);
    }
    if (R[t] < n) t++, L[t] = R[t - 1] + 1, R[t] = n;
    for (int i = 1; i <= t; i++)
        for (int j = L[i]; j <= R[i]; j++) {
            pos[j] = i;
            sum[i] += a[j];
        }
    while (m--) {
        int d;
        scanf("%d", &d);
        change(1, 1, d);
    }
    printf("%lld\n", ask(1, 1));
}

                          LCT c++

                          #include<bits/stdc++.h>
using namespace std;
struct node
{
    int data,rev,sum;
    node *son[2],*pre;
    bool judge();
    bool isroot();
    void pushdown();
    void update();
    void setson(node *child,int lr);
}lct[233];
int top,a,b;
node *getnew(int x)
{
    node *now=lct+ ++top;
    now->data=x;
    now->pre=now->son[1]=now->son[0]=lct;
    now->sum=0;
    now->rev=0;
    return now;
}
bool node::judge()
{
    return pre->son[1]==this;
}
bool node::isroot()
{
    if(pre==lct)return true;
    return !(pre->son[1]==this||pre->son[0]==this);
}
void node::pushdown()
{
    if(this==lct||!rev)return;
    swap(son[0],son[1]);
    son[0]->rev^=1;
    son[1]->rev^=1;
    rev=0;
}
void node::update()
{
    sum=son[1]->sum+son[0]->sum+data;
}
void node::setson(node *child,int lr)
{
    this->pushdown();
    child->pre=this;
    son[lr]=child;
    this->update();
}
void rotate(node *now)
{
    node *father=now->pre,*grandfa=father->pre;
    if(!father->isroot()) grandfa->pushdown();
    father->pushdown();
    now->pushdown();
    int lr=now->judge();
    father->setson(now->son[lr^1],lr);
    if(father->isroot()) now->pre=grandfa;
    else grandfa->setson(now,father->judge());
    now->setson(father,lr^1);
    father->update();
    now->update();
    if(grandfa!=lct) grandfa->update();
}
void splay(node *now)
{
    if(now->isroot())return;
    for(; !now->isroot(); rotate(now))
    if(!now->pre->isroot())
    now->judge()==now->pre->judge()?rotate(now->pre):rotate(now);
}
node *access(node *now)
{
    node *last=lct;
    for(; now!=lct; last=now,now=now->pre) {
        splay(now);
        now->setson(last,1);
    }
    return last;
}
void changeroot(node *now)
{
    access(now)->rev^=1;
    splay(now);
}
void connect(node *x,node *y)
{
    changeroot(x);
    x->pre=y;
    access(x);
}
void cut(node *x,node *y)
{
    changeroot(x);
    access(y);
    splay(x);
    x->pushdown();
    x->son[1]=y->pre=lct;
    x->update();
}
int query(node *x,node *y)
{
    changeroot(x);
    node *now=access(y);
    return now->sum;
}
int main()
{
    scanf("%d%d",&a,&b);
    node *A=getnew(a);
    node *B=getnew(b);
    connect(A,B);
    cut(A,B);
    connect(A,B);
    printf("%d",query(A,B));
    return 0;
}

                          暴力枚举优化版 c++

                          #include <bits/stdc++.h>
using namespace std;
int main() {
    int a, b; scanf("%d%d", &a, &b);
    for (int i = min(2 * a, 2 * b);i <= max(2 * a, 2 * b); i++)
        if (a + b == i) {
            printf("%d", i); //注意要输出i，不然如果输出a+b循环就没意义了……
            return 0;
        }
}

                          极限卡点 c++

                          #include <bits/stdc++.h>
using namespace std;
int st = clock();
int main() {
    int a, b; scanf("%d%d", &a, &b);
    while (clock() - st < 995000) {}
    printf("%d", a + b);
    return 0;
}

                          Treap（平衡树）c++

                          #include<bits/stdc++.h>
using namespace std;
const int N=1e5+5,INF=(1ll<<31)-1;
struct BST
{
    int l,r,x,p,siz,cnt;
}a[N];
int q,p,idx,root;
int New(int x)
{
    a[++idx].x=x;
    a[idx].p=rand();
    a[idx].siz=a[idx].cnt=1;
    return idx;
}
void Update(int u)
{
    a[u].siz=a[a[u].l].siz+a[a[u].r].siz+a[u].cnt;
}
void Build()
{
    New(-INF),New(INF);
    root=1,a[1].r=2;
    Update(root);
}
int GetRank(int u,int x)
{
    if(!u) return 0;
    if(x==a[u].x) return a[a[u].l].siz;
    if(x<a[u].x) return GetRank(a[u].l,x);
    else return GetRank(a[u].r,x)+a[a[u].l].siz+a[u].cnt;
}
int GetValue(int u,int x)
{
    if(!u) return INF;
    if(a[a[u].l].siz>=x) return GetValue(a[u].l,x);
    if(a[a[u].l].siz+a[u].cnt>=x) return a[u].x;
    return GetValue(a[u].r,x-a[a[u].l].siz-a[u].cnt);
}
void zig(int &u)
{
    int v=a[u].l;
    a[u].l=a[v].r,a[v].r=u,u=v;
    Update(a[u].r),Update(u);
}
void zag(int &u)
{
    int v=a[u].r;
    a[u].r=a[v].l,a[v].l=u,u=v;
    Update(a[u].l),Update(u);
}
void Insert(int &u,int x)
{
    if(!u)
    {
        u=New(x);
        return;
    }
    if(x==a[u].x)
    {
        a[u].cnt++,Update(u);
        return;
    }
    if(x<a[u].x) 
    {
        Insert(a[u].l,x);
        if(a[u].p<a[a[u].l].p)
            zig(u);
    }
    else
    {
        Insert(a[u].r,x);
        if(a[u].p<a[a[u].r].p)
            zag(u);
    }
    Update(u);
}
int GetPrev(int u,int x,int res)
{
    if(a[u].x>=x)
    {
        if(!a[u].l) return res;
        return GetPrev(a[u].l,x,res);
    }
    if(!a[u].r) return a[u].x;
    return GetPrev(a[u].r,x,a[u].x);
}
int GetNext(int u,int x,int res)
{
    if(a[u].x<=x)
    {
        if(!a[u].r) return res;
        return GetNext(a[u].r,x,res);
    }
    if(!a[u].l) return a[u].x;
    return GetNext(a[u].l,x,a[u].x);
}
void Remove(int &u,int x)
{
    if(!u) return;
    if(x==a[u].x)
    {
        if(a[u].cnt>1)
        {
            a[u].cnt--,Update(u);
            return;
        }
        if(a[u].l||a[u].r)
        {
            if(!a[u].r||a[a[u].l].p>a[a[u].r].p)
                zig(u),Remove(a[u].r,x);
            else zag(u),Remove(a[u].l,x);
            Update(u);
            return;
        }
        u=0;
        return;
    }
    if(x<a[u].x) Remove(a[u].l,x);
    else Remove(a[u].r,x);
    Update(u);
}
int main()
{
    cin>>q>>p;
    if(q>p) swap(q,p);
    Build();
    Insert(root,q);Insert(root,p);
    Remove(root,p);Insert(root,p);
    cout<<(GetPrev(root,p,-INF)+GetNext(root,q,INF)+GetValue(root,GetRank(root,q)+1)+GetValue(root,GetRank(root,p)+1))/2<<endl;
    return 0;
}

                          马占武看我写的代码

                          这就是我的实力！哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈

                          • 0
                            @ 2025-4-21 16:43:24 
                            #include<bits/stdc++.h>
using namespace std;
int a[2000],b[2000],f[2000],l,p,o,g;
int main()
{
	string n,m;
	cin>>n>>m;
	int a1=n.size(),a2=m.size(),a3=max(a1,a2)+1;
	for (int i=1;i<=a1;i++) a[i]=n[a1-i]-'0';
	for (int i=1;i<=a2;i++) b[i]=m[a2-i]-'0';
	for (int i=1;i<=a3;i++)
	{
		f[i]+=a[i]+b[i];
		if (f[i]>=10)
		{
			f[i]-=10;
			f[i+1]++;
		}
	}
	if (f[a3]==0) a3--;
	for (int i=a3;i>=1;i--) cout<<f[i];
}
                            • 0
                              @ 2025-3-12 18:46:56 
                              #include<bits/stdc++.h>
using namespace std;
long long t,f,n,m,a[100000],b[100000];
int main()
{
	cin>>n>>m;
	t=n,f=m;
	n=false;
	m=false;
	while (n<t)
	{
		n++;
		a[n]=n;
	}
	while (m<f)
	{
		m++;
		b[m]=m;
	}
	cout<<b[m]+a[n];
}
                              • 0
                                @ 2025-3-11 16:58:15 
                                try:
    while True:
	    a,b=map(int,input().split(' '))
	    print(a+b)
except:
	pass
                                • 0
                                  @ 2024-10-1 12:53:17

                                  c

                                  #include <stdio.h>

int main() {
    int a,b;
    scanf ("%d %d",&a,&b);
    printf ("%d",a+b);
 }
                                  • 0
                                    @ 2024-7-21 15:39:28

                                    #include<bits/stdc++.h> using namespace std; int a[10010],b[10010],c[10010]; int main() { string x,y; cin>>x>>y; int t=0,lena=x.size(),lenb=y.size(); int lenc=max(lena,lenb); for(int i=0;i<lena;i++)a[lena-i]=x[i]-'0'; for(int i=0;i<lenb;i++)b[lenb-i]=y[i]-'0'; for(int i=1;i<=lenc;i++) { t=a[i]+b[i]+t; c[i]=t%10; t/=10; } if(t>0)c[++lenc]=t; for(int i=lenc;i>=1;i--)cout<<c[i]; return 0; }

                                    • 0
                                      @ 2023-10-12 21:21:34

                                      #include<bits/stdc++.h> using namespace std; int a[10010],b[10010],c[10010]; int main() { string x,y; cin>>x>>y; int t=0,lena=x.size(),lenb=y.size(); int lenc=max(lena,lenb); for(int i=0;i<lena;i++)a[lena-i]=x[i]-'0'; for(int i=0;i<lenb;i++)b[lenb-i]=y[i]-'0'; for(int i=1;i<=lenc;i++) { t=a[i]+b[i]+t; c[i]=t%10; t/=10; } if(t>0)c[++lenc]=t; for(int i=lenc;i>=1;i--)cout<<c[i]; return 0; }

                                      • 0
                                        @ 2023-8-23 15:15:13 
                                        #include<bits/stdc++.h>
using namespace std;
int a[10010],b[10010],c[10010];
int main()
{
	string x,y;
	cin>>x>>y;
	int t=0,lena=x.size(),lenb=y.size();
	int lenc=max(lena,lenb);
	for(int i=0;i<lena;i++)a[lena-i]=x[i]-'0';
	for(int i=0;i<lenb;i++)b[lenb-i]=y[i]-'0';
	for(int i=1;i<=lenc;i++)
	{
		t=a[i]+b[i]+t;
		c[i]=t%10;
		t/=10;
	}
	if(t>0)c[++lenc]=t;
	for(int i=lenc;i>=1;i--)cout<<c[i];
	return 0;
}
                                        • 0
                                          @ 2023-8-7 14:18:04 
                                          #include<bits/stdc++.h>
using namespace std;
int main()
{
	int a,b;
	cin>>a>>b;
	cout<<a+b;
	return 0;
}

                                          A+B

                                          信息

                                          ID
                                          1
                                          时间
                                          1000ms
                                          内存
                                          256MiB
                                          难度
                                          4
                                          标签
                                          (无)
                                          递交数
                                          426
                                          已通过
                                          208
                                          上传者
                                          1. 关于
                                          2. 联系我们
                                          3. 隐私
                                          4. 服务条款
                                          5. 版权申诉
                                          6. Language
                                          7. 兼容模式
                                          8. 主题
                                          3. Worker 0, 76ms
                                          4. Powered by Hydro v4.11.2 Community