时空复杂度

时空复杂度

时间复杂度

评测机大概 1 s 1s 1s 最多运行 1 1 1 亿次,即 1 e 8 1e8 1e8

时间复杂度一般小于 1 e 7 ∼ 1 e 8 1e7 \sim 1e8 1e71e8 就可以

2 20 ≈ 1 0 6 2^{20} ≈ 10^6 220106

2 16 = 65536 2^{16} = 65536 216=65536

2 15 = 32768 2^{15} = 32768 215=32768

2 63 = 1 0 18 2^{63} = 10^{18} 263=1018

根据数据范围反推算法复杂度及算法

源自 y y y 总,指路:原文链接

  1. n ≤ 30 n \le 30 n30, 指数级别, d f s dfs dfs+剪枝,状态压缩 d p dp dp
  2. n ≤ 100 n \le 100 n100 => O ( n 3 ) O(n^3) O(n3) f l o y d , d p , floyd,dp, floyddp高斯消元
  3. n ≤ 1000 n \le 1000 n1000 => O ( n 2 ) O(n^2) O(n2) O ( n 2 l o g n ) O(n^2logn) O(n2logn) d p dp dp,二分,朴素版 D i j k s t r a Dijkstra Dijkstra、朴素版 P r i m Prim Prim B e l l m a n − F o r d Bellman-Ford BellmanFord
  4. n ≤ 10000 n \le 10000 n10000 => O ( n ∗ n ) O(n * \sqrt n) O(nn ),块状链表、分块、莫队
  5. n ≤ 100000 n \le 100000 n100000 => O ( n l o g n ) O(nlogn) O(nlogn) => 各种 s o r t sort sort,线段树、树状数组、 s e t / m a p set/map set/map h e a p heap heap、拓扑排序、 d i j k s t r a + h e a p dijkstra+heap dijkstra+heap p r i m + h e a p prim+heap prim+heap K r u s k a l Kruskal Kruskal s p f a spfa spfa、求凸包、求半平面交、二分、 C D Q CDQ CDQ分治、整体二分、后缀数组、树链剖分、动态树
  6. n ≤ 1000000 n \le 1000000 n1000000 => O ( n ) O(n) O(n), 以及常数较小的 O ( n l o g n ) O(nlogn) O(nlogn) 算法 => 单调队列、 h a s h hash hash、双指针扫描、 B F S BFS BFS、并查集, k m p kmp kmp A C AC AC自动机,常数比较大的 O ( n l o g n ) O(nlogn) O(nlogn) 的做法: s o r t sort sort、树状数组、 h e a p heap heap d i j k s t r a dijkstra dijkstra s p f a spfa spfa
  7. n ≤ 10000000 n \le 10000000 n10000000 => O ( n ) O(n) O(n),双指针扫描、 k m p kmp kmp A C AC AC自动机、线性筛素数
  8. n ≤ 1 0 9 n \le 10^9 n109 => O ( n ) O(\sqrt n) O(n ),判断质数
  9. n ≤ 1 0 18 n \le 10^{18} n1018 => O ( l o g n ) O(logn) O(logn),最大公约数,快速幂,数位 D P DP DP
  10. n ≤ 1 0 1000 n \le 10^{1000} n101000 => O ( ( l o g n ) 2 ) O((logn)^2) O((logn)2),高精度加减乘除
  11. n ≤ 1 0 100000 n \le 10^{100000} n10100000 => O ( l o g k × l o g l o g k ) , k O(logk \times loglogk),k O(logk×loglogk)k表示位数,高精度加减、 F F T / N T T FFT/NTT FFT/NTT

空间复杂度

对于空间复杂度

i n t   =   4   B y t e int ~ =~4 ~ Byte int = 4 Byte

c h a r   =   1   B y t e char ~ =~1 ~ Byte char = 1 Byte

l o n g   l o n g   =   8   B y t e long~ long ~ =~8 ~ Byte long long = 8 Byte

f l o a t   =   4   B y t e float ~ =~4 ~ Byte float = 4 Byte

d o u b l e   =   8   B y t e double ~ =~8 ~ Byte double = 8 Byte

64 M B = 6 × 2 20 B y t e = 6.4 × 1 0 7 B y t e 64MB = 6\times 2^{20}Byte = 6.4 \times 10^{7} Byte 64MB=6×220Byte=6.4×107Byte

可以开 1.6 × 1 0 7 1.6 \times 10^{7} 1.6×107 i n t int int

数据量对于输入输出的影响

n < 1 0 5 n < 10^5 n<105 时,用 s c a n f , p r i n t f , c i n , c o u t scanf,printf,cin,cout scanf,printf,cin,cout 差不多

n ≥ 1 0 5 n \ge 10^5 n105 时,用 s c a n f , p r i n t f scanf,printf scanf,printf

如果想用 c i n , c o u t cin, cout cin,cout,需要关闭同步

#include 

using namespace std;

int main()
{
	ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
}

你可能感兴趣的:(算法,蓝桥杯,c++,算法)