十二组题解

A

#include
#include
using namespace std;
char s[22][22];
int st[22];
int ans;
int n,k;
void dfs(int x,int t)
{
	if(t==0){
		ans++;
		return ;
	}
	if(x>=n) return ;
	for(int j=0;j<n;j++){
		if(s[x][j]=='#'&&!st[j]){
			st[j]=1;
			dfs(x+1,t-1);
			st[j]=0;
		}
	}
	dfs(x+1,t);
	return ;
}
int main()
{
	while(cin>>n>>k)
	{
		if(n==-1&&k==-1) break;
		memset(st,0,sizeof(st));
		for(int i=0;i<n;i++)
		cin>>s[i];
		ans=0;
		dfs(0,k);
		cout<<ans<<endl;
	}
	
	return 0;
}

B

#include
using namespace std;
int n;
int s[22],b[22];
int ans=1e9+10;
void dfs(int u,int x,int y)
{
	if(u==n){
		if(x==1&&y==0) return ;
		ans=min(ans,abs(x-y));
		return ;
	}
	dfs(u+1,x*s[u],y+b[u]);
	dfs(u+1,x,y);
}
int main()
{
	cin>>n;
	for(int i=0;i<n;i++){
		cin>>s[i]>>b[i];
	}
	dfs(0,1,0);
	cout<<ans<<endl;
	return 0;
}

C

#include
using namespace std;
int main()
{
	char s[66];
	cin>>s;
	do{
		for(int i=0;i<strlen(s);i++)
		cout<<s[i];
		cout<<endl;
	}while(next_permutation(s,s+strlen(s)));
	
	return 0;
}

D

#include
#include
using namespace std;
int n;
int a[22];
void dfs(int u,int k)
{
    for(int i=1;i<=u;i++)
    {
        if(i==n)
            return;
        if(i>=a[k-1])
        {
            a[k]=i;
            int rest=u-i;
            if(k>=1&&rest==0)
            {
                printf("%d=",n);
                for(int j=1;j<k;j++)
                    printf("%d+",a[j]);
                cout<<a[k]<<endl;
            }
            else 
                dfs(rest,k+1);
            a[k]=0;
        }
    }
}
int main()
{
    cin>>n;
    dfs(n,1);
}

E

#include
#include
#include
#include
using namespace std;
int s[22];
int st[22];
int cnt=1;
int n;
bool pd(int x,int y)
{
	int k=x+y;
	int i=2;
	while(i<=sqrt(k)&&k%i!=0) i++;
	if(i>sqrt(k)) return true;
	else return false;
}
void print()
{
	for(int i=1;i<n;i++)
	cout<<s[i]<<" ";
	cout<<s[n]<<endl;
}
void dfs(int x)
{
	if(x==n&&pd(s[n],s[1]))
	{
		print();
		return ;
	}
	for(int j=2;j<=n;j++)
	{
		if(!st[j]&&pd(j,s[x]))
		{
			st[j]=1;
			s[x+1]=j;
			dfs(x+1);
			st[j]=0;
		}
	}
}
int main()
{
	int f=1;
	while(cin>>n)
	{
		memset(s,0,sizeof(s));
		memset(st,0,sizeof(st));
		if(f!=1) 
		cout<<endl;
		cout<<"Case "<<cnt++<<":"<<endl;
		s[1]=1;
		dfs(1);
		f++;
	}
	return 0;
}

F

#include
#include
using namespace std;
char s[22][22];
int st[22][22];
int n,m;
int ans;
int dx[]={0,0,-1,1},dy[]={-1,1,0,0};
void dfs(int x,int y)
{
	for(int i=0;i<4;i++){
		int tx=x+dx[i],ty=y+dy[i];
		if(tx>=1&&ty>=1&&tx<=n&&ty<=m&&s[tx][ty]=='.'&&!st[tx][ty])
		{
			st[tx][ty]=1;
			ans++;
			dfs(tx,ty);
		}
	}
}
int main()
{
	while(cin>>m>>n){
		if(n==0&&m==0) break;
		ans=1;
		int sx,sy;
		memset(st,0,sizeof(st));
		memset(s,0,sizeof(s));
		for(int i=1;i<=n;i++)
		{
			for(int j=1;j<=m;j++)
			{
				cin>>s[i][j];
				if(s[i][j]=='@'){
					sx=i;
					sy=j;
				}
			}
		}
		st[sx][sy]=1;
		dfs(sx,sy);
		cout<<ans<<endl;
	}
	return 0;
}

G

