最近又将之前买上的《算法》拾了起来,打算好好读读，后悔当初买上没有好好看，现在看来，真的是一本好书，让人着迷。

结合着 Coursear 上的课程，尝试完成了第一个编程作业。

经过多次提交分数才达到 89 分

准备

经过一周的学习发现，要做这周的编程题，首先要把这一章书籍内容自习看一遍，把书上写的算法代码可以看懂，并且可以写出来。书上内容阅读完成再看视频，视频会介绍书上的内容并和后面的习题有一些思路提示。

为了能完成作业需要下载与书籍配套的 algs4.jar 包，以编写代码。

试题

这是一个连通性问题，和最后一个视频课中提及的问题一样，只不过需要用算法写出来。

该题包含两个问题

构建一个可以渗透的网格

你需要编写一个 Percolation 类来进行构建，要实现下面的 API

public class Percolation {
   public Percolation(int n)                // create n-by-n grid, with all sites blocked
   public    void open(int row, int col)    // open site (row, col) if it is not open already
   public boolean isOpen(int row, int col)  // is site (row, col) open?
   public boolean isFull(int row, int col)  // is site (row, col) full?
   public     int numberOfOpenSites()       // number of open sites
   public boolean percolates()              // does the system percolate?

   public static void main(String[] args)   // test client (optional)
}

分别解释一下每个方法的意思。

Percolation(int n) 该方法是该类的构造器，要传入一个 n 用来构建一个 n × n 大小的网格。

open(int row,int col) 打开行为 row 列为 col 的格子，新构建的网格默认为全部关闭，我们需要通过这个方法打开表格。

isOpen(int row,int col) 检查这个坐标的网格是否处于 open 状态。

isFull(int row,int col) 检查从顶部到该网格是否连通。

numberOfOpenSites() 返回有多少网格处于 Open 状态。

percolates() 返回网格是否从上到下是否连通。

在视频里讲到可以把方格上下虚拟出来一个格子，只要证明上方虚拟格子连通就可以证明连通。

思路

当我们要检查网格之间是否连通时，可以用到书上关于连通性的算法，algs4.jar 里已经有加权连通性的算法实行，我们可以直接使用。

需要一个数组来进行初始化网格，这里用 sites 数组，将网格的初始值存放进去。使用一维数组来保存该网格数据，同时长度要比要求长两位，用来表示虚拟头部和虚拟底部,将这两个点默认为打开(open)

在将一个网格打开(open)的同时 openSites 进行计数，要将要将它与周围网格进行连通。首先考虑第一行和最后一行，有打开状态的就将它与虚拟头部或虚拟底部进行连通。之后在考虑其他的网格和它的周围(上，下，左，右)进行连通。

代码

import edu.princeton.cs.algs4.WeightedQuickUnionUF;

public class Percolation {

    private final WeightedQuickUnionUF uf;
    private final int n;
    private int[] sites;
    private int openSites = 0;

    // create n-by-n grid, with all sites blocked
    public Percolation(int n) {
        if (n <= 0) {
            throw new IllegalArgumentException();
        }
        this.n = n;
        uf = new WeightedQuickUnionUF(n * n + 2);
        sites = new int[n * n + 2];
        for (int i = 0; i < sites.length; i++) {
            sites[i] = 0;
        }
        sites[0] = 1;
        sites[sites.length - 1] = 1;
    }

    // open site (row, col) if it is not open already
    public void open(int row, int col) {
        if (row > n || col > n || row < 1 || col < 1) {
            throw new IllegalArgumentException();
        }
        if (!isOpen(row, col)) {
            int index = (row - 1) * n + col;
            sites[index] = 1;
            openSites++;
            if (row == 1) {
                uf.union(0, col);
            }
            if (row == n) {
                uf.union(sites.length - 1, index);
            }
            if (row < n) {
                // connected bottom
                if (isOpen(row + 1, col)) {
                    int newIndex = row * n + col;
                    uf.union(index, newIndex);
                }
            }
            if (row > 1) {
                // connected top
                if (isOpen(row - 1, col)) {
                    int newIndex = (row - 2) * n + col;
                    uf.union(index, newIndex);
                }
            }
            if (col < n) {
                if (isOpen(row, col + 1)) {
                    int newIndex = (row - 1) * n + col + 1;
                    uf.union(index, newIndex);
                }
            }
            if (col > 1) {
                // connected top
                if (isOpen(row, col - 1)) {
                    int newIndex = (row - 1) * n + col - 1;
                    uf.union(index, newIndex);
                }
            }
        }
    }

