蓝桥：回形取数

最新推荐文章于 2022-03-01 14:05:54 发布

向上Claire

最新推荐文章于 2022-03-01 14:05:54 发布

阅读量1.1k

点赞数 1

分类专栏：蓝桥

本文链接：https://blog.csdn.net/weixin_44522477/article/details/104254787

版权

蓝桥专栏收录该内容

205 篇文章 6 订阅

订阅专栏

蓝桥：回形取数

题目

问题描述
　　回形取数就是沿矩阵的边取数，若当前方向上无数可取或已经取过，则左转90度。一开始位于矩阵左上角，方向向下。
输入格式
　　输入第一行是两个不超过200的正整数m, n，表示矩阵的行和列。接下来m行每行n个整数，表示这个矩阵。
输出格式
　　输出只有一行，共mn个数，为输入矩阵回形取数得到的结果。数之间用一个空格分隔，行末不要有多余的空格。
样例输入
3 3
1 2 3
4 5 6
7 8 9
样例输出
1 4 7 8 9 6 3 2 5
样例输入
3 2
1 2
3 4
5 6
样例输出
1 3 5 6 4 2

锦囊1
循环，标记。
锦囊2
使用多次循环来处理，也可以对取过的数标记来简化循环的判断。

代码1（错误的，右边上来出不来了）

他是全部都要取到，并不是只取边缘

import java.util.Scanner;

public class 回形针取数 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int m=sc.nextInt();
		int arr[][]=new int[m][n];
		for(int i=0;i<m;i++){
			for(int j=0;j<n;j++){
				arr[i][j]=sc.nextInt();
			}
		}
		for(int i=0;i<m;i++)
			System.out.print(arr[i][0]+" ");
		for(int j=1;j<n;j++)
			System.out.print(arr[m-1][j]+" ");
		for(int i=m-2;i<=0;i--)
			System.out.print(arr[i][n-1]+" ");
		for(int j=n-2;j<0;j--)
			System.out.print(arr[0][j-1]+" ");
	}

}

分析

此处我利用递归的方法去做。递归的限制条件（跳出条件）有三个：

①：当元素取完是结束递归

②：当只有或只剩一行时，直接按照顺序输出数组的元素

③：当只有或只剩一列时，直接按照顺序输出数组的元素

1.当元素取完是递归，即取出了m*n个数

我很想知道这个为什么错了

import java.util.Scanner;

public class 回形针取数 {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int m=sc.nextInt();
		int a[][]=new int[m][n];
		for(int i=0;i<m;i++){
			for(int j=0;j<n;j++){
				a[i][j]=sc.nextInt();
			}
		}
		
		Qu(a[][],m,n);
	}
		public static int[][] Qu(int arr[][],int m,int n){
			int b[][]=new int[200][200];
			//条件1
			if(m==0&&n==0)
				return 0;
			//条件2
			if(m==1&&n>0){
				for(int i=0;i<n;i++)
					System.out.print(arr[0][i]);
				return 0;
			}
			//条件三
			if(n==1&&m>0){
				for(int i=0;i<m;i++)
					System.out.print(arr[i][0]);
				return 0;
			}
			
			for(int i=0;i<m;i++)
				System.out.print(arr[i][0]);//输出第一行向下的数
			
			//向右旋转90度
			//这个代码太牛逼了，大写的牛逼！！！！！！
			for(int i=1;i<n;i++){
				for(int j=0;j<m;j++){
					b[i-1][j]=arr[m-j-1][i];
				}
			}
			 Qu(b,m-1,n);
		}
}

解决思想（递归）
将矩阵从里到外分为多层，每一层都是一个口字型数字序列，方向都是顺时针，由此我们可以将问题分解为相同的子问题，采用递归算法

分析
先将输入m*n个数先用二维数组num[m][n]保存起来
在这里插入图片描述
设当前所在位置为i，j，设当前的方向变量为direction（int）∈{1，2，3，4}
（direction数值在1，2，3，4，1，2，3，4……不断的循环变化）

规定：
当num[i][j]的值为-1时，代表当前的数已经输出了，且当num[i][j]输出之后，将-1赋值给num[i][j]表示已经输出

