2. 程式人生 > >淺談分塊演算法

淺談分塊演算法

阿新 • • 發佈：2019-01-25

一直覺得分塊是一個很高階的東西…一直沒敢碰，現在才知道分塊就是一種稍微優美一些的暴力，所以沒有學過分塊的同學不要害怕啦…

首先，分塊是什麼意思呢，顧名思義就是把要處理的東西進行分塊，分成一塊一塊的233，舉個很簡單的例子，對於一個數列 size（a{ }）=5，我們可以把前2個分到一起，再兩個分到一起，最後單下來一個，為什麼要這樣處理呢？這樣處理的好處又是什麼呢？
我們也可以這樣思考，如果我們把一個數列，當該數列的長度為n的時候，我們以根號n為一段，分出來的段數不超過根號n，如果我們要進行區間的處理，比如加法減法等，可以對於修改區間[ L , R ]可以把其中框起來的塊（一塊是根號n的大小）直接打上標記，由於每一塊的長度不大於根號n，所以對於兩邊沒有框起來的部分，我們直接暴力地進行更新，這樣操作次數是最多2倍根號n的，而中間的標記是O（1）處理的，這就是為什麼該類演算法是根號級別的原因

思路看起來很清晰吧，好像很簡單的樣子，那麼我們馬上就來試試吧

以黃學長的分塊學習順序為例
（本文的所有題目，均來自黃學長，www.hzwer.com）

我們先進行區間修改單點查詢操作

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#define MAXN 100000
using namespace std;
int a[MAXN],add[MAXN],b[MAXN],len,n,m;//add為標記
void modify(int l,int
 
 r,int ad){
    for(register int i=l;i<=min(b[l]*len,r);i++) a[i]+=ad;
    if(b[l]!=b[r]){//注意此處的min操作，可能會在小資料卡到你
        for(register int i=(b[r]-1)*len+1;i<=r;i++) a[i]+=ad; 
    }
    for(register int i=b[l]+1;i<=b[r]-1;i++)add[i]+=ad;
}
int main(){
    scanf("%d%d",&n,&m);
    len=sqrt
 
(n);
    for(register int i=1;i<=n;i++)scanf("%d",&a[i]);
    for(register int i=1;i<=n;i++)b[i]=(i-1)/len+1;
    for(register int i=1;i<=m;i++){
        int temp;
        scanf("%d",&temp);
        if(temp==1){
            int l,r,ad;
            scanf("%d%d%d",&l,&r,&ad);
            modify(l,r,ad);
        }else{
            int loc;
            scanf("%d",&loc);
            printf("%d\n",a[loc]+add[b[loc]]);
        }//該點的值和該店所在的區間累加的標記
    }
    return 0;
}

接下來是區間修改，區間查詢小於某值的數有多少個

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<vector>
#include<cmath> 
#define MAXN 1000000+10
#define MINN 5000
using namespace std;
vector<int>v[MINN];
int len,a[MAXN],b[MAXN],add[MINN];
void reset(int zone){
    v[zone].clear();
    for(register int i=(zone-1)*len+1;i<=zone*len;i++) v[zone].push_back(a[i]);
    sort(v[zone].begin(),v[zone].end());
}
void modify(int l,int r,int ad){
    for(register int i=l;i<=min(b[l]*len,r);i++) a[i]+=ad;
    reset(b[l]);
    if(b[l]!=b[r]){
        for(register int i=(b[r]-1)*len+1;i<=r;i++) a[i]+=ad;
        reset(b[r]);
    }
    for(register int i=b[l]+1;i<=b[r]-1;i++) add[i]+=ad;
}
int query(int l,int r,int k){
    int cnt=0;
    for(register int i=l;i<=min(b[l]*len,r);i++){
        if(a[i]+add[b[i]]<k)cnt++;
    }
    if(b[l]!=b[r]){
        for(register int i=(b[r]-1)*len+1;i<=r;i++){
            if(a[i]+add[b[i]]<k)cnt++;
        }
    }
    for(register int i=b[l]+1;i<=b[r]-1;i++){
        int x=k-add[i];
        cnt+=lower_bound(v[i].begin(),v[i].end(),x)-v[i].begin();
    }
    return cnt;
}
int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    len=sqrt(n);
    for(register int i=1;i<=n;i++) scanf("%d",&a[i]);
    for(register int i=1;i<=n;i++){
        b[i]=(i-1)/len+1;
        v[b[i]].push_back(a[i]);
    }
    for(register int i=1;i<=b[n];i++) sort(v[i].begin(),v[i].end());
    for(register int i=1;i<=m;i++){
        int temp;
        scanf("%d",&temp);
        if(temp==1){
            int l,r,ad;
            scanf("%d%d%d",&l,&r,&ad);
            modify(l,r,ad);
        }else{
            int l,r,k;
            scanf("%d%d%d",&l,&r,&k);
            printf("%d\n",query(l,r,k));
        }
    }
    return 0;
}

