时间复杂度分析

1.根据数据范围判断时间复杂度

  一般C++一秒可以执行10⁷-10⁸次运算，那么就可以根据数据量，判断算法类型。
1.n<30,指数级别，dfs+剪枝,状态压缩dp
2.n<100,O(n³) floyd,dp
3.n<1000,O(lognn²) dp 二分
4.n<100000,O(nlogn) 排序，map/set,
5.n<1000000,O(n) 双指针，KMP，并查集或常数较小的O(n*logn) spfa。
6.n<10000000,O(n) 双指针

2.判断时间复杂度

2.1 递推问题
仓库选址

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 1e6 + 10;
int n,a[maxn];
long long ans;
int main(){
    cin>>n;
    for(int i=0;i<n;i++){
        scanf("%d",&a[i]);
    }
    sort(a,a + n);
    int i = 0,j = n - 1;
    while(i != j && j - i >= 1){
        int t = (a[j] - a[i]);
        ans += t;
        i++,j--;
    }
    cout<<ans;
    return 0;
}

  在一维数轴上，曼哈顿距离最小的点。利用绝对值不等式，可以推出该点是中位数。
时间复杂度分析，观察循环。因为循环从1-n枚举了一遍，因此复杂度O(n).
最长连续不重复序列

#include<iostream>
#include<algorithm>
using namespace std;
const int maxn = 1e5 + 10;
int a[maxn],n,ans,s[maxn];
int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
    }
    for(int i=1,j=1;i<=n;i++){
        s[a[i]] ++;
        while(s[a[i]] > 1){
            s[a[j]] --;
            j++;
        }
        ans = max(ans , i -j + 1);
    }
    cout<<ans;
    return 0;
}

  利用数组S动态维护区间内元素数量。指针i向前，遍历数组a。当出现重复元素时，指针j向前扫去除区间内重复元素。虽然看着双重循环但是i,j都是单调增的，只进行了2*n次操作，时间复杂度O(n)。
2.2 递归问题
  一种方法可以利用主定理
实际分析起来，可以简便很多，以快排为例。

#include<iostream>
using namespace std;
const int maxn = 1e5 + 10;
int n,a[maxn];
void quick_sort(int a[],int l,int r){
    if(l>=r) return;
    int x=a[l + r >> 1],i = l - 1 ,j = r + 1;
    while(i<j){
        do i++; while(a[i] < x);
        do j--;while(a[j] > x);
        if(i<j) swap(a[i],a[j]);
    }
    quick_sort(a,l,j);
    quick_sort(a,j+1,r);
}
int main(){
    cin>>n;
    for(int i=0;i<n;i++) scanf("%d",&a[i]);
    quick_sort(a,0,n-1);
    for(int i=0;i<n;i++) printf("%d ",a[i]);
    return 0;
}

  可以看到，对于快排的平均情况而言，每次将区间缩短一半，那么递归的层数是O(logn)，对于每一层而言，扫描交换每一层是O(n)。那么，总共时间复杂度是O(n*logn).
2.3 DFS
以排列问题为例。

#include<algorithm>
#include<iostream>
using namespace std;
int n,a[10];
bool b[10];
void dfs(int x){
    if(x == n){
        for(int i = 0;i<n; i++){
            cout<<a[i]<<" ";
        }
        cout<<endl;
        return ;
    }
    for(int i = 1;i <= n; i++){
        if(!b[i]){
            a[x] = i;
            b[i] = true;
            dfs(x + 1);
            b[i] = false;
        }
    }
}
int main(){
    cin>>n;
    dfs(0);
    return 0;
}

分析：第一层由一个节点扩展出n个结点，第二层每一个节点扩展出n-1个结点，总共是n*(n-1)个结点。第三层每一个节点扩展出n-2个结点，总共是n*(n-1)*(n-2)个结点。以此类推，总共n!个点，最后一层每个节点计算时，还需要遍历1-n，因此复杂度是n * n!.
以图表的形式分析，更加直观。