在开始沿当前方向输出之前,进行判断
————————————————
位置②为什么要记录下初始位置：
在这里插入图片描述
当出现下面的情况时
这里写图片描述
本来是应该左转向下，
如果不判断当前位置是否时初始位置时，继续下去就会在下一个位置左转，然后就结
束迭代了。然而中间的却没输出，与题意不符
版权声明：本文为CSDN博主「cc_bk」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/cc_bk/article/details/79447552

①：首先判断当前方向为哪个方向
if（当前方向的下一个位置越过了数组的界限  ||  以及下一个位置的值为-1）{
    if（左侧的第一个数越界  ||  左侧的第一个数为-1）
        return结束迭代
    else
        向左侧转向，方向变量改变，回到位置①，继续向下走
}else{

    while（不越过数组的界限）{

        ②:将初始位置记录下来

        if（num[i][j]!=-1）{
            输出num[i][j]
            num[i][j]=-1;
        }else{
            if(不是初始位置)
                break;
        }
        向左转，方向变量改变，回到位置①，继续向下走
    }
}

方向向下

//i为现在的横坐标，j为现在的纵坐标，direction为方向，num为数组，m为给定的行，n为给定的列
 if(direction==1){//①：首先判断当前方向为哪个方向  
            if(i+1==m||num[i+1][j]==-1){//if（当前方向的下一个位置越过了数组的界限  ||  以及下一个位置的值为-1）
                if(j+1==n||num[i][j+1]==-1)//if（右侧的第一个数越界  || 右侧的第一个数为-1）这样就不能改变方向
                    return; //return结束迭代
                else
                    result(i, j, 2, num, m, n);//如果没有越界，就是说进行变方向；向右侧转向，方向变量改变，回到位置①，继续向下走
            }else{//还可以继续向下
                int begin=i;//开始值为begin为i
                while(i<m){// while（不越过数组的界限） ②:将初始位置记录下来
                    if(num[i][j]!=-1){//就是还没有被标为-1,没有被，其实我不明白这个有什么用，这个不是多次一举吗？
                        System.out.print(num[i][j]+" ");//输出
                        num[i][j]=-1;//标为-1
                    }else{
                        if(begin!=i)//判断是否为最开始的横坐标
                            break;
                    }
                    i++;//i向下走
                }
                result(i-1, j, 2, num, m, n);
            }   
        }

方向向右

if(direction==2){//①：首先判断当前方向为哪个方向  
            if(j+1==n||num[i][j+1]==-1){//if（当前方向的下一个位置越过了数组的界限  ||  以及下一个位置的值为-1）
                if(i-1==-1||num[i-1][j]==-1)//if（上侧的第一个数越界  || 上侧的第一个数为-1）
                    return; //return结束迭代
                else
                    result(i, j, 3, num, m, n);//如果没有越界，就是说进行变方向；向上侧转向，方向变量改变，回到位置①，继续向下走
            }else{//还可以继续向右
                int begin=j;//开始值为begin为j
                while(j<n){// while（不越过数组的界限） ②:将初始位置记录下来
                    if(num[i][j]!=-1){//就是还没有被标为-1,没有被，其实我不明白这个有什么用，这个不是多次一举吗？
                        System.out.print(num[i][j]+" ");//输出
                        num[i][j]=-1;//标为-1
                    }else{
                        if(begin!=j)//判断是否为最开始的纵坐标
                            break;
                    }
                    j++;//i向you走
                }
                result(i, j-1, 3, num, m, n);//向右转，方向变量改变，回到位置①，向右走
            }   
        }

向上走

if(direction==3){//①：首先判断当前方向为哪个方向  
            if(i-1==-1||num[i-1][j]==-1){//if（当前方向的下一个位置越过了数组的界限  ||  以及下一个位置的值为-1）
                if(j-1==-1||num[i][j-1]==-1)//if（zuo侧的第一个数越界  || zuo侧的第一个数为-1）
                    return; //return结束迭代
                else
                    result(i, j, 4, num, m, n);//如果没有越界，就是说进行变方向；向左侧转向，方向变量改变，回到位置①，继续向上走
            }else{//还可以继续向右
                int begin=i;//开始值为begin为i
                while(i>=0){// while（不越过数组的界限） ②:将初始位置记录下来
                    if(num[i][j]!=-1){//就是还没有被标为-1,没有被，其实我不明白这个有什么用，这个不是多次一举吗？
                        System.out.print(num[i][j]+" ");//输出
                        num[i][j]=-1;//标为-1
                    }else{
                        if(begin!=i)//判断是否为最开始的横坐标
                            break;
                    }
                    i++;//i向you走
                }
                result(i+1, j, 4, num, m, n);
            }   
        }

