【剑指Offer】抽象建模能力

n个骰子的点数

题目描述

把n个骰子仍在地上，所有骰子朝上一面的点数之和为s。输入n，打印出s的所有可能值出现得概率。

分析

以六面骰子为例，n个骰子向上的数字和的范围为[n, n×6]。
考虑用两个数组来存储骰子点数的每一个总数出现的次数。
使用循环的方式，每次循环加一个骰子，则循环n次就可以得到n个骰子的点数和。
以n=3为例，令k分别等于：1,2,3（从1到3）

当k=1时，出现的点数可能是1，2，3，4，5，6中任意一个，这些数字等概率出现。

当k=2时，出现的点数和分别为2，3，4，……，11，12，
点数和为2时， 2=1+1；（1种）
点数和为3时， 3=1+2=2+1；（2种）
点数和为4时， 4=1+3=2+2=3+1；（3种）
点数和为5时， 5=1+4=2+3=3+2=4+1；（4种）
点数和为6时， 6=1+5=2+4=3+3=4+2=5+1；（5种）
点数和为7时， 7=1+6=2+5=3+4=4+3=5+2=6+1；（6种）
点数和为8时， 8=2+6=3+5=4+4=5+3=6+2；（5种）
点数和为9时， 9=3+6=4+5=5+4=6+3；（4种）
点数和为10时，10=4+6=5+5=6+4；（3种）
点数和为11时，11=5+6=6+5；（2种）
点数和为12时，12=6+6；（1种）
总结
当 n<6 时，arr1[n]=$\sum$(arr2[n-1], ……, arr2[0]）;
当 6<=n<=k×6 时，arr1[n]=$\sum$(arr2[n-1], arr2[n-2], arr2[n-3], arr2[n-4],arr2[n-5], arr[n-6])

当k=3时，同理，出现的点数和分别为3，4，5，……，17，18，

Java代码

import java.util.*;

class Solution{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int cnt = sc.nextInt();
		printP(cnt);
		sc.close();
	}
	public static void printP(int n) {
		if(n < 1)
			return;
		int[][] arr = new int[2][6*n+1];
		
		int flag = 0;
		for(int i=1; i<=6; i++) 
			arr[flag][i] = 1;
		
		for(int k=2; k<=n; k++) {
			for(int i=0; i<k; i++)
				arr[flag][i] = 0;
			for(int i=k; i<=6*k; i++) {
				for(int j=1; j<=i && j<=6; j++) {
					arr[1-flag][i] += arr[flag][i-j];
				}
			}
			flag = 1-flag;
		}
		
		double total = Math.pow(6, n);
		for(int i=n; i<=6*n; i++) {
			double ratio = (double)arr[flag][i] / total;
			System.out.format("%d: %.3f\n", i, ratio);
		}
	}
}

实例1
输入

1

输出

1: 0.167
2: 0.167
3: 0.167
4: 0.167
5: 0.167
6: 0.167

实例2
输入

3

输出

3: 0.005
4: 0.009
5: 0.019
6: 0.032
7: 0.046
8: 0.069
9: 0.093
10: 0.106
11: 0.111
12: 0.106
13: 0.093
14: 0.069
15: 0.046
16: 0.028
17: 0.014
18: 0.005

---

扑克牌的顺子

题目描述

从扑克牌种随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。2~10为数字本身，A为1，J为11，Q为12，K为13，大小王共有4张，记为0，可以当作任何数字。

分析

情况1
5张牌中没有大小王时，5张牌一定是连续的5个非0数字，即最大值-最小值=4；

情况2
5张牌中有大王或小王n(1<=n<=4)张，其他(5-n)张牌的数值互异，且最大值(max)-最小值(min)<=4

• 当max-min=4时，
  max与min之间差3个连续的数值，则那3张牌中可能有0，1，2，3个王；
• 当max-min=3时，
  max与min之间差2个连续的数值，则那3张牌中可能有0，1，2个王。还有一张牌一定为王，可以当作 (min-1)或 (max+1)，共可能有1，2，3个王；
