二维数组最大连通子数组

设计思想:

主要用数据结构中遍历的思想,按照一定次序访问,不通则回溯。改程序已经做成界面版,在消灭星星中运用。

源代码 :

package star;

import java.awt.Component;
import java.awt.Container;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;

public class Star extends JFrame implements ActionListener{
    int[][] random;
    JButton[][] star;
     int[][] visited;//用于判断是否被访问过若未被访问过为0访问过为1需要回溯则为3
     JLabel back;
    public Star() {
        // TODO Auto-generated constructor stub
        this.setTitle("消灭星星");
        ImageIcon im=new ImageIcon("5.jpg");
        Image image=im.getImage();//对窗体图标的设置
        this.setIconImage(image);
        this.setSize(515, 710);
        this.setLocation(100, 0);
        this.setLayout(null);//窗体设置,布局为空
        
        Container con=this.getContentPane();//加一个容器
        
        JPanel panel=new JPanel();//添加一个面板把控件都放在面板上
        con.add(panel);
        panel.setSize(500, 700);
        panel.setLocation(0, 0);
        panel.setLayout(null);//设置为网格布局
        
        ImageIcon ii=new ImageIcon("7.jpg");//添加背景图片
        back=new JLabel(ii);
        back.setSize(500, 700);
        back.setLocation(0, 0);
        panel.add(back);
        
        random=new int[10][10];//把产生的随机数存入二维矩阵二维矩阵数字元素和图片名称相对应
        star=new JButton[10][10];//申请按钮矩阵
        
        Random ran=new Random();//产生随机数用于显示随机图片
        for(int i=0;i<10;i++)
        {
            for(int j=0;j<10;j++)
            {
                random[i][j]=ran.nextInt(4)+1;
            }
        }
        
        for(int i=0;i<10;i++)
        {
            for(int j=0;j<10;j++)
            {
                String str=Integer.toString(random[i][j]);//把产生的随机整肃转化为字符串类型
                String stri=str+".jpg";//和图片格式连接 生成"x.jpg"的字符串
                ImageIcon icon=new ImageIcon(stri);//实例化图片
                star[i][j]=new JButton(icon);//实例化按钮
                star[i][j].setSize(50, 50);//按钮的位置大小的设置
                star[i][j].setLocation(50*i, 50*j+180);
                star[i][j].setVisible(true);//图片设置为可见性
                star[i][j].addActionListener((ActionListener) this);
                back.add(star[i][j]);//加入按钮,只有把按钮放在背景上才不会出现 只有当鼠标放在按钮上才显示按钮
            }
        } 
        visited=new int[10][10];//实例化存储访问性的数组
        for(int i=0;i<10;i++)
        {
            for(int j=0;j<10;j++)
            {
                visited[i][j]=0;//初始化设置为0表示均未访问            
            }
        }
    }

/**
     * @param args
     */
    public static void main(final String[] args) {
        // TODO Auto-generated method stub

Star s=new Star();
        s.setVisible(true);
    }

public void actionPerformed(ActionEvent e) {
        // TODO Auto-generated method stub

for(int i=0;i<10;i++)
            {
                for(int j=0;j<10;j++)
                {
                    if(e.getSource()==star[i][j])
                    {
                        int a=i;
                        int b=j;
                        star[i][j].setVisible(false);
                        visited[a][b]=1;
                        int count=1;
                        boolean flag=true;
                        while(flag==true)
                        {//按照左下右上的顺序 visited[][]为0表示没被访问过1表示访问过3表示访问过并且不需要回溯
                            if(b-1>=0&&random[a][b]==random[a][b-1]&&visited[a][b-1]==0)
                            {
                                visited[a][b-1]=1;                                
                                b=b-1;
                                count++;
                                star[a][b].setVisible(false);
                            }
                            else if(a+1<=9&&random[a][b]==random[a+1][b]&&visited[a+1][b]==0)
                            {
                                visited[a+1][b]=1;
                                
                                a=a+1;
                                count++;
                                star[a][b].setVisible(false);
                            }
                            else if(b+1<=9&&random[a][b]==random[a][b+1]&&visited[a][b+1]==0)
                            {
                                visited[a][b+1]=1;
                                
                                b=b+1;
                                count++;
                                
                                star[a][b].setVisible(false);
                            }
                            else if(a-1>=0&&random[a][b]==random[a-1][b]&&visited[a-1][b]==0)
                            {
                                visited[a-1][b]=1;
                                
                                a=a-1;
                                count++;
                                
                                star[a][b].setVisible(false);
                            }
                            else//都不满足开始回溯
                            {
                                if(b-1>=0&&random[a][b-1]==random[a][b]&&visited[a][b-1]==1)
                                {
                                    visited[a][b]=3;
                                    b=b-1;
                                    count++;
                                    System.out.println(a+","+b);
                                }
                                else if(a+1<=9&&random[a+1][b]==random[a][b]&&visited[a+1][b]==1)
                                {
                                    visited[a][b]=3;
                                    a=a+1;
                                    count++;
                                    System.out.println(a+","+b);
                                }
                                else if(b+1<=9&&random[a][b+1]==random[a][b]&&visited[a][b+1]==1)
                                {
                                    visited[a][b]=3;
                                    b=b+1;
                                    count++;
                                    System.out.println(a+","+b);
                                }
                                else if(a-1>=0&&random[a-1][b]==random[a][b]&&visited[a-1][b]==1)
                                {
                                    visited[a][b]=3;
                                    a=a-1;
                                    count++;
                                    System.out.println(a+","+b);
                                }
                                else
                                {
                                     System.out.println("所有星星已被消灭完!");
                                     flag=false;
                                }
                                
                            }
                        }
                    }
                }
            }
        
    }

}

