做分布式優化演算法的大牛知乎

A. 什麼地方要用到分布式資料庫 知乎

設計分布式資料庫時，應特別考慮如下幾個方面的問題：1. 數據保存 (存儲分段/復制，橫向/縱向表分區);2. 目錄管理(catalog management): 命名，數據獨立性3. 查詢處理(基於代價的調優， 半合並)4. 數據更新(同步/非同步)

B. 什麼是 分布式梯度跟蹤優化

一種基於隨機梯度追蹤技術的大數據二分類分布式優化方法，具體步驟為：設定二分類問題，獲取訓練樣本數據、測試樣本數據、樣本特徵；採用one‑hot編碼將訓練樣本數據和測試樣本數據擴展成向量數據，得到訓練樣本向量數據和測試樣本向量數據；將訓練樣本向量數據進行智能體分配，結合梯度跟蹤策略與隨機平均梯度策略，建立帶未知參數的分布式隨機梯度跟蹤策略S‑DIGing的問題模型；求解未知參數；將測試樣本向量數據代入分布式隨機梯度跟蹤策略S‑DIGing的問題模型中進行二分類驗證，並輸出所述二分類問題對應的分布式隨機梯度跟蹤策略S‑DIGing的問題模型。極大降低了策略的復雜度和計算量，從而使S‑DIGing策略能夠很好地處理大規模問題。響優化演算法的收斂速度的問題，提出一種時延情形下的分布式Push-sum次梯度優化演算法，該方法在權矩陣不具有正對角線元素時仍適用，並應用系統擴維的方法將有時延優化問題轉化為無時延優化問題。在時延和次梯度有界且有向切換網路周期強連通的條件下，證明了所提出的分布式Push-sum次梯度優化演算法的收斂性。研究表明：存在通信時延時的演算法收斂速度比無時延時的收斂速度要慢，並具有較大的收斂誤差。最後，通過數值模擬驗證了研究的結論。

C. 知乎發布的分布式日誌系統 Kids 意義在於哪裡

