斗毆演算法

A. 暴力窮舉和回溯法（八皇後問題）

以前每次遇到演算法問題都是直接暴力求解，一直以為自己用的是暴力窮舉法，現在學了回溯法，發現部分問題其實使用的是回溯法，而不是單純的暴力窮舉。

例如求解一個n皇後問題：

1.使用暴力窮舉，由於沒有兩個皇後能夠放在一列上，那麼解向量一定是數1，2，····，n的一個排列（第一行n種放法，第二行n-1種，以此類推）。時間復雜度O(n!).

為什麼是一維而不是兩維？因為沒有兩個皇後能在同一列，所以只用行標志就可以表示出皇後的位置，簡化了問題

2.回溯法，就等於是一個一個的試，從1到n，時間復雜度O(n^n),每一行n種放法，總共n行。

看起來回溯法要比暴力窮舉差很多，但是實際上回溯法很多時候實際演算法復雜度並沒有暴力窮舉高。比如4皇後問題中，僅需要341個可能節點中的27個節點就可以找到解，但是暴力窮舉實際會慢很多。

換一個思路，比如第一個皇後放在了0位置，暴力窮舉第二個皇後放在1位置，那麼之後的皇後無論怎麼放都是錯誤的，也就是(n-2)!個向量全部都是錯誤的，而回溯法面對這種問題，會在之前就直接拋棄這種情況，速度會快很多。不要問為什麼暴力窮舉為什麼不學回溯法那樣提前拋棄，因為它是 暴力窮舉 （這還算優化過一次，不然直接O(n^n)）。

總而言之，回溯法並不需要得到所有情況，而且運行過程中會提前拋棄不合要求的情況，所以演算法復雜度一般不會到最差的情況。

B. 408演算法題暴力解法多少分

408演算法題暴力解法110到120左右。答題標准：

第一部分：單項選擇題部分。

80分選擇題，每題2分，共40題，看重基礎，出題順序是數據結構，組成原理，操作系統，網路，如果408目標130+，選擇題必去嚴格控制錯4個以內，其中數據結構和網路選擇題不能丟分，操作系統和組成原理每年都會有相對超綱的概念題。

第二部分：綜合應用題部分。

最後說數據結構都是演算法題，題源來自LeetCode，一般是LeetCode的改編，這幾年的演算法題都不簡單，相當於PAT乙級前3題難度，如果演算法想拿高分題還是要刷題的，如果不想刷題，暴力解（幾層for循環）也能拿到一半分，刷題是很耗時間的，復習時間緊的建議放棄。

本專業畢業生應獲得以下幾個方面的知識和能力：

1、掌握電子技術和計算機組成與體系結構的基本原理、分析方法和實驗技能，能從事計算機硬體系統開發與設計。

2、掌握程序設計語言、演算法與數據結構、操作系統以及軟體設計方法和工程的基本理論、基本知識與基本技能，具有較強的程序設計能力,能從事系統軟體和大型應用軟體的開發與研製。

3、掌握並行處理、分布式系統、網路與通信、多媒體信息處理、計算機安全、圖形圖象處理以及計算機輔助設計等方面的基本理論、分析方法和工程實踐技能，具有計算機應用和開發的能力。

4、掌握計算機科學的基本理論，具有從事計算機科學研究的堅實基礎。

以上內容參考：網路--408演算法題

C. 什麼叫暴力演算法

當前對於各種加密演算法．除了有針對性的破解演算法，最基本的思想就是窮舉密鑰進行匹配，通常稱為暴力破解演算法。由於暴力破解演算法包含密鑰個數較多，遍歷的時間超過實際可接受的范圍。如果計算速度提高到足夠快。這種遍歷的演算法因結構設計簡便而具有實際應用的前景。

D. C語言暴力

所謂的暴力演算法，就是用窮舉的方法解決問題。
例如，如果讓你驗證一個數num是否為素數，暴力演算法就是窮舉2->num-1的每一個值，然後看這些值有沒有num的因子。當窮舉結束時就可以判斷num是不是素數了。

E. 阿爾法狗採用了暴力窮舉演算法對嗎

阿爾法狗採用了暴力窮舉演算法對。阿爾法狗是人工智慧，阿爾法狗圍棋對弈的人工智慧解讀，阿爾法狗其實也是基於蠻力窮舉的下法，只不過運用新的機器學習方法。窮舉法和機器學習不矛盾。

F. python 井字棋 ALPHA-BETA剪枝演算法和暴力演算法 具體代碼