向左走

if(direction==4){
            if(j-1<0||num[i][j-1]==-1){
                if(i+1==m||num[i+1][j]==-1)
                    return ;
                else
                    result(i, j, 1, num, m, n);
            }else{
                int begin=j;
                while(j>=0){
                    if(num[i][j]!=-1){
                        System.out.print(num[i][j]+" ");
                        num[i][j]=-1;                   
                    }else{
                        if(begin!=j)
                            break;
                    }
                    j--;    
                }
                result(i, j+1, 1, num, m, n);
            }       
        }

这个还是有问题

import java.util.Scanner;

public class 回形针取数 {
	
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int m=sc.nextInt();
		int a[][]=new int[m][n];
		for(int i=0;i<m;i++){
			for(int j=0;j<n;j++){
				a[i][j]=sc.nextInt();
			}
		}
		
		result(0,0,1,a,m,n);
	}
	public static void result(int i,int j,int direction,int num[][],int m,int n){

        if(direction==1){   
            if(i+1==m||num[i+1][j]==-1){
                if(j+1==n||num[i][j+1]==-1)
                    return;
                else
                    result(i, j, 2, num, m, n);
            }else{
                int begin=i;
                while(i<m){
                    if(num[i][j]!=-1){
                        System.out.print(num[i][j]+" ");
                        num[i][j]=-1;
                    }else{
                        if(begin!=i)
                            break;
                    }
                    i++;
                }
                result(i-1, j, 2, num, m, n);
            }   
        }
        if(direction==2){
            if(j+1==n||num[i][j+1]==-1){
                if(i-1<0||num[i-1][j]==-1)
                    return;
                else
                    result(i, j, 3, num, m, n);
            }else{
                int begin=j;
                while(j<n){
                    if(num[i][j]!=-1){
                        System.out.print(num[i][j]+" ");
                        num[i][j]=-1;
                    }else{
                        if(begin!=j)
                            break;
                    }
                    j++;
                }
                result(i, j-1, 3, num, m, n);
            }
        }
        if(direction==3){
            if(i-1<0||num[i-1][j]==-1){
                if(j-1<0||num[i][j-1]==-1)
                    return;
                else
                    result(i, j, 4, num, m, n);
            }else{
                int begin=i;
                while(i>=0){
                    if(num[i][j]!=-1){
                        System.out.print(num[i][j]+" ");
                        num[i][j]=-1;
                    }else{
                        if(begin!=i)
                            break;
                    }
                    i--;
                }
                result(i+1, j, 4, num, m, n);
            }


        } 
        if(direction==4){
            if(j-1<0||num[i][j-1]==-1){
                if(i+1==m||num[i+1][j]==-1)
                    return ;
                else
                    result(i, j, 1, num, m, n);
            }else{
                int begin=j;
                while(j>=0){
                    if(num[i][j]!=-1){
                        System.out.print(num[i][j]+" ");
                        num[i][j]=-1;                   
                    }else{
                        if(begin!=j)
                            break;
                    }
                    j--;    
                }
                result(i, j+1, 1, num, m, n);
            }       
        }
    }
}

向上Claire

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
蓝桥：回形取数

蓝桥：回形取数题目问题描述　　回形取数就是沿矩阵的边取数，若当前方向上无数可取或已经取过，则左转90度。一开始位于矩阵左上角，方向向下。输入格式　　输入第一行是两个不超过200的正整数m, n，表示矩阵的行和列。接下来m行每行n个整数，表示这个矩阵。输出格式　　输出只有一行，共mn个数，为输入矩阵回形取数得到的结果。数之间用一个空格分隔，行末不要有多余的空格。样例输入3 31 ...
复制链接

扫一扫