「當然，在這之前，我們考察了一些項目，如scribe，但是這個貨依賴thrift，且沒有實時訂閱功能，另外對scribe的xml風格的配置文件表示難以理解:-(。redis有發布/訂閱功能，但是沒有存儲。其他諸如kafka，flume等項目基本都是基於java的，且較重，不合我們的口味。於是我們決定自己寫一個支持訂閱的scribe，同時實現scribe的分布式收集日誌，和redis的發布/訂閱功能。」

D. 知乎上有哪些 Android 開發的大牛

其實總有那麼一些大牛因為表現的不怎麼活躍而漸漸的消失在人們的視野里。

比如

@范懷宇@Oasis Feng

史岩 http://www.hu.com/people/shiyan

彭鵬 http://www.hu.com/people/peng-peng-98

鄧鋆 http://www.hu.com/people/tdzl2003

林俊琦 http://www.hu.com/people/lin-jun-qi

沙舟 http://www.hu.com/people/sha-zhou

許飛：http://www.hu.com/people/yadizzz

鄒宇：http://www.hu.com/people/zouyu

范懷宇：http://www.hu.com/people/guguiyu

Holly Lee：http://www.hu.com/people/holly-lee

梁泉：http://www.hu.com/people/liangquan

billycui: http://www.hu.com/people/billycui

朱勤斯 http://www.hu.com/people/zhu-qin-si

以上這些都全是知乎上的牛人了吧，和自己對那些大能表示一些個人的見解。

E. 知乎上有哪些比較活躍的資料庫領域大牛

阿里雲資料庫團隊比較熟，隨手梳理了以下

丁奇：MySQL社區核心成員。專注於數據存儲系統、MySQL 源碼研究和改進、MySQL 性能優化和功能改進。

子嘉：Redis中國用戶會發起人，Redis技術大學校長

葉翔：MongoDB江浙地區用戶會主席
在此之前也是淘寶Tair分布式KV系統的技術負責人，負責過阿里雲Memcache，Redis服務等，在阿里集團工作8年，一直在做NoSQL相關的技術。

德歌：阿里雲 PostgreSQL技術負責人，PostgreSQL中國技術大學校長、GreenPlum源碼深度研究者

彭立勛：參與了ACMUG（MySQL中國用戶組）的發起和組建，擔任副主席和杭州地區的組織者。MariaDB基金會唯一的中國成員

蕭少聰：PostgreSQL 中國社區主席

F. 分布式資料庫的查詢優化

指在執行分布式查詢時選擇查詢執行計劃的方法和關系運算符的實現演算法。根據系統環境的不同，查詢優化所使用的演算法也有所不同，通常分為遠程廣域網環境和高速區域網環境，其區別主要在網路的帶寬。對於一元運算符可以採用集中式資料庫中的查詢優化方法。而對於二元運算符，由於涉及場地間的數據傳輸，因此必須考慮通信代價。分布式查詢中常見的連接運算執行策略包括：
（1）半連接方法：利用半連接運算的轉換方法R∞S=（RµS）∞S。假設場地1和場地2上分別有關系R和關系S，首先在S上執行連接屬性上的投影並將結果傳輸至場地1，在場地1上執行關系R與投影的連接操作，再將結果傳輸至場地2與關系S執行連接操作。這種方法能夠降低執行連接運算時的網路通信代價，主要適用於帶寬較低的遠程廣域網路。
（2）枚舉法方法：指枚舉關系運算符的物理執行計劃，通過對比執行計劃的代價選擇執行演算法的方法。其中，連接運算符的物理執行計劃包括嵌套循環方法、哈希連接法和歸並連接法。枚舉法主要適用於以磁碟IO代價為主的高速區域網環境。

G. 知乎有哪些大牛

知乎是一個真實的網路問答社區，社區氛圍友好與理性，連接各行各業的精英。用戶分享著彼此的專業知識、經驗和見解，為中文互聯網源源不斷地提供高質量的信息。

---

首先我們來看下大牛的解釋吧

大牛可不是說牛很大的意思哦，大牛是一個最近漸漸流行起來的一個網路用語，指在某個領域很突出的優秀人物，詞語與「牛人」同義，也指極少數能力超過常人的人」或「在某個領域非常有影響力的人。指某一方面或領域中的優秀者，被稱為大牛。

我眼中的大牛就是—— 了解人性的一切丑與惡，但一直保持內心純凈善良，不被浮躁骯臟的世界污染的人。 值得慶幸的是，我周圍有好多這樣的人，我以他們為榮。

H. 除了梯度下降 還有什麼優化演算法 深度學習 知乎

這要說梯度的意義了。梯度是一個向量，對應方向導數取得最大值的方向，也就是函數增長最快的方向，梯度的反向，就是函數下降最快的方向。要求最小值，自然可以用梯度下降法來求。

I. 那位大牛講一下8皇後的優化

八皇後問題是一個古老而著名的問題，是回溯演算法的典型例題。該問題是十九世紀著名的數學家高斯1850年提出：在8X8格的國際象棋上擺放八個皇後，使其不能互相攻擊，即任意兩個皇後都不能處於同一行、同一列或同一斜線上，問有多少種擺法。
高斯認為有76種方案。1854年在柏林的象棋雜志上不同的作者發表了40種不同的解，後來有人用圖論的方法解出92種結果。
對於八皇後問題的實現，如果結合動態的圖形演示，則可以使演算法的描述更形象、更生動，使教學能產生良好的效果。下面是用Turbo C實現的八皇後問題的圖形程序，能夠演示全部的92組解。八皇後問題動態圖形的實現，主要應解決以下兩個問題。
（1）回溯演算法的實現
（a）為解決這個問題，我們把棋盤的橫坐標定為i，縱坐標定為j,i和j的取值范圍是從1到8。當某個皇後佔了位置(i,j)時，在這個位置的垂直方向、水平方向和斜線方向都不能再放其它皇後了。用語句實現，可定義如下三個整型數組：a[8],b[15],c[24]。其中：
a[j-1]=1 第j列上無皇後
a[j-1]=0 第j列上有皇後
b[i+j-2]=1 (i,j)的對角線（左上至右下）無皇後
b[i+j-2]=0 (i,j)的對角線（左上至右下）有皇後
c[i-j+7]=1 (i,j)的對角線（右上至左下）無皇後
c[i-j+7]=0 (i,j)的對角線（右上至左下）有皇後
（b）為第i個皇後選擇位置的演算法如下：
for(j=1;j<=8;j++) /*第i個皇後在第j行*/
if ((i,j)位置為空)） /*即相應的三個數組的對應元素值為1*/
{佔用位置（i,j） /*置相應的三個數組對應的元素值為0*/
if i<8
為i+1個皇後選擇合適的位置；
else 輸出一個解
}
(2)圖形存取
在Turbo C語言中，圖形的存取可用如下標准函數實現：
size=imagesize(x1,y1,x2,y2) ;返回存儲區域所需位元組數。
arrow=malloc(size);建立指定大小的動態區域點陣圖，並設定一指針arrow。
getimage(x1,y1,x2,y2,arrow);將指定區域點陣圖存於一緩沖區。
putimage(x,y,arrow,)將點陣圖置於屏幕上以（x，y）左上角的區域。
(3)程序清單如下
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <dos.h>
char n[3]={'0','0'};/*用於記錄第幾組解*/
int a[8],b[15],c[24],i;
int h[8]={127,177,227,277,327,377,427,477};/*每個皇後的行坐標*/
int l[8]={252,217,182,147,112,77,42,7}; /*每個皇後的列坐標*/
void *arrow;
void try(int i)
{int j;
for (j=1;j<=8;j++)
if (a[j-1]+b[i+j-2]+c[i-j+7]==3) /*如果第i列第j行為空*/
{a[j-1]=0;b[i+j-2]=0;c[i-j+7]=0;/*佔用第i列第j行*/
putimage(h[i-1],l[j-1],arrow,COPY_PUT);/*顯示皇後圖形*/
delay(500);/*延時*/
if(i<8) try(i+1);
else /*輸出一組解*/
{n[1]++;if (n[1]>'9') {n[0]++;n[1]='0';}
bar(260,300,390,340);/*顯示第n組解*/
outtextxy(275,300,n);
delay(3000);
}
a[j-1]=1;b[i+j-2]=1;c[i-j+7]=1;
putimage(h[i-1],l[j-1],arrow,XOR_PUT);/*消去皇後，繼續尋找下一組解*/
delay(500);
}}
int main(void)
{int gdrive=DETECT,gmode,errorcode;
unsigned int size;
initgraph(&gdrive,&gmode,"");
errorcode=graphresult();
if (errorcode!=grOk)
{printf("Graphics error\n");exit(1);}
rectangle(50,5,100,40);
rectangle(60,25,90,33);
/* 畫皇冠 */
line(60,28,90,28);line(60,25,55,15);
line(55,15,68,25);line(68,25,68,10);
line(68,10,75,25);line(75,25,82,10);
line(82,10,82,25);line(82,25,95,15);
line(95,15,90,25);
size=imagesize(52,7,98,38); arrow=malloc(size);
getimage(52,7,98,38,arrow); /* 把皇冠保存到緩沖區 */
clearviewport();
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 4);
setusercharsize(3, 1, 1, 1);
setfillstyle(1,4);
for (i=0;i<=7;i++) a=1;
for (i=0;i<=14;i++) b=1;
for (i=0;i<=23;i++) c=1;
for (i=0;i<=8;i++) line(125,i*35+5,525,i*35+5); /* 畫棋盤 */
for (i=0;i<=8;i++) line(125+i*50,5,125+i*50,285);
try(1); /* 調用遞歸函數 */
delay(3000);
closegraph();
free(arrow);
}
二、循環實現 Java

