精华内容
下载资源
问答
  • 权重结构的加权排序算法 开始算法之前,首先介绍一下向量中的排序方式,这里使用的是STL中的std::sort排序方式,具体使用的代码如下: //定义加权排序的结构 template<typename T> struct _sortStru ...

    权重结构的加权排序算法

           开始算法之前,首先介绍一下向量中的排序方式,这里使用的是STL中的std::sort排序方式,具体使用的代码如下:

    //定义加权排序的结构
    template<typename T>
    struct _sortStru 
    {
        T _data1;
        T _data2;
        T _data3;
        T _data4;
        int nWeight[4];
        _sortStru()
        {
            memset(this, 0, sizeof(_sortStru));
        }
    };
    
    bool _sort_sample(const _sortStru<int> &l,  const _sortStru<int> &r)
    {
        return l._data1 < r._data1;
    }
    
    int main()
    {
        // 初始化一个vector,成员类型为_sortStru<int>
        vector< _sortStru<int> > vec;
        int i = 0;
        for (i = 0; i < MAXNUM; i++)
        {
            _sortStru<int> sort;
            sort._data1 = Random();
            sort._data2 = Random();
            sort._data3 = Random();
            sort._data4 = Random();
            vec.push_back(sort);
        }
        
        // 输出
        for (i = 0; i < MAXNUM; i++)
        {
            _sortStru<int> out;
            out = vec.at(i);
            cout<< out._data1<<" "<<out._data2<<" "<<out._data3<<" "<<out._data4<<" ";
            cout<<endl;
        }
        cout<<endl;
        
        // 简单排序,最结构体中的第一个成员进行排序
        std::sort(vec.begin(), vec.end(), _sort_sample);
        for (i = 0; i < MAXNUM; i++)
        {
            _sortStru<int> out;
            out = vec.at(i);
            cout<< out._data1<<" "<<out._data2<<" "<<out._data3<<" "<<out._data4<<" ";
            cout<<endl;
        }
        cout<<endl;
        return 0;
    }

     

      正面代码段时对vec中的_sortStru<int>成员,按照结构体中第一个成员进行排序。

     

     下面给出的是对这个的加权排序

      每一个结构体的成员都有一个自己的权重,结构体的定义如下:

    //定义加权排序的结构
    template<typename T>
    struct _sortStru 
    {
        T _data1;
        T _data2;
        T _data3;
        T _data4;
        int nWeight[4];
        _sortStru()
        {
            memset(this, 0, sizeof(_sortStru));
        }
    };

      在这个结构中有四个成员变量,分别任_data1 - _data4,这个四个成员都有自己的权重,比如_data1的权重是30,_data2的权重是20,_data3的权重是40,_data4的权重是10。然后根据这些权重对一组数据进行排序。然后将排序后的结果从大到小排列出来。

      具体的排序方法是:

      首先,对这组数据中的每个成员从小到大排序,具体的先对第一个成员进行从小到大排序,排好序后给这些成员添加上自己的位置权重,最小的为0,然后依次增加,循环的给所有的成员都添加上位置权重。

      然后,对这些具有位置权重的数据进行加权排序。

      具体代码如下:

      1 #include <iostream>
      2 #include <vector>
      3 #include <assert.h>
      4 #include <algorithm>
      5 #define Random() (rand()%100)
      6 using namespace std;
      7 #define MAXNUM 10
      8 
      9 //定义加权排序的结构
     10 template<typename T>
     11 struct _sortStru 
     12 {
     13     T _data1;
     14     T _data2;
     15     T _data3;
     16     T _data4;
     17     int nWeight[4];
     18     _sortStru()
     19     {
     20         memset(this, 0, sizeof(_sortStru));
     21     }
     22 };
     23 
     24 
     25 bool _sort_sample(const _sortStru<int> &l,  const _sortStru<int> &r)
     26 {
     27     return l._data1 < r._data1;
     28 }
     29 
     30 
     31 class _sort
     32 {
     33 public:
     34     _sort() : pos(0){}
     35     _sort(int nPos) : pos(nPos){}
     36     bool operator()(const _sortStru<int> &l,  const _sortStru<int> &r)
     37     {
     38         switch (pos)
     39         {
     40         case 0:
     41             return l._data1 < r._data1;
     42         case 1:
     43             return l._data2 < r._data2;
     44         case 2:
     45             return l._data3 < r._data3;
     46         case 3:
     47             return l._data4 < r._data4;
     48         default:
     49             return l._data1 < r._data1;
     50         }
     51     }
     52 
     53 private:
     54     int pos;
     55 };
     56 
     57 template<class T>
     58 class Add_Weight
     59 {
     60 public:
     61     Add_Weight(int type, int start) 
     62         : ntype(type), nstart(start), nLastValue(0), nLastWeight(0)
     63     {
     64     }
     65 
     66     void operator()(_sortStru<T> &_F)
     67     {
     68         switch (ntype)
     69         {
     70         case 0: default:
     71             if (_F._data1 == nLastValue)
     72             {
     73                 _F.nWeight[ntype] = nLastWeight;
     74             }
     75             else
     76             {
     77                 _F.nWeight[ntype] = nstart;
     78                 nLastValue = _F._data1;
     79                 nLastWeight = nstart;
     80             }
     81             break;
     82         case 1:
     83             if (_F._data2 == nLastValue)
     84             {
     85                 _F.nWeight[ntype] = nLastWeight;
     86             }
     87             else
     88             {
     89                 _F.nWeight[ntype] = nstart;
     90                 nLastValue = _F._data2;
     91                 nLastWeight = nstart;
     92             }
     93             break;
     94         case 2:
     95             if (_F._data3 == nLastValue)
     96             {
     97                 _F.nWeight[ntype] = nLastWeight;
     98             }
     99             else
    100             {
    101                 _F.nWeight[ntype] = nstart;
    102                 nLastValue = _F._data3;
    103                 nLastWeight = nstart;
    104             }
    105             break;
    106         case 3:
    107             if (_F._data4 == nLastValue)
    108             {
    109                 _F.nWeight[ntype] = nLastWeight;
    110             }
    111             else
    112             {
    113                 _F.nWeight[ntype] = nstart;
    114                 nLastValue = _F._data4;
    115                 nLastWeight = nstart;
    116             }
    117             break;
    118         }
    119         nstart++;
    120     }
    121 private:
    122     int ntype;
    123     int nstart;
    124     T nLastValue;
    125     int nLastWeight;
    126 };
    127 
    128 
    129 
    130 // 四个参数的权重类
    131 class CWeight
    132 {
    133 public:
    134     CWeight()
    135     {
    136         weight_1 = 0;
    137         weight_1 = 0;
    138         weight_1 = 0;
    139         weight_1 = 0;
    140     };
    141 
    142     CWeight(int Fir, int Sec, int thi, int Fou)
    143         : weight_1(Fir), weight_2(Sec), weight_3(thi), weight_4(Fou)
    144     {
    145     };
    146 
    147     void Check()
    148     {
    149         assert(weight_1 + weight_2 + weight_3 + weight_4 == 100);
    150     }
    151 
    152 public:
    153     int weight_1;
    154     int weight_2;
    155     int weight_3;
    156     int weight_4;
    157 };
    158 
    159 template<class T>
    160 class Compare_Weight
    161 {
    162 public:
    163     Compare_Weight(CWeight *pF)
    164         : pweight(pF)
    165     {
    166     }
    167 
    168     bool operator()(const _sortStru<T> &_F, const  _sortStru<T> &_L)
    169     {
    170         T t1 = _F.nWeight[0] * pweight->weight_1 
    171             + _F.nWeight[1] * pweight->weight_2 
    172             + _F.nWeight[2] * pweight->weight_3
    173             + _F.nWeight[3] * pweight->weight_4;
    174 
    175         T t2 = _L.nWeight[0] * pweight->weight_1 
    176             + _L.nWeight[1] * pweight->weight_2 
    177             + _L.nWeight[2] * pweight->weight_3
    178             + _L.nWeight[3] * pweight->weight_4;
    179 
    180         return t1 > t2;
    181     }
    182 
    183 private:
    184     CWeight *pweight;
    185 };
    186 
    187 int main()
    188 {
    189     // 初始化一个vector,成员类型为_sortStru<int>
    190     vector< _sortStru<int> > vec;
    191     int i = 0;
    192     for (i = 0; i < MAXNUM; i++)
    193     {
    194         _sortStru<int> sort;
    195         sort._data1 = Random();
    196         sort._data2 = Random();
    197         sort._data3 = Random();
    198         sort._data4 = Random();
    199         vec.push_back(sort);
    200     }
    201     
    202     // 输出
    203     for (i = 0; i < MAXNUM; i++)
    204     {
    205         _sortStru<int> out;
    206         out = vec.at(i);
    207         cout<< out._data1<<" "<<out._data2<<" "<<out._data3<<" "<<out._data4<<" ";
    208         cout<<endl;
    209     }
    210     cout<<endl;
    211     
    212     // 简单排序,最结构体中的第一个成员进行排序
    213     std::sort(vec.begin(), vec.end(), _sort_sample);
    214     for (i = 0; i < MAXNUM; i++)
    215     {
    216         _sortStru<int> out;
    217         out = vec.at(i);
    218         cout<< out._data1<<" "<<out._data2<<" "<<out._data3<<" "<<out._data4<<" ";
    219         cout<<endl;
    220     }
    221     cout<<endl;
    222 
    223     // 简单排序,最结构体中的第N个成员进行排序
    224     std::sort(vec.begin(), vec.end(), _sort(2));
    225     for (i = 0; i < MAXNUM; i++)
    226     {
    227         _sortStru<int> out;
    228         out = vec.at(i);
    229         cout<< out._data1<<" "<<out._data2<<" "<<out._data3<<" "<<out._data4<<" ";
    230         cout<<endl;
    231     }
    232     cout<<endl;
    233 
    234     // 加权排序
    235     for (i = 0; i < 4; i++)
    236     {
    237         std::sort(vec.begin(), vec.end(), _sort(i));
    238         std::for_each(vec.begin(), vec.end(), Add_Weight<int>(i, 0));
    239     }
    240     CWeight *weight = new CWeight(50, 50, 0, 0);
    241     weight->Check();
    242     std::sort(vec.begin(), vec.end(), Compare_Weight<int>(weight));
    243     for (i = 0; i < MAXNUM; i++)
    244     {
    245         _sortStru<int> out;
    246         out = vec.at(i);
    247         cout<< out._data1<<" "<<out._data2<<" "<<out._data3<<" "<<out._data4<<" ";
    248         cout<<endl;
    249     }
    250     cout<<endl;
    251     
    252     return 0;
    253 }

     

    转载于:https://www.cnblogs.com/aimenfeifei/p/4269702.html

    展开全文
  • 为解决卷积混合频域盲源分离排序不确定问题,研究了分离矩阵行列式变化和频点距离对基于相邻频点幅度相关性排序算法的影响,提出了改进的盲源分离排序算法。改进算法用权重系数来衡量频点对排序的影响,并将分离矩阵...
  • 将整数按权重排序题目描述方法一:递归思路代码方法二:字典思路代码方法三:记忆化(字典+递归)思路代码 题目描述 我们将整数 x 的 权重 定义为按照下述规则将 x 变成 1 所需要的步数: 如果 x 是偶数,那么 x = x /...

    题目描述

    我们将整数 x 的 权重 定义为按照下述规则将 x 变成 1 所需要的步数:
    如果 x 是偶数,那么 x = x / 2
    如果 x 是奇数,那么 x = 3 * x + 1
    比方说,x=3 的权重为 7 。因为 3 需要 7 步变成 1 (3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1)。
    给你三个整数 lo, hi 和 k 。你的任务是将区间 [lo, hi] 之间的整数按照它们的权重升序排序如果大于等于 2 个整数有相同的权重,那么按照数字自身的数值升序排序
    请你返回区间 [lo, hi] 之间的整数按权重排序后的第 k 个数
    注意,题目保证对于任意整数 x (lo <= x <= hi) ,它变成 1 所需要的步数是一个 32 位有符号整数。

    示例 1:
    输入:lo = 12, hi = 15, k = 2
    输出:13
    解释:12 的权重为 912 --> 6 --> 3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 113 的权重为 9
    14 的权重为 17
    15 的权重为 17
    区间内的数按权重排序以后的结果为 [12,13,14,15] 。对于 k = 2 ,答案是第二个整数也就是 13 。
    注意,1213 有相同的权重,所以我们按照它们本身升序排序。1415 同理。
    
    示例 2:
    输入:lo = 1, hi = 1, k = 1
    输出:1
    
    示例 3:
    输入:lo = 7, hi = 11, k = 4
    输出:7
    解释:区间内整数 [7, 8, 9, 10, 11] 对应的权重为 [16, 3, 19, 6, 14] 。
    按权重排序后得到的结果为 [8, 10, 11, 7, 9] 。
    排序后数组中第 4 个数字为 7 。
    
    示例 4:
    输入:lo = 10, hi = 20, k = 5
    输出:13
    
    示例 5:
    输入:lo = 1, hi = 1000, k = 777
    输出:570
    

    方法一:递归

    思路

    记 x 的权重为 f(x),按照题意很明显我们可以构造这样的递归式:
    在这里插入图片描述
    于是我们就可以递归求解每个数字的权重了。

    代码

    class Solution:
        def getKth(self, lo: int, hi: int, k: int) -> int:
            def get_weight(n):
                if n==1:return 0
                if n%2==0:return get_weight(n/2)+1
                else: return get_weight(3*n+1)+1
            return sorted(list(range(lo,hi+1)),key=lambda x:(get_weight(x),x))[k-1]
    

    方法二:字典

    思路

    • 通过字典存放整数及其权重
      • 若整数最初就为1,权重为0
      • 若 x 是偶数,那么 x = x / 2,若x 是奇数,那么 x = 3 * x + 1,每个过程权重均增加1
    • 排序:先按照值排序在按照键排序

    代码

    class Solution:
        def getKth(self, lo: int, hi: int, k: int) -> int:        
            dic={}
            for item in range(lo,hi+1):
                i=0
                old_item=item
                if item==1: i=0
                while item!=1: 
                    i+=1
                    item=(item/2) if item%2==0 else (3*item+1)
                dic[old_item]=i
            return sorted(dic.items(),key=lambda x:(x[1],x[0]))[k-1][0]
    

    方法三:记忆化(字典+递归)

    思路

    我们知道在求 f(3)的时候会调用到 f(10),在求f(20) 的时候也会调用到 f(10)。同样的,如果单纯递归计算权重的话,会存在很多重复计算,我们可以用记忆化的方式来加速这个过程,即==「先查表,再计算」和「先记忆,再返回」。我们可以用一个哈希映射==作为这里的记忆化的「表」,这样保证每个元素的权值只被计算 1次。

    代码

    class Solution:
        def getKth(self, lo: int, hi: int, k: int) -> int:
            dic={1:0}
            def get_weight(n):
                if n in dic:
                    return dic[n]
                dic[n]=(get_weight(n/2)+1) if n%2==0 else (get_weight(3*n+1)+1)
                return dic[n]
            return sorted(list(range(lo,hi+1)),key=lambda x:(get_weight(x),x))[k-1]
    
    展开全文
  • 权重随机算法

    千次阅读 2018-10-30 17:38:37
    一个Test类的Start方法,用于测试 实例化一个 ...思路就是将权重值乘一个1到100的随机数,然后将随机后的权重排序。 [code]csharpcode: using System.Collections; using System.Collections.Generic;...

    一个Test类的Start方法,用于测试
    实例化一个 RandomControllerEx ,传入数据与数据对应的权重值。
    GetDatas方法可以获取到当前这一次随机的值。
    思路就是将权重值乘一个1到100的随机数,然后将随机后的权重值排序。

    [code]csharpcode:
    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;

    public class Test : MonoBehaviour
    {

    private void Start()
    {
        RandomControllerEx rcEx = new RandomControllerEx(new int[] { 0, 1, 2, 3 }, new int[] { 60, 30, 10, 3 });
    
        Dictionary<int, int> dict = new Dictionary<int, int>();
    
        for (int i = 0; i < 10000; i++)
        {
            int[] resultData = rcEx.GetDatas(1);
    
            if (dict.ContainsKey(resultData[0]))
                dict[resultData[0]] += 1;
            else
                dict[resultData[0]] = 1;
        }
    
        foreach (var xxx in dict)
        {
            Debug.Log("key:[" + xxx.Key + "]     value:[" + (xxx.Value * 1.0f / 103));
        }
    
    }
    

    }

    public class RandomControllerEx
    {
    int[] datas;
    int[] widgets;

    public RandomControllerEx(int[] datas, int[] widgets)
    {
        if (datas == null || widgets == null)
        {
            Debug.LogError("datas or widgets is null");
            return;
        }
        if (datas.Length != widgets.Length)
        {
            Debug.LogError("must has same count");
            return;
        }
    
        this.datas = datas;
        this.widgets = widgets;
    }
    
    /// <summary>
    /// 按权重获取数据
    /// </summary>
    /// <param name="count">一次获取几个</param>
    /// <returns></returns>
    public int[] GetDatas(int count)
    {
        List<KeyValuePair<int, int>> sortList = new List<KeyValuePair<int, int>>();
    
        for (int i = 0; i < datas.Length; i++)
        {
            int key = datas[i];
            int value = Random.Range(1, 100) * widgets[i];
            sortList.Add(new KeyValuePair<int, int>(key, value));
        }
    
        sortList.Sort((kvp1, kvp2) =>
        {
            return kvp2.Value - kvp1.Value;
        });
    
        List<int> result = new List<int>();
    
        foreach (KeyValuePair<int, int> kvp in sortList.GetRange(0, count))
        {
            result.Add(kvp.Key);
        }
    
        return result.ToArray();
    }
    
    /// <summary>
    /// 排序集合
    /// </summary>
    /// <param name="dict"></param>
    /// <returns></returns>
    private List<KeyValuePair<int, int>> SortByValue(Dictionary<int, int> dict)
    {
        List<KeyValuePair<int, int>> list = new List<KeyValuePair<int, int>>();
    
        if (dict != null)
        {
            list.AddRange(dict);
    
            list.Sort(
                delegate (KeyValuePair<int, int> kvp1, KeyValuePair<int, int> kvp2)
                {
                    return kvp2.Value - kvp1.Value;
                });
        }
        return list;
    }
    

    }

    展开全文
  • 将整数按权重排序 一、题目简介 我们将整数 x 的 权重 定义为按照下述规则将 x 变成 1 所需要的步数: 如果 x 是偶数,那么 x = x / 2 如果 x 是奇数,那么 x = 3 * x + 1 比方说,x=3 的权重为 7 。因为 3 需要 7 ...

    将整数按权重排序

    一、题目简介

    我们将整数 x 的 权重 定义为按照下述规则将 x 变成 1 所需要的步数:

    如果 x 是偶数,那么 x = x / 2
    如果 x 是奇数,那么 x = 3 * x + 1
    比方说,x=3 的权重为 7 。因为 3 需要 7 步变成 1 (3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1)。

    给你三个整数 lo, hi 和 k 。你的任务是将区间 [lo, hi] 之间的整数按照它们的权重 升序排序 ,如果大于等于 2 个整数有 相同 的权重,那么按照数字自身的数值 升序排序 。

    请你返回区间 [lo, hi] 之间的整数按权重排序后的第 k 个数。

    注意,题目保证对于任意整数 x (lo <= x <= hi) ,它变成 1 所需要的步数是一个 32 位有符号整数。
    (题目来源:力扣(LeetCode))

    示例 1:
    输入:lo = 12, hi = 15, k = 2
    输出:13
    解释:12 的权重为 9(12 --> 6 --> 3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1)
    13 的权重为 9
    14 的权重为 17
    15 的权重为 17
    区间内的数按权重排序以后的结果为 [12,13,14,15] 。对于 k = 2 ,答案是第二个整数也就是 13 。
    注意,12 和 13 有相同的权重,所以我们按照它们本身升序排序。14 和 15 同理。
    
    示例 2:
    输入:lo = 1, hi = 1, k = 1
    输出:1
    
    示例 3:
    输入:lo = 7, hi = 11, k = 4
    输出:7
    解释:区间内整数 [7, 8, 9, 10, 11] 对应的权重为 [16, 3, 19, 6, 14] 。
    按权重排序后得到的结果为 [8, 10, 11, 7, 9] 。
    排序后数组中第 4 个数字为 7 。
    
    示例 4:
    输入:lo = 10, hi = 20, k = 5
    输出:13
    
    示例 5:
    输入:lo = 1, hi = 1000, k = 777
    输出:570
    
    提示:
    1 <= lo <= hi <= 1000
    1 <= k <= hi - lo + 1
    

    二、解决方法

    1. 暴力法

    class Solution {
        public int getKth(int lo, int hi, int k) {
            int length=hi-lo+1;
            //存储区间数字的数组
            List<Integer> nums=new ArrayList<>();
            for (int i = 0; i <length; i++) {
                //存储当前数字
                nums.add(i+lo);
            }
            //定义排序规则
            Collections.sort(nums, new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                	//如果权值相等,则比较原数
                    if(getWeight(o1)==getWeight(o2)){
                        return o1-o2;
                    }else{
                    //否则比较权值
                        return getWeight(o1)-getWeight(o2);
                    }
                }
            });
            return nums.get(k-1);
        }
        
        public int getWeight(int currentNum){
        	//权值
            int weight=0;
            //循环获取权值
            while(currentNum!=1){
                currentNum=(currentNum&1)==0?(currentNum>>1):(3*currentNum+1);
                weight++;
            }
            return weight;
        }
    }
    

    2. 递归+记忆化

    class Solution {
        Map<Integer,Integer> map=new HashMap<>();
        public int getKth(int lo, int hi, int k) {
            int length=hi-lo+1;
            //存储区间数字的数组
            List<Integer> nums=new ArrayList<>();
            for (int i = 0; i <length; i++) {
                int currentNum=i+lo;
                //存储当前数字
                nums.add(currentNum);
                //获取权值
                getWeight(currentNum);
            }
            //定义排序规则
            Collections.sort(nums, new Comparator<Integer>() {
                @Override
                public int compare(Integer o1, Integer o2) {
                	//map中已经将数字对应权值全部计算完了,此时直接在map中取就可以了
                	//如果权值相等,则比较原数
                    if(map.get(o1)==map.get(o2)){
                        return o1-o2;
                    }else{
                    	//否则比较权值
                        return map.get(o1)-map.get(o2);
                    }
                }
            });
            return nums.get(k-1);
        }
    
        public int getWeight(int currentNum){
        	//递归,并将所求得的权值存储在map中
            if(!map.containsKey(currentNum)){
                if (currentNum == 1) {
                	//等于直接存储权值0
                    map.put(1, 0);
                } else if ((currentNum & 1) != 0) {
                	//如果不是偶数,则currentNum对应的权值也就是(currentNum * 3 + 1)的权值+1
                    map.put(currentNum, getWeight(currentNum * 3 + 1) + 1);
                } else {
                	//如果是偶数,则currentNum对应的权值也就是(currentNum*2)的权值+1
                    map.put(currentNum, getWeight(currentNum>>1) + 1);
                }
            }
            return map.get(currentNum);
        }
    }
    

    3. Arrays排序覆盖+递归+记忆化
    题解区大佬方法

    class Solution {
        Map<Integer,Integer> map=new HashMap<>();
        public int getKth(int lo, int hi, int k) {
            if(lo==hi) return hi;
            //二维数组存储数字及其对应的权值
            int[][] weight=new int[hi-lo+1][2];
            for (int i = lo; i <= hi; i++) {
            	//一维数组的第一个数存储权值
                weight[i-lo][0]=getWeight(i);
                //一维数组的第二个数存储数字
                weight[i-lo][1]=i;
            }
            //自定义排序规则
            Arrays.sort(weight, (a, b) -> a[0] == b[0] ? a[1] - b[1] : a[0] - b[0]);
            return weight[k-1][1];
        }
        
        public int getWeight(int currentNum){
        	//递归,并将所求得的权值存储在map中
            if(!map.containsKey(currentNum)){
                if (currentNum == 1) {
                	//等于直接存储权值0
                    map.put(1, 0);
                } else if ((currentNum & 1) != 0) {
                	//如果不是偶数,则currentNum对应的权值也就是(currentNum * 3 + 1)的权值+1
                    map.put(currentNum, getWeight(currentNum * 3 + 1) + 1);
                } else {
                	//如果是偶数,则currentNum对应的权值也就是(currentNum*2)的权值+1
                    map.put(currentNum, getWeight(currentNum>>1) + 1);
                }
            }
            return map.get(currentNum);
        }
    }
    
    

    4. 小根堆(这里记忆化反而运行更久,时间更长)
    评论区大佬方法

    class Solution {
    
        public int getKth(int lo, int hi, int k) {
        	//自定义排序规则
            Queue<int[]> queue = new PriorityQueue<>((o1, o2) -> o1[1] != o2[1] ? o2[1] - o1[1] : o2[0] - o1[0]);
            for (int i = lo; i <= hi; ++i) {
            	//添加数字及其对应的权值
                queue.offer(new int[]{i, getP(i)});
                if (i - lo + 1 > k) {
                	//将第k个数字前面的全部移出队列
                    queue.poll();
                }
            }
            return queue.poll()[0];
        }
        
        private int getP(int currentNum) {
        	//权值
            int weight = 0;
            //循环获取当前数字对应的权值
            while (currentNum != 1) {
                if ((currentNum & 1) == 1) {
                    currentNum += (x << 1) + 1;
                } else {
                    currentNum >>= 1;
                }
                ++weight ;
            }
            return weight;
        }
    }
    
    展开全文
  • 论文研究-多人层次单排序权重向量的算法.pdf,
  • 针对于有多个关键字的排序算法。先按照一个关键字进行排序,完成后在按另一个关键字排序。先按照权重小关键字排序,在按照权重大的关键字排序。 按照每个关键字的值的范围,定义上相同数量的队列。对于数字我们先...
  • 排序算法之——基数排序 基数排序的思想: 针对于有多个关键子的排序算法。先按照一个关键字进行排序,完成后再按照另一个关键字排序。先按照权重小的关键字排序,再按照权重大的关键字排序。 按照每个关键字的值的...
  • 基于添加节点权重HITS算法的改进分析,李业泰,,本文给出了一种改进的HITS算法研究方法,在一种基于链接结构分析的HITS网页排序算法的基础上进行改进。首先介绍了HITS算法的基本思想
  • 所有排序算法基数排序所有排序算法 基数排序 唯一一种不需要比较的排序 需要多个权重 类似1234的百位千位 把相同的权重放在一起,达到在相同的权重上是有序的。 //求最大值的位数 int GetWidth(int *arr, int len) {...
  • 即集合的排序是倒序)。但如果 C 在第二位或者第一位,那么,C 就不会被击中。这样是不是不够公平? 并且我好像没有从代码中看到对服务列表进行倒序。 还请您解答!谢谢!</p>...
  • 目前,大多数Hash排序算法通过比较数据在欧氏空间和海明空间的排序一致性来构造损失函数,然而,在海明空间的排序过程中,因为海明距离是离散的整数值,可能存在多个数据点共享相同的海明距离,这样就无法准确地排序...
  • 如题: 对一个表 按照 时间*50% 和 距离*50% 进行排序。 这个表中记录了用户最近登入的时间和距离。我要获取距离最近并且用户最近登入的人。
  • 只需要给出权重算法即可调用算法完成排序, 支持List Array 上代码: public static class SortHelper { /// /// 要排序的元素 /// private class SortItem { public object data; public int weight; } private...
  • 提出了一个基于层次分类的搜索引擎页面排序算法。该算法通过对页面进行层次化分类进而计算贝面之间相关性,根据相关性的不同,对来自不同页面的外部链接赋予不同的权重,从而更公正、有效地计算页面的PageRank值。...
  • 提出了一种基于可组合关联模型的服务排序算法。该算法充分挖掘服务间的关联关系,将每个Web服务重要度关联到所有直接前驱可组合的Web服务上,而每个Web服务又将自身权重值以类似的方式分配给所有后续可组合的Web服务...
  • LR 个性化排序算法

    2020-06-15 19:05:54
    LR | Logic Regression | 逻辑回归 Y = ax1 + bx2 + cx3 + dx4 ... 针对召回算法返回的数据,进行二次精排,... 是每个特征值的权重; Y 介于 0 和 1 之间,越接近 1,越可能被点中了,越趋近 0,被点击的概率就...
  • 描述了当前突发公共事件中社会认知管理的现状,针对当前...针对传统PageRank算法偏重旧网页的现象,对算法进行了改进,增加了时间权重。在Hadoop分布式计算平台上实现了该算法,并对比分析了算法改进前后的排序结果。
  • 为提高论文检索的效率和质量,在原有检索技术的基础上,建立学术论文质量评价模型,提出1种基于此模型的检索排序算法。采用“元数据思想”实现将PDF全文转换成xML格式输出,在此基础上利用基于词条位置权重的向量...
  • 针对目前商品简单的排序结果无法满足用户需求的情况,提出了一种改进的基于商品属性权重的多级匹配算法算法根据用户对商品不同属性的重视程度,预先设置属性权重,然后再结合传统多级匹配算法对商品进行重新排序....
  • 以Gödel系统为背景,针对由单个或两个原子生成的公式,解决了公式的真度分布问题。得到任一由单个或两个原子生成的公式的真度必为0,1/6,2/6,1/2,4/6,5/6,1之一。进而按照真度将由单原子或两个原子生成的公式...
  • 记录几个在做题时碰到的高效算法: 快排 dfs 位运算求某数二进制1的个数 快排 public void sort(int[] a,int st,int ben) { if (ben-st < 1) return; //int ben = a.length - 1;//意为基准 //int l =...
  • 这篇文章主要分析公平调度器的公平排序算法,基于hadoop-2.3.0-cdh5.0.0 首先,了解这几个概念: 资源需求量:当前队列或者应用希望获得的资源的总量。 最小份额:队列的最小共享量在配置中指定。应用的最小...
  • lucene 排序算法思路

    千次阅读 2007-03-02 16:07:00
    关于搜索引擎搜索结果排序的一点看法... 与搜索相关的排名机制,如:网站质量、网站活跃度、级别等 参数 综合公式计算权重加入到boost因子中。 计算出score. 这种排序方法比较理想。(2) 根据字段对结果排序 Luc
  • 提出了基于需求动态优先级排序算法的领域资产权重设置方法,建立领域资产的权重和用户最近的访问频度的关系,即能根据用户的即时需求,动态计算用户所提出的需求的优先级,进而求得各个领域模型的权重值;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 621
精华内容 248
关键字:

权重排序算法