LeetCode刷题自用_移动零_双指针(Python)

1.题目描述

给定一个数组 nums,编写一个函数将所有 0 移动到数组的末尾,同时保持非零元素的相对顺序。

请注意 ,必须在不复制数组的情况下原地对数组进行操作。

示例:

输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
输入: nums = [0]
输出: [0]

2.我的思路

本人愚笨,再加上python真的不太会用,所以,复杂度好高,但是即使是笨笨的方法,也值得记录

这个题按照我的思路,把0全部换到后面,就是一次判断序列中第i个元素是否为0,如果是0,就给依次进行交换换到后面。BUT!如果一次进行i增大,如果把第i个位置上的0已经交换到最后面了,此时第i个位置还是0,那么就会忽略掉这个0。另外,如果此时仅仅加上判断再看看第i个位置是不是0,就会导致可能后面全为0的时候,i不增加,进入无限循环。因此可以先判断出序列中有几个0,如果后面已经有足够的0了,i就不增加了。

#我的代码
class Solution(object):
    def moveZeroes(self, nums):
        """
        :type nums: List[int]
        :rtype: None Do not return anything, modify nums in-place instead.
        """
        i=0
        cnt=nums.count(0)
        l=len(nums)
        while i < l:
            if nums[i] == 0:
                j = i
                while j + 1 < l:
                    t = nums[j]
                    nums[j] = nums[j + 1]
                    nums[j+1] = t
                    j += 1

            if i==l-cnt:
                break
            elif nums[i]==0 and i<l-cnt:
                i=i
            else:
                i+=1

        print(nums)

nums=[0,1,0,3,12]
nums1=[0]
nums2=[0,0,1]
s=Solution()
s.moveZeroes(nums2)

3.其他做法

左指针是在0序列的最前端,右指针是在非0序列的最前端,右指针遇到非0数与左指针的数交换,然后左指针增大,依旧在0序列最前端

#官方题解
class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        n = len(nums)
        left = right = 0
        while right < n:
            if nums[right] != 0:
                nums[left], nums[right] = nums[right], nums[left]
                left += 1
            right += 1

### U-Net 实战教程示例 #### 使用 U-Net 进行图像分割的实际案例 U-Net 是一种常用于医学影像分析的卷积神经网络架构,特别适合于语义分割任务。它通过编码器-解码器结构实现输入图像到像素级分类结果的映射[^1]。 以下是基于 PyTorch 的 U-Net 图像分割实战教程的一个简单概述: --- #### 数据集准备 通常情况下,U-Net 需要高质量的标注数据来完成训练过程。例如,在医疗领域中常用的 LUNA 2016 数据集可以作为肺部 CT 扫描中的结节检测任务的数据源[^2]。对于其他应用场景,也可以选择公开可用的图像分割数据集,如 CamVid 或 Cityscapes。 为了加载和预处理数据,可以采用如下方法: ```python import torch from torchvision import transforms from torch.utils.data import Dataset, DataLoader class CustomDataset(Dataset): def __init__(self, image_paths, mask_paths, transform=None): self.image_paths = image_paths self.mask_paths = mask_paths self.transform = transform def __len__(self): return len(self.image_paths) def __getitem__(self, idx): image = load_image(self.image_paths[idx]) # 自定义函数加载图片 mask = load_mask(self.mask_paths[idx]) # 自定义函数加载掩膜 if self.transform: image = self.transform(image) return image, mask ``` 上述代码展示了如何创建自定义数据集类 `CustomDataset` 来管理图像及其对应的分割掩膜[^3]。 --- #### 模型构建 U-Net 的核心在于其对称的编码器-解码器设计以及跳跃连接机制。以下是一个简化版的 U-Net 定义: ```python import torch.nn as nn import torch.nn.functional as F class UNet(nn.Module): def __init__(self, in_channels=1, out_channels=1): super(UNet, self).__init__() # 编码器部分 self.encoder1 = self.conv_block(in_channels, 64) self.encoder2 = self.conv_block(64, 128) self.encoder3 = self.conv_block(128, 256) # 解码器部分 self.decoder1 = self.up_conv(256, 128) self.decoder2 = self.up_conv(128, 64) self.final_layer = nn.Conv2d(64, out_channels, kernel_size=1) def conv_block(self, in_channels, out_channels): return nn.Sequential( nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), nn.ReLU(inplace=True), nn.Conv2d(out_channels, out_channels, kernel_size=3, padding=1), nn.ReLU(inplace=True) ) def up_conv(self, in_channels, out_channels): return nn.Sequential( nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True), nn.Conv2d(in_channels, out_channels, kernel_size=1) ) def forward(self, x): enc1 = self.encoder1(x) pool1 = F.max_pool2d(enc1, kernel_size=2, stride=2) enc2 = self.encoder2(pool1) pool2 = F.max_pool2d(enc2, kernel_size=2, stride=2) enc3 = self.encoder3(pool2) dec1 = self.decoder1(enc3) concat1 = torch.cat([dec1, enc2], dim=1) # 跳跃连接 dec2 = self.decoder2(concat1) concat2 = torch.cat([dec2, enc1], dim=1) # 跳跃连接 final_output = self.final_layer(concat2) return final_output ``` 此代码片段实现了基本的 U-Net 结构,并支持灵活调整输入通道数和输出类别数量。 --- #### 训练流程 在模型训练阶段,可以选择交叉熵损失或其他适用于分割任务的目标函数。下面是一段简单的训练循环代码: ```python device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') model = UNet().to(device) criterion = nn.CrossEntropyLoss() optimizer = torch.optim.Adam(model.parameters(), lr=0.001) def train_model(dataloader, model, criterion, optimizer, epochs=10): for epoch in range(epochs): running_loss = 0.0 for images, masks in dataloader: images, masks = images.to(device), masks.to(device) outputs = model(images) loss = criterion(outputs, masks.long()) optimizer.zero_grad() loss.backward() optimizer.step() running_loss += loss.item() print(f"Epoch {epoch+1}, Loss: {running_loss/len(dataloader)}") train_loader = DataLoader(CustomDataset(...)) # 替换为实际路径 train_model(train_loader, model, criterion, optimizer) ``` 该脚本演示了如何利用 PyTorch 对 U-Net 模型进行端到端训练。 --- #### 测试评估 测试过程中可以通过可视化工具展示预测效果并真实标签对比。例如: ```python import matplotlib.pyplot as plt def visualize_results(model, test_dataset, index=0): image, mask = test_dataset[index] with torch.no_grad(): prediction = model(image.unsqueeze(0).to(device)) fig, ax = plt.subplots(1, 3, figsize=(12, 4)) ax[0].imshow(image.permute(1, 2, 0).numpy()) # 原始图像 ax[1].imshow(mask.numpy()) # 真实掩膜 ax[2].imshow(prediction.squeeze().argmax(dim=0).cpu().numpy()) # 预测结果 plt.show() visualize_results(model, test_dataset, index=5) ``` 这段代码允许用户直观地比较原始图像、真实掩膜及模型预测之间的差异。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值