/*
* 8皇後問題：
*
* 問題描述：
* 在一個8×8的棋盤里放置8個皇後，要求每個皇後兩兩之間不相沖突
*（在每一橫列，豎列，斜列只有一個皇後）。
*
* 數據表示：
* 用一個 8 位的 8 進制數表示棋盤上皇後的位置：
* 比如：45615353 表示：
* 第0列皇後在第4個位置
* 第1列皇後在第5個位置
* 第2列皇後在第6個位置
* 。。。
* 第7列皇後在第3個位置
*
* 循環變數從 00000000 加到 77777777 （8進制數）的過程，就遍歷了皇後所有的情況
* 程序中用八進制數用一個一維數組 data[] 表示
*
* 檢測沖突：
* 橫列沖突：data == data[j]
* 斜列沖突：(data+i) == (data[j]+j) 或者 (data-i) == (data[j]-j)
*
* 好處：
* 採用循環，而不是遞規，系統資源佔有少
* 可計算 n 皇後問題
* 把問題線性化處理，可以把問題分塊，在分布式環境下用多台計算機一起算。
*
* ToDo：
* 枚舉部分還可以進行優化，多加些判斷條件速度可以更快。
* 輸出部分可以修改成棋盤形式的輸出
*
* @author cinc 2002-09-11
*
*/