    // is site (row, col) open?
    public boolean isOpen(int row, int col) {
        if (row > n || col > n || row < 1 || col < 1) {
            throw new IllegalArgumentException();
        }
        int index = (row - 1) * n + col;
        return sites[index] == 1;
    }

    // is site (row, col) full?
    public boolean isFull(int row, int col) {
        if (row > n || col > n || row < 1 || col < 1) {
            throw new IllegalArgumentException();
        }
        if (isOpen(row, col)) {
            int index = (row - 1) * n + col;
            return uf.connected(0, index);
        } else {
            return false;
        }
    }

    // number of open sites
    public int numberOfOpenSites() {
        return openSites;
    }

    // does the system percolate?
    public boolean percolates() {
        return uf.connected(0, sites.length - 1);
    }
}

蒙特卡洛模拟

当我们构建的 sites 中的网格不断为 open 状态的时候，当多少个网格状态成为 open 的时候该网格成为连通状态。计算蒙特卡洛模拟连通的阈值。

蒙特卡洛模拟也是先实现下面的 API

public class PercolationStats {
   public PercolationStats(int n, int trials)    // perform trials independent experiments on an n-by-n grid
   public double mean()                          // sample mean of percolation threshold
   public double stddev()                        // sample standard deviation of percolation threshold
   public double confidenceLo()                  // low  endpoint of 95% confidence interval
   public double confidenceHi()                  // high endpoint of 95% confidence interval
   public static void main(String[] args)        // test client (described below)
}

PercolationStats(int n, in trails) 这个是个构造函数，在初始化对象的时候传入构造网格的 n 和训练次数。

mean() 用于计算平均值

stddev() 用于计算标准差

confidenceLo() 计算置信区间下限

confidenceHi() 计算置信区间上限

思路

关于计算平均值，标准差，置信区间的公式试题上已经说明，而且在计算平均值和标准差的时候可以使用 algs4.jar 包中的 StdStats API。

我们要计算当打开多少个 site 的时候， 该网格处于连通状态。我们要做的就是不断的打开每个 site ，并且记录对应的值。 xi 数据记录渗透率。整体上不算难，只要我们使用前一问的 Percolation 类就可以很快的写出该构造函数。

代码

import edu.princeton.cs.algs4.StdIn;
import edu.princeton.cs.algs4.StdOut;
import edu.princeton.cs.algs4.StdRandom;
import edu.princeton.cs.algs4.StdStats;

public class PercolationStats {

    private Percolation percolation;
    private int trials;
    private final double[] xi;

    // perform trials independent experiments on an n-by-n grid
    public PercolationStats(int n, int trials) {
        if (n <= 0 || trials <= 0) {
            throw new IllegalArgumentException();
        }
        this.trials = trials;
        xi = new double[trials];
        for (int i = 0; i < trials; i++) {
            percolation = new Percolation(n);
            int count = 0;
            while (true) {
                int col = StdRandom.uniform(1, n + 1);
                int row = StdRandom.uniform(1, n + 1);
                if (!percolation.isOpen(row, col)) {
                    percolation.open(row, col);
                    count++;
                    boolean isP = percolation.percolates();
                    if (isP) {
                        double x = count * 1.0 / (n * n);
                        xi[i] = x;
                        break;
                    }
                }
            }
        }
    }

    // sample mean of percolation threshold
    public double mean() {
        return StdStats.mean(xi);
    }

    // sample standard deviation of percolation threshold
    public double stddev() {
        return StdStats.stddev(xi);
    }

    // low  endpoint of 95% confidence interval
    public double confidenceLo() {
        return mean() - (1.96 * stddev()) / Math.sqrt(trials);
    }

    // high endpoint of 95% confidence interval
    public double confidenceHi() {
        return mean() + (1.96 * stddev()) / Math.sqrt(trials);
    }

    public static void main(String[] args) {
        int n = StdIn.readInt();
        int t = StdIn.readInt();
        PercolationStats ps = new PercolationStats(n, t);
        StdOut.println("mean =" + ps.mean());
        StdOut.println("stddev = " + ps.stddev());
        StdOut.println("95% confidence interval = [" + ps.confidenceLo() + ", " + ps.confidenceHi() + "]");
    }
}

