ACM寒假集训5

num1:C++
code:#include
using namespace std;
int n,a[10];
void dfs(int he,int c,int qs){
if(he==n){
for(int i=1;i<=c-2;i++){
cout<<a[i]<<'+';
}
cout<<a[c-1]<<endl;
return ;
}
if(he>n) return;
for(int i=qs;i<=n-1;i++){
a[c]=i;
dfs(he+i,c+1,i);
a[c]=0;
}
}
int main(){
cin>>n;
dfs(0,1,1);
return 0;
}
解题思路：首先，根据用户输入的整数n，初始化一个数组a来存储数列的元素。然后，通过DFS递归地尝试将不同的数字（从1开始）添加到数列中，同时跟踪当前已添加的数字数量（c）和当前数字的和（he）。当数列的和等于或超过n时，根据特定格式（数字之间用加号连接，最后一个数字前不加加号）打印出数列。通过递归地回溯和尝试不同的数字组合，可以找到所有满足条件的数列。

num2:C++
code:#include

include

include

using namespace std;
int num[40][40],c;
int k;
int main()
{
int i,j,k,l;
cin>>c;
for(i=1;i<=c;i++)for(j=1;j<=c;j++)
{
scanf("%d",&num[i][j]);
if(num[i][j]0)num[i][j]=2;
}
for(i=1;i<=39;i++)
{num[0][i]=9;num[i][0]=9;}
for(i=1;i<=c;i++)
{
if(num[1][i]2){num[1][i]=0;}
if(num[i][1]2)num[i][1]=0;
if(num[c][i]2)num[c][i]=0;
if(num[i][c]2)num[i][c]=0;
}
for(k=1;k<=100;k++)
for(i=1;i<=c;i++)
for(j=1;j<=c;j++)
{
if(num[i][j]!=1)
if(num[i][j-1]0||num[i-1][j]0||num[i+1][j]0||num[i][j+1]==0)
num[i][j]=0;
}
for(i=1;i<=c;i++)
{

for(j=1;j<=c;j++)
printf("%d ",num[i][j]);
cout<<endl;

}
return 0;
}
解题思路：首先，程序读取用户输入的矩阵大小c和矩阵元素。为了简化边界处理，程序在矩阵的四周添加了一圈值为9的边界元素（这些元素在后续逻辑中视为“墙”，不可通过）。接着，程序将输入矩阵中的0替换为2，代表空地（或可通过的路径）。然后，对矩阵的第一行、第一列、最后一行和最后一列进行检查，将边界上的2（如果有的话）替换为0，因为这些位置被视为不可通过的。
接下来，程序进入一个迭代过程，最多迭代100次。在每次迭代中，程序检查每个非1元素（即非障碍物），如果该元素至少有一个相邻的边界元素（或之前已被设置为0的元素），则将该元素也设置为0。这个过程模拟了某种“腐蚀”或“传播”效果，使得与边界或已设置为0的元素相邻的所有空地（2）最终都被设置为0。
最后，程序打印出修改后的矩阵。

num3:C++
code:#include<bits/stdc++.h>
using namespace std;
int n,m;
struct MAP
{
int x,y;
}a[1000010];
bool f[1010][1010];
int d[1010][1010];
int dx[5]={0,0,0,-1,1},dy[5]={0,-1,1,0,0};
int tail=0,head=0;
int main()
{
memset(f,true,sizeof(f));
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
{
string s;
cin>>s;
for(int j=0;j<s.size();j++)
if(s[j]=='0')
f[i][j+1]=false;
else
{
d[i][j+1]=0;
f[i][j+1]=true;
a[++tail].x=i;
a[tail].y=j+1;
}
}
for(head=1;head<=tail;head++)
{
for(int i=1;i<=4;i++)
{
int xx=a[head].x+dx[i],yy=a[head].y+dy[i];
if(!f[xx][yy])
{
d[xx][yy]=d[a[head].x][a[head].y]+1;
f[xx][yy]=true;
a[++tail].x=xx;
a[tail].y=yy;
}
}
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=m;j++)
printf("%d ",d[i][j]);
printf("\n");
}
return 0;
}
解题思路：本题采用广度优先搜索（BFS）算法解决迷宫最短路径问题。首先，读取迷宫大小及布局，将空地（'0'）标记为可访问并加入队列，同时初始化访问标记数组和距离数组。然后，从队列头部取出点，尝试向四个方向扩展，若新点可访问且未被访问过，则更新其访问状态和最短路径长度，并将其加入队列尾部。重复此过程直至队列为空。最后，遍历整个迷宫，打印每个点的最短路径长度。此算法保证了找到从任意起点到各点的最短路径。

