猫狗队列(java实现)

一、题目

       宠物、狗和猫的类如下

  public class Pet {

   private String type;
   public Pet(String type) {
          this.type = type;   
   }
   public String getPetType() {
  return type;
   }

}


public class Dog extends Pet{
      public  Dog() {
      super("dog");
}
}


public class Cat extends Pet{
      public Cat() {
     super("cat");
      }

}

实现一种狗猫队列的结构,要求如下:

(1)用户可以调用add方法将cat类或dog类的实例放入队列中;

(2)用户可以调用pollAll方法,将队列中所有的实例按照进队列的先后顺序依次弹出;

(3)用户可以调用pollDog方法,将队列中dog类的实例按照进队列的先后顺序依次弹出;

(4)用户可以调用pollCat方法,将队列中cat类的实例按照进队列的先后顺序依次弹出;

(5)用户可以调用isEmpty方法,检查队列中是否还有dog或cat的实例;

(6)用户可以调用isDogEmpty方法,检查队列中是否还有dog类的实例;

(7)用户可以调用isCatEmpty方法,检查队列中是否还有cat类的实例。


二、解答

     实现思路我们其实是想把每次进入队列的实例都加上时间戳的方法,但不能改变原有的数据结构,所以只能定义一个新类来封装时间戳,具体实现如下PetEnterQueue类:

public class PetEnterQueue {
         private Pet pet;
         private long count;
         
         public PetEnterQueue(Pet pet,long count) {
        	 this.pet = pet;
        	 this.count = count;
         }
         
         public Pet getPet() {
        	 return this.pet;
         }
         
         public long getCount() {
        	 return this.count;
         }
         
         public String getEnterPetType() {
        	 return this.pet.getPetType();
         }
}

            上述代码中的count就是我们加上的时间戳。队列里存放的就是PetEnterQueue实例。

DogCatQueue类的整体代码如下:

import java.beans.PersistenceDelegate;
import java.util.LinkedList;
import java.util.Queue;

public class DogCatQueue {
        private Queue<PetEnterQueue> dogQ;
        private Queue<PetEnterQueue> catQ;
        private long count;
        
        public DogCatQueue() {
        	this.dogQ = new LinkedList<PetEnterQueue>();
        	this.catQ = new LinkedList<PetEnterQueue>();
        	this.count = 0;
        }
        
        public void add(Pet pet) {
        	if(pet.getPetType().equals("dog")) {
        		this.dogQ.add(new PetEnterQueue(pet, this.count++));
        	}else if(pet.getPetType().equals("cat")) {
        		this.catQ.add(new PetEnterQueue(pet, count++));
        	}else {
        		throw new RuntimeException("error,not dog or cat");
        	}
        }
        
        public Pet pollAll() {
        	if(!this.dogQ.isEmpty() && !this.catQ.isEmpty()) {
        		if(this.dogQ.peek().getCount() < this.catQ.peek().getCount()) {
        			return this.dogQ.poll().getPet();
        		}else {
        			return this.catQ.poll().getPet();
        		}
        	}else if(!this.dogQ.isEmpty()) {
        		return this.dogQ.poll().getPet();
        	}else if(!this.catQ.isEmpty()) {
        		return this.catQ.poll().getPet();
        	}else {
        		throw new RuntimeException("err,queue is empty");
        	}
        }
        
        public Dog polldog() {
        	if(!this.dogQ.isEmpty()) {
        		return (Dog)this.dogQ.poll().getPet();
        	}else {
        		throw new RuntimeException("Dog Queue is empty!");
        	}
        }
        
        public Cat pollcat() {
        	if(!this.catQ.isEmpty()) {
        		return (Cat)this.catQ.poll().getPet();
        	}else {
        		throw new RuntimeException("Cat Queue is empty!");
        	}
        }
    
        public boolean isEmpty(){
        	return this.dogQ.isEmpty()&&this.catQ.isEmpty();
        }
        
        public boolean isDogQueueEmpty() {
        	return this.dogQ.isEmpty();
        }
        
        public boolean isCatQueueEmpty() {
        	return this.catQ.isEmpty();
        }
}
 








分类是一个经典的计算机视觉问题,可以使用PyTorch框架实现。以下是一个简单的分类器的实现过程。 首先,准备数据集。可以从Kaggle下载分类数据集(https://www.kaggle.com/c/dogs-vs-cats/data)并解压缩到本地路径。数据集包含训练集和测试集,每个样本都是一张图片,分为两类。我们需要将数据集进行处理,将图片转换成PyTorch可以处理的格式。 接下来,我们将使用PyTorch的torchvision模块加载数据集。可以使用如下代码: ``` import torch import torchvision import torchvision.transforms as transforms transform = transforms.Compose( [transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])]) trainset = torchvision.datasets.ImageFolder(root='./train', transform=transform) trainloader = torch.utils.data.DataLoader(trainset, batch_size=32, shuffle=True, num_workers=2) testset = torchvision.datasets.ImageFolder(root='./test', transform=transform) testloader = torch.utils.data.DataLoader(testset, batch_size=32, shuffle=False, num_workers=2) classes = ('cat', 'dog') ``` 这里使用了transforms模块对图片进行预处理,包括将图片大小调整为224x224,转换成张量,并进行标准化。然后使用ImageFolder加载数据集,并将其包装为DataLoader,可以设置批次大小和线程数量等参数。 接下来,定义模型。我们可以使用预训练的ResNet-18模型,并将其最后一层替换成一个全连接层,输出维度为2(即两类)。可以使用如下代码: ``` import torch.nn as nn import torch.optim as optim import torchvision.models as models model = models.resnet18(pretrained=True) num_ftrs = model.fc.in_features model.fc = nn.Linear(num_ftrs, 2) criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9) ``` 这里使用了ResNet-18模型,将其最后一层fc替换成一个线性层。然后定义损失函数和优化器。可以使用交叉熵作为损失函数,使用随机梯度下降进行优化。 最后,训练模型。可以使用如下代码: ``` for epoch in range(10): # 训练10个epoch running_loss = 0.0 for i, data in enumerate(trainloader, 0): inputs, labels = data optimizer.zero_grad() outputs = model(inputs) loss = criterion(outputs, labels) loss.backward() optimizer.step() running_loss += loss.item() if i % 100 == 99: # 每100个batch输出一次loss print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 100)) running_loss = 0.0 print('Finished Training') ``` 这里使用了一个简单的训练过程,训练10个epoch,每100个batch输出一次loss值。可以根据需要进行调整。 最后,可以在测试集上对模型进行评估。可以使用如下代码: ``` correct = 0 total = 0 with torch.no_grad(): for data in testloader: images, labels = data outputs = model(images) _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += (predicted == labels).sum().item() print('Accuracy of the network on the test images: %d %%' % ( 100 * correct / total)) ``` 这里使用了测试集对模型进行评估,计算出模型的准确率。可以根据需要进行调整。 以上就是一个简单的分类器的实现过程。可以根据需要进行调整和优化。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值