2. 程式人生 > >2048遊戲回想二：算法總結（移動、合並、動畫等）

2048遊戲回想二：算法總結（移動、合並、動畫等）

阿新 • • 發佈：2018-02-20
switch com asm isp error 結束 復雜 因此 playsound

假設僅僅是單純的寫一個2048遊戲。讓這個遊戲能夠玩的話，工作量還是蠻小的。只是，在這寫工作中，你可能花時間最多的就是數字的移動與合並的算法了，假設沒有做過，可能確實要花點時間來構思，所以。寫完2048遊戲以後，我希望能把它做個記錄。

移動與合並的算法

比方說我們有例如以下一個界面：
技術分享圖片
如今。玩家向左劃。這個導致全部的數字向左移動，而且移動的過程中假設發生碰撞。會檢查數字是不是能夠合並。
我們的算法應該是通用的。不僅對於4*4模式，即便是針對3*3模式。n*n模式，它都應該是一樣的。
那麽怎麽做呢？事實上就兩步：
第一步：把第一個空格和空格後面的第一個數字（假設有）交換。
第二步：交換後檢查需不須要合並。
以此類推。
為了便於陳述。我們給圖片做一個坐標：
技術分享圖片


在這張圖片中，依照我們說的，第一個空白和第一個數字交換，也就是把（2，C）和（3，C）交換。交換後檢查能不能合並，假設能則合並，只是不能則不合並。這裏顯然能夠合並。所以我們把他們合並為4.然後空白後面就沒有數字了。算法結束。
因此。我們的算法必須記錄第一個空白的位置和第一個數字的位置，那麽我們用k記錄空白。用j記錄第一個數字。然後對於每一行，從左向右做這種事情。


直接上代碼吧，結合代碼一說就會明確：
首先，我們的一個數字使用一個Number類來表述：

public class Number {
    public int mScores;
    public int mCurPosition;
    public
 
 int mBeforePosition;
    public boolean isNeedMove;
    public boolean isNeedCombine;
    public Number(int position,int scores){
        mScores = scores;
        mCurPosition = mBeforePosition = position;
        isNeedMove = false;
        isNeedCombine = false;
    }
    public void reset(){
        mScores = 0
 
;
        isNeedMove = false;
        isNeedCombine = false;
    }
}

可見一個Number中有scores。也就是分數，當前的位置和之前的位置是用來計算動畫的，我們須要把一個Number從之前的位置移動到當前的位置。
然後整個遊戲使用一個Numbers類來表述：

public class Numbers {
    Number [][] mNumbers = new Number[Game2048StaticControl.gamePlayMode][Game2048StaticControl.gamePlayMode];
    public Numbers(){
        for(int i=0;i<Game2048StaticControl.gamePlayMode;i++){
            for(int j=0;j<Game2048StaticControl.gamePlayMode;j++){
                mNumbers[i][j] = new Number(0,0);
            }
        }
    }
    public Number getNumber(int x,int y){
        return mNumbers[x][y];
    }
    public Number [][] getNumbers (){
        return mNumbers;
    }
    public int getBlankCount(){
        int count = 0;
        for(int i=0;i<Game2048StaticControl.gamePlayMode;i++){
            for(int j=0;j<Game2048StaticControl.gamePlayMode;j++){
                if(mNumbers[i][j].mScores==0){
                    count++;
                }
            }
        }
        return count;
    }
    public int getPositonFromBlankCountTh(int blankTh){
        int count = 0;
        for(int i=0;i<Game2048StaticControl.gamePlayMode;i++){
            for(int j=0;j<Game2048StaticControl.gamePlayMode;j++){
                if(mNumbers[i][j].mScores==0){
                    if(count==blankTh){
                        return i*Game2048StaticControl.gamePlayMode+j;
                    }else {
                        count++;
                    }
                }
            }
        }
        return -1;
    }
    public void swapNumber(int position1,int position2){
        mNumbers[position1/Game2048StaticControl.gamePlayMode][position1%Game2048StaticControl.gamePlayMode].mCurPosition = position2;
        mNumbers[position1/Game2048StaticControl.gamePlayMode][position1%Game2048StaticControl.gamePlayMode].mBeforePosition = position1;
        mNumbers[position2/Game2048StaticControl.gamePlayMode][position2%Game2048StaticControl.gamePlayMode].mCurPosition = position1;
        mNumbers[position2/Game2048StaticControl.gamePlayMode][position2%Game2048StaticControl.gamePlayMode].mBeforePosition = position2;
        Number tem = mNumbers[position1/Game2048StaticControl.gamePlayMode][position1%Game2048StaticControl.gamePlayMode];
        mNumbers[position1/Game2048StaticControl.gamePlayMode][position1%Game2048StaticControl.gamePlayMode] = mNumbers[position2/Game2048StaticControl.gamePlayMode][position2%Game2048StaticControl.gamePlayMode];
        mNumbers[position2/Game2048StaticControl.gamePlayMode][position2%Game2048StaticControl.gamePlayMode] = tem;
    }
}