num4:C++
code:#include
using namespace std;
int f,nfeed[30],type,t[30][30],m=20,mx[30],ans[30];
bool cz(int x)
{
for(int i=1;i<=f;i++)
{
int he=0;
for(int j=1;j<=x;j++)
{
he+=t[ans[j]][i];
}
if(he<nfeed[i]) return false;
}
return true;
}
void dfs(int pos,int z)
{
if(pos>type)
{
if(cz(z) && z<m)
{
m=z;
for(int i=1;i<=z;i++)
{
mx[i]=ans[i];
}
}
return ;
}
ans[z+1]=pos;
dfs(pos+1,z+1);
dfs(pos+1,z);
}
int main()
{
cin>>f;
for(int i=1;i<=f;i++)
cin>>nfeed[i];
cin>>type;
for(int i=1;i<=type;i++)
{
for(int j=1;j<=f;j++)
{
cin>>t[i][j];
}
}
dfs(1,0);
cout<<m<<" ";
for(int i=1;i<=m;i++)
cout<<mx[i]<<" ";
cout<<endl;
return 0;
}
解题思路：本题通过深度优先搜索（DFS）算法求解。首先，读取食物种类数、每种食物的需求量和动物种类及其提供的食物量。然后，利用DFS遍历所有可能的动物组合，对于每种组合，计算其提供的食物总量是否满足需求。在遍历过程中，记录满足需求且动物种类数最少的组合。最后，输出最少动物种类数及对应的动物编号。通过递归地尝试包含或不包含每种动物，DFS能够探索所有可能的组合，从而找到最优解。

num5:C++
code:#include

include

using namespace std;
int n,hei[1010][1010],w;bool g[1010][1010];
int mx[9]={0,-1,-1,-1,0,0,1,1,1},a=0,b=0;
int my[9]={0,-1,0,1,-1,1,-1,0,1};
void search(int posx,int posy)
{
for(int i=1;i<=8;i++)
{
int xx=posx+mx[i],yy=posy+my[i];
if(!(xx>=1&&xx<=n&&yy>=1&&yy<=n))
continue;
if(hei[xx][yy]hei[posx][posy]&&g[xx][yy]0)
g[xx][yy]=1,search(xx,yy);
else if(hei[xx][yy]<hei[posx][posy]&&w1)
w=-1;
else if(hei[xx][yy]>hei[posx][posy]&&w2)
w=-1;
else if(w0)
{
if(hei[xx][yy]<hei[posx][posy])
w=2;
if(hei[xx][yy]>hei[posx][posy])
w=1;
}
}
}
int main()
{
scanf("%d",&n);
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
scanf("%d",&hei[i][j]);
int x=hei[1][1]; w=1;
for(int i=2;i<=n;i++)
if(hei[1][i]!=x)
w=0;
if(w1)
for(int i=2;i<=n;i++)
for(int j=1;j<=n;j++)
if(hei[i][j]!=x)
w=0;
if(w1)
{
cout<<"1 1";
return 0;
}
for(int i=1;i<=n;i++)
{
for(int j=1;j<=n;j++)
{
if(g[i][j]0)
{
w=0;
g[i][j]=1;
search(i,j);
if(w1)
a++;
else if(w2)
b++;
}
}
}
printf("%d %d",b,a);
return 0;
}
解题思路：本题通过深度优先搜索（DFS）算法遍历高度矩阵。首先，检查初始位置（1,1）是否为山峰，若是则直接输出。然后，检查第一行和第一列以确定是否整个矩阵为同一高度（山峰情况）。若非上述两种情况，则对矩阵进行DFS遍历，对每个未访问的位置，根据其高度与相邻位置的比较，判断是山峰还是山谷，并分别计数。最后，输出山谷和山峰的数量。DFS确保了每个位置都被访问且仅被访问一次，从而准确统计了山峰和山谷的数量。

num6:C++
code:#include

include

include

include

include

using namespace std;
int a[50][50],yi[20],xjay[50],xjiany[50];
int n,c=0,s=0;
void out() {
if(c>=3)c++;
else {
for(int i=1; i<=n; i++) {
for(int k=1;k<=n;k++){
if(a[i][k]1)cout<<k<<" ";
}
}
cout<<endl;
c++;
}
}
void zhanlin(int x,int y){
a[x][y]=1;
yi[y]=1;
xjiany[x-y+n]=1;
xjay[x+y]=1;
}
void fangqi(int x,int y){
a[x][y]=0;
yi[y]=0;
xjiany[x-y+n]=0;
xjay[x+y]=0;
}
int isok(int x,int y){
if(a[x][y]0&&yi[y]0&&xjiany[x-y+n]0&&xjay[x+y]0)return 0;
return 1;
}
void dfs(int x) {
if(xn+1) {
out();
}
else {
for(int k=1; k<=n; k++) {
if(isok(x,k)==0){
zhanlin(x,k);
dfs(x+1);
fangqi(x,k);
}
}
}
}
int main() {
int i,k;
cin>>n;
dfs(1);
cout<<c;
return 0;
}
解题思路：本题采用深度优先搜索（DFS）策略。首先，初始化矩阵和辅助标记数组。然后，从第一行开始，对每一行的每个空位进行DFS，尝试占用该位置并更新标记数组。递归地搜索下一行，直到填满所有行或无法继续。每当填满所有行时，检查并输出符合条件的排列（根据题目具体要求，此处可能有所省略，因为原代码中的out函数实现与问题描述不完全对应）。最后，统计并输出所有有效排列的数量。DFS确保了所有可能的排列都被考虑。