接著是第三個問題

區間修改，查區間內某個數的前驅，如果沒有則返回0

這個問題和上個問題類似，只不過由於需要查前驅，vector不能做到（只能upper _ bound和lower _ bound），而vector是支援元素可重的，這樣一來無法得知其前驅（因為lower _ bound是返回第一個大於他的元素的迭代器，upper _ bound是返回值第一個大於他並且在可重範圍內的最後一個數），所以只需把資料結構改成set就好了，因為set是不可重集

#include<cstdio>
#include<cstring>
#include<iostream>
#include<set>
#include<cmath> 
#define MAXN 100000
#define MINN 1000
using namespace std;
int len,n,m;
set<int>s[MINN];
int add[MINN];
int a[MAXN],be[MAXN];
void reset(int loc){
    s[loc].clear();
    for(register int i=(loc-1)*len+1;i<=loc*len;i++) s[loc].insert(a[i]); 
}
void modify(int from,int to,int ad){
    for(register int i=from;i<=min(to,be[from]*len);i++) a[i]+=ad;
    reset(be[from]);
    if(be[from]!=be[to]){
        for(register int i=(be[to]-1)*len+1;i<=to;i++) a[i]+=ad;
        reset(be[to]);
    }
    for(register int i=be[from]+1;i<=be[to]-1;i++) add[i]+=ad;
}
int query(int from,int to,int k){
    int cnt=0;
    for(register int i=from;i<=min(be[from]*len,to);i++)if(a[i]<k)cnt=max(cnt,a[i]);
    if(be[from]!=be[to]){
        for(register int i=(be[to]-1)*len+1;i<=to;i++) if(a[i]<k)cnt=max(cnt,a[i]);
    }
    for(register int i=be[from]+1;i<=be[to]-1;i++){
        int x=k-add[i];
        set<int>::iterator loc=s[i].lower_bound(x);
        if(loc==s[i].begin()) continue;
        loc--;
        cnt=max(cnt,*loc+add[i]);
    }
    return cnt;
}
int main(){
    //freopen(".txt","r",stdin);
    //freopen(".out","w",stdout);
    scanf("%d%d",&n,&m);
    len=sqrt(n);
    for(register int i=1;i<=n;i++) scanf("%d",&a[i]);
    for(register int i=1;i<=n;i++){
        be[i]=(i-1)/len+1;
        s[be[i]].insert(a[i]);
    }
    for(register int i=1;i<=m;i++){
        int temp;
        scanf("%d",&temp);
        if(temp==1){
            int l,r,ad;
            scanf("%d%d%d",&l,&r,&ad);
            modify(l,r,ad);
        }else{
            int l,r,k;
            scanf("%d%d%d",&l,&r,&k);
            printf("%d\n",query(l,r,k));//0表示沒有 
        }
    }
    return 0;
}
/*
10 5
1 2 3 4 5 6 7 8 9 10
2 1 9 9
1 1 3 2
2 1 4 5
*/

區間加法區間求和