這個類的核心就是一個Number [n][n]的數組。n能夠為隨意值，由於我們的算法是通用的。

有了這個的概念以後，我們來看向左移動的算法，思想前面已經講過了，直接看代碼，結合代碼很easy理解。

   //return 0:do nothing
    //return 1:move
    //return 2:combine
    public int leftKeyDealAlgorithm(){
        int i, j, k;
        boolean isMoved = false;
        boolean isFinalMove = false;
        boolean isFinalCombie = false;
        for(i=0;i<Game2048StaticControl.gamePlayMode;i++){
            j=k=0;
            isMoved = false;
            while (true) {
                while (j<Game2048StaticControl.gamePlayMode && !isPosionHasNumber(i,j))
                    j++;
                if (j > Game2048StaticControl.gamePlayMode-1)
                    break;
                if (j > k){
                    isMoved = true;
                    isFinalMove = true;
                    Number number = getNumber(i,j);
                    number.isNeedMove = true;
                    number.isNeedCombine = false;
                    swapNumber(i*Game2048StaticControl.gamePlayMode+k,i*Game2048StaticControl.gamePlayMode+j);
                }
                if (k > 0 && getNumber(i,k).mScores==getNumber(i,k-1).mScores && !getNumber(i,k-1).isNeedCombine){
                    isFinalCombie = true;
                    Number numberk = getNumber(i,k);
                    Number numberkl = getNumber(i,k-1);
                    if(isMoved){
                        numberkl.mBeforePosition = numberk.mBeforePosition;
                    }else {
                        numberkl.mBeforePosition =  i*Game2048StaticControl.gamePlayMode+k;
                    }
                    numberkl.mCurPosition = i*Game2048StaticControl.gamePlayMode+k-1;
                    numberkl.isNeedMove = true;
                    numberkl.isNeedCombine = true;
                    numberkl.mScores <<=1;
                    updateCurScoresAndHistoryScores(numberkl.mScores);
                    numberk.reset();
                    numberk.mCurPosition = numberk.mBeforePosition = i*Game2048StaticControl.gamePlayMode+k;
                } else{
                    k++;
                }
                j++;
            }
        }
        return isFinalCombie?2:(isFinalMove?1:0);
    }

第一步：j=k=0;
第二步：找到第一個數字：

                while (j<Game2048StaticControl.gamePlayMode && !isPosionHasNumber(i,j))
                    j++;

第三步：假設j > k，那就意味這k這個位置的數字一定是空的，j這個位置的一定是第一個數字。所以就把他們交換。
第四步：推斷是不是須要合並