public class Queen {
int size;
int resultCount;

public void compute ( int size ) {
this.size = size;
resultCount = 0;
int data[] = new int[size];
int count; // 所有可能的情況個數
int i,j;

// 計算所有可能的情況的個數
count = 1;
for ( i=0 ; i<size ; i++ ) {
count = count * size;
}
// 對每一個可能的情況
for ( i=0 ; i<count ; i++ ) {
// 計算這種情況下的棋盤上皇後的擺放位置，用 8 進制數表示
// 此處可優化
int temp = i;
for ( j=0 ; j<size ; j++ ) {
data [j] = temp % size;
temp = temp / size;
}
// 測試這種情況是否可行，如果可以，輸出
if ( test(data) )
output( data );
}
}

/*
* 測試這種情況皇後的排列是否可行
*
*/
public boolean test( int[] data ) {
int i,j;
for ( i=0 ; i<size ; i++ ) {
for ( j=i+1 ; j<size ; j++ ) {
// 測試是否在同一排
if ( data == data[j] )
return false;
// 測試是否在一斜線
if ( (data+i) == (data[j]+j) )
return false;
// 測試是否在一反斜線
if ( (data-i) == (data[j]-j) )
return false;
}
}
return true;
}

/*
* 輸出某種情況下皇後的坐標
*
*/
public void output ( int[] data ) {
int i;
System.out.print ( ++resultCount + ": " );
for ( i=0 ; i<size ; i++ ) {
System.out.print ( "(" + i + "," + data + ") " );
}
System.out.println ();
}
public static void main(String args[]) {
(new Queen()).compute( 8 );
}
}
三、八皇後問題的Qbasic版的解決方案

10 I = 1

20 A(I) = 1

30 G = 1

40 FOR K = I - 1 TO 1 STEP -1

50 IF A(I) = A(K) THEN 70

60 IF ABS(A(I) - A(K)) <> I - K THEN 90

70 G = 0

80 GOTO 100

90 NEXT K

100 IF I <> 8 THEN 180

110 IF G = 0 THEN 180

120 FOR L = 1 TO 8

130 PRINT USING 「##」; A(L);

140 NEXT L

150 PRINT 「*」;

160 M = M + 1

170 IF M MOD 3 = 0 THEN PRINT

180 IF G = 0 THEN 230

190 IF I = 8 THEN 230

200 I = I + 1

210 A(I) = 1

220 GOTO 30

230 IF A(I) < 8 THEN 270

240 I = I - 1

250 IF I = 0 THEN 290

260 GOTO 230

270 A(I) = A(I) + 1

280 GOTO 30

290 PRINT

300 PRINT 「SUM=」; USING 「##」; M;

310 PRINT

320 END
四、八皇後問題的高效解法-遞歸版

//8 Queen 遞歸演算法
//如果有一個Q 為 chess=j;
//則不安全的地方是 k行 j位置,j+k-i位置,j-k+i位置

class Queen8{

static final int QueenMax = 8;
static int oktimes = 0;
static int chess[] = new int[QueenMax];//每一個Queen的放置位置

public static void main(String args[]){
for (int i=0;i<QueenMax;i++)chess=-1;
placequeen(0);
System.out.println("\n\n\n八皇後共有"+oktimes+"個解法 made by yifi 2003");
}

public static void placequeen(int num){ //num 為現在要放置的行數
int i=0;
boolean qsave[] = new boolean[QueenMax];
for(;i<QueenMax;i++) qsave=true;

//下面先把安全位數組完成
i=0;//i 是現在要檢查的數組值
while (i<num){
qsave[chess]=false;
int k=num-i;
if ( (chess+k >= 0) && (chess+k < QueenMax) ) qsave[chess+k]=false;
if ( (chess-k >= 0) && (chess-k < QueenMax) ) qsave[chess-k]=false;
i++;
}
//下面歷遍安全位
for(i=0;i<QueenMax;i++){
if (qsave==false)continue;
if (num<QueenMax-1){
chess[num]=i;
placequeen(num+1);
}
else{ //num is last one
chess[num]=i;
oktimes++;
System.out.println("這是第"+oktimes+"個解法 如下:");
System.out.println("第n行: 1 2 3 4 5 6 7 8");

for (i=0;i<QueenMax;i++){
String row="第"+(i+1)+"行: ";
if (chess==0);
else
for(int j=0;j<chess;j++) row+="--";
row+="++";
int j = chess;
while(j<QueenMax-1){row+="--";j++;}
System.out.println(row);
}
}
}
//歷遍完成就停止
}

}