和前面一樣，打mark就行了

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#define MAXN 100000
#define MINN 1000 
using namespace std;
int len;
int n,m;
int a[MAXN],add[MINN],val[MINN],be[MAXN];
void modify(int from,int to,int ad){
    for(register int i=from;i<=min(to,be[from]*len);i++) a[i]+=ad,val[be[from]]+=ad;
    if(be[from]!=be[to]){
        for(register int i=(be[to]-1)*len+1;i<=to;i++) a[i]+=ad,val[be[to]]+=ad;
    }
    for(register int i=be[from]+1;i<=be[to]-1;i++) add[i]+=ad;
}
int query(int from,int to){
    int cnt=0;
    for(register int i=from;i<=min(to,be[from]*len);i++) cnt+=(a[i]+add[be[from]]);
    if(be[from]!=be[to]){
        for(register int i=(be[to]-1)*len+1;i<=to;i++) cnt+=(a[i]+add[be[to]]);
    }
    for(register int i=be[from]+1;i<=be[to]-1;i++) cnt+=(val[i]+add[i]*len);
    return cnt;
}
int main(){
    //freopen(".txt","r",stdin);
    //freopen(".out","w",stdout);
    scanf("%d%d",&n,&m);
    len=sqrt(n);
    for(register int i=1;i<=n;i++)be[i]=(i-1)/len+1;
    for(register int i=1;i<=n;i++)scanf("%d",&a[i]),val[be[i]]+=a[i];
    for(register int i=1;i<=m;i++){
        int temp;
        scanf("%d",&temp);
        if(temp==1){
            int f,t,ad;
            scanf("%d%d%d",&f,&t,&ad);
            modify(f,t,ad);
        }else{
            int f,t;
            cin>>f>>t;
            printf("%d\n",query(f,t));
        }
    }
    return 0;
}

區間開方，區間求和

我們可以考慮一個數，在保留int的情況下，只需要幾次就會開方到1或者0，所以我們只需要記錄一個塊是否全部是0或者1就行了，因為再進行操作不會對其進行修改

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#define MAXN 10000
#define MINN 1000
using namespace std;
int n,m,be[MAXN],a[MAXN];
int val[MINN];
bool flag[MAXN];
int len;
void sqrtt(int zone){
    if(flag[zone]) return;
    flag[zone]=true;
    val[zone]=0;
    for(register int i=(zone-1)*len+1;i<=zone*len;i++){
        a[i]=sqrt(a[i]);
        val[zone]+=a[i];
        if(a[i]>1)flag[zone]=false;
    }
}
void modify(int from,int to){
    for(register int i=from;i<=min(to,be[from]*len);i++){
        val[be[from]]-=a[i];
        a[i]=sqrt(a[i]);
        val[be[from]]+=a[i];
    }
    if(be[from]!=be[to]){
        for(register int i=(be[to]-1)*len+1;i<=to;i++){
            val[be[to]]-=a[i];
            a[i]=sqrt(a[i]);
            val[be[to]]+=a[i];
        }
    } 
    for(register int i=be[from]+1;i<=be[to]-1;i++) sqrtt(i);
}
int query(int from,int to){
    int cnt=0;
    for(register int i=from;i<=min(to,be[from]*len);i++) cnt+=a[i];
    if(be[from]!=be[to]){
        for(register int i=(be[to]-1)*len+1;i<=to;i++) cnt+=a[i];
    }
    for(register int i=be[from]+1;i<=be[to]-1;i++) cnt+=val[i];
    return cnt;
}
int main(){
    //freopen("sqrt.txt","r",stdin);
    //ios::sync_with_stdio(false);
    cin>>n>>m;
    len=sqrt(n);
    for(register int i=1;i<=n;i++) be[i]=(i-1)/len+1; 
    for(register int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        val[be[i]]+=a[i]; 
    }
    for(register int i=1;i<=m;i++){
        int temp;
        scanf("%d",&temp);
        if(temp==1){
            int f,t;
            cin>>f>>t;
            modify(f,t);
        }else{
            int f,t;
            cin>>f>>t;
            printf("%d\n",query(f,t));
        }
    }
    return 0;
}

區間乘法，區間加法和區間查詢

其實這道題有一個更簡單的做法，把乘法轉化為加法，比如乘n可以想成加這個數的n-1倍，注意程式中mul（乘法）lazy陣列和add（加法）lazy陣列的轉化

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#define MAXN 10000
#define MINN 100
using namespace std;