总结

这个题的两个问题层层递进，将计算渗透率的问题化解问两个问题，并且在第一问中还会使用到前面的连通性计算的问题,并且在问题的分解上和书籍一样，先给出每个方法的 API，我们只要去实现对应API即可，可见设计该问题时候作者的用心。

下文所有内容基本总结于 《数据挖掘概念与技术 第三版》机械工业出版社

最近复习数据挖掘课程，就把复习的几个算法记录一下。

什么是Apriori算法

Apriori算法是 Agrawal 和 R.Srikant 与1994 提出的，为布尔关联规则挖掘频繁项集的原创性算法。Apriori算法使用一宗称为逐层搜索的迭代方法，其中 k 项集用于探索 (k+1) 项。

基本为扫描数据库，累计每个项的计数，并且收集满足最小支持度的项，找出频繁1项集的集合。该集合记为L1。然后，使用L1找出频繁2项集的集合L2，如此一直找下去，知道不能再找到频繁k项集，找出每个Lk需要一次数据库的完整扫描。

寻找频繁项集

先验性质

为了提高频繁项集逐层产生的效率，一种称为先验性质的重要性质用于压缩搜索空间。

先验性质：频繁项集的所有非空子集也一定是频繁的。

该表是一个事务数据库D。该数据库有9个事务，即|D|=9。假设最小支持度为2

1. 在算法第一次迭代的时候，每个项都是候选1项集的集合C1的成员。算法扫描，统计出每个项出现的次数。

2. 可以确定频繁1项集的集合L1，它由满足最小支持段的候选1项集组成。

3. 为发现频繁2项集的集合L2，算法使用L1 🔗 L1产生候选2项集的集合C2。注意剪枝，没有候选的C2中删除，因为这些候选的每个子集也是频繁的。

4. 扫描D中的事务，累计C2中的每个候选项集的支持技术。

5. 然后确定频繁2项集的集合L2，它由C2中满足最小支持度的候选2项集组成。

6. …………

重复以上步骤，直到Cn = ∅，此算法终止，找出所有的频繁项集。

由频繁项集产生关联规则

一旦由数据库D中的事务找出频繁项集，就可以直接由它们产生强关联规则。对于置信度，可以用下面的公式计算。

confidence(A ＝>B) = P（A | B）= support_count(A ∪ B) / support_count(A)

继续使用上面的案例，该数据包含频繁项集 x = {I1,I2,I5},可有X产生哪些关联规则，并且计算{I1,I2},{I1,I5},{I1}置信度

产生的关联规则

{I1,I2},{I1,I5},{I2,I5},{I1},{I2},{I5}

{I1,I2} => I5, confidence = 2 / 4 = 50%

{I1,I5} => I2, confidence = 2 / 2 = 100%

在推荐系统中有很多算法，其中一种就是协同过滤算法。

分类

在协同过滤算法中，分为两类，基于用户的协同过滤(UserCF)和基于物品的协同过滤(ItemCF)。每个类型的适用情况不同。

在上述的两种类型中，基于用户的协同过滤算法是不太常用的，原因如下

• 用户的数量是远远大于物品的数量，计算用户之间的相似度计算量会很大。
• 对于一个新用户很难找到相似度

所以一般是不会使用基于用户的协同过滤，但是并不表示不用，一般用于新闻推送等。

相似度计算

离散图表示

目前有五个用户对商品1和商品2的喜爱程度，分析用户之间的关系。

寻找他们的相似度

通过离散图来进行表示

可以看出 用户1 用户3 用户4 之间是存在关系的。

# coding = utf8
import matplotlib.pyplot as plt
import numpy as np

# 散点图分析五个用户之间的相关程度
# x轴为对于商品 1 的喜欢程度
# y轴是对于商品 2 的喜欢程度
# 数据如下
# 商品1 [3.3, 5.8, 3.6, 3.4, 5.2]
# 商品2 [6.5, 2.6, 6.3, 5.8, 3.1]

shop1 = [3.3, 5.8, 3.6, 3.4, 5.2]
shop2 = [6.5, 2.6, 6.3, 5.8, 3.1]
color = ['r', 'b', 'c', 'g', 'y', 'k', 'm', '0xff0012']
for i in range(0, len(shop1)):
    plt.scatter(shop1[i], shop2[i], c=color[i])
