c++ Part

12.27阶段测试

最得意之作·【基础】等式（snarf）

代码如下

100 Accepted

#include<bits/stdc++.h>
using namespace std;
#pragma GCC optimize(3,"Ofast","inline")
int main(){
    freopen("snarf.in","r",stdin);
	freopen("snarf.out","w",stdout);
	long long a,k,n,rt_delta,root;
	scanf("%ld",&a);
	for(long long i=a;;i++){
		k=i;
		if(sqrt(1+8*k*k)==floor(sqrt(1+8*k*k))&&-0.5+0.5*sqrt(1+8*k*k)==floor(-0.5+0.5*sqrt(1+8*k*k))){//delta,root
			n=-0.5+0.5*sqrt(1+8*k*k);
			break;
		}
	} 
	cout<<k<<" "<<n;
	return 0;

修改过的ver.

#include<bits/stdc++.h>
using namespace std;
#pragma GCC optimize(3,"Ofast","inline")
int main(){
    freopen("snarf.in","r",stdin);
	freopen("snarf.out","w",stdout);
	long long a,k,n;
	scanf("%lld",&a);
	for(long long i=a;;i++){
		k=i;
		if(sqrt(1+8*k*k)==floor(sqrt(1+8*k*k))&&-0.5+0.5*sqrt(1+8*k*k)==floor(-0.5+0.5*sqrt(1+8*k*k))){
			n=-0.5+0.5*sqrt(1+8*k*k);
			break;
		}
	} 
	cout<<k<<" "<<n;
	return 0;

Energy and Persistence Conquer All Things

👀️本人最爱的英语名言

by King

通用模板

#include<bits/stdc++.h>//主模板
using namespace std;
#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC optimize(3,"Ofast","inline")
int main(){
    ios::sync_with_stdio(false);
    freopen("(filename).in","r",stdin);
	freopen("(filename).out","w",stdout);
	return 0;
}

while(cin >> ws, !cin.eof()){ // 读入直到文件末尾

排序专区

(n为元素数量)

void bubble(int a[],int n)//冒泡排序,O(n²)
{
    int i,j,t;
    for(j=0;j<=n-2;j++)
        for(i=0;i<=n-2;i++)
            if(a[i]>a[i+1])
              t=a[i],a[i]=a[i+1],a[i+1]=t;
}

void selection(int a[],int n)//选择排序,O(n²)
{
    int i,j,k,t;
    for(j=0;j<=n-1;j++){
        k=j;
        for(i=j+1;i<n;i++)
            if(a[i]>a[k]) k=i;
        if(j!=k) t=a[j],a[j]=a[k],a[k]=t;
    }  
}

void insertion(int a[],int n)//插入排序,O(n²)
{
    int j,k,t;
    for(j=0;j<n;j++){
        t=a[j],k=j-1;
        while(t<a[k]){
            a[k+1]=a[k],k--;
            if(k==-1) break;
        }
        a[k+1]=t;
    }
}

void quick(int a[],int n,int l,int r)//快速排序,O(nlog₁₀n)
{
    int i,j,t;  
    if(l<r){  //一般来说,l=0,r=n-1
        i=l;j=r+1;
        while(1){
            while(i+1<n&&a[++i]<a[l]);//升序
            while(j-1>-1&&a[--j]>a[l]);//升序
            if(i>=j) break;
            t=a[i],a[i]=a[j],a[j]=t;
        }
        t=a[l],a[l]=a[j],a[j]=t;
        quick(a,n,l,j-1);
        quick(a,n,j+1,r);
    }
}

void msort(int s,int t)//归并排序
{
    if(s==t) return;        //如果只有一个数字则返回，无须排序
    int mid=(s+t)/2;
    msort(s,mid);           //分解左序列
    msort(mid+1,t);         //分解右序列
    int i=s, j=mid+1, k=s;  //接下来合并
    while(i<=mid && j<=t)
    {
          if(a[i]<=a[j])  
          {
                r[k]=a[i]; k++; i++;
           }else{
                    r[k]=a[j]; k++; j++;
                }
      }  
      while(i<=mid)               //复制左边子序列剩余
      {
           r[k]=a[i]; k++; i++;
       }
       while(j<=t)                   //复制右边子序列剩余  
       {
           r[k]=a[j]; k++; j++;
       }
        for(int i=s; i<=t; i++) a[i]=r[i];  
}

查找专区

int ordered(int a[],int n,int find)//顺序查找
{
    int i;
    for(i=0;i<n;i++) if(a[i]==find) return i;//找到返回index
    return -1;//未找到返回-1  
}

int binary(int a[],int n,int find)//二分查找
{
    int l=0,u=n-1,m;
    while(l<=u){
        m=l+(u-l)/2;
        if(a[m]<find) l=m+1; 
        else if(a[m]>find) u=m-1;
        else return m;//找到返回index
    } 
    return -1;//未找到返回-1
}

#define SORT(k) sort((k)+1,(k)+n+1)

要优化C++代码，需要考虑的方面很广泛，包括但不限于减少时间和空间消耗、提高可读性、减少错误等。以下是一些常见的优化技巧：

• 避免不必要的复制和分配，使用引用和指针。

• 使用const来指示不修改的变量或者函数参数。

• 使用inline函数来减少函数调用开销。

• 使用编译器的优化选项，比如-O2来启用优化。

• 使用std::move来转移资源所有权而非复制。

• 使用std::thread进行并发编程时，避免不必要的锁。

• 使用std::accumulate等算法替代手写循环。

• 使用std::function和std::bind代替函数指针。

• 使用std::array或std::tuple代替结构体传递小型数据。

• 使用更高效的数据结构，例如std::vector代替原生数组，std::unordered_map代替std::map。

未完待续......

sort(first,last,less);

sort(first,last,greater);

sort(first,last,less_equal);

sort(first,last,greater_equal);

stable_sort(first,last,less);

nth_element(first,nth,last,less);

partial_sort(first,middle,last,less);