#include
#include
#define N 333
//bfs模板题
//本题应用的是逐层扩散 
using namespace std;
char a[N][N];
bool vis[N][N];
int n;
int dr[8][2]={{-2,1},{-1,2},{1,2},{2,1},{2,-1},{1,-2},{-1,-2},{-2,-1}};
struct node{
	int x;
	int y;
	int step;
}q[100000];
void bfs(int sx,int sy,int ex,int ey)
{
	int head=1,tatil=1;
	memset(vis,0,sizeof(vis));
	vis[sx][sy]=1;
	q[tatil].x =sx;
	q[tatil].y =sy;
	q[tatil].step =0;
	tatil++;
	
	while(head<tatil)
	{
		int x=q[head].x ;
		int y=q[head].y ;
		int step=q[head].step ;
		if(x==ex&&y==ey)
		{
			cout<<step<<endl;
			break;
		}
		for(int i=0;i<8;i++)
		{
			int nx=x+dr[i][0];
			int ny=y+dr[i][1];
			if(nx>=0&&nx<n&&ny>=0&&ny<n&&vis[nx][ny]==0)
			{
				vis[nx][ny]=1;
				q[tatil].x =nx;
				q[tatil].y =ny;
				q[tatil].step =step+1;
				tatil++;
			}
		}
		head++;
	}
}
int main()
{
	int t;
	cin>>t;
	int sx,sy,ex,ey;
	while(t--)
	{
		cin>>n;
		cin>>sx>>sy>>ex>>ey;
		bfs(sx,sy,ex,ey);
	}
	return 0;
}

H

#include
#include
using namespace std;
char s[111][111];
int n,m;
int ans;
void dfs(int x,int y)
{
    if(x>=0&&x<n&&y>=0&&y<m&&s[x][y]=='@'){
        s[x][y]='#';
        dfs(x-1,y-1);
        dfs(x-1,y);
        dfs(x-1,y+1);
        dfs(x,y-1);
        dfs(x,y+1);
        dfs(x+1,y-1);
        dfs(x+1,y);
        dfs(x+1,y+1);
    }
}
int main()
{
    
    while(cin>>n>>m){
        memset(s,0,sizeof(s));
        ans=0;
       if(n==0&&m==0) break;
       for(int i=0;i<n;i++)
       cin>>s[i];
       for(int i=0;i<n;i++)
       {
       	for(int j=0;j<m;j++)
       	{
       		if(s[i][j]=='@'){
       			ans++;
       			dfs(i,j);
			   }
		}
	   }
	   cout<<ans<<endl;
    }
    return 0;
}

I

#include
#include
using namespace std;
char s[111][111];
int n,m;
int ans;
void dfs(int x,int y)
{
    if(x>=0&&x<n&&y>=0&&y<m&&s[x][y]=='W'){
        s[x][y]='.';
        dfs(x-1,y-1);
        dfs(x-1,y);
        dfs(x-1,y+1);
        dfs(x,y-1);
        dfs(x,y+1);
        dfs(x+1,y-1);
        dfs(x+1,y);
        dfs(x+1,y+1);
    }
}
int main()
{
    
    while(cin>>n>>m){
        memset(s,0,sizeof(s));
        ans=0;
        for(int i=0;i<n;i++)
            cin>>s[i];
        for(int i=0;i<n;i++){
            for(int j=0;j<m;j++){
                if(s[i][j]=='W'){
                    ans++;
                    dfs(i,j);
                }
            }
        }
        cout<<ans<<endl;
    }
    return 0;
}

J

#include
using namespace std;
struct node{
	int l;
	int r;
}s[100010];
int n;
void dfs(int x)
{
	if(x==0){
		return ;
	}
	cout<<x<<endl;
	dfs(s[x].l );
	dfs(s[x].r );
}
int main()
{
	cin>>n;
	for(int i=1;i<=n;i++) cin>>s[i].l>>s[i].r;
	dfs(1);
	return 0;
}

K

#include
using namespace std;
int n,m;
int sn,sm;
int en,em;
char s[22][22];
bool st[22][22];
int f;
int dx[]={0,0,-1,1},dy[]={-1,1,0,0};
void dfs(int x,int y)
{
	if(x==en&&y==em) {
		f=1;
		return ;
	}
	for(int i=0;i<4;i++){
	int tx=x+dx[i],ty=y+dy[i];
	if(tx>=0&&ty>=0&&tx<n&&ty<m&&!st[tx][ty]&&(s[tx][ty]=='.'||s[tx][ty]=='T'))
	{
		//cout<
		st[tx][ty]=true;
		dfs(tx,ty);
		st[tx][ty]=false;	
	}
	}
}
int main()
{
	cin>>n>>m;
	for(int i=0;i<n;i++)
	for(int j=0;j<m;j++)
	{
		cin>>s[i][j];
		if(s[i][j]=='T') en=i,em=j;
		else if(s[i][j]=='S') sn=i,sm=j;
	}
	st[sn][sm]=true;
	dfs(sn,sm);
	if(f==1) cout<<"yes"<<endl;
	else cout<<"no"<<endl;
	return 0;
}