plt.xlim(0, 10)
plt.ylim(0, 10)
plt.ylabel("shopping 2")
plt.xlabel("shopping 1")
plt.legend('12345')
plt.show()

欧几里得距离

欧几里得距离是最常用的距离公式,用于计算两点之间的距离。公式如下：

通过计算两点之间的距离来表示他们之间的相关程度。

我们通过 python 计算 欧几里得距离。

# coding = utf8

#        1    2     3   4   5
shop1 = [3.3, 5.8, 3.6, 3.4, 5.2]
shop2 = [6.5, 2.6, 6.3, 5.8, 3.1]
for i in range(0, len(shop1) - 1):
    for j in range(i + 1, len(shop2)):
        distance = (shop1[i] - shop1[j]) ** 2 + (shop2[i] - shop2[j]) ** 2
        correlation = 1 / (1 + distance) # 将范围缩小至0 ~ 1 之间
        if correlation > 0.60:  # 根据需求更换相关系数
            print("第 {} and {}  distance is {}".format(i + 1, j + 1, correlation))

计算结果

第 1 和 2 相关系数是 0.04452359750667854

第 1 和 3 相关系数是 0.8849557522123891

第 1 和 4 相关系数是 0.6666666666666665

第 1 和 5 相关系数是 0.061842918985776124

第 2 和 3 相关系数是 0.051203277009728626

第 2 和 4 相关系数是 0.058823529411764705

第 2 和 5 相关系数是 0.6211180124223604

第 3 和 4 相关系数是 0.7751937984496123

第 3 和 5 相关系数是 0.07246376811594203

第 4 和 5 相关系数是 0.08673026886383348

得出结论，基本和离散图相似。

这样就可以根据需求来判断用户之间的相似度。

皮尔逊相关系数

皮尔逊相关系数同样也是计算距离的一种方式

通过相关系数可以计算出他们的相关程度。

适用范围

皮尔逊相关系数是有一定的适用条件。

当两个变量的标准差都不为零时，相关系数才有定义，皮尔逊相关系数适用于： (1)、两个变量之间是线性关系，都是连续数据。 (2)、两个变量的总体是正态分布，或接近正态的单峰分布。 (3)、两个变量的观测值是成对的，每对观测值之间相互独立。

同样这个算法也是有缺陷的,但数据越少的时候,波动性越大。当数据很少的时候不建议使用。

皮尔逊相关系数公式有四个

公式一：

公式二：

公式三：

公式四：

相关系数

• 0.8-1.0 极强相关
• 0.6-0.8 强相关
• 0.4-0.6 中等程度相关
• 0.2-0.4 弱相关
• 0.0-0.2 极弱相关或无相关

我们通过第四个公式进行计算

简单案例

通过 python 计算出相关系数

# coding=utf8


# 皮尔孙相关系数计算
def PearsonCorrelationSimilarity(vec1, vec2):
    value = range(len(vec1))

    sum_vec1 = sum([vec1[i] for i in value])
    sum_vec2 = sum([vec2[i] for i in value])

    square_sum_vec1 = sum([pow(vec1[i], 2) for i in value])
    square_sum_vec2 = sum([pow(vec2[i], 2) for i in value])

    product = sum([vec1[i] * vec2[i] for i in value])

    numerator = product - (sum_vec1 * sum_vec2 / len(vec1))
    dominator = ((square_sum_vec1 - pow(sum_vec1, 2) / len(vec1)) * (
        square_sum_vec2 - pow(sum_vec2, 2) / len(vec2))) ** 0.5

    if dominator == 0:
        return 0
    result = numerator / (dominator * 1.0)

    return result


if __name__ == '__main__':
    # 五个用户对五个商品的评价
    user1 = [3.3, 5.8, 3.6, 3.4, 5.2]
    user2 = [6.5, 2.6, 6.3, 5.8, 3.1]
    user3 = [5.5, 3.2, 6.5, 4.7, 4.4]
    user4 = [4.4, 6.2, 2.3, 5.1, 3.3]
    user5 = [2.1, 5.2, 4.2, 2.2, 4.1]

    userlist = [user1, user2, user3, user4, user5]
    for i in range(0, len(userlist) - 1):
        for j in range(i + 1, len(userlist)):
            result = PearsonCorrelationSimilarity(userlist[i], userlist[j])
            print "user%d 和 user%d 的相关系数是%f" % (i + 1, j + 1, result)

user1 和 user2 的相关系数是0.999774

