1.DFS：
Recursively, build a search tree.
[Example 1] Full arrangement problem:
#include<cstdio>
#include<iostream>
using namespace std;
int n;
bool vis[1005];
int a[1005];
void print(){
for(int i=1;i<=n;i++) printf("%d ",a[i]);
printf("\n");
}
void DFS(int x){
if(x==n+1){
print();
return;
}
for(int i=1;i<=n;i++){
if(vis[i]) continue;
a[x]=i;
vis[i]=1;
DFS(x+1);
vis[i]=0;
}
}
int main(){
scanf("%d",&n);
DFS(1);
return 0;
}
[Example 2] The Eight Queens Problem (Luogu P1219):
(https://www.luogu.com.cn/problem/P1219) The
diagonals are i+j, i-j+n. The size of the array must be greater than max(i+j,i-j+n).
#include<cstdio>
#include<iostream>
using namespace std;
int n;
const int N=520;
int cnt;
int a[N],c[N],d[N],p[N];
void print(){
for(int i=1;i<=n;i++) printf("%d ",p[i]);
printf("\n");
}
void dfs(int x){
if(x==n+1){
if(cnt<=2) print();
cnt++;
return;
}
for(int i=1;i<=n;i++){
if(a[i]==0&&c[i-x+n]==0&&d[i+x]==0){
p[x]=i;
a[i]=1;
c[i-x+n]=1;
d[i+x]=1;
dfs(x+1);
a[i]=0;
c[i-x+n]=0;
d[i+x]=0;
}
}
}
int main(){
scanf("%d",&n);
dfs(1);
printf("%d\n",cnt);
return 0;
}
2.
BFS: It is best to use BFS to count connected blocks:
DFS has up to n*m layers, which will burst the stack, while BFS has up to n+m layers.
[Example 1] Number of connected blocks:
#include<cstdio>
#include<iostream>
#include<queue>
using namespace std;
queue<pair<int,int> > q;
const int dx[4]={
0,0,1,-1};
const int dy[4]={
1,-1,0,0};
int n,m,cnt;
bool vis[105][105];
int a[105][105];
void BFS(int sx,int sy){
q.push(make_pair(sx,sy));
while(!q.empty()){
pair<int,int> f=q.front();
q.pop();
int x=f.first,y=f.second;
for(int i=0;i<4;i++){
int nx=x+dx[i];
int ny=y+dy[i];
if(nx<1||nx>n||ny<1||ny>m) continue;
if(vis[nx][ny]) continue;
if(a[nx][ny]!=a[x][y]) continue;
vis[nx][ny]=1;
q.push(make_pair(nx,ny));
}
}
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++) scanf("%d",&a[i][j]);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++){
if(!vis[i][j]){
vis[i][j]=1;
cnt++;
BFS(i,j);
}
}
printf("%d\n",cnt);
return 0;
}
[Example 2] Shortest path problem: In
a directed/undirected graph, and the edge weights are the same number, find the shortest path from 1 to n.
#include<cstdio>
#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
const int N=10005;
queue<int> q;
int n,m,tot;
int head[N],dis[N];
struct node{
int to,next;
}edge[N<<1];
void add(int u,int v){
edge[tot].next=head[u];
edge[tot].to=v;
head[u]=tot++;
}
void BFS(int s){
q.push(s);
dis[s]=0;
while(!q.empty()){
int u=q.front();
q.pop();
for(int i=head[u];i!=-1;i=edge[i].next){
int v=edge[i].to;
if(dis[v]==-1){
dis[v]=dis[u]+1;
q.push(v);
}
}
}
}
int main(){
memset(head,-1,sizeof(head));
memset(dis,-1,sizeof(dis));
scanf("%d%d",&n,&m);
for(int i=1;i<=m;i++){
int x,y;
scanf("%d%d",&x,&y);
add(x,y); add(y,x);
}
BFS(1);
printf("%d",dis[n]);
return 0;
}
3. Memory search:
each problem is solved once, and each time it takes O(1) to see if it has been solved.
[Example 1] Digital triangle:
(1) DP:
#include<cstdio>
#include<iostream>
using namespace std;
int n;
int mp[105][105],dp[105][105];
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)
for(int j=1;j<=i;j++) scanf("%d",&mp[i][j]);
for(int i=n;i>=1;i--)
for(int j=1;j<=i;j++) dp[i][j]=mp[i][j]+max(dp[i+1][j],dp[i+1][j+1]);
printf("%d",dp[1][1]);
return 0;
}
（2）DFS：
#include<cstdio>
#include<iostream>
using namespace std;
int n;
int mp[105][105],dp[105][105];
int DFS(int x,int y){
if(dp[x][y]>0) return dp[x][y];
if(x==n+1) return 0;
return dp[x][y]=mp[x][y]+max(DFS(x+1,y),DFS(x+1,y+1));
}
int main(){
scanf("%d",&n);
for(int i=1;i<=n;i++)
for(int j=1;j<=i;j++) scanf("%d",&mp[i][j]);
printf("%d",DFS(1,1));
return 0;
}
[Example 2] Skiing (Luogu P1434):
(https://www.luogu.com.cn/problem/P1434)
Because the state transition equation is not well defined, memoized search is used instead.
#include<cstdio>
#include<iostream>
using namespace std;
int n,m,ans;
int dp[1005][1005],g[1005][1005];
int dx[4]={
1,-1,0,0};
int dy[4]={
0,0,-1,1};
int DFS(int x,int y){
if(dp[x][y]) return dp[x][y];
dp[x][y]=1;
for(int i=0;i<4;i++){
int nx=x+dx[i];
int ny=y+dy[i];
if(nx<1||ny<1||nx>n||ny>m) continue;
if(g[x][y]>=g[nx][ny]) continue;
dp[x][y]=max(dp[x][y],DFS(nx,ny)+1);
}
return dp[x][y];
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++) scanf("%d",&g[i][j]);
for(int i=1;i<=n;i++)
for(int j=1;j<=m;j++){
dp[i][j]=DFS(i,j);
ans=max(ans,dp[i][j]);
}
printf("%d",ans);
return 0;
}