深搜算法:倒油/面向对象的思想来做

简介: 深搜算法:倒油/面向对象的思想来做

题目:有一位厨师要从盛12斤油(a桶)的桶中倒出6斤油来,可是手边只有盛8斤油(b桶)和盛5斤油(c桶)的两个桶,问如何操作才能将6斤取出来呢?

下面为JAVA实现代码:

主类:

package cn.hncu.oil.dfs1;
import cn.hncu.oil.common.Bucket;
import cn.hncu.oil.common.DumpCase;
import cn.hncu.oil.common.Myset;
public class DumpOilDFS {
    public static void main(String[] args) {
        Bucket buckets[] = new Bucket[3];
        buckets[0] = new Bucket(12, 12);
        buckets[1] = new Bucket(8, 0);
        buckets[2] = new Bucket(5, 0);
        DumpCase u = new DumpCase(buckets);
        Myset caseset = new Myset();
        caseset.add(u);
        dfs(u,caseset);
    }
    private static void dfs(DumpCase u0, Myset caseset) {
        for(Bucket bucket: u0.getBucket()){
            if(bucket.getNow()==6){
                //System.out.println("find a case");
                print(u0);
                return;
            }
        }
        int n = u0.getBucket().length;//桶的个数
        DumpCase u = new DumpCase(u0);
        //用备份节点去搜
        //遍历所有的DumpCase: 依次让桶i向j倒
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(i==j){//不能自己给自己的桶倒油
                    continue;
                }
                //算出桶i给j倒时,能倒多少-->temp
                int temp = u.getBucket()[i].canOut();
                if(u.getBucket()[j].canIn()<u.getBucket()[i].canOut()){
                    temp = u.getBucket()[j].canIn();
                }
                //倒油
                u.getBucket()[i].out(temp);
                u.getBucket()[j].in(temp);
                //判断该情况是否已经出现过了//如果存在,要还原(把油倒回去)
                if(caseset.contains(u)){
                    u.getBucket()[i].in(temp);
                    u.getBucket()[j].out(temp);
                    continue;
                }
                DumpCase v = new DumpCase(u);
                v.setParent(u0);
                caseset.add(v);
                //System.out.println(a);
                dfs(v,caseset);
                u.getBucket()[i].in(temp);
                u.getBucket()[j].out(temp);
            }
        }
    }
    private static void print(DumpCase u0) {
        Myset set  =new Myset();
        set.add(u0);
        DumpCase v =u0.getParent();
        while(v!=null){
            set.add(v);
            //System.out.println(v.getBucket()[0].getNow()+","+v.getBucket()[1].getNow()+","+v.getBucket()[2].getNow());
            v= v.getParent();
        }
        System.out.println("------------");
        //System.out.println("12,0,0");
        Object objs[] = set.getAll();
        for(int i=objs.length-1;i>=0;i--){
            DumpCase u =(DumpCase) objs[i];
            System.out.println(u.getBucket()[0].getNow()+","+u.getBucket()[1].getNow()+","+u.getBucket()[2].getNow());
        }
    }
}


DumpCase 类:

package cn.hncu.oil.common;
import java.util.Arrays;
public class DumpCase {
    Bucket buckets[];
    DumpCase parent = null;
    public DumpCase(){
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + Arrays.hashCode(buckets);
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        DumpCase other = (DumpCase) obj;
        if (!Arrays.equals(buckets, other.buckets))
            return false;
        return true;
    }
    public DumpCase(Bucket buckets[]){
        this.buckets = buckets;
    }
    public DumpCase(DumpCase u) {//必须要深拷贝
        this.buckets = new Bucket[u.getBucket().length];
        for(int i=0;i<u.getBucket().length;i++){
            this.buckets[i] = new Bucket(0, 0);
            this.buckets[i].max=u.buckets[i].max;
            this.buckets[i].now=u.buckets[i].now;
        }
    }
    public Bucket[] getBucket() {
        return buckets;
    }
    public void setBucket(Bucket[] buckets) {
        this.buckets = buckets;
    }
    public DumpCase getParent() {
        return parent;
    }
    public void setParent(DumpCase parent) {
        this.parent = parent;
    }
}


Bucket 类:

