斗殴算法

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);
}
}
}

}

不过建议不要暴力，有针对性会好一点