#!/usr/bin/env python
'''Tic tac toe in python, Minimax with alpha-beta pruning.'''
import sys
import random
import getopt

# Board: array of 9 int, positionally numbered like this:
# 0 1 2
# 3 4 5
# 6 7 8

# Well-known board positions
WINNING_TRIADS = ((0, 1, 2), (3, 4, 5), (6, 7, 8), (0, 3, 6), (1, 4, 7),
(2, 5, 8), (0, 4, 8), (2, 4, 6))
PRINTING_TRIADS = ((0, 1, 2), (3, 4, 5), (6, 7, 8))
# The order in which slots get checked for absence of a player's token:
SLOTS = (0, 1, 2, 3, 4, 5, 6, 7, 8)

# Internal-use values. Chosen so that the "winner" of a finished
# game has an appropriate value, as X minimizes and O maximizes
# the board's value (function board_valuation() defines "value")
# Internally, the computer always plays Os, even though the markers[]
# array can change based on -r command line flag.
X_token = -1
Open_token = 0
O_token = 1

# Strings for output: player's markers, phrase for end-of-game
MARKERS = ['_', 'O', 'X']
END_PHRASE = ('draw', 'win', 'loss')

HUMAN = 1
COMPUTER = 0

def board_valuation(board, player, next_player, alpha, beta):
'''Dynamic and static evaluation of board position.'''
# Static evaluation - value for next_player
wnnr = winner(board)
if wnnr != Open_token:
# Not a draw or a move left: someone won
return wnnr
elif not legal_move_left(board):
# Draw - no moves left
return 0 # Cat
# If flow-of-control gets here, no winner yet, not a draw.
# Check all legal moves for "player"
for move in SLOTS:
if board[move] == Open_token:
board[move] = player
val = board_valuation(board, next_player, player, alpha, beta)
board[move] = Open_token
if player == O_token: # Maximizing player
if val > alpha:
alpha = val
if alpha >= beta:
return beta
else: # X_token player, minimizing
if val < beta:
beta = val
if beta <= alpha:
return alpha
if player == O_token:
retval = alpha
else:
retval = beta
return retval

def print_board(board):
'''Print the board in human-readable format.
Called with current board (array of 9 ints).
'''
for row in PRINTING_TRIADS:
for hole in row:
print MARKERS[board[hole]],
print

def legal_move_left(board):
''' Returns True if a legal move remains, False if not. '''
for slot in SLOTS:
if board[slot] == Open_token:
return True
return False

def winner(board):
''' Returns -1 if X wins, 1 if O wins, 0 for a cat game,
0 for an unfinished game.
Returns the first "win" it finds, so check after each move.
Note that clever choices of X_token, O_token, Open_token
make this work better.
'''
for triad in WINNING_TRIADS:
triad_sum = board[triad[0]] + board[triad[1]] + board[triad[2]]
if triad_sum == 3 or triad_sum == -3:
return board[triad[0]] # Take advantage of "_token" values
return 0

def determine_move(board):
''' Determine Os next move. Check that a legal move remains before calling.
Randomly picks a single move from any group of moves with the same value.
'''
best_val = -2 # 1 less than min of O_token, X_token
my_moves = []
for move in SLOTS:
if board[move] == Open_token:
board[move] = O_token
val = board_valuation(board, X_token, O_token, -2, 2)
board[move] = Open_token
print "My move", move, "causes a", END_PHRASE[val]
if val > best_val:
best_val = val
my_moves = [move]
if val == best_val:
my_moves.append(move)
return random.choice(my_moves)

def recv_human_move(board):
''' Encapsulate human's input reception and validation.
Call with current board configuration. Returns
an int of value 0..8, the Human's move.
'''
looping = True
while looping:
try:
inp = input("Your move: ")
yrmv = int(inp)
if 0 <= yrmv <= 8:
if board[yrmv] == Open_token:
looping = False
else:
print "Spot already filled."
else:
print "Bad move, no donut."

except EOFError:
print
sys.exit(0)
except NameError:
print "Not 0-9, try again."
except SyntaxError:
print "Not 0-9, try again."

if looping:
print_board(board)

return yrmv

def usage(progname):
'''Call with name of program, to explain its usage.'''
print progname + ": Tic Tac Toe in python"
print "Usage:", progname, "[-h] [-c] [-r] [-x] [-X]"
print "Flags:"
print "-x, -X: print this usage message, then exit."
print "-h: human goes first (default)"
print "-c: computer goes first"
print "-r: computer is X, human is O"
print "The computer O and the human plays X by default."

