题目描述
排列与组合是常用的数学方法。 先给一个正整数 ( 1 < = n < = 10 ) 。例如n＝3，所有组合,并且按字典序输出：
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
输入
输入一个整数n( 1<=n<=10)
输出
输出所有全排列
每个全排列一行，相邻两个数用空格隔开（最后一个数后面没有空格）
代码
global n
num=[]
vis=[]
def DFS(x):
if x==n:
for i in range(n-1):
print(str(num[i]),end=' ')
print(num[n-1])
return
for i in range(n):
if vis[i]==0:
vis[i]=1
num[x]=i+1
DFS(x+1)
vis[i]=0
if __name__=="__main__":
n=int(input())
vis=[0]*n
num=[0]*n
DFS(0)
题目描述
排列与组合是常用的数学方法，其中组合就是从n个元素中抽出r个元素(不分顺序且r < ＝ n)，我们可以简单地将n个元素理解为自然数1，2，…，n，从中任取r个数。
现要求你不用递归的方法输出所有组合。
例如n ＝ 5 ，r ＝ 3 ，所有组合为：
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 3 5
2 4 5
3 4 5
输入
一行两个自然数n、r ( 1 < n < 21，1 < ＝ r < ＝ n )。
输出
所有的组合，每一个组合占一行且其中的元素按由小到大的顺序排列，所有的组合也按字典顺序。
global n,r
com=[]
vis=[]
def DFS(cur,count):
if count==r:
com.sort()
for i in range(r-1):
print(com[i],end=' ')
print(com[r-1])
return
for i in range(com[count-1],n):
if vis[i]==0:
vis[i]=1
com[count]=i+1
DFS(cur+1,count+1)
vis[i]=0
if __name__=="__main__":
n,r=str(input()).split(' ')
n=int(n)
r=int(r)
com=[0]*r
vis=[0]*n
DFS(0,0)
题目描述
已知 n 个整数b1,b2,…,bn
以及一个整数 k（k＜n）。
从 n 个整数中任选 k 个整数相加，可分别得到一系列的和。
例如当 n=4，k＝3，4 个整数分别为 3，7，12，19 时，可得全部的组合与它们的和为：
3＋7＋12=22 3＋7＋19＝29 7＋12＋19＝38 3＋12＋19＝34。
现在，要求你计算出和为素数共有多少种。
例如上例，只有一种的和为素数：3＋7＋19＝29。
输入
第一行两个整数：n , k （1<=n<=20，k＜n）
第二行n个整数：x1,x2，…,xn （1<=xi<=5000000）
输出
一个整数（满足条件的方案数）。
nums=[]
vis=[]
global n,k,count
def isprime(x):
if x<=1:
return False
for i in range(2,x):
if x%i==0:
return False
return True
def DFS(s,curnum,cur):
global n,k,count
if curnum==k and isprime(s):
count=count+1
print(s)
return
for i in range(cur,n):
if vis[i]==0:
vis[i]=1
DFS(s+nums[i],curnum+1,i+1)
vis[i]=0
if __name__=="__main__":
global n,k,count
n,k=str(input()).split(' ')
n=int(n)
k=int(k)
count=0
vis=[0]*n
nums=str(input()).split(' ')
for i in range(n):
nums[i]=int(nums[i])
DFS(0,0,0)
print(count)
题目描述
会下国际象棋的人都很清楚：皇后可以在横、竖、斜线上不限步数地吃掉其他棋子。如何将8个皇后放在棋盘上（有8 * 8个方格），使它们谁也不能被吃掉！这就是著名的八皇后问题。
输入
一个整数n（ 1 < = n < = 10 )
输出
每行输出对应一种方案，按字典序输出所有方案。每种方案顺序输出皇后所在的列号，相邻两数之间用空格隔开。如果一组可行方案都没有，输出“no solute!”
global n,count
chess=[]
vis=[]
def isok(row,col):
for i in range(row):
if row-col==i-chess[i] or row+col==i+chess[i] or col==chess[i]:
return False
return True
def DFS(row):
global n,count
if row==n:
count=count+1
for i in range(n-1):
print(chess[i]+1,end=' ')
print(chess[n-1]+1)
return
for i in range(n):
if vis[i]==0 and isok(row,i):
vis[i]=1
chess[row]=i
DFS(row+1)
vis[i]=0
if __name__=="__main__":
global n,count
n=int(input())
chess=[0]*n
vis=[0]*n
DFS(0)
if count==0:
print("no solute!")
题目描述
栈是常用的一种数据结构，有n令元素在栈顶端一侧等待进栈，栈顶端另一侧是出栈序列。你已经知道栈的操作有两•种：push和pop，前者是将一个元素进栈，后者是将栈顶元素弹出。现在要使用这两种操作，由一个操作序列可以得到一系列的输出序列。请你编程求出对于给定的n，计算并输出由操作数序列1，2，…，n，经过一系列操作可能得到的输出序列总数。
输入
一个整数n（1<=n<=15）
输出
一个整数，即可能输出序列的总数目。
统计代码：
int t;
int n;
void DFS(int num,int x,int y){
if(y==n){
t++;
return;
}
if(num>0) DFS(num-1,x+1,y); //先进栈操作（限制个数），
if(x>0) DFS(num,x-1,y+1); //当栈内有元素是吗，才可判断是否出栈或者留栈，即不操作。
}
int main()
{
cin>>n;
DFS(n,0,0);
cout<<t;
return 0;
}
输出+统计代码：
global n,count
num=[]
vis=[]
def find(index):
x=max(num)
while x>0:
if vis[x]==0:
return x
x=x-1
return 0
def DFS(index):
global n,count,num
if index==n+1:
for i in range(1,n):
print(num[i],end=' ')
print(num[n])
count=count+1
return
for i in range(1,n+1):
if vis[i]==0 and (num[index-1]<i or i==find(index-1)):
vis[i]=1
num[index]=i
DFS(index+1)
vis[i]=0
num[index]=0
if __name__=="__main__":
global n,count
count=0
n=int(input())
vis=[0]*(n+1)
num=[0]*(n+1)
DFS(1)
print(count)
题目描述
有一个n*m格的迷宫(表示有n行、m列)，其中有可走的也有不可走的，如果用1表示可以走，0表示不可以走，文件读入这n*m个数据和起始点、结束点(起始点和结束点都是用两个数据来描述的，分别表示这个点的行号和列号)。现在要你编程找出所有可行的道路，要求所走的路中没有重复的点，走时只能是上下左右四个方向。如果一条路都不可行，则输出相应信息(用-l表示无路)。
请统一用 左上右下的顺序拓展，也就是 (0,-1),(-1,0),(0,1),(1,0)
输入
第一行是两个数n，m( 1 < n ， m < 15 )，接下来是m行n列由1和0组成的数据，最后两行是起始点和结束点。
输出
所有可行的路径，描述一个点时用(x，y)的形式，除开始点外，其他的都要用“->”表示方向。
如果没有一条可行的路则输出-1。
代码：
global m,n,si,sj,ei,ej,count
mapping=[]
vis=[]
load=[]
dirs=[[0,-1],[-1,0],[0,1],[1,0]]
def DFS(x,y):
global m,n,si,sj,ei,ej,count
if x==ei and y==ej:
count=count+1
print("(%d,%d)->"%(si+1,sj+1),end=' ')
for i in range(len(load)-1):
print("(%d,%d)->"%(load[i][0]+1,load[i][1]+1),end=' ')
print("(%d,%d)"%(load[len(load)-1][0]+1,load[len(load)-1][1]+1))
return
for i in range(4):
x=x+dirs[i][0]
y=y+dirs[i][1]
if x>-1 and x<n and y>-1 and y<m and mapping[x][y]==1 and vis[x][y]==0:
vis[x][y]=1
load.append([x,y])
DFS(x,y)
vis[x][y]=0
load.pop()
x=x-dirs[i][0]
y=y-dirs[i][1]
if __name__=="__main__":
global m,n,si,sj,ei,ej,count
n,m=input().split(' ')
n=int(n)
m=int(m)
for i in range(n):
mapping.append(input().split(' '))
vis.append([0]*m)
for j in range(m):
mapping[i][j]=int(mapping[i][j])
si,sj=input().split(' ')
si=int(si)-1
sj=int(sj)-1
ei,ej=input().split(' ')
ei=int(ei)-1
ej=int(ej)-1
count=0
DFS(si,sj)
if count==0:
print(-1)
来源：CSDN
作者：xiaoxiaokeke_
链接：https://blog.csdn.net/xiaoxiaokeke_/article/details/104593483