給ACM newer的編程技巧

時間 2020-07-07

原文原文鏈接

1、複雜度

1.1什麼是複雜度？

在設計知足問題要求的算法時，複雜度的估算是很是重要的。咱們不可能把每一個想到的算法實現一遍看看是否足夠快。應當經過估計算法的複雜度來判斷所想的算法是否足夠高效。c++

1.2 時間複雜度

1、概念
時間複雜度是總運算次數表達式中受n的變化影響最大的那一項(不含係數)
好比：通常總運算次數表達式相似於這樣：
a*2n+b*n3+c*n2+d*n*lg(n)+e*n+f
a ！ =0時，時間複雜度就是O(2n);
a=0,b<>0 =>O(n3);
a,b=0,c<>0 =>O(n2)依此類推
例子:
(1)   for(i=1;i<=n;i++)   //循環了n*n次，固然是O(n2)
            for(j=1;j<=n;j++)
                 s++;
(2)   for(i=1;i<=n;i++)//循環了(n+n-1+n-2+...+1)≈(n2)/2，由於時間複雜度是不考慮係數的，因此也是O(n2)
            for(j=i;j<=n;j++)
                 s++;
(3)   for(i=1;i<=n;i++)//循環了(1+2+3+...+n)≈(n^2)/2,固然也是O(n2)
            for(j=1;j<=i;j++)
                 s++;
(4)   i=1;k=0;//循環了n-1≈n次，因此是O(n)
      while(i<=n-1){
           k+=10*i;
i++; }
(5) for(i=1;i<=n;i++)
             for(j=1;j<=i;j++)
                 for(k=1;k<=j;k++)
                       x=x+1;
//
循環了(12+22+32+...+n2)=n(n+1)(2n+1)/6(這個公式要記住哦)≈(n3)/3，不考慮係數，天然是O(n3)
另外，在時間複雜度中，log2n與lg(n)(同lg10(n))是等價的，由於對數換底公式：
logab=logcb/logca
因此，log2n=log210 * lg(n),忽略掉係數，兩者固然是等價的
2、計算方法
1.一個算法執行所耗費的時間，從理論上是不能算出來的，必須上機運行測試才能知道。
但咱們不可能也沒有必要對每一個算法都上機測試，只需知道哪一個算法花費的時間多，哪一個算法花費的時間少就能夠了。
而且一個算法花費的時間與算法中語句的執行次數成正比例，哪一個算法中語句執行次數多，它花費時間就多。
一個算法中的語句執行次數稱爲語句頻度或時間頻度。記爲T(n)。
2.通常狀況下，算法的基本操做重複執行的次數是模塊n的某一個函數f（n），
所以，算法的時間複雜度記作：T（n）=O（f（n））。隨着模塊n的增大，算法執行的時間的增加率和f（n）的增加率成正比，
因此f（n）越小，算法的時間複雜度越低，算法的效率越高。
在計算時間複雜度的時候，先找出算法的基本操做，而後根據相應的各語句肯定它的執行次數，
再找出T（n）的同數量級（它的同數量級有如下：1，Log2n ，n ，nLog2n ，n的平方，n的三次方，2的n次方，n！），
找出後，f（n）=該數量級，若T(n)/f(n)求極限可獲得一常數c，則時間複雜度T（n）=O（f（n））。
3.常見的時間複雜度
按數量級遞增排列，常見的時間複雜度有：
常數階O(1),  對數階O(log2n),  線性階O(n),  線性對數階O(nlog2n),  平方階O(n2)，
 立方階O(n3),...， k次方階O(nk), 指數階O(2n) 。