int a[MAXN],be[MAXN];
int val[MINN],add[MINN],mul[MINN];
int len,n,m;
void modifyadd(int from,int to,int ad){
    for(register int i=from;i<=min(to,be[from]*len);i++){
        val[be[i]]+=ad;
        a[i]+=ad;
    }
    if(be[from]!=be[to]){
        for(register int i=(be[to]-1)*len+1;i<=to;i++){
            val[be[i]]+=ad;
            a[i]+=ad;
        }
    }
    for(register int i=be[from]+1;i<=be[to]-1;i++){
        add[i]+=ad;
    }
}
void modifymul(int from,int to,int mu){
    for(register int i=from;i<=min(to,be[from]*len);i++){
        val[be[i]]-=a[i];
        a[i]*=mu;   
        val[be[i]]+=a[i];
    }
    if(be[from]!=be[to]){
        for(register int i=(be[to]-1)*len+1;i<=to;i++){
            val[be[i]]-=a[i];
            a[i]*=mu;
            val[be[i]]+=a[i];
        }
    }
    for(register int i=be[from]+1;i<=be[to]-1;i++){
        add[i]*=mu;
        mul[i]*=mu;
    }
}
int query(int from,int to){
    int cnt=0;
    for(register int i=from;i<=min(be[from]*len,to);i++) cnt+=(a[i]*mul[be[i]]+add[be[i]]);
    if(be[from]!=be[to]){
        for(register int i=(be[to]-1)*len+1;i<=to;i++) cnt+=(a[i]*mul[be[i]]+add[be[i]]);
    }
    for(register int i=be[from]+1;i<=be[to]-1;i++){
        cnt+=val[i]*mul[i]+add[i];
    }
    return cnt;
}
int main(){
    //freopen("mul.txt","r",stdin); 
    cin>>n>>m;
    len=sqrt(n);
    for(register int i=0;i<MINN;i++)mul[i]=1;
    for(register int i=1;i<=n;i++)be[i]=(i-1)/len+1;
    for(register int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        val[be[i]]+=a[i];
    }
    for(register int i=1;i<=m;i++){
        int temp;
        scanf("%d",&temp);
        if(temp==1){
            int f,t,ju,num;
            scanf("%d%d%d%d",&f,&t,&ju,&num);
            if(ju==1){//1乘法 
                modifymul(f,t,num);
            }else{
                modifyadd(f,t,num);
            }
        }else{
            int f,t;
            cin>>f>>t;
            printf("%d\n",query(f,t));
        }
    }
    return 0;
}
/*
5 7
1 2 3 4 5
2 
1 3
//6
1
1 3 1 2
// 2 4 6 4 5 
2
1 3
// 12
1
1 4 2 1
// 3 5 7 5 5
2 
1 4
// 20
1
1 4 1 3
// 9 15 21 15 5
2 
1 5
// 65
*/

給出一個長為n的數列，以及n個操作，操作涉及區間詢問等於一個數c的元素，並將這個區間的所有元素改為c

顯然我們可以邊query邊處理，用一個數組記錄該塊是否全為某一數，比如mark[1]=3表示第一個區間的所有數都為3，mark[2]=-1表示塊2裡的資料是亂序，沒有統一

#include<cstdio>
#include<cstring>
#include<iostream>
#include<cmath>
#define MAXN 100000
#define MINN 1000
using namespace std;