时间: 2024-10-06 07:03:40

二维数组最大连通子数组的相关文章

浅谈二维中的树状数组与线段树

一般来说,树状数组可以实现的东西线段树均可胜任,实际应用中也是如此.但是在二维中,线段树的操作变得太过复杂,更新子矩阵时第一维的lazy标记更是麻烦到不行. 但是树状数组在某些询问中又无法胜任,如最值等不符合区间减法的询问.此时就需要根据线段树与树状数组的优缺点来选择了. 做一下基本操作的对比,如下图. 因为线段树为自上向下更新,从而可以使用lazy标记使得矩阵的更新变的高校起来,几个不足就是代码长,代码长和代码长. 对于将将矩阵内元素变为某个值,因为树状数组自下向上更新,且要满足区间加法等限制

JS:二维数组排序和获取子级元素

JS:二维数组排序和获取子级元素 1. 二维数组排序 1.按数值排序 1 var arr = [[1, 2, 3], [7, 2, 3], [3, 2, 3]]; 如果我们要按每个子数组的第一列来排序要如何做呢,我们可以定义一个比较函数: 1 arr.sort(function(x, y){ 2 return x[0] – y[0]; 3 }); 这里的比较函数的作用是什么呢?其实是数组依次将数组元素复制给x,y,比如首先将arr[0]赋给x,arr[1]赋给y,然后用x[0] – y[0],根

二维数组最大联通子数组和

1.设计思想:先用户键盘输入一个自定义的几行几列的矩阵,然后输入相关的值,再调用求二维数组最大联通子数组和的方法,最终输出最大值. 2.出现问题:对于求联通子数组的这个思路不是很懂,不清楚. 3.解决方案:先求每行的最大和最小块,再求总的最大值,再将其输出:当列数为1时,当成一维计算: 4.源代码: /*返回一个整数数组中最大子数组的和. 输入一个一维整形数组,数组里有正数也有负数. 一维数组首尾相接,象个一条首尾相接带子一样. 数组中连续的一个或多个整数组成一个子数组,每个子数组都有一个和.

二维数据和一维指针数组

1.二维数组名a的含义: 定义一个二维数组a : int a[3][4] = {{1,3,5,7}, {9,11,13,15}, {17,19,21,23}}; a数组包含3个行元素,a[0],a[1],a[2]. 每个行元素a[i] 又是一个一维数组,它包含4个元素. a == &a[0] a + i == &a[i] a[0] == &a[0][0] a[i] == &a[ i ][0] 2.二维数组地址的关系:(地址由行至列以元素类型递增) 3.二维数组与一维指针数组

Java数组分隔成子数组

有这样一个需求,循环数组输出动态表单为一行两列 分隔数组每两个为一组,如果单数最后一个为一组 import java.util.ArrayList; import java.util.List; public class SplitArray { public static void main(String[] args) { String ary[] = { "a", "b", "c", "d", "e"

二维数组的最大联通子数组和

设计题目:求一个二维数组的连通的数组中和最大的最大值. 设计思路: 建立二维数组并遍历二维数组,将所有正整数分块,验证是否联通,如果不联通,判断路径. package demo;import java.util.*;public class Lmax { static Scanner scanner = new Scanner(System.in); public static void main(String args[]){ int m,n; int b; Scanner scanner =

二维数组最大子数组(结对开发)

1.题目要求 题目:返回一个二维整数数组中最大联通子数组的和. 要求: 输入一个二维整形数组,数组里有正数也有负数. 求所有子数组的和的最大值. 2.设计思想: 对n*m的二维数组进行分解,分解为n个一维数组,再先求这n个一维数组的最大子数组和,并记下每行最大一维子数组的下标如2-5,这是就会分两种情况第一种是行之间的最大子数组是相连的,如第一行是2-5,第二行是3-6,这是直接相加就行.第二种是不相连的如第一行是2-5,第二行是6-7,这时候就把每行的最大子数组看成一个整体,再使每个最大数组块

二维数组最大连通和的求解

求一个二维数组的连通的数组中和最大的最大值. 代码 #include<iostream> #include<string> using namespace std; void MaxIntArray(int a[],int &max,int &begin,int &end,int n); //先将二维数组按行分成n个一维数组,求出每个一维数组最大子数组和,并记录最大子数组和的首末位置,在通过首末位置判断是否联通 void main() { int n,m;/

求一个已知二维数组的最大子数组和(司宇,廖强)

小组成员:司宇,廖强 设计流程:          设计界面:               程序设计:1.封装一个求二维整数组最大子数组和的子程序: 2.设计一个主函数,主函数可以调用子函数: 3.在主函数中添加代码,使主函数可以调用一个TXT文件并且得到要求的结果. 遇到的问题:1.在调用txt文件时,没办法使调用文件前两行分别显示行数和列数: 2.在调用子函数的时候,不知道应该赋值给子函数一个什么类型的参数: 3.如何将String类型的二维数组转化为int类型. 解决方案:(当我们遇到问题