def main():
'''Call without arguments from __main__ context.'''
try:
opts, args = getopt.getopt(sys.argv[1:], "chrxX",
["human", "computer", "help"])
except getopt.GetoptError:
# print help information and exit:
usage(sys.argv[0])
sys.exit(2)

next_move = HUMAN # Human goes first by default

for opt, arg in opts:
if opt == "-h":
next_move = HUMAN
if opt == "-c":
next_move = COMPUTER
if opt == "-r":
MARKERS[-1] = 'O'
MARKERS[1] = 'X'
if opt in ("-x", "-X", "--help"):
usage(sys.argv[0])
sys.exit(1)

# Initial state of board: all open spots.
board = [Open_token, Open_token, Open_token, Open_token, Open_token,
Open_token, Open_token, Open_token, Open_token]

# State machine to decide who goes next, and when the game ends.
# This allows letting computer or human go first.
while legal_move_left(board) and winner(board) == Open_token:
print
print_board(board)

if next_move == HUMAN and legal_move_left(board):
humanmv = recv_human_move(board)
board[humanmv] = X_token
next_move = COMPUTER

if next_move == COMPUTER and legal_move_left(board):
mymv = determine_move(board)
print "I choose", mymv
board[mymv] = O_token
next_move = HUMAN

print_board(board)
# Final board state/winner and congratulatory output.
try:
# "You won" should never appear on output: the program
# should always at least draw.
print ["Cat got the game", "I won", "You won"][winner(board)]
except IndexError:
print "Really bad error, winner is", winner(board)

sys.exit(0)
#-------
if __name__ == '__main__':
try:
main()
except KeyboardInterrupt:
print
sys.exit(1)

G. 什麼叫暴力演算法

暴力演算法：利用枚舉所有的情況，或者其它大量運算又不用技巧的方式，來求解問題的方法。廣義的暴力法在解決問題，特別是數學和計算機編程問題方面應用廣泛，有著巨大的作用。它的缺點是效率低下，優點是編碼復雜度低，幾乎不用思考，不容易出錯。狹義的暴力法：這是一種簡單的串匹配演算法，用來判斷一個短串t是不是一個長串s的子串。

H. 暴力窮舉法是什麼意思

暴力窮舉法就是充分利用算機的高性能。把一件事情的所有可能性全部羅列出來的一種演算法。之所以成為暴力，就是把所有的情況不考慮技巧，不考慮策略 全部一一列舉出來。

I. 藍橋杯上的一題，題目為排列數，用了暴力演算法超時，請問該怎麼處理，謝謝！