其中，
1.O(n)，O(n2)， 立方階O(n3),...， k次方階O(nk) 爲多項式階時間複雜度，分別稱爲一階時間複雜度，二階時間複雜度。。。。
2.O(2n)，指數階時間複雜度，該種不實用
3.對數階O(log2n),   線性對數階O(nlog2n)，除了常數階之外，該種效率最高
例：算法：
  for（i=1;i<=n;++i）
  {
     for(j=1;j<=n;++j)
     {
         c[ i ][ j ]=0; //該步驟屬於基本操做 執行次數：n2
          for(k=1;k<=n;++k)
               c[ i ][ j ]+=a[ i ][ k ]*b[ k ][ j ]; //該步驟屬於基本操做 執行次數：n3
     }
  }
  則有 T（n）= n2+n3，根據上面括號裏的同數量級，咱們能夠肯定 n3爲T（n）的同數量級
  則有f（n）= n3，而後根據T（n）/f（n）求極限可獲得常數c
  則該算法的 時間複雜度：T（n）=O（n3)
4、定義：
若是一個問題的規模是n，解這一問題的某一算法所須要的時間爲T(n)，它是n的某一函數 T(n)稱爲這一算法的「時間複雜性」。
當輸入量n逐漸加大時，時間複雜性的極限情形稱爲算法的「漸近時間複雜性」。
咱們經常使用大O表示法表示時間複雜性，注意它是某一個算法的時間複雜性。大O表示只是說有上界，由定義若是f(n)=O(n)，那顯然成立f(n)=O(n^2)，它給你一個上界，但並非上確界，但人們在表示的時候通常都習慣表示前者。
此外，一個問題自己也有它的複雜性，若是某個算法的複雜性到達了這個問題複雜性的下界，那就稱這樣的算法是最佳算法。
「大O記法」：在這種描述中使用的基本參數是 n，即問題實例的規模，把複雜性或運行時間表達爲n的函數。這裏的「O」表示量級 (order)，好比說「二分檢索是 O(logn)的」,也就是說它須要「經過logn量級的步驟去檢索一個規模爲n的數組」記法 O ( f(n) )表示當 n增大時，運行時間至多將以正比於 f(n)的速度增加。
這種漸進估計對算法的理論分析和大體比較是很是有價值的，但在實踐中細節也可能形成差別。
例如，一個低附加代價的O(n2)算法在n較小的狀況下可能比一個高附加代價的 O(nlogn)算法運行得更快。
固然，隨着n足夠大之後，具備較慢上升函數的算法必然工做得更快。
O(1)
Temp=i;i=j;j=temp;                    
以上三條單個語句的頻度均爲1，該程序段的執行時間是一個與問題規模n無關的常數。
算法的時間複雜度爲常數階，記做T(n)=O(1)。若是算法的執行時間不隨着問題規模n的增長而增加，
即便算法中有上千條語句，其執行時間也不過是一個較大的常數。此類算法的時間複雜度是O(1)。
O(n2) 
1) 交換i和j的內容      
sum=0；                 （一次）
      for(i=1;i<=n;i++)       （n次 ）   
      for(j=1;j<=n;j++) （n2次 ）    
      sum++；       （n^2次 ） 
解：T(n)=2n^2+n+1 =O(n^2)
2)        
for (i=1;i<n;i++)     {
         y=y+1;         //頻度是n-1   
     for (j=0;j<=(2*n);j++) 
               x++;       //頻度是(n-1)*(2n+1)=2n2-n-1 
         }         
　　　　f(n)=2n2-n-1+(n-1)=2n2-2           該程序的時間複雜度T(n)=O(n2).         
O(n)                                                              
3)
    a=0;     b=1;                     //頻度：2
    for (i=1;i<=n;i++) //頻度： n
    {
         s=a+b;　　　　//頻度： n-1
       　b=a;　　　　　//頻度：n-1
         a=s;　　　　　//頻度：n-1
     }                 
 T(n)=2+n+3(n-1)=4n-1=O(n). 

O(log2n )
4)
      i=1;       //頻度是1 
　　  while (i<=n)
        i=i*2; //頻度是f(n),   
