2 luanpaixie262 luanpaixie262 于 2016.03.19 12:34 提问

拉丁方针问题如何解决用java方法

这个java问题困惑了好久,作为一个不是共建班的学生,只能靠自己努力好好学,求各位大神教教我看题目要求求代码图片说明

3个回答

zqftisson
zqftisson   2016.03.19 18:42
已采纳

改造后


package questions;

import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Scanner;

public class LatinArrayHandler {

    private static int STOP_SIGNAL = 0;

    private boolean isLatinArray(int stepNum, List<Integer> sourceArray) {
        Map<Integer, Integer> itemMap = new HashMap<Integer, Integer>();
        int firstRowCount = 0;
        for (int i = 0; i < stepNum; i++) {
            firstRowCount += sourceArray.get(i);
            itemMap.put(sourceArray.get(i), sourceArray.get(i));
        }
        if (itemMap.size() != stepNum) {
            return false;
        }
//      System.out.println("firstRowCount=" + firstRowCount);
        int rowPointer = 0;
        int colPointer = 0;
        for (int j = 0; j < stepNum; j++) {
//          System.out.println("========the [" + j + "] row and col count======");
            if (!checkRowNums(stepNum, rowPointer, sourceArray, firstRowCount, itemMap)
                    || !countColNums(stepNum, colPointer, sourceArray, firstRowCount, itemMap)) {
                return false;
            } else {
                rowPointer += stepNum;
                colPointer++;
            }
        }
        return true;
    }

    private boolean checkRowNums(int stepNum, int curPointer, List<Integer> sourceArray, int firstRowCount, Map<Integer, Integer> itemMap) {
        int rowTotal = 0;
        for (int i = 0; i < stepNum; i++) {
            if (!itemMap.containsKey(sourceArray.get(curPointer))) {
                return false;
            } else {
                rowTotal += sourceArray.get(curPointer);
                curPointer++;
            }
        }
//      System.out.println(" this row total = " + rowTotal);
        if (rowTotal != firstRowCount) {
            return false;
        }
        return true;
    }

    private boolean countColNums(int stepNum, int curPointer,
            List<Integer> sourceArray, int firstRowCount, Map<Integer, Integer> itemMap) {
        int colTotal = 0;
        for (int i = 0; i < stepNum; i++) {
            if (!itemMap.containsKey(sourceArray.get(curPointer))) {
                return false;
            } else {
                colTotal += sourceArray.get(curPointer);
                curPointer += stepNum;
            }
        }

//      System.out.println(" this col total = " + colTotal);
        if (colTotal != firstRowCount) {
            return false;
        }
        return true;
    }

    private boolean isStandardLatinArray(int stepNum, List<Integer> sourceArray) {
        int rowPointer = 0;
        int colPointer = 0;
        return isSequenceRow(stepNum, rowPointer, sourceArray)
                && isSequenceCol(stepNum, colPointer, sourceArray);
    }

    private boolean isSequenceRow(int stepNum, int curPointer,
            List<Integer> sourceArray) {
        int expectedNum = sourceArray.get(curPointer) + 1;
        for (int i = 1; i < stepNum; i++) {
            if (expectedNum != sourceArray.get(i)) {
                return false;
            } else {
                expectedNum++;
            }
        }
        return true;
    }

    private boolean isSequenceCol(int stepNum, int curPointer,
            List<Integer> sourceArray) {
        int expectedNum = sourceArray.get(curPointer) + 1;
        for (int i = 1; i < stepNum; i++) {
            if (expectedNum != sourceArray.get(i)) {
                return false;
            } else {
                expectedNum += stepNum;
            }
        }
        return true;
    }

    private void printResult(boolean isLatinArray, boolean isStandardLatinArray) {
        if (isLatinArray) {
            if (isStandardLatinArray) {
                System.out.println(">>>>>checking result == the array is standard latin array == 2");
            } else {
                System.out.println(">>>>>checking result == the array is latin array == 1");
            }
        } else {
            System.out.println(">>>>>checking result == the array not latin array == 0");
        }
    }

    public static void main(String[] args) throws IOException {
        LatinArrayHandler latinArrayHandler = new LatinArrayHandler();
        int stepNum = 0;
        while (true) {
            System.out.println("===== start the latin array checking===========");
            System.out.println("please input the step number>>");
            Scanner scanner = new Scanner(new InputStreamReader(System.in));
            stepNum = Integer.parseInt(scanner.nextLine());
            if (stepNum <= STOP_SIGNAL) {
                scanner.close();
                break;
            } else {
                List<Integer> sourceList = new ArrayList<Integer>();
                System.out.println("the step number is [" + stepNum + "], please input the array with the format:" + stepNum + " * " + stepNum);
                for (int i = 0; i < stepNum; i++) {
                    String line = scanner.nextLine();
                    String[] numsLine = line.split(" ");
                    for (String str : numsLine) {
                        sourceList.add(Integer.parseInt(str));
                    }
                }
                boolean isLatinArray = latinArrayHandler.isLatinArray(stepNum, sourceList);
                boolean isStandardLatinArray = latinArrayHandler.isStandardLatinArray(stepNum, sourceList);
                latinArrayHandler.printResult(isLatinArray, isStandardLatinArray);
            }
        }
        System.out.println("===== stopped the latin array checking===========");
    }
}