user1 和 user3 的相关系数是-0.847758

user1 和 user4 的相关系数是-0.841816

user1 和 user5 的相关系数是-0.915237

user2 和 user3 的相关系数是-0.841741

user2 和 user4 的相关系数是-0.835320

user2 和 user5 的相关系数是-0.909975

user3 和 user4 的相关系数是0.998987

user3 和 user5 的相关系数是0.976272

user4 和 user5 的相关系数是0.969782

通过计算出来的结果可以看出来等到的结果

余弦距离

余弦相似度用向量空间中两个向量夹角的余弦值作为衡量两个个体间差异的大小。余弦值越接近1，就表明夹角越接近0度，也就是两个向量越相似，这就叫"余弦相似性"。

公式

一般余弦定理这个公式运用与文本分析。

分别采用下列的文本进行

示例

A：这里距离北京有多远，火车多长时间

B:北京离这里有多远，坐火车多长时间

对A，B进行分词

A:这里/距离/北京/有/多远，火车/多长/时间

B:北京/离/这里/有/多远，坐/火车/多长/时间

列出所有的词

这里 距离 北京 有 多远 火车 多长 时间 离 坐

进行词频统计

A: 这里(1)距离(1)北京(1)有(1)多远(1)火车(1)多长(1)时间(1)离(0)坐(0)

B: 这里(1)距离(0)北京(1)有(1)多远(1)火车(1)多长(1)时间(1)离(1)坐(1)

计算句子的词频向量

A (1,1,1,1,1,1,1,1,0,0)

B (1,0,1,1,1,1,1,1,1,1)

通过余弦定理计算相似度

# coding=utf8

import math

# 余弦定理
def cos(v1, v2):
    l = 0.0
    for i in range(0, len(v1)):
        l += v1[i] * v2[i]
    v = 0.0
    w = 0.0
    for i in range(0, len(v1)):
        v += math.pow(v1[i], 2)
        w += math.pow(v2[i], 2)
    cos = l / (math.sqrt(v) * math.sqrt(w))
    return cos

if __name__ == '__main__':
    v1 = [1, 1, 1, 1, 1, 1, 1, 1, 0, 0]
    v2 = [1, 0, 1, 1, 1, 1, 1, 1, 1, 1]
    l = cos(v1, v2)
    print l

计算出的相似度为：

0.824957911384

说明这两句话基本相等

这是一些基本的相似度计算方法。

经过了好久，终于开始学习算法，刷算法题了。从LeetCode上开始刷题。也是完成之前立下的flag。

