lol低优先级的队列是啥

Posted 2023-05-15

lol低优先级队列也就是英雄联盟裁决之镰的一种惩罚标准。

通常情况下，导致低优先级队列的主要原因如下：

1、 故意退出、逃跑；

2、 恶意挂机、消极、不参与游戏；

3、 消极比赛遭到举报；

4、 在游戏中恶意利用BUG，使用外挂等影响游戏平衡的软件；

5、 在游戏中发布虚假、诈骗信息，发表涉及政治、法律等信息；

6、 冒充腾讯官方人员进行诈骗。

7、 其他恶劣游戏行为。

扩展资料：

裁决之镰惩罚流程：

1、玩家首次违规系统会弹出惩罚警告。

2、玩家继续在对局中出现挂机、逃跑等消极游戏行为，对局结束后惩罚提示。

3、对局结束后玩家返回大厅时会提示玩家剩余惩罚场数。

4、玩家完成5场惩罚时的提示。

参考资料：百度百科-裁决之镰

参考技术A

低优先级队列是英雄联盟裁决之镰的一种惩罚标准。

主要原因：

1、 故意退出、逃跑

2、 恶意挂机、消极、不参与游戏

3、 消极比赛遭到举报

4、 在游戏中恶意利用BUG，使用外挂等影响游戏平衡的软件

5、 在游戏中发布虚假、诈骗信息，发表涉及政治、法律等信息

6、 冒充腾讯官方人员进行诈骗

7、 其他恶劣游戏行为

惩罚内容：

1、一级惩罚是5把游戏，要等5分钟才能进入队列，而且不容易匹配到人

2、二级惩罚是10分钟，三级惩罚是20分钟

3、3级以后还是逃跑挂机被人举报，就会被系统封号处理的

解决方法：
根据游戏提示时间等五把就可以了不要点取消点了就要重新等，没有其他可以解决的办法了。情节严重会导致封号，建议尽量减少挂机次数，文明游戏。

扩展资料：

匹配系统

匹配系统的目的如下，优先级从高到低：

1、保护新手不被有经验的玩家虐；让高手局中没有新手。

2、创造竞技和公平的游戏对局，使玩家的游戏乐趣最大化。

3、无需等待太久就能找到对手进入游戏。

4、匹配系统尽其所能的匹配水平接近的玩家，玩家的水平是来自他们在此之前赢了谁以及他们对手的水平。

参考资料来源：百度百科-英雄联盟

参考技术B 进入低优先级队列每把都要等十分钟是因为你打游戏的时候挂机了或者退游戏了，被举报了。等五把就可以了不要点取消点了就要重新等，没有其他可以解决的办法了。如果还挂机被举报的话，就是20分钟了没一把开之前都要等20分钟了。 参考技术C 就是当你挂机逃跑时候被人举报，就会被裁决之镰惩罚，就会进入低优先级的队列，一级惩罚是5把游戏，要等5分钟才能进入队列，而且不容易匹配到人，二级惩罚是10分钟，三级惩罚是20分钟，如果3级以后还是逃跑挂机被人举报，就会被系统封号处理的本回答被提问者采纳 参考技术D

就是：当你挂机逃跑时候被人举报，就会被裁决之镰惩罚，就会进入低优先级的队列。

一级惩罚是5把游戏，要等5分钟才能进入队列，而且不容易匹配到人。

二级惩罚是10分钟，三级惩罚是20分钟。

3级以后还是逃跑挂机被人举报，就会被系统封号处理的。

英雄联盟（2011年腾讯运营的电子竞技类游戏）

《英雄联盟》(简称LOL)是由美国拳头游戏(Riot Games)开发、中国大陆地区腾讯游戏代理运营的英雄对战MOBA竞技网游。

游戏里拥有数百个个性英雄，并拥有排位系统、符文系统等特色养成系统。

《英雄联盟》还致力于推动全球电子竞技的发展，除了联动各赛区发展职业联赛、打造电竞体系之外，每年还会举办“季中冠军赛”“全球总决赛”“All Star全明星赛”三大世界级赛事，获得了亿万玩家的喜爱，形成了自己独有的电子竞技文化。