if (k > 0 && getNumber(i,k).mScores==getNumber(i,k-1).mScores && !getNumber(i,k-1).isNeedCombine

推斷的條件是k>0,由於是向前合並，所以合並至少是從第二個開始的。其次就是兩個數字要相等，同一時候，已經合並了得數字不能再合並。
然後再做下一個循環，如此往復就可以完畢。

以下貼出其它三個方向的代碼。

   public int rightKeyDealAlgorithm(){
        int i, j, k;
        boolean isMoved = false;
        boolean isFinalMove = false;
        boolean isFinalCombie = false;
        for(i=0;i<Game2048StaticControl.gamePlayMode;i++){
            j=k=Game2048StaticControl.gamePlayMode-1;
            isMoved = false;
            while (true) {
                while (j>-1 && !isPosionHasNumber(i,j))
                    j--;
                if (j < 0)
                    break;
                if (j < k){
                    isMoved = true;
                    isFinalMove = true;
                    Number number = getNumber(i,j);
                    number.isNeedMove = true;
                    number.isNeedCombine = false;
                    swapNumber(i*Game2048StaticControl.gamePlayMode+k,i*Game2048StaticControl.gamePlayMode+j);
                }
                if (k < Game2048StaticControl.gamePlayMode-1 && getNumber(i,k).mScores==getNumber(i,k+1).mScores && !getNumber(i,k+1).isNeedCombine){
                    isFinalCombie = true;
                    Number numberk = getNumber(i,k);
                    Number numberkl = getNumber(i,k+1);
                    if(isMoved){
                        numberkl.mBeforePosition = numberk.mBeforePosition;
                    }else {
                        numberkl.mBeforePosition =  i*Game2048StaticControl.gamePlayMode+k;
                    }
                    numberkl.mCurPosition = i*Game2048StaticControl.gamePlayMode+k+1;
                    numberkl.isNeedMove = true;
                    numberkl.isNeedCombine = true;
                    numberkl.mScores <<=1;
                    updateCurScoresAndHistoryScores(numberkl.mScores);
                    numberk.reset();
                    numberk.mCurPosition = numberk.mBeforePosition = i*Game2048StaticControl.gamePlayMode+k;
                } else{
                    k--;
                }
                j--;
            }
        }
        return isFinalCombie?2:(isFinalMove?1:0);
    }
    public int upKeyDealAlgorithm(){
        int i, j, k;
        boolean isMoved = false;
        boolean isFinalMove = false;
        boolean isFinalCombie = false;
        for(i=0;i<Game2048StaticControl.gamePlayMode;i++){
            j=k=0;
            isMoved = false;
            while (true) {
                while (j<Game2048StaticControl.gamePlayMode && !isPosionHasNumber(j,i))
                    j++;
                if (j > Game2048StaticControl.gamePlayMode-1)
                    break;
                if (j > k){
                    isMoved = true;
                    isFinalMove = true;
                    Number number = getNumber(j,i);
                    number.isNeedMove = true;
                    number.isNeedCombine = false;
                    swapNumber(k*Game2048StaticControl.gamePlayMode+i,j*Game2048StaticControl.gamePlayMode+i);
                }
                if (k > 0 && getNumber(k,i).mScores==getNumber(k-1,i).mScores && !getNumber(k-1,i).isNeedCombine){
                    isFinalCombie = true;
                    Number numberk = getNumber(k,i);
                    Number numberkl = getNumber(k-1,i);
                    if(isMoved){
                        numberkl.mBeforePosition = numberk.mBeforePosition;
                    }else {
                        numberkl.mBeforePosition =  k*Game2048StaticControl.gamePlayMode+i;
                    }
                    numberkl.mCurPosition = (k-1)*Game2048StaticControl.gamePlayMode+i;
                    numberkl.isNeedMove = true;
                    numberkl.isNeedCombine = true;
                    numberkl.mScores <<=1;
                    updateCurScoresAndHistoryScores(numberkl.mScores);
                    numberk.reset();
                    numberk.mCurPosition = numberk.mBeforePosition = k*Game2048StaticControl.gamePlayMode+i;
                } else{
                    k++;
                }
                j++;
            }
        }
        return isFinalCombie?2:(isFinalMove?1:0);
    }
    public int downKeyDealAlgorithm(){
        int i, j, k;
        boolean isMoved = false;
        boolean isFinalMove = false;
        boolean isFinalCombie = false;
        for(i=0;i<Game2048StaticControl.gamePlayMode;i++){
            j=k=Game2048StaticControl.gamePlayMode-1;
            isMoved = false;
            while (true) {
                while (j>-1 && !isPosionHasNumber(j,i))
                    j--;
                if (j < 0)
                    break;
                if (j < k){
                    isMoved = true;
                    isFinalMove = true;
                    Number number = getNumber(j,i);
                    number.isNeedMove = true;
                    number.isNeedCombine = false;
                    swapNumber(k*Game2048StaticControl.gamePlayMode+i,j*Game2048StaticControl.gamePlayMode+i);
                }
                if (k < Game2048StaticControl.gamePlayMode-1 && getNumber(k,i).mScores==getNumber(k+1,i).mScores && !getNumber(k+1,i).isNeedCombine){
                    isFinalCombie = true;
                    Number numberk = getNumber(k,i);
                    Number numberkl = getNumber(k+1,i);
                    if(isMoved){
                        numberkl.mBeforePosition = numberk.mBeforePosition;
                    }else {
                        numberkl.mBeforePosition =  k*Game2048StaticControl.gamePlayMode+i;
                    }
                    numberkl.mCurPosition = (k+1)*Game2048StaticControl.gamePlayMode+i;
                    numberkl.isNeedMove = true;
                    numberkl.isNeedCombine = true;
                    numberkl.mScores <<=1;
                    updateCurScoresAndHistoryScores(numberkl.mScores);
                    numberk.reset();
                    numberk.mCurPosition = numberk.mBeforePosition = k*Game2048StaticControl.gamePlayMode+i;
                } else{
                    k--;
                }
                j--;
            }
        }
        return isFinalCombie?
2:(isFinalMove?1:0);
    }

動畫

計算結束以後，我們須要使用動畫移動和合並數字，由於都是直線運動。所以動畫並不復雜，想想我們的Number類，計算動畫僅僅須要兩個變量。一個之前的位置。一個是當前的位置。
我們能夠理一下思路：當用戶須要向左移動時：

                    case Game2048StaticControl.DIRECT_LEFT:{
                        mNumberQueue.pushItem(mGAM.getmNumbers());
                        int ret =  mGAM.leftKeyDealAlgorithm();
                        if (ret>0){
                            startAnimation(mHolder,mPaint,Game2048StaticControl.DIRECT_LEFT);
                            mGAM.updateNumbers();
                            doDrawGameSurface();
                            sendEmptyMessage(Game2048StaticControl.GENERATE_NUMBER);
                            playSoundEffect(ret);
                        }
                        break;
                    }

我們須要做例如以下幾步：
第一步：保存當前的遊戲。用於反悔的時候回退。mNumberQueue.pushItem(mGAM.getmNumbers())
第二步：計算移動與合並
mGAM.leftKeyDealAlgorithm();
第三步：使用動畫移動和合並數字
startAnimation(mHolder,mPaint,Game2048StaticControl.DIRECT_LEFT);
第四步：生成一個新的數字
sendEmptyMessage(Game2048StaticControl.GENERATE_NUMBER);
通過發送消息來實現，詳細的實如今消息的處理代碼中，這很easy。這裏暫不展開。
以下看一個startAnimation方法。


startAnimation定義例如以下：

    public void startAnimation(SurfaceHolder holder,Paint paint,int direct){
        int count = 0;
        RectF rectF = new RectF();
        while (count++<Game2048StaticControl.ANIMATION_MOVE_STEP) {
            Canvas canvas = holder.lockCanvas();
            mDrawTools.initSurfaceBg(canvas, paint);
            mDrawTools.drawSurfaceMap(canvas, paint);
            mDrawTools.drawSurfaceMapAndNumbersWhoIsNeedCombine(canvas,paint);
            for (int i = 0; i < Game2048StaticControl.gamePlayMode; i++) {
                for (int j = 0; j < Game2048StaticControl.gamePlayMode; j++) {
                    mGAM.aniInsertValue(i, j, count, Game2048StaticControl.ANIMATION_MOVE_STEP,direct,rectF);
                    if(rectF != null && mGAM.isPosionHasNumber(i,j) && mGAM.getNumber(i,j).isNeedMove){
                        mDrawTools.drawNumberByRectF(i,j,canvas,paint,rectF);
                    }
                }
            }
            holder.unlockCanvasAndPost(canvas);
        }
    }

就是對每個Number，使用 mGAM.aniInsertValue方法來計算它的坐標：

  public void aniInsertValue(int x,int y,int count,int insertCount,int direct,RectF rectF){
        Number number = getNumber(x,y);
        if(number.mCurPosition ==  number.mBeforePosition){
            return;
        }
        float xDiffPixels = Game2048StaticControl.GameNumberViewPosition[number.mCurPosition/Game2048StaticControl.gamePlayMode]
                [number.mCurPosition%Game2048StaticControl.gamePlayMode].left
                -Game2048StaticControl.GameNumberViewPosition[number.mBeforePosition/Game2048StaticControl.gamePlayMode]
                [number.mBeforePosition%Game2048StaticControl.gamePlayMode].left;
        float yDiffPixels = Game2048StaticControl.GameNumberViewPosition[number.mCurPosition/Game2048StaticControl.gamePlayMode]
                [number.mCurPosition%Game2048StaticControl.gamePlayMode].top
                -Game2048StaticControl.GameNumberViewPosition[number.mBeforePosition/Game2048StaticControl.gamePlayMode]
                [number.mBeforePosition%Game2048StaticControl.gamePlayMode].top;
        xDiffPixels = Math.abs(xDiffPixels);
        yDiffPixels = Math.abs(yDiffPixels);
        float xStep = xDiffPixels/insertCount;
        float yStep = yDiffPixels/insertCount;
        float xNewPosition = Game2048StaticControl.GameNumberViewPosition[number.mCurPosition/Game2048StaticControl.gamePlayMode]
                [number.mCurPosition%Game2048StaticControl.gamePlayMode].left;
        float yNewPosition = Game2048StaticControl.GameNumberViewPosition[number.mCurPosition/Game2048StaticControl.gamePlayMode]
                [number.mCurPosition%Game2048StaticControl.gamePlayMode].top;;
        switch (direct){
            case DIRECT_UP:{
                yNewPosition = Game2048StaticControl.GameNumberViewPosition[number.mBeforePosition/Game2048StaticControl.gamePlayMode]
                        [number.mBeforePosition%Game2048StaticControl.gamePlayMode].top
                        - yStep*count;
                break;
            }
            case DIRECT_DOWN:{
                yNewPosition = Game2048StaticControl.GameNumberViewPosition[number.mBeforePosition/Game2048StaticControl.gamePlayMode]
                        [number.mBeforePosition%Game2048StaticControl.gamePlayMode].top
                                + yStep*count;
                break;
            }
            case DIRECT_LEFT:{
                xNewPosition = Game2048StaticControl.GameNumberViewPosition[number.mBeforePosition/Game2048StaticControl.gamePlayMode]
                        [number.mBeforePosition%Game2048StaticControl.gamePlayMode].left
                        - xStep*count;
                break;
            }
            case DIRECT_RIGHT:{
                xNewPosition = Game2048StaticControl.GameNumberViewPosition[number.mBeforePosition/Game2048StaticControl.gamePlayMode]
                        [number.mBeforePosition%Game2048StaticControl.gamePlayMode].left
                        + xStep*count;
                break;
            }
            default:break;
        }
        rectF.set(xNewPosition,yNewPosition,xNewPosition+Game2048StaticControl.gameNumberViewLength
                ,yNewPosition+Game2048StaticControl.gameNumberViewLength);
    }

計算的過程正對上下左右各不同樣。原理很easy：
技術分享圖片
原理就是在途中的花點的地方繪制一下數字就好了。也就是所謂的線性插值法。

在隨機位置隨機生成2或者4

生成2或者4就太簡單了，隨機位置怎麽計算呢？這裏要註意實在空白方格的隨機位置哦，因此首先要獲取當前有多少個空格：

    public int getBlankCount(){
        return mNumbers.getBlankCount();
    }

進一步：

    public int getBlankCount(){
        int count = 0;
        for(int i=0;i<Game2048StaticControl.gamePlayMode;i++){
            for(int j=0;j<Game2048StaticControl.gamePlayMode;j++){
                if(mNumbers[i][j].mScores==0){
                    count++;
                }
            }
        }
        return count;
    }

比方說當前有7個空白處。那麽就僅僅能生7以內的隨機數n，然後 把它插到第n個空白處。


插入方法例如以下：

    public int  setOneRandomNumberInRandomPosition(){
        int scores = Game2048Algorithm.getRandom2Or4();
        int blankCount = getBlankCount();
        Log.d(TAG,"blankCount:"+blankCount);
        int blankTh = 0;
        if(blankCount<=0){
            return -1;
        }else{
            blankTh = Game2048Algorithm.getRandomPosition(blankCount);
        }
        int position = mNumbers.getPositonFromBlankCountTh(blankTh);
        if (position<0){
            Log.d(TAG,"getPositonFromBlankCountTh return error");
            return -1;
        }
        Number num = mNumbers.getNumber(position/Game2048StaticControl.gamePlayMode,position%Game2048StaticControl.gamePlayMode);
        num.mScores = scores;
        num.mBeforePosition = num.mCurPosition = position;
        num.isNeedCombine = num.isNeedMove = false;
        return position;
    }

檢測遊戲失敗

檢測遊戲的失敗也有一個通用的方式：

   public boolean checkGameOver(){
        Log.d(TAG,"checkGameOver");
        for (int i = 0; i < Game2048StaticControl.gamePlayMode; i++)
        {
            for (int j = 0; j < Game2048StaticControl.gamePlayMode; j++)
            {
                if (j != Game2048StaticControl.gamePlayMode-1 && getNumber(i,j).mScores == getNumber(i,j+1).mScores)
                    return false;
                if (i != Game2048StaticControl.gamePlayMode-1 && getNumber(i,j).mScores == getNumber(i+1,j).mScores)
                    return false;
            }
        }
        if (mListener!=null){
            mListener.onGameOver();
        }
        return true;
    }

算法的核心思想就是一定要對每個數字對照它的前後左右。

僅僅要發現有相等的就覺得能夠繼續。當然。推斷的前提的空白格子的數量為0。

2048遊戲回想二：算法總結（移動、合並、動畫等）

相關推薦

2048遊戲回想二：算法總結（移動、合並、動畫等）

switch com asm isp error 結束 復雜 因此 playsound 假設僅僅是單純的寫一個2048遊戲。讓這個遊戲能夠玩的話，工作量還是蠻小的。只

2048遊戲回顧二：演算法總結（移動、合併、動畫等）

如果只是單純的寫一個2048遊戲，讓這個遊戲可以玩的話，工作量還是蠻小的。不過，在這寫工作中，你可能花時間最多的就是數字的移動與合併的演算法了，如果沒有做過，可能確實要花點時間來構思，所以，寫完2048遊戲以後，我希望能把它做個記錄。 移動與合併的演算法

八大排序算法總結（1）

n-1 冒泡排序 int 排序算法 length != 位置 倒數 選擇 冒泡排序： 第一輪：從下標0到n-1(n 是數組長度)，如果前一個元素比後一個元素大，那麽，相鄰的兩兩交換，最後數組中最大的元素放在最後一個位置上。 第二輪：從標0到n-2,重復上過程，這樣第二大的元

編程之法：面試和算法心得（最大連續子數組和）

參考 否則 ++ 例子 返回 log 遍歷 方法 時間 內容全部來自編程之法：面試和算法心得一書，實現是自己寫的使用的是java 題目描述 輸入一個整形數組，數組裏有正數也有負數。數組中連續的一個或多個整數組成一個子數組，每個子數組都有一個和。 求所有子數組的和的最大值，要

Hash算法總結（轉載）

avr 人員 鏈地址法 函數 說明 rfc jdk8 的人 完成 1. Hash是什麽，它的作用 先舉個例子。我們每個活在世上的人，為了能夠參與各種社會活動，都需要一個用於識別自己的標誌。也許你覺得名字或是身份證就足以代表你這個人，但是這種代表性非常脆弱，因為重名的人很多，

二分法總結 （以後直接就是抄板子了！）

這兩天又碰到了用到了二分法的題，但是由於我之前學的不是很清楚，許多二分的題都是憑感覺寫出二分格式，然後WA之後憑感覺調整（竟然還能A過！！），因此再次碰到之後就感覺還是需要總結一下，要不然以後太浪費時間了。 我們用套路的方法來二分： 對於一個區間[l,r]，滿足 迴圈不變式：  &

c++：深淺拷貝總結（深拷貝的傳統和現代寫法）

深淺拷貝區別： 淺拷貝只拷貝指標，但拷貝後兩個指標指向同一個記憶體空間； 深拷貝不但對指標進行拷貝，而且對指標指向的內容進行拷貝， 呼叫拷貝建構函式後，淺拷貝還有聯絡，深拷貝的兩個物件完全獨立。 淺拷貝類似於檔案建立快捷方式，而深拷貝好比檔案複製。 編譯器預設提供的

pandas數據大發888平臺出租規整化：清理、轉換、合並、重塑

右連接 foo 規整化 float 數據集 str none num out 數據分析和大發888平臺出租 haozbbs.com Q1446595067建模方面的大量編程工作都是用在數據準備上的：加載、清理、轉換以及重塑。許多人選擇使用通用編程語言或unix文本處理工

FFmpeg：視頻轉碼、剪切、合並、播放速調整

基本上 不安裝 同時 using 上傳 lis got 轉碼 導師 原文：https://fzheng.me/2016/01/08/ffmpeg/ FFmpeg：視頻轉碼、剪切、合並、播放速調整 2016-01-08 前陣子幫導師處理項目 ppt，因為插入視頻的格式問題被搞

查找算法總結(一)—順序、二分、二叉、紅黑

hash 要求 保存 ges 標準 正是 搜索路徑 初始化 返回鍵 1.順序查找 在查找中我們一個一個順序的遍歷表中的所有鍵並使用equals（）方法來查找匹配的鍵。 優點：對數組的結構沒有特定的要求，可以使用數組或者鏈表實現，算法簡單。 缺點：當數組個數n較大時，效率低下

Spark機器學習(10)：ALS交替最小二乘算法

mllib 測試 con 相互 idt color ted 個人 使用 1. Alternating Least Square ALS(Alternating Least Square)，交替最小二乘法。在機器學習中，特指使用最小二乘法的一種協同推薦算法。如下圖所示，u表

二叉樹遍歷算法總結

使用 preorder 說明 stack height type pri content 結構圖 ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

百度的一道二面算法題分析：補全括號序列

subst 地址 block lock sub amp 循環 imp not 算法題：補全括號序列 百度二面遇到的一個問題 大概意思就是 給出一個中括號序列，在序列前後可以加中括號字符，補全它。。。 當時沒想起來解決辦法，然後涼涼了，後來專門去搞了這道題，終於搞定 思路在註

八大排序算法總結：（五）快速排序

con 遞歸調用 結果 width 算法總結 調用 小數 排序算法總結 png 目的：掌握 快速排序 的 基本思想與過程、代碼實現、時間復雜度 1、基本思想與過程：（分治思想，挖坑填數） 　　（1）從數列中選擇一個數作為key值； 　　（2）將比這個數小的數全部放在它的左邊

JS排序算法總結：（八）基數排序

clas style dig ret .com strong spa radi 基本 目的：掌握 基數排序 的 基本思想與過程、代碼實現、時間復雜度 1、基本思想與過程：（只針對數字） 　　（1）首先確定基數為10，數組的長度也就是10.每個數都會在這10個數中尋找自己的位

JS排序算法總結：八種算法對比

線性 nlog 對比 http xxx 運行 bsp 排序 image 目的：掌握 排序算法的分類及不同算法復雜度的對比、搞清楚 XXX與數組初始狀態無關分為幾種情況： 　　a、算法復雜度與初始狀態無關； 　　b、元素總比較次數與初始狀態無關； 　　c、元素總移動次數與初始

資料結構與算法系列課程之二：複雜度分析（上）

資料結構和演算法，本身就是要解決 “快” 和 “省” 的問題。考量的指標分別就是 “時間複雜度” 和 “空間複雜度”。 時間複雜度表示程式碼執行時間隨著資料規模增長的變化趨勢，也叫漸進時間複雜度。 空間複雜度，全稱漸進空間複雜度，表示演算法的儲存空間和資料規模之間的增長關

轉：目標檢測算法總結

拆分 compute 涵蓋 代碼 檢測器 cti nes 深度網絡 上層 目標檢測是很多計算機視覺任務的基礎，不論我們需要實現圖像與文字的交互還是需要識別精細類別，它都提供了可靠的信息。本文對目標檢測進行了整體回顧，第一部分從RCNN開始介紹基於候選區域的目標檢測器

幾種基本排序算法總結

子序列 system aop 大於等於 != pri i++ index 元素移動 以下均采用從小到大排序： 1.選擇排序算法 個人覺得選擇排序算法是容易理解的排序算法，即從n個元素中選擇最小的一個元素與第一個元素交換，再將除第一個元素之外的n-1個元素找到最小的一

Akamai在內容分發網絡中的算法研究（翻譯總結）

程序 占用 election etl 時延 dal 負載均衡 文件訪問 散列 BLOOM FILTERS Bloom filters的研究主要用在akamai的CDN中的兩個場景：1）索引管理優化；2）內容過濾。 Bloom filters是hash算法的一個變種，有非