zqftisson
zqftisson   2016.03.19 17:52

其实挺简单的。所谓的拉丁方阵,你研究它的特点,无非就是行列相加的结果相同。标准拉丁方阵只是多了一点限制。

根据这些特点,很容易就可以编码了。

package questions;

import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

public class LatinArrayHandler {

    private static int STOP_SIGNAL = 0;

    private boolean isLatinArray(int stepNum, List<Integer> sourceArray) {
        int firstRowCount = 0;
        for (int i = 0; i < stepNum; i++) {
            firstRowCount += sourceArray.get(i);
        }
//      System.out.println("firstRowCount=" + firstRowCount);
        int rowPointer = 0;
        int colPointer = 0;
        for (int j = 0; j < stepNum; j++) {
//          System.out.println("========the [" + j + "] row and col count======");
            if (countRowNums(stepNum, rowPointer, sourceArray) != firstRowCount
                    || countColNums(stepNum, colPointer, sourceArray) != firstRowCount) {
                return false;
            } else {
                rowPointer += stepNum;
                colPointer++;
            }
        }
        return true;
    }

    private int countRowNums(int stepNum, int curPointer,
            List<Integer> sourceArray) {
        int rowTotal = 0;
        for (int i = 0; i < stepNum; i++) {
            rowTotal += sourceArray.get(curPointer);
            curPointer++;
        }
//      System.out.println(" this row total = " + rowTotal);
        return rowTotal;
    }

    private int countColNums(int stepNum, int curPointer,
            List<Integer> sourceArray) {
        int colTotal = 0;
        for (int i = 0; i < stepNum; i++) {
            colTotal += sourceArray.get(curPointer);
            curPointer += stepNum;
        }
//      System.out.println(" this col total = " + colTotal);
        return colTotal;
    }

    private boolean isStandardLatinArray(int stepNum, List<Integer> sourceArray) {
        int rowPointer = 0;
        int colPointer = 0;
        return isSequenceRow(stepNum, rowPointer, sourceArray)
                && isSequenceCol(stepNum, colPointer, sourceArray);
    }

    private boolean isSequenceRow(int stepNum, int curPointer,
            List<Integer> sourceArray) {
        int expectedNum = sourceArray.get(curPointer) + 1;
        for (int i = 1; i < stepNum; i++) {
            if (expectedNum != sourceArray.get(i)) {
                return false;
            } else {
                expectedNum++;
            }
        }
        return true;
    }

    private boolean isSequenceCol(int stepNum, int curPointer,
            List<Integer> sourceArray) {
        int expectedNum = sourceArray.get(curPointer) + 1;
        for (int i = 1; i < stepNum; i++) {
            if (expectedNum != sourceArray.get(i)) {
                return false;
            } else {
                expectedNum += stepNum;
            }
        }
        return true;
    }

    private void printResult(boolean isLatinArray, boolean isStandardLatinArray) {
        if (isLatinArray) {
            if (isStandardLatinArray) {
                System.out.println(">>>>>checking result == the array is standard latin array == 2");
            } else {
                System.out.println(">>>>>checking result == the array is latin array == 1");
            }
        } else {
            System.out.println(">>>>>checking result == the array not latin array == 0");
        }
    }

    public static void main(String[] args) throws IOException {
        LatinArrayHandler latinArrayHandler = new LatinArrayHandler();
        int stepNum = 0;
        while (true) {
            System.out.println("===== start the latin array checking===========");
            System.out.println("please input the step number>>");
            Scanner scanner = new Scanner(new InputStreamReader(System.in));
            stepNum = Integer.parseInt(scanner.nextLine());
            if (stepNum <= STOP_SIGNAL) {
                scanner.close();
                break;
            } else {
                List<Integer> sourceList = new ArrayList<Integer>();
                System.out.println("the step number is [" + stepNum + "], please input the array with the format:" + stepNum + " * " + stepNum);
                for (int i = 0; i < stepNum; i++) {
                    String line = scanner.nextLine();
                    String[] numsLine = line.split(" ");
                    for (String str : numsLine) {
                        sourceList.add(Integer.parseInt(str));
                    }
                }
                boolean isLatinArray = latinArrayHandler.isLatinArray(stepNum, sourceList);
                boolean isStandardLatinArray = latinArrayHandler.isStandardLatinArray(stepNum, sourceList);
                latinArrayHandler.printResult(isLatinArray, isStandardLatinArray);
            }
        }
        System.out.println("===== stopped the latin array checking===========");
    }
}


