memset

传送门： https://nanti.jisuanke.com/t/41400 给你三个数组a，b，c，要你求有多少个三元组（i，j，k），使得 \[ \begin{array}{l}{\left|A_{i}-B_{j}\right| \leq C_{k}, \text { and }} \\ {\left|B_{j}-C_{k}\right| \leq A_{i}, \text { and }} \\ {\left|A_{i}-C_{k}\right| \leq B_{j}}\end{array} \] 上面的不等式经过化简，我们可以得到 我们需要求有多少个三元组，使得 \(A_i,B_j,C_k\) 可以组成一个三角形 这样组成三角形的题目类似于HDU4609 ( https://www.cnblogs.com/buerdepepeqi/p/11236100.html ) 但是不同的是 我们需要从三个数组中选择 所以这里就涉及到了选择重复的问题，我们考虑去重 假设拿a+b做一遍卷积，得到长度为a+b的木棍的数量， 我们假设 c是三角形的最长边，那么a，b，c三根木棍不能组成三角形的情况就是c的长度大于a+b的数量 我们枚举（a+b）这个长度，那么不能组成三角形的数量就是 可以组成当前长度的（a，b）的方案数*大于这个长度的c的数量 所以按照这样来说 我们就可以得到 做三遍卷积

memset()是一个来自于string库的函数，正规用法是初始化char类型的数组。因为char类型只占1个字节，memset按字节赋值后，会将char类型数组的所有元素变为你指定的值。但是 来源：博客园 作者： MiserWeyte 链接：https://www.cnblogs.com/miserweyte/p/11461574.html

memset(isprime,1,sizeof(isprime)); isprime[1]=false; for(int i=2;i<=N;i++){ if(isprime[i]){ prime[++primesize]=i; } for(int j=1;j<=primesize&&i*prime[j]<=N;j++){ isprime[i*prime[j]]=false; if(i%prime[j]==0){ break; } } }

最常规的大数加法 (两个数都是非负的整数) 思路： 用字符串的方式去存储我们需要计算的数 ，但是 要注意的一点就是我们是倒过来存储这个大数的 最常规的大数加法 (两个数都是非负的整数) 1 #include<iostream> 2 #include<cstring> 3 #include<algorithm> 4 using namespace std; 5 const int L=110; 6 string add(string a,string b)//只限两个非负整数相加 7 { 8 string ans; 9 int na[L]={0},nb[L]={0}; 10 int la=a.size(); 11 int lb=b.size(); 12 // 倒叙存储 13 for(int i=0;i<la;i++) 14 na[la-1-i]=a[i]-'0'; 15 // 倒叙存储 16 for(int i=0;i<lb;i++) 17 nb[lb-1-i]=b[i]-'0'; 18 int lmax=la>lb?la:lb; 19 // 从个位开始计算 20 for(int i=0;i<lmax;i++) 21 { 22 na[i]+=nb[i]; 23 na[i+1]+=na[i]/10; 24 na[i]%=10; 25 } 26 // 去除前置0 27 if(!na

D. 1-2-K Game time limit per test2 seconds memory limit per test256 megabytes inputstandard input outputstandard output Who wins if both participants play optimally? Alice and Bob would like to play several games, so you should determine the winner in each game. Input Output For each game, print Alice if Alice wins this game and Bob otherwise. Example inputCopy 4 0 3 3 3 3 4 4 4 outputCopy Bob Alice Bob Alice 题意： 当前在n位置，每一次可以向左走1,2，或者k步，最左的位置是0，不能走到0之后， 二人博弈问题，谁没发走谁输，问先手必赢还是后手必赢。 思路： 首先确定的是 0位置是必数位置，因为 1 2 和k这三个位置可以一步就走到0位置，所以这3个位置是必赢位置，以此规律，我们可以递推出sg函数。 #include <iostream> #include <cstdio>

　　　　 稍他妈心疼迪神 　　　　以后干脆不要在准备提交的代码里放调试信息。 　　　　再也不忘删printf可是memset还是看不见... 　　　　T1 玄学错误，不想研究。 　　　　T2 傻逼做法。 　　　　　　发现一个点的修改可以被k的整数倍距离外的相反修改完全抵消，所以干脆在%k意义下解决问题。 　　　　　　所有位置数值相同时，puts(“Yes”); 　　　　　　需要hash表，比较慢。 　　　　T3 　　　　　　没删调试，是个memset。 　　　　　　打这个memset的时候提醒自己千万不要忘了删，然后太紧张了就忘了 　　　　　　nlogn，1e5的数据跑了1s。 　　　　　　泪奔，dsu on tree常数有这么大吗 　　　　　　考后还大声地喊我被卡常了　　 　　　　　　我真是傻逼。 　　　　　　今天必须打出虚树做法。 来源： https://www.cnblogs.com/yxsplayxs/p/11767195.html