• 当max-min=2时，
  max与min之间差1个连续的数值，则那3张牌中可能有0，1个王。还有两张牌一定为王，可以当作 (min-2)(min-1) 或 (min-1)(max+1) 或 (max+1)(max+2)；
• 当max-min=1时，
  其他三张牌一定为王牌，可以当作 (min-3)(min-2)(min-1) 或 (min-2)(min-1)(max+1) 或 (min-1)(max+1)(max+2) 或 (max+1)(max+2)(max+3)；
• 当max-min=0时，
  其他四张牌一定为王牌，可以当作 (min-4)(min-3)(min-2)(min-1) 或 (min-3)(min-2)(min-1)(max+1) 或 (min-2)(min-1)(max+1)(max+2) 或 (min-1)(max+1)(max+2)(max+3) 或 (max+1)(max+2)(max+3)(max+4)。

总结如下：

1. 最大值-最小值<5；
2. 除了0，没有连续的数字。

Java代码

public class Solution {
    public boolean isContinuous(int [] numbers) {
        if(numbers==null || numbers.length <5)
            return false;
        int min = Integer.MAX_VALUE;
        int max = Integer.MIN_VALUE;
        int cnts[] = new int[14]; //记录0-13的个数
        for(int x : numbers){
            cnts[x]++;
            if(x!=0){
                max = x>max ? x : max;
                min = x<min ? x : min;
            }
        }
        if(max-min > 4)
            return false;
        for(int k=1; k<14; k++){
            if(cnts[k] > 1)
                return false;
        }
        return true;
    }
}

---

圆圈中最后剩下的数字

题目描述

0，1，2，……，n这n个数字排成一个圆圈，从数字0开始每次从这个圆圈中删除第m个数字，求这个圆圈中剩下的最后一个数字。

分析

方法1
可以使用环形链表或者数组模拟圆圈，为了方便下面的代码中采用数组。

1. 数组中被删除的元素用-1代替；
2. 记录剩下的个数cnt，当cnt==n时，跳出循环，即删除了最后一个数字，返回该数字即可；
3. 当下标>=n时，说明已经访问到数组的最后，重新令下标等于0，以模拟圆圈。

方法2（存疑）
《剑指Offer》上的创新做法。

1. 记n和m的关系为$f(n,m)$，表示从n个数字的序列中删除第m个数字后剩下的数字。
2. 删除的第$m$个元素值为$k=(m-1)\%n$;
3. $f(n,m)$经过删除元素和序列的重排之后记为$f^{\prime }(n-1,m)$，该序列和原序列相比已经发生了改变，有(n-1)个元素，从下一个删除的元素(k-1)开始。
   且$f(n,m)=f^{\prime }(n-1,m)$。
4. $f^{\prime }(n-1,m)$通过映射函数p映射为一个连续的升序序列，从该序列中删除第m个元素得到$f(n-1,m)$。
5. 很容易推导出，映射函数为$p(x)=(x-k-1)\%n$，则其逆映射为$p^{-1}(x)=(x+k+1)\%n$。所以，$f^{\prime }(n-1,m)=p^{-1}[f(n-1,m)]=[f(n-1,m)+k+1]\%n$。
6. 代入$k=(m-1)\%n$可得$f(n,m)=f’(n-1,m)=[f(n-1,m)+m]%n。f(1)=0，当圆圈中只剩下一个数字的时候一定是0。

疑问：
$f^{\prime }(n-1,m)$中的元素个数为(n-1)，而$f(n-1,m)$中的元素个数为(n-2)，之间不能实现一一映射。

Java代码

public class Solution {
	public int LastRemaining_Solution(int n, int m) {
        int[] arr = new int[n];
        int cnt = n;
        int idx = -1;
        int step = 0;
        while(cnt != 0){
        	idx++; //每次删除从下一个元素开始计数
        	idx = idx>=n ? 0 : idx; //当前访问的数组的元素的下标
        	if(arr[idx] == -1) // 若被访问过，则跳过该元素
        		continue;
        	step++; //若没有访问过，则步数+1
        	if(step == m) { //步数等于m时表示当前元素即为需删除的元素
        		arr[idx] = -1;
        		step = 0;
        		cnt--;
        	}
        }
        return idx;
	}
}