package cn.hncu.oil.common;
public class Bucket {//桶的容量和现在装的油的多少
    int now;
    int max;
    public Bucket(int max,int now) {
        this.max=max;
        this.now=now;
    }
    public void in(int n){
         now+=n;
    }
    public void out(int n){
        now-=n;
    }
    public int getNow() {
        return now;
    }
    public int getMax() {
        return max;
    }
    public int canIn(){
        return max-now;
    }
    public int canOut(){
        return now;
    }
    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + max;
        result = prime * result + now;
        return result;
    }
    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Bucket other = (Bucket) obj;
        if (max != other.max)
            return false;
        if (now != other.now)
            return false;
        return true;
    }
}


Myset 类:

package cn.hncu.oil.common;
public class Myset {
    private Object[] objs = new Object[0];
    public boolean contains(Object obj){
        for(Object objtemp:objs){
            if(objtemp.equals(obj)){
                return true;
            }
        }
        return false;
    }
    public boolean add(Object obj){
        if(contains(obj)){
            return false;
        }
        Object[] objstemp = new Object[objs.length+1];
        System.arraycopy(objs, 0, objstemp, 0, objs.length);
        objstemp[objs.length]=obj;
        objs = objstemp;
        return true;
    }
    public Object[] getAll(){
        return objs;
    }
    public int Size(){
        return objs.length;
    }
}
目录
相关文章
|
存储 算法 JavaScript
JavaScript专项算法题(5):面向对象
面向对象 使用实义化的对象 挑战1/1 MAKEPERSON 问题: 构建一个称为makePerson的接受两个参数(name和age)的函数,返回一个对象。此函数会: 创建一个空对象; 给空对象一个键名为name的属性,键值为输入函数的name参数的值; 给空对象一个键名为age的属性,键值为输入函数的age参数的值; 返回对象。 题解: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 /****************************************************************
|
算法 Java
深搜算法:倒油/面向对象的思想来做
题目:有一位厨师要从盛12斤油(a桶)的桶中倒出6斤油来,可是手边只有盛8斤油(b桶)和盛5斤油(c桶)的两个桶,问如何操作才能将6斤取出来呢? 下面为JAVA实现代码: 主类: package cn.
1004 0
|
7月前
|
机器学习/深度学习 算法 机器人
【水下图像增强融合算法】基于融合的水下图像与视频增强研究(Matlab代码实现)
【水下图像增强融合算法】基于融合的水下图像与视频增强研究(Matlab代码实现)
642 0
|
7月前
|
数据采集 分布式计算 并行计算
mRMR算法实现特征选择-MATLAB
mRMR算法实现特征选择-MATLAB
413 2
|
8月前
|
传感器 机器学习/深度学习 编解码
MATLAB|主动噪声和振动控制算法——对较大的次级路径变化具有鲁棒性
MATLAB|主动噪声和振动控制算法——对较大的次级路径变化具有鲁棒性
345 3
|
8月前
|
存储 编解码 算法
【多光谱滤波器阵列设计的最优球体填充】使用MSFA设计方法进行各种重建算法时,图像质量可以提高至多2 dB,并在光谱相似性方面实现了显著提升(Matlab代码实现)
【多光谱滤波器阵列设计的最优球体填充】使用MSFA设计方法进行各种重建算法时,图像质量可以提高至多2 dB,并在光谱相似性方面实现了显著提升(Matlab代码实现)
243 6
|
7月前
|
机器学习/深度学习 算法 机器人
使用哈里斯角Harris和SIFT算法来实现局部特征匹配(Matlab代码实现)
使用哈里斯角Harris和SIFT算法来实现局部特征匹配(Matlab代码实现)
314 8
|
7月前
|
机器学习/深度学习 算法 自动驾驶
基于导向滤波的暗通道去雾算法在灰度与彩色图像可见度复原中的研究(Matlab代码实现)
基于导向滤波的暗通道去雾算法在灰度与彩色图像可见度复原中的研究(Matlab代码实现)
357 8
|
7月前
|
机器学习/深度学习 算法 数据可视化
基于MVO多元宇宙优化的DBSCAN聚类算法matlab仿真
本程序基于MATLAB实现MVO优化的DBSCAN聚类算法,通过多元宇宙优化自动搜索最优参数Eps与MinPts,提升聚类精度。对比传统DBSCAN,MVO-DBSCAN有效克服参数依赖问题,适应复杂数据分布,增强鲁棒性,适用于非均匀密度数据集的高效聚类分析。
|
8月前
|
机器学习/深度学习 传感器 算法
【高创新】基于优化的自适应差分导纳算法的改进最大功率点跟踪研究(Matlab代码实现)
【高创新】基于优化的自适应差分导纳算法的改进最大功率点跟踪研究(Matlab代码实现)
379 14

热门文章

最新文章