is memset more efficient than for loop. so if i have char x[500]; memset(x,0,sizeof(x)); or char x[500]; for(int i = 0 ; i < 500 ; i ++) x[i] = 0; which one is more efficient and why? is there any special instruction in hardware to do block level initialization. Most certainly, memset will be much faster than that loop. Note how you treat one character at a time, but those functions are so optimized that set several bytes at a time, even using, when available, MMX and SSE instructions. I think the paradigmatic example of these optimizations, that go unnoticed usually, is the GNU C library

最短路分为单源最短路和多源汇最短路； 1单源最短路根据边长的正负分为两类（n表示点，m表示边） （1）边长为正 dijkstra算法 朴素版（o(n^2)） 堆优化版（0（mlogn)) 当稠密图（m>=n^2)时朴素版的时间更优，稀疏图则用堆优化版更优； （2）边权有负 bellman_ford算法 0（nm） 由于SPFA算法是bellman_ford的优化，bellman_ford常用于求有边数限制的最短路，如在不经过超过k条边时的最短路，注意这时的不存在最短路的临界条件是dist[n]>0x3f3f3f3f,因为可能存在，dist[t]=0x3f3f3f3f,但存在t到n的边可能松弛dist[n]； SPFA O(m),最坏O(nm) 还可用来求负环，也可以用来求正权最短路 2.多源汇最短路 folyd算法 0（n^3) 适合稠密图 dijkstra算法朴素版 #include<iostream> #include<cstring> using namespace std; int g[510][510]; int n,m; int vis[510],dist[510]; int dijkstra() { memset(dist,0x3f,sizeof dist); dist[1]=0; for(int i=0;i<n;i++) { int t=-1; for(int j

CSP-S 2019图论总结 一、最短路问题 模板 Floyd算法 void floyd() { memset(map,0x3f,sizeof(map)); for(int i=1;i<=n;i++) map[i][i]=0; for(int k=1;k<=n;k++) for(int i=1;i<=n;i++) for(int j=1;j<=n;j++) map[i][j]=min(map[i][j],map[i][k]+map[k][j]); } Dijkstra算法 const int INF=1e9; void dijkstra(int s) { int temp,k,y; memset(dist,0x3f,sizeof(dist)); memset(v,0,sizeof(v)); dist[s]=0; for(int i=1;i<=n;i++) { temp=INF; for(int j=1;j<=n;j++) if(dist[j]<temp && !v[j]) k=j,temp=dist[j]; v[k]=1; for(int j=head[i];j;j=nxt[j]) { y=to[i]; if(dist[y]>dist[k]+val[j]) dist[y]=dist[k]+val[j]; } } } SPFA算法 void spfa(int s) { memset

1.求<=k点对数，容斥法 /* 求树中距离不超过k的点对数 暴力枚举两点，lca求的复杂度是O(n^2logn)，这样很多次询问都是冗余的 那么选择重心作为根，问题分成两部分，求经过重心的距离<=k的点对+不经过重心的距离<=k的点对 先来求第一部分，计算所有点的深度，排序，O(nlogn)可以计算出距离<=k的过重心点对 但是这样还不是正确答案，因为还要容斥掉来自同一棵子树的非法点对，那么对这部分再算一次即可 再求第二部分，这部分其实等价于原问题的子问题，所以我们再去重心的每个子树里找重心，和上面一样求 如果一个点已经被当过重心了，那么给它打个vis标记，之后不再访问 这样最多递归O(logn) 次，所以总复杂度是O(n*logn*logn) */ #include<iostream> #include<cstdio> #include<cstring> #include<algorithm> #define N 10005 using namespace std; struct Edge{int to,nxt,w;}e[N<<1]; int head[N],tot,n,k,ans; void add(int u,int v,int w){ e[tot].to=v;e[tot].w=w;e[tot].nxt=head[u];head[u]=tot++; } int vis[N]