结果大概是这样

图片说明

我没帮你做异常处理和输入检测。

ps:做IT的英雄某问出处,平时自己多动手就会有提高的。

zqftisson
zqftisson   2016.03.19 18:26

吃饭的时候想到我漏了一个重要的特性:每一行(或列)中的元素应该是互斥的。在你的题目要求中就是说每一行(列)都应该包含有不一样的正整数。
你把这个加强条件也加进去吧,改造一下 isLatinArray() 和 isStandardLatinArray()。

Csdn user default icon
上传中...
上传图片
插入图片
准确详细的回答,更有利于被提问者采纳,从而获得C币。复制、灌水、广告等回答会被删除,是时候展现真正的技术了!
其他相关推荐
拉丁矩阵问题
#include<iostream> #include<fstream> #include<algorithm> using namespace std;const int MAX = 50; int n, m; int board[MAX][MAX];//考察当前列是否有相同形状的宝石 bool ok(int r, int c, int k) { for(int i=1; i<r; i++
拉丁矩阵问题 利用回溯法的C++实现方案
这两天正好在赶算法设计的作业,这里把做的几个需要写代码的题放上来,方便以后查看。 1.题目要求 2.算法思想 这个题目基本思想是 利用回溯法,对于 m 行 n 列, 本质上就是一个二维数组, 我们可以将问题的解写成 x[1],x[2],x[3] … x[m*n], 那么对于每个点 x[i] 的取值实际上是 [1, n], 套用回溯法的算法框架,这里的 约束条件 ,就是同行,同列 没有相
算法 拉丁矩阵问题
题目现有n种不同形状的宝石,每种宝石有足够多颗。欲将这些宝石排列成m行n列的一个矩阵,m<=n,使矩阵中每一行和每一列的宝石都没有相同的形状。 试设计一个算法,计算出对于给定的m和n,有多少种不同的宝石排列方案。#include <stdio.h> #include <math.h> #define m 3 #define n 3 int a[m][n]; int count=0;//
拉丁方块填数字--蓝桥杯国赛历年真题
方块填数  “数独”是当下炙手可热的智力游戏。一般认为它的起源是“拉丁方块”,是大数学家欧拉于1783年发明的。 如图[1.jpg]所示:6x6的小格被分为6个部分(图中用不同的颜色区分),每个部分含有6个小格(以下也称为分组)。     开始的时候,某些小格中已经填写了字母(ABCDEF之一)。需要在所有剩下的小格中补填字母。     全部填好后,必须满足如下约束:    1. 所填字母只允许是...
互联网上的维吾尔文拉丁字符问题
互联网上的维吾尔文拉丁字符问题,互联网上的维吾尔文拉丁字符问题,互联网上的维吾尔文拉丁字符问题,互联网上的维吾尔文拉丁字符问题
关于“拉丁方”的C语言程序
构造N*N  阶的拉丁方阵(2     如N=4时:                                                     1         2         3          4                                                      2        3         4        
重复拉丁矩阵
#include<iostream> #include<fstream> #include<algorithm> using namespace std;const int MAX = 50; int n, m, k; int times[MAX]; //每种宝石的重复次数 int id[MAX]; //每个宝石的价值序号 int board[MAX][MAX]; //宝石矩阵//考察当前列宝
小猪的数据结构辅助教程——2.6 经典例子:魔术师发牌问题和拉丁方阵问题
小猪的数据结构辅助教程——2.6 经典例子:魔术师发牌问题和拉丁方阵问题标签(空格分隔): 数据结构本节引言: 本节继续带来的是循环链表的两个经典例子,分别是魔术师发牌问题和拉丁方阵问题! 1.魔术师发牌问题问题描述: 魔术师利用一副牌中的13张黑桃牌,预先将他们排好后叠放在一起,牌面朝下。对观众说:“我不看牌,只数数就可以次熬到每张牌是什么,我大声数数,你们听,不信?现场演示。”魔术师将牌
拉丁超立方抽样软件
拉丁超立方抽样软件,pest公司开发的应用于拉丁超立方抽样的软件,可以参考
拉丁超立方抽样 Latin hypercube sampling,java 代码
生成随机样本时,若是简单的随机抽样,会有数据过度聚集的问题,拉丁超立方抽样解决了这个问题。 下面用图说明两者的区别: 图中可以看出,简单随机抽样中的数据大部分在中间,而拉丁立方抽样则均匀产生在各个小区间内。 拉丁立方抽样必须首先明确生成的样本个数 n,拉丁立方抽样的步骤: 1. 将 [0, 1] 分为 n 等份,每个小区间内 [i/n, (i+1)/n] 内根据均匀分布随机产生一个数。...