五、java實現//8 Queen 遞歸演算法

//如果有一個Q 為 chess=j;
//則不安全的地方是 k行 j位置,j+k-i位置,j-k+i位置
class Queen8{

static final int QueenMax = 8;
static int oktimes = 0;
static int chess[] = new int[QueenMax];//每一個Queen的放置位置

public static void main(String args[]){
for (int i=0;i<QueenMax;i++)chess=-1;
placequeen(0);
System.out.println("\n\n\n八皇後共有"+oktimes+"個解法 made by yifi 2003");
}

public static void placequeen(int num){ //num 為現在要放置的行數
int i=0;
boolean qsave[] = new boolean[QueenMax];
for(;i<QueenMax;i++) qsave=true;

//下面先把安全位數組完成
i=0;//i 是現在要檢查的數組值
while (i<num){
qsave[chess]=false;
int k=num-i;
if ( (chess+k >= 0) && (chess+k < QueenMax) ) qsave[chess+k]=false;
if ( (chess-k >= 0) && (chess-k < QueenMax) ) qsave[chess-k]=false;
i++;
}
//下面歷遍安全位
for(i=0;i<QueenMax;i++){
if (qsave==false)continue;
if (num<QueenMax-1){
chess[num]=i;
placequeen(num+1);
}
else{ //num is last one
chess[num]=i;
oktimes++;
System.out.println("這是第"+oktimes+"個解法 如下:");
System.out.println("第n行: 1 2 3 4 5 6 7 8");

for (i=0;i<QueenMax;i++){
String row="第"+(i+1)+"行: ";
if (chess==0);
else
for(int j=0;j<chess;j++) row+="--";
row+="++";
int j = chess;
while(j<QueenMax-1){row+="--";j++;}
System.out.println(row);
}
}
}
//歷遍完成就停止
}
}

六、c＃實現