为一系列具有较高优先级的元素和其他具有较低优先级的元素排序优先级队列

【中文标题】为一系列具有较高优先级的元素和其他具有较低优先级的元素排序优先级队列

【英文标题】：Sorting priority queue for a range of elements with higher priority and other elements with lower priority

【发布时间】：2017-08-30 04:57:47

【问题描述】：

我有一个包含以下字段的实体类：id、orderNo。每个 实体必须存储在 java 优先级队列中。元素 id 在 1 - 3000 之间的具有更高的优先级，必须存储在 在 id > 3000 的元素之上 orderNo 的升序。 元素 ids > 3000 以 orderNo 的升序存储在下面 更高优先级的元素（ids 1 - 3000）。

例如：

(1st insertion to queue: id=4000 orderNo=1) 
(2nd insertion to queue: id=5000 orderNo=2) 
(3rd insertion to queue: id=100  orderNo=3)
(4th insertion to queue: id=50   orderNo=4)

预期的排序顺序：

(id=100  orderNo=3) 
(id=50   orderNo=4) 
(id=4000 orderNo=1) 
(id=5000 orderNo=2)

OrderEntity 类：

public class OrderEntity implements Comparable<OrderEntity> 
    private int id;
    private int getOrderNo;

    public int getId() 
        return id;
    

    public void setId(int id) 
        this.id = id;
    

    public int getOrderNo() 
        return getOrderNo;
    

    public void setOrderNo(int getOrderNo) 
        this.getOrderNo = getOrderNo;
    

    @Override
    public int compareTo(OrderEntity arg0) 
        if ((this.getId() >= 1 && this.getId() <= 3000) && (arg0.getId() >= 1 && arg0.getId() <= 3000)) 
            if (this.getOrderNo() > arg0.getOrderNo()) 
                return 1;
             else 
                return 0;
            
         else if ((this.getId() <= 3000) && (arg0.getId() > 3000)) 
            return 1;
         else if ((this.getId() > 3000) && (arg0.getId() <= 3000)) 
            return 1;
         else if ((this.getId() > 3000) && (arg0.getId() > 3000)) 
            if (this.getOrderNo() > arg0.getOrderNo()) 
                return 1;
             else 
                return 0;
            
         else 
            return 0;
        
    

OrderProcessor 类：

public class OrderProcessor 
    private static int count;
    static Queue<OrderEntity> pq = new PriorityQueue<>();

    public String createOrder(int id) 
        OrderEntity orderEntity = new OrderEntity();
        orderEntity.setId(id);
        count = count + 1;
        orderEntity.setOrderNo(count);
        pq.add(orderEntity);

        String res = "";
        for (OrderEntity rd : pq) 
            res = res + rd.getId() + " " + rd.getOrderNo() + "\n";
        
        return res.trim();
    

【问题讨论】：

你的问题是......？

我的问题是我无法通过上述实现获得这个序列。想知道我哪里出错了。

一个问题是您的compareTo 方法，如果第一项不大于第二项，则返回0（表示相等）。 compareTo 应返回 -1、0 或 1，具体取决于第一项小于、等于还是大于第二项。通常，您使用Integer.compare 来检查。

【参考方案1】：

在这种情况下，对象的自然顺序与您的特殊要求不同，最好不要使用Comparable，因为它将来可能会有其他用途。所以，剩下的解决方案是使用Comparator，它非常适合你的问题，因为你的OrderEntity 类不会依赖这个特殊的比较。以下是显示解决方案的示例代码：

import java.util.Comparator;
import java.util.PriorityQueue;