L

#include
#include
using namespace std;
int st[22][22];
int ans;
int n,m,x,y;
int dx[8]={1,1,2,2,-1,-1,-2,-2},dy[8]={2,-2,1,-1,2,-2,1,-1};
void dfs(int x,int y,int s)
{
	if(s==n*m){
		ans++;
		return ;
	}
	for(int i=0;i<8;i++)
	{
		int tx=x+dx[i],ty=y+dy[i];
		if(tx>=0&&tx<n&&ty>=0&&ty<m&&!st[tx][ty]){
			st[tx][ty]=1;
			dfs(tx,ty,s+1);
			st[tx][ty]=0;
		}
	}
}
int main()
{
	int t;
	cin>>t;
	while(t--){
		memset(st,0,sizeof(st));
		ans=0;
		cin>>n>>m>>x>>y;
		st[x][y]=1;
		dfs(x,y,1);
		cout<<ans<<endl;
	}
	return 0;
}

M

#include
#include
using namespace std;
int k;
int ans;
int s[33][33];
int st[33][33];
int b[33],c[33],d[33];
int a[33];
void dfs(int i)
{
	for(int j=1;j<=8;j++)
	if((!b[j])&&(!c[i+j])&&(!d[i-j+7]))
	{
		a[i]=j;
		b[j]=1;
		c[i+j]=1;
		d[i-j+7]=1;
		if(i==8){
			int sum=0;
			for(int p=1;p<=8;p++)
			sum+=s[p][a[p]];
			ans=max(ans,sum);
		}
		else dfs(i+1);
		b[j]=0;
		c[i+j]=0;
		d[i-j+7]=0;
	}
}
int main()
{
	cin>>k;
	while(k--)
	{
		memset(s,0,sizeof(s));
		memset(st,0,sizeof(st));
		memset(a,0,sizeof(a));
		memset(b,0,sizeof(b));
		memset(c,0,sizeof(c));
		memset(d,0,sizeof(d));
		for(int i=1;i<=8;i++)
		for(int j=1;j<=8;j++)
			cin>>s[i][j];
			ans=-1;
			dfs(1);
		cout<<ans<<endl;
	}
	return 0;
}

N

#include
#include
using namespace std;
int s[22];
int n,k,ans;
bool pd(int x){
	int i=2;
	while(i<=sqrt(x)&&x%i!=0) i++;
	if(i>sqrt(x)) return true;
	else return false;
}
void dfs(int t,int sum,int d){
    if(t==k){
        if(pd(sum))ans++;
    }
    else{
        for(int i=d;i<=n;i++){
            dfs(t+1,sum+s[i],i+1);
        }
    }
}
int main(){
    cin>>n>>k;
    for(int i=1;i<=n;i++) cin>>s[i];
    dfs(0,0,1);
    cout<<ans<<endl;
    return 0;
}

O

#include 
#include 
#include 
#include 
#include 

using namespace std;

typedef pair<int, int > PII;

int n, m;
const int N = 510;
char g[N][N];
int d[N][N];

inline bool check(int x, int y)
{
    if(x >= 0 && x <= n && y >= 0 && y <= m) return true;
    return false;
}

inline int bfs()
{
    memset(d, 0x3f, sizeof d);

    deque<PII> dq;
    dq.push_front({0, 0});
    d[0][0] = 0;

    int moved[4][2] = {
        {-1, -1},
        {-1, 1},
        {1, 1},
        {1, -1},
    };
    int movei[4][2] = {
      {-1, -1},
      {-1, 0},
      {0, 0},
      {0, -1},
    };
    char cp[] = "\\/\\/";

    while(dq.size())
    {
        auto t = dq.front();
        dq.pop_front();

        int x = t.first, y = t.second;
        for(int i = 0; i < 4; i ++)
        {
            int a = x + moved[i][0], b = y + moved[i][1];
            if(check(a, b))
            {
                int j = x + movei[i][0], k = y + movei[i][1];
                int w;
                if(g[j][k] != cp[i]) w = 1;
                else w = 0;

                if(d[a][b] > d[x][y] + w)
                {
                    d[a][b] = d[x][y] + w;
                    if(w) dq.push_back({a, b});
                    else dq.push_front({a, b});
                }
            }
        }
    }

    if(d[n][m] == 0x3f3f3f3f) return -1;
    else return d[n][m];
}

inline void solve()
{
    cin >> n >> m;
    for(int i = 0; i < n; i ++) cin >> g[i];

    int res = bfs();

    if(res == -1) puts("NO SOLUTION");
    else cout << res << endl;
}

int main()
{
    solve();
    return 0;
}