則：2f(n)<=n;f(n)<=log2n               取最大值f(n)= log2n,           T(n)=O(log2n )
O(n3)
5)
  for(i=0;i<n;i++)     {
      for(j=0;j<i;j++)          { 
          for(k=0;k<j;k++)
              x=x+2; 
         }
     } 
解：當i=m, j=k的時候,內層循環的次數爲k當i=m時, j 能夠取 0,1,...,m-1 , 因此這裏最內循環共
進行了0+1+...+m-1=(m-1)m/2次因此,i從0取到n, 則循環共進行了: 0+(1-1)*1/2+...+(n-1)n/2=n(n+1)(n-1)/6
因此時間複雜度爲O(n3).                                   
咱們還應該區分算法的最壞狀況的行爲和指望行爲。如快速排序的最壞狀況運行時間是 O(n2)，
但指望時間是 O(nlogn)。經過每次都仔細 地選擇基準值，咱們有可能把平方狀況 (即O(n2)狀況)
的機率減少到幾乎等於 0。在實際中，精心實現的快速排序通常都能以 (O(nlogn)時間運行。
 下面是一些經常使用的記法：
 訪問數組中的元素是常數時間操做，或說O(1)操做。一個算法如 果能在每一個步驟去掉一半數據元素，
如二分檢索，一般它就取 O(logn)時間。用strcmp比較兩個具備n個字符的串須要O(n)時間。
常規的矩陣乘算法是O(n3)，由於算出每一個元素都須要將n對 元素相乘並加到一塊兒，全部元素的個數是n2。
 指數時間算法一般來源於須要求出全部可能結果。例如，n個元 素的集合共有2n個子集,因此要求出
全部子集的算法將是O(2n)的。指數算法通常說來是太複雜了，除非n的值很是小，由於，在 這個問題
中增長一個元素就致使運行時間加倍。不幸的是，確實有許多問題 (如著名的「巡迴售貨員問題」 )，
到目前爲止找到的算法都是指數的。若是咱們真的遇到這種狀況，一般應該用尋找近似最佳結果的算法替代之。

1.3 空間複雜度

空間複雜度(Space Complexity)是對一個算法在運行過程當中臨時佔用存儲空間大小的量度。 一個算法在計算機存儲器上所佔用的存儲空間， 包括程序代碼所佔用的空間，輸入數據所佔用的空間和輔助變量所佔用的空間這三個方面。 算法的輸入輸出數據所佔用的存儲空間是由要解決的問題決定的，是經過參數表由調用函數傳遞而來的， 它不隨本算法的不一樣而改變。存儲算法自己所佔用的存儲空間與算法書寫的長短成正比，要壓縮這方面的存儲空間， 就必須編寫出較短的算法。算法在運行過程當中臨時佔用的存儲空間隨算法的不一樣而異，有的算法只須要佔用少許的臨時工做單元， 並且不隨問題規模的大小而改變，咱們稱這種算法是「就地"進行的，是節省存儲的算法，如這些介紹過的幾個算法都是如此； 有的算法須要佔用的臨時工做單元數與解決問題的規模n有關，它隨着n的增大而增大，當n較大時，將佔用較多的存儲單元， 例如將在第九章介紹的快速排序和歸併排序算法就屬於這種狀況。 分析一個算法所佔用的存儲空間要從各方面綜合考慮。如對於遞歸算法來講，通常都比較簡短，算法自己所佔用的存儲空間較少，但運行時須要一個附加堆棧，從而佔用較多的臨時工做單元；若寫成非遞歸算法，通常可能比較長，算法自己佔用的存儲空間較多，但運行時將可能須要較少的存儲單元。 一個算法的空間複雜度只考慮在運行過程當中爲局部變量分配的存儲空間的大小，它包括爲參數表中形參變量分配的存儲空間和爲在函數體中定義的局部變量分配的存儲空間兩個部分。若一個算法爲遞歸算法，其空間複雜度爲遞歸所使用的堆棧空間的大小，它等於一次調用所分配的臨時存儲空間的大小乘以被調用的次數(即爲遞歸調用的次數加1，這個1表不開始進行的一次非遞歸調用)。算法的空間複雜度通常也以數量級的形式給出。如當一個算法的空間複雜度爲一個常量，即不隨被處理數據量n的大小而改變時，可表示爲O(1)；當一個算法的空間複雜度與以2爲底的n的對數成正比時，可表示爲0(log2n)；當一個算法的空I司複雜度與n成線性比例關係時，可表示爲0(n).若形參爲數組，則只須要爲它分配一個存儲由實參傳送來的一個地址指針的空間，即一個機器字長空間；若形參爲引用方式，則也只須要爲其分配存儲一個地址的空間，用它來存儲對應實參變量的地址，以便由系統自動引用實參變量。 對於一個算法，其時間複雜度和空間複雜度每每是相互影響的。當追求一個較好的時間複雜度時，可能會使空間複雜度的性能變差，便可能致使佔用較多的存儲空間；反之，當=i自求一個較好的空間複雜度時，可能會使時間複雜度的性能變差，便可能致使佔用較長的運行時間。另外，算法的全部性能之間都存在着或多或少的相互影響。所以，當設計一個算法(特別是大型算法)時，要綜合考慮算法的各項性能，算法的使用頻率，算法處理的數據量的大小，算法描述語言的特性，算法運行的機器系統環境等各方面因素，纔可以設計出比較好的算法。 空間複雜度是程序運行因此須要的額外消耗存儲空間,也用o()來表示 　　好比插入排序的時間複雜度是o(n2),空間複雜度是o(1) 　　而通常的遞歸算法就要有o(n)的空間複雜度了,由於每次遞歸都要存儲返回信息 　　一個算法的優劣主要從算法的執行時間和所須要佔用的存儲空間兩個方面衡量，算法執行時間的度量不是採用算法執行的絕對時間來計算的，由於一個算法在不一樣的機器上執行所花的時間不同，在不一樣時刻也會因爲計算機資源佔用狀況的不一樣，使得算法在同一臺計算機上執行的時間也不同，因此對於算法的時間複雜性，採用算法執行過程當中其基本操做的執行次數，稱爲計算量來度量。 　　算法中基本操做的執行次數通常是與問題規模有關的，對於結點個數爲n的數據處理問題，用T(n)表示算法基本操做的執行次數.在評價算法的時間複雜性時，不考慮兩算法執行次數之間的細小區別，而只關心算法的本質差異: 　　爲此，引入一個所謂的O() 記號，則T1(n)=2n=O(n),T2(n)=n+1=O(n)。一個函數f(n)是O(g(n))的，則必定存在正常數c和m，使對全部的n>m，都知足f(n)<c*g(n)。

經常使用的算法的時間複雜度和空間複雜度算法

排序法	最差時間分析	平均時間複雜度	穩定度	空間複雜度
冒泡排序	O(n2)	O(n2)	穩定	O(1)
快速排序	O(n2)	O(n*log2n)	不穩定	O(log2n)~O(n)
選擇排序	O(n2)	O(n2)	穩定	O(1)
二叉樹排序	O(n2)	O(n*log2n)	不一頂	O(n)
插入排序	O(n2)	O(n2)	穩定	O(1)
堆排序	O(n*log2n)	O(n*log2n)	不穩定	O(1)
希爾排序	O	O	不穩定	O(1)

1.4 關於運行時間

假設時間限制爲1秒數組

複雜度	程度
1e6	遊刃有餘
1e7	勉勉強強
1e8	很懸，僅限循環體很是簡單的狀況

2、debug姿式

通常要作到50行之內的程序不用調試、100行之內的二分鐘內調試成功.acm主要是考算法的
，主要時間是花在思考算法上，不是花在寫程序與debug上。函數

2.1 幾大錯誤

Compile Error ;
Run Time Error;
Time Limit Exceeded;
Wrong Answer ;
Presentation Error
Accepted性能

2.2 debug技巧

調試使用代碼測試

/*hdu 1007 首先咱們在創建線段樹以前應該思考的是線段樹的節點維護一個什麼值， 在比勝過程中，我想到了維護a[i]的值可是時間複雜度過高，又想到維護a[i]/b[i]可是取下整， 這樣的話沒法更新∑的值。 在題解中，維護了b[i]的值，由於a[i]最初是0，因此在update過程當中當a[i]>=b[i]時,a[i]/b[i]才>=1； 纔會對sum有貢獻，因此不妨維護b[i]的值，對每次區間更新，將區間中的b[i]減1，當b[i]減到0時，更新sum的值+1,而後b[i]更新回初始的b[i]的值 整個更新過程當中須要維護lazy標誌、numzero當前子樹中0的個數（即sum+1的次數）、minx當前子樹中最小的b[i]值、valb當前節點初始的b[i]值 */



#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1

const int MAXN=10010;
struct
{
    int minx,valb,numzero;
    int lazy;
}sum[MAXN<<2];
int b[MAXN];
void push_up(int rt)
{
    sum[rt].numzero=sum[rt<<1].numzero+sum[rt<<1|1].numzero;
    sum[rt].minx=min(sum[rt<<1].minx,sum[rt<<1|1].minx);

}
void push_down(int rt,int l,int r)
{
    sum[rt<<1].lazy+=sum[rt].lazy;
    sum[rt<<1|1].lazy+=sum[rt].lazy;
    sum[rt<<1].minx-=sum[rt<<1].lazy;
    sum[rt<<1|1].minx-=sum[rt<<1|1].lazy;
    sum[rt].lazy=0;
}



void build(int l,int r,int rt=1)
{
    sum[rt].lazy=0;
    sum[rt].numzero=0;
    if(l==r)
    {
        sum[rt].lazy=0;
        sum[rt].minx=b[l];
        sum[rt].numzero=0;
        sum[rt].valb=b[l];
    }
    int m=(l+r)>>1;
    build(lson);
    build(rson);
    push_up(rt);
}
/*update操做 */
void update(int L,int R,int l,int r,int rt)
{
    if(L<=l&&r<=r&&sum[rt].minx>1)
    {
        sum[rt].lazy++;
        sum[rt].minx--;
        return;
    }
    if(l==r&&sum[rt].minx==1)
    {
        sum[rt].numzero++;
        sum[rt].lazy++;
        sum[rt].minx=sum[rt].valb;
        return;
    }
    if(sum[rt].lazy>0)
        push_down(rt,l,r);
    int m=(l+r)>>1;
    if(L<=m)update(L,R,lson);
    if(m<R)update(L,R,rson);
    push_up(rt);
}
/*query操做 求和操做，就是求子樹中numzero和 */


int query(int L,int R,int l,int r,int rt)
{
    if(L<=l&&r<=R)
    {
        return sum[rt].numzero;
    }
    if(sum[rt].lazy>0)push_down(rt,l,r);
    int m=(l+r)>>1;
    int ret=0;
    if(L<=m)ret+=query(L,R,lson);
    if(R>m)ret+=query(L,R,rson);
    return ret;



}




int main()
{
    int n,m;

    while(cin>>n>>m)
    {
        char ch[10],L,R;
        for(int i=1;i<=n;i++)
            scanf("%d",b+i);
        while(m--)
        {
            scanf("%s%d%d",ch,L,R);
            if(strcmp(ch,"add")==0)
            {
                update(L,R,1,n,1);
            }
            else if(strcmp(ch,"query")==0)
            {
                printf("%d\n",query(L,R,1,n,1));
            }
        }
    }
    return 0;

}

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。