public class OrderProcessor 
    public static void main(String[] args) 
        PriorityQueue<OrderEntity> q = new PriorityQueue<>(new OrderEntityComparator());
        q.add(new OrderEntity(4000, 1));
        q.add(new OrderEntity(5000, 2));
        q.add(new OrderEntity(100, 3));
        q.add(new OrderEntity(50, 4));

        while(!q.isEmpty())
            System.out.println(q.poll());
    

    public static class OrderEntityComparator implements Comparator<OrderEntity> 

        @Override
        public int compare(OrderEntity o1, OrderEntity o2) 
            if(o1.getId() <= 3000 && o2.getId() <= 3000)
                return Integer.compare(o1.getOrderNo(), o2.getOrderNo());
            if(o1.getId() > 3000 && o2.getId() > 3000)
                return Integer.compare(o1.getOrderNo(), o2.getOrderNo());
            if(o1.getId() <= 3000 && o2.getId() > 3000)
                return -1;
            return 1;
        
    

    public static class OrderEntity 
        private int id;
        private int orderNo;

        public OrderEntity(int id, int orderNo) 
            this.id = id;
            this.orderNo = orderNo;
        

        public int getId() 
            return id;
        

        public void setId(int id) 
            this.id = id;
        

        public int getOrderNo() 
            return orderNo;
        

        public void setOrderNo(int orderNo) 
            this.orderNo = orderNo;
        

        @Override
        public String toString() 
            return "OrderEntity" +
                    "id=" + id +
                    ", orderNo=" + orderNo +
                    '';
        
    

编辑：

如果您不想通过调用poll 方法删除元素，则必须将元素排序到数组或列表中，如下所示：

    OrderEntity[] a = new OrderEntity[q.size()];
    q.toArray(a);
    Arrays.sort(a, new OrderEntityComparator());

    for(OrderEntity entity : a)
        System.out.println(entity);

事实上，在这种情况下，您不需要使用 PriorityQueue，只需对 List 或数组进行简单排序即可。

【讨论】：

不工作。尝试使用以下输入：(100,1) (200,2) (4000,3) (300,4)。预期输出：(100,1) (200,2) (300,4) (4000,3)。实际输出：(100,1) (200,2) (4000,3) (300,4)

@AshwinShirva 您的预期输出是什么？我的输出是：(100,1) (200,2) (300,4) (4000,3)

@AshwinShirva 我运行了代码，输出与您预期的相同。请检查我的代码好吗？

@MehdiJavan 我接受了您对问题的建议编辑，并进行了我自己的小幅编辑:)

它可以工作，正如你提到的那样，在 while 循环中使用 poll()。一个简单的问题，有没有办法在不使用 poll() 的情况下按顺序遍历优先级队列元素？因为我不想修改原来的队列。我只想检索值（按顺序）。

【参考方案2】：

这是一个使用 Java 8 的解决方案，不需要任何复杂的比较器实现。我针对您提供的两个示例运行它。诀窍是要意识到有 2 组 id，那些

public class Main 
    private static Comparator<OrderEntity> orderEntityComparator =
        Comparator.<OrderEntity, Integer>comparing(OrderEntity::getId,
                comparingInt(id -> id / 3000)
        )
                .thenComparingInt(OrderEntity::getOrderNo);

    public static void main(String[] args) 
        PriorityQueue<OrderEntity> queue = new PriorityQueue<>(orderEntityComparator);
        queue.add(new OrderEntity(4000, 1));
        queue.add(new OrderEntity(5000, 2));
        queue.add(new OrderEntity(100, 3));
        queue.add(new OrderEntity(50, 4));

        // 100, 50, 4000, 5000

        queue.clear();

        queue.add(new OrderEntity(100, 1));
        queue.add(new OrderEntity(200, 2));
        queue.add(new OrderEntity(4000, 3));
        queue.add(new OrderEntity(300, 4));

        while (!queue.isEmpty()) 
            System.out.println(queue.poll());
        
        // 100, 200, 300, 4000
    

    static class OrderEntity 
        private int id;
        private int orderNo;

        public OrderEntity(int id, int orderNo) 
            this.id = id;
            this.orderNo = orderNo;
        

        public int getId() 
            return id;
        

        public int getOrderNo() 
            return orderNo;
        

        @Override
        public String toString() 
            return String.format("(id=%d, orderNo=%d)", id, orderNo);