Hamming Distance(#461)

思路

这个试题 主要是计算 两个数源码中有几位不相同。

对于这个问题，首先我想到的是用按位异或(^)，按位异或后再用递归移位来计算。这仅仅是一个想法。但是思考了好久都没有写出来。无奈之下只好到 Discuss 看一下。

原来还有这个奇淫技巧。。。。。

Java 是提供了 API 来统计原码中的 1 的。这个方法叫做 binCount() 。 这个题就这样解决了。

代码

public class Solution {
    public int hammingDistance(int x, int y) {
        return Integer.bitCount(x ^ y);
    }
}

Total Hamming Distance(#477)

思路

该题只不过是把给出的数组中的每两个数的 Hamming Distance 相加。

还是使用 #461 的方法。

代码

public class Solution {
    public int totalHammingDistance(int[] nums) {
        for (int i = 0; i< nums.length-1;i++){
            for(int j = i+1;j<nums.length;j++){ 
                sum += Integer.bitCount(nums[i] ^ nums[i + 1]);
           }
        }
        return sum;
    }
}

这是第二年参加蓝桥杯了。一年过去了，还是没有好好的学习算法。今年才意识到算法的重要性，所以立下一个 flag—手头这个项目做完就开始系统的学习一下算法。

相比于去年的 蓝桥杯，今年感觉提醒有点变化，不在是一味的暴力。数据量变大了，但是个人感觉没有意义。第一道题完全是个水题，按照出题意思应该是要从文件读取数据吧。可是我用了 Excel 。一分钟秒出答案。就连我这样的菜鸟都能做出来，不说了。

第二题

题目： 用扑克牌 A,2,3,4,5,6,7,8,9组成一个三角形,使每条边的和相同 三角形如下

A代表1，符合三边之和相等的一共有多少种情况？经过翻转，镜像为同一种的算一种！

这个题首先要考虑的是镜像和翻转的情况. 如图 这个为镜像

在考虑翻转和镜像问题后,同样的排列就会产生6种情况,我们需要在最后的结果除以6。

public class Tra {
    static boolean[] flag = new boolean[9];
    static int count = 0;
    static int[] a = new int[9];

    public static void main(String[] args) {

        dfs(0);
        System.out.println(count / 6);
    }

    public static void dfs(int index) {
        if (index == 9) {
            int b1 = a[0] + a[1] + a[3] + a[5];
            int b2 = a[0] + a[2] + a[4] + a[8];
            int b3 = a[5] + a[6] + a[7] + a[8];
            if (b1 == b2 && b1 == b3) {
                count++;
            }
        }
        for (int i = 0; i < 9; i++) {
            if (flag[i]) {
                continue;
            }
            flag[i] = true;
            a[index] = i;
            dfs(index + 1);
            flag[i] = false;
        }
    }
}

答案:144

第三题

又是一个数据量比较大的题，这个题是没有做出来的，回头自己再慢慢题解研究一下吧。这个题应该也是要从文件读取，而且当时没有找出什么规律。

第四题

还是不会，一个拧魔方的题，要求是二阶魔方，目前还没有找到题，找到题后补上。

代码填空

代码填空题略过，一般我做代码填空题是在所需要填写的位置打断点，根据 DEBUG 和输出要求来进行试探性的填写，一般不需要读懂全部代码，只需要知道部分代码即可，做题速度比较快。 可惜，一不小心翻船了。

第五题

所填写的空 f(x/10,k)

第六题

答案 a[i-1][j-1]+1

船翻在了第六题，但是直接填写了 i 答案是测试是正常输出的。不知道给不给分。排除这个模棱两可的答案，前面一共做对了三道题。比去年是有点进步，但是发现还是很差啊。。。。。一定要好好研究算法。

第七题

标题：日期问题 小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日至2059年12月31日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。 比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。 给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？ 输入

一个日期，格式是"AA/BB/CC"。 (0 <= A, B, C <= 9) 输出

输出若干个不相同的日期，每个日期一行，格式是"yyyy-MM-dd"。多个日期按从早到晚排列

输入

02/03/04

样例输出

2002-03-04
2004-02-03
2004-03-02
资源约定： 峰值内存消耗（含虚拟机） < 256M CPU消耗 < 1000ms 请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。

这个题说实话，其实不难，关键是考虑各种情况，比如是否闰年，年，月，日格式是否合法，最后还要有个排序。我没有写完，当时越写越烦，最后就成了能过多少测试过多少测试，完全成了骗分。

第八题

标题：包子凑数

小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺有N种蒸笼，其中第i种蒸笼恰好能放Ai个包子。每种> 蒸笼都有非常多笼，可以认为是无限笼。

每当有顾客想买X个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有X个包子。比如一共有> 3种蒸笼，分别能放3、4和5个包子。当顾客想买11个包子时，大叔就会选2笼3个的再加1笼5个的（也可能选出1笼3个> 的再加2笼4个的）。

当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有3种蒸笼，分别能放4、5和6个包子。而顾客想买7个> 包子时，大叔就凑不出来了。

小明想知道一共有多少种数目是包子大叔凑不出来的。 输入

第一行包含一个整数N。(1 <= N <= 100) 以下N行每行包含一个整数Ai。(1 <= Ai <= 100) 输出

一个整数代表答案。如果凑不出的数目有无限多个，输出INF。

例如， 输入： 2
4
5

程序应该输出： 6

再例如， 输入： 2
4
6

程序应该输出： INF

样例解释： 对于样例1，凑不出的数目包括：1, 2, 3, 6, 7, 11。
对于样例2，所有奇数都凑不出来，所以有无限多个。

刚刚开始的时候想的这个题使用除法，比如输入4和5两种包子，分别枚举出1~1000，用每个数去除以包子的情况，如果有余数，就用余数接着除。但是很快发现了不对。然后就叒变成了一个骗分题。把输入是偶数的情况先输出 INF。

总结

最后的试题就写到了第八题，感觉今年的题应该是要比去年难的，明显不是暴力杯了。成绩很快出来了，省二。钱还没有白交，剩下就看看能不能申请学校的单项奖学金了。钱不是重要的，重要的是靠前的一周备考中还是学会了 DFS 。之前是不会这个算法的。有收获就好，记得自己立下的 Flag 。

MD5 加密即 Message-Digest Algorithm 5，历经了 MD3，MD4 发展，在1991年提出。

• 中文名：消息摘要算法第五版
• 英文名：Message-Digest Algorithm5
• 提出时间：1991年

基本原理

MD5 就是 byte 值和一个 int 的 255 进行 与 运算，得到一个 int 值，再将这个 int 值转化为十六进制的值，这样就完成了一个 MD5 摘要。

特点

只能从明文加密为密文，不能把密文在转化为明文。加密后是不可逆性。确保明文的加密性。

MD5摘要代码

通过MD5的明文进行摘要。

示例代码

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class MD5Utils {
    public static void main(String[] args) {
        String passWord = "123456";
        StringBuilder sb = new StringBuilder();
        //获取数据摘要器
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            //将一个byte数组进行加密操作，返回的是一个加密的byte数组，二进制的哈西计算，md5加密的第一步
            byte[] digest = messageDigest.digest(passWord.getBytes());
            for (int i = 0; i < digest.length; i++) {
                int result = digest[i] & 0xff;
                //将得到的int类型的值转化为16进制的值
                String hexString = Integer.toHexString(result);
                if (hexString.length()<2){//系统会自动把0省略，所以添加0
                   sb.append("0");
                }
                sb.append(hexString);
            }
            System.out.println(sb.toString());
        } catch (NoSuchAlgorithmException e) {//找不到加密方式异常
            e.printStackTrace();
        }

    }
}

输出结果为： e10adc3949ba59abbe56e057f20f883e

防破解

上面的代码可以对123456进行加密，但是目前网上有好多破解网站，他们的破解原理就是将一些常见的MD5摘要密文保存到数据库中，通过比对来达到所谓的破解。所以通过下面的方法进行加密会完全是网上

不规则加密(加盐)

通过对十六进制变量后进行不规则操作加密,在13行代码后边加数，进行不规则加密。这样会的话几乎已经无法完成破解了。

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class MD5Utils {
    public static void main(String[] args) {
        String passWord = "123456";
        StringBuilder sb = new StringBuilder();
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            byte[] digest = messageDigest.digest(passWord.getBytes());
            for (int i = 0; i < digest.length; i++) {
                int result = digest[i] & 0xff;
                String hexString = Integer.toHexString(result)+1;//不规则加密，俗称加盐
                if (hexString.length()<2){
                   sb.append("0");
                }
                sb.append(hexString);
            }
            System.out.println("密码为 123456\n 加密后");
            System.out.println(sb.toString());
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }
}

加密结果 e11a1dc1391491ba1591ab1be1561e01571f21f18813e1

银行系统MD5加密方式

这种是银行等系统要求安全性非常高的系统，一般会对加密后的密文再次进行一次MD5加密，这样进行10-30次，达到一个无法破解的密文。

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

public class MD5Utils {
    //银行 银行卡 6位数 将密码进行十到三十次MD5加密
    public static void main(String[] args) {
        String passWord = "123456";
        StringBuilder sb = new StringBuilder();
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            for (int h = 0; h < 10; h++) { //进行多次循环加密
                byte[] digest = messageDigest.digest(passWord.getBytes());
                for (int i = 0; i < digest.length; i++) {
                    int result = digest[i] & 0xff;
                    String hexString = Integer.toHexString(result)+1;
                    if (hexString.length() < 2) {
                        sb.append("0");
                    }
                    sb.append(hexString);
                }
                passWord = sb.toString();
                sb.delete(0, sb.length());

            }
            System.out.println(passWord);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }
}

加密后结果： 6912c1901801301e61951b01281ca1f21ca1dd1dc17e12a1

补充 Kotlin 版本

import java.security.MessageDigest

/**
 * md5 加密工具类用于加密密码
 * 默认没有加盐
 */

object Md5Utils {

    private const val salt: Int = 0

    fun md5(message: String): String {
        val sb = StringBuilder()
        val messageDigest = MessageDigest.getInstance("MD5")
        val digest: ByteArray = messageDigest.digest(message.toByteArray())
        for (i in 0 until digest.size) {
            val result: Int = digest[i].toInt() and (0xff)
            val hexString = Integer.toHexString(result) + salt
            if (hexString.length < 2) {
                sb.append("0")
            }
            sb.append(hexString)
        }
        return sb.toString()
    }
}