渔夫分鱼算法的实现

Question

A，B，C，D，E五个渔夫夜间合伙捕鱼，凌晨都疲惫不堪，各自在草丛中熟睡。
第二天清晨A先醒来，他把鱼均分五份，把多余的一条扔回湖中，便拿了自己的一份回家了，
B醒来后，也把鱼均分五份，把多余的一条扔回湖中，便拿了自己的一份回家了，
C,D,E也按同样方法分鱼。问5人至少捕到多少条鱼？请给出代码。

Answer 1

此回复为自动发出,仅用于显示而已，并无任何其他特殊作用
楼主【tteesstt】截止到2008-06-28 22:09:35的历史汇总数据(不包括此帖)：
发帖数:73                 发帖分:3600               
结贴数:73                 结贴分:3600               
未结数:0                  未结分:0                  
结贴率:100.00%            结分率:100.00%            
敬礼!

Answer 2

public class Csdn { public static void main(String[] args){
    for (int i = 0;; i++) {
        int sum = i;
        for (int j = 0; j < 5; j++) {
            if (sum % 5 == 1)
                sum = (sum / 5)*4;
            else
                sum = 0;
        }
        if (sum != 0) {
            System.out.println(i);
            break;
        }
    }
}
}

Answer 3

public class test {
public static void main (String[] arge) {
int i=0;
do{
i++;
if ( f (5,i*5+1) ) {
System.out.println (i*5+1);
System.exit (0);
}
}
while(true);
}
public static boolean f (int a,int b) {
if ( (b-1)%5==0 ) {
if (a==1) return true;
else return f (a-1,(b-1)/5*4);
}
return false;
}
}

Answer 4

main(){
int n,i,x,flag=1;
for(n=6;flag;n++){
for(x=n,i=1;flag&&i<=5;i++)
if((x-1)%5==0)x=4*(x-1)/5;
else flag=0;
if(flag)break;
else flag=1;
}
printf("Total fish=%d\n",n);
}答案3121

Answer 5

n mod 5=1
第一个拿走自己的一堆后同样除5余1，
即4k mod 5=1，
所以 k mod 5 =4
同理，第二个、第三个……都是4堆余1，自然一堆余4
这正是“除基数取余”的方法，所以答案就是5进制的 44441
(44441)5=3121D---------------
(44441)5 / (10)5=(4444)5    余1（5）
(4444/4堆)5 mod (10)5=(1111)5mod(10)5=4

Answer 6

public class test {
public static void main (String[] arge) {
int i=0;
do{
i++;
if ( f (5,i*5+1) ) {
System.out.println (i*5+1);
System.exit (0);
}
}
while(true);
}
public static boolean f (int a,int b) {
if ( (b-1)%5==0 ) {
if (a==1) return true;
else return f (a-1,(b-1)/5*4);
}
return false;
}
}这个递归是正确的

Answer 7

代码：
public class Fy { /**
 * 求解渔夫分鱼问题（穷举法）。
 * @param num 渔夫数。
 * @param mod 每次丢掉鱼数。
 * @return 这些渔夫至少捕到多少条鱼能使条件成立。
 */
public static int fy(final int num, final int mod) {
if (num < 1 || mod < 1) return -1;
int min = num + mod;
while (min < Integer.MAX_VALUE) {
int m = min;
int i = num;
do {
if (m % num != mod) break;
m -= mod;
m -= m / num;
} while (--i > 0);
if (i == 0) return min;
++min;
}
return -1;
} public static void main(String[] args) {
System.out.println(fy(5, 1));
}}
答案：
3121

Answer 8

public class Fy {    /**
     * 求解渔夫分鱼问题（穷举法）。
     * @param num 渔夫数。
     * @param mod 每次丢掉鱼数。
     * @return 这些渔夫至少捕到多少条鱼能使条件成立。
     */
    public static int fy(final int num, final int mod) {
        if (num < 1 || mod < 1) return -1;
        int min = num + mod;
        while (min < Integer.MAX_VALUE) {
            int m = min;
            int i = num;
            do {
                if (m % num != mod) break;
                m -= mod;
                m -= m / num;
            } while (--i > 0);
            if (i == 0) return min;
            ++min;
        }
        return -1;
    }    public static void main(String[] args) {
        System.out.println(fy(5, 1));
    }}

Answer 9

import java.io.*;public class Fenyu {

public static int FishNum(int n,int i,int j){
//FishNum(人数，每份鱼数，扔掉的），返回参与分配的鱼总数
return n*i+j;
}

public static void main(String args[]){
int a[]=new int [5];
a[4]=1;
for (int i=3;i>=0;i--){
a[i]=FishNum(5,a[i+1],1);
}
int sum=FishNum(5,a[0],1);
System.out.println("鱼总数为："+sum);
}
}鱼总数为：3906;

Answer 10

3楼 lord_is_layuping 的算法也正确，速度比我的要快些。

Answer 11

应该是3906条鱼，因为问题问的是至少捕到多少鱼，所以最后一个渔夫分鱼时，应该是6条鱼
public class CentFish{
    private static long count_peach(int n) //n为5个渔夫
    {
        if(n == 1)
        {
           return 6;
        }
        else
        {
            return count_peach(n - 1) * 5 + 1;
        }
    }
    public static void main(String[] args) {
        System.out.print(count_peach(5));
    }
}

Answer 12

应该是3906条，，
用递归
class Demo{
public static void main(String[] args){
long x=f(5);
System.out.println("有"+x+"条鱼");
   
}
static long f(int i){
     
     if(i==1){
    
    return 6;
    }
    else   
    return f(i-1)*5+1;
}
}

Answer 13

[code]
/**
 * @(#)Fenyu.java
 *
 *
 * @nuciewth 
 * @version 1.00 2008/6/29
 */
public class Fenyu {    public Fenyu() {
    }
    public static void main (String[] args) {
     int temp=1;
        for(int i = 1 ; i < 6; i++){
         temp=temp*5+1;
        }
        System.out.println(temp);
    } 
}
[/code]

Answer 14

/**
 * @(#)Fenyu.java
 *
 *
 * @nuciewth 
 * @version 1.00 2008/6/29
 */
public class Fenyu {    public Fenyu() {
    }
    public static void main (String[] args) {
     int temp=1;
        for(int i = 1 ; i < 6; i++){
         temp=temp*5+1;
        }
        System.out.println(temp);
    } 
}

Answer 15

给一个简单的算法，不需要递归
  public static void main(String[] arge) {
    int i, j, num;
    for (i = 1;; i++) {
      num = i;
      for (j = 0; j < 4; j++) {
        if ((num * 5 + 1) * 5 % 4 != 0)
          break;
        else
          num = (num * 5 + 1) / 4;
      }
      if (j == 4) {
        System.out.println("num*5+1  :" + (num * 5 + 1));
        System.out.println("i   :" + i);
        break;
      }
    }
  }

Answer 16

倒过来求， 最后一人分五堆扔一条，最少要5的整数倍加一条， 但是这总数又必须是上次分完剩余的 4 堆， 所以必须能被4整除， 
就是求 5X + 1 = 4Y   要求最少， 就是求符合条件的最小{X,Y}