採用的思路大致是這樣：
將一個皇後向下移動一個位置；
如果沒有成功移動（超出邊界），失敗；
如果成功移動，則判斷當前位置是否可用？如果不可用，則重做 1；
繼續給下一個皇後安排位置。
結束條件：
如果第一個皇後的所有位置都嘗試完畢仍然沒有可用的解決方案或者最後一個皇後已經安排完畢。
代碼如下：
1// AppEntry.cs
2using System;
3
4namespace Chenglin
5{
6 class AppEntry
7 {
8 static void Main(string[] args)
9 {
10 int queenNumber = 8;
11 QueenRowCollection q = new QueenRowCollection(queenNumber);
12
13 bool flag;
14 DateTime timeStarted = DateTime.Now;
15 flag = q.PositionQueens();
16 TimeSpan ts = DateTime.Now.Subtract( timeStarted );
17
18
19 if( flag ) {
20 Console.WriteLine( q.ToString() );
21 }
22 else {
23 Console.WriteLine( "Failed" );
24 }
25
26 Console.WriteLine( " seconds has been elapsed.", ts.TotalSeconds );
27 }
28 }
29} 1// QueenRowCollection.cs
2using System;
3using System.Text;
4
5namespace Chenglin
6{
7 public class QueenRowCollection
8 {
9
10 public QueenRowCollection( int numberOfQueens ){
11 this.numberOfQueens = numberOfQueens;
12 this.rows = new QueenRow[ numberOfQueens ];
13
14 for( int i=0;i<numberOfQueens;i++ ){
15 rows = new QueenRow( numberOfQueens );
16 }
17 }
18
19 public bool PositionQueens()
20 {
21 return PositionQueen( 0 );
22 }
23
24 private bool PositionQueen( int row )
25 {
26 if( row>=this.numberOfQueens ) {
27 return true;
28 }
29
30 QueenRow q = rows[row];
31 while( q.MoveNext() )
32 {
33 if( PositionAvailable( row, q.CurrentPosition ) ) {
34 // An available position has been found for the current queen,
35 // and try to find a proper position for the next queen.
36 //
37 // If no available position can be found for the next queen,
38 // the current queen should move to the next position and try again.
39 //
40 if( PositionQueen( row+1 ) )
41 {
42 // Both the current queen and the next queen
43 // have found available positions.
44 //
45 return true;
46 }
47 }
48 }
49
50 // No position is available for the current queen,
51 //
52 return false;
53 }
54
55 private bool PositionAvailable( int row, int column ){
56 for( int i=row-1; i>=0; i-- )
57 {
58 if( rows.PositionOccupied( column ) )
59 return false;
60
61 if( rows.PositionOccupied( column-(i-row) ) )
62 return false;
63
64 if( rows.PositionOccupied( column+(i-row) ) )
65 return false;
66 }
67
68 return true;
69 }
70
71 public override string ToString()
72 {
73 StringBuilder s = new StringBuilder();
74
75 foreach( QueenRow q in rows ){
76 s.AppendFormat( "", q, Environment.NewLine );
77 }
78
79 return s.ToString();
80 }
81
82 private int numberOfQueens;
83 private QueenRow [] rows;
84 }
85} 1// QueenRow.cs
2using System;
3using System.Text;
4
5namespace Chenglin
6{
7 public class QueenRow
8 {
9 public QueenRow( int numberOfPositions )
10 {
11 this.numberOfPositions = numberOfPositions;
12 this.currentPosition = -1;
13 this.columns = new bool[ numberOfPositions ];
14 }
15
16 public bool MoveNext(){
17 if( currentPosition>=0 && currentPosition<this.numberOfPositions ){
18 columns[currentPosition] = false;
19 }
20
21 if( currentPosition<this.numberOfPositions-1){
22 currentPosition ++;
23 columns[currentPosition] = true;
24 return true;
25 }
26 else {
27 currentPosition = -1;
28 return false;
29 }
30 }
31
32 public bool PositionOccupied( int column ){
33 if( column<0 || column>=numberOfPositions ){
34 return false;
35 }
36
37 return columns[column];
38 }
39
40 public override string ToString()
41 {
42 StringBuilder s = new StringBuilder();
43
44 foreach( bool b in columns ){
45 s.AppendFormat( " ", (b ? "*" : "-") );
46 }
47
48 return s.ToString();
49 }
50
51 public int CurrentPosition
52 {
53 get { return currentPosition; }
54 }
55
56 private int currentPosition;
57 private int numberOfPositions;
58 private bool [] columns;
59 }
60}

程序運行的時候，當皇後個數增加的時候，運行的時間也會急劇增加！下面這副圖表示了皇後個數與運行時間的大致關系：

J. 分布式資料庫查詢優化寫這個論文的話有推薦的書嗎

Distributed Algorithms An Intuitive Approach.
一個小節的內容就一篇論文至少。作者概括了下演算法細節和給了相關舉例。有人評價很高，我評價一般，結合具體論文看會效果好，不過略吃力，然而直接看也略吃力，因為作者太高度概括，不好理解，沒有大部分原文教材那種怕你不懂的啰嗦的特點。所以書也就挺薄的，才200多頁而已。

Distributed Systems concepts and design.
基本上分布式系統的各基本細節都涵蓋了。系統級別書籍，略硬，算厚。這本我也還在磕。

Introction to Distributed Algorithms second edition.
這本是祖師爺級別的經典教材。不過我還沒讀過，評價略高，某些美帝高校課堂參考教材就是這本。沒有讀是因為網上的pdf都沒有索引，所以先讀上一本了。

Distributed Computing Principle, Algorithms, and Systems.
第一本算師父帶入門，對分布式演算法有大致框架和了解的話。這本可以有助於理解得更深。所以建議先讀第一本，再這本。

Principles of Distributed Database Systems.
這本是我唯一在America Amazon找到的關於分布式資料庫並且評價較高的教材。不過這本還沒排上讓我讀的行程，不知內容如何。