int n,m,be[MAXN],a[MAXN];
int val[MINN],mark[MINN];
int len;
void reset(int zone){
    if(mark[zone]==-1) return;
    for(register int i=(zone-1)*len+1;i<=zone*len;i++) a[i]=mark[zone];
    mark[zone]=-1;
} 
int solve(int from,int to,int c){
    int cnt=0;
    reset(be[from]);
    for(register int i=from;i<=min(to,be[from]*len);i++){
        if(a[i]==c) cnt++;
        else a[i]=c;
    }
    if(be[from]!=be[to]){
        reset(be[to]);
        for(register int i=(be[to]-1)*len+1;i<=to;i++){
            if(a[i]==c) cnt++;
            else a[i]=c;
        }
    }
    for(register int i=be[from]+1;i<=be[to]-1;i++){
        if(mark[i]!=-1){
            if(mark[i]==c){
                cnt+=len;
            }else{
                mark[i]=c;
            }
        }else{
            for(register int j=(i-1)*len+1;j<=i*len;j++){
                if(a[j]==c) cnt++;
                else a[j]=c;
            }
        }
    }
    return cnt;
}
int main(){
    //freopen("query.txt","r",stdin);
    cin>>n>>m;
    len=sqrt(n);
    memset(mark,-1,sizeof(mark));
    for(register int i=1;i<=n;i++) be[i]=(i-1)/len+1;
    for(register int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        val[be[i]]+=a[i];
    }
    for(register int i=1;i<=m;i++){
        int f,t,c;
        scanf("%d%d%d",&f,&t,&c);
        printf("%d\n",solve(f,t,c));
    }
    return 0;
}
/*
5 6
1 2 3 4 5
1 3 2
// 1->2 2 2 4 5
1 4 2
// 3->2 2 2 2 5
1 2 3
// 0->3 3 2 2 5
1 5 2
// 2->2 2 2 2 2
1 2 4
// 0->4 4 2 2 2
2 5 4
// 1-> 4 4 4 4 4
*/

最後一個是求區間眾數

注意其中的lower_bound和upper _bound的操作，非常的巧妙，可以算出該區間該數為多少個，程式中的二元陣列則是代表第i個塊到第j個塊的眾數

#include<iostream>
#include<cstdio>
#include<cmath>
#include<vector>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<map>
#define MAXN 50000+10
#define MINN 500+10
using namespace std;
map<int,int>m;
vector<int>v[MAXN];
int val[MAXN];
int len,n,mm;
int cnt[MINN][MINN];
int ccnt;
int rock[MAXN];
int a[MAXN],be[MAXN];
void pre(int zone){
    memset(rock,0,sizeof(rock));
    int maxn=0,loc=0;
    for(register int i=(zone-1)*len+1;i<=n;i++){
        rock[a[i]]++;
        if(rock[a[i]]>maxn||(rock[a[i]]==maxn&&val[a[i]]<val[loc])){
            loc=a[i];
            maxn=rock[a[i]];
        }
        cnt[zone][be[i]]=loc;
    }
}
int query(int from,int to,int x){
    int temp=upper_bound(v[x].begin(),v[x].end(),to)-lower_bound(v[x].begin(),v[x].end(),from);
    return temp;
}
int query(int from,int to){
    int ans=cnt[be[from]+1][be[to]-1];
    int maxn=query(from,to,ans);
    for(register int i=from;i<=min(to,be[from]*len);i++){
        int temp=query(from,to,a[i]);
        if(temp>maxn||(temp==maxn&&val[a[i]]<val[ans])){
            ans=a[i];
            maxn=temp;
        }
    }
    if(be[from]!=be[to]){
        for(register int i=(be[to]-1)*len+1;i<=to;i++){
            int temp=query(from,to,a[i]);
            if(temp>maxn||(temp==maxn&&val[a[i]]<val[ans])){
                ans=a[i];
                maxn=temp;
            }
        }
    }
    return ans;
}
int main(){
    //freopen("txt.txt","r",stdin);
    scanf("%d%d",&n,&mm);
    len=sqrt(n);
    int ans=0;
    for(register int i=1;i<=n;i++) be[i]=(i-1)/len+1;
    for(register int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        if(!m[a[i]]){
            m[a[i]]=++ccnt;
            val[ccnt]=a[i];//注意這裡的離散化並不是需要排序,而只是給每一個數一個編號 
        }
        a[i]=m[a[i]];//給數列的每個數一個編號 
        v[a[i]].push_back(i);//該編號的數的位置加入一個i 
    }
    for(register int i=1;i<=be[n];i++) pre(i);//對每個塊進行pre操作 
    for(register int i=1;i<=mm;i++){
        int aa,bb;
        scanf("%d%d",&aa,&bb);
        aa=(aa+ans-1)%n+1;bb=(bb+ans-1)%n+1;
        if(aa>bb)swap(aa,bb);
        ans=val[query(aa,bb)];
        printf("%d\n",ans);
    }
    return 0;
}
/*
20 3
1 0 25 14 34 1 25 25 48 8 4 4 9 8 2 2 3 3 3 10
1 20
10 16
4 8
*/

