UVA 1609 Foul Play

题目链接

给你一群队伍,1号对至少能击败一半的队伍,每只一号队不能击败的队伍都有另一只队伍能击败他。给一个比赛安排让一号队夺冠(黑幕!)

n=2时,一号队必能击败对手夺冠。所以我们的目标就是在满足题目条件的情况下不断减少队伍,最后n=2一号队夺冠。

四个阶段:尽量配对打不过的,给1号队挑一个能打败的,把剩下黑色队伍任意配对,剩下所有队伍任意配对,然后递归。

因为过程是一个log2 n 所以用n>>1正好;

AC代码:

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
using namespace std;
int beat[1100][1100];
vector<int>::iterator i1,i2;
int main()
{
    int n;
    while(cin>>n)
    {
        char s[1100];
        vector<int>Left;
        for(int i=1;i<=n;i++)
        {
            scanf("%s",s+1);
            for(int j=1;j<=n;j++)
                beat[i][j]=s[j]-'0';
        }
        for(int i=2;i<=n;i++)
            Left.push_back(i);
        while(n>1)
        {
            n>>=1;
            vector<int>Left1,Left2,fin,win,lose;
            for(int i=0;i<Left.size();i++)
                if(beat[1][Left[i]]) win.push_back(Left[i]);
                else lose.push_back(Left[i]);

            for(int i=0;i<lose.size();i++)
            {
                int b=0;
                for(int j=0;j<win.size();j++)
                    if(win[j]>0&&beat[win[j]][lose[i]])
                    {
                        printf("%d %d\n",win[j],lose[i]);
                        b=1;
                        fin.push_back(win[j]);
                        win[j]=-1;
                        break;
                    }
                if(!b) Left1.push_back(lose[i]);
            }

            for(int i=0;i<win.size();i++)
            {
                if(win[i]>0)
                {
                    printf("1 %d\n",win[i]);
                    win[i]=-1;
                    break;
                }
            }

            for(int i=0;i+1<Left1.size();i+=2)
            {
                printf("%d %d\n",Left1[i],Left1[i+1]);
                if(beat[Left1[i]][Left1[i+1]]) fin.push_back(Left1[i]);
                else fin.push_back(Left1[i+1]);
            }

            if(Left1.size()%2)
                Left2.push_back(Left1[Left1.size()-1]);
            for(int i=0;i<win.size();i++)
                if(win[i]>0) Left2.push_back(win[i]);

            for(int i=0;i+1<Left2.size();i+=2)
            {
                printf("%d %d\n",Left2[i],Left2[i+1]);
                if(beat[Left2[i]][Left2[i+1]]) fin.push_back(Left2[i]);
                else fin.push_back(Left2[i+1]);
            }
            Left=fin;
        }
    }
    return 0;
}

 

### YOLO中的Focal CIoU损失函数 在YOLO系列的目标检测算法中,为了提升边界框回归的准确性并处理类别不平衡问题,引入了多种改进型损失函数。其中一种组合方式是将Focal Loss与CIoU (Complete Intersection over Union) 结合起来形成所谓的 **Focal CIoU** 损失函数。 #### Focal CIoU损失函数的作用 该损失函数不仅能够有效减少正负样本之间的数量差异带来的影响,还能更精确地衡量预测框和真实框之间位置关系的质量[^3]。具体来说: - **Focal Loss部分**: 主要用于解决前景背景极度不均衡的问题,通过调整难易分类样本权重来改善模型学习效果; - **CIoU部分**: 则专注于提高边框回归质量,相比传统的IoU或GIoU, CIoU考虑到了更多几何特性因素如中心点距离以及宽高比例等因素的影响; 两者结合可以更好地服务于目标检测任务,在保持较高召回率的同时降低误检概率。 #### 实现代码示例 以下是基于PyTorch框架下实现的一个简单版`focal_ciou_loss()` 函数: ```python import torch from torchvision.ops import box_iou def focal_ciou_loss(pred_boxes, target_boxes, alpha=0.25, gamma=2.0): """ 计算Focal CIoU损失 参数: pred_boxes: 预测框坐标 Tensor[N, 4], xyxy格式 target_boxes: 真实框坐标 Tensor[N, 4], xyxy格式 alpha: Focal loss 的alpha参数,默认为0.25 gamma: Focal loss 的gamma参数,默认为2 返回: float: 平均后的总损失值 """ # 获取iou矩阵 ious = box_iou(pred_boxes, target_boxes).diag() # 计算ciou cious = compute_ciou(pred_boxes, target_boxes) # 计算focal factor p_t = ious * ((target_boxes[:, None]).eq(1)).float().sum(dim=-1) modulating_factor = (p_t / (1 - p_t + 1e-8)) ** gamma weighting_factor = alpha * target_boxes.new_ones(target_boxes.size()) + \ (1-alpha)*((pred_boxes[:,None]-target_boxes)**2).mean(-1).sqrt() # 综合计算最终loss final_loss = -(weighting_factor * modulating_factor * torch.log(cious.clamp(min=1e-9))).mean() return final_loss def compute_ciou(bboxes1, bboxes2): """Compute the CIOU of two sets of boxes.""" rows = bboxes1.shape[0] cols = bboxes2.shape[0] center_x1 = (bboxes1[..., 0] + bboxes1[..., 2]) / 2. center_y1 = (bboxes1[..., 1] + bboxes1[..., 3]) / 2. center_x2 = (bboxes2[..., 0] + bboxes2[..., 2]) / 2. center_y2 = (bboxes2[..., 1] + bboxes2[..., 3]) / 2. inter_max_xy = torch.min(bboxes1[:, 2:], bboxes2[:, 2:]) inter_min_xy = torch.max(bboxes1[:, :2], bboxes2[:, :2]) out_max_xy = torch.max(bboxes1[:, 2:], bboxes2[:, 2:]) out_min_xy = torch.min(bboxes1[:, :2], bboxes2[:, :2]) inter = torch.clamp((inter_max_xy - inter_min_xy), min=0) inter_area = inter[:, 0] * inter[:, 1] inter_diag = (center_x2 - center_x1) ** 2 + (center_y2 - center_y1) ** 2 outer = torch.clamp((out_max_xy - out_min_xy), min=0) outer_diagonal = (outer[:, 0] ** 2) + (outer[:, 1] ** 2) union = area1 + area2 - inter_area u = (inter_diag) / outer_diagonal w1 = bboxes1[..., 2] - bboxes1[..., 0] h1 = bboxes1[..., 3] - bboxes1[..., 1] w2 = bboxes2[..., 2] - bboxes2[..., 0] h2 = bboxes2[..., 3] - bboxes2[..., 1] v = (4 / math.pi ** 2) * torch.pow( torch.atan(w2 / h2) - torch.atan(w1 / h1), 2 ) with torch.no_grad(): S = 1 - inter_area / union alpha = v / (S + v) ciou_term = v * alpha ciou = iou - u - ciou_term return ciou.mean() if __name__ == '__main__': pass ``` 此段代码实现了针对给定的真实标签框(`target_boxes`)及其对应的预测框(`pred_boxes`)计算其间的平均Focal CIoU损失。注意这里简化了一些细节以便理解核心逻辑[^2]。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值