楼主可以用下面的方法，我刚做的，有注释！最后结果为436！如果不懂，可以再问我！
public class RenShu {
public static void main(String[] args) {
int peop = 500//有500个人
boolean[] brr = new boolean[peop]//声明一个500个元素的Boolean数组
Arrays.fill(brr, true)//默认都为true
int count=0//报数号
int remain=peop//剩下的人数
int index=0//数组下标号
while(remain!=1){//剩下人不是一个时继续
if(brr[index]){//该元素为false时不计数
count++//计数
if(count%3==0){//计数为3时做以下三件事
brr[index]=false//将该元素值改为false，为了标志他被淘汰，不参加报数
remain--//剩下的人数减一
count=0//计数清零，重新报数
}
}
index++//数组下标增加
if(index==peop){
index=0//如果数组下标和人数相等，即一个循环结束，应重新开始
}
}
for(int i=0i<brr.lengthi++){
if(brr[i]){
System.out.println(i+1)//最后打印那个唯一的true的下标值，因为数组从0开始，所以要加1
}
}
}
}
public static int [] getRemoveSame(int [] srcArray){List<Integer>list = new ArrayList<Integer>()
for (int i = 0i <srcArray.lengthi++) {
//如果list里已经有数组的某个元素，则不添加到list中，进行下次循环
if (list.contains(srcArray[i])) {
continue
}
list.add(srcArray[i])
}
int [] newArray = new int[list.size()]
int index = 0
for (int a : list) {
newArray[index++] = a
}
return newArray
}
方法一：import java.util.ArrayList
import java.util.List
public class test10 {
// 解题思路：先带走猫，后带走狗，再把猫带回，把鱼带过去，最后再把猫带过去即可
// 定义两个集合，存放，带过去的动物，和剩下的动物
static List<String>there = new ArrayList<String>()
static List<String>here = new ArrayList<String>()
public static void main(String[] args) {
here.add("cat")
here.add("dog")
here.add("fish")
test10 test10 = new test10()
test10.take()
}
// 判断动物是否安全
public boolean isSafty(List<String>list) {
// 如果一个集合中同时出现了猫和狗，猫和鱼的都认为不安全
if (list.add("dog") &&list.add("cat") || list.add("cat")
&&list.add("fish")) {
return false
}
return true
}
public void take() {
// 得到要带走的动物
String anim = here.get(0)
// 从剩下的集合中删除
here.remove(here.get(0))
if (anim.equals("cat")) {
// 添加到以带过去的集合里面
there.add(anim)
// 继续带下一个动物
if (here.isEmpty()) {
System.out.println()
System.out.println("最后在把" + anim + "带走了")
return
} else {
System.out.println("带走了" + anim)
System.out.print("剩下：")
for (String s : here) {
System.out.print(s + " ")
}
System.out.println()
System.out.println("----------------------------")
take()
}
} else if (anim.equals("dog")) {
there.add(anim)
System.out.println("然后把" + anim + "带走")
// 判断是否安全，之后继续带下一个动物
if (isSafty(there)) {
take()
} else {
String animal = there.get(0)
there.remove(animal)
here.add(animal)
System.out.println("然后把" + animal + "带回")
// 继续带下一个动物
take()
}
} else if (anim.equals("fish")) {
System.out.print("之后把" + anim + "带走")
take()
}
}
}
方法二：
import java.util.ArrayList
import java.util.Random
/*
* 需求:
* 一位老农带着猫、狗、鱼过河，河边有一条船，每次老农只能带一只动物过河。
* 当老农不和猫狗鱼在一起时，狗会咬猫，猫会吃鱼，当老农和猫狗鱼在一起时，则不会发生这种问题。
* 编程解决猫狗鱼过河问题。
* 分析:
* 定义猫,狗,鱼元素.定义两岸集合.定义方法判断不和谐状况.
* 步骤:
* 1.将猫狗鱼抽象为三个String型变量.将两岸抽象为两个集合.
* 2.定义判断是否和谐方法.
* */
public class Test10 {
public static void main(String[] args) {
//开始过河.
doTransport()
}
public static void doTransport() {
// 抽象出猫,鱼,狗和两岸.
ArrayList<String>arr1 = new ArrayList<String>()
ArrayList<String>arr2 = new ArrayList<String>()
arr1.add("鱼")
arr1.add("猫")
arr1.add("狗")
// 农夫将要携带到船上动物.(前一字符表示农夫当前携带动物,后一字符表示上次农夫携带的动物,为了让农夫不出现重复拿同一个动物的情况)
System.out.println("农夫,猫,鱼,狗都在此岸,开始过河.\n")
String[] boat ={"-","-"}
while (arr1.size() >0) {
move(arr1, arr2, boat)
}
System.out.println("\n农夫,猫,鱼,狗都到达彼岸.")
}
public static void move(ArrayList<String>arr1, ArrayList<String>arr2,String[] boat) {
//农夫船上是否有动物,有则不需随机选择携带.
if (boat[0].equals("-")) {
int one=0
do{
// 农夫从此岸随机带上一个动物.
one = new Random().nextInt(arr1.size())
}while(arr1.get(one).equals(boat[1]))
boat[1]=boat[0]
boat[0] = arr1.get(one)
arr1.remove(one)
}
// 判断此岸是否和谐
if (ifNice(arr1)) {
// 此岸和谐,农夫则将动物送去彼岸.
arr2.add(boat[0])
System.out.println("--->农夫带" + boat[0] + "去彼岸")
//首先判断是否将三个动物都放彼岸,是则无需判断是否和谐.
if(arr2.size()==3){
return
}
// 判断彼岸是否和谐.
if (ifNice(arr2)) {
// 彼岸和谐,农夫则完成此次运送.
boat[1]=boat[0]
boat[0] ="-"
System.out.println("农夫单独回此岸<---")
} else {
// 彼岸不和谐,农夫则将岸上动物与携带动物交换.送回此岸.
boat[0]=arr2.get(0)
System.out.println("农夫带" +boat[0]+ "回此岸<---")
arr2.remove(0)
arr1.add(boat[0])
boat[1]=boat[0]
boat[0]="-"
}
} else {
// 如果此岸不和谐则放回此岸.
arr1.add(boat[0])
boat[1]=boat[0]
boat[0]="-"
}
}
public static boolean ifNice(ArrayList<String>arr) {// 判断是能否共存.
if ((arr.contains("猫") &&arr.contains("狗"))
|| (arr.contains("鱼") &&arr.contains("猫"))) {
return false
} else {
return true
}
}
}
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）