相關推薦

BZOJ 2724 淺談分塊演算法求區間眾數

世界真的很大 分塊演算法大概算是一種線上的資料結構，和線段樹作用差不多，但是卻能維護一些線段樹維護不了的資訊。 線段樹要求維護的資訊必須要具備可合併性，就是說子區間的資訊能夠合併到大區間裡，比如區間和，區間值域等 但是分塊卻不需要這樣的條件 有點暴力

淺談分塊演算法

一直覺得分塊是一個很高階的東西…一直沒敢碰，現在才知道分塊就是一種稍微優美一些的暴力，所以沒有學過分塊的同學不要害怕啦… 首先，分塊是什麼意思呢，顧名思義就是把要處理的東西進行分塊，分成一塊一塊的233，舉個很簡單的例子，對於一個數列 size（a

淺談分塊——入門

前言 　　在學會分塊之前，覺得分塊是一個很深奧的東西，很玄學。但其實分塊的作用也很廣泛，也非常簡單，在這裡分享一下。 分塊的定義與分塊的基本性質 　　分塊，顧名思義，就是將一個數組分成一些小塊。        而分塊有一個基本性質，就是塊的大小不會影響答案，只對

淺談分詞演算法（4）基於字的分詞方法（CRF）

目錄 前言 目錄 條件隨機場（conditional random field CRF） 核心點 線性鏈條件隨機場 簡化形式 CRF分詞 CRF VS HMM 程式碼實現 訓練程式碼 實驗結果 參考文獻

淺談分塊