不用擔心的，看看別人是怎麼學習單片機的，加油。 最近論壇上發了一個連載帖子——吳鑒鷹單片機實戰項目精講，因此受到不少網友的關注，在這里吳鑒謝謝各位網友的支持、關心和信任。 在帖子中留了幾個群號，有兩千多讀者加了群，通過QQ向我詢問了很多問題，如果在工作不是太忙的時候我看到了就會回答，但是有時候做項目太忙就沒時間解答。 為此，在這里應群內成員以及一些網友的要求，專門寫一篇文章來針對這些問題做一個總結。希望能為大家的疑惑有一點點幫助就足以。不足之處，也希望大家客觀指出，君子和而不同。 1、學習單片機有用嗎？ 有很多初學者有這樣的困惑，單片機初學者感覺入門很難，學著學著，就會產生這樣的疑問——自己辛辛苦苦學習單片機，將來有用嗎？ 單片機只是一個工具，重要的還是思想，有了自己的想法，電子行業地域遼闊，隨便你闖。單片機這個切入點入手還是不錯的，可以讓你盡快進入電子殿堂的大門，如果你還在上學，不要眼睛裡面只盯著暫時的薪水，哪怕是畢業兩三年的也一樣。重要的是掌握程度和對技術的理解程度，有句話叫「水到渠成」，到時候再去研究工資的事情也不晚。 2、學習嵌入式編程有必要從51單片機開始嗎？ 我原本來在讀大學的時候，有很多同學聽說學習ARM很牛逼，於是就跑到圖書館借了一兩本關於ARM的書，學一兩天後發現跟自己想的不太像，於是學著學著就慢慢放棄了。所以我總結一下，與其邁很大的步子，不如放慢腳步一步步走。從最基本的做起，一步步走，等單片機學會之後再進行像ARM，DSP之類高端處理器的運用，也就能得心應手了，如果想一口吃成一個胖子，只怕最後沒胖起來，倒把自己給噎死了！ 3、會用高端處理器就牛了嗎？ 不少網友問我：是不是學會了ARM、嵌入式操作系統就會很牛？是不是單片機就是運用在低檔產品上，ARM做出來的產品就高端了。 首先，從本質上說，是同一類東西，都是嵌入式應用方面的主力。十八般兵器，沒有優劣之分，只是在乎持兵器的人修為高低，當年解放軍憑借小米加步槍不也取得了抗戰勝利。 微處理器，單片機、DSP、FPGA、ARM，每一種都有自己的側重點，都具備自己的優勢和劣勢。 單片機：技術比較成熟，運用在工控領域比較多，但進行嵌入式應用顯得太龐大，因而派生出ARM單片機進行高端應用，可以進行操作系統的移植，但是現在一些高端單片機也可以移植操作系統，單片機跟ARM並沒有什麼本質的區別。 DSP：是數據處理的縮寫。也可以做控制運用，它的優勢是運算，主要用在運算量大的領域，如數字信號處理，圖像處理，視屏處理，導彈雷達上也等等。如果要用的好，需要學會很多高深的演算法，需要有較強的數學功底。 FPGA：可編程邏輯陣列的縮寫。實際上就是做一個晶元，用軟體實現它的內部連接，達到用軟體的方法實現硬體的目標。是用硬體實現的一種方法。是早期單片機（功能簡單的邏輯應用）的現代實現方法。 總結：一個嵌入式軟體工程師，其實核心競爭力不是你會運用什麼晶元，當你會了一兩種以後，再學其他的，就會覺得很容易了。一個真正的有競爭力的工程師，應該是具備良好的編程習慣，編程思路，還應該具備扎實的數學功底。只有把握核心的東西，才能走的更遠。 4、單片機行業技術研發有前途嗎？ 這也是初學者最為關心的一個話題，單片機行業的技術研發將來前途如何？ 著名的高爾夫球手，老虎伍茲說過一句話：我只需成為高爾夫數一數二的高手,錢自然會追著我來。 單片機技術研發，也就是一個類型的職業崗位，同樣叫做「單片機工程師」，能力、經驗、學歷，參差不齊，因此待遇肯定也不盡相同。 高待遇者，年薪數百萬也有，低收入者，養家糊口都難。 只有倒閉的企業，沒有倒閉的行業！ 不是行業沒有前景，只能反思自己為何沒有足夠的優秀。 5、單片機技術研發太苦太累，值得去堅持嗎？ 在論壇里看到很多人在抱怨：現在電子行業的研發做起來太累，待遇又不是很好，感覺沒什麼出路。 既然我們選擇了單片機行業，就堅持做下去，不要輕信別人講的：單片機研發工程師沒有前途，太苦太累。 學好單片機你至少可以找一份技術性的工作，就算目前累一點，至少你可以看到希望，隨著自己經驗的積累，未來的路會越走越寬！至少可以坐在辦公室裡面，有自由的時間可以支配。 你知道那種專業課沒學好，只能去車間做一線工人的感覺嗎？坐在車間里像一個機器人一樣每天重復同樣的工作嗎？你喜歡過那種一點自由都沒有，在流水線上忙碌著，連上廁所時間都沒有的工作嗎？我相信沒有人喜歡！ 所有不要被一些工作了幾年的工程師的話語所迷惑，說做技術很苦，拿的錢又少，當你真正有一天想去做技術，發現原來因為自己缺少知識的積累，沒有公司願意要你。 簡單地分享了自己對單片機領域一些問題的看法，歡迎同行積極分享自己的心得，能讓更多初學者少走彎路，擺正心態進行單片機的學習。

J. 求大神幫忙寫一個暴力破解演算法，c或Java都行，密碼由數字和字母組成，最大密碼長度10位最小一位

import org.junit.Test;

public class T {

//最小長度
private int min = 1;
//最大長度
private int max = 10;
//准備數字，大小寫
private char[] psw = {'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};

@Test
public void t(){
for(int i=min; i<=max; i++){
permutation(psw, i);
}
}

/**
* 全排列入口
* @param array 密碼數據
* @param n 密碼長度
*/
private void permutation(char[] array, int n) {
permutation("", array, n);
}

/**
*
* @param s 已生成臨時字串
* @param array 密碼數據
* @param n 剩餘未生成的字元長度
*/
private void permutation(String s, char[] array, int n) {
if(n == 1) {
for(int i=0; i<array.length; i++) {
//這是密碼結果
String result = s+array[i];
System.out.println(result);
}
} else {
for(int i=0; i<array.length; i++) {
permutation(s+array[i], array, n-1);
}
}
}

}

不過建議不要暴力，有針對性會好一點