更優體驗請移步[CSDN](https://blog.csdn.net/LZX_lzx/article/details/112639743) # 前言 $NOIP$已過，訓練難度瞬間變大。很多沒有學過的知識點以各種方式出現在題目裡。而本蒟蒻的腦子裡只有那慘兮兮一點點的演算法，於是本蒟蒻就開始走上惡補知識點的

演算法淺談——遞迴演算法與海盜分金問題

本文始發於個人公眾號：TechFlow 最近看到一道很有意思的問題，分享給大家。 還是老規矩，在我們聊演算法問題之前，先來看一個故事。 傳說中，有5個海盜組成了一支無敵的海盜艦隊，他們在最後一次的尋寶當中找尋到了100枚價值連城的金幣。於是，很自然的，這群海盜面臨分贓的問題。為了防止海盜內訌，殘忍的海盜們

【轉】淺談分布式服務協調技術 Zookeeper

客戶 內存數據 訂閱 數據開發 watcher database 所有 ren info 非常好介紹Zookeeper的文章， Google的三篇論文影響了很多很多人，也影響了很多很多系統。這三篇論文一直是分布式領域傳閱的經典。根據MapReduce，於是

淺談分布式事務（轉）

back 微服務 目的 light ber message values 及其 環境 現今互聯網界，分布式系統和微服務架構盛行。一個簡單操作，在服務端非常可能是由多個服務和數據庫實例協同完成的。在一致性要求較高的場景下，多個獨立操作之間的一致性問題顯得格外棘手。基

淺談分布式事務

復制 -a number rep 是否 blog space opera 自己的 現今互聯網界，分布式系統和微服務架構盛行。一個簡單操作，在服務端非常可能是由多個服務和數據庫實例協同完成的。在一致性要求較高的場景下，多個獨立操作之間的一致性問題顯得格外棘手。 基於水平擴容能

淺談分布式鎖

獲得 edi 同時 問題 用戶 get() 內部 nds 允許 分布式一致性問題 首先我們先來看一個小例子： 假設某商城有一個商品庫存剩10個，用戶A想要買6個，用戶B想要買5個，在理想狀態下，用戶A先買走了6了，庫存減少6個還剩4個，此時用戶B應該無法購買5個，給出數量不

【轉】淺談分布式鎖

共享 消失 特性 提示 了解 鎖表 有序 文件系統 小例子 前言 隨著互聯網技術的不斷發展，數據量的不斷增加，業務邏輯日趨復雜，在這種背景下，傳統的集中式系統已經無法滿足我們的業務需求，分布式系統被應用在更多的場景，而在分布式系統中訪問共享資源就需要一種互斥機制，來防止彼此

淺談分詞算法（1）分詞中的基本問題

最短 hub 好的 說明 可能 漢語 等等 http ring [TOC] 前言 分詞或說切詞是自然語言處理中一個經典且基礎的問題，在平時的工作中也反復的接觸到分詞問題，用到了不同的模型，不同的方法應用在各個領域中，所以想對分詞問題做一個系統的梳理。大多數分詞問題主要是針對

【幹貨】淺談分布式數據庫中間件之分庫分表

-o img 資源 註意 淺談 中間件 water 大數據 分離 分庫分表，顧名思義就是把原本存儲於一個庫的數據分塊存儲到多個庫上，把原本存儲於一個表的數據分塊存儲到多個表上。那麽關於分庫分表，你了解多少呢？接下來，我們將從什麽是數據分片及如何進行分片兩方面對DDM分庫分表

淺談分布式數據庫

base uic 形式 業界 trac 最佳實踐 iam 沒有 繼續 文章集中整理總結mysql分庫分表開源產品，分布式數據庫的設計，以及實際應用案例等相關內容，部分附上本文作者實際應用過程中的理解。 本文感謝sjdbc，mycat，姜承堯，林濤等文章提供的精彩介紹。

淺談分布式消息技術 Kafka

o-c 發送 nginx日誌 發送消息 ack reference 自動 分配 http http://www.linkedkeeper.com/1016.html Kafka的基本介紹 Kafka是最初由Linkedin公司開發，是一個分布式、分區的、多副本的、多訂閱者，

淺談分布式消息技術 Kafka(轉)

2-66 tail 不可 tar 通過 cat cnblogs 內核空間 tro 一只神秘的程序猿。 Kafka的基本介紹 Kafka是最初由Linkedin公司開發，是一個分布式、分區的、多副本的、多訂閱者，基於zoo

c++分塊演算法（暴力資料結構）

快要noip了，該寫些題解攢攢rp了（逃） 看到題解裡那麼多線段樹啊，樹狀陣列啊，本蒟蒻表示：這都是什麼鬼東西？ 在所有高階資料結構中，樹狀陣列是碼量最小的，跑的也基本是最快的，但理解很難，並且支援的操作很少；線段樹的碼量，相信寫過線段樹題的童鞋都親身體驗過這種恐怖（那些3min寫完splay的巨佬不要d

淺談分布式CAP定理

ase 出了 嘗試 這一 ges 技術分享 head 無法 最大 互聯網發展到現在，由於數據量大、操作並發高等問題，大部分網站項目都采用分布式的架構。而分布式系統最大的特點數據分散，在不同網絡節點在某些時刻（數據未同步完，數據丟失），數據會不一致。 在2000年，Eric

淺談 磁碟排程演算法

磁碟排程在多道程式設計的計算機系統中，各個程序可能會不斷提出不同的對磁碟進行讀/寫操作的請求。由於有時候這些程序的傳送請求的速度比磁碟響應的還要快，因此我們有必要為每個磁碟裝置建立一個等待佇列，常用的磁碟排程演算法有以下四種： 先來先服務演算法（FCFS）， 最短尋道

淺談路徑規劃演算法之Dijkstra演算法

 迪傑斯特拉（dijkstra）演算法是典型的用來解決最短路徑的演算法，也是很多教程中的範例，由荷蘭電腦科學家狄克斯特拉於1959年提出，用來求得從起始點到其他所有點最短路徑。該演算法採用了貪心的思想，每次都查詢與該點距離最的點，也因為這樣，它不能用來解決存在負權邊的圖。解